*wisent-log*

*** Wisent ooc-wisent-wy.el - 2010-07-18 00:13



Useless nonterminals:

   KW
   import_name
   import_path_part
   comment
   dot_optional
   dot_rest
   dots_optional
   WHITESPACE


Terminals which are not used:

   BREAK_KW
   CONTINUE_KW
   RETURN_KW
   FUNC_KW
   CLASS_KW
   COVER_KW
   ENUM_KW
   INTERFACE_KW
   FROM_KW
   ABSTRACT_KW
   FINAL_KW
   STATIC_KW
   INLINE_KW
   EXTENDS_KW
   EXTERN_KW
   UNMANGLED_KW
   IMPLEMENTS_KW
   INCLUDE_KW
   USE_KW
   IF_KW
   ELSE_KW
   FOR_KW
   WHILE_KW
   MATCH_KW
   CASE_KW
   AS_KW
   IN_KW
   VERSION_KW
   PROTO_KW
   SET_KW
   GET_KW
   OPERATOR_KW
   CONST_KW
   R_ARROW
   DOUBLE_ARROW
   ASS_DECL
   ASS_ADD
   ASS_SUB
   ASS_MUL
   OOCDOC_SINGLE_LINE_START
   COMMENT_SINGLE_LINE_START
   ASS_B_RSHIFT
   ASS_B_LSHIFT
   ASS_B_XOR
   ASS_B_OR
   ASS_B_AND
   QUEST
   L_OR
   L_AND
   B_XOR
   EQUALS
   NOT_EQUALS
   LESSTHAN
   MORETHAN
   CMP
   LESSTHAN_EQ
   MORETHAN_EQ
   B_LSHIFT
   B_RSHIFT
   L_NOT
   B_NOT
   PLUS
   MINUS
   PERCENT
   STAR
   BRACKET_BLOCK
   OPEN_BRACKET
   CLOSE_BRACKET
   TILDE
   SPACES
   EOL


Useless rules:

#7     KW: BREAK_KW;
#8     KW: CONTINUE_KW;
#9     KW: RETURN_KW;
#10    KW: FUNC_KW;
#11    KW: COVER_KW;
#12    KW: ENUM_KW;
#13    KW: FROM_KW;
#14    KW: ABSTRACT_KW;
#15    KW: FINAL_KW;
#16    KW: STATIC_KW;
#17    KW: INLINE_KW;
#18    KW: EXTENDS_KW;
#19    KW: EXTERN_KW;
#20    KW: UNMANGLED_KW;
#21    KW: IMPORT_KW;
#22    KW: INCLUDE_KW;
#23    KW: IF_KW;
#24    KW: ELSE_KW;
#25    KW: FOR_KW;
#26    KW: WHILE_KW;
#27    KW: AS_KW;
#28    KW: OPERATOR_KW;
#29    KW: CONST_KW;
#30    KW: NULL_KW;
#31    KW: MATCH_KW;
#32    KW: CASE_KW;
#43    import_name: ALPHANUMERIC;
#46    import_path_part: alphanumeric_dot;
#47    comment:;
#69    dot_optional:;
#70    dot_optional: DOT;
#71    dot_rest: dot_optional;
#72    dot_rest: dot_rest dot_optional;
#73    dots_optional:;
#74    dots_optional: DOTS;
#80    WHITESPACE:;
#81    WHITESPACE: SPACES;
#82    WHITESPACE: EOL;
#83    WHITESPACE: comment;


State 11 contains 2 shift/reduce conflicts.
State 27 contains 1 reduce/reduce conflict.
State 47 contains 2 shift/reduce conflicts.
State 49 contains 2 shift/reduce conflicts.
State 50 contains 2 shift/reduce conflicts.
State 51 contains 2 shift/reduce conflicts.


Grammar

  Number, Rule
  1       $STARTS -> $goal
  2       $STARTS -> $tuple_item
  3       $STARTS -> $array_literal_item
  4       $goal -> $$goal goal
  5       $tuple_item -> $$tuple_item tuple_item
  6       $array_literal_item -> $$array_literal_item array_literal_item
  33      goal -> statement
  34      statement -> import
  35      statement -> tuple
  36      statement -> expression
  37      import -> IMPORT_KW import_list
  38      import_list -> import_atom
  39      import_list -> import_list COMMA import_atom
  40      import_atom -> import_atom_part
  41      import_atom -> import_atom_part INTO_KW identifier
  42      import_atom_part -> import_path
  44      import_path -> alphanumeric_dot
  45      import_path -> import_path ASS_DIV alphanumeric_dot
  48      array_literal -> SQUARE_BLOCK
  49      array_literal_item -> OPEN_SQUARE expression CLOSE_SQUARE
  50      tuple -> PAREN_BLOCK
  51      tuple_item -> OPEN_PAREN expression CLOSE_PAREN
  52      expression -> value_core
  53      value_core -> number_literal
  54      value_core -> STRING_LITERAL
  55      value_core -> BOOLEAN_LITERAL
  56      value_core -> NULL_KW
  57      value_core -> array_literal
  58      value_core -> tuple
  59      number_literal -> integer_literal
  60      number_literal -> FLOAT_LITERAL
  61      number_literal -> BIN_LITERAL
  62      integer_literal -> OCT_LITERAL
  63      integer_literal -> HEX_LITERAL
  64      integer_literal -> DEC_LITERAL
  65      identifier -> ALPHANUMERIC
  66      identifier -> IDENTIFIER
  67      alphanumeric_dot -> dots_rest ALPHANUMERIC dots_rest
  68      alphanumeric_dot -> alphanumeric_dot ALPHANUMERIC dots_rest
  75      dots_rest -> /* empty */
  76      dots_rest -> DOTS
  77      dots_rest -> dots_rest DOTS
  78      DOTS -> DOT
  79      DOTS -> DOUBLE_DOT
  84      BOOLEAN_LITERAL -> TRUE_KW
  85      BOOLEAN_LITERAL -> FALSE_KW


Terminals, with rules where they appear

$EOI (-1)
error (1)
BREAK_KW (2) 7
CONTINUE_KW (3) 8
RETURN_KW (4) 9
FUNC_KW (5) 10
CLASS_KW (6)
COVER_KW (7) 11
ENUM_KW (8) 12
INTERFACE_KW (9)
FROM_KW (10) 13
ABSTRACT_KW (11) 14
FINAL_KW (12) 15
STATIC_KW (13) 16
INLINE_KW (14) 17
EXTENDS_KW (15) 18
EXTERN_KW (16) 19
UNMANGLED_KW (17) 20
IMPLEMENTS_KW (18)
IMPORT_KW (19) 21 37
INCLUDE_KW (20) 22
USE_KW (21)
IF_KW (22) 23
ELSE_KW (23) 24
FOR_KW (24) 25
WHILE_KW (25) 26
MATCH_KW (26) 31
CASE_KW (27) 32
AS_KW (28) 27
IN_KW (29)
INTO_KW (30) 41
VERSION_KW (31)
PROTO_KW (32)
SET_KW (33)
GET_KW (34)
OPERATOR_KW (35) 28
CONST_KW (36) 29
TRUE_KW (37) 84
FALSE_KW (38) 85
NULL_KW (39) 30 56
COMMA (40) 39
DOUBLE_DOT (41) 79
DOT (42) 70 78
R_ARROW (43)
DOUBLE_ARROW (44)
ASS_DECL (45)
ASS_ADD (46)
ASS_SUB (47)
ASS_MUL (48)
OOCDOC_SINGLE_LINE_START (49)
COMMENT_SINGLE_LINE_START (50)
ASS_DIV (51) 45
ASS_B_RSHIFT (52)
ASS_B_LSHIFT (53)
ASS_B_XOR (54)
ASS_B_OR (55)
ASS_B_AND (56)
QUEST (57)
L_OR (58)
L_AND (59)
B_XOR (60)
EQUALS (61)
NOT_EQUALS (62)
LESSTHAN (63)
MORETHAN (64)
CMP (65)
LESSTHAN_EQ (66)
MORETHAN_EQ (67)
B_LSHIFT (68)
B_RSHIFT (69)
L_NOT (70)
B_NOT (71)
PLUS (72)
MINUS (73)
PERCENT (74)
STAR (75)
PAREN_BLOCK (76) 50
SQUARE_BLOCK (77) 48
BRACKET_BLOCK (78)
OPEN_PAREN (79) 51
CLOSE_PAREN (80) 51
OPEN_SQUARE (81) 49
CLOSE_SQUARE (82) 49
OPEN_BRACKET (83)
CLOSE_BRACKET (84)
DEC_LITERAL (85) 64
FLOAT_LITERAL (86) 60
OCT_LITERAL (87) 62
BIN_LITERAL (88) 61
HEX_LITERAL (89) 63
TILDE (90)
STRING_LITERAL (91) 54
ALPHANUMERIC (92) 43 65 67 68
IDENTIFIER (93) 66
SPACES (94) 81
EOL (95) 82
$$array_literal_item (96) 6
$$tuple_item (97) 5
$$goal (98) 4


Nonterminals, with rules where they appear

goal (99)
    on left: 33, on right: 4
statement (100)
    on left: 34 35 36, on right: 33
import (101)
    on left: 37, on right: 34
import_list (102)
    on left: 38 39, on right: 37 39
import_atom (103)
    on left: 40 41, on right: 38 39
import_atom_part (104)
    on left: 42, on right: 40 41
import_path (105)
    on left: 44 45, on right: 42 45
array_literal (106)
    on left: 48, on right: 57
array_literal_item (107)
    on left: 49, on right: 6
tuple (108)
    on left: 50, on right: 35 58
tuple_item (109)
    on left: 51, on right: 5
expression (110)
    on left: 52, on right: 36 49 51
value_core (111)
    on left: 53 54 55 56 57 58, on right: 52
number_literal (112)
    on left: 59 60 61, on right: 53
integer_literal (113)
    on left: 62 63 64, on right: 59
identifier (114)
    on left: 65 66, on right: 41
alphanumeric_dot (115)
    on left: 67 68, on right: 44 45 46 68
dots_rest (116)
    on left: 75 76 77, on right: 67 68 77
DOTS (117)
    on left: 78 79, on right: 74 76 77
BOOLEAN_LITERAL (118)
    on left: 84 85, on right: 55
$array_literal_item (119)
    on left: 6, on right: 3
$tuple_item (120)
    on left: 5, on right: 2
$goal (121)
    on left: 4, on right: 1
$STARTS (122)
    on left: 1 2 3


state 0

    $$array_literal_item	shift, and go to state 1
    $$tuple_item	shift, and go to state 2
    $$goal	shift, and go to state 3

    $array_literal_item	go to state 4
    $tuple_item	go to state 5
    $goal	go to state 6
    $STARTS	go to state 60



state 1

    $array_literal_item  ->  $$array_literal_item . array_literal_item   (rule 6)

    OPEN_SQUARE	shift, and go to state 7

    array_literal_item	go to state 8



state 2

    $tuple_item  ->  $$tuple_item . tuple_item   (rule 5)

    OPEN_PAREN	shift, and go to state 9

    tuple_item	go to state 10



state 3

    $goal  ->  $$goal . goal   (rule 4)

    IMPORT_KW	shift, and go to state 11
    TRUE_KW	shift, and go to state 12
    FALSE_KW	shift, and go to state 13
    NULL_KW	shift, and go to state 14
    PAREN_BLOCK	shift, and go to state 15
    SQUARE_BLOCK	shift, and go to state 16
    DEC_LITERAL	shift, and go to state 17
    FLOAT_LITERAL	shift, and go to state 18
    OCT_LITERAL	shift, and go to state 19
    BIN_LITERAL	shift, and go to state 20
    HEX_LITERAL	shift, and go to state 21
    STRING_LITERAL	shift, and go to state 22

    goal	go to state 23
    statement	go to state 24
    import	go to state 25
    array_literal	go to state 26
    tuple	go to state 27
    expression	go to state 28
    value_core	go to state 29
    number_literal	go to state 30
    integer_literal	go to state 31
    BOOLEAN_LITERAL	go to state 32



state 4

    $STARTS  ->  $array_literal_item .   (rule 3)

    $default	reduce using rule 3 ($STARTS)



state 5

    $STARTS  ->  $tuple_item .   (rule 2)

    $default	reduce using rule 2 ($STARTS)



state 6

    $STARTS  ->  $goal .   (rule 1)

    $default	reduce using rule 1 ($STARTS)



state 7

    array_literal_item  ->  OPEN_SQUARE . expression CLOSE_SQUARE   (rule 49)

    TRUE_KW	shift, and go to state 12
    FALSE_KW	shift, and go to state 13
    NULL_KW	shift, and go to state 14
    PAREN_BLOCK	shift, and go to state 15
    SQUARE_BLOCK	shift, and go to state 16
    DEC_LITERAL	shift, and go to state 17
    FLOAT_LITERAL	shift, and go to state 18
    OCT_LITERAL	shift, and go to state 19
    BIN_LITERAL	shift, and go to state 20
    HEX_LITERAL	shift, and go to state 21
    STRING_LITERAL	shift, and go to state 22

    array_literal	go to state 26
    tuple	go to state 33
    expression	go to state 34
    value_core	go to state 29
    number_literal	go to state 30
    integer_literal	go to state 31
    BOOLEAN_LITERAL	go to state 32



state 8

    $array_literal_item  ->  $$array_literal_item array_literal_item .   (rule 6)

    $default	reduce using rule 6 ($array_literal_item)



state 9

    tuple_item  ->  OPEN_PAREN . expression CLOSE_PAREN   (rule 51)

    TRUE_KW	shift, and go to state 12
    FALSE_KW	shift, and go to state 13
    NULL_KW	shift, and go to state 14
    PAREN_BLOCK	shift, and go to state 15
    SQUARE_BLOCK	shift, and go to state 16
    DEC_LITERAL	shift, and go to state 17
    FLOAT_LITERAL	shift, and go to state 18
    OCT_LITERAL	shift, and go to state 19
    BIN_LITERAL	shift, and go to state 20
    HEX_LITERAL	shift, and go to state 21
    STRING_LITERAL	shift, and go to state 22

    array_literal	go to state 26
    tuple	go to state 33
    expression	go to state 35
    value_core	go to state 29
    number_literal	go to state 30
    integer_literal	go to state 31
    BOOLEAN_LITERAL	go to state 32



state 10

    $tuple_item  ->  $$tuple_item tuple_item .   (rule 5)

    $default	reduce using rule 5 ($tuple_item)



state 11

    import  ->  IMPORT_KW . import_list   (rule 37)

    DOUBLE_DOT	shift, and go to state 36
    DOT	shift, and go to state 37

    DOUBLE_DOT	[reduce using rule 75 (dots_rest)]
    DOT	[reduce using rule 75 (dots_rest)]
    $default	reduce using rule 75 (dots_rest)

    import_list	go to state 38
    import_atom	go to state 39
    import_atom_part	go to state 40
    import_path	go to state 41
    alphanumeric_dot	go to state 42
    dots_rest	go to state 43
    DOTS	go to state 44



state 12

    BOOLEAN_LITERAL  ->  TRUE_KW .   (rule 84)

    $default	reduce using rule 84 (BOOLEAN_LITERAL)



state 13

    BOOLEAN_LITERAL  ->  FALSE_KW .   (rule 85)

    $default	reduce using rule 85 (BOOLEAN_LITERAL)



state 14

    value_core  ->  NULL_KW .   (rule 56)

    $default	reduce using rule 56 (value_core)



state 15

    tuple  ->  PAREN_BLOCK .   (rule 50)

    $default	reduce using rule 50 (tuple)



state 16

    array_literal  ->  SQUARE_BLOCK .   (rule 48)

    $default	reduce using rule 48 (array_literal)



state 17

    integer_literal  ->  DEC_LITERAL .   (rule 64)

    $default	reduce using rule 64 (integer_literal)



state 18

    number_literal  ->  FLOAT_LITERAL .   (rule 60)

    $default	reduce using rule 60 (number_literal)



state 19

    integer_literal  ->  OCT_LITERAL .   (rule 62)

    $default	reduce using rule 62 (integer_literal)



state 20

    number_literal  ->  BIN_LITERAL .   (rule 61)

    $default	reduce using rule 61 (number_literal)



state 21

    integer_literal  ->  HEX_LITERAL .   (rule 63)

    $default	reduce using rule 63 (integer_literal)



state 22

    value_core  ->  STRING_LITERAL .   (rule 54)

    $default	reduce using rule 54 (value_core)



state 23

    $goal  ->  $$goal goal .   (rule 4)

    $default	reduce using rule 4 ($goal)



state 24

    goal  ->  statement .   (rule 33)

    $default	reduce using rule 33 (goal)



state 25

    statement  ->  import .   (rule 34)

    $default	reduce using rule 34 (statement)



state 26

    value_core  ->  array_literal .   (rule 57)

    $default	reduce using rule 57 (value_core)



state 27

    statement  ->  tuple .   (rule 35)
    value_core  ->  tuple .   (rule 58)

    $EOI	reduce using rule 35 (statement)
    $EOI	[reduce using rule 58 (value_core)]
    $default	reduce using rule 35 (statement)


state 28

    statement  ->  expression .   (rule 36)

    $default	reduce using rule 36 (statement)



state 29

    expression  ->  value_core .   (rule 52)

    $default	reduce using rule 52 (expression)



state 30

    value_core  ->  number_literal .   (rule 53)

    $default	reduce using rule 53 (value_core)



state 31

    number_literal  ->  integer_literal .   (rule 59)

    $default	reduce using rule 59 (number_literal)



state 32

    value_core  ->  BOOLEAN_LITERAL .   (rule 55)

    $default	reduce using rule 55 (value_core)



state 33

    value_core  ->  tuple .   (rule 58)

    $default	reduce using rule 58 (value_core)



state 34

    array_literal_item  ->  OPEN_SQUARE expression . CLOSE_SQUARE   (rule 49)

    CLOSE_SQUARE	shift, and go to state 45



state 35

    tuple_item  ->  OPEN_PAREN expression . CLOSE_PAREN   (rule 51)

    CLOSE_PAREN	shift, and go to state 46



state 36

    DOTS  ->  DOUBLE_DOT .   (rule 79)

    $default	reduce using rule 79 (DOTS)



state 37

    DOTS  ->  DOT .   (rule 78)

    $default	reduce using rule 78 (DOTS)



state 38

    import  ->  IMPORT_KW import_list .   (rule 37)
    import_list  ->  import_list . COMMA import_atom   (rule 39)

    COMMA	shift, and go to state 47

    $default	reduce using rule 37 (import)



state 39

    import_list  ->  import_atom .   (rule 38)

    $default	reduce using rule 38 (import_list)



state 40

    import_atom  ->  import_atom_part .   (rule 40)
    import_atom  ->  import_atom_part . INTO_KW identifier   (rule 41)

    INTO_KW	shift, and go to state 48

    $default	reduce using rule 40 (import_atom)



state 41

    import_atom_part  ->  import_path .   (rule 42)
    import_path  ->  import_path . ASS_DIV alphanumeric_dot   (rule 45)

    ASS_DIV	shift, and go to state 49

    $default	reduce using rule 42 (import_atom_part)



state 42

    import_path  ->  alphanumeric_dot .   (rule 44)
    alphanumeric_dot  ->  alphanumeric_dot . ALPHANUMERIC dots_rest   (rule 68)

    ALPHANUMERIC	shift, and go to state 50

    $default	reduce using rule 44 (import_path)



state 43

    alphanumeric_dot  ->  dots_rest . ALPHANUMERIC dots_rest   (rule 67)
    dots_rest  ->  dots_rest . DOTS   (rule 77)

    DOUBLE_DOT	shift, and go to state 36
    DOT	shift, and go to state 37
    ALPHANUMERIC	shift, and go to state 51

    DOTS	go to state 52



state 44

    dots_rest  ->  DOTS .   (rule 76)

    $default	reduce using rule 76 (dots_rest)



state 45

    array_literal_item  ->  OPEN_SQUARE expression CLOSE_SQUARE .   (rule 49)

    $default	reduce using rule 49 (array_literal_item)



state 46

    tuple_item  ->  OPEN_PAREN expression CLOSE_PAREN .   (rule 51)

    $default	reduce using rule 51 (tuple_item)



state 47

    import_list  ->  import_list COMMA . import_atom   (rule 39)

    DOUBLE_DOT	shift, and go to state 36
    DOT	shift, and go to state 37

    DOUBLE_DOT	[reduce using rule 75 (dots_rest)]
    DOT	[reduce using rule 75 (dots_rest)]
    $default	reduce using rule 75 (dots_rest)

    import_atom	go to state 53
    import_atom_part	go to state 40
    import_path	go to state 41
    alphanumeric_dot	go to state 42
    dots_rest	go to state 43
    DOTS	go to state 44



state 48

    import_atom  ->  import_atom_part INTO_KW . identifier   (rule 41)

    ALPHANUMERIC	shift, and go to state 54
    IDENTIFIER	shift, and go to state 55

    identifier	go to state 56



state 49

    import_path  ->  import_path ASS_DIV . alphanumeric_dot   (rule 45)

    DOUBLE_DOT	shift, and go to state 36
    DOT	shift, and go to state 37

    DOUBLE_DOT	[reduce using rule 75 (dots_rest)]
    DOT	[reduce using rule 75 (dots_rest)]
    $default	reduce using rule 75 (dots_rest)

    alphanumeric_dot	go to state 57
    dots_rest	go to state 43
    DOTS	go to state 44



state 50

    alphanumeric_dot  ->  alphanumeric_dot ALPHANUMERIC . dots_rest   (rule 68)

    DOUBLE_DOT	shift, and go to state 36
    DOT	shift, and go to state 37

    DOUBLE_DOT	[reduce using rule 75 (dots_rest)]
    DOT	[reduce using rule 75 (dots_rest)]
    $default	reduce using rule 75 (dots_rest)

    dots_rest	go to state 58
    DOTS	go to state 44



state 51

    alphanumeric_dot  ->  dots_rest ALPHANUMERIC . dots_rest   (rule 67)

    DOUBLE_DOT	shift, and go to state 36
    DOT	shift, and go to state 37

    DOUBLE_DOT	[reduce using rule 75 (dots_rest)]
    DOT	[reduce using rule 75 (dots_rest)]
    $default	reduce using rule 75 (dots_rest)

    dots_rest	go to state 59
    DOTS	go to state 44



state 52

    dots_rest  ->  dots_rest DOTS .   (rule 77)

    $default	reduce using rule 77 (dots_rest)



state 53

    import_list  ->  import_list COMMA import_atom .   (rule 39)

    $default	reduce using rule 39 (import_list)



state 54

    identifier  ->  ALPHANUMERIC .   (rule 65)

    $default	reduce using rule 65 (identifier)



state 55

    identifier  ->  IDENTIFIER .   (rule 66)

    $default	reduce using rule 66 (identifier)



state 56

    import_atom  ->  import_atom_part INTO_KW identifier .   (rule 41)

    $default	reduce using rule 41 (import_atom)



state 57

    import_path  ->  import_path ASS_DIV alphanumeric_dot .   (rule 45)
    alphanumeric_dot  ->  alphanumeric_dot . ALPHANUMERIC dots_rest   (rule 68)

    ALPHANUMERIC	shift, and go to state 50

    $default	reduce using rule 45 (import_path)



state 58

    alphanumeric_dot  ->  alphanumeric_dot ALPHANUMERIC dots_rest .   (rule 68)
    dots_rest  ->  dots_rest . DOTS   (rule 77)

    DOUBLE_DOT	shift, and go to state 36
    DOT	shift, and go to state 37

    $default	reduce using rule 68 (alphanumeric_dot)

    DOTS	go to state 52



state 59

    alphanumeric_dot  ->  dots_rest ALPHANUMERIC dots_rest .   (rule 67)
    dots_rest  ->  dots_rest . DOTS   (rule 77)

    DOUBLE_DOT	shift, and go to state 36
    DOT	shift, and go to state 37

    $default	reduce using rule 67 (alphanumeric_dot)

    DOTS	go to state 52



state 60

    $EOI	shift, and go to state 61



state 61

    $EOI	shift, and go to state 62



state 62

    $default	accept