//SMALLTALK -------------------------> #( (keywords where) (ReadaheadTable 1 (Expression 'RSN' 2) (Term 'RSN' 3) (Primary 'RSN' 38) (Integer 'RSN' 39) (Identifier 'RSN' 4) (Grammar 'RSN' 63) (#'(' 'RS' 5)) (ReadaheadTable 2 (#'+' 'RS' 6) (#'-' 'RS' 7) (where 'RS' 8) (#'-|' 'L' 36)) (ReadaheadTable 3 (#'*' 'RS' 9) (#'/' 'RS' 10) (#'+' 'L' 37) (#'-' 'L' 37) (where 'L' 37) (#'-|' 'L' 37) (#';' 'L' 37) (#')' 'L' 37) (#',' 'L' 37)) (ReadaheadTable 4 (#'(' 'RS' 11) (#'=' 'RS' 12) (#'+' 'L' 39) (#'-' 'L' 39) (#'*' 'L' 39) (#'/' 'L' 39) (where 'L' 39) (#'-|' 'L' 39) (#';' 'L' 39) (#')' 'L' 39) (#',' 'L' 39)) (ReadaheadTable 5 (Expression 'RSN' 13) (Primary 'RSN' 38) (Term 'RSN' 3) (Integer 'RSN' 39) (Identifier 'RSN' 14) (#'(' 'RS' 5)) (ReadaheadTable 6 (Identifier 'RSN' 14) (#'(' 'RS' 5) (Integer 'RSN' 39) (Primary 'RSN' 38) (Term 'RSN' 15)) (ReadaheadTable 7 (Identifier 'RSN' 14) (#'(' 'RS' 5) (Integer 'RSN' 39) (Primary 'RSN' 38) (Term 'RSN' 16)) (ReadaheadTable 8 (Identifier 'RSN' 17)) (ReadaheadTable 9 (Identifier 'RSN' 14) (#'(' 'RS' 5) (Integer 'RSN' 39) (Primary 'RSN' 43)) (ReadaheadTable 10 (Identifier 'RSN' 14) (#'(' 'RS' 5) (Integer 'RSN' 39) (Primary 'RSN' 44)) (ReadaheadTable 11 (Expression 'RSN' 18) (#')' 'RS' 45) (Term 'RSN' 3) (Primary 'RSN' 38) (Integer 'RSN' 39) (Identifier 'RSN' 14) (#'(' 'RS' 5)) (ReadaheadTable 12 (Expression 'RSN' 19) (Primary 'RSN' 38) (Term 'RSN' 3) (Integer 'RSN' 39) (Identifier 'RSN' 14) (#'(' 'RS' 5)) (ReadaheadTable 13 (#')' 'RS' 40) (#'+' 'RS' 6) (#'-' 'RS' 7)) (ReadaheadTable 14 (#'(' 'RS' 11) (#'+' 'L' 39) (#'-' 'L' 39) (#'*' 'L' 39) (#'/' 'L' 39) (where 'L' 39) (#'-|' 'L' 39) (#';' 'L' 39) (#')' 'L' 39) (#',' 'L' 39)) (ReadaheadTable 15 (#'*' 'RS' 9) (#'/' 'RS' 10) (#'+' 'L' 41) (#'-' 'L' 41) (where 'L' 41) (#'-|' 'L' 41) (#';' 'L' 41) (#')' 'L' 41) (#',' 'L' 41)) (ReadaheadTable 16 (#'*' 'RS' 9) (#'/' 'RS' 10) (#'+' 'L' 42) (#'-' 'L' 42) (where 'L' 42) (#'-|' 'L' 42) (#';' 'L' 42) (#')' 'L' 42) (#',' 'L' 42)) (ReadaheadTable 17 (#'=' 'RS' 20)) (ReadaheadTable 18 (#'+' 'RS' 6) (#'-' 'RS' 7) (#',' 'RS' 21) (#')' 'RS' 45)) (ReadaheadTable 19 (#';' 'RS' 22) (#'+' 'RS' 6) (#'-' 'RS' 7)) (ReadaheadTable 20 (Expression 'RSN' 23) (Primary 'RSN' 38) (Term 'RSN' 3) (Integer 'RSN' 39) (Identifier 'RSN' 14) (#'(' 'RS' 5)) (ReadaheadTable 21 (Expression 'RSN' 24) (Primary 'RSN' 38) (Term 'RSN' 3) (Integer 'RSN' 39) (Identifier 'RSN' 14) (#'(' 'RS' 5)) (ReadaheadTable 22 (Identifier 'RSN' 25) (#'-|' 'L' 46)) (ReadaheadTable 23 (#'+' 'RS' 6) (#'-' 'RS' 7) (#';' 'RS' 26)) (ReadaheadTable 24 (#'+' 'RS' 6) (#'-' 'RS' 7) (#',' 'RS' 21) (#')' 'RS' 45)) (ReadaheadTable 25 (#'=' 'RS' 12)) (ReadaheadTable 26 (Identifier 'RSN' 17) (#'-|' 'L' 47)) (ReadbackTable 27 ((Expression 24) 'RSN' 49) ((Expression 18) 'RSN' 50) ((#'(' 11) 'RS' 32)) (ReadbackTable 28 ((Expression 13) 'RSN' 56) ((Expression 23) 'RSN' 56) ((Expression 24) 'RSN' 56) ((Expression 2) 'RSN' 56) ((Expression 18) 'RSN' 56) ((Expression 19) 'RSN' 56)) (ReadbackTable 29 ((Expression 13) 'RSN' 57) ((Expression 23) 'RSN' 57) ((Expression 24) 'RSN' 57) ((Expression 2) 'RSN' 57) ((Expression 18) 'RSN' 57) ((Expression 19) 'RSN' 57)) (ReadbackTable 30 ((Term 15) 'RSN' 58) ((Term 16) 'RSN' 58) ((Term 3) 'RSN' 58)) (ReadbackTable 31 ((Term 15) 'RSN' 59) ((Term 16) 'RSN' 59) ((Term 3) 'RSN' 59)) (ReadbackTable 32 ((Identifier 14) 'RSN' 60) ((Identifier 4) 'RSN' 60)) (ReadbackTable 33 ((Expression 24) 'RSN' 49) ((Expression 18) 'RSN' 50)) (ReadbackTable 34 ((Identifier 25) 'RSN' 46) ((Identifier 4) 'RSN' 61)) (ReadbackTable 35 ((#';' 26) 'RS' 48) ((where 8) 'RS' 51)) (ShiftbackTable 36 1 53) (ShiftbackTable 37 1 52) (ShiftbackTable 38 1 54) (ShiftbackTable 39 1 55) (ShiftbackTable 40 3 55) (ShiftbackTable 41 2 28) (ShiftbackTable 42 2 29) (ShiftbackTable 43 2 30) (ShiftbackTable 44 2 31) (ShiftbackTable 45 1 27) (ShiftbackTable 46 3 34) (ShiftbackTable 47 4 35) (ShiftbackTable 48 3 35) (ShiftbackTable 49 1 33) (ShiftbackTable 50 1 32) (ShiftbackTable 51 1 62) (ReduceTable 52 Expression (1 'RSN' 2)(5 'RSN' 13)(11 'RSN' 18)(12 'RSN' 19)(20 'RSN' 23)(21 'RSN' 24)) (ReduceTable 53 Grammar (1 'RSN' 63)) (ReduceTable 54 Term (1 'RSN' 3)(5 'RSN' 3)(6 'RSN' 15)(7 'RSN' 16)(11 'RSN' 3)(12 'RSN' 3)(20 'RSN' 3)(21 'RSN' 3)) (ReduceTable 55 Primary (1 'RSN' 38)(5 'RSN' 38)(6 'RSN' 38)(7 'RSN' 38)(9 'RSN' 43)(10 'RSN' 44)(11 'RSN' 38)(12 'RSN' 38)(20 'RSN' 38)(21 'RSN' 38)) (SemanticTable 56 buildTree: #'+' 52) (SemanticTable 57 buildTree: #'-' 52) (SemanticTable 58 buildTree: #'*' 54) (SemanticTable 59 buildTree: #'/' 54) (SemanticTable 60 buildTree: send 55) (SemanticTable 61 buildTree: #'<-' 53) (SemanticTable 62 buildTree: where 53) (AcceptTable 63)) //RUBY -----------------------------------> [ [:keywords, 'where'], [:ReadaheadTable, 1, [Expression, 'RSN', 2], [Term, 'RSN', 3], [Primary, 'RSN', 38], [Integer, 'RSN', 39], [Identifier, 'RSN', 4], [Grammar, 'RSN', 63], [:'(', 'RS', 5]], [:ReadaheadTable, 2, [:'+', 'RS', 6], [:'-', 'RS', 7], [where, 'RS', 8], [:'-|', 'L', 36]], [:ReadaheadTable, 3, [:'*', 'RS', 9], [:'/', 'RS', 10], [:'+', 'L', 37], [:'-', 'L', 37], [where, 'L', 37], [:'-|', 'L', 37], [:';', 'L', 37], [:')', 'L', 37], [:',', 'L', 37]], [:ReadaheadTable, 4, [:'(', 'RS', 11], [:'=', 'RS', 12], [:'+', 'L', 39], [:'-', 'L', 39], [:'*', 'L', 39], [:'/', 'L', 39], [where, 'L', 39], [:'-|', 'L', 39], [:';', 'L', 39], [:')', 'L', 39], [:',', 'L', 39]], [:ReadaheadTable, 5, [Expression, 'RSN', 13], [Primary, 'RSN', 38], [Term, 'RSN', 3], [Integer, 'RSN', 39], [Identifier, 'RSN', 14], [:'(', 'RS', 5]], [:ReadaheadTable, 6, [Identifier, 'RSN', 14], [:'(', 'RS', 5], [Integer, 'RSN', 39], [Primary, 'RSN', 38], [Term, 'RSN', 15]], [:ReadaheadTable, 7, [Identifier, 'RSN', 14], [:'(', 'RS', 5], [Integer, 'RSN', 39], [Primary, 'RSN', 38], [Term, 'RSN', 16]], [:ReadaheadTable, 8, [Identifier, 'RSN', 17]], [:ReadaheadTable, 9, [Identifier, 'RSN', 14], [:'(', 'RS', 5], [Integer, 'RSN', 39], [Primary, 'RSN', 43]], [:ReadaheadTable, 10, [Identifier, 'RSN', 14], [:'(', 'RS', 5], [Integer, 'RSN', 39], [Primary, 'RSN', 44]], [:ReadaheadTable, 11, [Expression, 'RSN', 18], [:')', 'RS', 45], [Term, 'RSN', 3], [Primary, 'RSN', 38], [Integer, 'RSN', 39], [Identifier, 'RSN', 14], [:'(', 'RS', 5]], [:ReadaheadTable, 12, [Expression, 'RSN', 19], [Primary, 'RSN', 38], [Term, 'RSN', 3], [Integer, 'RSN', 39], [Identifier, 'RSN', 14], [:'(', 'RS', 5]], [:ReadaheadTable, 13, [:')', 'RS', 40], [:'+', 'RS', 6], [:'-', 'RS', 7]], [:ReadaheadTable, 14, [:'(', 'RS', 11], [:'+', 'L', 39], [:'-', 'L', 39], [:'*', 'L', 39], [:'/', 'L', 39], [where, 'L', 39], [:'-|', 'L', 39], [:';', 'L', 39], [:')', 'L', 39], [:',', 'L', 39]], [:ReadaheadTable, 15, [:'*', 'RS', 9], [:'/', 'RS', 10], [:'+', 'L', 41], [:'-', 'L', 41], [where, 'L', 41], [:'-|', 'L', 41], [:';', 'L', 41], [:')', 'L', 41], [:',', 'L', 41]], [:ReadaheadTable, 16, [:'*', 'RS', 9], [:'/', 'RS', 10], [:'+', 'L', 42], [:'-', 'L', 42], [where, 'L', 42], [:'-|', 'L', 42], [:';', 'L', 42], [:')', 'L', 42], [:',', 'L', 42]], [:ReadaheadTable, 17, [:'=', 'RS', 20]], [:ReadaheadTable, 18, [:'+', 'RS', 6], [:'-', 'RS', 7], [:',', 'RS', 21], [:')', 'RS', 45]], [:ReadaheadTable, 19, [:';', 'RS', 22], [:'+', 'RS', 6], [:'-', 'RS', 7]], [:ReadaheadTable, 20, [Expression, 'RSN', 23], [Primary, 'RSN', 38], [Term, 'RSN', 3], [Integer, 'RSN', 39], [Identifier, 'RSN', 14], [:'(', 'RS', 5]], [:ReadaheadTable, 21, [Expression, 'RSN', 24], [Primary, 'RSN', 38], [Term, 'RSN', 3], [Integer, 'RSN', 39], [Identifier, 'RSN', 14], [:'(', 'RS', 5]], [:ReadaheadTable, 22, [Identifier, 'RSN', 25], [:'-|', 'L', 46]], [:ReadaheadTable, 23, [:'+', 'RS', 6], [:'-', 'RS', 7], [:';', 'RS', 26]], [:ReadaheadTable, 24, [:'+', 'RS', 6], [:'-', 'RS', 7], [:',', 'RS', 21], [:')', 'RS', 45]], [:ReadaheadTable, 25, [:'=', 'RS', 12]], [:ReadaheadTable, 26, [Identifier, 'RSN', 17], [:'-|', 'L', 47]], [:ReadbackTable, 27, [[Expression, 24], 'RSN', 49], [[Expression, 18], 'RSN', 50], [[:'(', 11], 'RS', 32]], [:ReadbackTable, 28, [[Expression, 13], 'RSN', 56], [[Expression, 23], 'RSN', 56], [[Expression, 24], 'RSN', 56], [[Expression, 2], 'RSN', 56], [[Expression, 18], 'RSN', 56], [[Expression, 19], 'RSN', 56]], [:ReadbackTable, 29, [[Expression, 13], 'RSN', 57], [[Expression, 23], 'RSN', 57], [[Expression, 24], 'RSN', 57], [[Expression, 2], 'RSN', 57], [[Expression, 18], 'RSN', 57], [[Expression, 19], 'RSN', 57]], [:ReadbackTable, 30, [[Term, 15], 'RSN', 58], [[Term, 16], 'RSN', 58], [[Term, 3], 'RSN', 58]], [:ReadbackTable, 31, [[Term, 15], 'RSN', 59], [[Term, 16], 'RSN', 59], [[Term, 3], 'RSN', 59]], [:ReadbackTable, 32, [[Identifier, 14], 'RSN', 60], [[Identifier, 4], 'RSN', 60]], [:ReadbackTable, 33, [[Expression, 24], 'RSN', 49], [[Expression, 18], 'RSN', 50]], [:ReadbackTable, 34, [[Identifier, 25], 'RSN', 46], [[Identifier, 4], 'RSN', 61]], [:ReadbackTable, 35, [[:';', 26], 'RS', 48], [[where, 8], 'RS', 51]], [ShiftbackTable, 36, 1, 53], [ShiftbackTable, 37, 1, 52], [ShiftbackTable, 38, 1, 54], [ShiftbackTable, 39, 1, 55], [ShiftbackTable, 40, 3, 55], [ShiftbackTable, 41, 2, 28], [ShiftbackTable, 42, 2, 29], [ShiftbackTable, 43, 2, 30], [ShiftbackTable, 44, 2, 31], [ShiftbackTable, 45, 1, 27], [ShiftbackTable, 46, 3, 34], [ShiftbackTable, 47, 4, 35], [ShiftbackTable, 48, 3, 35], [ShiftbackTable, 49, 1, 33], [ShiftbackTable, 50, 1, 32], [ShiftbackTable, 51, 1, 62], [:ReduceTable, 52, Expression, [[1, 'RSN', 2], [5, 'RSN', 13], [11, 'RSN', 18], [12, 'RSN', 19], [20, 'RSN', 23], [21, 'RSN', 24]]], [:ReduceTable, 53, Grammar, [[1, 'RSN', 63]]], [:ReduceTable, 54, Term, [[1, 'RSN', 3], [5, 'RSN', 3], [6, 'RSN', 15], [7, 'RSN', 16], [11, 'RSN', 3], [12, 'RSN', 3], [20, 'RSN', 3], [21, 'RSN', 3]]], [:ReduceTable, 55, Primary, [[1, 'RSN', 38], [5, 'RSN', 38], [6, 'RSN', 38], [7, 'RSN', 38], [9, 'RSN', 43], [10, 'RSN', 44], [11, 'RSN', 38], [12, 'RSN', 38], [20, 'RSN', 38], [21, 'RSN', 38]]], [:SemanticTable, 56, :buildTree, :'+', 52], [:SemanticTable, 57, :buildTree, :'-', 52], [:SemanticTable, 58, :buildTree, :'*', 54], [:SemanticTable, 59, :buildTree, :'/', 54], [:SemanticTable, 60, :buildTree, send, 55], [:SemanticTable, 61, :buildTree, :'<-', 53], [:SemanticTable, 62, :buildTree, where, 53], [:AcceptTable, 63]] //C++: ONE EXPRESSION VERSION ----------------------> //For parsingTables.h struct RawReadaheadTriple {const char *string; const char *attributes; long gotoTable;}; struct RawReadaheadTable {const char *name; long state; long size; RawReadaheadTriple **triples;}; struct RawReadbackPair {const char *symbol; long state;}; struct RawReadbackTriple {RawReadbackPair pair; const char *attributes; long gotoTable;}; struct RawReadbackTable {const char *name; long state; long size; RawReadbackTriple **triples;}; struct RawShiftbackTable {const char *name; long state; long shift; long gotoTable;}; struct RawReduceTriple {long stackTopState; const char *attributes; long gotoTable;}; struct RawReduceTable {const char *name; long state; const char *nonterminal; long size; RawReduceTriple **triples;}; //The following is assumed available from scanner.h //struct RawSemanticTable {const char *name; long state; const char *action; long size; const char **parameters; long gotoTable;}; struct RawAcceptTable {const char *name; long state;}; struct ParserTables { long keywordsSize; const char **keywords; long readaheadTablesSize; RawReadaheadTable **readaheadTables; long readbackTablesSize; RawReadbackTable **readbackTables; long shiftbackTablesSize; RawShiftbackTable **shiftbackTables; long reduceTablesSize; RawReduceTable **reduceTables; long semanticTablesSize; RawSemanticTable **semanticTables; RawAcceptTable *acceptTable; }; ParserTables *parserTables(); void deleteParserTables(ParserTables *parserTable); ParserTables *parserTables () { return new ParserTables { 1, new const char * [1] {"where"}, 26, new RawReadaheadTable* [26] { new RawReadaheadTable {"ReadaheadTable", 0, 7, new RawReadaheadTriple* [7] { new RawReadaheadTriple {"Expression", "RSN", 1}, new RawReadaheadTriple {"Term", "RSN", 2}, new RawReadaheadTriple {"Primary", "RSN", 37}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Identifier", "RSN", 3}, new RawReadaheadTriple {"Grammar", "RSN", 62}, new RawReadaheadTriple {"(", "RS", 4}}}, new RawReadaheadTable {"ReadaheadTable", 1, 4, new RawReadaheadTriple* [4] { new RawReadaheadTriple {"+", "RS", 5}, new RawReadaheadTriple {"-", "RS", 6}, new RawReadaheadTriple {"where", "RS", 7}, new RawReadaheadTriple {"-|", "L", 35}}}, new RawReadaheadTable {"ReadaheadTable", 2, 9, new RawReadaheadTriple* [9] { new RawReadaheadTriple {"*", "RS", 8}, new RawReadaheadTriple {"/", "RS", 9}, new RawReadaheadTriple {"+", "L", 36}, new RawReadaheadTriple {"-", "L", 36}, new RawReadaheadTriple {"where", "L", 36}, new RawReadaheadTriple {"-|", "L", 36}, new RawReadaheadTriple {";", "L", 36}, new RawReadaheadTriple {")", "L", 36}, new RawReadaheadTriple {",", "L", 36}}}, new RawReadaheadTable {"ReadaheadTable", 3, 11, new RawReadaheadTriple* [11] { new RawReadaheadTriple {"(", "RS", 10}, new RawReadaheadTriple {"=", "RS", 11}, new RawReadaheadTriple {"+", "L", 38}, new RawReadaheadTriple {"-", "L", 38}, new RawReadaheadTriple {"*", "L", 38}, new RawReadaheadTriple {"/", "L", 38}, new RawReadaheadTriple {"where", "L", 38}, new RawReadaheadTriple {"-|", "L", 38}, new RawReadaheadTriple {";", "L", 38}, new RawReadaheadTriple {")", "L", 38}, new RawReadaheadTriple {",", "L", 38}}}, new RawReadaheadTable {"ReadaheadTable", 4, 6, new RawReadaheadTriple* [6] { new RawReadaheadTriple {"Expression", "RSN", 12}, new RawReadaheadTriple {"Primary", "RSN", 37}, new RawReadaheadTriple {"Term", "RSN", 2}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Identifier", "RSN", 13}, new RawReadaheadTriple {"(", "RS", 4}}}, new RawReadaheadTable {"ReadaheadTable", 5, 5, new RawReadaheadTriple* [5] { new RawReadaheadTriple {"Identifier", "RSN", 13}, new RawReadaheadTriple {"(", "RS", 4}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Primary", "RSN", 37}, new RawReadaheadTriple {"Term", "RSN", 14}}}, new RawReadaheadTable {"ReadaheadTable", 6, 5, new RawReadaheadTriple* [5] { new RawReadaheadTriple {"Identifier", "RSN", 13}, new RawReadaheadTriple {"(", "RS", 4}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Primary", "RSN", 37}, new RawReadaheadTriple {"Term", "RSN", 15}}}, new RawReadaheadTable {"ReadaheadTable", 7, 1, new RawReadaheadTriple* [1] { new RawReadaheadTriple {"Identifier", "RSN", 16}}}, new RawReadaheadTable {"ReadaheadTable", 8, 4, new RawReadaheadTriple* [4] { new RawReadaheadTriple {"Identifier", "RSN", 13}, new RawReadaheadTriple {"(", "RS", 4}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Primary", "RSN", 42}}}, new RawReadaheadTable {"ReadaheadTable", 9, 4, new RawReadaheadTriple* [4] { new RawReadaheadTriple {"Identifier", "RSN", 13}, new RawReadaheadTriple {"(", "RS", 4}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Primary", "RSN", 43}}}, new RawReadaheadTable {"ReadaheadTable", 10, 7, new RawReadaheadTriple* [7] { new RawReadaheadTriple {"Expression", "RSN", 17}, new RawReadaheadTriple {")", "RS", 44}, new RawReadaheadTriple {"Term", "RSN", 2}, new RawReadaheadTriple {"Primary", "RSN", 37}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Identifier", "RSN", 13}, new RawReadaheadTriple {"(", "RS", 4}}}, new RawReadaheadTable {"ReadaheadTable", 11, 6, new RawReadaheadTriple* [6] { new RawReadaheadTriple {"Expression", "RSN", 18}, new RawReadaheadTriple {"Primary", "RSN", 37}, new RawReadaheadTriple {"Term", "RSN", 2}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Identifier", "RSN", 13}, new RawReadaheadTriple {"(", "RS", 4}}}, new RawReadaheadTable {"ReadaheadTable", 12, 3, new RawReadaheadTriple* [3] { new RawReadaheadTriple {")", "RS", 39}, new RawReadaheadTriple {"+", "RS", 5}, new RawReadaheadTriple {"-", "RS", 6}}}, new RawReadaheadTable {"ReadaheadTable", 13, 10, new RawReadaheadTriple* [10] { new RawReadaheadTriple {"(", "RS", 10}, new RawReadaheadTriple {"+", "L", 38}, new RawReadaheadTriple {"-", "L", 38}, new RawReadaheadTriple {"*", "L", 38}, new RawReadaheadTriple {"/", "L", 38}, new RawReadaheadTriple {"where", "L", 38}, new RawReadaheadTriple {"-|", "L", 38}, new RawReadaheadTriple {";", "L", 38}, new RawReadaheadTriple {")", "L", 38}, new RawReadaheadTriple {",", "L", 38}}}, new RawReadaheadTable {"ReadaheadTable", 14, 9, new RawReadaheadTriple* [9] { new RawReadaheadTriple {"*", "RS", 8}, new RawReadaheadTriple {"/", "RS", 9}, new RawReadaheadTriple {"+", "L", 40}, new RawReadaheadTriple {"-", "L", 40}, new RawReadaheadTriple {"where", "L", 40}, new RawReadaheadTriple {"-|", "L", 40}, new RawReadaheadTriple {";", "L", 40}, new RawReadaheadTriple {")", "L", 40}, new RawReadaheadTriple {",", "L", 40}}}, new RawReadaheadTable {"ReadaheadTable", 15, 9, new RawReadaheadTriple* [9] { new RawReadaheadTriple {"*", "RS", 8}, new RawReadaheadTriple {"/", "RS", 9}, new RawReadaheadTriple {"+", "L", 41}, new RawReadaheadTriple {"-", "L", 41}, new RawReadaheadTriple {"where", "L", 41}, new RawReadaheadTriple {"-|", "L", 41}, new RawReadaheadTriple {";", "L", 41}, new RawReadaheadTriple {")", "L", 41}, new RawReadaheadTriple {",", "L", 41}}}, new RawReadaheadTable {"ReadaheadTable", 16, 1, new RawReadaheadTriple* [1] { new RawReadaheadTriple {"=", "RS", 19}}}, new RawReadaheadTable {"ReadaheadTable", 17, 4, new RawReadaheadTriple* [4] { new RawReadaheadTriple {"+", "RS", 5}, new RawReadaheadTriple {"-", "RS", 6}, new RawReadaheadTriple {",", "RS", 20}, new RawReadaheadTriple {")", "RS", 44}}}, new RawReadaheadTable {"ReadaheadTable", 18, 3, new RawReadaheadTriple* [3] { new RawReadaheadTriple {";", "RS", 21}, new RawReadaheadTriple {"+", "RS", 5}, new RawReadaheadTriple {"-", "RS", 6}}}, new RawReadaheadTable {"ReadaheadTable", 19, 6, new RawReadaheadTriple* [6] { new RawReadaheadTriple {"Expression", "RSN", 22}, new RawReadaheadTriple {"Primary", "RSN", 37}, new RawReadaheadTriple {"Term", "RSN", 2}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Identifier", "RSN", 13}, new RawReadaheadTriple {"(", "RS", 4}}}, new RawReadaheadTable {"ReadaheadTable", 20, 6, new RawReadaheadTriple* [6] { new RawReadaheadTriple {"Expression", "RSN", 23}, new RawReadaheadTriple {"Primary", "RSN", 37}, new RawReadaheadTriple {"Term", "RSN", 2}, new RawReadaheadTriple {"Integer", "RSN", 38}, new RawReadaheadTriple {"Identifier", "RSN", 13}, new RawReadaheadTriple {"(", "RS", 4}}}, new RawReadaheadTable {"ReadaheadTable", 21, 2, new RawReadaheadTriple* [2] { new RawReadaheadTriple {"Identifier", "RSN", 24}, new RawReadaheadTriple {"-|", "L", 45}}}, new RawReadaheadTable {"ReadaheadTable", 22, 3, new RawReadaheadTriple* [3] { new RawReadaheadTriple {"+", "RS", 5}, new RawReadaheadTriple {"-", "RS", 6}, new RawReadaheadTriple {";", "RS", 25}}}, new RawReadaheadTable {"ReadaheadTable", 23, 4, new RawReadaheadTriple* [4] { new RawReadaheadTriple {"+", "RS", 5}, new RawReadaheadTriple {"-", "RS", 6}, new RawReadaheadTriple {",", "RS", 20}, new RawReadaheadTriple {")", "RS", 44}}}, new RawReadaheadTable {"ReadaheadTable", 24, 1, new RawReadaheadTriple* [1] { new RawReadaheadTriple {"=", "RS", 11}}}, new RawReadaheadTable {"ReadaheadTable", 25, 2, new RawReadaheadTriple* [2] { new RawReadaheadTriple {"Identifier", "RSN", 16}, new RawReadaheadTriple {"-|", "L", 46}}}}, 9, new RawReadbackTable* [9] { new RawReadbackTable {"ReadbackTable", 26, 3, new RawReadbackTriple* [3] { new RawReadbackTriple {{"Expression", 23}, "RSN", 48}, new RawReadbackTriple {{"Expression", 17}, "RSN", 49}, new RawReadbackTriple {{"(", 10}, "RS", 31}}}, new RawReadbackTable {"ReadbackTable", 27, 6, new RawReadbackTriple* [6] { new RawReadbackTriple {{"Expression", 12}, "RSN", 55}, new RawReadbackTriple {{"Expression", 22}, "RSN", 55}, new RawReadbackTriple {{"Expression", 23}, "RSN", 55}, new RawReadbackTriple {{"Expression", 1}, "RSN", 55}, new RawReadbackTriple {{"Expression", 17}, "RSN", 55}, new RawReadbackTriple {{"Expression", 18}, "RSN", 55}}}, new RawReadbackTable {"ReadbackTable", 28, 6, new RawReadbackTriple* [6] { new RawReadbackTriple {{"Expression", 12}, "RSN", 56}, new RawReadbackTriple {{"Expression", 22}, "RSN", 56}, new RawReadbackTriple {{"Expression", 23}, "RSN", 56}, new RawReadbackTriple {{"Expression", 1}, "RSN", 56}, new RawReadbackTriple {{"Expression", 17}, "RSN", 56}, new RawReadbackTriple {{"Expression", 18}, "RSN", 56}}}, new RawReadbackTable {"ReadbackTable", 29, 3, new RawReadbackTriple* [3] { new RawReadbackTriple {{"Term", 14}, "RSN", 57}, new RawReadbackTriple {{"Term", 15}, "RSN", 57}, new RawReadbackTriple {{"Term", 2}, "RSN", 57}}}, new RawReadbackTable {"ReadbackTable", 30, 3, new RawReadbackTriple* [3] { new RawReadbackTriple {{"Term", 14}, "RSN", 58}, new RawReadbackTriple {{"Term", 15}, "RSN", 58}, new RawReadbackTriple {{"Term", 2}, "RSN", 58}}}, new RawReadbackTable {"ReadbackTable", 31, 2, new RawReadbackTriple* [2] { new RawReadbackTriple {{"Identifier", 13}, "RSN", 59}, new RawReadbackTriple {{"Identifier", 3}, "RSN", 59}}}, new RawReadbackTable {"ReadbackTable", 32, 2, new RawReadbackTriple* [2] { new RawReadbackTriple {{"Expression", 23}, "RSN", 48}, new RawReadbackTriple {{"Expression", 17}, "RSN", 49}}}, new RawReadbackTable {"ReadbackTable", 33, 2, new RawReadbackTriple* [2] { new RawReadbackTriple {{"Identifier", 24}, "RSN", 45}, new RawReadbackTriple {{"Identifier", 3}, "RSN", 60}}}, new RawReadbackTable {"ReadbackTable", 34, 2, new RawReadbackTriple* [2] { new RawReadbackTriple {{";", 25}, "RS", 47}, new RawReadbackTriple {{"where", 7}, "RS", 50}}}}, 16, new RawShiftbackTable* [16] { new RawShiftbackTable {"ShiftbackTable", 35, 1, 52}, new RawShiftbackTable {"ShiftbackTable", 36, 1, 51}, new RawShiftbackTable {"ShiftbackTable", 37, 1, 53}, new RawShiftbackTable {"ShiftbackTable", 38, 1, 54}, new RawShiftbackTable {"ShiftbackTable", 39, 3, 54}, new RawShiftbackTable {"ShiftbackTable", 40, 2, 27}, new RawShiftbackTable {"ShiftbackTable", 41, 2, 28}, new RawShiftbackTable {"ShiftbackTable", 42, 2, 29}, new RawShiftbackTable {"ShiftbackTable", 43, 2, 30}, new RawShiftbackTable {"ShiftbackTable", 44, 1, 26}, new RawShiftbackTable {"ShiftbackTable", 45, 3, 33}, new RawShiftbackTable {"ShiftbackTable", 46, 4, 34}, new RawShiftbackTable {"ShiftbackTable", 47, 3, 34}, new RawShiftbackTable {"ShiftbackTable", 48, 1, 32}, new RawShiftbackTable {"ShiftbackTable", 49, 1, 31}, new RawShiftbackTable {"ShiftbackTable", 50, 1, 61}}, 4, new RawReduceTable* [4] { new RawReduceTable {"ReduceTable", 51, "Expression", 6, new RawReduceTriple* [6] { new RawReduceTriple {0, "RSN", 1}, new RawReduceTriple {4, "RSN", 12}, new RawReduceTriple {10, "RSN", 17}, new RawReduceTriple {11, "RSN", 18}, new RawReduceTriple {19, "RSN", 22}, new RawReduceTriple {20, "RSN", 23}}}, new RawReduceTable {"ReduceTable", 52, "Grammar", 1, new RawReduceTriple* [1] { new RawReduceTriple {0, "RSN", 62}}}, new RawReduceTable {"ReduceTable", 53, "Term", 8, new RawReduceTriple* [8] { new RawReduceTriple {0, "RSN", 2}, new RawReduceTriple {4, "RSN", 2}, new RawReduceTriple {5, "RSN", 14}, new RawReduceTriple {6, "RSN", 15}, new RawReduceTriple {10, "RSN", 2}, new RawReduceTriple {11, "RSN", 2}, new RawReduceTriple {19, "RSN", 2}, new RawReduceTriple {20, "RSN", 2}}}, new RawReduceTable {"ReduceTable", 54, "Primary", 10, new RawReduceTriple* [10] { new RawReduceTriple {0, "RSN", 37}, new RawReduceTriple {4, "RSN", 37}, new RawReduceTriple {5, "RSN", 37}, new RawReduceTriple {6, "RSN", 37}, new RawReduceTriple {8, "RSN", 42}, new RawReduceTriple {9, "RSN", 43}, new RawReduceTriple {10, "RSN", 37}, new RawReduceTriple {11, "RSN", 37}, new RawReduceTriple {19, "RSN", 37}, new RawReduceTriple {20, "RSN", 37}}}}, 7, new RawSemanticTable* [7] { new RawSemanticTable {"SemanticTable", 55, "buildTree", 1, new const char * [1] {"+"}, 51}, new RawSemanticTable {"SemanticTable", 56, "buildTree", 1, new const char * [1] {"-"}, 51}, new RawSemanticTable {"SemanticTable", 57, "buildTree", 1, new const char * [1] {"*"}, 53}, new RawSemanticTable {"SemanticTable", 58, "buildTree", 1, new const char * [1] {"/"}, 53}, new RawSemanticTable {"SemanticTable", 59, "buildTree", 1, new const char * [1] {"send"}, 54}, new RawSemanticTable {"SemanticTable", 60, "buildTree", 1, new const char * [1] {"<-"}, 52}, new RawSemanticTable {"SemanticTable", 61, "buildTree", 1, new const char * [1] {"where"}, 52}}, new RawAcceptTable {"AcceptTable", 62}}; }; void deleteParserTables (ParserTables *parserTable) { delete [] parserTable->keywords; for (long index0 = 0; index0 < parserTable->readaheadTablesSize; index0++) { for (long index1 = 0; index1< parserTable->readaheadTables [index0]->size; index1++) { delete parserTable->readaheadTables [index0]->triples [index1]; } delete [] parserTable->readaheadTables [index0]->triples; delete parserTable->readaheadTables [index0]; } delete [] parserTable->readaheadTables; for (long index0 = 0; index0 < parserTable->readbackTablesSize; index0++) { for (long index1 = 0; index1< parserTable->readbackTables [index0]->size; index1++) { delete parserTable->readbackTables [index0]->triples [index1]; } delete [] parserTable->readbackTables [index0]->triples; delete parserTable->readbackTables [index0]; } delete [] parserTable->readbackTables; for (long index0 = 0; index0 < parserTable->shiftbackTablesSize; index0++) { delete parserTable->shiftbackTables [index0]; } delete [] parserTable->shiftbackTables; for (long index0 = 0; index0 < parserTable->reduceTablesSize; index0++) { for (long index1 = 0; index1< parserTable->reduceTables [index0]->size; index1++) { delete parserTable->reduceTables [index0]->triples [index1]; } delete [] parserTable->reduceTables [index0]->triples; delete parserTable->reduceTables [index0]; } delete [] parserTable->reduceTables; for (long index = 0; index < parserTable->semanticTablesSize; index++) { delete [] parserTable->semanticTables [index]->parameters; delete parserTable->semanticTables [index]; } delete [] parserTable->semanticTables; delete parserTable->acceptTable; delete parserTable; } //C++: MULTI-STATEMENT VERSION ----------------------> //NOTE: The following declarations should probably be moved manually to a more global location for access elsewhere... struct RawReadaheadTriple {const char *string; const char *attributes; long gotoTable;}; struct RawReadaheadTable {const char *name; long state; long size; RawReadaheadTriple *triples;}; struct RawReadbackPair {const char *symbol; long state;}; struct RawReadbackTriple {RawReadbackPair pair; const char *attributes; long gotoTable;}; struct RawReadbackTable {const char *name; long state; long size; RawReadbackTriple *triples;}; struct RawShiftbackTable {const char *name; long state; long shift; long gotoTable;}; struct RawReduceTriple {long stackTopState; const char *attributes; long gotoTable;}; struct RawReduceTable {const char *name; long state; const char *nonterminal; long size; RawReduceTriple *triples;}; struct RawSemanticTable {const char *name; long state; const char *action; long size; const char **parameters; long gotoTable;}; struct RawAcceptTable {const char *name; long state;}; struct ParserTables { long keywordsSize; const char **keywords; long readaheadTablesSize; RawReadaheadTable *readaheadTables; long readbackTablesSize; RawReadbackTable *readbackTables; long shiftbackTablesSize; RawShiftbackTable *shiftbackTables; long reduceTablesSize; RawReduceTable *reduceTables; long semanticTablesSize; RawSemanticTable *semanticTables; RawAcceptTable *acceptTable; }; //For parsingTables.cpp ParserTables *parserTables () { const char **keywords = new const char * [1] {"where"}; //Define VARIABLES to refer to readahead table TRIPLEs. //FORMAT: RawReadaheadTriple {const char *string; const char *attributes; long gotoTableNumber;} //Note: string == NULL is equivalent to "{256}" (end of file). RawReadaheadTriple *ra0 = new RawReadaheadTriple [7] {{"Expression", "RSN", 1}, {"Term", "RSN", 2}, {"Primary", "RSN", 37}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 3}, {"Grammar", "RSN", 62}, {"(", "RS", 4}}; RawReadaheadTriple *ra1 = new RawReadaheadTriple [4] {{"+", "RS", 5}, {"-", "RS", 6}, {"where", "RS", 7}, {"-|", "L", 35}}; RawReadaheadTriple *ra2 = new RawReadaheadTriple [9] {{"*", "RS", 8}, {"/", "RS", 9}, {"+", "L", 36}, {"-", "L", 36}, {"where", "L", 36}, {"-|", "L", 36}, {";", "L", 36}, {")", "L", 36}, {",", "L", 36}}; RawReadaheadTriple *ra3 = new RawReadaheadTriple [11] {{"(", "RS", 10}, {"=", "RS", 11}, {"+", "L", 38}, {"-", "L", 38}, {"*", "L", 38}, {"/", "L", 38}, {"where", "L", 38}, {"-|", "L", 38}, {";", "L", 38}, {")", "L", 38}, {",", "L", 38}}; RawReadaheadTriple *ra4 = new RawReadaheadTriple [6] {{"Expression", "RSN", 12}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra5 = new RawReadaheadTriple [5] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 37}, {"Term", "RSN", 14}}; RawReadaheadTriple *ra6 = new RawReadaheadTriple [5] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 37}, {"Term", "RSN", 15}}; RawReadaheadTriple *ra7 = new RawReadaheadTriple [1] {{"Identifier", "RSN", 16}}; RawReadaheadTriple *ra8 = new RawReadaheadTriple [4] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 42}}; RawReadaheadTriple *ra9 = new RawReadaheadTriple [4] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 43}}; RawReadaheadTriple *ra10 = new RawReadaheadTriple [7] {{"Expression", "RSN", 17}, {")", "RS", 44}, {"Term", "RSN", 2}, {"Primary", "RSN", 37}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra11 = new RawReadaheadTriple [6] {{"Expression", "RSN", 18}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra12 = new RawReadaheadTriple [3] {{")", "RS", 39}, {"+", "RS", 5}, {"-", "RS", 6}}; RawReadaheadTriple *ra13 = new RawReadaheadTriple [10] {{"(", "RS", 10}, {"+", "L", 38}, {"-", "L", 38}, {"*", "L", 38}, {"/", "L", 38}, {"where", "L", 38}, {"-|", "L", 38}, {";", "L", 38}, {")", "L", 38}, {",", "L", 38}}; RawReadaheadTriple *ra14 = new RawReadaheadTriple [9] {{"*", "RS", 8}, {"/", "RS", 9}, {"+", "L", 40}, {"-", "L", 40}, {"where", "L", 40}, {"-|", "L", 40}, {";", "L", 40}, {")", "L", 40}, {",", "L", 40}}; RawReadaheadTriple *ra15 = new RawReadaheadTriple [9] {{"*", "RS", 8}, {"/", "RS", 9}, {"+", "L", 41}, {"-", "L", 41}, {"where", "L", 41}, {"-|", "L", 41}, {";", "L", 41}, {")", "L", 41}, {",", "L", 41}}; RawReadaheadTriple *ra16 = new RawReadaheadTriple [1] {{"=", "RS", 19}}; RawReadaheadTriple *ra17 = new RawReadaheadTriple [4] {{"+", "RS", 5}, {"-", "RS", 6}, {",", "RS", 20}, {")", "RS", 44}}; RawReadaheadTriple *ra18 = new RawReadaheadTriple [3] {{";", "RS", 21}, {"+", "RS", 5}, {"-", "RS", 6}}; RawReadaheadTriple *ra19 = new RawReadaheadTriple [6] {{"Expression", "RSN", 22}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra20 = new RawReadaheadTriple [6] {{"Expression", "RSN", 23}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra21 = new RawReadaheadTriple [2] {{"Identifier", "RSN", 24}, {"-|", "L", 45}}; RawReadaheadTriple *ra22 = new RawReadaheadTriple [3] {{"+", "RS", 5}, {"-", "RS", 6}, {";", "RS", 25}}; RawReadaheadTriple *ra23 = new RawReadaheadTriple [4] {{"+", "RS", 5}, {"-", "RS", 6}, {",", "RS", 20}, {")", "RS", 44}}; RawReadaheadTriple *ra24 = new RawReadaheadTriple [1] {{"=", "RS", 11}}; RawReadaheadTriple *ra25 = new RawReadaheadTriple [2] {{"Identifier", "RSN", 16}, {"-|", "L", 46}}; //Define an array of readahead tables. //FORMAT: RawReadaheadTable {char *name; long stateNumber; long size; RawReadaheadTriple *triples;} RawReadaheadTable *readaheadTables = new RawReadaheadTable [26] { {"ReadaheadTable", 0, 7, &ra0[0]}, {"ReadaheadTable", 1, 4, &ra1[0]}, {"ReadaheadTable", 2, 9, &ra2[0]}, {"ReadaheadTable", 3, 11, &ra3[0]}, {"ReadaheadTable", 4, 6, &ra4[0]}, {"ReadaheadTable", 5, 5, &ra5[0]}, {"ReadaheadTable", 6, 5, &ra6[0]}, {"ReadaheadTable", 7, 1, &ra7[0]}, {"ReadaheadTable", 8, 4, &ra8[0]}, {"ReadaheadTable", 9, 4, &ra9[0]}, {"ReadaheadTable", 10, 7, &ra10[0]}, {"ReadaheadTable", 11, 6, &ra11[0]}, {"ReadaheadTable", 12, 3, &ra12[0]}, {"ReadaheadTable", 13, 10, &ra13[0]}, {"ReadaheadTable", 14, 9, &ra14[0]}, {"ReadaheadTable", 15, 9, &ra15[0]}, {"ReadaheadTable", 16, 1, &ra16[0]}, {"ReadaheadTable", 17, 4, &ra17[0]}, {"ReadaheadTable", 18, 3, &ra18[0]}, {"ReadaheadTable", 19, 6, &ra19[0]}, {"ReadaheadTable", 20, 6, &ra20[0]}, {"ReadaheadTable", 21, 2, &ra21[0]}, {"ReadaheadTable", 22, 3, &ra22[0]}, {"ReadaheadTable", 23, 4, &ra23[0]}, {"ReadaheadTable", 24, 1, &ra24[0]}, {"ReadaheadTable", 25, 2, &ra25[0]}}; //Define VARIABLES to refer to readback table TRIPLEs. //FORMAT: RawReadbackPair {const char *symbol; long state;} //FORMAT: RawReadbackTriple {RawReadbackPair pair; const char *attributes; long gotoTableNumber;} RawReadbackTriple *rb26 = new RawReadbackTriple [3] {{{"Expression", 23}, "RSN", 48}, {{"Expression", 17}, "RSN", 49}, {{"(", 10}, "RS", 31}}; RawReadbackTriple *rb27 = new RawReadbackTriple [6] {{{"Expression", 12}, "RSN", 55}, {{"Expression", 22}, "RSN", 55}, {{"Expression", 23}, "RSN", 55}, {{"Expression", 1}, "RSN", 55}, {{"Expression", 17}, "RSN", 55}, {{"Expression", 18}, "RSN", 55}}; RawReadbackTriple *rb28 = new RawReadbackTriple [6] {{{"Expression", 12}, "RSN", 56}, {{"Expression", 22}, "RSN", 56}, {{"Expression", 23}, "RSN", 56}, {{"Expression", 1}, "RSN", 56}, {{"Expression", 17}, "RSN", 56}, {{"Expression", 18}, "RSN", 56}}; RawReadbackTriple *rb29 = new RawReadbackTriple [3] {{{"Term", 14}, "RSN", 57}, {{"Term", 15}, "RSN", 57}, {{"Term", 2}, "RSN", 57}}; RawReadbackTriple *rb30 = new RawReadbackTriple [3] {{{"Term", 14}, "RSN", 58}, {{"Term", 15}, "RSN", 58}, {{"Term", 2}, "RSN", 58}}; RawReadbackTriple *rb31 = new RawReadbackTriple [2] {{{"Identifier", 13}, "RSN", 59}, {{"Identifier", 3}, "RSN", 59}}; RawReadbackTriple *rb32 = new RawReadbackTriple [2] {{{"Expression", 23}, "RSN", 48}, {{"Expression", 17}, "RSN", 49}}; RawReadbackTriple *rb33 = new RawReadbackTriple [2] {{{"Identifier", 24}, "RSN", 45}, {{"Identifier", 3}, "RSN", 60}}; RawReadbackTriple *rb34 = new RawReadbackTriple [2] {{{";", 25}, "RS", 47}, {{"where", 7}, "RS", 50}}; //Define an array of readback tables. //FORMAT: RawReadabackTable {const char *name; long stateNumber; long size; RawReadbackTriple *triples;} RawReadbackTable *readbackTables = new RawReadbackTable [9] { {"ReadbackTable", 26, 3, rb27}, {"ReadbackTable", 27, 6, rb28}, {"ReadbackTable", 28, 6, rb29}, {"ReadbackTable", 29, 3, rb30}, {"ReadbackTable", 30, 3, rb31}, {"ReadbackTable", 31, 2, rb32}, {"ReadbackTable", 32, 2, rb33}, {"ReadbackTable", 33, 2, rb34}, {"ReadbackTable", 34, 2, rb35}}; //Define an array of shiftback tables. //FORMAT: RawShiftbackTable {const char *name; long stateNumber; long shift; long gotoTable;} RawShiftbackTable *shiftbackTables = new RawShiftbackTable [16] { {"ShiftbackTable", 35, 1, 52}, {"ShiftbackTable", 36, 1, 51}, {"ShiftbackTable", 37, 1, 53}, {"ShiftbackTable", 38, 1, 54}, {"ShiftbackTable", 39, 3, 54}, {"ShiftbackTable", 40, 2, 27}, {"ShiftbackTable", 41, 2, 28}, {"ShiftbackTable", 42, 2, 29}, {"ShiftbackTable", 43, 2, 30}, {"ShiftbackTable", 44, 1, 26}, {"ShiftbackTable", 45, 3, 33}, {"ShiftbackTable", 46, 4, 34}, {"ShiftbackTable", 47, 3, 34}, {"ShiftbackTable", 48, 1, 32}, {"ShiftbackTable", 49, 1, 31}, {"ShiftbackTable", 50, 1, 61}}; //Define VARIABLES to refer to reduce table TRIPLEs. //FORMAT: RawReduceTriple {long stackTopState; const char *attributes; long gotoTableNumber;} RawReduceTriple *rd51 = new RawReduceTriple [6] {{0, "RSN", 1}, {4, "RSN", 12}, {10, "RSN", 17}, {11, "RSN", 18}, {19, "RSN", 22}, {20, "RSN", 23}}; RawReduceTriple *rd52 = new RawReduceTriple [1] {{0, "RSN", 62}}; RawReduceTriple *rd53 = new RawReduceTriple [8] {{0, "RSN", 2}, {4, "RSN", 2}, {5, "RSN", 14}, {6, "RSN", 15}, {10, "RSN", 2}, {11, "RSN", 2}, {19, "RSN", 2}, {20, "RSN", 2}}; RawReduceTriple *rd54 = new RawReduceTriple [10] {{0, "RSN", 37}, {4, "RSN", 37}, {5, "RSN", 37}, {6, "RSN", 37}, {8, "RSN", 42}, {9, "RSN", 43}, {10, "RSN", 37}, {11, "RSN", 37}, {19, "RSN", 37}, {20, "RSN", 37}}; //Define an array of reduce tables. //FORMAT: RawReduceTable {const char *name; long stateNumber; const char *nonterminal, long size; RawReduceTriple *triples;} RawReduceTable *reduceTables = new RawReduceTable [4] { {"ReduceTable", 51, "Expression", 6, rd51}, {"ReduceTable", 52, "Grammar", 1, rd52}, {"ReduceTable", 53, "Term", 8, rd53}, {"ReduceTable", 54, "Primary", 10, rd54}}; //Define VARIABLES to refer to semantic table PARAMETERs. //FORMAT {string0, string1, ...} const char **p55 = new const char * [1] {"+"}; const char **p56 = new const char * [1] {"-"}; const char **p57 = new const char * [1] {"*"}; const char **p58 = new const char * [1] {"/"}; const char **p59 = new const char * [1] {"send"}; const char **p60 = new const char * [1] {"<-"}; const char **p61 = new const char * [1] {"where"}; //Define an array of semantic tables. //FORMAT SemanticTable {const char *name; long stateNumber; const char *action; long size; const char **parameters; long gotoTableNumber;} RawSemanticTable *semanticTables = new RawSemanticTable [7] { {"SemanticTable", 55, "buildTree", 1, p55, 51}, {"SemanticTable", 56, "buildTree", 1, p56, 51}, {"SemanticTable", 57, "buildTree", 1, p57, 53}, {"SemanticTable", 58, "buildTree", 1, p58, 53}, {"SemanticTable", 59, "buildTree", 1, p59, 54}, {"SemanticTable", 60, "buildTree", 1, p60, 52}, {"SemanticTable", 61, "buildTree", 1, p61, 52} }; RawAcceptTable *acceptTable = new RawAcceptTable {"AcceptTable", 62}; ParserTables *parserTables = new ParserTables { 1, keywords, 26, readaheadTables, 9, readbackTables, 16, shiftbackTables, 4, reduceTables, 7, semanticTables, acceptTable}; return parserTables; } void deleteParserTables (ParserTables *parserTable) { for (long index = 0; index < parserTable->readaheadTablesSize; index++) { delete [] parserTable->readaheadTables [index].triples; } delete [] parserTable->readaheadTables; for (long index = 0; index < parserTable->readbackTablesSize; index++) { delete [] parserTable->readbackTables [index].triples; } delete [] parserTable->readbackTables; delete [] parserTable->shiftbackTables; for (long index = 0; index < parserTable->reduceTablesSize; index++) { delete [] parserTable->reduceTables [index].triples; } delete [] parserTable->reduceTables; for (long index = 0; index < parserTable->semanticTablesSize; index++) { delete [] parserTable->semanticTables [index].parameters; } delete [] parserTable->semanticTables; } //C++98 -----------------------------------> //NOTE: The following declarations should probably be moved manually to a more global location for access elsewhere... struct RawReadaheadTriple {const char *string; const char *attributes; long gotoTable;}; struct RawReadaheadTable {const char *name; long state; long size; RawReadaheadTriple *triples;}; struct RawReadbackPair {const char *symbol; long state;}; struct RawReadbackTriple {RawReadbackPair pair; const char *attributes; long gotoTable;}; struct RawReadbackTable {const char *name; long state; long size; RawReadbackTriple *triples;}; struct RawShiftbackTable {const char *name; long state; long shift; long gotoTable;}; struct RawReduceTriple {long stackTopState; const char *attributes; long gotoTable;}; struct RawReduceTable {const char *name; long state; const char *nonterminal; long size; RawReduceTriple *triples;}; struct RawSemanticTable {const char *name; long state; const char *action; long size; const char **parameters; long gotoTable;}; struct RawAcceptTable {const char *name; long state;}; struct ParserTables { long keywordsSize; const char **keywords; long readaheadTablesSize; RawReadaheadTable *readaheadTables; long readbackTablesSize; RawReadbackTable *readbackTables; long shiftbackTablesSize; RawShiftbackTable *shiftbackTables; long reduceTablesSize; RawReduceTable *reduceTables; long semanticTablesSize; RawSemanticTable *semanticTables; RawAcceptTable *acceptTable; }; #define copy(a,b) CopyMemory (a, b, sizeof (b)) //For parsingTables.cpp ParserTables *parserTables () { const char **keywords = new const char * [1] {"where"}; //Define VARIABLES to refer to readahead table TRIPLEs. //FORMAT: RawReadaheadTriple {const char *string; const char *attributes; long gotoTableNumber;} //Note: string == NULL is equivalent to "{256}" (end of file). RawReadaheadTriple *ra0 = new RawReadaheadTriple [7] {{"Expression", "RSN", 1}, {"Term", "RSN", 2}, {"Primary", "RSN", 37}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 3}, {"Grammar", "RSN", 62}, {"(", "RS", 4}}; RawReadaheadTriple *ra1 = new RawReadaheadTriple [4] {{"+", "RS", 5}, {"-", "RS", 6}, {"where", "RS", 7}, {"-|", "L", 35}}; RawReadaheadTriple *ra2 = new RawReadaheadTriple [9] {{"*", "RS", 8}, {"/", "RS", 9}, {"+", "L", 36}, {"-", "L", 36}, {"where", "L", 36}, {"-|", "L", 36}, {";", "L", 36}, {")", "L", 36}, {",", "L", 36}}; RawReadaheadTriple *ra3 = new RawReadaheadTriple [11] {{"(", "RS", 10}, {"=", "RS", 11}, {"+", "L", 38}, {"-", "L", 38}, {"*", "L", 38}, {"/", "L", 38}, {"where", "L", 38}, {"-|", "L", 38}, {";", "L", 38}, {")", "L", 38}, {",", "L", 38}}; RawReadaheadTriple *ra4 = new RawReadaheadTriple [6] {{"Expression", "RSN", 12}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra5 = new RawReadaheadTriple [5] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 37}, {"Term", "RSN", 14}}; RawReadaheadTriple *ra6 = new RawReadaheadTriple [5] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 37}, {"Term", "RSN", 15}}; RawReadaheadTriple *ra7 = new RawReadaheadTriple [1] {{"Identifier", "RSN", 16}}; RawReadaheadTriple *ra8 = new RawReadaheadTriple [4] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 42}}; RawReadaheadTriple *ra9 = new RawReadaheadTriple [4] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 43}}; RawReadaheadTriple *ra10 = new RawReadaheadTriple [7] {{"Expression", "RSN", 17}, {")", "RS", 44}, {"Term", "RSN", 2}, {"Primary", "RSN", 37}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra11 = new RawReadaheadTriple [6] {{"Expression", "RSN", 18}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra12 = new RawReadaheadTriple [3] {{")", "RS", 39}, {"+", "RS", 5}, {"-", "RS", 6}}; RawReadaheadTriple *ra13 = new RawReadaheadTriple [10] {{"(", "RS", 10}, {"+", "L", 38}, {"-", "L", 38}, {"*", "L", 38}, {"/", "L", 38}, {"where", "L", 38}, {"-|", "L", 38}, {";", "L", 38}, {")", "L", 38}, {",", "L", 38}}; RawReadaheadTriple *ra14 = new RawReadaheadTriple [9] {{"*", "RS", 8}, {"/", "RS", 9}, {"+", "L", 40}, {"-", "L", 40}, {"where", "L", 40}, {"-|", "L", 40}, {";", "L", 40}, {")", "L", 40}, {",", "L", 40}}; RawReadaheadTriple *ra15 = new RawReadaheadTriple [9] {{"*", "RS", 8}, {"/", "RS", 9}, {"+", "L", 41}, {"-", "L", 41}, {"where", "L", 41}, {"-|", "L", 41}, {";", "L", 41}, {")", "L", 41}, {",", "L", 41}}; RawReadaheadTriple *ra16 = new RawReadaheadTriple [1] {{"=", "RS", 19}}; RawReadaheadTriple *ra17 = new RawReadaheadTriple [4] {{"+", "RS", 5}, {"-", "RS", 6}, {",", "RS", 20}, {")", "RS", 44}}; RawReadaheadTriple *ra18 = new RawReadaheadTriple [3] {{";", "RS", 21}, {"+", "RS", 5}, {"-", "RS", 6}}; RawReadaheadTriple *ra19 = new RawReadaheadTriple [6] {{"Expression", "RSN", 22}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra20 = new RawReadaheadTriple [6] {{"Expression", "RSN", 23}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra21 = new RawReadaheadTriple [2] {{"Identifier", "RSN", 24}, {"-|", "L", 45}}; RawReadaheadTriple *ra22 = new RawReadaheadTriple [3] {{"+", "RS", 5}, {"-", "RS", 6}, {";", "RS", 25}}; RawReadaheadTriple *ra23 = new RawReadaheadTriple [4] {{"+", "RS", 5}, {"-", "RS", 6}, {",", "RS", 20}, {")", "RS", 44}}; RawReadaheadTriple *ra24 = new RawReadaheadTriple [1] {{"=", "RS", 11}}; RawReadaheadTriple *ra25 = new RawReadaheadTriple [2] {{"Identifier", "RSN", 16}, {"-|", "L", 46}}; //Define an array of readahead tables. //FORMAT: RawReadaheadTable {char *name; long stateNumber; long size; RawReadaheadTriple *triples;} RawReadaheadTable *readaheadTables = new RawReadaheadTable [26] { {"ReadaheadTable", 0, 7, &ra0[0]}, {"ReadaheadTable", 1, 4, &ra1[0]}, {"ReadaheadTable", 2, 9, &ra2[0]}, {"ReadaheadTable", 3, 11, &ra3[0]}, {"ReadaheadTable", 4, 6, &ra4[0]}, {"ReadaheadTable", 5, 5, &ra5[0]}, {"ReadaheadTable", 6, 5, &ra6[0]}, {"ReadaheadTable", 7, 1, &ra7[0]}, {"ReadaheadTable", 8, 4, &ra8[0]}, {"ReadaheadTable", 9, 4, &ra9[0]}, {"ReadaheadTable", 10, 7, &ra10[0]}, {"ReadaheadTable", 11, 6, &ra11[0]}, {"ReadaheadTable", 12, 3, &ra12[0]}, {"ReadaheadTable", 13, 10, &ra13[0]}, {"ReadaheadTable", 14, 9, &ra14[0]}, {"ReadaheadTable", 15, 9, &ra15[0]}, {"ReadaheadTable", 16, 1, &ra16[0]}, {"ReadaheadTable", 17, 4, &ra17[0]}, {"ReadaheadTable", 18, 3, &ra18[0]}, {"ReadaheadTable", 19, 6, &ra19[0]}, {"ReadaheadTable", 20, 6, &ra20[0]}, {"ReadaheadTable", 21, 2, &ra21[0]}, {"ReadaheadTable", 22, 3, &ra22[0]}, {"ReadaheadTable", 23, 4, &ra23[0]}, {"ReadaheadTable", 24, 1, &ra24[0]}, {"ReadaheadTable", 25, 2, &ra25[0]}}; //Define VARIABLES to refer to readback table TRIPLEs. //FORMAT: RawReadbackPair {const char *symbol; long state;} //FORMAT: RawReadbackTriple {RawReadbackPair pair; const char *attributes; long gotoTableNumber;} RawReadbackTriple *rb26 = new RawReadbackTriple [3] {{{"Expression", 23}, "RSN", 48}, {{"Expression", 17}, "RSN", 49}, {{"(", 10}, "RS", 31}}; RawReadbackTriple *rb27 = new RawReadbackTriple [6] {{{"Expression", 12}, "RSN", 55}, {{"Expression", 22}, "RSN", 55}, {{"Expression", 23}, "RSN", 55}, {{"Expression", 1}, "RSN", 55}, {{"Expression", 17}, "RSN", 55}, {{"Expression", 18}, "RSN", 55}}; RawReadbackTriple *rb28 = new RawReadbackTriple [6] {{{"Expression", 12}, "RSN", 56}, {{"Expression", 22}, "RSN", 56}, {{"Expression", 23}, "RSN", 56}, {{"Expression", 1}, "RSN", 56}, {{"Expression", 17}, "RSN", 56}, {{"Expression", 18}, "RSN", 56}}; RawReadbackTriple *rb29 = new RawReadbackTriple [3] {{{"Term", 14}, "RSN", 57}, {{"Term", 15}, "RSN", 57}, {{"Term", 2}, "RSN", 57}}; RawReadbackTriple *rb30 = new RawReadbackTriple [3] {{{"Term", 14}, "RSN", 58}, {{"Term", 15}, "RSN", 58}, {{"Term", 2}, "RSN", 58}}; RawReadbackTriple *rb31 = new RawReadbackTriple [2] {{{"Identifier", 13}, "RSN", 59}, {{"Identifier", 3}, "RSN", 59}}; RawReadbackTriple *rb32 = new RawReadbackTriple [2] {{{"Expression", 23}, "RSN", 48}, {{"Expression", 17}, "RSN", 49}}; RawReadbackTriple *rb33 = new RawReadbackTriple [2] {{{"Identifier", 24}, "RSN", 45}, {{"Identifier", 3}, "RSN", 60}}; RawReadbackTriple *rb34 = new RawReadbackTriple [2] {{{";", 25}, "RS", 47}, {{"where", 7}, "RS", 50}}; //Define an array of readback tables. //FORMAT: RawReadabackTable {const char *name; long stateNumber; long size; RawReadbackTriple *triples;} RawReadbackTable *readbackTables = new RawReadbackTable [9] { {"ReadbackTable", 26, 3, rb27}, {"ReadbackTable", 27, 6, rb28}, {"ReadbackTable", 28, 6, rb29}, {"ReadbackTable", 29, 3, rb30}, {"ReadbackTable", 30, 3, rb31}, {"ReadbackTable", 31, 2, rb32}, {"ReadbackTable", 32, 2, rb33}, {"ReadbackTable", 33, 2, rb34}, {"ReadbackTable", 34, 2, rb35}}; //Define an array of shiftback tables. //FORMAT: RawShiftbackTable {const char *name; long stateNumber; long shift; long gotoTable;} RawShiftbackTable *shiftbackTables = new RawShiftbackTable [16] { {"ShiftbackTable", 35, 1, 52}, {"ShiftbackTable", 36, 1, 51}, {"ShiftbackTable", 37, 1, 53}, {"ShiftbackTable", 38, 1, 54}, {"ShiftbackTable", 39, 3, 54}, {"ShiftbackTable", 40, 2, 27}, {"ShiftbackTable", 41, 2, 28}, {"ShiftbackTable", 42, 2, 29}, {"ShiftbackTable", 43, 2, 30}, {"ShiftbackTable", 44, 1, 26}, {"ShiftbackTable", 45, 3, 33}, {"ShiftbackTable", 46, 4, 34}, {"ShiftbackTable", 47, 3, 34}, {"ShiftbackTable", 48, 1, 32}, {"ShiftbackTable", 49, 1, 31}, {"ShiftbackTable", 50, 1, 61}}; //Define VARIABLES to refer to reduce table TRIPLEs. //FORMAT: RawReduceTriple {long stackTopState; const char *attributes; long gotoTableNumber;} RawReduceTriple *rd51 = new RawReduceTriple [6] {{0, "RSN", 1}, {4, "RSN", 12}, {10, "RSN", 17}, {11, "RSN", 18}, {19, "RSN", 22}, {20, "RSN", 23}}; RawReduceTriple *rd52 = new RawReduceTriple [1] {{0, "RSN", 62}}; RawReduceTriple *rd53 = new RawReduceTriple [8] {{0, "RSN", 2}, {4, "RSN", 2}, {5, "RSN", 14}, {6, "RSN", 15}, {10, "RSN", 2}, {11, "RSN", 2}, {19, "RSN", 2}, {20, "RSN", 2}}; RawReduceTriple *rd54 = new RawReduceTriple [10] {{0, "RSN", 37}, {4, "RSN", 37}, {5, "RSN", 37}, {6, "RSN", 37}, {8, "RSN", 42}, {9, "RSN", 43}, {10, "RSN", 37}, {11, "RSN", 37}, {19, "RSN", 37}, {20, "RSN", 37}}; //Define an array of reduce tables. //FORMAT: RawReduceTable {const char *name; long stateNumber; const char *nonterminal, long size; RawReduceTriple *triples;} RawReduceTable *reduceTables = new RawReduceTable [4] { {"ReduceTable", 51, "Expression", 6, rd51}, {"ReduceTable", 52, "Grammar", 1, rd52}, {"ReduceTable", 53, "Term", 8, rd53}, {"ReduceTable", 54, "Primary", 10, rd54}}; //Define VARIABLES to refer to semantic table PARAMETERs. //FORMAT {string0, string1, ...} const char **p55 = new const char * [1] {"+"}; const char **p56 = new const char * [1] {"-"}; const char **p57 = new const char * [1] {"*"}; const char **p58 = new const char * [1] {"/"}; const char **p59 = new const char * [1] {"send"}; const char **p60 = new const char * [1] {"<-"}; const char **p61 = new const char * [1] {"where"}; //Define an array of semantic tables. //FORMAT SemanticTable {const char *name; long stateNumber; const char *action; long size; const char **parameters; long gotoTableNumber;} RawSemanticTable *semanticTables = new RawSemanticTable [7] { {"SemanticTable", 55, "buildTree", 1, p55, 51}, {"SemanticTable", 56, "buildTree", 1, p56, 51}, {"SemanticTable", 57, "buildTree", 1, p57, 53}, {"SemanticTable", 58, "buildTree", 1, p58, 53}, {"SemanticTable", 59, "buildTree", 1, p59, 54}, {"SemanticTable", 60, "buildTree", 1, p60, 52}, {"SemanticTable", 61, "buildTree", 1, p61, 52} }; RawAcceptTable *acceptTable = new RawAcceptTable {"AcceptTable", 62}; ParserTables *parserTables = new ParserTables; ParserTables rawParserTables = { 1, keywords, 26, readaheadTables, 9, readbackTables, 16, shiftbackTables, 4, reduceTables, 7, semanticTables, acceptTable}; copy (parserTables, &rawParserTables); return parserTables; } void deleteParserTables (ParserTables *parserTable) { for (long index = 0; index < parserTable->readaheadTablesSize; index++) { delete [] parserTable->readaheadTables [index].triples; } delete [] parserTable->readaheadTables; for (long index = 0; index < parserTable->readbackTablesSize; index++) { delete [] parserTable->readbackTables [index].triples; } delete [] parserTable->readbackTables; delete [] parserTable->shiftbackTables; for (long index = 0; index < parserTable->reduceTablesSize; index++) { delete [] parserTable->reduceTables [index].triples; } delete [] parserTable->reduceTables; for (long index = 0; index < parserTable->semanticTablesSize; index++) { delete [] parserTable->semanticTables [index].parameters; } delete [] parserTable->semanticTables; } //JAVA ------------------------------------> //NOTE: The following declarations should probably be moved manually to a more global location for access elsewhere... struct RawReadaheadTriple {const char *string; const char *attributes; long gotoTable;}; struct RawReadaheadTable {const char *name; long state; long size; RawReadaheadTriple *triples;}; struct RawReadbackPair {const char *symbol; long state;}; struct RawReadbackTriple {RawReadbackPair pair; const char *attributes; long gotoTable;}; struct RawReadbackTable {const char *name; long state; long size; RawReadbackTriple *triples;}; struct RawShiftbackTable {const char *name; long state; long shift; long gotoTable;}; struct RawReduceTriple {long stackTopState; const char *attributes; long gotoTable;}; struct RawReduceTable {const char *name; long state; const char *nonterminal; long size; RawReduceTriple *triples;}; struct RawSemanticTable {const char *name; long state; const char *action; long size; const char **parameters; long gotoTable;}; struct RawAcceptTable {const char *name; long state;}; struct ParserTables { long keywordsSize; const char **keywords; long readaheadTablesSize; RawReadaheadTable *readaheadTables; long readbackTablesSize; RawReadbackTable *readbackTables; long shiftbackTablesSize; RawShiftbackTable *shiftbackTables; long reduceTablesSize; RawReduceTable *reduceTables; long semanticTablesSize; RawSemanticTable *semanticTables; RawAcceptTable *acceptTable; }; #define copy(a,b) CopyMemory (a, b, sizeof (b)) //For parsingTables.cpp ParserTables *parserTables () { const char **keywords = new const char * [1] {"where"}; //Define VARIABLES to refer to readahead table TRIPLEs. //FORMAT: RawReadaheadTriple {const char *string; const char *attributes; long gotoTableNumber;} //Note: string == NULL is equivalent to "{256}" (end of file). RawReadaheadTriple *ra0 = new RawReadaheadTriple [7] {{"Expression", "RSN", 1}, {"Term", "RSN", 2}, {"Primary", "RSN", 37}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 3}, {"Grammar", "RSN", 62}, {"(", "RS", 4}}; RawReadaheadTriple *ra1 = new RawReadaheadTriple [4] {{"+", "RS", 5}, {"-", "RS", 6}, {"where", "RS", 7}, {"-|", "L", 35}}; RawReadaheadTriple *ra2 = new RawReadaheadTriple [9] {{"*", "RS", 8}, {"/", "RS", 9}, {"+", "L", 36}, {"-", "L", 36}, {"where", "L", 36}, {"-|", "L", 36}, {";", "L", 36}, {")", "L", 36}, {",", "L", 36}}; RawReadaheadTriple *ra3 = new RawReadaheadTriple [11] {{"(", "RS", 10}, {"=", "RS", 11}, {"+", "L", 38}, {"-", "L", 38}, {"*", "L", 38}, {"/", "L", 38}, {"where", "L", 38}, {"-|", "L", 38}, {";", "L", 38}, {")", "L", 38}, {",", "L", 38}}; RawReadaheadTriple *ra4 = new RawReadaheadTriple [6] {{"Expression", "RSN", 12}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra5 = new RawReadaheadTriple [5] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 37}, {"Term", "RSN", 14}}; RawReadaheadTriple *ra6 = new RawReadaheadTriple [5] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 37}, {"Term", "RSN", 15}}; RawReadaheadTriple *ra7 = new RawReadaheadTriple [1] {{"Identifier", "RSN", 16}}; RawReadaheadTriple *ra8 = new RawReadaheadTriple [4] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 42}}; RawReadaheadTriple *ra9 = new RawReadaheadTriple [4] {{"Identifier", "RSN", 13}, {"(", "RS", 4}, {"Integer", "RSN", 38}, {"Primary", "RSN", 43}}; RawReadaheadTriple *ra10 = new RawReadaheadTriple [7] {{"Expression", "RSN", 17}, {")", "RS", 44}, {"Term", "RSN", 2}, {"Primary", "RSN", 37}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra11 = new RawReadaheadTriple [6] {{"Expression", "RSN", 18}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra12 = new RawReadaheadTriple [3] {{")", "RS", 39}, {"+", "RS", 5}, {"-", "RS", 6}}; RawReadaheadTriple *ra13 = new RawReadaheadTriple [10] {{"(", "RS", 10}, {"+", "L", 38}, {"-", "L", 38}, {"*", "L", 38}, {"/", "L", 38}, {"where", "L", 38}, {"-|", "L", 38}, {";", "L", 38}, {")", "L", 38}, {",", "L", 38}}; RawReadaheadTriple *ra14 = new RawReadaheadTriple [9] {{"*", "RS", 8}, {"/", "RS", 9}, {"+", "L", 40}, {"-", "L", 40}, {"where", "L", 40}, {"-|", "L", 40}, {";", "L", 40}, {")", "L", 40}, {",", "L", 40}}; RawReadaheadTriple *ra15 = new RawReadaheadTriple [9] {{"*", "RS", 8}, {"/", "RS", 9}, {"+", "L", 41}, {"-", "L", 41}, {"where", "L", 41}, {"-|", "L", 41}, {";", "L", 41}, {")", "L", 41}, {",", "L", 41}}; RawReadaheadTriple *ra16 = new RawReadaheadTriple [1] {{"=", "RS", 19}}; RawReadaheadTriple *ra17 = new RawReadaheadTriple [4] {{"+", "RS", 5}, {"-", "RS", 6}, {",", "RS", 20}, {")", "RS", 44}}; RawReadaheadTriple *ra18 = new RawReadaheadTriple [3] {{";", "RS", 21}, {"+", "RS", 5}, {"-", "RS", 6}}; RawReadaheadTriple *ra19 = new RawReadaheadTriple [6] {{"Expression", "RSN", 22}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra20 = new RawReadaheadTriple [6] {{"Expression", "RSN", 23}, {"Primary", "RSN", 37}, {"Term", "RSN", 2}, {"Integer", "RSN", 38}, {"Identifier", "RSN", 13}, {"(", "RS", 4}}; RawReadaheadTriple *ra21 = new RawReadaheadTriple [2] {{"Identifier", "RSN", 24}, {"-|", "L", 45}}; RawReadaheadTriple *ra22 = new RawReadaheadTriple [3] {{"+", "RS", 5}, {"-", "RS", 6}, {";", "RS", 25}}; RawReadaheadTriple *ra23 = new RawReadaheadTriple [4] {{"+", "RS", 5}, {"-", "RS", 6}, {",", "RS", 20}, {")", "RS", 44}}; RawReadaheadTriple *ra24 = new RawReadaheadTriple [1] {{"=", "RS", 11}}; RawReadaheadTriple *ra25 = new RawReadaheadTriple [2] {{"Identifier", "RSN", 16}, {"-|", "L", 46}}; //Define an array of readahead tables. //FORMAT: RawReadaheadTable {char *name; long stateNumber; long size; RawReadaheadTriple *triples;} RawReadaheadTable *readaheadTables = new RawReadaheadTable [26] { {"ReadaheadTable", 0, 7, &ra0[0]}, {"ReadaheadTable", 1, 4, &ra1[0]}, {"ReadaheadTable", 2, 9, &ra2[0]}, {"ReadaheadTable", 3, 11, &ra3[0]}, {"ReadaheadTable", 4, 6, &ra4[0]}, {"ReadaheadTable", 5, 5, &ra5[0]}, {"ReadaheadTable", 6, 5, &ra6[0]}, {"ReadaheadTable", 7, 1, &ra7[0]}, {"ReadaheadTable", 8, 4, &ra8[0]}, {"ReadaheadTable", 9, 4, &ra9[0]}, {"ReadaheadTable", 10, 7, &ra10[0]}, {"ReadaheadTable", 11, 6, &ra11[0]}, {"ReadaheadTable", 12, 3, &ra12[0]}, {"ReadaheadTable", 13, 10, &ra13[0]}, {"ReadaheadTable", 14, 9, &ra14[0]}, {"ReadaheadTable", 15, 9, &ra15[0]}, {"ReadaheadTable", 16, 1, &ra16[0]}, {"ReadaheadTable", 17, 4, &ra17[0]}, {"ReadaheadTable", 18, 3, &ra18[0]}, {"ReadaheadTable", 19, 6, &ra19[0]}, {"ReadaheadTable", 20, 6, &ra20[0]}, {"ReadaheadTable", 21, 2, &ra21[0]}, {"ReadaheadTable", 22, 3, &ra22[0]}, {"ReadaheadTable", 23, 4, &ra23[0]}, {"ReadaheadTable", 24, 1, &ra24[0]}, {"ReadaheadTable", 25, 2, &ra25[0]}}; //Define VARIABLES to refer to readback table TRIPLEs. //FORMAT: RawReadbackPair {const char *symbol; long state;} //FORMAT: RawReadbackTriple {RawReadbackPair pair; const char *attributes; long gotoTableNumber;} RawReadbackTriple *rb26 = new RawReadbackTriple [3] {{{"Expression", 23}, "RSN", 48}, {{"Expression", 17}, "RSN", 49}, {{"(", 10}, "RS", 31}}; RawReadbackTriple *rb27 = new RawReadbackTriple [6] {{{"Expression", 12}, "RSN", 55}, {{"Expression", 22}, "RSN", 55}, {{"Expression", 23}, "RSN", 55}, {{"Expression", 1}, "RSN", 55}, {{"Expression", 17}, "RSN", 55}, {{"Expression", 18}, "RSN", 55}}; RawReadbackTriple *rb28 = new RawReadbackTriple [6] {{{"Expression", 12}, "RSN", 56}, {{"Expression", 22}, "RSN", 56}, {{"Expression", 23}, "RSN", 56}, {{"Expression", 1}, "RSN", 56}, {{"Expression", 17}, "RSN", 56}, {{"Expression", 18}, "RSN", 56}}; RawReadbackTriple *rb29 = new RawReadbackTriple [3] {{{"Term", 14}, "RSN", 57}, {{"Term", 15}, "RSN", 57}, {{"Term", 2}, "RSN", 57}}; RawReadbackTriple *rb30 = new RawReadbackTriple [3] {{{"Term", 14}, "RSN", 58}, {{"Term", 15}, "RSN", 58}, {{"Term", 2}, "RSN", 58}}; RawReadbackTriple *rb31 = new RawReadbackTriple [2] {{{"Identifier", 13}, "RSN", 59}, {{"Identifier", 3}, "RSN", 59}}; RawReadbackTriple *rb32 = new RawReadbackTriple [2] {{{"Expression", 23}, "RSN", 48}, {{"Expression", 17}, "RSN", 49}}; RawReadbackTriple *rb33 = new RawReadbackTriple [2] {{{"Identifier", 24}, "RSN", 45}, {{"Identifier", 3}, "RSN", 60}}; RawReadbackTriple *rb34 = new RawReadbackTriple [2] {{{";", 25}, "RS", 47}, {{"where", 7}, "RS", 50}}; //Define an array of readback tables. //FORMAT: RawReadabackTable {const char *name; long stateNumber; long size; RawReadbackTriple *triples;} RawReadbackTable *readbackTables = new RawReadbackTable [9] { {"ReadbackTable", 26, 3, rb27}, {"ReadbackTable", 27, 6, rb28}, {"ReadbackTable", 28, 6, rb29}, {"ReadbackTable", 29, 3, rb30}, {"ReadbackTable", 30, 3, rb31}, {"ReadbackTable", 31, 2, rb32}, {"ReadbackTable", 32, 2, rb33}, {"ReadbackTable", 33, 2, rb34}, {"ReadbackTable", 34, 2, rb35}}; //Define an array of shiftback tables. //FORMAT: RawShiftbackTable {const char *name; long stateNumber; long shift; long gotoTable;} RawShiftbackTable *shiftbackTables = new RawShiftbackTable [16] { {"ShiftbackTable", 35, 1, 52}, {"ShiftbackTable", 36, 1, 51}, {"ShiftbackTable", 37, 1, 53}, {"ShiftbackTable", 38, 1, 54}, {"ShiftbackTable", 39, 3, 54}, {"ShiftbackTable", 40, 2, 27}, {"ShiftbackTable", 41, 2, 28}, {"ShiftbackTable", 42, 2, 29}, {"ShiftbackTable", 43, 2, 30}, {"ShiftbackTable", 44, 1, 26}, {"ShiftbackTable", 45, 3, 33}, {"ShiftbackTable", 46, 4, 34}, {"ShiftbackTable", 47, 3, 34}, {"ShiftbackTable", 48, 1, 32}, {"ShiftbackTable", 49, 1, 31}, {"ShiftbackTable", 50, 1, 61}}; //Define VARIABLES to refer to reduce table TRIPLEs. //FORMAT: RawReduceTriple {long stackTopState; const char *attributes; long gotoTableNumber;} RawReduceTriple *rd51 = new RawReduceTriple [6] {{0, "RSN", 1}, {4, "RSN", 12}, {10, "RSN", 17}, {11, "RSN", 18}, {19, "RSN", 22}, {20, "RSN", 23}}; RawReduceTriple *rd52 = new RawReduceTriple [1] {{0, "RSN", 62}}; RawReduceTriple *rd53 = new RawReduceTriple [8] {{0, "RSN", 2}, {4, "RSN", 2}, {5, "RSN", 14}, {6, "RSN", 15}, {10, "RSN", 2}, {11, "RSN", 2}, {19, "RSN", 2}, {20, "RSN", 2}}; RawReduceTriple *rd54 = new RawReduceTriple [10] {{0, "RSN", 37}, {4, "RSN", 37}, {5, "RSN", 37}, {6, "RSN", 37}, {8, "RSN", 42}, {9, "RSN", 43}, {10, "RSN", 37}, {11, "RSN", 37}, {19, "RSN", 37}, {20, "RSN", 37}}; //Define an array of reduce tables. //FORMAT: RawReduceTable {const char *name; long stateNumber; const char *nonterminal, long size; RawReduceTriple *triples;} RawReduceTable *reduceTables = new RawReduceTable [4] { {"ReduceTable", 51, "Expression", 6, rd51}, {"ReduceTable", 52, "Grammar", 1, rd52}, {"ReduceTable", 53, "Term", 8, rd53}, {"ReduceTable", 54, "Primary", 10, rd54}}; //Define VARIABLES to refer to semantic table PARAMETERs. //FORMAT {string0, string1, ...} const char **p55 = new const char * [1] {"+"}; const char **p56 = new const char * [1] {"-"}; const char **p57 = new const char * [1] {"*"}; const char **p58 = new const char * [1] {"/"}; const char **p59 = new const char * [1] {"send"}; const char **p60 = new const char * [1] {"<-"}; const char **p61 = new const char * [1] {"where"}; //Define an array of semantic tables. //FORMAT SemanticTable {const char *name; long stateNumber; const char *action; long size; const char **parameters; long gotoTableNumber;} RawSemanticTable *semanticTables = new RawSemanticTable [7] { {"SemanticTable", 55, "buildTree", 1, p55, 51}, {"SemanticTable", 56, "buildTree", 1, p56, 51}, {"SemanticTable", 57, "buildTree", 1, p57, 53}, {"SemanticTable", 58, "buildTree", 1, p58, 53}, {"SemanticTable", 59, "buildTree", 1, p59, 54}, {"SemanticTable", 60, "buildTree", 1, p60, 52}, {"SemanticTable", 61, "buildTree", 1, p61, 52} }; RawAcceptTable *acceptTable = new RawAcceptTable {"AcceptTable", 62}; ParserTables *parserTables = new ParserTables; ParserTables rawParserTables = { 1, keywords, 26, readaheadTables, 9, readbackTables, 16, shiftbackTables, 4, reduceTables, 7, semanticTables, acceptTable}; copy (parserTables, &rawParserTables); return parserTables; } void deleteParserTables (ParserTables *parserTable) { for (long index = 0; index < parserTable->readaheadTablesSize; index++) { delete [] parserTable->readaheadTables [index].triples; } delete [] parserTable->readaheadTables; for (long index = 0; index < parserTable->readbackTablesSize; index++) { delete [] parserTable->readbackTables [index].triples; } delete [] parserTable->readbackTables; delete [] parserTable->shiftbackTables; for (long index = 0; index < parserTable->reduceTablesSize; index++) { delete [] parserTable->reduceTables [index].triples; } delete [] parserTable->reduceTables; for (long index = 0; index < parserTable->semanticTablesSize; index++) { delete [] parserTable->semanticTables [index].parameters; } delete [] parserTable->semanticTables; } //JAVA: LIST VERSION --------------> static List rawParserTables () {return asList ( asList (keywords, "where"), asList ("ReadaheadTable", 0, asList ("Expression", "RSN", 1), asList ("Term", "RSN", 2), asList ("Primary", "RSN", 37), asList ("Integer", "RSN", 38), asList ("Identifier", "RSN", 3), asList ("Grammar", "RSN", 62), asList ("(", "RS", 4)), asList ("ReadaheadTable", 1, asList ("+", "RS", 5), asList ("-", "RS", 6), asList ("where", "RS", 7), asList ("-|", "L", 35)), asList ("ReadaheadTable", 2, asList ("*", "RS", 8), asList ("/", "RS", 9), asList ("+", "L", 36), asList ("-", "L", 36), asList ("where", "L", 36), asList ("-|", "L", 36), asList (";", "L", 36), asList (")", "L", 36), asList (",", "L", 36)), asList ("ReadaheadTable", 3, asList ("(", "RS", 10), asList ("=", "RS", 11), asList ("+", "L", 38), asList ("-", "L", 38), asList ("*", "L", 38), asList ("/", "L", 38), asList ("where", "L", 38), asList ("-|", "L", 38), asList (";", "L", 38), asList (")", "L", 38), asList (",", "L", 38)), asList ("ReadaheadTable", 4, asList ("Expression", "RSN", 12), asList ("Primary", "RSN", 37), asList ("Term", "RSN", 2), asList ("Integer", "RSN", 38), asList ("Identifier", "RSN", 13), asList ("(", "RS", 4)), asList ("ReadaheadTable", 5, asList ("Identifier", "RSN", 13), asList ("(", "RS", 4), asList ("Integer", "RSN", 38), asList ("Primary", "RSN", 37), asList ("Term", "RSN", 14)), asList ("ReadaheadTable", 6, asList ("Identifier", "RSN", 13), asList ("(", "RS", 4), asList ("Integer", "RSN", 38), asList ("Primary", "RSN", 37), asList ("Term", "RSN", 15)), asList ("ReadaheadTable", 7, asList ("Identifier", "RSN", 16)), asList ("ReadaheadTable", 8, asList ("Identifier", "RSN", 13), asList ("(", "RS", 4), asList ("Integer", "RSN", 38), asList ("Primary", "RSN", 42)), asList ("ReadaheadTable", 9, asList ("Identifier", "RSN", 13), asList ("(", "RS", 4), asList ("Integer", "RSN", 38), asList ("Primary", "RSN", 43)), asList ("ReadaheadTable", 10, asList ("Expression", "RSN", 17), asList (")", "RS", 44), asList ("Term", "RSN", 2), asList ("Primary", "RSN", 37), asList ("Integer", "RSN", 38), asList ("Identifier", "RSN", 13), asList ("(", "RS", 4)), asList ("ReadaheadTable", 11, asList ("Expression", "RSN", 18), asList ("Primary", "RSN", 37), asList ("Term", "RSN", 2), asList ("Integer", "RSN", 38), asList ("Identifier", "RSN", 13), asList ("(", "RS", 4)), asList ("ReadaheadTable", 12, asList (")", "RS", 39), asList ("+", "RS", 5), asList ("-", "RS", 6)), asList ("ReadaheadTable", 13, asList ("(", "RS", 10), asList ("+", "L", 38), asList ("-", "L", 38), asList ("*", "L", 38), asList ("/", "L", 38), asList ("where", "L", 38), asList ("-|", "L", 38), asList (";", "L", 38), asList (")", "L", 38), asList (",", "L", 38)), asList ("ReadaheadTable", 14, asList ("*", "RS", 8), asList ("/", "RS", 9), asList ("+", "L", 40), asList ("-", "L", 40), asList ("where", "L", 40), asList ("-|", "L", 40), asList (";", "L", 40), asList (")", "L", 40), asList (",", "L", 40)), asList ("ReadaheadTable", 15, asList ("*", "RS", 8), asList ("/", "RS", 9), asList ("+", "L", 41), asList ("-", "L", 41), asList ("where", "L", 41), asList ("-|", "L", 41), asList (";", "L", 41), asList (")", "L", 41), asList (",", "L", 41)), asList ("ReadaheadTable", 16, asList ("=", "RS", 19)), asList ("ReadaheadTable", 17, asList ("+", "RS", 5), asList ("-", "RS", 6), asList (",", "RS", 20), asList (")", "RS", 44)), asList ("ReadaheadTable", 18, asList (";", "RS", 21), asList ("+", "RS", 5), asList ("-", "RS", 6)), asList ("ReadaheadTable", 19, asList ("Expression", "RSN", 22), asList ("Primary", "RSN", 37), asList ("Term", "RSN", 2), asList ("Integer", "RSN", 38), asList ("Identifier", "RSN", 13), asList ("(", "RS", 4)), asList ("ReadaheadTable", 20, asList ("Expression", "RSN", 23), asList ("Primary", "RSN", 37), asList ("Term", "RSN", 2), asList ("Integer", "RSN", 38), asList ("Identifier", "RSN", 13), asList ("(", "RS", 4)), asList ("ReadaheadTable", 21, asList ("Identifier", "RSN", 24), asList ("-|", "L", 45)), asList ("ReadaheadTable", 22, asList ("+", "RS", 5), asList ("-", "RS", 6), asList (";", "RS", 25)), asList ("ReadaheadTable", 23, asList ("+", "RS", 5), asList ("-", "RS", 6), asList (",", "RS", 20), asList (")", "RS", 44)), asList ("ReadaheadTable", 24, asList ("=", "RS", 11)), asList ("ReadaheadTable", 25, asList ("Identifier", "RSN", 16), asList ("-|", "L", 46)), asList ("ReadbackTable", 26, asList (asList ("Expression", 23), "RSN", 48), asList (asList ("Expression", 17), "RSN", 49), asList (asList ("(", 10), "RS", 31)), asList ("ReadbackTable", 27, asList (asList ("Expression", 12), "RSN", 55), asList (asList ("Expression", 22), "RSN", 55), asList (asList ("Expression", 23), "RSN", 55), asList (asList ("Expression", 1), "RSN", 55), asList (asList ("Expression", 17), "RSN", 55), asList (asList ("Expression", 18), "RSN", 55)), asList ("ReadbackTable", 28, asList (asList ("Expression", 12), "RSN", 56), asList (asList ("Expression", 22), "RSN", 56), asList (asList ("Expression", 23), "RSN", 56), asList (asList ("Expression", 1), "RSN", 56), asList (asList ("Expression", 17), "RSN", 56), asList (asList ("Expression", 18), "RSN", 56)), asList ("ReadbackTable", 29, asList (asList ("Term", 14), "RSN", 57), asList (asList ("Term", 15), "RSN", 57), asList (asList ("Term", 2), "RSN", 57)), asList ("ReadbackTable", 30, asList (asList ("Term", 14), "RSN", 58), asList (asList ("Term", 15), "RSN", 58), asList (asList ("Term", 2), "RSN", 58)), asList ("ReadbackTable", 31, asList (asList ("Identifier", 13), "RSN", 59), asList (asList ("Identifier", 3), "RSN", 59)), asList ("ReadbackTable", 32, asList (asList ("Expression", 23), "RSN", 48), asList (asList ("Expression", 17), "RSN", 49)), asList ("ReadbackTable", 33, asList (asList ("Identifier", 24), "RSN", 45), asList (asList ("Identifier", 3), "RSN", 60)), asList ("ReadbackTable", 34, asList (asList (";", 25), "RS", 47), asList (asList ("where", 7), "RS", 50)), asList ("ShiftbackTable", 35, 1, 52), asList ("ShiftbackTable", 36, 1, 51), asList ("ShiftbackTable", 37, 1, 53), asList ("ShiftbackTable", 38, 1, 54), asList ("ShiftbackTable", 39, 3, 54), asList ("ShiftbackTable", 40, 2, 27), asList ("ShiftbackTable", 41, 2, 28), asList ("ShiftbackTable", 42, 2, 29), asList ("ShiftbackTable", 43, 2, 30), asList ("ShiftbackTable", 44, 1, 26), asList ("ShiftbackTable", 45, 3, 33), asList ("ShiftbackTable", 46, 4, 34), asList ("ShiftbackTable", 47, 3, 34), asList ("ShiftbackTable", 48, 1, 32), asList ("ShiftbackTable", 49, 1, 31), asList ("ShiftbackTable", 50, 1, 61), asList ("ReduceTable", 51, "Expression", asList (0, "RSN", 1), asList (4, "RSN", 12), asList (10, "RSN", 17), asList (11, "RSN", 18), asList (19, "RSN", 22), asList (20, "RSN", 23)), asList ("ReduceTable", 52, "Grammar", asList (0, "RSN", 62)), asList ("ReduceTable", 53, "Term", asList (0, "RSN", 2), asList (4, "RSN", 2), asList (5, "RSN", 14), asList (6, "RSN", 15), asList (10, "RSN", 2), asList (11, "RSN", 2), asList (19, "RSN", 2), asList (20, "RSN", 2)), asList ("ReduceTable", 54, "Primary", asList (0, "RSN", 37), asList (4, "RSN", 37), asList (5, "RSN", 37), asList (6, "RSN", 37), asList (8, "RSN", 42), asList (9, "RSN", 43), asList (10, "RSN", 37), asList (11, "RSN", 37), asList (19, "RSN", 37), asList (20, "RSN", 37)), asList ("SemanticTable", 55, buildTree, asList ("+"), 51), asList ("SemanticTable", 56, buildTree, asList ("-"), 51), asList ("SemanticTable", 57, buildTree, asList ("*"), 53), asList ("SemanticTable", 58, buildTree, asList ("/"), 53), asList ("SemanticTable", 59, buildTree, asList ("send"), 54), asList ("SemanticTable", 60, buildTree, asList ("<-"), 52), asList ("SemanticTable", 61, buildTree, asList ("where"), 52), asList ("AcceptTable", 62));}