Bon, en fait là il y a des petites subtilités. Pour pouvoir écrire facilement l’analyseur syntaxique à la main, le plus simple est d’écrire une grammaire « LL(1) » (ça veut juste dire que tu dois respecter certaines règles dans son écriture). Mais avec un langage non structuré et aussi simple que l’asm, ça ne devrait pas être compliqué…

L’idée est de partir d’un programme (le fichier source), et de le décrire en fonction de ses constituants (des déclarations de labels, des instructions, des directives, etc.), et de préciser petit à petit à quoi correspond chaque constituant. On utilise pour cela des règles, par exemple ceci :

prog -> operations  /* un programme est un ensemble d’opérations */
operations -> operation (NEWLINE+ operations)?  /* le « ? » indique une partie optionnelle */
operation -> label_declaration | instruction /* le « | » indique l’alternative */
label_declaration -> IDENTIFICATEUR COLON
instruction -> TAB IDENTIFICATEUR (DOT SIZE)? operandes?
operandes -> operande (COMMA operande)
operande -> data_reg | addr_reg | imm_value | abs_addr
imm_value -> SHARP expr
expr -> prod ((PLUS | MINUS) prod)*
prod -> fact ((MULT | DIV) fact)*
fact -> NUMBER | NUMBER_BIN | NUMBER_HEX

Là encore, je ne mets pas tout, juste pour que tu comprennes le principe.

L’idée est ensuite de parvenir à décrire le fichier source que tu lis en fonction de ces règles, par exemple le programme de toute à l’heure produirait la dérivation suivante :

prog
  operations
    operation
      instruction
        TAB
        IDENTIFICATEUR "move"
        DOT
        SIZE "w"
        operandes
          imm_value
            SHARP
            NUMBER "1234"
          COMMA
          data_reg
            IDENTIFICATEUR "d0"
    NEWLINE
    operation
      instruction
        IDENTIFICATEUR "rts"