Evaluation d'une expression - Page 1

;==================================================================
;	EvalExpression
;------------------------------------------------------------------
; 	Evaluate an expression
;
;	input	a0	*expression
;	output	d0.l	value of the expression
;	destroy	std
;==================================================================
EvalExpression:
	rts

Hein ZeroSquare ?

NOMBRE_DEC = [0-9]+ /* Une suite de chiffres */
NOMBRE_BIN = %[0-1]+ /* Une suite de 0 ou 1 précédée d’un « % » */
NOMBRE_HEX = $[0-9a-fA-F]+
IDENTIFICATEUR = [a-zA-Z][a-zA-Z_0-9]* /* Une lettre suivie de n’importe quel caractère alphanumérique ASCII ou « _ » */
MULT = '*'
DIV = '/'
PLUS = '+'
MINUS = '-'
LSL = '<<'
LSR = '>>'
COMMA = ','
DOT = '.'
OPEN_B = '('
CLOSE_B = ')'
SHARP = '#'

  move.w #1234, d0
  rts

IDENTIFICATEUR "move"
DOT
SIZE "w"
SHARP
NUMBER "1234"
COMMA
IDENTIFICATEUR "d0"
NEWLINE
IDENTIFICATEUR "rts"

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

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"

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;
}

Sasume (./16) :
(est-ce que tu veux pouvoir gérer les macros

Sasume (./16) :
le fait de pouvoir inclure des labels dans les expressions (par exemple pour exprimer une distance entre différents points du code)

Folco (./13) :
Mais comment implémenter ça, le représenter en mémoire ? J'avais idée d'écrire les instructions dans un buffer de 10 octets (ou directement dans le handle du binaire), au fur et à mesure de ce que je lis

Sasume (./19) :
Ça me semble bien dans l’idée, je pense que tu peux même écrire directement dans le fichier de sortie (qui ne sera peut-être pas l’exécutable si tu fais une édition de liens ensuite, ou si tu veux gérer le format kernel).

Sasume (./19) :
Pour ce qui est des labels, tu dois simplement construire une table de symbles au fur et à mesure de l’assemblage, dans laquelle tu notes à quoi correspond chaque déclaration de label que tu croises (où il est physiquement et où il est utilisé).

Sasume (./19) :
Quand tu dois calculer un saut, tu regardes si le label auquel le saut fait référence est déjà dans ta table, si oui tu calcules la distance du saut, sinon tu notes le fait qu’il est utilisé à cet endroit comme ça quand tu trouveras sa définition plus bas tu rempliras la valeur du déplacement. Ça te permet d’assembler en une seule passe.

Je ne parle pas encore d'adressage de BSS sur 2 ou 4 octets

Folco (./17) :
C'est surpuissant cette approche Sasume, ça permet de parser n'importe quoi avec le même code, pour peu que tu redéfinisse une nouvelle grammaire, je me trompe ?
Et puis, même question que squalyl, en plus "polissé", ai-je besoin de passer par cette étape nécessairement ? Ne puis-je pas faire quelque chose de plus intuitif ?

Avec à chaque fois, chaqun des composants qui est optionnel. Je me suis même amusé à mettre les directives dans la table des instructions : ça accélère la recherche, et comme j'avais un bit de libre dans chaque entée de la table, je l'utilise pour savoir si j'ai affaire à une instruction ou à une directive. Les instructions passent toutes à la même moulinette, mais les directives, c'est du cas par cas.

Folco (./20) :
Exact, j'ai un handle pour le binaire, je devrais pouvoir écrire dedans directement, au moins le masque de l'instruction. Parce que j'ai pas encore regardé, mais si les adressages en <truc.size> x(an),y(am) s'écrivent "à l'envers" dans le binaire, il faut attendre d'avoir parsé la seconde opérande pour savoir où écrire les offsets. Mais c'est pas un problème, j'ai un stack frame global au programme, suffit de les mettre dedans.

Quitte à devoir faire un linker, autant tout faire à ce moment, à mon avis.

Thibaut (./29) :
Il faudrait évaluer ce genre de calculs dans l'éditeur des liens.

Thibaut (./29) :
mais dédouble le parseur

Thibaut (./29) :
complique ton format objet