Conception du compilateur - Récupération d'erreur
Un analyseur devrait être capable de détecter et de signaler toute erreur dans le programme. Il est prévu que lorsqu'une erreur est rencontrée, l'analyseur devrait être capable de la gérer et de continuer à analyser le reste de l'entrée. La plupart du temps, il est attendu de l'analyseur pour vérifier les erreurs, mais des erreurs peuvent survenir à différentes étapes du processus de compilation. Un programme peut présenter les types d'erreurs suivants à différentes étapes:
Lexical : nom d'un identifiant mal saisi
Syntactical : point-virgule manquant ou parenthèse non équilibrée
Semantical : attribution de valeur incompatible
Logical : code non accessible, boucle infinie
Il existe quatre stratégies de récupération d'erreur courantes qui peuvent être implémentées dans l'analyseur pour traiter les erreurs dans le code.
Mode panique
Lorsqu'un analyseur rencontre une erreur n'importe où dans l'instruction, il ignore le reste de l'instruction en ne traitant pas l'entrée d'une entrée erronée vers un délimiteur, tel qu'un point-virgule. C'est le moyen le plus simple de récupérer les erreurs et empêche également l'analyseur de développer des boucles infinies.
Mode déclaration
Lorsqu'un analyseur rencontre une erreur, il essaie de prendre des mesures correctives afin que le reste des entrées de l'instruction autorise l'analyseur à analyser en avant. Par exemple, insérer un point-virgule manquant, remplacer la virgule par un point-virgule, etc. Les concepteurs d'analyseurs doivent être prudents ici car une mauvaise correction peut conduire à une boucle infinie.
Productions d'erreur
Certaines erreurs courantes sont connues des concepteurs du compilateur qui peuvent se produire dans le code. De plus, les concepteurs peuvent créer une grammaire augmentée à utiliser, comme des productions qui génèrent des constructions erronées lorsque ces erreurs sont rencontrées.
Correction globale
L'analyseur considère le programme en cours dans son ensemble et essaie de comprendre ce que le programme est censé faire et essaie de trouver une correspondance la plus proche pour lui, ce qui est sans erreur. Lorsqu'une entrée erronée (instruction) X est alimentée, elle crée un arbre d'analyse pour une instruction Y sans erreur la plus proche. Cela peut permettre à l'analyseur d'apporter des modifications minimes dans le code source, mais en raison de la complexité (temps et espace) de cette stratégie, elle n’a pas encore été mise en œuvre dans la pratique.
Arbres de syntaxe abstraite
Les représentations d'arbre d'analyse ne sont pas faciles à analyser par le compilateur, car elles contiennent plus de détails que nécessaire. Prenons comme exemple l'arborescence d'analyse suivante:
Si on les regarde de près, on constate que la plupart des nœuds feuilles sont des enfants uniques à leurs nœuds parents. Ces informations peuvent être éliminées avant de les transmettre à la phase suivante. En masquant des informations supplémentaires, nous pouvons obtenir un arbre comme indiqué ci-dessous:
L'arbre abstrait peut être représenté comme:
Les AST sont des structures de données importantes dans un compilateur avec le moins d'informations inutiles. Les AST sont plus compacts qu'un arbre d'analyse et peuvent être facilement utilisés par un compilateur.