GrammarParser


1   /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2    * This file is part of Beaver Parser Generator.                       *
3    * Copyright (C) 2003,2005 Alexander Demenchuk <alder@softanvil.com>.  *
4    * All rights reserved.                                                *
5    * See the file "LICENSE" for the terms and conditions for copying,    *
6    * distribution and modification of Beaver.                            *
7    * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
8   
9   package beaver.spec.parser;
10  
11  import beaver.comp.util.Log;
12  import beaver.*;
13  import beaver.spec.ast.*;
14  import java.util.ArrayList  ;
15  
16  /**
17   * This class is a LALR parser generated by
18   * <a HREF="http://beaver.sourceforge.net">Beaver</a> v0.9.6
19   * from the grammar specification "beaver.grammar".
20   */
21  public class GrammarParser extends Parser {
22      static public class Terminals {
23          static public final short EOF = 0;
24          static public final short IDENT = 1;
25          static public final short SEMI = 2;
26          static public final short TYPEOF = 3;
27          static public final short HEADER = 4;
28          static public final short PACKAGE = 5;
29          static public final short CLASS = 6;
30          static public final short EMBED = 7;
31          static public final short INIT = 8;
32          static public final short GOAL = 9;
33          static public final short IMPORT = 10;
34          static public final short TERMINALS = 11;
35          static public final short LEFT = 12;
36          static public final short RIGHT = 13;
37          static public final short NONASSOC = 14;
38          static public final short BAR = 15;
39          static public final short CODE = 16;
40          static public final short AT = 17;
41          static public final short COMMA = 18;
42          static public final short TEXT = 19;
43          static public final short IS = 20;
44          static public final short QUESTION = 21;
45          static public final short PLUS = 22;
46          static public final short STAR = 23;
47          static public final short DOT = 24;
48  
49          static public final String  [] NAMES = {
50              "EOF",
51              "IDENT",
52              "SEMI",
53              "TYPEOF",
54              "HEADER",
55              "PACKAGE",
56              "CLASS",
57              "EMBED",
58              "INIT",
59              "GOAL",
60              "IMPORT",
61              "TERMINALS",
62              "LEFT",
63              "RIGHT",
64              "NONASSOC",
65              "BAR",
66              "CODE",
67              "AT",
68              "COMMA",
69              "TEXT",
70              "IS",
71              "QUESTION",
72              "PLUS",
73              "STAR",
74              "DOT"
75          };
76      }
77  
78      static final ParsingTables PARSING_TABLES = new ParsingTables(
79          "U9pLbqbmLKKKXlztBm42n8GGXinXa459a2Ga94moAGwe33AZKEMQXMkjOgrLhbsuTg5LbbM" +
80          "wK9T2GWX1a8G4XIX31iAKYKcG7B##xmP2h8wQqYfvV$rzJlT$Uhgtxkb#Kd10fVQRKhH9#$" +
81          "IQnjgFcgjvcgy5UaRFQg6ALQ95UawBKPxI7CrKe5BA5CtMqqhJ63laxV50eLvLkIhrlDRg1" +
82          "RsaQctLTktINljTaxtQWB9im8ExAh2x7jpHKhlZmMsjijiUtD8ok#N1JQsqcnxqQxNrUz2d" +
83          "bwtFWrvjiLuFUhJHUZperklMxS4DRROR7bndlkiUNDERTis3g$Ixwi4LxR0h7dJHhyk3ozf" +
84          "jbptef5#d1nrwopeyQ9UitOFpQESzQ4Dhy#0IsYKFBg9TzE02sWKF3CttEsx7DKjJxRJAbA" +
85          "abAjH4EsR7D45Jd0PEHuXyvJiDD5Y39YbRESgrUtPFwwpEwfJknd4QE6jdzMBirqL8ZXFvp" +
86          "3JUpKHyaugOgHdy38xQKQLQlTMhmfeYd8cqPerp6gYFS0ISiLghLPNLM8scMOkrQ8toh37I" +
87          "ZZWDr4HeYT1eZSgmKtRE3ckwjTe9hTSCEwaDzeFzfEKef#mmE6SdOAkTX2Xst#vBMc6$sA$" +
88          "QfftQexVrYjxGi5#aRugHJKE2NUOh2mJahLdahJbahiTpLheoo5dPMWopwL50ZnBAAc#F11" +
89          "akr1Zou5YDuoccygOcyYxIo989uDToHzbloYYr9V$1c2EjSoGjvtyqtnFIZwpnn6jyUK5SP" +
90          "lEbvIelgXMISzoNDpakfsgQfcj6N7CHnN6R#uepefQAg4n695kJ4NyU9vkueJCvg#WzkFx9" +
91          "rIJZ1stfOwCCZNDbMUnNFeptbK64yjWkZUtWV8wPb5bncGuKFR$C8P4HXXyIH3o2jFzWCkK" +
92          "jX3dHtfHe8wmFMmCVm6xO9GKyhM01CIdObN0rhAA#3Eku5j8$G4zy3nlmK#4ac0#Bu6pQM#" +
93          "cp7Tj1VIvSXty8EnvkHQk66#0s#0vy5xfbVWG$WP$1Rs0jR8ASfUfX35SVm7x7E6bOvjKM$" +
94          "9duRc$xyTVZpyT$7v$n0zQX3x7pQA#0pVYhi6vDdCF16kncOZx7tuE$3$zRdaylrgrvBsq7" +
95          "y3dh0zOThC172tRG$Xva7S5Ex0UGPnVimduCMKUm6$if$DfjZZ4xuO1x1mVZ3UEs3$6$ZEr" +
96          "NnFKCjWydlqLnN3zpJF35ZKIDei$V77VZlpJE5t#XTppo4y4Gls28Npryp$oMSuOdOC0vBk" +
97          "ZEQCU0SppWH4$yGxhxGiZv7t832Ba3XDm2Gku18JU1a9j0o5qWv3OGyWM6t0rIE6kJvsrEd" +
98          "DCBo8W5qJ#c10oZB5H4FO$rkSnKZ2t6bc1Bi8N456BBgBjyKuujZ#yCbL4kIJnaXSkcVm2p" +
99          "BaPq");
100 
101     static class Events extends Parser.Events
102     {
103         private final Log log;
104 
105         Events(Log log)
106         {
107             this.log = log;
108         }
109 
110         public void scannerError(Scanner.Exception e)
111         {
112             log.error(e);
113         }
114         public void syntaxError(Symbol token)
115         {
116             log.error(token, "unexpected token");
117         }
118         public void unexpectedTokenRemoved(Symbol token)
119         {
120             log.warning(token, "recovered by removing unexpected token");
121         }
122         public void missingTokenInserted(Symbol token)
123         {
124             log.warning(token, "recovered by inserting missing '" + Terminals.NAMES[token.getId()] + "'");
125         }
126         public void misspelledTokenReplaced(Symbol token)
127         {
128             log.warning(token, "recovered by replacing misspelled token with '" + Terminals.NAMES[token.getId()] + "'");
129         }
130         public void errorPhraseRemoved(Symbol error)
131         {
132             log.warning(error, "recovered by removing error phrase");
133         }
134     }
135 
136     private Log log;
137 
138     public GrammarParser(Log log)
139     {
140         this();
141         report = new Events(this.log = log);
142     }
143 
144     public GrammarParser() {
145         super(PARSING_TABLES);
146     }
147 
148     protected Symbol invokeReduceAction(int rule_num, int offset) {
149         switch(rule_num) {
150             case 0: // lst$declaration = declaration
151             {
152                     ArrayList   lst = new ArrayList  (); lst.add(_symbols[offset + 1].value); return new Symbol(lst);
153             }
154             case 1: // lst$declaration = lst$declaration declaration
155             {
156                     ((ArrayList  ) _symbols[offset + 1].value).add(_symbols[offset + 2].value); return _symbols[offset + 1];
157             }
158             case 4: // lst$rule = rule
159             {
160                     ArrayList   lst = new ArrayList  (); lst.add(_symbols[offset + 1].value); return new Symbol(lst);
161             }
162             case 5: // lst$rule = lst$rule rule
163             {
164                     ((ArrayList  ) _symbols[offset + 1].value).add(_symbols[offset + 2].value); return _symbols[offset + 1];
165             }
166             case 6: // grammar = opt$lst$declaration.decl lst$rule.rules
167             {
168                     final Symbol _symbol_decl = _symbols[offset + 1];
169                     final ArrayList   _list_decl = (ArrayList  ) _symbol_decl.value;
170                     final Declaration[] decl = _list_decl == null ? new Declaration[0] : (Declaration[]) _list_decl.toArray(new Declaration[_list_decl.size()]);
171                     final Symbol _symbol_rules = _symbols[offset + 2];
172                     final ArrayList   _list_rules = (ArrayList  ) _symbol_rules.value;
173                     final Rule[] rules = _list_rules == null ? new Rule[0] : (Rule[]) _list_rules.toArray(new Rule[_list_rules.size()]);
174                     
175                     return new GrammarTreeRoot(decl, rules);
176             }
177             case 19: // declaration = error.e SEMI
178             {
179                     final Symbol e = _symbols[offset + 1];
180                     
181                     log.error(e, "malformed declaration"); return new Declaration.Error();
182             }
183             case 20: // header = HEADER CODE.code SEMI
184             {
185                     final Symbol code = _symbols[offset + 2];
186                     
187                     return new Declaration.Header(code);
188             }
189             case 21: // package = PACKAGE TEXT.name SEMI
190             {
191                     final Symbol name = _symbols[offset + 2];
192                     
193                     return new Declaration.PackageName(name);
194             }
195             case 22: // import = IMPORT txt_list.names SEMI
196             {
197                     final Symbol _symbol_names = _symbols[offset + 2];
198                     final ArrayList   _list_names = (ArrayList  ) _symbol_names.value;
199                     final beaver.Symbol[] names = _list_names == null ? new beaver.Symbol[0] : (beaver.Symbol[]) _list_names.toArray(new beaver.Symbol[_list_names.size()]);
200                     
201                     return new Declaration.Imports(names);
202             }
203             case 23: // class_name = CLASS TEXT.name SEMI
204             {
205                     final Symbol name = _symbols[offset + 2];
206                     
207                     return new Declaration.ClassName(name);
208             }
209             case 24: // class_code = EMBED CODE.code SEMI
210             {
211                     final Symbol code = _symbols[offset + 2];
212                     
213                     return new Declaration.ClassCode(code);
214             }
215             case 25: // class_init = INIT CODE.code SEMI
216             {
217                     final Symbol code = _symbols[offset + 2];
218                     
219                     return new Declaration.ConstructorCode(code);
220             }
221             case 26: // grammar_goal = GOAL IDENT.name SEMI
222             {
223                     final Symbol name = _symbols[offset + 2];
224                     
225                     return new Declaration.Goal(name);
226             }
227             case 27: // terminals = TERMINALS sym_list.symbols SEMI
228             {
229                     final Symbol _symbol_symbols = _symbols[offset + 2];
230                     final ArrayList   _list_symbols = (ArrayList  ) _symbol_symbols.value;
231                     final beaver.Symbol[] symbols = _list_symbols == null ? new beaver.Symbol[0] : (beaver.Symbol[]) _list_symbols.toArray(new beaver.Symbol[_list_symbols.size()]);
232                     
233                     return new Declaration.Terminals(symbols);
234             }
235             case 28: // left_assoc = LEFT sym_list.symbols SEMI
236             {
237                     final Symbol _symbol_symbols = _symbols[offset + 2];
238                     final ArrayList   _list_symbols = (ArrayList  ) _symbol_symbols.value;
239                     final beaver.Symbol[] symbols = _list_symbols == null ? new beaver.Symbol[0] : (beaver.Symbol[]) _list_symbols.toArray(new beaver.Symbol[_list_symbols.size()]);
240                     
241                     return new Declaration.LeftAssoc(symbols);
242             }
243             case 29: // right_assoc = RIGHT sym_list.symbols SEMI
244             {
245                     final Symbol _symbol_symbols = _symbols[offset + 2];
246                     final ArrayList   _list_symbols = (ArrayList  ) _symbol_symbols.value;
247                     final beaver.Symbol[] symbols = _list_symbols == null ? new beaver.Symbol[0] : (beaver.Symbol[]) _list_symbols.toArray(new beaver.Symbol[_list_symbols.size()]);
248                     
249                     return new Declaration.RightAssoc(symbols);
250             }
251             case 30: // nonassoc = NONASSOC sym_list.symbols SEMI
252             {
253                     final Symbol _symbol_symbols = _symbols[offset + 2];
254                     final ArrayList   _list_symbols = (ArrayList  ) _symbol_symbols.value;
255                     final beaver.Symbol[] symbols = _list_symbols == null ? new beaver.Symbol[0] : (beaver.Symbol[]) _list_symbols.toArray(new beaver.Symbol[_list_symbols.size()]);
256                     
257                     return new Declaration.NonAssoc(symbols);
258             }
259             case 31: // typeof = TYPEOF sym_list.symbols IS TEXT.type SEMI
260             {
261                     final Symbol _symbol_symbols = _symbols[offset + 2];
262                     final ArrayList   _list_symbols = (ArrayList  ) _symbol_symbols.value;
263                     final beaver.Symbol[] symbols = _list_symbols == null ? new beaver.Symbol[0] : (beaver.Symbol[]) _list_symbols.toArray(new beaver.Symbol[_list_symbols.size()]);
264                     final Symbol type = _symbols[offset + 4];
265                     
266                     return new Declaration.TypeOf(symbols, type);
267             }
268             case 32: // txt_list = TEXT
269             {
270                     ArrayList   lst = new ArrayList  (); lst.add(_symbols[offset + 1]); return new Symbol(lst);
271             }
272             case 33: // txt_list = txt_list COMMA TEXT
273             {
274                     ((ArrayList  ) _symbols[offset + 1].value).add(_symbols[offset + 3]); return _symbols[offset + 1];
275             }
276             case 34: // sym_list = IDENT
277             {
278                     ArrayList   lst = new ArrayList  (); lst.add(_symbols[offset + 1]); return new Symbol(lst);
279             }
280             case 35: // sym_list = sym_list COMMA IDENT
281             {
282                     ((ArrayList  ) _symbols[offset + 1].value).add(_symbols[offset + 3]); return _symbols[offset + 1];
283             }
284             case 36: // rule = IDENT.name IS def_list.defs SEMI
285             {
286                     final Symbol name = _symbols[offset + 1];
287                     final Symbol _symbol_defs = _symbols[offset + 3];
288                     final ArrayList   _list_defs = (ArrayList  ) _symbol_defs.value;
289                     final Rule.Definition[] defs = _list_defs == null ? new Rule.Definition[0] : (Rule.Definition[]) _list_defs.toArray(new Rule.Definition[_list_defs.size()]);
290                     
291                     return new Rule(name, defs);
292             }
293             case 37: // rule = error.e SEMI
294             {
295                     final Symbol e = _symbols[offset + 1];
296                     
297                     log.error(e, "malformed production");
298                     return new Rule(new Symbol(""), new Rule.Definition[] {});
299             }
300             case 38: // def_list = definition
301             {
302                     ArrayList   lst = new ArrayList  (); lst.add(_symbols[offset + 1].value); return new Symbol(lst);
303             }
304             case 39: // def_list = def_list BAR definition
305             {
306                     ((ArrayList  ) _symbols[offset + 1].value).add(_symbols[offset + 3].value); return _symbols[offset + 1];
307             }
308             case 40: // lst$def_element = def_element
309             {
310                     ArrayList   lst = new ArrayList  (); lst.add(_symbols[offset + 1].value); return new Symbol(lst);
311             }
312             case 41: // lst$def_element = lst$def_element def_element
313             {
314                     ((ArrayList  ) _symbols[offset + 1].value).add(_symbols[offset + 2].value); return _symbols[offset + 1];
315             }
316             case 48: // definition = opt$lst$def_element.elts opt$rule_precedence.prec opt$CODE.code
317             {
318                     final Symbol _symbol_elts = _symbols[offset + 1];
319                     final ArrayList   _list_elts = (ArrayList  ) _symbol_elts.value;
320                     final Rule.Definition.Element[] elts = _list_elts == null ? new Rule.Definition.Element[0] : (Rule.Definition.Element[]) _list_elts.toArray(new Rule.Definition.Element[_list_elts.size()]);
321                     final Symbol prec = _symbols[offset + 2];
322                     final Symbol code = _symbols[offset + 3];
323                     
324                     return new Rule.Definition(elts, prec, code);
325             }
326             case 49: // definition = error.e
327             {
328                     final Symbol e = _symbols[offset + 1];
329                     
330                     log.error(e, "malformed nonterminal definition");
331                     return new Rule.Definition(null, new Symbol(null), new Symbol(null));
332             }
333             case 54: // def_element = IDENT.name opt$alias.alias opt$ebnf_symbol.ebnf_mark
334             {
335                     final Symbol name = _symbols[offset + 1];
336                     final Symbol alias = _symbols[offset + 2];
337                     final Symbol ebnf_mark = _symbols[offset + 3];
338                     
339                     return new Rule.Definition.Element(name, alias, ebnf_mark);
340             }
341             case 2: // opt$lst$declaration = 
342             case 42: // opt$lst$def_element = 
343             case 44: // opt$rule_precedence = 
344             case 46: // opt$CODE = 
345             case 50: // opt$alias = 
346             case 52: // opt$ebnf_symbol = 
347             {
348                 return new Symbol(null);
349             }
350             case 3: // opt$lst$declaration = lst$declaration
351             case 7: // declaration = header
352             case 8: // declaration = package
353             case 9: // declaration = import
354             case 10: // declaration = class_name
355             case 11: // declaration = class_code
356             case 12: // declaration = class_init
357             case 13: // declaration = grammar_goal
358             case 14: // declaration = typeof
359             case 15: // declaration = terminals
360             case 16: // declaration = left_assoc
361             case 17: // declaration = right_assoc
362             case 18: // declaration = nonassoc
363             case 43: // opt$lst$def_element = lst$def_element
364             case 45: // opt$rule_precedence = rule_precedence
365             case 47: // opt$CODE = CODE
366             case 51: // opt$alias = alias
367             case 53: // opt$ebnf_symbol = ebnf_symbol
368             case 56: // ebnf_symbol = QUESTION
369             case 57: // ebnf_symbol = PLUS
370             case 58: // ebnf_symbol = STAR
371             {
372                 return _symbols[offset + 1];
373             }
374             case 55: // alias = DOT IDENT
375             case 59: // rule_precedence = AT IDENT
376             {
377                 return _symbols[offset + 2];
378             }
379             default:
380                 throw new IllegalArgumentException  ("unknown production #" + rule_num);
381         }
382     }
383 }
384
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags