Apprendre à écrire un compilateur

Langues préférées : 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 bien C / C ++, Java et Ruby, alors je préfère les ressources qui impliquent l’un de ces trois, mais toute bonne ressource est acceptable.

Grande liste de ressources:

  • Un cadre Nanopass pour la formation du compilateur ¶
  • Conception et implémentation avancées du compilateur $
  • Une approche progressive de la construction de compilateurs ¶
  • Tutoriel vidéo ANTLR 3.x
  • Bases de la conception du compilateur
  • Construire un compilateur Parrot
  • Principes de base du compilateur
  • Construction du compilateur $
  • Conception et construction du compilateur $
  • Créer un compilateur avec C $
  • Interprètes d’artisanat
  • Conception du compilateur en C ¶
  • Comstackrs: Principes, techniques et outils $ – alias “The Dragon Book” ; largement considéré comme “le livre” pour l’écriture du compilateur.
  • Ingénierie d’un compilateur $
  • Principes fondamentaux des langages de programmation
  • Flipcode Article Archive (recherchez “Implémenter un moteur de script par Jan Niestadt”)
  • Maîsortingse des scripts de jeux
  • Comment construire une machine virtuelle à partir de zéro en C # ¶
  • Implémentation de langages fonctionnels
  • Implémentation des langages de programmation (avec BNFC)
  • Implémenter des langages de programmation en utilisant C # 4.0
  • 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 de langage: Créez vos propres langages de programmation spécifiques et spécifiques à un domaine
  • Construisons un compilateur par Jack Crenshaw – La version PDF ¶ (des exemples sont en Pascal, mais les informations sont généralement applicables)
  • Linkers and Loaders $ (Google Livres)
  • Lisp in Small Pieces (LiSP) $
  • Tutoriel LLVM
  • Implémentation moderne du compilateur dans ML $ – Il existe également une version Java $ et C $ – largement considérée comme un très bon livre
  • Construction de compilateur orienté object
  • Techniques d’parsing syntaxique – Guide pratique
  • Projet Oberon ¶ – Regardez le chapitre 13
  • Programmation d’un ordinateur personnel $
  • Langages de programmation: Application et interprétation
  • Rabbit: un compilateur pour le schéma ¶
  • Réflexions sur la confiance en soi – Guide rapide
  • Roll Your Own Comstackr pour le framework .NET – Un tutoriel rapide à partir de MSDN
  • Structure et interprétation des programmes informatiques
  • Types et langages de programmation
  • Voulez-vous écrire un compilateur? – un guide rapide
  • Ecrire 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 à cause de la profondeur du sujet concerné. Un compilateur peut être décomposé en deux parties distinctes, cependant; une moitié supérieure et une inférieure. La moitié supérieure prend généralement la langue source et la convertit en une représentation intermédiaire, et la moitié inférieure prend en charge 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) est de construire le compilateur dans les deux pièces décrites ci-dessus. Plus précisément, vous obtiendrez une bonne idée de l’ensemble du processus en construisant la moitié supérieure.

Le simple fait de faire la moitié supérieure vous permet d’écrire l’parsingur lexical et l’parsingur et de générer un “code” (cette représentation intermédiaire que j’ai mentionnée). Donc, il faudra que votre programme source le convertisse en une autre représentation et fasse de l’optimisation (si vous voulez), qui est le coeur du compilateur. La moitié inférieure prendra alors cette représentation intermédiaire et générera les octets nécessaires à l’exécution du 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és particulièrement utiles étaient les Principes et techniques des compilateurs (ou le livre du dragon, en raison du dragon mignon sur la couverture). Il a une bonne théorie et couvre sans aucun doute des Grammars sans contexte. De plus, pour construire l’parsingur lexical et l’parsingur syntaxique, vous utiliserez probablement les outils * nix lex et yacc. Et ce qui est sans intérêt, le livre intitulé ” lex et yacc ” a été repris là où le livre de dragon s’était arrêté pour cette partie.

Je pense que l’implémentation du compilateur moderne dans ML est le meilleur texte d’introduction au compilateur d’introduction. Il existe également une version Java et une version C , chacune d’elles pouvant être plus accessible compte tenu de l’arrière-plan de votre langue. Le livre contient beaucoup de matériel de base utile (numérisation et parsing, parsing sémantique, enregistrements d’activation, sélection d’instructions, génération de code natif RISC et x86) et divers sujets «avancés» (compilation des langages fonctionnels et fonctionnels, polymorphism, formulaire d’affectation statique unique) dans un espace relativement restreint (~ 500 pages).

Je préfère l’implémentation du compilateur moderne au livre Dragon, car l’implémentation du compilateur moderne étudie moins le sujet – au lieu de cela, il couvre vraiment tous les sujets dont vous avez besoin pour écrire un compilateur sérieux et décent. Après avoir parcouru ce livre, vous serez prêt à aborder directement les documents de recherche pour obtenir plus de détails si vous en avez besoin.

Je dois avouer que j’ai un sérieux faible pour Comstackr Construction de Niklaus Wirth . Il est disponible en ligne au format PDF. Je trouve que l’esthétique de la programmation de Wirth est tout simplement magnifique, mais certaines personnes trouvent son style trop minimal (par exemple, Wirth favorise les parsingurs récursifs, mais la plupart des cours de CS sont plutôt conservateurs). des idées de base de Wirth, alors que vous aimiez son style ou non, je vous recommande fortement de lire ce livre.

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

Si vous voulez un livre plus léger sur la théorie, Game 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’parsing plus pratiques (optant pour une descente récursive non prédictive sans discuter de l’parsing LL ou LR) et, si je me souviens bien, il ne discute même pas de la théorie de l’optimisation. De plus, au lieu de comstackr en code machine, il comstack 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 prendre pour pas cher sur Amazon. Si vous voulez seulement une introduction facile aux compilateurs, la maîsortingse des scripts de jeu n’est pas une mauvaise solution. Si vous voulez aller hardcore, vous devriez vous contenter du Dragon Book.

“Construisons un compilateur” est génial, mais c’est un peu dépassé. (Je ne dis pas que cela rend encore un peu moins valide.)

Ou consultez SLANG . Ceci est similaire à “Construisons un compilateur” mais est une ressource bien meilleure pour les débutants. Cela vient avec un tutoriel pdf qui prend une approche en 7 étapes pour vous apprendre un compilateur. L’ajout du lien quora a les liens vers tous les différents ports de SLANG, en C ++, Java et JS, ainsi que des interpréteurs en python et java, écrits à l’origine en utilisant C # et la plate-forme .NET.

Si vous souhaitez utiliser des outils puissants de haut niveau plutôt que de tout construire vous-même, passer en revue les projets et les lectures de ce cours est une bonne option. C’est un cours de langues par l’auteur du moteur d’parsing syntaxique Java ANTLR. Vous pouvez obtenir le livre pour le cours en format PDF auprès des programmeurs Pragmatic .

Le cours passe en revue le compilateur standard que vous voyez ailleurs: parsing, types et vérification de type, polymorphism, tables de symboles et génération de code. La seule chose qui ne soit pas couverte est l’optimisation. Le projet final est un programme qui comstack un sous-ensemble de C. Comme vous utilisez des outils comme ANTLR et LLVM, il est possible d’écrire le compilateur complet en une seule journée (j’en ai une preuve d’existence, bien que je parle d’environ 24 heures). Il est lourd d’ingénierie pratique en utilisant des outils modernes, un peu plus légers en théorie.

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

Si vous avez peu de temps, je vous recommande “Comstackr Construction” (Addison-Wesley. 1996) de Niklaus Wirth , un petit livret que vous pouvez lire en une journée, mais qui explique les bases (comment implémenter les lexers, parsingurs récursifs, et vos propres machines virtuelles basées sur des stacks). Après cela, si vous voulez une plongée en profondeur, il n’y a aucun moyen de contourner le livre Dragon, comme le suggèrent les autres commentateurs.

Vous voudrez peut-être examiner Lex / Yacc (ou Flex / Bison, peu importe comment vous voulez les appeler). Flex est un parsingur lexical, qui parsingra et identifiera les composants sémantiques (“jetons”) de votre langue, et Bison servira à définir ce qui se passe lorsque chaque jeton est analysé. Cela pourrait être, mais n’est certainement pas limité à, l’impression du code C, pour un compilateur qui comstackrait en C, ou exécuter dynamicment les instructions.

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

D’une 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 voulez 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 comstackr ou interpréter en fonction de la grammaire en un arbre de syntaxe abstrait, une forme interne du code source que l’ordinateur comprend et peut utiliser. Cette étape est généralement appelée parsing et le logiciel qui parsing le code source est appelé un parsingur. Souvent, l’parsingur est généré par un générateur d’parsingur qui transforme une grammaire formelle en code source ou en code machine. Pour une bonne explication non mathématique de l’parsing, je recommande des techniques d’parsing – un guide pratique. Wikipedia a une comparaison des générateurs d’parsingurs à partir desquels vous pouvez choisir celui qui vous convient. En fonction du générateur d’parsingurs choisi, vous trouverez des didacticiels sur Internet et pour les générateurs d’parsings très populaires (comme GNU bison), il existe également des livres.

Ecrire un parsingur 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 au C ++); un bon exemple est le LISP.

Dans la deuxième étape, l’arbre syntaxique abstrait est transformé d’une structure arborescente en une représentation intermédiaire linéaire. Comme bon exemple, le bytecode de Lua est souvent cité. Mais la représentation intermédiaire dépend vraiment de votre langue.

Si vous construisez un interprète, vous devrez simplement interpréter la représentation intermédiaire. Vous pouvez aussi le comstackr en un rien de temps. Je recommande LLVM et libjit pour la 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 comstackr le langage, ce sera plus compliqué. Vous devrez écrire des backends pour différentes architectures d’ordinateur 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 y a quelques livres sur ce sujet, mais je ne peux en recommander aucun pour un usage général. La plupart d’entre eux sont trop académiques ou trop pratiques. Il n’y a pas de “Apprendre à écrire le compilateur en 21 jours” et vous devrez donc acheter plusieurs livres pour bien comprendre ce sujet. Si vous effectuez une recherche sur Internet, vous rencontrerez des livres en ligne et des notes de cours. Peut-être y a-t-il une bibliothèque universitaire à proximité de chez vous où vous pouvez emprunter des livres sur les compilateurs.

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

Regardez le livre ci-dessous. L’auteur est le créateur d’ ANTLR .

Modèles d’implémentation de langage: Créez vos propres langages de programmation spécifiques à un domaine et généraux .

texte alt

Un livre pas encore suggéré mais très important est “Linkers and Loaders” de John Levine. Si vous n’utilisez pas un assembleur externe, vous aurez besoin d’un moyen de générer un fichier object pouvant être lié à votre programme final. Même si vous utilisez un assembleur externe, vous devrez probablement comprendre les déplacements et comment le processus de chargement de l’ensemble du programme fonctionne pour créer un outil de travail. Ce livre rassemble une grande partie des connaissances aléatoires entourant ce processus pour divers systèmes, y compris Win32 et Linux.

Le Dragon Book est certainement le livre “compilateurs de construction”, mais si votre langage n’est pas aussi compliqué que la génération actuelle des langages, vous voudrez peut-être examiner le motif d’interpréteur des motifs de conception .

L’exemple dans le livre conçoit un langage d’expression semblable à une expression et est bien pensé, mais comme on dit dans le livre, il est bon pour réfléchir tout au long du processus, mais il n’est efficace que pour 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 à en apprendre davantage sur les différents types d’parsingurs, yacc et lex, et cetera …

Si vous souhaitez utiliser LLVM, consultez ceci: http://llvm.org/docs/tutorial/ . Il vous apprend à écrire un compilateur à partir de rien en utilisant la structure de LLVM et ne présume pas que vous avez des connaissances sur le sujet.

Le tutoriel vous propose d’écrire votre propre parsingur syntaxique, lexer, etc., mais je vous conseille de regarder le bison et de le fléchir une fois que vous avez compris l’idée. Ils rendent la vie beaucoup plus facile.

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

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

Alt text

Je me penche sur le même concept et a trouvé cet article prometteur de Joel Pobar,

Créer un compilateur de langage pour le .NET Framework

Il discute d’un concept de haut niveau d’un compilateur et invente sa propre langue pour le framework .Net. Bien que visant le framework .Net, de nombreux concepts devraient pouvoir être reproduits. L’article couvre:

  1. Définition de Langauge
  2. Scanner
  3. Parser (le bit im principalement intéressé)
  4. Cibler le cadre .Net
  5. Générateur de code

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

Son destiné aux personnes débutant, écrit en C # (pas tout à fait Java)

HTH

des os

“… Construisons un compilateur …”

Je serais deuxième http://comstackrs.iecc.com/crenshaw/ par @sasb . Oubliez d’acheter plus de livres pour le moment.

Pourquoi? Outils et langue

Le langage requirejs est Pascal et si je me souviens bien est basé sur Turbo-Pascal. Il se trouve que si vous allez sur http://www.freepascal.org/ et téléchargez le compilateur Pascal, tous les exemples fonctionnent directement depuis la page ~ http://www.freepascal.org/download.var Pascal est que vous pouvez l’utiliser presque n’importe quel processeur ou système d’exploitation dont vous avez besoin.

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

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 quand j’ai demandé et étonnamment je n’ai pas reçu autant de critiques que vous obtenez ici. Ils m’ont cependant orienté dans la direction du ” Dragon Book ” qui, à mon avis, est un très bon livre qui explique tout ce que vous devez savoir pour écrire un compilateur (vous devrez bien sûr maîsortingser un langage ou deux. les 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 pas du tout d’accord avec cela.

Beaucoup de gens disent aussi que l’écriture de compilateurs est stupide et inutile. Eh bien, il y a un certain nombre de raisons pour lesquelles le développement du compilateur est utile: – Parce que c’est amusant. – C’est pédagogique, lorsque vous apprendrez à rédiger des compilateurs, vous en apprendrez beaucoup sur l’informatique et sur d’autres techniques utiles pour écrire d’autres applications. – Si personne n’a écrit de compilateurs, les langues existantes ne seraient pas meilleures.

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 beaucoup de langues différentes et lu le Dragon Book, écrire n’est pas vraiment un problème. (J’étudie également le génie informatique, mais la plupart de mes connaissances en programmation sont autodidactes.)

En conclusion: – Le Dragon Book est un excellent “tutoriel”. Mais passez du temps à maîsortingser un langage 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 parsingurs / interprètes.

Un moyen facile de créer un compilateur est d’utiliser bison et flex (ou similaire), de construire un arbre (AST) et de générer du code en C. La génération du code C étant l’étape la plus importante. En générant du code C, votre langage fonctionnera automatiquement sur toutes les plates-formes dotées d’un compilateur C.

Générer du code C est aussi simple que de générer du code HTML (utilisez simplement print ou équivalent), ce qui est beaucoup plus facile que d’écrire un parsingur C ou un parsingur HTML.

A partir de la FAQ comp.comstackrs :

“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 de l’implémentation pas à pas d’un compilateur Edison et d’un système d’exploitation simple, tous écrits en Edison lui-même (à l’exception d’un petit kernel compatible écrit dans un assembleur symbolique pour PDP 11/23). source complète peut également être commandé pour le PC IBM).

Les aspects les plus intéressants de ce livre sont: 1) sa capacité à démontrer comment créer un système de compilation et d’exploitation complet, autonome et autonome, et 2) la discussion intéressante des problèmes de conception et de spécification du langage et des échanges commerciaux. offs au chapitre 2.

“Brinch Hansen sur Pascal Comstackrs” de Per Brinch Hansen Prentice-Hall 1985 ISBN 0-13-083098-4

Un autre livre léger sur la théorie pragmatique est disponible ici. L’auteur présente la conception, l’implémentation et le code source complet pour un compilateur et un interpréteur de p-code pour Pascal- (Pascal “moins”), un sous-ensemble Pascal avec des types booléens et entiers (mais pas de caractères, réels, , définitions de constantes et de variables et types de tableau et d’enregistrement (mais pas de type compressé, variante, ensemble, pointeur, sans nom, renommé ou fichier), expressions, instructions d’assignation, définitions de procédures nestedes avec parameters value et variable, instructions if et les blocs de début et de fin (mais pas de définitions de fonction, de parameters de procédure, d’instructions et d’étiquettes de type goto, de déclarations de cas, d’instructions de répétition, d’instructions et d’instructions).

Le compilateur et l’interpréteur sont écrits en Pascal * (Pascal “star”), un sous-ensemble Pascal étendu avec des fonctionnalités de type Edison pour la création de 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 plate-forme Pascal.

Ce livre facilite la conception et la mise en œuvre d’un compilateur. J’aime particulièrement la manière dont l’auteur s’intéresse à la qualité, à la fiabilité et aux tests. Le compilateur et l’interpréteur peuvent facilement servir de base à un projet de langage ou de compilateur plus complexe, surtout si vous êtes pressé de mettre rapidement en place quelque chose.

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 de jouets est que le langage est suffisamment complet pour que le compilateur y soit écrit. (L’archive contient également un interpréteur pour amorcer la chose).

Il y a plus de choses à propos de ce que j’ai trouvé utile en apprenant à écrire un compilateur sur ma page Web Ur-Scheme .

Python est livré avec un compilateur python écrit en Python. Vous pouvez voir le code source, et il comprend toutes les phases, depuis l’parsing, l’arborescence de syntaxe abstraite, le code émetteur, etc.

Le compilateur LCC ( wikipedia ) ( page d’accueil du projet ) de Fraser et Hanson est décrit dans son livre “Un compilateur C reciable: conception et implémentation”. Il est assez lisible et explique tout le compilateur, jusqu’à la génération du code.

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 compilateur simple:

  • Comstackrs Design in C.
    Allen I. Holub

    Prentice Hall. 1990.

  • Compiladores. Teoría y Construcción.
    Sanchís Llorca, FJ, Galán Pascual, C. Éditorial 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 Martinez Fernández, Daniel Borrajo Millán. Addison-Wesley Iberoamericana (España). 1997.

  • L’art de la conception du compilateur. Théorie et pratique.
    Thomas Pittman, James Peters.

    Prentice Hall. 1992.

  • Construction du compilateur orienté object.
    Jim Holmes.
    Prentice Hall, Englewood Cliffs, New Jersey 1995

  • Compiladores Conceptos Fundamentales.
    B. Teufel, S. Schmidt, T. Teufel.

    Addison-Wesley Iberoamericana. 1995.

  • Introduction à la théorie des automates, aux langues et au calcul.

    John E. Hopcroft. Jeffref D. Ullman.
    Addison-Wesley. 1979.

  • Introduction aux langages formels.
    György E. Révész.

    Mc Graw Hill. 1983.

  • Techniques d’parsing 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
    Computing Science Technical Report Nº 32, 1975. Laboratoires Bell. Murray Hill, Nouveau
    Jersey.

  • Lex: Un générateur d’parsingur lexical.
    ME Lesk, E. Schmidt. Computing Science Technical Report Nº 39, 1975. Bell Laboratories. Murray Hill, New Jersey.

  • lex et 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. Papadimisortingou. Segunda Edición. Prentice Hall. 1998.

  • Un Algoritmo Eficiente pour la Construction de Graff de Dépendance.
    Salvador V. Cavadini.
    Trabajo Final de Grado pour obtenir le titre d’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) … Ce site vous guide à travers la construction d’un système de compilation complètement autonome pouvant comstackr lui-même et d’autres langages:

Tutoriel: Metacomstackrs Part 1

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

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

de l’honnête au dieu 1964. J’ai appris à construire des compilateurs à partir de ce moment en 1970. Il y a un moment époustouflant où vous finissez par comprendre comment le compilateur peut se régénérer ….

Je connais l’auteur du site depuis mes années de collège, mais je n’ai rien à voir avec le site.

Il y a beaucoup de bonnes réponses ici, alors j’ai pensé append un autre à la liste:

Il y a plus de dix ans, j’ai reçu un livre intitulé Project Oberon, qui contient des textes très bien écrits 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 (é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-old.oberon.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 seconder le livre des dragons, le temps passé sur ce livre en vaut la peine.

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émenter les 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 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 functional programming.

  1. C’est un vaste sujet. Ne sous-estimez pas ce point. Et ne sous-estimez pas mon sharepoint ne pas le sous-estimer.
  2. J’entends le livre de dragon est un (le?) Lieu pour commencer, avec la recherche. 🙂 Améliorez votre recherche, finalement ce sera 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.

J’ai aussi aimé le didacticiel de Crenshaw , car il est clair qu’un compilateur est un autre programme qui lit des entrées et en écrit des extraits.

Lis le.

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

And read On Trusting Trust , to get a clue about the unobvious things that can be done in this domain.

You can use BCEL by the Apache Software Foundation. With this tool you can generate assembler-like code, but it’s Java with the BCEL API. You can learn how you can generate intermediate language code (in this case byte code).

Simple example

  1. Create a Java class with this function:

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

Now run BCELifier with this class

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

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

 private void createMethod_1() { InstructionList il = new InstructionList(); MethodGen method = new MethodGen(ACC_PUBLIC, Type.STRING, new Type[] { Type.INT, Type.INT }, new Ssortingng[] { "arg0", "arg1" }, "maxAsSsortingng", "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", "toSsortingng", 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(); } 

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