blocks|key|1097744|text|资源大清单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1097745|一种用于编译教育的纳米框架倍频|unordered-list-item|offset|length|1097746|高级编译器的设计与实现+$|1097747|一种增量式编译结构方法倍频|1097748|ANTLR+3.x视频教程|1097749|编译器设计基础|1097750|构建鹦鹉编译器|1097751|编译器基础|1097752|编译器构造+$|1097753|编译器设计与构造+$|1097754|用C制作编译器+$|1097755|手工艺翻译|1097756|C语言的编译器设计倍频|1097757|编译器:原则、技术和工具+$-+aka+“龙书”；被广泛认为是用于编写编译器的“书”。|1097758|工程编译器+$|1097759|程序设计语言要点|1097760|Flipcode文章存档+(寻找“由Jan实现脚本引擎”)|1097761|游戏脚本掌握+$|1097762|如何在C#中从头开始构建虚拟机倍频|1097763|实现功能语言|1097764|实现编程语言(使用BNFC)|1097765|使用C#+4.0实现编程语言|1097766|解释器模式+(以设计模式+$描述)指定了一种在语言中计算句子的方法|1097767|语言实现模式:创建您自己的特定于域的通用编程语言+$|1097768|让我们构建一个编译器由Jack+PDF格式系列版本(例子在帕斯卡，但这些信息是普遍适用的)|1097769|连接器和装载机+$+(Google+)|1097770|小片段Lisp+(LiSP)+$|1097771|LLVM教程|1097772|现代编译器在ML中的实现+$-有一个Java+$和C+$版本，也被广泛认为是一本非常好的书。|1097773|面向对象编译器构建+$|1097774|解析技术-实用指南|1097775|Oberon项目+-看第13章|1097776|编写个人计算机的程序+$|1097777|编程语言:应用和口译|1097778|兔子:一个用于计划的编译器倍频|1097779|关于信任的思考+-快速指南|1097780|为.NET框架滚动您自己的编译器+--+MSDN的快速教程|1097781|计算机程序的结构与解释|1097782|类型和编程语言|1097783|想写一个编译器吗？+-快速指南|1097784|用Ruby自下而上编写编译器|1097785|编译Lisp+-直接编译到x86-64|1097786|图例：|1097787|链接到PDF文件|1097788|$链接到印刷的书|1097789|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cs.indiana.edu/%257Edyb/pubs/nano-jfp.pdf|1|http://www.amazon.com/gp/offer-listing/1558603204?tag=thecompilerconne&camp=14573&creative=327641&linkCode=am1&creativeASIN=1558603204&adid=1ZQWN5FGBA1JM6MNQ2ZV&|2|http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf|3|http://javadude.com/articles/antlr3xtut|4|http://www.diku.dk/%257Etorbenm/Basics/|5|http://web.archive.org/web/20160731061607/http://www.onlamp.com/pub/a/onlamp/2004/04/15/parrot_compiler_construction.html|6|http://www.cs.man.ac.uk/%257Epjj/farrell/compmain.html|7|https://rads.stackoverflow.com/amzn/click/com/0201403536|8|https://rads.stackoverflow.com/amzn/click/com/0442275366|9|https://rads.stackoverflow.com/amzn/click/com/0805321667|10|http://craftinginterpreters.com/|11|http://www.holub.com/software/compiler.design.in.c.html|12|https://rads.stackoverflow.com/amzn/click/com/0321486811|13|http://en.wikipedia.org/wiki/Compilers:_Principles%252C_Techniques%252C_and_Tools|14|https://rads.stackoverflow.com/amzn/click/com/012088478X|15|http://www.cs.indiana.edu/eopl/|16|http://flipcode.com/archives/articles.shtml|17|https://rads.stackoverflow.com/amzn/click/com/1931841578|18|http://www.codeproject.com/KB/recipes/B32Machine1/VMCS.pdf|19|http://research.microsoft.com/%257Esimonpj/papers/pj-lester-book/|20|http://www1.digitalgrammars.com/ipl-book/|21|http://www.codeproject.com/KB/recipes/programminglanguagetoools.aspx|22|http://en.wikipedia.org/wiki/Interpreter_pattern|23|https://rads.stackoverflow.com/amzn/click/com/0201633612|24|http://pragprog.com/titles/tpdsl/language-implementation-patterns|25|http://compilers.iecc.com/crenshaw/|26|http://www.stack.nl/%257Emarcov/compiler.pdf|27|http://books.google.com/books?id=Id9cYsIdjIwC&lpg=PP1&ots=IxFkFWJ-8V&dq=%2522linkers%2520and%2520loaders%2522&pg=PA215#v=onepage&q=%2522linkers%2520and%2520loaders%2522&f=false|28|https://rads.stackoverflow.com/amzn/click/com/0521562473|29|http://llvm.org/docs/tutorial/|30|https://rads.stackoverflow.com/amzn/click/com/0521607647|31|https://rads.stackoverflow.com/amzn/click/com/052182060X|32|https://rads.stackoverflow.com/amzn/click/com/0521607655|33|http://www.amazon.com/gp/offer-listing/013630740X?tag=thecompilerconne&camp=14573&creative=327641&linkCode=am1&creativeASIN=013630740X&adid=0JPMVBRNCAN6PDKGYSXX&|34|http://www.dickgrune.com/Books/PTAPG_1st_Edition/|35|http://www-old.oberon.ethz.ch/WirthPubl/ProjectOberon.pdf|36|https://rads.stackoverflow.com/amzn/click/com/0137302673|37|http://www.cs.brown.edu/%257Esk/Publications/Books/ProgLangs/|38|http://repository.readscheme.org/ftp/papers/ai-lab-pubs/AITR-474.pdf|39|http://web.archive.org/web/20141221110345/http://cm.bell-labs.com/who/ken/trust.html|40|http://msdn.microsoft.com/en-us/magazine/cc136756.aspx|41|http://mitpress.mit.edu/sicp/|42|http://www.cis.upenn.edu/%257Ebcpierce/tapl/|43|http://prog21.dadgum.com/30.html|44|http://www.hokstad.com/writing-a-compiler-in-ruby-bottom-up-step-1.html|45|https://bernsteinbear.com/blog/compiling-a-lisp-0/^0|0|0|D|0|0|0|B|1|0|0|B|2|0|0|D|3|0|0|7|4|0|0|7|5|0|0|5|6|0|0|5|7|0|0|8|8|0|0|7|9|0|0|5|A|0|0|9|B|0|0|C|C|K|4|D|0|0|5|E|0|0|8|F|0|0|C|G|0|0|6|H|0|0|F|I|0|0|6|J|0|0|E|K|0|0|E|L|0|0|5|M|8|4|N|0|0|O|O|0|0|A|P|G|5|Q|0|0|7|R|0|0|E|S|0|0|6|T|0|0|C|U|I|4|V|P|1|W|0|0|9|X|0|0|9|Y|0|0|8|Z|0|0|A|10|0|0|A|11|0|0|D|12|0|0|7|13|0|0|G|14|0|0|B|15|0|0|7|16|0|0|9|17|0|0|E|18|0|0|6|19|0|0|0|0^^$0|@$1|2|3|4|5|6|7|5K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|5L|8|@]|9|@$E|5M|F|5N|1|5O]]|A|$]]|$1|G|3|H|5|D|7|5P|8|@]|9|@$E|5Q|F|5R|1|5S]]|A|$]]|$1|I|3|J|5|D|7|5T|8|@]|9|@$E|5U|F|5V|1|5W]]|A|$]]|$1|K|3|L|5|D|7|5X|8|@]|9|@$E|5Y|F|5Z|1|60]]|A|$]]|$1|M|3|N|5|D|7|61|8|@]|9|@$E|62|F|63|1|64]]|A|$]]|$1|O|3|P|5|D|7|65|8|@]|9|@$E|66|F|67|1|68]]|A|$]]|$1|Q|3|R|5|D|7|69|8|@]|9|@$E|6A|F|6B|1|6C]]|A|$]]|$1|S|3|T|5|D|7|6D|8|@]|9|@$E|6E|F|6F|1|6G]]|A|$]]|$1|U|3|V|5|D|7|6H|8|@]|9|@$E|6I|F|6J|1|6K]]|A|$]]|$1|W|3|X|5|D|7|6L|8|@]|9|@$E|6M|F|6N|1|6O]]|A|$]]|$1|Y|3|Z|5|D|7|6P|8|@]|9|@$E|6Q|F|6R|1|6S]]|A|$]]|$1|10|3|11|5|D|7|6T|8|@]|9|@$E|6U|F|6V|1|6W]]|A|$]]|$1|12|3|13|5|D|7|6X|8|@]|9|@$E|6Y|F|6Z|1|70]|$E|71|F|72|1|73]]|A|$]]|$1|14|3|15|5|D|7|74|8|@]|9|@$E|75|F|76|1|77]]|A|$]]|$1|16|3|17|5|D|7|78|8|@]|9|@$E|79|F|7A|1|7B]]|A|$]]|$1|18|3|19|5|D|7|7C|8|@]|9|@$E|7D|F|7E|1|7F]]|A|$]]|$1|1A|3|1B|5|D|7|7G|8|@]|9|@$E|7H|F|7I|1|7J]]|A|$]]|$1|1C|3|1D|5|D|7|7K|8|@]|9|@$E|7L|F|7M|1|7N]]|A|$]]|$1|1E|3|1F|5|D|7|7O|8|@]|9|@$E|7P|F|7Q|1|7R]]|A|$]]|$1|1G|3|1H|5|D|7|7S|8|@]|9|@$E|7T|F|7U|1|7V]]|A|$]]|$1|1I|3|1J|5|D|7|7W|8|@]|9|@$E|7X|F|7Y|1|7Z]]|A|$]]|$1|1K|3|1L|5|D|7|80|8|@]|9|@$E|81|F|82|1|83]|$E|84|F|85|1|86]]|A|$]]|$1|1M|3|1N|5|D|7|87|8|@]|9|@$E|88|F|89|1|8A]]|A|$]]|$1|1O|3|1P|5|D|7|8B|8|@]|9|@$E|8C|F|8D|1|8E]|$E|8F|F|8G|1|8H]]|A|$]]|$1|1Q|3|1R|5|D|7|8I|8|@]|9|@$E|8J|F|8K|1|8L]]|A|$]]|$1|1S|3|1T|5|D|7|8M|8|@]|9|@$E|8N|F|8O|1|8P]]|A|$]]|$1|1U|3|1V|5|D|7|8Q|8|@]|9|@$E|8R|F|8S|1|8T]]|A|$]]|$1|1W|3|1X|5|D|7|8U|8|@]|9|@$E|8V|F|8W|1|8X]|$E|8Y|F|8Z|1|90]|$E|91|F|92|1|93]]|A|$]]|$1|1Y|3|1Z|5|D|7|94|8|@]|9|@$E|95|F|96|1|97]]|A|$]]|$1|20|3|21|5|D|7|98|8|@]|9|@$E|99|F|9A|1|9B]]|A|$]]|$1|22|3|23|5|D|7|9C|8|@]|9|@$E|9D|F|9E|1|9F]]|A|$]]|$1|24|3|25|5|D|7|9G|8|@]|9|@$E|9H|F|9I|1|9J]]|A|$]]|$1|26|3|27|5|D|7|9K|8|@]|9|@$E|9L|F|9M|1|9N]]|A|$]]|$1|28|3|29|5|D|7|9O|8|@]|9|@$E|9P|F|9Q|1|9R]]|A|$]]|$1|2A|3|2B|5|D|7|9S|8|@]|9|@$E|9T|F|9U|1|9V]]|A|$]]|$1|2C|3|2D|5|D|7|9W|8|@]|9|@$E|9X|F|9Y|1|9Z]]|A|$]]|$1|2E|3|2F|5|D|7|A0|8|@]|9|@$E|A1|F|A2|1|A3]]|A|$]]|$1|2G|3|2H|5|D|7|A4|8|@]|9|@$E|A5|F|A6|1|A7]]|A|$]]|$1|2I|3|2J|5|D|7|A8|8|@]|9|@$E|A9|F|AA|1|AB]]|A|$]]|$1|2K|3|2L|5|D|7|AC|8|@]|9|@$E|AD|F|AE|1|AF]]|A|$]]|$1|2M|3|2N|5|D|7|AG|8|@]|9|@$E|AH|F|AI|1|AJ]]|A|$]]|$1|2O|3|2P|5|6|7|AK|8|@]|9|@]|A|$]]|$1|2Q|3|2R|5|D|7|AL|8|@]|9|@]|A|$]]|$1|2S|3|2T|5|D|7|AM|8|@]|9|@]|A|$]]|$1|2U|3|-4|5|6|7|AN|8|@]|9|@]|A|$]]]|2V|$2W|$5|2X|2Y|2Z|A|$30|31]]|32|$5|2X|2Y|2Z|A|$30|33]]|34|$5|2X|2Y|2Z|A|$30|35]]|36|$5|2X|2Y|2Z|A|$30|37]]|38|$5|2X|2Y|2Z|A|$30|39]]|3A|$5|2X|2Y|2Z|A|$30|3B]]|3C|$5|2X|2Y|2Z|A|$30|3D]]|3E|$5|2X|2Y|2Z|A|$30|3F]]|3G|$5|2X|2Y|2Z|A|$30|3H]]|3I|$5|2X|2Y|2Z|A|$30|3J]]|3K|$5|2X|2Y|2Z|A|$30|3L]]|3M|$5|2X|2Y|2Z|A|$30|3N]]|3O|$5|2X|2Y|2Z|A|$30|3P]]|3Q|$5|2X|2Y|2Z|A|$30|3R]]|3S|$5|2X|2Y|2Z|A|$30|3T]]|3U|$5|2X|2Y|2Z|A|$30|3V]]|3W|$5|2X|2Y|2Z|A|$30|3X]]|3Y|$5|2X|2Y|2Z|A|$30|3Z]]|40|$5|2X|2Y|2Z|A|$30|41]]|42|$5|2X|2Y|2Z|A|$30|43]]|44|$5|2X|2Y|2Z|A|$30|45]]|46|$5|2X|2Y|2Z|A|$30|47]]|48|$5|2X|2Y|2Z|A|$30|49]]|4A|$5|2X|2Y|2Z|A|$30|4B]]|4C|$5|2X|2Y|2Z|A|$30|4D]]|4E|$5|2X|2Y|2Z|A|$30|4F]]|4G|$5|2X|2Y|2Z|A|$30|4H]]|4I|$5|2X|2Y|2Z|A|$30|4J]]|4K|$5|2X|2Y|2Z|A|$30|4L]]|4M|$5|2X|2Y|2Z|A|$30|4N]]|4O|$5|2X|2Y|2Z|A|$30|4P]]|4Q|$5|2X|2Y|2Z|A|$30|4R]]|4S|$5|2X|2Y|2Z|A|$30|4T]]|4U|$5|2X|2Y|2Z|A|$30|4V]]|4W|$5|2X|2Y|2Z|A|$30|4X]]|4Y|$5|2X|2Y|2Z|A|$30|4Z]]|50|$5|2X|2Y|2Z|A|$30|51]]|52|$5|2X|2Y|2Z|A|$30|53]]|54|$5|2X|2Y|2Z|A|$30|55]]|56|$5|2X|2Y|2Z|A|$30|57]]|58|$5|2X|2Y|2Z|A|$30|59]]|5A|$5|2X|2Y|2Z|A|$30|5B]]|5C|$5|2X|2Y|2Z|A|$30|5D]]|5E|$5|2X|2Y|2Z|A|$30|5F]]|5G|$5|2X|2Y|2Z|A|$30|5H]]|5I|$5|2X|2Y|2Z|A|$30|5J]]]]

<h2>Big List of Resources:</h2>
<ul>
<li><a href="http://www.cs.indiana.edu/%7Edyb/pubs/nano-jfp.pdf" rel="noreferrer">A Nanopass Framework for Compiler Education</a> ¶</li>
<li><a href="http://www.amazon.com/gp/offer-listing/1558603204?tag=thecompilerconne&amp;camp=14573&amp;creative=327641&amp;linkCode=am1&amp;creativeASIN=1558603204&amp;adid=1ZQWN5FGBA1JM6MNQ2ZV&amp;" rel="noreferrer">Advanced Compiler Design and Implementation</a> $</li>
<li><a href="http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf" rel="noreferrer">An Incremental Approach to Compiler Construction</a> ¶</li>
<li><a href="http://javadude.com/articles/antlr3xtut" rel="noreferrer">ANTLR 3.x Video Tutorial</a></li>
<li><a href="http://www.diku.dk/%7Etorbenm/Basics/" rel="noreferrer">Basics of Compiler Design</a></li>
<li><a href="http://web.archive.org/web/20160731061607/http://www.onlamp.com/pub/a/onlamp/2004/04/15/parrot_compiler_construction.html" rel="noreferrer">Building a Parrot Compiler</a></li>
<li><a href="http://www.cs.man.ac.uk/%7Epjj/farrell/compmain.html" rel="noreferrer">Compiler Basics</a></li>
<li><a href="https://rads.stackoverflow.com/amzn/click/com/0201403536" rel="noreferrer" rel="nofollow noreferrer">Compiler Construction</a> $</li>
<li><a href="https://rads.stackoverflow.com/amzn/click/com/0442275366" rel="noreferrer" rel="nofollow noreferrer">Compiler Design and Construction</a> $</li>
<li><a href="https://rads.stackoverflow.com/amzn/click/com/0805321667" rel="noreferrer" rel="nofollow noreferrer">Crafting a Compiler with C</a> $</li>
<li><a href="http://craftinginterpreters.com/" rel="noreferrer">Crafting Interpreters</a></li>
<li>[Compiler Design in C] <a href="http://www.holub.com/software/compiler.design.in.c.html" rel="noreferrer">12</a> ¶</li>
<li><a href="https://rads.stackoverflow.com/amzn/click/com/0321486811" rel="noreferrer" rel="nofollow noreferrer">Compilers: Principles, Techniques, and Tools</a> $ — aka <a href="http://en.wikipedia.org/wiki/Compilers:_Principles%2C_Techniques%2C_and_Tools" rel="noreferrer">&quot;The Dragon Book&quot;</a>; widely considered &quot;the book&quot; for compiler writing.</li>
<li><a href="https://rads.stackoverflow.com/amzn/click/com/012088478X" rel="noreferrer" rel="nofollow noreferrer">Engineering a Compiler</a> $</li>
<li><a href="http://www.cs.indiana.edu/eopl/" rel="noreferrer">Essentials of Programming Languages</a></li>
<li><a href="http://flipcode.com/archives/articles.shtml" rel="noreferrer">Flipcode Article Archive</a> (look for &quot;Implementing A Scripting Engine by Jan Niestadt&quot;)</li>
<li><a href="https://rads.stackoverflow.com/amzn/click/com/1931841578" rel="noreferrer" rel="nofollow noreferrer">Game Scripting Mastery</a> $</li>
<li><a href="http://www.codeproject.com/KB/recipes/B32Machine1/VMCS.pdf" rel="noreferrer">How to build a virtual machine from scratch in C#</a> ¶</li>
<li><a href="http://research.microsoft.com/%7Esimonpj/papers/pj-lester-book/" rel="noreferrer">Implementing Functional Languages</a></li>
<li><a href="http://www1.digitalgrammars.com/ipl-book/" rel="noreferrer">Implementing Programming Languages (with BNFC)</a></li>
<li><a href="http://www.codeproject.com/KB/recipes/programminglanguagetoools.aspx" rel="noreferrer">Implementing Programming Languages using C# 4.0</a></li>
<li><a href="http://en.wikipedia.org/wiki/Interpreter_pattern" rel="noreferrer">Interpreter pattern</a> (described in <a href="https://rads.stackoverflow.com/amzn/click/com/0201633612" rel="noreferrer" rel="nofollow noreferrer">Design Patterns</a> $) specifies a way to evaluate sentences in a language</li>
<li><a href="http://pragprog.com/titles/tpdsl/language-implementation-patterns" rel="noreferrer">Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages</a> $</li>
<li><a href="http://compilers.iecc.com/crenshaw/" rel="noreferrer">Let's Build a Compiler</a> by Jack Crenshaw — The <a href="http://www.stack.nl/%7Emarcov/compiler.pdf" rel="noreferrer">PDF</a> ¶ version (examples are in Pascal, but the information is generally applicable)</li>
<li><a href="http://books.google.com/books?id=Id9cYsIdjIwC&amp;lpg=PP1&amp;ots=IxFkFWJ-8V&amp;dq=%22linkers%20and%20loaders%22&amp;pg=PA215#v=onepage&amp;q=%22linkers%20and%20loaders%22&amp;f=false" rel="noreferrer">Linkers and Loaders</a> $ (Google Books)</li>
<li><a href="https://rads.stackoverflow.com/amzn/click/com/0521562473" rel="noreferrer" rel="nofollow noreferrer">Lisp in Small Pieces (LiSP)</a> $</li>
<li><a href="http://llvm.org/docs/tutorial/" rel="noreferrer">LLVM Tutorial</a></li>
<li><a href="https://rads.stackoverflow.com/amzn/click/com/0521607647" rel="noreferrer" rel="nofollow noreferrer">Modern Compiler Implementation in ML</a> $ — There is a <a href="https://rads.stackoverflow.com/amzn/click/com/052182060X" rel="noreferrer" rel="nofollow noreferrer">Java</a> $ and <a href="https://rads.stackoverflow.com/amzn/click/com/0521607655" rel="noreferrer" rel="nofollow noreferrer">C</a> $ version as well - widely considered a very good book</li>
<li><a href="http://www.amazon.com/gp/offer-listing/013630740X?tag=thecompilerconne&amp;camp=14573&amp;creative=327641&amp;linkCode=am1&amp;creativeASIN=013630740X&amp;adid=0JPMVBRNCAN6PDKGYSXX&amp;" rel="noreferrer">Object-Oriented Compiler Construction</a> $</li>
<li><a href="http://www.dickgrune.com/Books/PTAPG_1st_Edition/" rel="noreferrer">Parsing Techniques - A Practical Guide</a></li>
<li><a href="http://www-old.oberon.ethz.ch/WirthPubl/ProjectOberon.pdf" rel="noreferrer">Project Oberon</a> ¶ - Look at chapter 13</li>
<li><a href="https://rads.stackoverflow.com/amzn/click/com/0137302673" rel="noreferrer" rel="nofollow noreferrer">Programming a Personal Computer</a> $</li>
<li><a href="http://www.cs.brown.edu/%7Esk/Publications/Books/ProgLangs/" rel="noreferrer">Programing Languages: Application and Interpretation</a></li>
<li><a href="http://repository.readscheme.org/ftp/papers/ai-lab-pubs/AITR-474.pdf" rel="noreferrer">Rabbit: A Compiler for Scheme</a>¶</li>
<li><a href="http://web.archive.org/web/20141221110345/http://cm.bell-labs.com/who/ken/trust.html" rel="noreferrer">Reflections on Trusting Trust</a> — A quick guide</li>
<li><a href="http://msdn.microsoft.com/en-us/magazine/cc136756.aspx" rel="noreferrer">Roll Your Own Compiler for the .NET framework</a> — A quick tutorial from MSDN</li>
<li><a href="http://mitpress.mit.edu/sicp/" rel="noreferrer">Structure and Interpretation of Computer Programs</a></li>
<li><a href="http://www.cis.upenn.edu/%7Ebcpierce/tapl/" rel="noreferrer">Types and Programming Languages</a></li>
<li><a href="http://prog21.dadgum.com/30.html" rel="noreferrer">Want to Write a Compiler?</a> - a quick guide</li>
<li><a href="http://www.hokstad.com/writing-a-compiler-in-ruby-bottom-up-step-1.html" rel="noreferrer">Writing a Compiler in Ruby Bottom Up</a></li>
<li><a href="https://bernsteinbear.com/blog/compiling-a-lisp-0/" rel="noreferrer">Compiling a Lisp</a> — compile directly to x86-64</li>
</ul>
Legend:
<ul>
<li>¶ Link to a PDF file</li>
<li>$ Link to a printed book</li>
</ul>

blocks|key|816252|text|“让我们构建一个编译器”很棒，但它有点过时了。(我并不是说它会使它变得更不合理。)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|816253|或者去看看俚语。这类似于“让我们构建一个编译器”，但这是一个更好的资源，特别是对于初学者。这是一个pdf教程，采取7步的方法来教你一个编译器。添加quora链接，因为它具有C%2B%2B、java和JS中所有各种俚语端口的链接，也是python和Java中的解释器，最初使用C#和.NET平台编写。|816254|entityMap|0|LINK|mutability|MUTABLE|url|http://compilers.iecc.com/crenshaw/|1|https://www.quora.com/As-a-self-taught-programmer-how-can-I-learn-about-compilers/answer/Akhil-Kooliyatt?srid=TAGM^0|0|C|0|0|5|2|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]]]]

<a href="http://compilers.iecc.com/crenshaw/" rel="noreferrer">"Let's Build a Compiler"</a> is awesome, but it's a bit outdated. (I'm not saying it makes it even a little bit less valid.)

Or check out <a href="https://www.quora.com/As-a-self-taught-programmer-how-can-I-learn-about-compilers/answer/Akhil-Kooliyatt?srid=TAGM" rel="noreferrer">SLANG</a>. This is similar to "Let's Build a Compiler" but is a much better resource especially for beginners. This comes with a pdf tutorial which takes a 7 step approach at teaching you a compiler. Adding the quora link as it have the links to all the various ports of SLANG, in C++, Java and JS, also interpreters in python and java, originally written using C# and the .NET platform.

blocks|key|98335|text|我同意“龙书参考”，国际海事组织，它是编译器建设的最终指南。不过，为一些硬理论做好准备吧。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|98336|如果你想要一本理论上较轻的书，游戏脚本掌握可能是一本更适合你的书。如果你是编译器理论方面的新手，它提供了一个更温和的介绍。它没有涵盖更实际的解析方法(选择非预测递归下降而不讨论LL或LR解析)，我记得，它甚至没有讨论任何类型的优化理论。另外，它不是编译成机器代码，而是编译成一个字节码，该字节码应该运行在您也编写的VM上。|offset|length|98337|它仍然是一个不错的读物，特别是如果你能在亚马逊上以便宜的价格买到它。如果您只想简单地介绍编译器，那么掌握游戏脚本并不是一件坏事。如果你想硬着头皮走在前面，那么你就应该满足于“龙书”。|98338|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/1931841578^0|0|F|6|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

I concur with the Dragon Book reference; IMO, it is the definitive guide to compiler construction. Get ready for some hardcore theory, though.

If you want a book that is lighter on theory, <a href="https://rads.stackoverflow.com/amzn/click/com/1931841578" rel="noreferrer" rel="nofollow noreferrer">Game Scripting Mastery</a> might be a better book for you. If you are a total newbie at compiler theory, it provides a gentler introduction. It doesn't cover more practical parsing methods (opting for non-predictive recursive descent without discussing LL or LR parsing), and as I recall, it doesn't even discuss any sort of optimization theory. Plus, instead of compiling to machine code, it compiles to a bytecode that is supposed to run on a VM that you also write.

It's still a decent read, particularly if you can pick it up for cheap on Amazon. If you only want an easy introduction into compilers, Game Scripting Mastery is not a bad way to go. If you want to go hardcore up front, then you should settle for nothing less than the Dragon Book.

blocks|key|812111|text|如果您希望使用功能强大、级别更高的工具，而不是自己构建所有的东西，那么查看这门课的项目和阅读是一个不错的选择。这是Java解析器引擎ANTLR作者的语言课程。你可以从务实的程序员那里得到这门课程的这本书。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|812112|本课程介绍了您在其他地方可以看到的标准编译器内容:解析、类型和类型检查、多态性、符号表和代码生成。几乎所有未涉及的内容都是优化。最后一个项目是编译C的子集的一个程序。因为您使用了诸如ANTLR和LLVM之类的工具，所以在一天内编写整个编译器是可行的(我有这方面的存在证明，尽管我指的是24小时)。它在实际工程中使用现代工具很重，理论上稍微轻一些。|812113|顺便说一句，LLVM简直太棒了。在许多情况下，您通常会向下编译到程序集，那么最好将其编译为LLVM中间表示。它具有更高的层次，跨平台，并且LLVM非常擅长于从它生成优化的程序集。|812114|entityMap|0|LINK|mutability|MUTABLE|url|http://www.antlr.org/wiki/display/CS652/CS652%2BHome|1|http://www.pragprog.com/titles/tpantlr/the-definitive-antlr-reference|2|http://www.antlr.org/wiki/display/CS652/C%2Bsubset%2Bcompiler|3|http://llvm.org/docs/LangRef.html^0|11|3|0|2B|6|1|0|1Z|6|2|0|19|8|3|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]|$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|H|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]|T|$5|K|L|M|C|$N|U]]]]

If you're looking to use powerful, higher level tools rather than building everything yourself, going through the projects and readings for <a href="http://www.antlr.org/wiki/display/CS652/CS652+Home" rel="noreferrer">this course</a> is a pretty good option. It's a languages course by the author of the Java parser engine ANTLR. You can get the book for the course as a PDF from <a href="http://www.pragprog.com/titles/tpantlr/the-definitive-antlr-reference" rel="noreferrer">the Pragmatic Programmers</a>.

The course goes over the standard compiler compiler stuff that you'd see elsewhere: parsing, types and type checking, polymorphism, symbol tables, and code generation. Pretty much the only thing that isn't covered is optimizations. The final project is a program that <a href="http://www.antlr.org/wiki/display/CS652/C+subset+compiler" rel="noreferrer">compiles a subset of C</a>. Because you use tools like ANTLR and LLVM, it's feasible to write the entire compiler in a single day (I have an existence proof of this, though I do mean ~24 hours). It's heavy on practical engineering using modern tools, a bit lighter on theory.

LLVM, by the way, is simply fantastic. Many situations where you might normally compile down to assembly, you'd be much better off compiling to <a href="http://llvm.org/docs/LangRef.html" rel="noreferrer">LLVM's Intermediate Representation</a> instead. It's higher level, cross platform, and LLVM is quite good at generating optimized assembly from it.

blocks|key|98411|text|龙书绝对是一本“构建编译器”的书，但是如果您的语言不像当前一代语言那么复杂，您可能想看看设计模式的解释器模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|98412|书中的例子设计了一种规则表达式式的语言，并且经过深思熟虑，但正如他们在书中所说的那样，它对贯穿整个过程是有益的，但实际上只对小语言有效。然而，用这种模式为一种小型语言编写解释器要比学习所有不同类型的解析器、yacc和lex等等要快得多.|98413|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0321486811|1|https://rads.stackoverflow.com/amzn/click/com/0201633612^0|0|2|0|18|4|1|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|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]]]]

<a href="https://rads.stackoverflow.com/amzn/click/com/0321486811" rel="noreferrer" rel="nofollow noreferrer">The Dragon Book</a> is definitely the "building compilers" book, but if your language isn't quite as complicated as the current generation of languages, you may want to look at the Interpreter pattern from <a href="https://rads.stackoverflow.com/amzn/click/com/0201633612" rel="noreferrer" rel="nofollow noreferrer">Design Patterns</a>.

The example in the book designs a regular expression-like language and is well thought through, but as they say in the book, it's good for thinking through the process but is effective really only on small languages. However, it is much faster to write an Interpreter for a small language with this pattern than having to learn about all the different types of parsers, yacc and lex, et cetera...

blocks|key|98481|text|我认为现代编译器在ML中的实现是编写文本的最好的入门编译器。还有一个Java版本和一个C版，考虑到您的语言背景，这两种语言都可能更容易访问。这本书包含了许多有用的基本材料(扫描和解析、语义分析、激活记录、指令选择、RISC和x86本机代码生成)和各种“高级”主题(编译面向对象和函数语言、多态性、垃圾收集、优化和单个静态赋值形式)到相对较小的空间(约500页)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|98482|比起巨龙书，我更喜欢现代编译器的实现，因为现代编译器的实现对领域的调查较少--相反，它对所有主题都有很好的涵盖，你需要编写一个严肃、体面的编译器。在你读完这本书之后，如果你需要的话，你将准备好直接处理研究论文，以获得更多的深度。|98483|我必须承认，我对尼克劳斯·威尔斯(+Niklaus+)的“编译器构造”(这是一个PDF格式的可在线获得+)有一个严肃的软肋。我觉得Wirth的编程美学很美，但是有些人觉得他的风格太少了(例如，Wirth倾向于递归下降解析器，但大多数CS课程侧重于解析器生成器；Wirth的语言设计相当保守)。编译器结构是Wirth的基本思想的一个非常简洁的升华，所以不管你是否喜欢他的风格，我强烈推荐读这本书。|98484|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0521607647|1|https://rads.stackoverflow.com/amzn/click/com/052182060X|2|https://rads.stackoverflow.com/amzn/click/com/0521607655|3|https://rads.stackoverflow.com/amzn/click/com/0201403536|4|http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf^0|3|C|0|Y|6|1|17|2|2|0|0|T|5|3|1A|5|4|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]|$A|11|B|12|1|13]|$A|14|B|15|1|16]]|C|$]]|$1|D|3|E|5|6|7|17|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]|$A|1C|B|1D|1|1E]]|C|$]]|$1|H|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]|T|$5|K|L|M|C|$N|U]]|V|$5|K|L|M|C|$N|W]]]]

I think <a href="https://rads.stackoverflow.com/amzn/click/com/0521607647" rel="noreferrer" rel="nofollow noreferrer" title="Modern Compiler Implementation in ML">Modern Compiler Implementation in ML</a> is the best introductory compiler writing text. There's a <a href="https://rads.stackoverflow.com/amzn/click/com/052182060X" rel="noreferrer" rel="nofollow noreferrer" title="Modern Compiler Implementation in Java">Java version</a> and a <a href="https://rads.stackoverflow.com/amzn/click/com/0521607655" rel="noreferrer" rel="nofollow noreferrer" title="Modern Compiler Implementation in C">C version</a> too, either of which might be more accessible given your languages background. The book packs a lot of useful basic material (scanning and parsing, semantic analysis, activation records, instruction selection, RISC and x86 native code generation) and various "advanced" topics (compiling OO and functional languages, polymorphism, garbage collection, optimization and single static assignment form) into relatively little space (~500 pages).

I prefer Modern Compiler Implementation to the Dragon book because Modern Compiler implementation surveys less of the field--instead it has really solid coverage of all the topics you would need to write a serious, decent compiler. After you work through this book you'll be ready to tackle research papers directly for more depth if you need it.

I must confess I have a serious soft spot for Niklaus Wirth's <a href="https://rads.stackoverflow.com/amzn/click/com/0201403536" rel="noreferrer" rel="nofollow noreferrer" title="Compiler Construction">Compiler Construction.</a> It is <a href="http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf" rel="noreferrer" title="Compiler Construction (PDF)">available online</a> as a PDF. I find Wirth's programming aesthetic simply beautiful, however some people find his style too minimal (for example Wirth favors recursive descent parsers, but most CS courses focus on parser generator tools; Wirth's language designs are fairly conservative.) Compiler Construction is a very succinct distillation of Wirth's basic ideas, so whether you like his style or not or not, I highly recommend reading this book.

blocks|key|812140|text|Python与用Python编写的python编译器捆绑在一起。您可以看到源代码，它包括解析、抽象语法树、发射代码等所有阶段。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812141|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|$]]

Python comes bundled with a python compiler written in Python. You can see the source code, and it includes all phases, from parsing, abstract syntax tree, emitting code, etc.
Hack it.

blocks|key|98521|text|有一本书还没有提出，但非常重要的是约翰·莱文的““链接器和装载机””。如果不使用外部汇编程序，则需要一种输出对象文件的方法，该对象文件可以链接到最终程序中。即使您使用的是外部汇编程序，您也可能需要了解重新定位以及整个程序加载过程是如何工作的。这本书收集了很多关于这个过程的随机知识，包括Win32和Linux。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|98522|entityMap|0|LINK|mutability|MUTABLE|url|http://books.google.com/books?id=h34d_jr2iikC&dq=%2522linkers%2Band%2Bloaders%2522&pg=PP1&ots=IxFkFWJ-8V&sig=GSlclmkezTRL6YYguGJmZsnkM3c&hl=en&sa=X&oi=book_result&resnum=1&ct=result^0|O|9|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]]]]

One book not yet suggested but very important is <a href="http://books.google.com/books?id=h34d_jr2iikC&amp;dq=%22linkers+and+loaders%22&amp;pg=PP1&amp;ots=IxFkFWJ-8V&amp;sig=GSlclmkezTRL6YYguGJmZsnkM3c&amp;hl=en&amp;sa=X&amp;oi=book_result&amp;resnum=1&amp;ct=result" rel="noreferrer">"Linkers and Loaders"</a> by John Levine. If you're not using an external assembler, you'll need a way to output a object file that can be linked into your final program. Even if you're using an external assembler, you'll probably need to understand relocations and how the whole program loading process works to make a working tool. This book collects a lot of the random lore around this process for various systems, including Win32 and Linux.

blocks|key|1098103|text|创建编译器的一种简单方法是使用bison和flex+(或类似的)，在C中构建树(AST)并生成代码，生成C代码是最重要的步骤。通过生成C代码，您的语言将自动在所有具有C编译器的平台上工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1098104|生成C代码就像生成HTML一样容易(只需使用print或等效的)，而这又比编写C解析器或HTML解析器容易得多。|1098105|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

An easy way to create a compiler is to use bison and flex (or similar), build a tree (AST) and generate code in C. With generating C code being the most important step. By generating C code, your language will automatically work on all platforms that have a C compiler.

Generating C code is as easy as generating HTML (just use print, or equivalent), which in turn is much easier than writing a C parser or HTML parser.

blocks|key|812176|text|如果您愿意使用LLVM，请查看以下内容：http://llvm.org/docs/tutorial/。它教会您如何使用LLVM的框架从头开始编写编译器，并且不假定您对这个主题有任何了解。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|812177|本教程建议您编写自己的解析器和lexer等，但我建议您了解一下bison和flex。他们让生活变得轻松多了。|812178|entityMap|0|LINK|mutability|MUTABLE|url|http://llvm.org/docs/tutorial/^0|K|U|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

If you're willing to use LLVM, check this out: <a href="http://llvm.org/docs/tutorial/" rel="noreferrer">http://llvm.org/docs/tutorial/</a>. It teaches you how to write a compiler from scratch using LLVM's framework, and doesn't assume you have any knowledge about the subject.

The tutorial suggest you write your own parser and lexer etc, but I advise you to look into bison and flex once you get the idea. They make life so much easier.

blocks|key|816414|text|作为起点，最好创建递归下降解析器(RDP)+(假设您希望创建自己的BASIC风格并构建基本解释器)，以了解如何编写编译器。我在Herbert的"C超级用户“第7章中找到了最好的信息，这一章引用了H.+Schild的另一本书”C完全参考“，他在书中解释了如何创建一个计算器(一个简单的表达式解析器)。我发现两本关于eBay的书都很便宜。如果你去www.osborne.com或签入www.HerbSchildt.com，你可以检查这本书的代码--我在他最近的一本书中发现了C#的相同代码|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|816415|entityMap|0|LINK|mutability|MUTABLE|url|http://www.herbschildt.com/^0|59|J|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]]]]

As an starting point, it will be good to create a recursive descent parser (RDP) (let's say you want to create your own flavour of BASIC and build a BASIC interpreter) to understand how to write a compiler.
I found the best information in Herbert Schild's C Power Users, chapter 7. This chapter refers to another book of H. Schildt "C The complete Reference" where he explains how to create a calculator (a simple expression parser). I found both books on eBay very cheap.
You can check the code for the book if you go to www.osborne.com or check in <a href="http://www.HerbSchildt.com" rel="nofollow noreferrer">www.HerbSchildt.com</a>
I found the same code but for C# in his latest book

blocks|key|812232|text|“.让我们建立一个编译器.”|type|blockquote|depth|inlineStyleRanges|entityRanges|data|812233|我会在http://compilers.iecc.com/crenshaw/和@sasb第二位。暂时忘了多买些书吧。|unstyled|offset|length|812234|为什么？工具和语言。|812235|所需的语言是Pascal，如果我没记错的话，它是基于Turbo的.如果您访问http://www.freepascal.org/并下载Pascal编译器，所有的示例都直接从页面~+http://www.freepascal.org/download.var中运行，免费Pascal的优点是，您可以使用它，几乎可以使用您所关心的任何处理器或操作系统。|812236|一旦你掌握了课程，然后尝试更高级的"http://en.wikipedia.org/wiki/Dragon_book“~+书|812237|entityMap|0|LINK|mutability|MUTABLE|url|http://compilers.iecc.com/crenshaw/|1|https://stackoverflow.com/questions/1669/learning-to-write-a-compiler#1678|2|http://www.freepascal.org/|3|http://www.freepascal.org/download.var|4|http://en.wikipedia.org/wiki/Dragon_book|5^0|0|3|Z|0|13|5|1|0|0|12|Q|2|2I|12|3|0|I|14|4|1P|1|5|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@$E|15|F|16|1|17]|$E|18|F|19|1|1A]]|A|$]]|$1|G|3|H|5|D|7|1B|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1C|8|@]|9|@$E|1D|F|1E|1|1F]|$E|1G|F|1H|1|1I]]|A|$]]|$1|K|3|L|5|D|7|1J|8|@]|9|@$E|1K|F|1L|1|1M]|$E|1N|F|1O|1|1P]]|A|$]]|$1|M|3|-4|5|D|7|1Q|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]|W|$5|P|Q|R|A|$S|X]]|Y|$5|P|Q|R|A|$S|Z]]|10|$5|P|Q|R|A|$S|11]]|12|$5|P|Q|R|A|$S|11]]]]

<blockquote>
 "... Let's Build a Compiler ..."
</blockquote>

I'd second <a href="http://compilers.iecc.com/crenshaw/" rel="nofollow noreferrer">http://compilers.iecc.com/crenshaw/</a> by <a href="https://stackoverflow.com/questions/1669/learning-to-write-a-compiler#1678">@sasb</a>. Forget buying more books for the moment.

Why? Tools &amp; language. 

The language required is Pascal and if I remember correctly is based on Turbo-Pascal. It just so happens if you go to <a href="http://www.freepascal.org/" rel="nofollow noreferrer">http://www.freepascal.org/</a> and download the Pascal compiler all the examples work straight from the page ~ <a href="http://www.freepascal.org/download.var" rel="nofollow noreferrer">http://www.freepascal.org/download.var</a> The beaut thing about Free Pascal is you can use it almost whatever processor or OS you can care for. 

Once you have mastered the lessons then try the more advanced "<a href="http://en.wikipedia.org/wiki/Dragon_book" rel="nofollow noreferrer">Dragon Book</a>" ~ <a href="http://en.wikipedia.org/wiki/Dragon_book" rel="nofollow noreferrer">http://en.wikipedia.org/wiki/Dragon_book</a>

blocks|key|1098264|text|我也喜欢Crenshaw教程，因为它非常清楚地表明，编译器只是另一个程序，它读取一些输入，编写一些输出输出。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1098265|读一读。|1098266|如果您愿意，可以使用它，但是请看另一个关于如何真正编写更大和更完整的编译器的引用。|1098267|阅读论信任，了解在这个领域可以做的一些不明显的事情。|1098268|entityMap|0|LINK|mutability|MUTABLE|url|http://compilers.iecc.com/crenshaw/|1|http://cm.bell-labs.com/who/ken/trust.html^0|4|A|0|0|0|0|2|3|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|M|N|O|C|$P|S]]]]

I liked the <A HREF="http://compilers.iecc.com/crenshaw/" rel="nofollow noreferrer">Crenshaw tutorial</A> too, because it makes it absolutely clear that a compiler is just another program that reads some input and writes some out put. 

Read it. 

Work it if you want, but then look at another reference on how bigger and more complete compilers are really written.

And read <A href="http://cm.bell-labs.com/who/ken/trust.html" rel="nofollow noreferrer">On Trusting Trust</A>, to get a clue about the unobvious things that can be done in this domain.

blocks|key|816486|text|Fraser和Hanson的LCC编译器(维基百科)+(项目主页)+(github.com/drh/lcc)在他们的著作“一个可重定向的C编译器:设计和实现”中进行了描述。它非常可读性强，并解释了整个编译器，包括代码生成。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|816487|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Local_C_compiler|1|http://www.cs.princeton.edu/software/lcc/|2|https://github.com/drh/lcc^0|L|4|0|S|4|1|Z|I|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

The LCC compiler (<a href="http://en.wikipedia.org/wiki/Local_C_compiler" rel="nofollow noreferrer">wikipedia</a>) (<a href="http://www.cs.princeton.edu/software/lcc/" rel="nofollow noreferrer">project homepage</a>) (<a href="https://github.com/drh/lcc" rel="nofollow noreferrer">github.com/drh/lcc</a>) of Fraser and Hanson is described in their book "A Retargetable C Compiler: Design and Implementation". It is quite readable and explains the whole compiler, down to code generation.

blocks|key|1098345|text|这里有很多好的答案，所以我想我应该在清单上再加一个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1098346|十多年前，我买了一本叫做“Oberon项目”的书，里面有一些关于编译器的很好的文字。这本书确实很突出，因为它的来源和解释都是可读性很强的。完整的文本(2005年版)已经提供了pdf，所以你现在可以下载。编译器将在第12章中讨论：|1098347|http://www.ethoberon.ethz.ch/WirthPubl/ProjectOberon.pdf|offset|length|1098348|Niklaus+Wirth，Jürg+Gutknecht|1098349|(这种处理方式不如他关于编译器的书那么广泛)|1098350|我读过几本关于编译器的书，我可以再读一本龙书，花在这本书上的时间是非常值得的。|1098351|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1K|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@$F|X|G|Y|1|Z]]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|12|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|E]]]]

There's a lot of good answers here, so i thought I'd just add one more to the list:

I got a book called Project Oberon more than a decade ago, which has some very well written text on the compiler. The book really stands out in the sense that the source and explanations is very hands on and readable. The complete text (the 2005 edition) has been made available in pdf, so you can download right now. The compiler is discussed in chapter 12:

<a href="http://www.ethoberon.ethz.ch/WirthPubl/ProjectOberon.pdf" rel="nofollow noreferrer">http://www.ethoberon.ethz.ch/WirthPubl/ProjectOberon.pdf</a>

Niklaus Wirth, Jürg Gutknecht

(The treatment is not as extensive as his book on compilers)

I've read several books on compilers, and i can second the dragon book, time spent on this book is very worthwhile.

blocks|key|812309|text|如果您对为函数式语言(而不是程序性语言)编写编译器感兴趣，那么Simon和David的"实现功能语言:教程“是一个很好的指南。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|812310|功能评估如何工作的概念基础是以一种简单但强大的功能语言“核心”中的示例为指导的。此外，用Miranda+(一种非常类似于Haskell的纯函数式语言)的代码示例解释了Core语言编译器的每个部分。|812311|本文描述了几种不同类型的编译器，但是即使您只遵循所谓的Core模板编译器，您也会非常了解什么是函数编程。|812312|entityMap|0|LINK|mutability|MUTABLE|url|http://research.microsoft.com/~simonpj/papers/pj-lester-book/^0|18|9|0|0|0|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|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

If you are interested in writing a compiler for a functional language (rather than a procedural one) Simon Peyton-Jones and David Lester's "<a href="http://research.microsoft.com/~simonpj/papers/pj-lester-book/" rel="noreferrer">Implementing functional languages: a tutorial</a>" is an excellent guide. 

The conceptual basics of how functional evaluation works is guided by examples in a simple but powerful functional language called "Core". Additionally, each part of the Core language compiler is explained with code examples in Miranda (a pure functional language very similar to Haskell). 

Several different types of compilers are described but even if you only follow the so-called template compiler for Core you will have an excellent understanding of what makes functional programming tick.

blocks|key|816547|text|龙书太复杂了。因此，忽略它作为一个起点。它很好，一旦你有了一个起点，你就会想很多，但首先，也许你应该尝试用RD、LL或LR解析技术编写一个数学/逻辑表达式评估器，并使用C/Java中手工编写的所有东西(词法/解析)。这本身就很有趣，可以让您了解编译器所涉及的问题。然后，您可以使用一些脚本语言(因为在这些语言中处理文本通常更容易)进入您自己的DSL，就像有人说的那样，在脚本语言本身或C中生成代码。如果要在c/java中这样做，那么您可能应该使用flex/bison/antlr等来进行词法/解析。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|816548|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|$]]

The Dragon Book is too complicated. So ignore it as a starting point. It is good and makes you think a lot once you already have a starting point, but for starters, perhaps you should simply try to write an math/logical expression evaluator using RD, LL or LR parsing techniques with everything (lexing/parsing) written by hand in perhaps C/Java. This is interesting in itself and gives you an idea of the problems involved in a compiler. Then you can jump in to your own DSL using some scripting language (since processing text is usually easier in these) and like someone said, generate code in either the scripting language itself or C. You should probably use flex/bison/antlr etc to do the lexing/parsing if you are going to do it in c/java.

blocks|key|1098503|text|您应该查看Darius的"鱼翅"，它是一个针对C的小型Lisp方言的编译器，只需6页以上的代码即可。与大多数玩具编译器相比，它的优势是语言足够完整，编译器可以用它编写。(+tarball还包括一个用于引导该东西的解释器。)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1098504|在我的Ur-计划网页上学习编写编译器时，我发现了更多有用的东西。|1098505|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/darius/ichbins|1|http://www.canonical.org/~kragen/sw/urscheme/^0|D|2|0|0|3|5|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]]]]

You should check out Darius Bacon's "<a href="https://github.com/darius/ichbins" rel="nofollow noreferrer" title="I can hardly believe it&#39;s not Scheme">ichbins</a>", which is a compiler for a small Lisp dialect, targeting C, in just over 6 pages of code. The advantage it has over most toy compilers is that the language is complete enough that the compiler is written in it. (The tarball also includes an interpreter to bootstrap the thing.)

There's more stuff about what I found useful in learning to write a compiler on my <a href="http://www.canonical.org/~kragen/sw/urscheme/" rel="nofollow noreferrer" title="a small self-hosted Scheme to x86 asm compiler">Ur-Scheme</a> web page.

blocks|key|99036|text|我正在研究同样的概念，并发现Joel+Pobar的这篇很有前途的文章，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|99037|为.NET框架创建一个语言编译器--不确定它在哪里|offset|length|99038|为.NET框架创建一个语言编译器-原始文档的pdf副本|99039|他讨论了编译器的高级概念，并着手为.Net框架创建自己的语言。虽然它的目标是.Net框架，但许多概念应该能够被复制。该条涵盖：|99040|Langauge定义|ordered-list-item|99041|扫描仪|99042|解析器(我主要感兴趣的位)|99043|以.Net框架为目标|99044|码发生器|99045|还有其他的话题，但你得到了公正。|99046|它的目标是让人们开始学习，用C#编写(并不完全是Java)|99047|HTH|99048|骨骼|99049|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/magazine/cc136756.aspx|1^0|0|0|P|0|0|0|R|1|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@$D|1D|E|1E|1|1F]]|A|$]]|$1|F|3|G|5|6|7|1G|8|@]|9|@$D|1H|E|1I|1|1J]]|A|$]]|$1|H|3|I|5|6|7|1K|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1L|8|@]|9|@]|A|$]]|$1|M|3|N|5|L|7|1M|8|@]|9|@]|A|$]]|$1|O|3|P|5|L|7|1N|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1O|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|1P|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1S|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1T|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]|1A|$5|15|16|17|A|$18|19]]]]

I am looking into the same concept, and found this promising article by Joel Pobar,

<a href="http://msdn.microsoft.com/en-us/magazine/cc136756.aspx" rel="nofollow noreferrer">Create a Language Compiler for the .NET Framework - not sure where this has gone</a>

<a href="http://msdn.microsoft.com/en-us/magazine/cc136756.aspx" rel="nofollow noreferrer">Create a Language Compiler for the .NET Framework - pdf copy of the original doc</a>

he discusses a high level concept of a compiler and proceeds to invent his own langauge for the .Net framework. Although its aimed at the .Net Framework, many of the concepts should be able to be reproduced. The Article covers:

<ol>
<li>Langauge definition </li>
<li>Scanner </li>
<li>Parser (the bit im mainly interested in)</li>
<li>Targeting the .Net Framework The</li>
<li>Code Generator</li>
</ol>

there are other topics, but you get the just.

Its aimed to people starting out, written in C# (not quite Java)

HTH

bones

blocks|key|1098567|text|如果你和我一样，没有受过正规的计算机科学教育，并且对编译感兴趣/想知道编译器是如何工作的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1098568|我推荐“Java编程语言处理器:编译器和解释器”，这是一本对自学的计算机程序员来说很棒的书。|1098569|在我看来，理解这些基本语言理论、自动化机器和集合论并不是什么大问题。问题是如何将这些东西转换成代码。上面的书告诉您如何编写解析器、分析上下文和生成代码。如果你不能理解这本书，那么我不得不说，放弃构建一个编译器。这本书是我读过的最好的编程书。|1098570|还有另一本书，也是很好的，C中的编译器设计(+Compiler+)，里面有很多代码，它告诉你如何构建编译器和词汇工具。|1098571|构建编译器是一种有趣的编程实践，可以教会您大量的编程技能。|1098572|不要买龙书。这是浪费金钱和时间，而不是一个从业者。|offset|length|1098573|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools#Second_edition^0|0|0|0|0|0|3|2|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@$L|11|M|12|1|13]]|A|$]]|$1|N|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

If you are like me, who has no formal computer science education, and is interested in
building/want to know how a compiler works:

I am recommend "Programming Language Processors in Java: Compilers and Interpreters",
an amazing book for a self-taught computer programmer.

From my point of view, understanding those basic language theory, automate machine, and set theory is not a big problem. The problem is how to turn those things into code. The above book tells you how to write a parser, analysis context, and generate code. If you can not understand this book, then I have to say, give up building a compiler. The book is best programming book I have ever read.

There is an other book, also good, Compiler Design in C. There is a lot of code, and it tells you everything about how to build a compiler and lexer tools.

Building a compiler is a fun programming practice and can teach you heaps of programming skills.

Do not buy the <a href="http://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools#Second_edition" rel="nofollow noreferrer">Dragon book</a>. It was a waste of money and time and is not for a practitioner.

blocks|key|99155|text|对不起，这是西班牙文，但这是阿根廷一门名为“汇编和口译”的课程的参考书目。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|99156|课程从正式语言理论到编译器构造，这些都是您需要构建的主题，至少是一个简单的编译器：|99157|blockquote|99158|C语言的编译器设计。
艾伦I.霍卢布|unordered-list-item|99159|普伦提斯-霍尔。1990年。|99160|编剧。Teoría+y+Construcción
Sanchís+Llorca，F.J.，Galán+Pascual，C.社论Paraninfo。1988年。|99161|编译器构造
尼克劳斯|99162|艾迪生-韦斯利。1996年。|99163|Lenguajes，Gramáticas+y+Autómatas联合国恩福克普雷克蒂科
Pedro+Isasi+Vi+uela，Paloma+Martínez+Fernández，Daniel+Borrajo+Millán.+Addison(Espa)。1997年。|99164|编译器设计的艺术。理论和实践。
托马斯·皮特曼詹姆斯·彼得斯。|99165|普伦提斯-霍尔。1992年。|99166|面向对象编译器的构建。
吉姆·福尔摩斯。普伦提斯霍尔，恩格尔伍德悬崖，新泽西州，1995|99167|编剧。原教旨主义。
作者声明：[+B.+]B.+Teufel；|99168|艾迪生-韦斯利伊比利亚美洲。1995年。|99169|自动机理论、语言和计算概论。|99170|约翰·霍普克罗夫特。杰弗里·D·尤尔曼。|99171|Addison-Wesley.+1979.|code-block|syntax|javascript|99172|正式语言简介。
热尔吉·雷维斯兹。|99173|格劳山。1983年。|99174|解析技术。实用指南。
迪克·格鲁恩，克里尔·雅各布斯。
摩托·帕尔·洛斯汽车。一九九五年
http://www.cs.vu.nl/~dick/PTAPG.html|offset|length|99175|雅克:又一个编译器-编译器。
斯蒂芬·约翰逊
计算科学技术报告，第32号，1975年。贝尔实验室。新美利山
泽西岛。|99176|莱克斯:一个词汇分析器生成器。
莱斯克先生施密特先生。计算科学技术报告，第39号，1975年。贝尔实验室。新泽西的默里山。|99177|莱克斯和雅克。
约翰·莱文托尼·梅森道格·布朗。
奥莱利联合公司。1995年。|99178|计算理论的要素。
题名/责任者:+H.+.西贡达·埃迪森·普伦提斯·霍尔。1998年。|99179|联合国Algoritmo+Eficiente+para+la+Construcción+del+Grafo+de+Dependencia+de+Control。
萨尔瓦多V.卡瓦迪尼。
Trabajo+Final+de+Grado+para+el+Título+de+Ingeniero+en+Computación。
Aplicada公司。U.C.S.E.+.+2001。|99180|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cs.vu.nl/~dick/PTAPG.html^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|19|10|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|21|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|22|8|@]|9|@]|A|$]]|$1|D|3|-4|5|E|7|23|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|24|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|25|8|@]|9|@]|A|$]]|$1|K|3|L|5|H|7|26|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|27|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|28|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|29|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|2A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|2B|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|2C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|H|7|2D|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2E|8|@]|9|@]|A|$]]|$1|12|3|13|5|H|7|2F|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|2G|8|@]|9|@]|A|$]]|$1|16|3|17|5|18|7|2H|8|@]|9|@]|A|$19|1A]]|$1|1B|3|1C|5|H|7|2I|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2J|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|H|7|2K|8|@]|9|@$1H|2L|1I|2M|1|2N]]|A|$]]|$1|1J|3|1K|5|H|7|2O|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|H|7|2P|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|H|7|2Q|8|@]|9|@]|A|$]]|$1|1P|3|1Q|5|H|7|2R|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|H|7|2S|8|@]|9|@]|A|$]]|$1|1T|3|-4|5|6|7|2T|8|@]|9|@]|A|$]]]|1U|$1V|$5|1W|1X|1Y|A|$1Z|20]]]]

Sorry, it is in Spanish, but this is the bibliography of a course called "Compiladores e Intérpretes" (Compilers and Interpreters) in Argentina. 

The course was from formal language theory to compiler construction, and these are the topics you need to build, at least, a simple compiler:

<blockquote>
 <ul>
 <li>Compilers Design in C. Allen I. Holub 
 Prentice-Hall. 1990.</li>
 <li>Compiladores. Teoría y Construcción. Sanchís
 Llorca, F.J. , Galán Pascual, C. Editorial Paraninfo. 1988.</li>
 <li>Compiler Construction. Niklaus Wirth 
 Addison-Wesley. 1996.</li>
 <li>Lenguajes, Gramáticas y Autómatas. Un enfoque práctico. Pedro
 Isasi Viñuela, Paloma Martínez
 Fernández, Daniel Borrajo Millán. Addison-Wesley Iberoamericana
 (España). 1997.</li>
 <li>The art of compiler design. Theory and practice. Thomas
 Pittman, James Peters. 
 Prentice-Hall. 1992.</li>
 <li>Object-Oriented Compiler Construction. Jim Holmes.
 Prentice Hall, Englewood
 Cliffs, N.J. 1995</li>
 <li>Compiladores. Conceptos Fundamentales. B. Teufel, S.
 Schmidt, T. Teufel. 
 Addison-Wesley Iberoamericana. 1995.</li>
 <li>Introduction to Automata Theory, Languages, and Computation. 
 John E. Hopcroft. Jeffref D. Ullman.
 Addison-Wesley. 1979.</li>
 <li>Introduction to formal languages. György E. Révész. 
 Mc Graw Hill. 1983.</li>
 <li>Parsing Techniques. A Practical Guide. Dick Grune, Ceriel
 Jacobs. Impreso por los
 autores. 1995 
 <a href="http://www.cs.vu.nl/~dick/PTAPG.html" rel="nofollow noreferrer">http://www.cs.vu.nl/~dick/PTAPG.html</a></li>
 <li>Yacc: Yet Another Compiler-Compiler. Stephen
 C. Johnson Computing Science
 Technical Report Nº 32, 1975. Bell
 Laboratories. Murray Hill, New 
 Jersey.</li>
 <li>Lex: A Lexical Analyzer Generator. M. E. Lesk, E. Schmidt. Computing Science Technical
 Report Nº 39, 1975. Bell Laboratories.
 Murray Hill, New Jersey.</li>
 <li>lex &amp; yacc. John R. Levine, Tony Mason, Doug Brown. 
 O’Reilly &amp; Associates. 1995.</li>
 <li>Elements of the theory of computation. Harry R. Lewis,
 Christos H. Papadimitriou.
 Segunda Edición. Prentice Hall. 1998. </li>
 <li>Un Algoritmo Eficiente para la Construcción del Grafo de Dependencia de Control. 
 Salvador V. Cavadini. 
 Trabajo Final de Grado para obtener el Título de Ingeniero en Computación. 
 Facultad de Matemática Aplicada.
 U.C.S.E. 2001.</li>
 </ul>
</blockquote>

blocks|key|1098723|text|这是一个广泛的课题。不要低估这一点。不要低估我的观点，不要低估它。|type|ordered-list-item|depth|inlineStyleRanges|entityRanges|data|1098724|我听说龙书是(？)开始的地方，还有搜索。)更善于寻找，最终它将成为你的生命。|offset|length|1098725|构建自己的编程语言绝对是一个很好的练习！但要知道，它最终永远不会被用于任何实际目的。这方面的例外很少，而且非常遥远。|1098726|unstyled|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools^0|0|3|2|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@$D|S|E|T|1|U]]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|-4|5|I|7|W|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|P]]]]

<ol>
<li>This is a vast subject. Do not underestimate this point. And do not underestimate my point to not underestimate it.</li>
<li>I hear the <a href="http://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools" rel="nofollow noreferrer">Dragon Book</a> is a (the?) place to start, along with searching. :) Get better at searching, eventually it will be your life.</li>
<li>Building your own programming language is absolutely a good exercise! But know that it will never be used for any practical purpose in the end. Exceptions to this are few and very far between.</li>
</ol>

blocks|key|1098766|text|您可能需要查看Lex/Yacc+(或Flex/Bison，无论您想将它们称为什么)。Flex是一个词法分析器，它将解析和标识语言的语义组件(“记号”)，Bison将用于定义解析每个令牌时发生的事情。对于编译为C的编译器或动态运行指令的编译器来说，这可能是(但不限于)打印出C代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1098767|这个常见问题应该可以帮助您，本教程看起来非常有用。|offset|length|1098768|entityMap|0|LINK|mutability|MUTABLE|url|http://tldp.org/HOWTO/Lex-YACC-HOWTO-5.html|1|http://www.mactech.com/articles/mactech/Vol.16/16.07/UsingFlexandBison/^0|0|0|6|0|E|3|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]|$D|U|E|V|1|W]]|A|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]|N|$5|I|J|K|A|$L|O]]]]

You might want to look into Lex/Yacc (or Flex/Bison, whatever you want to call them). Flex is a lexical analyzer, which will parse and identify the semantic components ("tokens") of your language, and Bison will be used to define what happens when each token is parsed. This could be, but is definitely not limited to, printing out C code, for a compiler that would compile to C, or dynamically running the instructions.

<a href="http://tldp.org/HOWTO/Lex-YACC-HOWTO-5.html" rel="noreferrer">This FAQ</a> should help you, and <a href="http://www.mactech.com/articles/mactech/Vol.16/16.07/UsingFlexandBison/" rel="noreferrer">this tutorial</a> looks quite useful.

blocks|key|1098860|text|我认为，这是一个相当模糊的问题，仅仅是因为所涉问题的深度。然而，编译器可以被分解成两个独立的部分:上半部分和底层一部分.上半部分通常采用源语言并将其转换为中间表示，而下半部则负责平台特定的代码生成。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1098861|尽管如此，一个简单的方法来处理这个主题(至少在我的编译器类中使用的方法)是在上面描述的两部分中构建编译器。具体来说，你只需构建上半身就能很好地了解整个过程。|1098862|只需完成前半部分，您就可以获得编写词法分析器和解析器的经验，并开始生成一些“代码”(我提到的中间表示)。因此，它将获取您的源程序并将其转换为另一个表示，并进行一些优化(如果您愿意的话)，这是编译器的核心。下半部分将采用该中间表示，并生成在特定体系结构上运行程序所需的字节。例如，下半部分将接受您的中间表示并生成PE可执行文件。|1098863|关于这个主题的一些书，我发现特别有用的是编译器原则和技术+(或龙书，由于封面上可爱的龙)。它有一些很好的理论，并且以一种非常容易理解的方式肯定地涵盖了上下文无关的语法。此外，为了构建词法分析器和解析器，您可能会使用*nix工具--+lex和yacc。无趣的是，这本名为"lex和yacc“的书在”龙书“的结尾处找到了这个部分。|offset|length|1098864|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0321486811|1|https://rads.stackoverflow.com/amzn/click/com/1565920007^0|0|0|0|K|8|0|3R|8|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$H|X|I|Y|1|Z]|$H|10|I|11|1|12]]|A|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]]]

This is a pretty vague question, I think; just because of the depth of the topic involved. A compiler can be decomposed into two separate parts, however; a top-half and a bottom-one. The top-half generally takes the source language and converts it into an intermediate representation, and the bottom half takes care of the platform specific code generation.

Nonetheless, one idea for an easy way to approach this topic (the one we used in my compilers class, at least) is to build the compiler in the two pieces described above. Specifically, you'll get a good idea of the entire process by just building the top-half.

Just doing the top half lets you get the experience of writing the lexical analyzer and the parser and go to generating some "code" (that intermediate representation I mentioned). So it will take your source program and convert it to another representation and do some optimization (if you want), which is the heart of a compiler. The bottom half will then take that intermediate representation and generate the bytes needed to run the program on a specific architecture. For example, the the bottom half will take your intermediate representation and generate a PE executable. 

Some books on this topic that I found particularly helpful was <a href="https://rads.stackoverflow.com/amzn/click/com/0321486811" rel="noreferrer" rel="nofollow noreferrer">Compilers Principles and Techniques</a> (or the Dragon Book, due to the cute dragon on the cover). It's got some great theory and definitely covers Context-Free Grammars in a really accessible manner. Also, for building the lexical analyzer and parser, you'll probably use the *nix tools lex and yacc. And uninterestingly enough, the book called "<a href="https://rads.stackoverflow.com/amzn/click/com/1565920007" rel="noreferrer" rel="nofollow noreferrer">lex and yacc</a>" picked up where the Dragon Book left off for this part.

blocks|key|812522|text|我很惊讶它没有被提及，但是Donald的“计算机编程艺术”()最初是作为编译器编写的一种教程而写的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812523|当然，Knuth博士对主题深入研究的倾向导致编译器编写教程被扩展到大约9卷，其中只有3卷实际上已经出版。这是一个关于编程主题的相当完整的说明，涵盖了您需要知道的关于编写编译器的所有细节。|812524|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I'm surprised it hasn't been mentioned, but Donald Knuth's The Art of Computer Programming was originally penned as a sort of tutorial on compiler writing.

Of course, Dr. Knuth's propensity for going in-depth on topics has led to the compiler-writing tutorial being expanded to an estimated 9 volumes, only three of which have actually been published. It's a rather complete exposition on programming topics, and covers everything you would ever need to know about writing a compiler, in minute detail.

blocks|key|812535|text|每当我想尝试一种新的语言理念时，我只需编写一个简单的解析器，并让它生成一些很容易获得良好编译器的语言，比如C。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812536|你认为C%2B%2B是怎么做的？|812537|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Whenever I want to try out a new language idea, I just write a simple parser, and have it generate some language that's easy to get good compilers for, like C.

How do you think C++ was done?

blocks|key|1098984|text|一般来说，编译器没有五分钟的教程，因为它是一个复杂的主题，编写编译器可能需要几个月。你必须自己搜索。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1098985|Python和Ruby通常会被解释。也许你也想从翻译开始。一般比较容易。|1098986|第一步是编写一种正式的语言描述，即编程语言的语法。然后，您必须将要根据语法编译或解释的源代码转换为抽象语法树，这是计算机理解和操作的源代码的内部形式。这一步骤通常称为解析，解析源代码的软件称为解析器。解析器通常由解析器生成器生成，该生成器将形式语法转换为机器代码的源代码。对于一个好的，非数学的解析解释，我推荐解析技术-一个实用指南。Wikipedia对解析器生成器进行了比较，您可以从中选择适合您的生成器。根据您选择的解析器生成器，您将在Internet上找到教程，对于真正流行的解析器生成器(如GNU野牛)，也有书籍。|1098987|为您的语言编写解析器非常困难，但这取决于您的语法。因此，我建议保持语法简单(不像C%2B%2B)；这方面的一个很好的例子是LISP。|1098988|在第二步中，将抽象语法树从树结构转换为线性中间表示。作为一个很好的例子，卢阿的字节码经常被引用。但是中间表示实际上取决于您的语言。|1098989|如果您正在构建一个解释器，您将只需解释中间表示。你也可以及时编译它。我推荐LLVM和libjit进行即时编译。为了使语言可用，您还必须包括一些输入和输出函数，也许还包括一个小的标准库。|1098990|如果您要编译该语言，它将更加复杂。您必须为不同的计算机体系结构编写后端，并从这些后端的中间表示中生成机器代码。我建议LLVM用于此任务。|1098991|有几本关于这个主题的书，但我不能推荐它们中的任何一本用于一般用途。他们中的大多数都太学术或太实际。没有“21天内自学编写编译器”，因此，你必须买几本书才能很好地理解这个主题。如果你在互联网上搜索，你会发现一些在线书籍和课堂讲稿。也许在你附近有一个大学图书馆，你可以在那里借到关于编译器的书。|1098992|我也推荐一个良好的背景知识的理论，计算机科学和图论，如果你要使你的项目认真。拥有计算机科学学位也会有帮助。|1098993|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|10|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|11|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|S|$]]

Generally speaking, there's no five minutes tutorial for compilers, because it's a complicated topic and writing a compiler can take months. You will have to do your own search.

Python and Ruby are usually interpreted. Perhaps you want to start with an interpreter as well. It's generally easier.

The first step is to write a formal language description, the grammar of your programming language. Then you have to transform the source code that you want to compile or interpret according to the grammar into an abstract syntax tree, an internal form of the source code that the computer understands and can operate on. This step is usually called parsing and the software that parses the source code is called a parser. Often the parser is generated by a parser generator which transform a formal grammar into source oder machine code. For a good, non-mathematical explanation of parsing I recommend Parsing Techniques - A Practical Guide. Wikipedia has a comparison of parser generators from which you can choose that one that is suitable for you. Depending on the parser generator you chose, you will find tutorials on the Internet and for really popular parser generators (like GNU bison) there are also books.

Writing a parser for your language can be really hard, but this depends on your grammar. So I suggest to keep your grammar simple (unlike C++); a good example for this is LISP.

In the second step the abstract syntax tree is transformed from a tree structure into a linear intermediate representation. As a good example for this Lua's bytecode is often cited. But the intermediate representation really depends on your language.

If you are building an interpreter, you will simply have to interpret the intermediate representation. You could also just-in-time-compile it. I recommend LLVM and libjit for just-in-time-compilation. To make the language usable you will also have to include some input and output functions and perhaps a small standard library.

If you are going to compile the language, it will be more complicated. You will have to write backends for different computer architectures and generate machine code from the intermediate representation in those backends. I recommend LLVM for this task.

There are a few books on this topic, but I can recommend none of them for general use. Most of them are too academic or too practical. There's no "Teach yourself compiler writing in 21 days" and thus, you will have to buy several books to get a good understanding of this entire topic. If you search the Internet, you will come across some some online books and lecture notes. Maybe there's a university library nearby you where you can borrow books on compilers.

I also recommend a good background knowledge in theoretical computer science and graph theory, if you are going to make your project serious. A degree in computer science will also be helpful.

blocks|key|1099075|text|我记得大约七年前我刚开始编程时就问过这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1099076|当我问的时候，我非常小心，令人惊讶的是，我并没有像你在这里那样受到太多的批评。然而，他们确实指出了"龙书“的方向，在我看来，这是一本非常棒的书，它解释了编写编译器所需了解的一切(当然，您必须掌握一两种语言。你知道的语言越多，就越快乐。)|offset|length|1099077|是的，很多人说读那本书是疯狂的，你不会从中学到任何东西，但我完全不同意。|1099078|许多人还说，编写编译器是愚蠢和无意义的。嗯，编译器开发有用的原因有很多：|1099079|因为这很有趣。|unordered-list-item|1099080|这是有教育意义的，当你学习如何编写编译器时，你会学到很多关于计算机科学和其他技术的知识，这些技术在编写其他应用程序时很有用。|1099081|如果没有人编写编译器，现有的语言就不会变得更好。|1099082|我没有立即编写自己的编译器，但在询问之后，我知道从哪里开始。现在，在学习了许多不同的语言和阅读了“龙书”之后，写作就没那么大的问题了。(我还在学习计算机工程自动取款机(+atm+)，但我知道的大部分编程知识都是自学的。)|1099083|总之，“龙书”是一个伟大的“教程”。但是，在尝试编写编译器之前，要花一些时间掌握一两种语言。不过，不要指望在未来十年左右成为一名编译器大师。|1099084|如果您想学习如何编写解析器/解释器，这本书也是很好的。|1099085|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools^0|0|1E|2|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@$D|16|E|17|1|18]]|A|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1A|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1B|8|@]|9|@]|A|$]]|$1|M|3|N|5|L|7|1C|8|@]|9|@]|A|$]]|$1|O|3|P|5|L|7|1D|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1E|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1F|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1G|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

I remember asking this question about seven years ago when I was rather new to programming.

I was very careful when I asked and surprisingly I didn't get as much criticism as you are getting here. They did however point me in the direction of the "<a href="http://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools" rel="nofollow noreferrer">Dragon Book</a>" which is in my opinion, a really great book that explains everything you need to know to write a compiler (you will of course have to master a language or two. The more languages you know, the merrier.).

And yes, many people say reading that book is crazy and you won't learn anything from it, but I disagree completely with that.

Many people also say that writing compilers is stupid and pointless. Well, there are a number of reasons why compiler development are useful:

<ul>
<li>Because it's fun.</li>
<li>It's educational, when learning how to write compilers you will learn a lot about computer science and other techniques that are useful when writing other applications.</li>
<li>If nobody wrote compilers the existing languages wouldn't get any better.</li>
</ul>

I didn't write my own compiler right away, but after asking I knew where to start. And now, after learning many different languages and reading the Dragon Book, writing isn't that much of a problem. (I'm also studying computer engineering atm, but most of what I know about programming is self taught.)

In conclusion, The Dragon Book is a great "tutorial". But spend some time mastering a language or two before attempting to write a compiler. Don't expect to be a compiler guru within the next decade or so though.

The book is also good if you want to learn how to write parsers/interpreters.

blocks|key|816880|text|看看下面的书。作者是反的创建者。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|816881|语言实现模式:创建您自己的特定于域的通用编程语言。|816882|​|816883|📷|atomic|816884|816885|entityMap|0|LINK|mutability|MUTABLE|url|http://www.antlr.org/|1|http://pragprog.com/titles/tpdsl/language-implementation-patterns|2|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/1c139bc20aecda600c8c410de44f619e.jpg|imageAlt^0|A|1|0|0|0|O|1|0|0|0|1|2|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@$A|16|B|17|1|18]]|C|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|K|3|G|5|6|7|1E|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]|T|$5|O|P|Q|C|$R|U]]|V|$5|W|P|X|C|$Y|Z|10|-4]]]]

Take a look at the book below. The author is the creator of <a href="http://www.antlr.org/" rel="noreferrer">ANTLR</a>.

<a href="http://pragprog.com/titles/tpdsl/language-implementation-patterns" rel="noreferrer">Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages</a>.

<img src="https://i.stack.imgur.com/ukOkz.jpg" alt="alt text">

blocks|key|99693|text|来自comp.compilers常见问题|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|99694|“个人电脑编程”，1982年版，ISBN+0-13-730283-5|99695|这本题为“不幸的书”的书解释了使用一种叫做爱迪生的类似帕斯卡的语言为微系统设计和创建单用户编程环境的过程。作者给出了爱迪生编译器和简单支持操作系统的逐步实现的所有源代码和解释，所有这些都是用爱迪生自己编写的(除了在PDP+11/23的符号汇编程序中编写的小型支持内核；完整的源代码也可以为IBM+PC订购)。|99696|这本书最有趣的地方是:+1)它能够演示如何创建一个完整的、独立的、自我维护的、有用的编译器和操作系统；2)对语言设计和规范问题的有趣讨论以及第2章中的权衡。|99697|Pascal编译器上的"Brinch+Hansen+on+Pascal编译器“，由Per+Brinch+Hansen+Pr共-Hall+1985+ISBN+0-13-083098-4|99698|另一本理论上很重的语用学--这是一本如何编码的书。作者给出了编译器和Pascal+(Pascal“减号”)的p代码解释器的设计、实现和完整源代码，这是一个带有布尔型和整数类型(但没有字符、reals、子范围或枚举类型)、常量和变量定义以及数组和记录类型(但没有打包、变体、集、指针、无名、重命名或文件类型)、表达式、赋值语句、带值和变量参数的嵌套过程定义的Pascal子集，if语句和case+end块(但没有函数定义、过程参数、goto语句和标签、case语句、重复语句，用于语句，(并附有陈述)。|99699|编译器和解释器是用Pascal*+(Pascal+"star")编写的，这是一个Pascal子集，带有一些爱迪生风格的特性，用于创建软件开发系统。作者出售了一个用于IBM的Pascal*编译器，但是将该书的Pascal编译器移植到任何方便的Pascal平台是很容易的。|99700|这本书使编译器的设计和实现看起来很容易。我特别喜欢作者关注质量、可靠性和测试的方式。编译器和解释器可以很容易地用作更复杂的语言或编译器项目的基础，特别是当您迫切需要快速启动和运行的时候。|99701|entityMap|0|LINK|mutability|MUTABLE|url|http://www.faqs.org/faqs/compilers/faq/^0|2|I|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]]]

From the <a href="http://www.faqs.org/faqs/compilers/faq/" rel="noreferrer">comp.compilers FAQ</a>:

"Programming a Personal Computer" by Per Brinch Hansen
Prentice-Hall 1982 ISBN 0-13-730283-5

This unfortunately-titled book
explains the design and creation of a single-user programming environment
for micros, using a Pascal-like language called Edison. The author presents
all source code and explanations for the step-by-step implementation of an
Edison compiler and simple supporting operating system, all written in
Edison itself (except for a small supporting kernel written in a symbolic
assembler for PDP 11/23; the complete source can also be ordered for the IBM
PC).

The most interesting things about this book are: 1) its ability to
demonstrate how to create a complete, self-contained, self-maintaining,
useful compiler and operating system, and 2) the interesting discussion of
language design and specification problems and trade-offs in Chapter 2.

"Brinch Hansen on Pascal Compilers" by Per Brinch Hansen
Prentice-Hall 1985 ISBN 0-13-083098-4

Another light-on-theory
heavy-on-pragmatics here's-how-to-code-it book. The author presents the
design, implementation, and complete source code for a compiler and p-code
interpreter for Pascal- (Pascal "minus"), a Pascal subset with boolean and
integer types (but no characters, reals, subranged or enumerated types),
constant and variable definitions and array and record types (but no packed,
variant, set, pointer, nameless, renamed, or file types), expressions,
assignment statements, nested procedure definitions with value and variable
parameters, if statements, while statements, and begin-end blocks (but no
function definitions, procedural parameters, goto statements and labels,
case statements, repeat statements, for statements, and with statements).

The compiler and interpreter are written in Pascal* (Pascal "star"), a
Pascal subset extended with some Edison-style features for creating
software development systems. A Pascal* compiler for the IBM PC is sold by
the author, but it's easy to port the book's Pascal- compiler to any
convenient Pascal platform.

This book makes the design and implementation of a compiler look easy. I
particularly like the way the author is concerned with quality,
reliability, and testing. The compiler and interpreter can easily be used
as the basis for a more involved language or compiler project, especially
if you're pressed to quickly get something up and running.

blocks|key|1099211|text|从列表中缺失:垃圾收集:自动动态内存管理算法，由Jones和Lins编写。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1099212|(假设您正在编写编译器和运行时系统，并且正在实现垃圾收集语言。|1099213|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Missing from the list: Garbage Collection: Algorithms for Automatic Dynamic Memory Management, by Jones and Lins.

(Assuming you're writing the compiler and runtime system, and that you're implementing a garbage collected language.

blocks|key|816971|text|我发现“龙”这本书太难读了，过于关注语言理论，而实际上并不需要编写编译器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|816972|我会添加奥伯伦书，它包含了一个令人惊讶的快速和简单的Oberon项目编译器的全部源代码。|offset|length|816973|​|816974|📷|atomic|816975|816976|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Oberon_%2528programming_language%2529|1|http://www.amazon.de/Project-Oberon-Design-Operating-Compiler/dp/0201544288/ref=sr_1_3?ie=UTF8&s=books-intl-de&qid=1281378762&sr=8-3|2|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/7b5dffc2c8dd5b34f16e27b011cc939d.jpg|imageAlt^0|0|4|3|0|Q|8|1|0|0|0|1|2|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]|$D|16|E|17|1|18]]|A|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1A|8|@]|9|@$D|1B|E|1C|1|1D]]|A|$]]|$1|K|3|G|5|6|7|1E|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]|V|$5|W|P|X|A|$Y|Z|10|-4]]]]

I found the Dragon book much too hard to read with too much focus on language theory that is not really required to write a compiler in practice. 

I would add the <a href="http://en.wikipedia.org/wiki/Oberon_%28programming_language%29" rel="noreferrer">Oberon</a> book which contains the full source of an amazingly fast and simple Oberon compiler <a href="http://www.amazon.de/Project-Oberon-Design-Operating-Compiler/dp/0201544288/ref=sr_1_3?ie=UTF8&amp;s=books-intl-de&amp;qid=1281378762&amp;sr=8-3" rel="noreferrer">Project Oberon</a>.

<img src="https://i.stack.imgur.com/N3GFA.jpg" alt="Alt text">

blocks|key|99842|text|如果您没有时间，我推荐尼克劳斯威尔斯的“编译结构”(爱迪生-韦斯利。(1996年)，这是一本可以在一天内阅读的小小册子，但它解释了基本知识(包括如何实现词汇器、递归下降解析器和您自己的基于堆栈的虚拟机)。在那之后，如果你想深入潜水，就没有办法像其他评论者建议的那样绕过“龙书”了。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|99843|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf^0|B|U|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]]]]

If you have little time, I recommend <a href="http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf" rel="noreferrer">Niklaus Wirth's "Compiler Construction" (Addison-Wesley. 1996)</a>, a tiny little booklet that you can read in a day, but it explains the basics (including how to implement lexers, recursive descent parsers, and your own stack-based virtual machines). After that, if you want a deep dive, there's no way around the Dragon book as other commenters suggest.

blocks|key|1099469|text|最快的方法是通过两本书：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1099470|JP+1990年版的编译技术简介，使用ANSI、LeX和YaCC的第一门课程+--一个示例代码、解析理论和设计的完美平衡--它包含了一个完整的编译器，用C、lex和yacc编写，用于一个简单的语法。|offset|length|1099471|龙书+(旧版本)--主要是对前一本书中未涉及的特性的详细参考。|1099472|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/007709221X|1|https://rads.stackoverflow.com/amzn/click/com/0201000229^0|0|A|S|0|0|0|2|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

The quickest approach is through two books:

1990 version of <a href="https://rads.stackoverflow.com/amzn/click/com/007709221X" rel="nofollow noreferrer" rel="nofollow noreferrer">An Introduction to Compiling Techniques, a First Course using ANSI C, LeX, and YaCC</a> by JP Bennett - a perfect balance of example code, parsing theory and design- it contains a complete compiler written in C, lex and yacc for a simple grammar

<a href="https://rads.stackoverflow.com/amzn/click/com/0201000229" rel="nofollow noreferrer" rel="nofollow noreferrer">Dragon Book</a> (older version) - mostly a detailed reference for the features not covered in the former book

blocks|key|1099495|text|您可以通过使用BCEL。使用这个工具，您可以生成类似汇编程序的代码，但它是带有BCEL的Java。您可以了解如何生成中间语言代码(在本例中为字节代码)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1099496|简单例子|1099497|使用此函数创建Java类：
公共字符串maxAsString(int+a，int+b)+{+if+(a+>+b)+{返回Integer.valueOf+(a+).toString()；}+if+(a<+b)+{返回Integer.valueOf(b).toString()；}|ordered-list-item|1099498|现在使用这个类运行BCELifier|1099499|BCELifier+bcelifier+=+new+BCELifier("MyClass",+System.out);
bcelifier.start();|code-block|syntax|javascript|1099500|您可以在控制台上看到整个类的结果(如何构建字节代码MyClass.java)。该函数的代码如下：|1099501|private+void+createMethod_1()+{
++InstructionList+il+=+new+InstructionList();
++MethodGen+method+=+new+MethodGen(ACC_PUBLIC,+Type.STRING,+new+Type[]+{+Type.INT,+Type.INT+},+new+String[]+{+"arg0",+"arg1"+},+"maxAsString",+"MyClass",+il,+_cp);

++il.append(InstructionFactory.createLoad(Type.INT,+1));+//+Load+first+parameter+to+address+1
++il.append(InstructionFactory.createLoad(Type.INT,+2));+//+Load+second+parameter+to+adress+2
++++BranchInstruction+if_icmple_2+=+InstructionFactory.createBranchInstruction(Constants.IF_ICMPLE,+null);+//+Do+if+condition+(compare+a+>+b)
++il.append(if_icmple_2);
++il.append(InstructionFactory.createLoad(Type.INT,+1));+//+Load+value+from+address+1+into+the+stack
++il.append(_factory.createInvoke("java.lang.Integer",+"valueOf",+new+ObjectType("java.lang.Integer"),+new+Type[]+{+Type.INT+},+Constants.INVOKESTATIC));
++il.append(_factory.createInvoke("java.lang.Integer",+"toString",+Type.STRING,+Type.NO_ARGS,+Constants.INVOKEVIRTUAL));
++il.append(InstructionFactory.createReturn(Type.OBJECT));
++InstructionHandle+ih_13+=+il.append(InstructionFactory.createLoad(Type.INT,+1));
++il.append(InstructionFactory.createLoad(Type.INT,+2));
++++BranchInstruction+if_icmpge_15+=+InstructionFactory.createBranchInstruction(Constants.IF_ICMPGE,+null);+//+Do+if+condition+(compare+a+<+b)
++il.append(if_icmpge_15);
++il.append(InstructionFactory.createLoad(Type.INT,+2));
++il.append(_factory.createInvoke("java.lang.Integer",+"valueOf",+new+ObjectType("java.lang.Integer"),+new+Type[]+{+Type.INT+},+Constants.INVOKESTATIC));
++il.append(_factory.createInvoke("java.lang.Integer",+"toString",+Type.STRING,+Type.NO_ARGS,+Constants.INVOKEVIRTUAL));
++il.append(InstructionFactory.createReturn(Type.OBJECT));
++InstructionHandle+ih_26+=+il.append(new+PUSH(_cp,+"equals"));+//+Return+"equals"+string
++il.append(InstructionFactory.createReturn(Type.OBJECT));
++if_icmple_2.setTarget(ih_13);
++if_icmpge_15.setTarget(ih_26);
++method.setMaxStack();
++method.setMaxLocals();
++_cg.addMethod(method.getMethod());
++il.dispose();
}|1099502|entityMap|0|LINK|mutability|MUTABLE|url|http://jakarta.apache.org/bcel/^0|7|4|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|16|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|18|8|@]|9|@]|C|$N|O]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|C|$]]|$1|R|3|S|5|M|7|1A|8|@]|9|@]|C|$N|O]]|$1|T|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|U|$V|$5|W|X|Y|C|$Z|10]]]]

You can use <a href="http://jakarta.apache.org/bcel/" rel="noreferrer">BCEL</a> by the Apache Software Foundation. With this tool you can generate assembler-like code, but it's Java with the BCEL API. You can learn how you can generate intermediate language code (in this case byte code).

<h3>Simple example</h3>

<ol>
<li>Create a Java class with this function:

<pre><code>public String maxAsString(int a, int b) {
 if (a &gt; b) {
 return Integer.valueOf(a).toString();
 } else if (a &lt; b) {
 return Integer.valueOf(b).toString();
 } else {
 return "equals";
 }
}
</code></pre></li>
</ol>

Now run BCELifier with this class

<pre><code>BCELifier bcelifier = new BCELifier("MyClass", System.out);
bcelifier.start();
</code></pre>

You can see the result on the console for the whole class (how to build byte code MyClass.java). The code for the function is this:

<pre><code>private void createMethod_1() {
 InstructionList il = new InstructionList();
 MethodGen method = new MethodGen(ACC_PUBLIC, Type.STRING, new Type[] { Type.INT, Type.INT }, new String[] { "arg0", "arg1" }, "maxAsString", "MyClass", il, _cp);

 il.append(InstructionFactory.createLoad(Type.INT, 1)); // Load first parameter to address 1
 il.append(InstructionFactory.createLoad(Type.INT, 2)); // Load second parameter to adress 2
 BranchInstruction if_icmple_2 = InstructionFactory.createBranchInstruction(Constants.IF_ICMPLE, null); // Do if condition (compare a &gt; b)
 il.append(if_icmple_2);
 il.append(InstructionFactory.createLoad(Type.INT, 1)); // Load value from address 1 into the stack
 il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
 il.append(_factory.createInvoke("java.lang.Integer", "toString", Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
 il.append(InstructionFactory.createReturn(Type.OBJECT));
 InstructionHandle ih_13 = il.append(InstructionFactory.createLoad(Type.INT, 1));
 il.append(InstructionFactory.createLoad(Type.INT, 2));
 BranchInstruction if_icmpge_15 = InstructionFactory.createBranchInstruction(Constants.IF_ICMPGE, null); // Do if condition (compare a &lt; b)
 il.append(if_icmpge_15);
 il.append(InstructionFactory.createLoad(Type.INT, 2));
 il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
 il.append(_factory.createInvoke("java.lang.Integer", "toString", Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
 il.append(InstructionFactory.createReturn(Type.OBJECT));
 InstructionHandle ih_26 = il.append(new PUSH(_cp, "equals")); // Return "equals" string
 il.append(InstructionFactory.createReturn(Type.OBJECT));
 if_icmple_2.setTarget(ih_13);
 if_icmpge_15.setTarget(ih_26);
 method.setMaxStack();
 method.setMaxLocals();
 _cg.addMethod(method.getMethod());
 il.dispose();
}
</code></pre>

blocks|key|1099544|text|到目前为止，没有列入清单的是这本书：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1099545|​|1099546|编译设计基础(Torben+Mogensen)+(来自部门)。哥本哈根大学计算机科学专业)|offset|length|1099547|1099548|我也有兴趣学习编译器，并计划在未来几年进入这个行业。据我所见，这本书是开始学习编译器的理想理论书。它可以自由地复制和复制，干净而仔细地写好，并在没有任何代码的情况下以通俗易懂的英语提供给你，但仍然以指令和图表等方式呈现机械原理，值得一看，海事组织。|1099549|entityMap|0|LINK|mutability|MUTABLE|url|http://www.diku.dk/~torbenm/Basics/^0|0|0|0|N|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@$F|V|G|W|1|X]]|A|$]]|$1|H|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Not included in the list so far is this book:

<a href="http://www.diku.dk/~torbenm/Basics/" rel="noreferrer">Basics of Compiler Design (Torben Mogensen)</a>
(from the dept. of Computer Science, University of Copenhagen)

I'm also interested in learning about compilers and plan to enter that industry in the next couple of years. This book is the ideal theory book to begin learning compilers as far as I can see. It's FREE to copy and reproduce, cleanly and carefully written and gives it to you in plain English without any code but still presents the mechanics by way of instructions and diagrams etc. Worth a look imo.

blocks|key|1099584|text|如果您不仅在寻找书籍，而且还对有关于该主题的文章的网站感兴趣，我已经在博客中谈到了创建一种编程语言的各个方面。大部分的帖子都可以在我博客的“语言设计”范畴上找到。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1099585|特别是，我包括手动生成Intel机器代码、自动生成机器或字节码、创建字节码解释器、编写面向对象的运行时、创建简单的加载程序和编写简单的标记/扫描垃圾收集器。所有这些都是以一种非常实用和务实的方式，而不是用大量的理论来无聊你。|1099586|会很感激你对这些信息的反馈。|1099587|entityMap|0|LINK|mutability|MUTABLE|url|http://web.archive.org/web/20161024215644/http://orangejuiceliberationfront.com/category/language-design/^0|1X|8|0|0|0|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|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

If you're not just looking for books, but also interested in web sites that have articles on the topic, I've blogged about various aspects of creating a programming language. Most of the posts can be found in my blog's <a href="http://web.archive.org/web/20161024215644/http://orangejuiceliberationfront.com/category/language-design/" rel="nofollow noreferrer">"Language Design" category</a>.

In particular, I cover generating Intel machine code manually, automatically generating machine- or bytecode, creating a bytecode interpreter, writing an object-oriented runtime, creating a simple loader, and writing a simple mark/sweep garbage collector. All of this in a very practical and pragmatic way instead of boring you with lots of theory.

Would appreciate feedback on these.

Preferred languages: C/C++, Java, and Ruby.

I am looking for some helpful books/tutorials on how to write your own compiler simply for educational purposes. I am most familiar with C/C++, Java, and Ruby, so I prefer resources that involve one of those three, but any good resource is acceptable.

Learning to write a compiler

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

首选语言: C/C++、Java和Ruby。我正在寻找一些有用的书籍/教程，关于如何编写您自己的编译器只是为了教育目的。我最熟悉C/C++、Java和Ruby，所以我更喜欢涉及这三种资源之一的资源，但是任何好的资源都是可以接受的。

问学习编写编译器
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问学习编写编译器EN