Universal Accelerator Parser: ExpressionTreeWalker.cpp Source File

00001 /* $ANTLR 2.7.0: "Expression.g" -> "ExpressionTreeWalker.cpp"$ */
00002 #include "ExpressionTreeWalker.hpp"
00003 #include "antlr/Token.hpp"
00004 #include "antlr/AST.hpp"
00005 #include "antlr/NoViableAltException.hpp"
00006 #include "antlr/MismatchedTokenException.hpp"
00007 #include "antlr/SemanticException.hpp"
00008 #include "antlr/BitSet.hpp"
00009 
00010   #include <sstream>
00011   #include <cmath>
00012   #include <cstdlib>
00013   #include <cassert>
00014   #include <algorithm>
00015   #include <queue>
00016   #include "UAP/UAPUtilities.hpp"
00017 
00018 ExpressionTreeWalker::ExpressionTreeWalker() {
00019         setTokenNames(_tokenNames);
00020 }
00021 
00023 double  ExpressionTreeWalker::evaluate(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
00024         double r;
00025         
00026         ANTLR_USE_NAMESPACE(antlr)RefAST evaluate_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00027         ANTLR_USE_NAMESPACE(antlr)RefAST n = ANTLR_USE_NAMESPACE(antlr)nullAST;
00028         ANTLR_USE_NAMESPACE(antlr)RefAST m = ANTLR_USE_NAMESPACE(antlr)nullAST;
00029         
00030         double a=0;
00031         double b=0;
00032         r=0;
00033         bool unitary_minus = true;
00034         bool unitary_plus = true;
00035         
00036         
00037         try {      // for error handling
00038                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00039                 switch ( _t->getType()) {
00040                 case PLUS:
00041                 {
00042                         ANTLR_USE_NAMESPACE(antlr)RefAST __t97 = _t;
00043                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00044                         match(_t,PLUS);
00045                         _t = _t->getFirstChild();
00046                         a=evaluate(_t);
00047                         _t = _retTree;
00048                         {
00049                         if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00050                         switch ( _t->getType()) {
00051                         case PLUS:
00052                         case MINUS:
00053                         case MULT:
00054                         case DIV:
00055                         case POW:
00056                         case LPAREN:
00057                         case NUM_DOUBLE:
00058                         case NUM_FLOAT:
00059                         case FUNC:
00060                         {
00061                                 b=evaluate(_t);
00062                                 _t = _retTree;
00063                                 unitary_plus = false;
00064                                 break;
00065                         }
00066                         case 3:
00067                         {
00068                                 break;
00069                         }
00070                         default:
00071                         {
00072                                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00073                         }
00074                         }
00075                         }
00076                         r = unitary_plus ? a : a+b;
00077                         _t = __t97;
00078                         _t = _t->getNextSibling();
00079                         break;
00080                 }
00081                 case MINUS:
00082                 {
00083                         ANTLR_USE_NAMESPACE(antlr)RefAST __t99 = _t;
00084                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00085                         match(_t,MINUS);
00086                         _t = _t->getFirstChild();
00087                         a=evaluate(_t);
00088                         _t = _retTree;
00089                         {
00090                         if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00091                         switch ( _t->getType()) {
00092                         case PLUS:
00093                         case MINUS:
00094                         case MULT:
00095                         case DIV:
00096                         case POW:
00097                         case LPAREN:
00098                         case NUM_DOUBLE:
00099                         case NUM_FLOAT:
00100                         case FUNC:
00101                         {
00102                                 b=evaluate(_t);
00103                                 _t = _retTree;
00104                                 unitary_minus = false;
00105                                 break;
00106                         }
00107                         case 3:
00108                         {
00109                                 break;
00110                         }
00111                         default:
00112                         {
00113                                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00114                         }
00115                         }
00116                         }
00117                         r = unitary_minus ? -a : a-b;
00118                         _t = __t99;
00119                         _t = _t->getNextSibling();
00120                         break;
00121                 }
00122                 case MULT:
00123                 {
00124                         ANTLR_USE_NAMESPACE(antlr)RefAST __t101 = _t;
00125                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00126                         match(_t,MULT);
00127                         _t = _t->getFirstChild();
00128                         a=evaluate(_t);
00129                         _t = _retTree;
00130                         b=evaluate(_t);
00131                         _t = _retTree;
00132                         r = a*b;
00133                         _t = __t101;
00134                         _t = _t->getNextSibling();
00135                         break;
00136                 }
00137                 case DIV:
00138                 {
00139                         ANTLR_USE_NAMESPACE(antlr)RefAST __t102 = _t;
00140                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00141                         match(_t,DIV);
00142                         _t = _t->getFirstChild();
00143                         a=evaluate(_t);
00144                         _t = _retTree;
00145                         b=evaluate(_t);
00146                         _t = _retTree;
00147                         if (b == 0) { 
00148                         throw UAPInvalidExpressionException("error: divide by zero");
00149                         }
00150                         r = a/b;
00151                         
00152                         _t = __t102;
00153                         _t = _t->getNextSibling();
00154                         break;
00155                 }
00156                 case POW:
00157                 {
00158                         ANTLR_USE_NAMESPACE(antlr)RefAST __t103 = _t;
00159                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00160                         match(_t,POW);
00161                         _t = _t->getFirstChild();
00162                         a=evaluate(_t);
00163                         _t = _retTree;
00164                         b=evaluate(_t);
00165                         _t = _retTree;
00166                         r = pow(a,b);
00167                         _t = __t103;
00168                         _t = _t->getNextSibling();
00169                         break;
00170                 }
00171                 case LPAREN:
00172                 {
00173                         ANTLR_USE_NAMESPACE(antlr)RefAST __t104 = _t;
00174                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00175                         match(_t,LPAREN);
00176                         _t = _t->getFirstChild();
00177                         r=evaluate(_t);
00178                         _t = _retTree;
00179                         _t = __t104;
00180                         _t = _t->getNextSibling();
00181                         break;
00182                 }
00183                 case FUNC:
00184                 {
00185                         r=evaluate_function(_t);
00186                         _t = _retTree;
00187                         break;
00188                 }
00189                 case NUM_DOUBLE:
00190                 {
00191                         n = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00192                         match(_t,NUM_DOUBLE);
00193                         _t = _t->getNextSibling();
00194                         r = atof(n->getText().c_str());
00195                         break;
00196                 }
00197                 case NUM_FLOAT:
00198                 {
00199                         m = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00200                         match(_t,NUM_FLOAT);
00201                         _t = _t->getNextSibling();
00202                         r = atof(m->getText().c_str());
00203                         break;
00204                 }
00205                 default:
00206                 {
00207                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00208                 }
00209                 }
00210         }
00211         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00212                 reportError(ex);
00213                 if (_t!=ANTLR_USE_NAMESPACE(antlr)nullAST) {_t = _t->getNextSibling();}
00214         }
00215         _retTree = _t;
00216         return r;
00217 }
00218 
00220 double  ExpressionTreeWalker::evaluate_function(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
00221         double r;
00222         
00223         ANTLR_USE_NAMESPACE(antlr)RefAST evaluate_function_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00224         ANTLR_USE_NAMESPACE(antlr)RefAST f = ANTLR_USE_NAMESPACE(antlr)nullAST;
00225         
00226         double e=0;
00227         double a=0;
00228         double b=0;
00229         r=0;
00230         std::queue<double> args;
00231         
00232         
00233         try {      // for error handling
00234                 ANTLR_USE_NAMESPACE(antlr)RefAST __t106 = _t;
00235                 ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00236                 match(_t,FUNC);
00237                 _t = _t->getFirstChild();
00238                 f = _t==ASTNULL ? ANTLR_USE_NAMESPACE(antlr)nullAST : ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00239                 mathFunction(_t);
00240                 _t = _retTree;
00241                 {
00242                 for (;;) {
00243                         if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00244                         if ((_tokenSet_0.member(_t->getType()))) {
00245                                 e=evaluate(_t);
00246                                 _t = _retTree;
00247                                 args.push(e);
00248                         }
00249                         else {
00250                                 goto _loop108;
00251                         }
00252                         
00253                 }
00254                 _loop108:;
00255                 }
00256                 _t = __t106;
00257                 _t = _t->getNextSibling();
00258                 
00259                 switch(f->getType()){
00260                 case LITERAL_sqrt:
00261                 r = sqrt(args.front());
00262                 break;
00263                 case LITERAL_log:
00264                 r = log(args.front());
00265                 break;
00266                 case LITERAL_exp:
00267                 r = exp(args.front());
00268                 break;
00269                 case LITERAL_sin:
00270                 r = sin(args.front());
00271                 break;
00272                 case LITERAL_cos:
00273                 r = cos(args.front());
00274                 break;
00275                 case LITERAL_tan:
00276                 r = tan(args.front());
00277                 break;
00278                 case LITERAL_asin:
00279                 r = asin(args.front());
00280                 break;
00281                 case LITERAL_acos:
00282                 r = acos(args.front());
00283                 break;
00284                 case LITERAL_atan:
00285                 r = atan(args.front());
00286                 break;
00287                 case LITERAL_abs:
00288                 r = abs(static_cast<int>(args.front()));
00289                 break;
00290                 case LITERAL_ran:
00291                 r = utilities->nextDouble();
00292                 break;
00293                 case LITERAL_ran_gauss:
00294                 r = utilities->nextGaussian();
00295                 break;
00296                 case LITERAL_atan2:
00297                 if (args.size() == 2){
00298                 a = args.front();
00299                 args.pop();
00300                 b = args.front();
00301                 r = atan2(a,b);
00302                 }
00303                 break;
00304                 case LITERAL_min:
00305                 if (args.size() == 2){
00306                 a = args.front();
00307                 args.pop();
00308                 b = args.front();
00309                 r = (b < a)? b : a;
00310                 }
00311                 break;
00312                 case LITERAL_max:
00313                 if (args.size() == 2){
00314                 a = args.front();
00315                 args.pop();
00316                 b = args.front();
00317                 r = (b > a)? b : a;
00318                 }
00319                 break;
00320                 default:
00321                 break;
00322                 }
00323                 
00324         }
00325         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00326                 reportError(ex);
00327                 if (_t!=ANTLR_USE_NAMESPACE(antlr)nullAST) {_t = _t->getNextSibling();}
00328         }
00329         _retTree = _t;
00330         return r;
00331 }
00332 
00333 void ExpressionTreeWalker::mathFunction(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
00334         
00335         ANTLR_USE_NAMESPACE(antlr)RefAST mathFunction_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00336         
00337         try {      // for error handling
00338                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00339                 switch ( _t->getType()) {
00340                 case LITERAL_sqrt:
00341                 {
00342                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00343                         match(_t,LITERAL_sqrt);
00344                         _t = _t->getNextSibling();
00345                         break;
00346                 }
00347                 case LITERAL_log:
00348                 {
00349                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00350                         match(_t,LITERAL_log);
00351                         _t = _t->getNextSibling();
00352                         break;
00353                 }
00354                 case LITERAL_exp:
00355                 {
00356                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00357                         match(_t,LITERAL_exp);
00358                         _t = _t->getNextSibling();
00359                         break;
00360                 }
00361                 case LITERAL_sin:
00362                 {
00363                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00364                         match(_t,LITERAL_sin);
00365                         _t = _t->getNextSibling();
00366                         break;
00367                 }
00368                 case LITERAL_cos:
00369                 {
00370                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00371                         match(_t,LITERAL_cos);
00372                         _t = _t->getNextSibling();
00373                         break;
00374                 }
00375                 case LITERAL_tan:
00376                 {
00377                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00378                         match(_t,LITERAL_tan);
00379                         _t = _t->getNextSibling();
00380                         break;
00381                 }
00382                 case LITERAL_asin:
00383                 {
00384                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00385                         match(_t,LITERAL_asin);
00386                         _t = _t->getNextSibling();
00387                         break;
00388                 }
00389                 case LITERAL_acos:
00390                 {
00391                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00392                         match(_t,LITERAL_acos);
00393                         _t = _t->getNextSibling();
00394                         break;
00395                 }
00396                 case LITERAL_atan:
00397                 {
00398                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00399                         match(_t,LITERAL_atan);
00400                         _t = _t->getNextSibling();
00401                         break;
00402                 }
00403                 case LITERAL_atan2:
00404                 {
00405                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00406                         match(_t,LITERAL_atan2);
00407                         _t = _t->getNextSibling();
00408                         break;
00409                 }
00410                 case LITERAL_abs:
00411                 {
00412                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00413                         match(_t,LITERAL_abs);
00414                         _t = _t->getNextSibling();
00415                         break;
00416                 }
00417                 case LITERAL_max:
00418                 {
00419                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00420                         match(_t,LITERAL_max);
00421                         _t = _t->getNextSibling();
00422                         break;
00423                 }
00424                 case LITERAL_min:
00425                 {
00426                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00427                         match(_t,LITERAL_min);
00428                         _t = _t->getNextSibling();
00429                         break;
00430                 }
00431                 case LITERAL_ran:
00432                 {
00433                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00434                         match(_t,LITERAL_ran);
00435                         _t = _t->getNextSibling();
00436                         break;
00437                 }
00438                 case LITERAL_ran_gauss:
00439                 {
00440                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00441                         match(_t,LITERAL_ran_gauss);
00442                         _t = _t->getNextSibling();
00443                         break;
00444                 }
00445                 case LITERAL_randf:
00446                 {
00447                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00448                         match(_t,LITERAL_randf);
00449                         _t = _t->getNextSibling();
00450                         break;
00451                 }
00452                 case LITERAL_gauss:
00453                 {
00454                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00455                         match(_t,LITERAL_gauss);
00456                         _t = _t->getNextSibling();
00457                         break;
00458                 }
00459                 case LITERAL_tgauss:
00460                 {
00461                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00462                         match(_t,LITERAL_tgauss);
00463                         _t = _t->getNextSibling();
00464                         break;
00465                 }
00466                 case 43:
00467                 {
00468                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00469                         match(_t,43);
00470                         _t = _t->getNextSibling();
00471                         break;
00472                 }
00473                 case 44:
00474                 {
00475                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00476                         match(_t,44);
00477                         _t = _t->getNextSibling();
00478                         break;
00479                 }
00480                 case 45:
00481                 {
00482                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00483                         match(_t,45);
00484                         _t = _t->getNextSibling();
00485                         break;
00486                 }
00487                 default:
00488                 {
00489                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00490                 }
00491                 }
00492         }
00493         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00494                 reportError(ex);
00495                 if (_t!=ANTLR_USE_NAMESPACE(antlr)nullAST) {_t = _t->getNextSibling();}
00496         }
00497         _retTree = _t;
00498 }
00499 
00501 std::string  ExpressionTreeWalker::subs_params(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
00502         std::string v;
00503         
00504         ANTLR_USE_NAMESPACE(antlr)RefAST subs_params_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00505         ANTLR_USE_NAMESPACE(antlr)RefAST n = ANTLR_USE_NAMESPACE(antlr)nullAST;
00506         ANTLR_USE_NAMESPACE(antlr)RefAST f = ANTLR_USE_NAMESPACE(antlr)nullAST;
00507         
00508         v = "";
00509         std::string v1 = "";
00510         std::string v2 = "";
00511         std::queue<std::string> args;
00512         
00513         
00514         try {      // for error handling
00515                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00516                 switch ( _t->getType()) {
00517                 case IDENT:
00518                 case NUM_DOUBLE:
00519                 case NUM_FLOAT:
00520                 {
00521                         n = _t==ASTNULL ? ANTLR_USE_NAMESPACE(antlr)nullAST : ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00522                         twConst(_t);
00523                         _t = _retTree;
00524                         v = "(" + n->getText() + ")";
00525                         break;
00526                 }
00527                 case AMLPATH:
00528                 {
00529                         v=amlPath(_t);
00530                         _t = _retTree;
00531                         break;
00532                 }
00533                 case PLUS:
00534                 {
00535                         ANTLR_USE_NAMESPACE(antlr)RefAST __t110 = _t;
00536                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00537                         match(_t,PLUS);
00538                         _t = _t->getFirstChild();
00539                         v1=subs_params(_t);
00540                         _t = _retTree;
00541                         {
00542                         if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00543                         switch ( _t->getType()) {
00544                         case PLUS:
00545                         case MINUS:
00546                         case MULT:
00547                         case DIV:
00548                         case POW:
00549                         case LPAREN:
00550                         case IDENT:
00551                         case NUM_DOUBLE:
00552                         case NUM_FLOAT:
00553                         case FUNC:
00554                         case AMLPATH:
00555                         {
00556                                 v2=subs_params(_t);
00557                                 _t = _retTree;
00558                                 break;
00559                         }
00560                         case 3:
00561                         {
00562                                 break;
00563                         }
00564                         default:
00565                         {
00566                                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00567                         }
00568                         }
00569                         }
00570                         v = (v2 == "")? v + v1 : v + v1 + "+" + v2;
00571                         _t = __t110;
00572                         _t = _t->getNextSibling();
00573                         break;
00574                 }
00575                 case MINUS:
00576                 {
00577                         ANTLR_USE_NAMESPACE(antlr)RefAST __t112 = _t;
00578                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00579                         match(_t,MINUS);
00580                         _t = _t->getFirstChild();
00581                         v1=subs_params(_t);
00582                         _t = _retTree;
00583                         {
00584                         if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00585                         switch ( _t->getType()) {
00586                         case PLUS:
00587                         case MINUS:
00588                         case MULT:
00589                         case DIV:
00590                         case POW:
00591                         case LPAREN:
00592                         case IDENT:
00593                         case NUM_DOUBLE:
00594                         case NUM_FLOAT:
00595                         case FUNC:
00596                         case AMLPATH:
00597                         {
00598                                 v2=subs_params(_t);
00599                                 _t = _retTree;
00600                                 break;
00601                         }
00602                         case 3:
00603                         {
00604                                 break;
00605                         }
00606                         default:
00607                         {
00608                                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00609                         }
00610                         }
00611                         }
00612                         
00613                         // Encloses v1 in parentheses if v1 is negative. Performs negation.
00614                         if (v1.substr(0,1) == "-")
00615                         v1 = "(" + v1 + ")";
00616                         v = (v2 == "")? v + "-" + v1 : v + v1 + "-" + v2;
00617                         
00618                         _t = __t112;
00619                         _t = _t->getNextSibling();
00620                         break;
00621                 }
00622                 case MULT:
00623                 {
00624                         ANTLR_USE_NAMESPACE(antlr)RefAST __t114 = _t;
00625                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00626                         match(_t,MULT);
00627                         _t = _t->getFirstChild();
00628                         v1=subs_params(_t);
00629                         _t = _retTree;
00630                         v2=subs_params(_t);
00631                         _t = _retTree;
00632                         v = v + v1 + "*" + v2;
00633                         _t = __t114;
00634                         _t = _t->getNextSibling();
00635                         break;
00636                 }
00637                 case DIV:
00638                 {
00639                         ANTLR_USE_NAMESPACE(antlr)RefAST __t115 = _t;
00640                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00641                         match(_t,DIV);
00642                         _t = _t->getFirstChild();
00643                         v1=subs_params(_t);
00644                         _t = _retTree;
00645                         v2=subs_params(_t);
00646                         _t = _retTree;
00647                         v = v + v1 + "/" + v2;
00648                         _t = __t115;
00649                         _t = _t->getNextSibling();
00650                         break;
00651                 }
00652                 case POW:
00653                 {
00654                         ANTLR_USE_NAMESPACE(antlr)RefAST __t116 = _t;
00655                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00656                         match(_t,POW);
00657                         _t = _t->getFirstChild();
00658                         v1=subs_params(_t);
00659                         _t = _retTree;
00660                         v2=subs_params(_t);
00661                         _t = _retTree;
00662                         v = v + v1 + "^" + v2;
00663                         _t = __t116;
00664                         _t = _t->getNextSibling();
00665                         break;
00666                 }
00667                 case LPAREN:
00668                 {
00669                         ANTLR_USE_NAMESPACE(antlr)RefAST __t117 = _t;
00670                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00671                         match(_t,LPAREN);
00672                         _t = _t->getFirstChild();
00673                         v1=subs_params(_t);
00674                         _t = _retTree;
00675                         v = v + "(" + v1 + ")";
00676                         _t = __t117;
00677                         _t = _t->getNextSibling();
00678                         break;
00679                 }
00680                 case FUNC:
00681                 {
00682                         ANTLR_USE_NAMESPACE(antlr)RefAST __t118 = _t;
00683                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00684                         match(_t,FUNC);
00685                         _t = _t->getFirstChild();
00686                         f = _t==ASTNULL ? ANTLR_USE_NAMESPACE(antlr)nullAST : ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00687                         mathFunction(_t);
00688                         _t = _retTree;
00689                         {
00690                         for (;;) {
00691                                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00692                                 if ((_tokenSet_1.member(_t->getType()))) {
00693                                         v1=subs_params(_t);
00694                                         _t = _retTree;
00695                                         args.push(v1);
00696                                 }
00697                                 else {
00698                                         goto _loop120;
00699                                 }
00700                                 
00701                         }
00702                         _loop120:;
00703                         }
00704                         _t = __t118;
00705                         _t = _t->getNextSibling();
00706                         
00707                         v = v + f->getText() + "(";
00708                         while(args.size() > 1){
00709                         v = v + args.front() + ",";
00710                         args.pop();
00711                         }
00712                         v = v + args.front() + ")";
00713                         
00714                         break;
00715                 }
00716                 default:
00717                 {
00718                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00719                 }
00720                 }
00721         }
00722         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00723                 reportError(ex);
00724                 if (_t!=ANTLR_USE_NAMESPACE(antlr)nullAST) {_t = _t->getNextSibling();}
00725         }
00726         _retTree = _t;
00727         return v;
00728 }
00729 
00731 void ExpressionTreeWalker::twConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
00732         
00733         ANTLR_USE_NAMESPACE(antlr)RefAST twConst_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00734         ANTLR_USE_NAMESPACE(antlr)RefAST n = ANTLR_USE_NAMESPACE(antlr)nullAST;
00735         
00736         try {      // for error handling
00737                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00738                 switch ( _t->getType()) {
00739                 case NUM_DOUBLE:
00740                 {
00741                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00742                         match(_t,NUM_DOUBLE);
00743                         _t = _t->getNextSibling();
00744                         break;
00745                 }
00746                 case NUM_FLOAT:
00747                 {
00748                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00749                         match(_t,NUM_FLOAT);
00750                         _t = _t->getNextSibling();
00751                         break;
00752                 }
00753                 case IDENT:
00754                 {
00755                         n = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00756                         match(_t,IDENT);
00757                         _t = _t->getNextSibling();
00758                         
00759                         // Substitute identifier
00760                         std::string s;
00761                         std::string nText = n->getText();
00762                         int found_param = 0;
00763                         std::map<std::string, double>::const_iterator it = mathConstants.find(nText);
00764                         if (it != mathConstants.end()) {
00765                         std::stringstream tmp;
00766                         tmp << it->second;
00767                         found_param = 1;
00768                         s = tmp.str();
00769                         } else
00770                         found_param = utilities->getParameterValue(utilities->getUAPRootNode(),nText,s);
00771                         
00772                         if(!found_param)
00773                         s = "#" + nText + "@";
00774                         n->setText(s);
00775                         
00776                         break;
00777                 }
00778                 default:
00779                 {
00780                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00781                 }
00782                 }
00783         }
00784         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00785                 reportError(ex);
00786                 if (_t!=ANTLR_USE_NAMESPACE(antlr)nullAST) {_t = _t->getNextSibling();}
00787         }
00788         _retTree = _t;
00789 }
00790 
00792 std::string  ExpressionTreeWalker::amlPath(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
00793         std::string r;
00794         
00795         ANTLR_USE_NAMESPACE(antlr)RefAST amlPath_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00796         ANTLR_USE_NAMESPACE(antlr)RefAST tagName = ANTLR_USE_NAMESPACE(antlr)nullAST;
00797         ANTLR_USE_NAMESPACE(antlr)RefAST firstNodeName = ANTLR_USE_NAMESPACE(antlr)nullAST;
00798         ANTLR_USE_NAMESPACE(antlr)RefAST attrName = ANTLR_USE_NAMESPACE(antlr)nullAST;
00799         ANTLR_USE_NAMESPACE(antlr)RefAST nodeName = ANTLR_USE_NAMESPACE(antlr)nullAST;
00800         ANTLR_USE_NAMESPACE(antlr)RefAST aName = ANTLR_USE_NAMESPACE(antlr)nullAST;
00801         ANTLR_USE_NAMESPACE(antlr)RefAST aValue = ANTLR_USE_NAMESPACE(antlr)nullAST;
00802         ANTLR_USE_NAMESPACE(antlr)RefAST attrName2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
00803         
00804         r = "0";
00805         /* The current node in the UAP tree (initially: the root of the tree) */
00806         class UAPNode* currentNode = utilities->getUAPRootNode();
00807         /* The list of matched nodes. */
00808         NodeVec matchedNodes;
00809         /* The string representation of the tags of this path. */
00810         std::string tag = "";
00811         bool shouldUseContextNode = true;
00812         bool hasSpecifiedReturnAttrib = false;
00813         bool isAnonymousPath = false;
00814         /* Temporary list of nodes. */
00815         NodeVec _temp;
00816         
00817         
00818         try {      // for error handling
00819                 ANTLR_USE_NAMESPACE(antlr)RefAST __t122 = _t;
00820                 ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00821                 match(_t,AMLPATH);
00822                 _t = _t->getFirstChild();
00823                 {
00824                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00825                 switch ( _t->getType()) {
00826                 case AMLPATHTAGLIST:
00827                 {
00828                         ANTLR_USE_NAMESPACE(antlr)RefAST __t124 = _t;
00829                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00830                         match(_t,AMLPATHTAGLIST);
00831                         _t = _t->getFirstChild();
00832                         {
00833                         for (;;) {
00834                                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00835                                 if ((_t->getType()==IDENT)) {
00836                                         tagName = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00837                                         match(_t,IDENT);
00838                                         _t = _t->getNextSibling();
00839                                         tag += tagName->getText();
00840                                 }
00841                                 else {
00842                                         goto _loop126;
00843                                 }
00844                                 
00845                         }
00846                         _loop126:;
00847                         }
00848                         _t = __t124;
00849                         _t = _t->getNextSibling();
00850                         break;
00851                 }
00852                 case AMLPATHELEMENT:
00853                 {
00854                         break;
00855                 }
00856                 default:
00857                 {
00858                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00859                 }
00860                 }
00861                 }
00862                 ANTLR_USE_NAMESPACE(antlr)RefAST __t127 = _t;
00863                 ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00864                 match(_t,AMLPATHELEMENT);
00865                 _t = _t->getFirstChild();
00866                 {
00867                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00868                 switch ( _t->getType()) {
00869                 case IDENT:
00870                 {
00871                         firstNodeName = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00872                         match(_t,IDENT);
00873                         _t = _t->getNextSibling();
00874                         shouldUseContextNode = false;
00875                         break;
00876                 }
00877                 case COLON:
00878                 case AMLPATHNODE:
00879                 case AMLPATHATTRIB:
00880                 {
00881                         break;
00882                 }
00883                 default:
00884                 {
00885                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00886                 }
00887                 }
00888                 }
00889                 {
00890                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00891                 switch ( _t->getType()) {
00892                 case COLON:
00893                 {
00894                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00895                         match(_t,COLON);
00896                         _t = _t->getNextSibling();
00897                         isAnonymousPath = true;
00898                         break;
00899                 }
00900                 case AMLPATHNODE:
00901                 case AMLPATHATTRIB:
00902                 {
00903                         break;
00904                 }
00905                 default:
00906                 {
00907                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
00908                 }
00909                 }
00910                 }
00911                 
00912                 if (shouldUseContextNode)
00913                 /* Begin the search from the context node. */
00914                 currentNode = context;
00915                 else if (currentNode && isAnonymousPath)
00916                 currentNode = currentNode->getChildByName(firstNodeName->getText());
00917                 else if (currentNode) {
00918                 /* Find the node whose name attribute value is firstNodeName->getText(). */
00919                 bool hasFirstNode = false;
00920                 matchedNodes = utilities->getUAPRootNode()->getSubNodesByName("constant");
00921                 _temp = currentNode->getSubNodesByName("element");
00922                 matchedNodes.insert(matchedNodes.end(), _temp.begin(), _temp.end());
00923                 _temp = currentNode->getSubNodesByName("controller");
00924                 matchedNodes.insert(matchedNodes.end(), _temp.begin(), _temp.end());
00925                 _temp = currentNode->getSubNodesByName("beam");
00926                 matchedNodes.insert(matchedNodes.end(), _temp.begin(), _temp.end());
00927                 if (tag == "") {
00928                 /* Match attribute name. */
00929                 for (NodeVecCIter imm=matchedNodes.begin(); imm != matchedNodes.end(); ++imm)
00930                 if ((*imm)->getAttributeString("name") == firstNodeName->getText()) {
00931                 currentNode = *imm;
00932                 hasFirstNode = true;
00933                 break;
00934                 }
00935                 } else {
00936                 /* Match attribute name and tag. */
00937                 for (NodeVecCIter imn=matchedNodes.begin(); imn != matchedNodes.end(); ++imn)
00938                 if ((*imn)->getAttributeString("name") == firstNodeName->getText()
00939                 && (*imn)->getAttributeString("tag") == tag) {
00940                 currentNode = *imn;
00941                 hasFirstNode = true;
00942                 break;
00943                 }
00944                 }
00945                 if (!hasFirstNode)
00946                 currentNode = NULL;
00947                 }
00948                 if (!currentNode)
00949                 throw UAPParserException("error: '"+firstNodeName->getText()+"' undeclared");
00950                 
00951                 {
00952                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00953                 switch ( _t->getType()) {
00954                 case AMLPATHATTRIB:
00955                 {
00956                         {
00957                         ANTLR_USE_NAMESPACE(antlr)RefAST __t132 = _t;
00958                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00959                         match(_t,AMLPATHATTRIB);
00960                         _t = _t->getFirstChild();
00961                         attrName = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00962                         match(_t,IDENT);
00963                         _t = _t->getNextSibling();
00964                         _t = __t132;
00965                         _t = _t->getNextSibling();
00966                         
00967                         if (currentNode)
00968                         /* Retrieve the value of the attribute with the specified name. */
00969                         r = currentNode->getAttributeString(attrName->getText());
00970                         if (r == "")
00971                         /* If the attribute whose name is attrName->getText() is not defined. */
00972                         r = "0";
00973                         
00974                         }
00975                         break;
00976                 }
00977                 case AMLPATHNODE:
00978                 {
00979                         {
00980                         {
00981                         int _cnt139=0;
00982                         for (;;) {
00983                                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
00984                                 if ((_t->getType()==AMLPATHNODE)) {
00985                                         ANTLR_USE_NAMESPACE(antlr)RefAST __t135 = _t;
00986                                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00987                                         match(_t,AMLPATHNODE);
00988                                         _t = _t->getFirstChild();
00989                                         nodeName = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
00990                                         match(_t,IDENT);
00991                                         _t = _t->getNextSibling();
00992                                         
00993                                         /* Find the list of nodes matchedNodes whose name is nodeName->getText(). */
00994                                         if (currentNode)
00995                                         matchedNodes = currentNode->getChildrenByName(nodeName->getText());
00996                                         
00997                                         
00998                                         {
00999                                         for (;;) {
01000                                                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
01001                                                 if ((_t->getType()==AMLPATHATTREXPR)) {
01002                                                         ANTLR_USE_NAMESPACE(antlr)RefAST __t137 = _t;
01003                                                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01004                                                         match(_t,AMLPATHATTREXPR);
01005                                                         _t = _t->getFirstChild();
01006                                                         aName = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01007                                                         match(_t,IDENT);
01008                                                         _t = _t->getNextSibling();
01009                                                         aValue = _t==ASTNULL ? ANTLR_USE_NAMESPACE(antlr)nullAST : ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01010                                                         amlAttrValue(_t);
01011                                                         _t = _retTree;
01012                                                         _t = __t137;
01013                                                         _t = _t->getNextSibling();
01014                                                         
01015                                                         /* Compute the subset of the list matchedNodes whose elements have 
01016                                                         this attribute-value pair. */
01017                                                         NodeVec temp;
01018                                                         for (NodeVecCIter it=matchedNodes.begin(); it != matchedNodes.end(); ++it)
01019                                                         if ((*it)->getAttributeString(aName->getText()) == aValue->getText())
01020                                                         temp.push_back(*it);
01021                                                         matchedNodes = temp;
01022                                                         
01023                                                 }
01024                                                 else {
01025                                                         goto _loop138;
01026                                                 }
01027                                                 
01028                                         }
01029                                         _loop138:;
01030                                         }
01031                                         
01032                                         /* Set the current node to the node that matched every attribute-value pair; 
01033                                         otherwise set to <code>NULL</code>. */
01034                                         currentNode = (matchedNodes.empty())? NULL: matchedNodes.front();
01035                                         
01036                                         _t = __t135;
01037                                         _t = _t->getNextSibling();
01038                                 }
01039                                 else {
01040                                         if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
01041                                 }
01042                                 
01043                                 _cnt139++;
01044                         }
01045                         _loop139:;
01046                         }
01047                         {
01048                         if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
01049                         switch ( _t->getType()) {
01050                         case AMLPATHATTRIB:
01051                         {
01052                                 ANTLR_USE_NAMESPACE(antlr)RefAST __t141 = _t;
01053                                 ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01054                                 match(_t,AMLPATHATTRIB);
01055                                 _t = _t->getFirstChild();
01056                                 attrName2 = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01057                                 match(_t,IDENT);
01058                                 _t = _t->getNextSibling();
01059                                 hasSpecifiedReturnAttrib = true;
01060                                 _t = __t141;
01061                                 _t = _t->getNextSibling();
01062                                 break;
01063                         }
01064                         case 3:
01065                         {
01066                                 break;
01067                         }
01068                         default:
01069                         {
01070                                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
01071                         }
01072                         }
01073                         }
01074                         
01075                         if (currentNode && hasSpecifiedReturnAttrib)
01076                         /* Retrieve the value of the attribute with the specified name. */
01077                         r = "(" + currentNode->getAttributeString(attrName2->getText()) +")";
01078                         else if (currentNode)
01079                         /* Retrieve the value of the default attribute. */
01080                         r = "(" + currentNode->getAttributeString("design") + ")";
01081                         if (r == "()")
01082                         /* Either the attribute whose name is attrName2->getText() or 
01083                         the default attribute is not defined. */
01084                         r = "(0)";
01085                         
01086                         }
01087                         break;
01088                 }
01089                 default:
01090                 {
01091                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
01092                 }
01093                 }
01094                 }
01095                 _t = __t127;
01096                 _t = _t->getNextSibling();
01097                 _t = __t122;
01098                 _t = _t->getNextSibling();
01099         }
01100         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01101                 reportError(ex);
01102                 if (_t!=ANTLR_USE_NAMESPACE(antlr)nullAST) {_t = _t->getNextSibling();}
01103         }
01104         _retTree = _t;
01105         return r;
01106 }
01107 
01108 void ExpressionTreeWalker::amlAttrValue(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
01109         
01110         ANTLR_USE_NAMESPACE(antlr)RefAST amlAttrValue_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01111         
01112         try {      // for error handling
01113                 if (_t==ANTLR_USE_NAMESPACE(antlr)nullAST) _t=ASTNULL;
01114                 switch ( _t->getType()) {
01115                 case NUM_DOUBLE:
01116                 {
01117                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01118                         match(_t,NUM_DOUBLE);
01119                         _t = _t->getNextSibling();
01120                         break;
01121                 }
01122                 case NUM_FLOAT:
01123                 {
01124                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01125                         match(_t,NUM_FLOAT);
01126                         _t = _t->getNextSibling();
01127                         break;
01128                 }
01129                 case IDENT:
01130                 {
01131                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01132                         match(_t,IDENT);
01133                         _t = _t->getNextSibling();
01134                         break;
01135                 }
01136                 case STRING_LITERAL_S:
01137                 {
01138                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01139                         match(_t,STRING_LITERAL_S);
01140                         _t = _t->getNextSibling();
01141                         break;
01142                 }
01143                 case STRING_LITERAL_D:
01144                 {
01145                         ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST_in = ANTLR_USE_NAMESPACE(antlr)RefAST(_t);
01146                         match(_t,STRING_LITERAL_D);
01147                         _t = _t->getNextSibling();
01148                         break;
01149                 }
01150                 default:
01151                 {
01152                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
01153                 }
01154                 }
01155         }
01156         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01157                 reportError(ex);
01158                 if (_t!=ANTLR_USE_NAMESPACE(antlr)nullAST) {_t = _t->getNextSibling();}
01159         }
01160         _retTree = _t;
01161 }
01162 
01163 const char* ExpressionTreeWalker::_tokenNames[] = {
01164         "<0>",
01165         "EOF",
01166         "<2>",
01167         "NULL_TREE_LOOKAHEAD",
01168         "SEMI",
01169         "PLUS",
01170         "MINUS",
01171         "MULT",
01172         "DIV",
01173         "MOD",
01174         "POW",
01175         "LPAREN",
01176         "COMMA",
01177         "RPAREN",
01178         "a label",
01179         "LBRACKET",
01180         "COLON",
01181         "RBRACKET",
01182         "AT",
01183         "\".\"",
01184         "EQUAL",
01185         "NUM_DOUBLE",
01186         "NUM_FLOAT",
01187         "STRING_LITERAL_S",
01188         "STRING_LITERAL_D",
01189         "\"sqrt\"",
01190         "\"log\"",
01191         "\"exp\"",
01192         "\"sin\"",
01193         "\"cos\"",
01194         "\"tan\"",
01195         "\"asin\"",
01196         "\"acos\"",
01197         "\"atan\"",
01198         "\"atan2\"",
01199         "\"abs\"",
01200         "\"max\"",
01201         "\"min\"",
01202         "\"ran\"",
01203         "\"ran_gauss\"",
01204         "\"randf\"",
01205         "\"gauss\"",
01206         "\"tgauss\"",
01207         "\"user0\"",
01208         "\"user1\"",
01209         "\"user2\"",
01210         "FUNC",
01211         "AMLPATH",
01212         "AMLPATHNODE",
01213         "AMLPATHATTREXPR",
01214         "AMLPATHELEMENT",
01215         "AMLPATHTAGLIST",
01216         "AMLPATHATTRIB",
01217         "WS_",
01218         "ESC",
01219         0
01220 };
01221 
01222 const unsigned long ExpressionTreeWalker::_tokenSet_0_data_[] = { 6295008UL, 16384UL, 0UL, 0UL };
01223 const ANTLR_USE_NAMESPACE(antlr)BitSet ExpressionTreeWalker::_tokenSet_0(_tokenSet_0_data_,4);
01224 const unsigned long ExpressionTreeWalker::_tokenSet_1_data_[] = { 6311392UL, 49152UL, 0UL, 0UL };
01225 const ANTLR_USE_NAMESPACE(antlr)BitSet ExpressionTreeWalker::_tokenSet_1(_tokenSet_1_data_,4);
01226 
01227