La grammaire de ce programme ne reconnaît-elle que les variables portant le nom "ID" ?

Question

Je dois créer un scanner en lex/flex pour trouver des tokens et un parseur en yacc/bison pour traiter ces tokens sur la base de la grammaire suivante. Lorsque j'étais en train de créer le scanner, il m'est apparu que les variables, les fonctions et les tableaux dans ce langage ne peuvent avoir que le nom 'ID'. Ai-je mal interprété ce fichier yacc ?

/* C-Minus BNF Grammar */

%token ELSE
%token IF
%token INT
%token RETURN
%token VOID
%token WHILE

%token ID
%token NUM

%token LTE
%token GTE
%token EQUAL
%token NOTEQUAL
%%

program : declaration_list ;

declaration_list : declaration_list declaration | declaration ;

declaration : var_declaration | fun_declaration ;

var_declaration : type_specifier ID ';'
                | type_specifier ID '[' NUM ']' ';' ;

type_specifier : INT | VOID ;

fun_declaration : type_specifier ID '(' params ')' compound_stmt ;

params : param_list | VOID ;

param_list : param_list ',' param
           | param ;

param : type_specifier ID | type_specifier ID '[' ']' ;

compound_stmt : '{' local_declarations statement_list '}' ;

local_declarations : local_declarations var_declaration
                   | /* empty */ ;

statement_list : statement_list statement
               | /* empty */ ;

statement : expression_stmt
          | compound_stmt
          | selection_stmt
          | iteration_stmt
          | return_stmt ;

expression_stmt : expression ';'
                | ';' ;

selection_stmt : IF '(' expression ')' statement
               | IF '(' expression ')' statement ELSE statement ;

iteration_stmt : WHILE '(' expression ')' statement ;

return_stmt : RETURN ';' | RETURN expression ';' ;

expression : var '=' expression | simple_expression ;

var : ID | ID '[' expression ']' ;

simple_expression : additive_expression relop additive_expression
                  | additive_expression ;

relop : LTE | '<' | '>' | GTE | EQUAL | NOTEQUAL ;

additive_expression : additive_expression addop term | term ;

addop : '+' | '-' ;

term : term mulop factor | factor ;

mulop : '*' | '/' ;

factor : '(' expression ')' | var | call | NUM ;

call : ID '(' args ')' ;

args : arg_list | /* empty */ ;

arg_list : arg_list ',' expression | expression ;

Answer 1

ID est simplement le type de terminal retourné par le lexateur. L'idée est que, dans le cas de noms de variables (et de nombres), d'autres informations renvoyées spécifieront le nom (ou le nombre). En pseudo-code C, le lexateur fait quelque chose comme :

char *tok = tokenise();
if (!strcmp(tok, "int"))
{
    return INT;
}
else if (is_name(tok))
{
    strcpy(parser.name, tok);
    return ID;
}
else if (is_number(tok))
{
    parser.number = atoi(tok);
    return NUM;
}
...

L'analyseur syntaxique reçoit le type de terminal (INT, ID, NUM, etc.) et cette information est suffisante pour appliquer les règles de grammaire. Les actions des règles peuvent alors inclure les informations supplémentaires (parser.name, parser.number, etc.) soit directement, soit lors de la construction de l'AST.