Attachment 931656 Details for Bug 1134556 – parser.out

parser.out

parser.out (text/plain), 55.85 KB, created by Brian Lane on 2014-08-27 18:58:04 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Brian Lane

Created: 2014-08-27 18:58:04 UTC

Size: 55.85 KB

patch

obsolete

>Created by PLY version 3.0 (http://www.dabeaz.com/ply)
>
>Grammar
>
>Rule 1     S' -> mof
>Rule 2     mof -> mofItemList
>Rule 3     mofItemList -> empty
>Rule 4     mofItemList -> mofItemList mofItem
>Rule 5     mofItem -> pragma
>Rule 6     mofItem -> IDENTIFIER
>Rule 7     mofItem -> literal
>Rule 8     mofItem -> value
>Rule 9     pragma -> # PRAGMA pragmaName ( pragmaParameter )
>Rule 10    pragmaName -> identifier
>Rule 11    pragmaParameter -> stringValue
>Rule 12    value -> integerValue
>Rule 13    value -> floatValue
>Rule 14    value -> charValue
>Rule 15    value -> stringValue
>Rule 16    value -> booleanValue
>Rule 17    value -> nullValue
>Rule 18    literal -> (
>Rule 19    literal -> )
>Rule 20    literal -> {
>Rule 21    literal -> }
>Rule 22    literal -> ;
>Rule 23    literal -> [
>Rule 24    literal -> ]
>Rule 25    literal -> ,
>Rule 26    literal -> $
>Rule 27    literal -> :
>Rule 28    literal -> =
>Rule 29    integerValue -> binaryValue
>Rule 30    integerValue -> octalValue
>Rule 31    integerValue -> decimalValue
>Rule 32    integerValue -> hexValue
>Rule 33    booleanValue -> FALSE
>Rule 34    booleanValue -> TRUE
>Rule 35    nullValue -> NULL
>Rule 36    identifier -> IDENTIFIER
>Rule 37    empty -> <empty>
>
>Terminals, with rules where they appear
>
>#                    : 8
>$                    : 25
>(                    : 8 17
>)                    : 8 18
>,                    : 24
>:                    : 26
>;                    : 21
>=                    : 27
>FALSE                : 32
>IDENTIFIER           : 5 35
>NULL                 : 34
>PRAGMA               : 8
>TRUE                 : 33
>[                    : 22
>]                    : 23
>binaryValue          : 28
>charValue            : 13
>decimalValue         : 30
>error                : 
>floatValue           : 12
>hexValue             : 31
>octalValue           : 29
>stringValue          : 10 14
>{                    : 19
>}                    : 20
>
>Nonterminals, with rules where they appear
>
>booleanValue         : 15
>empty                : 2
>identifier           : 9
>integerValue         : 11
>literal              : 6
>mof                  : 0
>mofItem              : 3
>mofItemList          : 1 3
>nullValue            : 16
>pragma               : 4
>pragmaName           : 8
>pragmaParameter      : 8
>value                : 7
>
>Parsing method: LALR
>
>state 0
>
>    (0) S' -> . mof
>    (1) mof -> . mofItemList
>    (2) mofItemList -> . empty
>    (3) mofItemList -> . mofItemList mofItem
>    (36) empty -> .
>
>    IDENTIFIER      reduce using rule 36 (empty -> .)
>    #               reduce using rule 36 (empty -> .)
>    (               reduce using rule 36 (empty -> .)
>    )               reduce using rule 36 (empty -> .)
>    {               reduce using rule 36 (empty -> .)
>    }               reduce using rule 36 (empty -> .)
>    ;               reduce using rule 36 (empty -> .)
>    [               reduce using rule 36 (empty -> .)
>    ]               reduce using rule 36 (empty -> .)
>    ,               reduce using rule 36 (empty -> .)
>    $               reduce using rule 36 (empty -> .)
>    :               reduce using rule 36 (empty -> .)
>    =               reduce using rule 36 (empty -> .)
>    floatValue      reduce using rule 36 (empty -> .)
>    charValue       reduce using rule 36 (empty -> .)
>    stringValue     reduce using rule 36 (empty -> .)
>    binaryValue     reduce using rule 36 (empty -> .)
>    octalValue      reduce using rule 36 (empty -> .)
>    decimalValue    reduce using rule 36 (empty -> .)
>    hexValue        reduce using rule 36 (empty -> .)
>    FALSE           reduce using rule 36 (empty -> .)
>    TRUE            reduce using rule 36 (empty -> .)
>    NULL            reduce using rule 36 (empty -> .)
>    $end            reduce using rule 36 (empty -> .)
>
>    mofItemList                    shift and go to state 1
>    mof                            shift and go to state 2
>    empty                          shift and go to state 3
>
>state 1
>
>    (1) mof -> mofItemList .
>    (3) mofItemList -> mofItemList . mofItem
>    (4) mofItem -> . pragma
>    (5) mofItem -> . IDENTIFIER
>    (6) mofItem -> . literal
>    (7) mofItem -> . value
>    (8) pragma -> . # PRAGMA pragmaName ( pragmaParameter )
>    (17) literal -> . (
>    (18) literal -> . )
>    (19) literal -> . {
>    (20) literal -> . }
>    (21) literal -> . ;
>    (22) literal -> . [
>    (23) literal -> . ]
>    (24) literal -> . ,
>    (25) literal -> . $
>    (26) literal -> . :
>    (27) literal -> . =
>    (11) value -> . integerValue
>    (12) value -> . floatValue
>    (13) value -> . charValue
>    (14) value -> . stringValue
>    (15) value -> . booleanValue
>    (16) value -> . nullValue
>    (28) integerValue -> . binaryValue
>    (29) integerValue -> . octalValue
>    (30) integerValue -> . decimalValue
>    (31) integerValue -> . hexValue
>    (32) booleanValue -> . FALSE
>    (33) booleanValue -> . TRUE
>    (34) nullValue -> . NULL
>
>    $end            reduce using rule 1 (mof -> mofItemList .)
>    IDENTIFIER      shift and go to state 27
>    #               shift and go to state 11
>    (               shift and go to state 15
>    )               shift and go to state 14
>    {               shift and go to state 30
>    }               shift and go to state 31
>    ;               shift and go to state 19
>    [               shift and go to state 25
>    ]               shift and go to state 26
>    ,               shift and go to state 17
>    $               shift and go to state 13
>    :               shift and go to state 20
>    =               shift and go to state 21
>    floatValue      shift and go to state 22
>    charValue       shift and go to state 10
>    stringValue     shift and go to state 24
>    binaryValue     shift and go to state 23
>    octalValue      shift and go to state 5
>    decimalValue    shift and go to state 7
>    hexValue        shift and go to state 6
>    FALSE           shift and go to state 28
>    TRUE            shift and go to state 9
>    NULL            shift and go to state 12
>
>    booleanValue                   shift and go to state 8
>    mofItem                        shift and go to state 16
>    value                          shift and go to state 29
>    literal                        shift and go to state 18
>    pragma                         shift and go to state 4
>    integerValue                   shift and go to state 32
>    nullValue                      shift and go to state 33
>
>state 2
>
>    (0) S' -> mof .
>
>
>
>state 3
>
>    (2) mofItemList -> empty .
>
>    IDENTIFIER      reduce using rule 2 (mofItemList -> empty .)
>    #               reduce using rule 2 (mofItemList -> empty .)
>    (               reduce using rule 2 (mofItemList -> empty .)
>    )               reduce using rule 2 (mofItemList -> empty .)
>    {               reduce using rule 2 (mofItemList -> empty .)
>    }               reduce using rule 2 (mofItemList -> empty .)
>    ;               reduce using rule 2 (mofItemList -> empty .)
>    [               reduce using rule 2 (mofItemList -> empty .)
>    ]               reduce using rule 2 (mofItemList -> empty .)
>    ,               reduce using rule 2 (mofItemList -> empty .)
>    $               reduce using rule 2 (mofItemList -> empty .)
>    :               reduce using rule 2 (mofItemList -> empty .)
>    =               reduce using rule 2 (mofItemList -> empty .)
>    floatValue      reduce using rule 2 (mofItemList -> empty .)
>    charValue       reduce using rule 2 (mofItemList -> empty .)
>    stringValue     reduce using rule 2 (mofItemList -> empty .)
>    binaryValue     reduce using rule 2 (mofItemList -> empty .)
>    octalValue      reduce using rule 2 (mofItemList -> empty .)
>    decimalValue    reduce using rule 2 (mofItemList -> empty .)
>    hexValue        reduce using rule 2 (mofItemList -> empty .)
>    FALSE           reduce using rule 2 (mofItemList -> empty .)
>    TRUE            reduce using rule 2 (mofItemList -> empty .)
>    NULL            reduce using rule 2 (mofItemList -> empty .)
>    $end            reduce using rule 2 (mofItemList -> empty .)
>
>
>state 4
>
>    (4) mofItem -> pragma .
>
>    IDENTIFIER      reduce using rule 4 (mofItem -> pragma .)
>    #               reduce using rule 4 (mofItem -> pragma .)
>    (               reduce using rule 4 (mofItem -> pragma .)
>    )               reduce using rule 4 (mofItem -> pragma .)
>    {               reduce using rule 4 (mofItem -> pragma .)
>    }               reduce using rule 4 (mofItem -> pragma .)
>    ;               reduce using rule 4 (mofItem -> pragma .)
>    [               reduce using rule 4 (mofItem -> pragma .)
>    ]               reduce using rule 4 (mofItem -> pragma .)
>    ,               reduce using rule 4 (mofItem -> pragma .)
>    $               reduce using rule 4 (mofItem -> pragma .)
>    :               reduce using rule 4 (mofItem -> pragma .)
>    =               reduce using rule 4 (mofItem -> pragma .)
>    floatValue      reduce using rule 4 (mofItem -> pragma .)
>    charValue       reduce using rule 4 (mofItem -> pragma .)
>    stringValue     reduce using rule 4 (mofItem -> pragma .)
>    binaryValue     reduce using rule 4 (mofItem -> pragma .)
>    octalValue      reduce using rule 4 (mofItem -> pragma .)
>    decimalValue    reduce using rule 4 (mofItem -> pragma .)
>    hexValue        reduce using rule 4 (mofItem -> pragma .)
>    FALSE           reduce using rule 4 (mofItem -> pragma .)
>    TRUE            reduce using rule 4 (mofItem -> pragma .)
>    NULL            reduce using rule 4 (mofItem -> pragma .)
>    $end            reduce using rule 4 (mofItem -> pragma .)
>
>
>state 5
>
>    (29) integerValue -> octalValue .
>
>    IDENTIFIER      reduce using rule 29 (integerValue -> octalValue .)
>    #               reduce using rule 29 (integerValue -> octalValue .)
>    (               reduce using rule 29 (integerValue -> octalValue .)
>    )               reduce using rule 29 (integerValue -> octalValue .)
>    {               reduce using rule 29 (integerValue -> octalValue .)
>    }               reduce using rule 29 (integerValue -> octalValue .)
>    ;               reduce using rule 29 (integerValue -> octalValue .)
>    [               reduce using rule 29 (integerValue -> octalValue .)
>    ]               reduce using rule 29 (integerValue -> octalValue .)
>    ,               reduce using rule 29 (integerValue -> octalValue .)
>    $               reduce using rule 29 (integerValue -> octalValue .)
>    :               reduce using rule 29 (integerValue -> octalValue .)
>    =               reduce using rule 29 (integerValue -> octalValue .)
>    floatValue      reduce using rule 29 (integerValue -> octalValue .)
>    charValue       reduce using rule 29 (integerValue -> octalValue .)
>    stringValue     reduce using rule 29 (integerValue -> octalValue .)
>    binaryValue     reduce using rule 29 (integerValue -> octalValue .)
>    octalValue      reduce using rule 29 (integerValue -> octalValue .)
>    decimalValue    reduce using rule 29 (integerValue -> octalValue .)
>    hexValue        reduce using rule 29 (integerValue -> octalValue .)
>    FALSE           reduce using rule 29 (integerValue -> octalValue .)
>    TRUE            reduce using rule 29 (integerValue -> octalValue .)
>    NULL            reduce using rule 29 (integerValue -> octalValue .)
>    $end            reduce using rule 29 (integerValue -> octalValue .)
>
>
>state 6
>
>    (31) integerValue -> hexValue .
>
>    IDENTIFIER      reduce using rule 31 (integerValue -> hexValue .)
>    #               reduce using rule 31 (integerValue -> hexValue .)
>    (               reduce using rule 31 (integerValue -> hexValue .)
>    )               reduce using rule 31 (integerValue -> hexValue .)
>    {               reduce using rule 31 (integerValue -> hexValue .)
>    }               reduce using rule 31 (integerValue -> hexValue .)
>    ;               reduce using rule 31 (integerValue -> hexValue .)
>    [               reduce using rule 31 (integerValue -> hexValue .)
>    ]               reduce using rule 31 (integerValue -> hexValue .)
>    ,               reduce using rule 31 (integerValue -> hexValue .)
>    $               reduce using rule 31 (integerValue -> hexValue .)
>    :               reduce using rule 31 (integerValue -> hexValue .)
>    =               reduce using rule 31 (integerValue -> hexValue .)
>    floatValue      reduce using rule 31 (integerValue -> hexValue .)
>    charValue       reduce using rule 31 (integerValue -> hexValue .)
>    stringValue     reduce using rule 31 (integerValue -> hexValue .)
>    binaryValue     reduce using rule 31 (integerValue -> hexValue .)
>    octalValue      reduce using rule 31 (integerValue -> hexValue .)
>    decimalValue    reduce using rule 31 (integerValue -> hexValue .)
>    hexValue        reduce using rule 31 (integerValue -> hexValue .)
>    FALSE           reduce using rule 31 (integerValue -> hexValue .)
>    TRUE            reduce using rule 31 (integerValue -> hexValue .)
>    NULL            reduce using rule 31 (integerValue -> hexValue .)
>    $end            reduce using rule 31 (integerValue -> hexValue .)
>
>
>state 7
>
>    (30) integerValue -> decimalValue .
>
>    IDENTIFIER      reduce using rule 30 (integerValue -> decimalValue .)
>    #               reduce using rule 30 (integerValue -> decimalValue .)
>    (               reduce using rule 30 (integerValue -> decimalValue .)
>    )               reduce using rule 30 (integerValue -> decimalValue .)
>    {               reduce using rule 30 (integerValue -> decimalValue .)
>    }               reduce using rule 30 (integerValue -> decimalValue .)
>    ;               reduce using rule 30 (integerValue -> decimalValue .)
>    [               reduce using rule 30 (integerValue -> decimalValue .)
>    ]               reduce using rule 30 (integerValue -> decimalValue .)
>    ,               reduce using rule 30 (integerValue -> decimalValue .)
>    $               reduce using rule 30 (integerValue -> decimalValue .)
>    :               reduce using rule 30 (integerValue -> decimalValue .)
>    =               reduce using rule 30 (integerValue -> decimalValue .)
>    floatValue      reduce using rule 30 (integerValue -> decimalValue .)
>    charValue       reduce using rule 30 (integerValue -> decimalValue .)
>    stringValue     reduce using rule 30 (integerValue -> decimalValue .)
>    binaryValue     reduce using rule 30 (integerValue -> decimalValue .)
>    octalValue      reduce using rule 30 (integerValue -> decimalValue .)
>    decimalValue    reduce using rule 30 (integerValue -> decimalValue .)
>    hexValue        reduce using rule 30 (integerValue -> decimalValue .)
>    FALSE           reduce using rule 30 (integerValue -> decimalValue .)
>    TRUE            reduce using rule 30 (integerValue -> decimalValue .)
>    NULL            reduce using rule 30 (integerValue -> decimalValue .)
>    $end            reduce using rule 30 (integerValue -> decimalValue .)
>
>
>state 8
>
>    (15) value -> booleanValue .
>
>    IDENTIFIER      reduce using rule 15 (value -> booleanValue .)
>    #               reduce using rule 15 (value -> booleanValue .)
>    (               reduce using rule 15 (value -> booleanValue .)
>    )               reduce using rule 15 (value -> booleanValue .)
>    {               reduce using rule 15 (value -> booleanValue .)
>    }               reduce using rule 15 (value -> booleanValue .)
>    ;               reduce using rule 15 (value -> booleanValue .)
>    [               reduce using rule 15 (value -> booleanValue .)
>    ]               reduce using rule 15 (value -> booleanValue .)
>    ,               reduce using rule 15 (value -> booleanValue .)
>    $               reduce using rule 15 (value -> booleanValue .)
>    :               reduce using rule 15 (value -> booleanValue .)
>    =               reduce using rule 15 (value -> booleanValue .)
>    floatValue      reduce using rule 15 (value -> booleanValue .)
>    charValue       reduce using rule 15 (value -> booleanValue .)
>    stringValue     reduce using rule 15 (value -> booleanValue .)
>    binaryValue     reduce using rule 15 (value -> booleanValue .)
>    octalValue      reduce using rule 15 (value -> booleanValue .)
>    decimalValue    reduce using rule 15 (value -> booleanValue .)
>    hexValue        reduce using rule 15 (value -> booleanValue .)
>    FALSE           reduce using rule 15 (value -> booleanValue .)
>    TRUE            reduce using rule 15 (value -> booleanValue .)
>    NULL            reduce using rule 15 (value -> booleanValue .)
>    $end            reduce using rule 15 (value -> booleanValue .)
>
>
>state 9
>
>    (33) booleanValue -> TRUE .
>
>    IDENTIFIER      reduce using rule 33 (booleanValue -> TRUE .)
>    #               reduce using rule 33 (booleanValue -> TRUE .)
>    (               reduce using rule 33 (booleanValue -> TRUE .)
>    )               reduce using rule 33 (booleanValue -> TRUE .)
>    {               reduce using rule 33 (booleanValue -> TRUE .)
>    }               reduce using rule 33 (booleanValue -> TRUE .)
>    ;               reduce using rule 33 (booleanValue -> TRUE .)
>    [               reduce using rule 33 (booleanValue -> TRUE .)
>    ]               reduce using rule 33 (booleanValue -> TRUE .)
>    ,               reduce using rule 33 (booleanValue -> TRUE .)
>    $               reduce using rule 33 (booleanValue -> TRUE .)
>    :               reduce using rule 33 (booleanValue -> TRUE .)
>    =               reduce using rule 33 (booleanValue -> TRUE .)
>    floatValue      reduce using rule 33 (booleanValue -> TRUE .)
>    charValue       reduce using rule 33 (booleanValue -> TRUE .)
>    stringValue     reduce using rule 33 (booleanValue -> TRUE .)
>    binaryValue     reduce using rule 33 (booleanValue -> TRUE .)
>    octalValue      reduce using rule 33 (booleanValue -> TRUE .)
>    decimalValue    reduce using rule 33 (booleanValue -> TRUE .)
>    hexValue        reduce using rule 33 (booleanValue -> TRUE .)
>    FALSE           reduce using rule 33 (booleanValue -> TRUE .)
>    TRUE            reduce using rule 33 (booleanValue -> TRUE .)
>    NULL            reduce using rule 33 (booleanValue -> TRUE .)
>    $end            reduce using rule 33 (booleanValue -> TRUE .)
>
>
>state 10
>
>    (13) value -> charValue .
>
>    IDENTIFIER      reduce using rule 13 (value -> charValue .)
>    #               reduce using rule 13 (value -> charValue .)
>    (               reduce using rule 13 (value -> charValue .)
>    )               reduce using rule 13 (value -> charValue .)
>    {               reduce using rule 13 (value -> charValue .)
>    }               reduce using rule 13 (value -> charValue .)
>    ;               reduce using rule 13 (value -> charValue .)
>    [               reduce using rule 13 (value -> charValue .)
>    ]               reduce using rule 13 (value -> charValue .)
>    ,               reduce using rule 13 (value -> charValue .)
>    $               reduce using rule 13 (value -> charValue .)
>    :               reduce using rule 13 (value -> charValue .)
>    =               reduce using rule 13 (value -> charValue .)
>    floatValue      reduce using rule 13 (value -> charValue .)
>    charValue       reduce using rule 13 (value -> charValue .)
>    stringValue     reduce using rule 13 (value -> charValue .)
>    binaryValue     reduce using rule 13 (value -> charValue .)
>    octalValue      reduce using rule 13 (value -> charValue .)
>    decimalValue    reduce using rule 13 (value -> charValue .)
>    hexValue        reduce using rule 13 (value -> charValue .)
>    FALSE           reduce using rule 13 (value -> charValue .)
>    TRUE            reduce using rule 13 (value -> charValue .)
>    NULL            reduce using rule 13 (value -> charValue .)
>    $end            reduce using rule 13 (value -> charValue .)
>
>
>state 11
>
>    (8) pragma -> # . PRAGMA pragmaName ( pragmaParameter )
>
>    PRAGMA          shift and go to state 34
>
>
>state 12
>
>    (34) nullValue -> NULL .
>
>    IDENTIFIER      reduce using rule 34 (nullValue -> NULL .)
>    #               reduce using rule 34 (nullValue -> NULL .)
>    (               reduce using rule 34 (nullValue -> NULL .)
>    )               reduce using rule 34 (nullValue -> NULL .)
>    {               reduce using rule 34 (nullValue -> NULL .)
>    }               reduce using rule 34 (nullValue -> NULL .)
>    ;               reduce using rule 34 (nullValue -> NULL .)
>    [               reduce using rule 34 (nullValue -> NULL .)
>    ]               reduce using rule 34 (nullValue -> NULL .)
>    ,               reduce using rule 34 (nullValue -> NULL .)
>    $               reduce using rule 34 (nullValue -> NULL .)
>    :               reduce using rule 34 (nullValue -> NULL .)
>    =               reduce using rule 34 (nullValue -> NULL .)
>    floatValue      reduce using rule 34 (nullValue -> NULL .)
>    charValue       reduce using rule 34 (nullValue -> NULL .)
>    stringValue     reduce using rule 34 (nullValue -> NULL .)
>    binaryValue     reduce using rule 34 (nullValue -> NULL .)
>    octalValue      reduce using rule 34 (nullValue -> NULL .)
>    decimalValue    reduce using rule 34 (nullValue -> NULL .)
>    hexValue        reduce using rule 34 (nullValue -> NULL .)
>    FALSE           reduce using rule 34 (nullValue -> NULL .)
>    TRUE            reduce using rule 34 (nullValue -> NULL .)
>    NULL            reduce using rule 34 (nullValue -> NULL .)
>    $end            reduce using rule 34 (nullValue -> NULL .)
>
>
>state 13
>
>    (25) literal -> $ .
>
>    IDENTIFIER      reduce using rule 25 (literal -> $ .)
>    #               reduce using rule 25 (literal -> $ .)
>    (               reduce using rule 25 (literal -> $ .)
>    )               reduce using rule 25 (literal -> $ .)
>    {               reduce using rule 25 (literal -> $ .)
>    }               reduce using rule 25 (literal -> $ .)
>    ;               reduce using rule 25 (literal -> $ .)
>    [               reduce using rule 25 (literal -> $ .)
>    ]               reduce using rule 25 (literal -> $ .)
>    ,               reduce using rule 25 (literal -> $ .)
>    $               reduce using rule 25 (literal -> $ .)
>    :               reduce using rule 25 (literal -> $ .)
>    =               reduce using rule 25 (literal -> $ .)
>    floatValue      reduce using rule 25 (literal -> $ .)
>    charValue       reduce using rule 25 (literal -> $ .)
>    stringValue     reduce using rule 25 (literal -> $ .)
>    binaryValue     reduce using rule 25 (literal -> $ .)
>    octalValue      reduce using rule 25 (literal -> $ .)
>    decimalValue    reduce using rule 25 (literal -> $ .)
>    hexValue        reduce using rule 25 (literal -> $ .)
>    FALSE           reduce using rule 25 (literal -> $ .)
>    TRUE            reduce using rule 25 (literal -> $ .)
>    NULL            reduce using rule 25 (literal -> $ .)
>    $end            reduce using rule 25 (literal -> $ .)
>
>
>state 14
>
>    (18) literal -> ) .
>
>    IDENTIFIER      reduce using rule 18 (literal -> ) .)
>    #               reduce using rule 18 (literal -> ) .)
>    (               reduce using rule 18 (literal -> ) .)
>    )               reduce using rule 18 (literal -> ) .)
>    {               reduce using rule 18 (literal -> ) .)
>    }               reduce using rule 18 (literal -> ) .)
>    ;               reduce using rule 18 (literal -> ) .)
>    [               reduce using rule 18 (literal -> ) .)
>    ]               reduce using rule 18 (literal -> ) .)
>    ,               reduce using rule 18 (literal -> ) .)
>    $               reduce using rule 18 (literal -> ) .)
>    :               reduce using rule 18 (literal -> ) .)
>    =               reduce using rule 18 (literal -> ) .)
>    floatValue      reduce using rule 18 (literal -> ) .)
>    charValue       reduce using rule 18 (literal -> ) .)
>    stringValue     reduce using rule 18 (literal -> ) .)
>    binaryValue     reduce using rule 18 (literal -> ) .)
>    octalValue      reduce using rule 18 (literal -> ) .)
>    decimalValue    reduce using rule 18 (literal -> ) .)
>    hexValue        reduce using rule 18 (literal -> ) .)
>    FALSE           reduce using rule 18 (literal -> ) .)
>    TRUE            reduce using rule 18 (literal -> ) .)
>    NULL            reduce using rule 18 (literal -> ) .)
>    $end            reduce using rule 18 (literal -> ) .)
>
>
>state 15
>
>    (17) literal -> ( .
>
>    IDENTIFIER      reduce using rule 17 (literal -> ( .)
>    #               reduce using rule 17 (literal -> ( .)
>    (               reduce using rule 17 (literal -> ( .)
>    )               reduce using rule 17 (literal -> ( .)
>    {               reduce using rule 17 (literal -> ( .)
>    }               reduce using rule 17 (literal -> ( .)
>    ;               reduce using rule 17 (literal -> ( .)
>    [               reduce using rule 17 (literal -> ( .)
>    ]               reduce using rule 17 (literal -> ( .)
>    ,               reduce using rule 17 (literal -> ( .)
>    $               reduce using rule 17 (literal -> ( .)
>    :               reduce using rule 17 (literal -> ( .)
>    =               reduce using rule 17 (literal -> ( .)
>    floatValue      reduce using rule 17 (literal -> ( .)
>    charValue       reduce using rule 17 (literal -> ( .)
>    stringValue     reduce using rule 17 (literal -> ( .)
>    binaryValue     reduce using rule 17 (literal -> ( .)
>    octalValue      reduce using rule 17 (literal -> ( .)
>    decimalValue    reduce using rule 17 (literal -> ( .)
>    hexValue        reduce using rule 17 (literal -> ( .)
>    FALSE           reduce using rule 17 (literal -> ( .)
>    TRUE            reduce using rule 17 (literal -> ( .)
>    NULL            reduce using rule 17 (literal -> ( .)
>    $end            reduce using rule 17 (literal -> ( .)
>
>
>state 16
>
>    (3) mofItemList -> mofItemList mofItem .
>
>    IDENTIFIER      reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    #               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    (               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    )               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    {               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    }               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    ;               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    [               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    ]               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    ,               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    $               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    :               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    =               reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    floatValue      reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    charValue       reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    stringValue     reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    binaryValue     reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    octalValue      reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    decimalValue    reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    hexValue        reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    FALSE           reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    TRUE            reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    NULL            reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>    $end            reduce using rule 3 (mofItemList -> mofItemList mofItem .)
>
>
>state 17
>
>    (24) literal -> , .
>
>    IDENTIFIER      reduce using rule 24 (literal -> , .)
>    #               reduce using rule 24 (literal -> , .)
>    (               reduce using rule 24 (literal -> , .)
>    )               reduce using rule 24 (literal -> , .)
>    {               reduce using rule 24 (literal -> , .)
>    }               reduce using rule 24 (literal -> , .)
>    ;               reduce using rule 24 (literal -> , .)
>    [               reduce using rule 24 (literal -> , .)
>    ]               reduce using rule 24 (literal -> , .)
>    ,               reduce using rule 24 (literal -> , .)
>    $               reduce using rule 24 (literal -> , .)
>    :               reduce using rule 24 (literal -> , .)
>    =               reduce using rule 24 (literal -> , .)
>    floatValue      reduce using rule 24 (literal -> , .)
>    charValue       reduce using rule 24 (literal -> , .)
>    stringValue     reduce using rule 24 (literal -> , .)
>    binaryValue     reduce using rule 24 (literal -> , .)
>    octalValue      reduce using rule 24 (literal -> , .)
>    decimalValue    reduce using rule 24 (literal -> , .)
>    hexValue        reduce using rule 24 (literal -> , .)
>    FALSE           reduce using rule 24 (literal -> , .)
>    TRUE            reduce using rule 24 (literal -> , .)
>    NULL            reduce using rule 24 (literal -> , .)
>    $end            reduce using rule 24 (literal -> , .)
>
>
>state 18
>
>    (6) mofItem -> literal .
>
>    IDENTIFIER      reduce using rule 6 (mofItem -> literal .)
>    #               reduce using rule 6 (mofItem -> literal .)
>    (               reduce using rule 6 (mofItem -> literal .)
>    )               reduce using rule 6 (mofItem -> literal .)
>    {               reduce using rule 6 (mofItem -> literal .)
>    }               reduce using rule 6 (mofItem -> literal .)
>    ;               reduce using rule 6 (mofItem -> literal .)
>    [               reduce using rule 6 (mofItem -> literal .)
>    ]               reduce using rule 6 (mofItem -> literal .)
>    ,               reduce using rule 6 (mofItem -> literal .)
>    $               reduce using rule 6 (mofItem -> literal .)
>    :               reduce using rule 6 (mofItem -> literal .)
>    =               reduce using rule 6 (mofItem -> literal .)
>    floatValue      reduce using rule 6 (mofItem -> literal .)
>    charValue       reduce using rule 6 (mofItem -> literal .)
>    stringValue     reduce using rule 6 (mofItem -> literal .)
>    binaryValue     reduce using rule 6 (mofItem -> literal .)
>    octalValue      reduce using rule 6 (mofItem -> literal .)
>    decimalValue    reduce using rule 6 (mofItem -> literal .)
>    hexValue        reduce using rule 6 (mofItem -> literal .)
>    FALSE           reduce using rule 6 (mofItem -> literal .)
>    TRUE            reduce using rule 6 (mofItem -> literal .)
>    NULL            reduce using rule 6 (mofItem -> literal .)
>    $end            reduce using rule 6 (mofItem -> literal .)
>
>
>state 19
>
>    (21) literal -> ; .
>
>    IDENTIFIER      reduce using rule 21 (literal -> ; .)
>    #               reduce using rule 21 (literal -> ; .)
>    (               reduce using rule 21 (literal -> ; .)
>    )               reduce using rule 21 (literal -> ; .)
>    {               reduce using rule 21 (literal -> ; .)
>    }               reduce using rule 21 (literal -> ; .)
>    ;               reduce using rule 21 (literal -> ; .)
>    [               reduce using rule 21 (literal -> ; .)
>    ]               reduce using rule 21 (literal -> ; .)
>    ,               reduce using rule 21 (literal -> ; .)
>    $               reduce using rule 21 (literal -> ; .)
>    :               reduce using rule 21 (literal -> ; .)
>    =               reduce using rule 21 (literal -> ; .)
>    floatValue      reduce using rule 21 (literal -> ; .)
>    charValue       reduce using rule 21 (literal -> ; .)
>    stringValue     reduce using rule 21 (literal -> ; .)
>    binaryValue     reduce using rule 21 (literal -> ; .)
>    octalValue      reduce using rule 21 (literal -> ; .)
>    decimalValue    reduce using rule 21 (literal -> ; .)
>    hexValue        reduce using rule 21 (literal -> ; .)
>    FALSE           reduce using rule 21 (literal -> ; .)
>    TRUE            reduce using rule 21 (literal -> ; .)
>    NULL            reduce using rule 21 (literal -> ; .)
>    $end            reduce using rule 21 (literal -> ; .)
>
>
>state 20
>
>    (26) literal -> : .
>
>    IDENTIFIER      reduce using rule 26 (literal -> : .)
>    #               reduce using rule 26 (literal -> : .)
>    (               reduce using rule 26 (literal -> : .)
>    )               reduce using rule 26 (literal -> : .)
>    {               reduce using rule 26 (literal -> : .)
>    }               reduce using rule 26 (literal -> : .)
>    ;               reduce using rule 26 (literal -> : .)
>    [               reduce using rule 26 (literal -> : .)
>    ]               reduce using rule 26 (literal -> : .)
>    ,               reduce using rule 26 (literal -> : .)
>    $               reduce using rule 26 (literal -> : .)
>    :               reduce using rule 26 (literal -> : .)
>    =               reduce using rule 26 (literal -> : .)
>    floatValue      reduce using rule 26 (literal -> : .)
>    charValue       reduce using rule 26 (literal -> : .)
>    stringValue     reduce using rule 26 (literal -> : .)
>    binaryValue     reduce using rule 26 (literal -> : .)
>    octalValue      reduce using rule 26 (literal -> : .)
>    decimalValue    reduce using rule 26 (literal -> : .)
>    hexValue        reduce using rule 26 (literal -> : .)
>    FALSE           reduce using rule 26 (literal -> : .)
>    TRUE            reduce using rule 26 (literal -> : .)
>    NULL            reduce using rule 26 (literal -> : .)
>    $end            reduce using rule 26 (literal -> : .)
>
>
>state 21
>
>    (27) literal -> = .
>
>    IDENTIFIER      reduce using rule 27 (literal -> = .)
>    #               reduce using rule 27 (literal -> = .)
>    (               reduce using rule 27 (literal -> = .)
>    )               reduce using rule 27 (literal -> = .)
>    {               reduce using rule 27 (literal -> = .)
>    }               reduce using rule 27 (literal -> = .)
>    ;               reduce using rule 27 (literal -> = .)
>    [               reduce using rule 27 (literal -> = .)
>    ]               reduce using rule 27 (literal -> = .)
>    ,               reduce using rule 27 (literal -> = .)
>    $               reduce using rule 27 (literal -> = .)
>    :               reduce using rule 27 (literal -> = .)
>    =               reduce using rule 27 (literal -> = .)
>    floatValue      reduce using rule 27 (literal -> = .)
>    charValue       reduce using rule 27 (literal -> = .)
>    stringValue     reduce using rule 27 (literal -> = .)
>    binaryValue     reduce using rule 27 (literal -> = .)
>    octalValue      reduce using rule 27 (literal -> = .)
>    decimalValue    reduce using rule 27 (literal -> = .)
>    hexValue        reduce using rule 27 (literal -> = .)
>    FALSE           reduce using rule 27 (literal -> = .)
>    TRUE            reduce using rule 27 (literal -> = .)
>    NULL            reduce using rule 27 (literal -> = .)
>    $end            reduce using rule 27 (literal -> = .)
>
>
>state 22
>
>    (12) value -> floatValue .
>
>    IDENTIFIER      reduce using rule 12 (value -> floatValue .)
>    #               reduce using rule 12 (value -> floatValue .)
>    (               reduce using rule 12 (value -> floatValue .)
>    )               reduce using rule 12 (value -> floatValue .)
>    {               reduce using rule 12 (value -> floatValue .)
>    }               reduce using rule 12 (value -> floatValue .)
>    ;               reduce using rule 12 (value -> floatValue .)
>    [               reduce using rule 12 (value -> floatValue .)
>    ]               reduce using rule 12 (value -> floatValue .)
>    ,               reduce using rule 12 (value -> floatValue .)
>    $               reduce using rule 12 (value -> floatValue .)
>    :               reduce using rule 12 (value -> floatValue .)
>    =               reduce using rule 12 (value -> floatValue .)
>    floatValue      reduce using rule 12 (value -> floatValue .)
>    charValue       reduce using rule 12 (value -> floatValue .)
>    stringValue     reduce using rule 12 (value -> floatValue .)
>    binaryValue     reduce using rule 12 (value -> floatValue .)
>    octalValue      reduce using rule 12 (value -> floatValue .)
>    decimalValue    reduce using rule 12 (value -> floatValue .)
>    hexValue        reduce using rule 12 (value -> floatValue .)
>    FALSE           reduce using rule 12 (value -> floatValue .)
>    TRUE            reduce using rule 12 (value -> floatValue .)
>    NULL            reduce using rule 12 (value -> floatValue .)
>    $end            reduce using rule 12 (value -> floatValue .)
>
>
>state 23
>
>    (28) integerValue -> binaryValue .
>
>    IDENTIFIER      reduce using rule 28 (integerValue -> binaryValue .)
>    #               reduce using rule 28 (integerValue -> binaryValue .)
>    (               reduce using rule 28 (integerValue -> binaryValue .)
>    )               reduce using rule 28 (integerValue -> binaryValue .)
>    {               reduce using rule 28 (integerValue -> binaryValue .)
>    }               reduce using rule 28 (integerValue -> binaryValue .)
>    ;               reduce using rule 28 (integerValue -> binaryValue .)
>    [               reduce using rule 28 (integerValue -> binaryValue .)
>    ]               reduce using rule 28 (integerValue -> binaryValue .)
>    ,               reduce using rule 28 (integerValue -> binaryValue .)
>    $               reduce using rule 28 (integerValue -> binaryValue .)
>    :               reduce using rule 28 (integerValue -> binaryValue .)
>    =               reduce using rule 28 (integerValue -> binaryValue .)
>    floatValue      reduce using rule 28 (integerValue -> binaryValue .)
>    charValue       reduce using rule 28 (integerValue -> binaryValue .)
>    stringValue     reduce using rule 28 (integerValue -> binaryValue .)
>    binaryValue     reduce using rule 28 (integerValue -> binaryValue .)
>    octalValue      reduce using rule 28 (integerValue -> binaryValue .)
>    decimalValue    reduce using rule 28 (integerValue -> binaryValue .)
>    hexValue        reduce using rule 28 (integerValue -> binaryValue .)
>    FALSE           reduce using rule 28 (integerValue -> binaryValue .)
>    TRUE            reduce using rule 28 (integerValue -> binaryValue .)
>    NULL            reduce using rule 28 (integerValue -> binaryValue .)
>    $end            reduce using rule 28 (integerValue -> binaryValue .)
>
>
>state 24
>
>    (14) value -> stringValue .
>
>    IDENTIFIER      reduce using rule 14 (value -> stringValue .)
>    #               reduce using rule 14 (value -> stringValue .)
>    (               reduce using rule 14 (value -> stringValue .)
>    )               reduce using rule 14 (value -> stringValue .)
>    {               reduce using rule 14 (value -> stringValue .)
>    }               reduce using rule 14 (value -> stringValue .)
>    ;               reduce using rule 14 (value -> stringValue .)
>    [               reduce using rule 14 (value -> stringValue .)
>    ]               reduce using rule 14 (value -> stringValue .)
>    ,               reduce using rule 14 (value -> stringValue .)
>    $               reduce using rule 14 (value -> stringValue .)
>    :               reduce using rule 14 (value -> stringValue .)
>    =               reduce using rule 14 (value -> stringValue .)
>    floatValue      reduce using rule 14 (value -> stringValue .)
>    charValue       reduce using rule 14 (value -> stringValue .)
>    stringValue     reduce using rule 14 (value -> stringValue .)
>    binaryValue     reduce using rule 14 (value -> stringValue .)
>    octalValue      reduce using rule 14 (value -> stringValue .)
>    decimalValue    reduce using rule 14 (value -> stringValue .)
>    hexValue        reduce using rule 14 (value -> stringValue .)
>    FALSE           reduce using rule 14 (value -> stringValue .)
>    TRUE            reduce using rule 14 (value -> stringValue .)
>    NULL            reduce using rule 14 (value -> stringValue .)
>    $end            reduce using rule 14 (value -> stringValue .)
>
>
>state 25
>
>    (22) literal -> [ .
>
>    IDENTIFIER      reduce using rule 22 (literal -> [ .)
>    #               reduce using rule 22 (literal -> [ .)
>    (               reduce using rule 22 (literal -> [ .)
>    )               reduce using rule 22 (literal -> [ .)
>    {               reduce using rule 22 (literal -> [ .)
>    }               reduce using rule 22 (literal -> [ .)
>    ;               reduce using rule 22 (literal -> [ .)
>    [               reduce using rule 22 (literal -> [ .)
>    ]               reduce using rule 22 (literal -> [ .)
>    ,               reduce using rule 22 (literal -> [ .)
>    $               reduce using rule 22 (literal -> [ .)
>    :               reduce using rule 22 (literal -> [ .)
>    =               reduce using rule 22 (literal -> [ .)
>    floatValue      reduce using rule 22 (literal -> [ .)
>    charValue       reduce using rule 22 (literal -> [ .)
>    stringValue     reduce using rule 22 (literal -> [ .)
>    binaryValue     reduce using rule 22 (literal -> [ .)
>    octalValue      reduce using rule 22 (literal -> [ .)
>    decimalValue    reduce using rule 22 (literal -> [ .)
>    hexValue        reduce using rule 22 (literal -> [ .)
>    FALSE           reduce using rule 22 (literal -> [ .)
>    TRUE            reduce using rule 22 (literal -> [ .)
>    NULL            reduce using rule 22 (literal -> [ .)
>    $end            reduce using rule 22 (literal -> [ .)
>
>
>state 26
>
>    (23) literal -> ] .
>
>    IDENTIFIER      reduce using rule 23 (literal -> ] .)
>    #               reduce using rule 23 (literal -> ] .)
>    (               reduce using rule 23 (literal -> ] .)
>    )               reduce using rule 23 (literal -> ] .)
>    {               reduce using rule 23 (literal -> ] .)
>    }               reduce using rule 23 (literal -> ] .)
>    ;               reduce using rule 23 (literal -> ] .)
>    [               reduce using rule 23 (literal -> ] .)
>    ]               reduce using rule 23 (literal -> ] .)
>    ,               reduce using rule 23 (literal -> ] .)
>    $               reduce using rule 23 (literal -> ] .)
>    :               reduce using rule 23 (literal -> ] .)
>    =               reduce using rule 23 (literal -> ] .)
>    floatValue      reduce using rule 23 (literal -> ] .)
>    charValue       reduce using rule 23 (literal -> ] .)
>    stringValue     reduce using rule 23 (literal -> ] .)
>    binaryValue     reduce using rule 23 (literal -> ] .)
>    octalValue      reduce using rule 23 (literal -> ] .)
>    decimalValue    reduce using rule 23 (literal -> ] .)
>    hexValue        reduce using rule 23 (literal -> ] .)
>    FALSE           reduce using rule 23 (literal -> ] .)
>    TRUE            reduce using rule 23 (literal -> ] .)
>    NULL            reduce using rule 23 (literal -> ] .)
>    $end            reduce using rule 23 (literal -> ] .)
>
>
>state 27
>
>    (5) mofItem -> IDENTIFIER .
>
>    IDENTIFIER      reduce using rule 5 (mofItem -> IDENTIFIER .)
>    #               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    (               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    )               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    {               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    }               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    ;               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    [               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    ]               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    ,               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    $               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    :               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    =               reduce using rule 5 (mofItem -> IDENTIFIER .)
>    floatValue      reduce using rule 5 (mofItem -> IDENTIFIER .)
>    charValue       reduce using rule 5 (mofItem -> IDENTIFIER .)
>    stringValue     reduce using rule 5 (mofItem -> IDENTIFIER .)
>    binaryValue     reduce using rule 5 (mofItem -> IDENTIFIER .)
>    octalValue      reduce using rule 5 (mofItem -> IDENTIFIER .)
>    decimalValue    reduce using rule 5 (mofItem -> IDENTIFIER .)
>    hexValue        reduce using rule 5 (mofItem -> IDENTIFIER .)
>    FALSE           reduce using rule 5 (mofItem -> IDENTIFIER .)
>    TRUE            reduce using rule 5 (mofItem -> IDENTIFIER .)
>    NULL            reduce using rule 5 (mofItem -> IDENTIFIER .)
>    $end            reduce using rule 5 (mofItem -> IDENTIFIER .)
>
>
>state 28
>
>    (32) booleanValue -> FALSE .
>
>    IDENTIFIER      reduce using rule 32 (booleanValue -> FALSE .)
>    #               reduce using rule 32 (booleanValue -> FALSE .)
>    (               reduce using rule 32 (booleanValue -> FALSE .)
>    )               reduce using rule 32 (booleanValue -> FALSE .)
>    {               reduce using rule 32 (booleanValue -> FALSE .)
>    }               reduce using rule 32 (booleanValue -> FALSE .)
>    ;               reduce using rule 32 (booleanValue -> FALSE .)
>    [               reduce using rule 32 (booleanValue -> FALSE .)
>    ]               reduce using rule 32 (booleanValue -> FALSE .)
>    ,               reduce using rule 32 (booleanValue -> FALSE .)
>    $               reduce using rule 32 (booleanValue -> FALSE .)
>    :               reduce using rule 32 (booleanValue -> FALSE .)
>    =               reduce using rule 32 (booleanValue -> FALSE .)
>    floatValue      reduce using rule 32 (booleanValue -> FALSE .)
>    charValue       reduce using rule 32 (booleanValue -> FALSE .)
>    stringValue     reduce using rule 32 (booleanValue -> FALSE .)
>    binaryValue     reduce using rule 32 (booleanValue -> FALSE .)
>    octalValue      reduce using rule 32 (booleanValue -> FALSE .)
>    decimalValue    reduce using rule 32 (booleanValue -> FALSE .)
>    hexValue        reduce using rule 32 (booleanValue -> FALSE .)
>    FALSE           reduce using rule 32 (booleanValue -> FALSE .)
>    TRUE            reduce using rule 32 (booleanValue -> FALSE .)
>    NULL            reduce using rule 32 (booleanValue -> FALSE .)
>    $end            reduce using rule 32 (booleanValue -> FALSE .)
>
>
>state 29
>
>    (7) mofItem -> value .
>
>    IDENTIFIER      reduce using rule 7 (mofItem -> value .)
>    #               reduce using rule 7 (mofItem -> value .)
>    (               reduce using rule 7 (mofItem -> value .)
>    )               reduce using rule 7 (mofItem -> value .)
>    {               reduce using rule 7 (mofItem -> value .)
>    }               reduce using rule 7 (mofItem -> value .)
>    ;               reduce using rule 7 (mofItem -> value .)
>    [               reduce using rule 7 (mofItem -> value .)
>    ]               reduce using rule 7 (mofItem -> value .)
>    ,               reduce using rule 7 (mofItem -> value .)
>    $               reduce using rule 7 (mofItem -> value .)
>    :               reduce using rule 7 (mofItem -> value .)
>    =               reduce using rule 7 (mofItem -> value .)
>    floatValue      reduce using rule 7 (mofItem -> value .)
>    charValue       reduce using rule 7 (mofItem -> value .)
>    stringValue     reduce using rule 7 (mofItem -> value .)
>    binaryValue     reduce using rule 7 (mofItem -> value .)
>    octalValue      reduce using rule 7 (mofItem -> value .)
>    decimalValue    reduce using rule 7 (mofItem -> value .)
>    hexValue        reduce using rule 7 (mofItem -> value .)
>    FALSE           reduce using rule 7 (mofItem -> value .)
>    TRUE            reduce using rule 7 (mofItem -> value .)
>    NULL            reduce using rule 7 (mofItem -> value .)
>    $end            reduce using rule 7 (mofItem -> value .)
>
>
>state 30
>
>    (19) literal -> { .
>
>    IDENTIFIER      reduce using rule 19 (literal -> { .)
>    #               reduce using rule 19 (literal -> { .)
>    (               reduce using rule 19 (literal -> { .)
>    )               reduce using rule 19 (literal -> { .)
>    {               reduce using rule 19 (literal -> { .)
>    }               reduce using rule 19 (literal -> { .)
>    ;               reduce using rule 19 (literal -> { .)
>    [               reduce using rule 19 (literal -> { .)
>    ]               reduce using rule 19 (literal -> { .)
>    ,               reduce using rule 19 (literal -> { .)
>    $               reduce using rule 19 (literal -> { .)
>    :               reduce using rule 19 (literal -> { .)
>    =               reduce using rule 19 (literal -> { .)
>    floatValue      reduce using rule 19 (literal -> { .)
>    charValue       reduce using rule 19 (literal -> { .)
>    stringValue     reduce using rule 19 (literal -> { .)
>    binaryValue     reduce using rule 19 (literal -> { .)
>    octalValue      reduce using rule 19 (literal -> { .)
>    decimalValue    reduce using rule 19 (literal -> { .)
>    hexValue        reduce using rule 19 (literal -> { .)
>    FALSE           reduce using rule 19 (literal -> { .)
>    TRUE            reduce using rule 19 (literal -> { .)
>    NULL            reduce using rule 19 (literal -> { .)
>    $end            reduce using rule 19 (literal -> { .)
>
>
>state 31
>
>    (20) literal -> } .
>
>    IDENTIFIER      reduce using rule 20 (literal -> } .)
>    #               reduce using rule 20 (literal -> } .)
>    (               reduce using rule 20 (literal -> } .)
>    )               reduce using rule 20 (literal -> } .)
>    {               reduce using rule 20 (literal -> } .)
>    }               reduce using rule 20 (literal -> } .)
>    ;               reduce using rule 20 (literal -> } .)
>    [               reduce using rule 20 (literal -> } .)
>    ]               reduce using rule 20 (literal -> } .)
>    ,               reduce using rule 20 (literal -> } .)
>    $               reduce using rule 20 (literal -> } .)
>    :               reduce using rule 20 (literal -> } .)
>    =               reduce using rule 20 (literal -> } .)
>    floatValue      reduce using rule 20 (literal -> } .)
>    charValue       reduce using rule 20 (literal -> } .)
>    stringValue     reduce using rule 20 (literal -> } .)
>    binaryValue     reduce using rule 20 (literal -> } .)
>    octalValue      reduce using rule 20 (literal -> } .)
>    decimalValue    reduce using rule 20 (literal -> } .)
>    hexValue        reduce using rule 20 (literal -> } .)
>    FALSE           reduce using rule 20 (literal -> } .)
>    TRUE            reduce using rule 20 (literal -> } .)
>    NULL            reduce using rule 20 (literal -> } .)
>    $end            reduce using rule 20 (literal -> } .)
>
>
>state 32
>
>    (11) value -> integerValue .
>
>    IDENTIFIER      reduce using rule 11 (value -> integerValue .)
>    #               reduce using rule 11 (value -> integerValue .)
>    (               reduce using rule 11 (value -> integerValue .)
>    )               reduce using rule 11 (value -> integerValue .)
>    {               reduce using rule 11 (value -> integerValue .)
>    }               reduce using rule 11 (value -> integerValue .)
>    ;               reduce using rule 11 (value -> integerValue .)
>    [               reduce using rule 11 (value -> integerValue .)
>    ]               reduce using rule 11 (value -> integerValue .)
>    ,               reduce using rule 11 (value -> integerValue .)
>    $               reduce using rule 11 (value -> integerValue .)
>    :               reduce using rule 11 (value -> integerValue .)
>    =               reduce using rule 11 (value -> integerValue .)
>    floatValue      reduce using rule 11 (value -> integerValue .)
>    charValue       reduce using rule 11 (value -> integerValue .)
>    stringValue     reduce using rule 11 (value -> integerValue .)
>    binaryValue     reduce using rule 11 (value -> integerValue .)
>    octalValue      reduce using rule 11 (value -> integerValue .)
>    decimalValue    reduce using rule 11 (value -> integerValue .)
>    hexValue        reduce using rule 11 (value -> integerValue .)
>    FALSE           reduce using rule 11 (value -> integerValue .)
>    TRUE            reduce using rule 11 (value -> integerValue .)
>    NULL            reduce using rule 11 (value -> integerValue .)
>    $end            reduce using rule 11 (value -> integerValue .)
>
>
>state 33
>
>    (16) value -> nullValue .
>
>    IDENTIFIER      reduce using rule 16 (value -> nullValue .)
>    #               reduce using rule 16 (value -> nullValue .)
>    (               reduce using rule 16 (value -> nullValue .)
>    )               reduce using rule 16 (value -> nullValue .)
>    {               reduce using rule 16 (value -> nullValue .)
>    }               reduce using rule 16 (value -> nullValue .)
>    ;               reduce using rule 16 (value -> nullValue .)
>    [               reduce using rule 16 (value -> nullValue .)
>    ]               reduce using rule 16 (value -> nullValue .)
>    ,               reduce using rule 16 (value -> nullValue .)
>    $               reduce using rule 16 (value -> nullValue .)
>    :               reduce using rule 16 (value -> nullValue .)
>    =               reduce using rule 16 (value -> nullValue .)
>    floatValue      reduce using rule 16 (value -> nullValue .)
>    charValue       reduce using rule 16 (value -> nullValue .)
>    stringValue     reduce using rule 16 (value -> nullValue .)
>    binaryValue     reduce using rule 16 (value -> nullValue .)
>    octalValue      reduce using rule 16 (value -> nullValue .)
>    decimalValue    reduce using rule 16 (value -> nullValue .)
>    hexValue        reduce using rule 16 (value -> nullValue .)
>    FALSE           reduce using rule 16 (value -> nullValue .)
>    TRUE            reduce using rule 16 (value -> nullValue .)
>    NULL            reduce using rule 16 (value -> nullValue .)
>    $end            reduce using rule 16 (value -> nullValue .)
>
>
>state 34
>
>    (8) pragma -> # PRAGMA . pragmaName ( pragmaParameter )
>    (9) pragmaName -> . identifier
>    (35) identifier -> . IDENTIFIER
>
>    IDENTIFIER      shift and go to state 36
>
>    pragmaName                     shift and go to state 37
>    identifier                     shift and go to state 35
>
>state 35
>
>    (9) pragmaName -> identifier .
>
>    (               reduce using rule 9 (pragmaName -> identifier .)
>
>
>state 36
>
>    (35) identifier -> IDENTIFIER .
>
>    (               reduce using rule 35 (identifier -> IDENTIFIER .)
>
>
>state 37
>
>    (8) pragma -> # PRAGMA pragmaName . ( pragmaParameter )
>
>    (               shift and go to state 38
>
>
>state 38
>
>    (8) pragma -> # PRAGMA pragmaName ( . pragmaParameter )
>    (10) pragmaParameter -> . stringValue
>
>    stringValue     shift and go to state 40
>
>    pragmaParameter                shift and go to state 39
>
>state 39
>
>    (8) pragma -> # PRAGMA pragmaName ( pragmaParameter . )
>
>    )               shift and go to state 41
>
>
>state 40
>
>    (10) pragmaParameter -> stringValue .
>
>    )               reduce using rule 10 (pragmaParameter -> stringValue .)
>
>
>state 41
>
>    (8) pragma -> # PRAGMA pragmaName ( pragmaParameter ) .
>
>    IDENTIFIER      reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    #               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    (               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    )               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    {               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    }               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    ;               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    [               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    ]               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    ,               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    $               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    :               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    =               reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    floatValue      reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    charValue       reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    stringValue     reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    binaryValue     reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    octalValue      reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    decimalValue    reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    hexValue        reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    FALSE           reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    TRUE            reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    NULL            reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>    $end            reduce using rule 8 (pragma -> # PRAGMA pragmaName ( pragmaParameter ) .)
>

Actions: View

Attachments on bug 1134556: 931655 | 931656