]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.spreadsheet.graph/src/org/simantics/spreadsheet/graph/parser/SheetFormulaParser.java
Improved exception message
[simantics/platform.git] / bundles / org.simantics.spreadsheet.graph / src / org / simantics / spreadsheet / graph / parser / SheetFormulaParser.java
1 /* Generated By:JavaCC: Do not edit this line. SheetFormulaParser.java */
2 package org.simantics.spreadsheet.graph.parser;
3
4 import org.simantics.spreadsheet.graph.parser.ast.*;
5 import java.util.ArrayList;
6 import java.util.List;
7 import java.util.Collections;
8
9 /**
10  * Parser for spreadsheet formulas
11  * @author Antti Villberg
12  */
13 public class SheetFormulaParser implements SheetFormulaParserConstants {
14
15   final public AstValue primary() throws ParseException {
16     Token tok;
17     AstValue temp;
18     AstRange tempRange;
19     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
20     case 27:
21       jj_consume_token(27);
22              {if (true) return AstNull.NULL;}
23       break;
24     case 25:
25       jj_consume_token(25);
26              {if (true) return AstBoolean.TRUE;}
27       break;
28     case 26:
29       jj_consume_token(26);
30               {if (true) return AstBoolean.FALSE;}
31       break;
32     case 28:
33       jj_consume_token(28);
34              {if (true) return AstBoolean.TRUE;}
35       break;
36     case 29:
37       jj_consume_token(29);
38               {if (true) return AstBoolean.FALSE;}
39       break;
40     case STRING:
41       jj_consume_token(STRING);
42                {if (true) return new AstString(token.image);}
43       break;
44     case LONG_STRING:
45       jj_consume_token(LONG_STRING);
46                     {if (true) return new AstString(token.image);}
47       break;
48     case FLOAT:
49       jj_consume_token(FLOAT);
50               {if (true) return new AstDouble(token.image);}
51       break;
52     case INTEGER:
53       jj_consume_token(INTEGER);
54                 {if (true) return new AstInteger(Integer.parseInt(token.image));}
55       break;
56     default:
57       jj_la1[1] = jj_gen;
58       if (jj_2_1(2)) {
59         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
60         case IDENT:
61           tok = jj_consume_token(IDENT);
62           break;
63         case SHEET_NAME:
64           tok = jj_consume_token(SHEET_NAME);
65           break;
66         default:
67           jj_la1[0] = jj_gen;
68           jj_consume_token(-1);
69           throw new ParseException();
70         }
71         jj_consume_token(42);
72         tempRange = range();
73                                                                                 {if (true) return tempRange.inSheet(tok.image);}
74       } else if (jj_2_2(2)) {
75         temp = apply();
76                                   {if (true) return temp;}
77       } else {
78         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
79         case 5:
80           jj_consume_token(5);
81           temp = relation();
82           jj_consume_token(6);
83                                 {if (true) return temp;}
84           break;
85         case CELL_SINGLE:
86         case CELL_RANGE:
87         case 43:
88           temp = range();
89                      {if (true) return temp;}
90           break;
91         case 10:
92           temp = array();
93                      {if (true) return temp;}
94           break;
95         case IDENT:
96           jj_consume_token(IDENT);
97               {if (true) return new AstIdentifier(token.image);}
98           break;
99         default:
100           jj_la1[2] = jj_gen;
101           jj_consume_token(-1);
102           throw new ParseException();
103         }
104       }
105     }
106     throw new Error("Missing return statement in function");
107   }
108
109   final public AstApply apply() throws ParseException {
110     AstArgList al;
111     Token tok;
112     if (jj_2_3(3)) {
113       tok = jj_consume_token(IDENT);
114       jj_consume_token(5);
115       jj_consume_token(6);
116                                        {if (true) return new AstApply(tok.image, null);}
117     } else {
118       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
119       case IDENT:
120         tok = jj_consume_token(IDENT);
121         jj_consume_token(5);
122         al = arglist();
123         jj_consume_token(6);
124                                          {if (true) return new AstApply(tok.image, al);}
125         break;
126       default:
127         jj_la1[3] = jj_gen;
128         jj_consume_token(-1);
129         throw new ParseException();
130       }
131     }
132     throw new Error("Missing return statement in function");
133   }
134
135   final public AstValue array() throws ParseException {
136     AstArray arr = new AstArray();
137     AstValue temp;
138     if (jj_2_4(2)) {
139       jj_consume_token(10);
140       jj_consume_token(11);
141                          {if (true) return new AstArray();}
142     } else {
143       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
144       case 10:
145         jj_consume_token(10);
146         temp = relation();
147                           arr.add(temp);
148         jj_consume_token(18);
149         label_1:
150         while (true) {
151           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
152           case 5:
153           case 10:
154           case 13:
155           case 14:
156           case 25:
157           case 26:
158           case 27:
159           case 28:
160           case 29:
161           case STRING:
162           case SHEET_NAME:
163           case LONG_STRING:
164           case CELL_SINGLE:
165           case CELL_RANGE:
166           case IDENT:
167           case FLOAT:
168           case INTEGER:
169           case 43:
170           case 46:
171             ;
172             break;
173           default:
174             jj_la1[4] = jj_gen;
175             break label_1;
176           }
177           temp = relation();
178                                                                      arr.add(temp);
179         }
180         jj_consume_token(11);
181                                                                                                {if (true) return arr;}
182         break;
183       default:
184         jj_la1[5] = jj_gen;
185         jj_consume_token(-1);
186         throw new ParseException();
187       }
188     }
189     throw new Error("Missing return statement in function");
190   }
191
192   final public AstRange range() throws ParseException {
193     Token temp1;
194     Token temp2;
195     if (jj_2_5(2)) {
196       jj_consume_token(CELL_RANGE);
197                               {if (true) return new AstRange(token.image);}
198     } else {
199       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
200       case CELL_SINGLE:
201         jj_consume_token(CELL_SINGLE);
202                      {if (true) return new AstRange(token.image);}
203         break;
204       case 43:
205         jj_consume_token(43);
206                {if (true) return AstRange.REF;}
207         break;
208       default:
209         jj_la1[6] = jj_gen;
210         jj_consume_token(-1);
211         throw new ParseException();
212       }
213     }
214     throw new Error("Missing return statement in function");
215   }
216
217   final public AstArgList arglist() throws ParseException {
218     AstArgList ret = new AstArgList();
219     AstValue temp;
220     temp = relation();
221                        ret.add(temp);
222     label_2:
223     while (true) {
224       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
225       case 4:
226       case 18:
227         ;
228         break;
229       default:
230         jj_la1[7] = jj_gen;
231         break label_2;
232       }
233       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
234       case 4:
235         jj_consume_token(4);
236         break;
237       case 18:
238         jj_consume_token(18);
239         break;
240       default:
241         jj_la1[8] = jj_gen;
242         jj_consume_token(-1);
243         throw new ParseException();
244       }
245                 temp = AstNothing.INSTANCE;
246       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
247       case 5:
248       case 10:
249       case 13:
250       case 14:
251       case 25:
252       case 26:
253       case 27:
254       case 28:
255       case 29:
256       case STRING:
257       case SHEET_NAME:
258       case LONG_STRING:
259       case CELL_SINGLE:
260       case CELL_RANGE:
261       case IDENT:
262       case FLOAT:
263       case INTEGER:
264       case 43:
265       case 46:
266         temp = relation();
267         break;
268       default:
269         jj_la1[9] = jj_gen;
270         ;
271       }
272                                                                      ret.add(temp);
273     }
274                                                                                             {if (true) return ret;}
275     throw new Error("Missing return statement in function");
276   }
277
278   final public AstValue relation() throws ParseException {
279   AstRelation ret;
280   String op;
281   AstValue ex;
282     ex = arithmetic_expression();
283                                         ret = new AstRelation(ex);
284     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
285     case 21:
286     case 22:
287     case 23:
288     case 24:
289     case 44:
290     case 45:
291       op = rel_op();
292       ex = arithmetic_expression();
293                                                                                                                         ret.setRight(op, ex);
294       break;
295     default:
296       jj_la1[10] = jj_gen;
297       ;
298     }
299                                                                                                                                                      {if (true) return ret.simplify();}
300     throw new Error("Missing return statement in function");
301   }
302
303   final public String rel_op() throws ParseException {
304     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
305     case 22:
306       jj_consume_token(22);
307               {if (true) return "< ";}
308       break;
309     case 44:
310       jj_consume_token(44);
311                                      {if (true) return "<=";}
312       break;
313     case 23:
314       jj_consume_token(23);
315                                                            {if (true) return " >";}
316       break;
317     case 45:
318       jj_consume_token(45);
319                                                                                   {if (true) return " >=";}
320       break;
321     case 21:
322       jj_consume_token(21);
323                                                                                                          {if (true) return "=";}
324       break;
325     case 24:
326       jj_consume_token(24);
327                                                                                                                                {if (true) return "<>";}
328       break;
329     default:
330       jj_la1[11] = jj_gen;
331       jj_consume_token(-1);
332       throw new ParseException();
333     }
334     throw new Error("Missing return statement in function");
335   }
336
337 //   
338   final public AstValue arithmetic_expression() throws ParseException {
339     AstArithmeticExpression ret;
340     String op = null;
341     AstValue temp;
342     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
343     case 13:
344     case 14:
345     case 46:
346       op = add_op();
347       break;
348     default:
349       jj_la1[12] = jj_gen;
350       ;
351     }
352     temp = term();
353                                    ret = new AstArithmeticExpression(op, temp);
354     label_3:
355     while (true) {
356       if (jj_2_6(2)) {
357         ;
358       } else {
359         break label_3;
360       }
361       op = add_op();
362       temp = term();
363                                                                                                                                ret.add(op, temp);
364     }
365                                                                                                                                                          {if (true) return ret.simplify();}
366     throw new Error("Missing return statement in function");
367   }
368
369   final public String add_op() throws ParseException {
370     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
371     case 14:
372       jj_consume_token(14);
373           {if (true) return "+";}
374       break;
375     case 46:
376       jj_consume_token(46);
377                                {if (true) return "-";}
378       break;
379     case 13:
380       jj_consume_token(13);
381                                                     {if (true) return "&";}
382       break;
383     default:
384       jj_la1[13] = jj_gen;
385       jj_consume_token(-1);
386       throw new ParseException();
387     }
388     throw new Error("Missing return statement in function");
389   }
390
391   final public AstValue term() throws ParseException {
392     AstTerm ret;
393     String op;
394     AstValue temp;
395     temp = factor();
396                     ret = new AstTerm(temp);
397     label_4:
398     while (true) {
399       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
400       case 15:
401       case 16:
402         ;
403         break;
404       default:
405         jj_la1[14] = jj_gen;
406         break label_4;
407       }
408       op = mul_op();
409       temp = factor();
410                                                                                 ret.add(op, temp);
411     }
412                                                                                                           {if (true) return ret.simplify();}
413     throw new Error("Missing return statement in function");
414   }
415
416   final public String mul_op() throws ParseException {
417     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
418     case 15:
419       jj_consume_token(15);
420           {if (true) return "*";}
421       break;
422     case 16:
423       jj_consume_token(16);
424                                {if (true) return "/";}
425       break;
426     default:
427       jj_la1[15] = jj_gen;
428       jj_consume_token(-1);
429       throw new ParseException();
430     }
431     throw new Error("Missing return statement in function");
432   }
433
434   final public AstValue factor() throws ParseException {
435     AstFactor ret;
436     String op;
437     AstValue temp;
438     temp = primary();
439                      ret = new AstFactor(temp);
440     label_5:
441     while (true) {
442       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
443       case 17:
444         ;
445         break;
446       default:
447         jj_la1[16] = jj_gen;
448         break label_5;
449       }
450       op = factor_op();
451       temp = primary();
452                                                                                        ret.add(op, temp);
453     }
454                                                                                                                  {if (true) return ret.simplify();}
455     throw new Error("Missing return statement in function");
456   }
457
458   final public String factor_op() throws ParseException {
459     jj_consume_token(17);
460           {if (true) return "^";}
461     throw new Error("Missing return statement in function");
462   }
463
464   private boolean jj_2_1(int xla) {
465     jj_la = xla; jj_lastpos = jj_scanpos = token;
466     try { return !jj_3_1(); }
467     catch(LookaheadSuccess ls) { return true; }
468     finally { jj_save(0, xla); }
469   }
470
471   private boolean jj_2_2(int xla) {
472     jj_la = xla; jj_lastpos = jj_scanpos = token;
473     try { return !jj_3_2(); }
474     catch(LookaheadSuccess ls) { return true; }
475     finally { jj_save(1, xla); }
476   }
477
478   private boolean jj_2_3(int xla) {
479     jj_la = xla; jj_lastpos = jj_scanpos = token;
480     try { return !jj_3_3(); }
481     catch(LookaheadSuccess ls) { return true; }
482     finally { jj_save(2, xla); }
483   }
484
485   private boolean jj_2_4(int xla) {
486     jj_la = xla; jj_lastpos = jj_scanpos = token;
487     try { return !jj_3_4(); }
488     catch(LookaheadSuccess ls) { return true; }
489     finally { jj_save(3, xla); }
490   }
491
492   private boolean jj_2_5(int xla) {
493     jj_la = xla; jj_lastpos = jj_scanpos = token;
494     try { return !jj_3_5(); }
495     catch(LookaheadSuccess ls) { return true; }
496     finally { jj_save(4, xla); }
497   }
498
499   private boolean jj_2_6(int xla) {
500     jj_la = xla; jj_lastpos = jj_scanpos = token;
501     try { return !jj_3_6(); }
502     catch(LookaheadSuccess ls) { return true; }
503     finally { jj_save(5, xla); }
504   }
505
506   private boolean jj_3R_29() {
507     Token xsp;
508     xsp = jj_scanpos;
509     if (jj_3_4()) {
510     jj_scanpos = xsp;
511     if (jj_3R_32()) return true;
512     }
513     return false;
514   }
515
516   private boolean jj_3_4() {
517     if (jj_scan_token(10)) return true;
518     if (jj_scan_token(11)) return true;
519     return false;
520   }
521
522   private boolean jj_3R_7() {
523     Token xsp;
524     xsp = jj_scanpos;
525     if (jj_3R_10()) {
526     jj_scanpos = xsp;
527     if (jj_3R_11()) {
528     jj_scanpos = xsp;
529     if (jj_3R_12()) return true;
530     }
531     }
532     return false;
533   }
534
535   private boolean jj_3R_10() {
536     if (jj_scan_token(14)) return true;
537     return false;
538   }
539
540   private boolean jj_3R_12() {
541     if (jj_scan_token(13)) return true;
542     return false;
543   }
544
545   private boolean jj_3R_9() {
546     if (jj_scan_token(IDENT)) return true;
547     if (jj_scan_token(5)) return true;
548     return false;
549   }
550
551   private boolean jj_3R_6() {
552     Token xsp;
553     xsp = jj_scanpos;
554     if (jj_3_3()) {
555     jj_scanpos = xsp;
556     if (jj_3R_9()) return true;
557     }
558     return false;
559   }
560
561   private boolean jj_3_3() {
562     if (jj_scan_token(IDENT)) return true;
563     if (jj_scan_token(5)) return true;
564     if (jj_scan_token(6)) return true;
565     return false;
566   }
567
568   private boolean jj_3R_27() {
569     if (jj_scan_token(IDENT)) return true;
570     return false;
571   }
572
573   private boolean jj_3R_26() {
574     if (jj_3R_29()) return true;
575     return false;
576   }
577
578   private boolean jj_3R_25() {
579     if (jj_3R_28()) return true;
580     return false;
581   }
582
583   private boolean jj_3R_24() {
584     if (jj_scan_token(5)) return true;
585     return false;
586   }
587
588   private boolean jj_3_2() {
589     if (jj_3R_6()) return true;
590     return false;
591   }
592
593   private boolean jj_3_1() {
594     Token xsp;
595     xsp = jj_scanpos;
596     if (jj_scan_token(38)) {
597     jj_scanpos = xsp;
598     if (jj_scan_token(33)) return true;
599     }
600     if (jj_scan_token(42)) return true;
601     return false;
602   }
603
604   private boolean jj_3R_23() {
605     if (jj_scan_token(INTEGER)) return true;
606     return false;
607   }
608
609   private boolean jj_3_6() {
610     if (jj_3R_7()) return true;
611     if (jj_3R_8()) return true;
612     return false;
613   }
614
615   private boolean jj_3R_22() {
616     if (jj_scan_token(FLOAT)) return true;
617     return false;
618   }
619
620   private boolean jj_3R_21() {
621     if (jj_scan_token(LONG_STRING)) return true;
622     return false;
623   }
624
625   private boolean jj_3R_20() {
626     if (jj_scan_token(STRING)) return true;
627     return false;
628   }
629
630   private boolean jj_3R_19() {
631     if (jj_scan_token(29)) return true;
632     return false;
633   }
634
635   private boolean jj_3R_18() {
636     if (jj_scan_token(28)) return true;
637     return false;
638   }
639
640   private boolean jj_3R_17() {
641     if (jj_scan_token(26)) return true;
642     return false;
643   }
644
645   private boolean jj_3R_11() {
646     if (jj_scan_token(46)) return true;
647     return false;
648   }
649
650   private boolean jj_3R_16() {
651     if (jj_scan_token(25)) return true;
652     return false;
653   }
654
655   private boolean jj_3R_13() {
656     if (jj_3R_14()) return true;
657     return false;
658   }
659
660   private boolean jj_3R_14() {
661     Token xsp;
662     xsp = jj_scanpos;
663     if (jj_3R_15()) {
664     jj_scanpos = xsp;
665     if (jj_3R_16()) {
666     jj_scanpos = xsp;
667     if (jj_3R_17()) {
668     jj_scanpos = xsp;
669     if (jj_3R_18()) {
670     jj_scanpos = xsp;
671     if (jj_3R_19()) {
672     jj_scanpos = xsp;
673     if (jj_3R_20()) {
674     jj_scanpos = xsp;
675     if (jj_3R_21()) {
676     jj_scanpos = xsp;
677     if (jj_3R_22()) {
678     jj_scanpos = xsp;
679     if (jj_3R_23()) {
680     jj_scanpos = xsp;
681     if (jj_3_1()) {
682     jj_scanpos = xsp;
683     if (jj_3_2()) {
684     jj_scanpos = xsp;
685     if (jj_3R_24()) {
686     jj_scanpos = xsp;
687     if (jj_3R_25()) {
688     jj_scanpos = xsp;
689     if (jj_3R_26()) {
690     jj_scanpos = xsp;
691     if (jj_3R_27()) return true;
692     }
693     }
694     }
695     }
696     }
697     }
698     }
699     }
700     }
701     }
702     }
703     }
704     }
705     }
706     return false;
707   }
708
709   private boolean jj_3R_15() {
710     if (jj_scan_token(27)) return true;
711     return false;
712   }
713
714   private boolean jj_3R_31() {
715     if (jj_scan_token(43)) return true;
716     return false;
717   }
718
719   private boolean jj_3R_30() {
720     if (jj_scan_token(CELL_SINGLE)) return true;
721     return false;
722   }
723
724   private boolean jj_3R_28() {
725     Token xsp;
726     xsp = jj_scanpos;
727     if (jj_3_5()) {
728     jj_scanpos = xsp;
729     if (jj_3R_30()) {
730     jj_scanpos = xsp;
731     if (jj_3R_31()) return true;
732     }
733     }
734     return false;
735   }
736
737   private boolean jj_3_5() {
738     if (jj_scan_token(CELL_RANGE)) return true;
739     return false;
740   }
741
742   private boolean jj_3R_8() {
743     if (jj_3R_13()) return true;
744     return false;
745   }
746
747   private boolean jj_3R_32() {
748     if (jj_scan_token(10)) return true;
749     return false;
750   }
751
752   /** Generated Token Manager. */
753   public SheetFormulaParserTokenManager token_source;
754   SimpleCharStream jj_input_stream;
755   /** Current token. */
756   public Token token;
757   /** Next token. */
758   public Token jj_nt;
759   private int jj_ntk;
760   private Token jj_scanpos, jj_lastpos;
761   private int jj_la;
762   private int jj_gen;
763   final private int[] jj_la1 = new int[17];
764   static private int[] jj_la1_0;
765   static private int[] jj_la1_1;
766   static {
767       jj_la1_init_0();
768       jj_la1_init_1();
769    }
770    private static void jj_la1_init_0() {
771       jj_la1_0 = new int[] {0x0,0x3e000000,0x420,0x0,0x3e006420,0x400,0x0,0x40010,0x40010,0x3e006420,0x1e00000,0x1e00000,0x6000,0x6000,0x18000,0x18000,0x20000,};
772    }
773    private static void jj_la1_init_1() {
774       jj_la1_1 = new int[] {0x42,0x305,0x868,0x40,0x4b6f,0x0,0x808,0x0,0x0,0x4b6f,0x3000,0x3000,0x4000,0x4000,0x0,0x0,0x0,};
775    }
776   final private JJCalls[] jj_2_rtns = new JJCalls[6];
777   private boolean jj_rescan = false;
778   private int jj_gc = 0;
779
780   /** Constructor with InputStream. */
781   public SheetFormulaParser(java.io.InputStream stream) {
782      this(stream, null);
783   }
784   /** Constructor with InputStream and supplied encoding */
785   public SheetFormulaParser(java.io.InputStream stream, String encoding) {
786     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
787     token_source = new SheetFormulaParserTokenManager(jj_input_stream);
788     token = new Token();
789     jj_ntk = -1;
790     jj_gen = 0;
791     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
792     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
793   }
794
795   /** Reinitialise. */
796   public void ReInit(java.io.InputStream stream) {
797      ReInit(stream, null);
798   }
799   /** Reinitialise. */
800   public void ReInit(java.io.InputStream stream, String encoding) {
801     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
802     token_source.ReInit(jj_input_stream);
803     token = new Token();
804     jj_ntk = -1;
805     jj_gen = 0;
806     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
807     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
808   }
809
810   /** Constructor. */
811   public SheetFormulaParser(java.io.Reader stream) {
812     jj_input_stream = new SimpleCharStream(stream, 1, 1);
813     token_source = new SheetFormulaParserTokenManager(jj_input_stream);
814     token = new Token();
815     jj_ntk = -1;
816     jj_gen = 0;
817     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
818     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
819   }
820
821   /** Reinitialise. */
822   public void ReInit(java.io.Reader stream) {
823     jj_input_stream.ReInit(stream, 1, 1);
824     token_source.ReInit(jj_input_stream);
825     token = new Token();
826     jj_ntk = -1;
827     jj_gen = 0;
828     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
829     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
830   }
831
832   /** Constructor with generated Token Manager. */
833   public SheetFormulaParser(SheetFormulaParserTokenManager tm) {
834     token_source = tm;
835     token = new Token();
836     jj_ntk = -1;
837     jj_gen = 0;
838     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
839     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
840   }
841
842   /** Reinitialise. */
843   public void ReInit(SheetFormulaParserTokenManager tm) {
844     token_source = tm;
845     token = new Token();
846     jj_ntk = -1;
847     jj_gen = 0;
848     for (int i = 0; i < 17; i++) jj_la1[i] = -1;
849     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
850   }
851
852   private Token jj_consume_token(int kind) throws ParseException {
853     Token oldToken;
854     if ((oldToken = token).next != null) token = token.next;
855     else token = token.next = token_source.getNextToken();
856     jj_ntk = -1;
857     if (token.kind == kind) {
858       jj_gen++;
859       if (++jj_gc > 100) {
860         jj_gc = 0;
861         for (int i = 0; i < jj_2_rtns.length; i++) {
862           JJCalls c = jj_2_rtns[i];
863           while (c != null) {
864             if (c.gen < jj_gen) c.first = null;
865             c = c.next;
866           }
867         }
868       }
869       return token;
870     }
871     token = oldToken;
872     jj_kind = kind;
873     throw generateParseException();
874   }
875
876   static private final class LookaheadSuccess extends java.lang.Error { }
877   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
878   private boolean jj_scan_token(int kind) {
879     if (jj_scanpos == jj_lastpos) {
880       jj_la--;
881       if (jj_scanpos.next == null) {
882         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
883       } else {
884         jj_lastpos = jj_scanpos = jj_scanpos.next;
885       }
886     } else {
887       jj_scanpos = jj_scanpos.next;
888     }
889     if (jj_rescan) {
890       int i = 0; Token tok = token;
891       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
892       if (tok != null) jj_add_error_token(kind, i);
893     }
894     if (jj_scanpos.kind != kind) return true;
895     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
896     return false;
897   }
898
899
900 /** Get the next Token. */
901   final public Token getNextToken() {
902     if (token.next != null) token = token.next;
903     else token = token.next = token_source.getNextToken();
904     jj_ntk = -1;
905     jj_gen++;
906     return token;
907   }
908
909 /** Get the specific Token. */
910   final public Token getToken(int index) {
911     Token t = token;
912     for (int i = 0; i < index; i++) {
913       if (t.next != null) t = t.next;
914       else t = t.next = token_source.getNextToken();
915     }
916     return t;
917   }
918
919   private int jj_ntk() {
920     if ((jj_nt=token.next) == null)
921       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
922     else
923       return (jj_ntk = jj_nt.kind);
924   }
925
926   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
927   private int[] jj_expentry;
928   private int jj_kind = -1;
929   private int[] jj_lasttokens = new int[100];
930   private int jj_endpos;
931
932   private void jj_add_error_token(int kind, int pos) {
933     if (pos >= 100) return;
934     if (pos == jj_endpos + 1) {
935       jj_lasttokens[jj_endpos++] = kind;
936     } else if (jj_endpos != 0) {
937       jj_expentry = new int[jj_endpos];
938       for (int i = 0; i < jj_endpos; i++) {
939         jj_expentry[i] = jj_lasttokens[i];
940       }
941       jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
942         int[] oldentry = (int[])(it.next());
943         if (oldentry.length == jj_expentry.length) {
944           for (int i = 0; i < jj_expentry.length; i++) {
945             if (oldentry[i] != jj_expentry[i]) {
946               continue jj_entries_loop;
947             }
948           }
949           jj_expentries.add(jj_expentry);
950           break jj_entries_loop;
951         }
952       }
953       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
954     }
955   }
956
957   /** Generate ParseException. */
958   public ParseException generateParseException() {
959     jj_expentries.clear();
960     boolean[] la1tokens = new boolean[47];
961     if (jj_kind >= 0) {
962       la1tokens[jj_kind] = true;
963       jj_kind = -1;
964     }
965     for (int i = 0; i < 17; i++) {
966       if (jj_la1[i] == jj_gen) {
967         for (int j = 0; j < 32; j++) {
968           if ((jj_la1_0[i] & (1<<j)) != 0) {
969             la1tokens[j] = true;
970           }
971           if ((jj_la1_1[i] & (1<<j)) != 0) {
972             la1tokens[32+j] = true;
973           }
974         }
975       }
976     }
977     for (int i = 0; i < 47; i++) {
978       if (la1tokens[i]) {
979         jj_expentry = new int[1];
980         jj_expentry[0] = i;
981         jj_expentries.add(jj_expentry);
982       }
983     }
984     jj_endpos = 0;
985     jj_rescan_token();
986     jj_add_error_token(0, 0);
987     int[][] exptokseq = new int[jj_expentries.size()][];
988     for (int i = 0; i < jj_expentries.size(); i++) {
989       exptokseq[i] = jj_expentries.get(i);
990     }
991     return new ParseException(token, exptokseq, tokenImage);
992   }
993
994   /** Enable tracing. */
995   final public void enable_tracing() {
996   }
997
998   /** Disable tracing. */
999   final public void disable_tracing() {
1000   }
1001
1002   private void jj_rescan_token() {
1003     jj_rescan = true;
1004     for (int i = 0; i < 6; i++) {
1005     try {
1006       JJCalls p = jj_2_rtns[i];
1007       do {
1008         if (p.gen > jj_gen) {
1009           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
1010           switch (i) {
1011             case 0: jj_3_1(); break;
1012             case 1: jj_3_2(); break;
1013             case 2: jj_3_3(); break;
1014             case 3: jj_3_4(); break;
1015             case 4: jj_3_5(); break;
1016             case 5: jj_3_6(); break;
1017           }
1018         }
1019         p = p.next;
1020       } while (p != null);
1021       } catch(LookaheadSuccess ls) { }
1022     }
1023     jj_rescan = false;
1024   }
1025
1026   private void jj_save(int index, int xla) {
1027     JJCalls p = jj_2_rtns[index];
1028     while (p.gen > jj_gen) {
1029       if (p.next == null) { p = p.next = new JJCalls(); break; }
1030       p = p.next;
1031     }
1032     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
1033   }
1034
1035   static final class JJCalls {
1036     int gen;
1037     Token first;
1038     int arg;
1039     JJCalls next;
1040   }
1041
1042 }