language agnostic - Apprendre à écrire un compilateur

Translate

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 suis plus familier avec C / C ++, Java et Ruby, donc je préfère les ressources qui impliquent l'un de ces trois, mais toute bonne ressource est acceptable.

This question and all comments follow the "Attribution Required."

Toutes les réponses

Translate

Grande liste de ressources:

Légende:

  • ¶ Lien vers un fichier PDF
  • $ Lien vers un livre imprimé
La source
Allen Lee
Translate

C'est une question assez vague, je pense; juste à cause de la profondeur du sujet concerné. 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 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 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 prendra donc votre programme source et le convertira en une autre représentation et effectuera une 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 étaientPrincipes 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 définitivement 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 assez peu intéressant, le livre intitulé "lex et yacc"a repris là où le Dragon Book s'était arrêté pour cette partie.

La source
Translate

je penseImplémentation moderne du compilateur dans MLest le meilleur compilateur d'introduction à l'écriture de texte. Il y a unVersion Javaet unVersion Caussi, qui pourraient être plus accessibles compte tenu de vos connaissances linguistiques. Le livre contient de nombreux éléments de base utiles (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, ramasse-miettes, optimisation et formulaire d'affectation statique unique) dans un espace relativement restreint (~ 500 pages).

Je préfère Modern Compiler Implementation au livre Dragon car l'implémentation de Modern Compiler étudie moins le domaine - au lieu de cela, il couvre vraiment 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 documents de recherche pour plus de profondeur si vous en avez besoin.

Je dois avouer que j'ai un sérieux faible pour Niklaus WirthConstruction du compilateur.Il estdisponible en ligneau format PDF. Je trouve l'esthétique de la programmation de Wirth simplement belle, mais certaines personnes trouvent son style trop minimal (par exemple, Wirth favorise les analyseurs de descente récursifs, mais la plupart des cours de CS se concentrent sur les outils générateurs d'analyseurs; les conceptions de langage de Wirth sont assez conservatrices.) des idées de base de Wirth, donc que vous aimiez son style ou non, je vous recommande vivement de lire ce livre.

La source
Brian Lee
Translate

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

Si vous voulez un livre plus léger sur la théorie,Maîtrise des scripts de jeupourrait être un meilleur livre pour vous. Si vous êtes un novice total en théorie du compilateur, cela fournit une introduction plus douce. Il ne couvre pas les méthodes d'analyse plus pratiques (opter 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 se compile en un bytecode 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 à bon marché sur Amazon. Si vous voulez seulement une introduction facile aux compilateurs, la maîtrise des scripts de jeu n'est pas une mauvaise solution. Si vous voulez devenir hardcore à l'avant, vous ne devriez vous contenter de rien de moins que le Dragon Book.

La source
RBz
Translate

"Construisons 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 consultezARGOT. Ceci est similaire à "Construisons un compilateur" mais c'est une bien meilleure ressource en particulier pour les débutants. Cela vient avec un tutoriel 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, ainsi que des interprètes en python et java, initialement écrits en C # et la plateforme .NET.

La source
Translate

Si vous cherchez à utiliser des outils puissants et de niveau supérieur plutôt que de créertoutvous-même, en parcourant les projets et les lectures pource coursest une très bonne option. C'est un cours de langues par l'auteur du moteur d'analyse Java ANTLR. Vous pouvez obtenir le livre du cours au format PDF à partir deles programmeurs pragmatiques.

Le cours passe en revue les éléments du compilateur standard que vous verriez ailleurs: analyse, types et vérification de type, polymorphisme, tables de symboles et génération de code. Les optimisations sont à peu près la seule chose qui n'est pas couverte. Le projet final est un programme quicompile un sous-ensemble de C. Parce que vous utilisez des outils comme ANTLR et LLVM, il est possible d'écrire le compilateur entier en un seul jour (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.

LLVM, au fait, est tout simplement fantastique. Dans de nombreuses situations où vous pourriez normalement compiler jusqu'à l'assemblage, vous feriez bien mieux de compiler versReprésentation intermédiaire de LLVMau lieu. C'est un niveau supérieur, multiplateforme, et LLVM est assez bon pour générer un assemblage optimisé à partir de celui-ci.

La source
Translate

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 qui explique les bases (y compris comment implémenter des lexers, des analyseurs de descente récursifs et vos propres machines virtuelles basées sur la pile). Après cela, si vous voulez une plongée approfondie, il n'y a aucun moyen de contourner le livre Dragon comme le suggèrent d'autres commentateurs.

La source
Elijah Lee
Translate

Vous voudrez peut-être regarder dans Lex / Yacc (ou Flex / Bison, comme vous voulez les appeler). Flex est un analyseur lexical, qui analysera et identifiera les composants sémantiques («tokens») de votre langage, et Bison sera utilisé pour définir ce qui se passe lorsque chaque token est analysé. Cela pourrait être, mais n'est certainement pas limité à, l'impression de code C, pour un compilateur qui compilerait en C, ou l'exécution dynamique des instructions.

Cette FAQdevrait vous aider, etce tutorielsemble assez utile.

La source
Zenobia Lee
Translate

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. Peut-être voulez-vous également commencer par 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 fonctionner. Cette étape est généralement appelée analyse et le logiciel qui analyse le code source est appelé un analyseur. Souvent, l'analyseur est généré par un générateur d'analyseurs qui transforme une grammaire formelle en code machine ou source. Pour une bonne explication non mathématique de l'analyse, je recommande les techniques d'analyse - un guide pratique. Wikipedia propose une comparaison des 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, vous trouverez des tutoriels sur Internet et pour les générateurs d'analyseurs très populaires (comme GNU bison), il existe également des livres.

Ecrire 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 ++); LISP en est un bon exemple.

Dans la deuxième étape, l'arbre de syntaxe abstraite est transformé d'une structure arborescente en une représentation linéaire intermédiaire. Un bon exemple du bytecode de cette 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 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 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 sont trop académiques ou trop pratiques. Il n'y a pas de "Apprenez à rédiger un compilateur en 21 jours" et vous devrez donc acheter plusieurs livres pour bien comprendre tout ce sujet. Si vous recherchez sur Internet, vous rencontrerez des livres en ligne et des notes de cours. Peut-être qu'il y a une bibliothèque universitaire à proximité 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 rendre votre projet sérieux. Un diplôme en informatique sera également utile.

La source
Deborah Lee
Translate

Un livre pas encore suggéré mais très important est"Linkers and Loaders"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 réinstallations et le fonctionnement de l'ensemble du processus de chargement du programme pour créer un outil de travail. Ce livre rassemble une grande partie de la tradition aléatoire autour de ce processus pour divers systèmes, y compris Win32 et Linux.

La source
Cliff Lee
Translate

Le livre du dragonest sans aucun doute le livre "Construire des compilateurs", mais si votre langage n'est pas aussi compliqué que la génération actuelle de langages, vous voudrez peut-être regarder le modèle Interpreter deModèles de conception.

L'exemple du livre conçoit un langage semblable à une expression régulière et est bien pensé, mais comme on dit dans le livre, c'est bon pour réfléchir au processus, mais il n'est vraiment efficace que sur les petites langues. Cependant, il est beaucoup plus rapide d'écrire un interpréteur 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 ...

La source
Esther Lee
Translate

Si vous souhaitez utiliser LLVM, vérifiez 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 flex une fois que vous avez l'idée. Ils rendent la vie tellement plus facile.

La source
Translate

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 leOberonlivre qui contient la source complète d'un compilateur Oberon incroyablement rapide et simpleProjet Oberon.

Alt text

La source
Translate

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

J'ai été très prudent lorsque j'ai demandé et, étonnamment, je n'ai pas reçu autant de critiques que vous en arrivez ici. Ils m'ont cependant orienté vers leLivre de dragon"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 langue ou deux. 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 d'un compilateur 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 Dragon Book, l'écriture n'est plus 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 un ou deux langages avant d'essayer d'écrire un compilateur. Ne vous attendez pas à être un gourou du compilateur dans la prochaine décennie.

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

La source
Translate

"... Construisons un compilateur ..."

Je secondehttp://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 juste 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.varLa beauté de Free Pascal est que vous pouvez l'utiliser presque n'importe quel processeur ou système d'exploitation dont vous pouvez vous occuper.

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

La source
Translate

Je regarde dans 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 allé

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

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 vise le .Net Framework, de nombreux concepts devraient pouvoir être reproduits. L'article couvre:

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

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

Il s'adresse aux débutants, écrit en C # (pas tout à fait Java)

HTH

des os

La source
Mike Lee
Translate

Un moyen simple 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 de code C étant l'étape la plus importante. En générant du code C, votre langage fonctionnera automatiquement sur toutes les plates-formes qui ont un compilateur C.

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

La source
Translate

DuFAQ sur comp.compilers:

"Programmer 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 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 étape par étape d'un compilateur Edison et d'un système d'exploitation simple de support, tous écrits en Edison lui-même (à l'exception d'un petit noyau de support écrit dans un assembleur symbolique pour PDP 11/23; le 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, autonome et utile, et 2) la discussion intéressante sur la conception du langage et les problèmes de spécification et le commerce. offs au chapitre 2.

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

Un autre livre sur la théorie légère et 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 p-code pour Pascal- (Pascal "moins"), un sous-ensemble Pascal avec des types booléens et entiers (mais pas de caractères, de réels, de types subrangé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, ensemble, pointeur, sans nom, renommés ou fichiers), expressions, instructions d'affectation, définitions de procédure imbriquées avec paramètres de valeur et de variable, instructions if, instructions while, et blocs de début-fin (mais pas de définitions de fonction, de paramètres de procédure, d'instructions et d'étiquettes goto, d'instructions case, d'instructions de répétition, d'instructions for et d'instructions with).

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 IBM PC est vendu par l'auteur, mais il est facile de porter le compilateur Pascal du livre sur n'importe quelle plate-forme Pascal pratique.

Ce livre simplifie la conception et l'implémentation 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 langage ou un projet de compilateur plus impliqué, surtout si vous êtes pressé de mettre rapidement quelque chose en marche.

La source
Adelaide Lee
Translate

Vous devriez vérifier Darius Bacon's "ichbins", qui est un compilateur pour un petit dialecte Lisp, ciblant C, en 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 aussi comprend un interprète pour amorcer la chose.)

Il y a plus de choses sur ce que j'ai trouvé utile pour apprendre à écrire un compilateur sur monUr-Schemepage Web.

La source
Translate

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

La source
mfx
Translate

Le compilateur LCC (Wikipédia) (page d'accueil du projet) 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.

La source
Archer Lee
Translate

Désolé, c'est en espagnol, mais c'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 du 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.

  • 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 (Espagne). 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 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
    Computing Science Technical Report Nº 32, 1975. Bell Laboratories. Murray Hill, Nouveau
    Jersey.

  • Lex: un générateur d'analyseur lexical.
    ME Lesk, E. Schmidt. Computing Science Technical Report No. 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. 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.

La source
Translate
  1. C'est un vaste sujet. Ne sous-estimez pas ce point. Et ne sous-estimez pas mon point de vue de ne pas le sous-estimer.
  2. J'entends leLivre de dragonest un (le?) endroit pour commencer, 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 à cela sont rares ettrèsloin entre.
La source
Translate

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 les métacompilateurs) ...

Tutoriel: Métacompilateurs Partie 1

Tout cela est basé sur un incroyable petit article 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 comprenez enfin comment le compilateur peut se régénérer ...

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

La source
Translate

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

J'ai eu un livre appelé Project Oberon il y a plus de dix ans, qui contient du texte très bien écrit sur le compilateur. Le livre se démarque vraiment en ce sens que la source et les explications sont très pratiques et lisibles. Le texte complet (l'édition 2005) est disponible en 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 é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 passé sur ce livre en vaut la peine.

La source
Jamie Lee
Translate

Si vous souhaitez écrire un compilateur pour un langage fonctionnel (plutôt qu'un langage procédural) de 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 du 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 motive la programmation fonctionnelle.

La source
Translate

Vous pouvez utiliserBCELpar l'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 un code de langue intermédiaire (dans ce cas, un 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 du code d'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();
}
La source
Translate

j'ai aimé leTutoriel Crenshawaussi, parce qu'il est absolument clair qu'un compilateur est juste un autre programme qui lit certaines entrées et en écrit d'autres.

Lis le.

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

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

La source
Borg Lee
Translate

Ce livre n'est pas inclus dans la liste pour l'instant:

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

Je suis également intéressé à en savoir plus sur les compilateurs et je prévois d'entrer dans cette industrie au cours des deux prochaines années. Ce livre est le livre de théorie idéal pour commencer à apprendre les compilateurs aussi loin que je peux voir. Il est GRATUIT de copier et de reproduire, proprement et soigneusement écrit et vous le donne en anglais simple sans aucun code mais présente toujours la mécanique au moyen d'instructions et de diagrammes, etc. Vaut le détour.

La source