Apprendre à écrire un compilateur [fermé]

StackOverflow https://stackoverflow.com/questions/1669

Question

Langues préférées:C/C++, Java et Ruby.

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

Était-ce utile?

La solution

Grande liste de ressources :

Légende:

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

Autres conseils

C'est une question assez vague, je pense ;juste à cause de la profondeur du sujet abordé.Un compilateur peut cependant être décomposé en deux parties distinctes ;une moitié supérieure et une moitié 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 aborder facilement ce sujet (au moins celle que nous avons utilisée dans ma classe de compilateurs) consiste à construire le compilateur en deux parties 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.

Le simple fait de faire la moitié supérieure vous permet d'acquérir l'expérience de l'écriture de l'analyseur lexical et de l'analyseur et de générer du "code" (cette représentation intermédiaire que j'ai mentionnée).Il faudra donc que votre programme source le convertisse en une autre représentation et effectue une certaine optimisation (si vous le souhaitez), ce 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és particulièrement utiles étaient Principes et techniques des compilateurs (ou le Dragon Book, à cause du joli dragon sur la couverture).Il contient une excellente théorie et couvre définitivement les grammaires sans contexte d'une manière vraiment accessible.De plus, pour créer l'analyseur et l'analyseur lexical, vous utiliserez probablement les outils * nix lex et yacc.Et ce qui est assez inintéressant, c'est que le livre s'intitule "Lex et Yacc" a repris là où le Dragon Book s'était arrêté pour cette partie.

Je pense Implémentation du compilateur moderne en ML est le meilleur compilateur d'introduction pour écrire du texte.Il y a un Version Java et un version C également, l’un ou l’autre pourrait être plus accessible compte tenu de vos connaissances linguistiques.Le livre contient de nombreux documents de base utiles (analyse 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 de langages OO et fonctionnels, polymorphisme, garbage collection, optimisation et formulaire d'affectation statique unique) dans un espace relativement réduit (~ 500 pages).

Je préfère Modern Compiler Implementation au livre Dragon, car la mise en œuvre de Modern Compiler couvre moins le domaine - au lieu de cela, elle couvre très bien 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 directement les articles de recherche pour plus de profondeur si vous en avez besoin.

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

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

Si vous voulez un livre plus léger en théorie, Maîtrise des scripts de jeu pourrait être un meilleur livre pour vous.Si vous êtes totalement novice en théorie des compilateurs, cela constitue une introduction plus douce.Il ne couvre pas les méthodes d'analyse plus pratiques (en 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 discute même d'aucune sorte de théorie d'optimisation.De plus, au lieu de compiler en code machine, il compile en un bytecode censé s'exécuter sur une VM que vous écrivez également.

C'est toujours une lecture décente, surtout si vous pouvez l'acheter à bas prix sur Amazon.Si vous souhaitez uniquement une introduction facile aux compilateurs, la maîtrise des scripts de jeu n'est pas une mauvaise voie à suivre.Si vous voulez vous lancer dans le hardcore dès le départ, vous ne devriez vous contenter de rien de moins que le Dragon Book.

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

Ou consultez ARGOT.Ceci est similaire à « Construisons un compilateur » mais constitue une bien meilleure ressource, en particulier pour les débutants.Ceci est livré avec un didacticiel PDF qui adopte une approche en 7 étapes pour vous apprendre un compilateur.Ajout du lien quora car il contient les liens vers tous les différents ports de SLANG, en C++, Java et JS, également des interpréteurs en python et java, écrits à l'origine en C# et la plateforme .NET.

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

Le cours passe en revue les éléments 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 environ 24 heures).Il est riche en ingénierie pratique utilisant des outils modernes, un peu plus léger en théorie.

Au fait, LLVM est tout simplement fantastique.Dans de nombreuses situations où vous pourriez normalement compiler en assembleur, vous feriez bien mieux de compiler en Représentation intermédiaire du LLVM plutôt.Il s'agit d'un niveau supérieur, multiplateforme, et LLVM est assez efficace pour générer un assemblage optimisé à partir de celui-ci.

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

Vous voudrez peut-être vous pencher sur Lex/Yacc (ou Flex/Bison, peu importe comment vous voulez les appeler).Flex est un analyseur lexical, qui analysera et identifiera les composants sémantiques (« jetons ») de votre langue, 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 de code C, pour un compilateur qui compilerait en C, ou l'exécution dynamique des instructions.

Cette FAQ devrait vous aider, et ce tutoriel ça a l'air bien utile.

D'une manière générale, il n'existe pas de didacticiel de cinq minutes pour les compilateurs, car c'est un sujet complexe 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.Peut-être voudriez-vous également commencer avec un interprète.C'est généralement plus facile.

La première étape consiste à rédiger 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 un arbre syntaxique abstrait, 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 source ou code machine.Pour une bonne explication non mathématique de l'analyse, je recommande Parsing Techniques - A Practical Guide.Wikipedia propose une comparaison de générateurs d'analyseurs parmi lesquels vous pouvez choisir celui qui vous convient.En fonction du générateur d'analyseur que vous avez choisi, vous trouverez des tutoriels sur Internet et pour les générateurs d'analyseur très populaires (comme GNU bison), il existe également des livres.

É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 au C++) ;un bon exemple est 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éteur, vous devrez simplement 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 comptez compiler le langage, 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 un usage général.La plupart d’entre eux sont trop académiques ou trop pratiques.Il n'y a pas de "Apprenez-vous à écrire un compilateur en 21 jours" et vous devrez donc acheter plusieurs livres pour bien comprendre tout ce sujet.Si vous effectuez une recherche sur Internet, vous tomberez sur des livres et des notes de cours en ligne.Il y a peut-être une bibliothèque universitaire à proximité où vous pourrez 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 rendre votre projet sérieux.Un diplôme en informatique sera également utile.

Un livre pas encore suggéré mais très important est "Linkeurs et chargeurs" par John Levine.Si vous n'utilisez pas d'assembleur externe, vous aurez besoin d'un moyen de générer un fichier objet pouvant être lié à votre programme final.Même si vous utilisez un assembleur externe, vous devrez probablement comprendre les relocalisations et le fonctionnement de l'ensemble du processus de chargement du programme pour créer un outil fonctionnel.Ce livre rassemble une grande partie des connaissances aléatoires autour de ce processus pour divers systèmes, notamment Win32 et Linux.

Le livre des dragons est certainement le livre "construire des compilateurs", mais si votre langage n'est pas aussi compliqué que la génération actuelle de langages, vous souhaiterez peut-être consulter le modèle Interpreter de Modèles de conception.

L'exemple du livre conçoit un langage de type expression régulière et est bien pensé, mais comme on le dit dans le livre, c'est bon pour réfléchir au processus mais n'est efficace que sur les petits langages.Cependant, il est beaucoup plus rapide d'écrire un interprète pour un petit langage avec ce modèle que d'avoir à se renseigner sur tous les différents types d'analyseurs, 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 zéro en utilisant le framework LLVM et ne suppose pas que vous ayez des connaissances sur le sujet.

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

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

j'ajouterais le Obéron livre qui contient les sources complètes d'un compilateur Oberon incroyablement rapide et simple Projet Obéron.

Alt text

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

J'ai été très prudent lorsque j'ai posé la question et, étonnamment, je n'ai pas reçu autant de critiques que vous recevez ici.Ils m'ont cependant indiqué la direction du "Livre des dragons" qui est à mon avis un très bon livre qui explique tout ce qu'il faut savoir pour écrire un compilateur (il faudra bien sûr maîtriser un ou deux langages.Plus vous connaissez de langues, plus on est de fous.).

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 qu’écrire des compilateurs est stupide et inutile.Eh bien, il y a un certain nombre de raisons pour lesquelles le développement de compilateurs est utile :

  • Parce que c'est drôle.
  • C'est éducatif, en apprenant à é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 langages existants 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 Livre du Dragon, écrire 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 prenez le temps de maîtriser un ou deux langages avant de tenter d’écrire un compilateur.Ne vous attendez pas à devenir un gourou du compilateur au cours de la prochaine décennie.

Le livre est également utile si vous souhaitez 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 langage.

Le langage requis est Pascal et si je me souviens bien, il est basé sur Turbo-Pascal.Cela arrive si vous allez à 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 La beauté de Free 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îtrisé les leçons, essayez les cours les plus avancés. "Livre des dragons" ~ http://en.wikipedia.org/wiki/Dragon_book

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

Créer un compilateur de langage pour le .NET Framework - je ne sais pas où cela est passé

Créer un compilateur de langage pour le .NET Framework - copie pdf du document original

il discute d'un concept de haut niveau de compilateur et invente son propre langage pour le framework .Net.Bien qu'il soit destiné au .Net Framework, de nombreux concepts devraient pouvoir être reproduits.L'article couvre :

  1. Langage définition
  2. Scanner
  3. Analyseur (le bit qui m'intéresse principalement)
  4. Cibler le .Net Framework
  5. Générateur de code

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

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

HTH

os

Un moyen simple de créer un compilateur consiste à utiliser bison et flex (ou similaire), à ​​créer une arborescence (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.

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

Du FAQ comp.compilers:

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

Ce livre malheureusement titré explique la conception et la création d'un environnement de programmation à utilisateur unique pour 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 étape par étape d'un compilateur Edison et 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;La source complète peut également être commandée pour le PC IBM).

Les choses les plus intéressantes dans ce livre sont :1) sa capacité à démontrer comment créer un compilateur et un système d'exploitation complet, autonome, autonome, utile, et 2) la discussion intéressante des problèmes et compromis de conception et de spécification des langues au chapitre 2.

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

Une autre lumière sur la théorie lourde sur pragmatique ici-comment-code-it.L'auteur présente la conception, la mise en œuvre et le code source complet pour un compilateur et un interprète de code P pour Pascal- (Pascal "moins"), un sous-ensemble Pascal avec des types booléens et entiers (mais pas de caractères, de types réels, sous-générés ou énumérés) , des définitions constantes et variables et des types de tableau et d'enregistrement (mais pas de types emballés, variants, ensembles, pointeurs, sans nom, renommés ou de types de fichiers), des expressions, des instructions d'attribution, des définitions de procédure imbriquées avec des paramètres de valeur et de variable, IF Instructions, tandis que les déclarations, et les blocs de début (mais pas de définitions de fonction, des paramètres de procédure, des instructions et des étiquettes GOTO, des instructions de cas, des instructions de répétition, des instructions et avec des instructions).

Le compilateur et l'interprète sont écrits dans Pascal * (Pascal "Star"), un sous-ensemble Pascal étendu avec certaines fonctionnalités de style Edison pour créer des systèmes de développement de logiciels.Un compilateur Pascal * pour le PC IBM est vendu par l'auteur, mais il est facile de porter le compilateur Pascal du livre à n'importe quelle plate-forme Pascal pratique.

Ce livre rend la conception et la mise en œuvre d'un compilateur faciles.J'aime particulièrement la façon dont l'auteur est préoccupé par la qualité, la fiabilité et les tests.Le compilateur et l'interprète peuvent facilement être utilisés comme base pour un projet de langue ou de compilateur plus impliqué, surtout si vous êtes pressé de faire fonctionner rapidement quelque chose.

Vous devriez consulter " de Darius Bacon.ichbins", qui est un compilateur pour un petit dialecte Lisp, ciblant le C, en un peu plus de 6 pages de code.L'avantage qu'il présente par rapport à la plupart des compilateurs de jouets est que le langage est suffisamment complet pour que le compilateur y soit écrit.(L'archive tar comprend également un interpréteur pour amorcer la chose.)

Il y a plus de choses sur ce que j'ai trouvé utile pour apprendre à écrire un compilateur sur mon Ur-Schéma page web.

Python est fourni avec un compilateur Python écrit en Python.Vous pouvez voir le code source et il inclut toutes les phases, depuis l'analyse, l'arbre de syntaxe abstraite, l'émission de code, etc.Piratez-le.

Le compilateur LCC (Wikipédia) (page d'accueil du projet) de Fraser et Hanson est décrit dans leur livre "A Retargetable C Compiler :Conception et mise en œuvre".Il est assez lisible et explique l'ensemble du compilateur, jusqu'à la génération de code.

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

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

  • Conception de compilateurs en C.
    Allen I.Holub

    Prentice Hall.1990.

  • Compilateurs.Théorie et construction.
    Sanchís Llorca, FJ, Galán Pascual, C.Éditorial Paraninfo.1988.

  • Construction du compilateur.
    Nicolas Wirth

    Addison-Wesley.1996.

  • Langues, grammaires et automatas.Une étude pratique.
    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 d'un compilateur orienté objet.
    Jim Holmes.
    Prentice Hall, Englewood Cliffs, NJ1995

  • Compilateurs.Concepts fondamentaux.
    B.Teufel, S.Schmidt, T.Teufel.

    Addison-Wesley Ibéro-américain.1995.

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

    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'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 de la science de l'informatique Nº 32, 1975.Bell Laboratories.Murray Hill, Nouveau
    Jersey.

  • Lex :Un générateur d'analyseur lexical.
    M.E.Lesk, E.Schmidt.Rapport technique de la science de l'informatique Nº 39, 1975.Laboratoires Bell.Murray Hill, New Jersey.

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

  • Éléments de théorie du calcul.
    Harry R.Lewis, Christos H.Papadimitriou.Deuxième édition.Prentice Hall.1998.

  • Un algorithme efficace pour la construction du graphique de dépendance de contrôle.
    Salvador V.Cavadini.
    Travail final de grade pour obtenir le titre d'ingénieur en informatique.
    Faculté de Mathématiques Appliquées.U.C.S.E.2001.

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

Pas un livre, mais un article technique et une expérience d'apprentissage extrêmement amusante si vous voulez en savoir plus sur les compilateurs (et métacompilateurs)...Ce site Web vous guide dans la création d'un système de compilation entièrement autonome, capable de se compiler lui-même et d'autres langages :

Didacticiel:Métacompilateurs, partie 1

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

Val Schorré MÉTA II :Un langage d'écriture de compilateur orienté syntaxe

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

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

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

J'ai reçu un livre intitulé Project Oberon il y a plus de dix ans, 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 (l'édition 2005) est disponible en format PDF, vous pouvez donc le télécharger dès maintenant.Le compilateur est abordé au chapitre 12 :

http://www-old.oberon.ethz.ch/WirthPubl/ProjectOberon.pdf

Niklaus Wirth, Jürg Gutknecht

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

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

Si vous êtes intéressé à écrire un compilateur pour un langage fonctionnel (plutôt que procédural), suivez "Implémentation de 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 du langage Core est expliquée avec des exemples de code dans Miranda (un langage fonctionnel pur très similaire à Haskell).

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

j'ai aimé le Tutoriel Crenshaw aussi, car cela montre absolument clairement qu'un compilateur n'est qu'un autre programme qui lit certaines entrées et écrit certaines sorties.

Lis le.

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

Et lis Sur la confiance, pour avoir une idée des choses non évidentes qui peuvent être faites dans ce domaine.

Vous pouvez utiliser BCEL par la Fondation Apache Software.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 octet).

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 créer le byte code 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();
}

Ce livre n'est pas inclus dans la liste jusqu'à présent :

Bases de la conception de compilateurs (Torben Mogensen)(du département.d'informatique, Université de Copenhague)

Je souhaite également en savoir plus sur les compilateurs et je prévois de me lancer dans cette industrie au cours des prochaines années.Ce livre est, à ma connaissance, le livre théorique idéal pour commencer à apprendre les compilateurs.Il est GRATUIT de copier et de reproduire, écrit proprement et soigneusement et vous le donne dans un anglais simple sans aucun code, mais présente toujours la mécanique au moyen d'instructions et de diagrammes, etc.Ça vaut le coup d'oeil à mon avis.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top