parser.out

Created by PLY version 3.10 (http://www.dabeaz.com/ply)

Unused terminals:

    EQEQ
    FLOWERCLOSE
    IF
    GREATEREQ
    FLOWEROPEN
    NOTEQ
    GREATER
    AND
    NAME
    LESSEREQ
    LESSER
    OR

Grammar

Rule 0     S' -> start
Rule 1     start -> assign
Rule 2     start -> fLoop stmt
Rule 3     start -> fLoop stmt start
Rule 4     start -> assign start
Rule 5     start -> assign fLoop start
Rule 6     start -> stmt
Rule 7     stmt -> PRINT VAR
Rule 8     assign -> factor EQUAL expr
Rule 9     expr -> expr PLUS term
Rule 10    expr -> expr MINUS term
Rule 11    expr -> term
Rule 12    term -> term MULTIPLY factor
Rule 13    term -> term DIVIDE factor
Rule 14    term -> factor
Rule 15    factor -> VAR
Rule 16    factor -> NUMBER
Rule 17    fLoop -> FOR inner
Rule 18    inner -> PARANOPEN VAR IN rangeSpec PARANCLOSE COLON
Rule 19    inner -> VAR IN rangeSpec COLON
Rule 20    rangeSpec -> RANGE PARANOPEN expr COMMA expr PARANCLOSE

Terminals, with rules where they appear

AND                  : 
COLON                : 18 19
COMMA                : 20
DIVIDE               : 13
EQEQ                 : 
EQUAL                : 8
FLOWERCLOSE          : 
FLOWEROPEN           : 
FOR                  : 17
GREATER              : 
GREATEREQ            : 
IF                   : 
IN                   : 18 19
LESSER               : 
LESSEREQ             : 
MINUS                : 10
MULTIPLY             : 12
NAME                 : 
NOTEQ                : 
NUMBER               : 16
OR                   : 
PARANCLOSE           : 18 20
PARANOPEN            : 18 20
PLUS                 : 9
PRINT                : 7
RANGE                : 20
VAR                  : 7 15 18 19
error                : 

Nonterminals, with rules where they appear

assign               : 1 4 5
expr                 : 8 9 10 20 20
fLoop                : 2 3 5
factor               : 8 12 13 14
inner                : 17
rangeSpec            : 18 19
start                : 3 4 5 0
stmt                 : 2 3 6
term                 : 9 10 11 12 13

Parsing method: LALR

state 0

    (0) S' -> . start
    (1) start -> . assign
    (2) start -> . fLoop stmt
    (3) start -> . fLoop stmt start
    (4) start -> . assign start
    (5) start -> . assign fLoop start
    (6) start -> . stmt
    (8) assign -> . factor EQUAL expr
    (17) fLoop -> . FOR inner
    (7) stmt -> . PRINT VAR
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    FOR             shift and go to state 2
    PRINT           shift and go to state 7
    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    fLoop                          shift and go to state 1
    stmt                           shift and go to state 3
    start                          shift and go to state 5
    factor                         shift and go to state 6
    assign                         shift and go to state 9

state 1

    (2) start -> fLoop . stmt
    (3) start -> fLoop . stmt start
    (7) stmt -> . PRINT VAR

    PRINT           shift and go to state 7

    stmt                           shift and go to state 10

state 2

    (17) fLoop -> FOR . inner
    (18) inner -> . PARANOPEN VAR IN rangeSpec PARANCLOSE COLON
    (19) inner -> . VAR IN rangeSpec COLON

    PARANOPEN       shift and go to state 11
    VAR             shift and go to state 13

    inner                          shift and go to state 12

state 3

    (6) start -> stmt .

    $end            reduce using rule 6 (start -> stmt .)


state 4

    (16) factor -> NUMBER .

    EQUAL           reduce using rule 16 (factor -> NUMBER .)
    MULTIPLY        reduce using rule 16 (factor -> NUMBER .)
    DIVIDE          reduce using rule 16 (factor -> NUMBER .)
    PLUS            reduce using rule 16 (factor -> NUMBER .)
    MINUS           reduce using rule 16 (factor -> NUMBER .)
    FOR             reduce using rule 16 (factor -> NUMBER .)
    PRINT           reduce using rule 16 (factor -> NUMBER .)
    VAR             reduce using rule 16 (factor -> NUMBER .)
    NUMBER          reduce using rule 16 (factor -> NUMBER .)
    $end            reduce using rule 16 (factor -> NUMBER .)
    COMMA           reduce using rule 16 (factor -> NUMBER .)
    PARANCLOSE      reduce using rule 16 (factor -> NUMBER .)


state 5

    (0) S' -> start .



state 6

    (8) assign -> factor . EQUAL expr

    EQUAL           shift and go to state 14


state 7

    (7) stmt -> PRINT . VAR

    VAR             shift and go to state 15


state 8

    (15) factor -> VAR .

    EQUAL           reduce using rule 15 (factor -> VAR .)
    MULTIPLY        reduce using rule 15 (factor -> VAR .)
    DIVIDE          reduce using rule 15 (factor -> VAR .)
    PLUS            reduce using rule 15 (factor -> VAR .)
    MINUS           reduce using rule 15 (factor -> VAR .)
    FOR             reduce using rule 15 (factor -> VAR .)
    PRINT           reduce using rule 15 (factor -> VAR .)
    VAR             reduce using rule 15 (factor -> VAR .)
    NUMBER          reduce using rule 15 (factor -> VAR .)
    $end            reduce using rule 15 (factor -> VAR .)
    COMMA           reduce using rule 15 (factor -> VAR .)
    PARANCLOSE      reduce using rule 15 (factor -> VAR .)


state 9

    (1) start -> assign .
    (4) start -> assign . start
    (5) start -> assign . fLoop start
    (1) start -> . assign
    (2) start -> . fLoop stmt
    (3) start -> . fLoop stmt start
    (4) start -> . assign start
    (5) start -> . assign fLoop start
    (6) start -> . stmt
    (17) fLoop -> . FOR inner
    (8) assign -> . factor EQUAL expr
    (7) stmt -> . PRINT VAR
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    $end            reduce using rule 1 (start -> assign .)
    FOR             shift and go to state 2
    PRINT           shift and go to state 7
    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    fLoop                          shift and go to state 16
    stmt                           shift and go to state 3
    start                          shift and go to state 17
    factor                         shift and go to state 6
    assign                         shift and go to state 9

state 10

    (2) start -> fLoop stmt .
    (3) start -> fLoop stmt . start
    (1) start -> . assign
    (2) start -> . fLoop stmt
    (3) start -> . fLoop stmt start
    (4) start -> . assign start
    (5) start -> . assign fLoop start
    (6) start -> . stmt
    (8) assign -> . factor EQUAL expr
    (17) fLoop -> . FOR inner
    (7) stmt -> . PRINT VAR
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    $end            reduce using rule 2 (start -> fLoop stmt .)
    FOR             shift and go to state 2
    PRINT           shift and go to state 7
    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    fLoop                          shift and go to state 1
    stmt                           shift and go to state 3
    start                          shift and go to state 18
    factor                         shift and go to state 6
    assign                         shift and go to state 9

state 11

    (18) inner -> PARANOPEN . VAR IN rangeSpec PARANCLOSE COLON

    VAR             shift and go to state 19


state 12

    (17) fLoop -> FOR inner .

    PRINT           reduce using rule 17 (fLoop -> FOR inner .)
    FOR             reduce using rule 17 (fLoop -> FOR inner .)
    VAR             reduce using rule 17 (fLoop -> FOR inner .)
    NUMBER          reduce using rule 17 (fLoop -> FOR inner .)


state 13

    (19) inner -> VAR . IN rangeSpec COLON

    IN              shift and go to state 20


state 14

    (8) assign -> factor EQUAL . expr
    (9) expr -> . expr PLUS term
    (10) expr -> . expr MINUS term
    (11) expr -> . term
    (12) term -> . term MULTIPLY factor
    (13) term -> . term DIVIDE factor
    (14) term -> . factor
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    expr                           shift and go to state 22
    term                           shift and go to state 21
    factor                         shift and go to state 23

state 15

    (7) stmt -> PRINT VAR .

    $end            reduce using rule 7 (stmt -> PRINT VAR .)
    FOR             reduce using rule 7 (stmt -> PRINT VAR .)
    PRINT           reduce using rule 7 (stmt -> PRINT VAR .)
    VAR             reduce using rule 7 (stmt -> PRINT VAR .)
    NUMBER          reduce using rule 7 (stmt -> PRINT VAR .)


state 16

    (5) start -> assign fLoop . start
    (2) start -> fLoop . stmt
    (3) start -> fLoop . stmt start
    (1) start -> . assign
    (2) start -> . fLoop stmt
    (3) start -> . fLoop stmt start
    (4) start -> . assign start
    (5) start -> . assign fLoop start
    (6) start -> . stmt
    (7) stmt -> . PRINT VAR
    (8) assign -> . factor EQUAL expr
    (17) fLoop -> . FOR inner
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    PRINT           shift and go to state 7
    FOR             shift and go to state 2
    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    fLoop                          shift and go to state 1
    stmt                           shift and go to state 24
    start                          shift and go to state 25
    factor                         shift and go to state 6
    assign                         shift and go to state 9

state 17

    (4) start -> assign start .

    $end            reduce using rule 4 (start -> assign start .)


state 18

    (3) start -> fLoop stmt start .

    $end            reduce using rule 3 (start -> fLoop stmt start .)


state 19

    (18) inner -> PARANOPEN VAR . IN rangeSpec PARANCLOSE COLON

    IN              shift and go to state 26


state 20

    (19) inner -> VAR IN . rangeSpec COLON
    (20) rangeSpec -> . RANGE PARANOPEN expr COMMA expr PARANCLOSE

    RANGE           shift and go to state 27

    rangeSpec                      shift and go to state 28

state 21

    (11) expr -> term .
    (12) term -> term . MULTIPLY factor
    (13) term -> term . DIVIDE factor

    PARANCLOSE      reduce using rule 11 (expr -> term .)
    PLUS            reduce using rule 11 (expr -> term .)
    MINUS           reduce using rule 11 (expr -> term .)
    FOR             reduce using rule 11 (expr -> term .)
    PRINT           reduce using rule 11 (expr -> term .)
    VAR             reduce using rule 11 (expr -> term .)
    NUMBER          reduce using rule 11 (expr -> term .)
    $end            reduce using rule 11 (expr -> term .)
    COMMA           reduce using rule 11 (expr -> term .)
    MULTIPLY        shift and go to state 29
    DIVIDE          shift and go to state 30


state 22

    (8) assign -> factor EQUAL expr .
    (9) expr -> expr . PLUS term
    (10) expr -> expr . MINUS term

    FOR             reduce using rule 8 (assign -> factor EQUAL expr .)
    PRINT           reduce using rule 8 (assign -> factor EQUAL expr .)
    VAR             reduce using rule 8 (assign -> factor EQUAL expr .)
    NUMBER          reduce using rule 8 (assign -> factor EQUAL expr .)
    $end            reduce using rule 8 (assign -> factor EQUAL expr .)
    PLUS            shift and go to state 31
    MINUS           shift and go to state 32


state 23

    (14) term -> factor .

    MULTIPLY        reduce using rule 14 (term -> factor .)
    DIVIDE          reduce using rule 14 (term -> factor .)
    COMMA           reduce using rule 14 (term -> factor .)
    PLUS            reduce using rule 14 (term -> factor .)
    MINUS           reduce using rule 14 (term -> factor .)
    PARANCLOSE      reduce using rule 14 (term -> factor .)
    FOR             reduce using rule 14 (term -> factor .)
    PRINT           reduce using rule 14 (term -> factor .)
    VAR             reduce using rule 14 (term -> factor .)
    NUMBER          reduce using rule 14 (term -> factor .)
    $end            reduce using rule 14 (term -> factor .)


state 24

    (2) start -> fLoop stmt .
    (3) start -> fLoop stmt . start
    (6) start -> stmt .
    (1) start -> . assign
    (2) start -> . fLoop stmt
    (3) start -> . fLoop stmt start
    (4) start -> . assign start
    (5) start -> . assign fLoop start
    (6) start -> . stmt
    (8) assign -> . factor EQUAL expr
    (17) fLoop -> . FOR inner
    (7) stmt -> . PRINT VAR
    (15) factor -> . VAR
    (16) factor -> . NUMBER

  ! reduce/reduce conflict for $end resolved using rule 2 (start -> fLoop stmt .)
    $end            reduce using rule 2 (start -> fLoop stmt .)
    FOR             shift and go to state 2
    PRINT           shift and go to state 7
    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

  ! $end            [ reduce using rule 6 (start -> stmt .) ]

    fLoop                          shift and go to state 1
    stmt                           shift and go to state 3
    start                          shift and go to state 18
    factor                         shift and go to state 6
    assign                         shift and go to state 9

state 25

    (5) start -> assign fLoop start .

    $end            reduce using rule 5 (start -> assign fLoop start .)


state 26

    (18) inner -> PARANOPEN VAR IN . rangeSpec PARANCLOSE COLON
    (20) rangeSpec -> . RANGE PARANOPEN expr COMMA expr PARANCLOSE

    RANGE           shift and go to state 27

    rangeSpec                      shift and go to state 33

state 27

    (20) rangeSpec -> RANGE . PARANOPEN expr COMMA expr PARANCLOSE

    PARANOPEN       shift and go to state 34


state 28

    (19) inner -> VAR IN rangeSpec . COLON

    COLON           shift and go to state 35


state 29

    (12) term -> term MULTIPLY . factor
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    factor                         shift and go to state 36

state 30

    (13) term -> term DIVIDE . factor
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    factor                         shift and go to state 37

state 31

    (9) expr -> expr PLUS . term
    (12) term -> . term MULTIPLY factor
    (13) term -> . term DIVIDE factor
    (14) term -> . factor
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    term                           shift and go to state 38
    factor                         shift and go to state 23

state 32

    (10) expr -> expr MINUS . term
    (12) term -> . term MULTIPLY factor
    (13) term -> . term DIVIDE factor
    (14) term -> . factor
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    term                           shift and go to state 39
    factor                         shift and go to state 23

state 33

    (18) inner -> PARANOPEN VAR IN rangeSpec . PARANCLOSE COLON

    PARANCLOSE      shift and go to state 40


state 34

    (20) rangeSpec -> RANGE PARANOPEN . expr COMMA expr PARANCLOSE
    (9) expr -> . expr PLUS term
    (10) expr -> . expr MINUS term
    (11) expr -> . term
    (12) term -> . term MULTIPLY factor
    (13) term -> . term DIVIDE factor
    (14) term -> . factor
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    expr                           shift and go to state 41
    term                           shift and go to state 21
    factor                         shift and go to state 23

state 35

    (19) inner -> VAR IN rangeSpec COLON .

    PRINT           reduce using rule 19 (inner -> VAR IN rangeSpec COLON .)
    FOR             reduce using rule 19 (inner -> VAR IN rangeSpec COLON .)
    VAR             reduce using rule 19 (inner -> VAR IN rangeSpec COLON .)
    NUMBER          reduce using rule 19 (inner -> VAR IN rangeSpec COLON .)


state 36

    (12) term -> term MULTIPLY factor .

    MULTIPLY        reduce using rule 12 (term -> term MULTIPLY factor .)
    DIVIDE          reduce using rule 12 (term -> term MULTIPLY factor .)
    COMMA           reduce using rule 12 (term -> term MULTIPLY factor .)
    PLUS            reduce using rule 12 (term -> term MULTIPLY factor .)
    MINUS           reduce using rule 12 (term -> term MULTIPLY factor .)
    PARANCLOSE      reduce using rule 12 (term -> term MULTIPLY factor .)
    FOR             reduce using rule 12 (term -> term MULTIPLY factor .)
    PRINT           reduce using rule 12 (term -> term MULTIPLY factor .)
    VAR             reduce using rule 12 (term -> term MULTIPLY factor .)
    NUMBER          reduce using rule 12 (term -> term MULTIPLY factor .)
    $end            reduce using rule 12 (term -> term MULTIPLY factor .)


state 37

    (13) term -> term DIVIDE factor .

    MULTIPLY        reduce using rule 13 (term -> term DIVIDE factor .)
    DIVIDE          reduce using rule 13 (term -> term DIVIDE factor .)
    COMMA           reduce using rule 13 (term -> term DIVIDE factor .)
    PLUS            reduce using rule 13 (term -> term DIVIDE factor .)
    MINUS           reduce using rule 13 (term -> term DIVIDE factor .)
    PARANCLOSE      reduce using rule 13 (term -> term DIVIDE factor .)
    FOR             reduce using rule 13 (term -> term DIVIDE factor .)
    PRINT           reduce using rule 13 (term -> term DIVIDE factor .)
    VAR             reduce using rule 13 (term -> term DIVIDE factor .)
    NUMBER          reduce using rule 13 (term -> term DIVIDE factor .)
    $end            reduce using rule 13 (term -> term DIVIDE factor .)


state 38

    (9) expr -> expr PLUS term .
    (12) term -> term . MULTIPLY factor
    (13) term -> term . DIVIDE factor

    PARANCLOSE      reduce using rule 9 (expr -> expr PLUS term .)
    PLUS            reduce using rule 9 (expr -> expr PLUS term .)
    MINUS           reduce using rule 9 (expr -> expr PLUS term .)
    FOR             reduce using rule 9 (expr -> expr PLUS term .)
    PRINT           reduce using rule 9 (expr -> expr PLUS term .)
    VAR             reduce using rule 9 (expr -> expr PLUS term .)
    NUMBER          reduce using rule 9 (expr -> expr PLUS term .)
    $end            reduce using rule 9 (expr -> expr PLUS term .)
    COMMA           reduce using rule 9 (expr -> expr PLUS term .)
    MULTIPLY        shift and go to state 29
    DIVIDE          shift and go to state 30


state 39

    (10) expr -> expr MINUS term .
    (12) term -> term . MULTIPLY factor
    (13) term -> term . DIVIDE factor

    PARANCLOSE      reduce using rule 10 (expr -> expr MINUS term .)
    PLUS            reduce using rule 10 (expr -> expr MINUS term .)
    MINUS           reduce using rule 10 (expr -> expr MINUS term .)
    FOR             reduce using rule 10 (expr -> expr MINUS term .)
    PRINT           reduce using rule 10 (expr -> expr MINUS term .)
    VAR             reduce using rule 10 (expr -> expr MINUS term .)
    NUMBER          reduce using rule 10 (expr -> expr MINUS term .)
    $end            reduce using rule 10 (expr -> expr MINUS term .)
    COMMA           reduce using rule 10 (expr -> expr MINUS term .)
    MULTIPLY        shift and go to state 29
    DIVIDE          shift and go to state 30


state 40

    (18) inner -> PARANOPEN VAR IN rangeSpec PARANCLOSE . COLON

    COLON           shift and go to state 42


state 41

    (20) rangeSpec -> RANGE PARANOPEN expr . COMMA expr PARANCLOSE
    (9) expr -> expr . PLUS term
    (10) expr -> expr . MINUS term

    COMMA           shift and go to state 43
    PLUS            shift and go to state 31
    MINUS           shift and go to state 32


state 42

    (18) inner -> PARANOPEN VAR IN rangeSpec PARANCLOSE COLON .

    PRINT           reduce using rule 18 (inner -> PARANOPEN VAR IN rangeSpec PARANCLOSE COLON .)
    FOR             reduce using rule 18 (inner -> PARANOPEN VAR IN rangeSpec PARANCLOSE COLON .)
    VAR             reduce using rule 18 (inner -> PARANOPEN VAR IN rangeSpec PARANCLOSE COLON .)
    NUMBER          reduce using rule 18 (inner -> PARANOPEN VAR IN rangeSpec PARANCLOSE COLON .)


state 43

    (20) rangeSpec -> RANGE PARANOPEN expr COMMA . expr PARANCLOSE
    (9) expr -> . expr PLUS term
    (10) expr -> . expr MINUS term
    (11) expr -> . term
    (12) term -> . term MULTIPLY factor
    (13) term -> . term DIVIDE factor
    (14) term -> . factor
    (15) factor -> . VAR
    (16) factor -> . NUMBER

    VAR             shift and go to state 8
    NUMBER          shift and go to state 4

    expr                           shift and go to state 44
    term                           shift and go to state 21
    factor                         shift and go to state 23

state 44

    (20) rangeSpec -> RANGE PARANOPEN expr COMMA expr . PARANCLOSE
    (9) expr -> expr . PLUS term
    (10) expr -> expr . MINUS term

    PARANCLOSE      shift and go to state 45
    PLUS            shift and go to state 31
    MINUS           shift and go to state 32


state 45

    (20) rangeSpec -> RANGE PARANOPEN expr COMMA expr PARANCLOSE .

    COLON           reduce using rule 20 (rangeSpec -> RANGE PARANOPEN expr COMMA expr PARANCLOSE .)
    PARANCLOSE      reduce using rule 20 (rangeSpec -> RANGE PARANOPEN expr COMMA expr PARANCLOSE .)

WARNING: 
WARNING: Conflicts:
WARNING: 
WARNING: reduce/reduce conflict in state 24 resolved using rule (start -> fLoop stmt)
WARNING: rejected rule (start -> stmt) in state 24