blocks|key|1952053|text|SICP本身有几个章节详细介绍了如何构建元循环解释器，但我建议您阅读以下两本书，以获得更好的有关Scheme解释器的资源：编程语言:应用程序和口译和程序设计语言要点。它们既容易阅读，又能逐渐引导你建立口译员。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1952054|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/|1|http://www.eopl3.com/^0|1P|C|0|22|8|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

SICP itself has several sections detailing how to build a meta-circular interpreter, but I would suggest that you take a look at the following two books for better resources on Scheme interpreters: <a href="http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/">Programming Languages: Application and Interpretation</a> and <a href="http://www.eopl3.com/">Essentials of Programming Languages</a>. They're both easy to read and gradually guide you through building interpreters.

blocks|key|1952105|text|我推荐博客系列计划从无到有，它用C逐步建立一个方案解释器。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1952106|entityMap|0|LINK|mutability|MUTABLE|url|http://michaux.ca/articles/scheme-from-scratch-introduction^0|7|6|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I would recommend the blog series <a href="http://michaux.ca/articles/scheme-from-scratch-introduction" rel="noreferrer">Scheme from scratch</a> which incrementally builds up a scheme interpreter in C.

blocks|key|51110|text|克里斯蒂安·奎因内克的书“小片段里的李斯”(+Lisp+)非常棒。比EoPL更现代。包括Lisp和Scheme，并详细介绍了大多数书籍忽略的血淋淋的低级内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|51111|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Christian Queinnec's book Lisp In Small Pieces is superb. More modern that EoPL. Covers both Lisp and Scheme, and goes into detail about the gory low-level stuff that most books omit.

blocks|key|1952092|text|我建议阅读肯特·戴布维格的论文"方案的三种实现模式“。第一部分(直到第三章)讨论了基于堆的模型，它非常适合于方案的简单实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1952093|另一个很好的资源(如果我正确理解它，并且您希望在C中实现它)是尼尔斯·霍尔姆的“空空间9方案”。这个链接是到Nils的网页，在底部有一个链接到旧的，公共的领域，版本的书和更新的，更容易阅读，商业可用的版本。两样都读一读，都爱着。|1952094|entityMap|0|LINK|mutability|MUTABLE|url|https://www.google.com/url?sa=t&source=web&cd=4&ved=0CDsQFjAD&url=http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.66.786&rep=rep1&type=pdf&rct=j&q=3%2520implementation%2520techniques%2520scheme&ei=KJCcTtueCIT30gGOmY3iBA&usg=AFQjCNE1SURrGdmO4pgkpTzJu0On5wHz-g&sig2=NwbT8xyce7_rQ4K3p_B2dQ&cad=rja|1|http://www.t3x.org/^0|G|9|0|0|V|G|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

I would recommend reading Kent Dybvig's dissertation "<a href="https://www.google.com/url?sa=t&amp;source=web&amp;cd=4&amp;ved=0CDsQFjAD&amp;url=http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.66.786&amp;rep=rep1&amp;type=pdf&amp;rct=j&amp;q=3%20implementation%20techniques%20scheme&amp;ei=KJCcTtueCIT30gGOmY3iBA&amp;usg=AFQjCNE1SURrGdmO4pgkpTzJu0On5wHz-g&amp;sig2=NwbT8xyce7_rQ4K3p_B2dQ&amp;cad=rja" rel="nofollow">Three Implementation Models for Scheme</a>". Not the whole dissertation, but the first part (up to chapter 3) where he discusses the Heap-Based Model is very suitable for a naive implementation of Scheme.

Another great resource (if I understood it correctly and you want to implement it in C) is <a href="http://www.t3x.org/" rel="nofollow">Nils Holm's "Scheme 9 from Empty Space"</a>. This link is to Nils's page, and there's a link at the bottom to the old, public domain, edition of the book and to the newer, easier to read, commercially available edition. Read both and loved 'em.

blocks|key|1952136|text|我可以概述一下我的解释器是如何工作的，也许它可以给你一个关于一般事物的想法。虽然答案已经很晚了，但我希望这能帮助到其他人，他们已经来到这条线上，想要一个大致的想法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1952137|对于输入的每一行方案，都会创建一个Command对象。如果命令是部分的，那么它的nest级别就会被存储(剩余的右括号数以完成表达式)。如果命令完成，则会创建表达式对象，并在此对象上触发计算程序。|ordered-list-item|1952138|定义了4种类型的评估器类，每种类型都是从基类评估器派生出来的。|1952139|(+a)+Define_Evaluator+:用于定义语句|1952140|(+b)+Funcall_Evaluator+:用于处理其他用户定义的函数|1952141|(+c)+Read_Evaluator+:用于读取表达式并将其转换为方案对象|1952142|d)+Print_Evaluator+:根据对象的类型打印对象。|1952143|(+e)+Eval_Evaluator+:对表达式进行实际处理。|1952144|3.->首先使用read计算器读取每个表达式，它将从表达式中创建方案对象。嵌套表达式是递归计算的，直到表达式完成。|1952145|->Next，则触发Eval_Evaluator，它处理在第一步中形成的Scheme表达式对象。就这样发生了|1952146|(+a)如果要计算的表达式是符号。返回它的价值。因此，变量blk将返回该块的对象。|1952147|(+b)如果要计算的表达式是一个列表。打印名单。|1952148|(+c)如果要计算的表达式是函数。查找函数的定义，该函数将使用Funcall_Evaluator返回计算。|1952149|->Lastly打印计算器用于打印结果，此打印将取决于输出表达式的类型。|1952150|免责声明：--这就是我的解释器的工作方式，不必是那样的。|offset|length|style|BOLD|1952151|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|5|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1B|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|1C|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1D|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1E|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1F|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1I|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1J|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1K|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1L|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1M|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1N|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1O|8|@$14|1P|15|1Q|16|17]]|9|@]|A|$]]|$1|18|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|19|$]]

I can give you an overview on how my interpreter works, maybe it can give you an idea of the general thing. 
Although the answer is pretty late, I hope this can help someone else, who has come to this thread and wants a general idea.

<ol>
<li>For each line of scheme entered , a Command object is created. If the command is partial then its nest level is stored(number of remaining right brackets to complete the expression). If the command is complete an Expression Object is created and the evaluators are fired on this object.</li>
<li>There are 4 types of evaluator classes defined , each derived from the base class Evaluator</li>
</ol>

a) Define_Evaluator :for define statements

b) Funcall_Evaluator :for processing other user defined functions

c) Read_Evaluator :for reading an expression and converting it to a scheme object

d) Print_Evaluator :prints the object depending on the type of the object.

e) Eval_Evaluator :does the actual processing of the expression.

3.-> First each expression is read using the Read Evaluator which will create a scheme object out of the expression. Nested expressions are calculated recursively until the expression is complete.

->Next, the Eval_Evaluator is fired which processes the Scheme Expression Object formed in the first step.
this happens as so 

a) if the expression to be evaluated is a symbol. Return its value. Therefore the variable blk will return the object for that block.

b) if the expression to be evaluated is a list. Print the list.

c) if the expression to be evaluated is a function. Look for the definition of the function which will return the evaluation using the Funcall_Evaluator.

->Lastly the print evaluator is fired to print the outcome , this print will depend on what type the output expression is.

Disclaimer:
This is how my interpreter works , doesnt have to be that way.

blocks|key|127596|text|我也执行过类似的任务，但几年后，我提出了以下建议：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|127597|Peter的计划从零开始：http://michaux.ca/articles/scheme-from-scratch-introduction，和他的github回购：https://github.com/petermichaux/bootstrap-scheme/blob/v0.21/scheme.c。可悲的是，他的皇室计划似乎停滞不前了。有一个VM的承诺，如果他的解释清晰，这将是伟大的。|unordered-list-item|offset|length|127598|Peter+lis.py：http://norvig.com/lispy.html虽然是用python编写的，但它非常容易理解，并且利用了使用动态、弱类型语言来创建另一种语言的所有优点。他有一篇后续文章，其中添加了更高级的特性。|127599|安东尼C.海伊用lis.py作为灵感，在C%2B%2B：http://howtowriteaprogram.blogspot.co.uk/2010/11/lisp-interpreter-in-90-lines-of-c.html中创建了一个实现|127600|更完整的实现是chibi方案：http://synthcode.com/scheme/chibi/，它确实包含一个VM，但代码库仍然不太大，无法理解。|127601|我仍然在寻找关于创建lisp/+blog的好博客文章，它可以与JIT+(对任何有竞争力的JS实现都很重要:)结合在一起。|127602|entityMap|0|LINK|mutability|MUTABLE|url|http://michaux.ca/articles/scheme-from-scratch-introduction|1|https://github.com/petermichaux/bootstrap-scheme/blob/v0.21/scheme.c|2|http://norvig.com/lispy.html|3|http://howtowriteaprogram.blogspot.co.uk/2010/11/lisp-interpreter-in-90-lines-of-c.html|4|http://synthcode.com/scheme/chibi/^0|0|D|1N|0|2D|1W|1|0|D|S|2|0|O|2F|3|0|F|Y|4|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@$E|16|F|17|1|18]|$E|19|F|1A|1|1B]]|A|$]]|$1|G|3|H|5|D|7|1C|8|@]|9|@$E|1D|F|1E|1|1F]]|A|$]]|$1|I|3|J|5|D|7|1G|8|@]|9|@$E|1H|F|1I|1|1J]]|A|$]]|$1|K|3|L|5|D|7|1K|8|@]|9|@$E|1L|F|1M|1|1N]]|A|$]]|$1|M|3|N|5|6|7|1O|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]|Y|$5|R|S|T|A|$U|Z]]|10|$5|R|S|T|A|$U|11]]|12|$5|R|S|T|A|$U|13]]]]

I've been on a similar mission but several years later, recommendations:

<ul>
<li>Peter Michaux's scheme from scratch: <a href="http://michaux.ca/articles/scheme-from-scratch-introduction" rel="nofollow">http://michaux.ca/articles/scheme-from-scratch-introduction</a>, and his github repo: <a href="https://github.com/petermichaux/bootstrap-scheme/blob/v0.21/scheme.c" rel="nofollow">https://github.com/petermichaux/bootstrap-scheme/blob/v0.21/scheme.c</a>. Sadly his royal scheme effort seems to have stalled. There were promises of a VM, which with his clarity of explanations would have been great.</li>
<li>Peter Norvigs lis.py: <a href="http://norvig.com/lispy.html" rel="nofollow">http://norvig.com/lispy.html</a>, although written in python, is very understandable and exploits all the advantages of using a dynamic, weakly typed language to create another. He has a follow up article that adds more advanced features.</li>
<li>Anthony C. Hay used lis.py as an inspiration to create an implementation in C++: 
<a href="http://howtowriteaprogram.blogspot.co.uk/2010/11/lisp-interpreter-in-90-lines-of-c.html" rel="nofollow">http://howtowriteaprogram.blogspot.co.uk/2010/11/lisp-interpreter-in-90-lines-of-c.html</a></li>
<li>A more complete implementation is chibi scheme: <a href="http://synthcode.com/scheme/chibi/" rel="nofollow">http://synthcode.com/scheme/chibi/</a> which does include a VM, but the code base is still not too large to comprehend.</li>
</ul>

I'm still searching for good blog posts on creating a lisp/scheme VM, which could be coupled with JIT (important for any competitive JS implementation :).

blocks|key|127628|text|除了奎因尼克的书+(它可能是从方案到C转换中最全面的方案)之外，您还可以阅读旧平台library.readscheme.org的文献。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|127629|entityMap|0|LINK|mutability|MUTABLE|url|https://pages.lip6.fr/Christian.Queinnec/WWW/LiSP.html|1|https://web.archive.org/web/20180625085633/http://library.readscheme.org^0|2|6|0|15|M|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

Apart from <a href="https://pages.lip6.fr/Christian.Queinnec/WWW/LiSP.html" rel="nofollow noreferrer">Queinnec's book</a>, which probably is the most comprehensive one in scheme 
to C conversion, you can read also literature from the old platform <a href="https://web.archive.org/web/20180625085633/http://library.readscheme.org" rel="nofollow noreferrer">library.readscheme.org</a>.

I'm reading the book <a href="http://mitpress.mit.edu/sicp/full-text/book/book.html" rel="noreferrer">Structure and Interpretation 
of Computer Programs</a>, and I'd like to code a scheme interpreter gradually.

Do you knows the implementation of the scheme most easy to read (and short)?
I will make a JavaScript in C.

I want to implement a scheme interpreter for studying SICP

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我正在读“”一书，我想逐步编写一个方案解释器。你知道这个方案最容易读懂的是什么吗？我将用C制作一个JavaScript。

问我想要实现一个学习SICP的方案解释器。
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我想要实现一个学习SICP的方案解释器。EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我想要实现一个学习SICP的方案解释器。
EN