Apprendre à écrire un compilateur [fermé]


699

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

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


ANTLR jusqu'au bout. Toutes les ressources proposées ci-dessous me semblent exagérées. ANTLR est toujours le meilleur ami des concepteurs de compilateurs. A
A_Var

Si votre objectif principal est d'apprendre comment la compilation des idées fonctionne en général - vous pouvez vérifier et SICP abréviation de Structured Interpretation of Computer program based in Scheme (List) mais enseigne les principes généraux. mitpress.mit.edu/sicp . On m'a recommandé ce livre par un vétéran qui travaille pour une entreprise et fait la compilation et l'interprétation de ces œuvres pour vivre!
Nishant

Un plug sans vergogne: ma réponse à une question similaire .
9000

J'ai écrit un article sur la création d'un compilateur sur mon blog: orangejuiceliberationfront.com/how-to-write-a-compiler Il se concentre sur les bases et le démarrage, vraiment. Il y a un tas d'autres articles liés à la conception du compilateur / codegen / parser / langage.
uliwitness

Réponses:


1084

Grande liste de ressources:

Légende:

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

22
J'ai lu la série Let's Build a Compiler[ compilers.iecc.com/crenshaw/] , c'est vraiment un bon résumé et c'est un bon point de départ.
TheVillageIdiot

5
Je pense que le cours des compilateurs de Coursera mérite d'être mentionné. Il a de belles vidéos et des promenades à travers la création d'un compilateur langage / simple java. Coursera Compilers Link
QuantumKarl

1
Je voulais que cette réponse soit aussi originale que possible, j'ai donc décidé de publier cette référence ici: tutorialspoint.com/compiler_design/index.htm Ce que j'ai aimé de ce site, c'est qu'il ne s'implique pas dans l'écriture de code pour créer un compilateur, mais il décompose le compilateur en ses parties: phases et étapes. Il décrit l'approche de conception logique et algorithmique sans paradigme linguistique spécifique car il exprime les notations d'un langage et d'un alphabet arbitraires. C'est une lecture rapide, mais vous donne les concepts de ce qui est nécessaire pour chaque partie.
Francis Cugler

70

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

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

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

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


55

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

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

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


Construction du compilateur PDF ethoberon.ethz.ch/WirthPubl/CBEAll.pdf
matepal297

Je recommande fortement contre la version C de « Mise en œuvre moderne du compilateur », il est estropié par des détails de bas niveau à C. Il Clutter complètement le livre. Java 1st n'est pas trop bon car sa conception OO est médiocre, Java 2nd ed ne concerne plus le langage Tiger. Je recommande donc fortement le ML: il n'est pas nécessaire de parler couramment le ML pour le comprendre. ML est définitivement bien adapté pour le travail.
akim

44

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

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

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


1
La maîtrise des scripts de jeu est une excellente ressource d'apprentissage, car lorsque vous aurez terminé, vous aurez un jeu d'aventure 2D jouable et scriptable. Cela rend chaque exercice concentré sur un objectif spécifique et maintient le lecteur motivé.
Dour High Arch

1
Dragon est un peu trop concentré sur l'analyse syntaxique. Si vous n'essayez pas d'analyser quelque chose de purement impossible comme C ++ ou alors en utilisant des générateurs d'analyseurs, mais que vous pouvez utiliser par exemple une grammaire LL artisanale, vous voudrez peut-être rechercher quelque chose qui traite un pourcentage plus élevé des champs du compilateur autre que la transformation et la vérification de la grammaire
Marco van de Voort

27

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

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


5
Je suis d'accord que cette série est un peu dépassée, bien qu'elle soit toujours utile. Cependant, mon plus gros reproche est qu'il essaie de sortir directement en langage assembleur plutôt que de construire n'importe quel type d'arbre d'analyse, ce qui signifie (contrairement à ce qui est indiqué dans le premier article) qu'il n'est pas très utile pour écrire un interprète.
a_m0d

23

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

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

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


Le premier lien est mort.
Lynn

20

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


Si vous n'avez pas beaucoup de temps, n'écrivez pas de compilateur.
Ingo

17

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

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


17

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

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

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

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

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

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

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

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

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


++ Vous avez raison de dire qu'il est bon de savoir toutes ces choses, et cela peut être un gros travail, mais j'ai aussi appris de certains experts comment ne pas faire des choses un gros problème. C'est bon de savoir des choses, et c'est encore mieux de savoir quand ne pas les utiliser, ce qui est la plupart du temps.
Mike Dunlavey


11

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


10

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

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


10

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

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


Mais la documentation pour la configuration de Visual Studio est mal écrite, sans aucun exemple
SpicyWeenie

10

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

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

Texte alternatif


10

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

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

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

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

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

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

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

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


9

"... Construisons un compilateur ..."

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

Pourquoi? Outils et langue.

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

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


9

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

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

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

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

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

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

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

HTH

des os


Que signifie «pas tout à fait Java»?
Hejazzman

haha, désolé, je voulais dire son écrit pour .Net, qui en principe est similaire à java. Les deux sont de style JIT. :)
dbones

8

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

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


8

De la FAQ comp.compilers :

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

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

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

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

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

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

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


8

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

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


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

4
Si vous n'avez pas lu le livre Dragon. Veuillez ne pas le recommander. En fait, avez-vous déjà implémenté un compilateur?

Oui, comme son nom l'indique, le Dragon Book est un monstre. Très en profondeur, mais une très bonne ressource néanmoins. Je ne le recommanderais pas aux débutants, cependant ...
Zachary Murray

2
@Neil: Vous ne m'avez pas recherché sur Google, n'est-ce pas? lol. blog.280z28.org Mais non, je n'ai pas lu ce livre.
Sam Harwell

Je le lis (le livre du dragon) en ce moment, et aussi Lex / Yacc en même temps, je trouve le livre assez bon. Personnellement.
Simeon Pilgrim

1
Pour être juste, je l'ai préfacé par "j'entends ...". :) # 1 et # 3 sont les points qui me semblent extrêmement importants à connaître mais qui ne sont pas mentionnés aussi souvent.
Sam Harwell

8

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


Cela semble être une très bonne ressource merci.
gideon

7

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


7

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

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

  • Conception des compilateurs dans C.
    Allen I. Holub

    Prentice-Hall. 1990.

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

  • Construction du compilateur.
    Niklaus Wirth

    Addison-Wesley. 1996.

  • Lenguajes, Gramáticas y Autómatas. Un enfoque práctico.
    Pedro Isasi Viñuela, Paloma Martínez Fernández, Daniel Borrajo Millán. Addison-Wesley Iberoamericana (España). 1997.

  • L'art de la conception de compilateurs. Théorie et pratique.
    Thomas Pittman, James Peters.

    Prentice Hall. 1992.

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

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

    Addison-Wesley Iberoamericana. 1995.

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

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

  • Introduction aux langues formelles.
    György E. Révész.

    Mc Graw Hill. 1983.

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

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

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

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

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

  • Un Algoritmo Eficiente para la Construcción del Grafo de Dependencia de Control.
    Salvador V. Cavadini.
    Trabajo Final de Grado para obtener el Título de Ingeniero en Computación.
    Facultad de Matemática Aplicada. UCSE 2001.


6

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

Tutoriel: Metacompilers Part 1

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

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

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

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


Comme d'autres le disent, c'est un GRAND argument, je pense que le sushi une tâche est un travail final pour le baccalauréat, il nécessite de connaître BEAUCOUP de concepts de mathématiques, d'informatique, etc.
ingconti

Si vous ne connaissez pas ces sujets, vous ne devriez pas vraiment essayer de construire un compilateur sérieux. Cependant, si vous avez 2-3 ans d'études de premier cycle en informatique (programmation, structures de données, langage d'assemblage), le papier MetaII fonctionnera pour vous.
Ira Baxter

5

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

Lis le.

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

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


5

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

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

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


5

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

Exemple simple

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

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

Exécutez maintenant BCELifier avec cette classe

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

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

private void createMethod_1() {
  InstructionList il = new InstructionList();
  MethodGen method = new MethodGen(ACC_PUBLIC, Type.STRING, new Type[] { Type.INT, Type.INT }, new String[] { "arg0", "arg1" }, "maxAsString", "MyClass", il, _cp);

  il.append(InstructionFactory.createLoad(Type.INT, 1)); // Load first parameter to address 1
  il.append(InstructionFactory.createLoad(Type.INT, 2)); // Load second parameter to adress 2
    BranchInstruction if_icmple_2 = InstructionFactory.createBranchInstruction(Constants.IF_ICMPLE, null); // Do if condition (compare a > b)
  il.append(if_icmple_2);
  il.append(InstructionFactory.createLoad(Type.INT, 1)); // Load value from address 1 into the stack
  il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
  il.append(_factory.createInvoke("java.lang.Integer", "toString", Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
  il.append(InstructionFactory.createReturn(Type.OBJECT));
  InstructionHandle ih_13 = il.append(InstructionFactory.createLoad(Type.INT, 1));
  il.append(InstructionFactory.createLoad(Type.INT, 2));
    BranchInstruction if_icmpge_15 = InstructionFactory.createBranchInstruction(Constants.IF_ICMPGE, null); // Do if condition (compare a < b)
  il.append(if_icmpge_15);
  il.append(InstructionFactory.createLoad(Type.INT, 2));
  il.append(_factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new Type[] { Type.INT }, Constants.INVOKESTATIC));
  il.append(_factory.createInvoke("java.lang.Integer", "toString", Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
  il.append(InstructionFactory.createReturn(Type.OBJECT));
  InstructionHandle ih_26 = il.append(new PUSH(_cp, "equals")); // Return "equals" string
  il.append(InstructionFactory.createReturn(Type.OBJECT));
  if_icmple_2.setTarget(ih_13);
  if_icmpge_15.setTarget(ih_26);
  method.setMaxStack();
  method.setMaxLocals();
  _cg.addMethod(method.getMethod());
  il.dispose();
}

5

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

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

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

Niklaus Wirth, Jürg Gutknecht

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

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


4

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

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

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


Ajouté à la liste merci :)
Anton
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.