language-agnostic - Een compiler leren schrijven

Voorkeurstalen: C/C++, Java en Ruby.

Ik ben op zoek naar wat handige boeken/tutorials over hoe je je eigen compiler kunt schrijven, gewoon voor educatieve doeleinden. Ik ben het meest bekend met C/C++, Java en Ruby, dus ik geef de voorkeur aan bronnen met een van die drie, maar elke goede bron is acceptabel.

Antwoord 1, autoriteit 100%

Grote lijst met bronnen:

Een Nanopass Framework voor Compiler Education¶
Geavanceerd compilerontwerp en implementatie$
Een incrementele benadering van compilerconstructie¶
ANTLR 3.x-videozelfstudie
Basisprincipes van compilerontwerp
Een Parrot-compiler bouwen
Basisbeginselen van compiler
Compilerconstructie$
Compilerontwerp en constructie$
Een compiler maken met C$
Tolken maken
[Compilerontwerp in C] 12¶
Compilers: principes, technieken en hulpmiddelen$ — ook bekend als “The Dragon Book”; algemeen beschouwd als “het boek” voor schrijven door compilers.
Een compiler ontwikkelen$
Essentiële programmeertalen
Flipcode-artikelarchief(zoek naar “Implementing A Scripting Engine by Jan Niestadt”)
Game Scripting Mastery$
Hoe bouw je een virtuele machine helemaal opnieuw in C#¶
Functionele talen implementeren
Programmeertalen implementeren (met BNFC)
Programmeertalen implementeren met C# 4.0
Interpreterpatroon(beschreven in Ontwerppatronen$) specificeert een manier om zinnen in een taal te evalueren
Taalimplementatiepatronen: maak uw eigen domeinspecifieke en algemene programmeertalen$
Laten we een compiler bouwendoor Jack Crenshaw — De PDF¶ versie (voorbeelden staan in Pascal, maar de informatie is algemeen toepasbaar)
Linkers en Loaders$ (Google Books)
Lisp in kleine stukjes (LiSP)$
LLVM-zelfstudie
Moderne compilerimplementatie in ML$ — Er is een Java$ en C$ versie ook – algemeen beschouwd als een zeer goed boek
Objectgeoriënteerde compilerconstructie$
Ontledingstechnieken – een praktische gids
Project Oberon¶ – Kijk naar hoofdstuk 13
Een pc programmeren$
Programmeertalen: toepassing en interpretatie
Konijn: een compiler voor schema¶
Reflecties over Trusting Trust— Een korte handleiding
Roll Your Own Compiler voor het .NET-framework— Een korte handleiding van MSDN
Structuur en interpretatie van computerprogramma’s
Typen en programmeertalen
Wil je een compiler schrijven?– een korte handleiding
schrijven van een compiler in robijn Bottom-up
Compileer een lisp – Compileer rechtstreeks naar x86-64

Legenda:

¶ Link naar een PDF-bestand
$ Link naar een gedrukt boek

Antwoord 2, Autoriteit 6%

Dit is een vrij vage vraag, denk ik; alleen vanwege de diepte van het betrokken onderwerp. Een compiler kan echter in twee afzonderlijke delen worden ontleed; een vulling en een onderkant-een. De bovenste helft neemt in het algemeen de brontaal en converteert het in een tussenpresentatie en de onderste helft zorgt voor de platform specifieke code generatie.

Niettemin, een idee voor een gemakkelijke manier om dit onderwerp te benaderen (degene die we in mijn compilers-klasse hebben gebruikt, is tenminste) om de compiler in de twee hierboven beschreven stukken te bouwen. Specifiek krijgt u een goed idee van het hele proces door alleen de bovenste helft te bouwen.

Gewoon de bovenste helft doen, laat je de ervaring van het schrijven van de lexicalanalysator en de parser en gaan naar het genereren van een “code” (die gemiddelde vertegenwoordiging die ik noemde). Dus het zal je bronprogramma nemen en converteren naar een andere representatie en doe wat optimalisatie (als je wilt), wat het hart van een compiler is. De onderste helft neemt dan die tussenpersoon en genereert de bytes die nodig is om het programma op een specifieke architectuur uit te voeren. De onderste helft neemt bijvoorbeeld uw tussenprothese in en genereert een PE-uitvoerbaar bestand.

Enkele boeken over dit onderwerp die ik bijzonder nuttig vond, waren Beginselen en technieken van compilers(of het Drakenboek, vanwege de schattige draak op de omslag). Het heeft een geweldige theorie en behandelt absoluut contextvrije grammatica’s op een echt toegankelijke manier. Voor het bouwen van de lexicale analysator en parser zult u waarschijnlijk de *nix-tools lex en yacc gebruiken. En oninteressant genoeg ging het boek met de naam “lex en yacc” verder waar de Draak Boek gebleven voor dit deel.

Antwoord 3, autoriteit 5%

Ik denk dat Moderne compilerimplementatie in MLis de beste inleidende compiler voor het schrijven van tekst. Er is een Java-versieen een C-versie, die beide mogelijk toegankelijker zijn gezien uw talenachtergrond. Het boek bevat veel nuttig basismateriaal (scannen en parseren, semantische analyse, activeringsrecords, instructieselectie, RISC en x86 native codegeneratie) en verschillende “geavanceerde” onderwerpen (compileren van OO en functionele talen, polymorfisme, garbage collection, optimalisatie en enkele statische opdrachtformulier) in relatief weinig ruimte (~500 pagina’s).

Ik geef de voorkeur aan Modern Compiler-implementatie boven het Dragon-boek, omdat de implementatie van Modern Compiler minder van het veld bestrijkt – in plaats daarvan heeft het echt een solide dekking van alle onderwerpen die je nodig hebt om een serieuze, fatsoenlijke compiler te schrijven. Nadat je dit boek hebt doorgenomen, ben je klaar om onderzoekspapers direct aan te pakken voor meer diepgang als je dat nodig hebt.

Ik moet bekennen dat ik een serieuze zwak heb voor Niklaus Wirth’s Compilerconstructie.Het is beschikbaar onlineals pdf. Ik vind de programmeer-esthetiek van Wirth gewoonweg mooi, maar sommige mensen vinden zijn stijl te minimaal (Wirth geeft bijvoorbeeld de voorkeur aan recursieve descent-parsers, maar de meeste CS-cursussen richten zich op parsergeneratortools; Wirths taalontwerpen zijn vrij conservatief.) Compilerconstructie is een zeer beknopte distillatie van Wir’s basisideeën, dus of je nu van zijn stijl houdt of niet, ik raad je ten zeerste aan dit boek te lezen.

Antwoord 4, autoriteit 4%

Ik ben het eens met de verwijzing naar het Dragon Book; IMO, het is de definitieve gids voor compilerconstructie. Maak je echter klaar voor wat hardcore theorie.

Als je een boek wilt dat lichter is op theorie, Game Scripting Masterymisschien een beter boek voor jou. Als je een totale newbie bent op het gebied van compilertheorie, biedt het een zachtere introductie. Het behandelt niet meer praktische ontledingsmethoden (kiezen voor niet-voorspellende recursieve afdaling zonder LL- of LR-parsing te bespreken), en zoals ik me herinner, bespreekt het zelfs geen enkele vorm van optimalisatietheorie. Plus, in plaats van te compileren naar machinecode, compileert het naar een bytecode die verondersteld wordt te draaien op een VM die jij ook schrijft.

Het is nog steeds een goede lectuur, vooral als je het goedkoop op Amazon kunt kopen. Als je alleen een gemakkelijke introductie in compilers wilt, is Game Scripting Mastery geen slechte manier om te gaan. Als je van tevoren hardcore wilt gaan, moet je genoegen nemen met niets minder dan het Dragon Book.

Antwoord 5, autoriteit 3%

“Let’s Build a Compiler”is geweldig, maar het is een beetje achterhaald. (Ik zeg niet dat het het zelfs maar een beetje minder valide maakt.)

Of bekijk SLANG. Dit is vergelijkbaar met “Let’s Build a Compiler”, maar is een veel betere bron, vooral voor beginners. Dit wordt geleverd met een pdf-zelfstudie die een 7-stappenbenadering volgt om u een compiler te leren. De quora-link toevoegen omdat deze de links heeft naar alle verschillende poorten van SLANG, in C++, Java en JS, ook tolken in python en java, oorspronkelijk geschreven met C# en het .NET-platform.

Antwoord 6, autoriteit 2%

Als je krachtige tools van een hoger niveau wilt gebruiken in plaats van alleszelf te bouwen, ga dan door de projecten en lezingen voor deze cursusis een redelijk goede optie. Het is een taalcursus van de auteur van de Java-parserengine ANTLR. U kunt het boek voor de cursus als pdf verkrijgen bij de Pragmatic Programmers.

De cursus gaat over de standaard compiler-compiler-dingen die je elders zou zien: ontleden, typen en typecontrole, polymorfisme, symbooltabellen en het genereren van code. Vrijwel het enige dat niet wordt behandeld, zijn optimalisaties. Het uiteindelijke project is een programma dat een subset van C compileert. Omdat je tools zoals ANTLR en LLVM gebruikt, is het haalbaar om de hele compiler in één dag te schrijven (ik heb hier een bestaansbewijs van, hoewel ik bedoel ~24 uur). Het is zwaar op praktische engineering met behulp van moderne hulpmiddelen, een beetje lichter op theorie.

LLVM is trouwens gewoon fantastisch. In veel situaties waarin u normaal gesproken zou compileren tot montage, kunt u beter compileren naar LLVM’s Intermediate Representationin plaats daarvan. Het is een hoger niveau, platformoverschrijdend en LLVM is redelijk goed in het genereren van geoptimaliseerde assemblage ervan.

Antwoord 7, autoriteit 2%

Als je weinig tijd hebt, raad ik Niklaus Wirth’s “Compiler Construction” (Addison-Wesley . 1996), een klein boekje dat je in een dag kunt uitlezen, maar het legt de basis uit (inclusief hoe je lexers, recursive descent parsers en je eigen stack-gebaseerde virtuele machines implementeert). Als je daarna een diepe duik wilt, kun je niet om het Dragon-boek heen, zoals andere commentatoren suggereren.

Antwoord 8

Misschien wil je eens kijken naar Lex/Yacc (of Flex/Bison, hoe je ze ook wilt noemen). Flex is een lexicale analysator, die de semantische componenten (“tokens”) van uw taal zal ontleden en identificeren, en Bison zal worden gebruikt om te bepalen wat er gebeurt wanneer elk token wordt geparseerd. Dit kan zijn, maar is zeker niet beperkt tot, het afdrukken van C-code, voor een compiler die zou compileren naar C, of het dynamisch uitvoeren van de instructies.

Deze FAQzou je moeten helpen, en deze tutorialziet er best nuttig uit.

Antwoord 9

Over het algemeen is er geen tutorial van vijf minuten voor compilers, omdat het een ingewikkeld onderwerp is en het schrijven van een compiler maanden kan duren. U zult zelf moeten zoeken.

Python en Ruby worden meestal geïnterpreteerd. Misschien wilt u ook beginnen met een tolk. Het is over het algemeen makkelijker.

De eerste stap is om een formele taalbeschrijving te schrijven, de grammatica van uw programmeertaal. Vervolgens moet u de broncode transformeren die u wilt compileren of interpreteren volgens de grammatica in een abstracte syntaxstboom, een interne vorm van de broncode die de computer begrijpt en kan werken. Deze stap wordt meestal parsering genoemd en de software die de broncode parseert, wordt een parser genoemd. Vaak wordt de parser gegenereerd door een parser-generator die een formele grammatica transformeert in de machinecode van de bron Oder. Voor een goede, niet-wiskundige verklaring van parseren raad ik aan parserentechnieken – een praktische gids. Wikipedia heeft een vergelijking van parser-generatoren waaruit u die kunt kiezen die geschikt voor u is. Afhankelijk van de parser-generator die u koos, vindt u tutorials op internet en voor echt populaire parser-generatoren (zoals GNU Bison) zijn er ook boeken.

het schrijven van een parser voor uw taal kan heel hard zijn, maar dit is afhankelijk van uw grammatica. Dus ik stel voor om je grammatica eenvoudig (in tegenstelling tot C++) te houden; Een goed voorbeeld hiervoor is LISP.

In de tweede stap wordt de abstracte syntaxstructuur getransformeerd van een boomstructuur in een lineaire tussenpresentatie. Als een goed voorbeeld voor deze Bytecode van Lua wordt vaak geciteerd. Maar de tussenafweergave hangt echt af van uw taal.

Als u een tolk bouwt, moet u eenvoudig de tussenprogramma interpreteren. Je zou het ook gewoon in de tijd kunnen compileren. Ik beveel LLVM en Libjit aan voor just-in-time-compilatie. Om de taal bruikbaar te maken, moet u ook enkele invoer- en uitvoerfuncties opnemen en misschien een kleine standaardbibliotheek.

Als je de taal gaat compileren, wordt het ingewikkelder. Je zult backends moeten schrijven voor verschillende computerarchitecturen en machinecode moeten genereren uit de tussenliggende representatie in die backends. Ik raad LLVM aan voor deze taak.

Er zijn een paar boeken over dit onderwerp, maar ik kan ze geen van alle aanbevelen voor algemeen gebruik. De meeste zijn te academisch of te praktisch. Er is geen “leer jezelf compiler schrijven in 21 dagen” en dus zul je verschillende boeken moeten kopen om dit hele onderwerp goed te begrijpen. Als je op internet zoekt, kom je een aantal online boeken en college-aantekeningen tegen. Misschien is er een universiteitsbibliotheek bij jou in de buurt waar je boeken over compilers kunt lenen.

Ik raad ook een goede achtergrondkennis in theoretische informatica en grafentheorie aan, als je je project serieus wilt maken. Een graad in computerwetenschappen zal ook nuttig zijn.

Antwoord 10

Bekijk het onderstaande boek. De auteur is de maker van ANTLR.

Taalimplementatiepatronen: maak uw eigen domeinspecifieke en algemene programmeertalen.

Antwoord 11

Eén boek dat nog niet is voorgesteld, maar erg belangrijk is, is “Linkers and Loaders”door John Levine. Als je geen externe assembler gebruikt, heb je een manier nodig om een objectbestand uit te voeren dat aan je uiteindelijke programma kan worden gekoppeld. Zelfs als je een externe assembler gebruikt, moet je waarschijnlijk de verplaatsingen begrijpen en begrijpen hoe het hele laadproces van het programma werkt om een werkend hulpmiddel te maken. Dit boek verzamelt veel willekeurige kennis over dit proces voor verschillende systemen, waaronder Win32 en Linux.

Antwoord 12

Als je LLVM wilt gebruiken, kijk dan eens op: http://llvm.org/docs/ zelfstudie/. Het leert je hoe je vanaf het begin een compiler kunt schrijven met behulp van het framework van LLVM, en veronderstelt niet dat je enige kennis over het onderwerp hebt.

De tutorial stelt voor dat je je eigen parser en lexer enz. schrijft, maar ik raad je aan om naar bison en flex te kijken zodra je het idee hebt. Ze maken het leven zoveel gemakkelijker.

Antwoord 13

Ik vond het Dragon-boek veel te moeilijk om te lezen met te veel nadruk op taaltheorie die in de praktijk niet echt nodig is om een compiler te schrijven.

Ik zou het boek Oberonwillen toevoegen, dat de volledige bron van een verbazingwekkend snelle en eenvoudige Oberon-compiler Project Oberon.

Antwoord 14

Ik herinner me dat ik deze vraag ongeveer zeven jaar geleden heb gevraagd toen ik nogal nieuw was om te programmeren.

Ik was heel voorzichtig toen ik vroeg en verrassend genoeg kreeg ik niet zoveel kritiek als je hier komt. Ze trokken me echter in de richting van de “Dragon Book ” Wat naar mijn mening is, een echt geweldig boek dat alles uitlegt wat je moet weten om een compiler te schrijven (je zult natuurlijk een taal of twee moeten beheersen. Hoe meer talen die je kent, de Merrier.).

en ja, veel mensen zeggen dat het lezen dat boek gek is en je zult er niets van leren, maar ik ben het daar niet mee mee.

Veel mensen zeggen ook dat het schrijven van compilers dom en zinloos zijn. Nou, er zijn een aantal redenen waarom compiler-ontwikkeling nuttig is:

omdat het leuk is.
Het is educatief, bij het leren van het schrijven van compilers U zult veel leren over computerwetenschappen en andere technieken die handig zijn bij het schrijven van andere toepassingen.
Als niemand compilers schreef, zouden de bestaande talen niet beter worden.

Ik heb niet meteen mijn eigen compiler geschreven, maar na het vragen wist ik waar te beginnen. En nu, na het leren van veel verschillende talen en het lezen van het Dragon Book, is het schrijven niet zo veel van een probleem. (Ik studeer ook een computer engineering ATM, maar de meeste van wat ik weet over het programmeren is zelf onderwezen.)

Tot slot is het Dragon Book een geweldige “tutorial”. Maar breng wat tijd door met het beheersen van een taal of twee voordat u probeert een compiler te schrijven. Verwacht niet in het volgende decennium een compiler-goeroe te zijn of zo.

Het boek is ook goed als je wilt leren hoe je parsers / tolken kunt schrijven.

Antwoord 15

De LCC-compiler (wikipedia) (projecthomepage) (github.com/drh/lcc) van Fraser en Hanson wordt beschreven in hun boek “A Retargetable C Compiler: Design and Implementation”. Het is goed leesbaar en legt de hele compiler uit, tot aan het genereren van code.

Antwoord 16

The Dragon Bookis zeker het “building compilers”-boek, maar als uw taal niet zo ingewikkeld is als de huidige generatie talen, kunt u kijken naar het Interpreter-patroon van Ontwerppatronen.

Het voorbeeld in het boek ontwerpt een reguliere expressie-achtige taal en is goed doordacht, maar zoals ze in het boek zeggen, is het goed om het proces door te denken, maar het is eigenlijk alleen effectief in kleine talen. Het is echter veel sneller om een tolk te schrijven voor een kleine taal met dit patroon dan dat je moet leren over alle verschillende soorten parsers, yacc en lex, enzovoort…

Antwoord 17

Ik ben op zoek naar hetzelfde concept en vond dit veelbelovende artikel van Joel Pobar,

Maak een taalcompiler voor het .NET Framework – weet niet waar dit is weg

Maak een taalcompiler voor het .NET Framework – pdf-kopie van het origineel document

hij bespreekt een concept van een compiler op hoog niveau en gaat verder met het uitvinden van zijn eigen taal voor het .Net-framework. Hoewel het gericht is op het .Net Framework, zouden veel van de concepten gereproduceerd moeten kunnen worden. Het artikel behandelt:

Taaldefinitie
Scanner
Parser (het bit waarin ik vooral geïnteresseerd ben)
Het .Net-framework targeten De
Codegenerator

er zijn andere onderwerpen, maar u krijgt de juiste.

Het is bedoeld voor beginnende mensen, geschreven in C# (niet helemaal Java)

HTH

botten

Antwoord 18

“… Laten we een compiler bouwen …”

Ik zou http://compilers.iecc.com/crenshaw/door @sasb. Vergeet voorlopig geen boeken meer te kopen.

Waarom? Gereedschap & taal.

De vereiste taal is Pascal en als ik het me goed herinner, is het gebaseerd op Turbo-Pascal. Het gebeurt gewoon als je naar http://www.freepascal.org/gaat en de Pascal-compiler downloadt alle voorbeelden werken rechtstreeks van de pagina ~ http://www.freepascal.org/download.varHet mooie van Free Pascal is dat je het bijna elke processor of besturingssysteem kunt gebruiken.

Als je de lessen onder de knie hebt, probeer dan het meer geavanceerde “Dragon Book“~ http://en.wikipedia.org/wiki/Dragon_book

Antwoord 19

Een eenvoudige manier om een compiler te maken, is om bizon en flex (of vergelijkbaar) te gebruiken, een boom (AST) te bouwen en code in C. te genereren met het genereren van C-code is de belangrijkste stap. Door C-code te genereren, werkt uw taal automatisch op alle platforms met een C-compiler.

Het genereren van C-code is net zo eenvoudig als het genereren van HTML (gewoon afdrukken of equivalent gebruiken), die op zijn beurt veel gemakkelijker is dan het schrijven van een C PARDER of HTML-parser.

Antwoord 20

Vanaf de CompcomPilers FAQ :

“Een personal computer programmeren” door Per Brinch Hansen
Prentice-hal 1982 ISBN 0-13-730283-5

dit helaas-getiteld boek
Verklaart het ontwerp en de oprichting van een programmeeromgeving van één gebruiker
Voor Micres, met behulp van een Pascal-achtige taal genaamd Edison. De auteur presenteert
Alle broncode en uitleg voor de stapsgewijze implementatie van een
Edison Compiler en eenvoudig ondersteunend besturingssysteem, allemaal geschreven
Edison zelf (behalve een kleine ondersteunende kernel geschreven in een symbolisch
Assembler voor PDP 11/23; De volledige bron kan ook worden besteld voor de IBM
Pc).

De meest interessante dingen over dit boek zijn: 1) het vermogen ervan
Demonstreer hoe u een compleet, op zichzelf staand, zelfbewaarzaam kunt maken,
Nuttige compiler en besturingssysteem, en 2) de interessante discussie over
Taalontwerp en specificatieproblemen en wisselwerking in hoofdstuk 2.

“Brinch Hansen op Pascal Compilers” door Per Brinch Hansen
Prentice-hal 1985 ISBN 0-13-083098-4

Nog een licht-on-theorie
Heavy-on-Pragmatics hier-HOW-to-Code-IT-boek. De auteur presenteert de
Ontwerp, implementatie en voltooi broncode voor een compiler en p-code
Interpreter voor Pascal- (Pascal “minus”), een Pascal-subset met Boolean en
Integer-typen (maar geen tekens, reals, subranged of opgesomde typen),
constante en variabele definities en array- en recordtypen (maar geen verpakte,
variant, set, pointer, naamloos, hernoemd of bestandstype), uitdrukkingen,
toewijzingsinstructies, geneste proceduredefinities met waarde en variabele
parameters, if-statements, while-statements en begin-eindblokken (maar nee
functiedefinities, procedureparameters, goto-instructies en labels,
case-statements, herhaal-statements, for-statements en met statements).

De compiler en interpreter zijn geschreven in Pascal* (Pascal “star”), a
Pascal-subset uitgebreid met enkele functies in Edison-stijl voor het maken
software ontwikkelingssystemen. Een Pascal* compiler voor de IBM PC wordt verkocht door:
de auteur, maar het is gemakkelijk om de Pascal-compiler van het boek over te zetten naar een willekeurige
handig Pascal-platform.

Dit boek laat het ontwerp en de implementatie van een compiler er eenvoudig uitzien. l
vooral zoals de manier waarop de auteur omgaat met kwaliteit,
betrouwbaarheid en testen. De compiler en interpreter kunnen eenvoudig worden gebruikt
als basis voor een meer betrokken taal- of compilerproject, vooral
als je onder druk staat om snel iets op gang te krijgen.

Antwoord 21

Je moet Darius Bacon’s “ichbinseens bekijken “, een compiler voor een klein Lisp-dialect, gericht op C, in iets meer dan 6 pagina’s code. Het voordeel ten opzichte van de meeste speelgoedcompilers is dat de taal zo compleet is dat de compiler erin wordt geschreven. (De tarball bevat ook een interpreter om het ding op te starten.)

Er zijn meer dingen over wat ik nuttig vond bij het leren schrijven van een compiler op mijn Ur-Schemewebpagina.

Antwoord 22

Dit is een uitgebreid onderwerp. Onderschat dit punt niet. En onderschat mijn punt niet om het niet te onderschatten.
Ik hoor dat het Dragon Bookeen (de?) plaats om te beginnen, samen met zoeken. 🙂 Word beter in zoeken, uiteindelijk zal het jouw leven zijn.
Het bouwen van je eigen programmeertaal is absoluut een goede oefening! Maar weet dat het uiteindelijk nooit voor enig praktisch doel zal worden gebruikt. Uitzonderingen hierop zijn weinig en zeerver tussen.

Antwoord 23

Python wordt geleverd met een Python-compiler die is geschreven in Python. U kunt de broncode zien en deze bevat alle fasen, van parseren, abstracte syntaxisstructuur, code uitzenden, enz.
Hack het.

Antwoord 24

Sorry, het is in het Spaans, maar dit is de bibliografie van een cursus genaamd “Compiladores e Intérpretes” (Compilers en Tolken) in Argentinië.

De cursus ging van formele taaltheorie tot compilerconstructie, en dit zijn de onderwerpen die je nodig hebt om op zijn minst een eenvoudige compiler te bouwen:

Ontwerp van compilers in C.
Allen I. Holub

Prentice-Hall. 1990.

Compiladores. Teoría y Construcción.
Sanchís
Llorca, FJ, Galán Pascual, C. Redactioneel Paraninfo. 1988.

Compilerconstructie.
Niklaus Wirth

Addison-Wesley. 1996.

Lenguajes, Gramáticas en Automaten. Un enfoque práctico.
Pedro
Isasi Viñuela, Paloma Martínez
Fernandez, Daniel Borrajo Millán. Addison-Wesley Iberoamericana
(Spanje). 1997.

De kunst van compilerontwerp. Theorie en praktijk.
Thomas
Pittman, James Peters.

Prentice-Hall. 1992.

Objectgeoriënteerde compilerconstructie.
Jim Holmes.

Prentice Hall, Englewood
Cliffs, NJ 1995

Compiladores. Conceptos Fundamentals.
B. Teufel, S.
Schmidt, T. Teufel.

Addison-Wesley Iberoamericana. 1995.

Inleiding tot de theorie, talen en berekeningen van automaten.

John E. Hopcroft. Jeffref D.Ullman.

Addison-Wesley. 1979.

Inleiding tot formele talen.
György E. Révész.

McGraw Hill. 1983.

Ontledingstechnieken. Een praktische gids.
Dick Grune, Ceriel
Jacobs.
Impreso por los
autor. 1995
http://www.cs.vu.nl/~dick/PTAPG.html

Yacc: nog een compiler-compiler.
Stephen
C. Johnson
Informatica
Technisch rapport nr. 32, 1975. Bell
Laboratoria. Murray Hill, Nieuw
Jersey.

Lex: Een Lexical Analyzer Generator.
M.E. Lesk, E. Schmidt. Technische informatica
Rapport nr. 39, 1975. Bell Laboratories.
Murray Hill, New Jersey.

lex & ja.
John R. Levine, Tony Mason, Doug Brown.
O’Reilly & medewerkers. 1995.

Elementen van de rekentheorie.
Harry R. Lewis,
Christos H. Papadimitriou.
Segunda Edición. Prentenzaal. 1998.

Een Algoritmo Efficiënte 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.

Antwoord 25

Geen boek, maar een technische paper en een enorm leuke leerervaring als je meer wilt weten over compilers (en metacompilers)… Deze website begeleidt je bij het bouwen van een volledig op zichzelf staand compilersysteem dat zichzelf kan compileren en andere talen:

Zelfstudie: Metacompilers deel 1

Dit is allemaal gebaseerd op een verbazingwekkende kleine technische paper van 10 pagina’s:

Val SchorreMETA II: een syntaxisgerichte compiler-schrijftaal

van eerlijk-naar-god 1964. Ik heb hier in 1970 geleerd hoe ik compilers moet bouwen. Er is een verbluffend moment waarop je eindelijk begrijpt hoe de compiler zichzelf kan regenereren….

Ik ken de auteur van de website uit mijn studententijd, maar ik heb niets met de website te maken.

Antwoord 26

Er zijn hier veel goede antwoorden, dus ik dacht ik voeg er nog een toe aan de lijst:

Ik heb meer dan tien jaar geleden een boek gekregen met de naam Project Oberon, met zeer goed geschreven tekst op de compiler. Het boek springt er echt uit in die zin dat de bron en uitleg heel praktisch en leesbaar zijn. De volledige tekst (editie 2005) is in pdf beschikbaar gesteld, zodat u deze nu kunt downloaden. De compiler wordt besproken in hoofdstuk 12:

http://www.ethoberon.ethz.ch/WirthPubl/ProjectOberon.pdf

Niklaus Wirth, Jürg Gutknecht

(De behandeling is niet zo uitgebreid als zijn boek over compilers)

Ik heb verschillende boeken over compilers gelezen, en ik kan het drakenboek eens zijn, de tijd die aan dit boek wordt besteed, is zeer de moeite waard.

Antwoord 27

Ik vond de CRENSHAW-tutorial ook, omdat het absoluut duidelijk is dat een compiler gewoon is Een ander programma dat enige invoer leest en schrijft wat eruit gezet.

Lees het.

Werk het als je wilt, maar kijk dan naar een andere referentie over hoe groter en complete compilers echt zijn geschreven.

en lees over vertrouwing vertrouwen , om een aanwijzing te krijgen de onopvallende dingen die in dit domein kunnen worden gedaan.

Antwoord 28

Als u geïnteresseerd bent in het schrijven van een compiler voor een functionele taal (in plaats van een procedurele) Simon Peyton-Jones en David Lester’s “Implementatie van functionele talen: een tutorial ” is een uitstekende gids.

De conceptuele basisprincipes van hoe functionele evaluatiewerken worden geleid door voorbeelden in een eenvoudige maar krachtige functionele taal genaamd “Core”. Bovendien wordt elk deel van de Corecal Compiler uitgelegd met codevoorbeelden in Miranda (een pure functionele taal die erg op Haskell lijkt).

Verschillende soorten compilers worden beschreven, maar zelfs als u alleen de zogenaamde sjablooncompiler voor de kern volgt, heeft u een uitstekend begrip van wat functioneel programmeervink maakt.

Antwoord 29

U kunt bcel door de Apache Software Foundation gebruiken. Met deze tool kun je assembler-achtige code genereren, maar het is Java met de Bcel API. U kunt leren hoe u intermediaire taalcode kunt genereren (in dit geval BYTE-code).

Eenvoudig voorbeeld

Maak een Java-klasse met deze functie:

public String maxAsString(int a, int b) {
    if (a > b) {
        return Integer.valueOf(a).toString();
    } else if (a < b) {
        return Integer.valueOf(b).toString();
    } else {
        return "equals";
    }
}

Voer nu BCELifier uit met deze klasse

BCELifier bcelifier = new BCELifier("MyClass", System.out);
bcelifier.start();

Je kunt het resultaat op de console voor de hele klas zien (hoe je de bytecode MyClass.java bouwt). De code voor de functie is deze:

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();
}

Antwoord 30

Tot nu toe niet in de lijst opgenomen is dit boek:

Basisprincipes van compilerontwerp (Torben Mogensen)
(van de afdeling Computerwetenschappen, Universiteit van Kopenhagen)

Ik ben ook geïnteresseerd in het leren over compilers en ben van plan om in de komende jaren in die branche te stappen. Dit boek is het ideale theorieboek om te beginnen met het leren van compilers voor zover ik kan zien. Het is GRATIS te kopiëren en te reproduceren, netjes en zorgvuldig geschreven en geeft het je in gewoon Engels zonder enige code, maar geeft nog steeds de mechanica weer door middel van instructies en diagrammen enz. Het bekijken waard imo.

Een compiler leren schrijven