Imparare a scrivere un compilatore [chiuso]

Lingue preferite : C / C ++, Java e Ruby.

Sto cercando alcuni libri / tutorial utili su come scrivere il proprio compilatore semplicemente per scopi didattici. Conosco molto bene C / C ++, Java e Ruby, quindi preferisco risorse che coinvolgono una di quelle tre, ma ogni buona risorsa è accettabile.

Grande lista di risorse:

• Un framework nanopass per l'educazione dei compilatori ¶
• Progettazione e implementazione avanzate del compilatore $
• Un approccio incrementale alla costruzione del compilatore ¶
• Tutorial video ANTLR 3.x.
• Nozioni di base sulla progettazione di compilatori
• Costruire un compilatore Parrot
• Nozioni di base del compilatore
• Costruzione del compilatore $
• Progettazione e costruzione del compilatore $
• Creazione di un compilatore con C $
• Interpreti artigiani
• Progettazione del compilatore in C ¶
• Compilatori: principi, tecniche e strumenti $ - alias "The Dragon Book" ; ampiamente considerato "il libro" per la scrittura di compilatori.
• Ingegnerizzazione di un compilatore $
• Elementi essenziali dei linguaggi di programmazione
• Flipcode Article Archive (cerca "Implementing A Scripting Engine by Jan Niestadt")
• Padronanza degli script di gioco $
• Come costruire una macchina virtuale da zero in C # ¶
• Implementazione di linguaggi funzionali
• Implementazione di linguaggi di programmazione (con BNFC)
• Implementazione di linguaggi di programmazione mediante C # 4.0
• Il modello dell'interprete (descritto in Modelli di disegno $) specifica un modo per valutare le frasi in una lingua
• Schemi di implementazione della lingua: Crea il tuo linguaggio di programmazione specifico e di dominio specifico $
• Costruiamo un compilatore di Jack Crenshaw - La versione PDF ((gli esempi sono in Pascal, ma le informazioni sono generalmente applicabili)
• Linker e caricatori $ (Google Libri)
• Lisp in piccoli pezzi (LiSP) $
• Tutorial LLVM
• Implementazione moderna del compilatore in ML $ - Esiste anche una versione Java $ e C $ - ampiamente considerata un ottimo libro
• Costruzione di compilatori orientati agli oggetti $
• Tecniche di analisi - Una guida pratica
• Progetto Oberon ¶ - Guarda il capitolo 13
• Programmazione di un personal computer $
• Linguaggi di programmazione: applicazione e interpretazione
• Rabbit: un compilatore per lo schema ¶
• Riflessioni su Trusting Trust - Una guida rapida
• Crea il tuo compilatore per il framework .NET - Un breve tutorial da MSDN
• Struttura e interpretazione dei programmi per computer
• Tipi e linguaggi di programmazione
• Vuoi scrivere un compilatore? - una guida rapida
• Scrivere un compilatore in Ruby Bottom Up

Leggenda:

• ¶ Collegamento a un file PDF
• $ Collegamento a un libro stampato

Questa è una domanda piuttosto vaga, credo; proprio per la profondità dell'argomento in questione. Tuttavia, un compilatore può essere scomposto in due parti separate; una metà superiore e una inferiore. La metà superiore prende generalmente il linguaggio di origine e lo converte in una rappresentazione intermedia, mentre la metà inferiore si occupa della generazione di codice specifico della piattaforma.

Tuttavia, un'idea per un modo semplice di affrontare questo argomento (almeno quella che abbiamo usato nella mia classe di compilatori) è quella di costruire il compilatore nei due pezzi sopra descritti. In particolare, avrai una buona idea dell'intero processo semplicemente costruendo la metà superiore.

Basta fare la metà superiore per avere l'esperienza di scrivere l'analizzatore lessicale e il parser e andare a generare del "codice" (quella rappresentazione intermedia di cui ho parlato). Quindi prenderà il tuo programma sorgente e lo convertirà in un'altra rappresentazione e farà dell'ottimizzazione (se vuoi), che è il cuore di un compilatore. La metà inferiore prenderà quindi quella rappresentazione intermedia e genererà i byte necessari per eseguire il programma su un'architettura specifica. Ad esempio, la metà inferiore prenderà la tua rappresentazione intermedia e genererà un eseguibile PE.

Alcuni libri su questo argomento che ho trovato particolarmente utili erano i Principi e le tecniche dei compilatori (o il Libro del drago, a causa del simpatico drago in copertina). Ha una grande teoria e copre sicuramente grammatiche senza contesto in un modo davvero accessibile. Inoltre, per creare l'analizzatore lessicale e il parser, probabilmente userete gli strumenti * nix lex e yacc. E poco interessante, il libro chiamato " lex and yacc " riprende da dove il Libro del Drago ha interrotto per questa parte.

Penso che l'implementazione moderna del compilatore in ML sia il miglior testo introduttivo per la compilazione del compilatore. C'è una versione Java e anche una versione C , una delle quali potrebbe essere più accessibile dato il tuo background linguistico. Il libro contiene un sacco di materiale di base utile (scansione e analisi, analisi semantica, record di attivazione, selezione di istruzioni, generazione di codice nativo RISC e x86) e vari argomenti "avanzati" (compilazione di OO e linguaggi funzionali, polimorfismo, raccolta dei rifiuti, ottimizzazione e singolo modulo di assegnazione statico) in uno spazio relativamente piccolo (~ 500 pagine).

Preferisco l'implementazione del compilatore moderno al libro di Dragon perché l'implementazione del compilatore moderno esamina meno del campo, invece ha una copertura davvero solida di tutti gli argomenti di cui avresti bisogno per scrivere un compilatore serio e decente. Dopo aver lavorato su questo libro, sarai pronto per affrontare i documenti di ricerca direttamente per una maggiore profondità se ne avrai bisogno.

Devo confessare di avere un debole per la costruzione del compilatore di Niklaus Wirth . È disponibile online come PDF. Trovo che l'estetica della programmazione di Wirth sia semplicemente meravigliosa, tuttavia alcune persone trovano il suo stile troppo minimale (ad esempio Wirth preferisce i parser di discesa ricorsivi, ma la maggior parte dei corsi CS si concentra su strumenti di generatore di parser; I design del linguaggio di Wirth sono abbastanza conservativi.) La costruzione del compilatore è una distillazione molto succinta delle idee di base di Wirth, quindi se ti piace il suo stile o no, consiglio vivamente di leggere questo libro.

Concordo con il riferimento al Libro del drago; IMO, è la guida definitiva alla costruzione del compilatore. Preparati per qualche teoria hardcore, però.

Se vuoi un libro più leggero in teoria, Game Scripting Mastery potrebbe essere un libro migliore per te. Se sei un principiante assoluto nella teoria dei compilatori, fornisce un'introduzione più delicata. Non copre metodi di analisi più pratici (optando per la discesa ricorsiva non predittiva senza discutere l'analisi di LL o LR) e, come ricordo, non discute nemmeno alcun tipo di teoria dell'ottimizzazione. Inoltre, invece di compilare in codice macchina, si compila in un bytecode che dovrebbe essere eseguito su una VM che si scrive anche.

È ancora una lettura decente, in particolare se puoi prenderlo a buon mercato su Amazon. Se vuoi solo una semplice introduzione ai compilatori, la padronanza degli script di gioco non è una brutta strada da percorrere. Se vuoi andare hardcore all'inizio, allora dovresti accontentarti di niente di meno che il Dragon Book.

"Let's Build a Compiler" è fantastico, ma è un po 'obsoleto. (Non sto dicendo che lo rende ancora un po 'meno valido.)

Oppure dai un'occhiata a SLANG . Questo è simile a "Costruiamo un compilatore" ma è una risorsa molto migliore soprattutto per i principianti. Questo viene fornito con un tutorial in pdf che utilizza un approccio in 7 passaggi per insegnarti un compilatore. Aggiungendo il collegamento quora in quanto ha i collegamenti a tutte le varie porte di SLANG, in C ++, Java e JS, anche interpreti in Python e Java, originariamente scritti usando C # e la piattaforma .NET.

Se stai cercando di utilizzare strumenti potenti di livello superiore anziché costruire tutto da solo, passare attraverso i progetti e le letture per questo corso è un'opzione abbastanza buona. È un corso di lingue dell'autore del motore di analisi Java ANTLR. È possibile ottenere il libro per il corso in formato PDF dai programmatori Pragmatic .

Il corso esamina le cose standard del compilatore del compilatore che vedresti altrove: analisi, tipi e verifica dei tipi, polimorfismo, tabelle dei simboli e generazione di codice. Praticamente l'unica cosa che non è coperta sono le ottimizzazioni. Il progetto finale è un programma che compila un sottoinsieme di C . Poiché usi strumenti come ANTLR e LLVM, è possibile scrivere l'intero compilatore in un solo giorno (ne ho una prova di esistenza, anche se intendo ~ 24 ore). È pesante in ingegneria pratica utilizzando strumenti moderni, un po 'più leggero in teoria.

LLVM, a proposito, è semplicemente fantastico. In molte situazioni in cui è possibile compilare normalmente in assembly, è preferibile invece compilare la rappresentazione intermedia di LLVM . È di livello superiore, multipiattaforma e LLVM è abbastanza brava a generare assemblaggi ottimizzati da esso.

Se hai poco tempo, raccomando "Compiler Construction" di Niklaus Wirth (Addison-Wesley. 1996) , un piccolo libretto che puoi leggere in un giorno, ma spiega le basi (incluso come implementare lexer, parser ricorsivi di discesa, e le tue macchine virtuali basate su stack). Dopodiché, se desideri un'immersione profonda, non c'è modo di aggirare il libro del Drago come suggeriscono altri commentatori.

Potresti voler esaminare Lex / Yacc (o Flex / Bison, come vuoi chiamarli). Flex è un analizzatore lessicale, che analizzerà e identificherà i componenti semantici ("token") della tua lingua, e Bison sarà usato per definire cosa succede quando ogni token viene analizzato. Questo potrebbe essere, ma non solo, la stampa del codice C, per un compilatore che verrà compilato in C o che eseguirà dinamicamente le istruzioni.

Questa FAQ dovrebbe aiutarti e questo tutorial sembra abbastanza utile.

In generale, non c'è un tutorial di cinque minuti per i compilatori, perché è un argomento complicato e scrivere un compilatore può richiedere mesi. Dovrai fare la tua ricerca.

Python e Ruby sono generalmente interpretati. Forse vuoi iniziare anche con un interprete. È generalmente più facile.

Il primo passo è scrivere una descrizione formale del linguaggio, la grammatica del tuo linguaggio di programmazione. Quindi devi trasformare il codice sorgente che vuoi compilare o interpretare secondo la grammatica in un albero di sintassi astratto, una forma interna del codice sorgente che il computer capisce e su cui può operare. Questo passaggio viene in genere chiamato analisi e il software che analizza il codice sorgente viene chiamato parser. Spesso il parser è generato da un generatore di parser che trasforma una grammatica formale in codice sorgente o sorgente della macchina. Per una buona spiegazione non matematica dell'analisi, raccomando le tecniche di analisi: una guida pratica. Wikipedia ha un confronto tra i generatori di parser da cui puoi scegliere quello adatto a te. A seconda del generatore di parser scelto,

Scrivere un parser per la tua lingua può essere davvero difficile, ma questo dipende dalla tua grammatica. Quindi suggerisco di mantenere semplice la tua grammatica (a differenza del C ++); un buon esempio per questo è LISP.

Nella seconda fase l'albero di sintassi astratto viene trasformato da una struttura ad albero in una rappresentazione intermedia lineare. Come buon esempio di questo codice byte di Lua viene spesso citato. Ma la rappresentazione intermedia dipende davvero dalla tua lingua.

Se stai costruendo un interprete, dovrai semplicemente interpretare la rappresentazione intermedia. Puoi anche compilarlo just-in-time. Consiglio LLVM e libjit per la compilazione just-in-time. Per rendere utilizzabile la lingua dovrai anche includere alcune funzioni di input e output e forse una piccola libreria standard.

Se hai intenzione di compilare la lingua, sarà più complicato. Dovrai scrivere backend per diverse architetture di computer e generare codice macchina dalla rappresentazione intermedia in quei backend. Raccomando LLVM per questo compito.

Ci sono alcuni libri su questo argomento, ma non posso raccomandare nessuno di essi per un uso generale. Molti di loro sono troppo accademici o troppo pratici. Non c'è "Insegnati a scrivere compilatore in 21 giorni" e quindi dovrai acquistare diversi libri per capire bene l'intero argomento. Se cerchi in Internet, ti imbatterai in alcuni libri online e appunti di lezione. Forse c'è una biblioteca universitaria vicino a te dove puoi prendere in prestito libri sui compilatori.

Raccomando anche una buona conoscenza di base nell'informatica teorica e nella teoria dei grafi, se vuoi rendere serio il tuo progetto. Sarà utile anche una laurea in informatica.

Dai un'occhiata al libro qui sotto. L'autore è il creatore di ANTLR .

Schemi di implementazione della lingua: creare i propri linguaggi di programmazione specifici e specifici per il dominio .

Un libro non ancora suggerito ma molto importante è "Linkers and Loaders" di John Levine. Se non si utilizza un assemblatore esterno, è necessario un modo per generare un file oggetto che può essere collegato al programma finale. Anche se stai usando un assemblatore esterno, probabilmente dovrai capire i trasferimenti e come funziona l'intero processo di caricamento del programma per creare uno strumento funzionante. Questo libro raccoglie molte delle conoscenze casuali su questo processo per vari sistemi, inclusi Win32 e Linux.

Dragon Book è sicuramente il libro "compilatori di edifici", ma se la tua lingua non è così complicata come l'attuale generazione di lingue, potresti voler guardare il modello Interprete da Design Patterns .

L'esempio nel libro disegna un linguaggio regolare simile all'espressione ed è ben ponderato, ma come si dice nel libro, è buono per pensare attraverso il processo ma è efficace solo su linguaggi di piccole dimensioni. Tuttavia, è molto più veloce scrivere un interprete per una piccola lingua con questo modello piuttosto che dover conoscere tutti i diversi tipi di parser, yacc e lex, eccetera ...

Se sei disposto a utilizzare LLVM, dai un'occhiata a: http://llvm.org/docs/tutorial/ . Ti insegna a scrivere un compilatore da zero usando il framework di LLVM e non presume che tu abbia alcuna conoscenza sull'argomento.

Il tutorial ti suggerisce di scrivere il tuo parser e lexer ecc., Ma ti consiglio di guardare bisonte e flettere una volta che hai avuto l'idea. Rendono la vita molto più semplice.

Ho trovato il libro del Drago troppo difficile da leggere con troppa attenzione alla teoria del linguaggio che in realtà non è necessario per scrivere un compilatore.

Vorrei aggiungere il libro Oberon che contiene la fonte completa di un compilatore Oberon incredibilmente veloce e semplice Project Oberon .

Ricordo di aver fatto questa domanda circa sette anni fa, quando ero piuttosto nuovo nella programmazione.

Sono stato molto attento quando ho chiesto e sorprendentemente non ho ricevuto tante critiche quanto tu stai arrivando qui. Mi hanno comunque indicato la direzione del " Libro dei draghi ", che secondo me è un libro davvero grandioso che spiega tutto ciò che devi sapere per scrivere un compilatore (dovrai ovviamente padroneggiare una lingua o due). lingue che conosci, meglio è.).

E sì, molte persone dicono che leggere quel libro sia pazzo e non imparerai nulla da esso, ma non sono completamente d'accordo.

Molte persone dicono anche che scrivere compilatori è stupido e inutile. Bene, ci sono una serie di ragioni per cui lo sviluppo del compilatore è utile:

• Perche è divertente.
• È educativo, imparando a scrivere compilatori imparerai molto sull'informatica e su altre tecniche che sono utili quando scrivi altre applicazioni.
• Se nessuno scrivesse compilatori, le lingue esistenti non migliorerebbero.

Non ho scritto subito il mio compilatore, ma dopo aver chiesto sapevo da dove iniziare. E ora, dopo aver appreso molte lingue diverse e aver letto il Libro dei draghi, scrivere non è un gran problema. (Sto anche studiando atm di ingegneria informatica, ma la maggior parte di ciò che so sulla programmazione è autodidatta.)

In conclusione, The Dragon Book è un ottimo "tutorial". Ma passa un po 'di tempo a padroneggiare una o due lingue prima di provare a scrivere un compilatore. Non aspettarti di essere un guru del compilatore entro il prossimo decennio o giù di lì.

Il libro è anche buono se vuoi imparare a scrivere parser / interpreti.

"... costruiamo un compilatore ..."

In secondo luogo http://compilers.iecc.com/crenshaw/ di @sasb . Dimentica di comprare più libri per il momento.

Perché? Strumenti e lingua.

La lingua richiesta è Pascal e, se ricordo bene, si basa su Turbo-Pascal. Accade solo se vai su http://www.freepascal.org/ e scarichi il compilatore Pascal, tutti gli esempi funzionano direttamente dalla pagina ~ http://www.freepascal.org/download.var La cosa bella di Free Pascal è che puoi usarlo quasi qualunque processore o sistema operativo ti interessi.

Dopo aver imparato le lezioni, prova il più avanzato " Libro dei draghi " ~ http://it.wikipedia.org/wiki/Dragon_book

Sto esaminando lo stesso concetto e ho trovato questo promettente articolo di Joel Pobar,

Crea un compilatore di lingue per .NET Framework - non sei sicuro di dove sia andato

Crea un compilatore di lingue per .NET Framework - copia pdf del documento originale

discute un concetto di alto livello di un compilatore e procede a inventare la sua lingua per il framework .Net. Sebbene sia mirato al .Net Framework, molti dei concetti dovrebbero poter essere riprodotti. L'articolo riguarda:

1. Definizione di Langauge
2. Scanner
3. Parser (il bit mi interessa principalmente)
4. Targeting per .Net Framework
5. Generatore di codici

ci sono altri argomenti, ma ottieni il giusto.

Si rivolge alle persone che iniziano, scritto in C # (non proprio Java)

HTH

ossatura

Un modo semplice per creare un compilatore è usare bisonte e flex (o simili), costruire un albero (AST) e generare codice in C. Con la generazione di codice C è il passo più importante. Generando il codice C, la tua lingua funzionerà automaticamente su tutte le piattaforme che hanno un compilatore C.

Generare codice C è facile come generare HTML (basta usare print, o equivalente), che a sua volta è molto più semplice che scrivere un parser C o un parser HTML.

Dalle FAQ di comp.compilers :

"Programmazione di un personal computer" di Per Brinch Hansen Prentice-Hall 1982 ISBN 0-13-730283-5

Questo libro dal titolo sfortunato spiega la progettazione e la creazione di un ambiente di programmazione per utente singolo per i micro, usando un linguaggio simile a Pascal chiamato Edison. L'autore presenta tutto il codice sorgente e le spiegazioni per l'implementazione passo-passo di un compilatore Edison e di un semplice sistema operativo di supporto, tutti scritti in Edison stesso (tranne per un piccolo kernel di supporto scritto in un assemblatore simbolico per PDP 11/23; il la fonte completa può anche essere ordinata per il PC IBM).

Le cose più interessanti di questo libro sono: 1) la sua capacità di dimostrare come creare un compilatore e un sistema operativo completi, autonomi, autosufficienti e utili, e 2) l'interessante discussione sulla progettazione del linguaggio e sui problemi di specifica e commercio- offs nel capitolo 2.

"Brinch Hansen su Pascal Compilers" di Per Brinch Hansen Prentice-Hall 1985 ISBN 0-13-083098-4

Un altro libro di pragmatica pesante sulla teoria della luce, ecco come codificare. L'autore presenta la progettazione, l'implementazione e il codice sorgente completo per un compilatore e un interprete di codice p per Pascal- (Pascal "meno"), un sottoinsieme Pascal con tipi booleani e interi (ma senza caratteri, real, tipi di sottorange o elencati) , definizioni costanti e variabili e tipi di array e record (ma nessun tipo impacchettato, variante, set, puntatore, senza nome, rinominato o file), espressioni, istruzioni di assegnazione, definizioni di procedure nidificate con valore e parametri variabili, se istruzioni, mentre istruzioni, e blocchi di inizio-fine (ma nessuna definizione di funzione, parametri procedurali, istruzioni goto ed etichette, istruzioni case, istruzioni repeat, per istruzioni e con istruzioni).

Il compilatore e l'interprete sono scritti in Pascal * (Pascal "star"), un sottoinsieme Pascal ampliato con alcune funzionalità in stile Edison per la creazione di sistemi di sviluppo software. Un compilatore Pascal * per il PC IBM viene venduto dall'autore, ma è facile portare il compilatore Pascal del libro su qualsiasi comoda piattaforma Pascal.

Questo libro semplifica la progettazione e l'implementazione di un compilatore. Mi piace particolarmente il modo in cui l'autore si preoccupa di qualità, affidabilità e test. Il compilatore e l'interprete possono essere facilmente utilizzati come base per un linguaggio più coinvolto o un progetto di compilatore, specialmente se si preme per avviare rapidamente qualcosa.

Dovresti dare un'occhiata agli " ichbin " di Darius Bacon , che è un compilatore per un piccolo dialetto Lisp, che prende di mira C, in poco più di 6 pagine di codice. Il vantaggio che ha sulla maggior parte dei compilatori di giocattoli è che la lingua è abbastanza completa da essere scritta dal compilatore. (Il tarball include anche un interprete per avviare la cosa.)

Ci sono altre cose su ciò che ho trovato utile per imparare a scrivere un compilatore sulla mia pagina web Ur-Scheme .

1. Questo è un argomento vasto. Non sottovalutare questo punto. E non sottovalutare il mio punto di non sottovalutare.
2. Ho sentito che il Libro del Drago è un (il??) Punto di partenza, insieme alla ricerca. :) Migliora la ricerca, alla fine sarà la tua vita.
3. Costruire il tuo linguaggio di programmazione è assolutamente un buon esercizio! Ma sappi che alla fine non verrà mai usato per nessuno scopo pratico. Le eccezioni a questo sono poche e molto distanti tra loro.

Il compilatore LCC ( wikipedia ) ( homepage del progetto ) ( github.com/drh/lcc ) di Fraser e Hanson è descritto nel loro libro "A Retargetable C Compiler: Design and Implementation". È abbastanza leggibile e spiega l'intero compilatore, fino alla generazione del codice.

Python viene fornito in bundle con un compilatore Python scritto in Python. Puoi vedere il codice sorgente e include tutte le fasi, dall'analisi, l'albero astratto della sintassi, l'emissione del codice, ecc. Hack.

Siamo spiacenti, è in spagnolo, ma questa è la bibliografia di un corso chiamato "Compiladores e Intérpretes" (Compilatori e interpreti) in Argentina.

Il corso è stato dalla teoria del linguaggio formale alla costruzione del compilatore, e questi sono gli argomenti di cui hai bisogno per costruire, almeno, un semplice compilatore:

• Progettazione di compilatori in C.
  Allen I. Holub
  
  Prentice-Hall. 1990.

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

• Costruzione del compilatore.
  Niklaus Wirth
  
  Addison-Wesley. 1996.

• 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.

• L'arte del design del compilatore. Teoria e pratica.
  Thomas Pittman, James Peters.
  
  Prentice-Hall. 1992.

• Costruzione di compilatori orientati agli oggetti.
  Jim Holmes.
  Prentice Hall, Englewood Cliffs, NJ 1995

• Compiladores. Conceptos Fundamentales.
  B. Teufel, S. Schmidt, T. Teufel.
  
  Addison-Wesley Iberoamericana. 1995.

• Introduzione alla teoria, alle lingue e al calcolo degli automi.
  
  John E. Hopcroft. Jeffref D. Ullman.
  Addison-Wesley. 1979.

• Introduzione ai linguaggi formali.
  György E. Révész.
  
  Mc Graw Hill. 1983.

• Tecniche di analisi. Una guida pratica.
  Dick Grune, Ceriel Jacobs.
  Impreso por los autores. 1995
  http://www.cs.vu.nl/~dick/PTAPG.html

• Yacc: ancora un altro compilatore-compilatore.
  Stephen C. Johnson
  Relazione tecnica sulla scienza informatica n. 32, 1975. Bell Laboratories. Murray Hill, New
  Jersey.

• Lex: un generatore di analizzatori lessicali.
  ME Lesk, E. Schmidt. Rapporto tecnico scienza informatica n. 39, 1975. Bell Laboratories. Murray Hill, New Jersey.

• lex & yacc.
  John R. Levine, Tony Mason, Doug Brown.
  O'Reilly & Associates. 1995.

• Elementi della teoria del calcolo.
  Harry R. Lewis, Christos H. Papadimitriou. Segunda Edición. Prentice Hall. 1998.

• Un algoritmo efficace per la costruzione del grafo de Dependencia de Control.
  Salvador V. Cavadini.
  Trabajo Final de Grado per l'ottenimento del Título de Ingeniero in Computación.
  Facultad de Matemática Aplicada. UCSE 2001.

Non un libro, ma un documento tecnico e un'esperienza di apprendimento estremamente divertente se vuoi saperne di più sui compilatori (e sui metacompilatori) ... Questo sito ti guida attraverso la costruzione di un sistema di compilazione completamente autonomo in grado di compilare se stesso e altre lingue:

Tutorial: Metacompilers Part 1

Tutto questo è basato su un fantastico piccolo foglio tecnico di 10 pagine:

Val Schorre META II: un linguaggio di scrittura per compilatore orientato alla sintassi

da onesto a dio 1964. Ho imparato a costruire compilatori da questo nel lontano 1970. C'è un momento strabiliante in cui finalmente riesci a capire come il compilatore può rigenerarsi ...

Conosco l'autore del sito web dai tempi del college, ma non ho nulla a che fare con il sito web.

Mi è piaciuto anche il tutorial di Crenshaw , perché rende assolutamente chiaro che un compilatore è solo un altro programma che legge alcuni input e ne scrive alcuni.

Leggilo.

Lavora se vuoi, ma poi guarda un altro riferimento su come i compilatori più grandi e più completi sono davvero scritti.

E leggi On Trusting Trust , per avere un'idea delle cose invisibili che si possono fare in questo dominio.

Se sei interessato a scrivere un compilatore per un linguaggio funzionale (piuttosto che un linguaggio procedurale) " Implementare i linguaggi funzionali: un tutorial " di Simon Peyton-Jones e David Lester è una guida eccellente.

Le basi concettuali di come funziona la valutazione funzionale sono guidate da esempi in un linguaggio funzionale semplice ma potente chiamato "Core". Inoltre, ogni parte del compilatore del linguaggio Core è spiegata con esempi di codice in Miranda (un linguaggio funzionale puro molto simile a Haskell).

Sono descritti diversi tipi di compilatori ma anche se segui solo il cosiddetto compilatore di modelli per Core avrai una comprensione eccellente di ciò che rende la programmazione funzionale ticchettabile.

È possibile utilizzare BCEL da Apache Software Foundation. Con questo strumento puoi generare codice simile a un assemblatore, ma è Java con l'API BCEL. Puoi imparare come generare un codice di lingua intermedia (in questo caso il codice byte).

Semplice esempio

1. Crea una classe Java con questa funzione:

   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";
       }
   }
   

Ora esegui BCELifier con questa classe

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

Puoi vedere il risultato sulla console per l'intera classe (come costruire il codice byte MyClass.java). Il codice per la funzione è questo:

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

Ci sono molte buone risposte qui, quindi ho pensato di aggiungere solo un'altra alla lista:

Ho ricevuto un libro chiamato Project Oberon più di un decennio fa, che contiene un testo molto ben scritto sul compilatore. Il libro si distingue davvero nel senso che la fonte e le spiegazioni sono molto pratiche e leggibili. Il testo completo (edizione 2005) è stato reso disponibile in pdf, quindi puoi scaricarlo subito. Il compilatore è discusso nel capitolo 12:

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

Niklaus Wirth, Jürg Gutknecht

(Il trattamento non è esteso come il suo libro sui compilatori)

Ho letto diversi libri sui compilatori e posso secondare il libro sui draghi, il tempo speso in questo libro è molto utile.

Finora questo libro non è incluso nell'elenco:

Basics of Compiler Design (Torben Mogensen) (dal dipartimento di Informatica, Università di Copenaghen)

Sono anche interessato a conoscere i compilatori e ho intenzione di entrare in questo settore nei prossimi due anni. Questo libro è il libro teorico ideale per iniziare a studiare compilatori per quanto posso vedere. È GRATUITO copiare e riprodurre, scritto in modo pulito e accurato e te lo dà in un inglese semplice senza alcun codice, ma presenta ancora la meccanica tramite istruzioni, diagrammi ecc. Vale la pena dare un'occhiata imo.