00001
00002 #include "ExpressionParser.hpp"
00003 #include "antlr/NoViableAltException.hpp"
00004 #include "antlr/SemanticException.hpp"
00005
00006 #include <list>
00007 #include "antlr/MismatchedTokenException.hpp"
00008 #include "UAP/UAPException.hpp"
00009 #define EXP_DEFAULT_CATCH ANTLR_USE_NAMESPACE(antlr)Token* nextToken = NULL; \
00010 try { \
00011 nextToken = LT(2); \
00012 } catch (...) { \
00013 throw UAPParserException("error: parse error at end of input"); \
00014 } \
00015 throw UAPParserException("error: parse error before '"+(nextToken)->getText()+"' token"); \
00016
00017 ExpressionParser::ExpressionParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
00018 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
00019 {
00020 setTokenNames(_tokenNames);
00021 }
00022
00023 ExpressionParser::ExpressionParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
00024 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2)
00025 {
00026 setTokenNames(_tokenNames);
00027 }
00028
00029 ExpressionParser::ExpressionParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
00030 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
00031 {
00032 setTokenNames(_tokenNames);
00033 }
00034
00035 ExpressionParser::ExpressionParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
00036 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2)
00037 {
00038 setTokenNames(_tokenNames);
00039 }
00040
00041 ExpressionParser::ExpressionParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
00042 : ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2)
00043 {
00044 setTokenNames(_tokenNames);
00045 }
00046
00048 int ExpressionParser::expr() {
00049 int n;
00050
00051 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00052 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00053 ANTLR_USE_NAMESPACE(antlr)RefAST expr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00054 n = 0; nident = &n;
00055
00056 try {
00057 aExpr();
00058 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00059 {
00060 ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00061 tmp51_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00062 match(SEMI);
00063 }
00064 expr_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00065 }
00066 catch (ANTLR_USE_NAMESPACE(antlr)ANTLRException& ex) {
00067
00068 ANTLR_USE_NAMESPACE(antlr)Token* nextToken = NULL;
00069 try {
00070 nextToken = LT(2);
00071 } catch (...) {
00072 throw UAPParserException("error: syntax error at end of input");
00073 }
00074 throw UAPParserException("error: parse error before '"+(nextToken)->getText()+"' token");
00075
00076 }
00077 returnAST = expr_AST;
00078 return n;
00079 }
00080
00082 void ExpressionParser::aExpr() {
00083
00084 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00085 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00086 ANTLR_USE_NAMESPACE(antlr)RefAST aExpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00087
00088 prodExpr();
00089 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00090 {
00091 for (;;) {
00092 if ((LA(1)==PLUS||LA(1)==MINUS)) {
00093 {
00094 switch ( LA(1)) {
00095 case PLUS:
00096 {
00097 ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00098 tmp52_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00099 astFactory.makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp52_AST));
00100 match(PLUS);
00101 break;
00102 }
00103 case MINUS:
00104 {
00105 ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00106 tmp53_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00107 astFactory.makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp53_AST));
00108 match(MINUS);
00109 break;
00110 }
00111 default:
00112 {
00113 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00114 }
00115 }
00116 }
00117 prodExpr();
00118 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00119 }
00120 else {
00121 goto _loop6;
00122 }
00123
00124 }
00125 _loop6:;
00126 }
00127 aExpr_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00128 returnAST = aExpr_AST;
00129 }
00130
00132 void ExpressionParser::prodExpr() {
00133
00134 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00135 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00136 ANTLR_USE_NAMESPACE(antlr)RefAST prodExpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00137
00138 powExpr();
00139 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00140 {
00141 for (;;) {
00142 if (((LA(1) >= MULT && LA(1) <= MOD))) {
00143 {
00144 switch ( LA(1)) {
00145 case MULT:
00146 {
00147 ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00148 tmp54_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00149 astFactory.makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp54_AST));
00150 match(MULT);
00151 break;
00152 }
00153 case DIV:
00154 {
00155 ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00156 tmp55_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00157 astFactory.makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp55_AST));
00158 match(DIV);
00159 break;
00160 }
00161 case MOD:
00162 {
00163 ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00164 tmp56_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00165 astFactory.makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp56_AST));
00166 match(MOD);
00167 break;
00168 }
00169 default:
00170 {
00171 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00172 }
00173 }
00174 }
00175 powExpr();
00176 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00177 }
00178 else {
00179 goto _loop10;
00180 }
00181
00182 }
00183 _loop10:;
00184 }
00185 prodExpr_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00186 returnAST = prodExpr_AST;
00187 }
00188
00190 void ExpressionParser::powExpr() {
00191
00192 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00193 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00194 ANTLR_USE_NAMESPACE(antlr)RefAST powExpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00195
00196 tExpr();
00197 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00198 {
00199 switch ( LA(1)) {
00200 case POW:
00201 {
00202 ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00203 tmp57_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00204 astFactory.makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp57_AST));
00205 match(POW);
00206 tExpr();
00207 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00208 break;
00209 }
00210 case SEMI:
00211 case PLUS:
00212 case MINUS:
00213 case MULT:
00214 case DIV:
00215 case MOD:
00216 case COMMA:
00217 case RPAREN:
00218 {
00219 break;
00220 }
00221 default:
00222 {
00223 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00224 }
00225 }
00226 }
00227 powExpr_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00228 returnAST = powExpr_AST;
00229 }
00230
00234 void ExpressionParser::tExpr() {
00235
00236 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00237 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00238 ANTLR_USE_NAMESPACE(antlr)RefAST tExpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00239
00240 {
00241 switch ( LA(1)) {
00242 case PLUS:
00243 {
00244 ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00245 tmp58_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00246 astFactory.makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp58_AST));
00247 match(PLUS);
00248 break;
00249 }
00250 case MINUS:
00251 {
00252 ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00253 tmp59_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00254 astFactory.makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp59_AST));
00255 match(MINUS);
00256 break;
00257 }
00258 case LPAREN:
00259 case IDENT:
00260 case LBRACKET:
00261 case NUM_DOUBLE:
00262 case NUM_FLOAT:
00263 case LITERAL_sqrt:
00264 case LITERAL_log:
00265 case LITERAL_exp:
00266 case LITERAL_sin:
00267 case LITERAL_cos:
00268 case LITERAL_tan:
00269 case LITERAL_asin:
00270 case LITERAL_acos:
00271 case LITERAL_atan:
00272 case LITERAL_atan2:
00273 case LITERAL_abs:
00274 case LITERAL_max:
00275 case LITERAL_min:
00276 case LITERAL_ran:
00277 case LITERAL_ran_gauss:
00278 case LITERAL_randf:
00279 case LITERAL_gauss:
00280 case LITERAL_tgauss:
00281 case 43:
00282 case 44:
00283 case 45:
00284 {
00285 break;
00286 }
00287 default:
00288 {
00289 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00290 }
00291 }
00292 }
00293 {
00294 switch ( LA(1)) {
00295 case LITERAL_sqrt:
00296 case LITERAL_log:
00297 case LITERAL_exp:
00298 case LITERAL_sin:
00299 case LITERAL_cos:
00300 case LITERAL_tan:
00301 case LITERAL_asin:
00302 case LITERAL_acos:
00303 case LITERAL_atan:
00304 case LITERAL_atan2:
00305 case LITERAL_abs:
00306 case LITERAL_max:
00307 case LITERAL_min:
00308 case LITERAL_ran:
00309 case LITERAL_ran_gauss:
00310 case LITERAL_randf:
00311 case LITERAL_gauss:
00312 case LITERAL_tgauss:
00313 case 43:
00314 case 44:
00315 case 45:
00316 {
00317 tFunc();
00318 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00319 break;
00320 }
00321 case LPAREN:
00322 case IDENT:
00323 case LBRACKET:
00324 case NUM_DOUBLE:
00325 case NUM_FLOAT:
00326 {
00327 atom();
00328 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00329 break;
00330 }
00331 default:
00332 {
00333 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00334 }
00335 }
00336 }
00337 tExpr_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00338 returnAST = tExpr_AST;
00339 }
00340
00342 void ExpressionParser::tFunc() {
00343
00344 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00345 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00346 ANTLR_USE_NAMESPACE(antlr)RefAST tFunc_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00347
00348 mathFunction();
00349 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00350 ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00351 tmp60_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00352 match(LPAREN);
00353 {
00354 switch ( LA(1)) {
00355 case PLUS:
00356 case MINUS:
00357 case LPAREN:
00358 case IDENT:
00359 case LBRACKET:
00360 case NUM_DOUBLE:
00361 case NUM_FLOAT:
00362 case LITERAL_sqrt:
00363 case LITERAL_log:
00364 case LITERAL_exp:
00365 case LITERAL_sin:
00366 case LITERAL_cos:
00367 case LITERAL_tan:
00368 case LITERAL_asin:
00369 case LITERAL_acos:
00370 case LITERAL_atan:
00371 case LITERAL_atan2:
00372 case LITERAL_abs:
00373 case LITERAL_max:
00374 case LITERAL_min:
00375 case LITERAL_ran:
00376 case LITERAL_ran_gauss:
00377 case LITERAL_randf:
00378 case LITERAL_gauss:
00379 case LITERAL_tgauss:
00380 case 43:
00381 case 44:
00382 case 45:
00383 {
00384 aExpr();
00385 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00386 {
00387 for (;;) {
00388 if ((LA(1)==COMMA)) {
00389 ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00390 tmp61_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00391 match(COMMA);
00392 aExpr();
00393 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00394 }
00395 else {
00396 goto _loop19;
00397 }
00398
00399 }
00400 _loop19:;
00401 }
00402 break;
00403 }
00404 case RPAREN:
00405 {
00406 break;
00407 }
00408 default:
00409 {
00410 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00411 }
00412 }
00413 }
00414 ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00415 tmp62_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00416 match(RPAREN);
00417 tFunc_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00418 tFunc_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.make( (new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(FUNC,"FUNC")))->add(tFunc_AST)));
00419 currentAST.root = tFunc_AST;
00420 currentAST.child = tFunc_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&tFunc_AST->getFirstChild()!=ANTLR_USE_NAMESPACE(antlr)nullAST ?
00421 tFunc_AST->getFirstChild() : tFunc_AST;
00422 currentAST.advanceChildToEnd();
00423 tFunc_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00424 returnAST = tFunc_AST;
00425 }
00426
00428 void ExpressionParser::atom() {
00429
00430 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00431 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00432 ANTLR_USE_NAMESPACE(antlr)RefAST atom_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00433 ANTLR_USE_NAMESPACE(antlr)RefToken iName = ANTLR_USE_NAMESPACE(antlr)nullToken;
00434 ANTLR_USE_NAMESPACE(antlr)RefAST iName_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00435
00436 try {
00437 switch ( LA(1)) {
00438 case NUM_DOUBLE:
00439 {
00440 ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00441 tmp63_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00442 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp63_AST));
00443 match(NUM_DOUBLE);
00444 atom_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00445 break;
00446 }
00447 case NUM_FLOAT:
00448 {
00449 ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00450 tmp64_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00451 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp64_AST));
00452 match(NUM_FLOAT);
00453 atom_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00454 break;
00455 }
00456 case IDENT:
00457 case LBRACKET:
00458 {
00459 {
00460 if ((LA(1)==IDENT||LA(1)==LBRACKET) && (_tokenSet_0.member(LA(2)))) {
00461 amlPath();
00462 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00463 }
00464 else if ((LA(1)==IDENT) && (_tokenSet_1.member(LA(2)))) {
00465 iName = LT(1);
00466 iName_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(iName));
00467 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(iName_AST));
00468 match(IDENT);
00469 idents.push_back(iName->getText());
00470 }
00471 else {
00472 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00473 }
00474
00475 }
00476 (*nident)++;
00477 atom_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00478 break;
00479 }
00480 case LPAREN:
00481 {
00482 {
00483 ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00484 tmp65_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00485 astFactory.makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp65_AST));
00486 match(LPAREN);
00487 }
00488 aExpr();
00489 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00490 ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00491 tmp66_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00492 match(RPAREN);
00493 atom_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00494 break;
00495 }
00496 default:
00497 {
00498 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00499 }
00500 }
00501 }
00502 catch (ANTLR_USE_NAMESPACE(antlr)ANTLRException& ex) {
00503
00504 EXP_DEFAULT_CATCH
00505
00506 }
00507 returnAST = atom_AST;
00508 }
00509
00511 void ExpressionParser::mathFunction() {
00512
00513 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00514 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00515 ANTLR_USE_NAMESPACE(antlr)RefAST mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00516
00517 switch ( LA(1)) {
00518 case LITERAL_sqrt:
00519 {
00520 ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00521 tmp67_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00522 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp67_AST));
00523 match(LITERAL_sqrt);
00524 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00525 break;
00526 }
00527 case LITERAL_log:
00528 {
00529 ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00530 tmp68_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00531 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp68_AST));
00532 match(LITERAL_log);
00533 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00534 break;
00535 }
00536 case LITERAL_exp:
00537 {
00538 ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00539 tmp69_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00540 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp69_AST));
00541 match(LITERAL_exp);
00542 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00543 break;
00544 }
00545 case LITERAL_sin:
00546 {
00547 ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00548 tmp70_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00549 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp70_AST));
00550 match(LITERAL_sin);
00551 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00552 break;
00553 }
00554 case LITERAL_cos:
00555 {
00556 ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00557 tmp71_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00558 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp71_AST));
00559 match(LITERAL_cos);
00560 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00561 break;
00562 }
00563 case LITERAL_tan:
00564 {
00565 ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00566 tmp72_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00567 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp72_AST));
00568 match(LITERAL_tan);
00569 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00570 break;
00571 }
00572 case LITERAL_asin:
00573 {
00574 ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00575 tmp73_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00576 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp73_AST));
00577 match(LITERAL_asin);
00578 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00579 break;
00580 }
00581 case LITERAL_acos:
00582 {
00583 ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00584 tmp74_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00585 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp74_AST));
00586 match(LITERAL_acos);
00587 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00588 break;
00589 }
00590 case LITERAL_atan:
00591 {
00592 ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00593 tmp75_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00594 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp75_AST));
00595 match(LITERAL_atan);
00596 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00597 break;
00598 }
00599 case LITERAL_atan2:
00600 {
00601 ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00602 tmp76_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00603 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp76_AST));
00604 match(LITERAL_atan2);
00605 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00606 break;
00607 }
00608 case LITERAL_abs:
00609 {
00610 ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00611 tmp77_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00612 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp77_AST));
00613 match(LITERAL_abs);
00614 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00615 break;
00616 }
00617 case LITERAL_max:
00618 {
00619 ANTLR_USE_NAMESPACE(antlr)RefAST tmp78_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00620 tmp78_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00621 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp78_AST));
00622 match(LITERAL_max);
00623 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00624 break;
00625 }
00626 case LITERAL_min:
00627 {
00628 ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00629 tmp79_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00630 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp79_AST));
00631 match(LITERAL_min);
00632 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00633 break;
00634 }
00635 case LITERAL_ran:
00636 {
00637 ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00638 tmp80_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00639 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp80_AST));
00640 match(LITERAL_ran);
00641 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00642 break;
00643 }
00644 case LITERAL_ran_gauss:
00645 {
00646 ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00647 tmp81_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00648 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp81_AST));
00649 match(LITERAL_ran_gauss);
00650 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00651 break;
00652 }
00653 case LITERAL_randf:
00654 {
00655 ANTLR_USE_NAMESPACE(antlr)RefAST tmp82_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00656 tmp82_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00657 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp82_AST));
00658 match(LITERAL_randf);
00659 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00660 break;
00661 }
00662 case LITERAL_gauss:
00663 {
00664 ANTLR_USE_NAMESPACE(antlr)RefAST tmp83_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00665 tmp83_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00666 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp83_AST));
00667 match(LITERAL_gauss);
00668 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00669 break;
00670 }
00671 case LITERAL_tgauss:
00672 {
00673 ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00674 tmp84_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00675 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp84_AST));
00676 match(LITERAL_tgauss);
00677 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00678 break;
00679 }
00680 case 43:
00681 {
00682 ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00683 tmp85_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00684 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp85_AST));
00685 match(43);
00686 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00687 break;
00688 }
00689 case 44:
00690 {
00691 ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00692 tmp86_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00693 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp86_AST));
00694 match(44);
00695 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00696 break;
00697 }
00698 case 45:
00699 {
00700 ANTLR_USE_NAMESPACE(antlr)RefAST tmp87_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00701 tmp87_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00702 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp87_AST));
00703 match(45);
00704 mathFunction_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00705 break;
00706 }
00707 default:
00708 {
00709 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00710 }
00711 }
00712 returnAST = mathFunction_AST;
00713 }
00714
00719 void ExpressionParser::amlPath() {
00720
00721 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00722 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00723 ANTLR_USE_NAMESPACE(antlr)RefAST amlPath_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00724
00725 try {
00726 amlPathElement();
00727 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00728 amlPath_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00729 amlPath_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.make( (new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(AMLPATH,"AMLPATH")))->add(amlPath_AST)));
00730 currentAST.root = amlPath_AST;
00731 currentAST.child = amlPath_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&amlPath_AST->getFirstChild()!=ANTLR_USE_NAMESPACE(antlr)nullAST ?
00732 amlPath_AST->getFirstChild() : amlPath_AST;
00733 currentAST.advanceChildToEnd();
00734 amlPath_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00735 }
00736 catch (UAPException& ex) {
00737
00738 ANTLR_USE_NAMESPACE(antlr)Token* nextToken = NULL;
00739 try {
00740 nextToken = LT(2);
00741 } catch (...) {
00742 throw UAPParserException("error: parse error at end of input", ex);
00743 }
00744 throw UAPParserException("error: parse error before '"+(nextToken)->getText()+"' token", ex);
00745
00746 }
00747 catch (ANTLR_USE_NAMESPACE(antlr)ANTLRException& ex) {
00748
00749 EXP_DEFAULT_CATCH
00750
00751 }
00752 returnAST = amlPath_AST;
00753 }
00754
00773 void ExpressionParser::amlPathElement() {
00774
00775 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00776 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00777 ANTLR_USE_NAMESPACE(antlr)RefAST amlPathElement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00778 ANTLR_USE_NAMESPACE(antlr)RefToken e1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
00779 ANTLR_USE_NAMESPACE(antlr)RefAST e1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00780
00781 try {
00782 {
00783 if ((LA(1)==IDENT||LA(1)==LBRACKET) && (LA(2)==IDENT||LA(2)==LBRACKET||LA(2)==AT)) {
00784 {
00785 switch ( LA(1)) {
00786 case IDENT:
00787 {
00788 try {
00789 e1 = LT(1);
00790 e1_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e1));
00791 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e1_AST));
00792 match(IDENT);
00793 }
00794 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
00795
00796 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid element name");
00797
00798 }
00799 break;
00800 }
00801 case LBRACKET:
00802 {
00803 break;
00804 }
00805 default:
00806 {
00807 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00808 }
00809 }
00810 }
00811 ANTLR_USE_NAMESPACE(antlr)RefAST tmp88_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00812 tmp88_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00813 match(LBRACKET);
00814 {
00815 switch ( LA(1)) {
00816 case AT:
00817 {
00818 amlPathAttrib();
00819 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00820 break;
00821 }
00822 case IDENT:
00823 {
00824 amlPathNode();
00825 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00826 {
00827 for (;;) {
00828 if ((LA(1)==COLON)) {
00829 ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00830 tmp89_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00831 match(COLON);
00832 amlPathNode();
00833 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00834 }
00835 else {
00836 goto _loop26;
00837 }
00838
00839 }
00840 _loop26:;
00841 }
00842 {
00843 switch ( LA(1)) {
00844 case AT:
00845 {
00846 amlPathAttrib();
00847 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00848 break;
00849 }
00850 case RBRACKET:
00851 {
00852 break;
00853 }
00854 default:
00855 {
00856 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00857 }
00858 }
00859 }
00860 break;
00861 }
00862 default:
00863 {
00864 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00865 }
00866 }
00867 }
00868 ANTLR_USE_NAMESPACE(antlr)RefAST tmp90_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00869 tmp90_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00870 match(RBRACKET);
00871 }
00872 else if ((LA(1)==IDENT) && (LA(2)==COLON)) {
00873 ANTLR_USE_NAMESPACE(antlr)RefAST tmp91_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00874 tmp91_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00875 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp91_AST));
00876 match(IDENT);
00877 ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00878 tmp92_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00879 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp92_AST));
00880 match(COLON);
00881 amlPathNode();
00882 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00883 {
00884 for (;;) {
00885 if ((LA(1)==COLON)) {
00886 ANTLR_USE_NAMESPACE(antlr)RefAST tmp93_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00887 tmp93_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00888 match(COLON);
00889 amlPathNode();
00890 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00891 }
00892 else {
00893 goto _loop29;
00894 }
00895
00896 }
00897 _loop29:;
00898 }
00899 {
00900 switch ( LA(1)) {
00901 case AT:
00902 {
00903 amlPathAttrib();
00904 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
00905 break;
00906 }
00907 case SEMI:
00908 case PLUS:
00909 case MINUS:
00910 case MULT:
00911 case DIV:
00912 case MOD:
00913 case POW:
00914 case COMMA:
00915 case RPAREN:
00916 {
00917 break;
00918 }
00919 default:
00920 {
00921 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00922 }
00923 }
00924 }
00925 }
00926 else {
00927 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00928 }
00929
00930 }
00931 amlPathElement_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00932 amlPathElement_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.make( (new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(AMLPATHELEMENT,"AMLPATHELEMENT")))->add(amlPathElement_AST)));
00933 currentAST.root = amlPathElement_AST;
00934 currentAST.child = amlPathElement_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&amlPathElement_AST->getFirstChild()!=ANTLR_USE_NAMESPACE(antlr)nullAST ?
00935 amlPathElement_AST->getFirstChild() : amlPathElement_AST;
00936 currentAST.advanceChildToEnd();
00937 amlPathElement_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00938 }
00939 catch (ANTLR_USE_NAMESPACE(antlr)ANTLRException& ex) {
00940
00941 EXP_DEFAULT_CATCH
00942
00943 }
00944 returnAST = amlPathElement_AST;
00945 }
00946
00950 void ExpressionParser::amlPathAttrib() {
00951
00952 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00953 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00954 ANTLR_USE_NAMESPACE(antlr)RefAST amlPathAttrib_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00955 ANTLR_USE_NAMESPACE(antlr)RefToken e1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
00956 ANTLR_USE_NAMESPACE(antlr)RefAST e1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00957
00958 ANTLR_USE_NAMESPACE(antlr)RefAST tmp94_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00959 tmp94_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
00960 match(AT);
00961 try {
00962 e1 = LT(1);
00963 e1_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e1));
00964 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e1_AST));
00965 match(IDENT);
00966 }
00967 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
00968
00969 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid attribute name");
00970
00971 }
00972 amlPathAttrib_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00973 amlPathAttrib_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.make( (new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(AMLPATHATTRIB,"AMLPATHATTRIB")))->add(amlPathAttrib_AST)));
00974 currentAST.root = amlPathAttrib_AST;
00975 currentAST.child = amlPathAttrib_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&amlPathAttrib_AST->getFirstChild()!=ANTLR_USE_NAMESPACE(antlr)nullAST ?
00976 amlPathAttrib_AST->getFirstChild() : amlPathAttrib_AST;
00977 currentAST.advanceChildToEnd();
00978 amlPathAttrib_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
00979 returnAST = amlPathAttrib_AST;
00980 }
00981
00985 void ExpressionParser::amlPathNode() {
00986
00987 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00988 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00989 ANTLR_USE_NAMESPACE(antlr)RefAST amlPathNode_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00990 ANTLR_USE_NAMESPACE(antlr)RefToken e1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
00991 ANTLR_USE_NAMESPACE(antlr)RefAST e1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
00992
00993 try {
00994 try {
00995 e1 = LT(1);
00996 e1_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e1));
00997 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e1_AST));
00998 match(IDENT);
00999 }
01000 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
01001
01002 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid node name");
01003
01004 }
01005 {
01006 switch ( LA(1)) {
01007 case LPAREN:
01008 {
01009 ANTLR_USE_NAMESPACE(antlr)RefAST tmp95_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01010 tmp95_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
01011 match(LPAREN);
01012 amlPathAttrExpr();
01013 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
01014 {
01015 for (;;) {
01016 if ((LA(1)==COMMA)) {
01017 ANTLR_USE_NAMESPACE(antlr)RefAST tmp96_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01018 tmp96_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
01019 match(COMMA);
01020 amlPathAttrExpr();
01021 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
01022 }
01023 else {
01024 goto _loop38;
01025 }
01026
01027 }
01028 _loop38:;
01029 }
01030 ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01031 tmp97_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
01032 match(RPAREN);
01033 break;
01034 }
01035 case SEMI:
01036 case PLUS:
01037 case MINUS:
01038 case MULT:
01039 case DIV:
01040 case MOD:
01041 case POW:
01042 case COMMA:
01043 case RPAREN:
01044 case COLON:
01045 case RBRACKET:
01046 case AT:
01047 {
01048 break;
01049 }
01050 default:
01051 {
01052 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01053 }
01054 }
01055 }
01056 amlPathNode_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
01057 amlPathNode_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.make( (new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(AMLPATHNODE,"AMLPATHNODE")))->add(amlPathNode_AST)));
01058 currentAST.root = amlPathNode_AST;
01059 currentAST.child = amlPathNode_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&amlPathNode_AST->getFirstChild()!=ANTLR_USE_NAMESPACE(antlr)nullAST ?
01060 amlPathNode_AST->getFirstChild() : amlPathNode_AST;
01061 currentAST.advanceChildToEnd();
01062 amlPathNode_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
01063 }
01064 catch (ANTLR_USE_NAMESPACE(antlr)ANTLRException& ex) {
01065
01066 EXP_DEFAULT_CATCH
01067
01068 }
01069 returnAST = amlPathNode_AST;
01070 }
01071
01073 void ExpressionParser::amlPathTagList() {
01074
01075 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01076 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01077 ANTLR_USE_NAMESPACE(antlr)RefAST amlPathTagList_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01078 ANTLR_USE_NAMESPACE(antlr)RefToken e1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
01079 ANTLR_USE_NAMESPACE(antlr)RefAST e1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01080
01081 try {
01082 {
01083 for (;;) {
01084 if ((LA(1)==IDENT)) {
01085 try {
01086 e1 = LT(1);
01087 e1_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e1));
01088 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e1_AST));
01089 match(IDENT);
01090 }
01091 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
01092
01093 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid tag name");
01094
01095 }
01096 ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01097 tmp98_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
01098 match(19);
01099 }
01100 else {
01101 goto _loop34;
01102 }
01103
01104 }
01105 _loop34:;
01106 }
01107 amlPathTagList_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
01108 amlPathTagList_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.make( (new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(AMLPATHTAGLIST,"AMLPATHTAGLIST")))->add(amlPathTagList_AST)));
01109 currentAST.root = amlPathTagList_AST;
01110 currentAST.child = amlPathTagList_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&amlPathTagList_AST->getFirstChild()!=ANTLR_USE_NAMESPACE(antlr)nullAST ?
01111 amlPathTagList_AST->getFirstChild() : amlPathTagList_AST;
01112 currentAST.advanceChildToEnd();
01113 amlPathTagList_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
01114 }
01115 catch (ANTLR_USE_NAMESPACE(antlr)ANTLRException& ex) {
01116
01117 EXP_DEFAULT_CATCH
01118
01119 }
01120 returnAST = amlPathTagList_AST;
01121 }
01122
01124 void ExpressionParser::amlPathAttrExpr() {
01125
01126 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01127 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01128 ANTLR_USE_NAMESPACE(antlr)RefAST amlPathAttrExpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01129 ANTLR_USE_NAMESPACE(antlr)RefToken e1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
01130 ANTLR_USE_NAMESPACE(antlr)RefAST e1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01131 ANTLR_USE_NAMESPACE(antlr)RefToken e2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
01132 ANTLR_USE_NAMESPACE(antlr)RefAST e2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01133 ANTLR_USE_NAMESPACE(antlr)RefToken e3 = ANTLR_USE_NAMESPACE(antlr)nullToken;
01134 ANTLR_USE_NAMESPACE(antlr)RefAST e3_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01135 ANTLR_USE_NAMESPACE(antlr)RefToken e4 = ANTLR_USE_NAMESPACE(antlr)nullToken;
01136 ANTLR_USE_NAMESPACE(antlr)RefAST e4_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01137 ANTLR_USE_NAMESPACE(antlr)RefToken e5 = ANTLR_USE_NAMESPACE(antlr)nullToken;
01138 ANTLR_USE_NAMESPACE(antlr)RefAST e5_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01139 ANTLR_USE_NAMESPACE(antlr)RefToken e6 = ANTLR_USE_NAMESPACE(antlr)nullToken;
01140 ANTLR_USE_NAMESPACE(antlr)RefAST e6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01141
01142 try {
01143 {
01144 switch ( LA(1)) {
01145 case AT:
01146 {
01147 ANTLR_USE_NAMESPACE(antlr)RefAST tmp99_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01148 tmp99_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
01149 match(AT);
01150 break;
01151 }
01152 case IDENT:
01153 {
01154 break;
01155 }
01156 default:
01157 {
01158 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01159 }
01160 }
01161 }
01162 try {
01163 e1 = LT(1);
01164 e1_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e1));
01165 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e1_AST));
01166 match(IDENT);
01167 }
01168 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
01169
01170 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid attribute name");
01171
01172 }
01173 ANTLR_USE_NAMESPACE(antlr)RefAST tmp100_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
01174 tmp100_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(LT(1)));
01175 match(EQUAL);
01176 {
01177 switch ( LA(1)) {
01178 case NUM_DOUBLE:
01179 {
01180 try {
01181 e2 = LT(1);
01182 e2_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e2));
01183 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e2_AST));
01184 match(NUM_DOUBLE);
01185 }
01186 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
01187
01188 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid attribute value");
01189
01190 }
01191 break;
01192 }
01193 case NUM_FLOAT:
01194 {
01195 try {
01196 e3 = LT(1);
01197 e3_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e3));
01198 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e3_AST));
01199 match(NUM_FLOAT);
01200 }
01201 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
01202
01203 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid attribute value");
01204
01205 }
01206 break;
01207 }
01208 case IDENT:
01209 {
01210 try {
01211 e4 = LT(1);
01212 e4_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e4));
01213 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e4_AST));
01214 match(IDENT);
01215 }
01216 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
01217
01218 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid attribute value");
01219
01220 }
01221 break;
01222 }
01223 case STRING_LITERAL_S:
01224 {
01225 try {
01226 e5 = LT(1);
01227 e5_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e5));
01228 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e5_AST));
01229 match(STRING_LITERAL_S);
01230 }
01231 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
01232
01233 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid attribute value");
01234
01235 }
01236 break;
01237 }
01238 case STRING_LITERAL_D:
01239 {
01240 try {
01241 e6 = LT(1);
01242 e6_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(e6));
01243 astFactory.addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e6_AST));
01244 match(STRING_LITERAL_D);
01245 }
01246 catch (ANTLR_USE_NAMESPACE(antlr)MismatchedTokenException& ex) {
01247
01248 throw UAPParserException("error: '"+(ex.token)->getText()+"' is not a valid attribute value");
01249
01250 }
01251 break;
01252 }
01253 default:
01254 {
01255 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01256 }
01257 }
01258 }
01259 amlPathAttrExpr_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
01260 amlPathAttrExpr_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.make( (new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory.create(AMLPATHATTREXPR,"AMLPATHATTREXPR")))->add(amlPathAttrExpr_AST)));
01261 currentAST.root = amlPathAttrExpr_AST;
01262 currentAST.child = amlPathAttrExpr_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST &&amlPathAttrExpr_AST->getFirstChild()!=ANTLR_USE_NAMESPACE(antlr)nullAST ?
01263 amlPathAttrExpr_AST->getFirstChild() : amlPathAttrExpr_AST;
01264 currentAST.advanceChildToEnd();
01265 amlPathAttrExpr_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root);
01266 }
01267 catch (ANTLR_USE_NAMESPACE(antlr)ANTLRException& ex) {
01268
01269 EXP_DEFAULT_CATCH
01270
01271 }
01272 returnAST = amlPathAttrExpr_AST;
01273 }
01274
01275 const char* ExpressionParser::_tokenNames[] = {
01276 "<0>",
01277 "EOF",
01278 "<2>",
01279 "NULL_TREE_LOOKAHEAD",
01280 "SEMI",
01281 "PLUS",
01282 "MINUS",
01283 "MULT",
01284 "DIV",
01285 "MOD",
01286 "POW",
01287 "LPAREN",
01288 "COMMA",
01289 "RPAREN",
01290 "a label",
01291 "LBRACKET",
01292 "COLON",
01293 "RBRACKET",
01294 "AT",
01295 "\".\"",
01296 "EQUAL",
01297 "NUM_DOUBLE",
01298 "NUM_FLOAT",
01299 "STRING_LITERAL_S",
01300 "STRING_LITERAL_D",
01301 "\"sqrt\"",
01302 "\"log\"",
01303 "\"exp\"",
01304 "\"sin\"",
01305 "\"cos\"",
01306 "\"tan\"",
01307 "\"asin\"",
01308 "\"acos\"",
01309 "\"atan\"",
01310 "\"atan2\"",
01311 "\"abs\"",
01312 "\"max\"",
01313 "\"min\"",
01314 "\"ran\"",
01315 "\"ran_gauss\"",
01316 "\"randf\"",
01317 "\"gauss\"",
01318 "\"tgauss\"",
01319 "\"user0\"",
01320 "\"user1\"",
01321 "\"user2\"",
01322 "FUNC",
01323 "AMLPATH",
01324 "AMLPATHNODE",
01325 "AMLPATHATTREXPR",
01326 "AMLPATHELEMENT",
01327 "AMLPATHTAGLIST",
01328 "AMLPATHATTRIB",
01329 "WS_",
01330 "ESC",
01331 0
01332 };
01333
01334 const unsigned long ExpressionParser::_tokenSet_0_data_[] = { 376832UL, 0UL, 0UL, 0UL };
01335 const ANTLR_USE_NAMESPACE(antlr)BitSet ExpressionParser::_tokenSet_0(_tokenSet_0_data_,4);
01336 const unsigned long ExpressionParser::_tokenSet_1_data_[] = { 14320UL, 0UL, 0UL, 0UL };
01337 const ANTLR_USE_NAMESPACE(antlr)BitSet ExpressionParser::_tokenSet_1(_tokenSet_1_data_,4);
01338
01339
