compiler.output

Terminaux inutilisés dans la grammaire

   CONST
   LIGN
   STRING_PRINTF
   FLOAT_PRINTF
   VOID
   RETURN


Grammaire

    0 $accept: main $end

    1 main: INT MAIN OP CP body

    2 $@1: %empty

    3 body: OA $@1 body_main CA

    4 body_main: instruction body_main
    5          | %empty

    6 instruction: declaration
    7            | affectation
    8            | printf
    9            | ifElse
   10            | while

   11 declaration: INT NOM PV
   12            | INT NOM VIR decSuite
   13            | INT NOM EGALE expression PV

   14 decSuite: NOM VIR decSuite
   15         | NOM PV

   16 affectation: NOM EGALE expression PV

   17 expression: expression PLUS expression
   18           | expression MOINS expression
   19           | expression MUL expression
   20           | expression DIV expression
   21           | NOM
   22           | NB
   23           | OP expression CP

   24 printf: PRINTF OP body_printf CP PV

   25 body_printf: QUOTE NOM QUOTE
   26            | QUOTE NOM INT_PRINTF QUOTE VIR NOM

   27 ifAction: %empty

   28 ifElse: IF OP test CP ifAction body

   29 $@2: %empty

   30 ifElse: IF OP test CP ifAction body ELSE $@2 body

   31 test: NOM
   32     | NB
   33     | test EGALE EGALE test
   34     | test SUP test
   35     | test INF test
   36     | test SUP EGALE test
   37     | test INF EGALE test

   38 @3: %empty

   39 $@4: %empty

   40 while: WHILE @3 OP test CP $@4 body


Terminaux, suivis des règles où ils apparaissent

$end (0) 0
error (256)
IF (258) 28 30
WHILE (259) 40
ELSE (260) 30
PRINTF (261) 24
MAIN (262) 1
OA (263) 3
CA (264) 3
CONST (265)
INT (266) 1 11 12 13
NOM (267) 11 12 13 14 15 16 21 25 26 31
PLUS (268) 17
MOINS (269) 18
MUL (270) 19
DIV (271) 20
EGALE (272) 13 16 33 36 37
OP (273) 1 23 24 28 30 40
CP (274) 1 23 24 28 30 40
LIGN (275)
PV (276) 11 13 15 16 24
QUOTE (277) 25 26
INT_PRINTF (278) 26
STRING_PRINTF (279)
FLOAT_PRINTF (280)
VIR (281) 12 14 26
NB (282) 22 32
INF (283) 35 37
SUP (284) 34 36
VOID (285)
RETURN (286)
IFREDUCE (287)


Non-terminaux, suivis des règles où ils apparaissent

$accept (33)
    à gauche: 0
main (34)
    à gauche: 1, à droite: 0
body (35)
    à gauche: 3, à droite: 1 28 30 40
$@1 (36)
    à gauche: 2, à droite: 3
body_main (37)
    à gauche: 4 5, à droite: 3 4
instruction (38)
    à gauche: 6 7 8 9 10, à droite: 4
declaration (39)
    à gauche: 11 12 13, à droite: 6
decSuite (40)
    à gauche: 14 15, à droite: 12 14
affectation (41)
    à gauche: 16, à droite: 7
expression (42)
    à gauche: 17 18 19 20 21 22 23, à droite: 13 16 17 18 19 20 23
printf (43)
    à gauche: 24, à droite: 8
body_printf (44)
    à gauche: 25 26, à droite: 24
ifAction (45)
    à gauche: 27, à droite: 28 30
ifElse (46)
    à gauche: 28 30, à droite: 9
$@2 (47)
    à gauche: 29, à droite: 30
test (48)
    à gauche: 31 32 33 34 35 36 37, à droite: 28 30 33 34 35 36 37
    40
while (49)
    à gauche: 40, à droite: 10
@3 (50)
    à gauche: 38, à droite: 40
$@4 (51)
    à gauche: 39, à droite: 40


État 0

    0 $accept: . main $end

    INT  décalage et aller à l'état 1

    main  aller à l'état 2


État 1

    1 main: INT . MAIN OP CP body

    MAIN  décalage et aller à l'état 3


État 2

    0 $accept: main . $end

    $end  décalage et aller à l'état 4


État 3

    1 main: INT MAIN . OP CP body

    OP  décalage et aller à l'état 5


État 4

    0 $accept: main $end .

    $défaut  accepter


État 5

    1 main: INT MAIN OP . CP body

    CP  décalage et aller à l'état 6


État 6

    1 main: INT MAIN OP CP . body

    OA  décalage et aller à l'état 7

    body  aller à l'état 8


État 7

    3 body: OA . $@1 body_main CA

    $défaut  réduction par utilisation de la règle 2 ($@1)

    $@1  aller à l'état 9


État 8

    1 main: INT MAIN OP CP body .

    $défaut  réduction par utilisation de la règle 1 (main)


État 9

    3 body: OA $@1 . body_main CA

    IF      décalage et aller à l'état 10
    WHILE   décalage et aller à l'état 11
    PRINTF  décalage et aller à l'état 12
    INT     décalage et aller à l'état 13
    NOM     décalage et aller à l'état 14

    $défaut  réduction par utilisation de la règle 5 (body_main)

    body_main    aller à l'état 15
    instruction  aller à l'état 16
    declaration  aller à l'état 17
    affectation  aller à l'état 18
    printf       aller à l'état 19
    ifElse       aller à l'état 20
    while        aller à l'état 21


État 10

   28 ifElse: IF . OP test CP ifAction body
   30       | IF . OP test CP ifAction body ELSE $@2 body

    OP  décalage et aller à l'état 22


État 11

   40 while: WHILE . @3 OP test CP $@4 body

    $défaut  réduction par utilisation de la règle 38 (@3)

    @3  aller à l'état 23


État 12

   24 printf: PRINTF . OP body_printf CP PV

    OP  décalage et aller à l'état 24


État 13

   11 declaration: INT . NOM PV
   12            | INT . NOM VIR decSuite
   13            | INT . NOM EGALE expression PV

    NOM  décalage et aller à l'état 25


État 14

   16 affectation: NOM . EGALE expression PV

    EGALE  décalage et aller à l'état 26


État 15

    3 body: OA $@1 body_main . CA

    CA  décalage et aller à l'état 27


État 16

    4 body_main: instruction . body_main

    IF      décalage et aller à l'état 10
    WHILE   décalage et aller à l'état 11
    PRINTF  décalage et aller à l'état 12
    INT     décalage et aller à l'état 13
    NOM     décalage et aller à l'état 14

    $défaut  réduction par utilisation de la règle 5 (body_main)

    body_main    aller à l'état 28
    instruction  aller à l'état 16
    declaration  aller à l'état 17
    affectation  aller à l'état 18
    printf       aller à l'état 19
    ifElse       aller à l'état 20
    while        aller à l'état 21


État 17

    6 instruction: declaration .

    $défaut  réduction par utilisation de la règle 6 (instruction)


État 18

    7 instruction: affectation .

    $défaut  réduction par utilisation de la règle 7 (instruction)


État 19

    8 instruction: printf .

    $défaut  réduction par utilisation de la règle 8 (instruction)


État 20

    9 instruction: ifElse .

    $défaut  réduction par utilisation de la règle 9 (instruction)


État 21

   10 instruction: while .

    $défaut  réduction par utilisation de la règle 10 (instruction)


État 22

   28 ifElse: IF OP . test CP ifAction body
   30       | IF OP . test CP ifAction body ELSE $@2 body

    NOM  décalage et aller à l'état 29
    NB   décalage et aller à l'état 30

    test  aller à l'état 31


État 23

   40 while: WHILE @3 . OP test CP $@4 body

    OP  décalage et aller à l'état 32


État 24

   24 printf: PRINTF OP . body_printf CP PV

    QUOTE  décalage et aller à l'état 33

    body_printf  aller à l'état 34


État 25

   11 declaration: INT NOM . PV
   12            | INT NOM . VIR decSuite
   13            | INT NOM . EGALE expression PV

    EGALE  décalage et aller à l'état 35
    PV     décalage et aller à l'état 36
    VIR    décalage et aller à l'état 37


État 26

   16 affectation: NOM EGALE . expression PV

    NOM  décalage et aller à l'état 38
    OP   décalage et aller à l'état 39
    NB   décalage et aller à l'état 40

    expression  aller à l'état 41


État 27

    3 body: OA $@1 body_main CA .

    $défaut  réduction par utilisation de la règle 3 (body)


État 28

    4 body_main: instruction body_main .

    $défaut  réduction par utilisation de la règle 4 (body_main)


État 29

   31 test: NOM .

    $défaut  réduction par utilisation de la règle 31 (test)


État 30

   32 test: NB .

    $défaut  réduction par utilisation de la règle 32 (test)


État 31

   28 ifElse: IF OP test . CP ifAction body
   30       | IF OP test . CP ifAction body ELSE $@2 body
   33 test: test . EGALE EGALE test
   34     | test . SUP test
   35     | test . INF test
   36     | test . SUP EGALE test
   37     | test . INF EGALE test

    EGALE  décalage et aller à l'état 42
    CP     décalage et aller à l'état 43
    INF    décalage et aller à l'état 44
    SUP    décalage et aller à l'état 45


État 32

   40 while: WHILE @3 OP . test CP $@4 body

    NOM  décalage et aller à l'état 29
    NB   décalage et aller à l'état 30

    test  aller à l'état 46


État 33

   25 body_printf: QUOTE . NOM QUOTE
   26            | QUOTE . NOM INT_PRINTF QUOTE VIR NOM

    NOM  décalage et aller à l'état 47


État 34

   24 printf: PRINTF OP body_printf . CP PV

    CP  décalage et aller à l'état 48


État 35

   13 declaration: INT NOM EGALE . expression PV

    NOM  décalage et aller à l'état 38
    OP   décalage et aller à l'état 39
    NB   décalage et aller à l'état 40

    expression  aller à l'état 49


État 36

   11 declaration: INT NOM PV .

    $défaut  réduction par utilisation de la règle 11 (declaration)


État 37

   12 declaration: INT NOM VIR . decSuite

    NOM  décalage et aller à l'état 50

    decSuite  aller à l'état 51


État 38

   21 expression: NOM .

    $défaut  réduction par utilisation de la règle 21 (expression)


État 39

   23 expression: OP . expression CP

    NOM  décalage et aller à l'état 38
    OP   décalage et aller à l'état 39
    NB   décalage et aller à l'état 40

    expression  aller à l'état 52


État 40

   22 expression: NB .

    $défaut  réduction par utilisation de la règle 22 (expression)


État 41

   16 affectation: NOM EGALE expression . PV
   17 expression: expression . PLUS expression
   18           | expression . MOINS expression
   19           | expression . MUL expression
   20           | expression . DIV expression

    PLUS   décalage et aller à l'état 53
    MOINS  décalage et aller à l'état 54
    MUL    décalage et aller à l'état 55
    DIV    décalage et aller à l'état 56
    PV     décalage et aller à l'état 57


État 42

   33 test: test EGALE . EGALE test

    EGALE  décalage et aller à l'état 58


État 43

   28 ifElse: IF OP test CP . ifAction body
   30       | IF OP test CP . ifAction body ELSE $@2 body

    $défaut  réduction par utilisation de la règle 27 (ifAction)

    ifAction  aller à l'état 59


État 44

   35 test: test INF . test
   37     | test INF . EGALE test

    NOM    décalage et aller à l'état 29
    EGALE  décalage et aller à l'état 60
    NB     décalage et aller à l'état 30

    test  aller à l'état 61


État 45

   34 test: test SUP . test
   36     | test SUP . EGALE test

    NOM    décalage et aller à l'état 29
    EGALE  décalage et aller à l'état 62
    NB     décalage et aller à l'état 30

    test  aller à l'état 63


État 46

   33 test: test . EGALE EGALE test
   34     | test . SUP test
   35     | test . INF test
   36     | test . SUP EGALE test
   37     | test . INF EGALE test
   40 while: WHILE @3 OP test . CP $@4 body

    EGALE  décalage et aller à l'état 42
    CP     décalage et aller à l'état 64
    INF    décalage et aller à l'état 44
    SUP    décalage et aller à l'état 45


État 47

   25 body_printf: QUOTE NOM . QUOTE
   26            | QUOTE NOM . INT_PRINTF QUOTE VIR NOM

    QUOTE       décalage et aller à l'état 65
    INT_PRINTF  décalage et aller à l'état 66


État 48

   24 printf: PRINTF OP body_printf CP . PV

    PV  décalage et aller à l'état 67


État 49

   13 declaration: INT NOM EGALE expression . PV
   17 expression: expression . PLUS expression
   18           | expression . MOINS expression
   19           | expression . MUL expression
   20           | expression . DIV expression

    PLUS   décalage et aller à l'état 53
    MOINS  décalage et aller à l'état 54
    MUL    décalage et aller à l'état 55
    DIV    décalage et aller à l'état 56
    PV     décalage et aller à l'état 68


État 50

   14 decSuite: NOM . VIR decSuite
   15         | NOM . PV

    PV   décalage et aller à l'état 69
    VIR  décalage et aller à l'état 70


État 51

   12 declaration: INT NOM VIR decSuite .

    $défaut  réduction par utilisation de la règle 12 (declaration)


État 52

   17 expression: expression . PLUS expression
   18           | expression . MOINS expression
   19           | expression . MUL expression
   20           | expression . DIV expression
   23           | OP expression . CP

    PLUS   décalage et aller à l'état 53
    MOINS  décalage et aller à l'état 54
    MUL    décalage et aller à l'état 55
    DIV    décalage et aller à l'état 56
    CP     décalage et aller à l'état 71


État 53

   17 expression: expression PLUS . expression

    NOM  décalage et aller à l'état 38
    OP   décalage et aller à l'état 39
    NB   décalage et aller à l'état 40

    expression  aller à l'état 72


État 54

   18 expression: expression MOINS . expression

    NOM  décalage et aller à l'état 38
    OP   décalage et aller à l'état 39
    NB   décalage et aller à l'état 40

    expression  aller à l'état 73


État 55

   19 expression: expression MUL . expression

    NOM  décalage et aller à l'état 38
    OP   décalage et aller à l'état 39
    NB   décalage et aller à l'état 40

    expression  aller à l'état 74


État 56

   20 expression: expression DIV . expression

    NOM  décalage et aller à l'état 38
    OP   décalage et aller à l'état 39
    NB   décalage et aller à l'état 40

    expression  aller à l'état 75


État 57

   16 affectation: NOM EGALE expression PV .

    $défaut  réduction par utilisation de la règle 16 (affectation)


État 58

   33 test: test EGALE EGALE . test

    NOM  décalage et aller à l'état 29
    NB   décalage et aller à l'état 30

    test  aller à l'état 76


État 59

   28 ifElse: IF OP test CP ifAction . body
   30       | IF OP test CP ifAction . body ELSE $@2 body

    OA  décalage et aller à l'état 7

    body  aller à l'état 77


État 60

   37 test: test INF EGALE . test

    NOM  décalage et aller à l'état 29
    NB   décalage et aller à l'état 30

    test  aller à l'état 78


État 61

   33 test: test . EGALE EGALE test
   34     | test . SUP test
   35     | test . INF test
   35     | test INF test .
   36     | test . SUP EGALE test
   37     | test . INF EGALE test

    $défaut  réduction par utilisation de la règle 35 (test)


État 62

   36 test: test SUP EGALE . test

    NOM  décalage et aller à l'état 29
    NB   décalage et aller à l'état 30

    test  aller à l'état 79


État 63

   33 test: test . EGALE EGALE test
   34     | test . SUP test
   34     | test SUP test .
   35     | test . INF test
   36     | test . SUP EGALE test
   37     | test . INF EGALE test

    $défaut  réduction par utilisation de la règle 34 (test)


État 64

   40 while: WHILE @3 OP test CP . $@4 body

    $défaut  réduction par utilisation de la règle 39 ($@4)

    $@4  aller à l'état 80


État 65

   25 body_printf: QUOTE NOM QUOTE .

    $défaut  réduction par utilisation de la règle 25 (body_printf)


État 66

   26 body_printf: QUOTE NOM INT_PRINTF . QUOTE VIR NOM

    QUOTE  décalage et aller à l'état 81


État 67

   24 printf: PRINTF OP body_printf CP PV .

    $défaut  réduction par utilisation de la règle 24 (printf)


État 68

   13 declaration: INT NOM EGALE expression PV .

    $défaut  réduction par utilisation de la règle 13 (declaration)


État 69

   15 decSuite: NOM PV .

    $défaut  réduction par utilisation de la règle 15 (decSuite)


État 70

   14 decSuite: NOM VIR . decSuite

    NOM  décalage et aller à l'état 50

    decSuite  aller à l'état 82


État 71

   23 expression: OP expression CP .

    $défaut  réduction par utilisation de la règle 23 (expression)


État 72

   17 expression: expression . PLUS expression
   17           | expression PLUS expression .
   18           | expression . MOINS expression
   19           | expression . MUL expression
   20           | expression . DIV expression

    MUL  décalage et aller à l'état 55
    DIV  décalage et aller à l'état 56

    $défaut  réduction par utilisation de la règle 17 (expression)


État 73

   17 expression: expression . PLUS expression
   18           | expression . MOINS expression
   18           | expression MOINS expression .
   19           | expression . MUL expression
   20           | expression . DIV expression

    MUL  décalage et aller à l'état 55
    DIV  décalage et aller à l'état 56

    $défaut  réduction par utilisation de la règle 18 (expression)


État 74

   17 expression: expression . PLUS expression
   18           | expression . MOINS expression
   19           | expression . MUL expression
   19           | expression MUL expression .
   20           | expression . DIV expression

    $défaut  réduction par utilisation de la règle 19 (expression)


État 75

   17 expression: expression . PLUS expression
   18           | expression . MOINS expression
   19           | expression . MUL expression
   20           | expression . DIV expression
   20           | expression DIV expression .

    $défaut  réduction par utilisation de la règle 20 (expression)


État 76

   33 test: test . EGALE EGALE test
   33     | test EGALE EGALE test .
   34     | test . SUP test
   35     | test . INF test
   36     | test . SUP EGALE test
   37     | test . INF EGALE test

    $défaut  réduction par utilisation de la règle 33 (test)


État 77

   28 ifElse: IF OP test CP ifAction body .
   30       | IF OP test CP ifAction body . ELSE $@2 body

    ELSE  décalage et aller à l'état 83

    $défaut  réduction par utilisation de la règle 28 (ifElse)


État 78

   33 test: test . EGALE EGALE test
   34     | test . SUP test
   35     | test . INF test
   36     | test . SUP EGALE test
   37     | test . INF EGALE test
   37     | test INF EGALE test .

    $défaut  réduction par utilisation de la règle 37 (test)


État 79

   33 test: test . EGALE EGALE test
   34     | test . SUP test
   35     | test . INF test
   36     | test . SUP EGALE test
   36     | test SUP EGALE test .
   37     | test . INF EGALE test

    $défaut  réduction par utilisation de la règle 36 (test)


État 80

   40 while: WHILE @3 OP test CP $@4 . body

    OA  décalage et aller à l'état 7

    body  aller à l'état 84


État 81

   26 body_printf: QUOTE NOM INT_PRINTF QUOTE . VIR NOM

    VIR  décalage et aller à l'état 85


État 82

   14 decSuite: NOM VIR decSuite .

    $défaut  réduction par utilisation de la règle 14 (decSuite)


État 83

   30 ifElse: IF OP test CP ifAction body ELSE . $@2 body

    $défaut  réduction par utilisation de la règle 29 ($@2)

    $@2  aller à l'état 86


État 84

   40 while: WHILE @3 OP test CP $@4 body .

    $défaut  réduction par utilisation de la règle 40 (while)


État 85

   26 body_printf: QUOTE NOM INT_PRINTF QUOTE VIR . NOM

    NOM  décalage et aller à l'état 87


État 86

   30 ifElse: IF OP test CP ifAction body ELSE $@2 . body

    OA  décalage et aller à l'état 7

    body  aller à l'état 88


État 87

   26 body_printf: QUOTE NOM INT_PRINTF QUOTE VIR NOM .

    $défaut  réduction par utilisation de la règle 26 (body_printf)


État 88

   30 ifElse: IF OP test CP ifAction body ELSE $@2 body .

    $défaut  réduction par utilisation de la règle 30 (ifElse)