Apprendre à écrire un compilateur [fermé]

Langages préférés : C / C ++, Java et Ruby.

Je cherche des livres / tutoriels utiles sur la façon d'écrire votre propre compilateur simplement à des fins éducatives. Je connais mieux C / C ++, Java et Ruby, donc je préfère les ressources qui impliquent l'une de ces trois, mais toute bonne ressource est acceptable.

Grande liste de ressources:

• Un cadre Nanopass pour la formation des compilateurs ¶
• Conception et implémentation avancées du compilateur $
• Une approche incrémentielle de la construction du compilateur ¶
• Tutoriel vidéo ANTLR 3.x
• Bases de la conception du compilateur
• Construire un compilateur Parrot
• Bases du compilateur
• Construction du compilateur $
• Conception et construction du compilateur $
• Création d'un compilateur avec C $
• Interprètes d'artisanat
• Conception du compilateur en C ¶
• Compilateurs: principes, techniques et outils $ - aka "The Dragon Book" ; largement considéré comme "le livre" pour l'écriture du compilateur.
• Ingénierie d'un compilateur $
• Les bases des langages de programmation
• Archives d'articles Flipcode (recherchez "Implémentation d'un moteur de script par Jan Niestadt")
• Maîtrise des scripts de jeu $
• Comment construire une machine virtuelle à partir de zéro en C # ¶
• Implémentation de langages fonctionnels
• Implémentation de langages de programmation (avec BNFC)
• Implémentation de langages de programmation à l'aide de C # 4.0
• Le modèle d'interpréteur (décrit dans Design Patterns $) spécifie un moyen d'évaluer les phrases dans une langue
• Modèles d'implémentation du langage: créez vos propres langages de programmation généraux et spécifiques au domaine $
• Construisons un compilateur par Jack Crenshaw - La version PDF ¶ (les exemples sont en Pascal, mais les informations sont généralement applicables)
• Liens et chargeurs $ (Google Books)
• Lisp en petits morceaux (LiSP) $
• Tutoriel LLVM
• Implémentation du compilateur moderne en ML $ - Il existe également une version Java $ et C $ - largement considéré comme un très bon livre
• Construction du compilateur orienté objet $
• Techniques d'analyse - Un guide pratique
• Projet Oberon ¶ - Regardez le chapitre 13
• Programmation d'un ordinateur personnel $
• Langues de programmation: application et interprétation
• Rabbit: un compilateur pour le schéma ¶
• Réflexions sur Trusting Trust - Un guide rapide
• Roll Your Own Compiler pour le framework .NET - Un rapide tutoriel de MSDN
• Structure et interprétation des programmes informatiques
• Types et langages de programmation
• Vous voulez écrire un compilateur? - un guide rapide
• Écriture d'un compilateur dans Ruby Bottom Up

Légende:

• ¶ Lien vers un fichier PDF
• $ Lien vers un livre imprimé

C'est une question assez vague, je pense; juste en raison de la profondeur du sujet concerné. Un compilateur peut cependant être décomposé en deux parties distinctes; une moitié supérieure et une inférieure. La moitié supérieure prend généralement le langage source et le convertit en une représentation intermédiaire, et la moitié inférieure s'occupe de la génération de code spécifique à la plate-forme.

Néanmoins, une idée pour un moyen facile d'aborder ce sujet (celui que nous avons utilisé dans ma classe de compilateurs, au moins) est de construire le compilateur dans les deux pièces décrites ci-dessus. Plus précisément, vous aurez une bonne idée de l'ensemble du processus en construisant simplement la moitié supérieure.

Faire juste la moitié supérieure vous permet d'acquérir l'expérience d'écrire l'analyseur lexical et l'analyseur et de générer du "code" (cette représentation intermédiaire que j'ai mentionnée). Il prendra donc votre programme source et le convertira en une autre représentation et fera une optimisation (si vous voulez), qui est le cœur d'un compilateur. La moitié inférieure prendra alors cette représentation intermédiaire et générera les octets nécessaires pour exécuter le programme sur une architecture spécifique. Par exemple, la moitié inférieure prendra votre représentation intermédiaire et générera un exécutable PE.

Certains livres sur ce sujet que j'ai trouvé particulièrement utiles étaient les principes et techniques des compilateurs (ou le livre du dragon, en raison du joli dragon sur la couverture). Il a une excellente théorie et couvre certainement les grammaires sans contexte d'une manière vraiment accessible. De plus, pour construire l'analyseur et l'analyseur lexical, vous utiliserez probablement les outils * nix lex et yacc. Et sans intérêt assez, le livre intitulé " lex et yacc " a repris là où le Dragon Book s'était arrêté pour cette partie.

Je pense que l'implémentation du compilateur moderne en ML est le meilleur texte d'introduction du compilateur. Il existe également une version Java et une version C , qui pourraient être plus accessibles compte tenu de vos antécédents linguistiques. Le livre contient beaucoup de matériel de base utile (numérisation et analyse, analyse sémantique, enregistrements d'activation, sélection d'instructions, génération de code natif RISC et x86) et divers sujets "avancés" (compilation OO et langages fonctionnels, polymorphisme, garbage collection, optimisation et formulaire d'attribution statique unique) dans un espace relativement petit (~ 500 pages).

Je préfère l'implémentation du compilateur moderne au livre Dragon parce que l'implémentation du compilateur moderne étudie moins le domaine - au lieu de cela, il a une couverture vraiment solide de tous les sujets dont vous auriez besoin pour écrire un compilateur sérieux et décent. Après avoir parcouru ce livre, vous serez prêt à aborder les articles de recherche directement pour plus de profondeur si vous en avez besoin.

Je dois avouer que j'ai un faible pour la construction du compilateur de Niklaus Wirth . Il est disponible en ligne au format PDF. Je trouve l'esthétique de programmation de Wirth tout simplement magnifique, mais certaines personnes trouvent son style trop minimal (par exemple, Wirth favorise les analyseurs de descente récursifs, mais la plupart des cours CS se concentrent sur les outils de générateur d'analyseurs; les conceptions du langage de Wirth sont assez conservatrices.) La construction du compilateur est une distillation très succincte. des idées de base de Wirth, donc que vous aimiez son style ou non, je vous recommande fortement de lire ce livre.

Je suis d'accord avec la référence Dragon Book; IMO, c'est le guide définitif de la construction du compilateur. Préparez-vous à une théorie hardcore, cependant.

Si vous voulez un livre plus léger sur la théorie, Game Master Scripting Mastery pourrait être un meilleur livre pour vous. Si vous êtes un débutant total à la théorie du compilateur, il fournit une introduction plus douce. Il ne couvre pas les méthodes d'analyse plus pratiques (optant pour une descente récursive non prédictive sans discuter de l'analyse LL ou LR), et si je me souviens bien, il ne traite même pas d'une sorte de théorie d'optimisation. De plus, au lieu de compiler en code machine, il compile en un bytecode qui est censé s'exécuter sur une machine virtuelle que vous écrivez également.

C'est toujours une lecture décente, surtout si vous pouvez le récupérer à bas prix sur Amazon. Si vous voulez seulement une introduction facile aux compilateurs, Game Scripting Mastery n'est pas une mauvaise façon de procéder. Si vous voulez aller du hardcore à l'avant, vous devriez vous contenter de rien de moins que le Dragon Book.

"Créons un compilateur" est génial, mais c'est un peu dépassé. (Je ne dis pas que cela le rend encore un peu moins valide.)

Ou consultez SLANG . Ceci est similaire à «Créons un compilateur» mais c'est une bien meilleure ressource, en particulier pour les débutants. Cela vient avec un tutoriel pdf qui prend une approche en 7 étapes pour vous enseigner un compilateur. Ajout du lien quora car il a les liens vers tous les différents ports de SLANG, en C ++, Java et JS, également des interprètes en python et java, écrits à l'origine en utilisant C # et la plate-forme .NET.

Si vous cherchez à utiliser des outils puissants de niveau supérieur plutôt que de tout construire vous-même, parcourir les projets et les lectures de ce cours est une très bonne option. Il s'agit d'un cours de langues par l'auteur du moteur d'analyse Java ANTLR. Vous pouvez obtenir le livre du cours au format PDF auprès des programmeurs pragmatiques .

Le cours passe en revue les éléments du compilateur de compilateur standard que vous verriez ailleurs: analyse, types et vérification de type, polymorphisme, tables de symboles et génération de code. La seule chose qui n'est pas couverte, ce sont les optimisations. Le projet final est un programme qui compile un sous - ensemble de C . Parce que vous utilisez des outils comme ANTLR et LLVM, il est possible d'écrire l'intégralité du compilateur en une seule journée (j'en ai une preuve d'existence, même si je veux dire ~ 24 heures). C'est lourd sur l'ingénierie pratique utilisant des outils modernes, un peu plus léger sur la théorie.

Soit dit en passant, LLVM est tout simplement fantastique. Dans de nombreuses situations où vous pourriez normalement compiler jusqu'à l'assemblage, vous feriez mieux de compiler vers la représentation intermédiaire de LLVM à la place. C'est un niveau supérieur, multiplateforme et LLVM est assez bon pour générer un assemblage optimisé à partir de celui-ci.

Si vous avez peu de temps, je recommande "Compiler Construction" de Niklaus Wirth (Addison-Wesley. 1996) , un tout petit livret que vous pouvez lire en une journée, mais il explique les bases (y compris comment implémenter des lexers, des analyseurs de descente récursive, et vos propres machines virtuelles basées sur la pile). Après cela, si vous voulez une plongée profonde, il n'y a aucun moyen de contourner le livre Dragon comme le suggèrent d'autres commentateurs.

Vous voudrez peut-être examiner Lex / Yacc (ou Flex / Bison, peu importe comment vous les appelez). Flex est un analyseur lexical, qui analysera et identifiera les composants sémantiques ("jetons") de votre langage, et Bison sera utilisé pour définir ce qui se passe lorsque chaque jeton est analysé. Cela pourrait être, mais sans s'y limiter, l'impression du code C, pour un compilateur qui compilerait en C, ou l'exécution dynamique des instructions.

Cette FAQ devrait vous aider et ce didacticiel semble très utile.

De manière générale, il n'y a pas de tutoriel de cinq minutes pour les compilateurs, car c'est un sujet compliqué et l'écriture d'un compilateur peut prendre des mois. Vous devrez faire votre propre recherche.

Python et Ruby sont généralement interprétés. Vous voudrez peut-être commencer par un interprète également. C'est généralement plus facile.

La première étape consiste à écrire une description formelle du langage, la grammaire de votre langage de programmation. Ensuite, vous devez transformer le code source que vous souhaitez compiler ou interpréter selon la grammaire en une arborescence de syntaxe abstraite, une forme interne du code source que l'ordinateur comprend et peut utiliser. Cette étape est généralement appelée analyse et le logiciel qui analyse le code source est appelé analyseur. Souvent, l'analyseur est généré par un générateur d'analyseur qui transforme une grammaire formelle en code machine source ou plus. Pour une bonne explication non mathématique de l'analyse, je recommande les techniques d'analyse - un guide pratique. Wikipedia a une comparaison de générateurs d'analyseurs parmi lesquels vous pouvez choisir celui qui vous convient. Selon le générateur d'analyseur que vous avez choisi,

Écrire un analyseur pour votre langue peut être très difficile, mais cela dépend de votre grammaire. Je suggère donc de garder votre grammaire simple (contrairement à C ++); un bon exemple pour cela est LISP.

Dans la deuxième étape, l'arbre de syntaxe abstraite est transformé d'une structure arborescente en une représentation intermédiaire linéaire. Un bon exemple de ce bytecode de Lua est souvent cité. Mais la représentation intermédiaire dépend vraiment de votre langue.

Si vous construisez un interprète, il vous suffira d'interpréter la représentation intermédiaire. Vous pouvez également le compiler juste à temps. Je recommande LLVM et libjit pour une compilation juste à temps. Pour rendre le langage utilisable, vous devrez également inclure des fonctions d'entrée et de sortie et peut-être une petite bibliothèque standard.

Si vous allez compiler la langue, ce sera plus compliqué. Vous devrez écrire des backends pour différentes architectures informatiques et générer du code machine à partir de la représentation intermédiaire dans ces backends. Je recommande LLVM pour cette tâche.

Il existe quelques livres sur ce sujet, mais je ne peux en recommander aucun pour une utilisation générale. La plupart d'entre eux sont trop académiques ou trop pratiques. Il n'y a pas "Apprenez à écrire le compilateur en 21 jours" et donc, vous devrez acheter plusieurs livres pour bien comprendre tout ce sujet. Si vous effectuez une recherche sur Internet, vous rencontrerez des livres en ligne et des notes de cours. Peut-être qu'il y a une bibliothèque universitaire près de chez vous où vous pouvez emprunter des livres sur des compilateurs.

Je recommande également une bonne connaissance de base en informatique théorique et en théorie des graphes, si vous voulez rendre votre projet sérieux. Un diplôme en informatique sera également utile.

Jetez un œil au livre ci-dessous. L'auteur est le créateur d' ANTLR .

Modèles d'implémentation du langage: créez vos propres langages de programmation spécifiques au domaine et généraux .

Un livre pas encore suggéré mais très important est "Linkers and Loaders" de John Levine. Si vous n'utilisez pas d'assembleur externe, vous aurez besoin d'un moyen de sortie d'un fichier objet qui peut être lié à votre programme final. Même si vous utilisez un assembleur externe, vous aurez probablement besoin de comprendre les délocalisations et le fonctionnement du processus de chargement du programme pour créer un outil de travail. Ce livre recueille une grande partie de la tradition aléatoire autour de ce processus pour divers systèmes, y compris Win32 et Linux.

Le Dragon Book est certainement le livre des "compilateurs de construction", mais si votre langue n'est pas aussi compliquée que la génération actuelle de langues, vous voudrez peut-être regarder le modèle d'interpréteur de Design Patterns .

L'exemple dans le livre conçoit un langage semblable à une expression régulière et est bien pensé, mais comme on dit dans le livre, il est bon pour réfléchir à travers le processus mais n'est efficace que sur les petites langues. Cependant, il est beaucoup plus rapide d'écrire un interprète pour une petite langue avec ce modèle que d'avoir à apprendre sur tous les différents types d'analyseurs, yacc et lex, et cetera ...

Si vous êtes prêt à utiliser LLVM, consultez ceci: http://llvm.org/docs/tutorial/ . Il vous apprend à écrire un compilateur à partir de zéro en utilisant le cadre de LLVM, et ne suppose pas que vous avez des connaissances sur le sujet.

Le didacticiel vous suggère d'écrire votre propre analyseur et lexer, etc., mais je vous conseille de vous pencher sur le bison et le flex une fois que vous avez l'idée. Ils rendent la vie tellement plus facile.

J'ai trouvé le livre Dragon beaucoup trop difficile à lire avec trop de concentration sur la théorie du langage qui n'est pas vraiment nécessaire pour écrire un compilateur dans la pratique.

J'ajouterais le livre Oberon qui contient la source complète d'un projet de compilateur Oberon incroyablement rapide et simple .

Je me souviens d'avoir posé cette question il y a environ sept ans, alors que j'étais plutôt novice en programmation.

J'ai été très prudent lorsque j'ai demandé et, de façon surprenante, je n'ai pas reçu autant de critiques que vous. Ils m'ont cependant orienté vers le " Dragon Book " qui est à mon avis, un très bon livre qui explique tout ce que vous devez savoir pour écrire un compilateur (vous devrez bien sûr maîtriser une ou deux langues. Plus langues que vous connaissez, le plus joyeux.).

Et oui, beaucoup de gens disent que lire ce livre est fou et que vous n'en apprendrez rien, mais je ne suis absolument pas d'accord avec cela.

Beaucoup de gens disent aussi qu'écrire des compilateurs est stupide et inutile. Eh bien, il existe un certain nombre de raisons pour lesquelles le développement d'un compilateur est utile:

• Parce que c'est drôle.
• C'est pédagogique, lorsque vous apprendrez à écrire des compilateurs, vous en apprendrez beaucoup sur l'informatique et d'autres techniques utiles lors de l'écriture d'autres applications.
• Si personne n'écrivait de compilateurs, les langues existantes ne s'amélioreraient pas.

Je n'ai pas écrit mon propre compilateur tout de suite, mais après avoir demandé, je savais par où commencer. Et maintenant, après avoir appris de nombreuses langues différentes et lu le Dragon Book, l'écriture n'est plus vraiment un problème. (J'étudie également le génie informatique, mais la plupart de ce que je sais sur la programmation est autodidacte.)

En conclusion, The Dragon Book est un excellent "tutoriel". Mais passez du temps à maîtriser une langue ou deux avant d'essayer d'écrire un compilateur. Ne vous attendez pas à être un gourou du compilateur au cours de la prochaine décennie.

Le livre est également bon si vous voulez apprendre à écrire des analyseurs / interprètes.

"... Construisons un compilateur ..."

Je seconderais http://compilers.iecc.com/crenshaw/ par @sasb . Oubliez d'acheter plus de livres pour le moment.

Pourquoi? Outils et langue.

Le langage requis est Pascal et si je me souviens bien est basé sur Turbo-Pascal. Il en est ainsi si vous allez sur http://www.freepascal.org/ et téléchargez le compilateur Pascal, tous les exemples fonctionnent directement à partir de la page ~ http://www.freepascal.org/download.var La beauté de Free Pascal est que vous pouvez l'utiliser presque n'importe quel processeur ou système d'exploitation dont vous pouvez prendre soin.

Une fois que vous avez maîtrisé les leçons, essayez le " Dragon Book " plus avancé ~ http://en.wikipedia.org/wiki/Dragon_book

J'examine le même concept et j'ai trouvé cet article prometteur de Joel Pobar,

Créer un compilateur de langage pour .NET Framework - vous ne savez pas où cela est allé

Créer un compilateur de langage pour .NET Framework - copie pdf du document d'origine

il discute d'un concept de haut niveau d'un compilateur et procède à l'invention de sa propre langue pour le framework .Net. Bien qu'il s'adresse au .Net Framework, de nombreux concepts devraient pouvoir être reproduits. L'article couvre:

1. Définition de la jauge
2. Scanner
3. Analyseur (le bit qui m'intéresse principalement)
4. Cibler le cadre .Net
5. Générateur de code

il y a d'autres sujets, mais vous obtenez le juste.

Il est destiné aux personnes débutantes, écrit en C # (pas tout à fait Java)

HTH

des os

Un moyen facile de créer un compilateur consiste à utiliser bison et flex (ou similaire), à ​​construire un arbre (AST) et à générer du code en C. La génération de code C étant l'étape la plus importante. En générant du code C, votre langage fonctionnera automatiquement sur toutes les plateformes disposant d'un compilateur C.

La génération de code C est aussi simple que la génération de HTML (utilisez simplement print ou équivalent), ce qui est à son tour beaucoup plus facile que d'écrire un analyseur C ou HTML.

De la FAQ comp.compilers :

"Programmation d'un ordinateur personnel" par Per Brinch Hansen Prentice-Hall 1982 ISBN 0-13-730283-5

Ce livre malheureusement intitulé explique la conception et la création d'un environnement de programmation mono-utilisateur pour les micros, en utilisant un langage de type Pascal appelé Edison. L'auteur présente tout le code source et les explications pour l'implémentation pas à pas d'un compilateur Edison et d'un système d'exploitation de support simple, tous écrits dans Edison lui-même (à l'exception d'un petit noyau de support écrit dans un assembleur symbolique pour PDP 11/23; le la source complète peut également être commandée pour le PC IBM).

Les choses les plus intéressantes à propos de ce livre sont: 1) sa capacité à démontrer comment créer un compilateur et un système d'exploitation complet, autonome et auto-entretenu, et 2) la discussion intéressante sur les problèmes de conception et de spécification de langage et le commerce- au chapitre 2.

"Brinch Hansen sur Pascal Compilers" par Per Brinch Hansen Prentice-Hall 1985 ISBN 0-13-083098-4

Un autre livre léger sur la théorie et lourd sur la pragmatique, voici comment coder. L'auteur présente la conception, l'implémentation et le code source complet d'un compilateur et d'un interpréteur de code p pour Pascal- (Pascal "moins"), un sous-ensemble Pascal avec des types booléens et entiers (mais pas de caractères, réels, types sous-rangés ou énumérés) , définitions de constantes et de variables et types de tableaux et d'enregistrements (mais pas de types compressés, variant, définis, pointeurs, sans nom, renommés ou de fichiers), expressions, instructions d'affectation, définitions de procédures imbriquées avec des paramètres de valeur et de variable, si des instructions, alors que des instructions, et les blocs début-fin (mais pas de définitions de fonction, de paramètres procéduraux, d'instructions et d'étiquettes goto, d'instructions case, d'instructions repeat, pour les instructions et avec des instructions).

Le compilateur et l'interpréteur sont écrits en Pascal * (Pascal "star"), un sous-ensemble Pascal étendu avec quelques fonctionnalités de style Edison pour créer des systèmes de développement logiciel. Un compilateur Pascal * pour le PC IBM est vendu par l'auteur, mais il est facile de porter le compilateur Pascal du livre sur n'importe quelle plateforme Pascal pratique.

Ce livre facilite la conception et la mise en œuvre d'un compilateur. J'aime particulièrement la façon dont l'auteur se préoccupe de la qualité, de la fiabilité et des tests. Le compilateur et l'interpréteur peuvent facilement être utilisés comme base pour un projet de langage ou de compilateur plus impliqué, surtout si vous êtes pressé de mettre rapidement quelque chose en place.

Vous devriez vérifier les " ichbins " de Darius Bacon , qui est un compilateur pour un petit dialecte Lisp, ciblant C, dans un peu plus de 6 pages de code. L'avantage qu'il a sur la plupart des compilateurs jouets est que le langage est suffisamment complet pour que le compilateur y soit écrit. (L'archive tar inclut également un interprète pour amorcer la chose.)

Il y a plus d'informations sur ce que j'ai trouvé utile pour apprendre à écrire un compilateur sur ma page Web Ur-Scheme .

1. C'est un vaste sujet. Ne sous-estimez pas ce point. Et ne sous-estimez pas mon propos pour ne pas le sous-estimer.
2. J'entends que le Dragon Book est un (le?) Point de départ, avec la recherche. :) Améliorez votre recherche, ce sera finalement votre vie.
3. Construire votre propre langage de programmation est absolument un bon exercice! Mais sachez qu'il ne sera jamais utilisé à des fins pratiques à la fin. Les exceptions à cette règle sont rares et très éloignées.

Le compilateur LCC ( wikipedia ) ( page d'accueil du projet ) ( github.com/drh/lcc ) de Fraser et Hanson est décrit dans leur livre "A Retargetable C Compiler: Design and Implementation". Il est assez lisible et explique tout le compilateur, jusqu'à la génération de code.

Python est fourni avec un compilateur python écrit en Python. Vous pouvez voir le code source, et il comprend toutes les phases, de l'analyse syntaxique, l'arbre de syntaxe abstraite, l'émission de code, etc. Hack it.

Désolé, c'est en espagnol, mais voici la bibliographie d'un cours intitulé "Compiladores e Intérpretes" (Compilateurs et Interprètes) en Argentine.

Le cours allait de la théorie du langage formel à la construction du compilateur, et ce sont les sujets dont vous avez besoin pour construire, au moins, un simple compilateur:

• Conception des compilateurs dans C.
  Allen I. Holub
  
  Prentice-Hall. 1990.

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

• Construction du compilateur.
  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'art de la conception de compilateurs. Théorie et pratique.
  Thomas Pittman, James Peters.
  
  Prentice Hall. 1992.

• Construction du compilateur orienté objet.
  Jim Holmes.
  Prentice Hall, Englewood Cliffs, NJ 1995

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

• Introduction à la théorie des automates, aux langages et au calcul.
  
  John E. Hopcroft. Jeffref D. Ullman.
  Addison-Wesley. 1979.

• Introduction aux langues formelles.
  György E. Révész.
  
  Mc Graw Hill. 1983.

• Techniques d'analyse. Un guide pratique.
  Dick Grune, Ceriel Jacobs.
  Impreso por los autores. 1995
  http://www.cs.vu.nl/~dick/PTAPG.html

• Yacc: Encore un autre compilateur-compilateur.
  Stephen C. Johnson
  Rapport technique sur la science informatique n ° 32, 1975. Bell Laboratories. Murray Hill, New
  Jersey.

• Lex: un générateur d'analyseur lexical.
  ME Lesk, E. Schmidt. Rapport technique informatique n ° 39, 1975. Laboratoires Bell. Murray Hill, New Jersey.

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

• Éléments de la théorie du calcul.
  Harry R. Lewis, Christos H. Papadimitriou. Segunda Edición. Prentice Hall. 1998.

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

Pas un livre, mais un document technique et une expérience d'apprentissage extrêmement amusante si vous voulez en savoir plus sur les compilateurs (et les métacompilateurs) ...

Tutoriel: Metacompilers Part 1

Tout cela est basé sur un incroyable petit document technique de 10 pages:

Val Schorre META II: un langage d'écriture de compilateur orienté syntaxe

d'honnête à dieu 1964. J'ai appris à construire des compilateurs à partir de cela en 1970. Il y a un moment époustouflant où vous voyez enfin comment le compilateur peut se régénérer ....

Je connais l'auteur du site Web depuis mes années universitaires, mais je n'ai rien à voir avec le site Web.

J'ai aussi aimé le tutoriel de Crenshaw , car il montre clairement qu'un compilateur n'est qu'un autre programme qui lit des entrées et en écrit des sorties.

Lis le.

Travaillez-le si vous voulez, mais regardez une autre référence sur la façon dont les compilateurs plus grands et plus complets sont vraiment écrits.

Et lisez On Trusting Trust , pour avoir une idée des choses non évidentes qui peuvent être faites dans ce domaine.

Si vous êtes intéressé à écrire un compilateur pour un langage fonctionnel (plutôt qu'un langage procédural), Simon Peyton-Jones et David Lester " Implémentation des langages fonctionnels: un tutoriel " est un excellent guide.

Les bases conceptuelles du fonctionnement de l'évaluation fonctionnelle sont guidées par des exemples dans un langage fonctionnel simple mais puissant appelé "Core". De plus, chaque partie du compilateur de langage Core est expliquée avec des exemples de code dans Miranda (un langage fonctionnel pur très similaire à Haskell).

Plusieurs types de compilateurs différents sont décrits, mais même si vous ne suivez que le soi-disant compilateur de modèles pour Core, vous aurez une excellente compréhension de ce qui fait la programmation fonctionnelle.

Vous pouvez utiliser BCEL par la Apache Software Foundation. Avec cet outil, vous pouvez générer du code de type assembleur, mais c'est Java avec l'API BCEL. Vous pouvez apprendre comment générer du code de langue intermédiaire (dans ce cas, du code d'octets).

Exemple simple

1. Créez une classe Java avec cette fonction:

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

Exécutez maintenant BCELifier avec cette classe

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

Vous pouvez voir le résultat sur la console pour toute la classe (comment construire le code octet MyClass.java). Le code de la fonction est le suivant:

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

Il y a beaucoup de bonnes réponses ici, alors j'ai pensé que j'en ajouterais une autre à la liste:

J'ai obtenu un livre intitulé Project Oberon il y a plus d'une décennie, qui contient du texte très bien écrit sur le compilateur. Le livre se démarque vraiment dans le sens où la source et les explications sont très pratiques et lisibles. Le texte complet (l'édition 2005) a été mis à disposition en pdf, vous pouvez donc le télécharger dès maintenant. Le compilateur est discuté au chapitre 12:

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

Niklaus Wirth, Jürg Gutknecht

(Le traitement n'est pas aussi étendu que son livre sur les compilateurs)

J'ai lu plusieurs livres sur les compilateurs, et je peux appuyer le livre du dragon, le temps consacré à ce livre en vaut la peine.

Jusqu'à présent, ce livre n'est pas inclus dans la liste:

Basics of Compiler Design (Torben Mogensen) (du département d'informatique, Université de Copenhague)

Je suis également intéressé à en apprendre davantage sur les compilateurs et j'ai l'intention d'entrer dans cette industrie au cours des deux prochaines années. Ce livre est le livre théorique idéal pour commencer à apprendre les compilateurs pour autant que je puisse voir. Il est GRATUIT de copier et de reproduire, écrit proprement et soigneusement et vous le donne en anglais simple sans code mais présente toujours la mécanique au moyen d'instructions et de diagrammes, etc. Vaut le coup d'oeil.