La table de symboles représente un structure de données créée et traitée par le compilateur afin de stocker des informations sur l'apparition de certains éléments tels que le nom des variables, le nom des fonctions, les objets, les classes, les interfaces et d'autres similaires. Essentiellement, la table de symbole est utilisée pour acccomplir la fonction d'analyse du compilateur.

Selon le langage utilisé, le tableau de symbole peut servir aux suivants objectifs:

• stocker les noms de toutes les entités sous une forme structurée, a un seul endroit
• vérifier si une variable a été déclarée avant l'utilisation
• implémenter la vérification des types, en vérifiant si les attributions et les expressions du code source sont correctes de point de vue sémantique
• déterminer la portée (scope) d'un nom (résolution de la portée)

Pour stocker les variables dans la table de symboles, on va utiliser un dictionnaire:

// Dans VariableSymbolTable.java
public class VariableSymbolTable {
    String type;
    Object value;
}
 
// Dans SymbolTable.java
 
HashMap<String, VariableSymbolTable> symbolTable = new HashMap<>();
 
public void addVariableToSymbolTable(String variable, String type) {
      symbolTable.put(
              variable,
              new VariableSymbolTable(type, null)
      );
}

Du TP passé on a appris comment créer et structurer l'AST. Le but est de retourner les 2 structures de données dans un meme objet:

// Dans SymbolTree.java
public class SymbolTree {
    ASTNode ast;
    SymbolTable symbolTable;
}
 
// Dans Main.java
SymbolTree symbolTree = new SymbolTree(visitor.visit(tree), symbolTable);
 
writeToFile("files\\output.json", toJSON(symbolTree));

Pour générer le parse tree et la table de symboles on va utiliser la grammaire suivante:

Alf.g4

grammar Alf;
 
start               : (statement SEMICOLON NEWLINE*)*               #multilineProg
                    | statement SEMICOLON                           #singlelineProg 
                    ;
 
statement           : declaration                                   #declarationRule
                    | expression                                    #expressionRule
                    | list_declaration                              #listRule
                    | function_declaration                          #functionRule
                    | attribution                                   #attributionRule
                    ;
 
declaration         : type VARIABLE EQ expression                   #variableDeclaration
                    | type VARIABLE EQ function_call                #variableFunctionCall
                    ;
 
type                : INT                                           #typeInt
                    | FLOAT                                         #typeFloat
                    | STRING                                        #typeString
                    ;
 
value               : INT_NUMBER                                    #valueInt
                    | FLOAT_NUMBER                                  #valueFloat
                    | STRING_TEXT                                   #valueString
                    | VARIABLE                                      #valueVariable
                    ;
 
expression          : left=expression op=MUL right=expression       #expressionMultiply
                    | left=expression op=DIV right=expression       #expressionDivision                   
                    | left=expression op=REM right=expression       #expressionRem 
                    | left=expression op=ADD right=expression       #expressionAddition
                    | left=expression op=SUB right=expression       #expressionSubtraction
                    | LP expression RP                              #expressionParanthesis
                    | value                                         #expressionValue
                    ;
 
attribution         : VARIABLE EQ expression                        #variableAttribution
                    ;
 
list_declaration    : LIST VARIABLE EQ LSP values RSP               #listDeclaration
                    ;
 
values              : (value COMMA)*                                #listValues
                    ;
 
function_declaration: FUNCTION VARIABLE LP (parameter COMMA*)* RP LB (statement SEMICOLON)* return_function RB    #functionContent
                    ;
 
parameter           : declaration                                   #functionParameter
                    ;
 
return_function     : RETURN statement SEMICOLON                    #returnStatement
                    | RETURN SEMICOLON                              #emptyReturn
                    ;
 
function_call       : VARIABLE LP (value COMMA*)* RP                #functionCall
                    ;
 
 
WS                  :   (' ')       -> skip;
NEWLINE             :   ([\r\n]+)   -> skip;
FUNCTION            :   'function';
VARIABLE            :   ('_'[a-zA-Z0-9]+);
ADD                 :   '+';
SUB                 :   '-';
MUL                 :   '*';
DIV                 :   '/';
REM                 :   '%';
INT                 :   'int';
FLOAT               :   'float';
STRING              :   'string';
LIST                :   'list';
LP                  :   '(';
RP                  :   ')';
EQ                  :   '=';
SEMICOLON           :   ';';
LSP                 :   '[';
RSP                 :   ']';
COMMA               :   ',';
LB                  :   '{';
RB                  :   '}';
RETURN              :   'return';
INT_NUMBER          :   ([0-9]+);
FLOAT_NUMBER        :   ([0-9]+'.'[0-9]+);
STRING_TEXT         :   ('"'~["]+'"'|'\''~[']+'\'');

Pour pouvoir visiter tous les noeuds et générer les 2 structures de données, on va utiliser comme support les méthodes qui seront créées aujourd'hui au laboratoire. Vous pouvez observer la grammaire et aussi les implementations des classes, de visiteur et de SymbolTable dans le repository Github donné pour le TP d'aujourd'hui.

1. En suivant les lignes marquées par TODO 1, ajoutez les variables et leur type au tableau des symboles. Testez avec le fichier ex1.txt (2.5p).
2. Si une variable est définie plusieurs fois, retournez sur l'écran une erreur et arretez le programme. Suivez les lignes marquées par TODO 2 et puis testez avec le ficher ex2.txt (2p)
3. Pour chaque type d'expression, vérifiez le type de chaque élément (int, float ou string). Retournez une erreur et arretez l'exécution du programme si vous ne pouvez pas calculer la valeur de l'expression (par exemple, toute opération entre les string et les nombres, sauf la somme). (Hint: Vous pouvez définir une fonction supplémentaire qui fait toutes les validations et seulement l'appeler pour chaque regle). Suivez les lignes avec TODO 3 et testez avec ex3.txt. A la fin, modifiez le contenu du fichier ex3.txt pour tester votre programme pour l'expression 123 - “alf”;. (3p).
4. Pour les variables qui n'ont pas recu un type au moment de la déclaration, déterminez le type lorsque la variable obtient une valeur (regle assign). Vous devrez déterminer le type de chaque expression en tenant compte du type de chaque opérande. (Hint: Si l'un des opérandes est nombre réel/string, le résultat sera réel/string. Vous pouvez implémenter une fonction qui fait les vérifications et l'appeler pour déterminer le type de chaque expression). Testez avec le fichier ex4.txt. Suivez les lignes avec TODO 4. (2.5p).
5. BONUS: Ajoutez la définition de fonction dans la table des symboles, de facon similaire a l'ajout d'une variable. Chaque parametre doit etre ajouté au tableau des symboles avec le type parameter. L'entrée de la table de symboles recevra la fonction et la liste des paramètres de la fonction. Testez avec ex5.txt. Suivez les lignes marquées par TODO 5. (2p)