y.output

Description du code

y.output est un fichier du projet Compilateur LSD⁰10.
Ce fichier est situé dans /var/www/bin/sniplets/lsd010/.

Projet Compilateur LSD⁰10 :
Compilateur LSD⁰10 développé dans le cadre du cours de syntaxe et sémantique^{ref 1}
Code source ou contenu du fichier

Code _{[Syntaxe output non trouvée, coloration générique]} (y.output) (2512 lignes)
Terminals unused in grammar
 
   POINT
 
 
Grammaire
 
    0 $accept: Prg $end
 
    1 Prg: Functions
 
    2 Functions: /* vide */
    3          | Function Functions
 
    4 Function: FunctionType ID L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction
 
    5 PostFixeFunction: LSQUI_BRACKET LSQUI_BRACKET Declarations RSQUI_BRACKET Statements RSQUI_BRACKET
 
    6 Declarations: /* vide */
    7             | Declaration Declarations
 
    8 Declaration: LEXICAL_VOID_TYPE ID L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction
    9            | VarType ID FuncOrVar
 
   10 FuncOrVar: L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction
   11          | VarIds SEMICOLON
 
   12 VarIds: /* vide */
   13       | ID VarIds
 
   14 FunctionType: LEXICAL_BOOLEAN_TYPE
   15             | LEXICAL_INTEGER_TYPE
   16             | LEXICAL_VOID_TYPE
 
   17 ParamList: ArgDeclaration COMMA ParamList
   18          | ArgDeclaration
   19          | /* vide */
 
   20 ArgDeclaration: LEXICAL_VAR VarType ID
   21               | VarType ID
 
   22 VarType: LEXICAL_BOOLEAN_TYPE
   23        | LEXICAL_INTEGER_TYPE
   24        | LEXICAL_INSTACK_TYPE
   25        | LEXICAL_INTEGER_TYPE LSQUA_BRACKET NUMBER RSQUA_BRACKET
   26        | LEXICAL_BOOLEAN_TYPE LSQUA_BRACKET NUMBER RSQUA_BRACKET
 
   27 RExpr: LEXICAL_NOT RExpr
   28      | RExpr LEXICAL_AND RExpr
   29      | RExpr LEXICAL_OR RExpr
   30      | RExpr LEXICAL_ANDLAZY RExpr
   31      | RExpr LEXICAL_ORLAZY RExpr
   32      | LEXICAL_TRUE_VAL
   33      | LEXICAL_FALSE_VAL
   34      | LEXICAL_ISEMPTY_OPS L_PARENTHESIS ID R_PARENTHESIS
   35      | LEXICAL_GET_OPS L_PARENTHESIS ID R_PARENTHESIS
   36      | RExpr LEXICAL_EQUALS RExpr
   37      | RExpr LEXICAL_LESS_EQUALS RExpr
   38      | RExpr LEXICAL_LESS RExpr
   39      | RExpr LEXICAL_PLUS RExpr
   40      | RExpr LEXICAL_MINUS RExpr
   41      | RExpr LEXICAL_MULT RExpr
   42      | RExpr LEXICAL_DIV RExpr
   43      | RExpr LEXICAL_MOD RExpr
   44      | L_PARENTHESIS RExpr R_PARENTHESIS
   45      | LExpr
   46      | ID L_PARENTHESIS ParamList_FunctionCall R_PARENTHESIS
   47      | ID L_PARENTHESIS R_PARENTHESIS
   48      | NUMBER
   49      | LEXICAL_MINUS NUMBER
 
   50 LExpr: ID
   51      | ID LSQUA_BRACKET RExpr RSQUA_BRACKET
 
   52 ParamList_FunctionCall: RExpr COMMA ParamList_FunctionCall
   53                       | RExpr
 
   54 Statements: Statement Statements
   55           | /* vide */
 
   56 Statement: SEMICOLON
   57          | RExpr SEMICOLON
   58          | LExpr LEXICAL_AFFECTATION RExpr SEMICOLON
   59          | if_instruction
   60          | iteration_while
   61          | iteration_for
   62          | LEXICAL_WRITE_OPS L_PARENTHESIS RExpr R_PARENTHESIS SEMICOLON
   63          | LEXICAL_READ_OPS L_PARENTHESIS LExpr R_PARENTHESIS SEMICOLON
   64          | LEXICAL_PUT_OPS L_PARENTHESIS ID COMMA RExpr R_PARENTHESIS SEMICOLON
   65          | LEXICAL_RETURN_STMT L_PARENTHESIS RExpr R_PARENTHESIS SEMICOLON
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements COLON RExpr COLON Statements R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
   67 iteration_while: LEXICAL_WHILE_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET Statements RSQUI_BRACKET
   69               | LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
 
Terminaux, suivis des règles où ils apparaissent
 
$end (0) 0
error (256)
LEXICAL_BOOLEAN_TYPE (258) 14 22 26
LEXICAL_INTEGER_TYPE (259) 15 23 25
LEXICAL_VOID_TYPE (260) 8 16
LEXICAL_INSTACK_TYPE (261) 24
NUMBER (262) 25 26 48 49
LEXICAL_TRUE_VAL (263) 32
LEXICAL_FALSE_VAL (264) 33
LEXICAL_AND (265) 28
LEXICAL_OR (266) 29
LEXICAL_ANDLAZY (267) 30
LEXICAL_ORLAZY (268) 31
LEXICAL_NOT (269) 27
LEXICAL_EQUALS (270) 36
LEXICAL_LESS_EQUALS (271) 37
LEXICAL_LESS (272) 38
LEXICAL_AFFECTATION (273) 58
LEXICAL_PLUS (274) 39
LEXICAL_MINUS (275) 40 49
LEXICAL_MULT (276) 41
LEXICAL_DIV (277) 42
LEXICAL_MOD (278) 43
L_PARENTHESIS (279) 4 8 10 34 35 44 46 47 62 63 64 65 66 67 68 69
LSQUI_BRACKET (280) 5 66 67 68 69
LSQUA_BRACKET (281) 25 26 51
POINT (282)
RSQUA_BRACKET (283) 25 26 51
R_PARENTHESIS (284) 4 8 10 34 35 44 46 47 62 63 64 65 66 67 68 69
RSQUI_BRACKET (285) 5 66 67 68 69
LEXICAL_GET_OPS (286) 35
LEXICAL_ISEMPTY_OPS (287) 34
LEXICAL_WRITE_OPS (288) 62
LEXICAL_READ_OPS (289) 63
LEXICAL_PUT_OPS (290) 64
LEXICAL_RETURN_STMT (291) 65
LEXICAL_IF_STMT (292) 68 69
LEXICAL_ELSE_STMT (293) 68
LEXICAL_WHILE_STMT (294) 67
LEXICAL_FLEXICAL_OR_STMT (295) 66
COLON (296) 66
SEMICOLON (297) 11 56 57 58 62 63 64 65
COMMA (298) 17 52 64
LEXICAL_VAR (299) 20
ID (300) 4 8 9 13 20 21 34 35 46 47 50 51 64
 
 
Non-terminaux, suivis des règles où ils apparaissent
 
$accept (46)
    à gauche: 0
Prg (47)
    à gauche: 1, à droite: 0
Functions (48)
    à gauche: 2 3, à droite: 1 3
Function (49)
    à gauche: 4, à droite: 3
PostFixeFunction (50)
    à gauche: 5, à droite: 4 8 10
Declarations (51)
    à gauche: 6 7, à droite: 5 7
Declaration (52)
    à gauche: 8 9, à droite: 7
FuncOrVar (53)
    à gauche: 10 11, à droite: 9
VarIds (54)
    à gauche: 12 13, à droite: 11 13
FunctionType (55)
    à gauche: 14 15 16, à droite: 4
ParamList (56)
    à gauche: 17 18 19, à droite: 4 8 10 17
ArgDeclaration (57)
    à gauche: 20 21, à droite: 17 18
VarType (58)
    à gauche: 22 23 24 25 26, à droite: 9 20 21
RExpr (59)
    à gauche: 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
    45 46 47 48 49, à droite: 27 28 29 30 31 36 37 38 39 40 41 42
    43 44 51 52 53 57 58 62 64 65 66 67 68 69
LExpr (60)
    à gauche: 50 51, à droite: 45 58 63
ParamList_FunctionCall (61)
    à gauche: 52 53, à droite: 46 52
Statements (62)
    à gauche: 54 55, à droite: 5 54 66 67 68 69
Statement (63)
    à gauche: 56 57 58 59 60 61 62 63 64 65, à droite: 54
iteration_for (64)
    à gauche: 66, à droite: 61
iteration_while (65)
    à gauche: 67, à droite: 60
if_instruction (66)
    à gauche: 68 69, à droite: 59
 
 
état 0
 
    0 $accept: . Prg $end
 
    LEXICAL_BOOLEAN_TYPE  décalage et aller à l'état 1
    LEXICAL_INTEGER_TYPE  décalage et aller à l'état 2
    LEXICAL_VOID_TYPE     décalage et aller à l'état 3
 
    $défaut  réduction par utilisation de la règle 2 (Functions)
 
    Prg           aller à l'état 4
    Functions     aller à l'état 5
    Function      aller à l'état 6
    FunctionType  aller à l'état 7
 
 
état 1
 
   14 FunctionType: LEXICAL_BOOLEAN_TYPE .
 
    $défaut  réduction par utilisation de la règle 14 (FunctionType)
 
 
état 2
 
   15 FunctionType: LEXICAL_INTEGER_TYPE .
 
    $défaut  réduction par utilisation de la règle 15 (FunctionType)
 
 
état 3
 
   16 FunctionType: LEXICAL_VOID_TYPE .
 
    $défaut  réduction par utilisation de la règle 16 (FunctionType)
 
 
état 4
 
    0 $accept: Prg . $end
 
    $end  décalage et aller à l'état 8
 
 
état 5
 
    1 Prg: Functions .
 
    $défaut  réduction par utilisation de la règle 1 (Prg)
 
 
état 6
 
    3 Functions: Function . Functions
 
    LEXICAL_BOOLEAN_TYPE  décalage et aller à l'état 1
    LEXICAL_INTEGER_TYPE  décalage et aller à l'état 2
    LEXICAL_VOID_TYPE     décalage et aller à l'état 3
 
    $défaut  réduction par utilisation de la règle 2 (Functions)
 
    Functions     aller à l'état 9
    Function      aller à l'état 6
    FunctionType  aller à l'état 7
 
 
état 7
 
    4 Function: FunctionType . ID L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction
 
    ID  décalage et aller à l'état 10
 
 
état 8
 
    0 $accept: Prg $end .
 
    $défaut  accepter
 
 
état 9
 
    3 Functions: Function Functions .
 
    $défaut  réduction par utilisation de la règle 3 (Functions)
 
 
état 10
 
    4 Function: FunctionType ID . L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction
 
    L_PARENTHESIS  décalage et aller à l'état 11
 
 
état 11
 
    4 Function: FunctionType ID L_PARENTHESIS . ParamList R_PARENTHESIS PostFixeFunction
 
    LEXICAL_BOOLEAN_TYPE  décalage et aller à l'état 12
    LEXICAL_INTEGER_TYPE  décalage et aller à l'état 13
    LEXICAL_INSTACK_TYPE  décalage et aller à l'état 14
    LEXICAL_VAR           décalage et aller à l'état 15
 
    $défaut  réduction par utilisation de la règle 19 (ParamList)
 
    ParamList       aller à l'état 16
    ArgDeclaration  aller à l'état 17
    VarType         aller à l'état 18
 
 
état 12
 
   22 VarType: LEXICAL_BOOLEAN_TYPE .
   26        | LEXICAL_BOOLEAN_TYPE . LSQUA_BRACKET NUMBER RSQUA_BRACKET
 
    LSQUA_BRACKET  décalage et aller à l'état 19
 
    $défaut  réduction par utilisation de la règle 22 (VarType)
 
 
état 13
 
   23 VarType: LEXICAL_INTEGER_TYPE .
   25        | LEXICAL_INTEGER_TYPE . LSQUA_BRACKET NUMBER RSQUA_BRACKET
 
    LSQUA_BRACKET  décalage et aller à l'état 20
 
    $défaut  réduction par utilisation de la règle 23 (VarType)
 
 
état 14
 
   24 VarType: LEXICAL_INSTACK_TYPE .
 
    $défaut  réduction par utilisation de la règle 24 (VarType)
 
 
état 15
 
   20 ArgDeclaration: LEXICAL_VAR . VarType ID
 
    LEXICAL_BOOLEAN_TYPE  décalage et aller à l'état 12
    LEXICAL_INTEGER_TYPE  décalage et aller à l'état 13
    LEXICAL_INSTACK_TYPE  décalage et aller à l'état 14
 
    VarType  aller à l'état 21
 
 
état 16
 
    4 Function: FunctionType ID L_PARENTHESIS ParamList . R_PARENTHESIS PostFixeFunction
 
    R_PARENTHESIS  décalage et aller à l'état 22
 
 
état 17
 
   17 ParamList: ArgDeclaration . COMMA ParamList
   18          | ArgDeclaration .
 
    COMMA  décalage et aller à l'état 23
 
    $défaut  réduction par utilisation de la règle 18 (ParamList)
 
 
état 18
 
   21 ArgDeclaration: VarType . ID
 
    ID  décalage et aller à l'état 24
 
 
état 19
 
   26 VarType: LEXICAL_BOOLEAN_TYPE LSQUA_BRACKET . NUMBER RSQUA_BRACKET
 
    NUMBER  décalage et aller à l'état 25
 
 
état 20
 
   25 VarType: LEXICAL_INTEGER_TYPE LSQUA_BRACKET . NUMBER RSQUA_BRACKET
 
    NUMBER  décalage et aller à l'état 26
 
 
état 21
 
   20 ArgDeclaration: LEXICAL_VAR VarType . ID
 
    ID  décalage et aller à l'état 27
 
 
état 22
 
    4 Function: FunctionType ID L_PARENTHESIS ParamList R_PARENTHESIS . PostFixeFunction
 
    LSQUI_BRACKET  décalage et aller à l'état 28
 
    PostFixeFunction  aller à l'état 29
 
 
état 23
 
   17 ParamList: ArgDeclaration COMMA . ParamList
 
    LEXICAL_BOOLEAN_TYPE  décalage et aller à l'état 12
    LEXICAL_INTEGER_TYPE  décalage et aller à l'état 13
    LEXICAL_INSTACK_TYPE  décalage et aller à l'état 14
    LEXICAL_VAR           décalage et aller à l'état 15
 
    $défaut  réduction par utilisation de la règle 19 (ParamList)
 
    ParamList       aller à l'état 30
    ArgDeclaration  aller à l'état 17
    VarType         aller à l'état 18
 
 
état 24
 
   21 ArgDeclaration: VarType ID .
 
    $défaut  réduction par utilisation de la règle 21 (ArgDeclaration)
 
 
état 25
 
   26 VarType: LEXICAL_BOOLEAN_TYPE LSQUA_BRACKET NUMBER . RSQUA_BRACKET
 
    RSQUA_BRACKET  décalage et aller à l'état 31
 
 
état 26
 
   25 VarType: LEXICAL_INTEGER_TYPE LSQUA_BRACKET NUMBER . RSQUA_BRACKET
 
    RSQUA_BRACKET  décalage et aller à l'état 32
 
 
état 27
 
   20 ArgDeclaration: LEXICAL_VAR VarType ID .
 
    $défaut  réduction par utilisation de la règle 20 (ArgDeclaration)
 
 
état 28
 
    5 PostFixeFunction: LSQUI_BRACKET . LSQUI_BRACKET Declarations RSQUI_BRACKET Statements RSQUI_BRACKET
 
    LSQUI_BRACKET  décalage et aller à l'état 33
 
 
état 29
 
    4 Function: FunctionType ID L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction .
 
    $défaut  réduction par utilisation de la règle 4 (Function)
 
 
état 30
 
   17 ParamList: ArgDeclaration COMMA ParamList .
 
    $défaut  réduction par utilisation de la règle 17 (ParamList)
 
 
état 31
 
   26 VarType: LEXICAL_BOOLEAN_TYPE LSQUA_BRACKET NUMBER RSQUA_BRACKET .
 
    $défaut  réduction par utilisation de la règle 26 (VarType)
 
 
état 32
 
   25 VarType: LEXICAL_INTEGER_TYPE LSQUA_BRACKET NUMBER RSQUA_BRACKET .
 
    $défaut  réduction par utilisation de la règle 25 (VarType)
 
 
état 33
 
    5 PostFixeFunction: LSQUI_BRACKET LSQUI_BRACKET . Declarations RSQUI_BRACKET Statements RSQUI_BRACKET
 
    LEXICAL_BOOLEAN_TYPE  décalage et aller à l'état 12
    LEXICAL_INTEGER_TYPE  décalage et aller à l'état 13
    LEXICAL_VOID_TYPE     décalage et aller à l'état 34
    LEXICAL_INSTACK_TYPE  décalage et aller à l'état 14
 
    $défaut  réduction par utilisation de la règle 6 (Declarations)
 
    Declarations  aller à l'état 35
    Declaration   aller à l'état 36
    VarType       aller à l'état 37
 
 
état 34
 
    8 Declaration: LEXICAL_VOID_TYPE . ID L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction
 
    ID  décalage et aller à l'état 38
 
 
état 35
 
    5 PostFixeFunction: LSQUI_BRACKET LSQUI_BRACKET Declarations . RSQUI_BRACKET Statements RSQUI_BRACKET
 
    RSQUI_BRACKET  décalage et aller à l'état 39
 
 
état 36
 
    7 Declarations: Declaration . Declarations
 
    LEXICAL_BOOLEAN_TYPE  décalage et aller à l'état 12
    LEXICAL_INTEGER_TYPE  décalage et aller à l'état 13
    LEXICAL_VOID_TYPE     décalage et aller à l'état 34
    LEXICAL_INSTACK_TYPE  décalage et aller à l'état 14
 
    $défaut  réduction par utilisation de la règle 6 (Declarations)
 
    Declarations  aller à l'état 40
    Declaration   aller à l'état 36
    VarType       aller à l'état 37
 
 
état 37
 
    9 Declaration: VarType . ID FuncOrVar
 
    ID  décalage et aller à l'état 41
 
 
état 38
 
    8 Declaration: LEXICAL_VOID_TYPE ID . L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction
 
    L_PARENTHESIS  décalage et aller à l'état 42
 
 
état 39
 
    5 PostFixeFunction: LSQUI_BRACKET LSQUI_BRACKET Declarations RSQUI_BRACKET . Statements RSQUI_BRACKET
 
    NUMBER                    décalage et aller à l'état 43
    LEXICAL_TRUE_VAL          décalage et aller à l'état 44
    LEXICAL_FALSE_VAL         décalage et aller à l'état 45
    LEXICAL_NOT               décalage et aller à l'état 46
    LEXICAL_MINUS             décalage et aller à l'état 47
    L_PARENTHESIS             décalage et aller à l'état 48
    LEXICAL_GET_OPS           décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS       décalage et aller à l'état 50
    LEXICAL_WRITE_OPS         décalage et aller à l'état 51
    LEXICAL_READ_OPS          décalage et aller à l'état 52
    LEXICAL_PUT_OPS           décalage et aller à l'état 53
    LEXICAL_RETURN_STMT       décalage et aller à l'état 54
    LEXICAL_IF_STMT           décalage et aller à l'état 55
    LEXICAL_WHILE_STMT        décalage et aller à l'état 56
    LEXICAL_FLEXICAL_OR_STMT  décalage et aller à l'état 57
    SEMICOLON                 décalage et aller à l'état 58
    ID                        décalage et aller à l'état 59
 
    $défaut  réduction par utilisation de la règle 55 (Statements)
 
    RExpr            aller à l'état 60
    LExpr            aller à l'état 61
    Statements       aller à l'état 62
    Statement        aller à l'état 63
    iteration_for    aller à l'état 64
    iteration_while  aller à l'état 65
    if_instruction   aller à l'état 66
 
 
état 40
 
    7 Declarations: Declaration Declarations .
 
    $défaut  réduction par utilisation de la règle 7 (Declarations)
 
 
état 41
 
    9 Declaration: VarType ID . FuncOrVar
 
    L_PARENTHESIS  décalage et aller à l'état 67
    ID             décalage et aller à l'état 68
 
    $défaut  réduction par utilisation de la règle 12 (VarIds)
 
    FuncOrVar  aller à l'état 69
    VarIds     aller à l'état 70
 
 
état 42
 
    8 Declaration: LEXICAL_VOID_TYPE ID L_PARENTHESIS . ParamList R_PARENTHESIS PostFixeFunction
 
    LEXICAL_BOOLEAN_TYPE  décalage et aller à l'état 12
    LEXICAL_INTEGER_TYPE  décalage et aller à l'état 13
    LEXICAL_INSTACK_TYPE  décalage et aller à l'état 14
    LEXICAL_VAR           décalage et aller à l'état 15
 
    $défaut  réduction par utilisation de la règle 19 (ParamList)
 
    ParamList       aller à l'état 71
    ArgDeclaration  aller à l'état 17
    VarType         aller à l'état 18
 
 
état 43
 
   48 RExpr: NUMBER .
 
    $défaut  réduction par utilisation de la règle 48 (RExpr)
 
 
état 44
 
   32 RExpr: LEXICAL_TRUE_VAL .
 
    $défaut  réduction par utilisation de la règle 32 (RExpr)
 
 
état 45
 
   33 RExpr: LEXICAL_FALSE_VAL .
 
    $défaut  réduction par utilisation de la règle 33 (RExpr)
 
 
état 46
 
   27 RExpr: LEXICAL_NOT . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 72
    LExpr  aller à l'état 73
 
 
état 47
 
   49 RExpr: LEXICAL_MINUS . NUMBER
 
    NUMBER  décalage et aller à l'état 74
 
 
état 48
 
   44 RExpr: L_PARENTHESIS . RExpr R_PARENTHESIS
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 75
    LExpr  aller à l'état 73
 
 
état 49
 
   35 RExpr: LEXICAL_GET_OPS . L_PARENTHESIS ID R_PARENTHESIS
 
    L_PARENTHESIS  décalage et aller à l'état 76
 
 
état 50
 
   34 RExpr: LEXICAL_ISEMPTY_OPS . L_PARENTHESIS ID R_PARENTHESIS
 
    L_PARENTHESIS  décalage et aller à l'état 77
 
 
état 51
 
   62 Statement: LEXICAL_WRITE_OPS . L_PARENTHESIS RExpr R_PARENTHESIS SEMICOLON
 
    L_PARENTHESIS  décalage et aller à l'état 78
 
 
état 52
 
   63 Statement: LEXICAL_READ_OPS . L_PARENTHESIS LExpr R_PARENTHESIS SEMICOLON
 
    L_PARENTHESIS  décalage et aller à l'état 79
 
 
état 53
 
   64 Statement: LEXICAL_PUT_OPS . L_PARENTHESIS ID COMMA RExpr R_PARENTHESIS SEMICOLON
 
    L_PARENTHESIS  décalage et aller à l'état 80
 
 
état 54
 
   65 Statement: LEXICAL_RETURN_STMT . L_PARENTHESIS RExpr R_PARENTHESIS SEMICOLON
 
    L_PARENTHESIS  décalage et aller à l'état 81
 
 
état 55
 
   68 if_instruction: LEXICAL_IF_STMT . L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET Statements RSQUI_BRACKET
   69               | LEXICAL_IF_STMT . L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    L_PARENTHESIS  décalage et aller à l'état 82
 
 
état 56
 
   67 iteration_while: LEXICAL_WHILE_STMT . L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    L_PARENTHESIS  décalage et aller à l'état 83
 
 
état 57
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT . L_PARENTHESIS Statements COLON RExpr COLON Statements R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    L_PARENTHESIS  décalage et aller à l'état 84
 
 
état 58
 
   56 Statement: SEMICOLON .
 
    $défaut  réduction par utilisation de la règle 56 (Statement)
 
 
état 59
 
   46 RExpr: ID . L_PARENTHESIS ParamList_FunctionCall R_PARENTHESIS
   47      | ID . L_PARENTHESIS R_PARENTHESIS
   50 LExpr: ID .
   51      | ID . LSQUA_BRACKET RExpr RSQUA_BRACKET
 
    L_PARENTHESIS  décalage et aller à l'état 85
    LSQUA_BRACKET  décalage et aller à l'état 86
 
    $défaut  réduction par utilisation de la règle 50 (LExpr)
 
 
état 60
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   57 Statement: RExpr . SEMICOLON
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    SEMICOLON            décalage et aller à l'état 99
 
 
état 61
 
   45 RExpr: LExpr .
   58 Statement: LExpr . LEXICAL_AFFECTATION RExpr SEMICOLON
 
    LEXICAL_AFFECTATION  décalage et aller à l'état 100
 
    $défaut  réduction par utilisation de la règle 45 (RExpr)
 
 
état 62
 
    5 PostFixeFunction: LSQUI_BRACKET LSQUI_BRACKET Declarations RSQUI_BRACKET Statements . RSQUI_BRACKET
 
    RSQUI_BRACKET  décalage et aller à l'état 101
 
 
état 63
 
   54 Statements: Statement . Statements
 
    NUMBER                    décalage et aller à l'état 43
    LEXICAL_TRUE_VAL          décalage et aller à l'état 44
    LEXICAL_FALSE_VAL         décalage et aller à l'état 45
    LEXICAL_NOT               décalage et aller à l'état 46
    LEXICAL_MINUS             décalage et aller à l'état 47
    L_PARENTHESIS             décalage et aller à l'état 48
    LEXICAL_GET_OPS           décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS       décalage et aller à l'état 50
    LEXICAL_WRITE_OPS         décalage et aller à l'état 51
    LEXICAL_READ_OPS          décalage et aller à l'état 52
    LEXICAL_PUT_OPS           décalage et aller à l'état 53
    LEXICAL_RETURN_STMT       décalage et aller à l'état 54
    LEXICAL_IF_STMT           décalage et aller à l'état 55
    LEXICAL_WHILE_STMT        décalage et aller à l'état 56
    LEXICAL_FLEXICAL_OR_STMT  décalage et aller à l'état 57
    SEMICOLON                 décalage et aller à l'état 58
    ID                        décalage et aller à l'état 59
 
    $défaut  réduction par utilisation de la règle 55 (Statements)
 
    RExpr            aller à l'état 60
    LExpr            aller à l'état 61
    Statements       aller à l'état 102
    Statement        aller à l'état 63
    iteration_for    aller à l'état 64
    iteration_while  aller à l'état 65
    if_instruction   aller à l'état 66
 
 
état 64
 
   61 Statement: iteration_for .
 
    $défaut  réduction par utilisation de la règle 61 (Statement)
 
 
état 65
 
   60 Statement: iteration_while .
 
    $défaut  réduction par utilisation de la règle 60 (Statement)
 
 
état 66
 
   59 Statement: if_instruction .
 
    $défaut  réduction par utilisation de la règle 59 (Statement)
 
 
état 67
 
   10 FuncOrVar: L_PARENTHESIS . ParamList R_PARENTHESIS PostFixeFunction
 
    LEXICAL_BOOLEAN_TYPE  décalage et aller à l'état 12
    LEXICAL_INTEGER_TYPE  décalage et aller à l'état 13
    LEXICAL_INSTACK_TYPE  décalage et aller à l'état 14
    LEXICAL_VAR           décalage et aller à l'état 15
 
    $défaut  réduction par utilisation de la règle 19 (ParamList)
 
    ParamList       aller à l'état 103
    ArgDeclaration  aller à l'état 17
    VarType         aller à l'état 18
 
 
état 68
 
   13 VarIds: ID . VarIds
 
    ID  décalage et aller à l'état 68
 
    $défaut  réduction par utilisation de la règle 12 (VarIds)
 
    VarIds  aller à l'état 104
 
 
état 69
 
    9 Declaration: VarType ID FuncOrVar .
 
    $défaut  réduction par utilisation de la règle 9 (Declaration)
 
 
état 70
 
   11 FuncOrVar: VarIds . SEMICOLON
 
    SEMICOLON  décalage et aller à l'état 105
 
 
état 71
 
    8 Declaration: LEXICAL_VOID_TYPE ID L_PARENTHESIS ParamList . R_PARENTHESIS PostFixeFunction
 
    R_PARENTHESIS  décalage et aller à l'état 106
 
 
état 72
 
   27 RExpr: LEXICAL_NOT RExpr .
   28      | RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 27 (RExpr)
 
 
état 73
 
   45 RExpr: LExpr .
 
    $défaut  réduction par utilisation de la règle 45 (RExpr)
 
 
état 74
 
   49 RExpr: LEXICAL_MINUS NUMBER .
 
    $défaut  réduction par utilisation de la règle 49 (RExpr)
 
 
état 75
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   44      | L_PARENTHESIS RExpr . R_PARENTHESIS
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    R_PARENTHESIS        décalage et aller à l'état 107
 
 
état 76
 
   35 RExpr: LEXICAL_GET_OPS L_PARENTHESIS . ID R_PARENTHESIS
 
    ID  décalage et aller à l'état 108
 
 
état 77
 
   34 RExpr: LEXICAL_ISEMPTY_OPS L_PARENTHESIS . ID R_PARENTHESIS
 
    ID  décalage et aller à l'état 109
 
 
état 78
 
   62 Statement: LEXICAL_WRITE_OPS L_PARENTHESIS . RExpr R_PARENTHESIS SEMICOLON
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 110
    LExpr  aller à l'état 73
 
 
état 79
 
   63 Statement: LEXICAL_READ_OPS L_PARENTHESIS . LExpr R_PARENTHESIS SEMICOLON
 
    ID  décalage et aller à l'état 111
 
    LExpr  aller à l'état 112
 
 
état 80
 
   64 Statement: LEXICAL_PUT_OPS L_PARENTHESIS . ID COMMA RExpr R_PARENTHESIS SEMICOLON
 
    ID  décalage et aller à l'état 113
 
 
état 81
 
   65 Statement: LEXICAL_RETURN_STMT L_PARENTHESIS . RExpr R_PARENTHESIS SEMICOLON
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 114
    LExpr  aller à l'état 73
 
 
état 82
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS . RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET Statements RSQUI_BRACKET
   69               | LEXICAL_IF_STMT L_PARENTHESIS . RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 115
    LExpr  aller à l'état 73
 
 
état 83
 
   67 iteration_while: LEXICAL_WHILE_STMT L_PARENTHESIS . RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 116
    LExpr  aller à l'état 73
 
 
état 84
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS . Statements COLON RExpr COLON Statements R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    NUMBER                    décalage et aller à l'état 43
    LEXICAL_TRUE_VAL          décalage et aller à l'état 44
    LEXICAL_FALSE_VAL         décalage et aller à l'état 45
    LEXICAL_NOT               décalage et aller à l'état 46
    LEXICAL_MINUS             décalage et aller à l'état 47
    L_PARENTHESIS             décalage et aller à l'état 48
    LEXICAL_GET_OPS           décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS       décalage et aller à l'état 50
    LEXICAL_WRITE_OPS         décalage et aller à l'état 51
    LEXICAL_READ_OPS          décalage et aller à l'état 52
    LEXICAL_PUT_OPS           décalage et aller à l'état 53
    LEXICAL_RETURN_STMT       décalage et aller à l'état 54
    LEXICAL_IF_STMT           décalage et aller à l'état 55
    LEXICAL_WHILE_STMT        décalage et aller à l'état 56
    LEXICAL_FLEXICAL_OR_STMT  décalage et aller à l'état 57
    SEMICOLON                 décalage et aller à l'état 58
    ID                        décalage et aller à l'état 59
 
    $défaut  réduction par utilisation de la règle 55 (Statements)
 
    RExpr            aller à l'état 60
    LExpr            aller à l'état 61
    Statements       aller à l'état 117
    Statement        aller à l'état 63
    iteration_for    aller à l'état 64
    iteration_while  aller à l'état 65
    if_instruction   aller à l'état 66
 
 
état 85
 
   46 RExpr: ID L_PARENTHESIS . ParamList_FunctionCall R_PARENTHESIS
   47      | ID L_PARENTHESIS . R_PARENTHESIS
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    R_PARENTHESIS        décalage et aller à l'état 118
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr                   aller à l'état 119
    LExpr                   aller à l'état 73
    ParamList_FunctionCall  aller à l'état 120
 
 
état 86
 
   51 LExpr: ID LSQUA_BRACKET . RExpr RSQUA_BRACKET
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 121
    LExpr  aller à l'état 73
 
 
état 87
 
   28 RExpr: RExpr LEXICAL_AND . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 122
    LExpr  aller à l'état 73
 
 
état 88
 
   29 RExpr: RExpr LEXICAL_OR . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 123
    LExpr  aller à l'état 73
 
 
état 89
 
   30 RExpr: RExpr LEXICAL_ANDLAZY . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 124
    LExpr  aller à l'état 73
 
 
état 90
 
   31 RExpr: RExpr LEXICAL_ORLAZY . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 125
    LExpr  aller à l'état 73
 
 
état 91
 
   36 RExpr: RExpr LEXICAL_EQUALS . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 126
    LExpr  aller à l'état 73
 
 
état 92
 
   37 RExpr: RExpr LEXICAL_LESS_EQUALS . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 127
    LExpr  aller à l'état 73
 
 
état 93
 
   38 RExpr: RExpr LEXICAL_LESS . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 128
    LExpr  aller à l'état 73
 
 
état 94
 
   39 RExpr: RExpr LEXICAL_PLUS . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 129
    LExpr  aller à l'état 73
 
 
état 95
 
   40 RExpr: RExpr LEXICAL_MINUS . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 130
    LExpr  aller à l'état 73
 
 
état 96
 
   41 RExpr: RExpr LEXICAL_MULT . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 131
    LExpr  aller à l'état 73
 
 
état 97
 
   42 RExpr: RExpr LEXICAL_DIV . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 132
    LExpr  aller à l'état 73
 
 
état 98
 
   43 RExpr: RExpr LEXICAL_MOD . RExpr
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 133
    LExpr  aller à l'état 73
 
 
état 99
 
   57 Statement: RExpr SEMICOLON .
 
    $défaut  réduction par utilisation de la règle 57 (Statement)
 
 
état 100
 
   58 Statement: LExpr LEXICAL_AFFECTATION . RExpr SEMICOLON
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 134
    LExpr  aller à l'état 73
 
 
état 101
 
    5 PostFixeFunction: LSQUI_BRACKET LSQUI_BRACKET Declarations RSQUI_BRACKET Statements RSQUI_BRACKET .
 
    $défaut  réduction par utilisation de la règle 5 (PostFixeFunction)
 
 
état 102
 
   54 Statements: Statement Statements .
 
    $défaut  réduction par utilisation de la règle 54 (Statements)
 
 
état 103
 
   10 FuncOrVar: L_PARENTHESIS ParamList . R_PARENTHESIS PostFixeFunction
 
    R_PARENTHESIS  décalage et aller à l'état 135
 
 
état 104
 
   13 VarIds: ID VarIds .
 
    $défaut  réduction par utilisation de la règle 13 (VarIds)
 
 
état 105
 
   11 FuncOrVar: VarIds SEMICOLON .
 
    $défaut  réduction par utilisation de la règle 11 (FuncOrVar)
 
 
état 106
 
    8 Declaration: LEXICAL_VOID_TYPE ID L_PARENTHESIS ParamList R_PARENTHESIS . PostFixeFunction
 
    LSQUI_BRACKET  décalage et aller à l'état 28
 
    PostFixeFunction  aller à l'état 136
 
 
état 107
 
   44 RExpr: L_PARENTHESIS RExpr R_PARENTHESIS .
 
    $défaut  réduction par utilisation de la règle 44 (RExpr)
 
 
état 108
 
   35 RExpr: LEXICAL_GET_OPS L_PARENTHESIS ID . R_PARENTHESIS
 
    R_PARENTHESIS  décalage et aller à l'état 137
 
 
état 109
 
   34 RExpr: LEXICAL_ISEMPTY_OPS L_PARENTHESIS ID . R_PARENTHESIS
 
    R_PARENTHESIS  décalage et aller à l'état 138
 
 
état 110
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   62 Statement: LEXICAL_WRITE_OPS L_PARENTHESIS RExpr . R_PARENTHESIS SEMICOLON
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    R_PARENTHESIS        décalage et aller à l'état 139
 
 
état 111
 
   50 LExpr: ID .
   51      | ID . LSQUA_BRACKET RExpr RSQUA_BRACKET
 
    LSQUA_BRACKET  décalage et aller à l'état 86
 
    $défaut  réduction par utilisation de la règle 50 (LExpr)
 
 
état 112
 
   63 Statement: LEXICAL_READ_OPS L_PARENTHESIS LExpr . R_PARENTHESIS SEMICOLON
 
    R_PARENTHESIS  décalage et aller à l'état 140
 
 
état 113
 
   64 Statement: LEXICAL_PUT_OPS L_PARENTHESIS ID . COMMA RExpr R_PARENTHESIS SEMICOLON
 
    COMMA  décalage et aller à l'état 141
 
 
état 114
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   65 Statement: LEXICAL_RETURN_STMT L_PARENTHESIS RExpr . R_PARENTHESIS SEMICOLON
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    R_PARENTHESIS        décalage et aller à l'état 142
 
 
état 115
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr . R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET Statements RSQUI_BRACKET
   69               | LEXICAL_IF_STMT L_PARENTHESIS RExpr . R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    R_PARENTHESIS        décalage et aller à l'état 143
 
 
état 116
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   67 iteration_while: LEXICAL_WHILE_STMT L_PARENTHESIS RExpr . R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    R_PARENTHESIS        décalage et aller à l'état 144
 
 
état 117
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements . COLON RExpr COLON Statements R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    COLON  décalage et aller à l'état 145
 
 
état 118
 
   47 RExpr: ID L_PARENTHESIS R_PARENTHESIS .
 
    $défaut  réduction par utilisation de la règle 47 (RExpr)
 
 
état 119
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   52 ParamList_FunctionCall: RExpr . COMMA ParamList_FunctionCall
   53                       | RExpr .
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    COMMA                décalage et aller à l'état 146
 
    $défaut  réduction par utilisation de la règle 53 (ParamList_FunctionCall)
 
 
état 120
 
   46 RExpr: ID L_PARENTHESIS ParamList_FunctionCall . R_PARENTHESIS
 
    R_PARENTHESIS  décalage et aller à l'état 147
 
 
état 121
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   51 LExpr: ID LSQUA_BRACKET RExpr . RSQUA_BRACKET
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    RSQUA_BRACKET        décalage et aller à l'état 148
 
 
état 122
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   28      | RExpr LEXICAL_AND RExpr .
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 28 (RExpr)
 
 
état 123
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   29      | RExpr LEXICAL_OR RExpr .
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 29 (RExpr)
 
 
état 124
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   30      | RExpr LEXICAL_ANDLAZY RExpr .
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 30 (RExpr)
 
 
état 125
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   31      | RExpr LEXICAL_ORLAZY RExpr .
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 31 (RExpr)
 
 
état 126
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   36      | RExpr LEXICAL_EQUALS RExpr .
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_PLUS   décalage et aller à l'état 94
    LEXICAL_MINUS  décalage et aller à l'état 95
    LEXICAL_MULT   décalage et aller à l'état 96
    LEXICAL_DIV    décalage et aller à l'état 97
    LEXICAL_MOD    décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 36 (RExpr)
 
 
état 127
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   37      | RExpr LEXICAL_LESS_EQUALS RExpr .
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_PLUS   décalage et aller à l'état 94
    LEXICAL_MINUS  décalage et aller à l'état 95
    LEXICAL_MULT   décalage et aller à l'état 96
    LEXICAL_DIV    décalage et aller à l'état 97
    LEXICAL_MOD    décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 37 (RExpr)
 
 
état 128
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   38      | RExpr LEXICAL_LESS RExpr .
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_PLUS   décalage et aller à l'état 94
    LEXICAL_MINUS  décalage et aller à l'état 95
    LEXICAL_MULT   décalage et aller à l'état 96
    LEXICAL_DIV    décalage et aller à l'état 97
    LEXICAL_MOD    décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 38 (RExpr)
 
 
état 129
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   39      | RExpr LEXICAL_PLUS RExpr .
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_MULT  décalage et aller à l'état 96
    LEXICAL_DIV   décalage et aller à l'état 97
    LEXICAL_MOD   décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 39 (RExpr)
 
 
état 130
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   40      | RExpr LEXICAL_MINUS RExpr .
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    LEXICAL_MULT  décalage et aller à l'état 96
    LEXICAL_DIV   décalage et aller à l'état 97
    LEXICAL_MOD   décalage et aller à l'état 98
 
    $défaut  réduction par utilisation de la règle 40 (RExpr)
 
 
état 131
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   41      | RExpr LEXICAL_MULT RExpr .
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
 
    $défaut  réduction par utilisation de la règle 41 (RExpr)
 
 
état 132
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   42      | RExpr LEXICAL_DIV RExpr .
   43      | RExpr . LEXICAL_MOD RExpr
 
    $défaut  réduction par utilisation de la règle 42 (RExpr)
 
 
état 133
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   43      | RExpr LEXICAL_MOD RExpr .
 
    $défaut  réduction par utilisation de la règle 43 (RExpr)
 
 
état 134
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   58 Statement: LExpr LEXICAL_AFFECTATION RExpr . SEMICOLON
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    SEMICOLON            décalage et aller à l'état 149
 
 
état 135
 
   10 FuncOrVar: L_PARENTHESIS ParamList R_PARENTHESIS . PostFixeFunction
 
    LSQUI_BRACKET  décalage et aller à l'état 28
 
    PostFixeFunction  aller à l'état 150
 
 
état 136
 
    8 Declaration: LEXICAL_VOID_TYPE ID L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction .
 
    $défaut  réduction par utilisation de la règle 8 (Declaration)
 
 
état 137
 
   35 RExpr: LEXICAL_GET_OPS L_PARENTHESIS ID R_PARENTHESIS .
 
    $défaut  réduction par utilisation de la règle 35 (RExpr)
 
 
état 138
 
   34 RExpr: LEXICAL_ISEMPTY_OPS L_PARENTHESIS ID R_PARENTHESIS .
 
    $défaut  réduction par utilisation de la règle 34 (RExpr)
 
 
état 139
 
   62 Statement: LEXICAL_WRITE_OPS L_PARENTHESIS RExpr R_PARENTHESIS . SEMICOLON
 
    SEMICOLON  décalage et aller à l'état 151
 
 
état 140
 
   63 Statement: LEXICAL_READ_OPS L_PARENTHESIS LExpr R_PARENTHESIS . SEMICOLON
 
    SEMICOLON  décalage et aller à l'état 152
 
 
état 141
 
   64 Statement: LEXICAL_PUT_OPS L_PARENTHESIS ID COMMA . RExpr R_PARENTHESIS SEMICOLON
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 153
    LExpr  aller à l'état 73
 
 
état 142
 
   65 Statement: LEXICAL_RETURN_STMT L_PARENTHESIS RExpr R_PARENTHESIS . SEMICOLON
 
    SEMICOLON  décalage et aller à l'état 154
 
 
état 143
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS . LSQUI_BRACKET Statements RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET Statements RSQUI_BRACKET
   69               | LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS . LSQUI_BRACKET Statements RSQUI_BRACKET
 
    LSQUI_BRACKET  décalage et aller à l'état 155
 
 
état 144
 
   67 iteration_while: LEXICAL_WHILE_STMT L_PARENTHESIS RExpr R_PARENTHESIS . LSQUI_BRACKET Statements RSQUI_BRACKET
 
    LSQUI_BRACKET  décalage et aller à l'état 156
 
 
état 145
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements COLON . RExpr COLON Statements R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr  aller à l'état 157
    LExpr  aller à l'état 73
 
 
état 146
 
   52 ParamList_FunctionCall: RExpr COMMA . ParamList_FunctionCall
 
    NUMBER               décalage et aller à l'état 43
    LEXICAL_TRUE_VAL     décalage et aller à l'état 44
    LEXICAL_FALSE_VAL    décalage et aller à l'état 45
    LEXICAL_NOT          décalage et aller à l'état 46
    LEXICAL_MINUS        décalage et aller à l'état 47
    L_PARENTHESIS        décalage et aller à l'état 48
    LEXICAL_GET_OPS      décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS  décalage et aller à l'état 50
    ID                   décalage et aller à l'état 59
 
    RExpr                   aller à l'état 119
    LExpr                   aller à l'état 73
    ParamList_FunctionCall  aller à l'état 158
 
 
état 147
 
   46 RExpr: ID L_PARENTHESIS ParamList_FunctionCall R_PARENTHESIS .
 
    $défaut  réduction par utilisation de la règle 46 (RExpr)
 
 
état 148
 
   51 LExpr: ID LSQUA_BRACKET RExpr RSQUA_BRACKET .
 
    $défaut  réduction par utilisation de la règle 51 (LExpr)
 
 
état 149
 
   58 Statement: LExpr LEXICAL_AFFECTATION RExpr SEMICOLON .
 
    $défaut  réduction par utilisation de la règle 58 (Statement)
 
 
état 150
 
   10 FuncOrVar: L_PARENTHESIS ParamList R_PARENTHESIS PostFixeFunction .
 
    $défaut  réduction par utilisation de la règle 10 (FuncOrVar)
 
 
état 151
 
   62 Statement: LEXICAL_WRITE_OPS L_PARENTHESIS RExpr R_PARENTHESIS SEMICOLON .
 
    $défaut  réduction par utilisation de la règle 62 (Statement)
 
 
état 152
 
   63 Statement: LEXICAL_READ_OPS L_PARENTHESIS LExpr R_PARENTHESIS SEMICOLON .
 
    $défaut  réduction par utilisation de la règle 63 (Statement)
 
 
état 153
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   64 Statement: LEXICAL_PUT_OPS L_PARENTHESIS ID COMMA RExpr . R_PARENTHESIS SEMICOLON
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    R_PARENTHESIS        décalage et aller à l'état 159
 
 
état 154
 
   65 Statement: LEXICAL_RETURN_STMT L_PARENTHESIS RExpr R_PARENTHESIS SEMICOLON .
 
    $défaut  réduction par utilisation de la règle 65 (Statement)
 
 
état 155
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET . Statements RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET Statements RSQUI_BRACKET
   69               | LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET . Statements RSQUI_BRACKET
 
    NUMBER                    décalage et aller à l'état 43
    LEXICAL_TRUE_VAL          décalage et aller à l'état 44
    LEXICAL_FALSE_VAL         décalage et aller à l'état 45
    LEXICAL_NOT               décalage et aller à l'état 46
    LEXICAL_MINUS             décalage et aller à l'état 47
    L_PARENTHESIS             décalage et aller à l'état 48
    LEXICAL_GET_OPS           décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS       décalage et aller à l'état 50
    LEXICAL_WRITE_OPS         décalage et aller à l'état 51
    LEXICAL_READ_OPS          décalage et aller à l'état 52
    LEXICAL_PUT_OPS           décalage et aller à l'état 53
    LEXICAL_RETURN_STMT       décalage et aller à l'état 54
    LEXICAL_IF_STMT           décalage et aller à l'état 55
    LEXICAL_WHILE_STMT        décalage et aller à l'état 56
    LEXICAL_FLEXICAL_OR_STMT  décalage et aller à l'état 57
    SEMICOLON                 décalage et aller à l'état 58
    ID                        décalage et aller à l'état 59
 
    $défaut  réduction par utilisation de la règle 55 (Statements)
 
    RExpr            aller à l'état 60
    LExpr            aller à l'état 61
    Statements       aller à l'état 160
    Statement        aller à l'état 63
    iteration_for    aller à l'état 64
    iteration_while  aller à l'état 65
    if_instruction   aller à l'état 66
 
 
état 156
 
   67 iteration_while: LEXICAL_WHILE_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET . Statements RSQUI_BRACKET
 
    NUMBER                    décalage et aller à l'état 43
    LEXICAL_TRUE_VAL          décalage et aller à l'état 44
    LEXICAL_FALSE_VAL         décalage et aller à l'état 45
    LEXICAL_NOT               décalage et aller à l'état 46
    LEXICAL_MINUS             décalage et aller à l'état 47
    L_PARENTHESIS             décalage et aller à l'état 48
    LEXICAL_GET_OPS           décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS       décalage et aller à l'état 50
    LEXICAL_WRITE_OPS         décalage et aller à l'état 51
    LEXICAL_READ_OPS          décalage et aller à l'état 52
    LEXICAL_PUT_OPS           décalage et aller à l'état 53
    LEXICAL_RETURN_STMT       décalage et aller à l'état 54
    LEXICAL_IF_STMT           décalage et aller à l'état 55
    LEXICAL_WHILE_STMT        décalage et aller à l'état 56
    LEXICAL_FLEXICAL_OR_STMT  décalage et aller à l'état 57
    SEMICOLON                 décalage et aller à l'état 58
    ID                        décalage et aller à l'état 59
 
    $défaut  réduction par utilisation de la règle 55 (Statements)
 
    RExpr            aller à l'état 60
    LExpr            aller à l'état 61
    Statements       aller à l'état 161
    Statement        aller à l'état 63
    iteration_for    aller à l'état 64
    iteration_while  aller à l'état 65
    if_instruction   aller à l'état 66
 
 
état 157
 
   28 RExpr: RExpr . LEXICAL_AND RExpr
   29      | RExpr . LEXICAL_OR RExpr
   30      | RExpr . LEXICAL_ANDLAZY RExpr
   31      | RExpr . LEXICAL_ORLAZY RExpr
   36      | RExpr . LEXICAL_EQUALS RExpr
   37      | RExpr . LEXICAL_LESS_EQUALS RExpr
   38      | RExpr . LEXICAL_LESS RExpr
   39      | RExpr . LEXICAL_PLUS RExpr
   40      | RExpr . LEXICAL_MINUS RExpr
   41      | RExpr . LEXICAL_MULT RExpr
   42      | RExpr . LEXICAL_DIV RExpr
   43      | RExpr . LEXICAL_MOD RExpr
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements COLON RExpr . COLON Statements R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    LEXICAL_AND          décalage et aller à l'état 87
    LEXICAL_OR           décalage et aller à l'état 88
    LEXICAL_ANDLAZY      décalage et aller à l'état 89
    LEXICAL_ORLAZY       décalage et aller à l'état 90
    LEXICAL_EQUALS       décalage et aller à l'état 91
    LEXICAL_LESS_EQUALS  décalage et aller à l'état 92
    LEXICAL_LESS         décalage et aller à l'état 93
    LEXICAL_PLUS         décalage et aller à l'état 94
    LEXICAL_MINUS        décalage et aller à l'état 95
    LEXICAL_MULT         décalage et aller à l'état 96
    LEXICAL_DIV          décalage et aller à l'état 97
    LEXICAL_MOD          décalage et aller à l'état 98
    COLON                décalage et aller à l'état 162
 
 
état 158
 
   52 ParamList_FunctionCall: RExpr COMMA ParamList_FunctionCall .
 
    $défaut  réduction par utilisation de la règle 52 (ParamList_FunctionCall)
 
 
état 159
 
   64 Statement: LEXICAL_PUT_OPS L_PARENTHESIS ID COMMA RExpr R_PARENTHESIS . SEMICOLON
 
    SEMICOLON  décalage et aller à l'état 163
 
 
état 160
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements . RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET Statements RSQUI_BRACKET
   69               | LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements . RSQUI_BRACKET
 
    RSQUI_BRACKET  décalage et aller à l'état 164
 
 
état 161
 
   67 iteration_while: LEXICAL_WHILE_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements . RSQUI_BRACKET
 
    RSQUI_BRACKET  décalage et aller à l'état 165
 
 
état 162
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements COLON RExpr COLON . Statements R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    NUMBER                    décalage et aller à l'état 43
    LEXICAL_TRUE_VAL          décalage et aller à l'état 44
    LEXICAL_FALSE_VAL         décalage et aller à l'état 45
    LEXICAL_NOT               décalage et aller à l'état 46
    LEXICAL_MINUS             décalage et aller à l'état 47
    L_PARENTHESIS             décalage et aller à l'état 48
    LEXICAL_GET_OPS           décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS       décalage et aller à l'état 50
    LEXICAL_WRITE_OPS         décalage et aller à l'état 51
    LEXICAL_READ_OPS          décalage et aller à l'état 52
    LEXICAL_PUT_OPS           décalage et aller à l'état 53
    LEXICAL_RETURN_STMT       décalage et aller à l'état 54
    LEXICAL_IF_STMT           décalage et aller à l'état 55
    LEXICAL_WHILE_STMT        décalage et aller à l'état 56
    LEXICAL_FLEXICAL_OR_STMT  décalage et aller à l'état 57
    SEMICOLON                 décalage et aller à l'état 58
    ID                        décalage et aller à l'état 59
 
    $défaut  réduction par utilisation de la règle 55 (Statements)
 
    RExpr            aller à l'état 60
    LExpr            aller à l'état 61
    Statements       aller à l'état 166
    Statement        aller à l'état 63
    iteration_for    aller à l'état 64
    iteration_while  aller à l'état 65
    if_instruction   aller à l'état 66
 
 
état 163
 
   64 Statement: LEXICAL_PUT_OPS L_PARENTHESIS ID COMMA RExpr R_PARENTHESIS SEMICOLON .
 
    $défaut  réduction par utilisation de la règle 64 (Statement)
 
 
état 164
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET . LEXICAL_ELSE_STMT LSQUI_BRACKET Statements RSQUI_BRACKET
   69               | LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET .
 
    LEXICAL_ELSE_STMT  décalage et aller à l'état 167
 
    $défaut  réduction par utilisation de la règle 69 (if_instruction)
 
 
état 165
 
   67 iteration_while: LEXICAL_WHILE_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET .
 
    $défaut  réduction par utilisation de la règle 67 (iteration_while)
 
 
état 166
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements COLON RExpr COLON Statements . R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET
 
    R_PARENTHESIS  décalage et aller à l'état 168
 
 
état 167
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET LEXICAL_ELSE_STMT . LSQUI_BRACKET Statements RSQUI_BRACKET
 
    LSQUI_BRACKET  décalage et aller à l'état 169
 
 
état 168
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements COLON RExpr COLON Statements R_PARENTHESIS . LSQUI_BRACKET Statements RSQUI_BRACKET
 
    LSQUI_BRACKET  décalage et aller à l'état 170
 
 
état 169
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET . Statements RSQUI_BRACKET
 
    NUMBER                    décalage et aller à l'état 43
    LEXICAL_TRUE_VAL          décalage et aller à l'état 44
    LEXICAL_FALSE_VAL         décalage et aller à l'état 45
    LEXICAL_NOT               décalage et aller à l'état 46
    LEXICAL_MINUS             décalage et aller à l'état 47
    L_PARENTHESIS             décalage et aller à l'état 48
    LEXICAL_GET_OPS           décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS       décalage et aller à l'état 50
    LEXICAL_WRITE_OPS         décalage et aller à l'état 51
    LEXICAL_READ_OPS          décalage et aller à l'état 52
    LEXICAL_PUT_OPS           décalage et aller à l'état 53
    LEXICAL_RETURN_STMT       décalage et aller à l'état 54
    LEXICAL_IF_STMT           décalage et aller à l'état 55
    LEXICAL_WHILE_STMT        décalage et aller à l'état 56
    LEXICAL_FLEXICAL_OR_STMT  décalage et aller à l'état 57
    SEMICOLON                 décalage et aller à l'état 58
    ID                        décalage et aller à l'état 59
 
    $défaut  réduction par utilisation de la règle 55 (Statements)
 
    RExpr            aller à l'état 60
    LExpr            aller à l'état 61
    Statements       aller à l'état 171
    Statement        aller à l'état 63
    iteration_for    aller à l'état 64
    iteration_while  aller à l'état 65
    if_instruction   aller à l'état 66
 
 
état 170
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements COLON RExpr COLON Statements R_PARENTHESIS LSQUI_BRACKET . Statements RSQUI_BRACKET
 
    NUMBER                    décalage et aller à l'état 43
    LEXICAL_TRUE_VAL          décalage et aller à l'état 44
    LEXICAL_FALSE_VAL         décalage et aller à l'état 45
    LEXICAL_NOT               décalage et aller à l'état 46
    LEXICAL_MINUS             décalage et aller à l'état 47
    L_PARENTHESIS             décalage et aller à l'état 48
    LEXICAL_GET_OPS           décalage et aller à l'état 49
    LEXICAL_ISEMPTY_OPS       décalage et aller à l'état 50
    LEXICAL_WRITE_OPS         décalage et aller à l'état 51
    LEXICAL_READ_OPS          décalage et aller à l'état 52
    LEXICAL_PUT_OPS           décalage et aller à l'état 53
    LEXICAL_RETURN_STMT       décalage et aller à l'état 54
    LEXICAL_IF_STMT           décalage et aller à l'état 55
    LEXICAL_WHILE_STMT        décalage et aller à l'état 56
    LEXICAL_FLEXICAL_OR_STMT  décalage et aller à l'état 57
    SEMICOLON                 décalage et aller à l'état 58
    ID                        décalage et aller à l'état 59
 
    $défaut  réduction par utilisation de la règle 55 (Statements)
 
    RExpr            aller à l'état 60
    LExpr            aller à l'état 61
    Statements       aller à l'état 172
    Statement        aller à l'état 63
    iteration_for    aller à l'état 64
    iteration_while  aller à l'état 65
    if_instruction   aller à l'état 66
 
 
état 171
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET Statements . RSQUI_BRACKET
 
    RSQUI_BRACKET  décalage et aller à l'état 173
 
 
état 172
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements COLON RExpr COLON Statements R_PARENTHESIS LSQUI_BRACKET Statements . RSQUI_BRACKET
 
    RSQUI_BRACKET  décalage et aller à l'état 174
 
 
état 173
 
   68 if_instruction: LEXICAL_IF_STMT L_PARENTHESIS RExpr R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET LEXICAL_ELSE_STMT LSQUI_BRACKET Statements RSQUI_BRACKET .
 
    $défaut  réduction par utilisation de la règle 68 (if_instruction)
 
 
état 174
 
   66 iteration_for: LEXICAL_FLEXICAL_OR_STMT L_PARENTHESIS Statements COLON RExpr COLON Statements R_PARENTHESIS LSQUI_BRACKET Statements RSQUI_BRACKET .
 
    $défaut  réduction par utilisation de la règle 66 (iteration_for)
Retourner au début du code
Structure et Fichiers du projet

Afficher/masquer...
Répertoires contenus dans /var/www/bin/sniplets/lsd010/project/source/
Icône	Nom	Taille	Modification
Pas de sous-répertoires.
Icône	Nom	Taille	Modification
\| _	Répertoire parent	0 octets	1734857374 22/12/2024 09:49:34
Fichiers contenus dans /var/www/bin/sniplets/lsd010/project/source/
Icône	Nom	Taille	Modification	Action
Icône	Nom	Taille	Modification	Action
\|.o	graphVizHelper.o	4.72 Ko	31/10/2018 18:32:37	-refusé-
\|.c	ast.c	27.73 Ko	31/10/2018 18:32:37	-refusé-
\|.h	const.h	4.01 Ko	31/10/2018 18:32:37	-refusé-
\|.c	y.tab.c	84.53 Ko	31/10/2018 18:32:39	-refusé-
\|.y	lsd10.y	22.88 Ko	31/10/2018 18:32:38	-refusé-
\|.o	lex.yy.o	18.88 Ko	31/10/2018 18:32:38	-refusé-
\|.c	scopeStack.c	3.69 Ko	31/10/2018 18:32:38	-refusé-
\|.h	graphVizHelper.h	573 octets	31/10/2018 18:32:37	-refusé-
\|.h	symbolsTableDataRepresentation.h	1.31 Ko	31/10/2018 18:32:38	-refusé-
\|.o	symbolsTable.o	5.2 Ko	31/10/2018 18:32:38	-refusé-
\|.h	common.h	1.08 Ko	31/10/2018 18:32:37	-refusé-
\|.c	scopeHelper.c	4.09 Ko	31/10/2018 18:32:38	-refusé-
\|.o	hashCode.o	1.45 Ko	31/10/2018 18:32:37	-refusé-
\|.h	console.h	2.21 Ko	31/10/2018 18:32:37	-refusé-
\|.o	console.o	12.23 Ko	31/10/2018 18:32:37	-refusé-
\|lsd10	lsd10	75.26 Ko	31/10/2018 18:32:38	-refusé-
\|.h	hashCode.h	1020 octets	31/10/2018 18:32:37	-refusé-
\|.h	symbolsTable.h	2.65 Ko	31/10/2018 18:32:38	-refusé-
\|.h	pcode.h	417 octets	31/10/2018 18:32:38	-refusé-
\|.o	ast.o	11.45 Ko	31/10/2018 18:32:37	-refusé-
\|.h	scopeStack.h	2.2 Ko	31/10/2018 18:32:38	-refusé-
\|.c	graphVizHelper.c	6.11 Ko	31/10/2018 18:32:37	-refusé-
\|.l	lsd10.l	6.46 Ko	31/10/2018 18:32:38	-refusé-
\|.h	y.tab.h	4.69 Ko	31/10/2018 18:32:39	-refusé-
\|.output	y.output	81.69 Ko	31/10/2018 18:32:39	-refusé-
\|.o	y.tab.o	24.45 Ko	31/10/2018 18:32:39	-refusé-
\|.c	lex.yy.c	57.93 Ko	31/10/2018 18:32:37	-refusé-
\|.h	ast.h	2.39 Ko	31/10/2018 18:32:37	-refusé-
\|.o	scopeStack.o	1.34 Ko	31/10/2018 18:32:38	-refusé-
\|.o	scopeHelper.o	2.59 Ko	31/10/2018 18:32:38	-refusé-
\|.h	astDataRepresentation.h	1.87 Ko	31/10/2018 18:32:37	-refusé-
\|.c	symbolsTable.c	14.91 Ko	31/10/2018 18:32:38	-refusé-
\|.c	pcode.c	23.45 Ko	31/10/2018 18:32:38	-refusé-
\|.c	hashCode.c	3.94 Ko	31/10/2018 18:32:37	-refusé-
\|.c	console.c	18.01 Ko	31/10/2018 18:32:37	-refusé-
\|.h	scopeHelper.h	719 octets	31/10/2018 18:32:38	-refusé-
Avertissement
Ce code présente une manière possible d'implémenter un compilateur, et certains choix peuvent être discutés.
Cependant, il peut donner des pistes pour démarrer, ou approcher certains concepts, et je tenterais par la suite de mettre à jour le code.
Utilisation de l'explorateur de code
Navigation :
- Un clic sur une icône de répertoire ouvre ce répertoire pour en afficher les fichiers.
- Lorsque le répertoire en cours ne contient pas de sous-répertoires il est possible de remonter vers le répertoire parent.
- La structure de répertoires en treetable (tableau en forme d'arborescence) n'est plus possibledans cette version.
- Un clic sur une icône de fichier ouvre ce fichier pour en afficher le code avec la coloration syntaxique adaptée en fonction du langage principal utilisé dans le fichier.
Affichage :
- Il est possible de trier les répertoires ou les fichiers selon certains critères (nom, taille, date).
Actions :
- Les actions possible sur les fichiers dépendent de vos droits d'utilisateur sur le site. Veuillez activer le mode utilisateur pour activer les actions.
Version en cache
22/12/2024 09:49:33 Cette version de la page est en cache (à la date du 22/12/2024 09:49:33) afin d'accélérer le traitement. Vous pouvez activer le mode utilisateur dans le menu en haut pour afficher la dernère version de la page.
Document créé le 07/03/2010, dernière modification le 28/10/2018
Source du document imprimé : https://www.gaudry.be/langages-lsd10-source-rf-project/source//y.output.html
L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.
Notes
↑^a,b LSD⁰10 : Langage Simple et Didactique Il existe une un certain nombre d'interprétations de l'acronyme LSD (Langage Symbolique Didactique, Langage Sans Difficulté, Langage Simple et Didactique). LSD⁰10 est la version 2010 de la suite LSD80, LSD_02, LSD⁰3, LSD⁰4, LSD⁰5, LSD⁰6, LSD⁰7, LSD⁰8, et LSD⁰9.
Table des matières Haut
Références

IHDCB332 - Théorie des langages : Syntaxe et sémantique : PY Schobbens, Syntaxe et sémantique (January 2010)
Ces références et liens indiquent des documents consultés lors de la rédaction de cette page, ou qui peuvent apporter un complément d'information, mais les auteurs de ces sources ne peuvent être tenus responsables du contenu de cette page.
L'auteur de ce site est seul responsable de la manière dont sont présentés ici les différents concepts, et des libertés qui sont prises avec les ouvrages de référence. N'oubliez pas que vous devez croiser les informations de sources multiples afin de diminuer les risques d'erreurs.
Table des matières Haut