Existe-t-il une solution de rechange pour les systèmes flex/bison qui soit utilisable sur les systèmes 8 bits intégrés?

si vous voulez un moyen facile de code parsers, ou vous êtes serré sur l'espace, vous devez main-code un parseur de descente récursive; ceux-ci sont essentiellement LL (1) parsers. Cela est particulièrement efficace pour les langues qui sont aussi "simple" que de base. (J'ai fait plusieurs de ces retour dans les années 70!). La bonne nouvelle est que ceux-ci ne contiennent pas de code de bibliothèque; juste ce que vous écrivez.

ils sont assez faciles à coder, si vous avez déjà une grammaire. Tout d'abord, vous avez à se débarrasser des règles récursives de gauche (par exemple, X = X Y ). C'est généralement assez facile à faire, donc je laisse comme un exercice. (Vous n'avez pas à faire cette liste formant des règles; voir la discussion ci-dessous).

alors si vous avez la règle BNF du formulaire:

 X = A B C ;

créer un sous-programme pour chaque élément de la règle (X, A, B, C) qui renvoie un booléen en disant "j'ai vu la construction syntaxique correspondante". Pour X, code:

subroutine X()
     if ~(A()) return false;
     if ~(B()) { error(); return false; }
     if ~(C()) { error(); return false; }
     // insert semantic action here: generate code, do the work, ....
     return true;
end X;

De même pour A, B, C.

si un token est un terminal, écrire un code qui vérifie le flux d'entrée de la chaîne de caractères qui rend le terminal. Par exemple, pour un nombre, vérifier que le flux d'entrée contient des chiffres et avancer le flux d'entrée curseur dernières les chiffres. C'est particulièrement facile si vous sont parsing hors d'un tampon (pour de base, vous avez tendance à obtenir une ligne à la fois) en avançant ou non un pointeur de balayage de tampon. Ce code est essentiellement la partie lexer de analyseur.

si votre règle de la BNF est récursive... ne vous inquiétez pas. Juste le code de l'appel récursif. Cela traite des règles de grammaire comme:

T  =  '('  T  ')' ;

peut être codé comme:

subroutine T()
     if ~(left_paren()) return false;
     if ~(T()) { error(); return false; }
     if ~(right_paren()) { error(); return false; }
     // insert semantic action here: generate code, do the work, ....
     return true;
end T;

si vous avez une règle BNF avec une alternative:

 P = Q | R ;

puis code P avec des choix alternatifs:

subroutine P()
    if ~(Q())
        {if ~(R()) return false;
         return true;
        }
    return true;
end P;

parfois, vous rencontrerez des règles de formation de liste. Ils ont tendance à être laissés récursive, et cette affaire est facile à gérer. Exemple:

L  =  A |  L A ;

vous pouvez coder ceci comme:

subroutine L()
    if ~(A()) then return false;
    while (A()) do // loop
    return true;
end L;

Vous pouvez coder plusieurs centaines de règles de grammaire dans un jour ou deux de cette façon. Il y a plus de détails à remplir, mais les bases ici devraient être plus que suffisantes.

Si vous êtes vraiment serré sur l'espace, vous pouvez créer une machine virtuelle ces idées. C'est ce que j'ai fait dans les années 70, quand 8K 16 mots de bits était ce que vous pouviez obtenir.

---

si vous ne voulez pas coder cela à la main, vous pouvez l'automatiser avec un metacompiler ( Meta II ) qui produit essentiellement la même chose. Ces sont hallucinants techniques de plaisir et prend vraiment tout le travail de faire cela, même pour de grandes grammaires.

août 2014:

je reçois beaucoup de demandes pour "comment construire un AST avec un analyseur". Pour plus de détails à ce sujet, qui élabore essentiellement cette réponse, Voir mon autre SO réponse https://stackoverflow.com/a/25106688/120163

juillet 2015:

Il ya beaucoup de gens qui veulent écrire un évaluateur d'expression simple. Vous pouvez faire cela en faisant le même genre de choses que le lien "AST builder" ci-dessus suggère; faites juste de l'arithmétique au lieu de construire des noeuds d'arbre. Voici un évaluateur d'expression fait par ici .

vous pouvez utiliser flex/bison sur Linux avec son gcc natif pour générer le code que vous allez ensuite compiler avec votre avr gcc pour la cible embarquée.

GCC peut compiler à une variété de plates-formes, mais vous exécutez flex et bison sur la plate-forme sur laquelle vous exécutez le compilateur. Ils crachent juste le code C que le compilateur construit ensuite. Testez - le pour voir la taille réelle de l'exécutable résultant. Notez qu'ils ont lancé des bibliothèques de temps ( libfl.a etc.) que vous devrez également effectuer une compilation croisée avec votre cible.

Essayez De Boost::Spirit. C'est une bibliothèque d'en-tête seulement que vous pouvez déposer et construire un analyseur très rapide et propre complètement en C++. Les opérateurs surchargés en C++ sont utilisés à la place d'un fichier grammatical spécial.

au lieu de réinventer la roue, regardez LUA: www.lua.org . Il s'agit d'un langage d'interprétation destiné à être intégré à d'autres logiciels et utilisé sur des systèmes à petite échelle, comme les systèmes intégrés. L'arbre d'analyse de syntaxe intégrée, la logique de contrôle, les mathématiques et le support des variables - pas besoin de réinventer quelque chose que des milliers d'autres ont déjà débogué et utilisé. Et il est extensible, ce qui signifie que vous pouvez ajouter à la grammaire en ajoutant votre propre C fonction.