Bon ce n’est pas forcément super visible sur mon post précédent, mais en gros tu peux facilement construire une structure d’arbre pour naviguer entre les phrases du code source.

Chaque nœud de l’arbre correspond à une règle de grammaire. On écrit une fonction correspondant à chaque règle, qui construit le sous-arbre dont elle est responsable, en faisant appel aux autres fonctions construisant leurs sous-arbres respectifs. Cela permet une grande factorisation du code (l’inverse de la duplication de code !) et donc limite les risques de problèmes.

Je parle d’arbre, mais dans le cas de l’ASM tu n’as pas besoin de beaucoup d’informations, tu peux assembler le fichier ligne par ligne. Donc pour chaque nouvelle ligne du fichier source tu peux simplement réinitialiser une structure de données dans laquelle tu vas ensuite stocker les informations dont tu auras besoin pour générer du code, par exemple quelle instruction, quelles sont les opérandes, leur type, etc.

Et pour ce qui est de l’évaluation des expressions arithmétique, le code suit les règles de la grammaire :

int expr(void) {
  int p = prod();
  lex = lexemeCourant();
  while(lex == PLUS || lex == MINUS) {
    if(lex == PLUS) {
      p += prod();
    }
    if(lex == MINUS) {
      p -= prod();
    }
    lex = lexemeCourant();
  }
  return p;
}

Ce qu’il faut retenir, c’est que tes fonctions qui gèrent l’analyse syntaxique doivent suivre les règles que tu auras écrites sur papier. Après, à toi de voir ce qu’elles renvoient comme information pour pouvoir assembler correctement le code. Je n’ai pas en tête toutes tes spécifications (est-ce que tu veux pouvoir gérer les macros, le fait de pouvoir inclure des labels dans les expressions (par exemple pour exprimer une distance entre différents points du code), etc. Tout ça va modifier la nature des informations dont tu auras besoin pour générer le code correspondant).