• Allocation mémoire
• Génération de début et fin de programme
• Génération des expressions
• Génération des conditions
• Génération des instructions simples
• Génération des instructions avec rupture de séquence
• Procédures de génération de P-Code
• Travaux dirigés et travaux pratiques

Chapitre 5 :   Génération de code

5.1   Allocation mémoire

 var
    TABLESYM : array [TABLEINDEX] of record 
       NOM : ALFA ; 
       CLASSE : CLASSES ; 
       ADRESSE : integer 
    end ; 
    OFFSET : integer ; 

 procedure ENTRERSYM(C:CLASSES) ; 
 begin 
    if DERNIERSYM = INDEXMAX then ERREUR ; 
    DERNIERSYM := DERNIERSYM + 1 ;
    with TABLESYM [DERNIERSYM] do begin
       NOM := SYM ; 
       CLASSE := C ; 
       if C = VARIABLE then begin
          ADRESSE := OFFSET ; 
          OFFSET := OFFSET + 1
       end 
    end
 end ; 

5.2   Génération de début et fin de programme

 procedure BLOCK ; 
 begin
    OFFSET := 0 ;
    if TOKEN = CONST_TOKEN then CONSTS ;
    if TOKEN = VAR_TOKEN then VARS ;
    GENERER2 (INT, OFFSET) ; 
    INSTS
 end ; 

 procedure PROGRAM ; 
 begin 
    TESTE (PROGRAM_TOKEN) ; 
    TESTE_ET_ENTRE (ID_TOKEN, PROGRAMME) ; 
    TEST (PT_VIRG_TOKEN) ; 
    BLOCK ; 
    GENERER1 (HLT) ; 
    if TOKEN <> POINT_TOKEN then ERREUR 
 end ;  

5.3   Génération des expressions

5.3.1   Génération des facteurs (FACT)

 procedure FACT ; 
 begin 
    if TOKEN = ID_TOKEN then begin
       TESTE_ET_CHERCHE (ID_TOKEN, [CONSTANTE, VARIABLE]);
       with TABLESYM [PLACESYM] do 
          case CLASSE of 
             CONSTANTE : GENERER2 (LDI, ADRESSE) ; 
             VARIABLE : begin
                GENERER2 (LDA, ADRESSE) ; 
                GENERER1 (LDV) 
             end ; 
             PROGRAMME : ; 
          end
       end
    end ;
    else if TOKEN = NUM_TOKEN then begin
       GENERER2 (LDI, VAL) ;  
       NEXT_TOKEN  
    end 
    else begin
       TESTE (PAR_OUV_TOKEN) ; 
       EXPR ;
       TESTE (PAR_FER_TOKEN) 
    end 
 end ;

5.3.2   Génération des termes (TERM)

 procedure TERM ;
 var OP : TOKENS ; 
 begin 
    FACT ; 
    while TOKEN in [MULT_TOKEN, DIV_TOKEN] do 
       begin 
          OP := TOKEN ; (* memorise l'operation *)
          NEXT_TOKEN ; 
          FACT ; 
          if OP = MUL_TOKEN 
             then GENERER1 (MUL)
             else GENERER1 (DIV)  
       end 
 end ;

5.3.3   Génération des expressions (EXPR)

 procedure EXPR ; 
 var OP : TOKENS ; 
 begin 
    TERM ; 
    while TOKEN in [PLUS_TOKEN, MOINS_TOKEN] do 
       begin 
          OP := TOKEN ; (* memorise l'operation *)
          NEXT_TOKEN ; 
          TERM ; 
          if OP = PLUS_TOKEN
             then GENERER1 (ADD)
             else GENERER1 (SUB) 
       end 
 end ;

5.4   Génération des conditions

5.5   Génération des instructions simples

5.5.1   Génération d'une affectation

 procedure AFFEC ; 
 begin
    TESTE_ET_CHERCHE (ID_TOKEN, VARIABLE) ; 
    GENERER2 (LDA, TABLESYM [PLACESYM]. ADRESSE) ; 
    TESTE (AFFEC_TOKEN) ; 
    EXPR ; 
    GENERER1 (STO) 
 end ; 

5.5.2   Génération des instructions d'entrée/sortie

5.6   Génération des instructions avec rupture de séquence

 procedure NEXT_INST (var COMPT:integer) ; 
 procedure REMPLIR_INST (NUM_INST, DEP:integer) ; 

 procedure SI ;
 var SAUT, SUITE : integer ;  
 begin 
    TESTE (IF_TOKEN) ; 
    COND ; 
    TESTE (THEN_TOKEN) ;
    NEXT_INST (SAUT) ; 
    GENERER2 (BZE, 0) ; (* 0 car incomplet *)
    INST ;
    NEXT_INST (SUITE) ; 
    REMPLIR_INST (SAUT, SUITE) 
 end ;

 procedure TANTQUE ;
 var DEBUT, SAUT, SUITE ; integer ; 
 begin 
    TESTE (WHILE_TOKEN) ; 
    NEXT_INST (DEBUT) ; 
    COND ; 
    TESTE (DO_TOKEN) ; 
    NEXT_INST (SAUT) ; 
    GENERER2 (BZE, 0) ; (* 0 car incomplet *)
    INST ; 
    GENERER2 (BRN, DEBUT) ; 
    NEXT_INST (SUITE) ; 
    REMPLIR_INST (SAUT, SUITE)
 end ;

5.7   Procédures de génération de P-Code

 procedure GENERER1 (M:MNEMONIQUES) ; 
 begin
    if PC = TAILLECODE then ERREUR ; 
    PC := PC + 1 ; 
    with PCODE [PC] do 
       MNE := M  
 end ;

 procedure GENERER2 (M:MNEMONIQUES ; A:integer) ; 
 begin
    if PC = TAILLECODE then ERREUR ; 
    PC := PC + 1 ; 
    with PCODE [PC] do begin  
       MNE := M ; 
       SUITE := A 
    end 
 end ;

 procedure NEXT_INST (var COMPT:integer ) ;
 begin
    COMPT := PC + 1  
 end ;

 procedure REMPLIR_INST (NUM_INST, DEP : integer) ; 
 begin
    PCODE [NUM_INST]. SUITE := DEP
 end ;

5.8   Travaux dirigés et travaux pratiques

1. Implanter l'allocation des variables en mémoire et stockage des valeurs des constantes dans la table des symboles : modification des procédures ENTRERSYM et CONSTS (section 5.1). On testera la réalisation par l'extension de l'affichage de la table des symboles (exercice 4 ).
   
   
2. Ajouter la possibilité de déclarer des constantes avec une valeur signée et des constantes définies par des constantes précédemment déclarées, comme par exemple

    const 
       MAX = +456 ; 
       MIN = -456 ; 
       PETIT = -MAX ; 
   

3. Implanter les procédures de génération de P-Code GENERER1 et GENERER2 ainsi que les procédures utilitaires de générations de P-Code associées (section 5.7). Sous quelle forme générer le code ? Si le code généré doit être rechargé par le chargeur de P-Code, il paraît plus intéressant de passer par une forme non lisible (par un humain !), mais plus compacte du code. Proposer un tel codage.
   
   En complément, et pour faciliter le test du compilateur ou la mise au point de programmes PP1, il est aussi intéressant de pouvoir obtenir une forme lisible du P-Code généré. Quelles solutions sont envisageables pour ce faire ? En implanter une.
   
   
4. Lorsqu'une erreur est détectée, il est nécessaire de poursuivre la compilation. Il est cependant normal de ne pas continuer la génération de code. Pourquoi ? Mettre en oeuvre cette interruption de la génération.
   
   
5. Implanter la génération de code pour les expressions EXPR et les instructions simples (affectation, lecture écriture). Tester cette implantation.
   
   
6. On implantera maintenant les conditions COND et les structures de contrôles présentées : if et while.
   
   
7. On complétera les structures de contrôle if et while par des constructions repeat ... until et if ... then ... else. En définir la syntaxe, la sémantique et l'implantation.
   
   
8. Définir et implanter une structure à choix multiples telle le case Pascal. Que faire lorsqu'aucune des << branches >> du case ne convient ? Envisager la possibilité d'une alternative otherwise qui est exécutée dans ce cas.
   
   
9. Comment introduire une boucle for à la Pascal ? En Pascal, la variable de contrôle de la boucle ne peut pas être modifiée à l'intérieur de la boucle. Comment imposer cette contrainte ?
   
   Pourquoi, à votre avis, la valeur de l'indice des boucles for n'est pas définie à la sortie de la boucle en Pascal ?
   
   Certains pensent que la variable de contrôle de la boucle doit être une vraie variable locale et donc être implicitement déclarée au début de la boucle. Comment prendre cela en compte ?
   
   
10. Comment intégrer une instruction goto en PP1 ?

1

La technique de génération de code détaillée ici est directement liée au langage cible utilisé, le P-Code défini au chapitre 1. Dans le cas de génération d'un langage cible dans lequel les labels d'instruction sont définis par le programmeur et non implicites (n^od'instruction), la technique de génération de code est différente. L'instruction de saut peut être générée complètement avec un label défini au sein du compilateur ; ce label est mémorisé et sera utilisé pour l'écriture explicite du label de l'instruction sur laquelle est effectuée le branchement.