00001
00002 package org.objectweb.jonas_ejb.deployment.ejbql;
00003
00004 public class EJBQLimplements EJBQLTreeConstants, EJBQLConstants {
00005 protected JJTEJBQLState jjtree = new JJTEJBQLState();
00006
00007 final public SimpleNode EJBQL() throws ParseException {
00008
00009 ASTEJBQL jjtn000 = new ASTEJBQL(JJTEJBQL);
00010 boolean jjtc000 = true;
00011 jjtree.openNodeScope(jjtn000);
00012 try {
00013 SelectClause();
00014 FromClause();
00015 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00016 case WHERE:
00017 WhereClause();
00018 break;
00019 default:
00020 jj_la1[0] = jj_gen;
00021 ;
00022 }
00023 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00024 case ORDERBY:
00025 OrderByClause();
00026 break;
00027 default:
00028 jj_la1[1] = jj_gen;
00029 ;
00030 }
00031 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00032 case LIMIT:
00033 LimitClause();
00034 break;
00035 default:
00036 jj_la1[2] = jj_gen;
00037 ;
00038 }
00039 jj_consume_token(0);
00040 jjtree.closeNodeScope(jjtn000, true);
00041 jjtc000 = false;
00042 {if (true) return jjtn000;}
00043 } catch (Throwable jjte000) {
00044 if (jjtc000) {
00045 jjtree.clearNodeScope(jjtn000);
00046 jjtc000 = false;
00047 } else {
00048 jjtree.popNode();
00049 }
00050 if (jjte000 instanceof RuntimeException) {
00051 {if (true) throw (RuntimeException)jjte000;}
00052 }
00053 if (jjte000 instanceof ParseException) {
00054 {if (true) throw (ParseException)jjte000;}
00055 }
00056 {if (true) throw (Error)jjte000;}
00057 } finally {
00058 if (jjtc000) {
00059 jjtree.closeNodeScope(jjtn000, true);
00060 }
00061 }
00062 throw new Error("Missing return statement in function");
00063 }
00064
00065 final public void FromClause() throws ParseException {
00066
00067 ASTFromClause jjtn000 = new ASTFromClause(JJTFROMCLAUSE);
00068 boolean jjtc000 = true;
00069 jjtree.openNodeScope(jjtn000);
00070 try {
00071 jj_consume_token(FROM);
00072 IdentificationVariableDeclaration();
00073 label_1:
00074 while (true) {
00075 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00076 case COMMA:
00077 ;
00078 break;
00079 default:
00080 jj_la1[3] = jj_gen;
00081 break label_1;
00082 }
00083 jj_consume_token(COMMA);
00084 IdentificationVariableDeclaration();
00085 }
00086 } catch (Throwable jjte000) {
00087 if (jjtc000) {
00088 jjtree.clearNodeScope(jjtn000);
00089 jjtc000 = false;
00090 } else {
00091 jjtree.popNode();
00092 }
00093 if (jjte000 instanceof RuntimeException) {
00094 {if (true) throw (RuntimeException)jjte000;}
00095 }
00096 if (jjte000 instanceof ParseException) {
00097 {if (true) throw (ParseException)jjte000;}
00098 }
00099 {if (true) throw (Error)jjte000;}
00100 } finally {
00101 if (jjtc000) {
00102 jjtree.closeNodeScope(jjtn000, true);
00103 }
00104 }
00105 }
00106
00107 final public void IdentificationVariableDeclaration() throws ParseException {
00108 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00109 case IN:
00110 CollectionMemberDeclaration();
00111 break;
00112 case IDENTIFIER:
00113 RangeVariableDeclaration();
00114 break;
00115 default:
00116 jj_la1[4] = jj_gen;
00117 jj_consume_token(-1);
00118 throw new ParseException();
00119 }
00120 }
00121
00122 final public void CollectionMemberDeclaration() throws ParseException {
00123
00124 ASTCollectionMemberDeclaration jjtn000 = new ASTCollectionMemberDeclaration(JJTCOLLECTIONMEMBERDECLARATION);
00125 boolean jjtc000 = true;
00126 jjtree.openNodeScope(jjtn000);
00127 try {
00128 jj_consume_token(IN);
00129 jj_consume_token(LPAREN);
00130 CollectionValuedPathExpression();
00131 jj_consume_token(RPAREN);
00132 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00133 case AS:
00134 jj_consume_token(AS);
00135 break;
00136 default:
00137 jj_la1[5] = jj_gen;
00138 ;
00139 }
00140 Identifier();
00141 } catch (Throwable jjte000) {
00142 if (jjtc000) {
00143 jjtree.clearNodeScope(jjtn000);
00144 jjtc000 = false;
00145 } else {
00146 jjtree.popNode();
00147 }
00148 if (jjte000 instanceof RuntimeException) {
00149 {if (true) throw (RuntimeException)jjte000;}
00150 }
00151 if (jjte000 instanceof ParseException) {
00152 {if (true) throw (ParseException)jjte000;}
00153 }
00154 {if (true) throw (Error)jjte000;}
00155 } finally {
00156 if (jjtc000) {
00157 jjtree.closeNodeScope(jjtn000, true);
00158 }
00159 }
00160 }
00161
00162 final public void RangeVariableDeclaration() throws ParseException {
00163
00164 ASTRangeVariableDeclaration jjtn000 = new ASTRangeVariableDeclaration(JJTRANGEVARIABLEDECLARATION);
00165 boolean jjtc000 = true;
00166 jjtree.openNodeScope(jjtn000);
00167 try {
00168 AbstractSchemaName();
00169 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00170 case AS:
00171 jj_consume_token(AS);
00172 break;
00173 default:
00174 jj_la1[6] = jj_gen;
00175 ;
00176 }
00177 Identifier();
00178 } catch (Throwable jjte000) {
00179 if (jjtc000) {
00180 jjtree.clearNodeScope(jjtn000);
00181 jjtc000 = false;
00182 } else {
00183 jjtree.popNode();
00184 }
00185 if (jjte000 instanceof RuntimeException) {
00186 {if (true) throw (RuntimeException)jjte000;}
00187 }
00188 if (jjte000 instanceof ParseException) {
00189 {if (true) throw (ParseException)jjte000;}
00190 }
00191 {if (true) throw (Error)jjte000;}
00192 } finally {
00193 if (jjtc000) {
00194 jjtree.closeNodeScope(jjtn000, true);
00195 }
00196 }
00197 }
00198
00199 final public void SingleValuedPathExpression() throws ParseException {
00200
00201 ASTSingleValuedPathExpression jjtn000 = new ASTSingleValuedPathExpression(JJTSINGLEVALUEDPATHEXPRESSION);
00202 boolean jjtc000 = true;
00203 jjtree.openNodeScope(jjtn000);
00204 try {
00205 Path();
00206 } catch (Throwable jjte000) {
00207 if (jjtc000) {
00208 jjtree.clearNodeScope(jjtn000);
00209 jjtc000 = false;
00210 } else {
00211 jjtree.popNode();
00212 }
00213 if (jjte000 instanceof RuntimeException) {
00214 {if (true) throw (RuntimeException)jjte000;}
00215 }
00216 if (jjte000 instanceof ParseException) {
00217 {if (true) throw (ParseException)jjte000;}
00218 }
00219 {if (true) throw (Error)jjte000;}
00220 } finally {
00221 if (jjtc000) {
00222 jjtree.closeNodeScope(jjtn000, true);
00223 }
00224 }
00225 }
00226
00227 final public void CmpPathExpression() throws ParseException {
00228
00229 ASTCmpPathExpression jjtn000 = new ASTCmpPathExpression(JJTCMPPATHEXPRESSION);
00230 boolean jjtc000 = true;
00231 jjtree.openNodeScope(jjtn000);
00232 try {
00233 Path();
00234 } catch (Throwable jjte000) {
00235 if (jjtc000) {
00236 jjtree.clearNodeScope(jjtn000);
00237 jjtc000 = false;
00238 } else {
00239 jjtree.popNode();
00240 }
00241 if (jjte000 instanceof RuntimeException) {
00242 {if (true) throw (RuntimeException)jjte000;}
00243 }
00244 if (jjte000 instanceof ParseException) {
00245 {if (true) throw (ParseException)jjte000;}
00246 }
00247 {if (true) throw (Error)jjte000;}
00248 } finally {
00249 if (jjtc000) {
00250 jjtree.closeNodeScope(jjtn000, true);
00251 }
00252 }
00253 }
00254
00255 final public void SingleValuedCmrPathExpression() throws ParseException {
00256
00257 ASTSingleValuedCmrPathExpression jjtn000 = new ASTSingleValuedCmrPathExpression(JJTSINGLEVALUEDCMRPATHEXPRESSION);
00258 boolean jjtc000 = true;
00259 jjtree.openNodeScope(jjtn000);
00260 try {
00261 Path();
00262 } catch (Throwable jjte000) {
00263 if (jjtc000) {
00264 jjtree.clearNodeScope(jjtn000);
00265 jjtc000 = false;
00266 } else {
00267 jjtree.popNode();
00268 }
00269 if (jjte000 instanceof RuntimeException) {
00270 {if (true) throw (RuntimeException)jjte000;}
00271 }
00272 if (jjte000 instanceof ParseException) {
00273 {if (true) throw (ParseException)jjte000;}
00274 }
00275 {if (true) throw (Error)jjte000;}
00276 } finally {
00277 if (jjtc000) {
00278 jjtree.closeNodeScope(jjtn000, true);
00279 }
00280 }
00281 }
00282
00283 final public void CollectionValuedPathExpression() throws ParseException {
00284
00285 ASTCollectionValuedPathExpression jjtn000 = new ASTCollectionValuedPathExpression(JJTCOLLECTIONVALUEDPATHEXPRESSION);
00286 boolean jjtc000 = true;
00287 jjtree.openNodeScope(jjtn000);
00288 try {
00289 Path();
00290 } catch (Throwable jjte000) {
00291 if (jjtc000) {
00292 jjtree.clearNodeScope(jjtn000);
00293 jjtc000 = false;
00294 } else {
00295 jjtree.popNode();
00296 }
00297 if (jjte000 instanceof RuntimeException) {
00298 {if (true) throw (RuntimeException)jjte000;}
00299 }
00300 if (jjte000 instanceof ParseException) {
00301 {if (true) throw (ParseException)jjte000;}
00302 }
00303 {if (true) throw (Error)jjte000;}
00304 } finally {
00305 if (jjtc000) {
00306 jjtree.closeNodeScope(jjtn000, true);
00307 }
00308 }
00309 }
00310
00311 final public void SelectClause() throws ParseException {
00312
00313 ASTSelectClause jjtn000 = new ASTSelectClause(JJTSELECTCLAUSE);
00314 boolean jjtc000 = true;
00315 jjtree.openNodeScope(jjtn000);
00316 try {
00317 jj_consume_token(SELECT);
00318 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00319 case DISTINCT:
00320 jj_consume_token(DISTINCT);
00321 jjtn000.distinct=true;
00322 break;
00323 default:
00324 jj_la1[7] = jj_gen;
00325 ;
00326 }
00327 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00328 case AVG:
00329 case COUNT:
00330 case MAX:
00331 case MIN:
00332 case SUM:
00333 case IDENTIFIER:
00334 SelectExpression();
00335 break;
00336 case OBJECT:
00337 jj_consume_token(OBJECT);
00338 jj_consume_token(LPAREN);
00339 IdentificationVariable();
00340 jj_consume_token(RPAREN);
00341 break;
00342 default:
00343 jj_la1[8] = jj_gen;
00344 jj_consume_token(-1);
00345 throw new ParseException();
00346 }
00347 } catch (Throwable jjte000) {
00348 if (jjtc000) {
00349 jjtree.clearNodeScope(jjtn000);
00350 jjtc000 = false;
00351 } else {
00352 jjtree.popNode();
00353 }
00354 if (jjte000 instanceof RuntimeException) {
00355 {if (true) throw (RuntimeException)jjte000;}
00356 }
00357 if (jjte000 instanceof ParseException) {
00358 {if (true) throw (ParseException)jjte000;}
00359 }
00360 {if (true) throw (Error)jjte000;}
00361 } finally {
00362 if (jjtc000) {
00363 jjtree.closeNodeScope(jjtn000, true);
00364 }
00365 }
00366 }
00367
00368 final public void SelectExpression() throws ParseException {
00369
00370 ASTSelectExpression jjtn000 = new ASTSelectExpression(JJTSELECTEXPRESSION);
00371 boolean jjtc000 = true;
00372 jjtree.openNodeScope(jjtn000);
00373 try {
00374 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00375 case IDENTIFIER:
00376 SingleValuedPathExpression();
00377 break;
00378 case AVG:
00379 case COUNT:
00380 case MAX:
00381 case MIN:
00382 case SUM:
00383 AggregateSelectExpression();
00384 break;
00385 default:
00386 jj_la1[9] = jj_gen;
00387 jj_consume_token(-1);
00388 throw new ParseException();
00389 }
00390 } catch (Throwable jjte000) {
00391 if (jjtc000) {
00392 jjtree.clearNodeScope(jjtn000);
00393 jjtc000 = false;
00394 } else {
00395 jjtree.popNode();
00396 }
00397 if (jjte000 instanceof RuntimeException) {
00398 {if (true) throw (RuntimeException)jjte000;}
00399 }
00400 if (jjte000 instanceof ParseException) {
00401 {if (true) throw (ParseException)jjte000;}
00402 }
00403 {if (true) throw (Error)jjte000;}
00404 } finally {
00405 if (jjtc000) {
00406 jjtree.closeNodeScope(jjtn000, true);
00407 }
00408 }
00409 }
00410
00411 final public void AggregateSelectExpression() throws ParseException {
00412
00413 ASTAggregateSelectExpression jjtn000 = new ASTAggregateSelectExpression(JJTAGGREGATESELECTEXPRESSION);
00414 boolean jjtc000 = true;
00415 jjtree.openNodeScope(jjtn000);Token t;
00416 try {
00417 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00418 case AVG:
00419 case MAX:
00420 case MIN:
00421 case SUM:
00422 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00423 case AVG:
00424 t = jj_consume_token(AVG);
00425 break;
00426 case MAX:
00427 t = jj_consume_token(MAX);
00428 break;
00429 case MIN:
00430 t = jj_consume_token(MIN);
00431 break;
00432 case SUM:
00433 t = jj_consume_token(SUM);
00434 break;
00435 default:
00436 jj_la1[10] = jj_gen;
00437 jj_consume_token(-1);
00438 throw new ParseException();
00439 }
00440 jjtn000.ops.add(new Integer(t.kind));
00441 jj_consume_token(LPAREN);
00442 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00443 case DISTINCT:
00444 jj_consume_token(DISTINCT);
00445 jjtn000.distinct=true;
00446 break;
00447 default:
00448 jj_la1[11] = jj_gen;
00449 ;
00450 }
00451 CmpPathExpression();
00452 jj_consume_token(RPAREN);
00453 break;
00454 case COUNT:
00455 t = jj_consume_token(COUNT);
00456 jjtn000.ops.add(new Integer(t.kind));
00457 jj_consume_token(LPAREN);
00458 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00459 case DISTINCT:
00460 jj_consume_token(DISTINCT);
00461 jjtn000.distinct=true;
00462 break;
00463 default:
00464 jj_la1[12] = jj_gen;
00465 ;
00466 }
00467 if (jj_2_1(2147483647)) {
00468 SingleValuedPathExpression();
00469 } else {
00470 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00471 case IDENTIFIER:
00472 IdentificationVariable();
00473 break;
00474 default:
00475 jj_la1[13] = jj_gen;
00476 jj_consume_token(-1);
00477 throw new ParseException();
00478 }
00479 }
00480 jj_consume_token(RPAREN);
00481 break;
00482 default:
00483 jj_la1[14] = jj_gen;
00484 jj_consume_token(-1);
00485 throw new ParseException();
00486 }
00487 } catch (Throwable jjte000) {
00488 if (jjtc000) {
00489 jjtree.clearNodeScope(jjtn000);
00490 jjtc000 = false;
00491 } else {
00492 jjtree.popNode();
00493 }
00494 if (jjte000 instanceof RuntimeException) {
00495 {if (true) throw (RuntimeException)jjte000;}
00496 }
00497 if (jjte000 instanceof ParseException) {
00498 {if (true) throw (ParseException)jjte000;}
00499 }
00500 {if (true) throw (Error)jjte000;}
00501 } finally {
00502 if (jjtc000) {
00503 jjtree.closeNodeScope(jjtn000, true);
00504 }
00505 }
00506 }
00507
00508 final public void OrderByClause() throws ParseException {
00509
00510 ASTOrderByClause jjtn000 = new ASTOrderByClause(JJTORDERBYCLAUSE);
00511 boolean jjtc000 = true;
00512 jjtree.openNodeScope(jjtn000);
00513 try {
00514 jj_consume_token(ORDERBY);
00515 OrderByItem();
00516 label_2:
00517 while (true) {
00518 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00519 case COMMA:
00520 ;
00521 break;
00522 default:
00523 jj_la1[15] = jj_gen;
00524 break label_2;
00525 }
00526 jj_consume_token(COMMA);
00527 OrderByItem();
00528 }
00529 } catch (Throwable jjte000) {
00530 if (jjtc000) {
00531 jjtree.clearNodeScope(jjtn000);
00532 jjtc000 = false;
00533 } else {
00534 jjtree.popNode();
00535 }
00536 if (jjte000 instanceof RuntimeException) {
00537 {if (true) throw (RuntimeException)jjte000;}
00538 }
00539 if (jjte000 instanceof ParseException) {
00540 {if (true) throw (ParseException)jjte000;}
00541 }
00542 {if (true) throw (Error)jjte000;}
00543 } finally {
00544 if (jjtc000) {
00545 jjtree.closeNodeScope(jjtn000, true);
00546 }
00547 }
00548 }
00549
00550 final public void OrderByItem() throws ParseException {
00551
00552 ASTOrderByItem jjtn000 = new ASTOrderByItem(JJTORDERBYITEM);
00553 boolean jjtc000 = true;
00554 jjtree.openNodeScope(jjtn000);
00555 try {
00556 CmpPathExpression();
00557 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00558 case ASC:
00559 case DESC:
00560 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00561 case ASC:
00562 jj_consume_token(ASC);
00563 jjtn000.asc=true;
00564 break;
00565 case DESC:
00566 jj_consume_token(DESC);
00567 jjtn000.asc=false;
00568 break;
00569 default:
00570 jj_la1[16] = jj_gen;
00571 jj_consume_token(-1);
00572 throw new ParseException();
00573 }
00574 break;
00575 default:
00576 jj_la1[17] = jj_gen;
00577 ;
00578 }
00579 } catch (Throwable jjte000) {
00580 if (jjtc000) {
00581 jjtree.clearNodeScope(jjtn000);
00582 jjtc000 = false;
00583 } else {
00584 jjtree.popNode();
00585 }
00586 if (jjte000 instanceof RuntimeException) {
00587 {if (true) throw (RuntimeException)jjte000;}
00588 }
00589 if (jjte000 instanceof ParseException) {
00590 {if (true) throw (ParseException)jjte000;}
00591 }
00592 {if (true) throw (Error)jjte000;}
00593 } finally {
00594 if (jjtc000) {
00595 jjtree.closeNodeScope(jjtn000, true);
00596 }
00597 }
00598 }
00599
00600 final public void LimitClause() throws ParseException {
00601
00602 ASTLimitClause jjtn000 = new ASTLimitClause(JJTLIMITCLAUSE);
00603 boolean jjtc000 = true;
00604 jjtree.openNodeScope(jjtn000);
00605 try {
00606 jj_consume_token(LIMIT);
00607 LimitExpression();
00608 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00609 case COMMA:
00610 jj_consume_token(COMMA);
00611 LimitExpression();
00612 break;
00613 default:
00614 jj_la1[18] = jj_gen;
00615 ;
00616 }
00617 } catch (Throwable jjte000) {
00618 if (jjtc000) {
00619 jjtree.clearNodeScope(jjtn000);
00620 jjtc000 = false;
00621 } else {
00622 jjtree.popNode();
00623 }
00624 if (jjte000 instanceof RuntimeException) {
00625 {if (true) throw (RuntimeException)jjte000;}
00626 }
00627 if (jjte000 instanceof ParseException) {
00628 {if (true) throw (ParseException)jjte000;}
00629 }
00630 {if (true) throw (Error)jjte000;}
00631 } finally {
00632 if (jjtc000) {
00633 jjtree.closeNodeScope(jjtn000, true);
00634 }
00635 }
00636 }
00637
00638 final public void LimitExpression() throws ParseException {
00639
00640 ASTLimitExpression jjtn000 = new ASTLimitExpression(JJTLIMITEXPRESSION);
00641 boolean jjtc000 = true;
00642 jjtree.openNodeScope(jjtn000);
00643 try {
00644 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00645 case INTEGER_LITERAL:
00646 IntegerLiteral();
00647 break;
00648 case input_parameter:
00649 InputParameter();
00650 break;
00651 default:
00652 jj_la1[19] = jj_gen;
00653 jj_consume_token(-1);
00654 throw new ParseException();
00655 }
00656 } catch (Throwable jjte000) {
00657 if (jjtc000) {
00658 jjtree.clearNodeScope(jjtn000);
00659 jjtc000 = false;
00660 } else {
00661 jjtree.popNode();
00662 }
00663 if (jjte000 instanceof RuntimeException) {
00664 {if (true) throw (RuntimeException)jjte000;}
00665 }
00666 if (jjte000 instanceof ParseException) {
00667 {if (true) throw (ParseException)jjte000;}
00668 }
00669 {if (true) throw (Error)jjte000;}
00670 } finally {
00671 if (jjtc000) {
00672 jjtree.closeNodeScope(jjtn000, true);
00673 }
00674 }
00675 }
00676
00677 final public void WhereClause() throws ParseException {
00678
00679 ASTWhereClause jjtn000 = new ASTWhereClause(JJTWHERECLAUSE);
00680 boolean jjtc000 = true;
00681 jjtree.openNodeScope(jjtn000);
00682 try {
00683 jj_consume_token(WHERE);
00684 ConditionalExpression();
00685 } catch (Throwable jjte000) {
00686 if (jjtc000) {
00687 jjtree.clearNodeScope(jjtn000);
00688 jjtc000 = false;
00689 } else {
00690 jjtree.popNode();
00691 }
00692 if (jjte000 instanceof RuntimeException) {
00693 {if (true) throw (RuntimeException)jjte000;}
00694 }
00695 if (jjte000 instanceof ParseException) {
00696 {if (true) throw (ParseException)jjte000;}
00697 }
00698 {if (true) throw (Error)jjte000;}
00699 } finally {
00700 if (jjtc000) {
00701 jjtree.closeNodeScope(jjtn000, true);
00702 }
00703 }
00704 }
00705
00706 final public void ConditionalExpression() throws ParseException {
00707
00708 ASTConditionalExpression jjtn000 = new ASTConditionalExpression(JJTCONDITIONALEXPRESSION);
00709 boolean jjtc000 = true;
00710 jjtree.openNodeScope(jjtn000);
00711 try {
00712 ConditionalTerm();
00713 label_3:
00714 while (true) {
00715 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00716 case OR:
00717 ;
00718 break;
00719 default:
00720 jj_la1[20] = jj_gen;
00721 break label_3;
00722 }
00723 jj_consume_token(OR);
00724 ConditionalTerm();
00725 }
00726 } catch (Throwable jjte000) {
00727 if (jjtc000) {
00728 jjtree.clearNodeScope(jjtn000);
00729 jjtc000 = false;
00730 } else {
00731 jjtree.popNode();
00732 }
00733 if (jjte000 instanceof RuntimeException) {
00734 {if (true) throw (RuntimeException)jjte000;}
00735 }
00736 if (jjte000 instanceof ParseException) {
00737 {if (true) throw (ParseException)jjte000;}
00738 }
00739 {if (true) throw (Error)jjte000;}
00740 } finally {
00741 if (jjtc000) {
00742 jjtree.closeNodeScope(jjtn000, true);
00743 }
00744 }
00745 }
00746
00747 final public void ConditionalTerm() throws ParseException {
00748
00749 ASTConditionalTerm jjtn000 = new ASTConditionalTerm(JJTCONDITIONALTERM);
00750 boolean jjtc000 = true;
00751 jjtree.openNodeScope(jjtn000);
00752 try {
00753 ConditionalFactor();
00754 label_4:
00755 while (true) {
00756 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00757 case AND:
00758 ;
00759 break;
00760 default:
00761 jj_la1[21] = jj_gen;
00762 break label_4;
00763 }
00764 jj_consume_token(AND);
00765 ConditionalFactor();
00766 }
00767 } catch (Throwable jjte000) {
00768 if (jjtc000) {
00769 jjtree.clearNodeScope(jjtn000);
00770 jjtc000 = false;
00771 } else {
00772 jjtree.popNode();
00773 }
00774 if (jjte000 instanceof RuntimeException) {
00775 {if (true) throw (RuntimeException)jjte000;}
00776 }
00777 if (jjte000 instanceof ParseException) {
00778 {if (true) throw (ParseException)jjte000;}
00779 }
00780 {if (true) throw (Error)jjte000;}
00781 } finally {
00782 if (jjtc000) {
00783 jjtree.closeNodeScope(jjtn000, true);
00784 }
00785 }
00786 }
00787
00788 final public void ConditionalFactor() throws ParseException {
00789
00790 ASTConditionalFactor jjtn000 = new ASTConditionalFactor(JJTCONDITIONALFACTOR);
00791 boolean jjtc000 = true;
00792 jjtree.openNodeScope(jjtn000);
00793 try {
00794 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00795 case NOT:
00796 jj_consume_token(NOT);
00797 jjtn000.not=true;
00798 break;
00799 default:
00800 jj_la1[22] = jj_gen;
00801 ;
00802 }
00803 ConditionalPrimary();
00804 } catch (Throwable jjte000) {
00805 if (jjtc000) {
00806 jjtree.clearNodeScope(jjtn000);
00807 jjtc000 = false;
00808 } else {
00809 jjtree.popNode();
00810 }
00811 if (jjte000 instanceof RuntimeException) {
00812 {if (true) throw (RuntimeException)jjte000;}
00813 }
00814 if (jjte000 instanceof ParseException) {
00815 {if (true) throw (ParseException)jjte000;}
00816 }
00817 {if (true) throw (Error)jjte000;}
00818 } finally {
00819 if (jjtc000) {
00820 jjtree.closeNodeScope(jjtn000, true);
00821 }
00822 }
00823 }
00824
00825 final public void ConditionalPrimary() throws ParseException {
00826 if (jj_2_2(2147483647)) {
00827 SimpleCondExpression();
00828 } else if (jj_2_3(2147483647)) {
00829 jj_consume_token(LPAREN);
00830 ConditionalExpression();
00831 jj_consume_token(RPAREN);
00832 } else {
00833 jj_consume_token(-1);
00834 throw new ParseException();
00835 }
00836 }
00837
00838 final public void SimpleCondExpression() throws ParseException {
00839 if (jj_2_4(2147483647)) {
00840 ComparisonExpression();
00841 } else if (jj_2_5(2147483647)) {
00842 BetweenExpression();
00843 } else if (jj_2_6(2147483647)) {
00844 LikeExpression();
00845 } else if (jj_2_7(2147483647)) {
00846 InExpression();
00847 } else if (jj_2_8(2147483647)) {
00848 NullComparisonExpression();
00849 } else if (jj_2_9(2147483647)) {
00850 EmptyCollectionComparisonExpression();
00851 } else if (jj_2_10(2147483647)) {
00852 CollectionMemberExpression();
00853 } else {
00854 jj_consume_token(-1);
00855 throw new ParseException();
00856 }
00857 }
00858
00859 final public void BetweenExpression() throws ParseException {
00860
00861 ASTBetweenExpression jjtn000 = new ASTBetweenExpression(JJTBETWEENEXPRESSION);
00862 boolean jjtc000 = true;
00863 jjtree.openNodeScope(jjtn000);
00864 try {
00865 ArithmeticExpression();
00866 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00867 case NOT:
00868 jj_consume_token(NOT);
00869 jjtn000.not=true;
00870 break;
00871 default:
00872 jj_la1[23] = jj_gen;
00873 ;
00874 }
00875 jj_consume_token(BETWEEN);
00876 ArithmeticExpression();
00877 jj_consume_token(AND);
00878 ArithmeticExpression();
00879 } catch (Throwable jjte000) {
00880 if (jjtc000) {
00881 jjtree.clearNodeScope(jjtn000);
00882 jjtc000 = false;
00883 } else {
00884 jjtree.popNode();
00885 }
00886 if (jjte000 instanceof RuntimeException) {
00887 {if (true) throw (RuntimeException)jjte000;}
00888 }
00889 if (jjte000 instanceof ParseException) {
00890 {if (true) throw (ParseException)jjte000;}
00891 }
00892 {if (true) throw (Error)jjte000;}
00893 } finally {
00894 if (jjtc000) {
00895 jjtree.closeNodeScope(jjtn000, true);
00896 }
00897 }
00898 }
00899
00900 final public void InExpression() throws ParseException {
00901
00902 ASTInExpression jjtn000 = new ASTInExpression(JJTINEXPRESSION);
00903 boolean jjtc000 = true;
00904 jjtree.openNodeScope(jjtn000);
00905 try {
00906 CmpPathExpression();
00907 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00908 case NOT:
00909 jj_consume_token(NOT);
00910 jjtn000.not=true;
00911 break;
00912 default:
00913 jj_la1[24] = jj_gen;
00914 ;
00915 }
00916 jj_consume_token(IN);
00917 jj_consume_token(LPAREN);
00918 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00919 case string_literal:
00920 case FALSE:
00921 case TRUE:
00922 case INTEGER_LITERAL:
00923 case FLOATING_POINT_LITERAL:
00924 Literal();
00925 break;
00926 case input_parameter:
00927 InputParameter();
00928 break;
00929 default:
00930 jj_la1[25] = jj_gen;
00931 jj_consume_token(-1);
00932 throw new ParseException();
00933 }
00934 jjtn000.eltnum=1;
00935 label_5:
00936 while (true) {
00937 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00938 case COMMA:
00939 ;
00940 break;
00941 default:
00942 jj_la1[26] = jj_gen;
00943 break label_5;
00944 }
00945 jj_consume_token(COMMA);
00946 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00947 case string_literal:
00948 case FALSE:
00949 case TRUE:
00950 case INTEGER_LITERAL:
00951 case FLOATING_POINT_LITERAL:
00952 Literal();
00953 break;
00954 case input_parameter:
00955 InputParameter();
00956 break;
00957 default:
00958 jj_la1[27] = jj_gen;
00959 jj_consume_token(-1);
00960 throw new ParseException();
00961 }
00962 jjtn000.eltnum++;
00963 }
00964 jj_consume_token(RPAREN);
00965 } catch (Throwable jjte000) {
00966 if (jjtc000) {
00967 jjtree.clearNodeScope(jjtn000);
00968 jjtc000 = false;
00969 } else {
00970 jjtree.popNode();
00971 }
00972 if (jjte000 instanceof RuntimeException) {
00973 {if (true) throw (RuntimeException)jjte000;}
00974 }
00975 if (jjte000 instanceof ParseException) {
00976 {if (true) throw (ParseException)jjte000;}
00977 }
00978 {if (true) throw (Error)jjte000;}
00979 } finally {
00980 if (jjtc000) {
00981 jjtree.closeNodeScope(jjtn000, true);
00982 }
00983 }
00984 }
00985
00986 final public void LikeExpression() throws ParseException {
00987
00988 ASTLikeExpression jjtn000 = new ASTLikeExpression(JJTLIKEEXPRESSION);
00989 boolean jjtc000 = true;
00990 jjtree.openNodeScope(jjtn000);
00991 try {
00992 CmpPathExpression();
00993 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00994 case NOT:
00995 jj_consume_token(NOT);
00996 jjtn000.not=true;
00997 break;
00998 default:
00999 jj_la1[28] = jj_gen;
01000 ;
01001 }
01002 jj_consume_token(LIKE);
01003 PatternValue();
01004 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01005 case ESCAPE:
01006 jj_consume_token(ESCAPE);
01007 jjtn000.third=true;
01008 EscapeCharacter();
01009 break;
01010 default:
01011 jj_la1[29] = jj_gen;
01012 ;
01013 }
01014 } catch (Throwable jjte000) {
01015 if (jjtc000) {
01016 jjtree.clearNodeScope(jjtn000);
01017 jjtc000 = false;
01018 } else {
01019 jjtree.popNode();
01020 }
01021 if (jjte000 instanceof RuntimeException) {
01022 {if (true) throw (RuntimeException)jjte000;}
01023 }
01024 if (jjte000 instanceof ParseException) {
01025 {if (true) throw (ParseException)jjte000;}
01026 }
01027 {if (true) throw (Error)jjte000;}
01028 } finally {
01029 if (jjtc000) {
01030 jjtree.closeNodeScope(jjtn000, true);
01031 }
01032 }
01033 }
01034
01035 final public void NullComparisonExpression() throws ParseException {
01036
01037 ASTNullComparisonExpression jjtn000 = new ASTNullComparisonExpression(JJTNULLCOMPARISONEXPRESSION);
01038 boolean jjtc000 = true;
01039 jjtree.openNodeScope(jjtn000);
01040 try {
01041 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01042 case IDENTIFIER:
01043 SingleValuedPathExpression();
01044 break;
01045 case input_parameter:
01046 InputParameter();
01047 break;
01048 default:
01049 jj_la1[30] = jj_gen;
01050 jj_consume_token(-1);
01051 throw new ParseException();
01052 }
01053 jj_consume_token(IS);
01054 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01055 case NOT:
01056 jj_consume_token(NOT);
01057 jjtn000.not=true;
01058 break;
01059 default:
01060 jj_la1[31] = jj_gen;
01061 ;
01062 }
01063 jj_consume_token(NULL);
01064 } catch (Throwable jjte000) {
01065 if (jjtc000) {
01066 jjtree.clearNodeScope(jjtn000);
01067 jjtc000 = false;
01068 } else {
01069 jjtree.popNode();
01070 }
01071 if (jjte000 instanceof RuntimeException) {
01072 {if (true) throw (RuntimeException)jjte000;}
01073 }
01074 if (jjte000 instanceof ParseException) {
01075 {if (true) throw (ParseException)jjte000;}
01076 }
01077 {if (true) throw (Error)jjte000;}
01078 } finally {
01079 if (jjtc000) {
01080 jjtree.closeNodeScope(jjtn000, true);
01081 }
01082 }
01083 }
01084
01085 final public void EmptyCollectionComparisonExpression() throws ParseException {
01086
01087 ASTEmptyCollectionComparisonExpression jjtn000 = new ASTEmptyCollectionComparisonExpression(JJTEMPTYCOLLECTIONCOMPARISONEXPRESSION);
01088 boolean jjtc000 = true;
01089 jjtree.openNodeScope(jjtn000);
01090 try {
01091 CollectionValuedPathExpression();
01092 jj_consume_token(IS);
01093 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01094 case NOT:
01095 jj_consume_token(NOT);
01096 jjtn000.not=true;
01097 break;
01098 default:
01099 jj_la1[32] = jj_gen;
01100 ;
01101 }
01102 jj_consume_token(EMPTY);
01103 } catch (Throwable jjte000) {
01104 if (jjtc000) {
01105 jjtree.clearNodeScope(jjtn000);
01106 jjtc000 = false;
01107 } else {
01108 jjtree.popNode();
01109 }
01110 if (jjte000 instanceof RuntimeException) {
01111 {if (true) throw (RuntimeException)jjte000;}
01112 }
01113 if (jjte000 instanceof ParseException) {
01114 {if (true) throw (ParseException)jjte000;}
01115 }
01116 {if (true) throw (Error)jjte000;}
01117 } finally {
01118 if (jjtc000) {
01119 jjtree.closeNodeScope(jjtn000, true);
01120 }
01121 }
01122 }
01123
01124 final public void CollectionMemberExpression() throws ParseException {
01125
01126 ASTCollectionMemberExpression jjtn000 = new ASTCollectionMemberExpression(JJTCOLLECTIONMEMBEREXPRESSION);
01127 boolean jjtc000 = true;
01128 jjtree.openNodeScope(jjtn000);
01129 try {
01130 if (jj_2_11(2)) {
01131 SingleValuedCmrPathExpression();
01132 } else if (jj_2_12(2)) {
01133 IdentificationVariable();
01134 } else {
01135 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01136 case input_parameter:
01137 InputParameter();
01138 break;
01139 default:
01140 jj_la1[33] = jj_gen;
01141 jj_consume_token(-1);
01142 throw new ParseException();
01143 }
01144 }
01145 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01146 case NOT:
01147 jj_consume_token(NOT);
01148 jjtn000.not=true;
01149 break;
01150 default:
01151 jj_la1[34] = jj_gen;
01152 ;
01153 }
01154 jj_consume_token(MEMBER);
01155 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01156 case OF:
01157 jj_consume_token(OF);
01158 break;
01159 default:
01160 jj_la1[35] = jj_gen;
01161 ;
01162 }
01163 CollectionValuedPathExpression();
01164 } catch (Throwable jjte000) {
01165 if (jjtc000) {
01166 jjtree.clearNodeScope(jjtn000);
01167 jjtc000 = false;
01168 } else {
01169 jjtree.popNode();
01170 }
01171 if (jjte000 instanceof RuntimeException) {
01172 {if (true) throw (RuntimeException)jjte000;}
01173 }
01174 if (jjte000 instanceof ParseException) {
01175 {if (true) throw (ParseException)jjte000;}
01176 }
01177 {if (true) throw (Error)jjte000;}
01178 } finally {
01179 if (jjtc000) {
01180 jjtree.closeNodeScope(jjtn000, true);
01181 }
01182 }
01183 }
01184
01185 final public void ComparisonExpression() throws ParseException {
01186
01187 ASTComparisonExpression jjtn000 = new ASTComparisonExpression(JJTCOMPARISONEXPRESSION);
01188 boolean jjtc000 = true;
01189 jjtree.openNodeScope(jjtn000);Token t;
01190 try {
01191 if (jj_2_13(2147483647)) {
01192 StringValue();
01193 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01194 case EQ:
01195 t = jj_consume_token(EQ);
01196 break;
01197 case GT:
01198 t = jj_consume_token(GT);
01199 break;
01200 case GE:
01201 t = jj_consume_token(GE);
01202 break;
01203 case LT:
01204 t = jj_consume_token(LT);
01205 break;
01206 case LE:
01207 t = jj_consume_token(LE);
01208 break;
01209 case NE:
01210 t = jj_consume_token(NE);
01211 break;
01212 default:
01213 jj_la1[36] = jj_gen;
01214 jj_consume_token(-1);
01215 throw new ParseException();
01216 }
01217 jjtn000.ops.add(new Integer(t.kind));
01218 StringExpression();
01219 } else if (jj_2_14(2147483647)) {
01220 BooleanValue();
01221 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01222 case EQ:
01223 t = jj_consume_token(EQ);
01224 break;
01225 case NE:
01226 t = jj_consume_token(NE);
01227 break;
01228 default:
01229 jj_la1[37] = jj_gen;
01230 jj_consume_token(-1);
01231 throw new ParseException();
01232 }
01233 jjtn000.ops.add(new Integer(t.kind));
01234 BooleanExpression();
01235 } else if (jj_2_15(2147483647)) {
01236 DatetimeValue();
01237 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01238 case EQ:
01239 t = jj_consume_token(EQ);
01240 break;
01241 case GT:
01242 t = jj_consume_token(GT);
01243 break;
01244 case GE:
01245 t = jj_consume_token(GE);
01246 break;
01247 case LT:
01248 t = jj_consume_token(LT);
01249 break;
01250 case LE:
01251 t = jj_consume_token(LE);
01252 break;
01253 case NE:
01254 t = jj_consume_token(NE);
01255 break;
01256 default:
01257 jj_la1[38] = jj_gen;
01258 jj_consume_token(-1);
01259 throw new ParseException();
01260 }
01261 jjtn000.ops.add(new Integer(t.kind));
01262 DatetimeExpression();
01263 } else if (jj_2_16(2147483647)) {
01264 EntityBeanValue();
01265 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01266 case EQ:
01267 t = jj_consume_token(EQ);
01268 break;
01269 case NE:
01270 t = jj_consume_token(NE);
01271 break;
01272 default:
01273 jj_la1[39] = jj_gen;
01274 jj_consume_token(-1);
01275 throw new ParseException();
01276 }
01277 jjtn000.ops.add(new Integer(t.kind));
01278 EntityBeanExpression();
01279 } else if (jj_2_17(2147483647)) {
01280 ArithmeticValue();
01281 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01282 case EQ:
01283 t = jj_consume_token(EQ);
01284 break;
01285 case GT:
01286 t = jj_consume_token(GT);
01287 break;
01288 case GE:
01289 t = jj_consume_token(GE);
01290 break;
01291 case LT:
01292 t = jj_consume_token(LT);
01293 break;
01294 case LE:
01295 t = jj_consume_token(LE);
01296 break;
01297 case NE:
01298 t = jj_consume_token(NE);
01299 break;
01300 default:
01301 jj_la1[40] = jj_gen;
01302 jj_consume_token(-1);
01303 throw new ParseException();
01304 }
01305 jjtn000.ops.add(new Integer(t.kind));
01306 ArithmeticExpression();
01307 } else {
01308 jj_consume_token(-1);
01309 throw new ParseException();
01310 }
01311 } catch (Throwable jjte000) {
01312 if (jjtc000) {
01313 jjtree.clearNodeScope(jjtn000);
01314 jjtc000 = false;
01315 } else {
01316 jjtree.popNode();
01317 }
01318 if (jjte000 instanceof RuntimeException) {
01319 {if (true) throw (RuntimeException)jjte000;}
01320 }
01321 if (jjte000 instanceof ParseException) {
01322 {if (true) throw (ParseException)jjte000;}
01323 }
01324 {if (true) throw (Error)jjte000;}
01325 } finally {
01326 if (jjtc000) {
01327 jjtree.closeNodeScope(jjtn000, true);
01328 }
01329 }
01330 }
01331
01332 final public void ArithmeticValue() throws ParseException {
01333 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01334 case IDENTIFIER:
01335 CmpPathExpression();
01336 break;
01337 case ABS:
01338 case LENGTH:
01339 case LOCATE:
01340 case MOD:
01341 case SQRT:
01342 FunctionsReturningNumerics();
01343 break;
01344 default:
01345 jj_la1[41] = jj_gen;
01346 jj_consume_token(-1);
01347 throw new ParseException();
01348 }
01349 }
01350
01351 final public void ArithmeticExpression() throws ParseException {
01352
01353 ASTArithmeticExpression jjtn000 = new ASTArithmeticExpression(JJTARITHMETICEXPRESSION);
01354 boolean jjtc000 = true;
01355 jjtree.openNodeScope(jjtn000);Token t;
01356 try {
01357 ArithmeticTerm();
01358 label_6:
01359 while (true) {
01360 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01361 case MINUS:
01362 case PLUS:
01363 ;
01364 break;
01365 default:
01366 jj_la1[42] = jj_gen;
01367 break label_6;
01368 }
01369 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01370 case PLUS:
01371 t = jj_consume_token(PLUS);
01372 break;
01373 case MINUS:
01374 t = jj_consume_token(MINUS);
01375 break;
01376 default:
01377 jj_la1[43] = jj_gen;
01378 jj_consume_token(-1);
01379 throw new ParseException();
01380 }
01381 jjtn000.ops.add(new Integer(t.kind));
01382 ArithmeticTerm();
01383 }
01384 } catch (Throwable jjte000) {
01385 if (jjtc000) {
01386 jjtree.clearNodeScope(jjtn000);
01387 jjtc000 = false;
01388 } else {
01389 jjtree.popNode();
01390 }
01391 if (jjte000 instanceof RuntimeException) {
01392 {if (true) throw (RuntimeException)jjte000;}
01393 }
01394 if (jjte000 instanceof ParseException) {
01395 {if (true) throw (ParseException)jjte000;}
01396 }
01397 {if (true) throw (Error)jjte000;}
01398 } finally {
01399 if (jjtc000) {
01400 jjtree.closeNodeScope(jjtn000, true);
01401 }
01402 }
01403 }
01404
01405 final public void ArithmeticTerm() throws ParseException {
01406
01407 ASTArithmeticTerm jjtn000 = new ASTArithmeticTerm(JJTARITHMETICTERM);
01408 boolean jjtc000 = true;
01409 jjtree.openNodeScope(jjtn000);Token t;
01410 try {
01411 ArithmeticFactor();
01412 label_7:
01413 while (true) {
01414 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01415 case MULT:
01416 case DIV:
01417 ;
01418 break;
01419 default:
01420 jj_la1[44] = jj_gen;
01421 break label_7;
01422 }
01423 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01424 case MULT:
01425 t = jj_consume_token(MULT);
01426 break;
01427 case DIV:
01428 t = jj_consume_token(DIV);
01429 break;
01430 default:
01431 jj_la1[45] = jj_gen;
01432 jj_consume_token(-1);
01433 throw new ParseException();
01434 }
01435 jjtn000.ops.add(new Integer(t.kind));
01436 ArithmeticFactor();
01437 }
01438 } catch (Throwable jjte000) {
01439 if (jjtc000) {
01440 jjtree.clearNodeScope(jjtn000);
01441 jjtc000 = false;
01442 } else {
01443 jjtree.popNode();
01444 }
01445 if (jjte000 instanceof RuntimeException) {
01446 {if (true) throw (RuntimeException)jjte000;}
01447 }
01448 if (jjte000 instanceof ParseException) {
01449 {if (true) throw (ParseException)jjte000;}
01450 }
01451 {if (true) throw (Error)jjte000;}
01452 } finally {
01453 if (jjtc000) {
01454 jjtree.closeNodeScope(jjtn000, true);
01455 }
01456 }
01457 }
01458
01459 final public void ArithmeticFactor() throws ParseException {
01460
01461 ASTArithmeticFactor jjtn000 = new ASTArithmeticFactor(JJTARITHMETICFACTOR);
01462 boolean jjtc000 = true;
01463 jjtree.openNodeScope(jjtn000);Token t=null;
01464 try {
01465 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01466 case MINUS:
01467 case PLUS:
01468 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01469 case PLUS:
01470 t = jj_consume_token(PLUS);
01471 break;
01472 case MINUS:
01473 t = jj_consume_token(MINUS);
01474 break;
01475 default:
01476 jj_la1[46] = jj_gen;
01477 jj_consume_token(-1);
01478 throw new ParseException();
01479 }
01480 break;
01481 default:
01482 jj_la1[47] = jj_gen;
01483 ;
01484 }
01485 ArithmeticPrimary();
01486 jjtree.closeNodeScope(jjtn000, true);
01487 jjtc000 = false;
01488 jjtn000.ops.add(new Integer((t!=null)?t.kind:EJBQLConstants.PLUS));
01489 } catch (Throwable jjte000) {
01490 if (jjtc000) {
01491 jjtree.clearNodeScope(jjtn000);
01492 jjtc000 = false;
01493 } else {
01494 jjtree.popNode();
01495 }
01496 if (jjte000 instanceof RuntimeException) {
01497 {if (true) throw (RuntimeException)jjte000;}
01498 }
01499 if (jjte000 instanceof ParseException) {
01500 {if (true) throw (ParseException)jjte000;}
01501 }
01502 {if (true) throw (Error)jjte000;}
01503 } finally {
01504 if (jjtc000) {
01505 jjtree.closeNodeScope(jjtn000, true);
01506 }
01507 }
01508 }
01509
01510 final public void ArithmeticPrimary() throws ParseException {
01511 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01512 case IDENTIFIER:
01513 CmpPathExpression();
01514 break;
01515 case INTEGER_LITERAL:
01516 case FLOATING_POINT_LITERAL:
01517 ArithmeticLiteral();
01518 break;
01519 case LPAREN:
01520 jj_consume_token(LPAREN);
01521 ArithmeticExpression();
01522 jj_consume_token(RPAREN);
01523 break;
01524 case input_parameter:
01525 InputParameter();
01526 break;
01527 case ABS:
01528 case LENGTH:
01529 case LOCATE:
01530 case MOD:
01531 case SQRT:
01532 FunctionsReturningNumerics();
01533 break;
01534 default:
01535 jj_la1[48] = jj_gen;
01536 jj_consume_token(-1);
01537 throw new ParseException();
01538 }
01539 }
01540
01541 final public void StringValue() throws ParseException {
01542 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01543 case IDENTIFIER:
01544 CmpPathExpression();
01545 break;
01546 case CONCAT:
01547 case SUBSTRING:
01548 FunctionsReturningStrings();
01549 break;
01550 default:
01551 jj_la1[49] = jj_gen;
01552 jj_consume_token(-1);
01553 throw new ParseException();
01554 }
01555 }
01556
01557 final public void StringExpression() throws ParseException {
01558
01559 ASTStringExpression jjtn000 = new ASTStringExpression(JJTSTRINGEXPRESSION);
01560 boolean jjtc000 = true;
01561 jjtree.openNodeScope(jjtn000);
01562 try {
01563 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01564 case LPAREN:
01565 case CONCAT:
01566 case SUBSTRING:
01567 case string_literal:
01568 case IDENTIFIER:
01569 StringPrimary();
01570 break;
01571 case input_parameter:
01572 InputParameter();
01573 break;
01574 default:
01575 jj_la1[50] = jj_gen;
01576 jj_consume_token(-1);
01577 throw new ParseException();
01578 }
01579 } catch (Throwable jjte000) {
01580 if (jjtc000) {
01581 jjtree.clearNodeScope(jjtn000);
01582 jjtc000 = false;
01583 } else {
01584 jjtree.popNode();
01585 }
01586 if (jjte000 instanceof RuntimeException) {
01587 {if (true) throw (RuntimeException)jjte000;}
01588 }
01589 if (jjte000 instanceof ParseException) {
01590 {if (true) throw (ParseException)jjte000;}
01591 }
01592 {if (true) throw (Error)jjte000;}
01593 } finally {
01594 if (jjtc000) {
01595 jjtree.closeNodeScope(jjtn000, true);
01596 }
01597 }
01598 }
01599
01600 final public void StringPrimary() throws ParseException {
01601 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01602 case IDENTIFIER:
01603 CmpPathExpression();
01604 break;
01605 case string_literal:
01606 StringLiteral();
01607 break;
01608 case LPAREN:
01609 jj_consume_token(LPAREN);
01610 StringExpression();
01611 jj_consume_token(RPAREN);
01612 break;
01613 case CONCAT:
01614 case SUBSTRING:
01615 FunctionsReturningStrings();
01616 break;
01617 default:
01618 jj_la1[51] = jj_gen;
01619 jj_consume_token(-1);
01620 throw new ParseException();
01621 }
01622 }
01623
01624 final public void DatetimeValue() throws ParseException {
01625 CmpPathExpression();
01626 }
01627
01628 final public void DatetimeExpression() throws ParseException {
01629
01630 ASTDatetimeExpression jjtn000 = new ASTDatetimeExpression(JJTDATETIMEEXPRESSION);
01631 boolean jjtc000 = true;
01632 jjtree.openNodeScope(jjtn000);
01633 try {
01634 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01635 case IDENTIFIER:
01636 DatetimeValue();
01637 break;
01638 case input_parameter:
01639 InputParameter();
01640 break;
01641 default:
01642 jj_la1[52] = jj_gen;
01643 jj_consume_token(-1);
01644 throw new ParseException();
01645 }
01646 } catch (Throwable jjte000) {
01647 if (jjtc000) {
01648 jjtree.clearNodeScope(jjtn000);
01649 jjtc000 = false;
01650 } else {
01651 jjtree.popNode();
01652 }
01653 if (jjte000 instanceof RuntimeException) {
01654 {if (true) throw (RuntimeException)jjte000;}
01655 }
01656 if (jjte000 instanceof ParseException) {
01657 {if (true) throw (ParseException)jjte000;}
01658 }
01659 {if (true) throw (Error)jjte000;}
01660 } finally {
01661 if (jjtc000) {
01662 jjtree.closeNodeScope(jjtn000, true);
01663 }
01664 }
01665 }
01666
01667 final public void BooleanValue() throws ParseException {
01668 CmpPathExpression();
01669 }
01670
01671 final public void BooleanExpression() throws ParseException {
01672
01673 ASTBooleanExpression jjtn000 = new ASTBooleanExpression(JJTBOOLEANEXPRESSION);
01674 boolean jjtc000 = true;
01675 jjtree.openNodeScope(jjtn000);Token t=null;
01676 try {
01677 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01678 case IDENTIFIER:
01679 CmpPathExpression();
01680 break;
01681 case FALSE:
01682 case TRUE:
01683 BooleanLiteral();
01684 break;
01685 case input_parameter:
01686 InputParameter();
01687 jjtree.closeNodeScope(jjtn000, true);
01688 jjtc000 = false;
01689 if (t!=null) jjtn000.ops.add(new Integer(t.kind));
01690 break;
01691 default:
01692 jj_la1[53] = jj_gen;
01693 jj_consume_token(-1);
01694 throw new ParseException();
01695 }
01696 } catch (Throwable jjte000) {
01697 if (jjtc000) {
01698 jjtree.clearNodeScope(jjtn000);
01699 jjtc000 = false;
01700 } else {
01701 jjtree.popNode();
01702 }
01703 if (jjte000 instanceof RuntimeException) {
01704 {if (true) throw (RuntimeException)jjte000;}
01705 }
01706 if (jjte000 instanceof ParseException) {
01707 {if (true) throw (ParseException)jjte000;}
01708 }
01709 {if (true) throw (Error)jjte000;}
01710 } finally {
01711 if (jjtc000) {
01712 jjtree.closeNodeScope(jjtn000, true);
01713 }
01714 }
01715 }
01716
01717 final public void EntityBeanValue() throws ParseException {
01718 if (jj_2_18(2)) {
01719 SingleValuedCmrPathExpression();
01720 } else if (jj_2_19(2)) {
01721 IdentificationVariable();
01722 } else {
01723 jj_consume_token(-1);
01724 throw new ParseException();
01725 }
01726 }
01727
01728 final public void EntityBeanExpression() throws ParseException {
01729
01730 ASTEntityBeanExpression jjtn000 = new ASTEntityBeanExpression(JJTENTITYBEANEXPRESSION);
01731 boolean jjtc000 = true;
01732 jjtree.openNodeScope(jjtn000);
01733 try {
01734 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01735 case IDENTIFIER:
01736 EntityBeanValue();
01737 break;
01738 case input_parameter:
01739 InputParameter();
01740 break;
01741 default:
01742 jj_la1[54] = jj_gen;
01743 jj_consume_token(-1);
01744 throw new ParseException();
01745 }
01746 } catch (Throwable jjte000) {
01747 if (jjtc000) {
01748 jjtree.clearNodeScope(jjtn000);
01749 jjtc000 = false;
01750 } else {
01751 jjtree.popNode();
01752 }
01753 if (jjte000 instanceof RuntimeException) {
01754 {if (true) throw (RuntimeException)jjte000;}
01755 }
01756 if (jjte000 instanceof ParseException) {
01757 {if (true) throw (ParseException)jjte000;}
01758 }
01759 {if (true) throw (Error)jjte000;}
01760 } finally {
01761 if (jjtc000) {
01762 jjtree.closeNodeScope(jjtn000, true);
01763 }
01764 }
01765 }
01766
01767 final public void FunctionsReturningStrings() throws ParseException {
01768
01769 ASTFunctionsReturningStrings jjtn000 = new ASTFunctionsReturningStrings(JJTFUNCTIONSRETURNINGSTRINGS);
01770 boolean jjtc000 = true;
01771 jjtree.openNodeScope(jjtn000);Token t;
01772 try {
01773 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01774 case CONCAT:
01775 t = jj_consume_token(CONCAT);
01776 jjtn000.ops.add(new Integer(t.kind));
01777 jj_consume_token(LPAREN);
01778 StringExpression();
01779 jj_consume_token(COMMA);
01780 StringExpression();
01781 jj_consume_token(RPAREN);
01782 break;
01783 case SUBSTRING:
01784 t = jj_consume_token(SUBSTRING);
01785 jjtn000.ops.add(new Integer(t.kind));
01786 jj_consume_token(LPAREN);
01787 StringExpression();
01788 jj_consume_token(COMMA);
01789 ArithmeticExpression();
01790 jj_consume_token(COMMA);
01791 ArithmeticExpression();
01792 jj_consume_token(RPAREN);
01793 break;
01794 default:
01795 jj_la1[55] = jj_gen;
01796 jj_consume_token(-1);
01797 throw new ParseException();
01798 }
01799 } catch (Throwable jjte000) {
01800 if (jjtc000) {
01801 jjtree.clearNodeScope(jjtn000);
01802 jjtc000 = false;
01803 } else {
01804 jjtree.popNode();
01805 }
01806 if (jjte000 instanceof RuntimeException) {
01807 {if (true) throw (RuntimeException)jjte000;}
01808 }
01809 if (jjte000 instanceof ParseException) {
01810 {if (true) throw (ParseException)jjte000;}
01811 }
01812 {if (true) throw (Error)jjte000;}
01813 } finally {
01814 if (jjtc000) {
01815 jjtree.closeNodeScope(jjtn000, true);
01816 }
01817 }
01818 }
01819
01820 final public void FunctionsReturningNumerics() throws ParseException {
01821
01822 ASTFunctionsReturningNumerics jjtn000 = new ASTFunctionsReturningNumerics(JJTFUNCTIONSRETURNINGNUMERICS);
01823 boolean jjtc000 = true;
01824 jjtree.openNodeScope(jjtn000);Token t;
01825 try {
01826 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01827 case LENGTH:
01828 t = jj_consume_token(LENGTH);
01829 jjtn000.ops.add(new Integer(t.kind));
01830 jj_consume_token(LPAREN);
01831 StringExpression();
01832 jj_consume_token(RPAREN);
01833 break;
01834 case LOCATE:
01835 t = jj_consume_token(LOCATE);
01836 jjtn000.ops.add(new Integer(t.kind));
01837 jj_consume_token(LPAREN);
01838 StringExpression();
01839 jj_consume_token(COMMA);
01840 StringExpression();
01841 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01842 case COMMA:
01843 jj_consume_token(COMMA);
01844 jjtn000.third=true;
01845 ArithmeticExpression();
01846 break;
01847 default:
01848 jj_la1[56] = jj_gen;
01849 ;
01850 }
01851 jj_consume_token(RPAREN);
01852 break;
01853 case ABS:
01854 t = jj_consume_token(ABS);
01855 jjtn000.ops.add(new Integer(t.kind));
01856 jj_consume_token(LPAREN);
01857 ArithmeticExpression();
01858 jj_consume_token(RPAREN);
01859 break;
01860 case SQRT:
01861 t = jj_consume_token(SQRT);
01862 jjtn000.ops.add(new Integer(t.kind));
01863 jj_consume_token(LPAREN);
01864 ArithmeticExpression();
01865 jj_consume_token(RPAREN);
01866 break;
01867 case MOD:
01868 t = jj_consume_token(MOD);
01869 jjtn000.ops.add(new Integer(t.kind));
01870 jj_consume_token(LPAREN);
01871 ArithmeticExpression();
01872 jj_consume_token(COMMA);
01873 ArithmeticExpression();
01874 jj_consume_token(RPAREN);
01875 break;
01876 default:
01877 jj_la1[57] = jj_gen;
01878 jj_consume_token(-1);
01879 throw new ParseException();
01880 }
01881 } catch (Throwable jjte000) {
01882 if (jjtc000) {
01883 jjtree.clearNodeScope(jjtn000);
01884 jjtc000 = false;
01885 } else {
01886 jjtree.popNode();
01887 }
01888 if (jjte000 instanceof RuntimeException) {
01889 {if (true) throw (RuntimeException)jjte000;}
01890 }
01891 if (jjte000 instanceof ParseException) {
01892 {if (true) throw (ParseException)jjte000;}
01893 }
01894 {if (true) throw (Error)jjte000;}
01895 } finally {
01896 if (jjtc000) {
01897 jjtree.closeNodeScope(jjtn000, true);
01898 }
01899 }
01900 }
01901
01902 final public void PatternValue() throws ParseException {
01903 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01904 case string_literal:
01905 StringLiteral();
01906 break;
01907 case input_parameter:
01908 InputParameter();
01909 break;
01910 default:
01911 jj_la1[58] = jj_gen;
01912 jj_consume_token(-1);
01913 throw new ParseException();
01914 }
01915 }
01916
01917 final public void EscapeCharacter() throws ParseException {
01918 StringLiteral();
01919 }
01920
01921 final public void AbstractSchemaName() throws ParseException {
01922
01923 ASTAbstractSchemaName jjtn000 = new ASTAbstractSchemaName(JJTABSTRACTSCHEMANAME);
01924 boolean jjtc000 = true;
01925 jjtree.openNodeScope(jjtn000);Token t;
01926 try {
01927 t = jj_consume_token(IDENTIFIER);
01928 jjtree.closeNodeScope(jjtn000, true);
01929 jjtc000 = false;
01930 jjtn000.value= t.image;
01931 } finally {
01932 if (jjtc000) {
01933 jjtree.closeNodeScope(jjtn000, true);
01934 }
01935 }
01936 }
01937
01938 final public void IdentificationVariable() throws ParseException {
01939
01940 ASTIdentificationVariable jjtn000 = new ASTIdentificationVariable(JJTIDENTIFICATIONVARIABLE);
01941 boolean jjtc000 = true;
01942 jjtree.openNodeScope(jjtn000);Token t;
01943 try {
01944 t = jj_consume_token(IDENTIFIER);
01945 jjtree.closeNodeScope(jjtn000, true);
01946 jjtc000 = false;
01947 jjtn000.value= t.image;
01948 } finally {
01949 if (jjtc000) {
01950 jjtree.closeNodeScope(jjtn000, true);
01951 }
01952 }
01953 }
01954
01955 final public void Identifier() throws ParseException {
01956
01957 ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
01958 boolean jjtc000 = true;
01959 jjtree.openNodeScope(jjtn000);Token t;
01960 try {
01961 t = jj_consume_token(IDENTIFIER);
01962 jjtree.closeNodeScope(jjtn000, true);
01963 jjtc000 = false;
01964 jjtn000.value= t.image;
01965 } finally {
01966 if (jjtc000) {
01967 jjtree.closeNodeScope(jjtn000, true);
01968 }
01969 }
01970 }
01971
01972 final public void Path() throws ParseException {
01973
01974 ASTPath jjtn000 = new ASTPath(JJTPATH);
01975 boolean jjtc000 = true;
01976 jjtree.openNodeScope(jjtn000);Token t;
01977 try {
01978 t = jj_consume_token(IDENTIFIER);
01979 jjtn000.value= t.image;
01980 jj_consume_token(DOT);
01981 t = jj_consume_token(IDENTIFIER);
01982 jjtn000.value = jjtn000.value + "."+t.image;
01983 label_8:
01984 while (true) {
01985 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01986 case DOT:
01987 ;
01988 break;
01989 default:
01990 jj_la1[59] = jj_gen;
01991 break label_8;
01992 }
01993 jj_consume_token(DOT);
01994 t = jj_consume_token(IDENTIFIER);
01995 jjtn000.value = jjtn000.value + "."+t.image;
01996 }
01997 } finally {
01998 if (jjtc000) {
01999 jjtree.closeNodeScope(jjtn000, true);
02000 }
02001 }
02002 }
02003
02004 final public void Literal() throws ParseException {
02005
02006 ASTLiteral jjtn000 = new ASTLiteral(JJTLITERAL);
02007 boolean jjtc000 = true;
02008 jjtree.openNodeScope(jjtn000);
02009 try {
02010 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
02011 case string_literal:
02012 StringLiteral();
02013 break;
02014 case INTEGER_LITERAL:
02015 case FLOATING_POINT_LITERAL:
02016 ArithmeticLiteral();
02017 break;
02018 case FALSE:
02019 case TRUE:
02020 BooleanLiteral();
02021 break;
02022 default:
02023 jj_la1[60] = jj_gen;
02024 jj_consume_token(-1);
02025 throw new ParseException();
02026 }
02027 } catch (Throwable jjte000) {
02028 if (jjtc000) {
02029 jjtree.clearNodeScope(jjtn000);
02030 jjtc000 = false;
02031 } else {
02032 jjtree.popNode();
02033 }
02034 if (jjte000 instanceof RuntimeException) {
02035 {if (true) throw (RuntimeException)jjte000;}
02036 }
02037 if (jjte000 instanceof ParseException) {
02038 {if (true) throw (ParseException)jjte000;}
02039 }
02040 {if (true) throw (Error)jjte000;}
02041 } finally {
02042 if (jjtc000) {
02043 jjtree.closeNodeScope(jjtn000, true);
02044 }
02045 }
02046 }
02047
02048 final public void StringLiteral() throws ParseException {
02049
02050 ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL);
02051 boolean jjtc000 = true;
02052 jjtree.openNodeScope(jjtn000);Token t;
02053 try {
02054 t = jj_consume_token(string_literal);
02055 jjtree.closeNodeScope(jjtn000, true);
02056 jjtc000 = false;
02057 jjtn000.value= t.image.substring(1,t.image.length()-1);
02058 } finally {
02059 if (jjtc000) {
02060 jjtree.closeNodeScope(jjtn000, true);
02061 }
02062 }
02063 }
02064
02065 final public void ArithmeticLiteral() throws ParseException {
02066
02067 ASTArithmeticLiteral jjtn000 = new ASTArithmeticLiteral(JJTARITHMETICLITERAL);
02068 boolean jjtc000 = true;
02069 jjtree.openNodeScope(jjtn000);
02070 try {
02071 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
02072 case INTEGER_LITERAL:
02073 IntegerLiteral();
02074 break;
02075 case FLOATING_POINT_LITERAL:
02076 FloatingPointLiteral();
02077 break;
02078 default:
02079 jj_la1[61] = jj_gen;
02080 jj_consume_token(-1);
02081 throw new ParseException();
02082 }
02083 } catch (Throwable jjte000) {
02084 if (jjtc000) {
02085 jjtree.clearNodeScope(jjtn000);
02086 jjtc000 = false;
02087 } else {
02088 jjtree.popNode();
02089 }
02090 if (jjte000 instanceof RuntimeException) {
02091 {if (true) throw (RuntimeException)jjte000;}
02092 }
02093 if (jjte000 instanceof ParseException) {
02094 {if (true) throw (ParseException)jjte000;}
02095 }
02096 {if (true) throw (Error)jjte000;}
02097 } finally {
02098 if (jjtc000) {
02099 jjtree.closeNodeScope(jjtn000, true);
02100 }
02101 }
02102 }
02103
02104 final public void IntegerLiteral() throws ParseException {
02105
02106 ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(JJTINTEGERLITERAL);
02107 boolean jjtc000 = true;
02108 jjtree.openNodeScope(jjtn000);Token t;
02109 try {
02110 t = jj_consume_token(INTEGER_LITERAL);
02111 jjtree.closeNodeScope(jjtn000, true);
02112 jjtc000 = false;
02113 jjtn000.value= new Long(t.image);
02114 } finally {
02115 if (jjtc000) {
02116 jjtree.closeNodeScope(jjtn000, true);
02117 }
02118 }
02119 }
02120
02121 final public void FloatingPointLiteral() throws ParseException {
02122
02123 ASTFloatingPointLiteral jjtn000 = new ASTFloatingPointLiteral(JJTFLOATINGPOINTLITERAL);
02124 boolean jjtc000 = true;
02125 jjtree.openNodeScope(jjtn000);Token t;
02126 try {
02127 t = jj_consume_token(FLOATING_POINT_LITERAL);
02128 jjtree.closeNodeScope(jjtn000, true);
02129 jjtc000 = false;
02130 jjtn000.value= new Double(t.image);
02131 } finally {
02132 if (jjtc000) {
02133 jjtree.closeNodeScope(jjtn000, true);
02134 }
02135 }
02136 }
02137
02138 final public void BooleanLiteral() throws ParseException {
02139
02140 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(JJTBOOLEANLITERAL);
02141 boolean jjtc000 = true;
02142 jjtree.openNodeScope(jjtn000);Token t;
02143 try {
02144 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
02145 case TRUE:
02146 t = jj_consume_token(TRUE);
02147 jjtree.closeNodeScope(jjtn000, true);
02148 jjtc000 = false;
02149 jjtn000.value= Boolean.TRUE;
02150 break;
02151 case FALSE:
02152 t = jj_consume_token(FALSE);
02153 jjtree.closeNodeScope(jjtn000, true);
02154 jjtc000 = false;
02155 jjtn000.value= Boolean.FALSE;
02156 break;
02157 default:
02158 jj_la1[62] = jj_gen;
02159 jj_consume_token(-1);
02160 throw new ParseException();
02161 }
02162 } finally {
02163 if (jjtc000) {
02164 jjtree.closeNodeScope(jjtn000, true);
02165 }
02166 }
02167 }
02168
02169 final public void InputParameter() throws ParseException {
02170
02171 ASTInputParameter jjtn000 = new ASTInputParameter(JJTINPUTPARAMETER);
02172 boolean jjtc000 = true;
02173 jjtree.openNodeScope(jjtn000);Token t;
02174 try {
02175 t = jj_consume_token(input_parameter);
02176 jjtree.closeNodeScope(jjtn000, true);
02177 jjtc000 = false;
02178 jjtn000.value= new Integer(t.image.substring(1));
02179 } finally {
02180 if (jjtc000) {
02181 jjtree.closeNodeScope(jjtn000, true);
02182 }
02183 }
02184 }
02185
02186 final private boolean jj_2_1(int xla) {
02187 jj_la = xla; jj_lastpos = jj_scanpos = token;
02188 try { return !jj_3_1(); }
02189 catch(LookaheadSuccess ls) { return true; }
02190 finally { jj_save(0, xla); }
02191 }
02192
02193 final private boolean jj_2_2(int xla) {
02194 jj_la = xla; jj_lastpos = jj_scanpos = token;
02195 try { return !jj_3_2(); }
02196 catch(LookaheadSuccess ls) { return true; }
02197 finally { jj_save(1, xla); }
02198 }
02199
02200 final private boolean jj_2_3(int xla) {
02201 jj_la = xla; jj_lastpos = jj_scanpos = token;
02202 try { return !jj_3_3(); }
02203 catch(LookaheadSuccess ls) { return true; }
02204 finally { jj_save(2, xla); }
02205 }
02206
02207 final private boolean jj_2_4(int xla) {
02208 jj_la = xla; jj_lastpos = jj_scanpos = token;
02209 try { return !jj_3_4(); }
02210 catch(LookaheadSuccess ls) { return true; }
02211 finally { jj_save(3, xla); }
02212 }
02213
02214 final private boolean jj_2_5(int xla) {
02215 jj_la = xla; jj_lastpos = jj_scanpos = token;
02216 try { return !jj_3_5(); }
02217 catch(LookaheadSuccess ls) { return true; }
02218 finally { jj_save(4, xla); }
02219 }
02220
02221 final private boolean jj_2_6(int xla) {
02222 jj_la = xla; jj_lastpos = jj_scanpos = token;
02223 try { return !jj_3_6(); }
02224 catch(LookaheadSuccess ls) { return true; }
02225 finally { jj_save(5, xla); }
02226 }
02227
02228 final private boolean jj_2_7(int xla) {
02229 jj_la = xla; jj_lastpos = jj_scanpos = token;
02230 try { return !jj_3_7(); }
02231 catch(LookaheadSuccess ls) { return true; }
02232 finally { jj_save(6, xla); }
02233 }
02234
02235 final private boolean jj_2_8(int xla) {
02236 jj_la = xla; jj_lastpos = jj_scanpos = token;
02237 try { return !jj_3_8(); }
02238 catch(LookaheadSuccess ls) { return true; }
02239 finally { jj_save(7, xla); }
02240 }
02241
02242 final private boolean jj_2_9(int xla) {
02243 jj_la = xla; jj_lastpos = jj_scanpos = token;
02244 try { return !jj_3_9(); }
02245 catch(LookaheadSuccess ls) { return true; }
02246 finally { jj_save(8, xla); }
02247 }
02248
02249 final private boolean jj_2_10(int xla) {
02250 jj_la = xla; jj_lastpos = jj_scanpos = token;
02251 try { return !jj_3_10(); }
02252 catch(LookaheadSuccess ls) { return true; }
02253 finally { jj_save(9, xla); }
02254 }
02255
02256 final private boolean jj_2_11(int xla) {
02257 jj_la = xla; jj_lastpos = jj_scanpos = token;
02258 try { return !jj_3_11(); }
02259 catch(LookaheadSuccess ls) { return true; }
02260 finally { jj_save(10, xla); }
02261 }
02262
02263 final private boolean jj_2_12(int xla) {
02264 jj_la = xla; jj_lastpos = jj_scanpos = token;
02265 try { return !jj_3_12(); }
02266 catch(LookaheadSuccess ls) { return true; }
02267 finally { jj_save(11, xla); }
02268 }
02269
02270 final private boolean jj_2_13(int xla) {
02271 jj_la = xla; jj_lastpos = jj_scanpos = token;
02272 try { return !jj_3_13(); }
02273 catch(LookaheadSuccess ls) { return true; }
02274 finally { jj_save(12, xla); }
02275 }
02276
02277 final private boolean jj_2_14(int xla) {
02278 jj_la = xla; jj_lastpos = jj_scanpos = token;
02279 try { return !jj_3_14(); }
02280 catch(LookaheadSuccess ls) { return true; }
02281 finally { jj_save(13, xla); }
02282 }
02283
02284 final private boolean jj_2_15(int xla) {
02285 jj_la = xla; jj_lastpos = jj_scanpos = token;
02286 try { return !jj_3_15(); }
02287 catch(LookaheadSuccess ls) { return true; }
02288 finally { jj_save(14, xla); }
02289 }
02290
02291 final private boolean jj_2_16(int xla) {
02292 jj_la = xla; jj_lastpos = jj_scanpos = token;
02293 try { return !jj_3_16(); }
02294 catch(LookaheadSuccess ls) { return true; }
02295 finally { jj_save(15, xla); }
02296 }
02297
02298 final private boolean jj_2_17(int xla) {
02299 jj_la = xla; jj_lastpos = jj_scanpos = token;
02300 try { return !jj_3_17(); }
02301 catch(LookaheadSuccess ls) { return true; }
02302 finally { jj_save(16, xla); }
02303 }
02304
02305 final private boolean jj_2_18(int xla) {
02306 jj_la = xla; jj_lastpos = jj_scanpos = token;
02307 try { return !jj_3_18(); }
02308 catch(LookaheadSuccess ls) { return true; }
02309 finally { jj_save(17, xla); }
02310 }
02311
02312 final private boolean jj_2_19(int xla) {
02313 jj_la = xla; jj_lastpos = jj_scanpos = token;
02314 try { return !jj_3_19(); }
02315 catch(LookaheadSuccess ls) { return true; }
02316 finally { jj_save(18, xla); }
02317 }
02318
02319 final private boolean jj_3R_120() {
02320 if (jj_scan_token(LPAREN)) return true;
02321 if (jj_3R_30()) return true;
02322 if (jj_scan_token(RPAREN)) return true;
02323 return false;
02324 }
02325
02326 final private boolean jj_3R_102() {
02327 if (jj_3R_95()) return true;
02328 return false;
02329 }
02330
02331 final private boolean jj_3R_23() {
02332 if (jj_3R_47()) return true;
02333 return false;
02334 }
02335
02336 final private boolean jj_3_1() {
02337 if (jj_3R_9()) return true;
02338 return false;
02339 }
02340
02341 final private boolean jj_3R_69() {
02342 if (jj_3R_25()) return true;
02343 return false;
02344 }
02345
02346 final private boolean jj_3R_26() {
02347 Token xsp;
02348 xsp = jj_scanpos;
02349 if (jj_3R_69()) {
02350 jj_scanpos = xsp;
02351 if (jj_3R_70()) return true;
02352 }
02353 return false;
02354 }
02355
02356 final private boolean jj_3R_65() {
02357 if (jj_3R_84()) return true;
02358 return false;
02359 }
02360
02361 final private boolean jj_3R_63() {
02362 if (jj_3R_87()) return true;
02363 return false;
02364 }
02365
02366 final private boolean jj_3R_25() {
02367 if (jj_3R_47()) return true;
02368 return false;
02369 }
02370
02371 final private boolean jj_3R_122() {
02372 if (jj_3R_90()) return true;
02373 return false;
02374 }
02375
02376 final private boolean jj_3R_119() {
02377 if (jj_3R_116()) return true;
02378 return false;
02379 }
02380
02381 final private boolean jj_3R_101() {
02382 if (jj_3R_47()) return true;
02383 return false;
02384 }
02385
02386 final private boolean jj_3R_88() {
02387 Token xsp;
02388 xsp = jj_scanpos;
02389 if (jj_3R_101()) {
02390 jj_scanpos = xsp;
02391 if (jj_3R_102()) {
02392 jj_scanpos = xsp;
02393 if (jj_3R_103()) {
02394 jj_scanpos = xsp;
02395 if (jj_3R_104()) return true;
02396 }
02397 }
02398 }
02399 return false;
02400 }
02401
02402 final private boolean jj_3R_64() {
02403 if (jj_3R_88()) return true;
02404 return false;
02405 }
02406
02407 final private boolean jj_3R_22() {
02408 Token xsp;
02409 xsp = jj_scanpos;
02410 if (jj_3R_64()) {
02411 jj_scanpos = xsp;
02412 if (jj_3R_65()) return true;
02413 }
02414 return false;
02415 }
02416
02417 final private boolean jj_3R_62() {
02418 if (jj_3R_47()) return true;
02419 return false;
02420 }
02421
02422 final private boolean jj_3R_21() {
02423 Token xsp;
02424 xsp = jj_scanpos;
02425 if (jj_3R_62()) {
02426 jj_scanpos = xsp;
02427 if (jj_3R_63()) return true;
02428 }
02429 return false;
02430 }
02431
02432 final private boolean jj_3R_92() {
02433 Token xsp;
02434 xsp = jj_scanpos;
02435 if (jj_scan_token(6)) {
02436 jj_scanpos = xsp;
02437 if (jj_scan_token(11)) return true;
02438 }
02439 if (jj_3R_91()) return true;
02440 return false;
02441 }
02442
02443 final private boolean jj_3R_121() {
02444 if (jj_3R_84()) return true;
02445 return false;
02446 }
02447
02448 final private boolean jj_3R_118() {
02449 if (jj_3R_47()) return true;
02450 return false;
02451 }
02452
02453 final private boolean jj_3R_113() {
02454 Token xsp;
02455 xsp = jj_scanpos;
02456 if (jj_3R_118()) {
02457 jj_scanpos = xsp;
02458 if (jj_3R_119()) {
02459 jj_scanpos = xsp;
02460 if (jj_3R_120()) {
02461 jj_scanpos = xsp;
02462 if (jj_3R_121()) {
02463 jj_scanpos = xsp;
02464 if (jj_3R_122()) return true;
02465 }
02466 }
02467 }
02468 }
02469 return false;
02470 }
02471
02472 final private boolean jj_3R_76() {
02473 Token xsp;
02474 xsp = jj_scanpos;
02475 if (jj_scan_token(8)) {
02476 jj_scanpos = xsp;
02477 if (jj_scan_token(5)) return true;
02478 }
02479 if (jj_3R_75()) return true;
02480 return false;
02481 }
02482
02483 final private boolean jj_3R_74() {
02484 if (jj_3R_90()) return true;
02485 return false;
02486 }
02487
02488 final private boolean jj_3R_117() {
02489 if (jj_scan_token(COMMA)) return true;
02490 if (jj_3R_30()) return true;
02491 return false;
02492 }
02493
02494 final private boolean jj_3R_112() {
02495 Token xsp;
02496 xsp = jj_scanpos;
02497 if (jj_scan_token(8)) {
02498 jj_scanpos = xsp;
02499 if (jj_scan_token(5)) return true;
02500 }
02501 return false;
02502 }
02503
02504 final private boolean jj_3R_91() {
02505 Token xsp;
02506 xsp = jj_scanpos;
02507 if (jj_3R_112()) jj_scanpos = xsp;
02508 if (jj_3R_113()) return true;
02509 return false;
02510 }
02511
02512 final private boolean jj_3R_58() {
02513 if (jj_3R_31()) return true;
02514 return false;
02515 }
02516
02517 final private boolean jj_3R_84() {
02518 if (jj_scan_token(input_parameter)) return true;
02519 return false;
02520 }
02521
02522 final private boolean jj_3R_98() {
02523 if (jj_3R_89()) return true;
02524 return false;
02525 }
02526
02527 final private boolean jj_3R_75() {
02528 if (jj_3R_91()) return true;
02529 Token xsp;
02530 while (true) {
02531 xsp = jj_scanpos;
02532 if (jj_3R_92()) { jj_scanpos = xsp; break; }
02533 }
02534 return false;
02535 }
02536
02537 final private boolean jj_3R_19() {
02538 if (jj_3R_31()) return true;
02539 return false;
02540 }
02541
02542 final private boolean jj_3R_106() {
02543 if (jj_scan_token(FALSE)) return true;
02544 return false;
02545 }
02546
02547 final private boolean jj_3R_124() {
02548 if (jj_3R_126()) return true;
02549 return false;
02550 }
02551
02552 final private boolean jj_3R_105() {
02553 if (jj_scan_token(TRUE)) return true;
02554 return false;
02555 }
02556
02557 final private boolean jj_3R_89() {
02558 Token xsp;
02559 xsp = jj_scanpos;
02560 if (jj_3R_105()) {
02561 jj_scanpos = xsp;
02562 if (jj_3R_106()) return true;
02563 }
02564 return false;
02565 }
02566
02567 final private boolean jj_3R_30() {
02568 if (jj_3R_75()) return true;
02569 Token xsp;
02570 while (true) {
02571 xsp = jj_scanpos;
02572 if (jj_3R_76()) { jj_scanpos = xsp; break; }
02573 }
02574 return false;
02575 }
02576
02577 final private boolean jj_3R_47() {
02578 if (jj_3R_31()) return true;
02579 return false;
02580 }
02581
02582 final private boolean jj_3_17() {
02583 if (jj_3R_29()) return true;
02584 Token xsp;
02585 xsp = jj_scanpos;
02586 if (jj_scan_token(9)) {
02587 jj_scanpos = xsp;
02588 if (jj_scan_token(13)) {
02589 jj_scanpos = xsp;
02590 if (jj_scan_token(7)) {
02591 jj_scanpos = xsp;
02592 if (jj_scan_token(18)) {
02593 jj_scanpos = xsp;
02594 if (jj_scan_token(10)) {
02595 jj_scanpos = xsp;
02596 if (jj_scan_token(16)) return true;
02597 }
02598 }
02599 }
02600 }
02601 }
02602 if (jj_3R_30()) return true;
02603 return false;
02604 }
02605
02606 final private boolean jj_3_16() {
02607 if (jj_3R_27()) return true;
02608 Token xsp;
02609 xsp = jj_scanpos;
02610 if (jj_scan_token(9)) {
02611 jj_scanpos = xsp;
02612 if (jj_scan_token(16)) return true;
02613 }
02614 if (jj_3R_28()) return true;
02615 return false;
02616 }
02617
02618 final private boolean jj_3R_126() {
02619 if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
02620 return false;
02621 }
02622
02623 final private boolean jj_3R_73() {
02624 if (jj_3R_47()) return true;
02625 return false;
02626 }
02627
02628 final private boolean jj_3R_29() {
02629 Token xsp;
02630 xsp = jj_scanpos;
02631 if (jj_3R_73()) {
02632 jj_scanpos = xsp;
02633 if (jj_3R_74()) return true;
02634 }
02635 return false;
02636 }
02637
02638 final private boolean jj_3R_9() {
02639 if (jj_3R_31()) return true;
02640 return false;
02641 }
02642
02643 final private boolean jj_3_15() {
02644 if (jj_3R_25()) return true;
02645 Token xsp;
02646 xsp = jj_scanpos;
02647 if (jj_scan_token(9)) {
02648 jj_scanpos = xsp;
02649 if (jj_scan_token(13)) {
02650 jj_scanpos = xsp;
02651 if (jj_scan_token(7)) {
02652 jj_scanpos = xsp;
02653 if (jj_scan_token(18)) {
02654 jj_scanpos = xsp;
02655 if (jj_scan_token(10)) {
02656 jj_scanpos = xsp;
02657 if (jj_scan_token(16)) return true;
02658 }
02659 }
02660 }
02661 }
02662 }
02663 if (jj_3R_26()) return true;
02664 return false;
02665 }
02666
02667 final private boolean jj_3_14() {
02668 if (jj_3R_23()) return true;
02669 Token xsp;
02670 xsp = jj_scanpos;
02671 if (jj_scan_token(9)) {
02672 jj_scanpos = xsp;
02673 if (jj_scan_token(16)) return true;
02674 }
02675 if (jj_3R_24()) return true;
02676 return false;
02677 }
02678
02679 final private boolean jj_3R_125() {
02680 if (jj_scan_token(INTEGER_LITERAL)) return true;
02681 return false;
02682 }
02683
02684 final private boolean jj_3_13() {
02685 if (jj_3R_21()) return true;
02686 Token xsp;
02687 xsp = jj_scanpos;
02688 if (jj_scan_token(9)) {
02689 jj_scanpos = xsp;
02690 if (jj_scan_token(13)) {
02691 jj_scanpos = xsp;
02692 if (jj_scan_token(7)) {
02693 jj_scanpos = xsp;
02694 if (jj_scan_token(18)) {
02695 jj_scanpos = xsp;
02696 if (jj_scan_token(10)) {
02697 jj_scanpos = xsp;
02698 if (jj_scan_token(16)) return true;
02699 }
02700 }
02701 }
02702 }
02703 }
02704 if (jj_3R_22()) return true;
02705 return false;
02706 }
02707
02708 final private boolean jj_3R_45() {
02709 if (jj_3R_29()) return true;
02710 Token xsp;
02711 xsp = jj_scanpos;
02712 if (jj_scan_token(9)) {
02713 jj_scanpos = xsp;
02714 if (jj_scan_token(13)) {
02715 jj_scanpos = xsp;
02716 if (jj_scan_token(7)) {
02717 jj_scanpos = xsp;
02718 if (jj_scan_token(18)) {
02719 jj_scanpos = xsp;
02720 if (jj_scan_token(10)) {
02721 jj_scanpos = xsp;
02722 if (jj_scan_token(16)) return true;
02723 }
02724 }
02725 }
02726 }
02727 }
02728 if (jj_3R_30()) return true;
02729 return false;
02730 }
02731
02732 final private boolean jj_3R_56() {
02733 if (jj_3R_84()) return true;
02734 return false;
02735 }
02736
02737 final private boolean jj_3R_97() {
02738 if (jj_3R_116()) return true;
02739 return false;
02740 }
02741
02742 final private boolean jj_3R_44() {
02743 if (jj_3R_27()) return true;
02744 Token xsp;
02745 xsp = jj_scanpos;
02746 if (jj_scan_token(9)) {
02747 jj_scanpos = xsp;
02748 if (jj_scan_token(16)) return true;
02749 }
02750 if (jj_3R_28()) return true;
02751 return false;
02752 }
02753
02754 final private boolean jj_3R_43() {
02755 if (jj_3R_25()) return true;
02756 Token xsp;
02757 xsp = jj_scanpos;
02758 if (jj_scan_token(9)) {
02759 jj_scanpos = xsp;
02760 if (jj_scan_token(13)) {
02761 jj_scanpos = xsp;
02762 if (jj_scan_token(7)) {
02763 jj_scanpos = xsp;
02764 if (jj_scan_token(18)) {
02765 jj_scanpos = xsp;
02766 if (jj_scan_token(10)) {
02767 jj_scanpos = xsp;
02768 if (jj_scan_token(16)) return true;
02769 }
02770 }
02771 }
02772 }
02773 }
02774 if (jj_3R_26()) return true;
02775 return false;
02776 }
02777
02778 final private boolean jj_3R_123() {
02779 if (jj_3R_125()) return true;
02780 return false;
02781 }
02782
02783 final private boolean jj_3R_116() {
02784 Token xsp;
02785 xsp = jj_scanpos;
02786 if (jj_3R_123()) {
02787 jj_scanpos = xsp;
02788 if (jj_3R_124()) return true;
02789 }
02790 return false;
02791 }
02792
02793 final private boolean jj_3R_42() {
02794 if (jj_3R_23()) return true;
02795 Token xsp;
02796 xsp = jj_scanpos;
02797 if (jj_scan_token(9)) {
02798 jj_scanpos = xsp;
02799 if (jj_scan_token(16)) return true;
02800 }
02801 if (jj_3R_24()) return true;
02802 return false;
02803 }
02804
02805 final private boolean jj_3R_12() {
02806 Token xsp;
02807 xsp = jj_scanpos;
02808 if (jj_3R_41()) {
02809 jj_scanpos = xsp;
02810 if (jj_3R_42()) {
02811 jj_scanpos = xsp;
02812 if (jj_3R_43()) {
02813 jj_scanpos = xsp;
02814 if (jj_3R_44()) {
02815 jj_scanpos = xsp;
02816 if (jj_3R_45()) return true;
02817 }
02818 }
02819 }
02820 }
02821 return false;
02822 }
02823
02824 final private boolean jj_3R_41() {
02825 if (jj_3R_21()) return true;
02826 Token xsp;
02827 xsp = jj_scanpos;
02828 if (jj_scan_token(9)) {
02829 jj_scanpos = xsp;
02830 if (jj_scan_token(13)) {
02831 jj_scanpos = xsp;
02832 if (jj_scan_token(7)) {
02833 jj_scanpos = xsp;
02834 if (jj_scan_token(18)) {
02835 jj_scanpos = xsp;
02836 if (jj_scan_token(10)) {
02837 jj_scanpos = xsp;
02838 if (jj_scan_token(16)) return true;
02839 }
02840 }
02841 }
02842 }
02843 }
02844 if (jj_3R_22()) return true;
02845 return false;
02846 }
02847
02848 final private boolean jj_3R_61() {
02849 if (jj_scan_token(NOT)) return true;
02850 return false;
02851 }
02852
02853 final private boolean jj_3R_50() {
02854 if (jj_scan_token(ESCAPE)) return true;
02855 if (jj_3R_82()) return true;
02856 return false;
02857 }
02858
02859 final private boolean jj_3R_95() {
02860 if (jj_scan_token(string_literal)) return true;
02861 return false;
02862 }
02863
02864 final private boolean jj_3R_86() {
02865 if (jj_3R_84()) return true;
02866 return false;
02867 }
02868
02869 final private boolean jj_3R_60() {
02870 if (jj_3R_84()) return true;
02871 return false;
02872 }
02873
02874 final private boolean jj_3_12() {
02875 if (jj_3R_20()) return true;
02876 return false;
02877 }
02878
02879 final private boolean jj_3R_53() {
02880 if (jj_3R_84()) return true;
02881 return false;
02882 }
02883
02884 final private boolean jj_3_11() {
02885 if (jj_3R_19()) return true;
02886 return false;
02887 }
02888
02889 final private boolean jj_3R_48() {
02890 if (jj_scan_token(NOT)) return true;
02891 return false;
02892 }
02893
02894 final private boolean jj_3R_18() {
02895 Token xsp;
02896 xsp = jj_scanpos;
02897 if (jj_3_11()) {
02898 jj_scanpos = xsp;
02899 if (jj_3_12()) {
02900 jj_scanpos = xsp;
02901 if (jj_3R_60()) return true;
02902 }
02903 }
02904 xsp = jj_scanpos;
02905 if (jj_3R_61()) jj_scanpos = xsp;
02906 if (jj_scan_token(MEMBER)) return true;
02907 xsp = jj_scanpos;
02908 if (jj_scan_token(45)) jj_scanpos = xsp;
02909 if (jj_3R_58()) return true;
02910 return false;
02911 }
02912
02913 final private boolean jj_3R_96() {
02914 if (jj_3R_95()) return true;
02915 return false;
02916 }
02917
02918 final private boolean jj_3R_83() {
02919 Token xsp;
02920 xsp = jj_scanpos;
02921 if (jj_3R_96()) {
02922 jj_scanpos = xsp;
02923 if (jj_3R_97()) {
02924 jj_scanpos = xsp;
02925 if (jj_3R_98()) return true;
02926 }
02927 }
02928 return false;
02929 }
02930
02931 final private boolean jj_3R_59() {
02932 if (jj_scan_token(NOT)) return true;
02933 return false;
02934 }
02935
02936 final private boolean jj_3R_77() {
02937 if (jj_scan_token(DOT)) return true;
02938 if (jj_scan_token(IDENTIFIER)) return true;
02939 return false;
02940 }
02941
02942 final private boolean jj_3R_17() {
02943 if (jj_3R_58()) return true;
02944 if (jj_scan_token(IS)) return true;
02945 Token xsp;
02946 xsp = jj_scanpos;
02947 if (jj_3R_59()) jj_scanpos = xsp;
02948 if (jj_scan_token(EMPTY)) return true;
02949 return false;
02950 }
02951
02952 final private boolean jj_3R_51() {
02953 if (jj_scan_token(NOT)) return true;
02954 return false;
02955 }
02956
02957 final private boolean jj_3R_85() {
02958 if (jj_3R_83()) return true;
02959 return false;
02960 }
02961
02962 final private boolean jj_3R_57() {
02963 if (jj_scan_token(NOT)) return true;
02964 return false;
02965 }
02966
02967 final private boolean jj_3R_31() {
02968 if (jj_scan_token(IDENTIFIER)) return true;
02969 if (jj_scan_token(DOT)) return true;
02970 if (jj_scan_token(IDENTIFIER)) return true;
02971 Token xsp;
02972 while (true) {
02973 xsp = jj_scanpos;
02974 if (jj_3R_77()) { jj_scanpos = xsp; break; }
02975 }
02976 return false;
02977 }
02978
02979 final private boolean jj_3R_52() {
02980 if (jj_3R_83()) return true;
02981 return false;
02982 }
02983
02984 final private boolean jj_3R_46() {
02985 if (jj_scan_token(NOT)) return true;
02986 return false;
02987 }
02988
02989 final private boolean jj_3R_55() {
02990 if (jj_3R_9()) return true;
02991 return false;
02992 }
02993
02994 final private boolean jj_3R_16() {
02995 Token xsp;
02996 xsp = jj_scanpos;
02997 if (jj_3R_55()) {
02998 jj_scanpos = xsp;
02999 if (jj_3R_56()) return true;
03000 }
03001 if (jj_scan_token(IS)) return true;
03002 xsp = jj_scanpos;
03003 if (jj_3R_57()) jj_scanpos = xsp;
03004 if (jj_scan_token(NULL)) return true;
03005 return false;
03006 }
03007
03008 final private boolean jj_3R_54() {
03009 if (jj_scan_token(COMMA)) return true;
03010 Token xsp;
03011 xsp = jj_scanpos;
03012 if (jj_3R_85()) {
03013 jj_scanpos = xsp;
03014 if (jj_3R_86()) return true;
03015 }
03016 return false;
03017 }
03018
03019 final private boolean jj_3R_14() {
03020 if (jj_3R_47()) return true;
03021 Token xsp;
03022 xsp = jj_scanpos;
03023 if (jj_3R_48()) jj_scanpos = xsp;
03024 if (jj_scan_token(LIKE)) return true;
03025 if (jj_3R_49()) return true;
03026 xsp = jj_scanpos;
03027 if (jj_3R_50()) jj_scanpos = xsp;
03028 return false;
03029 }
03030
03031 final private boolean jj_3R_20() {
03032 if (jj_scan_token(IDENTIFIER)) return true;
03033 return false;
03034 }
03035
03036 final private boolean jj_3R_15() {
03037 if (jj_3R_47()) return true;
03038 Token xsp;
03039 xsp = jj_scanpos;
03040 if (jj_3R_51()) jj_scanpos = xsp;
03041 if (jj_scan_token(IN)) return true;
03042 if (jj_scan_token(LPAREN)) return true;
03043 xsp = jj_scanpos;
03044 if (jj_3R_52()) {
03045 jj_scanpos = xsp;
03046 if (jj_3R_53()) return true;
03047 }
03048 while (true) {
03049 xsp = jj_scanpos;
03050 if (jj_3R_54()) { jj_scanpos = xsp; break; }
03051 }
03052 if (jj_scan_token(RPAREN)) return true;
03053 return false;
03054 }
03055
03056 final private boolean jj_3_10() {
03057 if (jj_3R_18()) return true;
03058 return false;
03059 }
03060
03061 final private boolean jj_3R_81() {
03062 if (jj_3R_84()) return true;
03063 return false;
03064 }
03065
03066 final private boolean jj_3_9() {
03067 if (jj_3R_17()) return true;
03068 return false;
03069 }
03070
03071 final private boolean jj_3_8() {
03072 if (jj_3R_16()) return true;
03073 return false;
03074 }
03075
03076 final private boolean jj_3_7() {
03077 if (jj_3R_15()) return true;
03078 return false;
03079 }
03080
03081 final private boolean jj_3_6() {
03082 if (jj_3R_14()) return true;
03083 return false;
03084 }
03085
03086 final private boolean jj_3_19() {
03087 if (jj_3R_20()) return true;
03088 return false;
03089 }
03090
03091 final private boolean jj_3R_13() {
03092 if (jj_3R_30()) return true;
03093 Token xsp;
03094 xsp = jj_scanpos;
03095 if (jj_3R_46()) jj_scanpos = xsp;
03096 if (jj_scan_token(BETWEEN)) return true;
03097 if (jj_3R_30()) return true;
03098 if (jj_scan_token(AND)) return true;
03099 if (jj_3R_30()) return true;
03100 return false;
03101 }
03102
03103 final private boolean jj_3_5() {
03104 if (jj_3R_13()) return true;
03105 return false;
03106 }
03107
03108 final private boolean jj_3R_104() {
03109 if (jj_3R_87()) return true;
03110 return false;
03111 }
03112
03113 final private boolean jj_3_4() {
03114 if (jj_3R_12()) return true;
03115 return false;
03116 }
03117
03118 final private boolean jj_3R_38() {
03119 if (jj_3R_18()) return true;
03120 return false;
03121 }
03122
03123 final private boolean jj_3R_37() {
03124 if (jj_3R_17()) return true;
03125 return false;
03126 }
03127
03128 final private boolean jj_3R_36() {
03129 if (jj_3R_16()) return true;
03130 return false;
03131 }
03132
03133 final private boolean jj_3R_82() {
03134 if (jj_3R_95()) return true;
03135 return false;
03136 }
03137
03138 final private boolean jj_3_3() {
03139 if (jj_scan_token(LPAREN)) return true;
03140 if (jj_3R_11()) return true;
03141 if (jj_scan_token(RPAREN)) return true;
03142 return false;
03143 }
03144
03145 final private boolean jj_3R_35() {
03146 if (jj_3R_15()) return true;
03147 return false;
03148 }
03149
03150 final private boolean jj_3R_34() {
03151 if (jj_3R_14()) return true;
03152 return false;
03153 }
03154
03155 final private boolean jj_3R_33() {
03156 if (jj_3R_13()) return true;
03157 return false;
03158 }
03159
03160 final private boolean jj_3_2() {
03161 if (jj_3R_10()) return true;
03162 return false;
03163 }
03164
03165 final private boolean jj_3R_79() {
03166 if (jj_scan_token(AND)) return true;
03167 if (jj_3R_78()) return true;
03168 return false;
03169 }
03170
03171 final private boolean jj_3R_10() {
03172 Token xsp;
03173 xsp = jj_scanpos;
03174 if (jj_3R_32()) {
03175 jj_scanpos = xsp;
03176 if (jj_3R_33()) {
03177 jj_scanpos = xsp;
03178 if (jj_3R_34()) {
03179 jj_scanpos = xsp;
03180 if (jj_3R_35()) {
03181 jj_scanpos = xsp;
03182 if (jj_3R_36()) {
03183 jj_scanpos = xsp;
03184 if (jj_3R_37()) {
03185 jj_scanpos = xsp;
03186 if (jj_3R_38()) return true;
03187 }
03188 }
03189 }
03190 }
03191 }
03192 }
03193 return false;
03194 }
03195
03196 final private boolean jj_3R_32() {
03197 if (jj_3R_12()) return true;
03198 return false;
03199 }
03200
03201 final private boolean jj_3R_80() {
03202 if (jj_3R_95()) return true;
03203 return false;
03204 }
03205
03206 final private boolean jj_3R_68() {
03207 if (jj_3R_84()) return true;
03208 return false;
03209 }
03210
03211 final private boolean jj_3R_49() {
03212 Token xsp;
03213 xsp = jj_scanpos;
03214 if (jj_3R_80()) {
03215 jj_scanpos = xsp;
03216 if (jj_3R_81()) return true;
03217 }
03218 return false;
03219 }
03220
03221 final private boolean jj_3R_115() {
03222 if (jj_scan_token(LPAREN)) return true;
03223 if (jj_3R_11()) return true;
03224 if (jj_scan_token(RPAREN)) return true;
03225 return false;
03226 }
03227
03228 final private boolean jj_3R_111() {
03229 if (jj_scan_token(MOD)) return true;
03230 if (jj_scan_token(LPAREN)) return true;
03231 if (jj_3R_30()) return true;
03232 if (jj_scan_token(COMMA)) return true;
03233 if (jj_3R_30()) return true;
03234 if (jj_scan_token(RPAREN)) return true;
03235 return false;
03236 }
03237
03238 final private boolean jj_3R_110() {
03239 if (jj_scan_token(SQRT)) return true;
03240 if (jj_scan_token(LPAREN)) return true;
03241 if (jj_3R_30()) return true;
03242 if (jj_scan_token(RPAREN)) return true;
03243 return false;
03244 }
03245
03246 final private boolean jj_3R_72() {
03247 if (jj_3R_84()) return true;
03248 return false;
03249 }
03250
03251 final private boolean jj_3R_109() {
03252 if (jj_scan_token(ABS)) return true;
03253 if (jj_scan_token(LPAREN)) return true;
03254 if (jj_3R_30()) return true;
03255 if (jj_scan_token(RPAREN)) return true;
03256 return false;
03257 }
03258
03259 final private boolean jj_3R_108() {
03260 if (jj_scan_token(LOCATE)) return true;
03261 if (jj_scan_token(LPAREN)) return true;
03262 if (jj_3R_22()) return true;
03263 if (jj_scan_token(COMMA)) return true;
03264 if (jj_3R_22()) return true;
03265 Token xsp;
03266 xsp = jj_scanpos;
03267 if (jj_3R_117()) jj_scanpos = xsp;
03268 if (jj_scan_token(RPAREN)) return true;
03269 return false;
03270 }
03271
03272 final private boolean jj_3R_40() {
03273 if (jj_scan_token(OR)) return true;
03274 if (jj_3R_39()) return true;
03275 return false;
03276 }
03277
03278 final private boolean jj_3R_114() {
03279 if (jj_3R_10()) return true;
03280 return false;
03281 }
03282
03283 final private boolean jj_3R_94() {
03284 Token xsp;
03285 xsp = jj_scanpos;
03286 if (jj_3R_114()) {
03287 jj_scanpos = xsp;
03288 if (jj_3R_115()) return true;
03289 }
03290 return false;
03291 }
03292
03293 final private boolean jj_3R_107() {
03294 if (jj_scan_token(LENGTH)) return true;
03295 if (jj_scan_token(LPAREN)) return true;
03296 if (jj_3R_22()) return true;
03297 if (jj_scan_token(RPAREN)) return true;
03298 return false;
03299 }
03300
03301 final private boolean jj_3R_90() {
03302 Token xsp;
03303 xsp = jj_scanpos;
03304 if (jj_3R_107()) {
03305 jj_scanpos = xsp;
03306 if (jj_3R_108()) {
03307 jj_scanpos = xsp;
03308 if (jj_3R_109()) {
03309 jj_scanpos = xsp;
03310 if (jj_3R_110()) {
03311 jj_scanpos = xsp;
03312 if (jj_3R_111()) return true;
03313 }
03314 }
03315 }
03316 }
03317 return false;
03318 }
03319
03320 final private boolean jj_3R_93() {
03321 if (jj_scan_token(NOT)) return true;
03322 return false;
03323 }
03324
03325 final private boolean jj_3R_78() {
03326 Token xsp;
03327 xsp = jj_scanpos;
03328 if (jj_3R_93()) jj_scanpos = xsp;
03329 if (jj_3R_94()) return true;
03330 return false;
03331 }
03332
03333 final private boolean jj_3R_100() {
03334 if (jj_scan_token(SUBSTRING)) return true;
03335 if (jj_scan_token(LPAREN)) return true;
03336 if (jj_3R_22()) return true;
03337 if (jj_scan_token(COMMA)) return true;
03338 if (jj_3R_30()) return true;
03339 if (jj_scan_token(COMMA)) return true;
03340 if (jj_3R_30()) return true;
03341 if (jj_scan_token(RPAREN)) return true;
03342 return false;
03343 }
03344
03345 final private boolean jj_3R_99() {
03346 if (jj_scan_token(CONCAT)) return true;
03347 if (jj_scan_token(LPAREN)) return true;
03348 if (jj_3R_22()) return true;
03349 if (jj_scan_token(COMMA)) return true;
03350 if (jj_3R_22()) return true;
03351 if (jj_scan_token(RPAREN)) return true;
03352 return false;
03353 }
03354
03355 final private boolean jj_3R_87() {
03356 Token xsp;
03357 xsp = jj_scanpos;
03358 if (jj_3R_99()) {
03359 jj_scanpos = xsp;
03360 if (jj_3R_100()) return true;
03361 }
03362 return false;
03363 }
03364
03365 final private boolean jj_3R_67() {
03366 if (jj_3R_89()) return true;
03367 return false;
03368 }
03369
03370 final private boolean jj_3R_39() {
03371 if (jj_3R_78()) return true;
03372 Token xsp;
03373 while (true) {
03374 xsp = jj_scanpos;
03375 if (jj_3R_79()) { jj_scanpos = xsp; break; }
03376 }
03377 return false;
03378 }
03379
03380 final private boolean jj_3R_103() {
03381 if (jj_scan_token(LPAREN)) return true;
03382 if (jj_3R_22()) return true;
03383 if (jj_scan_token(RPAREN)) return true;
03384 return false;
03385 }
03386
03387 final private boolean jj_3R_71() {
03388 if (jj_3R_27()) return true;
03389 return false;
03390 }
03391
03392 final private boolean jj_3R_28() {
03393 Token xsp;
03394 xsp = jj_scanpos;
03395 if (jj_3R_71()) {
03396 jj_scanpos = xsp;
03397 if (jj_3R_72()) return true;
03398 }
03399 return false;
03400 }
03401
03402 final private boolean jj_3R_11() {
03403 if (jj_3R_39()) return true;
03404 Token xsp;
03405 while (true) {
03406 xsp = jj_scanpos;
03407 if (jj_3R_40()) { jj_scanpos = xsp; break; }
03408 }
03409 return false;
03410 }
03411
03412 final private boolean jj_3_18() {
03413 if (jj_3R_19()) return true;
03414 return false;
03415 }
03416
03417 final private boolean jj_3R_27() {
03418 Token xsp;
03419 xsp = jj_scanpos;
03420 if (jj_3_18()) {
03421 jj_scanpos = xsp;
03422 if (jj_3_19()) return true;
03423 }
03424 return false;
03425 }
03426
03427 final private boolean jj_3R_70() {
03428 if (jj_3R_84()) return true;
03429 return false;
03430 }
03431
03432 final private boolean jj_3R_66() {
03433 if (jj_3R_47()) return true;
03434 return false;
03435 }
03436
03437 final private boolean jj_3R_24() {
03438 Token xsp;
03439 xsp = jj_scanpos;
03440 if (jj_3R_66()) {
03441 jj_scanpos = xsp;
03442 if (jj_3R_67()) {
03443 jj_scanpos = xsp;
03444 if (jj_3R_68()) return true;
03445 }
03446 }
03447 return false;
03448 }
03449
03450 public EJBQLTokenManager token_source;
03451 SimpleCharStream jj_input_stream;
03452 public Token token, jj_nt;
03453 private int jj_ntk;
03454 private Token jj_scanpos, jj_lastpos;
03455 private int jj_la;
03456 public boolean lookingAhead = false;
03457 private boolean jj_semLA;
03458 private int jj_gen;
03459 final private int[] jj_la1 = new int[63];
03460 static private int[] jj_la1_0;
03461 static private int[] jj_la1_1;
03462 static private int[] jj_la1_2;
03463 static {
03464 jj_la1_0();
03465 jj_la1_1();
03466 jj_la1_2();
03467 }
03468 private static void jj_la1_0() {
03469 jj_la1_0 = new int[] {0x0,0x0,0x0,0x4000,0x0,0x200000,0x200000,0x10000000,0x4800000,0x4800000,0x800000,0x10000000,0x10000000,0x0,0x4800000,0x4000,0x8400000,0x8400000,0x4000,0x0,0x0,0x100000,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x52680,0x10200,0x52680,0x10200,0x52680,0x80000,0x120,0x120,0x840,0x840,0x120,0x120,0xa0000,0x2000000,0x2020000,0x2020000,0x0,0x0,0x0,0x2000000,0x4000,0x80000,0x0,0x1000,0x0,0x0,0x0,};
03470 }
03471 private static void jj_la1_1() {
03472 jj_la1_1 = new int[] {0x100000,0x8000,0x10,0x0,0x80000001,0x0,0x0,0x0,0x80081140,0x80080140,0x80140,0x0,0x0,0x80000000,0x80140,0x0,0x0,0x0,0x0,0x2400000,0x4000,0x0,0x400,0x400,0x400,0x23e00000,0x0,0x23e00000,0x400,0x0,0x80400000,0x400,0x400,0x400000,0x400,0x2000,0x0,0x0,0x0,0x0,0x0,0x80020224,0x0,0x0,0x0,0x0,0x0,0x0,0xa2420224,0x80040000,0x80640000,0x80240000,0x80400000,0x81c00000,0x80400000,0x40000,0x0,0x20224,0x600000,0x0,0x23a00000,0x22000000,0x1800000,};
03473 }
03474 private static void jj_la1_2() {
03475 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,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
03476 }
03477 final private JJCalls[] jj_2_rtns = new JJCalls[19];
03478 private boolean jj_rescan = false;
03479 private int jj_gc = 0;
03480
03481 public EJBQL(java.io.InputStream stream) {
03482 jj_input_stream = new SimpleCharStream(stream, 1, 1);
03483 token_source = new EJBQLTokenManager(jj_input_stream);
03484 token = new Token();
03485 jj_ntk = -1;
03486 jj_gen = 0;
03487 for (int i = 0; i < 63; i++) jj_la1[i] = -1;
03488 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
03489 }
03490
03491 public void ReInit(java.io.InputStream stream) {
03492 jj_input_stream.ReInit(stream, 1, 1);
03493 token_source.ReInit(jj_input_stream);
03494 token = new Token();
03495 jj_ntk = -1;
03496 jjtree.reset();
03497 jj_gen = 0;
03498 for (int i = 0; i < 63; i++) jj_la1[i] = -1;
03499 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
03500 }
03501
03502 public EJBQL(java.io.Reader stream) {
03503 jj_input_stream = new SimpleCharStream(stream, 1, 1);
03504 token_source = new EJBQLTokenManager(jj_input_stream);
03505 token = new Token();
03506 jj_ntk = -1;
03507 jj_gen = 0;
03508 for (int i = 0; i < 63; i++) jj_la1[i] = -1;
03509 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
03510 }
03511
03512 public void ReInit(java.io.Reader stream) {
03513 jj_input_stream.ReInit(stream, 1, 1);
03514 token_source.ReInit(jj_input_stream);
03515 token = new Token();
03516 jj_ntk = -1;
03517 jjtree.reset();
03518 jj_gen = 0;
03519 for (int i = 0; i < 63; i++) jj_la1[i] = -1;
03520 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
03521 }
03522
03523 public EJBQL(EJBQLTokenManager tm) {
03524 token_source = tm;
03525 token = new Token();
03526 jj_ntk = -1;
03527 jj_gen = 0;
03528 for (int i = 0; i < 63; i++) jj_la1[i] = -1;
03529 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
03530 }
03531
03532 public void ReInit(EJBQLTokenManager tm) {
03533 token_source = tm;
03534 token = new Token();
03535 jj_ntk = -1;
03536 jjtree.reset();
03537 jj_gen = 0;
03538 for (int i = 0; i < 63; i++) jj_la1[i] = -1;
03539 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
03540 }
03541
03542 final private Token jj_consume_token(int kind) throws ParseException {
03543 Token oldToken;
03544 if ((oldToken = token).next != null) token = token.next;
03545 else token = token.next = token_source.getNextToken();
03546 jj_ntk = -1;
03547 if (token.kind == kind) {
03548 jj_gen++;
03549 if (++jj_gc > 100) {
03550 jj_gc = 0;
03551 for (int i = 0; i < jj_2_rtns.length; i++) {
03552 JJCalls c = jj_2_rtns[i];
03553 while (c != null) {
03554 if (c.gen < jj_gen) c.first = null;
03555 c = c.next;
03556 }
03557 }
03558 }
03559 return token;
03560 }
03561 token = oldToken;
03562 jj_kind = kind;
03563 throw generateParseException();
03564 }
03565
03566 static private final class LookaheadSuccess extends java.lang.Error { }
03567 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
03568 final private boolean jj_scan_token(int kind) {
03569 if (jj_scanpos == jj_lastpos) {
03570 jj_la--;
03571 if (jj_scanpos.next == null) {
03572 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
03573 } else {
03574 jj_lastpos = jj_scanpos = jj_scanpos.next;
03575 }
03576 } else {
03577 jj_scanpos = jj_scanpos.next;
03578 }
03579 if (jj_rescan) {
03580 int i = 0; Token tok = token;
03581 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
03582 if (tok != null) jj_add_error_token(kind, i);
03583 }
03584 if (jj_scanpos.kind != kind) return true;
03585 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
03586 return false;
03587 }
03588
03589 final public Token getNextToken() {
03590 if (token.next != null) token = token.next;
03591 else token = token.next = token_source.getNextToken();
03592 jj_ntk = -1;
03593 jj_gen++;
03594 return token;
03595 }
03596
03597 final public Token getToken(int index) {
03598 Token t = lookingAhead ? jj_scanpos : token;
03599 for (int i = 0; i < index; i++) {
03600 if (t.next != null) t = t.next;
03601 else t = t.next = token_source.getNextToken();
03602 }
03603 return t;
03604 }
03605
03606 final private int jj_ntk() {
03607 if ((jj_nt=token.next) == null)
03608 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
03609 else
03610 return (jj_ntk = jj_nt.kind);
03611 }
03612
03613 private java.util.Vector jj_expentries = new java.util.Vector();
03614 private int[] jj_expentry;
03615 private int jj_kind = -1;
03616 private int[] jj_lasttokens = new int[100];
03617 private int jj_endpos;
03618
03619 private void jj_add_error_token(int kind, int pos) {
03620 if (pos >= 100) return;
03621 if (pos == jj_endpos + 1) {
03622 jj_lasttokens[jj_endpos++] = kind;
03623 } else if (jj_endpos != 0) {
03624 jj_expentry = new int[jj_endpos];
03625 for (int i = 0; i < jj_endpos; i++) {
03626 jj_expentry[i] = jj_lasttokens[i];
03627 }
03628 boolean exists = false;
03629 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
03630 int[] oldentry = (int[])(e.nextElement());
03631 if (oldentry.length == jj_expentry.length) {
03632 exists = true;
03633 for (int i = 0; i < jj_expentry.length; i++) {
03634 if (oldentry[i] != jj_expentry[i]) {
03635 exists = false;
03636 break;
03637 }
03638 }
03639 if (exists) break;
03640 }
03641 }
03642 if (!exists) jj_expentries.addElement(jj_expentry);
03643 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
03644 }
03645 }
03646
03647 public ParseException generateParseException() {
03648 jj_expentries.removeAllElements();
03649 boolean[] la1tokens = new boolean[66];
03650 for (int i = 0; i < 66; i++) {
03651 la1tokens[i] = false;
03652 }
03653 if (jj_kind >= 0) {
03654 la1tokens[jj_kind] = true;
03655 jj_kind = -1;
03656 }
03657 for (int i = 0; i < 63; i++) {
03658 if (jj_la1[i] == jj_gen) {
03659 for (int j = 0; j < 32; j++) {
03660 if ((jj_la1_0[i] & (1<<j)) != 0) {
03661 la1tokens[j] = true;
03662 }
03663 if ((jj_la1_1[i] & (1<<j)) != 0) {
03664 la1tokens[32+j] = true;
03665 }
03666 if ((jj_la1_2[i] & (1<<j)) != 0) {
03667 la1tokens[64+j] = true;
03668 }
03669 }
03670 }
03671 }
03672 for (int i = 0; i < 66; i++) {
03673 if (la1tokens[i]) {
03674 jj_expentry = new int[1];
03675 jj_expentry[0] = i;
03676 jj_expentries.addElement(jj_expentry);
03677 }
03678 }
03679 jj_endpos = 0;
03680 jj_rescan_token();
03681 jj_add_error_token(0, 0);
03682 int[][] exptokseq = new int[jj_expentries.size()][];
03683 for (int i = 0; i < jj_expentries.size(); i++) {
03684 exptokseq[i] = (int[])jj_expentries.elementAt(i);
03685 }
03686 return new ParseException(token, exptokseq, tokenImage);
03687 }
03688
03689 final public void enable_tracing() {
03690 }
03691
03692 final public void disable_tracing() {
03693 }
03694
03695 final private void jj_rescan_token() {
03696 jj_rescan = true;
03697 for (int i = 0; i < 19; i++) {
03698 JJCalls p = jj_2_rtns[i];
03699 do {
03700 if (p.gen > jj_gen) {
03701 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
03702 switch (i) {
03703 case 0: jj_3_1(); break;
03704 case 1: jj_3_2(); break;
03705 case 2: jj_3_3(); break;
03706 case 3: jj_3_4(); break;
03707 case 4: jj_3_5(); break;
03708 case 5: jj_3_6(); break;
03709 case 6: jj_3_7(); break;
03710 case 7: jj_3_8(); break;
03711 case 8: jj_3_9(); break;
03712 case 9: jj_3_10(); break;
03713 case 10: jj_3_11(); break;
03714 case 11: jj_3_12(); break;
03715 case 12: jj_3_13(); break;
03716 case 13: jj_3_14(); break;
03717 case 14: jj_3_15(); break;
03718 case 15: jj_3_16(); break;
03719 case 16: jj_3_17(); break;
03720 case 17: jj_3_18(); break;
03721 case 18: jj_3_19(); break;
03722 }
03723 }
03724 p = p.next;
03725 } while (p != null);
03726 }
03727 jj_rescan = false;
03728 }
03729
03730 final private void jj_save(int index, int xla) {
03731 JJCalls p = jj_2_rtns[index];
03732 while (p.gen > jj_gen) {
03733 if (p.next == null) { p = p.next = new JJCalls(); break; }
03734 p = p.next;
03735 }
03736 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
03737 }
03738
03739 static final class JJCalls {
03740 int gen;
03741 Token first;
03742 int arg;
03743 JJCalls next;
03744 }
03745
03746 }
