edits
[cdsspec-compiler.git] / src / edu / uci / eecs / utilParser / UtilParser.java
1 /* UtilParser.java */
2 /* Generated By:JavaCC: Do not edit this line. UtilParser.java */
3 package edu.uci.eecs.utilParser;
4 import edu.uci.eecs.specExtraction.FunctionHeader;
5 import edu.uci.eecs.specExtraction.QualifiedName;
6 import edu.uci.eecs.specExtraction.VariableDeclaration;
7 //import edu.uci.eecs.specExtraction.WrongAnnotationException;
8
9 import java.io.FileInputStream;
10 import java.io.FileNotFoundException;
11 import java.io.InputStream;
12 import java.io.ByteArrayInputStream;
13 import java.io.File;
14 import java.util.ArrayList;
15
16
17 public class UtilParser implements UtilParserConstants {
18         public static void main(String[] argvs)
19         throws ParseException, TokenMgrError {
20                 try {
21                         File f = new File("./grammer/spec1.txt");
22                         FileInputStream fis = new FileInputStream(f);
23                         UtilParser parser = new UtilParser(fis);
24
25                         //parser.Test();
26                         System.out.println("Parsing finished!");
27                 } catch (FileNotFoundException e) {
28                         e.printStackTrace();
29                 }
30         }
31
32         public static ArrayList<VariableDeclaration> getTemplateArg(String line)
33         throws ParseException {
34                 InputStream input = new ByteArrayInputStream(line.getBytes());
35                 UtilParser parser = new UtilParser(input);
36                 return parser.TemplateParamList();
37         }
38
39         public static FunctionHeader parseFuncHeader(String line)
40         throws ParseException {
41                 InputStream input = new ByteArrayInputStream(line.getBytes());
42                 UtilParser parser = new UtilParser(input);
43                 return parser.FuncDecl();
44         }
45
46         public static VariableDeclaration parseDeclaration(String line)
47         throws ParseException {
48                 InputStream input = new ByteArrayInputStream(line.getBytes());
49                 UtilParser parser = new UtilParser(input);
50                 return parser.Declaration();
51         }
52
53         public static String stringArray2String(ArrayList<String> content) {
54                 StringBuilder sb = new StringBuilder();
55                 if (content.size() == 1)
56                         return content.get(0);
57                 for (int i = 0; i < content.size(); i++) {
58                         sb.append(content.get(i) + "\u005cn");
59                 }
60                 return sb.toString();
61         }
62
63   final public String Type() throws ParseException {String type;
64         String str;
65         QualifiedName name;
66 type = "";
67     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
68     case CONST:{
69       jj_consume_token(CONST);
70 type = "const";
71       break;
72       }
73     default:
74       jj_la1[0] = jj_gen;
75       ;
76     }
77     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
78     case STRUCT:
79     case CLASS:
80     case UNSIGNED:{
81       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
82       case STRUCT:{
83         str = jj_consume_token(STRUCT).image;
84         break;
85         }
86       case CLASS:{
87         str = jj_consume_token(CLASS).image;
88         break;
89         }
90       case UNSIGNED:{
91         str = jj_consume_token(UNSIGNED).image;
92         break;
93         }
94       default:
95         jj_la1[1] = jj_gen;
96         jj_consume_token(-1);
97         throw new ParseException();
98       }
99 type = type.equals("") ? type + str : type + " " + str;
100       break;
101       }
102     default:
103       jj_la1[2] = jj_gen;
104       ;
105     }
106     name = ParseQualifiedName();
107 if (!type.equals(""))
108                         type = type + " " + name.fullName;
109                 else
110                         type = name.fullName;
111     label_1:
112     while (true) {
113       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
114       case CONST:
115       case STAR:
116       case AND:{
117         ;
118         break;
119         }
120       default:
121         jj_la1[3] = jj_gen;
122         break label_1;
123       }
124       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
125       case CONST:{
126         str = jj_consume_token(CONST).image;
127 if (!type.equals(""))
128                         type = type + " " + str;
129                 else
130                         type = str;
131         break;
132         }
133       case STAR:{
134         str = jj_consume_token(STAR).image;
135 if (!type.equals(""))
136                         type = type + " " + str;
137                 else
138                         type = str;
139         break;
140         }
141       case AND:{
142         str = jj_consume_token(AND).image;
143 if (!type.equals(""))
144                         type = type + " " + str;
145                 else
146                         type = str;
147         break;
148         }
149       default:
150         jj_la1[4] = jj_gen;
151         jj_consume_token(-1);
152         throw new ParseException();
153       }
154     }
155 {if ("" != null) return type;}
156     throw new Error("Missing return statement in function");
157   }
158
159   final public void Test() throws ParseException {String str;
160         FunctionHeader func;
161     /*
162         str = Type()
163         {
164                 System.out.println(str);
165         }
166         */
167             func = FuncDecl();
168 System.out.println(func);
169   }
170
171   final public String ParameterizedName() throws ParseException {String res = "";
172         String str;
173     str = jj_consume_token(IDENTIFIER).image;
174 res = str;
175     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
176     case LESS_THAN:{
177       jj_consume_token(LESS_THAN);
178       str = Type();
179 res = res + "<" + str;
180       label_2:
181       while (true) {
182         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
183         case COMMA:{
184           ;
185           break;
186           }
187         default:
188           jj_la1[5] = jj_gen;
189           break label_2;
190         }
191         jj_consume_token(COMMA);
192         str = Type();
193 res = res + ", " + str;
194       }
195       jj_consume_token(GREATER_THAN);
196 res = res + ">";
197       break;
198       }
199     default:
200       jj_la1[6] = jj_gen;
201       ;
202     }
203 {if ("" != null) return res;}
204     throw new Error("Missing return statement in function");
205   }
206
207   final public FunctionHeader FuncDecl() throws ParseException {String ret;
208         QualifiedName funcName;
209         ArrayList<VariableDeclaration> args;
210     label_3:
211     while (true) {
212       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
213       case INLINE:
214       case STATIC:{
215         ;
216         break;
217         }
218       default:
219         jj_la1[7] = jj_gen;
220         break label_3;
221       }
222       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
223       case STATIC:{
224         jj_consume_token(STATIC);
225         break;
226         }
227       case INLINE:{
228         jj_consume_token(INLINE);
229         break;
230         }
231       default:
232         jj_la1[8] = jj_gen;
233         jj_consume_token(-1);
234         throw new ParseException();
235       }
236     }
237     ret = Type();
238     funcName = ParseQualifiedName();
239     args = FormalParamList();
240 FunctionHeader res = new FunctionHeader(ret, funcName, args);
241                 //System.out.println(res);
242                 {if ("" != null) return res;}
243     throw new Error("Missing return statement in function");
244   }
245
246   final public QualifiedName ParseQualifiedName() throws ParseException {String qualifiedName, str;
247 qualifiedName = "";
248     str = ParameterizedName();
249 qualifiedName = qualifiedName + str;
250     label_4:
251     while (true) {
252       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
253       case DOUBLECOLON:{
254         ;
255         break;
256         }
257       default:
258         jj_la1[9] = jj_gen;
259         break label_4;
260       }
261       jj_consume_token(DOUBLECOLON);
262       str = ParameterizedName();
263 qualifiedName = qualifiedName +
264         "::" + str;
265     }
266 QualifiedName res = new QualifiedName(qualifiedName);
267                 //System.out.println(res);
268                 {if ("" != null) return res;}
269     throw new Error("Missing return statement in function");
270   }
271
272   final public ArrayList<VariableDeclaration> TemplateParamList() throws ParseException {ArrayList<VariableDeclaration> params;
273         String type;
274         String name;
275 params = new ArrayList<VariableDeclaration>();
276     jj_consume_token(TEMPLATE);
277     jj_consume_token(LESS_THAN);
278     type = jj_consume_token(IDENTIFIER).image;
279     name = jj_consume_token(IDENTIFIER).image;
280 params.add(new VariableDeclaration(type, name));
281     label_5:
282     while (true) {
283       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
284       case COMMA:{
285         ;
286         break;
287         }
288       default:
289         jj_la1[10] = jj_gen;
290         break label_5;
291       }
292       jj_consume_token(COMMA);
293       type = jj_consume_token(IDENTIFIER).image;
294       name = jj_consume_token(IDENTIFIER).image;
295 params.add(new VariableDeclaration(type, name));
296     }
297     jj_consume_token(GREATER_THAN);
298 //System.out.println(params);
299                 {if ("" != null) return params;}
300     throw new Error("Missing return statement in function");
301   }
302
303   final public ArrayList<VariableDeclaration > FormalParamList() throws ParseException {ArrayList<VariableDeclaration > typeParams;
304         VariableDeclaration varDecl;
305 typeParams = new ArrayList<VariableDeclaration >();
306     jj_consume_token(OPEN_PAREN);
307     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
308     case CONST:
309     case STRUCT:
310     case CLASS:
311     case UNSIGNED:
312     case IDENTIFIER:{
313       varDecl = TypeParam();
314 typeParams.add(varDecl);
315       label_6:
316       while (true) {
317         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
318         case COMMA:{
319           ;
320           break;
321           }
322         default:
323           jj_la1[11] = jj_gen;
324           break label_6;
325         }
326         jj_consume_token(COMMA);
327         varDecl = TypeParam();
328 typeParams.add(varDecl);
329       }
330       break;
331       }
332     default:
333       jj_la1[12] = jj_gen;
334       ;
335     }
336     jj_consume_token(CLOSE_PAREN);
337 {if ("" != null) return typeParams;}
338     throw new Error("Missing return statement in function");
339   }
340
341   final public VariableDeclaration Declaration() throws ParseException {String type, param;
342     type = Type();
343     param = jj_consume_token(IDENTIFIER).image;
344     jj_consume_token(SEMI_COLON);
345 {if ("" != null) return new VariableDeclaration(type, param);}
346     throw new Error("Missing return statement in function");
347   }
348
349   final public VariableDeclaration TypeParam() throws ParseException {String type, param;
350     type = Type();
351     param = jj_consume_token(IDENTIFIER).image;
352 {if ("" != null) return new VariableDeclaration(type, param);}
353     throw new Error("Missing return statement in function");
354   }
355
356   /** Generated Token Manager. */
357   public UtilParserTokenManager token_source;
358   JavaCharStream jj_input_stream;
359   /** Current token. */
360   public Token token;
361   /** Next token. */
362   public Token jj_nt;
363   private int jj_ntk;
364   private int jj_gen;
365   final private int[] jj_la1 = new int[13];
366   static private int[] jj_la1_0;
367   static private int[] jj_la1_1;
368   static private int[] jj_la1_2;
369   static {
370       jj_la1_init_0();
371       jj_la1_init_1();
372       jj_la1_init_2();
373    }
374    private static void jj_la1_init_0() {
375       jj_la1_0 = new int[] {0x40,0x380,0x380,0x20000040,0x20000040,0x4000000,0x0,0x1800,0x1800,0x0,0x4000000,0x4000000,0x103c0,};
376    }
377    private static void jj_la1_init_1() {
378       jj_la1_1 = new int[] {0x0,0x0,0x0,0x1,0x1,0x0,0x200,0x0,0x0,0x100000,0x0,0x0,0x0,};
379    }
380    private static void jj_la1_init_2() {
381       jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
382    }
383
384   /** Constructor with InputStream. */
385   public UtilParser(java.io.InputStream stream) {
386      this(stream, null);
387   }
388   /** Constructor with InputStream and supplied encoding */
389   public UtilParser(java.io.InputStream stream, String encoding) {
390     try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
391     token_source = new UtilParserTokenManager(jj_input_stream);
392     token = new Token();
393     jj_ntk = -1;
394     jj_gen = 0;
395     for (int i = 0; i < 13; i++) jj_la1[i] = -1;
396   }
397
398   /** Reinitialise. */
399   public void ReInit(java.io.InputStream stream) {
400      ReInit(stream, null);
401   }
402   /** Reinitialise. */
403   public void ReInit(java.io.InputStream stream, String encoding) {
404     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
405     token_source.ReInit(jj_input_stream);
406     token = new Token();
407     jj_ntk = -1;
408     jj_gen = 0;
409     for (int i = 0; i < 13; i++) jj_la1[i] = -1;
410   }
411
412   /** Constructor. */
413   public UtilParser(java.io.Reader stream) {
414     jj_input_stream = new JavaCharStream(stream, 1, 1);
415     token_source = new UtilParserTokenManager(jj_input_stream);
416     token = new Token();
417     jj_ntk = -1;
418     jj_gen = 0;
419     for (int i = 0; i < 13; i++) jj_la1[i] = -1;
420   }
421
422   /** Reinitialise. */
423   public void ReInit(java.io.Reader stream) {
424     jj_input_stream.ReInit(stream, 1, 1);
425     token_source.ReInit(jj_input_stream);
426     token = new Token();
427     jj_ntk = -1;
428     jj_gen = 0;
429     for (int i = 0; i < 13; i++) jj_la1[i] = -1;
430   }
431
432   /** Constructor with generated Token Manager. */
433   public UtilParser(UtilParserTokenManager tm) {
434     token_source = tm;
435     token = new Token();
436     jj_ntk = -1;
437     jj_gen = 0;
438     for (int i = 0; i < 13; i++) jj_la1[i] = -1;
439   }
440
441   /** Reinitialise. */
442   public void ReInit(UtilParserTokenManager tm) {
443     token_source = tm;
444     token = new Token();
445     jj_ntk = -1;
446     jj_gen = 0;
447     for (int i = 0; i < 13; i++) jj_la1[i] = -1;
448   }
449
450   private Token jj_consume_token(int kind) throws ParseException {
451     Token oldToken;
452     if ((oldToken = token).next != null) token = token.next;
453     else token = token.next = token_source.getNextToken();
454     jj_ntk = -1;
455     if (token.kind == kind) {
456       jj_gen++;
457       return token;
458     }
459     token = oldToken;
460     jj_kind = kind;
461     throw generateParseException();
462   }
463
464
465 /** Get the next Token. */
466   final public Token getNextToken() {
467     if (token.next != null) token = token.next;
468     else token = token.next = token_source.getNextToken();
469     jj_ntk = -1;
470     jj_gen++;
471     return token;
472   }
473
474 /** Get the specific Token. */
475   final public Token getToken(int index) {
476     Token t = token;
477     for (int i = 0; i < index; i++) {
478       if (t.next != null) t = t.next;
479       else t = t.next = token_source.getNextToken();
480     }
481     return t;
482   }
483
484   private int jj_ntk_f() {
485     if ((jj_nt=token.next) == null)
486       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
487     else
488       return (jj_ntk = jj_nt.kind);
489   }
490
491   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
492   private int[] jj_expentry;
493   private int jj_kind = -1;
494
495   /** Generate ParseException. */
496   public ParseException generateParseException() {
497     jj_expentries.clear();
498     boolean[] la1tokens = new boolean[80];
499     if (jj_kind >= 0) {
500       la1tokens[jj_kind] = true;
501       jj_kind = -1;
502     }
503     for (int i = 0; i < 13; i++) {
504       if (jj_la1[i] == jj_gen) {
505         for (int j = 0; j < 32; j++) {
506           if ((jj_la1_0[i] & (1<<j)) != 0) {
507             la1tokens[j] = true;
508           }
509           if ((jj_la1_1[i] & (1<<j)) != 0) {
510             la1tokens[32+j] = true;
511           }
512           if ((jj_la1_2[i] & (1<<j)) != 0) {
513             la1tokens[64+j] = true;
514           }
515         }
516       }
517     }
518     for (int i = 0; i < 80; i++) {
519       if (la1tokens[i]) {
520         jj_expentry = new int[1];
521         jj_expentry[0] = i;
522         jj_expentries.add(jj_expentry);
523       }
524     }
525     int[][] exptokseq = new int[jj_expentries.size()][];
526     for (int i = 0; i < jj_expentries.size(); i++) {
527       exptokseq[i] = jj_expentries.get(i);
528     }
529     return new ParseException(token, exptokseq, tokenImage);
530   }
531
532   /** Enable tracing. */
533   final public void enable_tracing() {
534   }
535
536   /** Disable tracing. */
537   final public void disable_tracing() {
538   }
539
540 }