?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial import into git.
[galago.git] / java / pig-galago / src / com / yahoo / pig / impl / logicalLayer / parser / QueryParser.java
blob44dae74002293e33d2508b56d826d836e322f482
1 /* Generated By:JJTree&JavaCC: Do not edit this line. QueryParser.java */
2 package com.yahoo.pig.impl.logicalLayer.parser;
3 import java.io.*;
4 import java.util.*;
5 import java.lang.reflect.*;
6 import com.yahoo.pig.impl.logicalLayer.*;
7 import com.yahoo.pig.impl.eval.*;
8 import com.yahoo.pig.impl.eval.func.*;
9 import com.yahoo.pig.impl.eval.groupby.*;
10 import com.yahoo.pig.impl.eval.filter.*;
11 import com.yahoo.pig.impl.eval.window.*;
12 import com.yahoo.pig.impl.eval.sad.*;
13 import com.yahoo.pig.impl.logicalLayer.schema.*;
14 import com.yahoo.pig.*;
15 import com.yahoo.pig.impl.PigContext;
16 import com.yahoo.pig.PigServer.ExecType;
17 import com.yahoo.pig.impl.physicalLayer.IntermedResult;
18 import com.yahoo.pig.impl.io.FileLocalizer;
19 import com.yahoo.pig.builtin.*;
20 public class QueryParser/*@bgen(jjtree)*/implements QueryParserTreeConstants, QueryParserConstants {/*@bgen(jjtree)*/
21 protected JJTQueryParserState jjtree = new JJTQueryParserState();private PigContext pigContext;
22 private Map<String, IntermedResult> aliases;
23
24 public QueryParser(InputStream in, PigContext pigContext, Map aliases) {
25 this(in);
26 this.pigContext = pigContext;
27 this.aliases = aliases;
28 }
29
30 public class EvalSpecPipeAndSchema{
31 EvalSpecPipe pipe;
32 SchemaItemList schema;
33 }
34
35 public class CogroupInput {
36 public LogicalOperator op;
37 public GroupBySpec spec;
38 }
39
40 static String unquote(String s) {
41 return s.substring(1, s.length()-1);
42 }
43
44 static int undollar(String s) {
45 return Integer.parseInt(s.substring(1, s.length()));
46 }
47
48 NestableEvalItem newFuncEvalItem(EvalFunc func, EvalItemList args) throws ParseException {
49 if (func instanceof AtomEvalFunc) return new AtomFuncEvalItem(pigContext, (AtomEvalFunc) func, args);
50 else if (func instanceof TupleEvalFunc) return new TupleFuncEvalItem(pigContext, (TupleEvalFunc) func, args);
51 else if (func instanceof BagEvalFunc) return new BagFuncEvalItem(pigContext, (BagEvalFunc) func, args);
52 else throw new ParseException("Error: unknown Eval Function type: " + func.getClass().getName());
53 }
54
55
56 LogicalOperator makeLORead(String alias) throws ParseException {
57 if (!aliases.containsKey(alias)) throw new ParseException("Unrecognized alias: " + alias);
58
59 LORead readOp = new LORead(pigContext, aliases.get(alias));
60 readOp.alias = alias;
61 return readOp;
62 }
63
64
65
66 String massageFilename(String filename) throws IOException {
67 if (pigContext.getExecType() != ExecType.LOCAL) {
68 if (filename.startsWith(FileLocalizer.LOCAL_PREFIX)) {
69 filename = FileLocalizer.hadoopify(filename);
70 } else {
71 if (filename.startsWith(FileLocalizer.HADOOP_PREFIX)) {
72 filename = filename.substring(FileLocalizer.HADOOP_PREFIX.length());
73 }
74 }
75 }
76
77 return filename;
78 }
79
80 LogicalOperator parseCogroup(ArrayList<CogroupInput> gis) throws ParseException{
81 int n = gis.size();
82
83 LogicalOperator[] los = new LogicalOperator[n];
84 GroupBySpec[] specs = new GroupBySpec[n];
85
86 for (int i = 0; i < n ; i++){
87
88 CogroupInput gi = gis.get(i);
89 los[i] = gi.op;
90 specs[i] = gi.spec;
91 }
92
93 return new LOCogroup(pigContext, los, specs);
94 }
95
96
97 LogicalOperator rewriteCross(ArrayList<LogicalOperator> inputs) throws IOException, ParseException{
98 ArrayList<CogroupInput> gis = new ArrayList<CogroupInput>();
99 Iterator<LogicalOperator> iter = inputs.iterator();
100 int n = inputs.size();
101
102 EvalSpecPipe pipe = new EvalSpecPipe(pigContext);
103 EvalItemList list = new EvalItemList(pigContext);
104 pipe.add(list);
105 for (int i=0; i< n; i++){
106
107 CogroupInput gi = new CogroupInput();
108 gis.add(gi);
109
110 gi.op = inputs.get(i);
111 EvalItemList itemList = new EvalItemList(pigContext);
112 itemList.add(new ConstEvalItem(pigContext, n+""));
113 itemList.add(new ConstEvalItem(pigContext, i+""));
114 gi.spec = new GroupBySpec(pigContext, (GroupFunc) pigContext.getUDF(GFCross.class.getName()), itemList, false);
115
116 ColEvalItem item = new ColEvalItem(pigContext, i+1);
117 EvalItemList subSpec = new EvalItemList(pigContext);
118 subSpec.add(new StarEvalItem(pigContext));
119 item.subColSpec = subSpec;
120
121 list.add(item);
122 }
123
124 return new LOEval(pigContext, parseCogroup(gis),pipe);
125 }
126
127 LOLoad getDefaultLoadOperator(boolean continuous, String filename) throws IOException{
128
129 String[] args = null;
130 /*
131 if (continuous){
132 args = new String[2];
133 args[0]="\t";
134 args[1]="0";
135 }
136 */
137 StorageFunc loadFunc = (StorageFunc) pigContext.getUDF(PigStorage.class.getName());
138 return new LOLoad(pigContext, massageFilename(filename), loadFunc, args);
139 }
140
141 void assertAtomic(EvalItem item, boolean desiredAtomic) throws ParseException{
142 Boolean isAtomic = null;
143 if (item instanceof ConstEvalItem || item instanceof AtomFuncEvalItem)
144 isAtomic = true;
145 else if (item instanceof FuncEvalItem)
146 isAtomic = false;
147
148 if (isAtomic != null && isAtomic != desiredAtomic){
149 if (desiredAtomic)
150 throw new ParseException("Atomic field expected but found non-atomic field");
151 else
152 throw new ParseException("Non-atomic field expected but found atomic field");
153 }
154 }
155
156 EvalItem copyItemAndAddSpec(EvalItem item, EvalSpec spec) throws ParseException{
157 assertAtomic(item,false);
158 item = item.copy();
159 if (!(item instanceof NestableEvalItem))
160 throw new ParseException("Internal Error: Cannot add spec to non-nestable field.");
161 NestableEvalItem nestableItem = (NestableEvalItem)item;
162 EvalSpecPipe specPipe = nestableItem.nestedEval;
163 nestableItem.addNestedEvalSpec(spec);
164 return item;
165 }
166
167 // Parse is the Starting function.
168 final public LogicalPlan Parse() throws ParseException {
169 /*@bgen(jjtree) Parse */
170 SimpleNode jjtn000 = new SimpleNode(JJTPARSE);
171 boolean jjtc000 = true;
172 jjtree.openNodeScope(jjtn000);LogicalOperator root; Token t1;
173 try {
174 if (jj_2_1(2)) {
175 t1 = jj_consume_token(IDENTIFIER);
176 jj_consume_token(52);
177 root = Expr();
178 jj_consume_token(53);
179 root.alias = t1.image;
180 } else {
181 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
182 case LOAD:
183 case FILTER:
184 case FOREACH:
185 case COGROUP:
186 case CROSS:
187 case UNION:
188 case GROUP:
189 case IDENTIFIER:
190 case 54:
191 root = Expr();
192 jj_consume_token(53);
193 break;
194 default:
195 jj_la1[0] = jj_gen;
196 jj_consume_token(-1);
197 throw new ParseException();
198 }
199 }
200 jjtree.closeNodeScope(jjtn000, true);
201 jjtc000 = false;
202 {if (true) return new LogicalPlan(root, pigContext);}
203 } catch (Throwable jjte000) {
204 if (jjtc000) {
205 jjtree.clearNodeScope(jjtn000);
206 jjtc000 = false;
207 } else {
208 jjtree.popNode();
209 }
210 if (jjte000 instanceof RuntimeException) {
211 {if (true) throw (RuntimeException)jjte000;}
212 }
213 if (jjte000 instanceof ParseException) {
214 {if (true) throw (ParseException)jjte000;}
215 }
216 {if (true) throw (Error)jjte000;}
217 } finally {
218 if (jjtc000) {
219 jjtree.closeNodeScope(jjtn000, true);
220 }
221 }
222 throw new Error("Missing return statement in function");
223 }
224
225 final public LogicalOperator Expr() throws ParseException {
226 /*@bgen(jjtree) Expr */
227 SimpleNode jjtn000 = new SimpleNode(JJTEXPR);
228 boolean jjtc000 = true;
229 jjtree.openNodeScope(jjtn000);LogicalOperator op; SchemaItemList schema;
230 try {
231 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
232 case IDENTIFIER:
233 case 54:
234 op = NestedExpr();
235 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
236 case AS:
237 jj_consume_token(AS);
238 schema = AsClause();
239 op.schema=schema;
240 break;
241 default:
242 jj_la1[1] = jj_gen;
243 ;
244 }
245 break;
246 case LOAD:
247 case FILTER:
248 case FOREACH:
249 case COGROUP:
250 case CROSS:
251 case UNION:
252 case GROUP:
253 op = BaseExpr();
254 break;
255 default:
256 jj_la1[2] = jj_gen;
257 jj_consume_token(-1);
258 throw new ParseException();
259 }
260 jjtree.closeNodeScope(jjtn000, true);
261 jjtc000 = false;
262 {if (true) return op;}
263 } catch (Throwable jjte000) {
264 if (jjtc000) {
265 jjtree.clearNodeScope(jjtn000);
266 jjtc000 = false;
267 } else {
268 jjtree.popNode();
269 }
270 if (jjte000 instanceof RuntimeException) {
271 {if (true) throw (RuntimeException)jjte000;}
272 }
273 if (jjte000 instanceof ParseException) {
274 {if (true) throw (ParseException)jjte000;}
275 }
276 {if (true) throw (Error)jjte000;}
277 } finally {
278 if (jjtc000) {
279 jjtree.closeNodeScope(jjtn000, true);
280 }
281 }
282 throw new Error("Missing return statement in function");
283 }
284
285 final public LogicalOperator NestedExpr() throws ParseException {
286 /*@bgen(jjtree) NestedExpr */
287 SimpleNode jjtn000 = new SimpleNode(JJTNESTEDEXPR);
288 boolean jjtc000 = true;
289 jjtree.openNodeScope(jjtn000);LogicalOperator op;
290 try {
291 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
292 case IDENTIFIER:
293 op = Alias();
294 break;
295 default:
296 jj_la1[3] = jj_gen;
297 if (jj_2_2(2)) {
298 jj_consume_token(54);
299 op = NestedExpr();
300 jj_consume_token(55);
301 } else {
302 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
303 case 54:
304 jj_consume_token(54);
305 op = BaseExpr();
306 jj_consume_token(55);
307 break;
308 default:
309 jj_la1[4] = jj_gen;
310 jj_consume_token(-1);
311 throw new ParseException();
312 }
313 }
314 }
315 jjtree.closeNodeScope(jjtn000, true);
316 jjtc000 = false;
317 {if (true) return op;}
318 } catch (Throwable jjte000) {
319 if (jjtc000) {
320 jjtree.clearNodeScope(jjtn000);
321 jjtc000 = false;
322 } else {
323 jjtree.popNode();
324 }
325 if (jjte000 instanceof RuntimeException) {
326 {if (true) throw (RuntimeException)jjte000;}
327 }
328 if (jjte000 instanceof ParseException) {
329 {if (true) throw (ParseException)jjte000;}
330 }
331 {if (true) throw (Error)jjte000;}
332 } finally {
333 if (jjtc000) {
334 jjtree.closeNodeScope(jjtn000, true);
335 }
336 }
337 throw new Error("Missing return statement in function");
338 }
339
340 // A reference to an alias
341 final public LogicalOperator Alias() throws ParseException {
342 /*@bgen(jjtree) Alias */
343 SimpleNode jjtn000 = new SimpleNode(JJTALIAS);
344 boolean jjtc000 = true;
345 jjtree.openNodeScope(jjtn000);Token t1; LogicalOperator op;
346 try {
347 t1 = jj_consume_token(IDENTIFIER);
348 jjtree.closeNodeScope(jjtn000, true);
349 jjtc000 = false;
350 op = makeLORead(t1.image);
351 {if (true) return op;}
352 } finally {
353 if (jjtc000) {
354 jjtree.closeNodeScope(jjtn000, true);
355 }
356 }
357 throw new Error("Missing return statement in function");
358 }
359
360 final public LogicalOperator BaseExpr() throws ParseException {
361 /*@bgen(jjtree) BaseExpr */
362 SimpleNode jjtn000 = new SimpleNode(JJTBASEEXPR);
363 boolean jjtc000 = true;
364 jjtree.openNodeScope(jjtn000);LogicalOperator op; SchemaItemList schema; Token t1, t2;
365 try {
366 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
367 case LOAD:
368 jj_consume_token(LOAD);
369 op = LoadClause();
370 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
371 case AS:
372 jj_consume_token(AS);
373 schema = AsClause();
374 op.schema=schema;
375 break;
376 default:
377 jj_la1[5] = jj_gen;
378 ;
379 }
380 break;
381 case COGROUP:
382 case GROUP:
383 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
384 case GROUP:
385 jj_consume_token(GROUP);
386 break;
387 case COGROUP:
388 jj_consume_token(COGROUP);
389 break;
390 default:
391 jj_la1[6] = jj_gen;
392 jj_consume_token(-1);
393 throw new ParseException();
394 }
395 op = CogroupClause();
396 break;
397 case FILTER:
398 jj_consume_token(FILTER);
399 op = FilterClause();
400 break;
401 case CROSS:
402 jj_consume_token(CROSS);
403 op = CrossClause();
404 break;
405 case UNION:
406 jj_consume_token(UNION);
407 op = UnionClause();
408 break;
409 case FOREACH:
410 jj_consume_token(FOREACH);
411 op = ForEachClause();
412 break;
413 default:
414 jj_la1[7] = jj_gen;
415 jj_consume_token(-1);
416 throw new ParseException();
417 }
418 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
419 case PARALLEL:
420 jj_consume_token(PARALLEL);
421 t2 = jj_consume_token(NUMBER);
422 op.requestedParallelism = Integer.parseInt(t2.image);
423 break;
424 default:
425 jj_la1[8] = jj_gen;
426 ;
427 }
428 jjtree.closeNodeScope(jjtn000, true);
429 jjtc000 = false;
430 {if (true) return op;}
431 } catch (Throwable jjte000) {
432 if (jjtc000) {
433 jjtree.clearNodeScope(jjtn000);
434 jjtc000 = false;
435 } else {
436 jjtree.popNode();
437 }
438 if (jjte000 instanceof RuntimeException) {
439 {if (true) throw (RuntimeException)jjte000;}
440 }
441 if (jjte000 instanceof ParseException) {
442 {if (true) throw (ParseException)jjte000;}
443 }
444 {if (true) throw (Error)jjte000;}
445 } finally {
446 if (jjtc000) {
447 jjtree.closeNodeScope(jjtn000, true);
448 }
449 }
450 throw new Error("Missing return statement in function");
451 }
452
453 final public LogicalOperator LoadClause() throws ParseException {
454 /*@bgen(jjtree) LoadClause */
455 SimpleNode jjtn000 = new SimpleNode(JJTLOADCLAUSE);
456 boolean jjtc000 = true;
457 jjtree.openNodeScope(jjtn000);Token t1, t2; String filename; StorageFunc loadFunc = null;
458 ArrayList<String> loadParams = new ArrayList<String>(); LOLoad lo=null; boolean continuous=false;
459 try {
460 t1 = jj_consume_token(QUOTEDSTRING);
461 filename = unquote(t1.image);
462 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
463 case USING:
464 jj_consume_token(USING);
465 loadFunc = LoadFunction();
466 jj_consume_token(54);
467 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
468 case QUOTEDSTRING:
469 t2 = jj_consume_token(QUOTEDSTRING);
470 loadParams.add(t2.image);
471 break;
472 default:
473 jj_la1[9] = jj_gen;
474 ;
475 }
476 label_1:
477 while (true) {
478 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
479 case 56:
480 ;
481 break;
482 default:
483 jj_la1[10] = jj_gen;
484 break label_1;
485 }
486 jj_consume_token(56);
487 t2 = jj_consume_token(QUOTEDSTRING);
488 loadParams.add(t2.image);
489 }
490 jj_consume_token(55);
491 lo = new LOLoad(pigContext, massageFilename(filename), loadFunc, loadParams);
492 break;
493 default:
494 jj_la1[11] = jj_gen;
495 ;
496 }
497 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
498 case CONTINUOUSLY:
499 jj_consume_token(CONTINUOUSLY);
500 continuous=true;
501 break;
502 default:
503 jj_la1[12] = jj_gen;
504 ;
505 }
506 jjtree.closeNodeScope(jjtn000, true);
507 jjtc000 = false;
508 if (lo == null){
509 lo = getDefaultLoadOperator(continuous,filename);
510 }
511 if (continuous)
512 lo.setOutputType(LogicalOperator.MONOTONE);
513 {if (true) return lo;}
514 } catch (Throwable jjte000) {
515 if (jjtc000) {
516 jjtree.clearNodeScope(jjtn000);
517 jjtc000 = false;
518 } else {
519 jjtree.popNode();
520 }
521 if (jjte000 instanceof RuntimeException) {
522 {if (true) throw (RuntimeException)jjte000;}
523 }
524 if (jjte000 instanceof ParseException) {
525 {if (true) throw (ParseException)jjte000;}
526 }
527 {if (true) throw (Error)jjte000;}
528 } finally {
529 if (jjtc000) {
530 jjtree.closeNodeScope(jjtn000, true);
531 }
532 }
533 throw new Error("Missing return statement in function");
534 }
535
536 final public LogicalOperator FilterClause() throws ParseException {
537 /*@bgen(jjtree) FilterClause */
538 SimpleNode jjtn000 = new SimpleNode(JJTFILTERCLAUSE);
539 boolean jjtc000 = true;
540 jjtree.openNodeScope(jjtn000);Cond cond; LogicalOperator input;
541 try {
542 input = NestedExpr();
543 jj_consume_token(BY);
544 cond = PCond(input.outputSchema(),null);
545 jjtree.closeNodeScope(jjtn000, true);
546 jjtc000 = false;
547 EvalSpecPipe specPipe = new EvalSpecPipe(pigContext);
548 specPipe.add(new FilterSpec(cond));
549 {if (true) return new LOEval(pigContext, input, specPipe);}
550 } catch (Throwable jjte000) {
551 if (jjtc000) {
552 jjtree.clearNodeScope(jjtn000);
553 jjtc000 = false;
554 } else {
555 jjtree.popNode();
556 }
557 if (jjte000 instanceof RuntimeException) {
558 {if (true) throw (RuntimeException)jjte000;}
559 }
560 if (jjte000 instanceof ParseException) {
561 {if (true) throw (ParseException)jjte000;}
562 }
563 {if (true) throw (Error)jjte000;}
564 } finally {
565 if (jjtc000) {
566 jjtree.closeNodeScope(jjtn000, true);
567 }
568 }
569 throw new Error("Missing return statement in function");
570 }
571
572 final public Cond PCond(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
573 /*@bgen(jjtree) PCond */
574 SimpleNode jjtn000 = new SimpleNode(JJTPCOND);
575 boolean jjtc000 = true;
576 jjtree.openNodeScope(jjtn000);Cond cond = null;
577 try {
578 cond = POrCond(over,pipes);
579 jjtree.closeNodeScope(jjtn000, true);
580 jjtc000 = false;
581 {if (true) return cond;}
582 } catch (Throwable jjte000) {
583 if (jjtc000) {
584 jjtree.clearNodeScope(jjtn000);
585 jjtc000 = false;
586 } else {
587 jjtree.popNode();
588 }
589 if (jjte000 instanceof RuntimeException) {
590 {if (true) throw (RuntimeException)jjte000;}
591 }
592 if (jjte000 instanceof ParseException) {
593 {if (true) throw (ParseException)jjte000;}
594 }
595 {if (true) throw (Error)jjte000;}
596 } finally {
597 if (jjtc000) {
598 jjtree.closeNodeScope(jjtn000, true);
599 }
600 }
601 throw new Error("Missing return statement in function");
602 }
603
604 final public Cond POrCond(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
605 /*@bgen(jjtree) POrCond */
606 SimpleNode jjtn000 = new SimpleNode(JJTPORCOND);
607 boolean jjtc000 = true;
608 jjtree.openNodeScope(jjtn000);Cond cond; List<Cond> cList = new ArrayList<Cond>();
609 try {
610 cond = PAndCond(over,pipes);
611 cList.add(cond);
612 label_2:
613 while (true) {
614 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
615 case OR:
616 ;
617 break;
618 default:
619 jj_la1[13] = jj_gen;
620 break label_2;
621 }
622 jj_consume_token(OR);
623 cond = PAndCond(over,pipes);
624 cList.add(cond);
625 }
626 jjtree.closeNodeScope(jjtn000, true);
627 jjtc000 = false;
628 if (cList.size()==1)
629 {if (true) return cond;}
630 else
631 {if (true) return new OrCond(cList);}
632 } catch (Throwable jjte000) {
633 if (jjtc000) {
634 jjtree.clearNodeScope(jjtn000);
635 jjtc000 = false;
636 } else {
637 jjtree.popNode();
638 }
639 if (jjte000 instanceof RuntimeException) {
640 {if (true) throw (RuntimeException)jjte000;}
641 }
642 if (jjte000 instanceof ParseException) {
643 {if (true) throw (ParseException)jjte000;}
644 }
645 {if (true) throw (Error)jjte000;}
646 } finally {
647 if (jjtc000) {
648 jjtree.closeNodeScope(jjtn000, true);
649 }
650 }
651 throw new Error("Missing return statement in function");
652 }
653
654 final public Cond PAndCond(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
655 /*@bgen(jjtree) PAndCond */
656 SimpleNode jjtn000 = new SimpleNode(JJTPANDCOND);
657 boolean jjtc000 = true;
658 jjtree.openNodeScope(jjtn000);Cond cond = null; List<Cond> cList = new ArrayList<Cond>();
659 try {
660 cond = PUnaryCond(over,pipes);
661 cList.add(cond);
662 label_3:
663 while (true) {
664 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
665 case AND:
666 ;
667 break;
668 default:
669 jj_la1[14] = jj_gen;
670 break label_3;
671 }
672 jj_consume_token(AND);
673 cond = PUnaryCond(over,pipes);
674 cList.add(cond);
675 }
676 jjtree.closeNodeScope(jjtn000, true);
677 jjtc000 = false;
678 if (cList.size()==1)
679 {if (true) return cond;}
680 else
681 {if (true) return new AndCond(cList);}
682 } catch (Throwable jjte000) {
683 if (jjtc000) {
684 jjtree.clearNodeScope(jjtn000);
685 jjtc000 = false;
686 } else {
687 jjtree.popNode();
688 }
689 if (jjte000 instanceof RuntimeException) {
690 {if (true) throw (RuntimeException)jjte000;}
691 }
692 if (jjte000 instanceof ParseException) {
693 {if (true) throw (ParseException)jjte000;}
694 }
695 {if (true) throw (Error)jjte000;}
696 } finally {
697 if (jjtc000) {
698 jjtree.closeNodeScope(jjtn000, true);
699 }
700 }
701 throw new Error("Missing return statement in function");
702 }
703
704 final public Cond PUnaryCond(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
705 /*@bgen(jjtree) PUnaryCond */
706 SimpleNode jjtn000 = new SimpleNode(JJTPUNARYCOND);
707 boolean jjtc000 = true;
708 jjtree.openNodeScope(jjtn000);Cond cond = null; EvalItem c1, c2; Token t1; FilterFunc func; EvalItemList args;
709 try {
710 if (jj_2_3(2147483647)) {
711 jj_consume_token(54);
712 cond = PCond(over,pipes);
713 jj_consume_token(55);
714 } else if (jj_2_4(2147483647)) {
715 func = FilterFunction();
716 jj_consume_token(54);
717 args = EvalArgs(over,pipes);
718 jj_consume_token(55);
719 cond = new FuncCond(func, args);
720 } else {
721 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
722 case NOT:
723 cond = PNotCond(over,pipes);
724 break;
725 default:
726 jj_la1[15] = jj_gen;
727 if (jj_2_5(2147483647)) {
728 c1 = InfixExpr(over,pipes);
729 t1 = jj_consume_token(FILTEROP);
730 c2 = InfixExpr(over,pipes);
731 cond = new CompCond(c1, t1.image, c2);
732 } else if (jj_2_6(2)) {
733 c1 = InfixExpr(over,pipes);
734 jj_consume_token(MATCHES);
735 t1 = jj_consume_token(QUOTEDSTRING);
736 cond = new RegexpCond(c1, unquote(t1.image));
737 } else {
738 jj_consume_token(-1);
739 throw new ParseException();
740 }
741 }
742 }
743 jjtree.closeNodeScope(jjtn000, true);
744 jjtc000 = false;
745 {if (true) return cond;}
746 } catch (Throwable jjte000) {
747 if (jjtc000) {
748 jjtree.clearNodeScope(jjtn000);
749 jjtc000 = false;
750 } else {
751 jjtree.popNode();
752 }
753 if (jjte000 instanceof RuntimeException) {
754 {if (true) throw (RuntimeException)jjte000;}
755 }
756 if (jjte000 instanceof ParseException) {
757 {if (true) throw (ParseException)jjte000;}
758 }
759 {if (true) throw (Error)jjte000;}
760 } finally {
761 if (jjtc000) {
762 jjtree.closeNodeScope(jjtn000, true);
763 }
764 }
765 throw new Error("Missing return statement in function");
766 }
767
768 final public Cond PNotCond(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
769 /*@bgen(jjtree) PNotCond */
770 SimpleNode jjtn000 = new SimpleNode(JJTPNOTCOND);
771 boolean jjtc000 = true;
772 jjtree.openNodeScope(jjtn000);Cond c1;
773 try {
774 jj_consume_token(NOT);
775 c1 = PUnaryCond(over,pipes);
776 jjtree.closeNodeScope(jjtn000, true);
777 jjtc000 = false;
778 {if (true) return new NotCond(c1);}
779 } catch (Throwable jjte000) {
780 if (jjtc000) {
781 jjtree.clearNodeScope(jjtn000);
782 jjtc000 = false;
783 } else {
784 jjtree.popNode();
785 }
786 if (jjte000 instanceof RuntimeException) {
787 {if (true) throw (RuntimeException)jjte000;}
788 }
789 if (jjte000 instanceof ParseException) {
790 {if (true) throw (ParseException)jjte000;}
791 }
792 {if (true) throw (Error)jjte000;}
793 } finally {
794 if (jjtc000) {
795 jjtree.closeNodeScope(jjtn000, true);
796 }
797 }
798 throw new Error("Missing return statement in function");
799 }
800
801 final public LogicalOperator CogroupClause() throws ParseException {
802 /*@bgen(jjtree) CogroupClause */
803 SimpleNode jjtn000 = new SimpleNode(JJTCOGROUPCLAUSE);
804 boolean jjtc000 = true;
805 jjtree.openNodeScope(jjtn000);CogroupInput gi; ArrayList<CogroupInput> gis = new ArrayList<CogroupInput>();
806 try {
807 gi = GroupItem();
808 gis.add(gi);
809 label_4:
810 while (true) {
811 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
812 case 56:
813 ;
814 break;
815 default:
816 jj_la1[16] = jj_gen;
817 break label_4;
818 }
819 jj_consume_token(56);
820 gi = GroupItem();
821 gis.add(gi);
822 }
823 jjtree.closeNodeScope(jjtn000, true);
824 jjtc000 = false;
825 {if (true) return parseCogroup(gis);}
826 } catch (Throwable jjte000) {
827 if (jjtc000) {
828 jjtree.clearNodeScope(jjtn000);
829 jjtc000 = false;
830 } else {
831 jjtree.popNode();
832 }
833 if (jjte000 instanceof RuntimeException) {
834 {if (true) throw (RuntimeException)jjte000;}
835 }
836 if (jjte000 instanceof ParseException) {
837 {if (true) throw (ParseException)jjte000;}
838 }
839 {if (true) throw (Error)jjte000;}
840 } finally {
841 if (jjtc000) {
842 jjtree.closeNodeScope(jjtn000, true);
843 }
844 }
845 throw new Error("Missing return statement in function");
846 }
847
848 final public CogroupInput GroupItem() throws ParseException {
849 /*@bgen(jjtree) GroupItem */
850 SimpleNode jjtn000 = new SimpleNode(JJTGROUPITEM);
851 boolean jjtc000 = true;
852 jjtree.openNodeScope(jjtn000);LogicalOperator op; GroupFunc groupFunc; CogroupInput cogroupInput = new CogroupInput();
853 try {
854 cogroupInput.op = NestedExpr();
855 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
856 case BY:
857 jj_consume_token(BY);
858 cogroupInput.spec = GroupByExpr(cogroupInput.op.outputSchema());
859 break;
860 case ALL:
861 jj_consume_token(ALL);
862 cogroupInput.spec = new GroupBySpec(pigContext, (GroupFunc) pigContext.getUDF(GFAll.class.getName()), new EvalItemList(pigContext), false);
863 break;
864 case ANY:
865 jj_consume_token(ANY);
866 cogroupInput.spec = new GroupBySpec(pigContext, (GroupFunc) pigContext.getUDF(GFAny.class.getName()), new EvalItemList(pigContext), false);
867 break;
868 default:
869 jj_la1[17] = jj_gen;
870 jj_consume_token(-1);
871 throw new ParseException();
872 }
873 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
874 case INNER:
875 case OUTER:
876 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
877 case INNER:
878 jj_consume_token(INNER);
879 cogroupInput.spec.isInner = true;
880 break;
881 case OUTER:
882 jj_consume_token(OUTER);
883 break;
884 default:
885 jj_la1[18] = jj_gen;
886 jj_consume_token(-1);
887 throw new ParseException();
888 }
889 break;
890 default:
891 jj_la1[19] = jj_gen;
892 ;
893 }
894 jjtree.closeNodeScope(jjtn000, true);
895 jjtc000 = false;
896 {if (true) return cogroupInput;}
897 } catch (Throwable jjte000) {
898 if (jjtc000) {
899 jjtree.clearNodeScope(jjtn000);
900 jjtc000 = false;
901 } else {
902 jjtree.popNode();
903 }
904 if (jjte000 instanceof RuntimeException) {
905 {if (true) throw (RuntimeException)jjte000;}
906 }
907 if (jjte000 instanceof ParseException) {
908 {if (true) throw (ParseException)jjte000;}
909 }
910 {if (true) throw (Error)jjte000;}
911 } finally {
912 if (jjtc000) {
913 jjtree.closeNodeScope(jjtn000, true);
914 }
915 }
916 throw new Error("Missing return statement in function");
917 }
918
919 final public GroupBySpec GroupByExpr(SchemaItem over) throws ParseException {
920 /*@bgen(jjtree) GroupByExpr */
921 SimpleNode jjtn000 = new SimpleNode(JJTGROUPBYEXPR);
922 boolean jjtc000 = true;
923 jjtree.openNodeScope(jjtn000);Token t1; GroupBySpec spec = null; EvalItem projItem = null; EvalItemList proj = null; String s; GroupFunc func = null;
924 try {
925 if (jj_2_7(2)) {
926 func = GroupFunction();
927 jj_consume_token(54);
928 proj = SimpleProjOrEmpty(over);
929 jj_consume_token(55);
930 spec = new GroupBySpec(pigContext, func, proj, false);
931 } else {
932 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
933 case STAR:
934 case GROUP:
935 case IDENTIFIER:
936 case QUOTEDSTRING:
937 case DOLLARVAR:
938 case 54:
939 proj = BracketedSimpleProj(over);
940 spec = new GroupBySpec(pigContext, (GroupFunc) pigContext.getUDF(GFTupleNoop.class.getName()), proj, false);
941 break;
942 default:
943 jj_la1[20] = jj_gen;
944 jj_consume_token(-1);
945 throw new ParseException();
946 }
947 }
948 jjtree.closeNodeScope(jjtn000, true);
949 jjtc000 = false;
950 {if (true) return spec;}
951 } catch (Throwable jjte000) {
952 if (jjtc000) {
953 jjtree.clearNodeScope(jjtn000);
954 jjtc000 = false;
955 } else {
956 jjtree.popNode();
957 }
958 if (jjte000 instanceof RuntimeException) {
959 {if (true) throw (RuntimeException)jjte000;}
960 }
961 if (jjte000 instanceof ParseException) {
962 {if (true) throw (ParseException)jjte000;}
963 }
964 {if (true) throw (Error)jjte000;}
965 } finally {
966 if (jjtc000) {
967 jjtree.closeNodeScope(jjtn000, true);
968 }
969 }
970 throw new Error("Missing return statement in function");
971 }
972
973 //Used in serialization and deserialization
974 final public GroupBySpec GroupBySpec() throws ParseException {
975 /*@bgen(jjtree) GroupBySpec */
976 SimpleNode jjtn000 = new SimpleNode(JJTGROUPBYSPEC);
977 boolean jjtc000 = true;
978 jjtree.openNodeScope(jjtn000);GroupBySpec spec = null;
979 try {
980 spec = GroupByExpr(null);
981 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
982 case INNER:
983 case OUTER:
984 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
985 case INNER:
986 jj_consume_token(INNER);
987 spec.isInner = true;
988 break;
989 case OUTER:
990 jj_consume_token(OUTER);
991 break;
992 default:
993 jj_la1[21] = jj_gen;
994 jj_consume_token(-1);
995 throw new ParseException();
996 }
997 break;
998 default:
999 jj_la1[22] = jj_gen;
1000 ;
1001 }
1002 jjtree.closeNodeScope(jjtn000, true);
1003 jjtc000 = false;
1004 {if (true) return spec;}
1005 } catch (Throwable jjte000) {
1006 if (jjtc000) {
1007 jjtree.clearNodeScope(jjtn000);
1008 jjtc000 = false;
1009 } else {
1010 jjtree.popNode();
1011 }
1012 if (jjte000 instanceof RuntimeException) {
1013 {if (true) throw (RuntimeException)jjte000;}
1014 }
1015 if (jjte000 instanceof ParseException) {
1016 {if (true) throw (ParseException)jjte000;}
1017 }
1018 {if (true) throw (Error)jjte000;}
1019 } finally {
1020 if (jjtc000) {
1021 jjtree.closeNodeScope(jjtn000, true);
1022 }
1023 }
1024 throw new Error("Missing return statement in function");
1025 }
1026
1027 final public LogicalOperator CrossClause() throws ParseException {
1028 /*@bgen(jjtree) CrossClause */
1029 SimpleNode jjtn000 = new SimpleNode(JJTCROSSCLAUSE);
1030 boolean jjtc000 = true;
1031 jjtree.openNodeScope(jjtn000);LogicalOperator op; ArrayList<LogicalOperator> inputs = new ArrayList<LogicalOperator>();
1032 try {
1033 op = NestedExpr();
1034 inputs.add(op);
1035 label_5:
1036 while (true) {
1037 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1038 case 56:
1039 ;
1040 break;
1041 default:
1042 jj_la1[23] = jj_gen;
1043 break label_5;
1044 }
1045 jj_consume_token(56);
1046 op = NestedExpr();
1047 inputs.add(op);
1048 }
1049 jjtree.closeNodeScope(jjtn000, true);
1050 jjtc000 = false;
1051 {if (true) return rewriteCross(inputs);}
1052 } catch (Throwable jjte000) {
1053 if (jjtc000) {
1054 jjtree.clearNodeScope(jjtn000);
1055 jjtc000 = false;
1056 } else {
1057 jjtree.popNode();
1058 }
1059 if (jjte000 instanceof RuntimeException) {
1060 {if (true) throw (RuntimeException)jjte000;}
1061 }
1062 if (jjte000 instanceof ParseException) {
1063 {if (true) throw (ParseException)jjte000;}
1064 }
1065 {if (true) throw (Error)jjte000;}
1066 } finally {
1067 if (jjtc000) {
1068 jjtree.closeNodeScope(jjtn000, true);
1069 }
1070 }
1071 throw new Error("Missing return statement in function");
1072 }
1073
1074 final public LogicalOperator UnionClause() throws ParseException {
1075 /*@bgen(jjtree) UnionClause */
1076 SimpleNode jjtn000 = new SimpleNode(JJTUNIONCLAUSE);
1077 boolean jjtc000 = true;
1078 jjtree.openNodeScope(jjtn000);LogicalOperator op; ArrayList<LogicalOperator> inputs = new ArrayList<LogicalOperator>();
1079 try {
1080 op = NestedExpr();
1081 inputs.add(op);
1082 label_6:
1083 while (true) {
1084 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1085 case 56:
1086 ;
1087 break;
1088 default:
1089 jj_la1[24] = jj_gen;
1090 break label_6;
1091 }
1092 jj_consume_token(56);
1093 op = NestedExpr();
1094 inputs.add(op);
1095 }
1096 jjtree.closeNodeScope(jjtn000, true);
1097 jjtc000 = false;
1098 {if (true) return new LOUnion(pigContext, inputs);}
1099 } catch (Throwable jjte000) {
1100 if (jjtc000) {
1101 jjtree.clearNodeScope(jjtn000);
1102 jjtc000 = false;
1103 } else {
1104 jjtree.popNode();
1105 }
1106 if (jjte000 instanceof RuntimeException) {
1107 {if (true) throw (RuntimeException)jjte000;}
1108 }
1109 if (jjte000 instanceof ParseException) {
1110 {if (true) throw (ParseException)jjte000;}
1111 }
1112 {if (true) throw (Error)jjte000;}
1113 } finally {
1114 if (jjtc000) {
1115 jjtree.closeNodeScope(jjtn000, true);
1116 }
1117 }
1118 throw new Error("Missing return statement in function");
1119 }
1120
1121 final public LogicalOperator ForEachClause() throws ParseException {
1122 /*@bgen(jjtree) ForEachClause */
1123 SimpleNode jjtn000 = new SimpleNode(JJTFOREACHCLAUSE);
1124 boolean jjtc000 = true;
1125 jjtree.openNodeScope(jjtn000);EvalSpecPipeAndSchema specPipeAndSchema = null; LogicalOperator input, op;
1126 try {
1127 input = NestedExpr();
1128 specPipeAndSchema = NestedBlock(input.outputSchema());
1129 jjtree.closeNodeScope(jjtn000, true);
1130 jjtc000 = false;
1131 op = new LOEval(pigContext, input, specPipeAndSchema.pipe);
1132 op.schema = specPipeAndSchema.schema;
1133 {if (true) return op;}
1134 } catch (Throwable jjte000) {
1135 if (jjtc000) {
1136 jjtree.clearNodeScope(jjtn000);
1137 jjtc000 = false;
1138 } else {
1139 jjtree.popNode();
1140 }
1141 if (jjte000 instanceof RuntimeException) {
1142 {if (true) throw (RuntimeException)jjte000;}
1143 }
1144 if (jjte000 instanceof ParseException) {
1145 {if (true) throw (ParseException)jjte000;}
1146 }
1147 {if (true) throw (Error)jjte000;}
1148 } finally {
1149 if (jjtc000) {
1150 jjtree.closeNodeScope(jjtn000, true);
1151 }
1152 }
1153 throw new Error("Missing return statement in function");
1154 }
1155
1156 final public EvalSpecPipeAndSchema NestedBlock(SchemaItem over) throws ParseException {
1157 /*@bgen(jjtree) NestedBlock */
1158 SimpleNode jjtn000 = new SimpleNode(JJTNESTEDBLOCK);
1159 boolean jjtc000 = true;
1160 jjtree.openNodeScope(jjtn000);EvalSpecPipeAndSchema pipeAndSchema; Map<String, EvalItem> pipes = new HashMap<String, EvalItem>();
1161 try {
1162 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1163 case GENERATE:
1164 pipeAndSchema = GenerateStatement(over,pipes);
1165 break;
1166 case 57:
1167 jj_consume_token(57);
1168 label_7:
1169 while (true) {
1170 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1171 case IDENTIFIER:
1172 ;
1173 break;
1174 default:
1175 jj_la1[25] = jj_gen;
1176 break label_7;
1177 }
1178 NestedCommand(over,pipes);
1179 jj_consume_token(53);
1180 }
1181 pipeAndSchema = GenerateStatement(over,pipes);
1182 jj_consume_token(53);
1183 jj_consume_token(58);
1184 break;
1185 default:
1186 jj_la1[26] = jj_gen;
1187 jj_consume_token(-1);
1188 throw new ParseException();
1189 }
1190 jjtree.closeNodeScope(jjtn000, true);
1191 jjtc000 = false;
1192 {if (true) return pipeAndSchema;}
1193 } catch (Throwable jjte000) {
1194 if (jjtc000) {
1195 jjtree.clearNodeScope(jjtn000);
1196 jjtc000 = false;
1197 } else {
1198 jjtree.popNode();
1199 }
1200 if (jjte000 instanceof RuntimeException) {
1201 {if (true) throw (RuntimeException)jjte000;}
1202 }
1203 if (jjte000 instanceof ParseException) {
1204 {if (true) throw (ParseException)jjte000;}
1205 }
1206 {if (true) throw (Error)jjte000;}
1207 } finally {
1208 if (jjtc000) {
1209 jjtree.closeNodeScope(jjtn000, true);
1210 }
1211 }
1212 throw new Error("Missing return statement in function");
1213 }
1214
1215 final public void NestedCommand(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1216 /*@bgen(jjtree) NestedCommand */
1217 SimpleNode jjtn000 = new SimpleNode(JJTNESTEDCOMMAND);
1218 boolean jjtc000 = true;
1219 jjtree.openNodeScope(jjtn000);Token t; EvalItem item;
1220 try {
1221 t = jj_consume_token(IDENTIFIER);
1222 jj_consume_token(52);
1223 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1224 case GROUP:
1225 case IDENTIFIER:
1226 case QUOTEDSTRING:
1227 case DOLLARVAR:
1228 case 54:
1229 item = InfixExpr(over,pipes);
1230 break;
1231 case FILTER:
1232 item = NestedFilter(over,pipes);
1233 break;
1234 case ORDER:
1235 case ARRANGE:
1236 item = NestedSortOrArrange(over,pipes);
1237 break;
1238 case DISTINCT:
1239 item = NestedDistinct(over,pipes);
1240 break;
1241 default:
1242 jj_la1[27] = jj_gen;
1243 jj_consume_token(-1);
1244 throw new ParseException();
1245 }
1246 jjtree.closeNodeScope(jjtn000, true);
1247 jjtc000 = false;
1248 pipes.put(t.image,item);
1249 } catch (Throwable jjte000) {
1250 if (jjtc000) {
1251 jjtree.clearNodeScope(jjtn000);
1252 jjtc000 = false;
1253 } else {
1254 jjtree.popNode();
1255 }
1256 if (jjte000 instanceof RuntimeException) {
1257 {if (true) throw (RuntimeException)jjte000;}
1258 }
1259 if (jjte000 instanceof ParseException) {
1260 {if (true) throw (ParseException)jjte000;}
1261 }
1262 {if (true) throw (Error)jjte000;}
1263 } finally {
1264 if (jjtc000) {
1265 jjtree.closeNodeScope(jjtn000, true);
1266 }
1267 }
1268 }
1269
1270 final public EvalItem NestedFilter(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1271 /*@bgen(jjtree) NestedFilter */
1272 SimpleNode jjtn000 = new SimpleNode(JJTNESTEDFILTER);
1273 boolean jjtc000 = true;
1274 jjtree.openNodeScope(jjtn000);Cond cond; EvalItem item; SchemaItem subSchema = null;
1275 try {
1276 jj_consume_token(FILTER);
1277 item = BaseEvalItem(over,pipes);
1278 subSchema = item.mapInputSchema(over);
1279 jj_consume_token(BY);
1280 cond = PCond(subSchema,null);
1281 jjtree.closeNodeScope(jjtn000, true);
1282 jjtc000 = false;
1283 {if (true) return copyItemAndAddSpec(item,new FilterSpec(cond));}
1284 } catch (Throwable jjte000) {
1285 if (jjtc000) {
1286 jjtree.clearNodeScope(jjtn000);
1287 jjtc000 = false;
1288 } else {
1289 jjtree.popNode();
1290 }
1291 if (jjte000 instanceof RuntimeException) {
1292 {if (true) throw (RuntimeException)jjte000;}
1293 }
1294 if (jjte000 instanceof ParseException) {
1295 {if (true) throw (ParseException)jjte000;}
1296 }
1297 {if (true) throw (Error)jjte000;}
1298 } finally {
1299 if (jjtc000) {
1300 jjtree.closeNodeScope(jjtn000, true);
1301 }
1302 }
1303 throw new Error("Missing return statement in function");
1304 }
1305
1306 final public EvalItem NestedSortOrArrange(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1307 /*@bgen(jjtree) NestedSortOrArrange */
1308 SimpleNode jjtn000 = new SimpleNode(JJTNESTEDSORTORARRANGE);
1309 boolean jjtc000 = true;
1310 jjtree.openNodeScope(jjtn000);EvalItemList list; EvalItem item; SchemaItem subSchema = null; Token t;
1311 try {
1312 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1313 case ORDER:
1314 t = jj_consume_token(ORDER);
1315 break;
1316 case ARRANGE:
1317 t = jj_consume_token(ARRANGE);
1318 break;
1319 default:
1320 jj_la1[28] = jj_gen;
1321 jj_consume_token(-1);
1322 throw new ParseException();
1323 }
1324 item = BaseEvalItem(over,pipes);
1325 subSchema = item.mapInputSchema(over);
1326 jj_consume_token(BY);
1327 list = SimpleProj(subSchema);
1328 jjtree.closeNodeScope(jjtn000, true);
1329 jjtc000 = false;
1330 {if (true) return copyItemAndAddSpec(item,new SortArrangeSpec(list,t.image.equalsIgnoreCase("arrange")));}
1331 } catch (Throwable jjte000) {
1332 if (jjtc000) {
1333 jjtree.clearNodeScope(jjtn000);
1334 jjtc000 = false;
1335 } else {
1336 jjtree.popNode();
1337 }
1338 if (jjte000 instanceof RuntimeException) {
1339 {if (true) throw (RuntimeException)jjte000;}
1340 }
1341 if (jjte000 instanceof ParseException) {
1342 {if (true) throw (ParseException)jjte000;}
1343 }
1344 {if (true) throw (Error)jjte000;}
1345 } finally {
1346 if (jjtc000) {
1347 jjtree.closeNodeScope(jjtn000, true);
1348 }
1349 }
1350 throw new Error("Missing return statement in function");
1351 }
1352
1353 final public EvalItem NestedDistinct(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1354 /*@bgen(jjtree) NestedDistinct */
1355 SimpleNode jjtn000 = new SimpleNode(JJTNESTEDDISTINCT);
1356 boolean jjtc000 = true;
1357 jjtree.openNodeScope(jjtn000);EvalItemList list; EvalItem item; LogicalOperator subOp = null; Token t;
1358 try {
1359 jj_consume_token(DISTINCT);
1360 item = BaseEvalItem(over,pipes);
1361 jjtree.closeNodeScope(jjtn000, true);
1362 jjtc000 = false;
1363 list = new EvalItemList(pigContext); list.add(new StarEvalItem(pigContext));
1364 {if (true) return copyItemAndAddSpec(item,new DistinctSpec(list));}
1365 } catch (Throwable jjte000) {
1366 if (jjtc000) {
1367 jjtree.clearNodeScope(jjtn000);
1368 jjtc000 = false;
1369 } else {
1370 jjtree.popNode();
1371 }
1372 if (jjte000 instanceof RuntimeException) {
1373 {if (true) throw (RuntimeException)jjte000;}
1374 }
1375 if (jjte000 instanceof ParseException) {
1376 {if (true) throw (ParseException)jjte000;}
1377 }
1378 {if (true) throw (Error)jjte000;}
1379 } finally {
1380 if (jjtc000) {
1381 jjtree.closeNodeScope(jjtn000, true);
1382 }
1383 }
1384 throw new Error("Missing return statement in function");
1385 }
1386
1387 final public EvalSpecPipeAndSchema GenerateStatement(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1388 /*@bgen(jjtree) GenerateStatement */
1389 SimpleNode jjtn000 = new SimpleNode(JJTGENERATESTATEMENT);
1390 boolean jjtc000 = true;
1391 jjtree.openNodeScope(jjtn000);EvalSpecPipeAndSchema pipeAndSchema = new EvalSpecPipeAndSchema(); EvalSpecPipe pipe = null; SchemaItemList schema;
1392 try {
1393 jj_consume_token(GENERATE);
1394 pipe = FlattenedGenerateItemList(over,pipes);
1395 jjtree.closeNodeScope(jjtn000, true);
1396 jjtc000 = false;
1397 pipeAndSchema.pipe = pipe;
1398 {if (true) return pipeAndSchema;}
1399 } catch (Throwable jjte000) {
1400 if (jjtc000) {
1401 jjtree.clearNodeScope(jjtn000);
1402 jjtc000 = false;
1403 } else {
1404 jjtree.popNode();
1405 }
1406 if (jjte000 instanceof RuntimeException) {
1407 {if (true) throw (RuntimeException)jjte000;}
1408 }
1409 if (jjte000 instanceof ParseException) {
1410 {if (true) throw (ParseException)jjte000;}
1411 }
1412 {if (true) throw (Error)jjte000;}
1413 } finally {
1414 if (jjtc000) {
1415 jjtree.closeNodeScope(jjtn000, true);
1416 }
1417 }
1418 throw new Error("Missing return statement in function");
1419 }
1420
1421 final public EvalSpecPipe FlattenedGenerateItemList(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1422 /*@bgen(jjtree) FlattenedGenerateItemList */
1423 SimpleNode jjtn000 = new SimpleNode(JJTFLATTENEDGENERATEITEMLIST);
1424 boolean jjtc000 = true;
1425 jjtree.openNodeScope(jjtn000);EvalSpecPipe pipe = new EvalSpecPipe(pigContext); EvalItemList list = new EvalItemList(pigContext); EvalItem item;
1426 try {
1427 item = FlattenedGenerateItem(over,pipes);
1428 list.add(item);
1429 label_8:
1430 while (true) {
1431 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1432 case 56:
1433 ;
1434 break;
1435 default:
1436 jj_la1[29] = jj_gen;
1437 break label_8;
1438 }
1439 jj_consume_token(56);
1440 item = FlattenedGenerateItem(over,pipes);
1441 list.add(item);
1442 }
1443 jjtree.closeNodeScope(jjtn000, true);
1444 jjtc000 = false;
1445 pipe.add(list); {if (true) return pipe;}
1446 } catch (Throwable jjte000) {
1447 if (jjtc000) {
1448 jjtree.clearNodeScope(jjtn000);
1449 jjtc000 = false;
1450 } else {
1451 jjtree.popNode();
1452 }
1453 if (jjte000 instanceof RuntimeException) {
1454 {if (true) throw (RuntimeException)jjte000;}
1455 }
1456 if (jjte000 instanceof ParseException) {
1457 {if (true) throw (ParseException)jjte000;}
1458 }
1459 {if (true) throw (Error)jjte000;}
1460 } finally {
1461 if (jjtc000) {
1462 jjtree.closeNodeScope(jjtn000, true);
1463 }
1464 }
1465 throw new Error("Missing return statement in function");
1466 }
1467
1468 final public EvalItem FlattenedGenerateItem(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1469 /*@bgen(jjtree) FlattenedGenerateItem */
1470 SimpleNode jjtn000 = new SimpleNode(JJTFLATTENEDGENERATEITEM);
1471 boolean jjtc000 = true;
1472 jjtree.openNodeScope(jjtn000);EvalItem item; SchemaItem schema = null;
1473 try {
1474 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1475 case FLATTEN:
1476 jj_consume_token(FLATTEN);
1477 jj_consume_token(54);
1478 item = GenerateItem(over,pipes);
1479 jj_consume_token(55);
1480 if (!(item instanceof NestableEvalItem) ||
1481 (item instanceof AtomFuncEvalItem) ){
1482 {if (true) throw new ParseException("Cannot flatten atom field");}
1483 }
1484
1485 EvalItemList list = new EvalItemList(pigContext);
1486 list.add(new StarEvalItem(pigContext));
1487 ((NestableEvalItem)item).subColSpec = list;
1488 break;
1489 case STAR:
1490 case GROUP:
1491 case IDENTIFIER:
1492 case QUOTEDSTRING:
1493 case DOLLARVAR:
1494 case 54:
1495 item = GenerateItem(over,pipes);
1496 break;
1497 default:
1498 jj_la1[30] = jj_gen;
1499 jj_consume_token(-1);
1500 throw new ParseException();
1501 }
1502 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1503 case AS:
1504 jj_consume_token(AS);
1505 schema = SchemaElement();
1506 break;
1507 default:
1508 jj_la1[31] = jj_gen;
1509 ;
1510 }
1511 jjtree.closeNodeScope(jjtn000, true);
1512 jjtc000 = false;
1513 item.schema = schema;
1514 {if (true) return item;}
1515 } catch (Throwable jjte000) {
1516 if (jjtc000) {
1517 jjtree.clearNodeScope(jjtn000);
1518 jjtc000 = false;
1519 } else {
1520 jjtree.popNode();
1521 }
1522 if (jjte000 instanceof RuntimeException) {
1523 {if (true) throw (RuntimeException)jjte000;}
1524 }
1525 if (jjte000 instanceof ParseException) {
1526 {if (true) throw (ParseException)jjte000;}
1527 }
1528 {if (true) throw (Error)jjte000;}
1529 } finally {
1530 if (jjtc000) {
1531 jjtree.closeNodeScope(jjtn000, true);
1532 }
1533 }
1534 throw new Error("Missing return statement in function");
1535 }
1536
1537 final public EvalItem GenerateItem(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1538 /*@bgen(jjtree) GenerateItem */
1539 SimpleNode jjtn000 = new SimpleNode(JJTGENERATEITEM);
1540 boolean jjtc000 = true;
1541 jjtree.openNodeScope(jjtn000);EvalItem item;
1542 try {
1543 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1544 case GROUP:
1545 case IDENTIFIER:
1546 case QUOTEDSTRING:
1547 case DOLLARVAR:
1548 case 54:
1549 item = InfixExpr(over,pipes);
1550 break;
1551 case STAR:
1552 item = Star();
1553 break;
1554 default:
1555 jj_la1[32] = jj_gen;
1556 jj_consume_token(-1);
1557 throw new ParseException();
1558 }
1559 jjtree.closeNodeScope(jjtn000, true);
1560 jjtc000 = false;
1561 {if (true) return item;}
1562 } catch (Throwable jjte000) {
1563 if (jjtc000) {
1564 jjtree.clearNodeScope(jjtn000);
1565 jjtc000 = false;
1566 } else {
1567 jjtree.popNode();
1568 }
1569 if (jjte000 instanceof RuntimeException) {
1570 {if (true) throw (RuntimeException)jjte000;}
1571 }
1572 if (jjte000 instanceof ParseException) {
1573 {if (true) throw (ParseException)jjte000;}
1574 }
1575 {if (true) throw (Error)jjte000;}
1576 } finally {
1577 if (jjtc000) {
1578 jjtree.closeNodeScope(jjtn000, true);
1579 }
1580 }
1581 throw new Error("Missing return statement in function");
1582 }
1583
1584 final public EvalItem InfixExpr(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1585 /*@bgen(jjtree) InfixExpr */
1586 SimpleNode jjtn000 = new SimpleNode(JJTINFIXEXPR);
1587 boolean jjtc000 = true;
1588 jjtree.openNodeScope(jjtn000);EvalItem expr;
1589 try {
1590 expr = AdditiveExpr(over,pipes);
1591 jjtree.closeNodeScope(jjtn000, true);
1592 jjtc000 = false;
1593 {if (true) return expr;}
1594 } catch (Throwable jjte000) {
1595 if (jjtc000) {
1596 jjtree.clearNodeScope(jjtn000);
1597 jjtc000 = false;
1598 } else {
1599 jjtree.popNode();
1600 }
1601 if (jjte000 instanceof RuntimeException) {
1602 {if (true) throw (RuntimeException)jjte000;}
1603 }
1604 if (jjte000 instanceof ParseException) {
1605 {if (true) throw (ParseException)jjte000;}
1606 }
1607 {if (true) throw (Error)jjte000;}
1608 } finally {
1609 if (jjtc000) {
1610 jjtree.closeNodeScope(jjtn000, true);
1611 }
1612 }
1613 throw new Error("Missing return statement in function");
1614 }
1615
1616 final public EvalItem AdditiveExpr(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1617 /*@bgen(jjtree) AdditiveExpr */
1618 SimpleNode jjtn000 = new SimpleNode(JJTADDITIVEEXPR);
1619 boolean jjtc000 = true;
1620 jjtree.openNodeScope(jjtn000);Token t; EvalItem lhs, rhs; EvalItemList args;
1621 try {
1622 lhs = MultiplicativeExpr(over,pipes);
1623 label_9:
1624 while (true) {
1625 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1626 case 59:
1627 case 60:
1628 ;
1629 break;
1630 default:
1631 jj_la1[33] = jj_gen;
1632 break label_9;
1633 }
1634 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1635 case 59:
1636 t = jj_consume_token(59);
1637 break;
1638 case 60:
1639 t = jj_consume_token(60);
1640 break;
1641 default:
1642 jj_la1[34] = jj_gen;
1643 jj_consume_token(-1);
1644 throw new ParseException();
1645 }
1646 rhs = MultiplicativeExpr(over,pipes);
1647 assertAtomic(lhs,true);
1648 assertAtomic(rhs,true);
1649 args = new EvalItemList(pigContext);
1650 args.add(lhs);
1651 args.add(rhs);
1652 if (t.image.equals("+")){
1653 lhs = newFuncEvalItem((EvalFunc)pigContext.getUDF("ADD"), args);
1654 }else{
1655 lhs = newFuncEvalItem((EvalFunc)pigContext.getUDF("SUBTRACT"), args);
1656 }
1657 }
1658 jjtree.closeNodeScope(jjtn000, true);
1659 jjtc000 = false;
1660 {if (true) return lhs;}
1661 } catch (Throwable jjte000) {
1662 if (jjtc000) {
1663 jjtree.clearNodeScope(jjtn000);
1664 jjtc000 = false;
1665 } else {
1666 jjtree.popNode();
1667 }
1668 if (jjte000 instanceof RuntimeException) {
1669 {if (true) throw (RuntimeException)jjte000;}
1670 }
1671 if (jjte000 instanceof ParseException) {
1672 {if (true) throw (ParseException)jjte000;}
1673 }
1674 {if (true) throw (Error)jjte000;}
1675 } finally {
1676 if (jjtc000) {
1677 jjtree.closeNodeScope(jjtn000, true);
1678 }
1679 }
1680 throw new Error("Missing return statement in function");
1681 }
1682
1683 final public EvalItem MultiplicativeExpr(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1684 /*@bgen(jjtree) MultiplicativeExpr */
1685 SimpleNode jjtn000 = new SimpleNode(JJTMULTIPLICATIVEEXPR);
1686 boolean jjtc000 = true;
1687 jjtree.openNodeScope(jjtn000);Token t; EvalItem lhs, rhs; EvalItemList args;
1688 try {
1689 lhs = UnaryExpr(over,pipes);
1690 label_10:
1691 while (true) {
1692 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1693 case STAR:
1694 case 61:
1695 ;
1696 break;
1697 default:
1698 jj_la1[35] = jj_gen;
1699 break label_10;
1700 }
1701 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1702 case STAR:
1703 t = jj_consume_token(STAR);
1704 break;
1705 case 61:
1706 t = jj_consume_token(61);
1707 break;
1708 default:
1709 jj_la1[36] = jj_gen;
1710 jj_consume_token(-1);
1711 throw new ParseException();
1712 }
1713 rhs = UnaryExpr(over,pipes);
1714 assertAtomic(lhs,true);
1715 assertAtomic(rhs,true);
1716 args = new EvalItemList(pigContext);
1717 args.add(lhs);
1718 args.add(rhs);
1719 if (t.image.equals("*")){
1720 lhs = newFuncEvalItem((EvalFunc)pigContext.getUDF("MULTIPLY"), args);
1721 }else{
1722 lhs = newFuncEvalItem((EvalFunc)pigContext.getUDF("DIVIDE"), args);
1723 }
1724 }
1725 jjtree.closeNodeScope(jjtn000, true);
1726 jjtc000 = false;
1727 {if (true) return lhs;}
1728 } catch (Throwable jjte000) {
1729 if (jjtc000) {
1730 jjtree.clearNodeScope(jjtn000);
1731 jjtc000 = false;
1732 } else {
1733 jjtree.popNode();
1734 }
1735 if (jjte000 instanceof RuntimeException) {
1736 {if (true) throw (RuntimeException)jjte000;}
1737 }
1738 if (jjte000 instanceof ParseException) {
1739 {if (true) throw (ParseException)jjte000;}
1740 }
1741 {if (true) throw (Error)jjte000;}
1742 } finally {
1743 if (jjtc000) {
1744 jjtree.closeNodeScope(jjtn000, true);
1745 }
1746 }
1747 throw new Error("Missing return statement in function");
1748 }
1749
1750 final public EvalItem UnaryExpr(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1751 /*@bgen(jjtree) UnaryExpr */
1752 SimpleNode jjtn000 = new SimpleNode(JJTUNARYEXPR);
1753 boolean jjtc000 = true;
1754 jjtree.openNodeScope(jjtn000);EvalItem expr;
1755 try {
1756 if (jj_2_8(2147483647)) {
1757 expr = BaseEvalItem(over,pipes);
1758 } else {
1759 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1760 case 54:
1761 jj_consume_token(54);
1762 expr = InfixExpr(over,pipes);
1763 jj_consume_token(55);
1764 break;
1765 default:
1766 jj_la1[37] = jj_gen;
1767 jj_consume_token(-1);
1768 throw new ParseException();
1769 }
1770 }
1771 jjtree.closeNodeScope(jjtn000, true);
1772 jjtc000 = false;
1773 {if (true) return expr;}
1774 } catch (Throwable jjte000) {
1775 if (jjtc000) {
1776 jjtree.clearNodeScope(jjtn000);
1777 jjtc000 = false;
1778 } else {
1779 jjtree.popNode();
1780 }
1781 if (jjte000 instanceof RuntimeException) {
1782 {if (true) throw (RuntimeException)jjte000;}
1783 }
1784 if (jjte000 instanceof ParseException) {
1785 {if (true) throw (ParseException)jjte000;}
1786 }
1787 {if (true) throw (Error)jjte000;}
1788 } finally {
1789 if (jjtc000) {
1790 jjtree.closeNodeScope(jjtn000, true);
1791 }
1792 }
1793 throw new Error("Missing return statement in function");
1794 }
1795
1796 final public EvalItem BaseEvalItem(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1797 /*@bgen(jjtree) BaseEvalItem */
1798 SimpleNode jjtn000 = new SimpleNode(JJTBASEEVALITEM);
1799 boolean jjtc000 = true;
1800 jjtree.openNodeScope(jjtn000);EvalItem item;EvalItemList projection; SchemaItem subSchema = null;
1801 try {
1802 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1803 case QUOTEDSTRING:
1804 item = Const();
1805 break;
1806 case GROUP:
1807 case IDENTIFIER:
1808 case DOLLARVAR:
1809 case 54:
1810 if (jj_2_9(2147483647)) {
1811 item = FuncEvalItem(over,pipes);
1812 } else {
1813 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1814 case GROUP:
1815 case IDENTIFIER:
1816 case DOLLARVAR:
1817 item = PColEvalItem(over,pipes);
1818 break;
1819 case 54:
1820 item = BinCond(over,pipes);
1821 break;
1822 default:
1823 jj_la1[38] = jj_gen;
1824 jj_consume_token(-1);
1825 throw new ParseException();
1826 }
1827 }
1828 subSchema = item.mapInputSchema(over);
1829 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1830 case 62:
1831 jj_consume_token(62);
1832 projection = BracketedSimpleProj(subSchema);
1833 assertAtomic(item,false);
1834 ((NestableEvalItem)item).addNestedEvalSpec(projection);
1835 break;
1836 default:
1837 jj_la1[39] = jj_gen;
1838 ;
1839 }
1840 break;
1841 default:
1842 jj_la1[40] = jj_gen;
1843 jj_consume_token(-1);
1844 throw new ParseException();
1845 }
1846 jjtree.closeNodeScope(jjtn000, true);
1847 jjtc000 = false;
1848 {if (true) return item;}
1849 } catch (Throwable jjte000) {
1850 if (jjtc000) {
1851 jjtree.clearNodeScope(jjtn000);
1852 jjtc000 = false;
1853 } else {
1854 jjtree.popNode();
1855 }
1856 if (jjte000 instanceof RuntimeException) {
1857 {if (true) throw (RuntimeException)jjte000;}
1858 }
1859 if (jjte000 instanceof ParseException) {
1860 {if (true) throw (ParseException)jjte000;}
1861 }
1862 {if (true) throw (Error)jjte000;}
1863 } finally {
1864 if (jjtc000) {
1865 jjtree.closeNodeScope(jjtn000, true);
1866 }
1867 }
1868 throw new Error("Missing return statement in function");
1869 }
1870
1871 final public NestableEvalItem BinCond(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1872 /*@bgen(jjtree) BinCond */
1873 SimpleNode jjtn000 = new SimpleNode(JJTBINCOND);
1874 boolean jjtc000 = true;
1875 jjtree.openNodeScope(jjtn000);Cond cond; EvalItem ifTrue, ifFalse; NestableEvalItem ret = null;
1876 try {
1877 jj_consume_token(54);
1878 cond = PCond(over,pipes);
1879 jj_consume_token(63);
1880 ifTrue = BaseEvalItem(over,pipes);
1881 jj_consume_token(64);
1882 ifFalse = BaseEvalItem(over,pipes);
1883 jj_consume_token(55);
1884 jjtree.closeNodeScope(jjtn000, true);
1885 jjtc000 = false;
1886 {if (true) return new BinCond(pigContext, cond,ifTrue,ifFalse);}
1887 } catch (Throwable jjte000) {
1888 if (jjtc000) {
1889 jjtree.clearNodeScope(jjtn000);
1890 jjtc000 = false;
1891 } else {
1892 jjtree.popNode();
1893 }
1894 if (jjte000 instanceof RuntimeException) {
1895 {if (true) throw (RuntimeException)jjte000;}
1896 }
1897 if (jjte000 instanceof ParseException) {
1898 {if (true) throw (ParseException)jjte000;}
1899 }
1900 {if (true) throw (Error)jjte000;}
1901 } finally {
1902 if (jjtc000) {
1903 jjtree.closeNodeScope(jjtn000, true);
1904 }
1905 }
1906 throw new Error("Missing return statement in function");
1907 }
1908
1909 final public NestableEvalItem FuncEvalItem(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1910 /*@bgen(jjtree) FuncEvalItem */
1911 SimpleNode jjtn000 = new SimpleNode(JJTFUNCEVALITEM);
1912 boolean jjtc000 = true;
1913 jjtree.openNodeScope(jjtn000);EvalFunc func; EvalItemList args; NestableEvalItem i;
1914 try {
1915 func = EvalFunction();
1916 jj_consume_token(54);
1917 args = EvalArgs(over,pipes);
1918 jj_consume_token(55);
1919 i = newFuncEvalItem(func, args);
1920 jjtree.closeNodeScope(jjtn000, true);
1921 jjtc000 = false;
1922 {if (true) return i;}
1923 } catch (Throwable jjte000) {
1924 if (jjtc000) {
1925 jjtree.clearNodeScope(jjtn000);
1926 jjtc000 = false;
1927 } else {
1928 jjtree.popNode();
1929 }
1930 if (jjte000 instanceof RuntimeException) {
1931 {if (true) throw (RuntimeException)jjte000;}
1932 }
1933 if (jjte000 instanceof ParseException) {
1934 {if (true) throw (ParseException)jjte000;}
1935 }
1936 {if (true) throw (Error)jjte000;}
1937 } finally {
1938 if (jjtc000) {
1939 jjtree.closeNodeScope(jjtn000, true);
1940 }
1941 }
1942 throw new Error("Missing return statement in function");
1943 }
1944
1945 final public EvalItemList EvalArgs(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
1946 /*@bgen(jjtree) EvalArgs */
1947 SimpleNode jjtn000 = new SimpleNode(JJTEVALARGS);
1948 boolean jjtc000 = true;
1949 jjtree.openNodeScope(jjtn000);EvalItemList list = new EvalItemList(pigContext); EvalItem item;
1950 try {
1951 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1952 case STAR:
1953 case GROUP:
1954 case IDENTIFIER:
1955 case QUOTEDSTRING:
1956 case DOLLARVAR:
1957 case 54:
1958 item = EvalArgsItem(over,pipes);
1959 list.add(item);
1960 label_11:
1961 while (true) {
1962 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1963 case 56:
1964 ;
1965 break;
1966 default:
1967 jj_la1[41] = jj_gen;
1968 break label_11;
1969 }
1970 jj_consume_token(56);
1971 item = EvalArgsItem(over,pipes);
1972 list.add(item);
1973 }
1974 break;
1975 default:
1976 jj_la1[42] = jj_gen;
1977 list = new EvalItemList(pigContext);
1978 }
1979 jjtree.closeNodeScope(jjtn000, true);
1980 jjtc000 = false;
1981 if (!list.isSimple()){
1982 {if (true) throw new ParseException("Cannot have non-jave function as an argument");}
1983 }
1984 {if (true) return list;}
1985 } catch (Throwable jjte000) {
1986 if (jjtc000) {
1987 jjtree.clearNodeScope(jjtn000);
1988 jjtc000 = false;
1989 } else {
1990 jjtree.popNode();
1991 }
1992 if (jjte000 instanceof RuntimeException) {
1993 {if (true) throw (RuntimeException)jjte000;}
1994 }
1995 if (jjte000 instanceof ParseException) {
1996 {if (true) throw (ParseException)jjte000;}
1997 }
1998 {if (true) throw (Error)jjte000;}
1999 } finally {
2000 if (jjtc000) {
2001 jjtree.closeNodeScope(jjtn000, true);
2002 }
2003 }
2004 throw new Error("Missing return statement in function");
2005 }
2006
2007 final public EvalItem EvalArgsItem(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
2008 /*@bgen(jjtree) EvalArgsItem */
2009 SimpleNode jjtn000 = new SimpleNode(JJTEVALARGSITEM);
2010 boolean jjtc000 = true;
2011 jjtree.openNodeScope(jjtn000);EvalItem item;
2012 try {
2013 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2014 case GROUP:
2015 case IDENTIFIER:
2016 case QUOTEDSTRING:
2017 case DOLLARVAR:
2018 case 54:
2019 item = InfixExpr(over,pipes);
2020 break;
2021 case STAR:
2022 item = Star();
2023 break;
2024 default:
2025 jj_la1[43] = jj_gen;
2026 jj_consume_token(-1);
2027 throw new ParseException();
2028 }
2029 jjtree.closeNodeScope(jjtn000, true);
2030 jjtc000 = false;
2031 {if (true) return item;}
2032 } catch (Throwable jjte000) {
2033 if (jjtc000) {
2034 jjtree.clearNodeScope(jjtn000);
2035 jjtc000 = false;
2036 } else {
2037 jjtree.popNode();
2038 }
2039 if (jjte000 instanceof RuntimeException) {
2040 {if (true) throw (RuntimeException)jjte000;}
2041 }
2042 if (jjte000 instanceof ParseException) {
2043 {if (true) throw (ParseException)jjte000;}
2044 }
2045 {if (true) throw (Error)jjte000;}
2046 } finally {
2047 if (jjtc000) {
2048 jjtree.closeNodeScope(jjtn000, true);
2049 }
2050 }
2051 throw new Error("Missing return statement in function");
2052 }
2053
2054 // Map a user schema onto a LogicalOperator
2055 final public SchemaItemList AsClause() throws ParseException {
2056 /*@bgen(jjtree) AsClause */
2057 SimpleNode jjtn000 = new SimpleNode(JJTASCLAUSE);
2058 boolean jjtc000 = true;
2059 jjtree.openNodeScope(jjtn000);Token t1; SchemaItem item = null; SchemaItemList list = new SchemaItemList(); Token t = null;
2060 try {
2061 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2062 case GROUP:
2063 case IDENTIFIER:
2064 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2065 case IDENTIFIER:
2066 t = jj_consume_token(IDENTIFIER);
2067 break;
2068 case GROUP:
2069 t = jj_consume_token(GROUP);
2070 break;
2071 default:
2072 jj_la1[44] = jj_gen;
2073 jj_consume_token(-1);
2074 throw new ParseException();
2075 }
2076 jj_consume_token(64);
2077 break;
2078 default:
2079 jj_la1[45] = jj_gen;
2080 ;
2081 }
2082 jj_consume_token(54);
2083 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2084 case GROUP:
2085 case IDENTIFIER:
2086 case 54:
2087 case 65:
2088 item = SchemaElement();
2089 list.add(item);
2090 label_12:
2091 while (true) {
2092 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2093 case 56:
2094 ;
2095 break;
2096 default:
2097 jj_la1[46] = jj_gen;
2098 break label_12;
2099 }
2100 jj_consume_token(56);
2101 item = SchemaElement();
2102 list.add(item);
2103 }
2104 break;
2105 default:
2106 jj_la1[47] = jj_gen;
2107 list = new SchemaItemList();
2108 }
2109 jj_consume_token(55);
2110 jjtree.closeNodeScope(jjtn000, true);
2111 jjtc000 = false;
2112 if (t!=null)
2113 list.alias = t.image;
2114 {if (true) return list;}
2115 } catch (Throwable jjte000) {
2116 if (jjtc000) {
2117 jjtree.clearNodeScope(jjtn000);
2118 jjtc000 = false;
2119 } else {
2120 jjtree.popNode();
2121 }
2122 if (jjte000 instanceof RuntimeException) {
2123 {if (true) throw (RuntimeException)jjte000;}
2124 }
2125 if (jjte000 instanceof ParseException) {
2126 {if (true) throw (ParseException)jjte000;}
2127 }
2128 {if (true) throw (Error)jjte000;}
2129 } finally {
2130 if (jjtc000) {
2131 jjtree.closeNodeScope(jjtn000, true);
2132 }
2133 }
2134 throw new Error("Missing return statement in function");
2135 }
2136
2137 final public SchemaItem SchemaElement() throws ParseException {
2138 /*@bgen(jjtree) SchemaElement */
2139 SimpleNode jjtn000 = new SimpleNode(JJTSCHEMAELEMENT);
2140 boolean jjtc000 = true;
2141 jjtree.openNodeScope(jjtn000);Token t1; SchemaItem item = null;
2142 try {
2143 if (jj_2_10(2147483647)) {
2144 item = SchemaBag();
2145 } else if (jj_2_11(2147483647)) {
2146 item = SchemaTuple();
2147 } else if (jj_2_12(2147483647)) {
2148 item = SchemaField();
2149 } else {
2150 jj_consume_token(-1);
2151 throw new ParseException();
2152 }
2153 jjtree.closeNodeScope(jjtn000, true);
2154 jjtc000 = false;
2155 {if (true) return item;}
2156 } catch (Throwable jjte000) {
2157 if (jjtc000) {
2158 jjtree.clearNodeScope(jjtn000);
2159 jjtc000 = false;
2160 } else {
2161 jjtree.popNode();
2162 }
2163 if (jjte000 instanceof RuntimeException) {
2164 {if (true) throw (RuntimeException)jjte000;}
2165 }
2166 if (jjte000 instanceof ParseException) {
2167 {if (true) throw (ParseException)jjte000;}
2168 }
2169 {if (true) throw (Error)jjte000;}
2170 } finally {
2171 if (jjtc000) {
2172 jjtree.closeNodeScope(jjtn000, true);
2173 }
2174 }
2175 throw new Error("Missing return statement in function");
2176 }
2177
2178 final public SchemaItem SchemaField() throws ParseException {
2179 /*@bgen(jjtree) SchemaField */
2180 SimpleNode jjtn000 = new SimpleNode(JJTSCHEMAFIELD);
2181 boolean jjtc000 = true;
2182 jjtree.openNodeScope(jjtn000);Token t1;
2183 try {
2184 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2185 case IDENTIFIER:
2186 t1 = jj_consume_token(IDENTIFIER);
2187 break;
2188 case GROUP:
2189 t1 = jj_consume_token(GROUP);
2190 break;
2191 default:
2192 jj_la1[48] = jj_gen;
2193 jj_consume_token(-1);
2194 throw new ParseException();
2195 }
2196 jjtree.closeNodeScope(jjtn000, true);
2197 jjtc000 = false;
2198 {if (true) return new SchemaField(t1.image);}
2199 } finally {
2200 if (jjtc000) {
2201 jjtree.closeNodeScope(jjtn000, true);
2202 }
2203 }
2204 throw new Error("Missing return statement in function");
2205 }
2206
2207 final public SchemaItem SchemaTuple() throws ParseException {
2208 /*@bgen(jjtree) SchemaTuple */
2209 SimpleNode jjtn000 = new SimpleNode(JJTSCHEMATUPLE);
2210 boolean jjtc000 = true;
2211 jjtree.openNodeScope(jjtn000);Token t1 = null; SchemaItem item = null; SchemaItemList list = new SchemaItemList();
2212 try {
2213 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2214 case GROUP:
2215 case IDENTIFIER:
2216 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2217 case IDENTIFIER:
2218 t1 = jj_consume_token(IDENTIFIER);
2219 break;
2220 case GROUP:
2221 t1 = jj_consume_token(GROUP);
2222 break;
2223 default:
2224 jj_la1[49] = jj_gen;
2225 jj_consume_token(-1);
2226 throw new ParseException();
2227 }
2228 jj_consume_token(64);
2229 break;
2230 default:
2231 jj_la1[50] = jj_gen;
2232 ;
2233 }
2234 jj_consume_token(54);
2235 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2236 case GROUP:
2237 case IDENTIFIER:
2238 case 54:
2239 case 65:
2240 item = SchemaElement();
2241 list.add(item);
2242 label_13:
2243 while (true) {
2244 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2245 case 56:
2246 ;
2247 break;
2248 default:
2249 jj_la1[51] = jj_gen;
2250 break label_13;
2251 }
2252 jj_consume_token(56);
2253 item = SchemaElement();
2254 list.add(item);
2255 }
2256 break;
2257 default:
2258 jj_la1[52] = jj_gen;
2259
2260 }
2261 jj_consume_token(55);
2262 jjtree.closeNodeScope(jjtn000, true);
2263 jjtc000 = false;
2264 if (t1!=null)
2265 list.alias = t1.image;
2266 list.setIsBag(false);
2267 {if (true) return list;}
2268 } catch (Throwable jjte000) {
2269 if (jjtc000) {
2270 jjtree.clearNodeScope(jjtn000);
2271 jjtc000 = false;
2272 } else {
2273 jjtree.popNode();
2274 }
2275 if (jjte000 instanceof RuntimeException) {
2276 {if (true) throw (RuntimeException)jjte000;}
2277 }
2278 if (jjte000 instanceof ParseException) {
2279 {if (true) throw (ParseException)jjte000;}
2280 }
2281 {if (true) throw (Error)jjte000;}
2282 } finally {
2283 if (jjtc000) {
2284 jjtree.closeNodeScope(jjtn000, true);
2285 }
2286 }
2287 throw new Error("Missing return statement in function");
2288 }
2289
2290 final public SchemaItem SchemaBag() throws ParseException {
2291 /*@bgen(jjtree) SchemaBag */
2292 SimpleNode jjtn000 = new SimpleNode(JJTSCHEMABAG);
2293 boolean jjtc000 = true;
2294 jjtree.openNodeScope(jjtn000);Token t1=null; SchemaItem item = null; SchemaItemList list = new SchemaItemList();
2295 try {
2296 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2297 case IDENTIFIER:
2298 t1 = jj_consume_token(IDENTIFIER);
2299 jj_consume_token(64);
2300 break;
2301 default:
2302 jj_la1[53] = jj_gen;
2303 ;
2304 }
2305 jj_consume_token(65);
2306 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2307 case GROUP:
2308 case IDENTIFIER:
2309 case 54:
2310 case 65:
2311 item = SchemaElement();
2312 list.add(item);
2313 label_14:
2314 while (true) {
2315 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2316 case 56:
2317 ;
2318 break;
2319 default:
2320 jj_la1[54] = jj_gen;
2321 break label_14;
2322 }
2323 jj_consume_token(56);
2324 item = SchemaElement();
2325 list.add(item);
2326 }
2327 break;
2328 default:
2329 jj_la1[55] = jj_gen;
2330
2331 }
2332 jj_consume_token(66);
2333 jjtree.closeNodeScope(jjtn000, true);
2334 jjtc000 = false;
2335 if (t1!=null)
2336 list.alias = t1.image;
2337 list.setIsBag(true);
2338 {if (true) return list;}
2339 } catch (Throwable jjte000) {
2340 if (jjtc000) {
2341 jjtree.clearNodeScope(jjtn000);
2342 jjtc000 = false;
2343 } else {
2344 jjtree.popNode();
2345 }
2346 if (jjte000 instanceof RuntimeException) {
2347 {if (true) throw (RuntimeException)jjte000;}
2348 }
2349 if (jjte000 instanceof ParseException) {
2350 {if (true) throw (ParseException)jjte000;}
2351 }
2352 {if (true) throw (Error)jjte000;}
2353 } finally {
2354 if (jjtc000) {
2355 jjtree.closeNodeScope(jjtn000, true);
2356 }
2357 }
2358 throw new Error("Missing return statement in function");
2359 }
2360
2361 // Used in serialization and deserialization
2362 final public EvalSpecPipe PEvalSpecPipe() throws ParseException {
2363 /*@bgen(jjtree) PEvalSpecPipe */
2364 SimpleNode jjtn000 = new SimpleNode(JJTPEVALSPECPIPE);
2365 boolean jjtc000 = true;
2366 jjtree.openNodeScope(jjtn000);EvalSpecPipe pipe = new EvalSpecPipe(pigContext); EvalSpec spec;
2367 try {
2368 label_15:
2369 while (true) {
2370 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2371 case 65:
2372 ;
2373 break;
2374 default:
2375 jj_la1[56] = jj_gen;
2376 break label_15;
2377 }
2378 jj_consume_token(65);
2379 spec = PEvalSpec();
2380 jj_consume_token(66);
2381 pipe.add(spec);
2382 }
2383 jjtree.closeNodeScope(jjtn000, true);
2384 jjtc000 = false;
2385 {if (true) return pipe;}
2386 } catch (Throwable jjte000) {
2387 if (jjtc000) {
2388 jjtree.clearNodeScope(jjtn000);
2389 jjtc000 = false;
2390 } else {
2391 jjtree.popNode();
2392 }
2393 if (jjte000 instanceof RuntimeException) {
2394 {if (true) throw (RuntimeException)jjte000;}
2395 }
2396 if (jjte000 instanceof ParseException) {
2397 {if (true) throw (ParseException)jjte000;}
2398 }
2399 {if (true) throw (Error)jjte000;}
2400 } finally {
2401 if (jjtc000) {
2402 jjtree.closeNodeScope(jjtn000, true);
2403 }
2404 }
2405 throw new Error("Missing return statement in function");
2406 }
2407
2408 final public EvalSpec PEvalSpec() throws ParseException {
2409 /*@bgen(jjtree) PEvalSpec */
2410 SimpleNode jjtn000 = new SimpleNode(JJTPEVALSPEC);
2411 boolean jjtc000 = true;
2412 jjtree.openNodeScope(jjtn000);EvalSpec spec;
2413 try {
2414 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2415 case FILTER:
2416 jj_consume_token(FILTER);
2417 spec = PFilter();
2418 break;
2419 case EVAL:
2420 jj_consume_token(EVAL);
2421 spec = PEvalItemList();
2422 break;
2423 case ORDER:
2424 case ARRANGE:
2425 case DISTINCT:
2426 spec = PSAD();
2427 break;
2428 default:
2429 jj_la1[57] = jj_gen;
2430 jj_consume_token(-1);
2431 throw new ParseException();
2432 }
2433 jjtree.closeNodeScope(jjtn000, true);
2434 jjtc000 = false;
2435 {if (true) return spec;}
2436 } catch (Throwable jjte000) {
2437 if (jjtc000) {
2438 jjtree.clearNodeScope(jjtn000);
2439 jjtc000 = false;
2440 } else {
2441 jjtree.popNode();
2442 }
2443 if (jjte000 instanceof RuntimeException) {
2444 {if (true) throw (RuntimeException)jjte000;}
2445 }
2446 if (jjte000 instanceof ParseException) {
2447 {if (true) throw (ParseException)jjte000;}
2448 }
2449 {if (true) throw (Error)jjte000;}
2450 } finally {
2451 if (jjtc000) {
2452 jjtree.closeNodeScope(jjtn000, true);
2453 }
2454 }
2455 throw new Error("Missing return statement in function");
2456 }
2457
2458 final public EvalSpec PFilter() throws ParseException {
2459 /*@bgen(jjtree) PFilter */
2460 SimpleNode jjtn000 = new SimpleNode(JJTPFILTER);
2461 boolean jjtc000 = true;
2462 jjtree.openNodeScope(jjtn000);Cond cond;
2463 try {
2464 cond = PCond(null,null);
2465 jjtree.closeNodeScope(jjtn000, true);
2466 jjtc000 = false;
2467 {if (true) return new FilterSpec(cond);}
2468 } catch (Throwable jjte000) {
2469 if (jjtc000) {
2470 jjtree.clearNodeScope(jjtn000);
2471 jjtc000 = false;
2472 } else {
2473 jjtree.popNode();
2474 }
2475 if (jjte000 instanceof RuntimeException) {
2476 {if (true) throw (RuntimeException)jjte000;}
2477 }
2478 if (jjte000 instanceof ParseException) {
2479 {if (true) throw (ParseException)jjte000;}
2480 }
2481 {if (true) throw (Error)jjte000;}
2482 } finally {
2483 if (jjtc000) {
2484 jjtree.closeNodeScope(jjtn000, true);
2485 }
2486 }
2487 throw new Error("Missing return statement in function");
2488 }
2489
2490 final public EvalSpec PSAD() throws ParseException {
2491 /*@bgen(jjtree) PSAD */
2492 SimpleNode jjtn000 = new SimpleNode(JJTPSAD);
2493 boolean jjtc000 = true;
2494 jjtree.openNodeScope(jjtn000);EvalSpec sad; EvalItemList proj;
2495 try {
2496 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2497 case ORDER:
2498 jj_consume_token(ORDER);
2499 jj_consume_token(BY);
2500 proj = SimpleProj(null);
2501 sad = new SortArrangeSpec(proj, false);
2502 break;
2503 case ARRANGE:
2504 jj_consume_token(ARRANGE);
2505 jj_consume_token(BY);
2506 proj = SimpleProj(null);
2507 sad = new SortArrangeSpec(proj, true);
2508 break;
2509 case DISTINCT:
2510 jj_consume_token(DISTINCT);
2511 proj = SimpleProj(null);
2512 sad = new DistinctSpec(proj);
2513 break;
2514 default:
2515 jj_la1[58] = jj_gen;
2516 jj_consume_token(-1);
2517 throw new ParseException();
2518 }
2519 jjtree.closeNodeScope(jjtn000, true);
2520 jjtc000 = false;
2521 {if (true) return sad;}
2522 } catch (Throwable jjte000) {
2523 if (jjtc000) {
2524 jjtree.clearNodeScope(jjtn000);
2525 jjtc000 = false;
2526 } else {
2527 jjtree.popNode();
2528 }
2529 if (jjte000 instanceof RuntimeException) {
2530 {if (true) throw (RuntimeException)jjte000;}
2531 }
2532 if (jjte000 instanceof ParseException) {
2533 {if (true) throw (ParseException)jjte000;}
2534 }
2535 {if (true) throw (Error)jjte000;}
2536 } finally {
2537 if (jjtc000) {
2538 jjtree.closeNodeScope(jjtn000, true);
2539 }
2540 }
2541 throw new Error("Missing return statement in function");
2542 }
2543
2544 final public EvalItemList PEvalItemList() throws ParseException {
2545 /*@bgen(jjtree) PEvalItemList */
2546 SimpleNode jjtn000 = new SimpleNode(JJTPEVALITEMLIST);
2547 boolean jjtc000 = true;
2548 jjtree.openNodeScope(jjtn000);EvalItemList list = new EvalItemList(pigContext); EvalItem item;
2549 try {
2550 item = PEvalItem();
2551 list.add(item);
2552 label_16:
2553 while (true) {
2554 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2555 case 56:
2556 ;
2557 break;
2558 default:
2559 jj_la1[59] = jj_gen;
2560 break label_16;
2561 }
2562 jj_consume_token(56);
2563 item = PEvalItem();
2564 list.add(item);
2565 }
2566 jjtree.closeNodeScope(jjtn000, true);
2567 jjtc000 = false;
2568 {if (true) return list;}
2569 } catch (Throwable jjte000) {
2570 if (jjtc000) {
2571 jjtree.clearNodeScope(jjtn000);
2572 jjtc000 = false;
2573 } else {
2574 jjtree.popNode();
2575 }
2576 if (jjte000 instanceof RuntimeException) {
2577 {if (true) throw (RuntimeException)jjte000;}
2578 }
2579 if (jjte000 instanceof ParseException) {
2580 {if (true) throw (ParseException)jjte000;}
2581 }
2582 {if (true) throw (Error)jjte000;}
2583 } finally {
2584 if (jjtc000) {
2585 jjtree.closeNodeScope(jjtn000, true);
2586 }
2587 }
2588 throw new Error("Missing return statement in function");
2589 }
2590
2591 final public EvalItem PEvalItem() throws ParseException {
2592 /*@bgen(jjtree) PEvalItem */
2593 SimpleNode jjtn000 = new SimpleNode(JJTPEVALITEM);
2594 boolean jjtc000 = true;
2595 jjtree.openNodeScope(jjtn000);EvalItem item; EvalSpec subSpec; EvalItemList subProj; LogicalOperator subOp = null;
2596 try {
2597 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2598 case QUOTEDSTRING:
2599 item = Const();
2600 break;
2601 case STAR:
2602 item = Star();
2603 break;
2604 case IDENTIFIER:
2605 case DOLLARVAR:
2606 case 54:
2607 item = PNestableEvalItem();
2608 label_17:
2609 while (true) {
2610 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2611 case 65:
2612 ;
2613 break;
2614 default:
2615 jj_la1[60] = jj_gen;
2616 break label_17;
2617 }
2618 jj_consume_token(65);
2619 subSpec = PEvalSpec();
2620 jj_consume_token(66);
2621 ((NestableEvalItem) item).addNestedEvalSpec(subSpec);
2622 }
2623 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2624 case 62:
2625 jj_consume_token(62);
2626 jj_consume_token(54);
2627 Star();
2628 jj_consume_token(55);
2629 EvalItemList list = new EvalItemList(pigContext);
2630 list.add(new StarEvalItem(pigContext));
2631 ((NestableEvalItem) item).subColSpec = list;
2632 break;
2633 default:
2634 jj_la1[61] = jj_gen;
2635 ;
2636 }
2637 break;
2638 default:
2639 jj_la1[62] = jj_gen;
2640 jj_consume_token(-1);
2641 throw new ParseException();
2642 }
2643 jjtree.closeNodeScope(jjtn000, true);
2644 jjtc000 = false;
2645 {if (true) return item;}
2646 } catch (Throwable jjte000) {
2647 if (jjtc000) {
2648 jjtree.clearNodeScope(jjtn000);
2649 jjtc000 = false;
2650 } else {
2651 jjtree.popNode();
2652 }
2653 if (jjte000 instanceof RuntimeException) {
2654 {if (true) throw (RuntimeException)jjte000;}
2655 }
2656 if (jjte000 instanceof ParseException) {
2657 {if (true) throw (ParseException)jjte000;}
2658 }
2659 {if (true) throw (Error)jjte000;}
2660 } finally {
2661 if (jjtc000) {
2662 jjtree.closeNodeScope(jjtn000, true);
2663 }
2664 }
2665 throw new Error("Missing return statement in function");
2666 }
2667
2668 final public NestableEvalItem PNestableEvalItem() throws ParseException {
2669 /*@bgen(jjtree) PNestableEvalItem */
2670 SimpleNode jjtn000 = new SimpleNode(JJTPNESTABLEEVALITEM);
2671 boolean jjtc000 = true;
2672 jjtree.openNodeScope(jjtn000);NestableEvalItem item;
2673 try {
2674 if (jj_2_13(2147483647)) {
2675 item = EvalFunctionItem();
2676 } else if (jj_2_14(2147483647)) {
2677 item = DollarVar();
2678 } else if (jj_2_15(2147483647)) {
2679 item = SerializedBinCond();
2680 } else {
2681 jj_consume_token(-1);
2682 throw new ParseException();
2683 }
2684 jjtree.closeNodeScope(jjtn000, true);
2685 jjtc000 = false;
2686 {if (true) return item;}
2687 } catch (Throwable jjte000) {
2688 if (jjtc000) {
2689 jjtree.clearNodeScope(jjtn000);
2690 jjtc000 = false;
2691 } else {
2692 jjtree.popNode();
2693 }
2694 if (jjte000 instanceof RuntimeException) {
2695 {if (true) throw (RuntimeException)jjte000;}
2696 }
2697 if (jjte000 instanceof ParseException) {
2698 {if (true) throw (ParseException)jjte000;}
2699 }
2700 {if (true) throw (Error)jjte000;}
2701 } finally {
2702 if (jjtc000) {
2703 jjtree.closeNodeScope(jjtn000, true);
2704 }
2705 }
2706 throw new Error("Missing return statement in function");
2707 }
2708
2709 final public NestableEvalItem EvalFunctionItem() throws ParseException {
2710 /*@bgen(jjtree) EvalFunctionItem */
2711 SimpleNode jjtn000 = new SimpleNode(JJTEVALFUNCTIONITEM);
2712 boolean jjtc000 = true;
2713 jjtree.openNodeScope(jjtn000);EvalFunc func; EvalItemList args; NestableEvalItem i;
2714 try {
2715 func = EvalFunction();
2716 jj_consume_token(54);
2717 args = PEvalItemList();
2718 jj_consume_token(55);
2719 i = newFuncEvalItem(func, args);
2720 jjtree.closeNodeScope(jjtn000, true);
2721 jjtc000 = false;
2722 {if (true) return i;}
2723 } catch (Throwable jjte000) {
2724 if (jjtc000) {
2725 jjtree.clearNodeScope(jjtn000);
2726 jjtc000 = false;
2727 } else {
2728 jjtree.popNode();
2729 }
2730 if (jjte000 instanceof RuntimeException) {
2731 {if (true) throw (RuntimeException)jjte000;}
2732 }
2733 if (jjte000 instanceof ParseException) {
2734 {if (true) throw (ParseException)jjte000;}
2735 }
2736 {if (true) throw (Error)jjte000;}
2737 } finally {
2738 if (jjtc000) {
2739 jjtree.closeNodeScope(jjtn000, true);
2740 }
2741 }
2742 throw new Error("Missing return statement in function");
2743 }
2744
2745 final public NestableEvalItem SerializedBinCond() throws ParseException {
2746 /*@bgen(jjtree) SerializedBinCond */
2747 SimpleNode jjtn000 = new SimpleNode(JJTSERIALIZEDBINCOND);
2748 boolean jjtc000 = true;
2749 jjtree.openNodeScope(jjtn000);Cond cond; EvalItem ifTrue, ifFalse; NestableEvalItem ret = null;
2750 try {
2751 jj_consume_token(54);
2752 cond = PSerializedCond();
2753 jj_consume_token(63);
2754 ifTrue = PEvalItem();
2755 jj_consume_token(64);
2756 ifFalse = PEvalItem();
2757 jj_consume_token(55);
2758 jjtree.closeNodeScope(jjtn000, true);
2759 jjtc000 = false;
2760 {if (true) return new BinCond(pigContext, cond,ifTrue,ifFalse);}
2761 } catch (Throwable jjte000) {
2762 if (jjtc000) {
2763 jjtree.clearNodeScope(jjtn000);
2764 jjtc000 = false;
2765 } else {
2766 jjtree.popNode();
2767 }
2768 if (jjte000 instanceof RuntimeException) {
2769 {if (true) throw (RuntimeException)jjte000;}
2770 }
2771 if (jjte000 instanceof ParseException) {
2772 {if (true) throw (ParseException)jjte000;}
2773 }
2774 {if (true) throw (Error)jjte000;}
2775 } finally {
2776 if (jjtc000) {
2777 jjtree.closeNodeScope(jjtn000, true);
2778 }
2779 }
2780 throw new Error("Missing return statement in function");
2781 }
2782
2783 final public Cond PSerializedCond() throws ParseException {
2784 /*@bgen(jjtree) PSerializedCond */
2785 SimpleNode jjtn000 = new SimpleNode(JJTPSERIALIZEDCOND);
2786 boolean jjtc000 = true;
2787 jjtree.openNodeScope(jjtn000);Cond cond = null;
2788 try {
2789 cond = PSerializedOrCond();
2790 jjtree.closeNodeScope(jjtn000, true);
2791 jjtc000 = false;
2792 {if (true) return cond;}
2793 } catch (Throwable jjte000) {
2794 if (jjtc000) {
2795 jjtree.clearNodeScope(jjtn000);
2796 jjtc000 = false;
2797 } else {
2798 jjtree.popNode();
2799 }
2800 if (jjte000 instanceof RuntimeException) {
2801 {if (true) throw (RuntimeException)jjte000;}
2802 }
2803 if (jjte000 instanceof ParseException) {
2804 {if (true) throw (ParseException)jjte000;}
2805 }
2806 {if (true) throw (Error)jjte000;}
2807 } finally {
2808 if (jjtc000) {
2809 jjtree.closeNodeScope(jjtn000, true);
2810 }
2811 }
2812 throw new Error("Missing return statement in function");
2813 }
2814
2815 final public Cond PSerializedOrCond() throws ParseException {
2816 /*@bgen(jjtree) PSerializedOrCond */
2817 SimpleNode jjtn000 = new SimpleNode(JJTPSERIALIZEDORCOND);
2818 boolean jjtc000 = true;
2819 jjtree.openNodeScope(jjtn000);Cond cond; List<Cond> cList = new ArrayList<Cond>();
2820 try {
2821 cond = PSerializedAndCond();
2822 cList.add(cond);
2823 label_18:
2824 while (true) {
2825 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2826 case OR:
2827 ;
2828 break;
2829 default:
2830 jj_la1[63] = jj_gen;
2831 break label_18;
2832 }
2833 jj_consume_token(OR);
2834 cond = PSerializedAndCond();
2835 cList.add(cond);
2836 }
2837 jjtree.closeNodeScope(jjtn000, true);
2838 jjtc000 = false;
2839 if (cList.size()==1)
2840 {if (true) return cond;}
2841 else
2842 {if (true) return new OrCond(cList);}
2843 } catch (Throwable jjte000) {
2844 if (jjtc000) {
2845 jjtree.clearNodeScope(jjtn000);
2846 jjtc000 = false;
2847 } else {
2848 jjtree.popNode();
2849 }
2850 if (jjte000 instanceof RuntimeException) {
2851 {if (true) throw (RuntimeException)jjte000;}
2852 }
2853 if (jjte000 instanceof ParseException) {
2854 {if (true) throw (ParseException)jjte000;}
2855 }
2856 {if (true) throw (Error)jjte000;}
2857 } finally {
2858 if (jjtc000) {
2859 jjtree.closeNodeScope(jjtn000, true);
2860 }
2861 }
2862 throw new Error("Missing return statement in function");
2863 }
2864
2865 final public Cond PSerializedAndCond() throws ParseException {
2866 /*@bgen(jjtree) PSerializedAndCond */
2867 SimpleNode jjtn000 = new SimpleNode(JJTPSERIALIZEDANDCOND);
2868 boolean jjtc000 = true;
2869 jjtree.openNodeScope(jjtn000);Cond cond = null; List<Cond> cList = new ArrayList<Cond>();
2870 try {
2871 cond = PSerializedUnaryCond();
2872 cList.add(cond);
2873 label_19:
2874 while (true) {
2875 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2876 case AND:
2877 ;
2878 break;
2879 default:
2880 jj_la1[64] = jj_gen;
2881 break label_19;
2882 }
2883 jj_consume_token(AND);
2884 cond = PSerializedUnaryCond();
2885 cList.add(cond);
2886 }
2887 jjtree.closeNodeScope(jjtn000, true);
2888 jjtc000 = false;
2889 if (cList.size()==1)
2890 {if (true) return cond;}
2891 else
2892 {if (true) return new AndCond(cList);}
2893 } catch (Throwable jjte000) {
2894 if (jjtc000) {
2895 jjtree.clearNodeScope(jjtn000);
2896 jjtc000 = false;
2897 } else {
2898 jjtree.popNode();
2899 }
2900 if (jjte000 instanceof RuntimeException) {
2901 {if (true) throw (RuntimeException)jjte000;}
2902 }
2903 if (jjte000 instanceof ParseException) {
2904 {if (true) throw (ParseException)jjte000;}
2905 }
2906 {if (true) throw (Error)jjte000;}
2907 } finally {
2908 if (jjtc000) {
2909 jjtree.closeNodeScope(jjtn000, true);
2910 }
2911 }
2912 throw new Error("Missing return statement in function");
2913 }
2914
2915 final public Cond PSerializedUnaryCond() throws ParseException {
2916 /*@bgen(jjtree) PSerializedUnaryCond */
2917 SimpleNode jjtn000 = new SimpleNode(JJTPSERIALIZEDUNARYCOND);
2918 boolean jjtc000 = true;
2919 jjtree.openNodeScope(jjtn000);Cond cond = null; EvalItem c1, c2; Token t1; FilterFunc func; EvalItemList args;
2920 try {
2921 if (jj_2_16(2147483647)) {
2922 jj_consume_token(54);
2923 cond = PSerializedCond();
2924 jj_consume_token(55);
2925 } else {
2926 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2927 case NOT:
2928 cond = PSerializedNotCond();
2929 break;
2930 default:
2931 jj_la1[65] = jj_gen;
2932 if (jj_2_17(2147483647)) {
2933 c1 = PEvalItem();
2934 t1 = jj_consume_token(FILTEROP);
2935 c2 = PEvalItem();
2936 cond = new CompCond(c1, t1.image, c2);
2937 } else if (jj_2_18(2147483647)) {
2938 c1 = PEvalItem();
2939 jj_consume_token(MATCHES);
2940 t1 = jj_consume_token(QUOTEDSTRING);
2941 cond = new RegexpCond(c1, unquote(t1.image));
2942 } else {
2943 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2944 case IDENTIFIER:
2945 func = FilterFunction();
2946 jj_consume_token(54);
2947 args = PEvalItemList();
2948 jj_consume_token(55);
2949 cond = new FuncCond(func, args);
2950 break;
2951 default:
2952 jj_la1[66] = jj_gen;
2953 jj_consume_token(-1);
2954 throw new ParseException();
2955 }
2956 }
2957 }
2958 }
2959 jjtree.closeNodeScope(jjtn000, true);
2960 jjtc000 = false;
2961 {if (true) return cond;}
2962 } catch (Throwable jjte000) {
2963 if (jjtc000) {
2964 jjtree.clearNodeScope(jjtn000);
2965 jjtc000 = false;
2966 } else {
2967 jjtree.popNode();
2968 }
2969 if (jjte000 instanceof RuntimeException) {
2970 {if (true) throw (RuntimeException)jjte000;}
2971 }
2972 if (jjte000 instanceof ParseException) {
2973 {if (true) throw (ParseException)jjte000;}
2974 }
2975 {if (true) throw (Error)jjte000;}
2976 } finally {
2977 if (jjtc000) {
2978 jjtree.closeNodeScope(jjtn000, true);
2979 }
2980 }
2981 throw new Error("Missing return statement in function");
2982 }
2983
2984 final public Cond PSerializedNotCond() throws ParseException {
2985 /*@bgen(jjtree) PSerializedNotCond */
2986 SimpleNode jjtn000 = new SimpleNode(JJTPSERIALIZEDNOTCOND);
2987 boolean jjtc000 = true;
2988 jjtree.openNodeScope(jjtn000);Cond c1;
2989 try {
2990 jj_consume_token(NOT);
2991 c1 = PSerializedUnaryCond();
2992 jjtree.closeNodeScope(jjtn000, true);
2993 jjtc000 = false;
2994 {if (true) return new NotCond(c1);}
2995 } catch (Throwable jjte000) {
2996 if (jjtc000) {
2997 jjtree.clearNodeScope(jjtn000);
2998 jjtc000 = false;
2999 } else {
3000 jjtree.popNode();
3001 }
3002 if (jjte000 instanceof RuntimeException) {
3003 {if (true) throw (RuntimeException)jjte000;}
3004 }
3005 if (jjte000 instanceof ParseException) {
3006 {if (true) throw (ParseException)jjte000;}
3007 }
3008 {if (true) throw (Error)jjte000;}
3009 } finally {
3010 if (jjtc000) {
3011 jjtree.closeNodeScope(jjtn000, true);
3012 }
3013 }
3014 throw new Error("Missing return statement in function");
3015 }
3016
3017 //CQ stuff
3018 final public EvalSpec PWindow() throws ParseException {
3019 /*@bgen(jjtree) PWindow */
3020 SimpleNode jjtn000 = new SimpleNode(JJTPWINDOW);
3021 boolean jjtc000 = true;
3022 jjtree.openNodeScope(jjtn000);EvalSpec spec; int numTuples; double time;
3023 try {
3024 jj_consume_token(WINDOW);
3025 if (jj_2_19(2)) {
3026 time = PTimeWindow();
3027 spec = new TimeWindowSpec(WindowSpec.windowType.SLIDING, time);
3028 } else {
3029 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3030 case NUMBER:
3031 numTuples = PTupleWindow();
3032 spec = new TupleWindowSpec(WindowSpec.windowType.SLIDING, numTuples);
3033 break;
3034 default:
3035 jj_la1[67] = jj_gen;
3036 jj_consume_token(-1);
3037 throw new ParseException();
3038 }
3039 }
3040 jjtree.closeNodeScope(jjtn000, true);
3041 jjtc000 = false;
3042 {if (true) return spec;}
3043 } catch (Throwable jjte000) {
3044 if (jjtc000) {
3045 jjtree.clearNodeScope(jjtn000);
3046 jjtc000 = false;
3047 } else {
3048 jjtree.popNode();
3049 }
3050 if (jjte000 instanceof RuntimeException) {
3051 {if (true) throw (RuntimeException)jjte000;}
3052 }
3053 if (jjte000 instanceof ParseException) {
3054 {if (true) throw (ParseException)jjte000;}
3055 }
3056 {if (true) throw (Error)jjte000;}
3057 } finally {
3058 if (jjtc000) {
3059 jjtree.closeNodeScope(jjtn000, true);
3060 }
3061 }
3062 throw new Error("Missing return statement in function");
3063 }
3064
3065 final public double PTimeWindow() throws ParseException {
3066 /*@bgen(jjtree) PTimeWindow */
3067 SimpleNode jjtn000 = new SimpleNode(JJTPTIMEWINDOW);
3068 boolean jjtc000 = true;
3069 jjtree.openNodeScope(jjtn000);double n; Token t;
3070 try {
3071 t = jj_consume_token(NUMBER);
3072 n = Double.parseDouble(t.image);
3073 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3074 case SECONDS:
3075 jj_consume_token(SECONDS);
3076 break;
3077 case MINUTES:
3078 jj_consume_token(MINUTES);
3079 n = n*60;
3080 break;
3081 case HOURS:
3082 jj_consume_token(HOURS);
3083 n = n * 3600;
3084 break;
3085 default:
3086 jj_la1[68] = jj_gen;
3087 jj_consume_token(-1);
3088 throw new ParseException();
3089 }
3090 jjtree.closeNodeScope(jjtn000, true);
3091 jjtc000 = false;
3092 {if (true) return n;}
3093 } finally {
3094 if (jjtc000) {
3095 jjtree.closeNodeScope(jjtn000, true);
3096 }
3097 }
3098 throw new Error("Missing return statement in function");
3099 }
3100
3101 final public int PTupleWindow() throws ParseException {
3102 /*@bgen(jjtree) PTupleWindow */
3103 SimpleNode jjtn000 = new SimpleNode(JJTPTUPLEWINDOW);
3104 boolean jjtc000 = true;
3105 jjtree.openNodeScope(jjtn000);int n; Token t;
3106 try {
3107 t = jj_consume_token(NUMBER);
3108 try{
3109 n = Integer.parseInt(t.image);
3110 }catch(NumberFormatException e){
3111 {if (true) throw new ParseException("Only whole number tuple windows allowed.");}
3112 }
3113 jj_consume_token(TUPLES);
3114 jjtree.closeNodeScope(jjtn000, true);
3115 jjtc000 = false;
3116 {if (true) return n;}
3117 } finally {
3118 if (jjtc000) {
3119 jjtree.closeNodeScope(jjtn000, true);
3120 }
3121 }
3122 throw new Error("Missing return statement in function");
3123 }
3124
3125 // These the simple non-terminals that are shared across many
3126 final public EvalFunc EvalFunction() throws ParseException {
3127 /*@bgen(jjtree) EvalFunction */
3128 SimpleNode jjtn000 = new SimpleNode(JJTEVALFUNCTION);
3129 boolean jjtc000 = true;
3130 jjtree.openNodeScope(jjtn000);String funcName;
3131 try {
3132 funcName = QualifiedFunction();
3133 jjtree.closeNodeScope(jjtn000, true);
3134 jjtc000 = false;
3135 {if (true) return (EvalFunc) pigContext.getUDF(funcName);}
3136 } catch (Throwable jjte000) {
3137 if (jjtc000) {
3138 jjtree.clearNodeScope(jjtn000);
3139 jjtc000 = false;
3140 } else {
3141 jjtree.popNode();
3142 }
3143 if (jjte000 instanceof RuntimeException) {
3144 {if (true) throw (RuntimeException)jjte000;}
3145 }
3146 if (jjte000 instanceof ParseException) {
3147 {if (true) throw (ParseException)jjte000;}
3148 }
3149 {if (true) throw (Error)jjte000;}
3150 } finally {
3151 if (jjtc000) {
3152 jjtree.closeNodeScope(jjtn000, true);
3153 }
3154 }
3155 throw new Error("Missing return statement in function");
3156 }
3157
3158 final public GroupFunc GroupFunction() throws ParseException {
3159 /*@bgen(jjtree) GroupFunction */
3160 SimpleNode jjtn000 = new SimpleNode(JJTGROUPFUNCTION);
3161 boolean jjtc000 = true;
3162 jjtree.openNodeScope(jjtn000);String funcName;
3163 try {
3164 funcName = QualifiedFunction();
3165 jjtree.closeNodeScope(jjtn000, true);
3166 jjtc000 = false;
3167 {if (true) return (GroupFunc) pigContext.getUDF(funcName);}
3168 } catch (Throwable jjte000) {
3169 if (jjtc000) {
3170 jjtree.clearNodeScope(jjtn000);
3171 jjtc000 = false;
3172 } else {
3173 jjtree.popNode();
3174 }
3175 if (jjte000 instanceof RuntimeException) {
3176 {if (true) throw (RuntimeException)jjte000;}
3177 }
3178 if (jjte000 instanceof ParseException) {
3179 {if (true) throw (ParseException)jjte000;}
3180 }
3181 {if (true) throw (Error)jjte000;}
3182 } finally {
3183 if (jjtc000) {
3184 jjtree.closeNodeScope(jjtn000, true);
3185 }
3186 }
3187 throw new Error("Missing return statement in function");
3188 }
3189
3190 final public StorageFunc LoadFunction() throws ParseException {
3191 /*@bgen(jjtree) LoadFunction */
3192 SimpleNode jjtn000 = new SimpleNode(JJTLOADFUNCTION);
3193 boolean jjtc000 = true;
3194 jjtree.openNodeScope(jjtn000);String funcName;
3195 try {
3196 funcName = QualifiedFunction();
3197 jjtree.closeNodeScope(jjtn000, true);
3198 jjtc000 = false;
3199 {if (true) return (StorageFunc) pigContext.getUDF(funcName);}
3200 } catch (Throwable jjte000) {
3201 if (jjtc000) {
3202 jjtree.clearNodeScope(jjtn000);
3203 jjtc000 = false;
3204 } else {
3205 jjtree.popNode();
3206 }
3207 if (jjte000 instanceof RuntimeException) {
3208 {if (true) throw (RuntimeException)jjte000;}
3209 }
3210 if (jjte000 instanceof ParseException) {
3211 {if (true) throw (ParseException)jjte000;}
3212 }
3213 {if (true) throw (Error)jjte000;}
3214 } finally {
3215 if (jjtc000) {
3216 jjtree.closeNodeScope(jjtn000, true);
3217 }
3218 }
3219 throw new Error("Missing return statement in function");
3220 }
3221
3222 final public FilterFunc FilterFunction() throws ParseException {
3223 /*@bgen(jjtree) FilterFunction */
3224 SimpleNode jjtn000 = new SimpleNode(JJTFILTERFUNCTION);
3225 boolean jjtc000 = true;
3226 jjtree.openNodeScope(jjtn000);String funcName;
3227 try {
3228 funcName = QualifiedFunction();
3229 jjtree.closeNodeScope(jjtn000, true);
3230 jjtc000 = false;
3231 {if (true) return (FilterFunc) pigContext.getUDF(funcName);}
3232 } catch (Throwable jjte000) {
3233 if (jjtc000) {
3234 jjtree.clearNodeScope(jjtn000);
3235 jjtc000 = false;
3236 } else {
3237 jjtree.popNode();
3238 }
3239 if (jjte000 instanceof RuntimeException) {
3240 {if (true) throw (RuntimeException)jjte000;}
3241 }
3242 if (jjte000 instanceof ParseException) {
3243 {if (true) throw (ParseException)jjte000;}
3244 }
3245 {if (true) throw (Error)jjte000;}
3246 } finally {
3247 if (jjtc000) {
3248 jjtree.closeNodeScope(jjtn000, true);
3249 }
3250 }
3251 throw new Error("Missing return statement in function");
3252 }
3253
3254 /**
3255 * Bug 831620 - '$' support
3256 */
3257 final public void ClassName() throws ParseException {
3258 jj_consume_token(IDENTIFIER);
3259 label_20:
3260 while (true) {
3261 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3262 case 62:
3263 case 67:
3264 ;
3265 break;
3266 default:
3267 jj_la1[69] = jj_gen;
3268 break label_20;
3269 }
3270 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3271 case 62:
3272 jj_consume_token(62);
3273 jj_consume_token(IDENTIFIER);
3274 break;
3275 case 67:
3276 jj_consume_token(67);
3277 jj_consume_token(IDENTIFIER);
3278 break;
3279 default:
3280 jj_la1[70] = jj_gen;
3281 jj_consume_token(-1);
3282 throw new ParseException();
3283 }
3284 }
3285 }
3286
3287 /**
3288 * Bug 831620 - '$' support
3289 */
3290 final public String QualifiedFunction() throws ParseException {
3291 Token t1;StringBuffer s=new StringBuffer();
3292 t1 = jj_consume_token(IDENTIFIER);
3293 s.append(t1.image);
3294 label_21:
3295 while (true) {
3296 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3297 case 62:
3298 case 67:
3299 ;
3300 break;
3301 default:
3302 jj_la1[71] = jj_gen;
3303 break label_21;
3304 }
3305 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3306 case 62:
3307 jj_consume_token(62);
3308 t1 = jj_consume_token(IDENTIFIER);
3309 s.append("." + t1.image);
3310 break;
3311 case 67:
3312 jj_consume_token(67);
3313 t1 = jj_consume_token(IDENTIFIER);
3314 s.append("$" + t1.image);
3315 break;
3316 default:
3317 jj_la1[72] = jj_gen;
3318 jj_consume_token(-1);
3319 throw new ParseException();
3320 }
3321 }
3322 {if (true) return s.toString();}
3323 throw new Error("Missing return statement in function");
3324 }
3325
3326 // If there is one time it may not be bracketed, but if multiple, they must be bracketed
3327 final public EvalItemList BracketedSimpleProj(SchemaItem over) throws ParseException {
3328 /*@bgen(jjtree) BracketedSimpleProj */
3329 SimpleNode jjtn000 = new SimpleNode(JJTBRACKETEDSIMPLEPROJ);
3330 boolean jjtc000 = true;
3331 jjtree.openNodeScope(jjtn000);EvalItem i = null; EvalItemList proj = new EvalItemList(pigContext);
3332 try {
3333 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3334 case STAR:
3335 case GROUP:
3336 case IDENTIFIER:
3337 case QUOTEDSTRING:
3338 case DOLLARVAR:
3339 i = PSimpleProjItem(over);
3340 proj.add(i);
3341 break;
3342 case 54:
3343 jj_consume_token(54);
3344 i = PSimpleProjItem(over);
3345 proj.add(i);
3346 label_22:
3347 while (true) {
3348 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3349 case 56:
3350 ;
3351 break;
3352 default:
3353 jj_la1[73] = jj_gen;
3354 break label_22;
3355 }
3356 jj_consume_token(56);
3357 i = PSimpleProjItem(over);
3358 proj.add(i);
3359 }
3360 jj_consume_token(55);
3361 break;
3362 default:
3363 jj_la1[74] = jj_gen;
3364 jj_consume_token(-1);
3365 throw new ParseException();
3366 }
3367 jjtree.closeNodeScope(jjtn000, true);
3368 jjtc000 = false;
3369 {if (true) return proj;}
3370 } catch (Throwable jjte000) {
3371 if (jjtc000) {
3372 jjtree.clearNodeScope(jjtn000);
3373 jjtc000 = false;
3374 } else {
3375 jjtree.popNode();
3376 }
3377 if (jjte000 instanceof RuntimeException) {
3378 {if (true) throw (RuntimeException)jjte000;}
3379 }
3380 if (jjte000 instanceof ParseException) {
3381 {if (true) throw (ParseException)jjte000;}
3382 }
3383 {if (true) throw (Error)jjte000;}
3384 } finally {
3385 if (jjtc000) {
3386 jjtree.closeNodeScope(jjtn000, true);
3387 }
3388 }
3389 throw new Error("Missing return statement in function");
3390 }
3391
3392 final public EvalItemList SimpleProjOrEmpty(SchemaItem over) throws ParseException {
3393 /*@bgen(jjtree) SimpleProjOrEmpty */
3394 SimpleNode jjtn000 = new SimpleNode(JJTSIMPLEPROJOREMPTY);
3395 boolean jjtc000 = true;
3396 jjtree.openNodeScope(jjtn000);EvalItemList list;
3397 try {
3398 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3399 case STAR:
3400 case GROUP:
3401 case IDENTIFIER:
3402 case QUOTEDSTRING:
3403 case DOLLARVAR:
3404 list = SimpleProj(over);
3405 break;
3406 default:
3407 jj_la1[75] = jj_gen;
3408 list = new EvalItemList(pigContext);
3409 }
3410 jjtree.closeNodeScope(jjtn000, true);
3411 jjtc000 = false;
3412 {if (true) return list;}
3413 } catch (Throwable jjte000) {
3414 if (jjtc000) {
3415 jjtree.clearNodeScope(jjtn000);
3416 jjtc000 = false;
3417 } else {
3418 jjtree.popNode();
3419 }
3420 if (jjte000 instanceof RuntimeException) {
3421 {if (true) throw (RuntimeException)jjte000;}
3422 }
3423 if (jjte000 instanceof ParseException) {
3424 {if (true) throw (ParseException)jjte000;}
3425 }
3426 {if (true) throw (Error)jjte000;}
3427 } finally {
3428 if (jjtc000) {
3429 jjtree.closeNodeScope(jjtn000, true);
3430 }
3431 }
3432 throw new Error("Missing return statement in function");
3433 }
3434
3435 //Just a simple list of projection items
3436 final public EvalItemList SimpleProj(SchemaItem over) throws ParseException {
3437 /*@bgen(jjtree) SimpleProj */
3438 SimpleNode jjtn000 = new SimpleNode(JJTSIMPLEPROJ);
3439 boolean jjtc000 = true;
3440 jjtree.openNodeScope(jjtn000);EvalItem i = null; EvalItemList proj = new EvalItemList(pigContext);
3441 try {
3442 i = PSimpleProjItem(over);
3443 proj.add(i);
3444 label_23:
3445 while (true) {
3446 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3447 case 56:
3448 ;
3449 break;
3450 default:
3451 jj_la1[76] = jj_gen;
3452 break label_23;
3453 }
3454 jj_consume_token(56);
3455 i = PSimpleProjItem(over);
3456 proj.add(i);
3457 }
3458 jjtree.closeNodeScope(jjtn000, true);
3459 jjtc000 = false;
3460 {if (true) return proj;}
3461 } catch (Throwable jjte000) {
3462 if (jjtc000) {
3463 jjtree.clearNodeScope(jjtn000);
3464 jjtc000 = false;
3465 } else {
3466 jjtree.popNode();
3467 }
3468 if (jjte000 instanceof RuntimeException) {
3469 {if (true) throw (RuntimeException)jjte000;}
3470 }
3471 if (jjte000 instanceof ParseException) {
3472 {if (true) throw (ParseException)jjte000;}
3473 }
3474 {if (true) throw (Error)jjte000;}
3475 } finally {
3476 if (jjtc000) {
3477 jjtree.closeNodeScope(jjtn000, true);
3478 }
3479 }
3480 throw new Error("Missing return statement in function");
3481 }
3482
3483 final public EvalItem PSimpleProjItem(SchemaItem over) throws ParseException {
3484 /*@bgen(jjtree) PSimpleProjItem */
3485 SimpleNode jjtn000 = new SimpleNode(JJTPSIMPLEPROJITEM);
3486 boolean jjtc000 = true;
3487 jjtree.openNodeScope(jjtn000);EvalItem item;
3488 try {
3489 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3490 case QUOTEDSTRING:
3491 item = Const();
3492 break;
3493 case GROUP:
3494 case IDENTIFIER:
3495 case DOLLARVAR:
3496 item = PColEvalItem(over,null);
3497 break;
3498 case STAR:
3499 item = Star();
3500 break;
3501 default:
3502 jj_la1[77] = jj_gen;
3503 jj_consume_token(-1);
3504 throw new ParseException();
3505 }
3506 jjtree.closeNodeScope(jjtn000, true);
3507 jjtc000 = false;
3508 {if (true) return item;}
3509 } catch (Throwable jjte000) {
3510 if (jjtc000) {
3511 jjtree.clearNodeScope(jjtn000);
3512 jjtc000 = false;
3513 } else {
3514 jjtree.popNode();
3515 }
3516 if (jjte000 instanceof RuntimeException) {
3517 {if (true) throw (RuntimeException)jjte000;}
3518 }
3519 if (jjte000 instanceof ParseException) {
3520 {if (true) throw (ParseException)jjte000;}
3521 }
3522 {if (true) throw (Error)jjte000;}
3523 } finally {
3524 if (jjtc000) {
3525 jjtree.closeNodeScope(jjtn000, true);
3526 }
3527 }
3528 throw new Error("Missing return statement in function");
3529 }
3530
3531 final public EvalItem Star() throws ParseException {
3532 /*@bgen(jjtree) Star */
3533 SimpleNode jjtn000 = new SimpleNode(JJTSTAR);
3534 boolean jjtc000 = true;
3535 jjtree.openNodeScope(jjtn000);Token t1;
3536 try {
3537 t1 = jj_consume_token(STAR);
3538 jjtree.closeNodeScope(jjtn000, true);
3539 jjtc000 = false;
3540 {if (true) return new StarEvalItem(pigContext);}
3541 } finally {
3542 if (jjtc000) {
3543 jjtree.closeNodeScope(jjtn000, true);
3544 }
3545 }
3546 throw new Error("Missing return statement in function");
3547 }
3548
3549 final public EvalItem Const() throws ParseException {
3550 /*@bgen(jjtree) Const */
3551 SimpleNode jjtn000 = new SimpleNode(JJTCONST);
3552 boolean jjtc000 = true;
3553 jjtree.openNodeScope(jjtn000);Token t1;
3554 try {
3555 t1 = jj_consume_token(QUOTEDSTRING);
3556 jjtree.closeNodeScope(jjtn000, true);
3557 jjtc000 = false;
3558 {if (true) return new ConstEvalItem(pigContext, unquote(t1.image));}
3559 } finally {
3560 if (jjtc000) {
3561 jjtree.closeNodeScope(jjtn000, true);
3562 }
3563 }
3564 throw new Error("Missing return statement in function");
3565 }
3566
3567 final public EvalItem PColEvalItem(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
3568 /*@bgen(jjtree) PColEvalItem */
3569 SimpleNode jjtn000 = new SimpleNode(JJTPCOLEVALITEM);
3570 boolean jjtc000 = true;
3571 jjtree.openNodeScope(jjtn000);EvalItem item;
3572 try {
3573 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3574 case DOLLARVAR:
3575 item = DollarVar();
3576 break;
3577 case GROUP:
3578 case IDENTIFIER:
3579 item = AliasField(over, pipes);
3580 break;
3581 default:
3582 jj_la1[78] = jj_gen;
3583 jj_consume_token(-1);
3584 throw new ParseException();
3585 }
3586 jjtree.closeNodeScope(jjtn000, true);
3587 jjtc000 = false;
3588 {if (true) return item;}
3589 } catch (Throwable jjte000) {
3590 if (jjtc000) {
3591 jjtree.clearNodeScope(jjtn000);
3592 jjtc000 = false;
3593 } else {
3594 jjtree.popNode();
3595 }
3596 if (jjte000 instanceof RuntimeException) {
3597 {if (true) throw (RuntimeException)jjte000;}
3598 }
3599 if (jjte000 instanceof ParseException) {
3600 {if (true) throw (ParseException)jjte000;}
3601 }
3602 {if (true) throw (Error)jjte000;}
3603 } finally {
3604 if (jjtc000) {
3605 jjtree.closeNodeScope(jjtn000, true);
3606 }
3607 }
3608 throw new Error("Missing return statement in function");
3609 }
3610
3611 final public ColEvalItem DollarVar() throws ParseException {
3612 /*@bgen(jjtree) DollarVar */
3613 SimpleNode jjtn000 = new SimpleNode(JJTDOLLARVAR);
3614 boolean jjtc000 = true;
3615 jjtree.openNodeScope(jjtn000);Token t1;
3616 try {
3617 t1 = jj_consume_token(DOLLARVAR);
3618 jjtree.closeNodeScope(jjtn000, true);
3619 jjtc000 = false;
3620 {if (true) return new ColEvalItem(pigContext, undollar(t1.image));}
3621 } finally {
3622 if (jjtc000) {
3623 jjtree.closeNodeScope(jjtn000, true);
3624 }
3625 }
3626 throw new Error("Missing return statement in function");
3627 }
3628
3629 final public EvalItem AliasField(SchemaItem over, Map<String, EvalItem> pipes) throws ParseException {
3630 /*@bgen(jjtree) AliasField */
3631 SimpleNode jjtn000 = new SimpleNode(JJTALIASFIELD);
3632 boolean jjtc000 = true;
3633 jjtree.openNodeScope(jjtn000);Token t1;
3634 try {
3635 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3636 case GROUP:
3637 t1 = jj_consume_token(GROUP);
3638 break;
3639 case IDENTIFIER:
3640 t1 = jj_consume_token(IDENTIFIER);
3641 break;
3642 default:
3643 jj_la1[79] = jj_gen;
3644 jj_consume_token(-1);
3645 throw new ParseException();
3646 }
3647 jjtree.closeNodeScope(jjtn000, true);
3648 jjtc000 = false;
3649 int i; EvalItem item = null;
3650 if (pipes!=null)
3651 item = pipes.get(t1.image);
3652
3653 if (item == null){
3654 if ( over == null || (i = over.colFor(t1.image)) == -1)
3655 {if (true) throw new ParseException("Invalid alias: " + t1.image + " in " + over.alias + "--> " + over);}
3656 item = new ColEvalItem(pigContext, i);
3657 }
3658 {if (true) return item;}
3659 } finally {
3660 if (jjtc000) {
3661 jjtree.closeNodeScope(jjtn000, true);
3662 }
3663 }
3664 throw new Error("Missing return statement in function");
3665 }
3666
3667 final private boolean jj_2_1(int xla) {
3668 jj_la = xla; jj_lastpos = jj_scanpos = token;
3669 try { return !jj_3_1(); }
3670 catch(LookaheadSuccess ls) { return true; }
3671 finally { jj_save(0, xla); }
3672 }
3673
3674 final private boolean jj_2_2(int xla) {
3675 jj_la = xla; jj_lastpos = jj_scanpos = token;
3676 try { return !jj_3_2(); }
3677 catch(LookaheadSuccess ls) { return true; }
3678 finally { jj_save(1, xla); }
3679 }
3680
3681 final private boolean jj_2_3(int xla) {
3682 jj_la = xla; jj_lastpos = jj_scanpos = token;
3683 try { return !jj_3_3(); }
3684 catch(LookaheadSuccess ls) { return true; }
3685 finally { jj_save(2, xla); }
3686 }
3687
3688 final private boolean jj_2_4(int xla) {
3689 jj_la = xla; jj_lastpos = jj_scanpos = token;
3690 try { return !jj_3_4(); }
3691 catch(LookaheadSuccess ls) { return true; }
3692 finally { jj_save(3, xla); }
3693 }
3694
3695 final private boolean jj_2_5(int xla) {
3696 jj_la = xla; jj_lastpos = jj_scanpos = token;
3697 try { return !jj_3_5(); }
3698 catch(LookaheadSuccess ls) { return true; }
3699 finally { jj_save(4, xla); }
3700 }
3701
3702 final private boolean jj_2_6(int xla) {
3703 jj_la = xla; jj_lastpos = jj_scanpos = token;
3704 try { return !jj_3_6(); }
3705 catch(LookaheadSuccess ls) { return true; }
3706 finally { jj_save(5, xla); }
3707 }
3708
3709 final private boolean jj_2_7(int xla) {
3710 jj_la = xla; jj_lastpos = jj_scanpos = token;
3711 try { return !jj_3_7(); }
3712 catch(LookaheadSuccess ls) { return true; }
3713 finally { jj_save(6, xla); }
3714 }
3715
3716 final private boolean jj_2_8(int xla) {
3717 jj_la = xla; jj_lastpos = jj_scanpos = token;
3718 try { return !jj_3_8(); }
3719 catch(LookaheadSuccess ls) { return true; }
3720 finally { jj_save(7, xla); }
3721 }
3722
3723 final private boolean jj_2_9(int xla) {
3724 jj_la = xla; jj_lastpos = jj_scanpos = token;
3725 try { return !jj_3_9(); }
3726 catch(LookaheadSuccess ls) { return true; }
3727 finally { jj_save(8, xla); }
3728 }
3729
3730 final private boolean jj_2_10(int xla) {
3731 jj_la = xla; jj_lastpos = jj_scanpos = token;
3732 try { return !jj_3_10(); }
3733 catch(LookaheadSuccess ls) { return true; }
3734 finally { jj_save(9, xla); }
3735 }
3736
3737 final private boolean jj_2_11(int xla) {
3738 jj_la = xla; jj_lastpos = jj_scanpos = token;
3739 try { return !jj_3_11(); }
3740 catch(LookaheadSuccess ls) { return true; }
3741 finally { jj_save(10, xla); }
3742 }
3743
3744 final private boolean jj_2_12(int xla) {
3745 jj_la = xla; jj_lastpos = jj_scanpos = token;
3746 try { return !jj_3_12(); }
3747 catch(LookaheadSuccess ls) { return true; }
3748 finally { jj_save(11, xla); }
3749 }
3750
3751 final private boolean jj_2_13(int xla) {
3752 jj_la = xla; jj_lastpos = jj_scanpos = token;
3753 try { return !jj_3_13(); }
3754 catch(LookaheadSuccess ls) { return true; }
3755 finally { jj_save(12, xla); }
3756 }
3757
3758 final private boolean jj_2_14(int xla) {
3759 jj_la = xla; jj_lastpos = jj_scanpos = token;
3760 try { return !jj_3_14(); }
3761 catch(LookaheadSuccess ls) { return true; }
3762 finally { jj_save(13, xla); }
3763 }
3764
3765 final private boolean jj_2_15(int xla) {
3766 jj_la = xla; jj_lastpos = jj_scanpos = token;
3767 try { return !jj_3_15(); }
3768 catch(LookaheadSuccess ls) { return true; }
3769 finally { jj_save(14, xla); }
3770 }
3771
3772 final private boolean jj_2_16(int xla) {
3773 jj_la = xla; jj_lastpos = jj_scanpos = token;
3774 try { return !jj_3_16(); }
3775 catch(LookaheadSuccess ls) { return true; }
3776 finally { jj_save(15, xla); }
3777 }
3778
3779 final private boolean jj_2_17(int xla) {
3780 jj_la = xla; jj_lastpos = jj_scanpos = token;
3781 try { return !jj_3_17(); }
3782 catch(LookaheadSuccess ls) { return true; }
3783 finally { jj_save(16, xla); }
3784 }
3785
3786 final private boolean jj_2_18(int xla) {
3787 jj_la = xla; jj_lastpos = jj_scanpos = token;
3788 try { return !jj_3_18(); }
3789 catch(LookaheadSuccess ls) { return true; }
3790 finally { jj_save(17, xla); }
3791 }
3792
3793 final private boolean jj_2_19(int xla) {
3794 jj_la = xla; jj_lastpos = jj_scanpos = token;
3795 try { return !jj_3_19(); }
3796 catch(LookaheadSuccess ls) { return true; }
3797 finally { jj_save(18, xla); }
3798 }
3799
3800 final private boolean jj_3R_63() {
3801 if (jj_3R_85()) return true;
3802 Token xsp;
3803 while (true) {
3804 xsp = jj_scanpos;
3805 if (jj_3R_86()) { jj_scanpos = xsp; break; }
3806 }
3807 return false;
3808 }
3809
3810 final private boolean jj_3R_121() {
3811 if (jj_3R_26()) return true;
3812 if (jj_scan_token(54)) return true;
3813 if (jj_3R_55()) return true;
3814 if (jj_scan_token(55)) return true;
3815 return false;
3816 }
3817
3818 final private boolean jj_3R_120() {
3819 if (jj_3R_38()) return true;
3820 if (jj_scan_token(MATCHES)) return true;
3821 if (jj_scan_token(QUOTEDSTRING)) return true;
3822 return false;
3823 }
3824
3825 final private boolean jj_3R_119() {
3826 if (jj_3R_38()) return true;
3827 if (jj_scan_token(FILTEROP)) return true;
3828 if (jj_3R_38()) return true;
3829 return false;
3830 }
3831
3832 final private boolean jj_3R_118() {
3833 if (jj_3R_129()) return true;
3834 return false;
3835 }
3836
3837 final private boolean jj_3R_117() {
3838 if (jj_scan_token(54)) return true;
3839 if (jj_3R_37()) return true;
3840 if (jj_scan_token(55)) return true;
3841 return false;
3842 }
3843
3844 final private boolean jj_3R_99() {
3845 Token xsp;
3846 xsp = jj_scanpos;
3847 if (jj_3R_117()) {
3848 jj_scanpos = xsp;
3849 if (jj_3R_118()) {
3850 jj_scanpos = xsp;
3851 if (jj_3R_119()) {
3852 jj_scanpos = xsp;
3853 if (jj_3R_120()) {
3854 jj_scanpos = xsp;
3855 if (jj_3R_121()) return true;
3856 }
3857 }
3858 }
3859 }
3860 return false;
3861 }
3862
3863 final private boolean jj_3R_64() {
3864 if (jj_scan_token(OR)) return true;
3865 if (jj_3R_63()) return true;
3866 return false;
3867 }
3868
3869 final private boolean jj_3R_126() {
3870 Token xsp;
3871 xsp = jj_scanpos;
3872 if (jj_scan_token(29)) {
3873 jj_scanpos = xsp;
3874 if (jj_scan_token(46)) return true;
3875 }
3876 return false;
3877 }
3878
3879 final private boolean jj_3R_42() {
3880 if (jj_3R_63()) return true;
3881 Token xsp;
3882 while (true) {
3883 xsp = jj_scanpos;
3884 if (jj_3R_64()) { jj_scanpos = xsp; break; }
3885 }
3886 return false;
3887 }
3888
3889 final private boolean jj_3R_100() {
3890 if (jj_scan_token(AND)) return true;
3891 if (jj_3R_99()) return true;
3892 return false;
3893 }
3894
3895 final private boolean jj_3R_25() {
3896 if (jj_3R_42()) return true;
3897 return false;
3898 }
3899
3900 final private boolean jj_3R_35() {
3901 if (jj_scan_token(DOLLARVAR)) return true;
3902 return false;
3903 }
3904
3905 final private boolean jj_3R_79() {
3906 if (jj_3R_99()) return true;
3907 Token xsp;
3908 while (true) {
3909 xsp = jj_scanpos;
3910 if (jj_3R_100()) { jj_scanpos = xsp; break; }
3911 }
3912 return false;
3913 }
3914
3915 final private boolean jj_3R_116() {
3916 if (jj_3R_81()) return true;
3917 return false;
3918 }
3919
3920 final private boolean jj_3R_112() {
3921 if (jj_3R_126()) return true;
3922 return false;
3923 }
3924
3925 final private boolean jj_3R_115() {
3926 if (jj_3R_27()) return true;
3927 return false;
3928 }
3929
3930 final private boolean jj_3R_111() {
3931 if (jj_3R_35()) return true;
3932 return false;
3933 }
3934
3935 final private boolean jj_3R_94() {
3936 Token xsp;
3937 xsp = jj_scanpos;
3938 if (jj_3R_115()) {
3939 jj_scanpos = xsp;
3940 if (jj_3R_116()) return true;
3941 }
3942 return false;
3943 }
3944
3945 final private boolean jj_3R_91() {
3946 Token xsp;
3947 xsp = jj_scanpos;
3948 if (jj_3R_111()) {
3949 jj_scanpos = xsp;
3950 if (jj_3R_112()) return true;
3951 }
3952 return false;
3953 }
3954
3955 final private boolean jj_3R_80() {
3956 if (jj_scan_token(OR)) return true;
3957 if (jj_3R_79()) return true;
3958 return false;
3959 }
3960
3961 final private boolean jj_3R_56() {
3962 if (jj_3R_79()) return true;
3963 Token xsp;
3964 while (true) {
3965 xsp = jj_scanpos;
3966 if (jj_3R_80()) { jj_scanpos = xsp; break; }
3967 }
3968 return false;
3969 }
3970
3971 final private boolean jj_3R_68() {
3972 if (jj_scan_token(QUOTEDSTRING)) return true;
3973 return false;
3974 }
3975
3976 final private boolean jj_3R_74() {
3977 return false;
3978 }
3979
3980 final private boolean jj_3R_37() {
3981 if (jj_3R_56()) return true;
3982 return false;
3983 }
3984
3985 final private boolean jj_3R_95() {
3986 if (jj_scan_token(56)) return true;
3987 if (jj_3R_94()) return true;
3988 return false;
3989 }
3990
3991 final private boolean jj_3R_81() {
3992 if (jj_scan_token(STAR)) return true;
3993 return false;
3994 }
3995
3996 final private boolean jj_3R_73() {
3997 if (jj_3R_94()) return true;
3998 Token xsp;
3999 while (true) {
4000 xsp = jj_scanpos;
4001 if (jj_3R_95()) { jj_scanpos = xsp; break; }
4002 }
4003 return false;
4004 }
4005
4006 final private boolean jj_3R_48() {
4007 Token xsp;
4008 xsp = jj_scanpos;
4009 if (jj_3R_73()) {
4010 jj_scanpos = xsp;
4011 if (jj_3R_74()) return true;
4012 }
4013 return false;
4014 }
4015
4016 final private boolean jj_3R_134() {
4017 if (jj_3R_81()) return true;
4018 return false;
4019 }
4020
4021 final private boolean jj_3R_133() {
4022 if (jj_3R_91()) return true;
4023 return false;
4024 }
4025
4026 final private boolean jj_3R_30() {
4027 if (jj_3R_47()) return true;
4028 if (jj_scan_token(54)) return true;
4029 if (jj_3R_48()) return true;
4030 if (jj_scan_token(55)) return true;
4031 return false;
4032 }
4033
4034 final private boolean jj_3R_139() {
4035 if (jj_scan_token(56)) return true;
4036 if (jj_3R_127()) return true;
4037 return false;
4038 }
4039
4040 final private boolean jj_3R_132() {
4041 if (jj_3R_68()) return true;
4042 return false;
4043 }
4044
4045 final private boolean jj_3R_127() {
4046 Token xsp;
4047 xsp = jj_scanpos;
4048 if (jj_3R_132()) {
4049 jj_scanpos = xsp;
4050 if (jj_3R_133()) {
4051 jj_scanpos = xsp;
4052 if (jj_3R_134()) return true;
4053 }
4054 }
4055 return false;
4056 }
4057
4058 final private boolean jj_3R_36() {
4059 if (jj_scan_token(54)) return true;
4060 if (jj_3R_37()) return true;
4061 if (jj_scan_token(63)) return true;
4062 if (jj_3R_38()) return true;
4063 if (jj_scan_token(64)) return true;
4064 if (jj_3R_38()) return true;
4065 if (jj_scan_token(55)) return true;
4066 return false;
4067 }
4068
4069 final private boolean jj_3_15() {
4070 if (jj_3R_36()) return true;
4071 return false;
4072 }
4073
4074 final private boolean jj_3_13() {
4075 if (jj_3R_34()) return true;
4076 return false;
4077 }
4078
4079 final private boolean jj_3_14() {
4080 if (jj_3R_35()) return true;
4081 return false;
4082 }
4083
4084 final private boolean jj_3R_92() {
4085 if (jj_scan_token(54)) return true;
4086 if (jj_3R_25()) return true;
4087 if (jj_scan_token(63)) return true;
4088 if (jj_3R_29()) return true;
4089 if (jj_scan_token(64)) return true;
4090 if (jj_3R_29()) return true;
4091 if (jj_scan_token(55)) return true;
4092 return false;
4093 }
4094
4095 final private boolean jj_3R_72() {
4096 if (jj_scan_token(62)) return true;
4097 if (jj_3R_93()) return true;
4098 return false;
4099 }
4100
4101 final private boolean jj_3R_34() {
4102 if (jj_3R_47()) return true;
4103 if (jj_scan_token(54)) return true;
4104 if (jj_3R_55()) return true;
4105 if (jj_scan_token(55)) return true;
4106 return false;
4107 }
4108
4109 final private boolean jj_3R_138() {
4110 if (jj_3R_127()) return true;
4111 Token xsp;
4112 while (true) {
4113 xsp = jj_scanpos;
4114 if (jj_3R_139()) { jj_scanpos = xsp; break; }
4115 }
4116 return false;
4117 }
4118
4119 final private boolean jj_3R_124() {
4120 if (jj_3R_131()) return true;
4121 return false;
4122 }
4123
4124 final private boolean jj_3_9() {
4125 if (jj_3R_30()) return true;
4126 return false;
4127 }
4128
4129 final private boolean jj_3R_103() {
4130 if (jj_3R_36()) return true;
4131 return false;
4132 }
4133
4134 final private boolean jj_3R_102() {
4135 if (jj_3R_35()) return true;
4136 return false;
4137 }
4138
4139 final private boolean jj_3R_101() {
4140 if (jj_3R_34()) return true;
4141 return false;
4142 }
4143
4144 final private boolean jj_3R_82() {
4145 Token xsp;
4146 xsp = jj_scanpos;
4147 if (jj_3R_101()) {
4148 jj_scanpos = xsp;
4149 if (jj_3R_102()) {
4150 jj_scanpos = xsp;
4151 if (jj_3R_103()) return true;
4152 }
4153 }
4154 return false;
4155 }
4156
4157 final private boolean jj_3R_128() {
4158 if (jj_scan_token(56)) return true;
4159 if (jj_3R_127()) return true;
4160 return false;
4161 }
4162
4163 final private boolean jj_3R_71() {
4164 if (jj_3R_92()) return true;
4165 return false;
4166 }
4167
4168 final private boolean jj_3R_70() {
4169 if (jj_3R_91()) return true;
4170 return false;
4171 }
4172
4173 final private boolean jj_3R_69() {
4174 if (jj_3R_30()) return true;
4175 return false;
4176 }
4177
4178 final private boolean jj_3R_84() {
4179 if (jj_scan_token(62)) return true;
4180 if (jj_scan_token(54)) return true;
4181 if (jj_3R_81()) return true;
4182 if (jj_scan_token(55)) return true;
4183 return false;
4184 }
4185
4186 final private boolean jj_3R_114() {
4187 if (jj_scan_token(54)) return true;
4188 if (jj_3R_127()) return true;
4189 Token xsp;
4190 while (true) {
4191 xsp = jj_scanpos;
4192 if (jj_3R_128()) { jj_scanpos = xsp; break; }
4193 }
4194 if (jj_scan_token(55)) return true;
4195 return false;
4196 }
4197
4198 final private boolean jj_3R_62() {
4199 if (jj_scan_token(IDENTIFIER)) return true;
4200 return false;
4201 }
4202
4203 final private boolean jj_3R_113() {
4204 if (jj_3R_127()) return true;
4205 return false;
4206 }
4207
4208 final private boolean jj_3R_93() {
4209 Token xsp;
4210 xsp = jj_scanpos;
4211 if (jj_3R_113()) {
4212 jj_scanpos = xsp;
4213 if (jj_3R_114()) return true;
4214 }
4215 return false;
4216 }
4217
4218 final private boolean jj_3R_83() {
4219 if (jj_scan_token(65)) return true;
4220 if (jj_3R_104()) return true;
4221 if (jj_scan_token(66)) return true;
4222 return false;
4223 }
4224
4225 final private boolean jj_3R_46() {
4226 Token xsp;
4227 xsp = jj_scanpos;
4228 if (jj_3R_69()) {
4229 jj_scanpos = xsp;
4230 if (jj_3R_70()) {
4231 jj_scanpos = xsp;
4232 if (jj_3R_71()) return true;
4233 }
4234 }
4235 xsp = jj_scanpos;
4236 if (jj_3R_72()) jj_scanpos = xsp;
4237 return false;
4238 }
4239
4240 final private boolean jj_3R_45() {
4241 if (jj_3R_68()) return true;
4242 return false;
4243 }
4244
4245 final private boolean jj_3R_29() {
4246 Token xsp;
4247 xsp = jj_scanpos;
4248 if (jj_3R_45()) {
4249 jj_scanpos = xsp;
4250 if (jj_3R_46()) return true;
4251 }
4252 return false;
4253 }
4254
4255 final private boolean jj_3_8() {
4256 if (jj_3R_29()) return true;
4257 return false;
4258 }
4259
4260 final private boolean jj_3R_59() {
4261 if (jj_3R_82()) return true;
4262 Token xsp;
4263 while (true) {
4264 xsp = jj_scanpos;
4265 if (jj_3R_83()) { jj_scanpos = xsp; break; }
4266 }
4267 xsp = jj_scanpos;
4268 if (jj_3R_84()) jj_scanpos = xsp;
4269 return false;
4270 }
4271
4272 final private boolean jj_3R_88() {
4273 if (jj_scan_token(67)) return true;
4274 if (jj_scan_token(IDENTIFIER)) return true;
4275 return false;
4276 }
4277
4278 final private boolean jj_3R_41() {
4279 if (jj_scan_token(54)) return true;
4280 return false;
4281 }
4282
4283 final private boolean jj_3R_58() {
4284 if (jj_3R_81()) return true;
4285 return false;
4286 }
4287
4288 final private boolean jj_3R_87() {
4289 if (jj_scan_token(62)) return true;
4290 if (jj_scan_token(IDENTIFIER)) return true;
4291 return false;
4292 }
4293
4294 final private boolean jj_3_2() {
4295 if (jj_scan_token(54)) return true;
4296 if (jj_3R_24()) return true;
4297 return false;
4298 }
4299
4300 final private boolean jj_3R_57() {
4301 if (jj_3R_68()) return true;
4302 return false;
4303 }
4304
4305 final private boolean jj_3R_65() {
4306 Token xsp;
4307 xsp = jj_scanpos;
4308 if (jj_3R_87()) {
4309 jj_scanpos = xsp;
4310 if (jj_3R_88()) return true;
4311 }
4312 return false;
4313 }
4314
4315 final private boolean jj_3R_40() {
4316 if (jj_3R_62()) return true;
4317 return false;
4318 }
4319
4320 final private boolean jj_3R_38() {
4321 Token xsp;
4322 xsp = jj_scanpos;
4323 if (jj_3R_57()) {
4324 jj_scanpos = xsp;
4325 if (jj_3R_58()) {
4326 jj_scanpos = xsp;
4327 if (jj_3R_59()) return true;
4328 }
4329 }
4330 return false;
4331 }
4332
4333 final private boolean jj_3R_123() {
4334 if (jj_scan_token(EVAL)) return true;
4335 if (jj_3R_55()) return true;
4336 return false;
4337 }
4338
4339 final private boolean jj_3R_24() {
4340 Token xsp;
4341 xsp = jj_scanpos;
4342 if (jj_3R_40()) {
4343 jj_scanpos = xsp;
4344 if (jj_3_2()) {
4345 jj_scanpos = xsp;
4346 if (jj_3R_41()) return true;
4347 }
4348 }
4349 return false;
4350 }
4351
4352 final private boolean jj_3R_43() {
4353 if (jj_scan_token(IDENTIFIER)) return true;
4354 Token xsp;
4355 while (true) {
4356 xsp = jj_scanpos;
4357 if (jj_3R_65()) { jj_scanpos = xsp; break; }
4358 }
4359 return false;
4360 }
4361
4362 final private boolean jj_3R_110() {
4363 if (jj_scan_token(54)) return true;
4364 if (jj_3R_27()) return true;
4365 if (jj_scan_token(55)) return true;
4366 return false;
4367 }
4368
4369 final private boolean jj_3R_78() {
4370 if (jj_scan_token(56)) return true;
4371 if (jj_3R_38()) return true;
4372 return false;
4373 }
4374
4375 final private boolean jj_3R_109() {
4376 if (jj_3R_29()) return true;
4377 return false;
4378 }
4379
4380 final private boolean jj_3R_89() {
4381 Token xsp;
4382 xsp = jj_scanpos;
4383 if (jj_3R_109()) {
4384 jj_scanpos = xsp;
4385 if (jj_3R_110()) return true;
4386 }
4387 return false;
4388 }
4389
4390 final private boolean jj_3R_55() {
4391 if (jj_3R_38()) return true;
4392 Token xsp;
4393 while (true) {
4394 xsp = jj_scanpos;
4395 if (jj_3R_78()) { jj_scanpos = xsp; break; }
4396 }
4397 return false;
4398 }
4399
4400 final private boolean jj_3R_137() {
4401 if (jj_scan_token(DISTINCT)) return true;
4402 if (jj_3R_138()) return true;
4403 return false;
4404 }
4405
4406 final private boolean jj_3R_136() {
4407 if (jj_scan_token(ARRANGE)) return true;
4408 if (jj_scan_token(BY)) return true;
4409 if (jj_3R_138()) return true;
4410 return false;
4411 }
4412
4413 final private boolean jj_3R_135() {
4414 if (jj_scan_token(ORDER)) return true;
4415 if (jj_scan_token(BY)) return true;
4416 if (jj_3R_138()) return true;
4417 return false;
4418 }
4419
4420 final private boolean jj_3R_131() {
4421 Token xsp;
4422 xsp = jj_scanpos;
4423 if (jj_3R_135()) {
4424 jj_scanpos = xsp;
4425 if (jj_3R_136()) {
4426 jj_scanpos = xsp;
4427 if (jj_3R_137()) return true;
4428 }
4429 }
4430 return false;
4431 }
4432
4433 final private boolean jj_3R_26() {
4434 if (jj_3R_43()) return true;
4435 return false;
4436 }
4437
4438 final private boolean jj_3R_90() {
4439 Token xsp;
4440 xsp = jj_scanpos;
4441 if (jj_scan_token(27)) {
4442 jj_scanpos = xsp;
4443 if (jj_scan_token(61)) return true;
4444 }
4445 if (jj_3R_89()) return true;
4446 return false;
4447 }
4448
4449 final private boolean jj_3_1() {
4450 if (jj_scan_token(IDENTIFIER)) return true;
4451 if (jj_scan_token(52)) return true;
4452 return false;
4453 }
4454
4455 final private boolean jj_3R_130() {
4456 if (jj_3R_25()) return true;
4457 return false;
4458 }
4459
4460 final private boolean jj_3R_66() {
4461 if (jj_3R_89()) return true;
4462 Token xsp;
4463 while (true) {
4464 xsp = jj_scanpos;
4465 if (jj_3R_90()) { jj_scanpos = xsp; break; }
4466 }
4467 return false;
4468 }
4469
4470 final private boolean jj_3R_122() {
4471 if (jj_scan_token(FILTER)) return true;
4472 if (jj_3R_130()) return true;
4473 return false;
4474 }
4475
4476 final private boolean jj_3R_104() {
4477 Token xsp;
4478 xsp = jj_scanpos;
4479 if (jj_3R_122()) {
4480 jj_scanpos = xsp;
4481 if (jj_3R_123()) {
4482 jj_scanpos = xsp;
4483 if (jj_3R_124()) return true;
4484 }
4485 }
4486 return false;
4487 }
4488
4489 final private boolean jj_3R_28() {
4490 if (jj_3R_43()) return true;
4491 return false;
4492 }
4493
4494 final private boolean jj_3R_47() {
4495 if (jj_3R_43()) return true;
4496 return false;
4497 }
4498
4499 final private boolean jj_3_7() {
4500 if (jj_3R_28()) return true;
4501 if (jj_scan_token(54)) return true;
4502 return false;
4503 }
4504
4505 final private boolean jj_3R_67() {
4506 Token xsp;
4507 xsp = jj_scanpos;
4508 if (jj_scan_token(59)) {
4509 jj_scanpos = xsp;
4510 if (jj_scan_token(60)) return true;
4511 }
4512 if (jj_3R_66()) return true;
4513 return false;
4514 }
4515
4516 final private boolean jj_3R_76() {
4517 if (jj_scan_token(56)) return true;
4518 if (jj_3R_75()) return true;
4519 return false;
4520 }
4521
4522 final private boolean jj_3R_61() {
4523 if (jj_scan_token(HOURS)) return true;
4524 return false;
4525 }
4526
4527 final private boolean jj_3R_44() {
4528 if (jj_3R_66()) return true;
4529 Token xsp;
4530 while (true) {
4531 xsp = jj_scanpos;
4532 if (jj_3R_67()) { jj_scanpos = xsp; break; }
4533 }
4534 return false;
4535 }
4536
4537 final private boolean jj_3R_60() {
4538 if (jj_scan_token(MINUTES)) return true;
4539 return false;
4540 }
4541
4542 final private boolean jj_3R_51() {
4543 return false;
4544 }
4545
4546 final private boolean jj_3R_49() {
4547 if (jj_scan_token(IDENTIFIER)) return true;
4548 if (jj_scan_token(64)) return true;
4549 return false;
4550 }
4551
4552 final private boolean jj_3R_50() {
4553 if (jj_3R_75()) return true;
4554 Token xsp;
4555 while (true) {
4556 xsp = jj_scanpos;
4557 if (jj_3R_76()) { jj_scanpos = xsp; break; }
4558 }
4559 return false;
4560 }
4561
4562 final private boolean jj_3R_27() {
4563 if (jj_3R_44()) return true;
4564 return false;
4565 }
4566
4567 final private boolean jj_3R_31() {
4568 Token xsp;
4569 xsp = jj_scanpos;
4570 if (jj_3R_49()) jj_scanpos = xsp;
4571 if (jj_scan_token(65)) return true;
4572 xsp = jj_scanpos;
4573 if (jj_3R_50()) {
4574 jj_scanpos = xsp;
4575 if (jj_3R_51()) return true;
4576 }
4577 if (jj_scan_token(66)) return true;
4578 return false;
4579 }
4580
4581 final private boolean jj_3R_39() {
4582 if (jj_scan_token(NUMBER)) return true;
4583 Token xsp;
4584 xsp = jj_scanpos;
4585 if (jj_scan_token(35)) {
4586 jj_scanpos = xsp;
4587 if (jj_3R_60()) {
4588 jj_scanpos = xsp;
4589 if (jj_3R_61()) return true;
4590 }
4591 }
4592 return false;
4593 }
4594
4595 final private boolean jj_3_19() {
4596 if (jj_3R_39()) return true;
4597 return false;
4598 }
4599
4600 final private boolean jj_3R_77() {
4601 if (jj_scan_token(56)) return true;
4602 if (jj_3R_75()) return true;
4603 return false;
4604 }
4605
4606 final private boolean jj_3R_54() {
4607 return false;
4608 }
4609
4610 final private boolean jj_3R_125() {
4611 if (jj_scan_token(NOT)) return true;
4612 if (jj_3R_85()) return true;
4613 return false;
4614 }
4615
4616 final private boolean jj_3_5() {
4617 if (jj_3R_27()) return true;
4618 if (jj_scan_token(FILTEROP)) return true;
4619 return false;
4620 }
4621
4622 final private boolean jj_3_4() {
4623 if (jj_3R_26()) return true;
4624 if (jj_scan_token(54)) return true;
4625 return false;
4626 }
4627
4628 final private boolean jj_3_3() {
4629 if (jj_scan_token(54)) return true;
4630 if (jj_3R_25()) return true;
4631 if (jj_scan_token(55)) return true;
4632 return false;
4633 }
4634
4635 final private boolean jj_3_6() {
4636 if (jj_3R_27()) return true;
4637 if (jj_scan_token(MATCHES)) return true;
4638 if (jj_scan_token(QUOTEDSTRING)) return true;
4639 return false;
4640 }
4641
4642 final private boolean jj_3R_108() {
4643 if (jj_3R_27()) return true;
4644 if (jj_scan_token(FILTEROP)) return true;
4645 if (jj_3R_27()) return true;
4646 return false;
4647 }
4648
4649 final private boolean jj_3R_53() {
4650 if (jj_3R_75()) return true;
4651 Token xsp;
4652 while (true) {
4653 xsp = jj_scanpos;
4654 if (jj_3R_77()) { jj_scanpos = xsp; break; }
4655 }
4656 return false;
4657 }
4658
4659 final private boolean jj_3R_107() {
4660 if (jj_3R_125()) return true;
4661 return false;
4662 }
4663
4664 final private boolean jj_3R_52() {
4665 Token xsp;
4666 xsp = jj_scanpos;
4667 if (jj_scan_token(46)) {
4668 jj_scanpos = xsp;
4669 if (jj_scan_token(29)) return true;
4670 }
4671 if (jj_scan_token(64)) return true;
4672 return false;
4673 }
4674
4675 final private boolean jj_3R_106() {
4676 if (jj_3R_26()) return true;
4677 if (jj_scan_token(54)) return true;
4678 if (jj_3R_48()) return true;
4679 if (jj_scan_token(55)) return true;
4680 return false;
4681 }
4682
4683 final private boolean jj_3R_32() {
4684 Token xsp;
4685 xsp = jj_scanpos;
4686 if (jj_3R_52()) jj_scanpos = xsp;
4687 if (jj_scan_token(54)) return true;
4688 xsp = jj_scanpos;
4689 if (jj_3R_53()) {
4690 jj_scanpos = xsp;
4691 if (jj_3R_54()) return true;
4692 }
4693 if (jj_scan_token(55)) return true;
4694 return false;
4695 }
4696
4697 final private boolean jj_3R_105() {
4698 if (jj_scan_token(54)) return true;
4699 if (jj_3R_25()) return true;
4700 if (jj_scan_token(55)) return true;
4701 return false;
4702 }
4703
4704 final private boolean jj_3_11() {
4705 if (jj_3R_32()) return true;
4706 return false;
4707 }
4708
4709 final private boolean jj_3R_85() {
4710 Token xsp;
4711 xsp = jj_scanpos;
4712 if (jj_3R_105()) {
4713 jj_scanpos = xsp;
4714 if (jj_3R_106()) {
4715 jj_scanpos = xsp;
4716 if (jj_3R_107()) {
4717 jj_scanpos = xsp;
4718 if (jj_3R_108()) {
4719 jj_scanpos = xsp;
4720 if (jj_3_6()) return true;
4721 }
4722 }
4723 }
4724 }
4725 return false;
4726 }
4727
4728 final private boolean jj_3_10() {
4729 if (jj_3R_31()) return true;
4730 return false;
4731 }
4732
4733 final private boolean jj_3_12() {
4734 if (jj_3R_33()) return true;
4735 return false;
4736 }
4737
4738 final private boolean jj_3R_33() {
4739 Token xsp;
4740 xsp = jj_scanpos;
4741 if (jj_scan_token(46)) {
4742 jj_scanpos = xsp;
4743 if (jj_scan_token(29)) return true;
4744 }
4745 return false;
4746 }
4747
4748 final private boolean jj_3_18() {
4749 if (jj_3R_38()) return true;
4750 if (jj_scan_token(MATCHES)) return true;
4751 return false;
4752 }
4753
4754 final private boolean jj_3R_129() {
4755 if (jj_scan_token(NOT)) return true;
4756 if (jj_3R_99()) return true;
4757 return false;
4758 }
4759
4760 final private boolean jj_3R_97() {
4761 if (jj_3R_32()) return true;
4762 return false;
4763 }
4764
4765 final private boolean jj_3_17() {
4766 if (jj_3R_38()) return true;
4767 if (jj_scan_token(FILTEROP)) return true;
4768 return false;
4769 }
4770
4771 final private boolean jj_3R_96() {
4772 if (jj_3R_31()) return true;
4773 return false;
4774 }
4775
4776 final private boolean jj_3R_86() {
4777 if (jj_scan_token(AND)) return true;
4778 if (jj_3R_85()) return true;
4779 return false;
4780 }
4781
4782 final private boolean jj_3R_75() {
4783 Token xsp;
4784 xsp = jj_scanpos;
4785 if (jj_3R_96()) {
4786 jj_scanpos = xsp;
4787 if (jj_3R_97()) {
4788 jj_scanpos = xsp;
4789 if (jj_3R_98()) return true;
4790 }
4791 }
4792 return false;
4793 }
4794
4795 final private boolean jj_3R_98() {
4796 if (jj_3R_33()) return true;
4797 return false;
4798 }
4799
4800 final private boolean jj_3_16() {
4801 if (jj_scan_token(54)) return true;
4802 if (jj_3R_37()) return true;
4803 if (jj_scan_token(55)) return true;
4804 return false;
4805 }
4806
4807 public QueryParserTokenManager token_source;
4808 SimpleCharStream jj_input_stream;
4809 public Token token, jj_nt;
4810 private int jj_ntk;
4811 private Token jj_scanpos, jj_lastpos;
4812 private int jj_la;
4813 public boolean lookingAhead = false;
4814 private boolean jj_semLA;
4815 private int jj_gen;
4816 final private int[] jj_la1 = new int[80];
4817 static private int[] jj_la1_0;
4818 static private int[] jj_la1_1;
4819 static private int[] jj_la1_2;
4820 static {
4821 jj_la1_0();
4822 jj_la1_1();
4823 jj_la1_2();
4824 }
4825 private static void jj_la1_0() {
4826 jj_la1_0 = new int[] {0x200e1c00,0x400000,0x200e1c00,0x0,0x0,0x400000,0x20020000,0x200e1c00,0x10000000,0x0,0x0,0x1000000,0x0,0x80000000,0x40000000,0x0,0x0,0xb00000,0x6000000,0x6000000,0x28000000,0x6000000,0x6000000,0x0,0x0,0x0,0x0,0x2001c800,0xc000,0x0,0x28000000,0x400000,0x28000000,0x0,0x0,0x8000000,0x8000000,0x0,0x20000000,0x0,0x20000000,0x0,0x28000000,0x28000000,0x20000000,0x20000000,0x0,0x20000000,0x20000000,0x20000000,0x20000000,0x0,0x20000000,0x0,0x0,0x20000000,0x0,0x1c800,0x1c000,0x0,0x0,0x0,0x8000000,0x80000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0x28000000,0x0,0x28000000,0x20000000,0x20000000,};
4827 }
4828 private static void jj_la1_1() {
4829 jj_la1_1 = new int[] {0x404000,0x0,0x404000,0x4000,0x400000,0x0,0x0,0x0,0x0,0x40000,0x1000000,0x0,0x2,0x0,0x0,0x1,0x1000000,0x0,0x0,0x0,0x4c4000,0x0,0x0,0x1000000,0x1000000,0x4000,0x2000080,0x4c4000,0x0,0x1000000,0x4c4100,0x0,0x4c4000,0x18000000,0x18000000,0x20000000,0x20000000,0x400000,0x484000,0x40000000,0x4c4000,0x1000000,0x4c4000,0x4c4000,0x4000,0x4000,0x1000000,0x404000,0x4000,0x4000,0x4000,0x1000000,0x404000,0x4000,0x1000000,0x404000,0x0,0x200,0x0,0x1000000,0x0,0x40000000,0x4c4000,0x0,0x0,0x1,0x4000,0x8000,0x38,0x40000000,0x40000000,0x40000000,0x40000000,0x1000000,0x4c4000,0xc4000,0x1000000,0xc4000,0x84000,0x4000,};
4830 }
4831 private static void jj_la1_2() {
4832 jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x2,0x2,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x8,0x8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
4833 }
4834 final private JJCalls[] jj_2_rtns = new JJCalls[19];
4835 private boolean jj_rescan = false;
4836 private int jj_gc = 0;
4837
4838 public QueryParser(java.io.InputStream stream) {
4839 this(stream, null);
4840 }
4841 public QueryParser(java.io.InputStream stream, String encoding) {
4842 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
4843 token_source = new QueryParserTokenManager(jj_input_stream);
4844 token = new Token();
4845 jj_ntk = -1;
4846 jj_gen = 0;
4847 for (int i = 0; i < 80; i++) jj_la1[i] = -1;
4848 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4849 }
4850
4851 public void ReInit(java.io.InputStream stream) {
4852 ReInit(stream, null);
4853 }
4854 public void ReInit(java.io.InputStream stream, String encoding) {
4855 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
4856 token_source.ReInit(jj_input_stream);
4857 token = new Token();
4858 jj_ntk = -1;
4859 jjtree.reset();
4860 jj_gen = 0;
4861 for (int i = 0; i < 80; i++) jj_la1[i] = -1;
4862 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4863 }
4864
4865 public QueryParser(java.io.Reader stream) {
4866 jj_input_stream = new SimpleCharStream(stream, 1, 1);
4867 token_source = new QueryParserTokenManager(jj_input_stream);
4868 token = new Token();
4869 jj_ntk = -1;
4870 jj_gen = 0;
4871 for (int i = 0; i < 80; i++) jj_la1[i] = -1;
4872 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4873 }
4874
4875 public void ReInit(java.io.Reader stream) {
4876 jj_input_stream.ReInit(stream, 1, 1);
4877 token_source.ReInit(jj_input_stream);
4878 token = new Token();
4879 jj_ntk = -1;
4880 jjtree.reset();
4881 jj_gen = 0;
4882 for (int i = 0; i < 80; i++) jj_la1[i] = -1;
4883 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4884 }
4885
4886 public QueryParser(QueryParserTokenManager tm) {
4887 token_source = tm;
4888 token = new Token();
4889 jj_ntk = -1;
4890 jj_gen = 0;
4891 for (int i = 0; i < 80; i++) jj_la1[i] = -1;
4892 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4893 }
4894
4895 public void ReInit(QueryParserTokenManager tm) {
4896 token_source = tm;
4897 token = new Token();
4898 jj_ntk = -1;
4899 jjtree.reset();
4900 jj_gen = 0;
4901 for (int i = 0; i < 80; i++) jj_la1[i] = -1;
4902 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
4903 }
4904
4905 final private Token jj_consume_token(int kind) throws ParseException {
4906 Token oldToken;
4907 if ((oldToken = token).next != null) token = token.next;
4908 else token = token.next = token_source.getNextToken();
4909 jj_ntk = -1;
4910 if (token.kind == kind) {
4911 jj_gen++;
4912 if (++jj_gc > 100) {
4913 jj_gc = 0;
4914 for (int i = 0; i < jj_2_rtns.length; i++) {
4915 JJCalls c = jj_2_rtns[i];
4916 while (c != null) {
4917 if (c.gen < jj_gen) c.first = null;
4918 c = c.next;
4919 }
4920 }
4921 }
4922 return token;
4923 }
4924 token = oldToken;
4925 jj_kind = kind;
4926 throw generateParseException();
4927 }
4928
4929 static private final class LookaheadSuccess extends java.lang.Error { }
4930 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
4931 final private boolean jj_scan_token(int kind) {
4932 if (jj_scanpos == jj_lastpos) {
4933 jj_la--;
4934 if (jj_scanpos.next == null) {
4935 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
4936 } else {
4937 jj_lastpos = jj_scanpos = jj_scanpos.next;
4938 }
4939 } else {
4940 jj_scanpos = jj_scanpos.next;
4941 }
4942 if (jj_rescan) {
4943 int i = 0; Token tok = token;
4944 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
4945 if (tok != null) jj_add_error_token(kind, i);
4946 }
4947 if (jj_scanpos.kind != kind) return true;
4948 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
4949 return false;
4950 }
4951
4952 final public Token getNextToken() {
4953 if (token.next != null) token = token.next;
4954 else token = token.next = token_source.getNextToken();
4955 jj_ntk = -1;
4956 jj_gen++;
4957 return token;
4958 }
4959
4960 final public Token getToken(int index) {
4961 Token t = lookingAhead ? jj_scanpos : token;
4962 for (int i = 0; i < index; i++) {
4963 if (t.next != null) t = t.next;
4964 else t = t.next = token_source.getNextToken();
4965 }
4966 return t;
4967 }
4968
4969 final private int jj_ntk() {
4970 if ((jj_nt=token.next) == null)
4971 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
4972 else
4973 return (jj_ntk = jj_nt.kind);
4974 }
4975
4976 private java.util.Vector jj_expentries = new java.util.Vector();
4977 private int[] jj_expentry;
4978 private int jj_kind = -1;
4979 private int[] jj_lasttokens = new int[100];
4980 private int jj_endpos;
4981
4982 private void jj_add_error_token(int kind, int pos) {
4983 if (pos >= 100) return;
4984 if (pos == jj_endpos + 1) {
4985 jj_lasttokens[jj_endpos++] = kind;
4986 } else if (jj_endpos != 0) {
4987 jj_expentry = new int[jj_endpos];
4988 for (int i = 0; i < jj_endpos; i++) {
4989 jj_expentry[i] = jj_lasttokens[i];
4990 }
4991 boolean exists = false;
4992 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
4993 int[] oldentry = (int[])(e.nextElement());
4994 if (oldentry.length == jj_expentry.length) {
4995 exists = true;
4996 for (int i = 0; i < jj_expentry.length; i++) {
4997 if (oldentry[i] != jj_expentry[i]) {
4998 exists = false;
4999 break;
5000 }
5001 }
5002 if (exists) break;
5003 }
5004 }
5005 if (!exists) jj_expentries.addElement(jj_expentry);
5006 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
5007 }
5008 }
5009
5010 public ParseException generateParseException() {
5011 jj_expentries.removeAllElements();
5012 boolean[] la1tokens = new boolean[68];
5013 for (int i = 0; i < 68; i++) {
5014 la1tokens[i] = false;
5015 }
5016 if (jj_kind >= 0) {
5017 la1tokens[jj_kind] = true;
5018 jj_kind = -1;
5019 }
5020 for (int i = 0; i < 80; i++) {
5021 if (jj_la1[i] == jj_gen) {
5022 for (int j = 0; j < 32; j++) {
5023 if ((jj_la1_0[i] & (1<<j)) != 0) {
5024 la1tokens[j] = true;
5025 }
5026 if ((jj_la1_1[i] & (1<<j)) != 0) {
5027 la1tokens[32+j] = true;
5028 }
5029 if ((jj_la1_2[i] & (1<<j)) != 0) {
5030 la1tokens[64+j] = true;
5031 }
5032 }
5033 }
5034 }
5035 for (int i = 0; i < 68; i++) {
5036 if (la1tokens[i]) {
5037 jj_expentry = new int[1];
5038 jj_expentry[0] = i;
5039 jj_expentries.addElement(jj_expentry);
5040 }
5041 }
5042 jj_endpos = 0;
5043 jj_rescan_token();
5044 jj_add_error_token(0, 0);
5045 int[][] exptokseq = new int[jj_expentries.size()][];
5046 for (int i = 0; i < jj_expentries.size(); i++) {
5047 exptokseq[i] = (int[])jj_expentries.elementAt(i);
5048 }
5049 return new ParseException(token, exptokseq, tokenImage);
5050 }
5051
5052 final public void enable_tracing() {
5053 }
5054
5055 final public void disable_tracing() {
5056 }
5057
5058 final private void jj_rescan_token() {
5059 jj_rescan = true;
5060 for (int i = 0; i < 19; i++) {
5061 try {
5062 JJCalls p = jj_2_rtns[i];
5063 do {
5064 if (p.gen > jj_gen) {
5065 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
5066 switch (i) {
5067 case 0: jj_3_1(); break;
5068 case 1: jj_3_2(); break;
5069 case 2: jj_3_3(); break;
5070 case 3: jj_3_4(); break;
5071 case 4: jj_3_5(); break;
5072 case 5: jj_3_6(); break;
5073 case 6: jj_3_7(); break;
5074 case 7: jj_3_8(); break;
5075 case 8: jj_3_9(); break;
5076 case 9: jj_3_10(); break;
5077 case 10: jj_3_11(); break;
5078 case 11: jj_3_12(); break;
5079 case 12: jj_3_13(); break;
5080 case 13: jj_3_14(); break;
5081 case 14: jj_3_15(); break;
5082 case 15: jj_3_16(); break;
5083 case 16: jj_3_17(); break;
5084 case 17: jj_3_18(); break;
5085 case 18: jj_3_19(); break;
5086 }
5087 }
5088 p = p.next;
5089 } while (p != null);
5090 } catch(LookaheadSuccess ls) { }
5091 }
5092 jj_rescan = false;
5093 }
5094
5095 final private void jj_save(int index, int xla) {
5096 JJCalls p = jj_2_rtns[index];
5097 while (p.gen > jj_gen) {
5098 if (p.next == null) { p = p.next = new JJCalls(); break; }
5099 p = p.next;
5100 }
5101 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
5102 }
5103
5104 static final class JJCalls {
5105 int gen;
5106 Token first;
5107 int arg;
5108 JJCalls next;
5109 }
5110
5111 }
Search engine toolkit