001    /* Generated By:JavaCC: Do not edit this line. TelemetryLanguageParserImpl.java */
002      package org.hackystat.telemetry.analyzer.language.parser.impl;
003    
004      import java.util.ArrayList;
005    import java.util.List;
006    
007    import org.hackystat.telemetry.analyzer.language.ast.ChartReference;
008    import org.hackystat.telemetry.analyzer.language.ast.Constant;
009    import org.hackystat.telemetry.analyzer.language.ast.DrawCommand;
010    import org.hackystat.telemetry.analyzer.language.ast.Expression;
011    import org.hackystat.telemetry.analyzer.language.ast.FunctionCall;
012    import org.hackystat.telemetry.analyzer.language.ast.NumberConstant;
013    import org.hackystat.telemetry.analyzer.language.ast.ReducerCall;
014    import org.hackystat.telemetry.analyzer.language.ast.StreamsReference;
015    import org.hackystat.telemetry.analyzer.language.ast.StringConstant;
016    import org.hackystat.telemetry.analyzer.language.ast.TelemetryChartDefinition;
017    import org.hackystat.telemetry.analyzer.language.ast.TelemetryChartYAxisDefinition;
018    import org.hackystat.telemetry.analyzer.language.ast.TelemetryReportDefinition;
019    import org.hackystat.telemetry.analyzer.language.ast.TelemetryStreamsDefinition;
020    import org.hackystat.telemetry.analyzer.language.ast.TextPosition;
021    import org.hackystat.telemetry.analyzer.language.ast.Variable;
022    import org.hackystat.telemetry.analyzer.language.ast.YAxisReference;
023    import org.hackystat.telemetry.analyzer.language.ast.TelemetryChartDefinition.SubChartDefinition;
024    
025      public class TelemetryLanguageParserImpl implements TelemetryLanguageParserImplConstants {
026    
027      final public String identifier() throws ParseException {
028                           Token t;
029        t = jj_consume_token(IDENTIFIER);
030        {if (true) return t.image;}
031        throw new Error("Missing return statement in function");
032      }
033    
034      final public String string_constant() throws ParseException {
035                                @SuppressWarnings("unused")
036                                String str; Token t;
037        jj_consume_token(DOUBLEQUOTE);
038          token_source.SwitchTo(COMMENT);
039        t = jj_consume_token(STRING_INTERNAL);
040          token_source.SwitchTo(DEFAULT);
041        jj_consume_token(DOUBLEQUOTE);
042          {if (true) return t.image;}
043        throw new Error("Missing return statement in function");
044      }
045    
046      final public Number number_constant() throws ParseException {
047                                @SuppressWarnings("unused")
048                                Token t; boolean negative = false; Number number;
049        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
050        case ADD:
051        case SUB:
052          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
053          case ADD:
054            jj_consume_token(ADD);
055            break;
056          case SUB:
057            jj_consume_token(SUB);
058                    negative = true;
059            break;
060          default:
061            jj_la1[0] = jj_gen;
062            jj_consume_token(-1);
063            throw new ParseException();
064          }
065          break;
066        default:
067          jj_la1[1] = jj_gen;
068          
069        }
070        number = non_negative_number_constant();
071         if (negative) {
072           if (number instanceof Integer) {
073             {if (true) return new Integer(0 - number.intValue());}
074           }
075           else {
076             {if (true) return new Double(0.0 - number.doubleValue());}
077           }
078         }
079         else {
080           {if (true) return number;}
081         }
082        throw new Error("Missing return statement in function");
083      }
084    
085      final public Number non_negative_number_constant() throws ParseException {
086                                             Token t;
087        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
088        case NON_NEG_INTEGER:
089          t = jj_consume_token(NON_NEG_INTEGER);
090                                 {if (true) return new Integer(t.image);}
091          break;
092        case NON_NEG_DOUBLE:
093          t = jj_consume_token(NON_NEG_DOUBLE);
094                                 {if (true) return new Double(t.image);}
095          break;
096        default:
097          jj_la1[2] = jj_gen;
098          jj_consume_token(-1);
099          throw new ParseException();
100        }
101        throw new Error("Missing return statement in function");
102      }
103    
104    //==========================================================================
105    //
106    //                           Main Grammar
107    //
108    //==========================================================================
109      @SuppressWarnings("unchecked")
110      final public List all_input() throws ParseException {
111                         List list;
112        list = statements();
113        jj_consume_token(0);
114        {if (true) return list;}
115        throw new Error("Missing return statement in function");
116      }
117    
118      @SuppressWarnings("unchecked")
119      final public List statements() throws ParseException {
120      List list = new ArrayList(2);
121      TelemetryStreamsDefinition streamsDef;
122      TelemetryChartDefinition chartDef;
123      TelemetryReportDefinition reportDef;
124      TelemetryChartYAxisDefinition chartYAxisDef;
125      DrawCommand drawCommand;
126        label_1:
127        while (true) {
128          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
129          case STREAMS:
130            streamsDef = streams_statement();
131                                                       list.add(streamsDef);
132            break;
133          case CHART:
134            chartDef = chart_statement();
135                                                       list.add(chartDef);
136            break;
137          case REPORT:
138            reportDef = report_statement();
139                                                       list.add(reportDef);
140            break;
141          case YAXIS:
142            chartYAxisDef = chart_y_axis_statement();
143                                                       list.add(chartYAxisDef);
144            break;
145          case DRAW:
146            drawCommand = draw_command();
147                                                       list.add(drawCommand);
148            break;
149          default:
150            jj_la1[3] = jj_gen;
151            jj_consume_token(-1);
152            throw new ParseException();
153          }
154          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
155          case STREAMS:
156          case CHART:
157          case REPORT:
158          case DRAW:
159          case YAXIS:
160            
161            break;
162          default:
163            jj_la1[4] = jj_gen;
164            break label_1;
165          }
166        }
167        {if (true) return list;}
168        throw new Error("Missing return statement in function");
169      }
170    
171      final public TelemetryStreamsDefinition streams_statement_input() throws ParseException {
172                                                            TelemetryStreamsDefinition def;
173        def = streams_statement();
174        jj_consume_token(0);
175        {if (true) return def;}
176        throw new Error("Missing return statement in function");
177      }
178    
179      final public TelemetryChartDefinition chart_statement_input() throws ParseException {
180                                                        TelemetryChartDefinition def;
181        def = chart_statement();
182        jj_consume_token(0);
183        {if (true) return def;}
184        throw new Error("Missing return statement in function");
185      }
186    
187      final public TelemetryChartYAxisDefinition chart_y_axis_statement_input() throws ParseException {
188                                                                    TelemetryChartYAxisDefinition def;
189        def = chart_y_axis_statement();
190        jj_consume_token(0);
191        {if (true) return def;}
192        throw new Error("Missing return statement in function");
193      }
194    
195      final public TelemetryReportDefinition report_statement_input() throws ParseException {
196                                                          TelemetryReportDefinition def;
197        def = report_statement();
198        jj_consume_token(0);
199        {if (true) return def;}
200        throw new Error("Missing return statement in function");
201      }
202    
203    //==========================================================================
204    //
205    //                       TelemetryStreamsDefinition
206    //
207    //==========================================================================
208      final public TelemetryStreamsDefinition streams_statement() throws ParseException {
209      String id;
210      String description;
211      Expression expression;
212      Variable[] vars;
213      Token startToken, endToken;
214        startToken = jj_consume_token(STREAMS);
215        id = identifier();
216        jj_consume_token(LPARA);
217        vars = variables();
218        jj_consume_token(RPARA);
219        jj_consume_token(25);
220        jj_consume_token(26);
221        description = streams_description();
222        jj_consume_token(COMMA);
223        expression = streams_definition();
224        jj_consume_token(27);
225        endToken = jj_consume_token(SEMICOLON);
226        try {
227          TextPosition position = new TextPosition(startToken.beginLine, startToken.beginColumn, endToken.endLine, endToken.endColumn);
228          TelemetryStreamsDefinition streamsDef = new TelemetryStreamsDefinition(id, expression, vars, position);
229          streamsDef.setDescription(description);
230          {if (true) return streamsDef;}
231        }
232        catch (Exception ex) {
233          {if (true) throw new ParseException(ex.getMessage());}
234        }
235        throw new Error("Missing return statement in function");
236      }
237    
238      final public String streams_description() throws ParseException {
239                                     String description;
240        description = string_constant();
241        {if (true) return description;}
242        throw new Error("Missing return statement in function");
243      }
244    
245      final public Expression streams_definition() throws ParseException {
246                                       Expression exp;
247        exp = expression();
248        {if (true) return exp;}
249        throw new Error("Missing return statement in function");
250      }
251    
252    //==========================================================================
253    //
254    //                        TelemetryChartYAxis
255    //
256    //==========================================================================
257    //y-axis fileAxis() = {"Size (LOC)", "integer|double", 0, 1000} 
258      final public TelemetryChartYAxisDefinition chart_y_axis_statement() throws ParseException {
259      String id; Variable[] vars; Expression labelParameter; String strLabel;
260      String numberType = TelemetryChartYAxisDefinition.NUMBER_TYPE_AUTO;
261      Number lowerBound = null; Number upperBound = null;
262      Token startToken, endToken;
263        startToken = jj_consume_token(YAXIS);
264        id = identifier();
265        jj_consume_token(LPARA);
266        vars = variables();
267        jj_consume_token(RPARA);
268        jj_consume_token(25);
269        jj_consume_token(26);
270        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
271        case DOUBLEQUOTE:
272          strLabel = string_constant();
273                                             labelParameter = new StringConstant(strLabel);
274          break;
275        case IDENTIFIER:
276          strLabel = identifier();
277                                             labelParameter = new Variable(strLabel);
278          break;
279        default:
280          jj_la1[5] = jj_gen;
281          jj_consume_token(-1);
282          throw new ParseException();
283        }
284        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
285        case COMMA:
286          jj_consume_token(COMMA);
287          numberType = string_constant();
288          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
289          case COMMA:
290            jj_consume_token(COMMA);
291            lowerBound = number_constant();
292            jj_consume_token(COMMA);
293            upperBound = number_constant();
294            break;
295          default:
296            jj_la1[6] = jj_gen;
297            
298          }
299          break;
300        default:
301          jj_la1[7] = jj_gen;
302          
303        }
304        jj_consume_token(27);
305        endToken = jj_consume_token(SEMICOLON);
306        try {
307          TextPosition position = new TextPosition(startToken.beginLine, startToken.beginColumn, endToken.endLine, endToken.endColumn);
308          {if (true) return new TelemetryChartYAxisDefinition(id, vars, labelParameter, numberType, lowerBound, upperBound, position);}
309        }
310        catch (Exception ex) {
311          {if (true) throw new ParseException(ex.getMessage());}
312        }
313        throw new Error("Missing return statement in function");
314      }
315    
316    //==========================================================================
317    //
318    //                        TelemetryChartDefinition
319    //
320    //==========================================================================
321      @SuppressWarnings("unchecked")
322      final public TelemetryChartDefinition chart_statement() throws ParseException {
323      String id;
324      String title;
325      Variable[] vars;
326      List<SubChartDefinition> subCharts;
327      Token startToken, endToken;
328        startToken = jj_consume_token(CHART);
329        id = identifier();
330        jj_consume_token(LPARA);
331        vars = variables();
332        jj_consume_token(RPARA);
333        jj_consume_token(25);
334        jj_consume_token(26);
335        title = chart_title();
336        jj_consume_token(COMMA);
337        subCharts = sub_charts();
338        jj_consume_token(27);
339        endToken = jj_consume_token(SEMICOLON);
340        try {
341          TextPosition position = new TextPosition(startToken.beginLine, startToken.beginColumn, endToken.endLine, endToken.endColumn);
342          {if (true) return new TelemetryChartDefinition(id, title, vars, subCharts, position);}
343        }
344        catch(Exception ex) {
345          {if (true) throw new ParseException(ex.getMessage());}
346        }
347        throw new Error("Missing return statement in function");
348      }
349    
350      final public String chart_title() throws ParseException {
351                             String title;
352        title = string_constant();
353        {if (true) return title;}
354        throw new Error("Missing return statement in function");
355      }
356    
357    //List<TelemetryChartDefinition.SubChartDefinition>
358      @SuppressWarnings("unchecked")
359      final public List sub_charts() throws ParseException {
360                         List list = new ArrayList(); TelemetryChartDefinition.SubChartDefinition subChartDef;
361        subChartDef = sub_chart_definition();
362                                                         list.add(subChartDef);
363        label_2:
364        while (true) {
365          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
366          case COMMA:
367            
368            break;
369          default:
370            jj_la1[8] = jj_gen;
371            break label_2;
372          }
373          jj_consume_token(COMMA);
374          subChartDef = sub_chart_definition();
375                                                         list.add(subChartDef);
376        }
377        {if (true) return list;}
378        throw new Error("Missing return statement in function");
379      }
380    
381      final public TelemetryChartDefinition.SubChartDefinition sub_chart_definition() throws ParseException {
382                                                                          StreamsReference streamsRef; YAxisReference yAxisRef;
383        jj_consume_token(LPARA);
384        streamsRef = streams_reference();
385        jj_consume_token(COMMA);
386        yAxisRef = y_axis_reference();
387        jj_consume_token(RPARA);
388        {if (true) return new TelemetryChartDefinition.SubChartDefinition(streamsRef, yAxisRef);}
389        throw new Error("Missing return statement in function");
390      }
391    
392      final public StreamsReference streams_reference() throws ParseException {
393                                            String id; Expression[] params;
394        id = identifier();
395        jj_consume_token(LPARA);
396        params = variables_and_constants();
397        jj_consume_token(RPARA);
398        {if (true) return new StreamsReference(id, params);}
399        throw new Error("Missing return statement in function");
400      }
401    
402      final public YAxisReference y_axis_reference() throws ParseException {
403                                         String id; Expression[] params;
404        id = identifier();
405        jj_consume_token(LPARA);
406        params = variables_and_constants();
407        jj_consume_token(RPARA);
408        {if (true) return new YAxisReference(id, params);}
409        throw new Error("Missing return statement in function");
410      }
411    
412    //==========================================================================
413    //
414    //                        TelemetryReportDefinition
415    //
416    //==========================================================================
417      @SuppressWarnings("unchecked")
418      final public TelemetryReportDefinition report_statement() throws ParseException {
419      String id;
420      String title;
421      Variable[] vars;
422      List reportDefinition;
423      Token startToken, endToken;
424        startToken = jj_consume_token(REPORT);
425        id = identifier();
426        jj_consume_token(LPARA);
427        vars = variables();
428        jj_consume_token(RPARA);
429        jj_consume_token(25);
430        jj_consume_token(26);
431        title = report_title();
432        jj_consume_token(COMMA);
433        reportDefinition = report_definition();
434        jj_consume_token(27);
435        endToken = jj_consume_token(SEMICOLON);
436        try {
437          TextPosition position = new TextPosition(startToken.beginLine, startToken.beginColumn, endToken.endLine, endToken.endColumn);
438          {if (true) return new TelemetryReportDefinition(id, title, vars, reportDefinition, position);}
439        }
440        catch(Exception ex) {
441          {if (true) throw new ParseException(ex.getMessage());}
442        }
443        throw new Error("Missing return statement in function");
444      }
445    
446      final public String report_title() throws ParseException {
447                             String title;
448        title = string_constant();
449        {if (true) return title;}
450        throw new Error("Missing return statement in function");
451      }
452    
453      @SuppressWarnings("unchecked")
454      final public List report_definition() throws ParseException {
455                                List list = new ArrayList(); ChartReference ref;
456        ref = chart_reference();
457                                list.add(ref);
458        label_3:
459        while (true) {
460          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
461          case COMMA:
462            
463            break;
464          default:
465            jj_la1[9] = jj_gen;
466            break label_3;
467          }
468          jj_consume_token(COMMA);
469          ref = chart_reference();
470          list.add(ref);
471        }
472        {if (true) return list;}
473        throw new Error("Missing return statement in function");
474      }
475    
476      final public ChartReference chart_reference() throws ParseException {
477                                        @SuppressWarnings("unused")
478                                        ChartReference ref; String id; Expression[] params;
479        id = identifier();
480        jj_consume_token(LPARA);
481        params = variables_and_constants();
482        jj_consume_token(RPARA);
483        {if (true) return new ChartReference(id, params);}
484        throw new Error("Missing return statement in function");
485      }
486    
487    //==============================================================================
488    //
489    //                            DrawCommand
490    //
491    //==============================================================================
492      final public DrawCommand draw_command() throws ParseException {
493      String id; Constant[] params; Token startToken, endToken;
494        startToken = jj_consume_token(DRAW);
495        id = identifier();
496        jj_consume_token(LPARA);
497        params = constants();
498        jj_consume_token(RPARA);
499        endToken = jj_consume_token(SEMICOLON);
500        TextPosition position = new TextPosition(startToken.beginLine, startToken.beginColumn, endToken.endLine, endToken.endColumn);
501        {if (true) return new DrawCommand(id, params, position);}
502        throw new Error("Missing return statement in function");
503      }
504    
505    //==========================================================================
506    //
507    //           Expression
508    //
509    //==========================================================================
510      final public Expression expression() throws ParseException {
511                                Expression exp;
512        exp = additive_expression();
513        {if (true) return exp;}
514        throw new Error("Missing return statement in function");
515      }
516    
517      final public Expression additive_expression() throws ParseException {
518                                         Expression exp1, exp2;
519        exp1 = multiplicative_expression();
520        label_4:
521        while (true) {
522          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
523          case ADD:
524          case SUB:
525            
526            break;
527          default:
528            jj_la1[10] = jj_gen;
529            break label_4;
530          }
531          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
532          case ADD:
533            jj_consume_token(ADD);
534            exp2 = multiplicative_expression();
535          exp1 = new FunctionCall("Add", new Expression[]{exp1, exp2});
536            break;
537          case SUB:
538            jj_consume_token(SUB);
539            exp2 = multiplicative_expression();
540          exp1 = new FunctionCall("Sub", new Expression[]{exp1, exp2});
541            break;
542          default:
543            jj_la1[11] = jj_gen;
544            jj_consume_token(-1);
545            throw new ParseException();
546          }
547        }
548        {if (true) return exp1;}
549        throw new Error("Missing return statement in function");
550      }
551    
552      final public Expression multiplicative_expression() throws ParseException {
553                                               Expression exp1, exp2;
554        exp1 = unary_expression();
555        label_5:
556        while (true) {
557          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
558          case MUL:
559          case DIV:
560            
561            break;
562          default:
563            jj_la1[12] = jj_gen;
564            break label_5;
565          }
566          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
567          case MUL:
568            jj_consume_token(MUL);
569            exp2 = unary_expression();
570          exp1 = new FunctionCall("Mul", new Expression[]{exp1, exp2});
571            break;
572          case DIV:
573            jj_consume_token(DIV);
574            exp2 = unary_expression();
575          exp1 = new FunctionCall("Div", new Expression[]{exp1, exp2});
576            break;
577          default:
578            jj_la1[13] = jj_gen;
579            jj_consume_token(-1);
580            throw new ParseException();
581          }
582        }
583        {if (true) return exp1;}
584        throw new Error("Missing return statement in function");
585      }
586    
587      final public Expression unary_expression() throws ParseException {
588                                     Number number; Expression exp;
589        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
590        case NON_NEG_INTEGER:
591        case NON_NEG_DOUBLE:
592          number = non_negative_number_constant();
593                                                      {if (true) return new NumberConstant(number);}
594          break;
595        case LPARA:
596          jj_consume_token(LPARA);
597          exp = expression();
598          jj_consume_token(RPARA);
599                                                      {if (true) return exp;}
600          break;
601        case IDENTIFIER:
602          exp = call();
603                                                      {if (true) return exp;}
604          break;
605        default:
606          jj_la1[14] = jj_gen;
607          jj_consume_token(-1);
608          throw new ParseException();
609        }
610        throw new Error("Missing return statement in function");
611      }
612    
613      final public Expression call() throws ParseException {
614                         String name; Expression[] params;
615        name = identifier();
616        jj_consume_token(LPARA);
617        params = parameters();
618        jj_consume_token(RPARA);
619        //Requirement: ReducerCall cannot have FunctionCall as its parameter
620        //             FunctionCall must have at least one parameter of type ReducerCall or FunctionCall  
621        //We return either ReducerCall or FunctionCall object here.
622    
623        boolean isReducerCall = true;
624        for (int i = 0; i < params.length; i++) {
625          Expression param = params[i];
626          if (param instanceof ReducerCall || param instanceof FunctionCall) {
627            isReducerCall = false;
628            break;
629          }
630        }
631    
632        if (isReducerCall) {
633          {if (true) return new ReducerCall(name, params);}
634        }
635        else {
636          {if (true) return new FunctionCall(name, params);}
637        }
638        throw new Error("Missing return statement in function");
639      }
640    
641      @SuppressWarnings("unchecked")
642      final public Expression[] parameters() throws ParseException {
643                                  ArrayList list = new ArrayList(); Expression exp;
644        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
645        case ADD:
646        case SUB:
647        case LPARA:
648        case DOUBLEQUOTE:
649        case NON_NEG_INTEGER:
650        case NON_NEG_DOUBLE:
651        case IDENTIFIER:
652          exp = parameter();
653                                        list.add(exp);
654          label_6:
655          while (true) {
656            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
657            case COMMA:
658              
659              break;
660            default:
661              jj_la1[15] = jj_gen;
662              break label_6;
663            }
664            jj_consume_token(COMMA);
665            exp = parameter();
666                                        list.add(exp);
667          }
668          break;
669        default:
670          jj_la1[16] = jj_gen;
671          
672        }
673        int size = list.size();
674        Expression[] exps = new Expression[size];
675        for (int i = 0; i < size; i++) {
676          exps[i] = (Expression) list.get(i);
677        }
678        {if (true) return exps;}
679        throw new Error("Missing return statement in function");
680      }
681    
682      final public Expression parameter() throws ParseException {
683                              String str; Number num; Expression exp;
684        if (jj_2_1(2)) {
685          exp = expression();
686                                           {if (true) return exp;}
687        } else {
688          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
689          case IDENTIFIER:
690            str = identifier();
691                                     {if (true) return new Variable(str);}
692            break;
693          case ADD:
694          case SUB:
695          case NON_NEG_INTEGER:
696          case NON_NEG_DOUBLE:
697            num = number_constant();
698                                       {if (true) return new NumberConstant(num);}
699            break;
700          case DOUBLEQUOTE:
701            str = string_constant();
702                                     {if (true) return new StringConstant(str);}
703            break;
704          default:
705            jj_la1[17] = jj_gen;
706            jj_consume_token(-1);
707            throw new ParseException();
708          }
709        }
710        throw new Error("Missing return statement in function");
711      }
712    
713    //==========================================================================
714    //
715    //                       Common Support
716    //
717    //==========================================================================
718      @SuppressWarnings("unchecked")
719      final public Variable[] variables() throws ParseException {
720                              ArrayList list = new ArrayList(); String id;
721        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
722        case IDENTIFIER:
723          id = identifier();
724                              list.add(new Variable(id));
725          label_7:
726          while (true) {
727            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
728            case COMMA:
729              
730              break;
731            default:
732              jj_la1[18] = jj_gen;
733              break label_7;
734            }
735            jj_consume_token(COMMA);
736            id = identifier();
737                                       list.add(new Variable(id));
738          }
739          break;
740        default:
741          jj_la1[19] = jj_gen;
742          
743        }
744        int size = list.size();
745        Variable[] exps = new Variable[size];
746        for (int i = 0; i < size; i++) {
747          exps[i] = (Variable) list.get(i);
748        }
749        {if (true) return exps;}
750        throw new Error("Missing return statement in function");
751      }
752    
753      @SuppressWarnings("unchecked")
754      final public Constant[] constants() throws ParseException {
755                              ArrayList list = new ArrayList(); String str; Number num;
756        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
757        case ADD:
758        case SUB:
759        case DOUBLEQUOTE:
760        case NON_NEG_INTEGER:
761        case NON_NEG_DOUBLE:
762          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
763          case ADD:
764          case SUB:
765          case NON_NEG_INTEGER:
766          case NON_NEG_DOUBLE:
767            num = number_constant();
768                                           list.add(new NumberConstant(num));
769            break;
770          case DOUBLEQUOTE:
771            str = string_constant();
772                                           list.add(new StringConstant(str));
773            break;
774          default:
775            jj_la1[20] = jj_gen;
776            jj_consume_token(-1);
777            throw new ParseException();
778          }
779          label_8:
780          while (true) {
781            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
782            case COMMA:
783              
784              break;
785            default:
786              jj_la1[21] = jj_gen;
787              break label_8;
788            }
789            jj_consume_token(COMMA);
790            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
791            case ADD:
792            case SUB:
793            case NON_NEG_INTEGER:
794            case NON_NEG_DOUBLE:
795              num = number_constant();
796                                             list.add(new NumberConstant(num));
797              break;
798            case DOUBLEQUOTE:
799              str = string_constant();
800                                             list.add(new StringConstant(str));
801              break;
802            default:
803              jj_la1[22] = jj_gen;
804              jj_consume_token(-1);
805              throw new ParseException();
806            }
807          }
808          break;
809        default:
810          jj_la1[23] = jj_gen;
811          
812        }
813        int size = list.size();
814        Constant[] exps = new Constant[size];
815        for (int i = 0; i < size; i++) {
816          exps[i] = (Constant) list.get(i);
817        }
818        {if (true) return exps;}
819        throw new Error("Missing return statement in function");
820      }
821    
822      @SuppressWarnings("unchecked")
823      final public Expression[] variables_and_constants() throws ParseException {
824                                              ArrayList list = new ArrayList(); String str; Number num;
825        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
826        case ADD:
827        case SUB:
828        case DOUBLEQUOTE:
829        case NON_NEG_INTEGER:
830        case NON_NEG_DOUBLE:
831        case IDENTIFIER:
832          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
833          case ADD:
834          case SUB:
835          case NON_NEG_INTEGER:
836          case NON_NEG_DOUBLE:
837            num = number_constant();
838                                           list.add(new NumberConstant(num));
839            break;
840          case DOUBLEQUOTE:
841            str = string_constant();
842                                           list.add(new StringConstant(str));
843            break;
844          case IDENTIFIER:
845            str = identifier();
846                                           list.add(new Variable(str));
847            break;
848          default:
849            jj_la1[24] = jj_gen;
850            jj_consume_token(-1);
851            throw new ParseException();
852          }
853          label_9:
854          while (true) {
855            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
856            case COMMA:
857              
858              break;
859            default:
860              jj_la1[25] = jj_gen;
861              break label_9;
862            }
863            jj_consume_token(COMMA);
864            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
865            case ADD:
866            case SUB:
867            case NON_NEG_INTEGER:
868            case NON_NEG_DOUBLE:
869              num = number_constant();
870                                             list.add(new NumberConstant(num));
871              break;
872            case DOUBLEQUOTE:
873              str = string_constant();
874                                             list.add(new StringConstant(str));
875              break;
876            case IDENTIFIER:
877              str = identifier();
878                                             list.add(new Variable(str));
879              break;
880            default:
881              jj_la1[26] = jj_gen;
882              jj_consume_token(-1);
883              throw new ParseException();
884            }
885          }
886          break;
887        default:
888          jj_la1[27] = jj_gen;
889          
890        }
891        int size = list.size();
892        Expression[] exps = new Expression[size];
893        for (int i = 0; i < size; i++) {
894          exps[i] = (Expression) list.get(i);
895        }
896        {if (true) return exps;}
897        throw new Error("Missing return statement in function");
898      }
899    
900      final private boolean jj_2_1(int xla) {
901        jj_la = xla; jj_lastpos = jj_scanpos = token;
902        try { return !jj_3_1(); }
903        catch(LookaheadSuccess ls) { return true; }
904        finally { jj_save(0, xla); }
905      }
906    
907      final private boolean jj_3R_11() {
908        if (jj_3R_12()) return true;
909        Token xsp;
910        while (true) {
911          xsp = jj_scanpos;
912          if (jj_3R_13()) { jj_scanpos = xsp; break; }
913        }
914        return false;
915      }
916    
917      final private boolean jj_3R_10() {
918        if (jj_3R_11()) return true;
919        return false;
920      }
921    
922      final private boolean jj_3R_24() {
923        if (jj_3R_27()) return true;
924        if (jj_scan_token(LPARA)) return true;
925        return false;
926      }
927    
928      final private boolean jj_3_1() {
929        if (jj_3R_10()) return true;
930        return false;
931      }
932    
933      final private boolean jj_3R_20() {
934        if (jj_3R_24()) return true;
935        return false;
936      }
937    
938      final private boolean jj_3R_19() {
939        if (jj_scan_token(LPARA)) return true;
940        if (jj_3R_10()) return true;
941        return false;
942      }
943    
944      final private boolean jj_3R_14() {
945        Token xsp;
946        xsp = jj_scanpos;
947        if (jj_3R_18()) {
948        jj_scanpos = xsp;
949        if (jj_3R_19()) {
950        jj_scanpos = xsp;
951        if (jj_3R_20()) return true;
952        }
953        }
954        return false;
955      }
956    
957      final private boolean jj_3R_18() {
958        if (jj_3R_23()) return true;
959        return false;
960      }
961    
962      final private boolean jj_3R_22() {
963        if (jj_scan_token(DIV)) return true;
964        return false;
965      }
966    
967      final private boolean jj_3R_27() {
968        if (jj_scan_token(IDENTIFIER)) return true;
969        return false;
970      }
971    
972      final private boolean jj_3R_15() {
973        Token xsp;
974        xsp = jj_scanpos;
975        if (jj_3R_21()) {
976        jj_scanpos = xsp;
977        if (jj_3R_22()) return true;
978        }
979        return false;
980      }
981    
982      final private boolean jj_3R_21() {
983        if (jj_scan_token(MUL)) return true;
984        return false;
985      }
986    
987      final private boolean jj_3R_26() {
988        if (jj_scan_token(NON_NEG_DOUBLE)) return true;
989        return false;
990      }
991    
992      final private boolean jj_3R_23() {
993        Token xsp;
994        xsp = jj_scanpos;
995        if (jj_3R_25()) {
996        jj_scanpos = xsp;
997        if (jj_3R_26()) return true;
998        }
999        return false;
1000      }
1001    
1002      final private boolean jj_3R_25() {
1003        if (jj_scan_token(NON_NEG_INTEGER)) return true;
1004        return false;
1005      }
1006    
1007      final private boolean jj_3R_12() {
1008        if (jj_3R_14()) return true;
1009        Token xsp;
1010        while (true) {
1011          xsp = jj_scanpos;
1012          if (jj_3R_15()) { jj_scanpos = xsp; break; }
1013        }
1014        return false;
1015      }
1016    
1017      final private boolean jj_3R_17() {
1018        if (jj_scan_token(SUB)) return true;
1019        return false;
1020      }
1021    
1022      final private boolean jj_3R_16() {
1023        if (jj_scan_token(ADD)) return true;
1024        return false;
1025      }
1026    
1027      final private boolean jj_3R_13() {
1028        Token xsp;
1029        xsp = jj_scanpos;
1030        if (jj_3R_16()) {
1031        jj_scanpos = xsp;
1032        if (jj_3R_17()) return true;
1033        }
1034        return false;
1035      }
1036    
1037      public TelemetryLanguageParserImplTokenManager token_source;
1038      SimpleCharStream jj_input_stream;
1039      public Token token, jj_nt;
1040      private int jj_ntk;
1041      private Token jj_scanpos, jj_lastpos;
1042      private int jj_la;
1043      public boolean lookingAhead = false;
1044      private int jj_gen;
1045      final private int[] jj_la1 = new int[28];
1046      static private int[] jj_la1_0;
1047      static {
1048          jj_la1_0();
1049       }
1050       private static void jj_la1_0() {
1051          jj_la1_0 = new int[] {0xc00,0xc00,0x180000,0x3e0,0x3e0,0x210000,0x20000,0x20000,0x20000,0x20000,0xc00,0xc00,0x3000,0x3000,0x384000,0x20000,0x394c00,0x390c00,0x20000,0x200000,0x190c00,0x20000,0x190c00,0x190c00,0x390c00,0x20000,0x390c00,0x390c00,};
1052       }
1053      final private JJCalls[] jj_2_rtns = new JJCalls[1];
1054      private boolean jj_rescan = false;
1055      private int jj_gc = 0;
1056    
1057      public TelemetryLanguageParserImpl(java.io.InputStream stream) {
1058         this(stream, null);
1059      }
1060      public TelemetryLanguageParserImpl(java.io.InputStream stream, String encoding) {
1061        try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
1062        token_source = new TelemetryLanguageParserImplTokenManager(jj_input_stream);
1063        token = new Token();
1064        jj_ntk = -1;
1065        jj_gen = 0;
1066        for (int i = 0; i < 28; i++) jj_la1[i] = -1;
1067        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1068      }
1069    
1070      public void ReInit(java.io.InputStream stream) {
1071         ReInit(stream, null);
1072      }
1073      public void ReInit(java.io.InputStream stream, String encoding) {
1074        try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
1075        token_source.ReInit(jj_input_stream);
1076        token = new Token();
1077        jj_ntk = -1;
1078        jj_gen = 0;
1079        for (int i = 0; i < 28; i++) jj_la1[i] = -1;
1080        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1081      }
1082    
1083      public TelemetryLanguageParserImpl(java.io.Reader stream) {
1084        jj_input_stream = new SimpleCharStream(stream, 1, 1);
1085        token_source = new TelemetryLanguageParserImplTokenManager(jj_input_stream);
1086        token = new Token();
1087        jj_ntk = -1;
1088        jj_gen = 0;
1089        for (int i = 0; i < 28; i++) jj_la1[i] = -1;
1090        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1091      }
1092    
1093      public void ReInit(java.io.Reader stream) {
1094        jj_input_stream.ReInit(stream, 1, 1);
1095        token_source.ReInit(jj_input_stream);
1096        token = new Token();
1097        jj_ntk = -1;
1098        jj_gen = 0;
1099        for (int i = 0; i < 28; i++) jj_la1[i] = -1;
1100        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1101      }
1102    
1103      public TelemetryLanguageParserImpl(TelemetryLanguageParserImplTokenManager tm) {
1104        token_source = tm;
1105        token = new Token();
1106        jj_ntk = -1;
1107        jj_gen = 0;
1108        for (int i = 0; i < 28; i++) jj_la1[i] = -1;
1109        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1110      }
1111    
1112      public void ReInit(TelemetryLanguageParserImplTokenManager tm) {
1113        token_source = tm;
1114        token = new Token();
1115        jj_ntk = -1;
1116        jj_gen = 0;
1117        for (int i = 0; i < 28; i++) jj_la1[i] = -1;
1118        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1119      }
1120    
1121      final private Token jj_consume_token(int kind) throws ParseException {
1122        Token oldToken;
1123        if ((oldToken = token).next != null) token = token.next;
1124        else token = token.next = token_source.getNextToken();
1125        jj_ntk = -1;
1126        if (token.kind == kind) {
1127          jj_gen++;
1128          if (++jj_gc > 100) {
1129            jj_gc = 0;
1130            for (int i = 0; i < jj_2_rtns.length; i++) {
1131              JJCalls c = jj_2_rtns[i];
1132              while (c != null) {
1133                if (c.gen < jj_gen) c.first = null;
1134                c = c.next;
1135              }
1136            }
1137          }
1138          return token;
1139        }
1140        token = oldToken;
1141        jj_kind = kind;
1142        throw generateParseException();
1143      }
1144    
1145      @SuppressWarnings("serial")
1146      static private final class LookaheadSuccess extends java.lang.Error { }
1147      final private LookaheadSuccess jj_ls = new LookaheadSuccess();
1148      final private boolean jj_scan_token(int kind) {
1149        if (jj_scanpos == jj_lastpos) {
1150          jj_la--;
1151          if (jj_scanpos.next == null) {
1152            jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
1153          } else {
1154            jj_lastpos = jj_scanpos = jj_scanpos.next;
1155          }
1156        } else {
1157          jj_scanpos = jj_scanpos.next;
1158        }
1159        if (jj_rescan) {
1160          int i = 0; Token tok = token;
1161          while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
1162          if (tok != null) jj_add_error_token(kind, i);
1163        }
1164        if (jj_scanpos.kind != kind) return true;
1165        if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
1166        return false;
1167      }
1168    
1169      final public Token getNextToken() {
1170        if (token.next != null) token = token.next;
1171        else token = token.next = token_source.getNextToken();
1172        jj_ntk = -1;
1173        jj_gen++;
1174        return token;
1175      }
1176    
1177      final public Token getToken(int index) {
1178        Token t = lookingAhead ? jj_scanpos : token;
1179        for (int i = 0; i < index; i++) {
1180          if (t.next != null) t = t.next;
1181          else t = t.next = token_source.getNextToken();
1182        }
1183        return t;
1184      }
1185    
1186      final private int jj_ntk() {
1187        if ((jj_nt=token.next) == null)
1188          return (jj_ntk = (token.next=token_source.getNextToken()).kind);
1189        else
1190          return (jj_ntk = jj_nt.kind);
1191      }
1192    
1193      @SuppressWarnings("unchecked")
1194      private java.util.Vector jj_expentries = new java.util.Vector();
1195      private int[] jj_expentry;
1196      private int jj_kind = -1;
1197      private int[] jj_lasttokens = new int[100];
1198      private int jj_endpos;
1199    
1200      @SuppressWarnings("unchecked")
1201      private void jj_add_error_token(int kind, int pos) {
1202        if (pos >= 100) return;
1203        if (pos == jj_endpos + 1) {
1204          jj_lasttokens[jj_endpos++] = kind;
1205        } else if (jj_endpos != 0) {
1206          jj_expentry = new int[jj_endpos];
1207          for (int i = 0; i < jj_endpos; i++) {
1208            jj_expentry[i] = jj_lasttokens[i];
1209          }
1210          boolean exists = false;
1211          for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
1212            int[] oldentry = (int[])(e.nextElement());
1213            if (oldentry.length == jj_expentry.length) {
1214              exists = true;
1215              for (int i = 0; i < jj_expentry.length; i++) {
1216                if (oldentry[i] != jj_expentry[i]) {
1217                  exists = false;
1218                  break;
1219                }
1220              }
1221              if (exists) break;
1222            }
1223          }
1224          if (!exists) jj_expentries.addElement(jj_expentry);
1225          if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
1226        }
1227      }
1228    
1229      @SuppressWarnings("unchecked")
1230      public ParseException generateParseException() {
1231        jj_expentries.removeAllElements();
1232        boolean[] la1tokens = new boolean[28];
1233        for (int i = 0; i < 28; i++) {
1234          la1tokens[i] = false;
1235        }
1236        if (jj_kind >= 0) {
1237          la1tokens[jj_kind] = true;
1238          jj_kind = -1;
1239        }
1240        for (int i = 0; i < 28; i++) {
1241          if (jj_la1[i] == jj_gen) {
1242            for (int j = 0; j < 32; j++) {
1243              if ((jj_la1_0[i] & (1<<j)) != 0) {
1244                la1tokens[j] = true;
1245              }
1246            }
1247          }
1248        }
1249        for (int i = 0; i < 28; i++) {
1250          if (la1tokens[i]) {
1251            jj_expentry = new int[1];
1252            jj_expentry[0] = i;
1253            jj_expentries.addElement(jj_expentry);
1254          }
1255        }
1256        jj_endpos = 0;
1257        jj_rescan_token();
1258        jj_add_error_token(0, 0);
1259        int[][] exptokseq = new int[jj_expentries.size()][];
1260        for (int i = 0; i < jj_expentries.size(); i++) {
1261          exptokseq[i] = (int[])jj_expentries.elementAt(i);
1262        }
1263        return new ParseException(token, exptokseq, tokenImage);
1264      }
1265    
1266      final public void enable_tracing() {
1267      }
1268    
1269      final public void disable_tracing() {
1270      }
1271    
1272      final private void jj_rescan_token() {
1273        jj_rescan = true;
1274        for (int i = 0; i < 1; i++) {
1275        try {
1276          JJCalls p = jj_2_rtns[i];
1277          do {
1278            if (p.gen > jj_gen) {
1279              jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
1280              switch (i) {
1281                case 0: jj_3_1(); break;
1282              }
1283            }
1284            p = p.next;
1285          } while (p != null);
1286          } catch(LookaheadSuccess ls) { }
1287        }
1288        jj_rescan = false;
1289      }
1290    
1291      final private void jj_save(int index, int xla) {
1292        JJCalls p = jj_2_rtns[index];
1293        while (p.gen > jj_gen) {
1294          if (p.next == null) { p = p.next = new JJCalls(); break; }
1295          p = p.next;
1296        }
1297        p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
1298      }
1299    
1300      static final class JJCalls {
1301        int gen;
1302        Token first;
1303        int arg;
1304        JJCalls next;
1305      }
1306    
1307      }