From 24575b502b0dd05c95ace336303f081573bcf812 Mon Sep 17 00:00:00 2001 From: Adrian Pop Date: Mon, 15 May 2006 00:43:03 +0000 Subject: [PATCH] Updated the XML part with the latest version of ModelicaXML and FlatModelicaXML git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@2377 f25d12d1-65f4-0310-ae8a-bbce733d8d8e --- .../xml/flatmodelicaxml/FlatModelicaLexer.cpp | 1507 +++ .../xml/flatmodelicaxml/FlatModelicaLexer.hpp | 87 + tools/xml/flatmodelicaxml/FlatModelicaXML.cpp | 135 + .../flatmodelicaxml/FlatModelicaXML.vcproj | 240 + tools/xml/flatmodelicaxml/FlatModelicaXml.h | 67 + tools/xml/flatmodelicaxml/Makefile | 71 + .../flatmodelicaxml/ModelicaXMLUtilities.cpp | 49 + .../flatmodelicaxml/ModelicaXMLUtilities.hpp | 32 + tools/xml/flatmodelicaxml/MyAST.h | 113 + .../flatmodelicaxml/flat_modelica_lexer.cpp | 1710 +++ .../xml/flatmodelicaxml/flat_modelica_lexer.g | 227 + .../flatmodelicaxml/flat_modelica_lexer.hpp | 99 + .../flatmodelicaxml/flat_modelica_parser.cpp | 4166 +++++++ .../flatmodelicaxml/flat_modelica_parser.g | 683 ++ .../flatmodelicaxml/flat_modelica_parser.hpp | 222 + .../flat_modelica_parserTokenTypes.hpp | 172 + .../flat_modelica_parserTokenTypes.txt | 154 + .../flat_modelica_tree_parser.cpp | 9109 +++++++++++++++ .../flat_modelica_tree_parser.hpp | 376 + .../flat_modelica_tree_parserTokenTypes.hpp | 175 + .../flat_modelica_tree_parserTokenTypes.txt | 157 + .../flatmodelicaTokenTypes.hpp | 131 + .../flatmodelicaTokenTypes.txt | 113 + .../xml/flatmodelicaxml/parse_tree_dumper.cpp | 10 + .../xml/flatmodelicaxml/parse_tree_dumper.hpp | 114 + tools/xml/flatmodelicaxml/test.cpp | 115 + tools/xml/flatmodelicaxml/walker.g | 2657 +++++ tools/xml/modelicaxml/Makefile | 55 + tools/xml/modelicaxml/Makefile_parser | 65 + tools/xml/modelicaxml/ModelicaXML.cpp | 487 + tools/xml/modelicaxml/ModelicaXML.sln | 29 + tools/xml/modelicaxml/ModelicaXML.vcproj | 321 + .../xml/modelicaxml/ModelicaXMLUtilities.cpp | 49 + .../xml/modelicaxml/ModelicaXMLUtilities.hpp | 32 + tools/xml/modelicaxml/ModelicaXml.h | 67 + tools/xml/modelicaxml/MyAST.h | 158 + tools/xml/modelicaxml/dirwalk.cpp | 154 + tools/xml/modelicaxml/dirwalk.h | 12 + tools/xml/modelicaxml/modelicaTokenTypes.hpp | 119 + tools/xml/modelicaxml/modelicaTokenTypes.txt | 101 + tools/xml/modelicaxml/modelica_lexer.cpp | 1751 +++ tools/xml/modelicaxml/modelica_lexer.g | 199 + tools/xml/modelicaxml/modelica_lexer.hpp | 92 + tools/xml/modelicaxml/modelica_parser.cpp | 5928 ++++++++++ tools/xml/modelicaxml/modelica_parser.g | 1069 ++ tools/xml/modelicaxml/modelica_parser.hpp | 287 + .../modelicaxml/modelica_parserTokenTypes.hpp | 163 + .../modelicaxml/modelica_parserTokenTypes.txt | 145 + .../xml/modelicaxml/modelica_tree_parser.cpp | 9801 +++++++++++++++++ .../xml/modelicaxml/modelica_tree_parser.hpp | 340 + .../modelica_tree_parserTokenTypes.hpp | 167 + .../modelica_tree_parserTokenTypes.txt | 149 + tools/xml/modelicaxml/modelicaxml-v2.dtd | 538 + tools/xml/modelicaxml/parse_tree_dumper.cpp | 10 + tools/xml/modelicaxml/parse_tree_dumper.hpp | 108 + tools/xml/modelicaxml/test.cpp | 37 + tools/xml/modelicaxml/token_names.cpp | 79 + tools/xml/modelicaxml/token_names.hpp | 56 + tools/xml/modelicaxml/walker.g | 2701 +++++ tools/xml/older/xml.tar.bz2 | Bin 0 -> 89456 bytes 60 files changed, 47960 insertions(+) create mode 100644 tools/xml/flatmodelicaxml/FlatModelicaLexer.cpp create mode 100644 tools/xml/flatmodelicaxml/FlatModelicaLexer.hpp create mode 100644 tools/xml/flatmodelicaxml/FlatModelicaXML.cpp create mode 100644 tools/xml/flatmodelicaxml/FlatModelicaXML.vcproj create mode 100644 tools/xml/flatmodelicaxml/FlatModelicaXml.h create mode 100644 tools/xml/flatmodelicaxml/Makefile create mode 100644 tools/xml/flatmodelicaxml/ModelicaXMLUtilities.cpp create mode 100644 tools/xml/flatmodelicaxml/ModelicaXMLUtilities.hpp create mode 100644 tools/xml/flatmodelicaxml/MyAST.h create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_lexer.cpp create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_lexer.g create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_lexer.hpp create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_parser.cpp create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_parser.g create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_parser.hpp create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_parserTokenTypes.hpp create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_parserTokenTypes.txt create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_tree_parser.cpp create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_tree_parser.hpp create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_tree_parserTokenTypes.hpp create mode 100644 tools/xml/flatmodelicaxml/flat_modelica_tree_parserTokenTypes.txt create mode 100644 tools/xml/flatmodelicaxml/flatmodelicaTokenTypes.hpp create mode 100644 tools/xml/flatmodelicaxml/flatmodelicaTokenTypes.txt create mode 100644 tools/xml/flatmodelicaxml/parse_tree_dumper.cpp create mode 100644 tools/xml/flatmodelicaxml/parse_tree_dumper.hpp create mode 100644 tools/xml/flatmodelicaxml/test.cpp create mode 100644 tools/xml/flatmodelicaxml/walker.g create mode 100644 tools/xml/modelicaxml/Makefile create mode 100644 tools/xml/modelicaxml/Makefile_parser create mode 100644 tools/xml/modelicaxml/ModelicaXML.cpp create mode 100644 tools/xml/modelicaxml/ModelicaXML.sln create mode 100644 tools/xml/modelicaxml/ModelicaXML.vcproj create mode 100644 tools/xml/modelicaxml/ModelicaXMLUtilities.cpp create mode 100644 tools/xml/modelicaxml/ModelicaXMLUtilities.hpp create mode 100644 tools/xml/modelicaxml/ModelicaXml.h create mode 100644 tools/xml/modelicaxml/MyAST.h create mode 100644 tools/xml/modelicaxml/dirwalk.cpp create mode 100644 tools/xml/modelicaxml/dirwalk.h create mode 100644 tools/xml/modelicaxml/modelicaTokenTypes.hpp create mode 100644 tools/xml/modelicaxml/modelicaTokenTypes.txt create mode 100644 tools/xml/modelicaxml/modelica_lexer.cpp create mode 100644 tools/xml/modelicaxml/modelica_lexer.g create mode 100644 tools/xml/modelicaxml/modelica_lexer.hpp create mode 100644 tools/xml/modelicaxml/modelica_parser.cpp create mode 100644 tools/xml/modelicaxml/modelica_parser.g create mode 100644 tools/xml/modelicaxml/modelica_parser.hpp create mode 100644 tools/xml/modelicaxml/modelica_parserTokenTypes.hpp create mode 100644 tools/xml/modelicaxml/modelica_parserTokenTypes.txt create mode 100644 tools/xml/modelicaxml/modelica_tree_parser.cpp create mode 100644 tools/xml/modelicaxml/modelica_tree_parser.hpp create mode 100644 tools/xml/modelicaxml/modelica_tree_parserTokenTypes.hpp create mode 100644 tools/xml/modelicaxml/modelica_tree_parserTokenTypes.txt create mode 100644 tools/xml/modelicaxml/modelicaxml-v2.dtd create mode 100644 tools/xml/modelicaxml/parse_tree_dumper.cpp create mode 100644 tools/xml/modelicaxml/parse_tree_dumper.hpp create mode 100644 tools/xml/modelicaxml/test.cpp create mode 100644 tools/xml/modelicaxml/token_names.cpp create mode 100644 tools/xml/modelicaxml/token_names.hpp create mode 100644 tools/xml/modelicaxml/walker.g create mode 100644 tools/xml/older/xml.tar.bz2 diff --git a/tools/xml/flatmodelicaxml/FlatModelicaLexer.cpp b/tools/xml/flatmodelicaxml/FlatModelicaLexer.cpp new file mode 100644 index 00000000000..71dd234bb9b --- /dev/null +++ b/tools/xml/flatmodelicaxml/FlatModelicaLexer.cpp @@ -0,0 +1,1507 @@ +/* $ANTLR 2.7.3: "flat_modelica_lexer.g" -> "FlatModelicaLexer.cpp"$ */ +#include "FlatModelicaLexer.hpp" +#include +#include +#include +#include +#include +#include +#include + +#line 1 "flat_modelica_lexer.g" +#line 13 "FlatModelicaLexer.cpp" +FlatModelicaLexer::FlatModelicaLexer(ANTLR_USE_NAMESPACE(std)istream& in) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),true) +{ + initLiterals(); +} + +FlatModelicaLexer::FlatModelicaLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true) +{ + initLiterals(); +} + +FlatModelicaLexer::FlatModelicaLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,true) +{ + initLiterals(); +} + +void FlatModelicaLexer::initLiterals() +{ + literals["external"] = 23; + literals["elsewhen"] = 17; + literals["loop"] = 35; + literals["for"] = 27; + literals["class"] = 9; + literals["block"] = 7; + literals["redeclare"] = 47; + literals["final"] = 25; + literals["parameter"] = 42; + literals["false"] = 24; + literals["true"] = 51; + literals["connect"] = 10; + literals["and"] = 5; + literals["boundary"] = 8; + literals["results"] = 49; + literals["import"] = 30; + literals["end"] = 18; + literals["outer"] = 38; + literals["when"] = 54; + literals["connector"] = 11; + literals["record"] = 46; + literals["within"] = 56; + literals["algorithm"] = 4; + literals["type"] = 52; + literals["in"] = 31; + literals["inner"] = 33; + literals["extends"] = 22; + literals["function"] = 28; + literals["output"] = 40; + literals["equation"] = 20; + literals["elseif"] = 16; + literals["each"] = 14; + literals["while"] = 55; + literals["unsigned_real"] = 53; + literals["or"] = 39; + literals["constant"] = 12; + literals["replaceable"] = 48; + literals["discrete"] = 13; + literals["model"] = 36; + literals["protected"] = 44; + literals["annotation"] = 6; + literals["encapsulated"] = 21; + literals["initial"] = 32; + literals["input"] = 34; + literals["partial"] = 43; + literals["if"] = 29; + literals["enumeration"] = 19; + literals["public"] = 45; + literals["package"] = 41; + literals["else"] = 15; + literals["flow"] = 26; + literals["not"] = 37; + literals["then"] = 50; +} + +ANTLR_USE_NAMESPACE(antlr)RefToken FlatModelicaLexer::nextToken() +{ + ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken; + for (;;) { + ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken; + int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE; + resetText(); + try { // for lexical and char stream error handling + switch ( LA(1)) { + case 0x28 /* '(' */ : + { + mLPAR(true); + theRetToken=_returnToken; + break; + } + case 0x29 /* ')' */ : + { + mRPAR(true); + theRetToken=_returnToken; + break; + } + case 0x5b /* '[' */ : + { + mLBRACK(true); + theRetToken=_returnToken; + break; + } + case 0x5d /* ']' */ : + { + mRBRACK(true); + theRetToken=_returnToken; + break; + } + case 0x7b /* '{' */ : + { + mLBRACE(true); + theRetToken=_returnToken; + break; + } + case 0x7d /* '}' */ : + { + mRBRACE(true); + theRetToken=_returnToken; + break; + } + case 0x2b /* '+' */ : + { + mPLUS(true); + theRetToken=_returnToken; + break; + } + case 0x2d /* '-' */ : + { + mMINUS(true); + theRetToken=_returnToken; + break; + } + case 0x2a /* '*' */ : + { + mSTAR(true); + theRetToken=_returnToken; + break; + } + case 0x2e /* '.' */ : + { + mDOT(true); + theRetToken=_returnToken; + break; + } + case 0x2c /* ',' */ : + { + mCOMMA(true); + theRetToken=_returnToken; + break; + } + case 0x3b /* ';' */ : + { + mSEMICOLON(true); + theRetToken=_returnToken; + break; + } + case 0x5e /* '^' */ : + { + mPOWER(true); + theRetToken=_returnToken; + break; + } + case 0x9 /* '\t' */ : + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + case 0x20 /* ' ' */ : + { + mWS(true); + theRetToken=_returnToken; + break; + } + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + case 0x5f /* '_' */ : + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + mIDENT(true); + theRetToken=_returnToken; + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + mUNSIGNED_INTEGER(true); + theRetToken=_returnToken; + break; + } + case 0x22 /* '"' */ : + { + mSTRING(true); + theRetToken=_returnToken; + break; + } + default: + if ((LA(1) == 0x3a /* ':' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mASSIGN(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mLESSEQ(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mGREATEREQ(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mEQEQ(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3e /* '>' */ )) { + mLESSGT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) { + mML_COMMENT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) { + mSL_COMMENT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (true)) { + mEQUALS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (true)) { + mSLASH(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (true)) { + mLESS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3e /* '>' */ ) && (true)) { + mGREATER(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3a /* ':' */ ) && (true)) { + mCOLON(true); + theRetToken=_returnToken; + } + else { + if (LA(1)==EOF_CHAR) + { + uponEOF(); + _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + } + else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + } + if ( !_returnToken ) + goto tryAgain; // found SKIP token + + _ttype = _returnToken->getType(); + _returnToken->setType(_ttype); + return _returnToken; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) { + throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e); + } + catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) { + throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io); + } + catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) { + throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage()); + } +tryAgain:; + } +} + +void FlatModelicaLexer::mLPAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = LPAR; + int _saveIndex; + + match('('); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mRPAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = RPAR; + int _saveIndex; + + match(')'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mLBRACK(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = LBRACK; + int _saveIndex; + + match('['); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mRBRACK(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = RBRACK; + int _saveIndex; + + match(']'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mLBRACE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = LBRACE; + int _saveIndex; + + match('{'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mRBRACE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = RBRACE; + int _saveIndex; + + match('}'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mEQUALS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = EQUALS; + int _saveIndex; + + match('='); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mASSIGN(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = ASSIGN; + int _saveIndex; + + match(":="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mPLUS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = PLUS; + int _saveIndex; + + match('+'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mMINUS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = MINUS; + int _saveIndex; + + match('-'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mSTAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = STAR; + int _saveIndex; + + match('*'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mSLASH(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = SLASH; + int _saveIndex; + + match('/'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mDOT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = DOT; + int _saveIndex; + + match('.'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mCOMMA(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = COMMA; + int _saveIndex; + + match(','); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mLESS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = LESS; + int _saveIndex; + + match('<'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mLESSEQ(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = LESSEQ; + int _saveIndex; + + match("<="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mGREATER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = GREATER; + int _saveIndex; + + match('>'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mGREATEREQ(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = GREATEREQ; + int _saveIndex; + + match(">="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mEQEQ(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = EQEQ; + int _saveIndex; + + match("=="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mLESSGT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = LESSGT; + int _saveIndex; + + match("<>"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mCOLON(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = COLON; + int _saveIndex; + + match(':'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mSEMICOLON(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = SEMICOLON; + int _saveIndex; + + match(';'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mPOWER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = POWER; + int _saveIndex; + + match('^'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mWS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = WS; + int _saveIndex; + + { + switch ( LA(1)) { + case 0x20 /* ' ' */ : + { + match(' '); + break; + } + case 0x9 /* '\t' */ : + { + match('\t'); + break; + } + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + { + { + if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) { + match("\r\n"); + } + else if ((LA(1) == 0xd /* '\r' */ ) && (true)) { + match('\r'); + } + else if ((LA(1) == 0xa /* '\n' */ )) { + match('\n'); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + } + if ( inputState->guessing==0 ) { +#line 118 "flat_modelica_lexer.g" + newline(); +#line 702 "FlatModelicaLexer.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( inputState->guessing==0 ) { +#line 120 "flat_modelica_lexer.g" + _ttype = antlr::Token::SKIP; +#line 715 "FlatModelicaLexer.cpp" + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mML_COMMENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = ML_COMMENT; + int _saveIndex; + + match("/*"); + { // ( ... )* + for (;;) { + if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */ && LA(2) <= 0xff)))&&(LA(2)!='/')) { + match('*'); + } + else if ((_tokenSet_0.member(LA(1)))) { + mML_COMMENT_CHAR(false); + } + else { + goto _loop29; + } + + } + _loop29:; + } // ( ... )* + match("*/"); + if ( inputState->guessing==0 ) { +#line 127 "flat_modelica_lexer.g" + _ttype = antlr::Token::SKIP; +#line 750 "FlatModelicaLexer.cpp" + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mML_COMMENT_CHAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = ML_COMMENT_CHAR; + int _saveIndex; + + if ((LA(1) == 0xa /* '\n' */ || LA(1) == 0xd /* '\r' */ )) { + { + switch ( LA(1)) { + case 0xd /* '\r' */ : + { + match("\r\n"); + break; + } + case 0xa /* '\n' */ : + { + match('\n'); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( inputState->guessing==0 ) { +#line 131 "flat_modelica_lexer.g" + newline(); +#line 787 "FlatModelicaLexer.cpp" + } + } + else if ((_tokenSet_1.member(LA(1)))) { + { + match(_tokenSet_1); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mSL_COMMENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = SL_COMMENT; + int _saveIndex; + + match("//"); + { // ( ... )* + for (;;) { + if ((_tokenSet_2.member(LA(1)))) { + { + match(_tokenSet_2); + } + } + else { + goto _loop36; + } + + } + _loop36:; + } // ( ... )* + if ( inputState->guessing==0 ) { +#line 137 "flat_modelica_lexer.g" + _ttype = antlr::Token::SKIP; +#line 830 "FlatModelicaLexer.cpp" + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mIDENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = IDENT; + int _saveIndex; + + mNONDIGIT(false); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case 0x2e /* '.' */ : + { + mDOT(false); + break; + } + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + case 0x5f /* '_' */ : + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + mNONDIGIT(false); + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + mDIGIT(false); + break; + } + default: + { + goto _loop39; + } + } + } + _loop39:; + } // ( ... )* + _ttype = testLiteralsTable(_ttype); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mNONDIGIT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = NONDIGIT; + int _saveIndex; + + { + switch ( LA(1)) { + case 0x5f /* '_' */ : + { + match('_'); + break; + } + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + matchRange('a','z'); + break; + } + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + { + matchRange('A','Z'); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mDIGIT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = DIGIT; + int _saveIndex; + + matchRange('0','9'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mEXPONENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = EXPONENT; + int _saveIndex; + + { + switch ( LA(1)) { + case 0x65 /* 'e' */ : + { + match('e'); + break; + } + case 0x45 /* 'E' */ : + { + match('E'); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { + switch ( LA(1)) { + case 0x2b /* '+' */ : + { + match('+'); + break; + } + case 0x2d /* '-' */ : + { + match('-'); + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { // ( ... )+ + int _cnt47=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt47>=1 ) { goto _loop47; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt47++; + } + _loop47:; + } // ( ... )+ + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mUNSIGNED_INTEGER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = UNSIGNED_INTEGER; + int _saveIndex; + + { + bool synPredMatched53 = false; + if ((((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_3.member(LA(2))))) { + int _m53 = mark(); + synPredMatched53 = true; + inputState->guessing++; + try { + { + { // ( ... )+ + int _cnt52=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt52>=1 ) { goto _loop52; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt52++; + } + _loop52:; + } // ( ... )+ + match('.'); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched53 = false; + } + rewind(_m53); + inputState->guessing--; + } + if ( synPredMatched53 ) { + { // ( ... )+ + int _cnt55=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt55>=1 ) { goto _loop55; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt55++; + } + _loop55:; + } // ( ... )+ + { + match('.'); + { // ( ... )+ + int _cnt58=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt58>=1 ) { goto _loop58; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt58++; + } + _loop58:; + } // ( ... )+ + } + if ( inputState->guessing==0 ) { +#line 159 "flat_modelica_lexer.g" + + _ttype = UNSIGNED_REAL; + +#line 1191 "FlatModelicaLexer.cpp" + } + } + else if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (true)) { + { // ( ... )+ + int _cnt60=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt60>=1 ) { goto _loop60; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt60++; + } + _loop60:; + } // ( ... )+ + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + } + { + if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) { + mEXPONENT(false); + if ( inputState->guessing==0 ) { +#line 164 "flat_modelica_lexer.g" + _ttype = UNSIGNED_REAL; +#line 1221 "FlatModelicaLexer.cpp" + } + } + else { + } + + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mSTRING(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = STRING; + int _saveIndex; + + _saveIndex = text.length(); + match('"'); + text.erase(_saveIndex); + { // ( ... )* + for (;;) { + if ((_tokenSet_4.member(LA(1)))) { + mSCHAR(false); + } + else if ((LA(1) == 0x5c /* '\\' */ )) { + mSESCAPE(false); + } + else { + goto _loop64; + } + + } + _loop64:; + } // ( ... )* + _saveIndex = text.length(); + match('"'); + text.erase(_saveIndex); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mSCHAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = SCHAR; + int _saveIndex; + + switch ( LA(1)) { + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + { + { + { + switch ( LA(1)) { + case 0xa /* '\n' */ : + { + match('\n'); + break; + } + case 0xd /* '\r' */ : + { + match("\r\n"); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + } + if ( inputState->guessing==0 ) { +#line 171 "flat_modelica_lexer.g" + newline(); +#line 1302 "FlatModelicaLexer.cpp" + } + break; + } + case 0x9 /* '\t' */ : + { + match('\t'); + break; + } + default: + if ((_tokenSet_5.member(LA(1)))) { + { + match(_tokenSet_5); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mSESCAPE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = SESCAPE; + int _saveIndex; + + match('\\'); + { + switch ( LA(1)) { + case 0x5c /* '\\' */ : + { + match('\\'); + break; + } + case 0x22 /* '"' */ : + { + match('"'); + break; + } + case 0x27 /* '\'' */ : + { + match("'"); + break; + } + case 0x3f /* '?' */ : + { + match('?'); + break; + } + case 0x61 /* 'a' */ : + { + match('a'); + break; + } + case 0x62 /* 'b' */ : + { + match('b'); + break; + } + case 0x66 /* 'f' */ : + { + match('f'); + break; + } + case 0x6e /* 'n' */ : + { + match('n'); + break; + } + case 0x72 /* 'r' */ : + { + match('r'); + break; + } + case 0x74 /* 't' */ : + { + match('t'); + break; + } + case 0x76 /* 'v' */ : + { + match('v'); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void FlatModelicaLexer::mESC(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length(); + _ttype = ESC; + int _saveIndex; + + match('\\'); + { + switch ( LA(1)) { + case 0x22 /* '"' */ : + { + match('"'); + break; + } + case 0x5c /* '\\' */ : + { + match('\\'); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + + +const unsigned long FlatModelicaLexer::_tokenSet_0_data_[] = { 4294967288UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// NULL_TREE_LOOKAHEAD "algorithm" "and" "annotation" "block" "boundary" +// "class" "connect" "connector" "constant" "discrete" "each" "else" "elseif" +// "elsewhen" "end" "enumeration" "equation" "encapsulated" "extends" "external" +// "false" "final" "flow" "for" "function" "if" "import" "in" "initial" +// "inner" "input" "loop" "model" "not" "outer" "or" "output" "package" +// "partial" "protected" "public" "record" "redeclare" "replaceable" "results" +// "then" "true" "type" "unsigned_real" "when" "while" "within" LPAR RPAR +// LBRACK RBRACK LBRACE RBRACE EQUALS ASSIGN PLUS MINUS STAR SLASH DOT +// COMMA LESS LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER +// WS ML_COMMENT ML_COMMENT_CHAR SL_COMMENT IDENT NONDIGIT DIGIT EXPONENT +// UNSIGNED_INTEGER STRING SCHAR SESCAPE ESC +const ANTLR_USE_NAMESPACE(antlr)BitSet FlatModelicaLexer::_tokenSet_0(_tokenSet_0_data_,16); +const unsigned long FlatModelicaLexer::_tokenSet_1_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// NULL_TREE_LOOKAHEAD "algorithm" "and" "annotation" "block" "boundary" +// "class" "connector" "constant" "each" "else" "elseif" "elsewhen" "end" +// "enumeration" "equation" "encapsulated" "extends" "external" "false" +// "final" "flow" "for" "function" "if" "import" "in" "initial" "inner" +// "input" "loop" "model" "not" "outer" "or" "output" "package" "partial" +// "protected" "public" "record" "redeclare" "replaceable" "results" "then" +// "true" "type" "unsigned_real" "when" "while" "within" LPAR RPAR LBRACK +// RBRACK LBRACE RBRACE EQUALS ASSIGN PLUS MINUS STAR SLASH DOT COMMA LESS +// LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER WS ML_COMMENT +// ML_COMMENT_CHAR SL_COMMENT IDENT NONDIGIT DIGIT EXPONENT UNSIGNED_INTEGER +// STRING SCHAR SESCAPE ESC +const ANTLR_USE_NAMESPACE(antlr)BitSet FlatModelicaLexer::_tokenSet_1(_tokenSet_1_data_,16); +const unsigned long FlatModelicaLexer::_tokenSet_2_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// NULL_TREE_LOOKAHEAD "algorithm" "and" "annotation" "block" "boundary" +// "class" "connector" "constant" "each" "else" "elseif" "elsewhen" "end" +// "enumeration" "equation" "encapsulated" "extends" "external" "false" +// "final" "flow" "for" "function" "if" "import" "in" "initial" "inner" +// "input" "loop" "model" "not" "outer" "or" "output" "package" "parameter" +// "partial" "protected" "public" "record" "redeclare" "replaceable" "results" +// "then" "true" "type" "unsigned_real" "when" "while" "within" LPAR RPAR +// LBRACK RBRACK LBRACE RBRACE EQUALS ASSIGN PLUS MINUS STAR SLASH DOT +// COMMA LESS LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER +// WS ML_COMMENT ML_COMMENT_CHAR SL_COMMENT IDENT NONDIGIT DIGIT EXPONENT +// UNSIGNED_INTEGER STRING SCHAR SESCAPE ESC +const ANTLR_USE_NAMESPACE(antlr)BitSet FlatModelicaLexer::_tokenSet_2(_tokenSet_2_data_,16); +const unsigned long FlatModelicaLexer::_tokenSet_3_data_[] = { 0UL, 67059712UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "record" "replaceable" "results" "then" "true" "type" "unsigned_real" +// "when" "while" "within" LPAR +const ANTLR_USE_NAMESPACE(antlr)BitSet FlatModelicaLexer::_tokenSet_3(_tokenSet_3_data_,10); +const unsigned long FlatModelicaLexer::_tokenSet_4_data_[] = { 4294967288UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// NULL_TREE_LOOKAHEAD "algorithm" "and" "annotation" "block" "boundary" +// "class" "connect" "connector" "constant" "discrete" "each" "else" "elseif" +// "elsewhen" "end" "enumeration" "equation" "encapsulated" "extends" "external" +// "false" "final" "flow" "for" "function" "if" "import" "in" "initial" +// "inner" "loop" "model" "not" "outer" "or" "output" "package" "parameter" +// "partial" "protected" "public" "record" "redeclare" "replaceable" "results" +// "then" "true" "type" "unsigned_real" "when" "while" "within" LPAR RPAR +// LBRACK RBRACK LBRACE RBRACE EQUALS ASSIGN PLUS MINUS STAR SLASH DOT +// COMMA LESS LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER +// WS ML_COMMENT ML_COMMENT_CHAR SL_COMMENT IDENT NONDIGIT DIGIT EXPONENT +// UNSIGNED_INTEGER STRING SCHAR SESCAPE +const ANTLR_USE_NAMESPACE(antlr)BitSet FlatModelicaLexer::_tokenSet_4(_tokenSet_4_data_,16); +const unsigned long FlatModelicaLexer::_tokenSet_5_data_[] = { 4294957560UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// NULL_TREE_LOOKAHEAD "algorithm" "and" "annotation" "block" "boundary" +// "connector" "constant" "each" "else" "elseif" "elsewhen" "end" "enumeration" +// "equation" "encapsulated" "extends" "external" "false" "final" "flow" +// "for" "function" "if" "import" "in" "initial" "inner" "loop" "model" +// "not" "outer" "or" "output" "package" "parameter" "partial" "protected" +// "public" "record" "redeclare" "replaceable" "results" "then" "true" +// "type" "unsigned_real" "when" "while" "within" LPAR RPAR LBRACK RBRACK +// LBRACE RBRACE EQUALS ASSIGN PLUS MINUS STAR SLASH DOT COMMA LESS LESSEQ +// GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER WS ML_COMMENT ML_COMMENT_CHAR +// SL_COMMENT IDENT NONDIGIT DIGIT EXPONENT UNSIGNED_INTEGER STRING SCHAR +// SESCAPE +const ANTLR_USE_NAMESPACE(antlr)BitSet FlatModelicaLexer::_tokenSet_5(_tokenSet_5_data_,16); + diff --git a/tools/xml/flatmodelicaxml/FlatModelicaLexer.hpp b/tools/xml/flatmodelicaxml/FlatModelicaLexer.hpp new file mode 100644 index 00000000000..9ffe4c66cf7 --- /dev/null +++ b/tools/xml/flatmodelicaxml/FlatModelicaLexer.hpp @@ -0,0 +1,87 @@ +#ifndef INC_FlatModelicaLexer_hpp_ +#define INC_FlatModelicaLexer_hpp_ + +#include +/* $ANTLR 2.7.3: "flat_modelica_lexer.g" -> "FlatModelicaLexer.hpp"$ */ +#include +#include +#include +#include "FlatModelicaTokenTypes.hpp" +#include +#line 1 "flat_modelica_lexer.g" + + #ifdef WIN32 + #pragma warning( disable : 4267) // Disable warning messages C4267 + #endif + //disable: 'initializing' : conversion from 'size_t' to 'int', possible loss of data + +#line 19 "FlatModelicaLexer.hpp" +class CUSTOM_API FlatModelicaLexer : public ANTLR_USE_NAMESPACE(antlr)CharScanner, public FlatModelicaTokenTypes +{ +#line 1 "flat_modelica_lexer.g" +#line 23 "FlatModelicaLexer.hpp" +private: + void initLiterals(); +public: + bool getCaseSensitiveLiterals() const + { + return true; + } +public: + FlatModelicaLexer(ANTLR_USE_NAMESPACE(std)istream& in); + FlatModelicaLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib); + FlatModelicaLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state); + ANTLR_USE_NAMESPACE(antlr)RefToken nextToken(); + public: void mLPAR(bool _createToken); + public: void mRPAR(bool _createToken); + public: void mLBRACK(bool _createToken); + public: void mRBRACK(bool _createToken); + public: void mLBRACE(bool _createToken); + public: void mRBRACE(bool _createToken); + public: void mEQUALS(bool _createToken); + public: void mASSIGN(bool _createToken); + public: void mPLUS(bool _createToken); + public: void mMINUS(bool _createToken); + public: void mSTAR(bool _createToken); + public: void mSLASH(bool _createToken); + public: void mDOT(bool _createToken); + public: void mCOMMA(bool _createToken); + public: void mLESS(bool _createToken); + public: void mLESSEQ(bool _createToken); + public: void mGREATER(bool _createToken); + public: void mGREATEREQ(bool _createToken); + public: void mEQEQ(bool _createToken); + public: void mLESSGT(bool _createToken); + public: void mCOLON(bool _createToken); + public: void mSEMICOLON(bool _createToken); + public: void mPOWER(bool _createToken); + public: void mWS(bool _createToken); + public: void mML_COMMENT(bool _createToken); + protected: void mML_COMMENT_CHAR(bool _createToken); + public: void mSL_COMMENT(bool _createToken); + public: void mIDENT(bool _createToken); + protected: void mNONDIGIT(bool _createToken); + protected: void mDIGIT(bool _createToken); + protected: void mEXPONENT(bool _createToken); + public: void mUNSIGNED_INTEGER(bool _createToken); + public: void mSTRING(bool _createToken); + protected: void mSCHAR(bool _createToken); + protected: void mSESCAPE(bool _createToken); + protected: void mESC(bool _createToken); +private: + + static const unsigned long _tokenSet_0_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0; + static const unsigned long _tokenSet_1_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1; + static const unsigned long _tokenSet_2_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2; + static const unsigned long _tokenSet_3_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3; + static const unsigned long _tokenSet_4_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_4; + static const unsigned long _tokenSet_5_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_5; +}; + +#endif /*INC_FlatModelicaLexer_hpp_*/ diff --git a/tools/xml/flatmodelicaxml/FlatModelicaXML.cpp b/tools/xml/flatmodelicaxml/FlatModelicaXML.cpp new file mode 100644 index 00000000000..61692097ea6 --- /dev/null +++ b/tools/xml/flatmodelicaxml/FlatModelicaXML.cpp @@ -0,0 +1,135 @@ +/* Copyright (c)2000 Linköping University Sweden, All Rights Reserved +/* Programming Environments Laboratory +******************************************************************************* + File : "FlatModelicaXML.cpp" + Author : Adrian Pop 2005-05-26 + Description : Antlr Parser caller and XML serializer for Flat Modelica +------------------------------------------------------------------------------- + Source: + Revision: + Author: Adrian Pop + Date: 2004-05-26 +******************************************************************************* +*/ + + +//** HEADERS ************************************************************ + +// standard include files +#include +#include +#include +#include + +// ModelicaParser related include file +// the following header files are automatically generated by the antlr parser (Do not modify them) +#include "Flat_Modelica_Lexer.hpp" +#include "Flat_Modelica_Parser.hpp" +#include "Flat_Modelica_Tree_Parser.hpp" +#include "Flat_Modelica_ParserTokenTypes.hpp" +#include "Flat_Modelica_Tree_ParserTokenTypes.hpp" +#include "parse_tree_dumper.hpp" + +// antlr related include files +#include "antlr/AST.hpp" +#include "antlr/CommonAST.hpp" +#include "antlr/ASTFactory.hpp" +#include "MyAST.h" + + +using namespace std; + +//----------------------------------------------------------------------------- +// func : main function for the modelica optimizer +// author : Adrian Pop 2003-10-25 +// organization : Linköping University Sweden, Programming Environment Laboratory +//----------------------------------------------------------------------------- +// the function accept as argument a flattened modelica file ad will generate as output the corresponding C files +// for the Modelica Simulator +int main( int argc, char* argv[] ) +{ + ifstream file; + //ofstream wfile; + + // check if the modelica file is present in the argument list + if (argc < 2) + { + cerr << "Incorrect number of arguments\n"; + return 1; + } + + //open the file passed as an argument + file.open(argv[1]); + + //if the file cannot be opened + if (!file) + { + cerr << "Could not open file: " << argv[1] << "\n"; + getchar(); + return 2; + } + + try + { + antlr::ASTFactory my_factory("MyAST", MyAST::factory); + flat_modelica_lexer lexer(file); + lexer.setFilename(argv[1]); + flat_modelica_parser parser(lexer); + parser.initializeASTFactory(my_factory); + parser.setASTFactory(&my_factory); + parser.stored_definition(); + //wfile.open("output.txt"); + //wfile << parser.getAST()->toStringList() << std::endl; + antlr::RefAST ast = parser.getAST(); + //parse_tree_dumper dumper(std::cout); + std::cout << std::flush; + if (ast) + { + //dumper.dump(ast); + flat_modelica_tree_parser walker; + walker.initializeASTFactory(my_factory); + walker.setASTFactory(&my_factory); + std::string xmlFile(argv[1]); + /* + http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.dtd + c:\\dev\\src\\modelicaxml\\modelicaxml-v2.dtd + */ + // set the doctype + std::string docType( + (argc > 2)?argv[2]:"http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.dtd"); + xmlFile += ".xml"; + walker.stored_definition( + RefMyAST(ast), + xmlFile, + argv[1], + docType); + } + else + { + //wfile << std::endl << "Parse error: AST\n"; + std::cerr << std::endl << "Parse error: AST\n"; + } + } + catch(antlr::ANTLRException& e) + { + std::cerr << "Parser/Lexer/Walker Exception: " << e.toString() << std::endl; + file.close(); + std::cerr << "ERROR! File:" << argv[1] << std::endl; + getchar(); + return EXIT_FAILURE; + } + catch(std::exception& e) + { + std::cerr << "Exception: " << e.what() << std::endl; + file.close(); + std::cerr << "ERROR! File:" << argv[1] << std::endl; + getchar(); + return EXIT_FAILURE; + } + + file.close(); + std::cout << "SUCCESS! File:" << argv[1] << std::endl; + //wfile << std::endl << "SUCCESS! File:" << argv[1] << std::endl; + //wfile.close(); + return EXIT_SUCCESS; +} \ No newline at end of file diff --git a/tools/xml/flatmodelicaxml/FlatModelicaXML.vcproj b/tools/xml/flatmodelicaxml/FlatModelicaXML.vcproj new file mode 100644 index 00000000000..45f60650cd5 --- /dev/null +++ b/tools/xml/flatmodelicaxml/FlatModelicaXML.vcproj @@ -0,0 +1,240 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tools/xml/flatmodelicaxml/FlatModelicaXml.h b/tools/xml/flatmodelicaxml/FlatModelicaXml.h new file mode 100644 index 00000000000..23969f0f415 --- /dev/null +++ b/tools/xml/flatmodelicaxml/FlatModelicaXml.h @@ -0,0 +1,67 @@ +/************************************************************************ +File: modelicaxml.h +Created By: Adrian Pop adrpo@ida.liu.se +Date: 2003-08-28 (PELAB Internal Conference) +Revised on 2003-10-26 17:58:42 +Comments: some includes for the xercesc parser and a xml helper class +************************************************************************/ + +#ifndef __FLATMODELICAXML_H_ +#define __FLATMODELICAXML_H_ + +// --------------------------------------------------------------------------- +// Includes +// --------------------------------------------------------------------------- +#include +#include +#include +#include +#include +#include +#include + +XERCES_CPP_NAMESPACE_USE + +// --------------------------------------------------------------------------- +// This is a simple class that lets us do easy (though not terribly efficient) +// trancoding of char* data to XMLCh data. +// --------------------------------------------------------------------------- +class XStr +{ +public : + // ----------------------------------------------------------------------- + // Constructors and Destructor + // ----------------------------------------------------------------------- + XStr(const char* const toTranscode) + { + // Call the private transcoding method + fUnicodeForm = XMLString::transcode(toTranscode); + } + + ~XStr() + { + XMLString::release(&fUnicodeForm); + } + + + // ----------------------------------------------------------------------- + // Getter methods + // ----------------------------------------------------------------------- + const XMLCh* unicodeForm() const + { + return fUnicodeForm; + } + +private : + // ----------------------------------------------------------------------- + // Private data members + // + // fUnicodeForm + // This is the Unicode XMLCh format of the string. + // ----------------------------------------------------------------------- + XMLCh* fUnicodeForm; +}; + +#define X(str) XStr(str).unicodeForm() + +#endif /* #ifndef _FLATMODELICAXML_ */ \ No newline at end of file diff --git a/tools/xml/flatmodelicaxml/Makefile b/tools/xml/flatmodelicaxml/Makefile new file mode 100644 index 00000000000..f74b36a1d2a --- /dev/null +++ b/tools/xml/flatmodelicaxml/Makefile @@ -0,0 +1,71 @@ +CXX=g++ +JAVA=java + +ANTLRFLAGS = +ANTLR_HOME = /home/pelab/pub/pkg/antlr-2.7.1 +ANTLR_CP= $(ANTLR_HOME)/classes/jdk13 + +ANTLR_INCP = -I$(ANTLR_HOME)/lib/cpp +ANTLR_LIBP = -L$(ANTLR_HOME)/lib/cpp/gcc-2.95.2/lib + +PARSE_HOME = .. +PARSE_INCP = -I$(PARSE_HOME)/src +PARSE_LIBP = -L$(PARSE_HOME)/src + +INCP = $(ANTLR_INCP) $(PARSE_INCP) +LIBP = $(ANTLR_LIBP) $(PARSE_LIBP) + +CFLAGS = $(INCP) -g -Wall +CXXFLAGS = $(CFLAGS) + +LIBS = -lantlr + +ANTLR = $(JAVA) -cp $(ANTLR_CP) antlr.Tool + +all : cpp modSimPackTest + +tmp : walker modSimPackTest + +test : modSimPackTest + +modSimPackTest : flat_modelica_lexer.o flat_modelica_parser.o \ + flat_modelica_tree_parser.o parse_tree_dumper.o + $(CXX) $(CXXFLAGS) -o modSimPackTest modSimPackTest.cc $(LIBP) \ + flat_modelica_lexer.o flat_modelica_parser.o flat_modelica_tree_parser.o \ + parse_tree_dumper.o $(LIBS) + +cpp : lexer parser walker + +lexer: flat_modelica_lexer.g + $(ANTLR) flat_modelica_lexer.g $(ANTLRFLAGS) + +parser: flat_modelica_parser.g + $(ANTLR) flat_modelica_parser.g $(ANTLRFLAGS) + +walker: walker.g + $(ANTLR) walker.g $(ANTLRFLAGS) + + +flat_modelica_parserTokenTypes.txt: + +flat_modelica_lexer.o : flat_modelica_lexer.cpp flat_modelica_lexer.hpp + $(CXX) $(CXXFLAGS) -c flat_modelica_lexer.cpp + +flat_modelica_parser.o : flat_modelica_parser.cpp flat_modelica_lexer.hpp \ + flat_modelica_parser.hpp flat_modelica_parserTokenTypes.txt + $(CXX) $(CXXFLAGS) -c flat_modelica_parser.cpp + +flat_modelica_tree_parser.o : flat_modelica_tree_parser.cpp flat_modelica_lexer.hpp \ + flat_modelica_parser.hpp + $(CXX) $(CXXFLAGS) -c flat_modelica_tree_parser.cpp + +parse_tree_dumper.o : parse_tree_dumper.cpp parse_tree_dumper.hpp + $(CXX) $(CXXFLAGS) -c parse_tree_dumper.cpp + + +clean: + -rm -f *.o *~ core *.core absyn_builder.a + -rm -f $(walkergen) flat_modelica_parserTokenTypes.txt + +reallyclean: clean + -rm -r *.hpp *.cpp diff --git a/tools/xml/flatmodelicaxml/ModelicaXMLUtilities.cpp b/tools/xml/flatmodelicaxml/ModelicaXMLUtilities.cpp new file mode 100644 index 00000000000..dbd64c21f54 --- /dev/null +++ b/tools/xml/flatmodelicaxml/ModelicaXMLUtilities.cpp @@ -0,0 +1,49 @@ +#include "ModelicaXMLUtilities.hpp" + +indentation::indentation() : m_indent_next(false),m_space_before(false) +{ +} + +void indentation::push(int element) +{ + m_indent.push(element); +} + +int indentation::top() +{ + if (!m_indent.empty()) + return m_indent.top(); + else + return 0; +} + +void indentation::pop() +{ + if (m_indent.size() > 1) + m_indent.pop(); +} + +void indentation::indent_next(bool f) +{ + m_indent_next = f; +} + +bool indentation::indent_next() +{ + return m_indent_next; +} + +void indentation::init() +{ + m_indent.push(0); +} + +void indentation::space_before(bool f) +{ + m_space_before = f; +} + +bool indentation::spacebefore() +{ + return m_space_before; +} diff --git a/tools/xml/flatmodelicaxml/ModelicaXMLUtilities.hpp b/tools/xml/flatmodelicaxml/ModelicaXMLUtilities.hpp new file mode 100644 index 00000000000..5113cb68c64 --- /dev/null +++ b/tools/xml/flatmodelicaxml/ModelicaXMLUtilities.hpp @@ -0,0 +1,32 @@ +#ifndef INDENTATION_HPP_ +#define INDENTATION_HPP_ + +#include +#include + +using namespace std ; + + +class indentation +{ +public: + indentation(); + + void push(int element); + int top(); + void pop(); + + void indent_next(bool f); + bool indent_next(); + void init(); + void space_before(bool f); + bool spacebefore(); + +private: + std::stack m_indent; + bool m_indent_next; + bool m_space_before; +}; + + +#endif diff --git a/tools/xml/flatmodelicaxml/MyAST.h b/tools/xml/flatmodelicaxml/MyAST.h new file mode 100644 index 00000000000..560b5004dd1 --- /dev/null +++ b/tools/xml/flatmodelicaxml/MyAST.h @@ -0,0 +1,113 @@ +#ifndef __MY_AST_H__ +# define __MY_AST_H__ + +#include + +class MyAST; + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; + +/** Custom AST class that adds line numbers to the AST nodes. + * easily extended with columns. Filenames will take more work since + * you'll need a custom token class as well (one that contains the + * filename) + */ +class MyAST : public ANTLR_USE_NAMESPACE(antlr)CommonAST { +public: + // copy constructor + MyAST( const MyAST& other ) + : CommonAST(other) + , line(other.line), column(other.column) + { + } + // Default constructor + MyAST( void ) : CommonAST(), line(0), column(0) {} + virtual ~MyAST( void ) {} + + // get the line number of the node (or try to derive it from the child node + virtual int getLine( void ) const + { + // most of the time the line number is not set if the node is a + // imaginary one. Usually this means it has a child. Refer to the + // child line number. Of course this could be extended a bit. + if ( line != 0 ) + return line; + if( getFirstChild() ) + return ( RefMyAST(getFirstChild())->getLine() ); + return 0; + } + + + virtual void setLine( int l ) + { + line = l; + } + + // get the line number of the node (or try to derive it from the child node + virtual int getColumn( void ) const + { + // most of the time the line number is not set if the node is a + // imaginary one. Usually this means it has a child. Refer to the + // child line number. Of course this could be extended a bit. + if ( column != 0 ) + return column; + if( getFirstChild() ) + return ( RefMyAST(getFirstChild())->getColumn() ); + return 0; + } + + virtual void setColumn( int c ) + { + column = c; + } + + /** the initialize methods are called by the tree building constructs + * depending on which version is called the line number is filled in. + * e.g. a bit depending on how the node is constructed it will have the + * line number filled in or not (imaginary nodes!). + */ + virtual void initialize(int t, const ANTLR_USE_NAMESPACE(std)string& txt) + { + CommonAST::initialize(t,txt); + line = 0; + column = 0; + } + + virtual void initialize( ANTLR_USE_NAMESPACE(antlr)RefToken t ) + { + CommonAST::initialize(t); + line = t->getLine(); + column = t->getColumn(); + } + + virtual void initialize( RefMyAST ast ) + { + CommonAST::initialize(ANTLR_USE_NAMESPACE(antlr)RefAST(ast)); + line = ast->getLine(); + line = ast->getColumn(); + } + // for convenience will also work without + void addChild( RefMyAST c ) + { + BaseAST::addChild( ANTLR_USE_NAMESPACE(antlr)RefAST(c) ); + } + // for convenience will also work without + void setNextSibling( RefMyAST c ) + { + BaseAST::setNextSibling( ANTLR_USE_NAMESPACE(antlr)RefAST(c) ); + } + // provide a clone of the node (no sibling/child pointers are copied) + virtual ANTLR_USE_NAMESPACE(antlr)RefAST clone( void ) + { + return ANTLR_USE_NAMESPACE(antlr)RefAST(new MyAST(*this)); + } + static ANTLR_USE_NAMESPACE(antlr)RefAST factory( void ) + { + return ANTLR_USE_NAMESPACE(antlr)RefAST(RefMyAST(new MyAST())); + } +private: + int line; + int column; +}; + +#endif diff --git a/tools/xml/flatmodelicaxml/flat_modelica_lexer.cpp b/tools/xml/flatmodelicaxml/flat_modelica_lexer.cpp new file mode 100644 index 00000000000..503accb4ebc --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_lexer.cpp @@ -0,0 +1,1710 @@ +/* $ANTLR 2.7.5rc2 (20050108): "flat_modelica_lexer.g" -> "flat_modelica_lexer.cpp"$ */ +#include "flat_modelica_lexer.hpp" +#include +#include +#include +#include +#include +#include +#include + +#line 1 "flat_modelica_lexer.g" +#line 13 "flat_modelica_lexer.cpp" +flat_modelica_lexer::flat_modelica_lexer(ANTLR_USE_NAMESPACE(std)istream& in) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),true) +{ + initLiterals(); +} + +flat_modelica_lexer::flat_modelica_lexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true) +{ + initLiterals(); +} + +flat_modelica_lexer::flat_modelica_lexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,true) +{ + initLiterals(); +} + +void flat_modelica_lexer::initLiterals() +{ + literals["type"] = 53; + literals["constant"] = 12; + literals["relation"] = 67; + literals["public"] = 46; + literals["initial"] = 32; + literals["annotation"] = 6; + literals["while"] = 56; + literals["end"] = 18; + literals["withtype"] = 72; + literals["equation"] = 20; + literals["overload"] = 39; + literals["flow"] = 26; + literals["then"] = 51; + literals["unsigned_real"] = 54; + literals["and"] = 5; + literals["module"] = 65; + literals["outer"] = 38; + literals["not"] = 37; + literals["package"] = 42; + literals["external"] = 23; + literals["replaceable"] = 49; + literals["protected"] = 45; + literals["output"] = 41; + literals["when"] = 55; + literals["class"] = 9; + literals["inner"] = 33; + literals["enumeration"] = 19; + literals["function"] = 28; + literals["each"] = 14; + literals["with"] = 71; + literals["redeclare"] = 48; + literals["model"] = 36; + literals["elseif"] = 16; + literals["parameter"] = 43; + literals["input"] = 34; + literals["interface"] = 64; + literals["of"] = 66; + literals["final"] = 25; + literals["or"] = 40; + literals["if"] = 29; + literals["record"] = 47; + literals["as"] = 59; + literals["connector"] = 11; + literals["connect"] = 10; + literals["results"] = 50; + literals["for"] = 27; + literals["extends"] = 22; + literals["axiom"] = 60; + literals["loop"] = 35; + literals["rule"] = 68; + literals["false"] = 24; + literals["fail"] = 62; + literals["datatype"] = 61; + literals["val"] = 69; + literals["elsewhen"] = 17; + literals["Code"] = 8; + literals["encapsulated"] = 21; + literals["partial"] = 44; + literals["abstype"] = 58; + literals["else"] = 15; + literals["import"] = 30; + literals["discrete"] = 13; + literals["_"] = 70; + literals["in"] = 31; + literals["let"] = 63; + literals["block"] = 7; + literals["true"] = 52; + literals["within"] = 57; + literals["algorithm"] = 4; +} + +ANTLR_USE_NAMESPACE(antlr)RefToken flat_modelica_lexer::nextToken() +{ + ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken; + for (;;) { + ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken; + int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE; + resetText(); + try { // for lexical and char stream error handling + switch ( LA(1)) { + case 0x28 /* '(' */ : + { + mLPAR(true); + theRetToken=_returnToken; + break; + } + case 0x29 /* ')' */ : + { + mRPAR(true); + theRetToken=_returnToken; + break; + } + case 0x5b /* '[' */ : + { + mLBRACK(true); + theRetToken=_returnToken; + break; + } + case 0x5d /* ']' */ : + { + mRBRACK(true); + theRetToken=_returnToken; + break; + } + case 0x7b /* '{' */ : + { + mLBRACE(true); + theRetToken=_returnToken; + break; + } + case 0x7d /* '}' */ : + { + mRBRACE(true); + theRetToken=_returnToken; + break; + } + case 0x2b /* '+' */ : + { + mPLUS(true); + theRetToken=_returnToken; + break; + } + case 0x2a /* '*' */ : + { + mSTAR(true); + theRetToken=_returnToken; + break; + } + case 0x2e /* '.' */ : + { + mDOT(true); + theRetToken=_returnToken; + break; + } + case 0x2c /* ',' */ : + { + mCOMMA(true); + theRetToken=_returnToken; + break; + } + case 0x3b /* ';' */ : + { + mSEMICOLON(true); + theRetToken=_returnToken; + break; + } + case 0x5e /* '^' */ : + { + mPOWER(true); + theRetToken=_returnToken; + break; + } + case 0x26 /* '&' */ : + { + mAMPERSAND(true); + theRetToken=_returnToken; + break; + } + case 0x7c /* '|' */ : + { + mPIPEBAR(true); + theRetToken=_returnToken; + break; + } + case 0x9 /* '\t' */ : + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + case 0x20 /* ' ' */ : + { + mWS(true); + theRetToken=_returnToken; + break; + } + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + case 0x5f /* '_' */ : + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + mIDENT(true); + theRetToken=_returnToken; + break; + } + case 0x27 /* '\'' */ : + { + mTYVARIDENT(true); + theRetToken=_returnToken; + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + mUNSIGNED_INTEGER(true); + theRetToken=_returnToken; + break; + } + case 0x22 /* '\"' */ : + { + mSTRING(true); + theRetToken=_returnToken; + break; + } + default: + if ((LA(1) == 0x3a /* ':' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mASSIGN(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mLESSEQ(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mGREATEREQ(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mEQEQ(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3e /* '>' */ )) { + mLESSGT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3e /* '>' */ )) { + mYIELDS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3a /* ':' */ ) && (LA(2) == 0x3a /* ':' */ )) { + mCOLONCOLON(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2d /* '-' */ ) && (LA(2) == 0x2d /* '-' */ )) { + mDASHES(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) { + mML_COMMENT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) { + mSL_COMMENT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (true)) { + mEQUALS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2d /* '-' */ ) && (true)) { + mMINUS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (true)) { + mSLASH(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (true)) { + mLESS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3e /* '>' */ ) && (true)) { + mGREATER(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3a /* ':' */ ) && (true)) { + mCOLON(true); + theRetToken=_returnToken; + } + else { + if (LA(1)==EOF_CHAR) + { + uponEOF(); + _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + } + else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + } + if ( !_returnToken ) + goto tryAgain; // found SKIP token + + _ttype = _returnToken->getType(); + _returnToken->setType(_ttype); + return _returnToken; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) { + throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e); + } + catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) { + throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io); + } + catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) { + throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage()); + } +tryAgain:; + } +} + +void flat_modelica_lexer::mLPAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LPAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('(' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mRPAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = RPAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(')' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mLBRACK(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LBRACK; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('[' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mRBRACK(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = RBRACK; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(']' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mLBRACE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LBRACE; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('{' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mRBRACE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = RBRACE; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('}' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mEQUALS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = EQUALS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('=' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mASSIGN(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ASSIGN; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(":="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mPLUS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = PLUS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('+' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mMINUS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = MINUS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('-' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mSTAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = STAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('*' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mSLASH(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SLASH; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('/' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mDOT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = DOT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('.' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mCOMMA(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = COMMA; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(',' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mLESS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LESS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('<' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mLESSEQ(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LESSEQ; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("<="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mGREATER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = GREATER; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('>' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mGREATEREQ(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = GREATEREQ; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(">="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mEQEQ(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = EQEQ; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("=="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mLESSGT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LESSGT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("<>"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mCOLON(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = COLON; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(':' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mSEMICOLON(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SEMICOLON; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(';' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mPOWER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = POWER; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('^' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mYIELDS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = YIELDS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("=>"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mAMPERSAND(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = AMPERSAND; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("&"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mPIPEBAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = PIPEBAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("|"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mCOLONCOLON(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = COLONCOLON; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("::"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mDASHES(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = DASHES; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('-' /* charlit */ ); + match('-' /* charlit */ ); + match('-' /* charlit */ ); + { // ( ... )* + for (;;) { + if ((LA(1) == 0x2d /* '-' */ )) { + match('-' /* charlit */ ); + } + else { + goto _loop30; + } + + } + _loop30:; + } // ( ... )* + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mWS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = WS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + { + switch ( LA(1)) { + case 0x20 /* ' ' */ : + { + match(' ' /* charlit */ ); + break; + } + case 0x9 /* '\t' */ : + { + match('\t' /* charlit */ ); + break; + } + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + { + { + if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) { + match("\r\n"); + } + else if ((LA(1) == 0xd /* '\r' */ ) && (true)) { + match('\r' /* charlit */ ); + } + else if ((LA(1) == 0xa /* '\n' */ )) { + match('\n' /* charlit */ ); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + } + if ( inputState->guessing==0 ) { +#line 143 "flat_modelica_lexer.g" + newline(); +#line 830 "flat_modelica_lexer.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( inputState->guessing==0 ) { +#line 145 "flat_modelica_lexer.g" + _ttype = antlr::Token::SKIP; +#line 843 "flat_modelica_lexer.cpp" + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mML_COMMENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ML_COMMENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("/*"); + { // ( ... )* + for (;;) { + if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */ && LA(2) <= 0xff)))&&(LA(2)!='/')) { + match('*' /* charlit */ ); + } + else if ((_tokenSet_0.member(LA(1)))) { + mML_COMMENT_CHAR(false); + } + else { + goto _loop36; + } + + } + _loop36:; + } // ( ... )* + match("*/"); + if ( inputState->guessing==0 ) { +#line 152 "flat_modelica_lexer.g" + _ttype = antlr::Token::SKIP; +#line 878 "flat_modelica_lexer.cpp" + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mML_COMMENT_CHAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ML_COMMENT_CHAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + if ((LA(1) == 0xa /* '\n' */ || LA(1) == 0xd /* '\r' */ )) { + { + switch ( LA(1)) { + case 0xd /* '\r' */ : + { + match("\r\n"); + break; + } + case 0xa /* '\n' */ : + { + match('\n' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( inputState->guessing==0 ) { +#line 156 "flat_modelica_lexer.g" + newline(); +#line 915 "flat_modelica_lexer.cpp" + } + } + else if ((_tokenSet_1.member(LA(1)))) { + { + match(_tokenSet_1); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mSL_COMMENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SL_COMMENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("//"); + { // ( ... )* + for (;;) { + if ((_tokenSet_2.member(LA(1)))) { + { + match(_tokenSet_2); + } + } + else { + goto _loop43; + } + + } + _loop43:; + } // ( ... )* + if ( inputState->guessing==0 ) { +#line 162 "flat_modelica_lexer.g" + _ttype = antlr::Token::SKIP; +#line 958 "flat_modelica_lexer.cpp" + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mIDENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = IDENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + mNONDIGIT(false); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + case 0x5f /* '_' */ : + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + mNONDIGIT(false); + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + mDIGIT(false); + break; + } + case 0x2e /* '.' */ : + { + mDOT(false); + break; + } + default: + { + goto _loop46; + } + } + } + _loop46:; + } // ( ... )* + if ( inputState->guessing==0 ) { +#line 167 "flat_modelica_lexer.g" + + std::string tmp=text.substr(_begin,text.length()-_begin); + { text.erase(_begin); text += replaceAll(tmp, + ".", + "_"); }; + +#line 1069 "flat_modelica_lexer.cpp" + } + _ttype = testLiteralsTable(_ttype); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mNONDIGIT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = NONDIGIT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + { + switch ( LA(1)) { + case 0x5f /* '_' */ : + { + match('_' /* charlit */ ); + break; + } + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + matchRange('a','z'); + break; + } + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + { + matchRange('A','Z'); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mDIGIT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = DIGIT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + matchRange('0','9'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mTYVARIDENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = TYVARIDENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('\'' /* charlit */ ); + mNONDIGIT(false); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + case 0x5f /* '_' */ : + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + mNONDIGIT(false); + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + mDIGIT(false); + break; + } + default: + { + goto _loop49; + } + } + } + _loop49:; + } // ( ... )* + _ttype = testLiteralsTable(_ttype); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mEXPONENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = EXPONENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + { + switch ( LA(1)) { + case 0x65 /* 'e' */ : + { + match('e' /* charlit */ ); + break; + } + case 0x45 /* 'E' */ : + { + match('E' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { + switch ( LA(1)) { + case 0x2b /* '+' */ : + { + match('+' /* charlit */ ); + break; + } + case 0x2d /* '-' */ : + { + match('-' /* charlit */ ); + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { // ( ... )+ + int _cnt57=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt57>=1 ) { goto _loop57; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt57++; + } + _loop57:; + } // ( ... )+ + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mUNSIGNED_INTEGER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = UNSIGNED_INTEGER; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + { + bool synPredMatched63 = false; + if ((((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_3.member(LA(2))))) { + int _m63 = mark(); + synPredMatched63 = true; + inputState->guessing++; + try { + { + { // ( ... )+ + int _cnt62=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt62>=1 ) { goto _loop62; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt62++; + } + _loop62:; + } // ( ... )+ + match('.' /* charlit */ ); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched63 = false; + } + rewind(_m63); + inputState->guessing--; + } + if ( synPredMatched63 ) { + { // ( ... )+ + int _cnt65=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt65>=1 ) { goto _loop65; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt65++; + } + _loop65:; + } // ( ... )+ + { + match('.' /* charlit */ ); + { // ( ... )* + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + goto _loop68; + } + + } + _loop68:; + } // ( ... )* + } + if ( inputState->guessing==0 ) { +#line 196 "flat_modelica_lexer.g" + + _ttype = UNSIGNED_REAL; + +#line 1425 "flat_modelica_lexer.cpp" + } + } + else if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ )) && (true)) { + { // ( ... )+ + int _cnt70=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt70>=1 ) { goto _loop70; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt70++; + } + _loop70:; + } // ( ... )+ + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + } + { + if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) { + mEXPONENT(false); + if ( inputState->guessing==0 ) { +#line 201 "flat_modelica_lexer.g" + _ttype = UNSIGNED_REAL; +#line 1455 "flat_modelica_lexer.cpp" + } + } + else { + } + + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mSTRING(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = STRING; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + _saveIndex = text.length(); + match('\"' /* charlit */ ); + text.erase(_saveIndex); + { // ( ... )* + for (;;) { + if ((_tokenSet_4.member(LA(1)))) { + mSCHAR(false); + } + else if ((LA(1) == 0x5c /* '\\' */ )) { + mSESCAPE(false); + } + else { + goto _loop74; + } + + } + _loop74:; + } // ( ... )* + _saveIndex = text.length(); + match('\"' /* charlit */ ); + text.erase(_saveIndex); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mSCHAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SCHAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + switch ( LA(1)) { + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + { + { + { + switch ( LA(1)) { + case 0xa /* '\n' */ : + { + match('\n' /* charlit */ ); + break; + } + case 0xd /* '\r' */ : + { + match("\r\n"); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + } + if ( inputState->guessing==0 ) { +#line 208 "flat_modelica_lexer.g" + newline(); +#line 1536 "flat_modelica_lexer.cpp" + } + break; + } + case 0x9 /* '\t' */ : + { + match('\t' /* charlit */ ); + break; + } + default: + if ((_tokenSet_5.member(LA(1)))) { + { + match(_tokenSet_5); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mSESCAPE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SESCAPE; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('\\' /* charlit */ ); + { + switch ( LA(1)) { + case 0x5c /* '\\' */ : + { + match('\\' /* charlit */ ); + break; + } + case 0x22 /* '\"' */ : + { + match('\"' /* charlit */ ); + break; + } + case 0x27 /* '\'' */ : + { + match("\'"); + break; + } + case 0x3f /* '?' */ : + { + match('?' /* charlit */ ); + break; + } + case 0x61 /* 'a' */ : + { + match('a' /* charlit */ ); + break; + } + case 0x62 /* 'b' */ : + { + match('b' /* charlit */ ); + break; + } + case 0x66 /* 'f' */ : + { + match('f' /* charlit */ ); + break; + } + case 0x6e /* 'n' */ : + { + match('n' /* charlit */ ); + break; + } + case 0x72 /* 'r' */ : + { + match('r' /* charlit */ ); + break; + } + case 0x74 /* 't' */ : + { + match('t' /* charlit */ ); + break; + } + case 0x76 /* 'v' */ : + { + match('v' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void flat_modelica_lexer::mESC(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ESC; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('\\' /* charlit */ ); + { + switch ( LA(1)) { + case 0x22 /* '\"' */ : + { + match('\"' /* charlit */ ); + break; + } + case 0x5c /* '\\' */ : + { + match('\\' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + + +const unsigned long flat_modelica_lexer::_tokenSet_0_data_[] = { 4294967288UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13 +// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # +// $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F +// G H I J K L M N O P Q R S T U V W X Y Z [ \\ ] ^ _ ` a b c d e f g h +// i j k l m n o p q r +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_lexer::_tokenSet_0(_tokenSet_0_data_,16); +const unsigned long flat_modelica_lexer::_tokenSet_1_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14 +// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # $ % +// & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H +// I J K L M N O P Q R S T U V W X Y Z [ \\ ] ^ _ ` a b c d e f g h i j +// k l m n o p q r +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_lexer::_tokenSet_1(_tokenSet_1_data_,16); +const unsigned long flat_modelica_lexer::_tokenSet_2_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14 +// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # $ % +// & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G +// H I J K L M N O P Q R S T U V W X Y Z [ \\ ] ^ _ ` a b c d e f g h i +// j k l m n o p q r +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_lexer::_tokenSet_2(_tokenSet_2_data_,16); +const unsigned long flat_modelica_lexer::_tokenSet_3_data_[] = { 0UL, 67059712UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// . 0 1 2 3 4 5 6 7 8 9 +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_lexer::_tokenSet_3(_tokenSet_3_data_,10); +const unsigned long flat_modelica_lexer::_tokenSet_4_data_[] = { 4294967288UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13 +// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! # $ +// % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F +// G H I J K L M N O P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f g h i +// j k l m n o p q r +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_lexer::_tokenSet_4(_tokenSet_4_data_,16); +const unsigned long flat_modelica_lexer::_tokenSet_5_data_[] = { 4294957560UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14 0x15 +// 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! # $ % & \' ( ) +// * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K +// L M N O P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f g h i j k l m n +// o p q r +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_lexer::_tokenSet_5(_tokenSet_5_data_,16); + diff --git a/tools/xml/flatmodelicaxml/flat_modelica_lexer.g b/tools/xml/flatmodelicaxml/flat_modelica_lexer.g new file mode 100644 index 00000000000..a56c98e6b89 --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_lexer.g @@ -0,0 +1,227 @@ +header { + +} + +options { + language = "Cpp"; +} + +class flat_modelica_lexer extends Lexer; + +options { + k=2; + charVocabulary = '\3'..'\377'; + exportVocab = flatmodelica; + testLiterals = false; + defaultErrorHandler = false; +} + +tokens { + ALGORITHM = "algorithm" ; + AND = "and" ; + ANNOTATION = "annotation" ; + BLOCK = "block" ; + CODE = "Code" ; + CLASS = "class" ; + CONNECT = "connect" ; + CONNECTOR = "connector" ; + CONSTANT = "constant" ; + DISCRETE = "discrete" ; + EACH = "each" ; + ELSE = "else" ; + ELSEIF = "elseif" ; + ELSEWHEN = "elsewhen" ; + END = "end" ; + ENUMERATION = "enumeration" ; + EQUATION = "equation" ; + ENCAPSULATED = "encapsulated"; + EXTENDS = "extends" ; + EXTERNAL = "external" ; + FALSE = "false" ; + FINAL = "final" ; + FLOW = "flow" ; + FOR = "for" ; + FUNCTION = "function" ; + IF = "if" ; + IMPORT = "import" ; + IN = "in" ; + INITIAL = "initial" ; + INNER = "inner" ; + INPUT = "input" ; + LOOP = "loop" ; + MODEL = "model" ; + NOT = "not" ; + OUTER = "outer" ; + OVERLOAD = "overload"; + OR = "or" ; + OUTPUT = "output" ; + PACKAGE = "package" ; + PARAMETER = "parameter" ; + PARTIAL = "partial" ; + PROTECTED = "protected" ; + PUBLIC = "public" ; + RECORD = "record" ; + REDECLARE = "redeclare" ; + REPLACEABLE = "replaceable" ; + RESULTS = "results" ; + THEN = "then" ; + TRUE = "true" ; + TYPE = "type" ; + UNSIGNED_REAL = "unsigned_real"; + WHEN = "when" ; + WHILE = "while" ; + WITHIN = "within" ; + +// SUM = "sum" ; +// ARRAY = "array"; + +// Extra tokens for RML + ABSTYPE = "abstype"; +// AND = "and"; + AS = "as"; + AXIOM = "axiom"; + DATATYPE = "datatype"; + FAIL = "fail"; + LET = "let"; + INTERFACE = "interface"; + MODULE = "module"; + OF = "of"; + RELATION = "relation"; + RULE = "rule"; + VAL = "val"; + WILD = "_"; + WITH = "with"; + WITHTYPE = "withtype"; +} +{ + std::string & replaceAll(std::string & str, const char *src, const char* dst) + { + size_t pos; + while((pos = str.find(".")) < str.size()-1) { + str.replace(pos,1,"_"); + } + return str; + } +} +// --------- +// Operators +// --------- + +LPAR : '(' ; +RPAR : ')' ; +LBRACK : '[' ; +RBRACK : ']' ; +LBRACE : '{' ; +RBRACE : '}' ; +EQUALS : '=' ; +ASSIGN : ":=" ; +PLUS : '+' ; +MINUS : '-' ; +STAR : '*' ; +SLASH : '/' ; +DOT : '.' ; +COMMA : ',' ; +LESS : '<' ; +LESSEQ : "<=" ; +GREATER : '>' ; +GREATEREQ : ">=" ; +EQEQ : "==" ; +LESSGT : "<>" ; +COLON : ':' ; +SEMICOLON : ';' ; +POWER : '^' ; +YIELDS : "=>" ; +AMPERSAND : "&" ; +PIPEBAR : "|" ; +COLONCOLON : "::" ; +DASHES : '-' '-' '-' ( '-' )* ; + + +WS : + ( ' ' + | '\t' + | ( "\r\n" | '\r' | '\n' ) { newline(); } + ) + { $setType(antlr::Token::SKIP); } + ; + +ML_COMMENT : + "/*" + (options { generateAmbigWarnings=false; } : ML_COMMENT_CHAR + | {LA(2)!='/'}? '*')* + "*/" { $setType(antlr::Token::SKIP); } ; + +protected +ML_COMMENT_CHAR : + ("\r\n" | '\n') { newline(); } + | ~('*'|'\n'|'\r') + ; + +SL_COMMENT : + "//" (~('\n' | '\r') )* + { $setType(antlr::Token::SKIP); } + ; + +IDENT options { testLiterals = true; paraphrase = "an identifier";} : + NONDIGIT (NONDIGIT | DIGIT | DOT )* + { + std::string tmp=$getText; + $setText(replaceAll(tmp, + ".", + "_")); + } + + ; + +TYVARIDENT options { testLiterals = true; paraphrase = "a type identifier";} : + '\'' NONDIGIT (NONDIGIT | DIGIT)* + ; + +protected +NONDIGIT : ('_' | 'a'..'z' | 'A'..'Z'); + +protected +DIGIT : + '0'..'9' + ; + +protected +EXPONENT : + ('e'|'E') ('+' | '-')? (DIGIT)+ + ; + + +UNSIGNED_INTEGER : + (( (DIGIT)+ '.' ) => (DIGIT)+ ( '.' (DIGIT)* ) + { + $setType(UNSIGNED_REAL); + } + | (DIGIT)+ + ) + (EXPONENT { $setType(UNSIGNED_REAL); } )? + ; + +STRING : '"'! (SCHAR | SESCAPE)* '"'!; + + +protected +SCHAR : (options { generateAmbigWarnings=false; } : ('\n' | "\r\n")) { newline(); } + | '\t' + | ~('\n' | '\t' | '\r' | '\\' | '"'); + +protected +SESCAPE : '\\' ('\\' | '"' | "'" | '?' | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v'); + + +protected +ESC : + '\\' + ( '"' + | '\\' + ) + ; + + + + + diff --git a/tools/xml/flatmodelicaxml/flat_modelica_lexer.hpp b/tools/xml/flatmodelicaxml/flat_modelica_lexer.hpp new file mode 100644 index 00000000000..cedd25fc8d2 --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_lexer.hpp @@ -0,0 +1,99 @@ +#ifndef INC_flat_modelica_lexer_hpp_ +#define INC_flat_modelica_lexer_hpp_ + +#include +/* $ANTLR 2.7.5rc2 (20050108): "flat_modelica_lexer.g" -> "flat_modelica_lexer.hpp"$ */ +#include +#include +#include +#include "flatmodelicaTokenTypes.hpp" +#include +#line 1 "flat_modelica_lexer.g" + + + +#line 16 "flat_modelica_lexer.hpp" +class CUSTOM_API flat_modelica_lexer : public ANTLR_USE_NAMESPACE(antlr)CharScanner, public flatmodelicaTokenTypes +{ +#line 96 "flat_modelica_lexer.g" + + std::string & replaceAll(std::string & str, const char *src, const char* dst) + { + size_t pos; + while((pos = str.find(".")) < str.size()-1) { + str.replace(pos,1,"_"); + } + return str; + } +#line 20 "flat_modelica_lexer.hpp" +private: + void initLiterals(); +public: + bool getCaseSensitiveLiterals() const + { + return true; + } +public: + flat_modelica_lexer(ANTLR_USE_NAMESPACE(std)istream& in); + flat_modelica_lexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib); + flat_modelica_lexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state); + ANTLR_USE_NAMESPACE(antlr)RefToken nextToken(); + public: void mLPAR(bool _createToken); + public: void mRPAR(bool _createToken); + public: void mLBRACK(bool _createToken); + public: void mRBRACK(bool _createToken); + public: void mLBRACE(bool _createToken); + public: void mRBRACE(bool _createToken); + public: void mEQUALS(bool _createToken); + public: void mASSIGN(bool _createToken); + public: void mPLUS(bool _createToken); + public: void mMINUS(bool _createToken); + public: void mSTAR(bool _createToken); + public: void mSLASH(bool _createToken); + public: void mDOT(bool _createToken); + public: void mCOMMA(bool _createToken); + public: void mLESS(bool _createToken); + public: void mLESSEQ(bool _createToken); + public: void mGREATER(bool _createToken); + public: void mGREATEREQ(bool _createToken); + public: void mEQEQ(bool _createToken); + public: void mLESSGT(bool _createToken); + public: void mCOLON(bool _createToken); + public: void mSEMICOLON(bool _createToken); + public: void mPOWER(bool _createToken); + public: void mYIELDS(bool _createToken); + public: void mAMPERSAND(bool _createToken); + public: void mPIPEBAR(bool _createToken); + public: void mCOLONCOLON(bool _createToken); + public: void mDASHES(bool _createToken); + public: void mWS(bool _createToken); + public: void mML_COMMENT(bool _createToken); + protected: void mML_COMMENT_CHAR(bool _createToken); + public: void mSL_COMMENT(bool _createToken); + public: void mIDENT(bool _createToken); + protected: void mNONDIGIT(bool _createToken); + protected: void mDIGIT(bool _createToken); + public: void mTYVARIDENT(bool _createToken); + protected: void mEXPONENT(bool _createToken); + public: void mUNSIGNED_INTEGER(bool _createToken); + public: void mSTRING(bool _createToken); + protected: void mSCHAR(bool _createToken); + protected: void mSESCAPE(bool _createToken); + protected: void mESC(bool _createToken); +private: + + static const unsigned long _tokenSet_0_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0; + static const unsigned long _tokenSet_1_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1; + static const unsigned long _tokenSet_2_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2; + static const unsigned long _tokenSet_3_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3; + static const unsigned long _tokenSet_4_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_4; + static const unsigned long _tokenSet_5_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_5; +}; + +#endif /*INC_flat_modelica_lexer_hpp_*/ diff --git a/tools/xml/flatmodelicaxml/flat_modelica_parser.cpp b/tools/xml/flatmodelicaxml/flat_modelica_parser.cpp new file mode 100644 index 00000000000..cf6a77a24be --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_parser.cpp @@ -0,0 +1,4166 @@ +/* $ANTLR 2.7.5rc2 (20050108): "flat_modelica_parser.g" -> "flat_modelica_parser.cpp"$ */ +#include "flat_modelica_parser.hpp" +#include +#include +#include +#line 1 "flat_modelica_parser.g" +#line 8 "flat_modelica_parser.cpp" +flat_modelica_parser::flat_modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k) +{ +} + +flat_modelica_parser::flat_modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2) +{ +} + +flat_modelica_parser::flat_modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k) +{ +} + +flat_modelica_parser::flat_modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2) +{ +} + +flat_modelica_parser::flat_modelica_parser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2) +{ +} + +void flat_modelica_parser::stored_definition() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST stored_definition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + class_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + stored_definition_AST = RefMyAST(currentAST.root); +#line 79 "flat_modelica_parser.g" + + stored_definition_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(STORED_DEFINITION,"STORED_DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(stored_definition_AST)))); + +#line 49 "flat_modelica_parser.cpp" + currentAST.root = stored_definition_AST; + if ( stored_definition_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + stored_definition_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = stored_definition_AST->getFirstChild(); + else + currentAST.child = stored_definition_AST; + currentAST.advanceChildToEnd(); + } + stored_definition_AST = RefMyAST(currentAST.root); + returnAST = stored_definition_AST; +} + +void flat_modelica_parser::class_definition() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_definition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + class_type(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + RefMyAST tmp1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp1_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp1_AST)); + } + match(IDENT); + class_specifier(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + class_definition_AST = RefMyAST(currentAST.root); +#line 94 "flat_modelica_parser.g" + + class_definition_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CLASS_DEFINITION,"CLASS_DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(class_definition_AST)))); + +#line 87 "flat_modelica_parser.cpp" + currentAST.root = class_definition_AST; + if ( class_definition_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + class_definition_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = class_definition_AST->getFirstChild(); + else + currentAST.child = class_definition_AST; + currentAST.advanceChildToEnd(); + } + class_definition_AST = RefMyAST(currentAST.root); + returnAST = class_definition_AST; +} + +void flat_modelica_parser::class_type() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_type_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp2_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp2_AST)); + } + match(MODEL); + class_type_AST = RefMyAST(currentAST.root); + returnAST = class_type_AST; +} + +void flat_modelica_parser::class_specifier() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_specifier_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((_tokenSet_0.member(LA(1)))) { + string_comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + composition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + name_path(); + match(SEMICOLON); + { // ( ... )* + for (;;) { + if (((LA(1) >= ALGORITHM && LA(1) <= UNQUALIFIED))) { + matchNot(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + } + else { + goto _loop7; + } + + } + _loop7:; + } // ( ... )* + match(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + } + else if ((LA(1) == EQUALS) && (_tokenSet_1.member(LA(2)))) { + RefMyAST tmp7_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp7_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp7_AST)); + } + match(EQUALS); + base_prefix(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_2.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == LPAR)) { + class_modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_3.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == EQUALS) && (LA(2) == ENUMERATION)) { + RefMyAST tmp8_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp8_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp8_AST)); + } + match(EQUALS); + enumeration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + class_specifier_AST = RefMyAST(currentAST.root); + returnAST = class_specifier_AST; +} + +void flat_modelica_parser::string_comment() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST string_comment_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == STRING)) { + RefMyAST tmp9_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp9_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp9_AST)); + } + match(STRING); + { + bool synPredMatched197 = false; + if (((LA(1) == PLUS))) { + int _m197 = mark(); + synPredMatched197 = true; + inputState->guessing++; + try { + { + match(PLUS); + match(STRING); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched197 = false; + } + rewind(_m197); + inputState->guessing--; + } + if ( synPredMatched197 ) { + { // ( ... )+ + int _cnt199=0; + for (;;) { + if ((LA(1) == PLUS)) { + RefMyAST tmp10_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp10_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp10_AST)); + } + match(PLUS); + RefMyAST tmp11_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp11_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp11_AST)); + } + match(STRING); + } + else { + if ( _cnt199>=1 ) { goto _loop199; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + + _cnt199++; + } + _loop199:; + } // ( ... )+ + } + else if ((_tokenSet_4.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + else if ((_tokenSet_4.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + string_comment_AST = RefMyAST(currentAST.root); +#line 673 "flat_modelica_parser.g" + + if (string_comment_AST) + { + string_comment_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(STRING_COMMENT,"STRING_COMMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(string_comment_AST)))); + } + +#line 298 "flat_modelica_parser.cpp" + currentAST.root = string_comment_AST; + if ( string_comment_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + string_comment_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = string_comment_AST->getFirstChild(); + else + currentAST.child = string_comment_AST; + currentAST.advanceChildToEnd(); + } + string_comment_AST = RefMyAST(currentAST.root); + returnAST = string_comment_AST; +} + +void flat_modelica_parser::composition() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST composition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PUBLIC: + { + public_element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PROTECTED: + { + protected_element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case EQUATION: + { + equation_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ALGORITHM: + { + algorithm_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + if ((LA(1) == INITIAL) && (LA(2) == EQUATION)) { + initial_equation_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == INITIAL) && (LA(2) == ALGORITHM)) { + initial_algorithm_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop21; + } + } + } + _loop21:; + } // ( ... )* + { + if ((LA(1) == EXTERNAL)) { + external_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == END)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + composition_AST = RefMyAST(currentAST.root); + returnAST = composition_AST; +} + +void flat_modelica_parser::name_path() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST name_path_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((LA(1) == IDENT) && (_tokenSet_5.member(LA(2))))&&( LA(2)!=DOT )) { + RefMyAST tmp12_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp12_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp12_AST)); + } + match(IDENT); + name_path_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == IDENT) && (LA(2) == DOT)) { + RefMyAST tmp13_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp13_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp13_AST)); + } + match(IDENT); + RefMyAST tmp14_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp14_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp14_AST)); + } + match(DOT); + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + name_path_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = name_path_AST; +} + +void flat_modelica_parser::base_prefix() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST base_prefix_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + type_prefix(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + base_prefix_AST = RefMyAST(currentAST.root); + returnAST = base_prefix_AST; +} + +void flat_modelica_parser::array_subscripts() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST array_subscripts_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp15_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp15_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp15_AST)); + } + match(LBRACK); + subscript(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + subscript(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop188; + } + + } + _loop188:; + } // ( ... )* + match(RBRACK); + array_subscripts_AST = RefMyAST(currentAST.root); + returnAST = array_subscripts_AST; +} + +void flat_modelica_parser::class_modification() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAR); + { + if ((LA(1) == EACH || LA(1) == IDENT)) { + argument_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(RPAR); + if ( inputState->guessing==0 ) { + class_modification_AST = RefMyAST(currentAST.root); +#line 244 "flat_modelica_parser.g" + + class_modification_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CLASS_MODIFICATION,"CLASS_MODIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(class_modification_AST)))); + +#line 509 "flat_modelica_parser.cpp" + currentAST.root = class_modification_AST; + if ( class_modification_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + class_modification_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = class_modification_AST->getFirstChild(); + else + currentAST.child = class_modification_AST; + currentAST.advanceChildToEnd(); + } + class_modification_AST = RefMyAST(currentAST.root); + returnAST = class_modification_AST; +} + +void flat_modelica_parser::comment() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST comment_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + string_comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_6.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + if ( inputState->guessing==0 ) { + comment_AST = RefMyAST(currentAST.root); +#line 666 "flat_modelica_parser.g" + + comment_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMMENT,"COMMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(comment_AST)))); + +#line 553 "flat_modelica_parser.cpp" + currentAST.root = comment_AST; + if ( comment_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + comment_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = comment_AST->getFirstChild(); + else + currentAST.child = comment_AST; + currentAST.advanceChildToEnd(); + } + comment_AST = RefMyAST(currentAST.root); + returnAST = comment_AST; +} + +void flat_modelica_parser::enumeration() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enumeration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp20_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp20_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST)); + } + match(ENUMERATION); + match(LPAR); + enum_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAR); + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + enumeration_AST = RefMyAST(currentAST.root); + returnAST = enumeration_AST; +} + +void flat_modelica_parser::type_prefix() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST type_prefix_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == FLOW)) { + RefMyAST tmp23_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp23_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST)); + } + match(FLOW); + } + else if ((_tokenSet_7.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + switch ( LA(1)) { + case DISCRETE: + { + RefMyAST tmp24_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp24_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST)); + } + match(DISCRETE); + break; + } + case PARAMETER: + { + RefMyAST tmp25_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp25_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp25_AST)); + } + match(PARAMETER); + break; + } + case CONSTANT: + { + RefMyAST tmp26_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp26_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp26_AST)); + } + match(CONSTANT); + break; + } + case INPUT: + case OUTPUT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case INPUT: + { + RefMyAST tmp27_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp27_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp27_AST)); + } + match(INPUT); + break; + } + case OUTPUT: + { + RefMyAST tmp28_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp28_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST)); + } + match(OUTPUT); + break; + } + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + type_prefix_AST = RefMyAST(currentAST.root); + returnAST = type_prefix_AST; +} + +void flat_modelica_parser::name_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST name_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop13; + } + + } + _loop13:; + } // ( ... )* + name_list_AST = RefMyAST(currentAST.root); + returnAST = name_list_AST; +} + +void flat_modelica_parser::enum_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enum_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + enumeration_literal(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + enumeration_literal(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop17; + } + + } + _loop17:; + } // ( ... )* + enum_list_AST = RefMyAST(currentAST.root); + returnAST = enum_list_AST; +} + +void flat_modelica_parser::enumeration_literal() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enumeration_literal_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp31_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp31_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp31_AST)); + } + match(IDENT); + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + enumeration_literal_AST = RefMyAST(currentAST.root); +#line 128 "flat_modelica_parser.g" + + enumeration_literal_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENUMERATION_LITERAL,"ENUMERATION_LITERAL")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(enumeration_literal_AST)))); + +#line 771 "flat_modelica_parser.cpp" + currentAST.root = enumeration_literal_AST; + if ( enumeration_literal_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + enumeration_literal_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = enumeration_literal_AST->getFirstChild(); + else + currentAST.child = enumeration_literal_AST; + currentAST.advanceChildToEnd(); + } + enumeration_literal_AST = RefMyAST(currentAST.root); + returnAST = enumeration_literal_AST; +} + +void flat_modelica_parser::element_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + if ((_tokenSet_8.member(LA(1)))) { + { + if ((_tokenSet_9.member(LA(1)))) { + element(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(SEMICOLON); + } + else { + goto _loop37; + } + + } + _loop37:; + } // ( ... )* + element_list_AST = RefMyAST(currentAST.root); + returnAST = element_list_AST; +} + +void flat_modelica_parser::public_element_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST public_element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp33_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp33_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp33_AST)); + } + match(PUBLIC); + element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + public_element_list_AST = RefMyAST(currentAST.root); + returnAST = public_element_list_AST; +} + +void flat_modelica_parser::protected_element_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST protected_element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp34_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp34_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp34_AST)); + } + match(PROTECTED); + element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + protected_element_list_AST = RefMyAST(currentAST.root); + returnAST = protected_element_list_AST; +} + +void flat_modelica_parser::initial_equation_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST initial_equation_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ec_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (!( LA(2)==EQUATION)) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" LA(2)==EQUATION"); + match(INITIAL); + equation_clause(); + if (inputState->guessing==0) { + ec_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + initial_equation_clause_AST = RefMyAST(currentAST.root); +#line 281 "flat_modelica_parser.g" + + initial_equation_clause_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INITIAL_EQUATION,"INTIAL_EQUATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(ec_AST)))); + +#line 881 "flat_modelica_parser.cpp" + currentAST.root = initial_equation_clause_AST; + if ( initial_equation_clause_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + initial_equation_clause_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = initial_equation_clause_AST->getFirstChild(); + else + currentAST.child = initial_equation_clause_AST; + currentAST.advanceChildToEnd(); + } + initial_equation_clause_AST = RefMyAST(currentAST.root); + returnAST = initial_equation_clause_AST; +} + +void flat_modelica_parser::initial_algorithm_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST initial_algorithm_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (!( LA(2)==ALGORITHM)) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" LA(2)==ALGORITHM"); + match(INITIAL); + RefMyAST tmp37_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp37_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp37_AST)); + } + match(ALGORITHM); + { // ( ... )* + for (;;) { + if ((_tokenSet_10.member(LA(1)))) { + algorithm(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + goto _loop78; + } + + } + _loop78:; + } // ( ... )* + if ( inputState->guessing==0 ) { + initial_algorithm_clause_AST = RefMyAST(currentAST.root); +#line 311 "flat_modelica_parser.g" + + initial_algorithm_clause_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INITIAL_ALGORITHM,"INTIAL_ALGORITHM")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(initial_algorithm_clause_AST)))); + +#line 937 "flat_modelica_parser.cpp" + currentAST.root = initial_algorithm_clause_AST; + if ( initial_algorithm_clause_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + initial_algorithm_clause_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = initial_algorithm_clause_AST->getFirstChild(); + else + currentAST.child = initial_algorithm_clause_AST; + currentAST.advanceChildToEnd(); + } + initial_algorithm_clause_AST = RefMyAST(currentAST.root); + returnAST = initial_algorithm_clause_AST; +} + +void flat_modelica_parser::equation_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp40_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp40_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp40_AST)); + } + match(EQUATION); + equation_annotation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equation_clause_AST = RefMyAST(currentAST.root); + returnAST = equation_clause_AST; +} + +void flat_modelica_parser::algorithm_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp41_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp41_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp41_AST)); + } + match(ALGORITHM); + { // ( ... )* + for (;;) { + if ((_tokenSet_10.member(LA(1)))) { + algorithm(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + goto _loop75; + } + + } + _loop75:; + } // ( ... )* + algorithm_clause_AST = RefMyAST(currentAST.root); + returnAST = algorithm_clause_AST; +} + +void flat_modelica_parser::external_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST external_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp44_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp44_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp44_AST)); + } + match(EXTERNAL); + { + if ((LA(1) == STRING)) { + language_specification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_11.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == IDENT)) { + external_function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == ANNOTATION || LA(1) == END || LA(1) == SEMICOLON)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == SEMICOLON)) { + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION || LA(1) == END)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == END)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + external_clause_AST = RefMyAST(currentAST.root); + returnAST = external_clause_AST; +} + +void flat_modelica_parser::language_specification() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST language_specification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp47_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp47_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp47_AST)); + } + match(STRING); + language_specification_AST = RefMyAST(currentAST.root); + returnAST = language_specification_AST; +} + +void flat_modelica_parser::external_function_call() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST external_function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == IDENT) && (LA(2) == LBRACK || LA(2) == EQUALS || LA(2) == DOT)) { + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + RefMyAST tmp48_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp48_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp48_AST)); + } + match(EQUALS); + } + else if ((LA(1) == IDENT) && (LA(2) == LPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + RefMyAST tmp49_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp49_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp49_AST)); + } + match(IDENT); + match(LPAR); + { + if ((_tokenSet_12.member(LA(1)))) { + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(RPAR); + if ( inputState->guessing==0 ) { + external_function_call_AST = RefMyAST(currentAST.root); +#line 170 "flat_modelica_parser.g" + + external_function_call_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXTERNAL_FUNCTION_CALL,"EXTERNAL_FUNCTION_CALL")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(external_function_call_AST)))); + +#line 1144 "flat_modelica_parser.cpp" + currentAST.root = external_function_call_AST; + if ( external_function_call_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + external_function_call_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = external_function_call_AST->getFirstChild(); + else + currentAST.child = external_function_call_AST; + currentAST.advanceChildToEnd(); + } + external_function_call_AST = RefMyAST(currentAST.root); + returnAST = external_function_call_AST; +} + +void flat_modelica_parser::annotation() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST annotation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp52_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp52_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp52_AST)); + } + match(ANNOTATION); + class_modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + annotation_AST = RefMyAST(currentAST.root); + returnAST = annotation_AST; +} + +void flat_modelica_parser::component_reference() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_reference_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp53_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp53_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp53_AST)); + } + match(IDENT); + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_13.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == DOT)) { + RefMyAST tmp54_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp54_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp54_AST)); + } + match(DOT); + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_14.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + component_reference_AST = RefMyAST(currentAST.root); + returnAST = component_reference_AST; +} + +void flat_modelica_parser::expression_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + expression_list2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + expression_list_AST = RefMyAST(currentAST.root); +#line 645 "flat_modelica_parser.g" + + expression_list_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXPRESSION_LIST,"EXPRESSION_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(expression_list_AST)))); + +#line 1240 "flat_modelica_parser.cpp" + currentAST.root = expression_list_AST; + if ( expression_list_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + expression_list_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = expression_list_AST->getFirstChild(); + else + currentAST.child = expression_list_AST; + currentAST.advanceChildToEnd(); + } + expression_list_AST = RefMyAST(currentAST.root); + returnAST = expression_list_AST; +} + +void flat_modelica_parser::element() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST cc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == FINAL)) { + RefMyAST tmp55_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp55_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp55_AST)); + } + match(FINAL); + } + else if ((_tokenSet_15.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + switch ( LA(1)) { + case INNER: + { + RefMyAST tmp56_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp56_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp56_AST)); + } + match(INNER); + break; + } + case OUTER: + { + RefMyAST tmp57_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp57_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp57_AST)); + } + match(OUTER); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case MODEL: + case OUTPUT: + case PARAMETER: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + if ((LA(1) == MODEL)) { + class_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_1.member(LA(1)))) { + component_clause(); + if (inputState->guessing==0) { + cc_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + element_AST = RefMyAST(currentAST.root); +#line 184 "flat_modelica_parser.g" + + if(cc_AST != null ) + { + element_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DECLARATION,"DECLARATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(element_AST)))); + } + else + { + element_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DEFINITION,"DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(element_AST)))); + } + +#line 1346 "flat_modelica_parser.cpp" + currentAST.root = element_AST; + if ( element_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + element_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = element_AST->getFirstChild(); + else + currentAST.child = element_AST; + currentAST.advanceChildToEnd(); + } + element_AST = RefMyAST(currentAST.root); + returnAST = element_AST; +} + +void flat_modelica_parser::component_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + type_prefix(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + type_specifier(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == IDENT)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + component_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_clause_AST = RefMyAST(currentAST.root); + returnAST = component_clause_AST; +} + +void flat_modelica_parser::type_specifier() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST type_specifier_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + type_specifier_AST = RefMyAST(currentAST.root); + returnAST = type_specifier_AST; +} + +void flat_modelica_parser::component_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + component_declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + component_declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop51; + } + + } + _loop51:; + } // ( ... )* + component_list_AST = RefMyAST(currentAST.root); + returnAST = component_list_AST; +} + +void flat_modelica_parser::component_declaration() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_declaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_declaration_AST = RefMyAST(currentAST.root); + returnAST = component_declaration_AST; +} + +void flat_modelica_parser::declaration() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST declaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp59_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp59_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp59_AST)); + } + match(IDENT); + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_16.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == LPAR || LA(1) == EQUALS || LA(1) == ASSIGN)) { + modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_17.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + declaration_AST = RefMyAST(currentAST.root); + returnAST = declaration_AST; +} + +void flat_modelica_parser::modification() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LPAR: + { + class_modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == EQUALS)) { + match(EQUALS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_18.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + break; + } + case EQUALS: + { + RefMyAST tmp61_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp61_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp61_AST)); + } + match(EQUALS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ASSIGN: + { + RefMyAST tmp62_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp62_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp62_AST)); + } + match(ASSIGN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + modification_AST = RefMyAST(currentAST.root); + returnAST = modification_AST; +} + +void flat_modelica_parser::expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == IF)) { + if_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_19.member(LA(1)))) { + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + expression_AST = RefMyAST(currentAST.root); + returnAST = expression_AST; +} + +void flat_modelica_parser::argument_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST argument_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + argument(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + argument(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop63; + } + + } + _loop63:; + } // ( ... )* + if ( inputState->guessing==0 ) { + argument_list_AST = RefMyAST(currentAST.root); +#line 252 "flat_modelica_parser.g" + + argument_list_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ARGUMENT_LIST,"ARGUMENT_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(argument_list_AST)))); + +#line 1622 "flat_modelica_parser.cpp" + currentAST.root = argument_list_AST; + if ( argument_list_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + argument_list_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = argument_list_AST->getFirstChild(); + else + currentAST.child = argument_list_AST; + currentAST.advanceChildToEnd(); + } + argument_list_AST = RefMyAST(currentAST.root); + returnAST = argument_list_AST; +} + +void flat_modelica_parser::argument() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST argument_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST em_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + element_modification(); + if (inputState->guessing==0) { + em_AST = returnAST; + } + if ( inputState->guessing==0 ) { + argument_AST = RefMyAST(currentAST.root); +#line 259 "flat_modelica_parser.g" + + argument_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELEMENT_MODIFICATION,"ELEMENT_MODIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(em_AST)))); + +#line 1651 "flat_modelica_parser.cpp" + currentAST.root = argument_AST; + if ( argument_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + argument_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = argument_AST->getFirstChild(); + else + currentAST.child = argument_AST; + currentAST.advanceChildToEnd(); + } + returnAST = argument_AST; +} + +void flat_modelica_parser::element_modification() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == EACH)) { + RefMyAST tmp64_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp64_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp64_AST)); + } + match(EACH); + } + else if ((LA(1) == IDENT)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == LPAR || LA(1) == EQUALS || LA(1) == ASSIGN)) { + modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == COMMA || LA(1) == STRING)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + string_comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + element_modification_AST = RefMyAST(currentAST.root); + returnAST = element_modification_AST; +} + +void flat_modelica_parser::component_clause1() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_clause1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + type_prefix(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + type_specifier(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_clause1_AST = RefMyAST(currentAST.root); + returnAST = component_clause1_AST; +} + +void flat_modelica_parser::equation_annotation_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_annotation_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((_tokenSet_20.member(LA(1))) && (_tokenSet_21.member(LA(2))))&&( LA(1) == END || LA(1) == EQUATION || LA(1) == ALGORITHM || LA(1)==INITIAL + || LA(1) == PROTECTED || LA(1) == PUBLIC )) { + equation_annotation_list_AST = RefMyAST(currentAST.root); + } + else if ((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2)))) { + { + if ((_tokenSet_24.member(LA(1)))) { + equation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + equation_annotation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equation_annotation_list_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = equation_annotation_list_AST; +} + +void flat_modelica_parser::equation() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IF: + { + conditional_equation_e(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR: + { + for_clause_e(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case WHEN: + { + when_clause_e(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + bool synPredMatched82 = false; + if (((_tokenSet_19.member(LA(1))) && (_tokenSet_23.member(LA(2))))) { + int _m82 = mark(); + synPredMatched82 = true; + inputState->guessing++; + try { + { + simple_expression(); + match(EQUALS); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched82 = false; + } + rewind(_m82); + inputState->guessing--; + } + if ( synPredMatched82 ) { + equality_equation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == IDENT) && (LA(2) == LPAR)) { + RefMyAST tmp67_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp67_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp67_AST)); + } + match(IDENT); + function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + equation_AST = RefMyAST(currentAST.root); +#line 323 "flat_modelica_parser.g" + + equation_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EQUATION_STATEMENT,"EQUATION_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(equation_AST)))); + +#line 1852 "flat_modelica_parser.cpp" + currentAST.root = equation_AST; + if ( equation_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + equation_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = equation_AST->getFirstChild(); + else + currentAST.child = equation_AST; + currentAST.advanceChildToEnd(); + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equation_AST = RefMyAST(currentAST.root); + returnAST = equation_AST; +} + +void flat_modelica_parser::algorithm() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IDENT: + { + assign_clause_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case LPAR: + { + multi_assign_clause_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IF: + { + conditional_equation_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR: + { + for_clause_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case WHILE: + { + while_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case WHEN: + { + when_clause_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + algorithm_AST = RefMyAST(currentAST.root); +#line 338 "flat_modelica_parser.g" + + algorithm_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ALGORITHM_STATEMENT,"ALGORITHM_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(algorithm_AST)))); + +#line 1940 "flat_modelica_parser.cpp" + currentAST.root = algorithm_AST; + if ( algorithm_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + algorithm_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = algorithm_AST->getFirstChild(); + else + currentAST.child = algorithm_AST; + currentAST.advanceChildToEnd(); + } + algorithm_AST = RefMyAST(currentAST.root); + returnAST = algorithm_AST; +} + +void flat_modelica_parser::simple_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST simple_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST l1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST l2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST l3_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + logical_expression(); + if (inputState->guessing==0) { + l1_AST = returnAST; + } + { + if ((LA(1) == COLON)) { + RefMyAST tmp68_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp68_AST = astFactory->create(LT(1)); + } + match(COLON); + logical_expression(); + if (inputState->guessing==0) { + l2_AST = returnAST; + } + { + if ((LA(1) == COLON)) { + RefMyAST tmp69_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp69_AST = astFactory->create(LT(1)); + } + match(COLON); + logical_expression(); + if (inputState->guessing==0) { + l3_AST = returnAST; + } + } + else if ((_tokenSet_25.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + else if ((_tokenSet_25.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + simple_expression_AST = RefMyAST(currentAST.root); +#line 467 "flat_modelica_parser.g" + + if (l3_AST != null) + { + simple_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(4))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(RANGE3,"RANGE3")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l1_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l2_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l3_AST)))); + } + else if (l2_AST != null) + { + simple_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(3))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(RANGE2,"RANGE2")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l1_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l2_AST)))); + } + else + { + simple_expression_AST = l1_AST; + } + +#line 2020 "flat_modelica_parser.cpp" + currentAST.root = simple_expression_AST; + if ( simple_expression_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + simple_expression_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = simple_expression_AST->getFirstChild(); + else + currentAST.child = simple_expression_AST; + currentAST.advanceChildToEnd(); + } + returnAST = simple_expression_AST; +} + +void flat_modelica_parser::equality_equation() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equality_equation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + RefMyAST tmp70_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp70_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp70_AST)); + } + match(EQUALS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equality_equation_AST = RefMyAST(currentAST.root); + returnAST = equality_equation_AST; +} + +void flat_modelica_parser::conditional_equation_e() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_equation_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp71_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp71_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp71_AST)); + } + match(IF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEIF)) { + equation_elseif(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop91; + } + + } + _loop91:; + } // ( ... )* + { + if ((LA(1) == ELSE)) { + RefMyAST tmp73_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp73_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp73_AST)); + } + match(ELSE); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == END)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(END); + match(IF); + conditional_equation_e_AST = RefMyAST(currentAST.root); + returnAST = conditional_equation_e_AST; +} + +void flat_modelica_parser::for_clause_e() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_clause_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp76_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp76_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp76_AST)); + } + match(FOR); + for_indices(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(LOOP); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(FOR); + for_clause_e_AST = RefMyAST(currentAST.root); + returnAST = for_clause_e_AST; +} + +void flat_modelica_parser::when_clause_e() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST when_clause_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp80_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp80_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp80_AST)); + } + match(WHEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEWHEN)) { + else_when_e(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop102; + } + + } + _loop102:; + } // ( ... )* + match(END); + match(WHEN); + when_clause_e_AST = RefMyAST(currentAST.root); + returnAST = when_clause_e_AST; +} + +void flat_modelica_parser::function_call() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAR); + { + function_arguments(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + match(RPAR); + if ( inputState->guessing==0 ) { + function_call_AST = RefMyAST(currentAST.root); +#line 588 "flat_modelica_parser.g" + + function_call_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FUNCTION_ARGUMENTS,"FUNCTION_ARGUMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(function_call_AST)))); + +#line 2202 "flat_modelica_parser.cpp" + currentAST.root = function_call_AST; + if ( function_call_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + function_call_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = function_call_AST->getFirstChild(); + else + currentAST.child = function_call_AST; + currentAST.advanceChildToEnd(); + } + function_call_AST = RefMyAST(currentAST.root); + returnAST = function_call_AST; +} + +void flat_modelica_parser::assign_clause_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST assign_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == ASSIGN)) { + RefMyAST tmp86_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp86_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp86_AST)); + } + match(ASSIGN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == LPAR)) { + function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + assign_clause_a_AST = RefMyAST(currentAST.root); + returnAST = assign_clause_a_AST; +} + +void flat_modelica_parser::multi_assign_clause_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST multi_assign_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAR); + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAR); + RefMyAST tmp89_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp89_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp89_AST)); + } + match(ASSIGN); + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + multi_assign_clause_a_AST = RefMyAST(currentAST.root); + returnAST = multi_assign_clause_a_AST; +} + +void flat_modelica_parser::conditional_equation_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_equation_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp90_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp90_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp90_AST)); + } + match(IF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEIF)) { + algorithm_elseif(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop95; + } + + } + _loop95:; + } // ( ... )* + { + if ((LA(1) == ELSE)) { + RefMyAST tmp92_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp92_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp92_AST)); + } + match(ELSE); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == END)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(END); + match(IF); + conditional_equation_a_AST = RefMyAST(currentAST.root); + returnAST = conditional_equation_a_AST; +} + +void flat_modelica_parser::for_clause_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp95_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp95_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp95_AST)); + } + match(FOR); + for_indices(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(LOOP); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(FOR); + for_clause_a_AST = RefMyAST(currentAST.root); + returnAST = for_clause_a_AST; +} + +void flat_modelica_parser::while_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST while_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp99_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp99_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp99_AST)); + } + match(WHILE); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(LOOP); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(WHILE); + while_clause_AST = RefMyAST(currentAST.root); + returnAST = while_clause_AST; +} + +void flat_modelica_parser::when_clause_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST when_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp103_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp103_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp103_AST)); + } + match(WHEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEWHEN)) { + else_when_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop106; + } + + } + _loop106:; + } // ( ... )* + match(END); + match(WHEN); + when_clause_a_AST = RefMyAST(currentAST.root); + returnAST = when_clause_a_AST; +} + +void flat_modelica_parser::equation_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ((((LA(1) >= ELSE && LA(1) <= END)) && (_tokenSet_24.member(LA(2))))&&(LA(1) != END || (LA(1) == END && LA(2) != IDENT))) { + equation_list_AST = RefMyAST(currentAST.root); + } + else if ((_tokenSet_24.member(LA(1))) && (_tokenSet_23.member(LA(2)))) { + { + equation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + equation_list_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = equation_list_AST; +} + +void flat_modelica_parser::equation_elseif() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_elseif_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp108_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp108_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp108_AST)); + } + match(ELSEIF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equation_elseif_AST = RefMyAST(currentAST.root); + returnAST = equation_elseif_AST; +} + +void flat_modelica_parser::algorithm_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + if ((_tokenSet_10.member(LA(1)))) { + algorithm(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + goto _loop114; + } + + } + _loop114:; + } // ( ... )* + algorithm_list_AST = RefMyAST(currentAST.root); + returnAST = algorithm_list_AST; +} + +void flat_modelica_parser::algorithm_elseif() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_elseif_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp111_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp111_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp111_AST)); + } + match(ELSEIF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + algorithm_elseif_AST = RefMyAST(currentAST.root); + returnAST = algorithm_elseif_AST; +} + +void flat_modelica_parser::for_indices() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_indices_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + for_index(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + for_indices2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + for_indices_AST = RefMyAST(currentAST.root); + returnAST = for_indices_AST; +} + +void flat_modelica_parser::else_when_e() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST else_when_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp113_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp113_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp113_AST)); + } + match(ELSEWHEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else_when_e_AST = RefMyAST(currentAST.root); + returnAST = else_when_e_AST; +} + +void flat_modelica_parser::else_when_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST else_when_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp115_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp115_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp115_AST)); + } + match(ELSEWHEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else_when_a_AST = RefMyAST(currentAST.root); + returnAST = else_when_a_AST; +} + +void flat_modelica_parser::if_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST if_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp117_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp117_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp117_AST)); + } + match(IF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEIF)) { + elseif_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop119; + } + + } + _loop119:; + } // ( ... )* + match(ELSE); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if_expression_AST = RefMyAST(currentAST.root); + returnAST = if_expression_AST; +} + +void flat_modelica_parser::elseif_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST elseif_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp120_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp120_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp120_AST)); + } + match(ELSEIF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + elseif_expression_AST = RefMyAST(currentAST.root); + returnAST = elseif_expression_AST; +} + +void flat_modelica_parser::for_index() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_index_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + RefMyAST tmp122_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp122_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp122_AST)); + } + match(IDENT); + { + if ((LA(1) == IN)) { + RefMyAST tmp123_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp123_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp123_AST)); + } + match(IN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_26.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + for_index_AST = RefMyAST(currentAST.root); + returnAST = for_index_AST; +} + +void flat_modelica_parser::for_indices2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_indices2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((_tokenSet_27.member(LA(1))))&&(LA(2) != IN)) { + for_indices2_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == COMMA)) { + { + match(COMMA); + for_index(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + for_indices2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + for_indices2_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = for_indices2_AST; +} + +void flat_modelica_parser::logical_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + logical_term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == OR)) { + RefMyAST tmp125_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp125_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp125_AST)); + } + match(OR); + logical_term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop132; + } + + } + _loop132:; + } // ( ... )* + logical_expression_AST = RefMyAST(currentAST.root); + returnAST = logical_expression_AST; +} + +void flat_modelica_parser::logical_term() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_term_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + logical_factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == AND)) { + RefMyAST tmp126_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp126_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp126_AST)); + } + match(AND); + logical_factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop135; + } + + } + _loop135:; + } // ( ... )* + logical_term_AST = RefMyAST(currentAST.root); + returnAST = logical_term_AST; +} + +void flat_modelica_parser::logical_factor() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_factor_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == NOT)) { + RefMyAST tmp127_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp127_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp127_AST)); + } + match(NOT); + } + else if ((_tokenSet_28.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + relation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + logical_factor_AST = RefMyAST(currentAST.root); + returnAST = logical_factor_AST; +} + +void flat_modelica_parser::relation() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST relation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + arithmetic_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if (((LA(1) >= LESS && LA(1) <= LESSGT))) { + { + switch ( LA(1)) { + case LESS: + { + RefMyAST tmp128_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp128_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp128_AST)); + } + match(LESS); + break; + } + case LESSEQ: + { + RefMyAST tmp129_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp129_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp129_AST)); + } + match(LESSEQ); + break; + } + case GREATER: + { + RefMyAST tmp130_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp130_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp130_AST)); + } + match(GREATER); + break; + } + case GREATEREQ: + { + RefMyAST tmp131_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp131_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp131_AST)); + } + match(GREATEREQ); + break; + } + case EQEQ: + { + RefMyAST tmp132_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp132_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp132_AST)); + } + match(EQEQ); + break; + } + case LESSGT: + { + RefMyAST tmp133_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp133_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp133_AST)); + } + match(LESSGT); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + arithmetic_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_29.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + relation_AST = RefMyAST(currentAST.root); + returnAST = relation_AST; +} + +void flat_modelica_parser::arithmetic_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST arithmetic_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + unary_arithmetic_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == PLUS || LA(1) == MINUS)) { + { + if ((LA(1) == PLUS)) { + RefMyAST tmp134_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp134_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp134_AST)); + } + match(PLUS); + } + else if ((LA(1) == MINUS)) { + RefMyAST tmp135_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp135_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp135_AST)); + } + match(MINUS); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop146; + } + + } + _loop146:; + } // ( ... )* + arithmetic_expression_AST = RefMyAST(currentAST.root); + returnAST = arithmetic_expression_AST; +} + +void flat_modelica_parser::rel_op() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST rel_op_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LESS: + { + RefMyAST tmp136_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp136_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp136_AST)); + } + match(LESS); + break; + } + case LESSEQ: + { + RefMyAST tmp137_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp137_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp137_AST)); + } + match(LESSEQ); + break; + } + case GREATER: + { + RefMyAST tmp138_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp138_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp138_AST)); + } + match(GREATER); + break; + } + case GREATEREQ: + { + RefMyAST tmp139_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp139_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp139_AST)); + } + match(GREATEREQ); + break; + } + case EQEQ: + { + RefMyAST tmp140_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp140_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp140_AST)); + } + match(EQEQ); + break; + } + case LESSGT: + { + RefMyAST tmp141_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp141_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp141_AST)); + } + match(LESSGT); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + rel_op_AST = RefMyAST(currentAST.root); + returnAST = rel_op_AST; +} + +void flat_modelica_parser::unary_arithmetic_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST unary_arithmetic_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t3_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case PLUS: + { + RefMyAST tmp142_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp142_AST = astFactory->create(LT(1)); + } + match(PLUS); + term(); + if (inputState->guessing==0) { + t1_AST = returnAST; + } + if ( inputState->guessing==0 ) { + unary_arithmetic_expression_AST = RefMyAST(currentAST.root); +#line 511 "flat_modelica_parser.g" + + unary_arithmetic_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(UNARY_PLUS,"PLUS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(t1_AST)))); + +#line 3082 "flat_modelica_parser.cpp" + currentAST.root = unary_arithmetic_expression_AST; + if ( unary_arithmetic_expression_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + unary_arithmetic_expression_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = unary_arithmetic_expression_AST->getFirstChild(); + else + currentAST.child = unary_arithmetic_expression_AST; + currentAST.advanceChildToEnd(); + } + break; + } + case MINUS: + { + RefMyAST tmp143_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp143_AST = astFactory->create(LT(1)); + } + match(MINUS); + term(); + if (inputState->guessing==0) { + t2_AST = returnAST; + } + if ( inputState->guessing==0 ) { + unary_arithmetic_expression_AST = RefMyAST(currentAST.root); +#line 515 "flat_modelica_parser.g" + + unary_arithmetic_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(UNARY_MINUS,"MINUS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(t2_AST)))); + +#line 3110 "flat_modelica_parser.cpp" + currentAST.root = unary_arithmetic_expression_AST; + if ( unary_arithmetic_expression_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + unary_arithmetic_expression_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = unary_arithmetic_expression_AST->getFirstChild(); + else + currentAST.child = unary_arithmetic_expression_AST; + currentAST.advanceChildToEnd(); + } + break; + } + case END: + case FALSE: + case INITIAL: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + { + term(); + if (inputState->guessing==0) { + t3_AST = returnAST; + } + if ( inputState->guessing==0 ) { + unary_arithmetic_expression_AST = RefMyAST(currentAST.root); +#line 519 "flat_modelica_parser.g" + + unary_arithmetic_expression_AST = t3_AST; + +#line 3143 "flat_modelica_parser.cpp" + currentAST.root = unary_arithmetic_expression_AST; + if ( unary_arithmetic_expression_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + unary_arithmetic_expression_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = unary_arithmetic_expression_AST->getFirstChild(); + else + currentAST.child = unary_arithmetic_expression_AST; + currentAST.advanceChildToEnd(); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + returnAST = unary_arithmetic_expression_AST; +} + +void flat_modelica_parser::term() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST term_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == STAR || LA(1) == SLASH)) { + { + if ((LA(1) == STAR)) { + RefMyAST tmp144_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp144_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp144_AST)); + } + match(STAR); + } + else if ((LA(1) == SLASH)) { + RefMyAST tmp145_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp145_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp145_AST)); + } + match(SLASH); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop152; + } + + } + _loop152:; + } // ( ... )* + term_AST = RefMyAST(currentAST.root); + returnAST = term_AST; +} + +void flat_modelica_parser::factor() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST factor_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == POWER)) { + RefMyAST tmp146_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp146_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp146_AST)); + } + match(POWER); + primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_30.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + factor_AST = RefMyAST(currentAST.root); + returnAST = factor_AST; +} + +void flat_modelica_parser::primary() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST primary_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case UNSIGNED_INTEGER: + { + RefMyAST tmp147_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp147_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp147_AST)); + } + match(UNSIGNED_INTEGER); + break; + } + case UNSIGNED_REAL: + { + RefMyAST tmp148_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp148_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp148_AST)); + } + match(UNSIGNED_REAL); + break; + } + case STRING: + { + RefMyAST tmp149_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp149_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp149_AST)); + } + match(STRING); + break; + } + case FALSE: + { + RefMyAST tmp150_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp150_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp150_AST)); + } + match(FALSE); + break; + } + case TRUE: + { + RefMyAST tmp151_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp151_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp151_AST)); + } + match(TRUE); + break; + } + case INITIAL: + case IDENT: + { + component_reference__function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case LPAR: + { + RefMyAST tmp152_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp152_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp152_AST)); + } + match(LPAR); + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAR); + break; + } + case LBRACK: + { + RefMyAST tmp154_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp154_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp154_AST)); + } + match(LBRACK); + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == SEMICOLON)) { + match(SEMICOLON); + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop158; + } + + } + _loop158:; + } // ( ... )* + match(RBRACK); + break; + } + case LBRACE: + { + RefMyAST tmp157_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp157_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp157_AST)); + } + match(LBRACE); + for_or_expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RBRACE); + break; + } + case END: + { + RefMyAST tmp159_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp159_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp159_AST)); + } + match(END); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + primary_AST = RefMyAST(currentAST.root); + returnAST = primary_AST; +} + +void flat_modelica_parser::component_reference__function_call() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_reference__function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST cr_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken i = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ((LA(1) == IDENT)) { + component_reference(); + if (inputState->guessing==0) { + cr_AST = returnAST; + } + { + if ((LA(1) == LPAR)) { + function_call(); + if (inputState->guessing==0) { + fc_AST = returnAST; + } + } + else if ((_tokenSet_31.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + component_reference__function_call_AST = RefMyAST(currentAST.root); +#line 549 "flat_modelica_parser.g" + + if (fc_AST != null) + { + component_reference__function_call_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(3))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FUNCTION_CALL,"FUNCTION_CALL")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(cr_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(fc_AST)))); + } + else + { + component_reference__function_call_AST = cr_AST; + } + +#line 3434 "flat_modelica_parser.cpp" + currentAST.root = component_reference__function_call_AST; + if ( component_reference__function_call_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + component_reference__function_call_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = component_reference__function_call_AST->getFirstChild(); + else + currentAST.child = component_reference__function_call_AST; + currentAST.advanceChildToEnd(); + } + } + else if ((LA(1) == INITIAL)) { + i = LT(1); + if ( inputState->guessing == 0 ) { + i_AST = astFactory->create(i); + } + match(INITIAL); + match(LPAR); + match(RPAR); + if ( inputState->guessing==0 ) { + component_reference__function_call_AST = RefMyAST(currentAST.root); +#line 559 "flat_modelica_parser.g" + + component_reference__function_call_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INITIAL_FUNCTION_CALL,"INITIAL_FUNCTION_CALL")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)))); + +#line 3458 "flat_modelica_parser.cpp" + currentAST.root = component_reference__function_call_AST; + if ( component_reference__function_call_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + component_reference__function_call_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = component_reference__function_call_AST->getFirstChild(); + else + currentAST.child = component_reference__function_call_AST; + currentAST.advanceChildToEnd(); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = component_reference__function_call_AST; +} + +void flat_modelica_parser::for_or_expression_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_or_expression_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST explist_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST forind_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (((LA(1) == RPAR || LA(1) == RBRACE || LA(1) == IDENT) && (_tokenSet_31.member(LA(2))))&&(LA(1)==IDENT && LA(2) == EQUALS|| LA(1) == RPAR)) { + } + else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_32.member(LA(2)))) { + { + expression(); + if (inputState->guessing==0) { + e_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case COMMA: + { + match(COMMA); + for_or_expression_list2(); + if (inputState->guessing==0) { + explist_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR: + { + RefMyAST tmp163_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp163_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp163_AST)); + } + match(FOR); + for_indices(); + if (inputState->guessing==0) { + forind_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case RPAR: + case RBRACE: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + } + if ( inputState->guessing==0 ) { + for_or_expression_list_AST = RefMyAST(currentAST.root); +#line 609 "flat_modelica_parser.g" + + if (forind_AST != null) { + for_or_expression_list_AST = + RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FOR_ITERATOR,"FOR_ITERATOR")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(for_or_expression_list_AST)))); + } + else { + for_or_expression_list_AST = + RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXPRESSION_LIST,"EXPRESSION_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(for_or_expression_list_AST)))); + } + +#line 3546 "flat_modelica_parser.cpp" + currentAST.root = for_or_expression_list_AST; + if ( for_or_expression_list_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + for_or_expression_list_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = for_or_expression_list_AST->getFirstChild(); + else + currentAST.child = for_or_expression_list_AST; + currentAST.advanceChildToEnd(); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + for_or_expression_list_AST = RefMyAST(currentAST.root); + returnAST = for_or_expression_list_AST; +} + +bool flat_modelica_parser::name_path_star() { +#line 569 "flat_modelica_parser.g" + bool val; +#line 3568 "flat_modelica_parser.cpp" + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST name_path_star_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken i = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST np_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((LA(1) == IDENT) && (LA(2) == ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE))&&( LA(2)!=DOT )) { + RefMyAST tmp164_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp164_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp164_AST)); + } + match(IDENT); + if ( inputState->guessing==0 ) { +#line 571 "flat_modelica_parser.g" + val=false; +#line 3586 "flat_modelica_parser.cpp" + } + name_path_star_AST = RefMyAST(currentAST.root); + } + else if (((LA(1) == STAR))&&( LA(2)!=DOT )) { + match(STAR); + if ( inputState->guessing==0 ) { +#line 572 "flat_modelica_parser.g" + val=true; +#line 3595 "flat_modelica_parser.cpp" + } + name_path_star_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == IDENT) && (LA(2) == DOT)) { + i = LT(1); + if ( inputState->guessing == 0 ) { + i_AST = astFactory->create(i); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + } + match(IDENT); + RefMyAST tmp166_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp166_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp166_AST)); + } + match(DOT); + val=name_path_star(); + if (inputState->guessing==0) { + np_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + name_path_star_AST = RefMyAST(currentAST.root); +#line 574 "flat_modelica_parser.g" + + if(!(np_AST)) + { + name_path_star_AST = i_AST; + } + +#line 3626 "flat_modelica_parser.cpp" + currentAST.root = name_path_star_AST; + if ( name_path_star_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + name_path_star_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = name_path_star_AST->getFirstChild(); + else + currentAST.child = name_path_star_AST; + currentAST.advanceChildToEnd(); + } + name_path_star_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = name_path_star_AST; + return val; +} + +void flat_modelica_parser::function_arguments() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST function_arguments_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + for_or_expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + { + if ((LA(1) == IDENT)) { + named_arguments(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + function_arguments_AST = RefMyAST(currentAST.root); + returnAST = function_arguments_AST; +} + +void flat_modelica_parser::named_arguments() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_arguments_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + named_arguments2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + named_arguments_AST = RefMyAST(currentAST.root); +#line 630 "flat_modelica_parser.g" + + named_arguments_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(NAMED_ARGUMENTS,"NAMED_ARGUMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(named_arguments_AST)))); + +#line 3689 "flat_modelica_parser.cpp" + currentAST.root = named_arguments_AST; + if ( named_arguments_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + named_arguments_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = named_arguments_AST->getFirstChild(); + else + currentAST.child = named_arguments_AST; + currentAST.advanceChildToEnd(); + } + named_arguments_AST = RefMyAST(currentAST.root); + returnAST = named_arguments_AST; +} + +void flat_modelica_parser::for_or_expression_list2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_or_expression_list2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((LA(1) == RPAR || LA(1) == RBRACE || LA(1) == IDENT) && (_tokenSet_31.member(LA(2))))&&(LA(2) == EQUALS)) { + for_or_expression_list2_AST = RefMyAST(currentAST.root); + } + else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_33.member(LA(2)))) { + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == COMMA)) { + match(COMMA); + for_or_expression_list2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == RBRACE || LA(1) == IDENT)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + for_or_expression_list2_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = for_or_expression_list2_AST; +} + +void flat_modelica_parser::named_arguments2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_arguments2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + named_argument(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + bool synPredMatched181 = false; + if (((LA(1) == COMMA))) { + int _m181 = mark(); + synPredMatched181 = true; + inputState->guessing++; + try { + { + match(COMMA); + match(IDENT); + match(EQUALS); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched181 = false; + } + rewind(_m181); + inputState->guessing--; + } + if ( synPredMatched181 ) { + match(COMMA); + named_arguments2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + named_arguments2_AST = RefMyAST(currentAST.root); + returnAST = named_arguments2_AST; +} + +void flat_modelica_parser::named_argument() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_argument_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp169_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp169_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp169_AST)); + } + match(IDENT); + RefMyAST tmp170_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp170_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp170_AST)); + } + match(EQUALS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + named_argument_AST = RefMyAST(currentAST.root); + returnAST = named_argument_AST; +} + +void flat_modelica_parser::expression_list2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_list2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == COMMA)) { + match(COMMA); + expression_list2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == RBRACK || LA(1) == SEMICOLON)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + expression_list2_AST = RefMyAST(currentAST.root); + returnAST = expression_list2_AST; +} + +void flat_modelica_parser::subscript() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST subscript_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ((_tokenSet_12.member(LA(1)))) { + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + subscript_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == COLON)) { + RefMyAST tmp172_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp172_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp172_AST)); + } + match(COLON); + subscript_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = subscript_AST; +} + +void flat_modelica_parser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) +{ + factory.setMaxNodeType(155); +} +const char* flat_modelica_parser::tokenNames[] = { + "<0>", + "EOF", + "<2>", + "NULL_TREE_LOOKAHEAD", + "\"algorithm\"", + "\"and\"", + "\"annotation\"", + "\"block\"", + "\"Code\"", + "\"class\"", + "\"connect\"", + "\"connector\"", + "\"constant\"", + "\"discrete\"", + "\"each\"", + "\"else\"", + "\"elseif\"", + "\"elsewhen\"", + "\"end\"", + "\"enumeration\"", + "\"equation\"", + "\"encapsulated\"", + "\"extends\"", + "\"external\"", + "\"false\"", + "\"final\"", + "\"flow\"", + "\"for\"", + "\"function\"", + "\"if\"", + "\"import\"", + "\"in\"", + "\"initial\"", + "\"inner\"", + "\"input\"", + "\"loop\"", + "\"model\"", + "\"not\"", + "\"outer\"", + "\"overload\"", + "\"or\"", + "\"output\"", + "\"package\"", + "\"parameter\"", + "\"partial\"", + "\"protected\"", + "\"public\"", + "\"record\"", + "\"redeclare\"", + "\"replaceable\"", + "\"results\"", + "\"then\"", + "\"true\"", + "\"type\"", + "\"unsigned_real\"", + "\"when\"", + "\"while\"", + "\"within\"", + "\"abstype\"", + "\"as\"", + "\"axiom\"", + "\"datatype\"", + "\"fail\"", + "\"let\"", + "\"interface\"", + "\"module\"", + "\"of\"", + "\"relation\"", + "\"rule\"", + "\"val\"", + "\"_\"", + "\"with\"", + "\"withtype\"", + "LPAR", + "RPAR", + "LBRACK", + "RBRACK", + "LBRACE", + "RBRACE", + "EQUALS", + "ASSIGN", + "PLUS", + "MINUS", + "STAR", + "SLASH", + "DOT", + "COMMA", + "LESS", + "LESSEQ", + "GREATER", + "GREATEREQ", + "EQEQ", + "LESSGT", + "COLON", + "SEMICOLON", + "POWER", + "YIELDS", + "AMPERSAND", + "PIPEBAR", + "COLONCOLON", + "DASHES", + "WS", + "ML_COMMENT", + "ML_COMMENT_CHAR", + "SL_COMMENT", + "an identifier", + "a type identifier", + "NONDIGIT", + "DIGIT", + "EXPONENT", + "UNSIGNED_INTEGER", + "STRING", + "SCHAR", + "SESCAPE", + "ESC", + "ALGORITHM_STATEMENT", + "ARGUMENT_LIST", + "BEGIN_DEFINITION", + "CLASS_DEFINITION", + "CLASS_MODIFICATION", + "CODE_EXPRESSION", + "CODE_MODIFICATION", + "CODE_ELEMENT", + "CODE_EQUATION", + "CODE_INITIALEQUATION", + "CODE_ALGORITHM", + "CODE_INITIALALGORITHM", + "COMMENT", + "COMPONENT_DEFINITION", + "DECLARATION", + "DEFINITION", + "END_DEFINITION", + "ENUMERATION_LITERAL", + "ELEMENT", + "ELEMENT_MODIFICATION", + "ELEMENT_REDECLARATION", + "EQUATION_STATEMENT", + "INITIAL_EQUATION", + "INITIAL_ALGORITHM", + "IMPORT_DEFINITION", + "EXPRESSION_LIST", + "EXTERNAL_FUNCTION_CALL", + "FOR_INDICES", + "FOR_ITERATOR", + "FUNCTION_CALL", + "INITIAL_FUNCTION_CALL", + "FUNCTION_ARGUMENTS", + "NAMED_ARGUMENTS", + "QUALIFIED", + "RANGE2", + "RANGE3", + "STORED_DEFINITION", + "STRING_COMMENT", + "UNARY_MINUS", + "UNARY_PLUS", + "UNQUALIFIED", + 0 +}; + +const unsigned long flat_modelica_parser::_tokenSet_0_data_[] = { 110374992UL, 27223UL, 0UL, 33280UL, 0UL, 0UL, 0UL, 0UL }; +// "algorithm" "annotation" "constant" "discrete" "end" "equation" "external" +// "final" "flow" "initial" "inner" "input" "model" "outer" "output" "parameter" +// "protected" "public" IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_0(_tokenSet_0_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_1_data_[] = { 67121152UL, 2564UL, 0UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// "constant" "discrete" "flow" "input" "output" "parameter" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_1(_tokenSet_1_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_2_data_[] = { 66UL, 0UL, 1073742336UL, 32768UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "annotation" LPAR SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_2(_tokenSet_2_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_3_data_[] = { 66UL, 0UL, 1073741824UL, 32768UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "annotation" SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_3(_tokenSet_3_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_4_data_[] = { 110374994UL, 27223UL, 1077937152UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "algorithm" "annotation" "constant" "discrete" "end" "equation" +// "external" "final" "flow" "initial" "inner" "input" "model" "outer" +// "output" "parameter" "protected" "public" RPAR COMMA SEMICOLON IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_4(_tokenSet_4_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_5_data_[] = { 66UL, 0UL, 1077938688UL, 33280UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "annotation" LPAR LBRACK COMMA SEMICOLON IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_5(_tokenSet_5_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_6_data_[] = { 2UL, 0UL, 1077937152UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// EOF RPAR COMMA SEMICOLON +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_6(_tokenSet_6_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_7_data_[] = { 12288UL, 2564UL, 0UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// "constant" "discrete" "input" "output" "parameter" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_7(_tokenSet_7_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_8_data_[] = { 100675648UL, 2646UL, 0UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "constant" "discrete" "final" "flow" "inner" "input" "model" +// "outer" "output" "parameter" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_8(_tokenSet_8_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_9_data_[] = { 100675584UL, 2646UL, 0UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// "constant" "discrete" "final" "flow" "inner" "input" "model" "outer" +// "output" "parameter" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_9(_tokenSet_9_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_10_data_[] = { 671088640UL, 25165824UL, 512UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// "for" "if" "when" "while" LPAR IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_10(_tokenSet_10_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_11_data_[] = { 262208UL, 0UL, 1073741824UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "end" SEMICOLON IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_11(_tokenSet_11_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_12_data_[] = { 553910272UL, 5242913UL, 403968UL, 49664UL, 0UL, 0UL, 0UL, 0UL }; +// "end" "false" "if" "initial" "not" "true" "unsigned_real" LPAR LBRACK +// LBRACE PLUS MINUS IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_12(_tokenSet_12_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_13_data_[] = { 134316130UL, 524552UL, 4294956544UL, 33280UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "and" "annotation" "else" "elseif" "for" "loop" "or" "then" LPAR +// RPAR RBRACK RBRACE EQUALS ASSIGN PLUS MINUS STAR SLASH DOT COMMA LESS +// LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_13(_tokenSet_13_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_14_data_[] = { 134316130UL, 524552UL, 4292859392UL, 33280UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "and" "annotation" "else" "elseif" "for" "loop" "or" "then" LPAR +// RPAR RBRACK RBRACE EQUALS ASSIGN PLUS MINUS STAR SLASH COMMA LESS LESSEQ +// GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_14(_tokenSet_14_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_15_data_[] = { 67121152UL, 2646UL, 0UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// "constant" "discrete" "flow" "inner" "input" "model" "outer" "output" +// "parameter" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_15(_tokenSet_15_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_16_data_[] = { 66UL, 0UL, 1078034944UL, 32768UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "annotation" LPAR EQUALS ASSIGN COMMA SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_16(_tokenSet_16_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_17_data_[] = { 66UL, 0UL, 1077936128UL, 32768UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "annotation" COMMA SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_17(_tokenSet_17_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_18_data_[] = { 66UL, 0UL, 1077937152UL, 32768UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "annotation" RPAR COMMA SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_18(_tokenSet_18_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_19_data_[] = { 17039360UL, 5242913UL, 403968UL, 49664UL, 0UL, 0UL, 0UL, 0UL }; +// "end" "false" "initial" "not" "true" "unsigned_real" LPAR LBRACK LBRACE +// PLUS MINUS IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_19(_tokenSet_19_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_20_data_[] = { 9699344UL, 24577UL, 0UL, 0UL, 0UL, 0UL }; +// "algorithm" "end" "equation" "external" "initial" "protected" "public" +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_20(_tokenSet_20_data_,6); +const unsigned long flat_modelica_parser::_tokenSet_21_data_[] = { 798240848UL, 30435959UL, 1074145792UL, 49664UL, 0UL, 0UL, 0UL, 0UL }; +// "algorithm" "annotation" "constant" "discrete" "end" "equation" "external" +// "false" "final" "flow" "for" "if" "initial" "inner" "input" "model" +// "not" "outer" "output" "parameter" "protected" "public" "true" "unsigned_real" +// "when" "while" LPAR LBRACK LBRACE PLUS MINUS SEMICOLON IDENT UNSIGNED_INTEGER +// STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_21(_tokenSet_21_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_22_data_[] = { 688128064UL, 13631521UL, 403968UL, 49664UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "end" "false" "for" "if" "initial" "not" "true" "unsigned_real" +// "when" LPAR LBRACK LBRACE PLUS MINUS IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_22(_tokenSet_22_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_23_data_[] = { 553910304UL, 5243169UL, 3216960000UL, 49664UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "end" "false" "if" "initial" "not" "or" "true" "unsigned_real" +// LPAR LBRACK LBRACE RBRACE EQUALS PLUS MINUS STAR SLASH DOT LESS LESSEQ +// GREATER GREATEREQ EQEQ LESSGT COLON POWER IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_23(_tokenSet_23_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_24_data_[] = { 688128000UL, 13631521UL, 403968UL, 49664UL, 0UL, 0UL, 0UL, 0UL }; +// "end" "false" "for" "if" "initial" "not" "true" "unsigned_real" "when" +// LPAR LBRACK LBRACE PLUS MINUS IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_24(_tokenSet_24_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_25_data_[] = { 134316098UL, 524296UL, 1077990400UL, 33280UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "annotation" "else" "elseif" "for" "loop" "then" RPAR RBRACK RBRACE +// EQUALS COMMA SEMICOLON IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_25(_tokenSet_25_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_26_data_[] = { 0UL, 8UL, 4211712UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// "loop" RPAR RBRACE COMMA IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_26(_tokenSet_26_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_27_data_[] = { 0UL, 8UL, 17408UL, 512UL, 0UL, 0UL, 0UL, 0UL }; +// "loop" RPAR RBRACE IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_27(_tokenSet_27_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_28_data_[] = { 17039360UL, 5242881UL, 403968UL, 49664UL, 0UL, 0UL, 0UL, 0UL }; +// "end" "false" "initial" "true" "unsigned_real" LPAR LBRACK LBRACE PLUS +// MINUS IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_28(_tokenSet_28_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_29_data_[] = { 134316130UL, 524552UL, 1614861312UL, 33280UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "and" "annotation" "else" "elseif" "for" "loop" "or" "then" RPAR +// RBRACK RBRACE EQUALS COMMA COLON SEMICOLON IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_29(_tokenSet_29_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_30_data_[] = { 134316130UL, 524552UL, 2145309696UL, 33280UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "and" "annotation" "else" "elseif" "for" "loop" "or" "then" RPAR +// RBRACK RBRACE EQUALS PLUS MINUS STAR SLASH COMMA LESS LESSEQ GREATER +// GREATEREQ EQEQ LESSGT COLON SEMICOLON IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_30(_tokenSet_30_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_31_data_[] = { 134316130UL, 524552UL, 4292793344UL, 33280UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "and" "annotation" "else" "elseif" "for" "loop" "or" "then" RPAR +// RBRACK RBRACE EQUALS PLUS MINUS STAR SLASH COMMA LESS LESSEQ GREATER +// GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_31(_tokenSet_31_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_32_data_[] = { 688128032UL, 5243169UL, 3221122560UL, 49664UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "end" "false" "for" "if" "initial" "not" "or" "true" "unsigned_real" +// LPAR RPAR LBRACK LBRACE RBRACE PLUS MINUS STAR SLASH DOT COMMA LESS +// LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON POWER IDENT UNSIGNED_INTEGER +// STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_32(_tokenSet_32_data_,8); +const unsigned long flat_modelica_parser::_tokenSet_33_data_[] = { 553910304UL, 5243169UL, 3221122560UL, 49664UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "end" "false" "if" "initial" "not" "or" "true" "unsigned_real" +// LPAR RPAR LBRACK LBRACE RBRACE PLUS MINUS STAR SLASH DOT COMMA LESS +// LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON POWER IDENT UNSIGNED_INTEGER +// STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_parser::_tokenSet_33(_tokenSet_33_data_,8); + + diff --git a/tools/xml/flatmodelicaxml/flat_modelica_parser.g b/tools/xml/flatmodelicaxml/flat_modelica_parser.g new file mode 100644 index 00000000000..486cbed678f --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_parser.g @@ -0,0 +1,683 @@ + +header "post_include_hpp" { +#define null 0 +#include "MyAST.h" + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; +} + +options { + language = "Cpp"; +} + +class flat_modelica_parser extends Parser; + +options { + codeGenMakeSwitchThreshold = 3; + codeGenBitsetTestThreshold = 4; + importVocab = flatmodelica; + defaultErrorHandler = false; + k = 2; + buildAST = true; + ASTLabelType = "RefMyAST"; + +} + +tokens { + ALGORITHM_STATEMENT; + ARGUMENT_LIST; + BEGIN_DEFINITION; + CLASS_DEFINITION ; + CLASS_MODIFICATION; + CODE_EXPRESSION; + CODE_MODIFICATION; + CODE_ELEMENT; + CODE_EQUATION; + CODE_INITIALEQUATION; + CODE_ALGORITHM; + CODE_INITIALALGORITHM; + COMMENT; + COMPONENT_DEFINITION; + DECLARATION ; + DEFINITION ; + END_DEFINITION; + ENUMERATION_LITERAL; + ELEMENT ; + ELEMENT_MODIFICATION ; + ELEMENT_REDECLARATION ; + EQUATION_STATEMENT; + INITIAL_EQUATION; + INITIAL_ALGORITHM; + IMPORT_DEFINITION; + EXPRESSION_LIST; + EXTERNAL_FUNCTION_CALL; + FOR_INDICES ; + FOR_ITERATOR ; + FUNCTION_CALL ; + INITIAL_FUNCTION_CALL ; + FUNCTION_ARGUMENTS; + NAMED_ARGUMENTS; + QUALIFIED; + RANGE2 ; + RANGE3 ; + STORED_DEFINITION ; + STRING_COMMENT; + UNARY_MINUS ; + UNARY_PLUS ; + UNQUALIFIED; + +} + + +/* + * 2.2.1 Stored definition + */ + + +stored_definition : + class_definition + { + #stored_definition = #([STORED_DEFINITION,"STORED_DEFINITION"], + #stored_definition); + } + + ; + +/* + * 2.2.2 Class definition + */ + +class_definition : + class_type + IDENT + class_specifier + { + #class_definition = #([CLASS_DEFINITION, "CLASS_DEFINITION"], + class_definition); + } + ; + +class_type : + MODEL + ; + +class_specifier : + ( string_comment composition END! name_path! SEMICOLON! (.!)* EOF! + | EQUALS^ base_prefix name_path ( array_subscripts )? ( class_modification )? comment + | EQUALS^ enumeration + ) + ; + +base_prefix: + type_prefix + ; + +name_list: + name_path (COMMA! name_path)* + ; + +enumeration : + ENUMERATION^ LPAR! enum_list RPAR! comment + ; +enum_list : + enumeration_literal ( COMMA! enumeration_literal)* + ; + +enumeration_literal : + IDENT comment + { + #enumeration_literal=#([ENUMERATION_LITERAL, + "ENUMERATION_LITERAL"],#enumeration_literal); + } + ; + +composition : + element_list + ( public_element_list + | protected_element_list + | initial_equation_clause + | initial_algorithm_clause + | equation_clause + | algorithm_clause + )* + ( external_clause )? + ; + +external_clause : + EXTERNAL^ + ( language_specification )? + ( external_function_call )? + (SEMICOLON!) ? + /* Relaxed from Modelica 2.0. This code will be correct in 2.1 */ + ( annotation SEMICOLON! )? + ; + +public_element_list : + PUBLIC^ element_list + ; + +protected_element_list : + PROTECTED^ element_list + ; + +language_specification : + STRING + ; + +external_function_call : + ( component_reference EQUALS^ )? + IDENT LPAR! ( expression_list )? RPAR! + { + #external_function_call=#([EXTERNAL_FUNCTION_CALL, + "EXTERNAL_FUNCTION_CALL"],#external_function_call); + } + ; + +element_list : + ((element | annotation ) SEMICOLON!)* + ; + +element : + (FINAL)? + (INNER | OUTER)? + (class_definition | cc:component_clause) + { + if(#cc != null ) + { + #element = #([DECLARATION,"DECLARATION"], #element); + } + else + { + #element = #([DEFINITION,"DEFINITION"], #element); + } + } + ; + +/* + * 2.2.4 Component clause + */ + +component_clause : + type_prefix type_specifier (array_subscripts)? component_list + ; + +type_prefix : + (FLOW)? + (DISCRETE + |PARAMETER + |CONSTANT + )? + (INPUT + |OUTPUT + )? + ; + +type_specifier : + name_path + ; + +component_list : + component_declaration (COMMA! component_declaration)* + ; + +component_declaration : + declaration comment + ; + +declaration : + IDENT^ (array_subscripts)? (modification)? + ; + +/* + * 2.2.5 Modification + */ + +modification : + ( class_modification ( EQUALS! expression )? + | EQUALS^ expression + | ASSIGN^ expression + ) + ; + +class_modification : + LPAR! ( argument_list )? RPAR! + { + #class_modification=#([CLASS_MODIFICATION,"CLASS_MODIFICATION"], + #class_modification); + } + ; + +argument_list : + argument ( COMMA! argument )* + { + #argument_list=#([ARGUMENT_LIST,"ARGUMENT_LIST"],#argument_list); + } + ; + +argument ! : + em:element_modification + { + #argument = #([ELEMENT_MODIFICATION,"ELEMENT_MODIFICATION"], #em); + } + ; + +element_modification : + ( EACH )? component_reference ( modification )? string_comment + ; + + +component_clause1 : + type_prefix type_specifier component_declaration + ; + + +/* + * 2.2.6 Equations + */ + +initial_equation_clause : + { LA(2)==EQUATION}? + INITIAL! ec:equation_clause + { + #initial_equation_clause = #([INITIAL_EQUATION,"INTIAL_EQUATION"], ec); + } + + ; + +equation_clause : + EQUATION^ + equation_annotation_list + ; + +equation_annotation_list : + { LA(1) == END || LA(1) == EQUATION || LA(1) == ALGORITHM || LA(1)==INITIAL + || LA(1) == PROTECTED || LA(1) == PUBLIC }? + | + ( equation SEMICOLON! | annotation SEMICOLON!) equation_annotation_list + ; + +algorithm_clause : + ALGORITHM^ + (algorithm SEMICOLON! + |annotation SEMICOLON! + )* + ; +initial_algorithm_clause : + { LA(2)==ALGORITHM}? + INITIAL! ALGORITHM^ + (algorithm SEMICOLON! + |annotation SEMICOLON! + )* + { + #initial_algorithm_clause = #([INITIAL_ALGORITHM,"INTIAL_ALGORITHM"], #initial_algorithm_clause); + } + ; +equation : + + ( (simple_expression EQUALS) => equality_equation + | conditional_equation_e + | for_clause_e + | when_clause_e + | IDENT function_call + ) + { + #equation = #([EQUATION_STATEMENT,"EQUATION_STATEMENT"], #equation); + } + comment + ; + +algorithm : + ( assign_clause_a + | multi_assign_clause_a + | conditional_equation_a + | for_clause_a + | while_clause + | when_clause_a + ) + comment + { + #algorithm = #([ALGORITHM_STATEMENT,"ALGORITHM_STATEMENT"], #algorithm); + } + ; + +assign_clause_a : component_reference ( ASSIGN^ expression | function_call ); + +multi_assign_clause_a : + LPAR! expression_list RPAR! ASSIGN^ component_reference function_call; + +equality_equation : + simple_expression EQUALS^ expression + ; + +conditional_equation_e : + IF^ expression THEN! equation_list + ( equation_elseif )* + ( ELSE equation_list )? + END! IF! + ; + +conditional_equation_a : + IF^ expression THEN! algorithm_list + ( algorithm_elseif )* + ( ELSE algorithm_list )? + END! IF! + ; + +for_clause_e : + FOR^ for_indices LOOP! + equation_list + END! FOR! + ; + +for_clause_a : + FOR^ for_indices LOOP! + algorithm_list + END! FOR! + ; + +while_clause : + WHILE^ expression LOOP! + algorithm_list + END! WHILE! + ; + +when_clause_e : + WHEN^ expression THEN! + equation_list + (else_when_e) * + END! WHEN! + ; + +else_when_e : + ELSEWHEN^ expression THEN! + equation_list + ; + +when_clause_a : + WHEN^ expression THEN! + algorithm_list + (else_when_a)* + END! WHEN! + ; + +else_when_a : + ELSEWHEN^ expression THEN! + algorithm_list + ; + +equation_elseif : + ELSEIF^ expression THEN! + equation_list + ; + +algorithm_elseif : + ELSEIF^ expression THEN! + algorithm_list + ; + +equation_list : + {LA(1) != END || (LA(1) == END && LA(2) != IDENT)}? + | + (equation SEMICOLON! equation_list) + ; + +algorithm_list : + ( algorithm SEMICOLON! )* + ; + + +/* + * 2.2.7 Expressions + */ + +expression : + ( if_expression + | simple_expression + ) + ; + +if_expression : + IF^ expression THEN! expression (elseif_expression)* ELSE! expression + ; + +elseif_expression : + ELSEIF^ expression THEN! expression + ; + +for_indices : + for_index for_indices2 + ; +for_indices2 : + {LA(2) != IN}? + | + (COMMA! for_index) for_indices2 + ; + +for_index: + (IDENT (IN^ expression)?) +; + + +simple_expression ! : + l1:logical_expression + ( COLON l2:logical_expression + ( COLON l3:logical_expression + )? + )? + { + if (#l3 != null) + { + #simple_expression = #([RANGE3,"RANGE3"], l1, l2, l3); + } + else if (#l2 != null) + { + #simple_expression = #([RANGE2,"RANGE2"], l1, l2); + } + else + { + #simple_expression = #l1; + } + } + ; + + +logical_expression : + logical_term ( OR^ logical_term )* + ; + +logical_term : + logical_factor ( AND^ logical_factor )* + ; + +logical_factor : + ( NOT^ )? + relation + ; + +relation : + arithmetic_expression ( ( LESS^ | LESSEQ^ | GREATER^ | GREATEREQ^ | EQEQ^ | LESSGT^ ) arithmetic_expression )? + ; + +rel_op : + ( LESS^ | LESSEQ^ | GREATER^ | GREATEREQ^ | EQEQ^ | LESSGT^ ) + ; + +arithmetic_expression : + unary_arithmetic_expression ( ( PLUS^ | MINUS^ ) term )* + ; + +unary_arithmetic_expression ! : + ( PLUS t1:term + { + #unary_arithmetic_expression = #([UNARY_PLUS,"PLUS"], #t1); + } + | MINUS t2:term + { + #unary_arithmetic_expression = #([UNARY_MINUS,"MINUS"], #t2); + } + | t3:term + { + #unary_arithmetic_expression = #t3; + } + ) + ; + +term : + factor ( ( STAR^ | SLASH^ ) factor )* + ; + +factor : + primary ( POWER^ primary )? + ; + +primary : + ( UNSIGNED_INTEGER + | UNSIGNED_REAL + | STRING + | FALSE + | TRUE + | component_reference__function_call + | LPAR^ expression_list RPAR! + | LBRACK^ expression_list (SEMICOLON! expression_list)* RBRACK! + | LBRACE^ for_or_expression_list RBRACE! + | END + ) + ; + +component_reference__function_call ! : + cr:component_reference ( fc:function_call )? + { + if (#fc != null) + { + #component_reference__function_call = #([FUNCTION_CALL,"FUNCTION_CALL"], #cr, #fc); + } + else + { + #component_reference__function_call = #cr; + } + } + | i:INITIAL LPAR! RPAR! { + #component_reference__function_call = #([INITIAL_FUNCTION_CALL,"INITIAL_FUNCTION_CALL"],i); + } + ; + +name_path : + { LA(2)!=DOT }? IDENT | + IDENT DOT^ name_path + ; + +name_path_star returns [bool val] + : + { LA(2)!=DOT }? IDENT { val=false;}| + { LA(2)!=DOT }? STAR! { val=true;}| + i:IDENT DOT^ val = np:name_path_star + { + if(!(#np)) + { + #name_path_star = #i; + } + } + ; + +component_reference : + IDENT^ ( array_subscripts)? ( DOT^ component_reference )? + ; + +function_call : + LPAR! (function_arguments) RPAR! + { + #function_call = #([FUNCTION_ARGUMENTS,"FUNCTION_ARGUMENTS"],#function_call); + } + ; + +function_arguments : + (for_or_expression_list) + (named_arguments) ? + ; + +for_or_expression_list + : + ( + {LA(1)==IDENT && LA(2) == EQUALS|| LA(1) == RPAR}? + | + ( + e:expression + ( COMMA! explist:for_or_expression_list2 + | FOR^ forind:for_indices + )? + ) + { + if (#forind != null) { + #for_or_expression_list = + #([FOR_ITERATOR,"FOR_ITERATOR"], #for_or_expression_list); + } + else { + #for_or_expression_list = + #([EXPRESSION_LIST,"EXPRESSION_LIST"], #for_or_expression_list); + } + } + ) + ; + +for_or_expression_list2 : + {LA(2) == EQUALS}? + | + expression (COMMA! for_or_expression_list2)? + ; + +named_arguments : + named_arguments2 + { + #named_arguments=#([NAMED_ARGUMENTS,"NAMED_ARGUMENTS"],#named_arguments); + } + ; + +named_arguments2 : + named_argument ( COMMA! (COMMA IDENT EQUALS) => named_arguments2)? + ; + +named_argument : + IDENT EQUALS^ expression + ; + +expression_list : + expression_list2 + { + #expression_list=#([EXPRESSION_LIST,"EXPRESSION_LIST"],#expression_list); + } + ; +expression_list2 : + expression (COMMA! expression_list2)? + ; + +array_subscripts : + LBRACK^ subscript ( COMMA! subscript )* RBRACK! + ; + +subscript : + expression | COLON + ; + +comment : + ( + //string_comment ANNOTATION )=> annotation + string_comment (annotation)? + ) + { + #comment=#([COMMENT,"COMMENT"],#comment); + } + ; + +string_comment : + ( STRING ((PLUS STRING) => ( PLUS^ STRING )+ | ) )? + { + if (#string_comment) + { + #string_comment = #([STRING_COMMENT,"STRING_COMMENT"], #string_comment); + } + } +; + +annotation : + ANNOTATION^ class_modification + ; diff --git a/tools/xml/flatmodelicaxml/flat_modelica_parser.hpp b/tools/xml/flatmodelicaxml/flat_modelica_parser.hpp new file mode 100644 index 00000000000..be560bda19c --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_parser.hpp @@ -0,0 +1,222 @@ +#ifndef INC_flat_modelica_parser_hpp_ +#define INC_flat_modelica_parser_hpp_ + +#include +/* $ANTLR 2.7.5rc2 (20050108): "flat_modelica_parser.g" -> "flat_modelica_parser.hpp"$ */ +#include +#include +#include "flat_modelica_parserTokenTypes.hpp" +#include + +#line 2 "flat_modelica_parser.g" + +#define null 0 +#include "MyAST.h" + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; + +#line 19 "flat_modelica_parser.hpp" +class CUSTOM_API flat_modelica_parser : public ANTLR_USE_NAMESPACE(antlr)LLkParser, public flat_modelica_parserTokenTypes +{ +#line 1 "flat_modelica_parser.g" +#line 23 "flat_modelica_parser.hpp" +public: + void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ); +protected: + flat_modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k); +public: + flat_modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf); +protected: + flat_modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k); +public: + flat_modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer); + flat_modelica_parser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state); + int getNumTokens() const + { + return flat_modelica_parser::NUM_TOKENS; + } + const char* getTokenName( int type ) const + { + if( type > getNumTokens() ) return 0; + return flat_modelica_parser::tokenNames[type]; + } + const char* const* getTokenNames() const + { + return flat_modelica_parser::tokenNames; + } + public: void stored_definition(); + public: void class_definition(); + public: void class_type(); + public: void class_specifier(); + public: void string_comment(); + public: void composition(); + public: void name_path(); + public: void base_prefix(); + public: void array_subscripts(); + public: void class_modification(); + public: void comment(); + public: void enumeration(); + public: void type_prefix(); + public: void name_list(); + public: void enum_list(); + public: void enumeration_literal(); + public: void element_list(); + public: void public_element_list(); + public: void protected_element_list(); + public: void initial_equation_clause(); + public: void initial_algorithm_clause(); + public: void equation_clause(); + public: void algorithm_clause(); + public: void external_clause(); + public: void language_specification(); + public: void external_function_call(); + public: void annotation(); + public: void component_reference(); + public: void expression_list(); + public: void element(); + public: void component_clause(); + public: void type_specifier(); + public: void component_list(); + public: void component_declaration(); + public: void declaration(); + public: void modification(); + public: void expression(); + public: void argument_list(); + public: void argument(); + public: void element_modification(); + public: void component_clause1(); + public: void equation_annotation_list(); + public: void equation(); + public: void algorithm(); + public: void simple_expression(); + public: void equality_equation(); + public: void conditional_equation_e(); + public: void for_clause_e(); + public: void when_clause_e(); + public: void function_call(); + public: void assign_clause_a(); + public: void multi_assign_clause_a(); + public: void conditional_equation_a(); + public: void for_clause_a(); + public: void while_clause(); + public: void when_clause_a(); + public: void equation_list(); + public: void equation_elseif(); + public: void algorithm_list(); + public: void algorithm_elseif(); + public: void for_indices(); + public: void else_when_e(); + public: void else_when_a(); + public: void if_expression(); + public: void elseif_expression(); + public: void for_index(); + public: void for_indices2(); + public: void logical_expression(); + public: void logical_term(); + public: void logical_factor(); + public: void relation(); + public: void arithmetic_expression(); + public: void rel_op(); + public: void unary_arithmetic_expression(); + public: void term(); + public: void factor(); + public: void primary(); + public: void component_reference__function_call(); + public: void for_or_expression_list(); + public: bool name_path_star(); + public: void function_arguments(); + public: void named_arguments(); + public: void for_or_expression_list2(); + public: void named_arguments2(); + public: void named_argument(); + public: void expression_list2(); + public: void subscript(); +public: + ANTLR_USE_NAMESPACE(antlr)RefAST getAST() + { + return ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST); + } + +protected: + RefMyAST returnAST; +private: + static const char* tokenNames[]; +#ifndef NO_STATIC_CONSTS + static const int NUM_TOKENS = 156; +#else + enum { + NUM_TOKENS = 156 + }; +#endif + + static const unsigned long _tokenSet_0_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0; + static const unsigned long _tokenSet_1_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1; + static const unsigned long _tokenSet_2_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2; + static const unsigned long _tokenSet_3_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3; + static const unsigned long _tokenSet_4_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_4; + static const unsigned long _tokenSet_5_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_5; + static const unsigned long _tokenSet_6_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_6; + static const unsigned long _tokenSet_7_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_7; + static const unsigned long _tokenSet_8_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_8; + static const unsigned long _tokenSet_9_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_9; + static const unsigned long _tokenSet_10_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_10; + static const unsigned long _tokenSet_11_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_11; + static const unsigned long _tokenSet_12_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_12; + static const unsigned long _tokenSet_13_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_13; + static const unsigned long _tokenSet_14_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_14; + static const unsigned long _tokenSet_15_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_15; + static const unsigned long _tokenSet_16_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_16; + static const unsigned long _tokenSet_17_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_17; + static const unsigned long _tokenSet_18_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_18; + static const unsigned long _tokenSet_19_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_19; + static const unsigned long _tokenSet_20_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_20; + static const unsigned long _tokenSet_21_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_21; + static const unsigned long _tokenSet_22_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_22; + static const unsigned long _tokenSet_23_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_23; + static const unsigned long _tokenSet_24_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_24; + static const unsigned long _tokenSet_25_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_25; + static const unsigned long _tokenSet_26_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_26; + static const unsigned long _tokenSet_27_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_27; + static const unsigned long _tokenSet_28_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_28; + static const unsigned long _tokenSet_29_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_29; + static const unsigned long _tokenSet_30_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_30; + static const unsigned long _tokenSet_31_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_31; + static const unsigned long _tokenSet_32_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_32; + static const unsigned long _tokenSet_33_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_33; +}; + +#endif /*INC_flat_modelica_parser_hpp_*/ diff --git a/tools/xml/flatmodelicaxml/flat_modelica_parserTokenTypes.hpp b/tools/xml/flatmodelicaxml/flat_modelica_parserTokenTypes.hpp new file mode 100644 index 00000000000..b237bb4edcc --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_parserTokenTypes.hpp @@ -0,0 +1,172 @@ +#ifndef INC_flat_modelica_parserTokenTypes_hpp_ +#define INC_flat_modelica_parserTokenTypes_hpp_ + +/* $ANTLR 2.7.5rc2 (20050108): "flat_modelica_parser.g" -> "flat_modelica_parserTokenTypes.hpp"$ */ + +#ifndef CUSTOM_API +# define CUSTOM_API +#endif + +#ifdef __cplusplus +struct CUSTOM_API flat_modelica_parserTokenTypes { +#endif + enum { + EOF_ = 1, + ALGORITHM = 4, + AND = 5, + ANNOTATION = 6, + BLOCK = 7, + CODE = 8, + CLASS = 9, + CONNECT = 10, + CONNECTOR = 11, + CONSTANT = 12, + DISCRETE = 13, + EACH = 14, + ELSE = 15, + ELSEIF = 16, + ELSEWHEN = 17, + END = 18, + ENUMERATION = 19, + EQUATION = 20, + ENCAPSULATED = 21, + EXTENDS = 22, + EXTERNAL = 23, + FALSE = 24, + FINAL = 25, + FLOW = 26, + FOR = 27, + FUNCTION = 28, + IF = 29, + IMPORT = 30, + IN = 31, + INITIAL = 32, + INNER = 33, + INPUT = 34, + LOOP = 35, + MODEL = 36, + NOT = 37, + OUTER = 38, + OVERLOAD = 39, + OR = 40, + OUTPUT = 41, + PACKAGE = 42, + PARAMETER = 43, + PARTIAL = 44, + PROTECTED = 45, + PUBLIC = 46, + RECORD = 47, + REDECLARE = 48, + REPLACEABLE = 49, + RESULTS = 50, + THEN = 51, + TRUE = 52, + TYPE = 53, + UNSIGNED_REAL = 54, + WHEN = 55, + WHILE = 56, + WITHIN = 57, + ABSTYPE = 58, + AS = 59, + AXIOM = 60, + DATATYPE = 61, + FAIL = 62, + LET = 63, + INTERFACE = 64, + MODULE = 65, + OF = 66, + RELATION = 67, + RULE = 68, + VAL = 69, + WILD = 70, + WITH = 71, + WITHTYPE = 72, + LPAR = 73, + RPAR = 74, + LBRACK = 75, + RBRACK = 76, + LBRACE = 77, + RBRACE = 78, + EQUALS = 79, + ASSIGN = 80, + PLUS = 81, + MINUS = 82, + STAR = 83, + SLASH = 84, + DOT = 85, + COMMA = 86, + LESS = 87, + LESSEQ = 88, + GREATER = 89, + GREATEREQ = 90, + EQEQ = 91, + LESSGT = 92, + COLON = 93, + SEMICOLON = 94, + POWER = 95, + YIELDS = 96, + AMPERSAND = 97, + PIPEBAR = 98, + COLONCOLON = 99, + DASHES = 100, + WS = 101, + ML_COMMENT = 102, + ML_COMMENT_CHAR = 103, + SL_COMMENT = 104, + IDENT = 105, + TYVARIDENT = 106, + NONDIGIT = 107, + DIGIT = 108, + EXPONENT = 109, + UNSIGNED_INTEGER = 110, + STRING = 111, + SCHAR = 112, + SESCAPE = 113, + ESC = 114, + ALGORITHM_STATEMENT = 115, + ARGUMENT_LIST = 116, + BEGIN_DEFINITION = 117, + CLASS_DEFINITION = 118, + CLASS_MODIFICATION = 119, + CODE_EXPRESSION = 120, + CODE_MODIFICATION = 121, + CODE_ELEMENT = 122, + CODE_EQUATION = 123, + CODE_INITIALEQUATION = 124, + CODE_ALGORITHM = 125, + CODE_INITIALALGORITHM = 126, + COMMENT = 127, + COMPONENT_DEFINITION = 128, + DECLARATION = 129, + DEFINITION = 130, + END_DEFINITION = 131, + ENUMERATION_LITERAL = 132, + ELEMENT = 133, + ELEMENT_MODIFICATION = 134, + ELEMENT_REDECLARATION = 135, + EQUATION_STATEMENT = 136, + INITIAL_EQUATION = 137, + INITIAL_ALGORITHM = 138, + IMPORT_DEFINITION = 139, + EXPRESSION_LIST = 140, + EXTERNAL_FUNCTION_CALL = 141, + FOR_INDICES = 142, + FOR_ITERATOR = 143, + FUNCTION_CALL = 144, + INITIAL_FUNCTION_CALL = 145, + FUNCTION_ARGUMENTS = 146, + NAMED_ARGUMENTS = 147, + QUALIFIED = 148, + RANGE2 = 149, + RANGE3 = 150, + STORED_DEFINITION = 151, + STRING_COMMENT = 152, + UNARY_MINUS = 153, + UNARY_PLUS = 154, + UNQUALIFIED = 155, + NULL_TREE_LOOKAHEAD = 3 + }; +#ifdef __cplusplus +}; +#endif +#endif /*INC_flat_modelica_parserTokenTypes_hpp_*/ diff --git a/tools/xml/flatmodelicaxml/flat_modelica_parserTokenTypes.txt b/tools/xml/flatmodelicaxml/flat_modelica_parserTokenTypes.txt new file mode 100644 index 00000000000..01f2d43f7cb --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_parserTokenTypes.txt @@ -0,0 +1,154 @@ +// $ANTLR 2.7.5rc2 (20050108): flat_modelica_parser.g -> flat_modelica_parserTokenTypes.txt$ +flat_modelica_parser // output token vocab name +ALGORITHM="algorithm"=4 +AND="and"=5 +ANNOTATION="annotation"=6 +BLOCK="block"=7 +CODE="Code"=8 +CLASS="class"=9 +CONNECT="connect"=10 +CONNECTOR="connector"=11 +CONSTANT="constant"=12 +DISCRETE="discrete"=13 +EACH="each"=14 +ELSE="else"=15 +ELSEIF="elseif"=16 +ELSEWHEN="elsewhen"=17 +END="end"=18 +ENUMERATION="enumeration"=19 +EQUATION="equation"=20 +ENCAPSULATED="encapsulated"=21 +EXTENDS="extends"=22 +EXTERNAL="external"=23 +FALSE="false"=24 +FINAL="final"=25 +FLOW="flow"=26 +FOR="for"=27 +FUNCTION="function"=28 +IF="if"=29 +IMPORT="import"=30 +IN="in"=31 +INITIAL="initial"=32 +INNER="inner"=33 +INPUT="input"=34 +LOOP="loop"=35 +MODEL="model"=36 +NOT="not"=37 +OUTER="outer"=38 +OVERLOAD="overload"=39 +OR="or"=40 +OUTPUT="output"=41 +PACKAGE="package"=42 +PARAMETER="parameter"=43 +PARTIAL="partial"=44 +PROTECTED="protected"=45 +PUBLIC="public"=46 +RECORD="record"=47 +REDECLARE="redeclare"=48 +REPLACEABLE="replaceable"=49 +RESULTS="results"=50 +THEN="then"=51 +TRUE="true"=52 +TYPE="type"=53 +UNSIGNED_REAL="unsigned_real"=54 +WHEN="when"=55 +WHILE="while"=56 +WITHIN="within"=57 +ABSTYPE="abstype"=58 +AS="as"=59 +AXIOM="axiom"=60 +DATATYPE="datatype"=61 +FAIL="fail"=62 +LET="let"=63 +INTERFACE="interface"=64 +MODULE="module"=65 +OF="of"=66 +RELATION="relation"=67 +RULE="rule"=68 +VAL="val"=69 +WILD="_"=70 +WITH="with"=71 +WITHTYPE="withtype"=72 +LPAR=73 +RPAR=74 +LBRACK=75 +RBRACK=76 +LBRACE=77 +RBRACE=78 +EQUALS=79 +ASSIGN=80 +PLUS=81 +MINUS=82 +STAR=83 +SLASH=84 +DOT=85 +COMMA=86 +LESS=87 +LESSEQ=88 +GREATER=89 +GREATEREQ=90 +EQEQ=91 +LESSGT=92 +COLON=93 +SEMICOLON=94 +POWER=95 +YIELDS=96 +AMPERSAND=97 +PIPEBAR=98 +COLONCOLON=99 +DASHES=100 +WS=101 +ML_COMMENT=102 +ML_COMMENT_CHAR=103 +SL_COMMENT=104 +IDENT("an identifier")=105 +TYVARIDENT("a type identifier")=106 +NONDIGIT=107 +DIGIT=108 +EXPONENT=109 +UNSIGNED_INTEGER=110 +STRING=111 +SCHAR=112 +SESCAPE=113 +ESC=114 +ALGORITHM_STATEMENT=115 +ARGUMENT_LIST=116 +BEGIN_DEFINITION=117 +CLASS_DEFINITION=118 +CLASS_MODIFICATION=119 +CODE_EXPRESSION=120 +CODE_MODIFICATION=121 +CODE_ELEMENT=122 +CODE_EQUATION=123 +CODE_INITIALEQUATION=124 +CODE_ALGORITHM=125 +CODE_INITIALALGORITHM=126 +COMMENT=127 +COMPONENT_DEFINITION=128 +DECLARATION=129 +DEFINITION=130 +END_DEFINITION=131 +ENUMERATION_LITERAL=132 +ELEMENT=133 +ELEMENT_MODIFICATION=134 +ELEMENT_REDECLARATION=135 +EQUATION_STATEMENT=136 +INITIAL_EQUATION=137 +INITIAL_ALGORITHM=138 +IMPORT_DEFINITION=139 +EXPRESSION_LIST=140 +EXTERNAL_FUNCTION_CALL=141 +FOR_INDICES=142 +FOR_ITERATOR=143 +FUNCTION_CALL=144 +INITIAL_FUNCTION_CALL=145 +FUNCTION_ARGUMENTS=146 +NAMED_ARGUMENTS=147 +QUALIFIED=148 +RANGE2=149 +RANGE3=150 +STORED_DEFINITION=151 +STRING_COMMENT=152 +UNARY_MINUS=153 +UNARY_PLUS=154 +UNQUALIFIED=155 diff --git a/tools/xml/flatmodelicaxml/flat_modelica_tree_parser.cpp b/tools/xml/flatmodelicaxml/flat_modelica_tree_parser.cpp new file mode 100644 index 00000000000..f3139ceeb71 --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_tree_parser.cpp @@ -0,0 +1,9109 @@ +/* $ANTLR 2.7.5rc2 (20050108): "walker.g" -> "flat_modelica_tree_parser.cpp"$ */ +#include "flat_modelica_tree_parser.hpp" +#include +#include +#include +#include +#include +#include +#line 47 "walker.g" + + +#line 13 "flat_modelica_tree_parser.cpp" +#line 1 "walker.g" +#line 15 "flat_modelica_tree_parser.cpp" +flat_modelica_tree_parser::flat_modelica_tree_parser() + : ANTLR_USE_NAMESPACE(antlr)TreeParser() { +} + +DOMElement * flat_modelica_tree_parser::stored_definition(RefMyAST _t, + mstring xmlFilename, + mstring mofFilename, + mstring docType +) { +#line 208 "walker.g" + DOMElement *ast; +#line 27 "flat_modelica_tree_parser.cpp" + RefMyAST stored_definition_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST stored_definition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 208 "walker.g" + + DOMElement *within = 0; + //DOMElement*class_def = 0; + l_stack el_stack; + + // initialize xml framework + XMLPlatformUtils::Initialize(); + + // XML DOM creation + DOMImplementation* pDOMImpl = DOMImplementationRegistry::getDOMImplementation(X("Core")); + + + // create the document type (according to flatmodelica.dtd) + DOMDocumentType* pDoctype = pDOMImpl->createDocumentType( + X("modelica"), + NULL, + X(docType.c_str())); + + // create the root element + pFlatModelicaXMLDoc = pDOMImpl->createDocument( + 0, // root element namespace URI. + X("modelica"), // root element name + pDoctype); // document type object (DTD). + + pRootElementModelica = pFlatModelicaXMLDoc->getDocumentElement(); + pRootElementFlatModelicaXML = pFlatModelicaXMLDoc->createElement(X("modelicaxml")); + // set the location of the .mo file we're representing in XML + pRootElementFlatModelicaXML->setAttribute(X("file"), X(mofFilename.c_str())); + + DOMElement* pDefinitionElement = 0; + +#line 66 "flat_modelica_tree_parser.cpp" + + RefMyAST __t2 = _t; + RefMyAST tmp1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp1_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp1_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp1_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp1_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST2 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STORED_DEFINITION); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case WITHIN: + { + pRootElementFlatModelicaXML=within_clause(_t,pRootElementFlatModelicaXML); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case FINAL: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == FINAL || _t->getType() == CLASS_DEFINITION)) { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 246 "walker.g" + pDefinitionElement = pFlatModelicaXMLDoc->createElement(X("definition")); +#line 133 "flat_modelica_tree_parser.cpp" + pDefinitionElement=class_definition(_t,f != NULL, pDefinitionElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 248 "walker.g" + + if (pDefinitionElement && pDefinitionElement->hasChildNodes()) + { + el_stack.push(pDefinitionElement); + } + +#line 144 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop6; + } + + } + _loop6:; + } // ( ... )* + currentAST = __currentAST2; + _t = __t2; + _t = _t->getNextSibling(); +#line 256 "walker.g" + + //pRootElementFlatModelicaXML = within; + + pRootElementFlatModelicaXML = (DOMElement*)appendKids(el_stack, pRootElementFlatModelicaXML); + pRootElementModelica->appendChild(pRootElementFlatModelicaXML); + ast = pRootElementModelica; + + unsigned int elementCount = pFlatModelicaXMLDoc->getElementsByTagName(X("*"))->getLength(); + std::cout << std::endl; + std::cout << "The tree just created contains: " << elementCount + << " elements." << std::endl; + + // create the writer + DOMWriter* domWriter = pDOMImpl->createDOMWriter(); + // set the pretty print feature + if (domWriter->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) + domWriter->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true); + // fix the file + + XMLFormatTarget *myFormatTarget = new LocalFileFormatTarget(X(xmlFilename.c_str())); + //XMLFormatTarget *myOutFormatTarget = new StdOutFormatTarget; + + // serialize a DOMNode to the local file " + domWriter->writeNode(myFormatTarget, *pFlatModelicaXMLDoc); + //domWriter->writeNode(myOutFormatTarget, *pFlatModelicaXMLDoc); + + myFormatTarget->flush(); + //myOutFormatTarget->flush(); + domWriter->release(); + + delete myFormatTarget; + //delete myOutFormatTarget; + // release the document + pFlatModelicaXMLDoc->release(); + // terminate the XML framework + XMLPlatformUtils::Terminate(); + +#line 194 "flat_modelica_tree_parser.cpp" + stored_definition_AST = RefMyAST(currentAST.root); + returnAST = stored_definition_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::within_clause(RefMyAST _t, + DOMElement* parent +) { +#line 298 "walker.g" + DOMElement* ast; +#line 206 "flat_modelica_tree_parser.cpp" + RefMyAST within_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST within_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 298 "walker.g" + + void* pNamePath = 0; + +#line 215 "flat_modelica_tree_parser.cpp" + + RefMyAST __t8 = _t; + RefMyAST tmp2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp2_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp2_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST8 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WITHIN); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT: + case IDENT: + { + pNamePath=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST8; + _t = __t8; + _t = _t->getNextSibling(); +#line 303 "walker.g" + + if (pNamePath) parent->setAttribute(X("within"), X(((mstring *)pNamePath)->c_str())); + ast = parent; + +#line 258 "flat_modelica_tree_parser.cpp" + within_clause_AST = RefMyAST(currentAST.root); + returnAST = within_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::class_definition(RefMyAST _t, + bool final, DOMElement *definitionElement +) { +#line 312 "walker.g" + DOMElement* ast; +#line 270 "flat_modelica_tree_parser.cpp" + RefMyAST class_definition_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_definition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 312 "walker.g" + + class_specifier_t sClassSpec; + sClassSpec.composition = definitionElement; + +#line 288 "flat_modelica_tree_parser.cpp" + + RefMyAST __t11 = _t; + RefMyAST tmp3_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp3_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp3_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp3_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp3_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST11 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CLASS_DEFINITION); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ENCAPSULATED: + { + e = _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENCAPSULATED); + _t = _t->getNextSibling(); + break; + } + case BLOCK: + case CLASS: + case CONNECTOR: + case FUNCTION: + case MODEL: + case PACKAGE: + case PARTIAL: + case RECORD: + case TYPE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PARTIAL: + { + p = _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PARTIAL); + _t = _t->getNextSibling(); + break; + } + case BLOCK: + case CLASS: + case CONNECTOR: + case FUNCTION: + case MODEL: + case PACKAGE: + case RECORD: + case TYPE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + r = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + class_restriction(_t); + _t = _retTree; + r_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + class_specifier(_t,sClassSpec); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 322 "walker.g" + definitionElement=sClassSpec.composition; +#line 382 "flat_modelica_tree_parser.cpp" + currentAST = __currentAST11; + _t = __t11; + _t = _t->getNextSibling(); +#line 324 "walker.g" + + definitionElement->setAttribute(X("ident"), X(i->getText().c_str())); + + definitionElement->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + definitionElement->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (p != 0) definitionElement->setAttribute(X("partial"), X("true")); + if (final) definitionElement->setAttribute(X("final"), X("true")); + if (e != 0) definitionElement->setAttribute(X("encapsulated"), X("true")); + if (r) definitionElement->setAttribute(X("restriction"), str2xml(r)); + if (sClassSpec.string_comment) + { + definitionElement->appendChild(sClassSpec.string_comment); + } + if (sClassSpec.composition) + { + // nothing to do, already done at the lower level. + //definitionElement->appendChild(sClassSpec.composition); + //appendKids(definitionElement, sClassSpec.composition); + } + if (sClassSpec.derived) + { + definitionElement->appendChild(sClassSpec.derived); + } + if (sClassSpec.enumeration) + { + definitionElement->appendChild(sClassSpec.enumeration); + } + if (sClassSpec.overload) + { + definitionElement->appendChild(sClassSpec.overload); + } + ast = definitionElement; + +#line 421 "flat_modelica_tree_parser.cpp" + class_definition_AST = RefMyAST(currentAST.root); + returnAST = class_definition_AST; + _retTree = _t; + return ast; +} + +void * flat_modelica_tree_parser::name_path(RefMyAST _t) { +#line 2277 "walker.g" + void *ast; +#line 431 "flat_modelica_tree_parser.cpp" + RefMyAST name_path_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST name_path_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2277 "walker.g" + + void *s1=0; + void *s2=0; + +#line 447 "flat_modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENT: + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); +#line 2284 "walker.g" + + ast = (void*)new mstring(i->getText()); + +#line 464 "flat_modelica_tree_parser.cpp" + name_path_AST = RefMyAST(currentAST.root); + break; + } + case DOT: + { + RefMyAST __t295 = _t; + d = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST d_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + d_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(d)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST295 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT); + _t = _t->getFirstChild(); + i2 = _t; + RefMyAST i2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i2_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + s2=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST295; + _t = __t295; + _t = _t->getNextSibling(); +#line 2288 "walker.g" + + s1 = (void*)new mstring(i2->getText()); + ast = (void*)new mstring(mstring(((mstring*)s1)->c_str())+mstring(".")+mstring(((mstring*)s2)->c_str())); + +#line 497 "flat_modelica_tree_parser.cpp" + name_path_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = name_path_AST; + _retTree = _t; + return ast; +} + +void flat_modelica_tree_parser::class_restriction(RefMyAST _t) { + RefMyAST class_restriction_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_restriction_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS: + { + RefMyAST tmp4_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp4_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp4_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp4_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp4_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CLASS); + _t = _t->getNextSibling(); + break; + } + case MODEL: + { + RefMyAST tmp5_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp5_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp5_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp5_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp5_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MODEL); + _t = _t->getNextSibling(); + break; + } + case RECORD: + { + RefMyAST tmp6_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp6_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp6_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp6_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp6_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RECORD); + _t = _t->getNextSibling(); + break; + } + case BLOCK: + { + RefMyAST tmp7_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp7_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp7_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp7_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp7_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BLOCK); + _t = _t->getNextSibling(); + break; + } + case CONNECTOR: + { + RefMyAST tmp8_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp8_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp8_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp8_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp8_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONNECTOR); + _t = _t->getNextSibling(); + break; + } + case TYPE: + { + RefMyAST tmp9_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp9_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp9_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp9_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp9_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TYPE); + _t = _t->getNextSibling(); + break; + } + case PACKAGE: + { + RefMyAST tmp10_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp10_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp10_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp10_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp10_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE); + _t = _t->getNextSibling(); + break; + } + case FUNCTION: + { + RefMyAST tmp11_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp11_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp11_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp11_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp11_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + class_restriction_AST = RefMyAST(currentAST.root); + returnAST = class_restriction_AST; + _retTree = _t; +} + +void flat_modelica_tree_parser::class_specifier(RefMyAST _t, + class_specifier_t& sClassSpec +) { + RefMyAST class_specifier_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_specifier_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 381 "walker.g" + + DOMElement *comp = 0; + DOMElement *cmt = 0; + DOMElement *d = 0; + DOMElement *e = 0; + DOMElement *o = 0; + +#line 635 "flat_modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case 3: + case ALGORITHM: + case ANNOTATION: + case EQUATION: + case EXTENDS: + case EXTERNAL: + case IMPORT: + case PROTECTED: + case PUBLIC: + case DECLARATION: + case DEFINITION: + case INITIAL_EQUATION: + case INITIAL_ALGORITHM: + case STRING_COMMENT: + { + { + { + cmt=string_comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + comp=composition(_t,sClassSpec.composition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 392 "walker.g" + + if (cmt) sClassSpec.string_comment = cmt; + sClassSpec.composition = comp; + +#line 669 "flat_modelica_tree_parser.cpp" + } + class_specifier_AST = RefMyAST(currentAST.root); + break; + } + case EQUALS: + { + RefMyAST __t20 = _t; + RefMyAST tmp12_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp12_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp12_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp12_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp12_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST20 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { + d=derived_class(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ENUMERATION: + { + e=enumeration(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case OVERLOAD: + { + o=overloading(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST20; + _t = __t20; + _t = _t->getNextSibling(); +#line 402 "walker.g" + + sClassSpec.derived = d; + sClassSpec.enumeration = e; + sClassSpec.overload = o; + +#line 734 "flat_modelica_tree_parser.cpp" + class_specifier_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = class_specifier_AST; + _retTree = _t; +} + +DOMElement* flat_modelica_tree_parser::string_comment(RefMyAST _t) { +#line 2530 "walker.g" + DOMElement* ast; +#line 750 "flat_modelica_tree_parser.cpp" + RefMyAST string_comment_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST string_comment_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sc = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case STRING_COMMENT: + { +#line 2531 "walker.g" + + DOMElement* cmt=0; + ast = 0; + +#line 768 "flat_modelica_tree_parser.cpp" + RefMyAST __t340 = _t; + sc = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST sc_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + sc_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(sc)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(sc_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST340 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING_COMMENT); + _t = _t->getFirstChild(); + cmt=string_concatenation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST340; + _t = __t340; + _t = _t->getNextSibling(); +#line 2536 "walker.g" + + DOMElement *pStringComment = pFlatModelicaXMLDoc->createElement(X("string_comment")); + + pStringComment->setAttribute(X("sline"), X(itoa(sc->getLine(),stmp,10))); + pStringComment->setAttribute(X("scolumn"), X(itoa(sc->getColumn(),stmp,10))); + + pStringComment->appendChild(cmt); + ast = pStringComment; + +#line 795 "flat_modelica_tree_parser.cpp" + string_comment_AST = RefMyAST(currentAST.root); + break; + } + case 3: + case ALGORITHM: + case ANNOTATION: + case EQUATION: + case EXTENDS: + case EXTERNAL: + case IMPORT: + case PROTECTED: + case PUBLIC: + case DECLARATION: + case DEFINITION: + case INITIAL_EQUATION: + case INITIAL_ALGORITHM: + { +#line 2546 "walker.g" + + ast = 0; + +#line 817 "flat_modelica_tree_parser.cpp" + string_comment_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = string_comment_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::composition(RefMyAST _t, + DOMElement* definition +) { +#line 529 "walker.g" + DOMElement* ast; +#line 836 "flat_modelica_tree_parser.cpp" + RefMyAST composition_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST composition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 529 "walker.g" + + DOMElement* el = 0; + l_stack el_stack; + DOMElement* ann; + DOMElement* pExternalFunctionCall = 0; + +#line 848 "flat_modelica_tree_parser.cpp" + + definition=element_list(_t,1 /* public */, definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_0.member(_t->getType()))) { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PUBLIC: + { + definition=public_element_list(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case PROTECTED: + { + definition=protected_element_list(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case EQUATION: + case INITIAL_EQUATION: + { + definition=equation_clause(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ALGORITHM: + case INITIAL_ALGORITHM: + { + definition=algorithm_clause(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + else { + goto _loop43; + } + + } + _loop43:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTERNAL: + { + RefMyAST __t45 = _t; + RefMyAST tmp13_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp13_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp13_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp13_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp13_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST45 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXTERNAL); + _t = _t->getFirstChild(); +#line 546 "walker.g" + pExternalFunctionCall = pFlatModelicaXMLDoc->createElement(X("external")); +#line 925 "flat_modelica_tree_parser.cpp" + { + pExternalFunctionCall=external_function_call(_t,pExternalFunctionCall); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ANNOTATION) && (_t->getType() == 3 || _t->getType() == ANNOTATION)) { + pExternalFunctionCall=annotation(_t,0 /*none*/, pExternalFunctionCall, INSIDE_EXTERNAL); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else if ((_t->getType() == 3 || _t->getType() == ANNOTATION) && (_t->getType() == 3 || _t->getType() == ANNOTATION)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + + } + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ANNOTATION)) { +#line 550 "walker.g" + pExternalFunctionCall->appendChild(pFlatModelicaXMLDoc->createElement(X("semicolon"))); +#line 953 "flat_modelica_tree_parser.cpp" + pExternalFunctionCall=annotation(_t,0 /*none*/, pExternalFunctionCall, INSIDE_EXTERNAL); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else { + goto _loop49; + } + + } + _loop49:; + } // ( ... )* + currentAST = __currentAST45; + _t = __t45; + _t = _t->getNextSibling(); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 555 "walker.g" + + if (pExternalFunctionCall) definition->appendChild(pExternalFunctionCall); + ast = definition; + +#line 985 "flat_modelica_tree_parser.cpp" + composition_AST = RefMyAST(currentAST.root); + returnAST = composition_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::derived_class(RefMyAST _t) { +#line 413 "walker.g" + DOMElement* ast; +#line 995 "flat_modelica_tree_parser.cpp" + RefMyAST derived_class_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST derived_class_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 413 "walker.g" + + void* p = 0; + DOMElement* as = 0; + void *cmod = 0; + DOMElement* cmt = 0; + DOMElement* attr = 0; + type_prefix_t pfx; + DOMElement* pDerived = pFlatModelicaXMLDoc->createElement(X("derived")); + +#line 1010 "flat_modelica_tree_parser.cpp" + + { + type_prefix(_t,pDerived); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + p=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + as=array_subscripts(_t,0); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case CLASS_MODIFICATION: + case COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_MODIFICATION: + { + cmod=class_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 429 "walker.g" + + if (p) pDerived->setAttribute(X("type"), X(((mstring*)p)->c_str())); + if (as) pDerived->appendChild(as); + if (cmod) pDerived = (DOMElement*)appendKidsFromStack((l_stack *)cmod, pDerived); + if (cmt) pDerived->appendChild(cmt); + ast = pDerived; + +#line 1093 "flat_modelica_tree_parser.cpp" + } + derived_class_AST = RefMyAST(currentAST.root); + returnAST = derived_class_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::enumeration(RefMyAST _t) { +#line 442 "walker.g" + DOMElement* ast; +#line 1104 "flat_modelica_tree_parser.cpp" + RefMyAST enumeration_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enumeration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST en = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST en_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 442 "walker.g" + + l_stack el_stack; + DOMElement* el = 0; + DOMElement* cmt = 0; + +#line 1117 "flat_modelica_tree_parser.cpp" + + RefMyAST __t28 = _t; + en = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST en_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + en_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(en)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(en_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST28 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENUMERATION); + _t = _t->getFirstChild(); + el=enumeration_literal(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 451 "walker.g" + el_stack.push(el); +#line 1134 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ENUMERATION_LITERAL)) { + el=enumeration_literal(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 454 "walker.g" + el_stack.push(el); +#line 1145 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop30; + } + + } + _loop30:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST28; + _t = __t28; + _t = _t->getNextSibling(); +#line 459 "walker.g" + + DOMElement* pEnumeration = pFlatModelicaXMLDoc->createElement(X("enumeration")); + pEnumeration = (DOMElement*)appendKids(el_stack, pEnumeration); + if (cmt) pEnumeration->appendChild(cmt); + + pEnumeration->setAttribute(X("sline"), X(itoa(en->getLine(),stmp,10))); + pEnumeration->setAttribute(X("scolumn"), X(itoa(en->getColumn(),stmp,10))); + + ast = pEnumeration; + +#line 1189 "flat_modelica_tree_parser.cpp" + enumeration_AST = RefMyAST(currentAST.root); + returnAST = enumeration_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::overloading(RefMyAST _t) { +#line 497 "walker.g" + DOMElement* ast; +#line 1199 "flat_modelica_tree_parser.cpp" + RefMyAST overloading_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST overloading_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ov = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ov_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 497 "walker.g" + + std::stack el_stack; + void* el = 0; + DOMElement* cmt = 0; + +#line 1212 "flat_modelica_tree_parser.cpp" + + RefMyAST __t36 = _t; + ov = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST ov_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ov_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ov)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ov_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST36 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OVERLOAD); + _t = _t->getFirstChild(); + el=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 506 "walker.g" + el_stack.push(el); +#line 1229 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == DOT || _t->getType() == IDENT)) { + el=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 509 "walker.g" + el_stack.push(el); +#line 1240 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop38; + } + + } + _loop38:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST36; + _t = __t36; + _t = _t->getNextSibling(); +#line 514 "walker.g" + + DOMElement* pOverload = pFlatModelicaXMLDoc->createElement(X("overload")); + if (cmt) pOverload->appendChild(cmt); + + pOverload->setAttribute(X("sline"), X(itoa(ov->getLine(),stmp,10))); + pOverload->setAttribute(X("scolumn"), X(itoa(ov->getColumn(),stmp,10))); + + ast = pOverload; + +#line 1283 "flat_modelica_tree_parser.cpp" + overloading_AST = RefMyAST(currentAST.root); + returnAST = overloading_AST; + _retTree = _t; + return ast; +} + +void flat_modelica_tree_parser::type_prefix(RefMyAST _t, + DOMElement* parent +) { + RefMyAST type_prefix_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST type_prefix_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FLOW: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FLOW); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DISCRETE: + { + d = _t; + RefMyAST d_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + d_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(d)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRETE); + _t = _t->getNextSibling(); + break; + } + case PARAMETER: + { + p = _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PARAMETER); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + { + c = _t; + RefMyAST c_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + c_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(c)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONSTANT); + _t = _t->getNextSibling(); + break; + } + case INPUT: + case OUTPUT: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case INPUT: + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INPUT); + _t = _t->getNextSibling(); + break; + } + case OUTPUT: + { + o = _t; + RefMyAST o_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + o_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(o)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(o_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OUTPUT); + _t = _t->getNextSibling(); + break; + } + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 917 "walker.g" + + if (f != NULL) { parent->setAttribute(X("flow"), X("true")); } + //else { parent->setAttribute(X("flow"), X("none")); } + if (d != NULL) { parent->setAttribute(X("variability"), X("discrete")); } + else if (p != NULL) { parent->setAttribute(X("variability"), X("parameter")); } + else if (c != NULL) { parent->setAttribute(X("variability"), X("constant")); } + //else { parent->setAttribute(X("variability"), X("variable")); } + if (i != NULL) { parent->setAttribute(X("direction"), X("input")); } + else if (o != NULL) { parent->setAttribute(X("direction"), X("output")); } + //else { parent->setAttribute(X("direction"), X("bidirectional")); } + +#line 1434 "flat_modelica_tree_parser.cpp" + type_prefix_AST = RefMyAST(currentAST.root); + returnAST = type_prefix_AST; + _retTree = _t; +} + +DOMElement* flat_modelica_tree_parser::array_subscripts(RefMyAST _t, + int kind +) { +#line 2463 "walker.g" + DOMElement* ast; +#line 1445 "flat_modelica_tree_parser.cpp" + RefMyAST array_subscripts_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST array_subscripts_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbk = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbk_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2463 "walker.g" + + l_stack el_stack; + DOMElement* s = 0; + DOMElement *pArraySubscripts = 0; + if (kind) + pArraySubscripts = pFlatModelicaXMLDoc->createElement(X("type_array_subscripts")); + else + pArraySubscripts = pFlatModelicaXMLDoc->createElement(X("array_subscripts")); + +#line 1462 "flat_modelica_tree_parser.cpp" + + RefMyAST __t331 = _t; + lbk = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lbk_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lbk_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lbk)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lbk_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST331 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LBRACK); + _t = _t->getFirstChild(); + pArraySubscripts=subscript(_t,pArraySubscripts); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_1.member(_t->getType()))) { + pArraySubscripts=subscript(_t,pArraySubscripts); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else { + goto _loop333; + } + + } + _loop333:; + } // ( ... )* + currentAST = __currentAST331; + _t = __t331; + _t = _t->getNextSibling(); +#line 2476 "walker.g" + + + pArraySubscripts->setAttribute(X("sline"), X(itoa(lbk->getLine(),stmp,10))); + pArraySubscripts->setAttribute(X("scolumn"), X(itoa(lbk->getColumn(),stmp,10))); + + ast = pArraySubscripts; + +#line 1504 "flat_modelica_tree_parser.cpp" + array_subscripts_AST = RefMyAST(currentAST.root); + returnAST = array_subscripts_AST; + _retTree = _t; + return ast; +} + +void * flat_modelica_tree_parser::class_modification(RefMyAST _t) { +#line 1036 "walker.g" + void *stack; +#line 1514 "flat_modelica_tree_parser.cpp" + RefMyAST class_modification_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1036 "walker.g" + + stack = 0; + +#line 1523 "flat_modelica_tree_parser.cpp" + + RefMyAST __t122 = _t; + RefMyAST tmp14_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp14_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp14_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp14_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp14_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST122 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CLASS_MODIFICATION); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ARGUMENT_LIST: + { + stack=argument_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST122; + _t = __t122; + _t = _t->getNextSibling(); + class_modification_AST = RefMyAST(currentAST.root); + returnAST = class_modification_AST; + _retTree = _t; + return stack; +} + +DOMElement* flat_modelica_tree_parser::comment(RefMyAST _t) { +#line 2509 "walker.g" + DOMElement* ast; +#line 1569 "flat_modelica_tree_parser.cpp" + RefMyAST comment_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST comment_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2509 "walker.g" + + DOMElement* ann=0; + DOMElement* cmt=0; + ast = 0; + DOMElement *pComment = pFlatModelicaXMLDoc->createElement(X("comment")); + bool bAnno = false; + +#line 1584 "flat_modelica_tree_parser.cpp" + + RefMyAST __t337 = _t; + c = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST c_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + c_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(c)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST337 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMMENT); + _t = _t->getFirstChild(); + cmt=string_comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2517 "walker.g" + if (cmt) pComment->appendChild(cmt); +#line 1601 "flat_modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ANNOTATION: + { + pComment=annotation(_t,0 /* none */, pComment, INSIDE_COMMENT); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2518 "walker.g" + bAnno = true; +#line 1613 "flat_modelica_tree_parser.cpp" + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST337; + _t = __t337; + _t = _t->getNextSibling(); +#line 2519 "walker.g" + + if (c) + { + pComment->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pComment->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + } + if ((cmt !=0) || bAnno) ast = pComment; + else ast = 0; + +#line 1639 "flat_modelica_tree_parser.cpp" + comment_AST = RefMyAST(currentAST.root); + returnAST = comment_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::enumeration_literal(RefMyAST _t) { +#line 475 "walker.g" + DOMElement* ast; +#line 1649 "flat_modelica_tree_parser.cpp" + RefMyAST enumeration_literal_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enumeration_literal_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i1 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + +#line 476 "walker.g" + + DOMElement* c1=0; + +#line 1661 "flat_modelica_tree_parser.cpp" + RefMyAST __t33 = _t; + RefMyAST tmp15_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp15_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp15_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp15_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp15_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST33 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENUMERATION_LITERAL); + _t = _t->getFirstChild(); + i1 = _t; + RefMyAST i1_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i1_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i1_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + c1=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST33; + _t = __t33; + _t = _t->getNextSibling(); +#line 480 "walker.g" + + DOMElement* pEnumerationLiteral = pFlatModelicaXMLDoc->createElement(X("enumeration_literal")); + pEnumerationLiteral->setAttribute(X("ident"), str2xml(i1)); + + pEnumerationLiteral->setAttribute(X("sline"), X(itoa(i1->getLine(),stmp,10))); + pEnumerationLiteral->setAttribute(X("scolumn"), X(itoa(i1->getColumn(),stmp,10))); + + if (c1) pEnumerationLiteral->appendChild(c1); + ast = pEnumerationLiteral; + +#line 1714 "flat_modelica_tree_parser.cpp" + enumeration_literal_AST = RefMyAST(currentAST.root); + returnAST = enumeration_literal_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::element_list(RefMyAST _t, + int iSwitch, DOMElement*definition +) { +#line 655 "walker.g" + DOMElement* ast; +#line 1726 "flat_modelica_tree_parser.cpp" + RefMyAST element_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 655 "walker.g" + + DOMElement* e = 0; + l_stack el_stack; + DOMElement* ann = 0; + +#line 1737 "flat_modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTENDS: + case IMPORT: + case DECLARATION: + case DEFINITION: + { + { + definition=element(_t,iSwitch, definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ANNOTATION: + { + { + definition=annotation(_t,iSwitch, definition, INSIDE_ELEMENT); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop67; + } + } + } + _loop67:; + } // ( ... )* +#line 664 "walker.g" + + ast = definition; + +#line 1777 "flat_modelica_tree_parser.cpp" + element_list_AST = RefMyAST(currentAST.root); + returnAST = element_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::public_element_list(RefMyAST _t, + DOMElement* definition +) { +#line 561 "walker.g" + DOMElement* ast; +#line 1789 "flat_modelica_tree_parser.cpp" + RefMyAST public_element_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST public_element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 561 "walker.g" + + DOMElement* el; + +#line 1800 "flat_modelica_tree_parser.cpp" + + RefMyAST __t51 = _t; + p = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST51 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PUBLIC); + _t = _t->getFirstChild(); + definition=element_list(_t,1 /* public */, definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST51; + _t = __t51; + _t = _t->getNextSibling(); +#line 569 "walker.g" + + ast = definition; + +#line 1822 "flat_modelica_tree_parser.cpp" + public_element_list_AST = RefMyAST(currentAST.root); + returnAST = public_element_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::protected_element_list(RefMyAST _t, + DOMElement* definition +) { +#line 574 "walker.g" + DOMElement* ast; +#line 1834 "flat_modelica_tree_parser.cpp" + RefMyAST protected_element_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST protected_element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 574 "walker.g" + + DOMElement* el; + +#line 1845 "flat_modelica_tree_parser.cpp" + + RefMyAST __t53 = _t; + p = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST53 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED); + _t = _t->getFirstChild(); + definition=element_list(_t,2 /* protected */, definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST53; + _t = __t53; + _t = _t->getNextSibling(); +#line 583 "walker.g" + + ast = definition; + +#line 1867 "flat_modelica_tree_parser.cpp" + protected_element_list_AST = RefMyAST(currentAST.root); + returnAST = protected_element_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::equation_clause(RefMyAST _t, + DOMElement *definition +) { +#line 1179 "walker.g" + DOMElement* ast; +#line 1879 "flat_modelica_tree_parser.cpp" + RefMyAST equation_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1179 "walker.g" + + l_stack el_stack; + DOMElement* e = 0; + DOMElement* ann = 0; + +#line 1892 "flat_modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUATION: + { + RefMyAST __t147 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST147 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUATION); + _t = _t->getFirstChild(); + { + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUATION_STATEMENT: + { + definition=equation(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ANNOTATION: + { + definition=annotation(_t,0 /*none*/, definition, INSIDE_EQUATION); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + goto _loop150; + } + } + } + _loop150:; + } // ( ... )* + } + currentAST = __currentAST147; + _t = __t147; + _t = _t->getNextSibling(); +#line 1193 "walker.g" + + ast = definition; + +#line 1945 "flat_modelica_tree_parser.cpp" + equation_clause_AST = RefMyAST(currentAST.root); + break; + } + case INITIAL_EQUATION: + { + RefMyAST __t151 = _t; + RefMyAST tmp16_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp16_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp16_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp16_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp16_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST151 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INITIAL_EQUATION); + _t = _t->getFirstChild(); + RefMyAST __t152 = _t; + RefMyAST tmp17_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp17_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp17_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp17_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp17_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST152 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUATION); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUATION_STATEMENT: + { + definition=equation(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ANNOTATION: + { + definition=annotation(_t,0 /* none */, definition, INSIDE_EQUATION ); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + goto _loop154; + } + } + } + _loop154:; + } // ( ... )* + currentAST = __currentAST152; + _t = __t152; + _t = _t->getNextSibling(); +#line 1203 "walker.g" + + ast = definition; + +#line 2007 "flat_modelica_tree_parser.cpp" + currentAST = __currentAST151; + _t = __t151; + _t = _t->getNextSibling(); + equation_clause_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = equation_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::algorithm_clause(RefMyAST _t, + DOMElement* definition +) { +#line 1209 "walker.g" + DOMElement* ast; +#line 2029 "flat_modelica_tree_parser.cpp" + RefMyAST algorithm_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1209 "walker.g" + + l_stack el_stack; + DOMElement* e; + DOMElement* ann; + +#line 2040 "flat_modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ALGORITHM: + { + RefMyAST __t156 = _t; + RefMyAST tmp18_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp18_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp18_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp18_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp18_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST156 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALGORITHM); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ALGORITHM_STATEMENT: + { + definition=algorithm(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ANNOTATION: + { + definition=annotation(_t,0 /* none */, definition, INSIDE_ALGORITHM); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + goto _loop158; + } + } + } + _loop158:; + } // ( ... )* + currentAST = __currentAST156; + _t = __t156; + _t = _t->getNextSibling(); +#line 1220 "walker.g" + + ast = definition; + +#line 2092 "flat_modelica_tree_parser.cpp" + algorithm_clause_AST = RefMyAST(currentAST.root); + break; + } + case INITIAL_ALGORITHM: + { + RefMyAST __t159 = _t; + RefMyAST tmp19_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp19_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp19_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp19_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp19_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST159 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INITIAL_ALGORITHM); + _t = _t->getFirstChild(); + RefMyAST __t160 = _t; + RefMyAST tmp20_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp20_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp20_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp20_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST160 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALGORITHM); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ALGORITHM_STATEMENT: + { + definition=algorithm(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ANNOTATION: + { + definition=annotation(_t,0 /* none */, definition, INSIDE_ALGORITHM); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + goto _loop162; + } + } + } + _loop162:; + } // ( ... )* + currentAST = __currentAST160; + _t = __t160; + _t = _t->getNextSibling(); +#line 1229 "walker.g" + + ast = definition; + +#line 2154 "flat_modelica_tree_parser.cpp" + currentAST = __currentAST159; + _t = __t159; + _t = _t->getNextSibling(); + algorithm_clause_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = algorithm_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::external_function_call(RefMyAST _t, + DOMElement *pExternalFunctionCall +) { +#line 599 "walker.g" + DOMElement* ast; +#line 2176 "flat_modelica_tree_parser.cpp" + RefMyAST external_function_call_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST external_function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 599 "walker.g" + + DOMElement* temp=0; + DOMElement* temp2=0; + DOMElement* temp3=0; + ast = 0; + DOMElement* pExternalEqual = pFlatModelicaXMLDoc->createElement(X("external_equal")); + +#line 2197 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case STRING: + { + s = _t; + RefMyAST s_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + s_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(s)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING); + _t = _t->getNextSibling(); + break; + } + case 3: + case ANNOTATION: + case EXTERNAL_FUNCTION_CALL: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTERNAL_FUNCTION_CALL: + { + RefMyAST __t57 = _t; + RefMyAST tmp21_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp21_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp21_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp21_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp21_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST57 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXTERNAL_FUNCTION_CALL); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENT: + { + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXPRESSION_LIST: + { + temp=expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } +#line 612 "walker.g" + + if (s != NULL) pExternalFunctionCall->setAttribute(X("language_specification"), str2xml(s)); + if (i != NULL) pExternalFunctionCall->setAttribute(X("ident"), str2xml(i)); + if (temp) pExternalFunctionCall->appendChild(temp); + + pExternalFunctionCall->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pExternalFunctionCall->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pExternalFunctionCall; + +#line 2288 "flat_modelica_tree_parser.cpp" + break; + } + case EQUALS: + { + RefMyAST __t61 = _t; + e = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST61 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + temp2=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + i2 = _t; + RefMyAST i2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i2_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXPRESSION_LIST: + { + temp3=expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST61; + _t = __t61; + _t = _t->getNextSibling(); +#line 623 "walker.g" + + if (s != NULL) pExternalFunctionCall->setAttribute(X("language_specification"), str2xml(s)); + if (i2 != NULL) pExternalFunctionCall->setAttribute(X("ident"), str2xml(i2)); + pExternalFunctionCall->setAttribute(X("sline"), X(itoa(i2->getLine(),stmp,10))); + pExternalFunctionCall->setAttribute(X("scolumn"), X(itoa(i2->getColumn(),stmp,10))); + DOMElement* pExternalEqual = + pFlatModelicaXMLDoc->createElement(X("external_equal")); + if (temp2) pExternalEqual->appendChild(temp2); + pExternalFunctionCall->appendChild(pExternalEqual); + if (temp3) pExternalFunctionCall->appendChild(temp3); + ast = pExternalFunctionCall; + +#line 2349 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST57; + _t = __t57; + _t = _t->getNextSibling(); + break; + } + case 3: + case ANNOTATION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 637 "walker.g" + + if (!ast) + { + //parent->appendChild(ast); + ast = pExternalFunctionCall; + } + +#line 2382 "flat_modelica_tree_parser.cpp" + external_function_call_AST = RefMyAST(currentAST.root); + returnAST = external_function_call_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::annotation(RefMyAST _t, + int iSwitch, DOMElement *parent, enum anno awhere +) { +#line 2590 "walker.g" + DOMElement* ast; +#line 2394 "flat_modelica_tree_parser.cpp" + RefMyAST annotation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST annotation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST a = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2590 "walker.g" + + void* cmod=0; + +#line 2405 "flat_modelica_tree_parser.cpp" + + RefMyAST __t344 = _t; + a = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST a_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + a_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(a)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST344 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ANNOTATION); + _t = _t->getFirstChild(); + cmod=class_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST344; + _t = __t344; + _t = _t->getNextSibling(); +#line 2596 "walker.g" + + DOMElement *pAnnotation = pFlatModelicaXMLDoc->createElement(X("annotation")); + + pAnnotation->setAttribute(X("sline"), X(itoa(a->getLine(),stmp,10))); + pAnnotation->setAttribute(X("scolumn"), X(itoa(a->getColumn(),stmp,10))); + + switch (awhere) + { + case INSIDE_ELEMENT: + pAnnotation->setAttribute(X("inside"), X("element")); + break; + case INSIDE_EQUATION: + pAnnotation->setAttribute(X("inside"), X("equation")); + break; + case INSIDE_ALGORITHM: + pAnnotation->setAttribute(X("inside"), X("algorithm")); + break; + case INSIDE_COMMENT: + pAnnotation->setAttribute(X("inside"), X("comment")); + break; + default: + //pAnnotation->setAttribute(X("inside"), X("unspecified")); + ; + } + setVisibility(iSwitch, pAnnotation); + if (cmod) pAnnotation = (DOMElement*)appendKidsFromStack((l_stack *)cmod, pAnnotation); + parent->appendChild(pAnnotation); + ast = parent; + +#line 2453 "flat_modelica_tree_parser.cpp" + annotation_AST = RefMyAST(currentAST.root); + returnAST = annotation_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::expression_list(RefMyAST _t) { +#line 2413 "walker.g" + DOMElement* ast; +#line 2463 "flat_modelica_tree_parser.cpp" + RefMyAST expression_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2413 "walker.g" + + l_stack el_stack; + DOMElement* e; + //DOMElement* pComma = pFlatModelicaXMLDoc->createElement(X("comma")); + +#line 2476 "flat_modelica_tree_parser.cpp" + + { + RefMyAST __t322 = _t; + el = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST el_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + el_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(el)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(el_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST322 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXPRESSION_LIST); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2421 "walker.g" + el_stack.push(e); +#line 2494 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_2.member(_t->getType()))) { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2422 "walker.g" + el_stack.push(pFlatModelicaXMLDoc->createElement(X("comma"))); el_stack.push(e); +#line 2505 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop324; + } + + } + _loop324:; + } // ( ... )* + currentAST = __currentAST322; + _t = __t322; + _t = _t->getNextSibling(); + } +#line 2425 "walker.g" + + ast = (DOMElement*)stack2DOMNode(el_stack, "expression_list"); + + ast->setAttribute(X("sline"), X(itoa(el->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(el->getColumn(),stmp,10))); + +#line 2525 "flat_modelica_tree_parser.cpp" + expression_list_AST = RefMyAST(currentAST.root); + returnAST = expression_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::component_reference(RefMyAST _t) { +#line 2294 "walker.g" + DOMElement* ast; +#line 2535 "flat_modelica_tree_parser.cpp" + RefMyAST component_reference_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_reference_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2294 "walker.g" + + DOMElement* arr = 0; + DOMElement* id = 0; + +#line 2549 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENT: + { + RefMyAST __t298 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST298 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + arr=array_subscripts(_t,0); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST298; + _t = __t298; + _t = _t->getNextSibling(); +#line 2301 "walker.g" + + DOMElement *pCref = pFlatModelicaXMLDoc->createElement(X("component_reference")); + + pCref->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pCref->setAttribute(X("ident"), str2xml(i)); + if (arr) pCref->appendChild(arr); + ast = pCref; + +#line 2602 "flat_modelica_tree_parser.cpp" + break; + } + case DOT: + { + RefMyAST __t300 = _t; + RefMyAST tmp22_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp22_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp22_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp22_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST300 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT); + _t = _t->getFirstChild(); + RefMyAST __t301 = _t; + i2 = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i2_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST301 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + arr=array_subscripts(_t,0); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST301; + _t = __t301; + _t = _t->getNextSibling(); + ast=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST300; + _t = __t300; + _t = _t->getNextSibling(); +#line 2313 "walker.g" + + DOMElement *pCref = pFlatModelicaXMLDoc->createElement(X("component_reference")); + pCref->setAttribute(X("ident"), str2xml(i2)); + + pCref->setAttribute(X("sline"), X(itoa(i2->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i2->getColumn(),stmp,10))); + + if (arr) pCref->appendChild(arr); + pCref->appendChild(ast); + ast = pCref; + +#line 2670 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + component_reference_AST = RefMyAST(currentAST.root); + returnAST = component_reference_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::element(RefMyAST _t, + int iSwitch, DOMElement *parent +) { +#line 673 "walker.g" + DOMElement* ast; +#line 2690 "flat_modelica_tree_parser.cpp" + RefMyAST element_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fd = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fd_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST id = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST id_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST od = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST od_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST rd = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST rd_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 673 "walker.g" + + DOMElement* class_def = 0; + DOMElement* e_spec = 0; + DOMElement* final = 0; + DOMElement* innerouter = 0; + DOMElement* constr = 0; + DOMElement* cmt = 0; + DOMElement* comp_clause = 0; + +#line 2721 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IMPORT: + { + parent=import_clause(_t,iSwitch, parent); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 685 "walker.g" + + ast = parent; + +#line 2736 "flat_modelica_tree_parser.cpp" + break; + } + case EXTENDS: + { + parent=extends_clause(_t,iSwitch, parent); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 689 "walker.g" + + ast = parent; + +#line 2748 "flat_modelica_tree_parser.cpp" + break; + } + case DECLARATION: + { + RefMyAST __t70 = _t; + RefMyAST tmp23_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp23_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp23_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp23_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST70 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DECLARATION); + _t = _t->getFirstChild(); + { +#line 693 "walker.g" + + DOMElement* componentElement = pFlatModelicaXMLDoc->createElement(X("component_clause")); + setVisibility(iSwitch, componentElement); + +#line 2770 "flat_modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INNER: + case INPUT: + case OUTER: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 697 "walker.g" + if (f) componentElement->setAttribute(X("final"), X("true")); +#line 2807 "flat_modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case INNER: + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INNER); + _t = _t->getNextSibling(); + break; + } + case OUTER: + { + o = _t; + RefMyAST o_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + o_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(o)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(o_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OUTER); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 699 "walker.g" + + if (i) componentElement->setAttribute(X("innerouter"), X("inner")); + if (o) componentElement->setAttribute(X("innerouter"), X("outer")); + +#line 2855 "flat_modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { + parent=component_clause(_t,parent, componentElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 704 "walker.g" + + ast = parent; + +#line 2876 "flat_modelica_tree_parser.cpp" + break; + } + case REPLACEABLE: + { + r = _t; + RefMyAST r_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + r_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(r)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REPLACEABLE); + _t = _t->getNextSibling(); +#line 707 "walker.g" + if (r) componentElement->setAttribute(X("replaceable"), X("true")); +#line 2889 "flat_modelica_tree_parser.cpp" + parent=component_clause(_t,parent, componentElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTENDS: + { + constr=constraining_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 710 "walker.g" + + if (constr) + { + // append the comment to the constraint + if (cmt) ((DOMElement*)constr)->appendChild(cmt); + parent->appendChild(constr); + } + ast = parent; + +#line 2927 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + currentAST = __currentAST70; + _t = __t70; + _t = _t->getNextSibling(); + break; + } + case DEFINITION: + { + RefMyAST __t76 = _t; + RefMyAST tmp24_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp24_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp24_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp24_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST76 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DEFINITION); + _t = _t->getFirstChild(); + { +#line 723 "walker.g" + + DOMElement* definitionElement = pFlatModelicaXMLDoc->createElement(X("definition")); + setVisibility(iSwitch, definitionElement); + +#line 2961 "flat_modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + fd = _t; + RefMyAST fd_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + fd_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(fd)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(fd_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case INNER: + case OUTER: + case REPLACEABLE: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 727 "walker.g" + if (fd) definitionElement->setAttribute(X("final"), X("true")); +#line 2991 "flat_modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case INNER: + { + id = _t; + RefMyAST id_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + id_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(id)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(id_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INNER); + _t = _t->getNextSibling(); + break; + } + case OUTER: + { + od = _t; + RefMyAST od_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + od_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(od)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(od_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OUTER); + _t = _t->getNextSibling(); + break; + } + case REPLACEABLE: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 729 "walker.g" + + if (i) definitionElement->setAttribute(X("innerouter"), X("inner")); + if (o) definitionElement->setAttribute(X("innerouter"), X("outer")); + +#line 3032 "flat_modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_DEFINITION: + { + definitionElement=class_definition(_t,fd != NULL, definitionElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 735 "walker.g" + + if (definitionElement && definitionElement->hasChildNodes()) + { + parent->appendChild(definitionElement); + } + ast = parent; + +#line 3050 "flat_modelica_tree_parser.cpp" + break; + } + case REPLACEABLE: + { + { + rd = _t; + RefMyAST rd_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + rd_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(rd)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(rd_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REPLACEABLE); + _t = _t->getNextSibling(); + definitionElement=class_definition(_t,fd != NULL, definitionElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTENDS: + { + constr=constraining_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } +#line 747 "walker.g" + + if (definitionElement) + { + if (innerouter) + definitionElement->appendChild(innerouter); + if (constr) + { + definitionElement->appendChild(constr); + // append the comment to the constraint + if (cmt) ((DOMElement*)constr)->appendChild(cmt); + } + if (rd) definitionElement->setAttribute(X("replaceable"), X("true")); + if (definitionElement->hasChildNodes()) + { + parent->appendChild(definitionElement); + } + } + ast = parent; + +#line 3110 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + currentAST = __currentAST76; + _t = __t76; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + element_AST = RefMyAST(currentAST.root); + returnAST = element_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::import_clause(RefMyAST _t, + int iSwitch, DOMElement *parent +) { +#line 775 "walker.g" + DOMElement* ast; +#line 3142 "flat_modelica_tree_parser.cpp" + RefMyAST import_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST import_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 775 "walker.g" + + DOMElement* imp = 0; + DOMElement* cmt = 0; + +#line 3154 "flat_modelica_tree_parser.cpp" + + RefMyAST __t84 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST84 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IMPORT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUALS: + { + imp=explicit_import_name(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case QUALIFIED: + case UNQUALIFIED: + { + imp=implicit_import_name(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST84; + _t = __t84; + _t = _t->getNextSibling(); +#line 787 "walker.g" + + DOMElement* pImport = pFlatModelicaXMLDoc->createElement(X("import")); + setVisibility(iSwitch, pImport); + + pImport->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pImport->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pImport->appendChild(imp); + if (cmt) pImport->appendChild(cmt); + parent->appendChild(pImport); + ast = parent; + +#line 3228 "flat_modelica_tree_parser.cpp" + import_clause_AST = RefMyAST(currentAST.root); + returnAST = import_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::extends_clause(RefMyAST _t, + int iSwitch, DOMElement* parent +) { +#line 856 "walker.g" + DOMElement* ast; +#line 3240 "flat_modelica_tree_parser.cpp" + RefMyAST extends_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST extends_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 856 "walker.g" + + void *path = 0; + void *mod = 0; + +#line 3252 "flat_modelica_tree_parser.cpp" + + { + RefMyAST __t95 = _t; + e = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST95 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXTENDS); + _t = _t->getFirstChild(); + path=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_MODIFICATION: + { + mod=class_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST95; + _t = __t95; + _t = _t->getNextSibling(); +#line 866 "walker.g" + + DOMElement* pExtends = pFlatModelicaXMLDoc->createElement(X("extends")); + setVisibility(iSwitch, pExtends); + + pExtends->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pExtends->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + if (mod) pExtends = (DOMElement*)appendKidsFromStack((l_stack *)mod, pExtends); + if (path) pExtends->setAttribute(X("type"), X(((mstring*)path)->c_str())); + parent->appendChild(pExtends); + ast = parent; + +#line 3305 "flat_modelica_tree_parser.cpp" + } + extends_clause_AST = RefMyAST(currentAST.root); + returnAST = extends_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::component_clause(RefMyAST _t, + DOMElement* parent, DOMElement* attributes +) { +#line 895 "walker.g" + DOMElement* ast; +#line 3318 "flat_modelica_tree_parser.cpp" + RefMyAST component_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 895 "walker.g" + + type_prefix_t pfx; + void* path = 0; + DOMElement* arr = 0; + DOMElement* comp_list = 0; + +#line 3330 "flat_modelica_tree_parser.cpp" + + type_prefix(_t,attributes); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + path=type_specifier(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 904 "walker.g" + if (path) attributes->setAttribute(X("type"), X(((mstring*)path)->c_str())); +#line 3340 "flat_modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + arr=array_subscripts(_t,1); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + parent=component_list(_t,parent, attributes, arr); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 907 "walker.g" + + ast = parent; + +#line 3369 "flat_modelica_tree_parser.cpp" + component_clause_AST = RefMyAST(currentAST.root); + returnAST = component_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::constraining_clause(RefMyAST _t) { +#line 884 "walker.g" + DOMElement* ast; +#line 3379 "flat_modelica_tree_parser.cpp" + RefMyAST constraining_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST constraining_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 884 "walker.g" + + DOMElement* pConstrain = pFlatModelicaXMLDoc->createElement(X("constrain")); + +#line 3388 "flat_modelica_tree_parser.cpp" + + { + ast=extends_clause(_t,0, pConstrain); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + constraining_clause_AST = RefMyAST(currentAST.root); + returnAST = constraining_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::explicit_import_name(RefMyAST _t) { +#line 804 "walker.g" + DOMElement* ast; +#line 3404 "flat_modelica_tree_parser.cpp" + RefMyAST explicit_import_name_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST explicit_import_name_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 804 "walker.g" + + void* path; + +#line 3415 "flat_modelica_tree_parser.cpp" + + RefMyAST __t88 = _t; + RefMyAST tmp25_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp25_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp25_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp25_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp25_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST88 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + path=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST88; + _t = __t88; + _t = _t->getNextSibling(); +#line 810 "walker.g" + + DOMElement* pExplicitImport = pFlatModelicaXMLDoc->createElement(X("named_import")); + pExplicitImport->setAttribute(X("ident"), str2xml(i)); + + pExplicitImport->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pExplicitImport->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (path) pExplicitImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + ast = pExplicitImport; + +#line 3451 "flat_modelica_tree_parser.cpp" + explicit_import_name_AST = RefMyAST(currentAST.root); + returnAST = explicit_import_name_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::implicit_import_name(RefMyAST _t) { +#line 824 "walker.g" + DOMElement* ast; +#line 3461 "flat_modelica_tree_parser.cpp" + RefMyAST implicit_import_name_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST implicit_import_name_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST unq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST unq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST qua = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST qua_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 824 "walker.g" + + void* path; + +#line 3474 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case UNQUALIFIED: + { + RefMyAST __t91 = _t; + unq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST unq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + unq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(unq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(unq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST91 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNQUALIFIED); + _t = _t->getFirstChild(); + path=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST91; + _t = __t91; + _t = _t->getNextSibling(); +#line 830 "walker.g" + + DOMElement* pUnqImport = pFlatModelicaXMLDoc->createElement(X("unqualified_import")); + if (path) pUnqImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + + pUnqImport->setAttribute(X("sline"), X(itoa(unq->getLine(),stmp,10))); + pUnqImport->setAttribute(X("scolumn"), X(itoa(unq->getColumn(),stmp,10))); + + ast = pUnqImport; + +#line 3508 "flat_modelica_tree_parser.cpp" + break; + } + case QUALIFIED: + { + RefMyAST __t92 = _t; + qua = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST qua_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + qua_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(qua)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(qua_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST92 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),QUALIFIED); + _t = _t->getFirstChild(); + path=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST92; + _t = __t92; + _t = _t->getNextSibling(); +#line 840 "walker.g" + + DOMElement* pQuaImport = pFlatModelicaXMLDoc->createElement(X("qualified_import")); + if (path) pQuaImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + + pQuaImport->setAttribute(X("sline"), X(itoa(qua->getLine(),stmp,10))); + pQuaImport->setAttribute(X("scolumn"), X(itoa(qua->getColumn(),stmp,10))); + + ast = pQuaImport; + +#line 3539 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + implicit_import_name_AST = RefMyAST(currentAST.root); + returnAST = implicit_import_name_AST; + _retTree = _t; + return ast; +} + +void* flat_modelica_tree_parser::type_specifier(RefMyAST _t) { +#line 931 "walker.g" + void* ast; +#line 3557 "flat_modelica_tree_parser.cpp" + RefMyAST type_specifier_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST type_specifier_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + ast=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + type_specifier_AST = RefMyAST(currentAST.root); + returnAST = type_specifier_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::component_list(RefMyAST _t, + DOMElement* parent, DOMElement *attributes, DOMElement* type_array +) { +#line 937 "walker.g" + DOMElement* ast; +#line 3577 "flat_modelica_tree_parser.cpp" + RefMyAST component_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 937 "walker.g" + + l_stack el_stack; + DOMElement* e=0; + +#line 3587 "flat_modelica_tree_parser.cpp" + + parent=component_declaration(_t,parent, attributes, type_array); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IDENT)) { + parent=component_declaration(_t,parent, attributes, type_array); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else { + goto _loop108; + } + + } + _loop108:; + } // ( ... )* +#line 946 "walker.g" + + ast = parent; + +#line 3612 "flat_modelica_tree_parser.cpp" + component_list_AST = RefMyAST(currentAST.root); + returnAST = component_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::component_declaration(RefMyAST _t, + DOMElement* parent, DOMElement *attributes, DOMElement *type_array +) { +#line 953 "walker.g" + DOMElement* ast; +#line 3624 "flat_modelica_tree_parser.cpp" + RefMyAST component_declaration_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_declaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 953 "walker.g" + + DOMElement* cmt = 0; + DOMElement* dec = 0; + + +#line 3635 "flat_modelica_tree_parser.cpp" + + { + dec=declaration(_t,attributes, type_array); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case EXTENDS: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 962 "walker.g" + + if (cmt) dec->appendChild(cmt); + parent->appendChild(dec); + ast = parent; + +#line 3671 "flat_modelica_tree_parser.cpp" + component_declaration_AST = RefMyAST(currentAST.root); + returnAST = component_declaration_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::declaration(RefMyAST _t, + DOMElement* parent, DOMElement* type_array +) { +#line 971 "walker.g" + DOMElement* ast; +#line 3683 "flat_modelica_tree_parser.cpp" + RefMyAST declaration_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST declaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 971 "walker.g" + + DOMElement* arr = 0; + DOMElement* mod = 0; + DOMElement* id = 0; + +#line 3696 "flat_modelica_tree_parser.cpp" + + RefMyAST __t113 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST113 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + arr=array_subscripts(_t,0); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case EQUALS: + case ASSIGN: + case CLASS_MODIFICATION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUALS: + case ASSIGN: + case CLASS_MODIFICATION: + { + mod=modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST113; + _t = __t113; + _t = _t->getNextSibling(); +#line 979 "walker.g" + + DOMElement *pComponent = pFlatModelicaXMLDoc->createElement(X("component")); + pComponent->setAttribute(X("ident"), str2xml(i)); + pComponent->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pComponent->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + setAttributes(pComponent, parent); + if (type_array) pComponent->appendChild(type_array); + if (arr) pComponent->appendChild(arr); + if (mod) pComponent->appendChild(mod); + ast = pComponent; + +#line 3770 "flat_modelica_tree_parser.cpp" + declaration_AST = RefMyAST(currentAST.root); + returnAST = declaration_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::modification(RefMyAST _t) { +#line 992 "walker.g" + DOMElement* ast; +#line 3780 "flat_modelica_tree_parser.cpp" + RefMyAST modification_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST as = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST as_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 992 "walker.g" + + DOMElement* e = 0; + void *cm = 0; + int iswitch = 0; + +#line 3795 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_MODIFICATION: + { + cm=class_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case END: + case FALSE: + case IF: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case DOT: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case CODE_EXPRESSION: + case CODE_MODIFICATION: + case CODE_ELEMENT: + case CODE_EQUATION: + case CODE_INITIALEQUATION: + case CODE_ALGORITHM: + case CODE_INITIALALGORITHM: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case RANGE2: + case RANGE3: + case UNARY_MINUS: + case UNARY_PLUS: + { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case STRING_COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + break; + } + case EQUALS: + { + RefMyAST __t119 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST119 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST119; + _t = __t119; + _t = _t->getNextSibling(); +#line 1000 "walker.g" + iswitch = 1; +#line 3888 "flat_modelica_tree_parser.cpp" + break; + } + case ASSIGN: + { + RefMyAST __t120 = _t; + as = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST as_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + as_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(as)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(as_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST120 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ASSIGN); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST120; + _t = __t120; + _t = _t->getNextSibling(); +#line 1001 "walker.g" + iswitch = 2; +#line 3911 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 1003 "walker.g" + + DOMElement *pModificationEQorASorARG = null; + if (iswitch == 1) pModificationEQorASorARG = pFlatModelicaXMLDoc->createElement(X("modification_equals")); + if (iswitch == 2) pModificationEQorASorARG = pFlatModelicaXMLDoc->createElement(X("modification_assign")); + if (iswitch == 0) pModificationEQorASorARG = pFlatModelicaXMLDoc->createElement(X("modification_arguments")); + if (cm) pModificationEQorASorARG = (DOMElement*)appendKidsFromStack((l_stack*)cm, pModificationEQorASorARG); + if (e) + { + if (iswitch == 0) + { + DOMElement *z = pFlatModelicaXMLDoc->createElement(X("modification_equals")); + z->appendChild(e); + pModificationEQorASorARG->appendChild(z); + } + else + { + pModificationEQorASorARG->appendChild(e); + } + } + if (eq) + { + pModificationEQorASorARG->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); + pModificationEQorASorARG->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); + } + if (as) + { + pModificationEQorASorARG->setAttribute(X("sline"), X(itoa(as->getLine(),stmp,10))); + pModificationEQorASorARG->setAttribute(X("scolumn"), X(itoa(as->getColumn(),stmp,10))); + } + ast = pModificationEQorASorARG; + +#line 3952 "flat_modelica_tree_parser.cpp" + modification_AST = RefMyAST(currentAST.root); + returnAST = modification_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::expression(RefMyAST _t) { +#line 1750 "walker.g" + DOMElement* ast; +#line 3962 "flat_modelica_tree_parser.cpp" + RefMyAST expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case END: + case FALSE: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case DOT: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case RANGE2: + case RANGE3: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=simple_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IF: + { + ast=if_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case CODE_EXPRESSION: + case CODE_MODIFICATION: + case CODE_ELEMENT: + case CODE_EQUATION: + case CODE_INITIALEQUATION: + case CODE_ALGORITHM: + case CODE_INITIALALGORITHM: + { + ast=code_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + expression_AST = RefMyAST(currentAST.root); + returnAST = expression_AST; + _retTree = _t; + return ast; +} + +void * flat_modelica_tree_parser::argument_list(RefMyAST _t) { +#line 1044 "walker.g" + void *stack; +#line 4044 "flat_modelica_tree_parser.cpp" + RefMyAST argument_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST argument_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1044 "walker.g" + + l_stack *el_stack = new l_stack; + DOMElement* e; + +#line 4054 "flat_modelica_tree_parser.cpp" + + RefMyAST __t125 = _t; + RefMyAST tmp26_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp26_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp26_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp26_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp26_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST125 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARGUMENT_LIST); + _t = _t->getFirstChild(); + e=argument(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1051 "walker.g" + el_stack->push(e); +#line 4072 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELEMENT_MODIFICATION || _t->getType() == ELEMENT_REDECLARATION)) { + e=argument(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1052 "walker.g" + el_stack->push(e); +#line 4083 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop127; + } + + } + _loop127:; + } // ( ... )* + currentAST = __currentAST125; + _t = __t125; + _t = _t->getNextSibling(); +#line 1054 "walker.g" + + if (el_stack) stack = (void*)el_stack; + else (stack = 0); + +#line 4100 "flat_modelica_tree_parser.cpp" + argument_list_AST = RefMyAST(currentAST.root); + returnAST = argument_list_AST; + _retTree = _t; + return stack; +} + +DOMElement* flat_modelica_tree_parser::argument(RefMyAST _t) { +#line 1060 "walker.g" + DOMElement* ast; +#line 4110 "flat_modelica_tree_parser.cpp" + RefMyAST argument_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST argument_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST em = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST em_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST er = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST er_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ELEMENT_MODIFICATION: + { + RefMyAST __t129 = _t; + em = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST em_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + em_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(em)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(em_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST129 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELEMENT_MODIFICATION); + _t = _t->getFirstChild(); + ast=element_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST129; + _t = __t129; + _t = _t->getNextSibling(); +#line 1063 "walker.g" + + if (em) + { + ast->setAttribute(X("sline"), X(itoa(em->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(em->getColumn(),stmp,10))); + } + +#line 4149 "flat_modelica_tree_parser.cpp" + argument_AST = RefMyAST(currentAST.root); + break; + } + case ELEMENT_REDECLARATION: + { + RefMyAST __t130 = _t; + er = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST er_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + er_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(er)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(er_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST130 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELEMENT_REDECLARATION); + _t = _t->getFirstChild(); + ast=element_redeclaration(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST130; + _t = __t130; + _t = _t->getNextSibling(); +#line 1071 "walker.g" + + if (er) + { + ast->setAttribute(X("sline"), X(itoa(er->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(er->getColumn(),stmp,10))); + } + +#line 4179 "flat_modelica_tree_parser.cpp" + argument_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = argument_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::element_modification(RefMyAST _t) { +#line 1080 "walker.g" + DOMElement* ast; +#line 4196 "flat_modelica_tree_parser.cpp" + RefMyAST element_modification_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1080 "walker.g" + + DOMElement* cref; + DOMElement* mod=0; + DOMElement* cmt=0; + +#line 4211 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EACH: + { + e = _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EACH); + _t = _t->getNextSibling(); + break; + } + case FINAL: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUALS: + case ASSIGN: + case CLASS_MODIFICATION: + { + mod=modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case STRING_COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + cmt=string_comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1092 "walker.g" + + DOMElement *pModification = pFlatModelicaXMLDoc->createElement(X("element_modification")); + if (f) pModification->setAttribute(X("final"), X("true")); + if (e) pModification->setAttribute(X("each"), X("true")); + pModification->appendChild(cref); + if (mod) pModification->appendChild(mod); + if (cmt) pModification->appendChild(cmt); + ast = pModification; + +#line 4304 "flat_modelica_tree_parser.cpp" + element_modification_AST = RefMyAST(currentAST.root); + returnAST = element_modification_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::element_redeclaration(RefMyAST _t) { +#line 1103 "walker.g" + DOMElement* ast; +#line 4314 "flat_modelica_tree_parser.cpp" + RefMyAST element_redeclaration_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_redeclaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST re = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST re_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1103 "walker.g" + + DOMElement* class_def = 0; + DOMElement* e_spec = 0; + DOMElement* constr = 0; + DOMElement* final = 0; + DOMElement* each = 0; + class_def = pFlatModelicaXMLDoc->createElement(X("definition")); + +#line 4336 "flat_modelica_tree_parser.cpp" + + { + RefMyAST __t137 = _t; + r = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST r_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + r_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(r)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST137 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REDECLARE); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EACH: + { + e = _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EACH); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FINAL: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + case CLASS_DEFINITION: + { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_DEFINITION: + { + class_def=class_definition(_t,false, class_def); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1116 "walker.g" + + DOMElement *pElementRedeclaration = pFlatModelicaXMLDoc->createElement(X("element_redeclaration")); + if (class_def->hasChildNodes()) + pElementRedeclaration->appendChild(class_def); + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (each) pElementRedeclaration->setAttribute(X("each"), X("true")); + ast = pElementRedeclaration; + +#line 4448 "flat_modelica_tree_parser.cpp" + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { +#line 1124 "walker.g" + DOMElement *pElementRedeclaration = pFlatModelicaXMLDoc->createElement(X("element_redeclaration")); +#line 4462 "flat_modelica_tree_parser.cpp" + pElementRedeclaration=component_clause1(_t,pElementRedeclaration); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1126 "walker.g" + + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (each) pElementRedeclaration->setAttribute(X("each"), X("true")); + ast = pElementRedeclaration; + +#line 4472 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + break; + } + case REPLACEABLE: + { + { + re = _t; + RefMyAST re_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + re_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(re)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(re_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REPLACEABLE); + _t = _t->getNextSibling(); +#line 1134 "walker.g" + DOMElement *pElementRedeclaration = pFlatModelicaXMLDoc->createElement(X("element_redeclaration")); +#line 4494 "flat_modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_DEFINITION: + { + class_def=class_definition(_t,false, class_def); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { + pElementRedeclaration=component_clause1(_t,pElementRedeclaration); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTENDS: + { + constr=constraining_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 1139 "walker.g" + + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (re) pElementRedeclaration->setAttribute(X("replaceable"), X("true")); + if (class_def && class_def->hasChildNodes()) + { + pElementRedeclaration->appendChild(class_def); + if (constr) pElementRedeclaration->appendChild(constr); + } + else + { + if (constr) pElementRedeclaration->appendChild(constr); + } + ast = pElementRedeclaration; + +#line 4563 "flat_modelica_tree_parser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST137; + _t = __t137; + _t = _t->getNextSibling(); + } + element_redeclaration_AST = RefMyAST(currentAST.root); + returnAST = element_redeclaration_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::component_clause1(RefMyAST _t, + DOMElement *parent +) { +#line 1160 "walker.g" + DOMElement* ast; +#line 4588 "flat_modelica_tree_parser.cpp" + RefMyAST component_clause1_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_clause1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1160 "walker.g" + + type_prefix_t pfx; + DOMElement* attr = pFlatModelicaXMLDoc->createElement(X("tmp")); + void* path = 0; + DOMElement* arr = 0; + DOMElement* comp_decl = 0; + DOMElement* comp_list = 0; + +#line 4602 "flat_modelica_tree_parser.cpp" + + type_prefix(_t,attr); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + path=type_specifier(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1171 "walker.g" + if (path) attr->setAttribute(X("type"), X(((mstring*)path)->c_str())); +#line 4612 "flat_modelica_tree_parser.cpp" + parent=component_declaration(_t,parent, attr, null); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1173 "walker.g" + + ast = parent; + +#line 4620 "flat_modelica_tree_parser.cpp" + component_clause1_AST = RefMyAST(currentAST.root); + returnAST = component_clause1_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::equation(RefMyAST _t, + DOMElement* definition +) { +#line 1235 "walker.g" + DOMElement* ast; +#line 4632 "flat_modelica_tree_parser.cpp" + RefMyAST equation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST es = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST es_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1235 "walker.g" + + DOMElement* cmt = 0; + +#line 4643 "flat_modelica_tree_parser.cpp" + + RefMyAST __t164 = _t; + es = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST es_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + es_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(es)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(es_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST164 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUATION_STATEMENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUALS: + { + ast=equality_equation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IF: + { + ast=conditional_equation_e(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case FOR: + { + ast=for_clause_e(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case WHEN: + { + ast=when_clause_e(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case CONNECT: + { + ast=connect_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IDENT: + { + ast=equation_funcall(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 1249 "walker.g" + + DOMElement* pEquation = pFlatModelicaXMLDoc->createElement(X("equation")); + pEquation->appendChild(ast); + if (cmt) pEquation->appendChild(cmt); + if (es) + { + pEquation->setAttribute(X("sline"), X(itoa(es->getLine(),stmp,10))); + pEquation->setAttribute(X("scolumn"), X(itoa(es->getColumn(),stmp,10))); + } + definition->appendChild(pEquation); + ast = definition; + +#line 4741 "flat_modelica_tree_parser.cpp" + currentAST = __currentAST164; + _t = __t164; + _t = _t->getNextSibling(); + equation_AST = RefMyAST(currentAST.root); + returnAST = equation_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::algorithm(RefMyAST _t, + DOMElement *definition +) { +#line 1280 "walker.g" + DOMElement* ast; +#line 4756 "flat_modelica_tree_parser.cpp" + RefMyAST algorithm_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST as = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST as_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST az = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST az_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1280 "walker.g" + + DOMElement* cref; + DOMElement* expr; + DOMElement* tuple; + DOMElement* args; + DOMElement* cmt=0; + +#line 4773 "flat_modelica_tree_parser.cpp" + + RefMyAST __t169 = _t; + as = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST as_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + as_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(as)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(as_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST169 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALGORITHM_STATEMENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ASSIGN: + { + RefMyAST __t171 = _t; + az = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST az_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + az_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(az)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(az_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST171 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ASSIGN); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT: + case IDENT: + { + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + expr=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1292 "walker.g" + + DOMElement* pAlgAssign = pFlatModelicaXMLDoc->createElement(X("alg_assign")); + if (az) + { + pAlgAssign->setAttribute(X("sline"), X(itoa(az->getLine(),stmp,10))); + pAlgAssign->setAttribute(X("scolumn"), X(itoa(az->getColumn(),stmp,10))); + } + pAlgAssign->appendChild(cref); + pAlgAssign->appendChild(expr); + ast = pAlgAssign; + +#line 4826 "flat_modelica_tree_parser.cpp" + break; + } + case EXPRESSION_LIST: + { + { + tuple=tuple_expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + args=function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } +#line 1304 "walker.g" + + DOMElement* pAlgAssign = pFlatModelicaXMLDoc->createElement(X("alg_assign")); + DOMElement* pCall = pFlatModelicaXMLDoc->createElement(X("call")); + + if (az) + { + pAlgAssign->setAttribute(X("sline"), X(itoa(az->getLine(),stmp,10))); + pAlgAssign->setAttribute(X("scolumn"), X(itoa(az->getColumn(),stmp,10))); + } + + pAlgAssign->appendChild(tuple); + + pCall->appendChild(cref); + pCall->appendChild(args); + + pAlgAssign->appendChild(pCall); + + ast = pAlgAssign; + /* + + + */ + +#line 4868 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST171; + _t = __t171; + _t = _t->getNextSibling(); + break; + } + case DOT: + case IDENT: + { + ast=algorithm_function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IF: + { + ast=conditional_equation_a(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case FOR: + { + ast=for_clause_a(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case WHILE: + { + ast=while_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case WHEN: + { + ast=when_clause_a(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 1338 "walker.g" + + DOMElement* pAlgorithm = pFlatModelicaXMLDoc->createElement(X("algorithm")); + if (as) + { + pAlgorithm->setAttribute(X("sline"), X(itoa(as->getLine(),stmp,10))); + pAlgorithm->setAttribute(X("scolumn"), X(itoa(as->getColumn(),stmp,10))); + } + pAlgorithm->appendChild(ast); + if (cmt) pAlgorithm->appendChild(cmt); + definition->appendChild(pAlgorithm); + ast = definition; + /* + + + */ + +#line 4965 "flat_modelica_tree_parser.cpp" + currentAST = __currentAST169; + _t = __t169; + _t = _t->getNextSibling(); + algorithm_AST = RefMyAST(currentAST.root); + returnAST = algorithm_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::equality_equation(RefMyAST _t) { +#line 1381 "walker.g" + DOMElement* ast; +#line 4978 "flat_modelica_tree_parser.cpp" + RefMyAST equality_equation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equality_equation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1381 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 4990 "flat_modelica_tree_parser.cpp" + + RefMyAST __t177 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST177 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + e1=simple_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST177; + _t = __t177; + _t = _t->getNextSibling(); +#line 1388 "walker.g" + + DOMElement* pEquEqual = pFlatModelicaXMLDoc->createElement(X("equ_equal")); + pEquEqual->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); + pEquEqual->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); + pEquEqual->appendChild(e1); + pEquEqual->appendChild(e2); + ast = pEquEqual; + /* + + + */ + +#line 5026 "flat_modelica_tree_parser.cpp" + equality_equation_AST = RefMyAST(currentAST.root); + returnAST = equality_equation_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::conditional_equation_e(RefMyAST _t) { +#line 1404 "walker.g" + DOMElement* ast; +#line 5036 "flat_modelica_tree_parser.cpp" + RefMyAST conditional_equation_e_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_equation_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1404 "walker.g" + + DOMElement* e1; + DOMElement* then_b; + DOMElement* else_b = 0; + DOMElement* else_if_b; + l_stack el_stack; + DOMElement* e; + + DOMElement* pEquIf = pFlatModelicaXMLDoc->createElement(X("equ_if")); + DOMElement* pEquThen = pFlatModelicaXMLDoc->createElement(X("equ_then")); + DOMElement* pEquElse = pFlatModelicaXMLDoc->createElement(X("equ_else")); + + bool fbElse = false; + +#line 5058 "flat_modelica_tree_parser.cpp" + + RefMyAST __t179 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST179 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF); + _t = _t->getFirstChild(); + e1=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1421 "walker.g" + pEquIf->appendChild(e1); +#line 5075 "flat_modelica_tree_parser.cpp" + pEquThen=equation_list(_t,pEquThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1422 "walker.g" + pEquIf->appendChild(pEquThen); +#line 5081 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEIF)) { + e=equation_elseif(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1423 "walker.g" + el_stack.push(e); +#line 5092 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop181; + } + + } + _loop181:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ELSE: + { + RefMyAST tmp27_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp27_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp27_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp27_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp27_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSE); + _t = _t->getNextSibling(); + pEquElse=equation_list(_t,pEquElse); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1424 "walker.g" + fbElse = true; +#line 5119 "flat_modelica_tree_parser.cpp" + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST179; + _t = __t179; + _t = _t->getNextSibling(); +#line 1426 "walker.g" + + pEquIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (el_stack.size()>0) pEquIf = (DOMElement*)appendKids(el_stack, pEquIf); // ?? is this ok? + if (fbElse) pEquIf->appendChild(pEquElse); + ast = pEquIf; + +#line 5144 "flat_modelica_tree_parser.cpp" + conditional_equation_e_AST = RefMyAST(currentAST.root); + returnAST = conditional_equation_e_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::for_clause_e(RefMyAST _t) { +#line 1477 "walker.g" + DOMElement* ast; +#line 5154 "flat_modelica_tree_parser.cpp" + RefMyAST for_clause_e_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_clause_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1477 "walker.g" + + DOMElement* f; + DOMElement* eq; + DOMElement* pEquFor = pFlatModelicaXMLDoc->createElement(X("equ_for")); + +#line 5167 "flat_modelica_tree_parser.cpp" + + RefMyAST __t189 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST189 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR); + _t = _t->getFirstChild(); + f=for_indices(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1484 "walker.g" + pEquFor->appendChild(f); +#line 5184 "flat_modelica_tree_parser.cpp" + pEquFor=equation_list(_t,pEquFor); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST189; + _t = __t189; + _t = _t->getNextSibling(); +#line 1486 "walker.g" + + pEquFor->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquFor->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pEquFor; + +#line 5198 "flat_modelica_tree_parser.cpp" + for_clause_e_AST = RefMyAST(currentAST.root); + returnAST = for_clause_e_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::when_clause_e(RefMyAST _t) { +#line 1575 "walker.g" + DOMElement* ast; +#line 5208 "flat_modelica_tree_parser.cpp" + RefMyAST when_clause_e_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST when_clause_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST wh = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST wh_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1575 "walker.g" + + l_stack el_stack; + DOMElement* e; + DOMElement* body; + DOMElement* el = 0; + DOMElement* pEquWhen = pFlatModelicaXMLDoc->createElement(X("equ_when")); + DOMElement* pEquThen = pFlatModelicaXMLDoc->createElement(X("equ_then")); + +#line 5224 "flat_modelica_tree_parser.cpp" + + RefMyAST __t200 = _t; + wh = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST wh_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + wh_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(wh)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(wh_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST200 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHEN); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1586 "walker.g" + pEquWhen->appendChild(e); +#line 5241 "flat_modelica_tree_parser.cpp" + pEquThen=equation_list(_t,pEquThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1587 "walker.g" + pEquWhen->appendChild(pEquThen); +#line 5247 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEWHEN)) { + el=else_when_e(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1588 "walker.g" + el_stack.push(el); +#line 5258 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop202; + } + + } + _loop202:; + } // ( ... )* + currentAST = __currentAST200; + _t = __t200; + _t = _t->getNextSibling(); +#line 1590 "walker.g" + + pEquWhen->setAttribute(X("sline"), X(itoa(wh->getLine(),stmp,10))); + pEquWhen->setAttribute(X("scolumn"), X(itoa(wh->getColumn(),stmp,10))); + + if (el_stack.size()>0) pEquWhen = (DOMElement*)appendKids(el_stack, pEquWhen); // ??is this ok? + ast = pEquWhen; + +#line 5278 "flat_modelica_tree_parser.cpp" + when_clause_e_AST = RefMyAST(currentAST.root); + returnAST = when_clause_e_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::connect_clause(RefMyAST _t) { +#line 1727 "walker.g" + DOMElement* ast; +#line 5288 "flat_modelica_tree_parser.cpp" + RefMyAST connect_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST connect_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1727 "walker.g" + + DOMElement* r1; + DOMElement* r2; + +#line 5300 "flat_modelica_tree_parser.cpp" + + RefMyAST __t222 = _t; + c = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST c_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + c_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(c)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST222 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONNECT); + _t = _t->getFirstChild(); + r1=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + r2=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST222; + _t = __t222; + _t = _t->getNextSibling(); +#line 1737 "walker.g" + + DOMElement* pEquConnect = pFlatModelicaXMLDoc->createElement(X("equ_connect")); + + pEquConnect->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pEquConnect->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + + pEquConnect->appendChild(r1); + pEquConnect->appendChild(r2); + ast = pEquConnect; + +#line 5332 "flat_modelica_tree_parser.cpp" + connect_clause_AST = RefMyAST(currentAST.root); + returnAST = connect_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::equation_funcall(RefMyAST _t) { +#line 1264 "walker.g" + DOMElement* ast; +#line 5342 "flat_modelica_tree_parser.cpp" + RefMyAST equation_funcall_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_funcall_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1264 "walker.g" + + DOMElement* fcall = 0; + +#line 5353 "flat_modelica_tree_parser.cpp" + + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + fcall=function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1270 "walker.g" + + DOMElement* pEquCall = pFlatModelicaXMLDoc->createElement(X("equ_call")); + pEquCall->setAttribute(X("ident"), str2xml(i)); + pEquCall->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquCall->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + pEquCall->appendChild(fcall); + ast = pEquCall; + +#line 5373 "flat_modelica_tree_parser.cpp" + equation_funcall_AST = RefMyAST(currentAST.root); + returnAST = equation_funcall_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::function_call(RefMyAST _t) { +#line 2327 "walker.g" + DOMElement* ast; +#line 5383 "flat_modelica_tree_parser.cpp" + RefMyAST function_call_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fa = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fa_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST __t304 = _t; + fa = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST fa_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + fa_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(fa)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(fa_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST304 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_ARGUMENTS); + _t = _t->getFirstChild(); + ast=function_arguments(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2330 "walker.g" + + ast->setAttribute(X("sline"), X(itoa(fa->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(fa->getColumn(),stmp,10))); + +#line 5409 "flat_modelica_tree_parser.cpp" + currentAST = __currentAST304; + _t = __t304; + _t = _t->getNextSibling(); + function_call_AST = RefMyAST(currentAST.root); + returnAST = function_call_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::tuple_expression_list(RefMyAST _t) { +#line 2433 "walker.g" + DOMElement* ast; +#line 5422 "flat_modelica_tree_parser.cpp" + RefMyAST tuple_expression_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST tuple_expression_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2433 "walker.g" + + l_stack el_stack; + DOMElement* e; + //DOMElement* pComma = pFlatModelicaXMLDoc->createElement(X("comma")); + +#line 5435 "flat_modelica_tree_parser.cpp" + + { + RefMyAST __t327 = _t; + el = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST el_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + el_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(el)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(el_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST327 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXPRESSION_LIST); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2441 "walker.g" + el_stack.push(e); +#line 5453 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_2.member(_t->getType()))) { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2442 "walker.g" + el_stack.push(pFlatModelicaXMLDoc->createElement(X("comma"))); el_stack.push(e); +#line 5464 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop329; + } + + } + _loop329:; + } // ( ... )* + currentAST = __currentAST327; + _t = __t327; + _t = _t->getNextSibling(); + } +#line 2445 "walker.g" + + if (el_stack.size() == 1) + { + ast = el_stack.top(); + } + else + { + DOMElement *pTuple = pFlatModelicaXMLDoc->createElement(X("output_expression_list")); + pTuple = (DOMElement*)appendKids(el_stack, pTuple); + + pTuple->setAttribute(X("sline"), X(itoa(el->getLine(),stmp,10))); + pTuple->setAttribute(X("scolumn"), X(itoa(el->getColumn(),stmp,10))); + + ast = pTuple; + } + +#line 5494 "flat_modelica_tree_parser.cpp" + tuple_expression_list_AST = RefMyAST(currentAST.root); + returnAST = tuple_expression_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::algorithm_function_call(RefMyAST _t) { +#line 1360 "walker.g" + DOMElement* ast; +#line 5504 "flat_modelica_tree_parser.cpp" + RefMyAST algorithm_function_call_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1360 "walker.g" + + DOMElement* cref; + DOMElement* args; + +#line 5514 "flat_modelica_tree_parser.cpp" + + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + args=function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1367 "walker.g" + + DOMElement* pAlgCall = pFlatModelicaXMLDoc->createElement(X("alg_call")); + pAlgCall->appendChild(cref); + pAlgCall->appendChild(args); + ast = pAlgCall; + /* + + + */ + +#line 5535 "flat_modelica_tree_parser.cpp" + algorithm_function_call_AST = RefMyAST(currentAST.root); + returnAST = algorithm_function_call_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::conditional_equation_a(RefMyAST _t) { +#line 1436 "walker.g" + DOMElement* ast; +#line 5545 "flat_modelica_tree_parser.cpp" + RefMyAST conditional_equation_a_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_equation_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1436 "walker.g" + + DOMElement* e1; + DOMElement* then_b; + DOMElement* else_b = 0; + DOMElement* else_if_b; + l_stack el_stack; + DOMElement* e; + DOMElement* pAlgIf = pFlatModelicaXMLDoc->createElement(X("alg_if")); + DOMElement* pAlgThen = pFlatModelicaXMLDoc->createElement(X("alg_then")); + DOMElement* pAlgElse = pFlatModelicaXMLDoc->createElement(X("alg_else")); + bool fbElse = false; + +#line 5565 "flat_modelica_tree_parser.cpp" + + RefMyAST __t184 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST184 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF); + _t = _t->getFirstChild(); + e1=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1451 "walker.g" + pAlgIf->appendChild(e1); +#line 5582 "flat_modelica_tree_parser.cpp" + pAlgThen=algorithm_list(_t,pAlgThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1453 "walker.g" + + if (pAlgThen) + pAlgIf->appendChild(pAlgThen); + +#line 5591 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEIF)) { + e=algorithm_elseif(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1457 "walker.g" + el_stack.push(e); +#line 5602 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop186; + } + + } + _loop186:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ELSE: + { + RefMyAST tmp28_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp28_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp28_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp28_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSE); + _t = _t->getNextSibling(); + pAlgElse=algorithm_list(_t,pAlgElse); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1458 "walker.g" + fbElse = true; +#line 5629 "flat_modelica_tree_parser.cpp" + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST184; + _t = __t184; + _t = _t->getNextSibling(); +#line 1460 "walker.g" + + pAlgIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pAlgIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + if (el_stack.size()>0) pAlgIf = (DOMElement*)appendKids(el_stack, pAlgIf); + if (fbElse) pAlgIf->appendChild(pAlgElse); + ast = pAlgIf; + +#line 5653 "flat_modelica_tree_parser.cpp" + conditional_equation_a_AST = RefMyAST(currentAST.root); + returnAST = conditional_equation_a_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::for_clause_a(RefMyAST _t) { +#line 1495 "walker.g" + DOMElement* ast; +#line 5663 "flat_modelica_tree_parser.cpp" + RefMyAST for_clause_a_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1495 "walker.g" + + DOMElement* f; + DOMElement* eq; + DOMElement* pAlgFor = pFlatModelicaXMLDoc->createElement(X("alg_for")); + +#line 5676 "flat_modelica_tree_parser.cpp" + + RefMyAST __t191 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST191 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR); + _t = _t->getFirstChild(); + f=for_indices(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1503 "walker.g" + + f->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + f->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + pAlgFor->appendChild(f); + +#line 5697 "flat_modelica_tree_parser.cpp" + pAlgFor=algorithm_list(_t,pAlgFor); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST191; + _t = __t191; + _t = _t->getNextSibling(); +#line 1509 "walker.g" + + pAlgFor->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pAlgFor->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pAlgFor; + +#line 5711 "flat_modelica_tree_parser.cpp" + for_clause_a_AST = RefMyAST(currentAST.root); + returnAST = for_clause_a_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::while_clause(RefMyAST _t) { +#line 1545 "walker.g" + DOMElement* ast; +#line 5721 "flat_modelica_tree_parser.cpp" + RefMyAST while_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST while_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST w = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST w_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1545 "walker.g" + + DOMElement* e; + DOMElement* body; + DOMElement* pAlgWhile = pFlatModelicaXMLDoc->createElement(X("alg_while")); + +#line 5734 "flat_modelica_tree_parser.cpp" + + RefMyAST __t198 = _t; + w = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST w_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + w_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(w)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST198 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHILE); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1554 "walker.g" + + pAlgWhile->appendChild(e); + +#line 5753 "flat_modelica_tree_parser.cpp" + pAlgWhile=algorithm_list(_t,pAlgWhile); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST198; + _t = __t198; + _t = _t->getNextSibling(); +#line 1558 "walker.g" + + pAlgWhile->setAttribute(X("sline"), X(itoa(w->getLine(),stmp,10))); + pAlgWhile->setAttribute(X("scolumn"), X(itoa(w->getColumn(),stmp,10))); + + ast = pAlgWhile; + +#line 5767 "flat_modelica_tree_parser.cpp" + while_clause_AST = RefMyAST(currentAST.root); + returnAST = while_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::when_clause_a(RefMyAST _t) { +#line 1618 "walker.g" + DOMElement* ast; +#line 5777 "flat_modelica_tree_parser.cpp" + RefMyAST when_clause_a_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST when_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST wh = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST wh_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1618 "walker.g" + + l_stack el_stack; + DOMElement* e; + DOMElement* body; + DOMElement* el = 0; + DOMElement* pAlgWhen = pFlatModelicaXMLDoc->createElement(X("alg_when")); + DOMElement* pAlgThen = pFlatModelicaXMLDoc->createElement(X("alg_then")); + +#line 5793 "flat_modelica_tree_parser.cpp" + + RefMyAST __t206 = _t; + wh = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST wh_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + wh_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(wh)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(wh_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST206 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHEN); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1629 "walker.g" + pAlgWhen->appendChild(e); +#line 5810 "flat_modelica_tree_parser.cpp" + pAlgThen=algorithm_list(_t,pAlgThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1630 "walker.g" + pAlgWhen->appendChild(pAlgThen); +#line 5816 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEWHEN)) { + el=else_when_a(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1631 "walker.g" + el_stack.push(el); +#line 5827 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop208; + } + + } + _loop208:; + } // ( ... )* + currentAST = __currentAST206; + _t = __t206; + _t = _t->getNextSibling(); +#line 1633 "walker.g" + + pAlgWhen->setAttribute(X("sline"), X(itoa(wh->getLine(),stmp,10))); + pAlgWhen->setAttribute(X("scolumn"), X(itoa(wh->getColumn(),stmp,10))); + + if (el_stack.size() > 0) pAlgWhen = (DOMElement*)appendKids(el_stack, pAlgWhen); + ast = pAlgWhen; + +#line 5847 "flat_modelica_tree_parser.cpp" + when_clause_a_AST = RefMyAST(currentAST.root); + returnAST = when_clause_a_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::simple_expression(RefMyAST _t) { +#line 1811 "walker.g" + DOMElement* ast; +#line 5857 "flat_modelica_tree_parser.cpp" + RefMyAST simple_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST simple_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r3 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r3_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1811 "walker.g" + + DOMElement* e1; + DOMElement* e2; + DOMElement* e3; + +#line 5872 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case RANGE3: + { + RefMyAST __t233 = _t; + r3 = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST r3_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + r3_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(r3)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r3_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST233 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE3); + _t = _t->getFirstChild(); + e1=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e3=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST233; + _t = __t233; + _t = _t->getNextSibling(); +#line 1821 "walker.g" + + DOMElement* pRange = pFlatModelicaXMLDoc->createElement(X("range")); + + pRange->setAttribute(X("sline"), X(itoa(r3->getLine(),stmp,10))); + pRange->setAttribute(X("scolumn"), X(itoa(r3->getColumn(),stmp,10))); + + pRange->appendChild(e1); + pRange->appendChild(e2); + pRange->appendChild(e3); + ast = pRange; + /* + + + */ + +#line 5920 "flat_modelica_tree_parser.cpp" + break; + } + case RANGE2: + { + RefMyAST __t234 = _t; + r2 = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST r2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + r2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(r2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r2_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST234 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE2); + _t = _t->getFirstChild(); + e1=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e3=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST234; + _t = __t234; + _t = _t->getNextSibling(); +#line 1839 "walker.g" + + DOMElement* pRange = pFlatModelicaXMLDoc->createElement(X("range")); + + pRange->setAttribute(X("sline"), X(itoa(r2->getLine(),stmp,10))); + pRange->setAttribute(X("scolumn"), X(itoa(r2->getColumn(),stmp,10))); + + pRange->appendChild(e1); + pRange->appendChild(e3); + ast = pRange; + +#line 5955 "flat_modelica_tree_parser.cpp" + break; + } + case AND: + case END: + case FALSE: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case DOT: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + simple_expression_AST = RefMyAST(currentAST.root); + returnAST = simple_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::equation_list(RefMyAST _t, + DOMElement* pEquationList +) { +#line 1703 "walker.g" + DOMElement* ast; +#line 6010 "flat_modelica_tree_parser.cpp" + RefMyAST equation_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1703 "walker.g" + + DOMElement* e; + l_stack el_stack; + +#line 6020 "flat_modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == EQUATION_STATEMENT)) { + pEquationList=equation(_t,pEquationList); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else { + goto _loop217; + } + + } + _loop217:; + } // ( ... )* +#line 1710 "walker.g" + + ast = pEquationList; + +#line 6042 "flat_modelica_tree_parser.cpp" + equation_list_AST = RefMyAST(currentAST.root); + returnAST = equation_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::equation_elseif(RefMyAST _t) { +#line 1661 "walker.g" + DOMElement* ast; +#line 6052 "flat_modelica_tree_parser.cpp" + RefMyAST equation_elseif_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_elseif_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1661 "walker.g" + + DOMElement* e; + DOMElement* eq; + DOMElement* pEquElseIf = pFlatModelicaXMLDoc->createElement(X("equ_elseif")); + DOMElement* pEquThen = pFlatModelicaXMLDoc->createElement(X("equ_then")); + +#line 6066 "flat_modelica_tree_parser.cpp" + + RefMyAST __t212 = _t; + els = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST els_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + els_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(els)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(els_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST212 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEIF); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1670 "walker.g" + pEquElseIf->appendChild(e); +#line 6083 "flat_modelica_tree_parser.cpp" + pEquThen=equation_list(_t,pEquThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST212; + _t = __t212; + _t = _t->getNextSibling(); +#line 1673 "walker.g" + + pEquElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pEquElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pEquElseIf->appendChild(pEquThen); + ast = pEquElseIf; + +#line 6098 "flat_modelica_tree_parser.cpp" + equation_elseif_AST = RefMyAST(currentAST.root); + returnAST = equation_elseif_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::algorithm_list(RefMyAST _t, + DOMElement* pAlgorithmList +) { +#line 1715 "walker.g" + DOMElement* ast; +#line 6110 "flat_modelica_tree_parser.cpp" + RefMyAST algorithm_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1715 "walker.g" + + DOMElement* e; + l_stack el_stack; + +#line 6120 "flat_modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ALGORITHM_STATEMENT)) { + pAlgorithmList=algorithm(_t,pAlgorithmList); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else { + goto _loop220; + } + + } + _loop220:; + } // ( ... )* +#line 1722 "walker.g" + + ast = pAlgorithmList; + +#line 6142 "flat_modelica_tree_parser.cpp" + algorithm_list_AST = RefMyAST(currentAST.root); + returnAST = algorithm_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::algorithm_elseif(RefMyAST _t) { +#line 1682 "walker.g" + DOMElement* ast; +#line 6152 "flat_modelica_tree_parser.cpp" + RefMyAST algorithm_elseif_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_elseif_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1682 "walker.g" + + DOMElement* e; + DOMElement* body; + DOMElement* pAlgElseIf = pFlatModelicaXMLDoc->createElement(X("alg_elseif")); + DOMElement* pAlgThen = pFlatModelicaXMLDoc->createElement(X("alg_then")); + +#line 6166 "flat_modelica_tree_parser.cpp" + + RefMyAST __t214 = _t; + els = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST els_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + els_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(els)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(els_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST214 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEIF); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1691 "walker.g" + pAlgElseIf->appendChild(e); +#line 6183 "flat_modelica_tree_parser.cpp" + pAlgThen=algorithm_list(_t,pAlgThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST214; + _t = __t214; + _t = _t->getNextSibling(); +#line 1694 "walker.g" + + pAlgElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pAlgElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pAlgElseIf->appendChild(pAlgThen); + ast = pAlgElseIf; + +#line 6198 "flat_modelica_tree_parser.cpp" + algorithm_elseif_AST = RefMyAST(currentAST.root); + returnAST = algorithm_elseif_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::for_indices(RefMyAST _t) { +#line 1519 "walker.g" + DOMElement* ast; +#line 6208 "flat_modelica_tree_parser.cpp" + RefMyAST for_indices_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_indices_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1519 "walker.g" + + DOMElement* f; + DOMElement* e; + l_stack el_stack; + +#line 6221 "flat_modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IN)) { + RefMyAST __t194 = _t; + RefMyAST tmp29_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp29_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp29_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp29_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp29_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST194 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IN); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case END: + case FALSE: + case IF: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case DOT: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case CODE_EXPRESSION: + case CODE_MODIFICATION: + case CODE_ELEMENT: + case CODE_EQUATION: + case CODE_INITIALEQUATION: + case CODE_ALGORITHM: + case CODE_INITIALALGORITHM: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case RANGE2: + case RANGE3: + case UNARY_MINUS: + case UNARY_PLUS: + { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST194; + _t = __t194; + _t = _t->getNextSibling(); +#line 1527 "walker.g" + + DOMElement* pForIndex = pFlatModelicaXMLDoc->createElement(X("for_index")); + pForIndex->setAttribute(X("ident"), str2xml(i)); + + pForIndex->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pForIndex->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (e) pForIndex->appendChild(e); + el_stack.push(pForIndex); + +#line 6318 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop196; + } + + } + _loop196:; + } // ( ... )* +#line 1538 "walker.g" + + DOMElement* pForIndices = pFlatModelicaXMLDoc->createElement(X("for_indices")); + pForIndices = (DOMElement*)appendKids(el_stack, pForIndices); + ast = pForIndices; + +#line 6333 "flat_modelica_tree_parser.cpp" + for_indices_AST = RefMyAST(currentAST.root); + returnAST = for_indices_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::else_when_e(RefMyAST _t) { +#line 1599 "walker.g" + DOMElement* ast; +#line 6343 "flat_modelica_tree_parser.cpp" + RefMyAST else_when_e_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST else_when_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1599 "walker.g" + + DOMElement* expr; + DOMElement* eqn; + DOMElement* pEquElseWhen = pFlatModelicaXMLDoc->createElement(X("equ_elsewhen")); + DOMElement* pEquThen = pFlatModelicaXMLDoc->createElement(X("equ_then")); + +#line 6357 "flat_modelica_tree_parser.cpp" + + RefMyAST __t204 = _t; + e = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST204 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEWHEN); + _t = _t->getFirstChild(); + expr=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1607 "walker.g" + pEquElseWhen->appendChild(expr); +#line 6374 "flat_modelica_tree_parser.cpp" + pEquThen=equation_list(_t,pEquThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST204; + _t = __t204; + _t = _t->getNextSibling(); +#line 1609 "walker.g" + + pEquElseWhen->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pEquElseWhen->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + pEquElseWhen->appendChild(pEquThen); + ast = pEquElseWhen; + +#line 6389 "flat_modelica_tree_parser.cpp" + else_when_e_AST = RefMyAST(currentAST.root); + returnAST = else_when_e_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::else_when_a(RefMyAST _t) { +#line 1642 "walker.g" + DOMElement* ast; +#line 6399 "flat_modelica_tree_parser.cpp" + RefMyAST else_when_a_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST else_when_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1642 "walker.g" + + DOMElement* expr; + DOMElement* alg; + DOMElement* pAlgElseWhen = pFlatModelicaXMLDoc->createElement(X("alg_elsewhen")); + DOMElement* pAlgThen = pFlatModelicaXMLDoc->createElement(X("alg_then")); + +#line 6413 "flat_modelica_tree_parser.cpp" + + RefMyAST __t210 = _t; + e = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST210 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEWHEN); + _t = _t->getFirstChild(); + expr=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1650 "walker.g" + pAlgElseWhen->appendChild(expr); +#line 6430 "flat_modelica_tree_parser.cpp" + pAlgThen=algorithm_list(_t,pAlgThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST210; + _t = __t210; + _t = _t->getNextSibling(); +#line 1652 "walker.g" + + pAlgElseWhen->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pAlgElseWhen->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + pAlgElseWhen->appendChild(pAlgThen); + ast = pAlgElseWhen; + +#line 6445 "flat_modelica_tree_parser.cpp" + else_when_a_AST = RefMyAST(currentAST.root); + returnAST = else_when_a_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::if_expression(RefMyAST _t) { +#line 1758 "walker.g" + DOMElement* ast; +#line 6455 "flat_modelica_tree_parser.cpp" + RefMyAST if_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST if_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1758 "walker.g" + + DOMElement* cond; + DOMElement* thenPart; + DOMElement* elsePart; + DOMElement* e; + DOMElement* elseifPart; + l_stack el_stack; + +#line 6471 "flat_modelica_tree_parser.cpp" + + RefMyAST __t226 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST226 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF); + _t = _t->getFirstChild(); + cond=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + thenPart=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEIF)) { + e=elseif_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1769 "walker.g" + el_stack.push(e); +#line 6499 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop228; + } + + } + _loop228:; + } // ( ... )* + elsePart=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1770 "walker.g" + + DOMElement* pIf = pFlatModelicaXMLDoc->createElement(X("if")); + DOMElement* pThen = pFlatModelicaXMLDoc->createElement(X("then")); + DOMElement* pElse = pFlatModelicaXMLDoc->createElement(X("else")); + + pIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pIf->appendChild(cond); + pThen->appendChild(thenPart); + pIf->appendChild(pThen); + if (el_stack.size()>0) pIf = (DOMElement*)appendKids(el_stack, pIf); //??is this ok?? + pElse->appendChild(elsePart); + pIf->appendChild(pElse); + ast = pIf; + +#line 6528 "flat_modelica_tree_parser.cpp" + currentAST = __currentAST226; + _t = __t226; + _t = _t->getNextSibling(); + if_expression_AST = RefMyAST(currentAST.root); + returnAST = if_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::code_expression(RefMyAST _t) { +#line 1854 "walker.g" + DOMElement* ast; +#line 6541 "flat_modelica_tree_parser.cpp" + RefMyAST code_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST code_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1854 "walker.g" + + DOMElement*pCode = pFlatModelicaXMLDoc->createElement(X("code")); + +#line 6550 "flat_modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CODE_MODIFICATION: + { + RefMyAST __t236 = _t; + RefMyAST tmp30_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp30_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp30_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp30_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp30_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST236 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_MODIFICATION); + _t = _t->getFirstChild(); + { + ast=modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST236; + _t = __t236; + _t = _t->getNextSibling(); +#line 1861 "walker.g" + + // ?? what the hack is this? + DOMElement* pModification = pFlatModelicaXMLDoc->createElement(X("modification")); + pModification->appendChild(ast); + ast = pModification; + /* + ast = Absyn__CODE(Absyn__C_5fMODIFICATION(ast)); + */ + +#line 6586 "flat_modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_EXPRESSION: + { + RefMyAST __t238 = _t; + RefMyAST tmp31_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp31_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp31_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp31_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp31_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST238 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_EXPRESSION); + _t = _t->getFirstChild(); + { + ast=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST238; + _t = __t238; + _t = _t->getNextSibling(); +#line 1872 "walker.g" + + // ?? what the hack is this? + DOMElement* pExpression = pFlatModelicaXMLDoc->createElement(X("expression")); + pExpression->appendChild(ast); + ast = pExpression; + /* ast = Absyn__CODE(Absyn__C_5fEXPRESSION(ast)); */ + +#line 6619 "flat_modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_ELEMENT: + { + RefMyAST __t240 = _t; + RefMyAST tmp32_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp32_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp32_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp32_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp32_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST240 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_ELEMENT); + _t = _t->getFirstChild(); + { + ast=element(_t,0 /* none */, pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST240; + _t = __t240; + _t = _t->getNextSibling(); +#line 1881 "walker.g" + + // ?? what the hack is this? + DOMElement* pElement = pFlatModelicaXMLDoc->createElement(X("element")); + pElement->appendChild(ast); + ast = pElement; + /* ast = Absyn__CODE(Absyn__C_5fELEMENT(ast)); */ + +#line 6652 "flat_modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_EQUATION: + { + RefMyAST __t242 = _t; + RefMyAST tmp33_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp33_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp33_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp33_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp33_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST242 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_EQUATION); + _t = _t->getFirstChild(); + { + ast=equation_clause(_t,pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST242; + _t = __t242; + _t = _t->getNextSibling(); +#line 1890 "walker.g" + + // ?? what the hack is this? + DOMElement* pEquationSection = pFlatModelicaXMLDoc->createElement(X("equation_section")); + pEquationSection->appendChild(ast); + ast = pEquationSection; + /* ast = Absyn__CODE(Absyn__C_5fEQUATIONSECTION(RML_FALSE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); */ + +#line 6686 "flat_modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_INITIALEQUATION: + { + RefMyAST __t244 = _t; + RefMyAST tmp34_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp34_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp34_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp34_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp34_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST244 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_INITIALEQUATION); + _t = _t->getFirstChild(); + { + ast=equation_clause(_t,pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST244; + _t = __t244; + _t = _t->getNextSibling(); +#line 1900 "walker.g" + + // ?? what the hack is this? + DOMElement* pEquationSection = pFlatModelicaXMLDoc->createElement(X("equation_section")); + ((DOMElement*)ast)->setAttribute(X("initial"), X("true")); + pEquationSection->appendChild(ast); + ast = pEquationSection; + /* + ast = Absyn__CODE(Absyn__C_5fEQUATIONSECTION(RML_TRUE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + +#line 6723 "flat_modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_ALGORITHM: + { + RefMyAST __t246 = _t; + RefMyAST tmp35_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp35_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp35_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp35_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp35_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST246 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_ALGORITHM); + _t = _t->getFirstChild(); + { + ast=algorithm_clause(_t,pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST246; + _t = __t246; + _t = _t->getNextSibling(); +#line 1912 "walker.g" + + // ?? what the hack is this? + DOMElement* pAlgorithmSection = pFlatModelicaXMLDoc->createElement(X("algorithm_section")); + pAlgorithmSection->appendChild(ast); + ast = pAlgorithmSection; + /* + ast = Absyn__CODE(Absyn__C_5fALGORITHMSECTION(RML_FALSE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + +#line 6759 "flat_modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_INITIALALGORITHM: + { + RefMyAST __t248 = _t; + RefMyAST tmp36_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp36_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp36_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp36_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp36_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST248 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_INITIALALGORITHM); + _t = _t->getFirstChild(); + { + ast=algorithm_clause(_t,pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST248; + _t = __t248; + _t = _t->getNextSibling(); +#line 1923 "walker.g" + + // ?? what the hack is this? + DOMElement* pAlgorithmSection = pFlatModelicaXMLDoc->createElement(X("algorithm_section")); + ((DOMElement*)ast)->setAttribute(X("initial"), X("true")); + pAlgorithmSection->appendChild(ast); + ast = pAlgorithmSection; + /* + ast = Absyn__CODE(Absyn__C_5fALGORITHMSECTION(RML_TRUE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + +#line 6796 "flat_modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = code_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::elseif_expression(RefMyAST _t) { +#line 1789 "walker.g" + DOMElement* ast; +#line 6813 "flat_modelica_tree_parser.cpp" + RefMyAST elseif_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST elseif_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1789 "walker.g" + + DOMElement* cond; + DOMElement* thenPart; + +#line 6825 "flat_modelica_tree_parser.cpp" + + RefMyAST __t230 = _t; + els = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST els_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + els_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(els)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(els_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST230 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEIF); + _t = _t->getFirstChild(); + cond=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + thenPart=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1796 "walker.g" + + DOMElement* pElseIf = pFlatModelicaXMLDoc->createElement(X("elseif")); + + pElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pElseIf->appendChild(cond); + DOMElement* pThen = pFlatModelicaXMLDoc->createElement(X("then")); + pThen->appendChild(thenPart); + pElseIf->appendChild(pThen); + ast = pElseIf; + +#line 6856 "flat_modelica_tree_parser.cpp" + currentAST = __currentAST230; + _t = __t230; + _t = _t->getNextSibling(); + elseif_expression_AST = RefMyAST(currentAST.root); + returnAST = elseif_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::logical_expression(RefMyAST _t) { +#line 1936 "walker.g" + DOMElement* ast; +#line 6869 "flat_modelica_tree_parser.cpp" + RefMyAST logical_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1936 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 6881 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case END: + case FALSE: + case NOT: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case DOT: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=logical_term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case OR: + { + RefMyAST __t252 = _t; + o = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST o_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + o_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(o)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(o_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST252 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OR); + _t = _t->getFirstChild(); + e1=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=logical_term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST252; + _t = __t252; + _t = _t->getNextSibling(); +#line 1944 "walker.g" + + DOMElement* pOr = pFlatModelicaXMLDoc->createElement(X("or")); + + pOr->setAttribute(X("sline"), X(itoa(o->getLine(),stmp,10))); + pOr->setAttribute(X("scolumn"), X(itoa(o->getColumn(),stmp,10))); + + pOr->appendChild(e1); + pOr->appendChild(e2); + ast = pOr; + +#line 6953 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + logical_expression_AST = RefMyAST(currentAST.root); + returnAST = logical_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::logical_term(RefMyAST _t) { +#line 1958 "walker.g" + DOMElement* ast; +#line 6971 "flat_modelica_tree_parser.cpp" + RefMyAST logical_term_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_term_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST a = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1958 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 6983 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case END: + case FALSE: + case NOT: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case DOT: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=logical_factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case AND: + { + RefMyAST __t255 = _t; + a = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST a_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + a_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(a)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST255 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AND); + _t = _t->getFirstChild(); + e1=logical_term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=logical_factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST255; + _t = __t255; + _t = _t->getNextSibling(); +#line 1966 "walker.g" + + DOMElement* pAnd = pFlatModelicaXMLDoc->createElement(X("and")); + + pAnd->setAttribute(X("sline"), X(itoa(a->getLine(),stmp,10))); + pAnd->setAttribute(X("scolumn"), X(itoa(a->getColumn(),stmp,10))); + + pAnd->appendChild(e1); + pAnd->appendChild(e2); + ast = pAnd; + +#line 7054 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + logical_term_AST = RefMyAST(currentAST.root); + returnAST = logical_term_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::logical_factor(RefMyAST _t) { +#line 1979 "walker.g" + DOMElement* ast; +#line 7072 "flat_modelica_tree_parser.cpp" + RefMyAST logical_factor_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_factor_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST n = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST n_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case NOT: + { + RefMyAST __t257 = _t; + n = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST n_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + n_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(n)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST257 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NOT); + _t = _t->getFirstChild(); + ast=relation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1982 "walker.g" + + DOMElement* pNot = pFlatModelicaXMLDoc->createElement(X("not")); + + pNot->setAttribute(X("sline"), X(itoa(n->getLine(),stmp,10))); + pNot->setAttribute(X("scolumn"), X(itoa(n->getColumn(),stmp,10))); + + pNot->appendChild(ast); + ast = pNot; + +#line 7108 "flat_modelica_tree_parser.cpp" + currentAST = __currentAST257; + _t = __t257; + _t = _t->getNextSibling(); + logical_factor_AST = RefMyAST(currentAST.root); + break; + } + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case DOT: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=relation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + logical_factor_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = logical_factor_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::relation(RefMyAST _t) { +#line 1993 "walker.g" + DOMElement* ast; +#line 7161 "flat_modelica_tree_parser.cpp" + RefMyAST relation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST relation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lt = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lt_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lte = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lte_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST gt = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST gt_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST gte = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST gte_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ne = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ne_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1993 "walker.g" + + DOMElement* e1; + DOMElement* op = 0; + DOMElement* e2 = 0; + +#line 7184 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case DOT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LESS: + { + RefMyAST __t261 = _t; + lt = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lt_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lt_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lt)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lt_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST261 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LESS); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST261; + _t = __t261; + _t = _t->getNextSibling(); +#line 2003 "walker.g" + op = pFlatModelicaXMLDoc->createElement(X("lt")); /* Absyn__LESS; */ +#line 7250 "flat_modelica_tree_parser.cpp" + break; + } + case LESSEQ: + { + RefMyAST __t262 = _t; + lte = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lte_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lte_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lte)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lte_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST262 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LESSEQ); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST262; + _t = __t262; + _t = _t->getNextSibling(); +#line 2005 "walker.g" + op = pFlatModelicaXMLDoc->createElement(X("lte")); /* Absyn__LESSEQ; */ +#line 7276 "flat_modelica_tree_parser.cpp" + break; + } + case GREATER: + { + RefMyAST __t263 = _t; + gt = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST gt_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + gt_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(gt)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(gt_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST263 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GREATER); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST263; + _t = __t263; + _t = _t->getNextSibling(); +#line 2007 "walker.g" + op = pFlatModelicaXMLDoc->createElement(X("gt")); /* Absyn__GREATER; */ +#line 7302 "flat_modelica_tree_parser.cpp" + break; + } + case GREATEREQ: + { + RefMyAST __t264 = _t; + gte = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST gte_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + gte_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(gte)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(gte_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST264 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GREATEREQ); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST264; + _t = __t264; + _t = _t->getNextSibling(); +#line 2009 "walker.g" + op = pFlatModelicaXMLDoc->createElement(X("gte")); /* Absyn__GREATEREQ; */ +#line 7328 "flat_modelica_tree_parser.cpp" + break; + } + case EQEQ: + { + RefMyAST __t265 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST265 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQEQ); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST265; + _t = __t265; + _t = _t->getNextSibling(); +#line 2011 "walker.g" + op = pFlatModelicaXMLDoc->createElement(X("eq")); /* Absyn__EQUAL; */ +#line 7354 "flat_modelica_tree_parser.cpp" + break; + } + case LESSGT: + { + RefMyAST __t266 = _t; + ne = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST ne_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ne_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ne)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ne_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST266 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LESSGT); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST266; + _t = __t266; + _t = _t->getNextSibling(); +#line 2013 "walker.g" + op = pFlatModelicaXMLDoc->createElement(X("ne")); /* op = Absyn__NEQUAL; */ +#line 7380 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 2015 "walker.g" + + op->appendChild(e1); + op->appendChild(e2); + if (lt) { op->setAttribute(X("sline"), X(itoa(lt->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(lt->getColumn(),stmp,10))); } + if (lte){ op->setAttribute(X("sline"), X(itoa(lte->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(lte->getColumn(),stmp,10))); } + if (gt) { op->setAttribute(X("sline"), X(itoa(gt->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(gt->getColumn(),stmp,10))); } + if (gte){ op->setAttribute(X("sline"), X(itoa(gte->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(gte->getColumn(),stmp,10))); } + if (eq) { op->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); } + if (ne) { op->setAttribute(X("sline"), X(itoa(ne->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(ne->getColumn(),stmp,10))); } + ast = op; + +#line 7401 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + relation_AST = RefMyAST(currentAST.root); + returnAST = relation_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::arithmetic_expression(RefMyAST _t) { +#line 2029 "walker.g" + DOMElement* ast; +#line 7419 "flat_modelica_tree_parser.cpp" + RefMyAST arithmetic_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST arithmetic_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST add = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST add_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sub = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sub_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2029 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 7433 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case STAR: + case SLASH: + case DOT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=unary_arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case PLUS: + { + RefMyAST __t269 = _t; + add = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST add_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + add_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(add)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(add_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST269 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PLUS); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST269; + _t = __t269; + _t = _t->getNextSibling(); +#line 2037 "walker.g" + + DOMElement* pAdd = pFlatModelicaXMLDoc->createElement(X("add")); + + pAdd->setAttribute(X("sline"), X(itoa(add->getLine(),stmp,10))); + pAdd->setAttribute(X("scolumn"), X(itoa(add->getColumn(),stmp,10))); + + pAdd->setAttribute(X("operation"), X("binary")); + pAdd->appendChild(e1); + pAdd->appendChild(e2); + ast = pAdd; + +#line 7496 "flat_modelica_tree_parser.cpp" + break; + } + case MINUS: + { + RefMyAST __t270 = _t; + sub = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST sub_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + sub_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(sub)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(sub_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST270 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MINUS); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST270; + _t = __t270; + _t = _t->getNextSibling(); +#line 2049 "walker.g" + + DOMElement* pSub = pFlatModelicaXMLDoc->createElement(X("sub")); + + pSub->setAttribute(X("sline"), X(itoa(sub->getLine(),stmp,10))); + pSub->setAttribute(X("scolumn"), X(itoa(sub->getColumn(),stmp,10))); + + pSub->setAttribute(X("operation"), X("binary")); + pSub->appendChild(e1); + pSub->appendChild(e2); + ast = pSub; + +#line 7532 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + arithmetic_expression_AST = RefMyAST(currentAST.root); + returnAST = arithmetic_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::unary_arithmetic_expression(RefMyAST _t) { +#line 2063 "walker.g" + DOMElement* ast; +#line 7550 "flat_modelica_tree_parser.cpp" + RefMyAST unary_arithmetic_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST unary_arithmetic_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST add = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST add_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sub = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sub_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case UNARY_PLUS: + { + RefMyAST __t273 = _t; + add = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST add_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + add_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(add)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(add_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST273 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNARY_PLUS); + _t = _t->getFirstChild(); + ast=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST273; + _t = __t273; + _t = _t->getNextSibling(); +#line 2066 "walker.g" + + DOMElement* pAdd = pFlatModelicaXMLDoc->createElement(X("add")); + + pAdd->setAttribute(X("sline"), X(itoa(add->getLine(),stmp,10))); + pAdd->setAttribute(X("scolumn"), X(itoa(add->getColumn(),stmp,10))); + + pAdd->setAttribute(X("operation"), X("unary")); + pAdd->appendChild(ast); + ast = pAdd; + +#line 7593 "flat_modelica_tree_parser.cpp" + break; + } + case UNARY_MINUS: + { + RefMyAST __t274 = _t; + sub = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST sub_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + sub_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(sub)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(sub_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST274 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNARY_MINUS); + _t = _t->getFirstChild(); + ast=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST274; + _t = __t274; + _t = _t->getNextSibling(); +#line 2077 "walker.g" + + DOMElement* pSub = pFlatModelicaXMLDoc->createElement(X("sub")); + + pSub->setAttribute(X("sline"), X(itoa(sub->getLine(),stmp,10))); + pSub->setAttribute(X("scolumn"), X(itoa(sub->getColumn(),stmp,10))); + + pSub->setAttribute(X("operation"), X("unary")); + pSub->appendChild(ast); + ast = pSub; + +#line 7625 "flat_modelica_tree_parser.cpp" + break; + } + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case STAR: + case SLASH: + case DOT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + { + ast=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + unary_arithmetic_expression_AST = RefMyAST(currentAST.root); + returnAST = unary_arithmetic_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::term(RefMyAST _t) { +#line 2091 "walker.g" + DOMElement* ast; +#line 7665 "flat_modelica_tree_parser.cpp" + RefMyAST term_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST term_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST mul = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST mul_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST div = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST div_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2091 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 7679 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case DOT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + { + ast=factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case STAR: + { + RefMyAST __t277 = _t; + mul = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST mul_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + mul_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(mul)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(mul_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST277 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STAR); + _t = _t->getFirstChild(); + e1=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST277; + _t = __t277; + _t = _t->getNextSibling(); +#line 2099 "walker.g" + + DOMElement* pMul = pFlatModelicaXMLDoc->createElement(X("mul")); + + pMul->setAttribute(X("sline"), X(itoa(mul->getLine(),stmp,10))); + pMul->setAttribute(X("scolumn"), X(itoa(mul->getColumn(),stmp,10))); + + pMul->appendChild(e1); + pMul->appendChild(e2); + ast = pMul; + +#line 7737 "flat_modelica_tree_parser.cpp" + break; + } + case SLASH: + { + RefMyAST __t278 = _t; + div = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST div_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + div_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(div)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(div_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST278 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SLASH); + _t = _t->getFirstChild(); + e1=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST278; + _t = __t278; + _t = _t->getNextSibling(); +#line 2110 "walker.g" + + DOMElement* pDiv = pFlatModelicaXMLDoc->createElement(X("div")); + + pDiv->setAttribute(X("sline"), X(itoa(div->getLine(),stmp,10))); + pDiv->setAttribute(X("scolumn"), X(itoa(div->getColumn(),stmp,10))); + + pDiv->appendChild(e1); + pDiv->appendChild(e2); + ast = pDiv; + +#line 7772 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + term_AST = RefMyAST(currentAST.root); + returnAST = term_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::factor(RefMyAST _t) { +#line 2123 "walker.g" + DOMElement* ast; +#line 7790 "flat_modelica_tree_parser.cpp" + RefMyAST factor_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST factor_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST pw = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST pw_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2123 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 7802 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case DOT: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + { + ast=primary(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case POWER: + { + RefMyAST __t281 = _t; + pw = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST pw_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + pw_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(pw)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pw_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST281 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),POWER); + _t = _t->getFirstChild(); + e1=primary(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=primary(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST281; + _t = __t281; + _t = _t->getNextSibling(); +#line 2131 "walker.g" + + DOMElement* pPow = pFlatModelicaXMLDoc->createElement(X("pow")); + + pPow->setAttribute(X("sline"), X(itoa(pw->getLine(),stmp,10))); + pPow->setAttribute(X("scolumn"), X(itoa(pw->getColumn(),stmp,10))); + + pPow->appendChild(e1); + pPow->appendChild(e2); + ast = pPow; + +#line 7859 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + factor_AST = RefMyAST(currentAST.root); + returnAST = factor_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::primary(RefMyAST _t) { +#line 2144 "walker.g" + DOMElement* ast; +#line 7877 "flat_modelica_tree_parser.cpp" + RefMyAST primary_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST primary_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ui = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ui_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ur = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ur_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST str = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST str_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbk = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbk_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbr = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbr_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tend = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tend_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2144 "walker.g" + + l_stack el_stack; + DOMElement* e; + DOMElement* pSemicolon = pFlatModelicaXMLDoc->createElement(X("semicolon")); + +#line 7904 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case UNSIGNED_INTEGER: + { + ui = _t; + RefMyAST ui_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ui_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ui)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ui_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNSIGNED_INTEGER); + _t = _t->getNextSibling(); +#line 2152 "walker.g" + + DOMElement* pIntegerLiteral = pFlatModelicaXMLDoc->createElement(X("integer_literal")); + pIntegerLiteral->setAttribute(X("value"), str2xml(ui)); + + pIntegerLiteral->setAttribute(X("sline"), X(itoa(ui->getLine(),stmp,10))); + pIntegerLiteral->setAttribute(X("scolumn"), X(itoa(ui->getColumn(),stmp,10))); + + ast = pIntegerLiteral; + +#line 7928 "flat_modelica_tree_parser.cpp" + break; + } + case UNSIGNED_REAL: + { + ur = _t; + RefMyAST ur_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ur_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ur)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ur_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNSIGNED_REAL); + _t = _t->getNextSibling(); +#line 2162 "walker.g" + + DOMElement* pRealLiteral = pFlatModelicaXMLDoc->createElement(X("real_literal")); + pRealLiteral->setAttribute(X("value"), str2xml(ur)); + + pRealLiteral->setAttribute(X("sline"), X(itoa(ur->getLine(),stmp,10))); + pRealLiteral->setAttribute(X("scolumn"), X(itoa(ur->getColumn(),stmp,10))); + + ast = pRealLiteral; + +#line 7949 "flat_modelica_tree_parser.cpp" + break; + } + case STRING: + { + str = _t; + RefMyAST str_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + str_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(str)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(str_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING); + _t = _t->getNextSibling(); +#line 2172 "walker.g" + + DOMElement* pStringLiteral = pFlatModelicaXMLDoc->createElement(X("string_literal")); + pStringLiteral->setAttribute(X("value"), str2xml(str)); + + pStringLiteral->setAttribute(X("sline"), X(itoa(str->getLine(),stmp,10))); + pStringLiteral->setAttribute(X("scolumn"), X(itoa(str->getColumn(),stmp,10))); + + ast = pStringLiteral; + +#line 7970 "flat_modelica_tree_parser.cpp" + break; + } + case FALSE: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FALSE); + _t = _t->getNextSibling(); +#line 2182 "walker.g" + + DOMElement* pBoolLiteral = pFlatModelicaXMLDoc->createElement(X("bool_literal")); + pBoolLiteral->setAttribute(X("value"), X("false")); + + pBoolLiteral->setAttribute(X("sline"), X(itoa(f->getLine(),stmp,10))); + pBoolLiteral->setAttribute(X("scolumn"), X(itoa(f->getColumn(),stmp,10))); + + ast = pBoolLiteral; + +#line 7991 "flat_modelica_tree_parser.cpp" + break; + } + case TRUE: + { + t = _t; + RefMyAST t_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + t_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(t)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TRUE); + _t = _t->getNextSibling(); +#line 2192 "walker.g" + + DOMElement* pBoolLiteral = pFlatModelicaXMLDoc->createElement(X("bool_literal")); + pBoolLiteral->setAttribute(X("value"), X("true")); + + pBoolLiteral->setAttribute(X("sline"), X(itoa(t->getLine(),stmp,10))); + pBoolLiteral->setAttribute(X("scolumn"), X(itoa(t->getColumn(),stmp,10))); + + ast = pBoolLiteral; + +#line 8012 "flat_modelica_tree_parser.cpp" + break; + } + case DOT: + case IDENT: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + { + ast=component_reference__function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case LPAR: + { + RefMyAST __t284 = _t; + RefMyAST tmp37_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp37_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp37_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp37_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp37_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST284 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LPAR); + _t = _t->getFirstChild(); + ast=tuple_expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST284; + _t = __t284; + _t = _t->getNextSibling(); + break; + } + case LBRACK: + { + RefMyAST __t285 = _t; + lbk = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lbk_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lbk_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lbk)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lbk_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST285 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LBRACK); + _t = _t->getFirstChild(); + e=expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2203 "walker.g" + el_stack.push(e); +#line 8063 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == EXPRESSION_LIST)) { + e=expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2204 "walker.g" + el_stack.push(e); +#line 8074 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop287; + } + + } + _loop287:; + } // ( ... )* + currentAST = __currentAST285; + _t = __t285; + _t = _t->getNextSibling(); +#line 2205 "walker.g" + + DOMElement* pConcat = pFlatModelicaXMLDoc->createElement(X("concat")); + + pConcat->setAttribute(X("sline"), X(itoa(lbk->getLine(),stmp,10))); + pConcat->setAttribute(X("scolumn"), X(itoa(lbk->getColumn(),stmp,10))); + + pConcat = (DOMElement*)appendKids(el_stack, pConcat); + ast = pConcat; + +#line 8096 "flat_modelica_tree_parser.cpp" + break; + } + case LBRACE: + { + RefMyAST __t288 = _t; + lbr = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lbr_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lbr_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lbr)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lbr_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST288 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LBRACE); + _t = _t->getFirstChild(); + ast=function_arguments(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST288; + _t = __t288; + _t = _t->getNextSibling(); +#line 2215 "walker.g" + + DOMElement* pArray = pFlatModelicaXMLDoc->createElement(X("array")); + + pArray->setAttribute(X("sline"), X(itoa(lbr->getLine(),stmp,10))); + pArray->setAttribute(X("scolumn"), X(itoa(lbr->getColumn(),stmp,10))); + + pArray->appendChild(ast); + ast = pArray; + +#line 8127 "flat_modelica_tree_parser.cpp" + break; + } + case END: + { + tend = _t; + RefMyAST tend_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tend_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(tend)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tend_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),END); + _t = _t->getNextSibling(); +#line 2225 "walker.g" + + DOMElement* pEnd = pFlatModelicaXMLDoc->createElement(X("end")); + pEnd->setAttribute(X("sline"), X(itoa(tend->getLine(),stmp,10))); + pEnd->setAttribute(X("scolumn"), X(itoa(tend->getColumn(),stmp,10))); + ast = pEnd; + +#line 8145 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + primary_AST = RefMyAST(currentAST.root); + returnAST = primary_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::component_reference__function_call(RefMyAST _t) { +#line 2234 "walker.g" + DOMElement* ast; +#line 8163 "flat_modelica_tree_parser.cpp" + RefMyAST component_reference__function_call_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_reference__function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fc = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ifc = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ifc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2234 "walker.g" + + DOMElement* cref; + DOMElement* fnc = 0; + +#line 8179 "flat_modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT: + case IDENT: + case FUNCTION_CALL: + { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FUNCTION_CALL: + { + RefMyAST __t291 = _t; + fc = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST fc_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + fc_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(fc)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(fc_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST291 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_CALL); + _t = _t->getFirstChild(); + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FUNCTION_ARGUMENTS: + { + fnc=function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST291; + _t = __t291; + _t = _t->getNextSibling(); +#line 2241 "walker.g" + + DOMElement* pCall = pFlatModelicaXMLDoc->createElement(X("call")); + + pCall->setAttribute(X("sline"), X(itoa(fc->getLine(),stmp,10))); + pCall->setAttribute(X("scolumn"), X(itoa(fc->getColumn(),stmp,10))); + + pCall->appendChild(cref); + if (fnc) pCall->appendChild(fnc); + ast = pCall; + +#line 8242 "flat_modelica_tree_parser.cpp" + break; + } + case DOT: + case IDENT: + { + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2252 "walker.g" + + if (fnc && cref) cref->appendChild(fnc); + ast = cref; + +#line 8256 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + component_reference__function_call_AST = RefMyAST(currentAST.root); + break; + } + case INITIAL_FUNCTION_CALL: + { + RefMyAST __t293 = _t; + ifc = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST ifc_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ifc_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ifc)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ifc_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST293 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INITIAL_FUNCTION_CALL); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INITIAL); + _t = _t->getNextSibling(); + currentAST = __currentAST293; + _t = __t293; + _t = _t->getNextSibling(); +#line 2259 "walker.g" + + // calling function initial + DOMElement* pCall = pFlatModelicaXMLDoc->createElement(X("call")); + + DOMElement* pCref = pFlatModelicaXMLDoc->createElement(X("component_reference")); + pCref->setAttribute(X("ident"), X("initial")); + pCref->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pCall->appendChild(pCref); + + pCall->setAttribute(X("sline"), X(itoa(ifc->getLine(),stmp,10))); + pCall->setAttribute(X("scolumn"), X(itoa(ifc->getColumn(),stmp,10))); + + ast = pCall; + +#line 8306 "flat_modelica_tree_parser.cpp" + component_reference__function_call_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = component_reference__function_call_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::function_arguments(RefMyAST _t) { +#line 2360 "walker.g" + DOMElement* ast; +#line 8323 "flat_modelica_tree_parser.cpp" + RefMyAST function_arguments_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST function_arguments_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2360 "walker.g" + + l_stack el_stack; + DOMElement* elist=0; + DOMElement* namel=0; + DOMElement *pFunctionArguments = pFlatModelicaXMLDoc->createElement(X("function_arguments")); + +#line 8335 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXPRESSION_LIST: + { + pFunctionArguments=expression_list2(_t,pFunctionArguments); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case NAMED_ARGUMENTS: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case NAMED_ARGUMENTS: + { + pFunctionArguments=named_arguments(_t,pFunctionArguments); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 2370 "walker.g" + + ast = pFunctionArguments; + +#line 8384 "flat_modelica_tree_parser.cpp" + function_arguments_AST = RefMyAST(currentAST.root); + returnAST = function_arguments_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::expression_list2(RefMyAST _t, + DOMElement *parent +) { +#line 2339 "walker.g" + DOMElement* ast; +#line 8396 "flat_modelica_tree_parser.cpp" + RefMyAST expression_list2_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_list2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2339 "walker.g" + + l_stack el_stack; + DOMElement* e; + +#line 8408 "flat_modelica_tree_parser.cpp" + + { + RefMyAST __t307 = _t; + el = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST el_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + el_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(el)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(el_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST307 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXPRESSION_LIST); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2346 "walker.g" + parent->appendChild(e); +#line 8426 "flat_modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_2.member(_t->getType()))) { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2347 "walker.g" + parent->appendChild(e); +#line 8437 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop309; + } + + } + _loop309:; + } // ( ... )* + currentAST = __currentAST307; + _t = __t307; + _t = _t->getNextSibling(); + } +#line 2350 "walker.g" + + ast = parent; + +#line 8454 "flat_modelica_tree_parser.cpp" + expression_list2_AST = RefMyAST(currentAST.root); + returnAST = expression_list2_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::named_arguments(RefMyAST _t, + DOMElement *parent +) { +#line 2378 "walker.g" + DOMElement* ast; +#line 8466 "flat_modelica_tree_parser.cpp" + RefMyAST named_arguments_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_arguments_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST na = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST na_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2378 "walker.g" + + l_stack el_stack; + DOMElement* n; + +#line 8478 "flat_modelica_tree_parser.cpp" + + RefMyAST __t314 = _t; + na = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST na_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + na_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(na)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(na_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST314 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NAMED_ARGUMENTS); + _t = _t->getFirstChild(); + { + n=named_argument(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2384 "walker.g" + parent->appendChild(n); +#line 8496 "flat_modelica_tree_parser.cpp" + } + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == EQUALS)) { + n=named_argument(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2385 "walker.g" + parent->appendChild(n); +#line 8508 "flat_modelica_tree_parser.cpp" + } + else { + goto _loop317; + } + + } + _loop317:; + } // ( ... )* + currentAST = __currentAST314; + _t = __t314; + _t = _t->getNextSibling(); +#line 2386 "walker.g" + + ast = parent; + +#line 8524 "flat_modelica_tree_parser.cpp" + named_arguments_AST = RefMyAST(currentAST.root); + returnAST = named_arguments_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::named_argument(RefMyAST _t) { +#line 2391 "walker.g" + DOMElement* ast; +#line 8534 "flat_modelica_tree_parser.cpp" + RefMyAST named_argument_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_argument_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2391 "walker.g" + + DOMElement* temp; + +#line 8547 "flat_modelica_tree_parser.cpp" + + RefMyAST __t319 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST319 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + temp=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST319; + _t = __t319; + _t = _t->getNextSibling(); +#line 2397 "walker.g" + + DOMElement *pNamedArgument = pFlatModelicaXMLDoc->createElement(X("named_argument")); + pNamedArgument->setAttribute(X("ident"), str2xml(i)); + + pNamedArgument->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pNamedArgument->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pNamedArgument->appendChild(temp); + ast = pNamedArgument; + +#line 8582 "flat_modelica_tree_parser.cpp" + named_argument_AST = RefMyAST(currentAST.root); + returnAST = named_argument_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::subscript(RefMyAST _t, + DOMElement* parent +) { +#line 2485 "walker.g" + DOMElement* ast; +#line 8594 "flat_modelica_tree_parser.cpp" + RefMyAST subscript_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST subscript_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2485 "walker.g" + + DOMElement* e; + DOMElement* pColon = pFlatModelicaXMLDoc->createElement(X("colon")); + +#line 8606 "flat_modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case END: + case FALSE: + case IF: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case DOT: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case CODE_EXPRESSION: + case CODE_MODIFICATION: + case CODE_ELEMENT: + case CODE_EQUATION: + case CODE_INITIALEQUATION: + case CODE_ALGORITHM: + case CODE_INITIALALGORITHM: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case RANGE2: + case RANGE3: + case UNARY_MINUS: + case UNARY_PLUS: + { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2493 "walker.g" + + parent->appendChild(e); + ast = parent; + +#line 8660 "flat_modelica_tree_parser.cpp" + break; + } + case COLON: + { + c = _t; + RefMyAST c_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + c_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(c)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COLON); + _t = _t->getNextSibling(); +#line 2498 "walker.g" + + + pColon->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pColon->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + + parent->appendChild(pColon); + ast = parent; + +#line 8680 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + subscript_AST = RefMyAST(currentAST.root); + returnAST = subscript_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::string_concatenation(RefMyAST _t) { +#line 2551 "walker.g" + DOMElement* ast; +#line 8698 "flat_modelica_tree_parser.cpp" + RefMyAST string_concatenation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST string_concatenation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2551 "walker.g" + + DOMElement*pString1; + l_stack el_stack; + +#line 8714 "flat_modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case STRING: + { + s = _t; + RefMyAST s_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + s_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(s)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING); + _t = _t->getNextSibling(); +#line 2558 "walker.g" + + DOMElement *pString = pFlatModelicaXMLDoc->createElement(X("string_literal")); + pString->setAttribute(X("value"), str2xml(s)); + + pString->setAttribute(X("sline"), X(itoa(s->getLine(),stmp,10))); + pString->setAttribute(X("scolumn"), X(itoa(s->getColumn(),stmp,10))); + + ast=pString; + +#line 8737 "flat_modelica_tree_parser.cpp" + string_concatenation_AST = RefMyAST(currentAST.root); + break; + } + case PLUS: + { + RefMyAST __t342 = _t; + p = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST342 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PLUS); + _t = _t->getFirstChild(); + pString1=string_concatenation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + s2 = _t; + RefMyAST s2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + s2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(s2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s2_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING); + _t = _t->getNextSibling(); + currentAST = __currentAST342; + _t = __t342; + _t = _t->getNextSibling(); +#line 2568 "walker.g" + + DOMElement *pString = pFlatModelicaXMLDoc->createElement(X("add_string")); + + pString->setAttribute(X("sline"), X(itoa(p->getLine(),stmp,10))); + pString->setAttribute(X("scolumn"), X(itoa(p->getColumn(),stmp,10))); + + pString->appendChild(pString1); + DOMElement *pString2 = pFlatModelicaXMLDoc->createElement(X("string_literal")); + pString2->setAttribute(X("value"), str2xml(s2)); + + pString2->setAttribute(X("sline"), X(itoa(s2->getLine(),stmp,10))); + pString2->setAttribute(X("scolumn"), X(itoa(s2->getColumn(),stmp,10))); + + pString->appendChild(pString2); + ast=pString; + +#line 8782 "flat_modelica_tree_parser.cpp" + string_concatenation_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = string_concatenation_AST; + _retTree = _t; + return ast; +} + +DOMElement* flat_modelica_tree_parser::interactive_stmt(RefMyAST _t) { +#line 2628 "walker.g" + DOMElement* ast; +#line 8799 "flat_modelica_tree_parser.cpp" + RefMyAST interactive_stmt_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST interactive_stmt_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2628 "walker.g" + + DOMElement* al=0; + DOMElement* el=0; + l_stack el_stack; + DOMElement *pInteractiveSTMT = pFlatModelicaXMLDoc->createElement(X("ISTMT")); + DOMElement *pInteractiveALG = pFlatModelicaXMLDoc->createElement(X("IALG")); + +#line 8814 "flat_modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case INTERACTIVE_ALG: + { + RefMyAST __t347 = _t; + RefMyAST tmp38_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp38_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp38_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp38_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp38_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST347 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INTERACTIVE_ALG); + _t = _t->getFirstChild(); + { + pInteractiveALG=algorithm(_t,pInteractiveALG); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST347; + _t = __t347; + _t = _t->getNextSibling(); +#line 2639 "walker.g" + + //pInteractiveALG->appendChild(al); + el_stack.push(pInteractiveALG); + +#line 8847 "flat_modelica_tree_parser.cpp" + break; + } + case INTERACTIVE_EXP: + { + RefMyAST __t349 = _t; + RefMyAST tmp39_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp39_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp39_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp39_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp39_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST349 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INTERACTIVE_EXP); + _t = _t->getFirstChild(); + { + el=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST349; + _t = __t349; + _t = _t->getNextSibling(); +#line 2645 "walker.g" + + DOMElement *pInteractiveEXP = pFlatModelicaXMLDoc->createElement(X("IEXP")); + pInteractiveEXP->appendChild(el); + el_stack.push(pInteractiveEXP); + +#line 8877 "flat_modelica_tree_parser.cpp" + break; + } + default: + { + goto _loop351; + } + } + } + _loop351:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case SEMICOLON: + { + s = _t; + RefMyAST s_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + s_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(s)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SEMICOLON); + _t = _t->getNextSibling(); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 2652 "walker.g" + + pInteractiveSTMT = (DOMElement*)appendKids(el_stack, pInteractiveSTMT); + if (s) pInteractiveSTMT->setAttribute(X("semicolon"),X("true")); + ast = pInteractiveSTMT; + +#line 8918 "flat_modelica_tree_parser.cpp" + interactive_stmt_AST = RefMyAST(currentAST.root); + returnAST = interactive_stmt_AST; + _retTree = _t; + return ast; +} + +void flat_modelica_tree_parser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) +{ + factory.setMaxNodeType(158); +} +const char* flat_modelica_tree_parser::tokenNames[] = { + "<0>", + "EOF", + "<2>", + "NULL_TREE_LOOKAHEAD", + "\"algorithm\"", + "\"and\"", + "\"annotation\"", + "\"block\"", + "\"Code\"", + "\"class\"", + "\"connect\"", + "\"connector\"", + "\"constant\"", + "\"discrete\"", + "\"each\"", + "\"else\"", + "\"elseif\"", + "\"elsewhen\"", + "\"end\"", + "\"enumeration\"", + "\"equation\"", + "\"encapsulated\"", + "\"extends\"", + "\"external\"", + "\"false\"", + "\"final\"", + "\"flow\"", + "\"for\"", + "\"function\"", + "\"if\"", + "\"import\"", + "\"in\"", + "\"initial\"", + "\"inner\"", + "\"input\"", + "\"loop\"", + "\"model\"", + "\"not\"", + "\"outer\"", + "\"overload\"", + "\"or\"", + "\"output\"", + "\"package\"", + "\"parameter\"", + "\"partial\"", + "\"protected\"", + "\"public\"", + "\"record\"", + "\"redeclare\"", + "\"replaceable\"", + "\"results\"", + "\"then\"", + "\"true\"", + "\"type\"", + "\"unsigned_real\"", + "\"when\"", + "\"while\"", + "\"within\"", + "\"abstype\"", + "\"as\"", + "\"axiom\"", + "\"datatype\"", + "\"fail\"", + "\"let\"", + "\"interface\"", + "\"module\"", + "\"of\"", + "\"relation\"", + "\"rule\"", + "\"val\"", + "\"_\"", + "\"with\"", + "\"withtype\"", + "LPAR", + "RPAR", + "LBRACK", + "RBRACK", + "LBRACE", + "RBRACE", + "EQUALS", + "ASSIGN", + "PLUS", + "MINUS", + "STAR", + "SLASH", + "DOT", + "COMMA", + "LESS", + "LESSEQ", + "GREATER", + "GREATEREQ", + "EQEQ", + "LESSGT", + "COLON", + "SEMICOLON", + "POWER", + "YIELDS", + "AMPERSAND", + "PIPEBAR", + "COLONCOLON", + "DASHES", + "WS", + "ML_COMMENT", + "ML_COMMENT_CHAR", + "SL_COMMENT", + "an identifier", + "a type identifier", + "NONDIGIT", + "DIGIT", + "EXPONENT", + "UNSIGNED_INTEGER", + "STRING", + "SCHAR", + "SESCAPE", + "ESC", + "ALGORITHM_STATEMENT", + "ARGUMENT_LIST", + "BEGIN_DEFINITION", + "CLASS_DEFINITION", + "CLASS_MODIFICATION", + "CODE_EXPRESSION", + "CODE_MODIFICATION", + "CODE_ELEMENT", + "CODE_EQUATION", + "CODE_INITIALEQUATION", + "CODE_ALGORITHM", + "CODE_INITIALALGORITHM", + "COMMENT", + "COMPONENT_DEFINITION", + "DECLARATION", + "DEFINITION", + "END_DEFINITION", + "ENUMERATION_LITERAL", + "ELEMENT", + "ELEMENT_MODIFICATION", + "ELEMENT_REDECLARATION", + "EQUATION_STATEMENT", + "INITIAL_EQUATION", + "INITIAL_ALGORITHM", + "IMPORT_DEFINITION", + "EXPRESSION_LIST", + "EXTERNAL_FUNCTION_CALL", + "FOR_INDICES", + "FOR_ITERATOR", + "FUNCTION_CALL", + "INITIAL_FUNCTION_CALL", + "FUNCTION_ARGUMENTS", + "NAMED_ARGUMENTS", + "QUALIFIED", + "RANGE2", + "RANGE3", + "STORED_DEFINITION", + "STRING_COMMENT", + "UNARY_MINUS", + "UNARY_PLUS", + "UNQUALIFIED", + "INTERACTIVE_STMT", + "INTERACTIVE_ALG", + "INTERACTIVE_EXP", + 0 +}; + +const unsigned long flat_modelica_tree_parser::_tokenSet_0_data_[] = { 1048592UL, 24576UL, 0UL, 0UL, 1536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "algorithm" "equation" "protected" "public" INITIAL_EQUATION INITIAL_ALGORITHM +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_tree_parser::_tokenSet_0(_tokenSet_0_data_,12); +const unsigned long flat_modelica_tree_parser::_tokenSet_1_data_[] = { 553910304UL, 5243168UL, 3216910848UL, 2130756096UL, 107151360UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "end" "false" "if" "not" "or" "true" "unsigned_real" LPAR LBRACK +// LBRACE PLUS MINUS STAR SLASH DOT LESS LESSEQ GREATER GREATEREQ EQEQ +// LESSGT COLON POWER IDENT UNSIGNED_INTEGER STRING CODE_EXPRESSION CODE_MODIFICATION +// CODE_ELEMENT CODE_EQUATION CODE_INITIALEQUATION CODE_ALGORITHM CODE_INITIALALGORITHM +// FUNCTION_CALL INITIAL_FUNCTION_CALL RANGE2 RANGE3 UNARY_MINUS UNARY_PLUS +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_tree_parser::_tokenSet_1(_tokenSet_1_data_,12); +const unsigned long flat_modelica_tree_parser::_tokenSet_2_data_[] = { 553910304UL, 5243168UL, 2680039936UL, 2130756096UL, 107151360UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "end" "false" "if" "not" "or" "true" "unsigned_real" LPAR LBRACK +// LBRACE PLUS MINUS STAR SLASH DOT LESS LESSEQ GREATER GREATEREQ EQEQ +// LESSGT POWER IDENT UNSIGNED_INTEGER STRING CODE_EXPRESSION CODE_MODIFICATION +// CODE_ELEMENT CODE_EQUATION CODE_INITIALEQUATION CODE_ALGORITHM CODE_INITIALALGORITHM +// FUNCTION_CALL INITIAL_FUNCTION_CALL RANGE2 RANGE3 UNARY_MINUS UNARY_PLUS +const ANTLR_USE_NAMESPACE(antlr)BitSet flat_modelica_tree_parser::_tokenSet_2(_tokenSet_2_data_,12); + + diff --git a/tools/xml/flatmodelicaxml/flat_modelica_tree_parser.hpp b/tools/xml/flatmodelicaxml/flat_modelica_tree_parser.hpp new file mode 100644 index 00000000000..1e6a976d951 --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_tree_parser.hpp @@ -0,0 +1,376 @@ +#ifndef INC_flat_modelica_tree_parser_hpp_ +#define INC_flat_modelica_tree_parser_hpp_ + +#line 2 "walker.g" + +// adrpo disabling warnings +#pragma warning( disable : 4267) // Disable warning messages C4267 +// disable: 'initializing' : conversion from 'size_t' to 'int', possible loss of data + +#pragma warning( disable : 4231) // Disable warning messages C4231 +// disable: nonstandard extension used : 'extern' before template explicit instantiation + +#pragma warning( disable : 4101) // Disable warning messages C4101 +// disable: warning C4101: 'pe' : unreferenced local variable + +#line 17 "flat_modelica_tree_parser.hpp" +#include +#include "flat_modelica_tree_parserTokenTypes.hpp" +/* $ANTLR 2.7.5rc2 (20050108): "walker.g" -> "flat_modelica_tree_parser.hpp"$ */ +#include + +#line 15 "walker.g" + +/************************************************************************ +File: walker.g +Created By: Adrian Pop adrpo@ida.liu.se +Date: 2004-05-26 +Revised on +Comments: we walk on the flat modelica tree, buil a XML DOM tree and serialize +************************************************************************/ + + #define null 0 + + extern "C" + { + #include + } + + #include + #include + #include + #include + +#ifndef __FLATMODELICAXML_H_ +#include "FlatModelicaXml.h" +#endif + +#include "MyAST.h" + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; + + +#line 54 "flat_modelica_tree_parser.hpp" +class CUSTOM_API flat_modelica_tree_parser : public ANTLR_USE_NAMESPACE(antlr)TreeParser, public flat_modelica_tree_parserTokenTypes +{ +#line 74 "walker.g" + + + /* some xml helpers declarations */ + DOMDocument* pFlatModelicaXMLDoc; + DOMElement* pRootElementModelica; + DOMElement* pRootElementFlatModelicaXML; + DOMImplementation* pDOMImpl; + char stmp[500]; + + + typedef std::stack l_stack; + typedef std::string mstring; + enum anno {UNSPECIFIED, INSIDE_EXTERNAL, INSIDE_ELEMENT, INSIDE_EQUATION, INSIDE_ALGORITHM, INSIDE_COMMENT}; + + const XMLCh* str2xml(RefMyAST node) + { + return XMLString::transcode(node->getText().c_str()); + } + + + DOMElement* stack2DOMNode(l_stack& s, mstring name) + { + // @HACK,@FIXME reverse the stack (better use a fifo) + DOMElement *pHoldingNode = pFlatModelicaXMLDoc->createElement(X(name.c_str())); + l_stack s_reverse; + //std::cout << "\nstack [" ; + while (!s.empty()) + { + DOMElement*z = s.top(); + //std::cout << XMLString::transcode((XMLCh*)(((DOMElement*)z)->getTagName())) << ", "; + s_reverse.push(z); + s.pop(); + } + //std::cout << "]" << std::endl; + //std::cout << "\n" << XMLString::transcode((XMLCh*)(((DOMElement*)pHoldingNode)->getTagName())) << "/kids [" ; + while (!s_reverse.empty()) + { + DOMElement*z = s_reverse.top(); + //std::cout << XMLString::transcode((XMLCh*)(((DOMElement*)z)->getTagName())) << ", "; + pHoldingNode->appendChild((DOMElement*)z); + s_reverse.pop(); + } + //std::cout << "]" << std::endl; + return pHoldingNode; + } + + + DOMElement* appendKids(l_stack& s, DOMElement* pParentNode) + { + // @HACK,@FIXME reverse the stack (better use a fifo) + l_stack s_reverse; + //std::cout << "\n" << XMLString::transcode((XMLCh*)(((DOMElement*)pParentNode)->getTagName())) << "/kids [" ; + while (!s.empty()) + { + DOMElement*z = s.top(); + //std::cout << XMLString::transcode((XMLCh*)(((DOMElement*)z)->getTagName())) << ","; + s_reverse.push(z); + s.pop(); + } + //std::cout << "]" << std::endl; + while (!s_reverse.empty()) + { + pParentNode->appendChild((DOMElement*)s_reverse.top()); + s_reverse.pop(); + } + return pParentNode; + } + + DOMElement* appendKidsFromStack(l_stack* s, DOMElement* pParentNode) + { + // @HACK,@FIXME reverse the stack (better use a fifo) + l_stack s_reverse; + //std::cout << "\n" << XMLString::transcode((XMLCh*)(((DOMElement*)pParentNode)->getTagName())) << "/kids [" ; + while (!s->empty()) + { + DOMElement*z = s->top(); + //std::cout << XMLString::transcode((XMLCh*)(((DOMElement*)z)->getTagName())) << ","; + s_reverse.push(z); + s->pop(); + } + //std::cout << "]" << std::endl; + while (!s_reverse.empty()) + { + pParentNode->appendChild((DOMElement*)s_reverse.top()); + s_reverse.pop(); + } + return pParentNode; + } + + void setAttributes(DOMElement *pNodeTo, DOMElement *pNodeFrom) + { + DOMNamedNodeMap *pAttributes = pNodeFrom->getAttributes(); + for (XMLSize_t i=0; i < pAttributes->getLength(); i++) + { + DOMAttr *z = (DOMAttr*)pAttributes->item(i); + pNodeTo->setAttribute(z->getName(), z->getValue()); + } + } + + struct type_prefix_t + { + type_prefix_t():flow(0), variability(0),direction(0){} + DOMElement* flow; + DOMElement* variability; + DOMElement* direction; + }; + + struct class_specifier_t + { + class_specifier_t():string_comment(0), composition(0), enumeration(0), derived(0), overload(0){} + DOMElement* string_comment; + DOMElement *composition; + DOMElement* derived; + DOMElement* enumeration; + DOMElement* overload; + }; + + DOMAttr* getAttributeNode(DOMElement* pNode, mstring stdstr) + { + return ((DOMElement*)pNode)->getAttributeNode(X(stdstr.c_str())); + } + + + void setVisibility(int iSwitch, DOMElement* pNode) + { + if (iSwitch == 1) pNode->setAttribute(X("visibility"), X("public")); + else if (iSwitch == 2) pNode->setAttribute(X("visibility"), X("protected")); + else { /* error, shouldn't happen */ } + } +#line 58 "flat_modelica_tree_parser.hpp" +public: + flat_modelica_tree_parser(); + static void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ); + int getNumTokens() const + { + return flat_modelica_tree_parser::NUM_TOKENS; + } + const char* getTokenName( int type ) const + { + if( type > getNumTokens() ) return 0; + return flat_modelica_tree_parser::tokenNames[type]; + } + const char* const* getTokenNames() const + { + return flat_modelica_tree_parser::tokenNames; + } + public: DOMElement * stored_definition(RefMyAST _t, + mstring xmlFilename, + mstring mofFilename, + mstring docType + ); + public: DOMElement* within_clause(RefMyAST _t, + DOMElement* parent + ); + public: DOMElement* class_definition(RefMyAST _t, + bool final, DOMElement *definitionElement + ); + public: void * name_path(RefMyAST _t); + public: void class_restriction(RefMyAST _t); + public: void class_specifier(RefMyAST _t, + class_specifier_t& sClassSpec + ); + public: DOMElement* string_comment(RefMyAST _t); + public: DOMElement* composition(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* derived_class(RefMyAST _t); + public: DOMElement* enumeration(RefMyAST _t); + public: DOMElement* overloading(RefMyAST _t); + public: void type_prefix(RefMyAST _t, + DOMElement* parent + ); + public: DOMElement* array_subscripts(RefMyAST _t, + int kind + ); + public: void * class_modification(RefMyAST _t); + public: DOMElement* comment(RefMyAST _t); + public: DOMElement* enumeration_literal(RefMyAST _t); + public: DOMElement* element_list(RefMyAST _t, + int iSwitch, DOMElement*definition + ); + public: DOMElement* public_element_list(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* protected_element_list(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* equation_clause(RefMyAST _t, + DOMElement *definition + ); + public: DOMElement* algorithm_clause(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* external_function_call(RefMyAST _t, + DOMElement *pExternalFunctionCall + ); + public: DOMElement* annotation(RefMyAST _t, + int iSwitch, DOMElement *parent, enum anno awhere + ); + public: DOMElement* expression_list(RefMyAST _t); + public: DOMElement* component_reference(RefMyAST _t); + public: DOMElement* element(RefMyAST _t, + int iSwitch, DOMElement *parent + ); + public: DOMElement* import_clause(RefMyAST _t, + int iSwitch, DOMElement *parent + ); + public: DOMElement* extends_clause(RefMyAST _t, + int iSwitch, DOMElement* parent + ); + public: DOMElement* component_clause(RefMyAST _t, + DOMElement* parent, DOMElement* attributes + ); + public: DOMElement* constraining_clause(RefMyAST _t); + public: DOMElement* explicit_import_name(RefMyAST _t); + public: DOMElement* implicit_import_name(RefMyAST _t); + public: void* type_specifier(RefMyAST _t); + public: DOMElement* component_list(RefMyAST _t, + DOMElement* parent, DOMElement *attributes, DOMElement* type_array + ); + public: DOMElement* component_declaration(RefMyAST _t, + DOMElement* parent, DOMElement *attributes, DOMElement *type_array + ); + public: DOMElement* declaration(RefMyAST _t, + DOMElement* parent, DOMElement* type_array + ); + public: DOMElement* modification(RefMyAST _t); + public: DOMElement* expression(RefMyAST _t); + public: void * argument_list(RefMyAST _t); + public: DOMElement* argument(RefMyAST _t); + public: DOMElement* element_modification(RefMyAST _t); + public: DOMElement* element_redeclaration(RefMyAST _t); + public: DOMElement* component_clause1(RefMyAST _t, + DOMElement *parent + ); + public: DOMElement* equation(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* algorithm(RefMyAST _t, + DOMElement *definition + ); + public: DOMElement* equality_equation(RefMyAST _t); + public: DOMElement* conditional_equation_e(RefMyAST _t); + public: DOMElement* for_clause_e(RefMyAST _t); + public: DOMElement* when_clause_e(RefMyAST _t); + public: DOMElement* connect_clause(RefMyAST _t); + public: DOMElement* equation_funcall(RefMyAST _t); + public: DOMElement* function_call(RefMyAST _t); + public: DOMElement* tuple_expression_list(RefMyAST _t); + public: DOMElement* algorithm_function_call(RefMyAST _t); + public: DOMElement* conditional_equation_a(RefMyAST _t); + public: DOMElement* for_clause_a(RefMyAST _t); + public: DOMElement* while_clause(RefMyAST _t); + public: DOMElement* when_clause_a(RefMyAST _t); + public: DOMElement* simple_expression(RefMyAST _t); + public: DOMElement* equation_list(RefMyAST _t, + DOMElement* pEquationList + ); + public: DOMElement* equation_elseif(RefMyAST _t); + public: DOMElement* algorithm_list(RefMyAST _t, + DOMElement* pAlgorithmList + ); + public: DOMElement* algorithm_elseif(RefMyAST _t); + public: DOMElement* for_indices(RefMyAST _t); + public: DOMElement* else_when_e(RefMyAST _t); + public: DOMElement* else_when_a(RefMyAST _t); + public: DOMElement* if_expression(RefMyAST _t); + public: DOMElement* code_expression(RefMyAST _t); + public: DOMElement* elseif_expression(RefMyAST _t); + public: DOMElement* logical_expression(RefMyAST _t); + public: DOMElement* logical_term(RefMyAST _t); + public: DOMElement* logical_factor(RefMyAST _t); + public: DOMElement* relation(RefMyAST _t); + public: DOMElement* arithmetic_expression(RefMyAST _t); + public: DOMElement* unary_arithmetic_expression(RefMyAST _t); + public: DOMElement* term(RefMyAST _t); + public: DOMElement* factor(RefMyAST _t); + public: DOMElement* primary(RefMyAST _t); + public: DOMElement* component_reference__function_call(RefMyAST _t); + public: DOMElement* function_arguments(RefMyAST _t); + public: DOMElement* expression_list2(RefMyAST _t, + DOMElement *parent + ); + public: DOMElement* named_arguments(RefMyAST _t, + DOMElement *parent + ); + public: DOMElement* named_argument(RefMyAST _t); + public: DOMElement* subscript(RefMyAST _t, + DOMElement* parent + ); + public: DOMElement* string_concatenation(RefMyAST _t); + public: DOMElement* interactive_stmt(RefMyAST _t); +public: + ANTLR_USE_NAMESPACE(antlr)RefAST getAST() + { + return ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST); + } + +protected: + RefMyAST returnAST; + RefMyAST _retTree; +private: + static const char* tokenNames[]; +#ifndef NO_STATIC_CONSTS + static const int NUM_TOKENS = 159; +#else + enum { + NUM_TOKENS = 159 + }; +#endif + + static const unsigned long _tokenSet_0_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0; + static const unsigned long _tokenSet_1_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1; + static const unsigned long _tokenSet_2_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2; +}; + +#endif /*INC_flat_modelica_tree_parser_hpp_*/ diff --git a/tools/xml/flatmodelicaxml/flat_modelica_tree_parserTokenTypes.hpp b/tools/xml/flatmodelicaxml/flat_modelica_tree_parserTokenTypes.hpp new file mode 100644 index 00000000000..08939fc70ba --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_tree_parserTokenTypes.hpp @@ -0,0 +1,175 @@ +#ifndef INC_flat_modelica_tree_parserTokenTypes_hpp_ +#define INC_flat_modelica_tree_parserTokenTypes_hpp_ + +/* $ANTLR 2.7.5rc2 (20050108): "walker.g" -> "flat_modelica_tree_parserTokenTypes.hpp"$ */ + +#ifndef CUSTOM_API +# define CUSTOM_API +#endif + +#ifdef __cplusplus +struct CUSTOM_API flat_modelica_tree_parserTokenTypes { +#endif + enum { + EOF_ = 1, + ALGORITHM = 4, + AND = 5, + ANNOTATION = 6, + BLOCK = 7, + CODE = 8, + CLASS = 9, + CONNECT = 10, + CONNECTOR = 11, + CONSTANT = 12, + DISCRETE = 13, + EACH = 14, + ELSE = 15, + ELSEIF = 16, + ELSEWHEN = 17, + END = 18, + ENUMERATION = 19, + EQUATION = 20, + ENCAPSULATED = 21, + EXTENDS = 22, + EXTERNAL = 23, + FALSE = 24, + FINAL = 25, + FLOW = 26, + FOR = 27, + FUNCTION = 28, + IF = 29, + IMPORT = 30, + IN = 31, + INITIAL = 32, + INNER = 33, + INPUT = 34, + LOOP = 35, + MODEL = 36, + NOT = 37, + OUTER = 38, + OVERLOAD = 39, + OR = 40, + OUTPUT = 41, + PACKAGE = 42, + PARAMETER = 43, + PARTIAL = 44, + PROTECTED = 45, + PUBLIC = 46, + RECORD = 47, + REDECLARE = 48, + REPLACEABLE = 49, + RESULTS = 50, + THEN = 51, + TRUE = 52, + TYPE = 53, + UNSIGNED_REAL = 54, + WHEN = 55, + WHILE = 56, + WITHIN = 57, + ABSTYPE = 58, + AS = 59, + AXIOM = 60, + DATATYPE = 61, + FAIL = 62, + LET = 63, + INTERFACE = 64, + MODULE = 65, + OF = 66, + RELATION = 67, + RULE = 68, + VAL = 69, + WILD = 70, + WITH = 71, + WITHTYPE = 72, + LPAR = 73, + RPAR = 74, + LBRACK = 75, + RBRACK = 76, + LBRACE = 77, + RBRACE = 78, + EQUALS = 79, + ASSIGN = 80, + PLUS = 81, + MINUS = 82, + STAR = 83, + SLASH = 84, + DOT = 85, + COMMA = 86, + LESS = 87, + LESSEQ = 88, + GREATER = 89, + GREATEREQ = 90, + EQEQ = 91, + LESSGT = 92, + COLON = 93, + SEMICOLON = 94, + POWER = 95, + YIELDS = 96, + AMPERSAND = 97, + PIPEBAR = 98, + COLONCOLON = 99, + DASHES = 100, + WS = 101, + ML_COMMENT = 102, + ML_COMMENT_CHAR = 103, + SL_COMMENT = 104, + IDENT = 105, + TYVARIDENT = 106, + NONDIGIT = 107, + DIGIT = 108, + EXPONENT = 109, + UNSIGNED_INTEGER = 110, + STRING = 111, + SCHAR = 112, + SESCAPE = 113, + ESC = 114, + ALGORITHM_STATEMENT = 115, + ARGUMENT_LIST = 116, + BEGIN_DEFINITION = 117, + CLASS_DEFINITION = 118, + CLASS_MODIFICATION = 119, + CODE_EXPRESSION = 120, + CODE_MODIFICATION = 121, + CODE_ELEMENT = 122, + CODE_EQUATION = 123, + CODE_INITIALEQUATION = 124, + CODE_ALGORITHM = 125, + CODE_INITIALALGORITHM = 126, + COMMENT = 127, + COMPONENT_DEFINITION = 128, + DECLARATION = 129, + DEFINITION = 130, + END_DEFINITION = 131, + ENUMERATION_LITERAL = 132, + ELEMENT = 133, + ELEMENT_MODIFICATION = 134, + ELEMENT_REDECLARATION = 135, + EQUATION_STATEMENT = 136, + INITIAL_EQUATION = 137, + INITIAL_ALGORITHM = 138, + IMPORT_DEFINITION = 139, + EXPRESSION_LIST = 140, + EXTERNAL_FUNCTION_CALL = 141, + FOR_INDICES = 142, + FOR_ITERATOR = 143, + FUNCTION_CALL = 144, + INITIAL_FUNCTION_CALL = 145, + FUNCTION_ARGUMENTS = 146, + NAMED_ARGUMENTS = 147, + QUALIFIED = 148, + RANGE2 = 149, + RANGE3 = 150, + STORED_DEFINITION = 151, + STRING_COMMENT = 152, + UNARY_MINUS = 153, + UNARY_PLUS = 154, + UNQUALIFIED = 155, + INTERACTIVE_STMT = 156, + INTERACTIVE_ALG = 157, + INTERACTIVE_EXP = 158, + NULL_TREE_LOOKAHEAD = 3 + }; +#ifdef __cplusplus +}; +#endif +#endif /*INC_flat_modelica_tree_parserTokenTypes_hpp_*/ diff --git a/tools/xml/flatmodelicaxml/flat_modelica_tree_parserTokenTypes.txt b/tools/xml/flatmodelicaxml/flat_modelica_tree_parserTokenTypes.txt new file mode 100644 index 00000000000..c69982d3c40 --- /dev/null +++ b/tools/xml/flatmodelicaxml/flat_modelica_tree_parserTokenTypes.txt @@ -0,0 +1,157 @@ +// $ANTLR 2.7.5rc2 (20050108): walker.g -> flat_modelica_tree_parserTokenTypes.txt$ +flat_modelica_tree_parser // output token vocab name +ALGORITHM="algorithm"=4 +AND="and"=5 +ANNOTATION="annotation"=6 +BLOCK="block"=7 +CODE="Code"=8 +CLASS="class"=9 +CONNECT="connect"=10 +CONNECTOR="connector"=11 +CONSTANT="constant"=12 +DISCRETE="discrete"=13 +EACH="each"=14 +ELSE="else"=15 +ELSEIF="elseif"=16 +ELSEWHEN="elsewhen"=17 +END="end"=18 +ENUMERATION="enumeration"=19 +EQUATION="equation"=20 +ENCAPSULATED="encapsulated"=21 +EXTENDS="extends"=22 +EXTERNAL="external"=23 +FALSE="false"=24 +FINAL="final"=25 +FLOW="flow"=26 +FOR="for"=27 +FUNCTION="function"=28 +IF="if"=29 +IMPORT="import"=30 +IN="in"=31 +INITIAL="initial"=32 +INNER="inner"=33 +INPUT="input"=34 +LOOP="loop"=35 +MODEL="model"=36 +NOT="not"=37 +OUTER="outer"=38 +OVERLOAD="overload"=39 +OR="or"=40 +OUTPUT="output"=41 +PACKAGE="package"=42 +PARAMETER="parameter"=43 +PARTIAL="partial"=44 +PROTECTED="protected"=45 +PUBLIC="public"=46 +RECORD="record"=47 +REDECLARE="redeclare"=48 +REPLACEABLE="replaceable"=49 +RESULTS="results"=50 +THEN="then"=51 +TRUE="true"=52 +TYPE="type"=53 +UNSIGNED_REAL="unsigned_real"=54 +WHEN="when"=55 +WHILE="while"=56 +WITHIN="within"=57 +ABSTYPE="abstype"=58 +AS="as"=59 +AXIOM="axiom"=60 +DATATYPE="datatype"=61 +FAIL="fail"=62 +LET="let"=63 +INTERFACE="interface"=64 +MODULE="module"=65 +OF="of"=66 +RELATION="relation"=67 +RULE="rule"=68 +VAL="val"=69 +WILD="_"=70 +WITH="with"=71 +WITHTYPE="withtype"=72 +LPAR=73 +RPAR=74 +LBRACK=75 +RBRACK=76 +LBRACE=77 +RBRACE=78 +EQUALS=79 +ASSIGN=80 +PLUS=81 +MINUS=82 +STAR=83 +SLASH=84 +DOT=85 +COMMA=86 +LESS=87 +LESSEQ=88 +GREATER=89 +GREATEREQ=90 +EQEQ=91 +LESSGT=92 +COLON=93 +SEMICOLON=94 +POWER=95 +YIELDS=96 +AMPERSAND=97 +PIPEBAR=98 +COLONCOLON=99 +DASHES=100 +WS=101 +ML_COMMENT=102 +ML_COMMENT_CHAR=103 +SL_COMMENT=104 +IDENT("an identifier")=105 +TYVARIDENT("a type identifier")=106 +NONDIGIT=107 +DIGIT=108 +EXPONENT=109 +UNSIGNED_INTEGER=110 +STRING=111 +SCHAR=112 +SESCAPE=113 +ESC=114 +ALGORITHM_STATEMENT=115 +ARGUMENT_LIST=116 +BEGIN_DEFINITION=117 +CLASS_DEFINITION=118 +CLASS_MODIFICATION=119 +CODE_EXPRESSION=120 +CODE_MODIFICATION=121 +CODE_ELEMENT=122 +CODE_EQUATION=123 +CODE_INITIALEQUATION=124 +CODE_ALGORITHM=125 +CODE_INITIALALGORITHM=126 +COMMENT=127 +COMPONENT_DEFINITION=128 +DECLARATION=129 +DEFINITION=130 +END_DEFINITION=131 +ENUMERATION_LITERAL=132 +ELEMENT=133 +ELEMENT_MODIFICATION=134 +ELEMENT_REDECLARATION=135 +EQUATION_STATEMENT=136 +INITIAL_EQUATION=137 +INITIAL_ALGORITHM=138 +IMPORT_DEFINITION=139 +EXPRESSION_LIST=140 +EXTERNAL_FUNCTION_CALL=141 +FOR_INDICES=142 +FOR_ITERATOR=143 +FUNCTION_CALL=144 +INITIAL_FUNCTION_CALL=145 +FUNCTION_ARGUMENTS=146 +NAMED_ARGUMENTS=147 +QUALIFIED=148 +RANGE2=149 +RANGE3=150 +STORED_DEFINITION=151 +STRING_COMMENT=152 +UNARY_MINUS=153 +UNARY_PLUS=154 +UNQUALIFIED=155 +INTERACTIVE_STMT=156 +INTERACTIVE_ALG=157 +INTERACTIVE_EXP=158 diff --git a/tools/xml/flatmodelicaxml/flatmodelicaTokenTypes.hpp b/tools/xml/flatmodelicaxml/flatmodelicaTokenTypes.hpp new file mode 100644 index 00000000000..38e177820d6 --- /dev/null +++ b/tools/xml/flatmodelicaxml/flatmodelicaTokenTypes.hpp @@ -0,0 +1,131 @@ +#ifndef INC_flatmodelicaTokenTypes_hpp_ +#define INC_flatmodelicaTokenTypes_hpp_ + +/* $ANTLR 2.7.5rc2 (20050108): "flat_modelica_lexer.g" -> "flatmodelicaTokenTypes.hpp"$ */ + +#ifndef CUSTOM_API +# define CUSTOM_API +#endif + +#ifdef __cplusplus +struct CUSTOM_API flatmodelicaTokenTypes { +#endif + enum { + EOF_ = 1, + ALGORITHM = 4, + AND = 5, + ANNOTATION = 6, + BLOCK = 7, + CODE = 8, + CLASS = 9, + CONNECT = 10, + CONNECTOR = 11, + CONSTANT = 12, + DISCRETE = 13, + EACH = 14, + ELSE = 15, + ELSEIF = 16, + ELSEWHEN = 17, + END = 18, + ENUMERATION = 19, + EQUATION = 20, + ENCAPSULATED = 21, + EXTENDS = 22, + EXTERNAL = 23, + FALSE = 24, + FINAL = 25, + FLOW = 26, + FOR = 27, + FUNCTION = 28, + IF = 29, + IMPORT = 30, + IN = 31, + INITIAL = 32, + INNER = 33, + INPUT = 34, + LOOP = 35, + MODEL = 36, + NOT = 37, + OUTER = 38, + OVERLOAD = 39, + OR = 40, + OUTPUT = 41, + PACKAGE = 42, + PARAMETER = 43, + PARTIAL = 44, + PROTECTED = 45, + PUBLIC = 46, + RECORD = 47, + REDECLARE = 48, + REPLACEABLE = 49, + RESULTS = 50, + THEN = 51, + TRUE = 52, + TYPE = 53, + UNSIGNED_REAL = 54, + WHEN = 55, + WHILE = 56, + WITHIN = 57, + ABSTYPE = 58, + AS = 59, + AXIOM = 60, + DATATYPE = 61, + FAIL = 62, + LET = 63, + INTERFACE = 64, + MODULE = 65, + OF = 66, + RELATION = 67, + RULE = 68, + VAL = 69, + WILD = 70, + WITH = 71, + WITHTYPE = 72, + LPAR = 73, + RPAR = 74, + LBRACK = 75, + RBRACK = 76, + LBRACE = 77, + RBRACE = 78, + EQUALS = 79, + ASSIGN = 80, + PLUS = 81, + MINUS = 82, + STAR = 83, + SLASH = 84, + DOT = 85, + COMMA = 86, + LESS = 87, + LESSEQ = 88, + GREATER = 89, + GREATEREQ = 90, + EQEQ = 91, + LESSGT = 92, + COLON = 93, + SEMICOLON = 94, + POWER = 95, + YIELDS = 96, + AMPERSAND = 97, + PIPEBAR = 98, + COLONCOLON = 99, + DASHES = 100, + WS = 101, + ML_COMMENT = 102, + ML_COMMENT_CHAR = 103, + SL_COMMENT = 104, + IDENT = 105, + TYVARIDENT = 106, + NONDIGIT = 107, + DIGIT = 108, + EXPONENT = 109, + UNSIGNED_INTEGER = 110, + STRING = 111, + SCHAR = 112, + SESCAPE = 113, + ESC = 114, + NULL_TREE_LOOKAHEAD = 3 + }; +#ifdef __cplusplus +}; +#endif +#endif /*INC_flatmodelicaTokenTypes_hpp_*/ diff --git a/tools/xml/flatmodelicaxml/flatmodelicaTokenTypes.txt b/tools/xml/flatmodelicaxml/flatmodelicaTokenTypes.txt new file mode 100644 index 00000000000..f462d04d3f3 --- /dev/null +++ b/tools/xml/flatmodelicaxml/flatmodelicaTokenTypes.txt @@ -0,0 +1,113 @@ +// $ANTLR 2.7.5rc2 (20050108): flat_modelica_lexer.g -> flatmodelicaTokenTypes.txt$ +flatmodelica // output token vocab name +ALGORITHM="algorithm"=4 +AND="and"=5 +ANNOTATION="annotation"=6 +BLOCK="block"=7 +CODE="Code"=8 +CLASS="class"=9 +CONNECT="connect"=10 +CONNECTOR="connector"=11 +CONSTANT="constant"=12 +DISCRETE="discrete"=13 +EACH="each"=14 +ELSE="else"=15 +ELSEIF="elseif"=16 +ELSEWHEN="elsewhen"=17 +END="end"=18 +ENUMERATION="enumeration"=19 +EQUATION="equation"=20 +ENCAPSULATED="encapsulated"=21 +EXTENDS="extends"=22 +EXTERNAL="external"=23 +FALSE="false"=24 +FINAL="final"=25 +FLOW="flow"=26 +FOR="for"=27 +FUNCTION="function"=28 +IF="if"=29 +IMPORT="import"=30 +IN="in"=31 +INITIAL="initial"=32 +INNER="inner"=33 +INPUT="input"=34 +LOOP="loop"=35 +MODEL="model"=36 +NOT="not"=37 +OUTER="outer"=38 +OVERLOAD="overload"=39 +OR="or"=40 +OUTPUT="output"=41 +PACKAGE="package"=42 +PARAMETER="parameter"=43 +PARTIAL="partial"=44 +PROTECTED="protected"=45 +PUBLIC="public"=46 +RECORD="record"=47 +REDECLARE="redeclare"=48 +REPLACEABLE="replaceable"=49 +RESULTS="results"=50 +THEN="then"=51 +TRUE="true"=52 +TYPE="type"=53 +UNSIGNED_REAL="unsigned_real"=54 +WHEN="when"=55 +WHILE="while"=56 +WITHIN="within"=57 +ABSTYPE="abstype"=58 +AS="as"=59 +AXIOM="axiom"=60 +DATATYPE="datatype"=61 +FAIL="fail"=62 +LET="let"=63 +INTERFACE="interface"=64 +MODULE="module"=65 +OF="of"=66 +RELATION="relation"=67 +RULE="rule"=68 +VAL="val"=69 +WILD="_"=70 +WITH="with"=71 +WITHTYPE="withtype"=72 +LPAR=73 +RPAR=74 +LBRACK=75 +RBRACK=76 +LBRACE=77 +RBRACE=78 +EQUALS=79 +ASSIGN=80 +PLUS=81 +MINUS=82 +STAR=83 +SLASH=84 +DOT=85 +COMMA=86 +LESS=87 +LESSEQ=88 +GREATER=89 +GREATEREQ=90 +EQEQ=91 +LESSGT=92 +COLON=93 +SEMICOLON=94 +POWER=95 +YIELDS=96 +AMPERSAND=97 +PIPEBAR=98 +COLONCOLON=99 +DASHES=100 +WS=101 +ML_COMMENT=102 +ML_COMMENT_CHAR=103 +SL_COMMENT=104 +IDENT("an identifier")=105 +TYVARIDENT("a type identifier")=106 +NONDIGIT=107 +DIGIT=108 +EXPONENT=109 +UNSIGNED_INTEGER=110 +STRING=111 +SCHAR=112 +SESCAPE=113 +ESC=114 diff --git a/tools/xml/flatmodelicaxml/parse_tree_dumper.cpp b/tools/xml/flatmodelicaxml/parse_tree_dumper.cpp new file mode 100644 index 00000000000..a524f15c8f9 --- /dev/null +++ b/tools/xml/flatmodelicaxml/parse_tree_dumper.cpp @@ -0,0 +1,10 @@ + +#include "parse_tree_dumper.hpp" + + + +char parse_tree_dumper::c1 = '|'; +char parse_tree_dumper::c2 = ' '; +char parse_tree_dumper::c; +char parse_tree_dumper::prefix[] = "+-"; +int parse_tree_dumper::indentSize = 2; diff --git a/tools/xml/flatmodelicaxml/parse_tree_dumper.hpp b/tools/xml/flatmodelicaxml/parse_tree_dumper.hpp new file mode 100644 index 00000000000..aa8c13fff92 --- /dev/null +++ b/tools/xml/flatmodelicaxml/parse_tree_dumper.hpp @@ -0,0 +1,114 @@ +#ifndef PARSE_TREE_DUMPER_H_ +#define PARSE_TREE_DUMPER_H_ + + +#ifndef COMMONAST_HPP_ +#define COMMONAST_HPP_ +#include "antlr/CommonAST.hpp" +#endif + +#include + + +class parse_tree_dumper +{ +private: + int fIndent; + static char c1; + static char c2; + + static char c; + static char prefix[]; + + static int indentSize; + + std::ostream &out; + +public: + parse_tree_dumper(std::ostream& os) : out(os){ + fIndent = 0; + } + + void flush() + { + out.flush(); + } + + void toIndent() + { + if (fIndent <= 0) + return; + for (int i=0; i"; + } + else + { + out << ast->toString(); + if (ast->getFirstChild() != 0) + { + out << " {" << std::endl; + indent(indentSize); + dump(ast->getFirstChild()); + indent(-indentSize); + toIndent(); + out << "}" << std::endl; + } + else + { + out << std::endl; + } + if (ast->getNextSibling() != 0) + { + dump(ast->getNextSibling()); + } + } + } + void dump_dot(antlr::RefAST ast) + { + out << "digraph G {\n"; + dump_dot_recursive(ast); + out << "}\n"; + } + + void dump_dot_recursive(antlr::RefAST ast) + { + if (ast == 0) + { + out << "\n"; + } + else + { + out << "\"" << ast.get() << "\" [label=\"" << ast->toString() << "\" shape=\"box\"];\n"; + antlr::RefAST current_ast = ast->getFirstChild(); + + while (current_ast != 0) + { + dump_dot_recursive(current_ast); + out << "\t\"" << ast.get() << "\" -> \"" << current_ast.get() << "\";\n"; + + current_ast = current_ast->getNextSibling(); + } + } + } + +}; + + +#endif diff --git a/tools/xml/flatmodelicaxml/test.cpp b/tools/xml/flatmodelicaxml/test.cpp new file mode 100644 index 00000000000..7c6e772790e --- /dev/null +++ b/tools/xml/flatmodelicaxml/test.cpp @@ -0,0 +1,115 @@ +#include +#include +#include + +#include "flat_modelica_parser.hpp" +#include "flat_modelica_lexer.hpp" +#include "parse_tree_dumper.hpp" +#include "antlr/ANTLRException.hpp" +#include "antlr/CharStreamException.hpp" +#include "antlr/TokenStreamException.hpp" +#include "antlr/RecognitionException.hpp" +#include "antlr/NoViableAltException.hpp" +#include "antlr/MismatchedTokenException.hpp" +#include "antlr/TokenStreamRecognitionException.hpp" +#include "antlr/ASTFactory.hpp" +#include "MyAST.h" + +using namespace std; + +int main(int argc, char **argv) { + char* filename = argv[1]; + string filestring(filename); + bool debug = false; + bool parsedump = true; + /* 2004-10-05 adrpo moved this declaration here to + * have the ast initialized before getting + * into the code. This way, if this relation fails at least the + * ast is initialized */ + void* ast= null; + + //For parsing flat modelica (mof) files, if such is given + bool parseFlatModelica=false; + if (filestring.size()-4 == filestring.rfind(".mof")){ + parseFlatModelica=true; + } + + std::ifstream stream(filename); + if (!stream) { + cerr << "File \"" << filename << "\" not found." << endl; + exit(1); + } + //bool debug = true; + flat_modelica_lexer *flat_lex=0; + flat_modelica_parser *flat_parse=0; + ANTLR_USE_NAMESPACE(antlr)ASTFactory my_factory( "MyAST", MyAST::factory ); + flat_lex = new flat_modelica_lexer(stream); + flat_lex->setFilename(filename); + + if (!stream) + { + std::cerr << "Error opening file" << std::endl; + } + RefMyAST t; + if (parseFlatModelica){ + //We are parsing flat modelica and not modelica + flat_parse = new flat_modelica_parser(*flat_lex); + flat_parse->setFilename(filename); + + // make factory with customized type of MyAST + flat_parse->initializeASTFactory(my_factory); + flat_parse->setASTFactory( &my_factory ); + + try{ + cout << "Parsing flat modelica" << endl; + flat_parse->stored_definition(); + cout << "done" << endl; + t = RefMyAST(flat_parse->getAST()); + } + catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException &e) + { + std::cerr << "Lexical error. CharStreamException. " << std::endl; + } + catch (ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException &e) + { + std::cerr << "Parsing error. TokenStreamRecognitionException on line " + << flat_lex->getLine() << "near :"<< flat_lex->getText() << std::endl; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException &e) + { + std::cerr << "[" << filestring << ":" << e.getLine() << ":" << e.getColumn() + << "]: error: " << e.getMessage() << std::endl; + } + catch (ANTLR_USE_NAMESPACE(antlr)TokenStreamException &e) + { + std::cerr << "[" << filestring << ":" << flat_lex->getLine() << ":" << flat_lex->getColumn() + << "]: error: illegal token" << std::endl; + } + catch (ANTLR_USE_NAMESPACE(antlr)ANTLRException &e) + { + std::cerr << "ANTLRException: " << e.getMessage() << std::endl; + } + catch (std::exception &e) + { + std::cerr << "Error while parsing:\n" << e.what() << "\n"; + } + catch (...) + { + std::cerr << "Error while parsing\n"; + } + + } + + if (parsedump) + { + parse_tree_dumper dumper(std::cout); + //dumper.initializeASTFactory(factory); + //dumper.setASTFactory(&factory); + dumper.dump(t); + } + + + if (flat_parse) delete flat_parse; + if (flat_lex) delete flat_lex; + +} diff --git a/tools/xml/flatmodelicaxml/walker.g b/tools/xml/flatmodelicaxml/walker.g new file mode 100644 index 00000000000..27a8e6b4f1f --- /dev/null +++ b/tools/xml/flatmodelicaxml/walker.g @@ -0,0 +1,2657 @@ +header "pre_include_hpp" +{ +// adrpo disabling warnings +#pragma warning( disable : 4267) // Disable warning messages C4267 +// disable: 'initializing' : conversion from 'size_t' to 'int', possible loss of data + +#pragma warning( disable : 4231) // Disable warning messages C4231 +// disable: nonstandard extension used : 'extern' before template explicit instantiation + +#pragma warning( disable : 4101) // Disable warning messages C4101 +// disable: warning C4101: 'pe' : unreferenced local variable +} + +header "post_include_hpp" +{ +/************************************************************************ +File: walker.g +Created By: Adrian Pop adrpo@ida.liu.se +Date: 2004-05-26 +Revised on +Comments: we walk on the flat modelica tree, buil a XML DOM tree and serialize +************************************************************************/ + + #define null 0 + + extern "C" + { + #include + } + + #include + #include + #include + #include + +#ifndef __FLATMODELICAXML_H_ +#include "FlatModelicaXml.h" +#endif + +#include "MyAST.h" + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; + +} + +header "post_include_cpp" +{ +} + + +options +{ + language = "Cpp"; +} + + +class flat_modelica_tree_parser extends TreeParser; + +options +{ + importVocab = flat_modelica_parser; + k = 2; + buildAST = true; + defaultErrorHandler = false; + ASTLabelType = "RefMyAST"; +} + +tokens +{ + INTERACTIVE_STMT; + INTERACTIVE_ALG; + INTERACTIVE_EXP; +} +{ + + /* some xml helpers declarations */ + DOMDocument* pFlatModelicaXMLDoc; + DOMElement* pRootElementModelica; + DOMElement* pRootElementFlatModelicaXML; + DOMImplementation* pDOMImpl; + char stmp[500]; + + + typedef std::stack l_stack; + typedef std::string mstring; + enum anno {UNSPECIFIED, INSIDE_EXTERNAL, INSIDE_ELEMENT, INSIDE_EQUATION, INSIDE_ALGORITHM, INSIDE_COMMENT}; + + const XMLCh* str2xml(RefMyAST node) + { + return XMLString::transcode(node->getText().c_str()); + } + + + DOMElement* stack2DOMNode(l_stack& s, mstring name) + { + // @HACK,@FIXME reverse the stack (better use a fifo) + DOMElement *pHoldingNode = pFlatModelicaXMLDoc->createElement(X(name.c_str())); + l_stack s_reverse; + //std::cout << "\nstack [" ; + while (!s.empty()) + { + DOMElement*z = s.top(); + //std::cout << XMLString::transcode((XMLCh*)(((DOMElement*)z)->getTagName())) << ", "; + s_reverse.push(z); + s.pop(); + } + //std::cout << "]" << std::endl; + //std::cout << "\n" << XMLString::transcode((XMLCh*)(((DOMElement*)pHoldingNode)->getTagName())) << "/kids [" ; + while (!s_reverse.empty()) + { + DOMElement*z = s_reverse.top(); + //std::cout << XMLString::transcode((XMLCh*)(((DOMElement*)z)->getTagName())) << ", "; + pHoldingNode->appendChild((DOMElement*)z); + s_reverse.pop(); + } + //std::cout << "]" << std::endl; + return pHoldingNode; + } + + + DOMElement* appendKids(l_stack& s, DOMElement* pParentNode) + { + // @HACK,@FIXME reverse the stack (better use a fifo) + l_stack s_reverse; + //std::cout << "\n" << XMLString::transcode((XMLCh*)(((DOMElement*)pParentNode)->getTagName())) << "/kids [" ; + while (!s.empty()) + { + DOMElement*z = s.top(); + //std::cout << XMLString::transcode((XMLCh*)(((DOMElement*)z)->getTagName())) << ","; + s_reverse.push(z); + s.pop(); + } + //std::cout << "]" << std::endl; + while (!s_reverse.empty()) + { + pParentNode->appendChild((DOMElement*)s_reverse.top()); + s_reverse.pop(); + } + return pParentNode; + } + + DOMElement* appendKidsFromStack(l_stack* s, DOMElement* pParentNode) + { + // @HACK,@FIXME reverse the stack (better use a fifo) + l_stack s_reverse; + //std::cout << "\n" << XMLString::transcode((XMLCh*)(((DOMElement*)pParentNode)->getTagName())) << "/kids [" ; + while (!s->empty()) + { + DOMElement*z = s->top(); + //std::cout << XMLString::transcode((XMLCh*)(((DOMElement*)z)->getTagName())) << ","; + s_reverse.push(z); + s->pop(); + } + //std::cout << "]" << std::endl; + while (!s_reverse.empty()) + { + pParentNode->appendChild((DOMElement*)s_reverse.top()); + s_reverse.pop(); + } + return pParentNode; + } + + void setAttributes(DOMElement *pNodeTo, DOMElement *pNodeFrom) + { + DOMNamedNodeMap *pAttributes = pNodeFrom->getAttributes(); + for (XMLSize_t i=0; i < pAttributes->getLength(); i++) + { + DOMAttr *z = (DOMAttr*)pAttributes->item(i); + pNodeTo->setAttribute(z->getName(), z->getValue()); + } + } + + struct type_prefix_t + { + type_prefix_t():flow(0), variability(0),direction(0){} + DOMElement* flow; + DOMElement* variability; + DOMElement* direction; + }; + + struct class_specifier_t + { + class_specifier_t():string_comment(0), composition(0), enumeration(0), derived(0), overload(0){} + DOMElement* string_comment; + DOMElement *composition; + DOMElement* derived; + DOMElement* enumeration; + DOMElement* overload; + }; + + DOMAttr* getAttributeNode(DOMElement* pNode, mstring stdstr) + { + return ((DOMElement*)pNode)->getAttributeNode(X(stdstr.c_str())); + } + + + void setVisibility(int iSwitch, DOMElement* pNode) + { + if (iSwitch == 1) pNode->setAttribute(X("visibility"), X("public")); + else if (iSwitch == 2) pNode->setAttribute(X("visibility"), X("protected")); + else { /* error, shouldn't happen */ } + } +} + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##modelicaxml +*/ +stored_definition + [mstring xmlFilename, + mstring mofFilename, + mstring docType] returns [DOMElement *ast] +{ + DOMElement *within = 0; + //DOMElement*class_def = 0; + l_stack el_stack; + + // initialize xml framework + XMLPlatformUtils::Initialize(); + + // XML DOM creation + DOMImplementation* pDOMImpl = DOMImplementationRegistry::getDOMImplementation(X("Core")); + + + // create the document type (according to flatmodelica.dtd) + DOMDocumentType* pDoctype = pDOMImpl->createDocumentType( + X("modelica"), + NULL, + X(docType.c_str())); + + // create the root element + pFlatModelicaXMLDoc = pDOMImpl->createDocument( + 0, // root element namespace URI. + X("modelica"), // root element name + pDoctype); // document type object (DTD). + + pRootElementModelica = pFlatModelicaXMLDoc->getDocumentElement(); + pRootElementFlatModelicaXML = pFlatModelicaXMLDoc->createElement(X("modelicaxml")); + // set the location of the .mo file we're representing in XML + pRootElementFlatModelicaXML->setAttribute(X("file"), X(mofFilename.c_str())); + + DOMElement* pDefinitionElement = 0; +} + : + #(STORED_DEFINITION + ( pRootElementFlatModelicaXML = within_clause[pRootElementFlatModelicaXML] )? + ((f:FINAL )? { pDefinitionElement = pFlatModelicaXMLDoc->createElement(X("definition")); } + pDefinitionElement = class_definition[f != NULL, pDefinitionElement] + { + if (pDefinitionElement && pDefinitionElement->hasChildNodes()) + { + el_stack.push(pDefinitionElement); + } + } + )* + ) + { + //pRootElementFlatModelicaXML = within; + + pRootElementFlatModelicaXML = (DOMElement*)appendKids(el_stack, pRootElementFlatModelicaXML); + pRootElementModelica->appendChild(pRootElementFlatModelicaXML); + ast = pRootElementModelica; + + unsigned int elementCount = pFlatModelicaXMLDoc->getElementsByTagName(X("*"))->getLength(); + std::cout << std::endl; + std::cout << "The tree just created contains: " << elementCount + << " elements." << std::endl; + + // create the writer + DOMWriter* domWriter = pDOMImpl->createDOMWriter(); + // set the pretty print feature + if (domWriter->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) + domWriter->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true); + // fix the file + + XMLFormatTarget *myFormatTarget = new LocalFileFormatTarget(X(xmlFilename.c_str())); + //XMLFormatTarget *myOutFormatTarget = new StdOutFormatTarget; + + // serialize a DOMNode to the local file " + domWriter->writeNode(myFormatTarget, *pFlatModelicaXMLDoc); + //domWriter->writeNode(myOutFormatTarget, *pFlatModelicaXMLDoc); + + myFormatTarget->flush(); + //myOutFormatTarget->flush(); + domWriter->release(); + + delete myFormatTarget; + //delete myOutFormatTarget; + // release the document + pFlatModelicaXMLDoc->release(); + // terminate the XML framework + XMLPlatformUtils::Terminate(); + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##modelicaxml +*/ +within_clause[DOMElement* parent] returns [DOMElement* ast] +{ + void* pNamePath = 0; +} + : #(WITHIN (pNamePath = name_path)?) + { + if (pNamePath) parent->setAttribute(X("within"), X(((mstring *)pNamePath)->c_str())); + ast = parent; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##definition +*/ +class_definition [bool final, DOMElement *definitionElement] returns [DOMElement* ast] +{ + class_specifier_t sClassSpec; + sClassSpec.composition = definitionElement; +} +: #(CLASS_DEFINITION + (e:ENCAPSULATED )? + (p:PARTIAL )? + (r:class_restriction) + i:IDENT + class_specifier[sClassSpec] { definitionElement=sClassSpec.composition; } + ) + { + definitionElement->setAttribute(X("ident"), X(i->getText().c_str())); + + definitionElement->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + definitionElement->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (p != 0) definitionElement->setAttribute(X("partial"), X("true")); + if (final) definitionElement->setAttribute(X("final"), X("true")); + if (e != 0) definitionElement->setAttribute(X("encapsulated"), X("true")); + if (r) definitionElement->setAttribute(X("restriction"), str2xml(r)); + if (sClassSpec.string_comment) + { + definitionElement->appendChild(sClassSpec.string_comment); + } + if (sClassSpec.composition) + { + // nothing to do, already done at the lower level. + //definitionElement->appendChild(sClassSpec.composition); + //appendKids(definitionElement, sClassSpec.composition); + } + if (sClassSpec.derived) + { + definitionElement->appendChild(sClassSpec.derived); + } + if (sClassSpec.enumeration) + { + definitionElement->appendChild(sClassSpec.enumeration); + } + if (sClassSpec.overload) + { + definitionElement->appendChild(sClassSpec.overload); + } + ast = definitionElement; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##definition +see restriction +*/ +class_restriction /* returns [DOMElement* ast] */ + : + ( CLASS /*{ ast = Absyn__R_5fCLASS; }*/ + | MODEL /*{ ast = Absyn__R_5fMODEL; }*/ + | RECORD /*{ ast = Absyn__R_5fRECORD; }*/ + | BLOCK /*{ ast = Absyn__R_5fBLOCK; }*/ + | CONNECTOR /*{ ast = Absyn__R_5fCONNECTOR; }*/ + | TYPE /*{ ast = Absyn__R_5fTYPE; }*/ + | PACKAGE /*{ ast = Absyn__R_5fPACKAGE; }*/ + | FUNCTION /*{ ast = Absyn__R_5fFUNCTION; }*/ + ) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##class_specifier +*/ +/* ([comment] + composition | derived | enumeration | overloading)*/ +class_specifier [class_specifier_t& sClassSpec] +{ + DOMElement *comp = 0; + DOMElement *cmt = 0; + DOMElement *d = 0; + DOMElement *e = 0; + DOMElement *o = 0; +} + : + ( (cmt = string_comment) + comp = composition[sClassSpec.composition] + { + if (cmt) sClassSpec.string_comment = cmt; + sClassSpec.composition = comp; + } + ) + | #(EQUALS + ( + d = derived_class | + e = enumeration | + o = overloading)) + { + sClassSpec.derived = d; + sClassSpec.enumeration = e; + sClassSpec.overload = o; + } + + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##derived +*/ +derived_class returns [DOMElement* ast] +{ + void* p = 0; + DOMElement* as = 0; + void *cmod = 0; + DOMElement* cmt = 0; + DOMElement* attr = 0; + type_prefix_t pfx; + DOMElement* pDerived = pFlatModelicaXMLDoc->createElement(X("derived")); +} + : + ( type_prefix[pDerived] + p = name_path + ( as = array_subscripts[0] )? + ( cmod = class_modification )? + (cmt = comment)? + { + if (p) pDerived->setAttribute(X("type"), X(((mstring*)p)->c_str())); + if (as) pDerived->appendChild(as); + if (cmod) pDerived = (DOMElement*)appendKidsFromStack((l_stack *)cmod, pDerived); + if (cmt) pDerived->appendChild(cmt); + ast = pDerived; + } + ) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##enumeration +*/ +enumeration returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* el = 0; + DOMElement* cmt = 0; +} + : + #(en:ENUMERATION + el = enumeration_literal + { el_stack.push(el); } + ( + el = enumeration_literal + { el_stack.push(el); } + + )* + (cmt=comment)? + ) + { + DOMElement* pEnumeration = pFlatModelicaXMLDoc->createElement(X("enumeration")); + pEnumeration = (DOMElement*)appendKids(el_stack, pEnumeration); + if (cmt) pEnumeration->appendChild(cmt); + + pEnumeration->setAttribute(X("sline"), X(itoa(en->getLine(),stmp,10))); + pEnumeration->setAttribute(X("scolumn"), X(itoa(en->getColumn(),stmp,10))); + + ast = pEnumeration; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##enumeration_literal +*/ + +enumeration_literal returns [DOMElement* ast] : +{ + DOMElement* c1=0; +} + #(ENUMERATION_LITERAL i1:IDENT (c1=comment)?) + { + DOMElement* pEnumerationLiteral = pFlatModelicaXMLDoc->createElement(X("enumeration_literal")); + pEnumerationLiteral->setAttribute(X("ident"), str2xml(i1)); + + pEnumerationLiteral->setAttribute(X("sline"), X(itoa(i1->getLine(),stmp,10))); + pEnumerationLiteral->setAttribute(X("scolumn"), X(itoa(i1->getColumn(),stmp,10))); + + if (c1) pEnumerationLiteral->appendChild(c1); + ast = pEnumerationLiteral; + } + ; + +/* +Overloading is used internaly in the OpenModelica. +It shouldn't appear in the normal use of the FlatModelicaXML. +We leave it here for the future. +*/ +overloading returns [DOMElement* ast] +{ + std::stack el_stack; + void* el = 0; + DOMElement* cmt = 0; +} + : + #(ov:OVERLOAD + el = name_path + { el_stack.push(el); } + ( + el = name_path + { el_stack.push(el); } + + )* + (cmt=comment)? + ) + { + DOMElement* pOverload = pFlatModelicaXMLDoc->createElement(X("overload")); + if (cmt) pOverload->appendChild(cmt); + + pOverload->setAttribute(X("sline"), X(itoa(ov->getLine(),stmp,10))); + pOverload->setAttribute(X("scolumn"), X(itoa(ov->getColumn(),stmp,10))); + + ast = pOverload; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##elements +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##composition +*/ +composition [DOMElement* definition] returns [DOMElement* ast] +{ + DOMElement* el = 0; + l_stack el_stack; + DOMElement* ann; + DOMElement* pExternalFunctionCall = 0; +} + : + definition = element_list[1 /* public */, definition] + ( + ( + definition = public_element_list[definition] + | definition = protected_element_list[definition] + | definition = equation_clause[definition] + | definition = algorithm_clause[definition] + ) + )* + ( #(EXTERNAL { pExternalFunctionCall = pFlatModelicaXMLDoc->createElement(X("external")); } + ( pExternalFunctionCall = external_function_call[pExternalFunctionCall]) + ( pExternalFunctionCall = annotation[0 /*none*/, pExternalFunctionCall, INSIDE_EXTERNAL])? + ( + { pExternalFunctionCall->appendChild(pFlatModelicaXMLDoc->createElement(X("semicolon"))); } + pExternalFunctionCall = annotation[0 /*none*/, pExternalFunctionCall, INSIDE_EXTERNAL] + )* + ) + )? + { + if (pExternalFunctionCall) definition->appendChild(pExternalFunctionCall); + ast = definition; + } + ; + +public_element_list[DOMElement* definition] returns [DOMElement* ast] +{ + DOMElement* el; +} + : + #(p:PUBLIC + definition = element_list[1 /* public */, definition] + ) + { + ast = definition; + } + ; + +protected_element_list[DOMElement* definition] returns [DOMElement* ast] +{ + DOMElement* el; +} + : + + #(p:PROTECTED + definition = element_list[2 /* protected */, definition] + ) + { + ast = definition; + } + ; + +/* + + +*/ + +external_function_call[DOMElement *pExternalFunctionCall] returns [DOMElement* ast] +{ + DOMElement* temp=0; + DOMElement* temp2=0; + DOMElement* temp3=0; + ast = 0; + DOMElement* pExternalEqual = pFlatModelicaXMLDoc->createElement(X("external_equal")); +} + : + (s:STRING)? + (#(EXTERNAL_FUNCTION_CALL + ( + (i:IDENT (temp = expression_list)?) + { + if (s != NULL) pExternalFunctionCall->setAttribute(X("language_specification"), str2xml(s)); + if (i != NULL) pExternalFunctionCall->setAttribute(X("ident"), str2xml(i)); + if (temp) pExternalFunctionCall->appendChild(temp); + + pExternalFunctionCall->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pExternalFunctionCall->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pExternalFunctionCall; + } + | #(e:EQUALS temp2 = component_reference i2:IDENT ( temp3 = expression_list)?) + { + if (s != NULL) pExternalFunctionCall->setAttribute(X("language_specification"), str2xml(s)); + if (i2 != NULL) pExternalFunctionCall->setAttribute(X("ident"), str2xml(i2)); + pExternalFunctionCall->setAttribute(X("sline"), X(itoa(i2->getLine(),stmp,10))); + pExternalFunctionCall->setAttribute(X("scolumn"), X(itoa(i2->getColumn(),stmp,10))); + DOMElement* pExternalEqual = + pFlatModelicaXMLDoc->createElement(X("external_equal")); + if (temp2) pExternalEqual->appendChild(temp2); + pExternalFunctionCall->appendChild(pExternalEqual); + if (temp3) pExternalFunctionCall->appendChild(temp3); + ast = pExternalFunctionCall; + } + ) + ))? + { + if (!ast) + { + //parent->appendChild(ast); + ast = pExternalFunctionCall; + } + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##elements + + @HACK @FIXME add an enumeration type + parameter iSwitch: + 1 public element + 2 protected element +*/ + +element_list[int iSwitch, DOMElement*definition] returns [DOMElement* ast] +{ + DOMElement* e = 0; + l_stack el_stack; + DOMElement* ann = 0; +} + : + ((definition = element[iSwitch, definition]) + |(definition = annotation[iSwitch, definition, INSIDE_ELEMENT]))* + { + ast = definition; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##elements +*/ + +element[int iSwitch, DOMElement *parent] returns [DOMElement* ast] +{ + DOMElement* class_def = 0; + DOMElement* e_spec = 0; + DOMElement* final = 0; + DOMElement* innerouter = 0; + DOMElement* constr = 0; + DOMElement* cmt = 0; + DOMElement* comp_clause = 0; +} + : + ( parent = import_clause[iSwitch, parent] + { + ast = parent; + } + | parent = extends_clause[iSwitch, parent] + { + ast = parent; + } + | #(DECLARATION + ( { + DOMElement* componentElement = pFlatModelicaXMLDoc->createElement(X("component_clause")); + setVisibility(iSwitch, componentElement); + } + (f:FINAL)? { if (f) componentElement->setAttribute(X("final"), X("true")); } + (i:INNER | o:OUTER)? + { + if (i) componentElement->setAttribute(X("innerouter"), X("inner")); + if (o) componentElement->setAttribute(X("innerouter"), X("outer")); + } + (parent = component_clause[parent, componentElement] + { + ast = parent; + } + | r:REPLACEABLE {if (r) componentElement->setAttribute(X("replaceable"), X("true"));} + parent = component_clause[parent, componentElement] + (constr = constraining_clause cmt=comment)? + { + if (constr) + { + // append the comment to the constraint + if (cmt) ((DOMElement*)constr)->appendChild(cmt); + parent->appendChild(constr); + } + ast = parent; + } + ) + ) + ) + | #(DEFINITION + ( { + DOMElement* definitionElement = pFlatModelicaXMLDoc->createElement(X("definition")); + setVisibility(iSwitch, definitionElement); + } + (fd:FINAL)? { if (fd) definitionElement->setAttribute(X("final"), X("true")); } + (id:INNER | od:OUTER)? + { + if (i) definitionElement->setAttribute(X("innerouter"), X("inner")); + if (o) definitionElement->setAttribute(X("innerouter"), X("outer")); + } + ( + definitionElement = class_definition[fd != NULL, definitionElement] + { + if (definitionElement && definitionElement->hasChildNodes()) + { + parent->appendChild(definitionElement); + } + ast = parent; + } + | + (rd:REPLACEABLE + definitionElement = class_definition[fd != NULL, definitionElement] + (constr = constraining_clause cmt=comment)? + ) + { + if (definitionElement) + { + if (innerouter) + definitionElement->appendChild(innerouter); + if (constr) + { + definitionElement->appendChild(constr); + // append the comment to the constraint + if (cmt) ((DOMElement*)constr)->appendChild(cmt); + } + if (rd) definitionElement->setAttribute(X("replaceable"), X("true")); + if (definitionElement->hasChildNodes()) + { + parent->appendChild(definitionElement); + } + } + ast = parent; + } + ) + ) + ) + ) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##import +*/ +import_clause[int iSwitch, DOMElement *parent] returns [DOMElement* ast] +{ + DOMElement* imp = 0; + DOMElement* cmt = 0; +} + : + #(i:IMPORT + (imp = explicit_import_name + |imp = implicit_import_name + ) + (cmt = comment)? + ) + { + DOMElement* pImport = pFlatModelicaXMLDoc->createElement(X("import")); + setVisibility(iSwitch, pImport); + + pImport->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pImport->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pImport->appendChild(imp); + if (cmt) pImport->appendChild(cmt); + parent->appendChild(pImport); + ast = parent; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##import +*/ +explicit_import_name returns [DOMElement* ast] +{ + void* path; +} + : + #(EQUALS i:IDENT path = name_path) + { + DOMElement* pExplicitImport = pFlatModelicaXMLDoc->createElement(X("named_import")); + pExplicitImport->setAttribute(X("ident"), str2xml(i)); + + pExplicitImport->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pExplicitImport->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (path) pExplicitImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + ast = pExplicitImport; + } + ; +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##import +*/ +implicit_import_name returns [DOMElement* ast] +{ + void* path; +} + : + (#(unq:UNQUALIFIED path = name_path) + { + DOMElement* pUnqImport = pFlatModelicaXMLDoc->createElement(X("unqualified_import")); + if (path) pUnqImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + + pUnqImport->setAttribute(X("sline"), X(itoa(unq->getLine(),stmp,10))); + pUnqImport->setAttribute(X("scolumn"), X(itoa(unq->getColumn(),stmp,10))); + + ast = pUnqImport; + } + |#(qua:QUALIFIED path = name_path) + { + DOMElement* pQuaImport = pFlatModelicaXMLDoc->createElement(X("qualified_import")); + if (path) pQuaImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + + pQuaImport->setAttribute(X("sline"), X(itoa(qua->getLine(),stmp,10))); + pQuaImport->setAttribute(X("scolumn"), X(itoa(qua->getColumn(),stmp,10))); + + ast = pQuaImport; + } + ) + ; + + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##extends +*/ +extends_clause[int iSwitch, DOMElement* parent] returns [DOMElement* ast] +{ + void *path = 0; + void *mod = 0; +} + : + (#(e:EXTENDS + path = name_path + ( mod = class_modification)? + ) + { + DOMElement* pExtends = pFlatModelicaXMLDoc->createElement(X("extends")); + setVisibility(iSwitch, pExtends); + + pExtends->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pExtends->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + if (mod) pExtends = (DOMElement*)appendKidsFromStack((l_stack *)mod, pExtends); + if (path) pExtends->setAttribute(X("type"), X(((mstring*)path)->c_str())); + parent->appendChild(pExtends); + ast = parent; + } + ) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##constrain +*/ +constraining_clause returns [DOMElement* ast] +{ + DOMElement* pConstrain = pFlatModelicaXMLDoc->createElement(X("constrain")); +} + : + (ast = extends_clause[0, pConstrain]) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##component +*/ +component_clause[DOMElement* parent, DOMElement* attributes] returns [DOMElement* ast] +{ + type_prefix_t pfx; + void* path = 0; + DOMElement* arr = 0; + DOMElement* comp_list = 0; +} + : + type_prefix[attributes] + path = type_specifier { if (path) attributes->setAttribute(X("type"), X(((mstring*)path)->c_str())); } + (arr = array_subscripts[1])? + parent = component_list[parent, attributes, arr] + { + ast = parent; + } + ; + +type_prefix[DOMElement* parent] + : + (f:FLOW)? + (d:DISCRETE | p:PARAMETER | c:CONSTANT)? + (i:INPUT | o:OUTPUT)? + { + if (f != NULL) { parent->setAttribute(X("flow"), X("true")); } + //else { parent->setAttribute(X("flow"), X("none")); } + if (d != NULL) { parent->setAttribute(X("variability"), X("discrete")); } + else if (p != NULL) { parent->setAttribute(X("variability"), X("parameter")); } + else if (c != NULL) { parent->setAttribute(X("variability"), X("constant")); } + //else { parent->setAttribute(X("variability"), X("variable")); } + if (i != NULL) { parent->setAttribute(X("direction"), X("input")); } + else if (o != NULL) { parent->setAttribute(X("direction"), X("output")); } + //else { parent->setAttribute(X("direction"), X("bidirectional")); } + } + ; + +// returns datatype Path +type_specifier returns [void* ast] + : + ast = name_path; + + +// returns datatype Component list +component_list[DOMElement* parent, DOMElement *attributes, DOMElement* type_array] + returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e=0; +} + : + parent = component_declaration[parent, attributes, type_array] + (parent = component_declaration[parent, attributes, type_array])* + { + ast = parent; + } + ; + + +// returns datatype Component +component_declaration[DOMElement* parent, DOMElement *attributes, DOMElement *type_array] + returns [DOMElement* ast] +{ + DOMElement* cmt = 0; + DOMElement* dec = 0; + +} + : + (dec = declaration[attributes, type_array]) (cmt = comment)? + { + if (cmt) dec->appendChild(cmt); + parent->appendChild(dec); + ast = parent; + } + ; + + +// returns datatype Component +declaration[DOMElement* parent, DOMElement* type_array] returns [DOMElement* ast] +{ + DOMElement* arr = 0; + DOMElement* mod = 0; + DOMElement* id = 0; +} + : + #(i:IDENT (arr = array_subscripts[0])? (mod = modification)?) + { + DOMElement *pComponent = pFlatModelicaXMLDoc->createElement(X("component")); + pComponent->setAttribute(X("ident"), str2xml(i)); + pComponent->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pComponent->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + setAttributes(pComponent, parent); + if (type_array) pComponent->appendChild(type_array); + if (arr) pComponent->appendChild(arr); + if (mod) pComponent->appendChild(mod); + ast = pComponent; + } + ; + +modification returns [DOMElement* ast] +{ + DOMElement* e = 0; + void *cm = 0; + int iswitch = 0; +} + : + ( cm = class_modification (e = expression )? + |#(eq:EQUALS e = expression) { iswitch = 1; } + |#(as:ASSIGN e = expression) { iswitch = 2; } + ) + { + DOMElement *pModificationEQorASorARG = null; + if (iswitch == 1) pModificationEQorASorARG = pFlatModelicaXMLDoc->createElement(X("modification_equals")); + if (iswitch == 2) pModificationEQorASorARG = pFlatModelicaXMLDoc->createElement(X("modification_assign")); + if (iswitch == 0) pModificationEQorASorARG = pFlatModelicaXMLDoc->createElement(X("modification_arguments")); + if (cm) pModificationEQorASorARG = (DOMElement*)appendKidsFromStack((l_stack*)cm, pModificationEQorASorARG); + if (e) + { + if (iswitch == 0) + { + DOMElement *z = pFlatModelicaXMLDoc->createElement(X("modification_equals")); + z->appendChild(e); + pModificationEQorASorARG->appendChild(z); + } + else + { + pModificationEQorASorARG->appendChild(e); + } + } + if (eq) + { + pModificationEQorASorARG->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); + pModificationEQorASorARG->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); + } + if (as) + { + pModificationEQorASorARG->setAttribute(X("sline"), X(itoa(as->getLine(),stmp,10))); + pModificationEQorASorARG->setAttribute(X("scolumn"), X(itoa(as->getColumn(),stmp,10))); + } + ast = pModificationEQorASorARG; + } + ; + +class_modification returns [void *stack] +{ + stack = 0; +} + : + #(CLASS_MODIFICATION (stack = argument_list)?) + ; + +argument_list returns [void *stack] +{ + l_stack *el_stack = new l_stack; + DOMElement* e; +} + : + #(ARGUMENT_LIST + e = argument { el_stack->push(e); } + (e = argument { el_stack->push(e); } )* + ) + { + if (el_stack) stack = (void*)el_stack; + else (stack = 0); + } + ; + +argument returns [DOMElement* ast] + : + #(em:ELEMENT_MODIFICATION ast = element_modification) + { + if (em) + { + ast->setAttribute(X("sline"), X(itoa(em->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(em->getColumn(),stmp,10))); + } + } + |#(er:ELEMENT_REDECLARATION ast = element_redeclaration) + { + if (er) + { + ast->setAttribute(X("sline"), X(itoa(er->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(er->getColumn(),stmp,10))); + } + } + ; + +element_modification returns [DOMElement* ast] +{ + DOMElement* cref; + DOMElement* mod=0; + DOMElement* cmt=0; +} + : + (e:EACH)? + (f:FINAL)? + cref = component_reference + (mod = modification)? + cmt = string_comment + { + DOMElement *pModification = pFlatModelicaXMLDoc->createElement(X("element_modification")); + if (f) pModification->setAttribute(X("final"), X("true")); + if (e) pModification->setAttribute(X("each"), X("true")); + pModification->appendChild(cref); + if (mod) pModification->appendChild(mod); + if (cmt) pModification->appendChild(cmt); + ast = pModification; + } + ; + +element_redeclaration returns [DOMElement* ast] +{ + DOMElement* class_def = 0; + DOMElement* e_spec = 0; + DOMElement* constr = 0; + DOMElement* final = 0; + DOMElement* each = 0; + class_def = pFlatModelicaXMLDoc->createElement(X("definition")); +} + : + (#(r:REDECLARE (e:EACH)? (f:FINAL)? + ( + (class_def = class_definition[false, class_def] + { + DOMElement *pElementRedeclaration = pFlatModelicaXMLDoc->createElement(X("element_redeclaration")); + if (class_def->hasChildNodes()) + pElementRedeclaration->appendChild(class_def); + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (each) pElementRedeclaration->setAttribute(X("each"), X("true")); + ast = pElementRedeclaration; + } + | { DOMElement *pElementRedeclaration = pFlatModelicaXMLDoc->createElement(X("element_redeclaration")); } + pElementRedeclaration = component_clause1[pElementRedeclaration] + { + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (each) pElementRedeclaration->setAttribute(X("each"), X("true")); + ast = pElementRedeclaration; + } + ) + | + ( re:REPLACEABLE + { DOMElement *pElementRedeclaration = pFlatModelicaXMLDoc->createElement(X("element_redeclaration")); } + (class_def = class_definition[false, class_def] + | pElementRedeclaration = component_clause1[pElementRedeclaration] + ) + (constr = constraining_clause)? + { + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (re) pElementRedeclaration->setAttribute(X("replaceable"), X("true")); + if (class_def && class_def->hasChildNodes()) + { + pElementRedeclaration->appendChild(class_def); + if (constr) pElementRedeclaration->appendChild(constr); + } + else + { + if (constr) pElementRedeclaration->appendChild(constr); + } + ast = pElementRedeclaration; + } + ) + ) + ) + ) + ; + +component_clause1[DOMElement *parent] returns [DOMElement* ast] +{ + type_prefix_t pfx; + DOMElement* attr = pFlatModelicaXMLDoc->createElement(X("tmp")); + void* path = 0; + DOMElement* arr = 0; + DOMElement* comp_decl = 0; + DOMElement* comp_list = 0; +} + : + type_prefix[attr] + path = type_specifier { if (path) attr->setAttribute(X("type"), X(((mstring*)path)->c_str())); } + parent = component_declaration[parent, attr, null] + { + ast = parent; + } + ; + +// Return datatype ClassPart +equation_clause[DOMElement *definition] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e = 0; + DOMElement* ann = 0; +} + : + #(eq:EQUATION + ( + ( + definition = equation[definition] + | definition = annotation[0 /*none*/, definition, INSIDE_EQUATION])* + ) + ) + { + ast = definition; + } + | + #(INITIAL_EQUATION + #(EQUATION + ( + definition = equation[definition] + | definition = annotation [0 /* none */, definition, INSIDE_EQUATION ])* + ) + { + ast = definition; + } + ) + ; + +algorithm_clause[DOMElement* definition] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + DOMElement* ann; +} + : + #(ALGORITHM + (definition = algorithm[definition] + | definition = annotation [0 /* none */, definition, INSIDE_ALGORITHM])* + ) + { + ast = definition; + } + | + #(INITIAL_ALGORITHM + #(ALGORITHM + (definition = algorithm[definition] + | definition = annotation [0 /* none */, definition, INSIDE_ALGORITHM])* + ) + { + ast = definition; + } + ) + ; + +equation[DOMElement* definition] returns [DOMElement* ast] +{ + DOMElement* cmt = 0; +} + : + #(es:EQUATION_STATEMENT + ( ast = equality_equation + | ast = conditional_equation_e + | ast = for_clause_e + | ast = when_clause_e + | ast = connect_clause + | ast = equation_funcall + ) + (cmt = comment)? + { + DOMElement* pEquation = pFlatModelicaXMLDoc->createElement(X("equation")); + pEquation->appendChild(ast); + if (cmt) pEquation->appendChild(cmt); + if (es) + { + pEquation->setAttribute(X("sline"), X(itoa(es->getLine(),stmp,10))); + pEquation->setAttribute(X("scolumn"), X(itoa(es->getColumn(),stmp,10))); + } + definition->appendChild(pEquation); + ast = definition; + } + ) + ; + +equation_funcall returns [DOMElement* ast] +{ + DOMElement* fcall = 0; +} + : + i:IDENT fcall = function_call + { + DOMElement* pEquCall = pFlatModelicaXMLDoc->createElement(X("equ_call")); + pEquCall->setAttribute(X("ident"), str2xml(i)); + pEquCall->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquCall->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + pEquCall->appendChild(fcall); + ast = pEquCall; + } + ; + +algorithm[DOMElement *definition] returns [DOMElement* ast] +{ + DOMElement* cref; + DOMElement* expr; + DOMElement* tuple; + DOMElement* args; + DOMElement* cmt=0; +} + : + #(as:ALGORITHM_STATEMENT + (#(az:ASSIGN + (cref = component_reference expr = expression + { + DOMElement* pAlgAssign = pFlatModelicaXMLDoc->createElement(X("alg_assign")); + if (az) + { + pAlgAssign->setAttribute(X("sline"), X(itoa(az->getLine(),stmp,10))); + pAlgAssign->setAttribute(X("scolumn"), X(itoa(az->getColumn(),stmp,10))); + } + pAlgAssign->appendChild(cref); + pAlgAssign->appendChild(expr); + ast = pAlgAssign; + } + | (tuple = tuple_expression_list cref = component_reference args = function_call) + { + DOMElement* pAlgAssign = pFlatModelicaXMLDoc->createElement(X("alg_assign")); + DOMElement* pCall = pFlatModelicaXMLDoc->createElement(X("call")); + + if (az) + { + pAlgAssign->setAttribute(X("sline"), X(itoa(az->getLine(),stmp,10))); + pAlgAssign->setAttribute(X("scolumn"), X(itoa(az->getColumn(),stmp,10))); + } + + pAlgAssign->appendChild(tuple); + + pCall->appendChild(cref); + pCall->appendChild(args); + + pAlgAssign->appendChild(pCall); + + ast = pAlgAssign; + /* + + + */ + } + ) + ) + | ast = algorithm_function_call + | ast = conditional_equation_a + | ast = for_clause_a + | ast = while_clause + | ast = when_clause_a + ) + (cmt = comment)? + { + DOMElement* pAlgorithm = pFlatModelicaXMLDoc->createElement(X("algorithm")); + if (as) + { + pAlgorithm->setAttribute(X("sline"), X(itoa(as->getLine(),stmp,10))); + pAlgorithm->setAttribute(X("scolumn"), X(itoa(as->getColumn(),stmp,10))); + } + pAlgorithm->appendChild(ast); + if (cmt) pAlgorithm->appendChild(cmt); + definition->appendChild(pAlgorithm); + ast = definition; + /* + + + */ + } + ) + ; + +algorithm_function_call returns [DOMElement* ast] +{ + DOMElement* cref; + DOMElement* args; +} + : + cref = component_reference args = function_call + { + DOMElement* pAlgCall = pFlatModelicaXMLDoc->createElement(X("alg_call")); + pAlgCall->appendChild(cref); + pAlgCall->appendChild(args); + ast = pAlgCall; + /* + + + */ + } + ; + +equality_equation returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + #(eq:EQUALS e1 = simple_expression e2 = expression) + { + DOMElement* pEquEqual = pFlatModelicaXMLDoc->createElement(X("equ_equal")); + pEquEqual->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); + pEquEqual->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); + pEquEqual->appendChild(e1); + pEquEqual->appendChild(e2); + ast = pEquEqual; + /* + + + */ + } + ; + +conditional_equation_e returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* then_b; + DOMElement* else_b = 0; + DOMElement* else_if_b; + l_stack el_stack; + DOMElement* e; + + DOMElement* pEquIf = pFlatModelicaXMLDoc->createElement(X("equ_if")); + DOMElement* pEquThen = pFlatModelicaXMLDoc->createElement(X("equ_then")); + DOMElement* pEquElse = pFlatModelicaXMLDoc->createElement(X("equ_else")); + + bool fbElse = false; +} + : + #(i:IF + e1 = expression { pEquIf->appendChild(e1); } + pEquThen = equation_list[pEquThen] { pEquIf->appendChild(pEquThen); } + ( e = equation_elseif { el_stack.push(e); } )* + (ELSE pEquElse = equation_list[pEquElse] { fbElse = true;} )? + ) + { + pEquIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (el_stack.size()>0) pEquIf = (DOMElement*)appendKids(el_stack, pEquIf); // ?? is this ok? + if (fbElse) pEquIf->appendChild(pEquElse); + ast = pEquIf; + } + ; + +conditional_equation_a returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* then_b; + DOMElement* else_b = 0; + DOMElement* else_if_b; + l_stack el_stack; + DOMElement* e; + DOMElement* pAlgIf = pFlatModelicaXMLDoc->createElement(X("alg_if")); + DOMElement* pAlgThen = pFlatModelicaXMLDoc->createElement(X("alg_then")); + DOMElement* pAlgElse = pFlatModelicaXMLDoc->createElement(X("alg_else")); + bool fbElse = false; +} + : + #(i:IF + e1 = expression { pAlgIf->appendChild(e1); } + pAlgThen = algorithm_list[pAlgThen] + { + if (pAlgThen) + pAlgIf->appendChild(pAlgThen); + } + ( e = algorithm_elseif { el_stack.push(e); } )* + ( ELSE pAlgElse = algorithm_list[pAlgElse] {fbElse = true; } )? + ) + { + pAlgIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pAlgIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + if (el_stack.size()>0) pAlgIf = (DOMElement*)appendKids(el_stack, pAlgIf); + if (fbElse) pAlgIf->appendChild(pAlgElse); + ast = pAlgIf; + } + ; + +/* + + +*/ + + +for_clause_e returns [DOMElement* ast] +{ + DOMElement* f; + DOMElement* eq; + DOMElement* pEquFor = pFlatModelicaXMLDoc->createElement(X("equ_for")); +} + : + #(i:FOR f=for_indices { pEquFor->appendChild(f); } + pEquFor=equation_list[pEquFor]) + { + pEquFor->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquFor->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pEquFor; + } + ; + + +for_clause_a returns [DOMElement* ast] +{ + DOMElement* f; + DOMElement* eq; + DOMElement* pAlgFor = pFlatModelicaXMLDoc->createElement(X("alg_for")); +} + : + #(i:FOR f=for_indices + { + f->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + f->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + pAlgFor->appendChild(f); + } + pAlgFor = algorithm_list[pAlgFor]) + { + pAlgFor->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pAlgFor->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pAlgFor; + } + ; + + + +for_indices returns [DOMElement* ast] +{ + DOMElement* f; + DOMElement* e; + l_stack el_stack; +} +: + (#(IN i:IDENT (e=expression)?) + { + DOMElement* pForIndex = pFlatModelicaXMLDoc->createElement(X("for_index")); + pForIndex->setAttribute(X("ident"), str2xml(i)); + + pForIndex->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pForIndex->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (e) pForIndex->appendChild(e); + el_stack.push(pForIndex); + } + )* + { + DOMElement* pForIndices = pFlatModelicaXMLDoc->createElement(X("for_indices")); + pForIndices = (DOMElement*)appendKids(el_stack, pForIndices); + ast = pForIndices; + } +; + +while_clause returns [DOMElement* ast] +{ + DOMElement* e; + DOMElement* body; + DOMElement* pAlgWhile = pFlatModelicaXMLDoc->createElement(X("alg_while")); +} + : + #(w:WHILE + e = expression + { + pAlgWhile->appendChild(e); + } + pAlgWhile = algorithm_list[pAlgWhile]) + { + pAlgWhile->setAttribute(X("sline"), X(itoa(w->getLine(),stmp,10))); + pAlgWhile->setAttribute(X("scolumn"), X(itoa(w->getColumn(),stmp,10))); + + ast = pAlgWhile; + } + ; + + +/* + + +*/ + +when_clause_e returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + DOMElement* body; + DOMElement* el = 0; + DOMElement* pEquWhen = pFlatModelicaXMLDoc->createElement(X("equ_when")); + DOMElement* pEquThen = pFlatModelicaXMLDoc->createElement(X("equ_then")); +} + : + #(wh:WHEN + e = expression { pEquWhen->appendChild(e); } + pEquThen = equation_list[pEquThen] { pEquWhen->appendChild(pEquThen); } + (el = else_when_e { el_stack.push(el); } )* + ) + { + pEquWhen->setAttribute(X("sline"), X(itoa(wh->getLine(),stmp,10))); + pEquWhen->setAttribute(X("scolumn"), X(itoa(wh->getColumn(),stmp,10))); + + if (el_stack.size()>0) pEquWhen = (DOMElement*)appendKids(el_stack, pEquWhen); // ??is this ok? + ast = pEquWhen; + } + ; + +else_when_e returns [DOMElement* ast] +{ + DOMElement* expr; + DOMElement* eqn; + DOMElement* pEquElseWhen = pFlatModelicaXMLDoc->createElement(X("equ_elsewhen")); + DOMElement* pEquThen = pFlatModelicaXMLDoc->createElement(X("equ_then")); +} + : + #(e:ELSEWHEN expr = expression { pEquElseWhen->appendChild(expr); } + pEquThen = equation_list[pEquThen]) + { + pEquElseWhen->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pEquElseWhen->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + pEquElseWhen->appendChild(pEquThen); + ast = pEquElseWhen; + } + ; + +when_clause_a returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + DOMElement* body; + DOMElement* el = 0; + DOMElement* pAlgWhen = pFlatModelicaXMLDoc->createElement(X("alg_when")); + DOMElement* pAlgThen = pFlatModelicaXMLDoc->createElement(X("alg_then")); +} + : + #(wh:WHEN + e = expression { pAlgWhen->appendChild(e); } + pAlgThen = algorithm_list[pAlgThen] { pAlgWhen->appendChild(pAlgThen); } + (el = else_when_a {el_stack.push(el); })* + ) + { + pAlgWhen->setAttribute(X("sline"), X(itoa(wh->getLine(),stmp,10))); + pAlgWhen->setAttribute(X("scolumn"), X(itoa(wh->getColumn(),stmp,10))); + + if (el_stack.size() > 0) pAlgWhen = (DOMElement*)appendKids(el_stack, pAlgWhen); + ast = pAlgWhen; + } + ; + +else_when_a returns [DOMElement* ast] +{ + DOMElement* expr; + DOMElement* alg; + DOMElement* pAlgElseWhen = pFlatModelicaXMLDoc->createElement(X("alg_elsewhen")); + DOMElement* pAlgThen = pFlatModelicaXMLDoc->createElement(X("alg_then")); +} + : + #(e:ELSEWHEN expr = expression { pAlgElseWhen->appendChild(expr); } + pAlgThen = algorithm_list[pAlgThen]) + { + pAlgElseWhen->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pAlgElseWhen->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + pAlgElseWhen->appendChild(pAlgThen); + ast = pAlgElseWhen; + } + ; + +equation_elseif returns [DOMElement* ast] +{ + DOMElement* e; + DOMElement* eq; + DOMElement* pEquElseIf = pFlatModelicaXMLDoc->createElement(X("equ_elseif")); + DOMElement* pEquThen = pFlatModelicaXMLDoc->createElement(X("equ_then")); +} + : + #(els:ELSEIF + e = expression { pEquElseIf->appendChild(e); } + pEquThen = equation_list[pEquThen] + ) + { + pEquElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pEquElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pEquElseIf->appendChild(pEquThen); + ast = pEquElseIf; + } + ; + +algorithm_elseif returns [DOMElement* ast] +{ + DOMElement* e; + DOMElement* body; + DOMElement* pAlgElseIf = pFlatModelicaXMLDoc->createElement(X("alg_elseif")); + DOMElement* pAlgThen = pFlatModelicaXMLDoc->createElement(X("alg_then")); +} + : + #(els:ELSEIF + e = expression { pAlgElseIf->appendChild(e); } + pAlgThen = algorithm_list[pAlgThen] + ) + { + pAlgElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pAlgElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pAlgElseIf->appendChild(pAlgThen); + ast = pAlgElseIf; + } + ; + +equation_list[DOMElement* pEquationList] returns [DOMElement* ast] +{ + DOMElement* e; + l_stack el_stack; +} + : + (pEquationList = equation[pEquationList])* + { + ast = pEquationList; + } + ; + +algorithm_list[DOMElement* pAlgorithmList] returns [DOMElement* ast] +{ + DOMElement* e; + l_stack el_stack; +} + : + (pAlgorithmList = algorithm[pAlgorithmList] )* + { + ast = pAlgorithmList; + } + ; + +connect_clause returns [DOMElement* ast] +{ + DOMElement* r1; + DOMElement* r2; +} + : + #(c:CONNECT + r1 = component_reference + r2 = component_reference + ) + { + DOMElement* pEquConnect = pFlatModelicaXMLDoc->createElement(X("equ_connect")); + + pEquConnect->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pEquConnect->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + + pEquConnect->appendChild(r1); + pEquConnect->appendChild(r2); + ast = pEquConnect; + } + ; + + +expression returns [DOMElement* ast] + : + ( ast = simple_expression + | ast = if_expression + | ast = code_expression + ) + ; + +if_expression returns [DOMElement* ast] +{ + DOMElement* cond; + DOMElement* thenPart; + DOMElement* elsePart; + DOMElement* e; + DOMElement* elseifPart; + l_stack el_stack; +} + : + #(i:IF cond = expression + thenPart = expression (e=elseif_expression {el_stack.push(e);} )* elsePart = expression + { + DOMElement* pIf = pFlatModelicaXMLDoc->createElement(X("if")); + DOMElement* pThen = pFlatModelicaXMLDoc->createElement(X("then")); + DOMElement* pElse = pFlatModelicaXMLDoc->createElement(X("else")); + + pIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pIf->appendChild(cond); + pThen->appendChild(thenPart); + pIf->appendChild(pThen); + if (el_stack.size()>0) pIf = (DOMElement*)appendKids(el_stack, pIf); //??is this ok?? + pElse->appendChild(elsePart); + pIf->appendChild(pElse); + ast = pIf; + } + ) + ; + +elseif_expression returns [DOMElement* ast] +{ + DOMElement* cond; + DOMElement* thenPart; +} + : + #(els:ELSEIF cond = expression thenPart = expression + { + DOMElement* pElseIf = pFlatModelicaXMLDoc->createElement(X("elseif")); + + pElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pElseIf->appendChild(cond); + DOMElement* pThen = pFlatModelicaXMLDoc->createElement(X("then")); + pThen->appendChild(thenPart); + pElseIf->appendChild(pThen); + ast = pElseIf; + } + ) + ; + +simple_expression returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; + DOMElement* e3; +} + : + (#(r3:RANGE3 e1 = logical_expression + e2 = logical_expression + e3 = logical_expression) + { + DOMElement* pRange = pFlatModelicaXMLDoc->createElement(X("range")); + + pRange->setAttribute(X("sline"), X(itoa(r3->getLine(),stmp,10))); + pRange->setAttribute(X("scolumn"), X(itoa(r3->getColumn(),stmp,10))); + + pRange->appendChild(e1); + pRange->appendChild(e2); + pRange->appendChild(e3); + ast = pRange; + /* + + + */ + } + |#(r2:RANGE2 e1 = logical_expression e3 = logical_expression) + { + DOMElement* pRange = pFlatModelicaXMLDoc->createElement(X("range")); + + pRange->setAttribute(X("sline"), X(itoa(r2->getLine(),stmp,10))); + pRange->setAttribute(X("scolumn"), X(itoa(r2->getColumn(),stmp,10))); + + pRange->appendChild(e1); + pRange->appendChild(e3); + ast = pRange; + } + | ast = logical_expression + ) + ; + +// ?? what the hack is this? +code_expression returns [DOMElement* ast] +{ + DOMElement*pCode = pFlatModelicaXMLDoc->createElement(X("code")); +} + + : + #(CODE_MODIFICATION (ast = modification) ) + { + // ?? what the hack is this? + DOMElement* pModification = pFlatModelicaXMLDoc->createElement(X("modification")); + pModification->appendChild(ast); + ast = pModification; + /* + ast = Absyn__CODE(Absyn__C_5fMODIFICATION(ast)); + */ + } + + | #(CODE_EXPRESSION (ast = expression) ) + { + // ?? what the hack is this? + DOMElement* pExpression = pFlatModelicaXMLDoc->createElement(X("expression")); + pExpression->appendChild(ast); + ast = pExpression; + /* ast = Absyn__CODE(Absyn__C_5fEXPRESSION(ast)); */ + } + + | #(CODE_ELEMENT (ast = element[0 /* none */, pCode]) ) + { + // ?? what the hack is this? + DOMElement* pElement = pFlatModelicaXMLDoc->createElement(X("element")); + pElement->appendChild(ast); + ast = pElement; + /* ast = Absyn__CODE(Absyn__C_5fELEMENT(ast)); */ + } + + | #(CODE_EQUATION (ast = equation_clause[pCode]) ) + { + // ?? what the hack is this? + DOMElement* pEquationSection = pFlatModelicaXMLDoc->createElement(X("equation_section")); + pEquationSection->appendChild(ast); + ast = pEquationSection; + /* ast = Absyn__CODE(Absyn__C_5fEQUATIONSECTION(RML_FALSE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); */ + } + + | #(CODE_INITIALEQUATION (ast = equation_clause[pCode]) ) + { + // ?? what the hack is this? + DOMElement* pEquationSection = pFlatModelicaXMLDoc->createElement(X("equation_section")); + ((DOMElement*)ast)->setAttribute(X("initial"), X("true")); + pEquationSection->appendChild(ast); + ast = pEquationSection; + /* + ast = Absyn__CODE(Absyn__C_5fEQUATIONSECTION(RML_TRUE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + } + | #(CODE_ALGORITHM (ast = algorithm_clause[pCode]) ) + { + // ?? what the hack is this? + DOMElement* pAlgorithmSection = pFlatModelicaXMLDoc->createElement(X("algorithm_section")); + pAlgorithmSection->appendChild(ast); + ast = pAlgorithmSection; + /* + ast = Absyn__CODE(Absyn__C_5fALGORITHMSECTION(RML_FALSE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + } + | #(CODE_INITIALALGORITHM (ast = algorithm_clause[pCode]) ) + { + // ?? what the hack is this? + DOMElement* pAlgorithmSection = pFlatModelicaXMLDoc->createElement(X("algorithm_section")); + ((DOMElement*)ast)->setAttribute(X("initial"), X("true")); + pAlgorithmSection->appendChild(ast); + ast = pAlgorithmSection; + /* + ast = Absyn__CODE(Absyn__C_5fALGORITHMSECTION(RML_TRUE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + } + ; + +logical_expression returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = logical_term + | #(o:OR e1 = logical_expression e2 = logical_term) + { + DOMElement* pOr = pFlatModelicaXMLDoc->createElement(X("or")); + + pOr->setAttribute(X("sline"), X(itoa(o->getLine(),stmp,10))); + pOr->setAttribute(X("scolumn"), X(itoa(o->getColumn(),stmp,10))); + + pOr->appendChild(e1); + pOr->appendChild(e2); + ast = pOr; + } + ) + + ; + +logical_term returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = logical_factor + | #(a:AND e1 = logical_term e2 = logical_factor) + { + DOMElement* pAnd = pFlatModelicaXMLDoc->createElement(X("and")); + + pAnd->setAttribute(X("sline"), X(itoa(a->getLine(),stmp,10))); + pAnd->setAttribute(X("scolumn"), X(itoa(a->getColumn(),stmp,10))); + + pAnd->appendChild(e1); + pAnd->appendChild(e2); + ast = pAnd; + } + ) + ; + +logical_factor returns [DOMElement* ast] + : + #(n:NOT ast = relation + { + DOMElement* pNot = pFlatModelicaXMLDoc->createElement(X("not")); + + pNot->setAttribute(X("sline"), X(itoa(n->getLine(),stmp,10))); + pNot->setAttribute(X("scolumn"), X(itoa(n->getColumn(),stmp,10))); + + pNot->appendChild(ast); + ast = pNot; + }) + | ast = relation; + +relation returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* op = 0; + DOMElement* e2 = 0; +} + : + ( ast = arithmetic_expression + | + ( #(lt:LESS e1=arithmetic_expression e2=arithmetic_expression) + { op = pFlatModelicaXMLDoc->createElement(X("lt")); /* Absyn__LESS; */ } + | #(lte:LESSEQ e1=arithmetic_expression e2=arithmetic_expression) + { op = pFlatModelicaXMLDoc->createElement(X("lte")); /* Absyn__LESSEQ; */ } + | #(gt:GREATER e1=arithmetic_expression e2=arithmetic_expression) + { op = pFlatModelicaXMLDoc->createElement(X("gt")); /* Absyn__GREATER; */ } + | #(gte:GREATEREQ e1=arithmetic_expression e2=arithmetic_expression) + { op = pFlatModelicaXMLDoc->createElement(X("gte")); /* Absyn__GREATEREQ; */ } + | #(eq:EQEQ e1=arithmetic_expression e2=arithmetic_expression) + { op = pFlatModelicaXMLDoc->createElement(X("eq")); /* Absyn__EQUAL; */ } + | #(ne:LESSGT e1=arithmetic_expression e2=arithmetic_expression ) + { op = pFlatModelicaXMLDoc->createElement(X("ne")); /* op = Absyn__NEQUAL; */ } + ) + { + op->appendChild(e1); + op->appendChild(e2); + if (lt) { op->setAttribute(X("sline"), X(itoa(lt->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(lt->getColumn(),stmp,10))); } + if (lte){ op->setAttribute(X("sline"), X(itoa(lte->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(lte->getColumn(),stmp,10))); } + if (gt) { op->setAttribute(X("sline"), X(itoa(gt->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(gt->getColumn(),stmp,10))); } + if (gte){ op->setAttribute(X("sline"), X(itoa(gte->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(gte->getColumn(),stmp,10))); } + if (eq) { op->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); } + if (ne) { op->setAttribute(X("sline"), X(itoa(ne->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(ne->getColumn(),stmp,10))); } + ast = op; + } + ) + ; + +arithmetic_expression returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = unary_arithmetic_expression + |#(add:PLUS e1 = arithmetic_expression e2 = term) + { + DOMElement* pAdd = pFlatModelicaXMLDoc->createElement(X("add")); + + pAdd->setAttribute(X("sline"), X(itoa(add->getLine(),stmp,10))); + pAdd->setAttribute(X("scolumn"), X(itoa(add->getColumn(),stmp,10))); + + pAdd->setAttribute(X("operation"), X("binary")); + pAdd->appendChild(e1); + pAdd->appendChild(e2); + ast = pAdd; + } + |#(sub:MINUS e1 = arithmetic_expression e2 = term) + { + DOMElement* pSub = pFlatModelicaXMLDoc->createElement(X("sub")); + + pSub->setAttribute(X("sline"), X(itoa(sub->getLine(),stmp,10))); + pSub->setAttribute(X("scolumn"), X(itoa(sub->getColumn(),stmp,10))); + + pSub->setAttribute(X("operation"), X("binary")); + pSub->appendChild(e1); + pSub->appendChild(e2); + ast = pSub; + } + ) + ; + +unary_arithmetic_expression returns [DOMElement* ast] + : + (#(add:UNARY_PLUS ast = term) + { + DOMElement* pAdd = pFlatModelicaXMLDoc->createElement(X("add")); + + pAdd->setAttribute(X("sline"), X(itoa(add->getLine(),stmp,10))); + pAdd->setAttribute(X("scolumn"), X(itoa(add->getColumn(),stmp,10))); + + pAdd->setAttribute(X("operation"), X("unary")); + pAdd->appendChild(ast); + ast = pAdd; + } + |#(sub:UNARY_MINUS ast = term) + { + DOMElement* pSub = pFlatModelicaXMLDoc->createElement(X("sub")); + + pSub->setAttribute(X("sline"), X(itoa(sub->getLine(),stmp,10))); + pSub->setAttribute(X("scolumn"), X(itoa(sub->getColumn(),stmp,10))); + + pSub->setAttribute(X("operation"), X("unary")); + pSub->appendChild(ast); + ast = pSub; + } + | ast = term + ) + ; + +term returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = factor + |#(mul:STAR e1 = term e2 = factor) + { + DOMElement* pMul = pFlatModelicaXMLDoc->createElement(X("mul")); + + pMul->setAttribute(X("sline"), X(itoa(mul->getLine(),stmp,10))); + pMul->setAttribute(X("scolumn"), X(itoa(mul->getColumn(),stmp,10))); + + pMul->appendChild(e1); + pMul->appendChild(e2); + ast = pMul; + } + |#(div:SLASH e1 = term e2 = factor) + { + DOMElement* pDiv = pFlatModelicaXMLDoc->createElement(X("div")); + + pDiv->setAttribute(X("sline"), X(itoa(div->getLine(),stmp,10))); + pDiv->setAttribute(X("scolumn"), X(itoa(div->getColumn(),stmp,10))); + + pDiv->appendChild(e1); + pDiv->appendChild(e2); + ast = pDiv; + } + ) + ; + +factor returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = primary + |#(pw:POWER e1 = primary e2 = primary) + { + DOMElement* pPow = pFlatModelicaXMLDoc->createElement(X("pow")); + + pPow->setAttribute(X("sline"), X(itoa(pw->getLine(),stmp,10))); + pPow->setAttribute(X("scolumn"), X(itoa(pw->getColumn(),stmp,10))); + + pPow->appendChild(e1); + pPow->appendChild(e2); + ast = pPow; + } + ) + ; + +primary returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + DOMElement* pSemicolon = pFlatModelicaXMLDoc->createElement(X("semicolon")); +} + : + ( ui:UNSIGNED_INTEGER + { + DOMElement* pIntegerLiteral = pFlatModelicaXMLDoc->createElement(X("integer_literal")); + pIntegerLiteral->setAttribute(X("value"), str2xml(ui)); + + pIntegerLiteral->setAttribute(X("sline"), X(itoa(ui->getLine(),stmp,10))); + pIntegerLiteral->setAttribute(X("scolumn"), X(itoa(ui->getColumn(),stmp,10))); + + ast = pIntegerLiteral; + } + | ur:UNSIGNED_REAL + { + DOMElement* pRealLiteral = pFlatModelicaXMLDoc->createElement(X("real_literal")); + pRealLiteral->setAttribute(X("value"), str2xml(ur)); + + pRealLiteral->setAttribute(X("sline"), X(itoa(ur->getLine(),stmp,10))); + pRealLiteral->setAttribute(X("scolumn"), X(itoa(ur->getColumn(),stmp,10))); + + ast = pRealLiteral; + } + | str:STRING + { + DOMElement* pStringLiteral = pFlatModelicaXMLDoc->createElement(X("string_literal")); + pStringLiteral->setAttribute(X("value"), str2xml(str)); + + pStringLiteral->setAttribute(X("sline"), X(itoa(str->getLine(),stmp,10))); + pStringLiteral->setAttribute(X("scolumn"), X(itoa(str->getColumn(),stmp,10))); + + ast = pStringLiteral; + } + | f:FALSE + { + DOMElement* pBoolLiteral = pFlatModelicaXMLDoc->createElement(X("bool_literal")); + pBoolLiteral->setAttribute(X("value"), X("false")); + + pBoolLiteral->setAttribute(X("sline"), X(itoa(f->getLine(),stmp,10))); + pBoolLiteral->setAttribute(X("scolumn"), X(itoa(f->getColumn(),stmp,10))); + + ast = pBoolLiteral; + } + | t:TRUE + { + DOMElement* pBoolLiteral = pFlatModelicaXMLDoc->createElement(X("bool_literal")); + pBoolLiteral->setAttribute(X("value"), X("true")); + + pBoolLiteral->setAttribute(X("sline"), X(itoa(t->getLine(),stmp,10))); + pBoolLiteral->setAttribute(X("scolumn"), X(itoa(t->getColumn(),stmp,10))); + + ast = pBoolLiteral; + } + | ast = component_reference__function_call + | #(LPAR ast = tuple_expression_list) + | #(lbk:LBRACK e = expression_list { el_stack.push(e); } + (e = expression_list { el_stack.push(e); } )* ) + { + DOMElement* pConcat = pFlatModelicaXMLDoc->createElement(X("concat")); + + pConcat->setAttribute(X("sline"), X(itoa(lbk->getLine(),stmp,10))); + pConcat->setAttribute(X("scolumn"), X(itoa(lbk->getColumn(),stmp,10))); + + pConcat = (DOMElement*)appendKids(el_stack, pConcat); + ast = pConcat; + } + | #(lbr:LBRACE ast = function_arguments) + { + DOMElement* pArray = pFlatModelicaXMLDoc->createElement(X("array")); + + pArray->setAttribute(X("sline"), X(itoa(lbr->getLine(),stmp,10))); + pArray->setAttribute(X("scolumn"), X(itoa(lbr->getColumn(),stmp,10))); + + pArray->appendChild(ast); + ast = pArray; + } + | tend:END + { + DOMElement* pEnd = pFlatModelicaXMLDoc->createElement(X("end")); + pEnd->setAttribute(X("sline"), X(itoa(tend->getLine(),stmp,10))); + pEnd->setAttribute(X("scolumn"), X(itoa(tend->getColumn(),stmp,10))); + ast = pEnd; + } + ) + ; + +component_reference__function_call returns [DOMElement* ast] +{ + DOMElement* cref; + DOMElement* fnc = 0; +} + : + (#(fc:FUNCTION_CALL cref = component_reference (fnc = function_call)?) + { + DOMElement* pCall = pFlatModelicaXMLDoc->createElement(X("call")); + + pCall->setAttribute(X("sline"), X(itoa(fc->getLine(),stmp,10))); + pCall->setAttribute(X("scolumn"), X(itoa(fc->getColumn(),stmp,10))); + + pCall->appendChild(cref); + if (fnc) pCall->appendChild(fnc); + ast = pCall; + } + | cref = component_reference + { + if (fnc && cref) cref->appendChild(fnc); + ast = cref; + } + ) + | + #(ifc:INITIAL_FUNCTION_CALL i:INITIAL ) + { + // calling function initial + DOMElement* pCall = pFlatModelicaXMLDoc->createElement(X("call")); + + DOMElement* pCref = pFlatModelicaXMLDoc->createElement(X("component_reference")); + pCref->setAttribute(X("ident"), X("initial")); + pCref->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pCall->appendChild(pCref); + + pCall->setAttribute(X("sline"), X(itoa(ifc->getLine(),stmp,10))); + pCall->setAttribute(X("scolumn"), X(itoa(ifc->getColumn(),stmp,10))); + + ast = pCall; + } + ; + +name_path returns [void *ast] +{ + void *s1=0; + void *s2=0; +} + : + i:IDENT + { + ast = (void*)new mstring(i->getText()); + } + |#(d:DOT i2:IDENT s2 = name_path) + { + s1 = (void*)new mstring(i2->getText()); + ast = (void*)new mstring(mstring(((mstring*)s1)->c_str())+mstring(".")+mstring(((mstring*)s2)->c_str())); + } + ; + +component_reference returns [DOMElement* ast] +{ + DOMElement* arr = 0; + DOMElement* id = 0; +} + : + (#(i:IDENT (arr = array_subscripts[0])?) + { + DOMElement *pCref = pFlatModelicaXMLDoc->createElement(X("component_reference")); + + pCref->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pCref->setAttribute(X("ident"), str2xml(i)); + if (arr) pCref->appendChild(arr); + ast = pCref; + } + |#(DOT #(i2:IDENT (arr = array_subscripts[0])?) + ast = component_reference) + { + DOMElement *pCref = pFlatModelicaXMLDoc->createElement(X("component_reference")); + pCref->setAttribute(X("ident"), str2xml(i2)); + + pCref->setAttribute(X("sline"), X(itoa(i2->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i2->getColumn(),stmp,10))); + + if (arr) pCref->appendChild(arr); + pCref->appendChild(ast); + ast = pCref; + } + ) + ; + +function_call returns [DOMElement* ast] + : + #(fa:FUNCTION_ARGUMENTS ast = function_arguments + { + ast->setAttribute(X("sline"), X(itoa(fa->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(fa->getColumn(),stmp,10))); + } + ) + ; + + + +expression_list2[DOMElement *parent] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; +} + : + (#(el:EXPRESSION_LIST + e = expression { parent->appendChild(e); } + (e = expression { parent->appendChild(e); } )* + ) + ) + { + ast = parent; + } + ; + + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##function_arguments +*/ + +function_arguments returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* elist=0; + DOMElement* namel=0; + DOMElement *pFunctionArguments = pFlatModelicaXMLDoc->createElement(X("function_arguments")); +} + : + (pFunctionArguments = expression_list2[pFunctionArguments])? + (pFunctionArguments = named_arguments[pFunctionArguments])? + { + ast = pFunctionArguments; + } + ; +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##named_arguments +*/ + +named_arguments[DOMElement *parent] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* n; +} + : + #(na:NAMED_ARGUMENTS (n = named_argument { parent->appendChild(n); }) + (n = named_argument { parent->appendChild(n); } )*) + { + ast = parent; + } + ; + +named_argument returns [DOMElement* ast] +{ + DOMElement* temp; +} + : + #(eq:EQUALS i:IDENT temp = expression) + { + DOMElement *pNamedArgument = pFlatModelicaXMLDoc->createElement(X("named_argument")); + pNamedArgument->setAttribute(X("ident"), str2xml(i)); + + pNamedArgument->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pNamedArgument->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pNamedArgument->appendChild(temp); + ast = pNamedArgument; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##expression_list +*/ + +expression_list returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + //DOMElement* pComma = pFlatModelicaXMLDoc->createElement(X("comma")); +} + : + (#(el:EXPRESSION_LIST + e = expression { el_stack.push(e); } + (e = expression { el_stack.push(pFlatModelicaXMLDoc->createElement(X("comma"))); el_stack.push(e); } )* + ) + ) + { + ast = (DOMElement*)stack2DOMNode(el_stack, "expression_list"); + + ast->setAttribute(X("sline"), X(itoa(el->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(el->getColumn(),stmp,10))); + } + ; + +tuple_expression_list returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + //DOMElement* pComma = pFlatModelicaXMLDoc->createElement(X("comma")); +} + : + (#(el:EXPRESSION_LIST + e = expression { el_stack.push(e); } + (e = expression { el_stack.push(pFlatModelicaXMLDoc->createElement(X("comma"))); el_stack.push(e); } )* + ) + ) + { + if (el_stack.size() == 1) + { + ast = el_stack.top(); + } + else + { + DOMElement *pTuple = pFlatModelicaXMLDoc->createElement(X("output_expression_list")); + pTuple = (DOMElement*)appendKids(el_stack, pTuple); + + pTuple->setAttribute(X("sline"), X(itoa(el->getLine(),stmp,10))); + pTuple->setAttribute(X("scolumn"), X(itoa(el->getColumn(),stmp,10))); + + ast = pTuple; + } + } + ; + +array_subscripts[int kind] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* s = 0; + DOMElement *pArraySubscripts = 0; + if (kind) + pArraySubscripts = pFlatModelicaXMLDoc->createElement(X("type_array_subscripts")); + else + pArraySubscripts = pFlatModelicaXMLDoc->createElement(X("array_subscripts")); +} + : + #(lbk:LBRACK pArraySubscripts = subscript[pArraySubscripts] + (pArraySubscripts = subscript[pArraySubscripts])*) + { + + pArraySubscripts->setAttribute(X("sline"), X(itoa(lbk->getLine(),stmp,10))); + pArraySubscripts->setAttribute(X("scolumn"), X(itoa(lbk->getColumn(),stmp,10))); + + ast = pArraySubscripts; + } + ; + +subscript[DOMElement* parent] returns [DOMElement* ast] +{ + DOMElement* e; + DOMElement* pColon = pFlatModelicaXMLDoc->createElement(X("colon")); +} + : + ( + e = expression + { + parent->appendChild(e); + ast = parent; + } + | c:COLON + { + + pColon->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pColon->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + + parent->appendChild(pColon); + ast = parent; + } + ) + ; + +comment returns [DOMElement* ast] +{ + DOMElement* ann=0; + DOMElement* cmt=0; + ast = 0; + DOMElement *pComment = pFlatModelicaXMLDoc->createElement(X("comment")); + bool bAnno = false; +} : +#(c:COMMENT cmt=string_comment { if (cmt) pComment->appendChild(cmt); } +(pComment = annotation [0 /* none */, pComment, INSIDE_COMMENT] { bAnno = true; })?) + { + if (c) + { + pComment->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pComment->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + } + if ((cmt !=0) || bAnno) ast = pComment; + else ast = 0; + } + ; + +string_comment returns [DOMElement* ast] : + { + DOMElement* cmt=0; + ast = 0; + } + #(sc:STRING_COMMENT cmt=string_concatenation) + { + DOMElement *pStringComment = pFlatModelicaXMLDoc->createElement(X("string_comment")); + + pStringComment->setAttribute(X("sline"), X(itoa(sc->getLine(),stmp,10))); + pStringComment->setAttribute(X("scolumn"), X(itoa(sc->getColumn(),stmp,10))); + + pStringComment->appendChild(cmt); + ast = pStringComment; + } + | + { + ast = 0; + } + ; + +string_concatenation returns [DOMElement* ast] + { + DOMElement*pString1; + l_stack el_stack; + } +: + s:STRING + { + DOMElement *pString = pFlatModelicaXMLDoc->createElement(X("string_literal")); + pString->setAttribute(X("value"), str2xml(s)); + + pString->setAttribute(X("sline"), X(itoa(s->getLine(),stmp,10))); + pString->setAttribute(X("scolumn"), X(itoa(s->getColumn(),stmp,10))); + + ast=pString; + } + |#(p:PLUS pString1=string_concatenation s2:STRING) + { + DOMElement *pString = pFlatModelicaXMLDoc->createElement(X("add_string")); + + pString->setAttribute(X("sline"), X(itoa(p->getLine(),stmp,10))); + pString->setAttribute(X("scolumn"), X(itoa(p->getColumn(),stmp,10))); + + pString->appendChild(pString1); + DOMElement *pString2 = pFlatModelicaXMLDoc->createElement(X("string_literal")); + pString2->setAttribute(X("value"), str2xml(s2)); + + pString2->setAttribute(X("sline"), X(itoa(s2->getLine(),stmp,10))); + pString2->setAttribute(X("scolumn"), X(itoa(s2->getColumn(),stmp,10))); + + pString->appendChild(pString2); + ast=pString; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##annotation +*/ + +annotation[int iSwitch, DOMElement *parent, enum anno awhere] returns [DOMElement* ast] +{ + void* cmod=0; +} + : + #(a:ANNOTATION cmod = class_modification) + { + DOMElement *pAnnotation = pFlatModelicaXMLDoc->createElement(X("annotation")); + + pAnnotation->setAttribute(X("sline"), X(itoa(a->getLine(),stmp,10))); + pAnnotation->setAttribute(X("scolumn"), X(itoa(a->getColumn(),stmp,10))); + + switch (awhere) + { + case INSIDE_ELEMENT: + pAnnotation->setAttribute(X("inside"), X("element")); + break; + case INSIDE_EQUATION: + pAnnotation->setAttribute(X("inside"), X("equation")); + break; + case INSIDE_ALGORITHM: + pAnnotation->setAttribute(X("inside"), X("algorithm")); + break; + case INSIDE_COMMENT: + pAnnotation->setAttribute(X("inside"), X("comment")); + break; + default: + //pAnnotation->setAttribute(X("inside"), X("unspecified")); + ; + } + setVisibility(iSwitch, pAnnotation); + if (cmod) pAnnotation = (DOMElement*)appendKidsFromStack((l_stack *)cmod, pAnnotation); + parent->appendChild(pAnnotation); + ast = parent; + } + ; + + +interactive_stmt returns [DOMElement* ast] +{ + DOMElement* al=0; + DOMElement* el=0; + l_stack el_stack; + DOMElement *pInteractiveSTMT = pFlatModelicaXMLDoc->createElement(X("ISTMT")); + DOMElement *pInteractiveALG = pFlatModelicaXMLDoc->createElement(X("IALG")); +} + : + ( + #(INTERACTIVE_ALG (pInteractiveALG = algorithm[pInteractiveALG]) ) + { + //pInteractiveALG->appendChild(al); + el_stack.push(pInteractiveALG); + } + | + #(INTERACTIVE_EXP (el = expression )) + { + DOMElement *pInteractiveEXP = pFlatModelicaXMLDoc->createElement(X("IEXP")); + pInteractiveEXP->appendChild(el); + el_stack.push(pInteractiveEXP); + } + + )* (s:SEMICOLON)? + { + pInteractiveSTMT = (DOMElement*)appendKids(el_stack, pInteractiveSTMT); + if (s) pInteractiveSTMT->setAttribute(X("semicolon"),X("true")); + ast = pInteractiveSTMT; + } + ; diff --git a/tools/xml/modelicaxml/Makefile b/tools/xml/modelicaxml/Makefile new file mode 100644 index 00000000000..c164d0ef126 --- /dev/null +++ b/tools/xml/modelicaxml/Makefile @@ -0,0 +1,55 @@ +CC=gcc +CXX=g++ + +ANTLR_HOME = "./antlr-2.7.2/lib/cpp/" + +ANTLR_INCP = -I"./antlr-2.7.2/lib/cpp" +ANTLR_LIBP = -L"./lib":"./xercesc/lib/" + +PARSE_INCP = -I"./":"./xercesc/include" +PARSE_LIBP = -L./ + +INCP = $(ANTLR_INCP) $(PARSE_INCP) +LIBP = $(ANTLR_LIBP) $(PARSE_LIBP) + +CFLAGS = $(INCP) -g -Wall -DDEBUG -fpic -w -O -DAPP_NO_THREADS -DXML_USE_NO_THREADS +CXXFLAGS = $(CFLAGS) +LINKFLAGS = $(LIBP) + +LIBS = -lantlr -lmodelica_parser -lxerces-c + +PARSER_OBJS = modelica_parser.o modelica_lexer.o token_names.o parse_tree_dumper.o + +walkergen= modelica_tree_parser.cpp modelica_tree_parser.hpp \ + modelica_tree_parserTokenTypes.hpp modelica_tree_parserTokenTypes.txt + +walkersrcs=$(filter %.cpp,$(walkergen)) +walkerobjs=$(walkersrcs:.cpp=.o) + +OBJS += $(walkerobjs) walker.o $(PARSER_OBJS) + +ANTLR = java -cp $(ANTLR_HOME) antlr.Tool + +all : parser walker + +parser: + $(MAKE) -f Makefile_parser + +walker : $(OBJS) + $(CXX) -o modelicaxml $(OBJS) $(LINKFLAGS) $(LIBS) + +$(walkergen): walker.g modelica_parserTokenTypes.txt + java antlr.Tool $(ANTLRFLAGS) $< + + +clean: + rm -f modelicaxml modelicaxml.exe *.o *.obj *~ core *.core + +reallyclean: clean + rm -f $(walkergen) modelica_parserTokenTypes.txt + $(MAKE) -f Makefile_parser reallyclean + + +walker.o : walker.cpp modelica_lexer.hpp modelica_parser.hpp + + diff --git a/tools/xml/modelicaxml/Makefile_parser b/tools/xml/modelicaxml/Makefile_parser new file mode 100644 index 00000000000..aec7d3400ad --- /dev/null +++ b/tools/xml/modelicaxml/Makefile_parser @@ -0,0 +1,65 @@ +CC=gcc +CXX=g++ +AR=ar -r + +ANTLR_HOME="./antlr-2.7.2/lib/cpp" + +INCLUDES=-I"./antlr-2.7.2/lib/cpp" + +LIBP=-L"./lib/" + +CFLAGS =-g -Wall $(INCLUDES) -D DEBUG +CXXFLAGS = $(CFLAGS) + +ANTLRFLAGS=-traceTreeParser + +LIB = $(LIBP) -lantlr + + +lexergen= modelica_lexer.cpp modelica_lexer.hpp \ + modelicaTokenTypes.hpp modelicaTokenTypes.txt + +parsergen= modelica_parser.cpp modelica_parser.hpp \ + modelica_parserTokenTypes.hpp modelica_parserTokenTypes.txt + +lexersrcs=$(filter %.cpp,$(lexergen)) +parsersrcs=$(filter %.cpp,$(parsergen)) + +lexerobjs=$(lexersrcs:.cpp=.o) +parserobjs=$(parsersrcs:.cpp=.o) + +helperobjs = token_names.o parse_tree_dumper.o + +OBJS += $(lexerobjs) $(parserobjs) $(helperobjs) + +all: libmodelica_parser.a + +libmodelica_parser.a: $(OBJS) + $(AR) $@ $(OBJS) + +$(lexergen): modelica_lexer.g + java antlr.Tool $(ANTLRFLAGS) $< + +$(parsergen): modelica_parser.g modelica_lexer.g + java antlr.Tool $(ANTLRFLAGS) $< + +.c.o: + $(CC) $(CFLAGS) -c $< + +.cpp.o: + $(CXX) $(CXXFLAGS) -c $< + +depend: $(DFILES) + +clean: + -rm -f *.o *~ core *.core libmodelica_parser.a + +reallyclean: clean + -rm -f $(lexergen) $(parsergen) + +modelica_lexer.o:modelica_lexer.cpp modelica_lexer.hpp +modelica_parser.o:modelica_parser.cpp modelica_parser.hpp +token_names.o:token_names.cpp +parse_tree_dumper.o:parse_tree_dumper.cpp parse_tree_dumper.hpp +#include $(DFILES) + diff --git a/tools/xml/modelicaxml/ModelicaXML.cpp b/tools/xml/modelicaxml/ModelicaXML.cpp new file mode 100644 index 00000000000..62cfbaeff55 --- /dev/null +++ b/tools/xml/modelicaxml/ModelicaXML.cpp @@ -0,0 +1,487 @@ +/* Copyright (c)2005 Linköping University Sweden, All Rights Reserved +/* Programming Environments Laboratory +******************************************************************************* + File : "modelicaXML.cpp" + Author : Adrian Pop 2003-10-25 + Description : Antlr Parser caller and XML serializer +------------------------------------------------------------------------------- + Source: + Revision: + Author: Adrian Pop + Date: 2004-05-12 + modification: 2004-11-01 - added directory walking, ModelicaXML class + modification: 2006-03-12 - updated to Modelica 2.2 and better command line parameters +******************************************************************************* +*/ + + +//** HEADERS ************************************************************ + +// standard include files +#include +#include +#include +#include + +// ModelicaParser related include file +// the following header files are automatically generated by the antlr parser (Do not modify them) +#include "Modelica_Lexer.hpp" +#include "Modelica_Parser.hpp" +#include "Modelica_Tree_Parser.hpp" +#include "Modelica_ParserTokenTypes.hpp" +#include "Modelica_Tree_ParserTokenTypes.hpp" +#include "parse_tree_dumper.hpp" + +// antlr related include files +#include "antlr/AST.hpp" +#include "antlr/CommonAST.hpp" +#include "antlr/ASTFactory.hpp" +#include "MyAST.h" +#include "dirwalk.h" + +using namespace std; + +#define modelicaDTDUrl "http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.dtd" + +class ModelicaXML +{ + typedef std::string mstring; +private: + /* some xml helpers declarations */ + mstring *dtdUrl; + DOMImplementation* pDOMImpl; + DOMDocumentType* pDoctype; + DOMDocument* pModelicaXMLDoc; + DOMElement* pRootElementModelica; + DOMWriter* domWriter; + int serializeXMLDocumentToFile(mstring xmlFileName); + DOMElement* createModelicaXMLDOMElement(const char *fileName); + l_list &sortMoFiles(l_list &fileList); + +public: + // constructor + ModelicaXML(char* dtdURL); + // destructor + ~ModelicaXML(); + void usageModelicaXML(); + int serializeMoFileToXML(char* fileName); + int serializeEachMoFileInDirectory(char *directoryName); + int serializeAllMoFilesInDirectoryInXMLFile(char *directoryName, char *fileName); +}; + +void usageModelicaXML(void) +{ + cout << "Usage:" << "ModelicaXML [-dtd dtdURL] [-f file1.mo file2.mo ... fileN.mo]" + << "[-d directory] [-o file]" << endl; + cout << "-dtd dtdURL\n\t sets the dtdURL as the dtd for the xml file:" + << "c:\\path\\to\\modelica.dtd OR http://host.to/modelica.dtd" + << "\n\t if none given, we use the default: " << modelicaDTDUrl << endl; + cout << "-f file1.mo file2.mo ... fileN.mo\n\t transforms the file1-N.mo into xml version of " + << "the files, named file1-N.mo.xml" << endl; + cout << "-d directory\n\t transforms each file.mo files from the directory" + << "\n\t AND subdirectories into xml version of files, named file.mo.xml" << endl; + cout << "-d directory -o outputFile\n\t transforms ALL file.mo files from the directory" + << "\n\t AND subdirectories one big xml file called directory\\file.xml" << endl; +} + +//----------------------------------------------------------------------------- +// func : main function for the modelica XML serializer +// author : Adrian Pop 2003-10-25 +// organization : Linköping University Sweden, Programming Environment Laboratory +//----------------------------------------------------------------------------- +// the function accept as argument a flattened modelica file ad will generate as output the corresponding C files +// for the Modelica Simulator +int main( int argc, char* argv[] ) +{ + // check if the modelica file is present in the argument list + if (argc < 2) + { + return usageModelicaXML(); + } + + if (strcmp(argv[1],"--help") == 0) + { + return usageModelicaXML(); + } + + list argvList; + cout << "Calling: " << argv[0] << " with arguments:\n\t "; + for (int i = 1; i < argc; i++) + { + cout << argv[i] << " "; + argvList.push_back(new string(argv[i])); + } + cout << endl << endl; + + list filesToConvert; + string* directoryToConvert = NULL; + string* serializedFile = NULL; + string* dtdUrl = NULL; + string* front = NULL; + while (true) + { + if (!argvList.size()) break; + front = argvList.front(); + argvList.pop_front(); + if (*front == "-f") + { + string* file = NULL; + while (true) + { + if (!argvList.size()) break; + file = argvList.front(); + if (!file) + { + if (filesToConvert.size() == 0) return usageModelicaXML(); + break; + } + if (*file == "-f" || *file == "--help" || + *file == "-d" || *file == "-dtd" || + *file == "-o") + { + if (filesToConvert.size() == 0) return usageModelicaXML(); + break; + } + argvList.pop_front(); + filesToConvert.push_back(file); + } + } + else + if (*front == "-d") + { + if (!argvList.size()) break; + string *directory = argvList.front(); + if (!directory || /* if is empty or if is command line parameter */ + (directory && (*directory == "-f" || *directory == "--help" || + *directory == "-d" || *directory == "-dtd" || + *directory == "-o"))) return usageModelicaXML(); + /* else just collect the directory to convert */ + directoryToConvert = directory; + argvList.pop_front(); + } + else + if (*front == "-dtd") + { + if (!argvList.size()) break; + string *url = argvList.front(); + if (!url || /* if is empty or if is command line parameter */ + (url && (*url == "-f" || *url == "--help" || + *url == "-d" || *url == "-dtd" || + *url == "-o"))) return usageModelicaXML(); + /* else just collect the dtd url */ + dtdUrl = url; + argvList.pop_front(); + } + else + if (*front == "--help") return usageModelicaXML(); + else + if (*front == "-o") + { + if (!argvList.size()) break; + string *f = argvList.front(); + if (!f || /* if is empty or if is command line parameter */ + (f && (*f == "-f" || *f == "--help" || + *f == "-d" || *f == "-dtd" || + *f == "-o"))) return usageModelicaXML(); + /* else just collect the output file */ + serializedFile = f; + argvList.pop_front(); + } + else return usageModelicaXML(); + } + /* see what we have */ + ModelicaXML* pModelicaXML = NULL; + if (dtdUrl) pModelicaXML = new ModelicaXML((char*)dtdUrl->c_str()); + else pModelicaXML = new ModelicaXML(NULL); + + bool somethingToDo = false; + + try + { + for (unsigned int i = 0; i < filesToConvert.size(); i++) + { + pModelicaXML->serializeMoFileToXML((char*)filesToConvert.front()->c_str()); + filesToConvert.pop_front(); + somethingToDo = true; + } + if (!serializedFile && directoryToConvert) + { + pModelicaXML->serializeEachMoFileInDirectory((char*)directoryToConvert->c_str()); + somethingToDo = true; + } + if (serializedFile && directoryToConvert) + { + pModelicaXML->serializeAllMoFilesInDirectoryInXMLFile( + (char*)directoryToConvert->c_str(), + (char*)serializedFile->c_str()); + somethingToDo = true; + } + if (!somethingToDo) usageModelicaXML(); + } + catch(XMLException& e) + { + std::cerr << "XMLException: " << XMLString::transcode(e.getMessage()) << std::endl; exit (1); + } + catch(DOMException& e) + { + std::cerr << "DOMException: Code: " << e.code << " Msg: " << e.msg << std::endl; exit (1); + } + catch(std::exception& e) + { + std::cerr << "STDException: " << e.what() << std::endl; exit (1); + } + return 0; +} + +ModelicaXML::ModelicaXML(char* dtdURL) +{ + // initialize xml framework + XMLPlatformUtils::Initialize(); + + // XML DOM creation + pDOMImpl = DOMImplementationRegistry::getDOMImplementation(X("Core")); + + // create the document type (according to modelica.dtd) + pDoctype = + pDOMImpl->createDocumentType( + X("modelica"), + NULL, + (dtdURL) ? X(string(dtdURL).c_str()) : X(string(modelicaDTDUrl).c_str())); + + // create the root element + pModelicaXMLDoc = pDOMImpl->createDocument( + 0, // root element namespace URI. + X("modelica"), // root element name + pDoctype); // document type object (DTD). + + pRootElementModelica = pModelicaXMLDoc->getDocumentElement(); + + // create the writer + domWriter = pDOMImpl->createDOMWriter(); + // set the pretty print feature + + if (domWriter->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) + domWriter->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true); +} + +ModelicaXML::~ModelicaXML() +{ + domWriter->release(); + // release the document + pModelicaXMLDoc->release(); + // terminate the XML framework + XMLPlatformUtils::Terminate(); +} + + +int ModelicaXML::serializeEachMoFileInDirectory(char *directoryName) +{ + typedef std::string mstring; + mstring filename; + l_list dirList; + getDirectoryStructure(directoryName, dirList); + std::list::const_iterator it; + for(it=dirList.begin(); it!=dirList.end(); ++it) + { + l_list fileList; + getFileList(*it, fileList, "*.mo"); + if (fileList.size()) fileList = sortMoFiles(fileList); + cout << "Found: " << fileList.size() << " *.mo files in directory: " << *it << endl; + if (!fileList.size()) { continue; } + std::list::const_iterator itFileList; + for(itFileList=fileList.begin(); itFileList!=fileList.end(); ++itFileList) + { + filename = mstring(*it) + "\\" + mstring(*itFileList); + DOMElement* pModelicaXML = createModelicaXMLDOMElement(filename.c_str()); + cout << " [" << *itFileList << "]"; + // if is not NULL append it to the element + if (pModelicaXML) pRootElementModelica->appendChild(pModelicaXML); + // vomit the current XML Document to file + std::string xmlFile(filename.c_str()); + xmlFile += ".xml"; + serializeXMLDocumentToFile(xmlFile); + if (pModelicaXML) pRootElementModelica->removeChild(pModelicaXML); + } + if (fileList.size()) cout << endl; + } + return 0; +} + +int ModelicaXML::serializeAllMoFilesInDirectoryInXMLFile(char *directoryName, char *xmlFileName) +{ + int i=0; + typedef std::string mstring; + mstring filename; + l_list dirList; + getDirectoryStructure(directoryName, dirList); + std::list::const_iterator it; + for(it=dirList.begin(); it!=dirList.end(); ++it) + { + l_list fileList; + getFileList(*it, fileList, "*.mo"); + // take care of pakage.mo first + fileList = sortMoFiles(fileList); + cout << "Found: " << fileList.size() << " *.mo files in directory: " << *it << endl; + std::list::const_iterator itFileList; + for(itFileList=fileList.begin(); itFileList!=fileList.end(); ++itFileList) + { + filename = mstring(*it) + "\\" + mstring(*itFileList); + cout << " [" << *itFileList << "]"; + DOMElement* pModelicaXML = createModelicaXMLDOMElement(filename.c_str()); + // if is not NULL append it to the element + if (pModelicaXML) + { + pRootElementModelica->appendChild(pModelicaXML); + i++; + } + } + if (fileList.size()) cout << endl; + } + // vomit the current XML Document to file + std::string xmlFile(xmlFileName); + xmlFile = mstring(directoryName) + mstring("\\") + xmlFile; + xmlFile += ".xml"; + serializeXMLDocumentToFile(xmlFile); + cout << "Found: " << i << " .mo files" << endl; + cout << "Serialized to: " << xmlFile << endl; + return 0; +} + +DOMElement* ModelicaXML::createModelicaXMLDOMElement(const char* fileName) +{ + ifstream file; + //ofstream wfile; + + //open the file passed as an argument + file.open(fileName); + + DOMElement* pRootElementModelicaXML = NULL; + + //if the file cannot be opened + if (!file) + { + cerr << "Could not open file: " << fileName << "\n"; + return NULL; + } + + try + { + antlr::ASTFactory my_factory("MyAST", MyAST::factory); + modelica_lexer lexer(file); + lexer.setFilename(fileName); + modelica_parser parser(lexer); + parser.initializeASTFactory(my_factory); + parser.setASTFactory(&my_factory); + parser.stored_definition(); + //wfile.open("output.txt"); + //wfile << parser.getAST()->toStringList() << std::endl; + antlr::RefAST ast = parser.getAST(); + //parse_tree_dumper dumper(std::cout); + //std::cout << std::flush; + if (ast) + { + //dumper.dump(ast); + modelica_tree_parser walker; + walker.initializeASTFactory(my_factory); + walker.setASTFactory(&my_factory); + pRootElementModelicaXML = walker.stored_definition(RefMyAST(ast), fileName, pModelicaXMLDoc); + } + else + { + //wfile << std::endl << "Parse error: AST\n"; + std::cerr << std::endl << "Parse error: AST\n"; + file.close(); + return NULL; + } + } + catch(antlr::ANTLRException& e) + { + std::cerr << "Parser/Lexer/Walker Exception: " << e.toString() << std::endl; + file.close(); + std::cerr << "ERROR! File:" << fileName << std::endl; + return NULL; + } + catch(std::exception& e) + { + std::cerr << "STDException: " << e.what() << std::endl; + file.close(); + std::cerr << "ERROR! File:" << fileName << std::endl; + return NULL; + } + file.close(); + //std::cout << "SUCCESS! File:" << fileName << std::endl; + //wfile << std::endl << "SUCCESS! File:" << fileName << std::endl; + //wfile.close(); + return pRootElementModelicaXML; +} + +int ModelicaXML::serializeXMLDocumentToFile(mstring xmlFileName) +{ + // fix the file + XMLFormatTarget *myFormatTarget = new LocalFileFormatTarget(X(xmlFileName.c_str())); + //XMLFormatTarget *myOutFormatTarget = new StdOutFormatTarget; + + // serialize a DOMNode to the local file " + domWriter->writeNode(myFormatTarget, *pModelicaXMLDoc); + //domWriter->writeNode(myOutFormatTarget, *pModelicaXMLDoc); + + myFormatTarget->flush(); + //myOutFormatTarget->flush(); + + delete myFormatTarget; + // delete myOutFormatTarget; + return 0; +} + +int ModelicaXML::serializeMoFileToXML(char* fileName) +{ + // ModelicaXML filename (normal operation) + DOMElement *pModelicaXMLElement = createModelicaXMLDOMElement(fileName); + if (pModelicaXMLElement) pRootElementModelica->appendChild(pModelicaXMLElement); + // vomit the current XML Document to file + std::string xmlFile(fileName); + xmlFile += ".xml"; + serializeXMLDocumentToFile(xmlFile); + + unsigned int elementCount = pModelicaXMLDoc->getElementsByTagName(X("*"))->getLength(); + std::cout << std::endl; + std::cout << "The tree serialized contains: " << elementCount << " elements." << std::endl; + + return 0; +} + + +l_list &ModelicaXML::sortMoFiles(l_list &fileList) +{ + bool bPackageExists = false; + bool bExampleExists = false; + mstring filename; + mstring str_package("package.mo"); + mstring str_example("Examples.mo"); + std::list::iterator itFileList; + for(itFileList=fileList.begin(); itFileList!=fileList.end(); ++itFileList) + { + filename = mstring(*itFileList); + if (filename == str_package) + { + bPackageExists = true; + fileList.erase(itFileList); + itFileList=fileList.begin(); + } + if (filename == str_example) + { + bExampleExists = true; + fileList.erase(itFileList); + itFileList=fileList.begin(); + } + } + if (bPackageExists) + { + fileList.push_front("package.mo"); + } + if (bExampleExists) + { + fileList.push_back("Examples.mo"); + } + return fileList; +} diff --git a/tools/xml/modelicaxml/ModelicaXML.sln b/tools/xml/modelicaxml/ModelicaXML.sln new file mode 100644 index 00000000000..921da799969 --- /dev/null +++ b/tools/xml/modelicaxml/ModelicaXML.sln @@ -0,0 +1,29 @@ +Microsoft Visual Studio Solution File, Format Version 8.00 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ModelicaXML", "ModelicaXML.vcproj", "{57E77DDB-F6BC-4CE1-91E7-D669544DCFFC}" + ProjectSection(ProjectDependencies) = postProject + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FlatModelicaXML", "..\FlatModelicaXML\FlatModelicaXML.vcproj", "{29D27443-5B16-45C0-B46F-3551BC103922}" + ProjectSection(ProjectDependencies) = postProject + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + Debug = Debug + Release = Release + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {57E77DDB-F6BC-4CE1-91E7-D669544DCFFC}.Debug.ActiveCfg = Debug|Win32 + {57E77DDB-F6BC-4CE1-91E7-D669544DCFFC}.Debug.Build.0 = Debug|Win32 + {57E77DDB-F6BC-4CE1-91E7-D669544DCFFC}.Release.ActiveCfg = Release|Win32 + {57E77DDB-F6BC-4CE1-91E7-D669544DCFFC}.Release.Build.0 = Release|Win32 + {29D27443-5B16-45C0-B46F-3551BC103922}.Debug.ActiveCfg = Debug|Win32 + {29D27443-5B16-45C0-B46F-3551BC103922}.Debug.Build.0 = Debug|Win32 + {29D27443-5B16-45C0-B46F-3551BC103922}.Release.ActiveCfg = Release|Win32 + {29D27443-5B16-45C0-B46F-3551BC103922}.Release.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/tools/xml/modelicaxml/ModelicaXML.vcproj b/tools/xml/modelicaxml/ModelicaXML.vcproj new file mode 100644 index 00000000000..411293570f4 --- /dev/null +++ b/tools/xml/modelicaxml/ModelicaXML.vcproj @@ -0,0 +1,321 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tools/xml/modelicaxml/ModelicaXMLUtilities.cpp b/tools/xml/modelicaxml/ModelicaXMLUtilities.cpp new file mode 100644 index 00000000000..dbd64c21f54 --- /dev/null +++ b/tools/xml/modelicaxml/ModelicaXMLUtilities.cpp @@ -0,0 +1,49 @@ +#include "ModelicaXMLUtilities.hpp" + +indentation::indentation() : m_indent_next(false),m_space_before(false) +{ +} + +void indentation::push(int element) +{ + m_indent.push(element); +} + +int indentation::top() +{ + if (!m_indent.empty()) + return m_indent.top(); + else + return 0; +} + +void indentation::pop() +{ + if (m_indent.size() > 1) + m_indent.pop(); +} + +void indentation::indent_next(bool f) +{ + m_indent_next = f; +} + +bool indentation::indent_next() +{ + return m_indent_next; +} + +void indentation::init() +{ + m_indent.push(0); +} + +void indentation::space_before(bool f) +{ + m_space_before = f; +} + +bool indentation::spacebefore() +{ + return m_space_before; +} diff --git a/tools/xml/modelicaxml/ModelicaXMLUtilities.hpp b/tools/xml/modelicaxml/ModelicaXMLUtilities.hpp new file mode 100644 index 00000000000..5113cb68c64 --- /dev/null +++ b/tools/xml/modelicaxml/ModelicaXMLUtilities.hpp @@ -0,0 +1,32 @@ +#ifndef INDENTATION_HPP_ +#define INDENTATION_HPP_ + +#include +#include + +using namespace std ; + + +class indentation +{ +public: + indentation(); + + void push(int element); + int top(); + void pop(); + + void indent_next(bool f); + bool indent_next(); + void init(); + void space_before(bool f); + bool spacebefore(); + +private: + std::stack m_indent; + bool m_indent_next; + bool m_space_before; +}; + + +#endif diff --git a/tools/xml/modelicaxml/ModelicaXml.h b/tools/xml/modelicaxml/ModelicaXml.h new file mode 100644 index 00000000000..132968d3921 --- /dev/null +++ b/tools/xml/modelicaxml/ModelicaXml.h @@ -0,0 +1,67 @@ +/************************************************************************ +File: modelicaxml.h +Created By: Adrian Pop adrpo@ida.liu.se +Date: 2003-08-28 (PELAB Internal Conference) +Revised on 2003-10-26 17:58:42 +Comments: some includes for the xercesc parser and a xml helper class +************************************************************************/ + +#ifndef __MODELICAXML_H_ +#define __MODELICAXML_H_ + +// --------------------------------------------------------------------------- +// Includes +// --------------------------------------------------------------------------- +#include +#include +#include +#include +#include +#include +#include + +XERCES_CPP_NAMESPACE_USE + +// --------------------------------------------------------------------------- +// This is a simple class that lets us do easy (though not terribly efficient) +// trancoding of char* data to XMLCh data. +// --------------------------------------------------------------------------- +class XStr +{ +public : + // ----------------------------------------------------------------------- + // Constructors and Destructor + // ----------------------------------------------------------------------- + XStr(const char* const toTranscode) + { + // Call the private transcoding method + fUnicodeForm = XMLString::transcode(toTranscode); + } + + ~XStr() + { + XMLString::release(&fUnicodeForm); + } + + + // ----------------------------------------------------------------------- + // Getter methods + // ----------------------------------------------------------------------- + const XMLCh* unicodeForm() const + { + return fUnicodeForm; + } + +private : + // ----------------------------------------------------------------------- + // Private data members + // + // fUnicodeForm + // This is the Unicode XMLCh format of the string. + // ----------------------------------------------------------------------- + XMLCh* fUnicodeForm; +}; + +#define X(str) XStr(str).unicodeForm() + +#endif /* #ifndef _MODELICAXML_ */ \ No newline at end of file diff --git a/tools/xml/modelicaxml/MyAST.h b/tools/xml/modelicaxml/MyAST.h new file mode 100644 index 00000000000..b8b3a1b4f2a --- /dev/null +++ b/tools/xml/modelicaxml/MyAST.h @@ -0,0 +1,158 @@ +#ifndef __MY_AST_H__ +# define __MY_AST_H__ + +#include + +class MyAST; + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; + +/** Custom AST class that adds line numbers to the AST nodes. + * easily extended with columns. Filenames will take more work since + * you'll need a custom token class as well (one that contains the + * filename) + */ +class MyAST : public ANTLR_USE_NAMESPACE(antlr)CommonAST { +public: + // copy constructor + MyAST( const MyAST& other ) + : CommonAST(other) + , line(other.line), column(other.column), + endline(other.endline), + endcolumn(other.endcolumn) + { + } + // Default constructor + MyAST( void ) : CommonAST(), line(0), column(0), endline(0), endcolumn(0) {} + virtual ~MyAST( void ) {} + + // get the line number of the node (or try to derive it from the child node + virtual int getLine( void ) const + { + // most of the time the line number is not set if the node is a + // imaginary one. Usually this means it has a child. Refer to the + // child line number. Of course this could be extended a bit. + if ( line != 0 ) + return line; + if( getFirstChild() ) + return ( RefMyAST(getFirstChild())->getLine() ); + return 0; + } + + + virtual void setLine( int l ) + { + line = l; + } + + // get the line number of the node (or try to derive it from the child node + virtual int getColumn( void ) const + { + // most of the time the line number is not set if the node is a + // imaginary one. Usually this means it has a child. Refer to the + // child line number. Of course this could be extended a bit. + if ( column != 0 ) + return column; + if( getFirstChild() ) + return ( RefMyAST(getFirstChild())->getColumn() ); + return 0; + } + + virtual void setColumn( int c ) + { + column = c; + } + + /* Adrian Pop, 2006-02-13 added endline, endcolumn */ + + virtual int getEndLine( void ) const + { + // most of the time the line number is not set if the node is a + // imaginary one. Usually this means it has a child. Refer to the + // child line number. Of course this could be extended a bit. + if ( endline != 0 ) return endline; + if( getNextSibling() ) + { + return ( RefMyAST(getNextSibling())->getLine() ); + } + else if (getFirstChild()) return ( RefMyAST(getFirstChild())->getLine() ); + return 0; + } + + + virtual void setEndLine( int l ) + { + if (l != 0) endline = l; + } + + // get the line number of the node (or try to derive it from the child node + virtual int getEndColumn( void ) const + { + // most of the time the line number is not set if the node is a + // imaginary one. Usually this means it has a child. Refer to the + // child line number. Of course this could be extended a bit. + if ( endcolumn != 0 ) return endcolumn; + if( getNextSibling() ) + { + return ( RefMyAST(getNextSibling())->getColumn() ); + } + else if (getFirstChild()) return ( RefMyAST(getFirstChild())->getColumn() ); + return 0; + } + + virtual void setEndColumn( int c ) + { + if (c != 0) endcolumn = c; + } + + /** the initialize methods are called by the tree building constructs + * depending on which version is called the line number is filled in. + * e.g. a bit depending on how the node is constructed it will have the + * line number filled in or not (imaginary nodes!). + */ + virtual void initialize(int t, const ANTLR_USE_NAMESPACE(std)string& txt) + { + CommonAST::initialize(t,txt); + line = 0; column = 0; + } + + virtual void initialize( ANTLR_USE_NAMESPACE(antlr)RefToken t ) + { + CommonAST::initialize(t); + line = t->getLine(); + column = t->getColumn(); + } + + virtual void initialize( RefMyAST ast ) + { + CommonAST::initialize(ANTLR_USE_NAMESPACE(antlr)RefAST(ast)); + line = ast->getLine(); + column = ast->getColumn(); + } + // for convenience will also work without + void addChild( RefMyAST c ) + { + BaseAST::addChild( ANTLR_USE_NAMESPACE(antlr)RefAST(c) ); + } + // for convenience will also work without + void setNextSibling( RefMyAST c ) + { + BaseAST::setNextSibling( ANTLR_USE_NAMESPACE(antlr)RefAST(c) ); + } + // provide a clone of the node (no sibling/child pointers are copied) + virtual ANTLR_USE_NAMESPACE(antlr)RefAST clone( void ) + { + return ANTLR_USE_NAMESPACE(antlr)RefAST(new MyAST(*this)); + } + static ANTLR_USE_NAMESPACE(antlr)RefAST factory( void ) + { + return ANTLR_USE_NAMESPACE(antlr)RefAST(RefMyAST(new MyAST())); + } +private: + int line; + int column; + int endline; + int endcolumn; +}; + +#endif diff --git a/tools/xml/modelicaxml/dirwalk.cpp b/tools/xml/modelicaxml/dirwalk.cpp new file mode 100644 index 00000000000..529588f0ab4 --- /dev/null +++ b/tools/xml/modelicaxml/dirwalk.cpp @@ -0,0 +1,154 @@ +// +// dirwalk.c +// +// Adrian Pop +// adrpo@ida.liu.se +// 2004-11-01 + + +#include +#include +#include +#include +#include "dirwalk.h" +#include +#include +#include +#include + + + +//------------------------------------------------ +int getDirectoryStructure(char *_current, l_list &dirList, int _dlevel) +//------------------------------------------------ +{ + char DirName[MAX_PATH]; + static char CurrDirName[MAX_PATH]; + HANDLE Hnd; + WIN32_FIND_DATA WFD; + + if (!_dlevel) + { + GetCurrentDirectory( MAX_PATH, CurrDirName ); + //std::cout << "Get:" << CurrDirName << std::endl; + } + + // Set the new current directory + if (!SetCurrentDirectory( _current )) + { + std::cerr << "Error: could not open directory: " << _current << std::endl; + exit(1); + } + + //std::cout << "+" << _current << " + " << _dlevel << std::endl; + + // Starts the search + Hnd = FindFirstFile( "*.*", &WFD ); + + if (!_dlevel) + { + GetCurrentDirectory( MAX_PATH, DirName ); + // add DirName to dirList + char *tmpDir = new char[sizeof(char)*strlen(DirName)+1]; + strcpy(tmpDir, DirName); + tmpDir[strlen(DirName)]='\0'; + dirList.push_back(tmpDir); + //printf("%s\n", DirName); + } + + // loop to get all inside the current directory + while ( FindNextFile( Hnd, &WFD ) ) + { + // If it is a real directory + if ( + ( WFD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) && + ( strcmp(WFD.cFileName, "..") && strcmp(WFD.cFileName, ".") ) + ) + { + // Get the current directory + GetCurrentDirectory( MAX_PATH, DirName ); + + // Put a "\" if necessary + if ( strncmp( &DirName[strlen(DirName)-1], "\\", 1 ) ) + (void) strcat( DirName, "\\" ); + + // Create a new path + (void) strcat( DirName, WFD.cFileName ); + + // Show the new directory + // add DirName to dirList + char *tmpDir = new char[sizeof(char)*strlen(DirName)+1]; + strcpy(tmpDir, DirName); + tmpDir[strlen(DirName)]='\0'; + dirList.push_back(tmpDir); + //printf("%s\n", DirName); + + // Make a new call to itself + getDirectoryStructure( DirName, dirList, ++_dlevel); + + // Go back one level + SetCurrentDirectory( ".." ); + + _dlevel--; + } + + } // End while + + // End the search to this call + (void) FindClose( Hnd ); + if (!_dlevel) + { + SetCurrentDirectory( CurrDirName ); + //std::cout << "Set:" << CurrDirName << " + " << _dlevel << std::endl; + } + return 1; +} + +//------------------------------------------------------------------------- +int getFileList(char *currentDir, l_list &fileList, char* fileFilter) +//------------------------------------------------------------------------- +{ + char CurrDirName[MAX_PATH]; + HANDLE Hnd; + WIN32_FIND_DATA WFD; + int fileNo = 0; + + GetCurrentDirectory( MAX_PATH, CurrDirName ); + + // Set the new current directory + SetCurrentDirectory( currentDir ); + + // Starts the search + Hnd = FindFirstFile( fileFilter, &WFD ); + + if (Hnd == INVALID_HANDLE_VALUE) + { + SetCurrentDirectory( CurrDirName ); + return 0; + } + + // loop to get all inside the current directory + do + { + // If it is a real file + if ( + (( WFD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + != FILE_ATTRIBUTE_DIRECTORY) && + ( strcmp(WFD.cFileName, "..") && strcmp(WFD.cFileName, ".") ) + ) + { + // add filename to fileList + char *tmpFile = new char[sizeof(char)*strlen(WFD.cFileName)+1]; + strcpy(tmpFile, WFD.cFileName); + tmpFile[strlen(WFD.cFileName)] = '\0'; + fileList.push_back(tmpFile); + fileNo++; + } + } // End while + while ( FindNextFile( Hnd, &WFD ) ); + + // End the search to this call + (void) FindClose( Hnd ); + SetCurrentDirectory( CurrDirName ); + return fileNo; +} diff --git a/tools/xml/modelicaxml/dirwalk.h b/tools/xml/modelicaxml/dirwalk.h new file mode 100644 index 00000000000..806a5d9dcfe --- /dev/null +++ b/tools/xml/modelicaxml/dirwalk.h @@ -0,0 +1,12 @@ + +#ifndef _DIRWALK_H_ +#define _DIRWALK_H_ + +#include + +typedef std::list l_list; + +extern int getDirectoryStructure(char *, l_list &dirList, int _dlevel=0); +int getFileList(char *currentDir, l_list &fileList, char* fileFilter="*.*"); + +#endif diff --git a/tools/xml/modelicaxml/modelicaTokenTypes.hpp b/tools/xml/modelicaxml/modelicaTokenTypes.hpp new file mode 100644 index 00000000000..46982099c6b --- /dev/null +++ b/tools/xml/modelicaxml/modelicaTokenTypes.hpp @@ -0,0 +1,119 @@ +#ifndef INC_modelicaTokenTypes_hpp_ +#define INC_modelicaTokenTypes_hpp_ + +/* $ANTLR 2.7.5rc2 (20050108): "modelica_lexer.g" -> "modelicaTokenTypes.hpp"$ */ + +#ifndef CUSTOM_API +# define CUSTOM_API +#endif + +#ifdef __cplusplus +struct CUSTOM_API modelicaTokenTypes { +#endif + enum { + EOF_ = 1, + ALGORITHM = 4, + AND = 5, + ANNOTATION = 6, + BLOCK = 7, + CODE = 8, + CLASS = 9, + CONNECT = 10, + CONNECTOR = 11, + CONSTANT = 12, + DISCRETE = 13, + DER = 14, + EACH = 15, + ELSE = 16, + ELSEIF = 17, + ELSEWHEN = 18, + END = 19, + ENUMERATION = 20, + EQUATION = 21, + ENCAPSULATED = 22, + EXPANDABLE = 23, + EXTENDS = 24, + EXTERNAL = 25, + FALSE = 26, + FINAL = 27, + FLOW = 28, + FOR = 29, + FUNCTION = 30, + IF = 31, + IMPORT = 32, + IN = 33, + INITIAL = 34, + INNER = 35, + INPUT = 36, + LOOP = 37, + MODEL = 38, + NOT = 39, + OUTER = 40, + OVERLOAD = 41, + OR = 42, + OUTPUT = 43, + PACKAGE = 44, + PARAMETER = 45, + PARTIAL = 46, + PROTECTED = 47, + PUBLIC = 48, + RECORD = 49, + REDECLARE = 50, + REPLACEABLE = 51, + RESULTS = 52, + THEN = 53, + TRUE = 54, + TYPE = 55, + UNSIGNED_REAL = 56, + DOT = 57, + WHEN = 58, + WHILE = 59, + WITHIN = 60, + LPAR = 61, + RPAR = 62, + LBRACK = 63, + RBRACK = 64, + LBRACE = 65, + RBRACE = 66, + EQUALS = 67, + ASSIGN = 68, + PLUS = 69, + MINUS = 70, + STAR = 71, + SLASH = 72, + COMMA = 73, + LESS = 74, + LESSEQ = 75, + GREATER = 76, + GREATEREQ = 77, + EQEQ = 78, + LESSGT = 79, + COLON = 80, + SEMICOLON = 81, + POWER = 82, + YIELDS = 83, + AMPERSAND = 84, + PIPEBAR = 85, + COLONCOLON = 86, + DASHES = 87, + WS = 88, + ML_COMMENT = 89, + ML_COMMENT_CHAR = 90, + SL_COMMENT = 91, + IDENT = 92, + QIDENT = 93, + NONDIGIT = 94, + DIGIT = 95, + EXPONENT = 96, + UNSIGNED_INTEGER = 97, + STRING = 98, + SCHAR = 99, + QCHAR = 100, + SESCAPE = 101, + ESC = 102, + NULL_TREE_LOOKAHEAD = 3 + }; +#ifdef __cplusplus +}; +#endif +#endif /*INC_modelicaTokenTypes_hpp_*/ diff --git a/tools/xml/modelicaxml/modelicaTokenTypes.txt b/tools/xml/modelicaxml/modelicaTokenTypes.txt new file mode 100644 index 00000000000..9d81215d04c --- /dev/null +++ b/tools/xml/modelicaxml/modelicaTokenTypes.txt @@ -0,0 +1,101 @@ +// $ANTLR 2.7.5rc2 (20050108): modelica_lexer.g -> modelicaTokenTypes.txt$ +modelica // output token vocab name +ALGORITHM="algorithm"=4 +AND="and"=5 +ANNOTATION="annotation"=6 +BLOCK="block"=7 +CODE="Code"=8 +CLASS="class"=9 +CONNECT="connect"=10 +CONNECTOR="connector"=11 +CONSTANT="constant"=12 +DISCRETE="discrete"=13 +DER="der"=14 +EACH="each"=15 +ELSE="else"=16 +ELSEIF="elseif"=17 +ELSEWHEN="elsewhen"=18 +END="end"=19 +ENUMERATION="enumeration"=20 +EQUATION="equation"=21 +ENCAPSULATED="encapsulated"=22 +EXPANDABLE="expandable"=23 +EXTENDS="extends"=24 +EXTERNAL="external"=25 +FALSE="false"=26 +FINAL="final"=27 +FLOW="flow"=28 +FOR="for"=29 +FUNCTION="function"=30 +IF="if"=31 +IMPORT="import"=32 +IN="in"=33 +INITIAL="initial"=34 +INNER="inner"=35 +INPUT="input"=36 +LOOP="loop"=37 +MODEL="model"=38 +NOT="not"=39 +OUTER="outer"=40 +OVERLOAD="overload"=41 +OR="or"=42 +OUTPUT="output"=43 +PACKAGE="package"=44 +PARAMETER="parameter"=45 +PARTIAL="partial"=46 +PROTECTED="protected"=47 +PUBLIC="public"=48 +RECORD="record"=49 +REDECLARE="redeclare"=50 +REPLACEABLE="replaceable"=51 +RESULTS="results"=52 +THEN="then"=53 +TRUE="true"=54 +TYPE="type"=55 +UNSIGNED_REAL="unsigned_real"=56 +DOT="."=57 +WHEN="when"=58 +WHILE="while"=59 +WITHIN="within"=60 +LPAR=61 +RPAR=62 +LBRACK=63 +RBRACK=64 +LBRACE=65 +RBRACE=66 +EQUALS=67 +ASSIGN=68 +PLUS=69 +MINUS=70 +STAR=71 +SLASH=72 +COMMA=73 +LESS=74 +LESSEQ=75 +GREATER=76 +GREATEREQ=77 +EQEQ=78 +LESSGT=79 +COLON=80 +SEMICOLON=81 +POWER=82 +YIELDS=83 +AMPERSAND=84 +PIPEBAR=85 +COLONCOLON=86 +DASHES=87 +WS=88 +ML_COMMENT=89 +ML_COMMENT_CHAR=90 +SL_COMMENT=91 +IDENT("an identifier")=92 +QIDENT("an identifier")=93 +NONDIGIT=94 +DIGIT=95 +EXPONENT=96 +UNSIGNED_INTEGER=97 +STRING=98 +SCHAR=99 +QCHAR=100 +SESCAPE=101 +ESC=102 diff --git a/tools/xml/modelicaxml/modelica_lexer.cpp b/tools/xml/modelicaxml/modelica_lexer.cpp new file mode 100644 index 00000000000..e9188bd86a8 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_lexer.cpp @@ -0,0 +1,1751 @@ +/* $ANTLR 2.7.5rc2 (20050108): "modelica_lexer.g" -> "modelica_lexer.cpp"$ */ +#include "modelica_lexer.hpp" +#include +#include +#include +#include +#include +#include +#include + +#line 1 "modelica_lexer.g" +#line 13 "modelica_lexer.cpp" +modelica_lexer::modelica_lexer(ANTLR_USE_NAMESPACE(std)istream& in) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),true) +{ + initLiterals(); +} + +modelica_lexer::modelica_lexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true) +{ + initLiterals(); +} + +modelica_lexer::modelica_lexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,true) +{ + initLiterals(); +} + +void modelica_lexer::initLiterals() +{ + literals["type"] = 55; + literals["constant"] = 12; + literals["public"] = 48; + literals["initial"] = 34; + literals["annotation"] = 6; + literals["while"] = 59; + literals["end"] = 19; + literals["equation"] = 21; + literals["overload"] = 41; + literals["flow"] = 28; + literals["then"] = 53; + literals["unsigned_real"] = 56; + literals["and"] = 5; + literals["outer"] = 40; + literals["not"] = 39; + literals["package"] = 44; + literals["external"] = 25; + literals["replaceable"] = 51; + literals["protected"] = 47; + literals["der"] = 14; + literals["output"] = 43; + literals["when"] = 58; + literals["class"] = 9; + literals["inner"] = 35; + literals["enumeration"] = 20; + literals["function"] = 30; + literals["each"] = 15; + literals["redeclare"] = 50; + literals["model"] = 38; + literals["elseif"] = 17; + literals["parameter"] = 45; + literals["input"] = 36; + literals["final"] = 27; + literals["or"] = 42; + literals["if"] = 31; + literals["record"] = 49; + literals["connector"] = 11; + literals["connect"] = 10; + literals["results"] = 52; + literals["for"] = 29; + literals["extends"] = 24; + literals["loop"] = 37; + literals["false"] = 26; + literals["elsewhen"] = 18; + literals["Code"] = 8; + literals["encapsulated"] = 22; + literals["partial"] = 46; + literals["expandable"] = 23; + literals["."] = 57; + literals["else"] = 16; + literals["import"] = 32; + literals["discrete"] = 13; + literals["in"] = 33; + literals["block"] = 7; + literals["true"] = 54; + literals["within"] = 60; + literals["algorithm"] = 4; +} + +ANTLR_USE_NAMESPACE(antlr)RefToken modelica_lexer::nextToken() +{ + ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken; + for (;;) { + ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken; + int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE; + resetText(); + try { // for lexical and char stream error handling + switch ( LA(1)) { + case 0x28 /* '(' */ : + { + mLPAR(true); + theRetToken=_returnToken; + break; + } + case 0x29 /* ')' */ : + { + mRPAR(true); + theRetToken=_returnToken; + break; + } + case 0x5b /* '[' */ : + { + mLBRACK(true); + theRetToken=_returnToken; + break; + } + case 0x5d /* ']' */ : + { + mRBRACK(true); + theRetToken=_returnToken; + break; + } + case 0x7b /* '{' */ : + { + mLBRACE(true); + theRetToken=_returnToken; + break; + } + case 0x7d /* '}' */ : + { + mRBRACE(true); + theRetToken=_returnToken; + break; + } + case 0x2b /* '+' */ : + { + mPLUS(true); + theRetToken=_returnToken; + break; + } + case 0x2a /* '*' */ : + { + mSTAR(true); + theRetToken=_returnToken; + break; + } + case 0x2c /* ',' */ : + { + mCOMMA(true); + theRetToken=_returnToken; + break; + } + case 0x3b /* ';' */ : + { + mSEMICOLON(true); + theRetToken=_returnToken; + break; + } + case 0x5e /* '^' */ : + { + mPOWER(true); + theRetToken=_returnToken; + break; + } + case 0x26 /* '&' */ : + { + mAMPERSAND(true); + theRetToken=_returnToken; + break; + } + case 0x7c /* '|' */ : + { + mPIPEBAR(true); + theRetToken=_returnToken; + break; + } + case 0x9 /* '\t' */ : + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + case 0x20 /* ' ' */ : + { + mWS(true); + theRetToken=_returnToken; + break; + } + case 0x27 /* '\'' */ : + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + case 0x5f /* '_' */ : + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + mIDENT(true); + theRetToken=_returnToken; + break; + } + case 0x2e /* '.' */ : + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + mUNSIGNED_INTEGER(true); + theRetToken=_returnToken; + break; + } + case 0x22 /* '\"' */ : + { + mSTRING(true); + theRetToken=_returnToken; + break; + } + default: + if ((LA(1) == 0x3a /* ':' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mASSIGN(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mLESSEQ(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mGREATEREQ(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mEQEQ(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3e /* '>' */ )) { + mLESSGT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3e /* '>' */ )) { + mYIELDS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3a /* ':' */ ) && (LA(2) == 0x3a /* ':' */ )) { + mCOLONCOLON(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2d /* '-' */ ) && (LA(2) == 0x2d /* '-' */ )) { + mDASHES(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) { + mML_COMMENT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) { + mSL_COMMENT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (true)) { + mEQUALS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2d /* '-' */ ) && (true)) { + mMINUS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (true)) { + mSLASH(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (true)) { + mLESS(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3e /* '>' */ ) && (true)) { + mGREATER(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3a /* ':' */ ) && (true)) { + mCOLON(true); + theRetToken=_returnToken; + } + else { + if (LA(1)==EOF_CHAR) + { + uponEOF(); + _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + } + else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + } + if ( !_returnToken ) + goto tryAgain; // found SKIP token + + _ttype = _returnToken->getType(); + _returnToken->setType(_ttype); + return _returnToken; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) { + throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e); + } + catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) { + throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io); + } + catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) { + throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage()); + } +tryAgain:; + } +} + +void modelica_lexer::mLPAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LPAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('(' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mRPAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = RPAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(')' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mLBRACK(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LBRACK; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('[' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mRBRACK(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = RBRACK; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(']' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mLBRACE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LBRACE; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('{' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mRBRACE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = RBRACE; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('}' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mEQUALS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = EQUALS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('=' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mASSIGN(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ASSIGN; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(":="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mPLUS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = PLUS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('+' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mMINUS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = MINUS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('-' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mSTAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = STAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('*' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mSLASH(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SLASH; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('/' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mCOMMA(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = COMMA; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(',' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mLESS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LESS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('<' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mLESSEQ(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LESSEQ; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("<="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mGREATER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = GREATER; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('>' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mGREATEREQ(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = GREATEREQ; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(">="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mEQEQ(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = EQEQ; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("=="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mLESSGT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LESSGT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("<>"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mCOLON(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = COLON; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(':' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mSEMICOLON(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SEMICOLON; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(';' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mPOWER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = POWER; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('^' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mYIELDS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = YIELDS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("=>"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mAMPERSAND(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = AMPERSAND; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("&"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mPIPEBAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = PIPEBAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("|"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mCOLONCOLON(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = COLONCOLON; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("::"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mDASHES(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = DASHES; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('-' /* charlit */ ); + match('-' /* charlit */ ); + match('-' /* charlit */ ); + { // ( ... )* + for (;;) { + if ((LA(1) == 0x2d /* '-' */ )) { + match('-' /* charlit */ ); + } + else { + goto _loop29; + } + + } + _loop29:; + } // ( ... )* + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mWS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = WS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + { + switch ( LA(1)) { + case 0x20 /* ' ' */ : + { + match(' ' /* charlit */ ); + break; + } + case 0x9 /* '\t' */ : + { + match('\t' /* charlit */ ); + break; + } + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + { + { + if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) { + match("\r\n"); + } + else if ((LA(1) == 0xd /* '\r' */ ) && (true)) { + match('\r' /* charlit */ ); + } + else if ((LA(1) == 0xa /* '\n' */ )) { + match('\n' /* charlit */ ); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + } + if ( inputState->guessing==0 ) { +#line 117 "modelica_lexer.g" + newline(); +#line 794 "modelica_lexer.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( inputState->guessing==0 ) { +#line 119 "modelica_lexer.g" + _ttype = antlr::Token::SKIP; +#line 807 "modelica_lexer.cpp" + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mML_COMMENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ML_COMMENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("/*"); + { // ( ... )* + for (;;) { + if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */ && LA(2) <= 0xff)))&&(LA(2)!='/')) { + match('*' /* charlit */ ); + } + else if ((_tokenSet_0.member(LA(1)))) { + mML_COMMENT_CHAR(false); + } + else { + goto _loop35; + } + + } + _loop35:; + } // ( ... )* + match("*/"); + if ( inputState->guessing==0 ) { +#line 126 "modelica_lexer.g" + _ttype = antlr::Token::SKIP; +#line 842 "modelica_lexer.cpp" + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mML_COMMENT_CHAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ML_COMMENT_CHAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + if ((LA(1) == 0xa /* '\n' */ || LA(1) == 0xd /* '\r' */ )) { + { + switch ( LA(1)) { + case 0xd /* '\r' */ : + { + match("\r\n"); + break; + } + case 0xa /* '\n' */ : + { + match('\n' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( inputState->guessing==0 ) { +#line 130 "modelica_lexer.g" + newline(); +#line 879 "modelica_lexer.cpp" + } + } + else if ((_tokenSet_1.member(LA(1)))) { + { + match(_tokenSet_1); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mSL_COMMENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SL_COMMENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("//"); + { // ( ... )* + for (;;) { + if ((_tokenSet_2.member(LA(1)))) { + { + match(_tokenSet_2); + } + } + else { + goto _loop42; + } + + } + _loop42:; + } // ( ... )* + if ( inputState->guessing==0 ) { +#line 136 "modelica_lexer.g" + _ttype = antlr::Token::SKIP; +#line 922 "modelica_lexer.cpp" + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mIDENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = IDENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + switch ( LA(1)) { + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + case 0x5f /* '_' */ : + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + mNONDIGIT(false); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + case 0x5f /* '_' */ : + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + mNONDIGIT(false); + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + mDIGIT(false); + break; + } + default: + { + goto _loop45; + } + } + } + _loop45:; + } // ( ... )* + break; + } + case 0x27 /* '\'' */ : + { + mQIDENT(false); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + _ttype = testLiteralsTable(_ttype); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mNONDIGIT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = NONDIGIT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + { + switch ( LA(1)) { + case 0x5f /* '_' */ : + { + match('_' /* charlit */ ); + break; + } + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + matchRange('a','z'); + break; + } + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + { + matchRange('A','Z'); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mDIGIT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = DIGIT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + matchRange('0','9'); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mQIDENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = QIDENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('\'' /* charlit */ ); + { + if ((_tokenSet_3.member(LA(1)))) { + mQCHAR(false); + } + else if ((LA(1) == 0x5c /* '\\' */ )) { + mSESCAPE(false); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + } + { // ( ... )* + for (;;) { + if ((_tokenSet_3.member(LA(1)))) { + mQCHAR(false); + } + else if ((LA(1) == 0x5c /* '\\' */ )) { + mSESCAPE(false); + } + else { + goto _loop49; + } + + } + _loop49:; + } // ( ... )* + match('\'' /* charlit */ ); + _ttype = testLiteralsTable(text.substr(_begin, text.length()-_begin),_ttype); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mQCHAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = QCHAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + switch ( LA(1)) { + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + { + { + { + switch ( LA(1)) { + case 0xa /* '\n' */ : + { + match('\n' /* charlit */ ); + break; + } + case 0xd /* '\r' */ : + { + match("\r\n"); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + } + if ( inputState->guessing==0 ) { +#line 180 "modelica_lexer.g" + newline(); +#line 1271 "modelica_lexer.cpp" + } + break; + } + case 0x9 /* '\t' */ : + { + match('\t' /* charlit */ ); + break; + } + default: + if ((_tokenSet_4.member(LA(1)))) { + { + match(_tokenSet_4); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mSESCAPE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SESCAPE; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('\\' /* charlit */ ); + { + switch ( LA(1)) { + case 0x5c /* '\\' */ : + { + match('\\' /* charlit */ ); + break; + } + case 0x22 /* '\"' */ : + { + match('\"' /* charlit */ ); + break; + } + case 0x27 /* '\'' */ : + { + match("\'"); + break; + } + case 0x3f /* '?' */ : + { + match('?' /* charlit */ ); + break; + } + case 0x61 /* 'a' */ : + { + match('a' /* charlit */ ); + break; + } + case 0x62 /* 'b' */ : + { + match('b' /* charlit */ ); + break; + } + case 0x66 /* 'f' */ : + { + match('f' /* charlit */ ); + break; + } + case 0x6e /* 'n' */ : + { + match('n' /* charlit */ ); + break; + } + case 0x72 /* 'r' */ : + { + match('r' /* charlit */ ); + break; + } + case 0x74 /* 't' */ : + { + match('t' /* charlit */ ); + break; + } + case 0x76 /* 'v' */ : + { + match('v' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mEXPONENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = EXPONENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + { + switch ( LA(1)) { + case 0x65 /* 'e' */ : + { + match('e' /* charlit */ ); + break; + } + case 0x45 /* 'E' */ : + { + match('E' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { + switch ( LA(1)) { + case 0x2b /* '+' */ : + { + match('+' /* charlit */ ); + break; + } + case 0x2d /* '-' */ : + { + match('-' /* charlit */ ); + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { // ( ... )+ + int _cnt57=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt57>=1 ) { goto _loop57; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt57++; + } + _loop57:; + } // ( ... )+ + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mUNSIGNED_INTEGER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = UNSIGNED_INTEGER; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + bool synPredMatched66 = false; + if (((LA(1) == 0x2e /* '.' */ ) && ((LA(2) >= 0x30 /* '0' */ && LA(2) <= 0x39 /* '9' */ )))) { + int _m66 = mark(); + synPredMatched66 = true; + inputState->guessing++; + try { + { + match('.' /* charlit */ ); + mDIGIT(false); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched66 = false; + } + rewind(_m66); + inputState->guessing--; + } + if ( synPredMatched66 ) { + { + match('.' /* charlit */ ); + { // ( ... )+ + int _cnt69=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt69>=1 ) { goto _loop69; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt69++; + } + _loop69:; + } // ( ... )+ + if ( inputState->guessing==0 ) { +#line 165 "modelica_lexer.g" + _ttype = UNSIGNED_REAL; +#line 1493 "modelica_lexer.cpp" + } + } + { + if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) { + mEXPONENT(false); + if ( inputState->guessing==0 ) { +#line 166 "modelica_lexer.g" + _ttype = UNSIGNED_REAL; +#line 1502 "modelica_lexer.cpp" + } + } + else { + } + + } + } + else if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + { // ( ... )+ + int _cnt60=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt60>=1 ) { goto _loop60; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt60++; + } + _loop60:; + } // ( ... )+ + { + if ((LA(1) == 0x2e /* '.' */ )) { + match('.' /* charlit */ ); + { // ( ... )* + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + goto _loop63; + } + + } + _loop63:; + } // ( ... )* + if ( inputState->guessing==0 ) { +#line 162 "modelica_lexer.g" + _ttype = UNSIGNED_REAL; +#line 1543 "modelica_lexer.cpp" + } + } + else { + } + + } + { + if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) { + mEXPONENT(false); + if ( inputState->guessing==0 ) { +#line 163 "modelica_lexer.g" + _ttype = UNSIGNED_REAL; +#line 1556 "modelica_lexer.cpp" + } + } + else { + } + + } + } + else if ((LA(1) == 0x2e /* '.' */ ) && (true)) { + match('.' /* charlit */ ); + if ( inputState->guessing==0 ) { +#line 168 "modelica_lexer.g" + _ttype = DOT; +#line 1569 "modelica_lexer.cpp" + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mSTRING(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = STRING; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + _saveIndex = text.length(); + match('\"' /* charlit */ ); + text.erase(_saveIndex); + { // ( ... )* + for (;;) { + if ((_tokenSet_5.member(LA(1)))) { + mSCHAR(false); + } + else if ((LA(1) == 0x5c /* '\\' */ )) { + mSESCAPE(false); + } + else { + goto _loop73; + } + + } + _loop73:; + } // ( ... )* + _saveIndex = text.length(); + match('\"' /* charlit */ ); + text.erase(_saveIndex); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mSCHAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SCHAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + switch ( LA(1)) { + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + { + { + { + switch ( LA(1)) { + case 0xa /* '\n' */ : + { + match('\n' /* charlit */ ); + break; + } + case 0xd /* '\r' */ : + { + match("\r\n"); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + } + if ( inputState->guessing==0 ) { +#line 175 "modelica_lexer.g" + newline(); +#line 1650 "modelica_lexer.cpp" + } + break; + } + case 0x9 /* '\t' */ : + { + match('\t' /* charlit */ ); + break; + } + default: + if ((_tokenSet_6.member(LA(1)))) { + { + match(_tokenSet_6); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void modelica_lexer::mESC(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ESC; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('\\' /* charlit */ ); + { + switch ( LA(1)) { + case 0x22 /* '\"' */ : + { + match('\"' /* charlit */ ); + break; + } + case 0x5c /* '\\' */ : + { + match('\\' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + + +const unsigned long modelica_lexer::_tokenSet_0_data_[] = { 4294967288UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13 +// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # +// $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F +// G H I J K L M N O P Q R S T U V W X Y Z [ \\ ] ^ _ ` a b c d e f +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_lexer::_tokenSet_0(_tokenSet_0_data_,16); +const unsigned long modelica_lexer::_tokenSet_1_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14 +// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # $ % +// & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H +// I J K L M N O P Q R S T U V W X Y Z [ \\ ] ^ _ ` a b c d e f +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_lexer::_tokenSet_1(_tokenSet_1_data_,16); +const unsigned long modelica_lexer::_tokenSet_2_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14 +// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # $ % +// & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G +// H I J K L M N O P Q R S T U V W X Y Z [ \\ ] ^ _ ` a b c d e f +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_lexer::_tokenSet_2(_tokenSet_2_data_,16); +const unsigned long modelica_lexer::_tokenSet_3_data_[] = { 4294967288UL, 4294967167UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13 +// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # +// $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F +// G H I J K L M N O P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_lexer::_tokenSet_3(_tokenSet_3_data_,16); +const unsigned long modelica_lexer::_tokenSet_4_data_[] = { 4294957560UL, 4294967167UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14 0x15 +// 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # $ % & ( ) +// * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K +// L M N O P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_lexer::_tokenSet_4(_tokenSet_4_data_,16); +const unsigned long modelica_lexer::_tokenSet_5_data_[] = { 4294967288UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13 +// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! # $ +// % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F +// G H I J K L M N O P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_lexer::_tokenSet_5(_tokenSet_5_data_,16); +const unsigned long modelica_lexer::_tokenSet_6_data_[] = { 4294957560UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// 0x3 0x4 0x5 0x6 0x7 0x8 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14 0x15 +// 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! # $ % & \' ( ) +// * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K +// L M N O P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_lexer::_tokenSet_6(_tokenSet_6_data_,16); + diff --git a/tools/xml/modelicaxml/modelica_lexer.g b/tools/xml/modelicaxml/modelica_lexer.g new file mode 100644 index 00000000000..a1bc63ecb51 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_lexer.g @@ -0,0 +1,199 @@ +header { + +} + +options { + language = "Cpp"; +} + +class modelica_lexer extends Lexer; + +options { + k=2; + charVocabulary = '\3'..'\377'; + exportVocab = modelica; + testLiterals = false; + defaultErrorHandler = false; +} + +tokens { + ALGORITHM = "algorithm" ; + AND = "and" ; + ANNOTATION = "annotation" ; + BLOCK = "block" ; + CODE = "Code" ; + CLASS = "class" ; + CONNECT = "connect" ; + CONNECTOR = "connector" ; + CONSTANT = "constant" ; + DISCRETE = "discrete" ; + DER = "der"; + EACH = "each" ; + ELSE = "else" ; + ELSEIF = "elseif" ; + ELSEWHEN = "elsewhen" ; + END = "end" ; + ENUMERATION = "enumeration" ; + EQUATION = "equation" ; + ENCAPSULATED = "encapsulated"; + EXPANDABLE = "expandable"; + EXTENDS = "extends" ; + EXTERNAL = "external" ; + FALSE = "false" ; + FINAL = "final" ; + FLOW = "flow" ; + FOR = "for" ; + FUNCTION = "function" ; + IF = "if" ; + IMPORT = "import" ; + IN = "in" ; + INITIAL = "initial" ; + INNER = "inner" ; + INPUT = "input" ; + LOOP = "loop" ; + MODEL = "model" ; + NOT = "not" ; + OUTER = "outer" ; + OVERLOAD = "overload"; + OR = "or" ; + OUTPUT = "output" ; + PACKAGE = "package" ; + PARAMETER = "parameter" ; + PARTIAL = "partial" ; + PROTECTED = "protected" ; + PUBLIC = "public" ; + RECORD = "record" ; + REDECLARE = "redeclare" ; + REPLACEABLE = "replaceable" ; + RESULTS = "results" ; + THEN = "then" ; + TRUE = "true" ; + TYPE = "type" ; + UNSIGNED_REAL = "unsigned_real"; + DOT = "."; + WHEN = "when" ; + WHILE = "while" ; + WITHIN = "within" ; +} + + +// --------- +// Operators +// --------- + +LPAR : '(' ; +RPAR : ')' ; +LBRACK : '[' ; +RBRACK : ']' ; +LBRACE : '{' ; +RBRACE : '}' ; +EQUALS : '=' ; +ASSIGN : ":=" ; +PLUS : '+' ; +MINUS : '-' ; +STAR : '*' ; +SLASH : '/' ; + +COMMA : ',' ; +LESS : '<' ; +LESSEQ : "<=" ; +GREATER : '>' ; +GREATEREQ : ">=" ; +EQEQ : "==" ; +LESSGT : "<>" ; +COLON : ':' ; +SEMICOLON : ';' ; +POWER : '^' ; +YIELDS : "=>" ; +AMPERSAND : "&" ; +PIPEBAR : "|" ; +COLONCOLON : "::" ; +DASHES : '-' '-' '-' ( '-' )* ; + + +WS : + ( ' ' + | '\t' + | ( "\r\n" | '\r' | '\n' ) { newline(); } + ) + { $setType(antlr::Token::SKIP); } + ; + +ML_COMMENT : + "/*" + (options { generateAmbigWarnings=false; } : ML_COMMENT_CHAR + | {LA(2)!='/'}? '*')* + "*/" { $setType(antlr::Token::SKIP); } ; + +protected +ML_COMMENT_CHAR : + ("\r\n" | '\n') { newline(); } + | ~('*'|'\n'|'\r') + ; + +SL_COMMENT : + "//" (~('\n' | '\r') )* + { $setType(antlr::Token::SKIP); } + ; + +IDENT options { testLiterals = true; paraphrase = "an identifier";} : + NONDIGIT (NONDIGIT | DIGIT)* | QIDENT + ; + +protected +QIDENT options { testLiterals = true; paraphrase = "an identifier";} : + '\'' (QCHAR | SESCAPE) (QCHAR | SESCAPE)* '\'' ; + +protected +NONDIGIT : ('_' | 'a'..'z' | 'A'..'Z'); + +protected +DIGIT : + '0'..'9' + ; + +protected +EXPONENT : + ('e'|'E') ('+' | '-')? (DIGIT)+ + ; + + +UNSIGNED_INTEGER : + (DIGIT)+ ('.' (DIGIT)* { $setType(UNSIGNED_REAL);} )? + (EXPONENT { $setType(UNSIGNED_REAL); } )? + | + ('.' DIGIT) => ('.' (DIGIT)+ { $setType(UNSIGNED_REAL);}) + (EXPONENT { $setType(UNSIGNED_REAL); } )? + | + '.' { $setType(DOT); } + ; + +STRING : '"'! (SCHAR | SESCAPE)* '"'!; + + +protected +SCHAR : (options { generateAmbigWarnings=false; } : ('\n' | "\r\n")) { newline(); } + | '\t' + | ~('\n' | '\t' | '\r' | '\\' | '"'); + +protected +QCHAR : (options { generateAmbigWarnings=false; } : ('\n' | "\r\n")) { newline(); } + | '\t' + | ~('\n' | '\t' | '\r' | '\\' | '\''); + +protected +SESCAPE : '\\' ('\\' | '"' | "'" | '?' | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v'); + + +protected +ESC : + '\\' + ( '"' + | '\\' + ) + ; + + + + + diff --git a/tools/xml/modelicaxml/modelica_lexer.hpp b/tools/xml/modelicaxml/modelica_lexer.hpp new file mode 100644 index 00000000000..cfb52107472 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_lexer.hpp @@ -0,0 +1,92 @@ +#ifndef INC_modelica_lexer_hpp_ +#define INC_modelica_lexer_hpp_ + +#include +/* $ANTLR 2.7.5rc2 (20050108): "modelica_lexer.g" -> "modelica_lexer.hpp"$ */ +#include +#include +#include +#include "modelicaTokenTypes.hpp" +#include +#line 1 "modelica_lexer.g" + + + +#line 16 "modelica_lexer.hpp" +class CUSTOM_API modelica_lexer : public ANTLR_USE_NAMESPACE(antlr)CharScanner, public modelicaTokenTypes +{ +#line 1 "modelica_lexer.g" +#line 20 "modelica_lexer.hpp" +private: + void initLiterals(); +public: + bool getCaseSensitiveLiterals() const + { + return true; + } +public: + modelica_lexer(ANTLR_USE_NAMESPACE(std)istream& in); + modelica_lexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib); + modelica_lexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state); + ANTLR_USE_NAMESPACE(antlr)RefToken nextToken(); + public: void mLPAR(bool _createToken); + public: void mRPAR(bool _createToken); + public: void mLBRACK(bool _createToken); + public: void mRBRACK(bool _createToken); + public: void mLBRACE(bool _createToken); + public: void mRBRACE(bool _createToken); + public: void mEQUALS(bool _createToken); + public: void mASSIGN(bool _createToken); + public: void mPLUS(bool _createToken); + public: void mMINUS(bool _createToken); + public: void mSTAR(bool _createToken); + public: void mSLASH(bool _createToken); + public: void mCOMMA(bool _createToken); + public: void mLESS(bool _createToken); + public: void mLESSEQ(bool _createToken); + public: void mGREATER(bool _createToken); + public: void mGREATEREQ(bool _createToken); + public: void mEQEQ(bool _createToken); + public: void mLESSGT(bool _createToken); + public: void mCOLON(bool _createToken); + public: void mSEMICOLON(bool _createToken); + public: void mPOWER(bool _createToken); + public: void mYIELDS(bool _createToken); + public: void mAMPERSAND(bool _createToken); + public: void mPIPEBAR(bool _createToken); + public: void mCOLONCOLON(bool _createToken); + public: void mDASHES(bool _createToken); + public: void mWS(bool _createToken); + public: void mML_COMMENT(bool _createToken); + protected: void mML_COMMENT_CHAR(bool _createToken); + public: void mSL_COMMENT(bool _createToken); + public: void mIDENT(bool _createToken); + protected: void mNONDIGIT(bool _createToken); + protected: void mDIGIT(bool _createToken); + protected: void mQIDENT(bool _createToken); + protected: void mQCHAR(bool _createToken); + protected: void mSESCAPE(bool _createToken); + protected: void mEXPONENT(bool _createToken); + public: void mUNSIGNED_INTEGER(bool _createToken); + public: void mSTRING(bool _createToken); + protected: void mSCHAR(bool _createToken); + protected: void mESC(bool _createToken); +private: + + static const unsigned long _tokenSet_0_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0; + static const unsigned long _tokenSet_1_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1; + static const unsigned long _tokenSet_2_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2; + static const unsigned long _tokenSet_3_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3; + static const unsigned long _tokenSet_4_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_4; + static const unsigned long _tokenSet_5_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_5; + static const unsigned long _tokenSet_6_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_6; +}; + +#endif /*INC_modelica_lexer_hpp_*/ diff --git a/tools/xml/modelicaxml/modelica_parser.cpp b/tools/xml/modelicaxml/modelica_parser.cpp new file mode 100644 index 00000000000..866628ae8c4 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_parser.cpp @@ -0,0 +1,5928 @@ +/* $ANTLR 2.7.5rc2 (20050108): "modelica_parser.g" -> "modelica_parser.cpp"$ */ +#include "modelica_parser.hpp" +#include +#include +#include +#line 1 "modelica_parser.g" +#line 8 "modelica_parser.cpp" +modelica_parser::modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k) +{ +} + +modelica_parser::modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2) +{ +} + +modelica_parser::modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k) +{ +} + +modelica_parser::modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2) +{ +} + +modelica_parser::modelica_parser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2) +{ +} + +void modelica_parser::stored_definition() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST stored_definition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST cd_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefMyAST s_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case END: + { + match(END); + RefMyAST tmp2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp2_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp2_AST)); + } + match(IDENT); + match(SEMICOLON); + match(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + if ( inputState->guessing==0 ) { + stored_definition_AST = RefMyAST(currentAST.root); +#line 96 "modelica_parser.g" + + stored_definition_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(END_DEFINITION,"END_DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(stored_definition_AST)))); + +#line 60 "modelica_parser.cpp" + currentAST.root = stored_definition_AST; + if ( stored_definition_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + stored_definition_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = stored_definition_AST->getFirstChild(); + else + currentAST.child = stored_definition_AST; + currentAST.advanceChildToEnd(); + } + stored_definition_AST = RefMyAST(currentAST.root); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case IDENT: + { + component_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + match(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + if ( inputState->guessing==0 ) { + stored_definition_AST = RefMyAST(currentAST.root); +#line 102 "modelica_parser.g" + + stored_definition_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_DEFINITION,"COMPONENT_DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(stored_definition_AST)))); + +#line 92 "modelica_parser.cpp" + currentAST.root = stored_definition_AST; + if ( stored_definition_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + stored_definition_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = stored_definition_AST->getFirstChild(); + else + currentAST.child = stored_definition_AST; + currentAST.advanceChildToEnd(); + } + stored_definition_AST = RefMyAST(currentAST.root); + break; + } + case IMPORT: + { + import_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + match(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + if ( inputState->guessing==0 ) { + stored_definition_AST = RefMyAST(currentAST.root); +#line 108 "modelica_parser.g" + + stored_definition_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(IMPORT_DEFINITION,"IMPORT_DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(stored_definition_AST)))); + +#line 118 "modelica_parser.cpp" + currentAST.root = stored_definition_AST; + if ( stored_definition_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + stored_definition_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = stored_definition_AST->getFirstChild(); + else + currentAST.child = stored_definition_AST; + currentAST.advanceChildToEnd(); + } + stored_definition_AST = RefMyAST(currentAST.root); + break; + } + default: + bool synPredMatched5 = false; + if (((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2))))) { + int _m5 = mark(); + synPredMatched5 = true; + inputState->guessing++; + try { + { + { + if ((LA(1) == ENCAPSULATED)) { + match(ENCAPSULATED); + } + else if ((_tokenSet_2.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == PARTIAL)) { + match(PARTIAL); + } + else if ((_tokenSet_3.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + class_type(); + match(IDENT); + match(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched5 = false; + } + rewind(_m5); + inputState->guessing--; + } + if ( synPredMatched5 ) { + { + { + if ((LA(1) == ENCAPSULATED)) { + RefMyAST tmp9_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp9_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp9_AST)); + } + match(ENCAPSULATED); + } + else if ((_tokenSet_2.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == PARTIAL)) { + RefMyAST tmp10_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp10_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp10_AST)); + } + match(PARTIAL); + } + else if ((_tokenSet_3.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + class_type(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + RefMyAST tmp11_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp11_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp11_AST)); + } + match(IDENT); + match(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + } + if ( inputState->guessing==0 ) { + stored_definition_AST = RefMyAST(currentAST.root); +#line 91 "modelica_parser.g" + + stored_definition_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BEGIN_DEFINITION,"BEGIN_DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(stored_definition_AST)))); + +#line 223 "modelica_parser.cpp" + currentAST.root = stored_definition_AST; + if ( stored_definition_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + stored_definition_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = stored_definition_AST->getFirstChild(); + else + currentAST.child = stored_definition_AST; + currentAST.advanceChildToEnd(); + } + stored_definition_AST = RefMyAST(currentAST.root); + } + else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2)))) { + { + if ((LA(1) == WITHIN)) { + within_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((_tokenSet_6.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { // ( ... )* + for (;;) { + if ((_tokenSet_7.member(LA(1)))) { + { + if ((LA(1) == FINAL)) { + RefMyAST tmp14_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp14_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp14_AST)); + } + match(FINAL); + } + else if ((_tokenSet_0.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + class_definition(); + if (inputState->guessing==0) { + cd_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + } + match(SEMICOLON); + if ( inputState->guessing==0 ) { +#line 116 "modelica_parser.g" + + /* adrpo, fix the end of this AST node */ + if(cd_AST != NULL) + { + /* + std::cout << (#cd)->toString() << std::endl; + std::cout << s->getLine() << ":" << s->getColumn() << std::endl; + */ + RefMyAST(cd_AST)->setEndLine(s->getLine()); + RefMyAST(cd_AST)->setEndColumn(s->getColumn()); + } + +#line 293 "modelica_parser.cpp" + } + } + else { + goto _loop14; + } + + } + _loop14:; + } // ( ... )* + match(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE); + if ( inputState->guessing==0 ) { + stored_definition_AST = RefMyAST(currentAST.root); +#line 130 "modelica_parser.g" + + stored_definition_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(STORED_DEFINITION,"STORED_DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(stored_definition_AST)))); + +#line 310 "modelica_parser.cpp" + currentAST.root = stored_definition_AST; + if ( stored_definition_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + stored_definition_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = stored_definition_AST->getFirstChild(); + else + currentAST.child = stored_definition_AST; + currentAST.advanceChildToEnd(); + } + stored_definition_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = stored_definition_AST; +} + +void modelica_parser::class_type() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_type_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case CLASS: + { + RefMyAST tmp16_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp16_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp16_AST)); + } + match(CLASS); + break; + } + case MODEL: + { + RefMyAST tmp17_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp17_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp17_AST)); + } + match(MODEL); + break; + } + case RECORD: + { + RefMyAST tmp18_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp18_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp18_AST)); + } + match(RECORD); + break; + } + case BLOCK: + { + RefMyAST tmp19_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp19_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp19_AST)); + } + match(BLOCK); + break; + } + case CONNECTOR: + case EXPANDABLE: + { + { + if ((LA(1) == EXPANDABLE)) { + RefMyAST tmp20_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp20_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST)); + } + match(EXPANDABLE); + } + else if ((LA(1) == CONNECTOR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + RefMyAST tmp21_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp21_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp21_AST)); + } + match(CONNECTOR); + break; + } + case TYPE: + { + RefMyAST tmp22_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp22_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST)); + } + match(TYPE); + break; + } + case PACKAGE: + { + RefMyAST tmp23_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp23_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST)); + } + match(PACKAGE); + break; + } + case FUNCTION: + { + RefMyAST tmp24_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp24_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST)); + } + match(FUNCTION); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + class_type_AST = RefMyAST(currentAST.root); + returnAST = class_type_AST; +} + +void modelica_parser::component_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + type_prefix(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + type_specifier(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == IDENT)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + component_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_clause_AST = RefMyAST(currentAST.root); + returnAST = component_clause_AST; +} + +void modelica_parser::import_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST import_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp25_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp25_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp25_AST)); + } + match(IMPORT); + { + if ((LA(1) == IDENT) && (LA(2) == EQUALS)) { + explicit_import_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == STAR || LA(1) == IDENT) && (_tokenSet_8.member(LA(2)))) { + implicit_import_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + import_clause_AST = RefMyAST(currentAST.root); + returnAST = import_clause_AST; +} + +void modelica_parser::within_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST within_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp26_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp26_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp26_AST)); + } + match(WITHIN); + { + if ((LA(1) == IDENT)) { + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == SEMICOLON)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + within_clause_AST = RefMyAST(currentAST.root); + returnAST = within_clause_AST; +} + +void modelica_parser::class_definition() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_definition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == ENCAPSULATED)) { + RefMyAST tmp27_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp27_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp27_AST)); + } + match(ENCAPSULATED); + } + else if ((_tokenSet_2.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == PARTIAL)) { + RefMyAST tmp28_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp28_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST)); + } + match(PARTIAL); + } + else if ((_tokenSet_3.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + class_type(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + class_specifier(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + class_definition_AST = RefMyAST(currentAST.root); +#line 150 "modelica_parser.g" + + class_definition_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CLASS_DEFINITION,"CLASS_DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(class_definition_AST)))); + +#line 594 "modelica_parser.cpp" + currentAST.root = class_definition_AST; + if ( class_definition_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + class_definition_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = class_definition_AST->getFirstChild(); + else + currentAST.child = class_definition_AST; + currentAST.advanceChildToEnd(); + } + class_definition_AST = RefMyAST(currentAST.root); + returnAST = class_definition_AST; +} + +void modelica_parser::name_path() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST name_path_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((LA(1) == IDENT) && (_tokenSet_9.member(LA(2))))&&( LA(2)!=DOT )) { + RefMyAST tmp29_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp29_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp29_AST)); + } + match(IDENT); + name_path_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == IDENT) && (LA(2) == DOT)) { + RefMyAST tmp30_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp30_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp30_AST)); + } + match(IDENT); + RefMyAST tmp31_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp31_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp31_AST)); + } + match(DOT); + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + name_path_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = name_path_AST; +} + +void modelica_parser::class_specifier() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_specifier_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ((LA(1) == IDENT)) { + RefMyAST tmp32_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp32_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp32_AST)); + } + match(IDENT); + class_specifier2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + class_specifier_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == EXTENDS)) { + match(EXTENDS); + RefMyAST tmp34_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp34_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp34_AST)); + } + match(IDENT); + { + if ((LA(1) == LPAR)) { + class_modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_10.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + string_comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + composition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(IDENT); + if ( inputState->guessing==0 ) { + class_specifier_AST = RefMyAST(currentAST.root); +#line 166 "modelica_parser.g" + + class_specifier_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CLASS_EXTENDS,"CLASS_EXTENDS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(class_specifier_AST)))); + +#line 703 "modelica_parser.cpp" + currentAST.root = class_specifier_AST; + if ( class_specifier_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + class_specifier_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = class_specifier_AST->getFirstChild(); + else + currentAST.child = class_specifier_AST; + currentAST.advanceChildToEnd(); + } + class_specifier_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = class_specifier_AST; +} + +void modelica_parser::class_specifier2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_specifier2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((_tokenSet_10.member(LA(1)))) { + string_comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + composition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(IDENT); + } + else if ((LA(1) == EQUALS) && (_tokenSet_11.member(LA(2)))) { + RefMyAST tmp39_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp39_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp39_AST)); + } + match(EQUALS); + base_prefix(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_12.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == LPAR)) { + class_modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_13.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == EQUALS) && (LA(2) == ENUMERATION)) { + RefMyAST tmp40_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp40_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp40_AST)); + } + match(EQUALS); + enumeration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == EQUALS) && (LA(2) == DER)) { + RefMyAST tmp41_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp41_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp41_AST)); + } + match(EQUALS); + pder(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == EQUALS) && (LA(2) == OVERLOAD)) { + RefMyAST tmp42_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp42_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp42_AST)); + } + match(EQUALS); + overloading(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + class_specifier2_AST = RefMyAST(currentAST.root); + returnAST = class_specifier2_AST; +} + +void modelica_parser::class_modification() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAR); + { + if ((_tokenSet_14.member(LA(1)))) { + argument_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(RPAR); + if ( inputState->guessing==0 ) { + class_modification_AST = RefMyAST(currentAST.root); +#line 446 "modelica_parser.g" + + class_modification_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CLASS_MODIFICATION,"CLASS_MODIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(class_modification_AST)))); + +#line 859 "modelica_parser.cpp" + currentAST.root = class_modification_AST; + if ( class_modification_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + class_modification_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = class_modification_AST->getFirstChild(); + else + currentAST.child = class_modification_AST; + currentAST.advanceChildToEnd(); + } + class_modification_AST = RefMyAST(currentAST.root); + returnAST = class_modification_AST; +} + +void modelica_parser::string_comment() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST string_comment_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == STRING)) { + RefMyAST tmp45_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp45_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp45_AST)); + } + match(STRING); + { + bool synPredMatched271 = false; + if (((LA(1) == PLUS))) { + int _m271 = mark(); + synPredMatched271 = true; + inputState->guessing++; + try { + { + match(PLUS); + match(STRING); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched271 = false; + } + rewind(_m271); + inputState->guessing--; + } + if ( synPredMatched271 ) { + { // ( ... )+ + int _cnt273=0; + for (;;) { + if ((LA(1) == PLUS)) { + RefMyAST tmp46_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp46_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp46_AST)); + } + match(PLUS); + RefMyAST tmp47_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp47_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp47_AST)); + } + match(STRING); + } + else { + if ( _cnt273>=1 ) { goto _loop273; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + + _cnt273++; + } + _loop273:; + } // ( ... )+ + } + else if ((_tokenSet_15.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + else if ((_tokenSet_15.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + string_comment_AST = RefMyAST(currentAST.root); +#line 1059 "modelica_parser.g" + + if (string_comment_AST) + { + string_comment_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(STRING_COMMENT,"STRING_COMMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(string_comment_AST)))); + } + +#line 954 "modelica_parser.cpp" + currentAST.root = string_comment_AST; + if ( string_comment_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + string_comment_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = string_comment_AST->getFirstChild(); + else + currentAST.child = string_comment_AST; + currentAST.advanceChildToEnd(); + } + string_comment_AST = RefMyAST(currentAST.root); + returnAST = string_comment_AST; +} + +void modelica_parser::composition() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST composition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PUBLIC: + { + public_element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PROTECTED: + { + protected_element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case EQUATION: + { + equation_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ALGORITHM: + { + algorithm_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + if ((LA(1) == INITIAL) && (LA(2) == EQUATION)) { + initial_equation_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == INITIAL) && (LA(2) == ALGORITHM)) { + initial_algorithm_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop44; + } + } + } + _loop44:; + } // ( ... )* + { + if ((LA(1) == EXTERNAL)) { + external_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == END)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + composition_AST = RefMyAST(currentAST.root); + returnAST = composition_AST; +} + +void modelica_parser::base_prefix() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST base_prefix_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + type_prefix(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + base_prefix_AST = RefMyAST(currentAST.root); + returnAST = base_prefix_AST; +} + +void modelica_parser::array_subscripts() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST array_subscripts_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp48_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp48_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp48_AST)); + } + match(LBRACK); + subscript(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + subscript(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop262; + } + + } + _loop262:; + } // ( ... )* + match(RBRACK); + array_subscripts_AST = RefMyAST(currentAST.root); + returnAST = array_subscripts_AST; +} + +void modelica_parser::comment() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST comment_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + string_comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_16.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + if ( inputState->guessing==0 ) { + comment_AST = RefMyAST(currentAST.root); +#line 1052 "modelica_parser.g" + + comment_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMMENT,"COMMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(comment_AST)))); + +#line 1129 "modelica_parser.cpp" + currentAST.root = comment_AST; + if ( comment_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + comment_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = comment_AST->getFirstChild(); + else + currentAST.child = comment_AST; + currentAST.advanceChildToEnd(); + } + comment_AST = RefMyAST(currentAST.root); + returnAST = comment_AST; +} + +void modelica_parser::enumeration() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enumeration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp51_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp51_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp51_AST)); + } + match(ENUMERATION); + match(LPAR); + { + if ((LA(1) == IDENT)) { + enum_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == COLON)) { + RefMyAST tmp53_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp53_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp53_AST)); + } + match(COLON); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(RPAR); + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + enumeration_AST = RefMyAST(currentAST.root); + returnAST = enumeration_AST; +} + +void modelica_parser::pder() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST pder_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp55_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp55_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp55_AST)); + } + match(DER); + match(LPAR); + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(COMMA); + ident_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAR); + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + pder_AST = RefMyAST(currentAST.root); + returnAST = pder_AST; +} + +void modelica_parser::overloading() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST overloading_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp59_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp59_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp59_AST)); + } + match(OVERLOAD); + match(LPAR); + name_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAR); + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + overloading_AST = RefMyAST(currentAST.root); + returnAST = overloading_AST; +} + +void modelica_parser::ident_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST ident_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ((LA(1) == IDENT) && (LA(2) == RPAR)) { + RefMyAST tmp62_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp62_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp62_AST)); + } + match(IDENT); + ident_list_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == IDENT) && (LA(2) == COMMA)) { + RefMyAST tmp63_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp63_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp63_AST)); + } + match(IDENT); + match(COMMA); + ident_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + ident_list_AST = RefMyAST(currentAST.root); +#line 185 "modelica_parser.g" + + ident_list_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(IDENT_LIST,"IDENT_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(ident_list_AST)))); + +#line 1270 "modelica_parser.cpp" + currentAST.root = ident_list_AST; + if ( ident_list_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + ident_list_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = ident_list_AST->getFirstChild(); + else + currentAST.child = ident_list_AST; + currentAST.advanceChildToEnd(); + } + ident_list_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = ident_list_AST; +} + +void modelica_parser::name_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST name_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop35; + } + + } + _loop35:; + } // ( ... )* + name_list_AST = RefMyAST(currentAST.root); + returnAST = name_list_AST; +} + +void modelica_parser::type_prefix() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST type_prefix_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == FLOW)) { + RefMyAST tmp66_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp66_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp66_AST)); + } + match(FLOW); + } + else if ((_tokenSet_17.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + switch ( LA(1)) { + case DISCRETE: + { + RefMyAST tmp67_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp67_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp67_AST)); + } + match(DISCRETE); + break; + } + case PARAMETER: + { + RefMyAST tmp68_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp68_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp68_AST)); + } + match(PARAMETER); + break; + } + case CONSTANT: + { + RefMyAST tmp69_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp69_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp69_AST)); + } + match(CONSTANT); + break; + } + case INPUT: + case OUTPUT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case INPUT: + { + RefMyAST tmp70_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp70_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp70_AST)); + } + match(INPUT); + break; + } + case OUTPUT: + { + RefMyAST tmp71_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp71_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp71_AST)); + } + match(OUTPUT); + break; + } + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + type_prefix_AST = RefMyAST(currentAST.root); + returnAST = type_prefix_AST; +} + +void modelica_parser::enum_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enum_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + enumeration_literal(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + enumeration_literal(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop40; + } + + } + _loop40:; + } // ( ... )* + enum_list_AST = RefMyAST(currentAST.root); + returnAST = enum_list_AST; +} + +void modelica_parser::enumeration_literal() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enumeration_literal_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp73_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp73_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp73_AST)); + } + match(IDENT); + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + enumeration_literal_AST = RefMyAST(currentAST.root); +#line 212 "modelica_parser.g" + + enumeration_literal_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENUMERATION_LITERAL,"ENUMERATION_LITERAL")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(enumeration_literal_AST)))); + +#line 1468 "modelica_parser.cpp" + currentAST.root = enumeration_literal_AST; + if ( enumeration_literal_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + enumeration_literal_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = enumeration_literal_AST->getFirstChild(); + else + currentAST.child = enumeration_literal_AST; + currentAST.advanceChildToEnd(); + } + enumeration_literal_AST = RefMyAST(currentAST.root); + returnAST = enumeration_literal_AST; +} + +void modelica_parser::element_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefMyAST s_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + if ((_tokenSet_18.member(LA(1)))) { + { + if ((_tokenSet_19.member(LA(1)))) { + element(); + if (inputState->guessing==0) { + e_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + a_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + } + match(SEMICOLON); + if ( inputState->guessing==0 ) { +#line 269 "modelica_parser.g" + + /* adrpo, fix the end of this AST node */ + if (e_AST) + { + /* + std::cout << (#e)->toString() << std::endl; + std::cout << s->getLine() << ":" << s->getColumn() << std::endl; + */ + RefMyAST(e_AST)->setEndLine(s->getLine()); + RefMyAST(e_AST)->setEndColumn(s->getColumn()); + if (e_AST->getFirstChild()) + { + /* + std::cout << (#e->getFirstChild())->toString() << std::endl; + std::cout << s->getLine() << ":" << s->getColumn() << std::endl; + */ + RefMyAST(e_AST->getFirstChild())->setEndLine(s->getLine()); + RefMyAST(e_AST->getFirstChild())->setEndColumn(s->getColumn()); + } + } + + +#line 1542 "modelica_parser.cpp" + } + } + else { + goto _loop61; + } + + } + _loop61:; + } // ( ... )* + element_list_AST = RefMyAST(currentAST.root); + returnAST = element_list_AST; +} + +void modelica_parser::public_element_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST public_element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp74_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp74_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp74_AST)); + } + match(PUBLIC); + element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + public_element_list_AST = RefMyAST(currentAST.root); + returnAST = public_element_list_AST; +} + +void modelica_parser::protected_element_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST protected_element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp75_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp75_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp75_AST)); + } + match(PROTECTED); + element_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + protected_element_list_AST = RefMyAST(currentAST.root); + returnAST = protected_element_list_AST; +} + +void modelica_parser::initial_equation_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST initial_equation_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ec_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (!( LA(2)==EQUATION)) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" LA(2)==EQUATION"); + match(INITIAL); + equation_clause(); + if (inputState->guessing==0) { + ec_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + initial_equation_clause_AST = RefMyAST(currentAST.root); +#line 503 "modelica_parser.g" + + initial_equation_clause_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INITIAL_EQUATION,"INTIAL_EQUATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(ec_AST)))); + +#line 1614 "modelica_parser.cpp" + currentAST.root = initial_equation_clause_AST; + if ( initial_equation_clause_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + initial_equation_clause_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = initial_equation_clause_AST->getFirstChild(); + else + currentAST.child = initial_equation_clause_AST; + currentAST.advanceChildToEnd(); + } + initial_equation_clause_AST = RefMyAST(currentAST.root); + returnAST = initial_equation_clause_AST; +} + +void modelica_parser::initial_algorithm_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST initial_algorithm_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (!( LA(2)==ALGORITHM)) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" LA(2)==ALGORITHM"); + match(INITIAL); + RefMyAST tmp78_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp78_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp78_AST)); + } + match(ALGORITHM); + { // ( ... )* + for (;;) { + if ((_tokenSet_20.member(LA(1)))) { + algorithm(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + goto _loop130; + } + + } + _loop130:; + } // ( ... )* + if ( inputState->guessing==0 ) { + initial_algorithm_clause_AST = RefMyAST(currentAST.root); +#line 574 "modelica_parser.g" + + initial_algorithm_clause_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INITIAL_ALGORITHM,"INTIAL_ALGORITHM")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(initial_algorithm_clause_AST)))); + +#line 1670 "modelica_parser.cpp" + currentAST.root = initial_algorithm_clause_AST; + if ( initial_algorithm_clause_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + initial_algorithm_clause_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = initial_algorithm_clause_AST->getFirstChild(); + else + currentAST.child = initial_algorithm_clause_AST; + currentAST.advanceChildToEnd(); + } + initial_algorithm_clause_AST = RefMyAST(currentAST.root); + returnAST = initial_algorithm_clause_AST; +} + +void modelica_parser::equation_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp81_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp81_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp81_AST)); + } + match(EQUATION); + equation_annotation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equation_clause_AST = RefMyAST(currentAST.root); + returnAST = equation_clause_AST; +} + +void modelica_parser::algorithm_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp82_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp82_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp82_AST)); + } + match(ALGORITHM); + { // ( ... )* + for (;;) { + if ((_tokenSet_20.member(LA(1)))) { + algorithm(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + goto _loop127; + } + + } + _loop127:; + } // ( ... )* + algorithm_clause_AST = RefMyAST(currentAST.root); + returnAST = algorithm_clause_AST; +} + +void modelica_parser::external_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST external_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp85_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp85_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp85_AST)); + } + match(EXTERNAL); + { + if ((LA(1) == STRING)) { + language_specification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == ANNOTATION || LA(1) == SEMICOLON || LA(1) == IDENT)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == IDENT)) { + external_function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == ANNOTATION || LA(1) == SEMICOLON)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == SEMICOLON)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(SEMICOLON); + { + if ((LA(1) == ANNOTATION)) { + external_annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == END)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + external_clause_AST = RefMyAST(currentAST.root); + returnAST = external_clause_AST; +} + +void modelica_parser::language_specification() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST language_specification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp87_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp87_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp87_AST)); + } + match(STRING); + language_specification_AST = RefMyAST(currentAST.root); + returnAST = language_specification_AST; +} + +void modelica_parser::external_function_call() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST external_function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == IDENT) && (LA(2) == DOT || LA(2) == LBRACK || LA(2) == EQUALS)) { + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + RefMyAST tmp88_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp88_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp88_AST)); + } + match(EQUALS); + } + else if ((LA(1) == IDENT) && (LA(2) == LPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + RefMyAST tmp89_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp89_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp89_AST)); + } + match(IDENT); + match(LPAR); + { + if ((_tokenSet_21.member(LA(1)))) { + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(RPAR); + if ( inputState->guessing==0 ) { + external_function_call_AST = RefMyAST(currentAST.root); +#line 261 "modelica_parser.g" + + external_function_call_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXTERNAL_FUNCTION_CALL,"EXTERNAL_FUNCTION_CALL")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(external_function_call_AST)))); + +#line 1880 "modelica_parser.cpp" + currentAST.root = external_function_call_AST; + if ( external_function_call_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + external_function_call_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = external_function_call_AST->getFirstChild(); + else + currentAST.child = external_function_call_AST; + currentAST.advanceChildToEnd(); + } + external_function_call_AST = RefMyAST(currentAST.root); + returnAST = external_function_call_AST; +} + +void modelica_parser::annotation() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST annotation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp92_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp92_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp92_AST)); + } + match(ANNOTATION); + class_modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + annotation_AST = RefMyAST(currentAST.root); + returnAST = annotation_AST; +} + +void modelica_parser::external_annotation() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST external_annotation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + if ( inputState->guessing==0 ) { + external_annotation_AST = RefMyAST(currentAST.root); +#line 240 "modelica_parser.g" + + external_annotation_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXTERNAL_ANNOTATION,"EXTERNAL_ANNOTATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(external_annotation_AST)))); + +#line 1928 "modelica_parser.cpp" + currentAST.root = external_annotation_AST; + if ( external_annotation_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + external_annotation_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = external_annotation_AST->getFirstChild(); + else + currentAST.child = external_annotation_AST; + currentAST.advanceChildToEnd(); + } + external_annotation_AST = RefMyAST(currentAST.root); + returnAST = external_annotation_AST; +} + +void modelica_parser::component_reference() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_reference_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp94_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp94_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp94_AST)); + } + match(IDENT); + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_22.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == DOT)) { + RefMyAST tmp95_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp95_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp95_AST)); + } + match(DOT); + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_23.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + component_reference_AST = RefMyAST(currentAST.root); + returnAST = component_reference_AST; +} + +void modelica_parser::expression_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + expression_list2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + expression_list_AST = RefMyAST(currentAST.root); +#line 1031 "modelica_parser.g" + + expression_list_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXPRESSION_LIST,"EXPRESSION_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(expression_list_AST)))); + +#line 2005 "modelica_parser.cpp" + currentAST.root = expression_list_AST; + if ( expression_list_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + expression_list_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = expression_list_AST->getFirstChild(); + else + currentAST.child = expression_list_AST; + currentAST.advanceChildToEnd(); + } + expression_list_AST = RefMyAST(currentAST.root); + returnAST = expression_list_AST; +} + +void modelica_parser::element() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ic_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ec_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST cc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST cc2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case IMPORT: + { + import_clause(); + if (inputState->guessing==0) { + ic_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + element_AST = RefMyAST(currentAST.root); + break; + } + case EXTENDS: + { + extends_clause(); + if (inputState->guessing==0) { + ec_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + element_AST = RefMyAST(currentAST.root); + break; + } + case BLOCK: + case CLASS: + case CONNECTOR: + case CONSTANT: + case DISCRETE: + case ENCAPSULATED: + case EXPANDABLE: + case FINAL: + case FLOW: + case FUNCTION: + case INNER: + case INPUT: + case MODEL: + case OUTER: + case OUTPUT: + case PACKAGE: + case PARAMETER: + case PARTIAL: + case RECORD: + case REDECLARE: + case REPLACEABLE: + case TYPE: + case IDENT: + { + { + if ((LA(1) == REDECLARE)) { + RefMyAST tmp96_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp96_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp96_AST)); + } + match(REDECLARE); + } + else if ((_tokenSet_24.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == FINAL)) { + RefMyAST tmp97_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp97_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp97_AST)); + } + match(FINAL); + } + else if ((_tokenSet_25.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == INNER)) { + RefMyAST tmp98_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp98_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp98_AST)); + } + match(INNER); + } + else if ((_tokenSet_26.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == OUTER)) { + RefMyAST tmp99_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp99_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp99_AST)); + } + match(OUTER); + } + else if ((_tokenSet_27.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((_tokenSet_28.member(LA(1)))) { + { + if ((_tokenSet_0.member(LA(1)))) { + class_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_11.member(LA(1)))) { + component_clause(); + if (inputState->guessing==0) { + cc_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + else if ((LA(1) == REPLACEABLE)) { + { + RefMyAST tmp100_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp100_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp100_AST)); + } + match(REPLACEABLE); + { + if ((_tokenSet_0.member(LA(1)))) { + class_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_11.member(LA(1)))) { + component_clause(); + if (inputState->guessing==0) { + cc2_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == EXTENDS)) { + constraining_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == SEMICOLON)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + element_AST = RefMyAST(currentAST.root); +#line 325 "modelica_parser.g" + + if(cc_AST != null || cc2_AST != null) + { + element_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DECLARATION,"DECLARATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(element_AST)))); + } + else + { + element_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DEFINITION,"DEFINITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(element_AST)))); + } + +#line 2223 "modelica_parser.cpp" + currentAST.root = element_AST; + if ( element_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + element_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = element_AST->getFirstChild(); + else + currentAST.child = element_AST; + currentAST.advanceChildToEnd(); + } + element_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = element_AST; +} + +void modelica_parser::extends_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST extends_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp101_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp101_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp101_AST)); + } + match(EXTENDS); + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == LPAR)) { + class_modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_29.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + extends_clause_AST = RefMyAST(currentAST.root); + returnAST = extends_clause_AST; +} + +void modelica_parser::constraining_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST constraining_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + extends_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + constraining_clause_AST = RefMyAST(currentAST.root); + returnAST = constraining_clause_AST; +} + +void modelica_parser::explicit_import_name() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST explicit_import_name_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp102_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp102_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp102_AST)); + } + match(IDENT); + RefMyAST tmp103_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp103_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp103_AST)); + } + match(EQUALS); + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + explicit_import_name_AST = RefMyAST(currentAST.root); + returnAST = explicit_import_name_AST; +} + +void modelica_parser::implicit_import_name() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST implicit_import_name_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST np_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 364 "modelica_parser.g" + + bool has_star = false; + +#line 2323 "modelica_parser.cpp" + + has_star=name_path_star(); + if (inputState->guessing==0) { + np_AST = returnAST; + } + if ( inputState->guessing==0 ) { + implicit_import_name_AST = RefMyAST(currentAST.root); +#line 370 "modelica_parser.g" + + if (has_star) + { + implicit_import_name_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(UNQUALIFIED,"UNQUALIFIED")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(np_AST)))); + } + else + { + implicit_import_name_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(QUALIFIED,"QUALIFIED")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(np_AST)))); + } + +#line 2342 "modelica_parser.cpp" + currentAST.root = implicit_import_name_AST; + if ( implicit_import_name_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + implicit_import_name_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = implicit_import_name_AST->getFirstChild(); + else + currentAST.child = implicit_import_name_AST; + currentAST.advanceChildToEnd(); + } + returnAST = implicit_import_name_AST; +} + +bool modelica_parser::name_path_star() { +#line 955 "modelica_parser.g" + bool val=false; +#line 2357 "modelica_parser.cpp" + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST name_path_star_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken i = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST np_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((LA(1) == IDENT) && (_tokenSet_30.member(LA(2))))&&( LA(2)!=DOT )) { + RefMyAST tmp104_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp104_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp104_AST)); + } + match(IDENT); + if ( inputState->guessing==0 ) { +#line 957 "modelica_parser.g" + val=false; +#line 2375 "modelica_parser.cpp" + } + name_path_star_AST = RefMyAST(currentAST.root); + } + else if (((LA(1) == STAR))&&( LA(2)!=DOT )) { + match(STAR); + if ( inputState->guessing==0 ) { +#line 958 "modelica_parser.g" + val=true; +#line 2384 "modelica_parser.cpp" + } + name_path_star_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == IDENT) && (LA(2) == DOT)) { + i = LT(1); + if ( inputState->guessing == 0 ) { + i_AST = astFactory->create(i); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + } + match(IDENT); + RefMyAST tmp106_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp106_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp106_AST)); + } + match(DOT); + val=name_path_star(); + if (inputState->guessing==0) { + np_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + name_path_star_AST = RefMyAST(currentAST.root); +#line 960 "modelica_parser.g" + + if(!(np_AST)) + { + name_path_star_AST = i_AST; + } + +#line 2415 "modelica_parser.cpp" + currentAST.root = name_path_star_AST; + if ( name_path_star_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + name_path_star_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = name_path_star_AST->getFirstChild(); + else + currentAST.child = name_path_star_AST; + currentAST.advanceChildToEnd(); + } + name_path_star_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = name_path_star_AST; + return val; +} + +void modelica_parser::type_specifier() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST type_specifier_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + name_path(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + type_specifier_AST = RefMyAST(currentAST.root); + returnAST = type_specifier_AST; +} + +void modelica_parser::component_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + component_declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + component_declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop88; + } + + } + _loop88:; + } // ( ... )* + component_list_AST = RefMyAST(currentAST.root); + returnAST = component_list_AST; +} + +void modelica_parser::component_declaration() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_declaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == IF)) { + conditional_attribute(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_13.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_declaration_AST = RefMyAST(currentAST.root); + returnAST = component_declaration_AST; +} + +void modelica_parser::declaration() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST declaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp108_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp108_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp108_AST)); + } + match(IDENT); + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_31.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == LPAR || LA(1) == EQUALS || LA(1) == ASSIGN)) { + modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_32.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + declaration_AST = RefMyAST(currentAST.root); + returnAST = declaration_AST; +} + +void modelica_parser::conditional_attribute() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_attribute_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp109_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp109_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp109_AST)); + } + match(IF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + conditional_attribute_AST = RefMyAST(currentAST.root); + returnAST = conditional_attribute_AST; +} + +void modelica_parser::expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IF: + { + if_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case DER: + case END: + case FALSE: + case INITIAL: + case NOT: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + { + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case CODE: + { + code_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + expression_AST = RefMyAST(currentAST.root); + returnAST = expression_AST; +} + +void modelica_parser::modification() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LPAR: + { + class_modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == EQUALS)) { + match(EQUALS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_32.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + break; + } + case EQUALS: + { + RefMyAST tmp111_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp111_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp111_AST)); + } + match(EQUALS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ASSIGN: + { + RefMyAST tmp112_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp112_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp112_AST)); + } + match(ASSIGN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + modification_AST = RefMyAST(currentAST.root); + returnAST = modification_AST; +} + +void modelica_parser::argument_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST argument_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + argument(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + argument(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop102; + } + + } + _loop102:; + } // ( ... )* + if ( inputState->guessing==0 ) { + argument_list_AST = RefMyAST(currentAST.root); +#line 454 "modelica_parser.g" + + argument_list_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ARGUMENT_LIST,"ARGUMENT_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(argument_list_AST)))); + +#line 2723 "modelica_parser.cpp" + currentAST.root = argument_list_AST; + if ( argument_list_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + argument_list_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = argument_list_AST->getFirstChild(); + else + currentAST.child = argument_list_AST; + currentAST.advanceChildToEnd(); + } + argument_list_AST = RefMyAST(currentAST.root); + returnAST = argument_list_AST; +} + +void modelica_parser::argument() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST argument_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST em_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST er_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((_tokenSet_33.member(LA(1)))) { + element_modification_or_replaceable(); + if (inputState->guessing==0) { + em_AST = returnAST; + } + if ( inputState->guessing==0 ) { + argument_AST = RefMyAST(currentAST.root); +#line 461 "modelica_parser.g" + + argument_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELEMENT_MODIFICATION,"ELEMENT_MODIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(em_AST)))); + +#line 2755 "modelica_parser.cpp" + currentAST.root = argument_AST; + if ( argument_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + argument_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = argument_AST->getFirstChild(); + else + currentAST.child = argument_AST; + currentAST.advanceChildToEnd(); + } + } + else if ((LA(1) == REDECLARE)) { + element_redeclaration(); + if (inputState->guessing==0) { + er_AST = returnAST; + } + if ( inputState->guessing==0 ) { + argument_AST = RefMyAST(currentAST.root); +#line 465 "modelica_parser.g" + + argument_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELEMENT_REDECLARATION,"ELEMENT_REDECLARATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(er_AST)))); +#line 2775 "modelica_parser.cpp" + currentAST.root = argument_AST; + if ( argument_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + argument_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = argument_AST->getFirstChild(); + else + currentAST.child = argument_AST; + currentAST.advanceChildToEnd(); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + returnAST = argument_AST; +} + +void modelica_parser::element_modification_or_replaceable() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_modification_or_replaceable_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == EACH)) { + RefMyAST tmp114_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp114_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp114_AST)); + } + match(EACH); + } + else if ((LA(1) == FINAL || LA(1) == REPLACEABLE || LA(1) == IDENT)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == FINAL)) { + RefMyAST tmp115_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp115_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp115_AST)); + } + match(FINAL); + } + else if ((LA(1) == REPLACEABLE || LA(1) == IDENT)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == IDENT)) { + element_modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == REPLACEABLE)) { + element_replaceable(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + element_modification_or_replaceable_AST = RefMyAST(currentAST.root); + returnAST = element_modification_or_replaceable_AST; +} + +void modelica_parser::element_redeclaration() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_redeclaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp116_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp116_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp116_AST)); + } + match(REDECLARE); + { + if ((LA(1) == EACH)) { + RefMyAST tmp117_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp117_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp117_AST)); + } + match(EACH); + } + else if ((_tokenSet_34.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == FINAL)) { + RefMyAST tmp118_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp118_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp118_AST)); + } + match(FINAL); + } + else if ((_tokenSet_27.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((_tokenSet_28.member(LA(1)))) { + { + if ((_tokenSet_0.member(LA(1)))) { + class_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_11.member(LA(1)))) { + component_clause1(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + else if ((LA(1) == REPLACEABLE)) { + element_replaceable(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + element_redeclaration_AST = RefMyAST(currentAST.root); + returnAST = element_redeclaration_AST; +} + +void modelica_parser::element_modification() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == LPAR || LA(1) == EQUALS || LA(1) == ASSIGN)) { + modification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == COMMA || LA(1) == STRING)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + string_comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + element_modification_AST = RefMyAST(currentAST.root); + returnAST = element_modification_AST; +} + +void modelica_parser::element_replaceable() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_replaceable_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp119_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp119_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp119_AST)); + } + match(REPLACEABLE); + { + if ((_tokenSet_0.member(LA(1)))) { + class_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_11.member(LA(1)))) { + component_clause1(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == EXTENDS)) { + constraining_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == COMMA)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + element_replaceable_AST = RefMyAST(currentAST.root); + returnAST = element_replaceable_AST; +} + +void modelica_parser::component_clause1() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_clause1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + type_prefix(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + type_specifier(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_declaration1(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_clause1_AST = RefMyAST(currentAST.root); + returnAST = component_clause1_AST; +} + +void modelica_parser::component_declaration1() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_declaration1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_declaration1_AST = RefMyAST(currentAST.root); + returnAST = component_declaration1_AST; +} + +void modelica_parser::equation_annotation_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_annotation_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((_tokenSet_35.member(LA(1))) && (_tokenSet_36.member(LA(2))))&&( LA(1) == END || LA(1) == EQUATION || LA(1) == ALGORITHM || LA(1)==INITIAL + || LA(1) == PROTECTED || LA(1) == PUBLIC )) { + equation_annotation_list_AST = RefMyAST(currentAST.root); + } + else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_38.member(LA(2)))) { + { + if ((_tokenSet_39.member(LA(1)))) { + equation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + equation_annotation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equation_annotation_list_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = equation_annotation_list_AST; +} + +void modelica_parser::equation() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IF: + { + conditional_equation_e(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR: + { + for_clause_e(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case CONNECT: + { + connect_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case WHEN: + { + when_clause_e(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + bool synPredMatched134 = false; + if (((_tokenSet_40.member(LA(1))) && (_tokenSet_38.member(LA(2))))) { + int _m134 = mark(); + synPredMatched134 = true; + inputState->guessing++; + try { + { + simple_expression(); + match(EQUALS); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched134 = false; + } + rewind(_m134); + inputState->guessing--; + } + if ( synPredMatched134 ) { + equality_equation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == IDENT) && (LA(2) == LPAR)) { + RefMyAST tmp122_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp122_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp122_AST)); + } + match(IDENT); + function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + equation_AST = RefMyAST(currentAST.root); +#line 607 "modelica_parser.g" + + equation_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EQUATION_STATEMENT,"EQUATION_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(equation_AST)))); + +#line 3180 "modelica_parser.cpp" + currentAST.root = equation_AST; + if ( equation_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + equation_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = equation_AST->getFirstChild(); + else + currentAST.child = equation_AST; + currentAST.advanceChildToEnd(); + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equation_AST = RefMyAST(currentAST.root); + returnAST = equation_AST; +} + +void modelica_parser::algorithm() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IDENT: + { + assign_clause_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case LPAR: + { + multi_assign_clause_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IF: + { + conditional_equation_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR: + { + for_clause_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case WHILE: + { + while_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case WHEN: + { + when_clause_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + comment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + algorithm_AST = RefMyAST(currentAST.root); +#line 641 "modelica_parser.g" + + algorithm_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ALGORITHM_STATEMENT,"ALGORITHM_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(algorithm_AST)))); + +#line 3268 "modelica_parser.cpp" + currentAST.root = algorithm_AST; + if ( algorithm_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + algorithm_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = algorithm_AST->getFirstChild(); + else + currentAST.child = algorithm_AST; + currentAST.advanceChildToEnd(); + } + algorithm_AST = RefMyAST(currentAST.root); + returnAST = algorithm_AST; +} + +void modelica_parser::simple_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST simple_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST l1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST l2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST l3_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + logical_expression(); + if (inputState->guessing==0) { + l1_AST = returnAST; + } + { + if ((LA(1) == COLON)) { + RefMyAST tmp123_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp123_AST = astFactory->create(LT(1)); + } + match(COLON); + logical_expression(); + if (inputState->guessing==0) { + l2_AST = returnAST; + } + { + if ((LA(1) == COLON)) { + RefMyAST tmp124_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp124_AST = astFactory->create(LT(1)); + } + match(COLON); + logical_expression(); + if (inputState->guessing==0) { + l3_AST = returnAST; + } + } + else if ((_tokenSet_41.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + else if ((_tokenSet_41.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + simple_expression_AST = RefMyAST(currentAST.root); +#line 801 "modelica_parser.g" + + if (l3_AST != null) + { + simple_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(4))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(RANGE3,"RANGE3")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l1_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l2_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l3_AST)))); + } + else if (l2_AST != null) + { + simple_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(3))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(RANGE2,"RANGE2")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l1_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(l2_AST)))); + } + else + { + simple_expression_AST = l1_AST; + } + +#line 3348 "modelica_parser.cpp" + currentAST.root = simple_expression_AST; + if ( simple_expression_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + simple_expression_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = simple_expression_AST->getFirstChild(); + else + currentAST.child = simple_expression_AST; + currentAST.advanceChildToEnd(); + } + returnAST = simple_expression_AST; +} + +void modelica_parser::equality_equation() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equality_equation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + RefMyAST tmp125_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp125_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp125_AST)); + } + match(EQUALS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equality_equation_AST = RefMyAST(currentAST.root); + returnAST = equality_equation_AST; +} + +void modelica_parser::conditional_equation_e() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_equation_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp126_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp126_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp126_AST)); + } + match(IF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEIF)) { + equation_elseif(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop143; + } + + } + _loop143:; + } // ( ... )* + { + if ((LA(1) == ELSE)) { + RefMyAST tmp128_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp128_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp128_AST)); + } + match(ELSE); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == END)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(END); + match(IF); + conditional_equation_e_AST = RefMyAST(currentAST.root); + returnAST = conditional_equation_e_AST; +} + +void modelica_parser::for_clause_e() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_clause_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp131_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp131_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp131_AST)); + } + match(FOR); + for_indices(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(LOOP); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(FOR); + for_clause_e_AST = RefMyAST(currentAST.root); + returnAST = for_clause_e_AST; +} + +void modelica_parser::connect_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST connect_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp135_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp135_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp135_AST)); + } + match(CONNECT); + match(LPAR); + connector_ref(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(COMMA); + connector_ref(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAR); + connect_clause_AST = RefMyAST(currentAST.root); + returnAST = connect_clause_AST; +} + +void modelica_parser::when_clause_e() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST when_clause_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp139_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp139_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp139_AST)); + } + match(WHEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEWHEN)) { + else_when_e(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop154; + } + + } + _loop154:; + } // ( ... )* + match(END); + match(WHEN); + when_clause_e_AST = RefMyAST(currentAST.root); + returnAST = when_clause_e_AST; +} + +void modelica_parser::function_call() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAR); + { + function_arguments(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + match(RPAR); + if ( inputState->guessing==0 ) { + function_call_AST = RefMyAST(currentAST.root); +#line 974 "modelica_parser.g" + + function_call_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FUNCTION_ARGUMENTS,"FUNCTION_ARGUMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(function_call_AST)))); + +#line 3556 "modelica_parser.cpp" + currentAST.root = function_call_AST; + if ( function_call_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + function_call_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = function_call_AST->getFirstChild(); + else + currentAST.child = function_call_AST; + currentAST.advanceChildToEnd(); + } + function_call_AST = RefMyAST(currentAST.root); + returnAST = function_call_AST; +} + +void modelica_parser::assign_clause_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST assign_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == ASSIGN)) { + RefMyAST tmp145_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp145_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp145_AST)); + } + match(ASSIGN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == LPAR)) { + function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + assign_clause_a_AST = RefMyAST(currentAST.root); + returnAST = assign_clause_a_AST; +} + +void modelica_parser::multi_assign_clause_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST multi_assign_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAR); + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAR); + RefMyAST tmp148_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp148_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp148_AST)); + } + match(ASSIGN); + component_reference(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + multi_assign_clause_a_AST = RefMyAST(currentAST.root); + returnAST = multi_assign_clause_a_AST; +} + +void modelica_parser::conditional_equation_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_equation_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp149_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp149_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp149_AST)); + } + match(IF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEIF)) { + algorithm_elseif(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop147; + } + + } + _loop147:; + } // ( ... )* + { + if ((LA(1) == ELSE)) { + RefMyAST tmp151_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp151_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp151_AST)); + } + match(ELSE); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == END)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(END); + match(IF); + conditional_equation_a_AST = RefMyAST(currentAST.root); + returnAST = conditional_equation_a_AST; +} + +void modelica_parser::for_clause_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp154_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp154_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp154_AST)); + } + match(FOR); + for_indices(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(LOOP); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(FOR); + for_clause_a_AST = RefMyAST(currentAST.root); + returnAST = for_clause_a_AST; +} + +void modelica_parser::while_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST while_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp158_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp158_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp158_AST)); + } + match(WHILE); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(LOOP); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(WHILE); + while_clause_AST = RefMyAST(currentAST.root); + returnAST = while_clause_AST; +} + +void modelica_parser::when_clause_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST when_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp162_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp162_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp162_AST)); + } + match(WHEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEWHEN)) { + else_when_a(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop158; + } + + } + _loop158:; + } // ( ... )* + match(END); + match(WHEN); + when_clause_a_AST = RefMyAST(currentAST.root); + returnAST = when_clause_a_AST; +} + +void modelica_parser::equation_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ((((LA(1) >= ELSE && LA(1) <= END)) && (_tokenSet_42.member(LA(2))))&&(LA(1) != END || (LA(1) == END && LA(2) != IDENT))) { + equation_list_AST = RefMyAST(currentAST.root); + } + else if ((_tokenSet_39.member(LA(1))) && (_tokenSet_38.member(LA(2)))) { + { + equation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + equation_list_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = equation_list_AST; +} + +void modelica_parser::equation_elseif() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_elseif_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp167_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp167_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp167_AST)); + } + match(ELSEIF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + equation_elseif_AST = RefMyAST(currentAST.root); + returnAST = equation_elseif_AST; +} + +void modelica_parser::algorithm_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + if ((_tokenSet_20.member(LA(1)))) { + algorithm(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + goto _loop166; + } + + } + _loop166:; + } // ( ... )* + algorithm_list_AST = RefMyAST(currentAST.root); + returnAST = algorithm_list_AST; +} + +void modelica_parser::algorithm_elseif() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_elseif_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp170_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp170_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp170_AST)); + } + match(ELSEIF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + algorithm_elseif_AST = RefMyAST(currentAST.root); + returnAST = algorithm_elseif_AST; +} + +void modelica_parser::for_indices() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_indices_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + for_index(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + for_indices2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + for_indices_AST = RefMyAST(currentAST.root); + returnAST = for_indices_AST; +} + +void modelica_parser::else_when_e() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST else_when_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp172_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp172_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp172_AST)); + } + match(ELSEWHEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + equation_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else_when_e_AST = RefMyAST(currentAST.root); + returnAST = else_when_e_AST; +} + +void modelica_parser::else_when_a() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST else_when_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp174_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp174_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp174_AST)); + } + match(ELSEWHEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + algorithm_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else_when_a_AST = RefMyAST(currentAST.root); + returnAST = else_when_a_AST; +} + +void modelica_parser::connector_ref() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST connector_ref_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp176_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp176_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp176_AST)); + } + match(IDENT); + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == DOT || LA(1) == RPAR || LA(1) == COMMA)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + if ((LA(1) == DOT)) { + RefMyAST tmp177_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp177_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp177_AST)); + } + match(DOT); + connector_ref_2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == COMMA)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + connector_ref_AST = RefMyAST(currentAST.root); + returnAST = connector_ref_AST; +} + +void modelica_parser::connector_ref_2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST connector_ref_2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp178_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp178_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp178_AST)); + } + match(IDENT); + { + if ((LA(1) == LBRACK)) { + array_subscripts(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == COMMA)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + connector_ref_2_AST = RefMyAST(currentAST.root); + returnAST = connector_ref_2_AST; +} + +void modelica_parser::if_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST if_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp179_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp179_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp179_AST)); + } + match(IF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == ELSEIF)) { + elseif_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop177; + } + + } + _loop177:; + } // ( ... )* + match(ELSE); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if_expression_AST = RefMyAST(currentAST.root); + returnAST = if_expression_AST; +} + +void modelica_parser::code_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST code_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST m_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ieq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST alg_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ialg_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp182_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp182_AST = astFactory->create(LT(1)); + } + match(CODE); + RefMyAST tmp183_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp183_AST = astFactory->create(LT(1)); + } + match(LPAR); + { + bool synPredMatched191 = false; + if (((_tokenSet_21.member(LA(1))) && (_tokenSet_43.member(LA(2))))) { + int _m191 = mark(); + synPredMatched191 = true; + inputState->guessing++; + try { + { + expression(); + match(RPAR); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched191 = false; + } + rewind(_m191); + inputState->guessing--; + } + if ( synPredMatched191 ) { + expression(); + if (inputState->guessing==0) { + e_AST = returnAST; + } + } + else if ((LA(1) == LPAR || LA(1) == EQUALS || LA(1) == ASSIGN) && (_tokenSet_44.member(LA(2)))) { + modification(); + if (inputState->guessing==0) { + m_AST = returnAST; + } + } + else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { + element(); + if (inputState->guessing==0) { + el_AST = returnAST; + } + { + if ((LA(1) == SEMICOLON)) { + match(SEMICOLON); + } + else if ((LA(1) == RPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + else if ((LA(1) == EQUATION)) { + code_equation_clause(); + if (inputState->guessing==0) { + eq_AST = returnAST; + } + } + else if ((LA(1) == INITIAL) && (LA(2) == EQUATION)) { + code_initial_equation_clause(); + if (inputState->guessing==0) { + ieq_AST = returnAST; + } + } + else if ((LA(1) == ALGORITHM)) { + code_algorithm_clause(); + if (inputState->guessing==0) { + alg_AST = returnAST; + } + } + else if ((LA(1) == INITIAL) && (LA(2) == ALGORITHM)) { + code_initial_algorithm_clause(); + if (inputState->guessing==0) { + ialg_AST = returnAST; + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + RefMyAST tmp185_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp185_AST = astFactory->create(LT(1)); + } + match(RPAR); + if ( inputState->guessing==0 ) { + code_expression_AST = RefMyAST(currentAST.root); +#line 822 "modelica_parser.g" + + if (e_AST) { + code_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CODE_EXPRESSION,"CODE_EXPRESSION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)))); + } else if (m_AST) { + code_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CODE_MODIFICATION,"CODE_MODIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(m_AST)))); + } else if (el_AST) { + code_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CODE_ELEMENT,"CODE_ELEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(el_AST)))); + } else if (eq_AST) { + code_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CODE_EQUATION,"CODE_EQUATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)))); + } else if (ieq_AST) { + code_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CODE_INITIALEQUATION,"CODE_EQUATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(ieq_AST)))); + } else if (alg_AST) { + code_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CODE_ALGORITHM,"CODE_ALGORITHM")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(alg_AST)))); + } else if (ialg_AST) { + code_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CODE_INITIALALGORITHM,"CODE_ALGORITHM")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(ialg_AST)))); + } + +#line 4201 "modelica_parser.cpp" + currentAST.root = code_expression_AST; + if ( code_expression_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + code_expression_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = code_expression_AST->getFirstChild(); + else + currentAST.child = code_expression_AST; + currentAST.advanceChildToEnd(); + } + returnAST = code_expression_AST; +} + +void modelica_parser::elseif_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST elseif_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp186_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp186_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp186_AST)); + } + match(ELSEIF); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + elseif_expression_AST = RefMyAST(currentAST.root); + returnAST = elseif_expression_AST; +} + +void modelica_parser::for_index() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_index_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + RefMyAST tmp188_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp188_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp188_AST)); + } + match(IDENT); + { + if ((LA(1) == IN)) { + RefMyAST tmp189_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp189_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp189_AST)); + } + match(IN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_46.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + } + for_index_AST = RefMyAST(currentAST.root); + returnAST = for_index_AST; +} + +void modelica_parser::for_indices2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_indices2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((_tokenSet_47.member(LA(1))))&&(LA(2) != IN)) { + for_indices2_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == COMMA)) { + { + match(COMMA); + for_index(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + for_indices2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + for_indices2_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = for_indices2_AST; +} + +void modelica_parser::logical_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + logical_term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == OR)) { + RefMyAST tmp191_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp191_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp191_AST)); + } + match(OR); + logical_term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop206; + } + + } + _loop206:; + } // ( ... )* + logical_expression_AST = RefMyAST(currentAST.root); + returnAST = logical_expression_AST; +} + +void modelica_parser::code_equation_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST code_equation_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + RefMyAST tmp192_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp192_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp192_AST)); + } + match(EQUATION); + { // ( ... )* + for (;;) { + if ((_tokenSet_39.member(LA(1)))) { + equation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + goto _loop196; + } + + } + _loop196:; + } // ( ... )* + } + code_equation_clause_AST = RefMyAST(currentAST.root); + returnAST = code_equation_clause_AST; +} + +void modelica_parser::code_initial_equation_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST code_initial_equation_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ec_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (!( LA(2)==EQUATION)) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" LA(2)==EQUATION"); + match(INITIAL); + code_equation_clause(); + if (inputState->guessing==0) { + ec_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + code_initial_equation_clause_AST = RefMyAST(currentAST.root); +#line 848 "modelica_parser.g" + + code_initial_equation_clause_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INITIAL_EQUATION,"INTIAL_EQUATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(ec_AST)))); + +#line 4397 "modelica_parser.cpp" + currentAST.root = code_initial_equation_clause_AST; + if ( code_initial_equation_clause_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + code_initial_equation_clause_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = code_initial_equation_clause_AST->getFirstChild(); + else + currentAST.child = code_initial_equation_clause_AST; + currentAST.advanceChildToEnd(); + } + code_initial_equation_clause_AST = RefMyAST(currentAST.root); + returnAST = code_initial_equation_clause_AST; +} + +void modelica_parser::code_algorithm_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST code_algorithm_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp196_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp196_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp196_AST)); + } + match(ALGORITHM); + { // ( ... )* + for (;;) { + if ((_tokenSet_20.member(LA(1)))) { + algorithm(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + goto _loop200; + } + + } + _loop200:; + } // ( ... )* + code_algorithm_clause_AST = RefMyAST(currentAST.root); + returnAST = code_algorithm_clause_AST; +} + +void modelica_parser::code_initial_algorithm_clause() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST code_initial_algorithm_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (!( LA(2) == ALGORITHM )) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" LA(2) == ALGORITHM "); + match(INITIAL); + RefMyAST tmp200_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp200_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp200_AST)); + } + match(ALGORITHM); + { // ( ... )* + for (;;) { + if ((_tokenSet_20.member(LA(1)))) { + algorithm(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else if ((LA(1) == ANNOTATION)) { + annotation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMICOLON); + } + else { + goto _loop203; + } + + } + _loop203:; + } // ( ... )* + if ( inputState->guessing==0 ) { + code_initial_algorithm_clause_AST = RefMyAST(currentAST.root); +#line 862 "modelica_parser.g" + + code_initial_algorithm_clause_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INITIAL_ALGORITHM,"INTIAL_ALGORITHM")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(code_initial_algorithm_clause_AST)))); + +#line 4491 "modelica_parser.cpp" + currentAST.root = code_initial_algorithm_clause_AST; + if ( code_initial_algorithm_clause_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + code_initial_algorithm_clause_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = code_initial_algorithm_clause_AST->getFirstChild(); + else + currentAST.child = code_initial_algorithm_clause_AST; + currentAST.advanceChildToEnd(); + } + code_initial_algorithm_clause_AST = RefMyAST(currentAST.root); + returnAST = code_initial_algorithm_clause_AST; +} + +void modelica_parser::logical_term() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_term_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + logical_factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == AND)) { + RefMyAST tmp203_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp203_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp203_AST)); + } + match(AND); + logical_factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop209; + } + + } + _loop209:; + } // ( ... )* + logical_term_AST = RefMyAST(currentAST.root); + returnAST = logical_term_AST; +} + +void modelica_parser::logical_factor() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_factor_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == NOT)) { + RefMyAST tmp204_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp204_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp204_AST)); + } + match(NOT); + } + else if ((_tokenSet_48.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + relation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + logical_factor_AST = RefMyAST(currentAST.root); + returnAST = logical_factor_AST; +} + +void modelica_parser::relation() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST relation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + arithmetic_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if (((LA(1) >= LESS && LA(1) <= LESSGT))) { + { + switch ( LA(1)) { + case LESS: + { + RefMyAST tmp205_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp205_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp205_AST)); + } + match(LESS); + break; + } + case LESSEQ: + { + RefMyAST tmp206_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp206_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp206_AST)); + } + match(LESSEQ); + break; + } + case GREATER: + { + RefMyAST tmp207_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp207_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp207_AST)); + } + match(GREATER); + break; + } + case GREATEREQ: + { + RefMyAST tmp208_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp208_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp208_AST)); + } + match(GREATEREQ); + break; + } + case EQEQ: + { + RefMyAST tmp209_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp209_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp209_AST)); + } + match(EQEQ); + break; + } + case LESSGT: + { + RefMyAST tmp210_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp210_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp210_AST)); + } + match(LESSGT); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + arithmetic_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_49.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + relation_AST = RefMyAST(currentAST.root); + returnAST = relation_AST; +} + +void modelica_parser::arithmetic_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST arithmetic_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + unary_arithmetic_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == PLUS || LA(1) == MINUS)) { + { + if ((LA(1) == PLUS)) { + RefMyAST tmp211_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp211_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp211_AST)); + } + match(PLUS); + } + else if ((LA(1) == MINUS)) { + RefMyAST tmp212_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp212_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp212_AST)); + } + match(MINUS); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop220; + } + + } + _loop220:; + } // ( ... )* + arithmetic_expression_AST = RefMyAST(currentAST.root); + returnAST = arithmetic_expression_AST; +} + +void modelica_parser::rel_op() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST rel_op_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LESS: + { + RefMyAST tmp213_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp213_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp213_AST)); + } + match(LESS); + break; + } + case LESSEQ: + { + RefMyAST tmp214_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp214_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp214_AST)); + } + match(LESSEQ); + break; + } + case GREATER: + { + RefMyAST tmp215_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp215_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp215_AST)); + } + match(GREATER); + break; + } + case GREATEREQ: + { + RefMyAST tmp216_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp216_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp216_AST)); + } + match(GREATEREQ); + break; + } + case EQEQ: + { + RefMyAST tmp217_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp217_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp217_AST)); + } + match(EQEQ); + break; + } + case LESSGT: + { + RefMyAST tmp218_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp218_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp218_AST)); + } + match(LESSGT); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + rel_op_AST = RefMyAST(currentAST.root); + returnAST = rel_op_AST; +} + +void modelica_parser::unary_arithmetic_expression() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST unary_arithmetic_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t3_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case PLUS: + { + RefMyAST tmp219_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp219_AST = astFactory->create(LT(1)); + } + match(PLUS); + term(); + if (inputState->guessing==0) { + t1_AST = returnAST; + } + if ( inputState->guessing==0 ) { + unary_arithmetic_expression_AST = RefMyAST(currentAST.root); +#line 896 "modelica_parser.g" + + unary_arithmetic_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(UNARY_PLUS,"PLUS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(t1_AST)))); + +#line 4816 "modelica_parser.cpp" + currentAST.root = unary_arithmetic_expression_AST; + if ( unary_arithmetic_expression_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + unary_arithmetic_expression_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = unary_arithmetic_expression_AST->getFirstChild(); + else + currentAST.child = unary_arithmetic_expression_AST; + currentAST.advanceChildToEnd(); + } + break; + } + case MINUS: + { + RefMyAST tmp220_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp220_AST = astFactory->create(LT(1)); + } + match(MINUS); + term(); + if (inputState->guessing==0) { + t2_AST = returnAST; + } + if ( inputState->guessing==0 ) { + unary_arithmetic_expression_AST = RefMyAST(currentAST.root); +#line 900 "modelica_parser.g" + + unary_arithmetic_expression_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(UNARY_MINUS,"MINUS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(t2_AST)))); + +#line 4844 "modelica_parser.cpp" + currentAST.root = unary_arithmetic_expression_AST; + if ( unary_arithmetic_expression_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + unary_arithmetic_expression_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = unary_arithmetic_expression_AST->getFirstChild(); + else + currentAST.child = unary_arithmetic_expression_AST; + currentAST.advanceChildToEnd(); + } + break; + } + case DER: + case END: + case FALSE: + case INITIAL: + case TRUE: + case UNSIGNED_REAL: + case LPAR: + case LBRACK: + case LBRACE: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + { + term(); + if (inputState->guessing==0) { + t3_AST = returnAST; + } + if ( inputState->guessing==0 ) { + unary_arithmetic_expression_AST = RefMyAST(currentAST.root); +#line 904 "modelica_parser.g" + + unary_arithmetic_expression_AST = t3_AST; + +#line 4878 "modelica_parser.cpp" + currentAST.root = unary_arithmetic_expression_AST; + if ( unary_arithmetic_expression_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + unary_arithmetic_expression_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = unary_arithmetic_expression_AST->getFirstChild(); + else + currentAST.child = unary_arithmetic_expression_AST; + currentAST.advanceChildToEnd(); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + returnAST = unary_arithmetic_expression_AST; +} + +void modelica_parser::term() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST term_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == STAR || LA(1) == SLASH)) { + { + if ((LA(1) == STAR)) { + RefMyAST tmp221_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp221_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp221_AST)); + } + match(STAR); + } + else if ((LA(1) == SLASH)) { + RefMyAST tmp222_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp222_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp222_AST)); + } + match(SLASH); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop226; + } + + } + _loop226:; + } // ( ... )* + term_AST = RefMyAST(currentAST.root); + returnAST = term_AST; +} + +void modelica_parser::factor() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST factor_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == POWER)) { + RefMyAST tmp223_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp223_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp223_AST)); + } + match(POWER); + primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_50.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + factor_AST = RefMyAST(currentAST.root); + returnAST = factor_AST; +} + +void modelica_parser::primary() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST primary_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case UNSIGNED_INTEGER: + { + RefMyAST tmp224_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp224_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp224_AST)); + } + match(UNSIGNED_INTEGER); + break; + } + case UNSIGNED_REAL: + { + RefMyAST tmp225_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp225_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp225_AST)); + } + match(UNSIGNED_REAL); + break; + } + case STRING: + { + RefMyAST tmp226_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp226_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp226_AST)); + } + match(STRING); + break; + } + case FALSE: + { + RefMyAST tmp227_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp227_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp227_AST)); + } + match(FALSE); + break; + } + case TRUE: + { + RefMyAST tmp228_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp228_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp228_AST)); + } + match(TRUE); + break; + } + case INITIAL: + case IDENT: + { + component_reference__function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case DER: + { + RefMyAST tmp229_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp229_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp229_AST)); + } + match(DER); + function_call(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case LPAR: + { + RefMyAST tmp230_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp230_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp230_AST)); + } + match(LPAR); + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAR); + break; + } + case LBRACK: + { + RefMyAST tmp232_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp232_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp232_AST)); + } + match(LBRACK); + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == SEMICOLON)) { + match(SEMICOLON); + expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop232; + } + + } + _loop232:; + } // ( ... )* + match(RBRACK); + break; + } + case LBRACE: + { + RefMyAST tmp235_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp235_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp235_AST)); + } + match(LBRACE); + for_or_expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RBRACE); + break; + } + case END: + { + RefMyAST tmp237_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp237_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp237_AST)); + } + match(END); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + primary_AST = RefMyAST(currentAST.root); + returnAST = primary_AST; +} + +void modelica_parser::component_reference__function_call() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_reference__function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST cr_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken i = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ((LA(1) == IDENT)) { + component_reference(); + if (inputState->guessing==0) { + cr_AST = returnAST; + } + { + if ((LA(1) == LPAR)) { + function_call(); + if (inputState->guessing==0) { + fc_AST = returnAST; + } + } + else if ((_tokenSet_51.member(LA(1)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + component_reference__function_call_AST = RefMyAST(currentAST.root); +#line 935 "modelica_parser.g" + + if (fc_AST != null) + { + component_reference__function_call_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(3))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FUNCTION_CALL,"FUNCTION_CALL")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(cr_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(fc_AST)))); + } + else + { + component_reference__function_call_AST = cr_AST; + } + +#line 5183 "modelica_parser.cpp" + currentAST.root = component_reference__function_call_AST; + if ( component_reference__function_call_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + component_reference__function_call_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = component_reference__function_call_AST->getFirstChild(); + else + currentAST.child = component_reference__function_call_AST; + currentAST.advanceChildToEnd(); + } + } + else if ((LA(1) == INITIAL)) { + i = LT(1); + if ( inputState->guessing == 0 ) { + i_AST = astFactory->create(i); + } + match(INITIAL); + match(LPAR); + match(RPAR); + if ( inputState->guessing==0 ) { + component_reference__function_call_AST = RefMyAST(currentAST.root); +#line 945 "modelica_parser.g" + + component_reference__function_call_AST = RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INITIAL_FUNCTION_CALL,"INITIAL_FUNCTION_CALL")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)))); + +#line 5207 "modelica_parser.cpp" + currentAST.root = component_reference__function_call_AST; + if ( component_reference__function_call_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + component_reference__function_call_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = component_reference__function_call_AST->getFirstChild(); + else + currentAST.child = component_reference__function_call_AST; + currentAST.advanceChildToEnd(); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = component_reference__function_call_AST; +} + +void modelica_parser::for_or_expression_list() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_or_expression_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST explist_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST forind_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (((LA(1) == RPAR || LA(1) == RBRACE || LA(1) == IDENT) && (_tokenSet_51.member(LA(2))))&&(LA(1)==IDENT && LA(2) == EQUALS|| LA(1) == RPAR)) { + } + else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_52.member(LA(2)))) { + { + expression(); + if (inputState->guessing==0) { + e_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case COMMA: + { + match(COMMA); + for_or_expression_list2(); + if (inputState->guessing==0) { + explist_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR: + { + RefMyAST tmp241_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp241_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp241_AST)); + } + match(FOR); + for_indices(); + if (inputState->guessing==0) { + forind_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case RPAR: + case RBRACE: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + } + if ( inputState->guessing==0 ) { + for_or_expression_list_AST = RefMyAST(currentAST.root); +#line 995 "modelica_parser.g" + + if (forind_AST != null) { + for_or_expression_list_AST = + RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FOR_ITERATOR,"FOR_ITERATOR")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(for_or_expression_list_AST)))); + } + else { + for_or_expression_list_AST = + RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXPRESSION_LIST,"EXPRESSION_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(for_or_expression_list_AST)))); + } + +#line 5295 "modelica_parser.cpp" + currentAST.root = for_or_expression_list_AST; + if ( for_or_expression_list_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + for_or_expression_list_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = for_or_expression_list_AST->getFirstChild(); + else + currentAST.child = for_or_expression_list_AST; + currentAST.advanceChildToEnd(); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + for_or_expression_list_AST = RefMyAST(currentAST.root); + returnAST = for_or_expression_list_AST; +} + +void modelica_parser::function_arguments() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST function_arguments_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + for_or_expression_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + { + if ((LA(1) == IDENT)) { + named_arguments(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + function_arguments_AST = RefMyAST(currentAST.root); + returnAST = function_arguments_AST; +} + +void modelica_parser::named_arguments() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_arguments_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + named_arguments2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + named_arguments_AST = RefMyAST(currentAST.root); +#line 1016 "modelica_parser.g" + + named_arguments_AST=RefMyAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(NAMED_ARGUMENTS,"NAMED_ARGUMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(named_arguments_AST)))); + +#line 5358 "modelica_parser.cpp" + currentAST.root = named_arguments_AST; + if ( named_arguments_AST!=RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + named_arguments_AST->getFirstChild() != RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = named_arguments_AST->getFirstChild(); + else + currentAST.child = named_arguments_AST; + currentAST.advanceChildToEnd(); + } + named_arguments_AST = RefMyAST(currentAST.root); + returnAST = named_arguments_AST; +} + +void modelica_parser::for_or_expression_list2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_or_expression_list2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((LA(1) == RPAR || LA(1) == RBRACE || LA(1) == IDENT) && (_tokenSet_51.member(LA(2))))&&(LA(2) == EQUALS)) { + for_or_expression_list2_AST = RefMyAST(currentAST.root); + } + else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_53.member(LA(2)))) { + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == COMMA)) { + match(COMMA); + for_or_expression_list2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == RBRACE || LA(1) == IDENT)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + for_or_expression_list2_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = for_or_expression_list2_AST; +} + +void modelica_parser::named_arguments2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_arguments2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + named_argument(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + bool synPredMatched255 = false; + if (((LA(1) == COMMA))) { + int _m255 = mark(); + synPredMatched255 = true; + inputState->guessing++; + try { + { + match(COMMA); + match(IDENT); + match(EQUALS); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched255 = false; + } + rewind(_m255); + inputState->guessing--; + } + if ( synPredMatched255 ) { + match(COMMA); + named_arguments2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + named_arguments2_AST = RefMyAST(currentAST.root); + returnAST = named_arguments2_AST; +} + +void modelica_parser::named_argument() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_argument_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST tmp244_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp244_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp244_AST)); + } + match(IDENT); + RefMyAST tmp245_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp245_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp245_AST)); + } + match(EQUALS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + named_argument_AST = RefMyAST(currentAST.root); + returnAST = named_argument_AST; +} + +void modelica_parser::expression_list2() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_list2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == COMMA)) { + match(COMMA); + expression_list2(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == RPAR || LA(1) == RBRACK || LA(1) == SEMICOLON)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + expression_list2_AST = RefMyAST(currentAST.root); + returnAST = expression_list2_AST; +} + +void modelica_parser::subscript() { + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST subscript_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ((_tokenSet_21.member(LA(1)))) { + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + subscript_AST = RefMyAST(currentAST.root); + } + else if ((LA(1) == COLON)) { + RefMyAST tmp247_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp247_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp247_AST)); + } + match(COLON); + subscript_AST = RefMyAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = subscript_AST; +} + +void modelica_parser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) +{ + factory.setMaxNodeType(146); +} +const char* modelica_parser::tokenNames[] = { + "<0>", + "EOF", + "<2>", + "NULL_TREE_LOOKAHEAD", + "\"algorithm\"", + "\"and\"", + "\"annotation\"", + "\"block\"", + "\"Code\"", + "\"class\"", + "\"connect\"", + "\"connector\"", + "\"constant\"", + "\"discrete\"", + "\"der\"", + "\"each\"", + "\"else\"", + "\"elseif\"", + "\"elsewhen\"", + "\"end\"", + "\"enumeration\"", + "\"equation\"", + "\"encapsulated\"", + "\"expandable\"", + "\"extends\"", + "\"external\"", + "\"false\"", + "\"final\"", + "\"flow\"", + "\"for\"", + "\"function\"", + "\"if\"", + "\"import\"", + "\"in\"", + "\"initial\"", + "\"inner\"", + "\"input\"", + "\"loop\"", + "\"model\"", + "\"not\"", + "\"outer\"", + "\"overload\"", + "\"or\"", + "\"output\"", + "\"package\"", + "\"parameter\"", + "\"partial\"", + "\"protected\"", + "\"public\"", + "\"record\"", + "\"redeclare\"", + "\"replaceable\"", + "\"results\"", + "\"then\"", + "\"true\"", + "\"type\"", + "\"unsigned_real\"", + "\".\"", + "\"when\"", + "\"while\"", + "\"within\"", + "LPAR", + "RPAR", + "LBRACK", + "RBRACK", + "LBRACE", + "RBRACE", + "EQUALS", + "ASSIGN", + "PLUS", + "MINUS", + "STAR", + "SLASH", + "COMMA", + "LESS", + "LESSEQ", + "GREATER", + "GREATEREQ", + "EQEQ", + "LESSGT", + "COLON", + "SEMICOLON", + "POWER", + "YIELDS", + "AMPERSAND", + "PIPEBAR", + "COLONCOLON", + "DASHES", + "WS", + "ML_COMMENT", + "ML_COMMENT_CHAR", + "SL_COMMENT", + "an identifier", + "an identifier", + "NONDIGIT", + "DIGIT", + "EXPONENT", + "UNSIGNED_INTEGER", + "STRING", + "SCHAR", + "QCHAR", + "SESCAPE", + "ESC", + "ALGORITHM_STATEMENT", + "ARGUMENT_LIST", + "BEGIN_DEFINITION", + "CLASS_DEFINITION", + "CLASS_EXTENDS", + "CLASS_MODIFICATION", + "CODE_EXPRESSION", + "CODE_MODIFICATION", + "CODE_ELEMENT", + "CODE_EQUATION", + "CODE_INITIALEQUATION", + "CODE_ALGORITHM", + "CODE_INITIALALGORITHM", + "COMMENT", + "COMPONENT_DEFINITION", + "DECLARATION", + "DEFINITION", + "END_DEFINITION", + "ENUMERATION_LITERAL", + "ELEMENT", + "ELEMENT_MODIFICATION", + "ELEMENT_REDECLARATION", + "EQUATION_STATEMENT", + "EXTERNAL_ANNOTATION", + "INITIAL_EQUATION", + "INITIAL_ALGORITHM", + "IMPORT_DEFINITION", + "IDENT_LIST", + "EXPRESSION_LIST", + "EXTERNAL_FUNCTION_CALL", + "FOR_INDICES", + "FOR_ITERATOR", + "FUNCTION_CALL", + "INITIAL_FUNCTION_CALL", + "FUNCTION_ARGUMENTS", + "NAMED_ARGUMENTS", + "QUALIFIED", + "RANGE2", + "RANGE3", + "STORED_DEFINITION", + "STRING_COMMENT", + "UNARY_MINUS", + "UNARY_PLUS", + "UNQUALIFIED", + 0 +}; + +const unsigned long modelica_parser::_tokenSet_0_data_[] = { 1086327424UL, 8540224UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "encapsulated" "expandable" "function" "model" +// "package" "partial" "record" "type" +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_0(_tokenSet_0_data_,6); +const unsigned long modelica_parser::_tokenSet_1_data_[] = { 1082133120UL, 8540224UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "expandable" "function" "model" "package" +// "partial" "record" "type" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_1(_tokenSet_1_data_,8); +const unsigned long modelica_parser::_tokenSet_2_data_[] = { 1082133120UL, 8540224UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "expandable" "function" "model" "package" +// "partial" "record" "type" +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_2(_tokenSet_2_data_,6); +const unsigned long modelica_parser::_tokenSet_3_data_[] = { 1082133120UL, 8523840UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "expandable" "function" "model" "package" +// "record" "type" +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_3(_tokenSet_3_data_,6); +const unsigned long modelica_parser::_tokenSet_4_data_[] = { 1220545154UL, 276975680UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "block" "class" "connector" "encapsulated" "expandable" "final" +// "function" "model" "package" "partial" "record" "type" "within" +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_4(_tokenSet_4_data_,6); +const unsigned long modelica_parser::_tokenSet_5_data_[] = { 1103104642UL, 8540224UL, 268566528UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "block" "class" "connector" "encapsulated" "expandable" "extends" +// "function" "model" "package" "partial" "record" "type" SEMICOLON IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_5(_tokenSet_5_data_,8); +const unsigned long modelica_parser::_tokenSet_6_data_[] = { 1220545154UL, 8540224UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "block" "class" "connector" "encapsulated" "expandable" "final" +// "function" "model" "package" "partial" "record" "type" +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_6(_tokenSet_6_data_,6); +const unsigned long modelica_parser::_tokenSet_7_data_[] = { 1220545152UL, 8540224UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "encapsulated" "expandable" "final" "function" +// "model" "package" "partial" "record" "type" +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_7(_tokenSet_7_data_,6); +const unsigned long modelica_parser::_tokenSet_8_data_[] = { 64UL, 1107296256UL, 131072UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "." RPAR SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_8(_tokenSet_8_data_,8); +const unsigned long modelica_parser::_tokenSet_9_data_[] = { 16777280UL, 3758096384UL, 268567040UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "extends" LPAR RPAR LBRACK COMMA SEMICOLON IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_9(_tokenSet_9_data_,8); +const unsigned long modelica_parser::_tokenSet_10_data_[] = { 1541946064UL, 9435485UL, 268435456UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "algorithm" "annotation" "block" "class" "connector" "constant" "discrete" +// "end" "equation" "encapsulated" "expandable" "extends" "external" "final" +// "flow" "function" "import" "initial" "inner" "input" "model" "outer" +// "output" "package" "parameter" "partial" "protected" "public" "record" +// "redeclare" "replaceable" "type" IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_10(_tokenSet_10_data_,8); +const unsigned long modelica_parser::_tokenSet_11_data_[] = { 268447744UL, 10256UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "constant" "discrete" "flow" "input" "output" "parameter" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_11(_tokenSet_11_data_,8); +const unsigned long modelica_parser::_tokenSet_12_data_[] = { 16777280UL, 1610612736UL, 131584UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "extends" LPAR RPAR COMMA SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_12(_tokenSet_12_data_,8); +const unsigned long modelica_parser::_tokenSet_13_data_[] = { 16777280UL, 1073741824UL, 131584UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "extends" RPAR COMMA SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_13(_tokenSet_13_data_,8); +const unsigned long modelica_parser::_tokenSet_14_data_[] = { 134250496UL, 786432UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "each" "final" "redeclare" "replaceable" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_14(_tokenSet_14_data_,8); +const unsigned long modelica_parser::_tokenSet_15_data_[] = { 1541946064UL, 1083177309UL, 268567040UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "algorithm" "annotation" "block" "class" "connector" "constant" "discrete" +// "end" "equation" "encapsulated" "expandable" "extends" "external" "final" +// "flow" "function" "import" "initial" "inner" "input" "model" "outer" +// "output" "package" "parameter" "partial" "protected" "public" "record" +// "redeclare" "replaceable" "type" RPAR COMMA SEMICOLON IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_15(_tokenSet_15_data_,8); +const unsigned long modelica_parser::_tokenSet_16_data_[] = { 16777216UL, 1073741824UL, 131584UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "extends" RPAR COMMA SEMICOLON +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_16(_tokenSet_16_data_,8); +const unsigned long modelica_parser::_tokenSet_17_data_[] = { 12288UL, 10256UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "constant" "discrete" "input" "output" "parameter" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_17(_tokenSet_17_data_,8); +const unsigned long modelica_parser::_tokenSet_18_data_[] = { 1505770176UL, 9337177UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "block" "class" "connector" "constant" "discrete" "encapsulated" +// "expandable" "extends" "final" "flow" "function" "import" "inner" "input" +// "model" "outer" "output" "package" "parameter" "partial" "record" "redeclare" +// "replaceable" "type" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_18(_tokenSet_18_data_,8); +const unsigned long modelica_parser::_tokenSet_19_data_[] = { 1505770112UL, 9337177UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "constant" "discrete" "encapsulated" "expandable" +// "extends" "final" "flow" "function" "import" "inner" "input" "model" +// "outer" "output" "package" "parameter" "partial" "record" "redeclare" +// "replaceable" "type" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_19(_tokenSet_19_data_,8); +const unsigned long modelica_parser::_tokenSet_20_data_[] = { 2684354560UL, 738197504UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "for" "if" "when" "while" LPAR IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_20(_tokenSet_20_data_,8); +const unsigned long modelica_parser::_tokenSet_21_data_[] = { 2215133440UL, 2705326212UL, 268435554UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "Code" "der" "end" "false" "if" "initial" "not" "true" "unsigned_real" +// LPAR LBRACK LBRACE PLUS MINUS IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_21(_tokenSet_21_data_,8); +const unsigned long modelica_parser::_tokenSet_22_data_[] = { 2701328480UL, 1646265376UL, 268959741UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "annotation" "else" "elseif" "extends" "for" "if" "loop" "or" +// "then" "." LPAR RPAR RBRACK RBRACE EQUALS ASSIGN PLUS MINUS STAR SLASH +// COMMA LESS LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER +// IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_22(_tokenSet_22_data_,8); +const unsigned long modelica_parser::_tokenSet_23_data_[] = { 2701328480UL, 1612710944UL, 268959741UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "annotation" "else" "elseif" "extends" "for" "if" "loop" "or" +// "then" LPAR RPAR RBRACK RBRACE EQUALS ASSIGN PLUS MINUS STAR SLASH COMMA +// LESS LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER IDENT +// STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_23(_tokenSet_23_data_,8); +const unsigned long modelica_parser::_tokenSet_24_data_[] = { 1488992896UL, 9075032UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "constant" "discrete" "encapsulated" "expandable" +// "final" "flow" "function" "inner" "input" "model" "outer" "output" "package" +// "parameter" "partial" "record" "replaceable" "type" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_24(_tokenSet_24_data_,8); +const unsigned long modelica_parser::_tokenSet_25_data_[] = { 1354775168UL, 9075032UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "constant" "discrete" "encapsulated" "expandable" +// "flow" "function" "inner" "input" "model" "outer" "output" "package" +// "parameter" "partial" "record" "replaceable" "type" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_25(_tokenSet_25_data_,8); +const unsigned long modelica_parser::_tokenSet_26_data_[] = { 1354775168UL, 9075024UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "constant" "discrete" "encapsulated" "expandable" +// "flow" "function" "input" "model" "outer" "output" "package" "parameter" +// "partial" "record" "replaceable" "type" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_26(_tokenSet_26_data_,8); +const unsigned long modelica_parser::_tokenSet_27_data_[] = { 1354775168UL, 9074768UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "constant" "discrete" "encapsulated" "expandable" +// "flow" "function" "input" "model" "output" "package" "parameter" "partial" +// "record" "replaceable" "type" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_27(_tokenSet_27_data_,8); +const unsigned long modelica_parser::_tokenSet_28_data_[] = { 1354775168UL, 8550480UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "constant" "discrete" "encapsulated" "expandable" +// "flow" "function" "input" "model" "output" "package" "parameter" "partial" +// "record" "type" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_28(_tokenSet_28_data_,8); +const unsigned long modelica_parser::_tokenSet_29_data_[] = { 64UL, 1073741824UL, 131584UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" RPAR COMMA SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_29(_tokenSet_29_data_,8); +const unsigned long modelica_parser::_tokenSet_30_data_[] = { 64UL, 1073741824UL, 131072UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" RPAR SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_30(_tokenSet_30_data_,8); +const unsigned long modelica_parser::_tokenSet_31_data_[] = { 2164260928UL, 1610612736UL, 131608UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "extends" "if" LPAR RPAR EQUALS ASSIGN COMMA SEMICOLON +// STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_31(_tokenSet_31_data_,8); +const unsigned long modelica_parser::_tokenSet_32_data_[] = { 2164260928UL, 1073741824UL, 131584UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "extends" "if" RPAR COMMA SEMICOLON STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_32(_tokenSet_32_data_,8); +const unsigned long modelica_parser::_tokenSet_33_data_[] = { 134250496UL, 524288UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "each" "final" "replaceable" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_33(_tokenSet_33_data_,8); +const unsigned long modelica_parser::_tokenSet_34_data_[] = { 1488992896UL, 9074768UL, 268435456UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "constant" "discrete" "encapsulated" "expandable" +// "final" "flow" "function" "input" "model" "output" "package" "parameter" +// "partial" "record" "replaceable" "type" IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_34(_tokenSet_34_data_,8); +const unsigned long modelica_parser::_tokenSet_35_data_[] = { 36175888UL, 98308UL, 0UL, 0UL, 0UL, 0UL }; +// "algorithm" "end" "equation" "external" "initial" "protected" "public" +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_35(_tokenSet_35_data_,6); +const unsigned long modelica_parser::_tokenSet_36_data_[] = { 4293426896UL, 2916088285UL, 268566626UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "algorithm" "annotation" "block" "class" "connect" "connector" "constant" +// "discrete" "der" "end" "equation" "encapsulated" "expandable" "extends" +// "external" "false" "final" "flow" "for" "function" "if" "import" "initial" +// "inner" "input" "model" "not" "outer" "output" "package" "parameter" +// "partial" "protected" "public" "record" "redeclare" "replaceable" "true" +// "type" "unsigned_real" "when" "while" LPAR LBRACK LBRACE PLUS MINUS +// SEMICOLON IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_36(_tokenSet_36_data_,8); +const unsigned long modelica_parser::_tokenSet_37_data_[] = { 2752005184UL, 2772435076UL, 268435554UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "connect" "der" "end" "false" "for" "if" "initial" "not" +// "true" "unsigned_real" "when" LPAR LBRACK LBRACE PLUS MINUS IDENT UNSIGNED_INTEGER +// STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_37(_tokenSet_37_data_,8); +const unsigned long modelica_parser::_tokenSet_38_data_[] = { 2215133472UL, 2738881668UL, 268828142UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "Code" "der" "end" "false" "if" "initial" "not" "or" "true" "unsigned_real" +// "." LPAR LBRACK LBRACE RBRACE EQUALS PLUS MINUS STAR SLASH LESS LESSEQ +// GREATER GREATEREQ EQEQ LESSGT COLON POWER IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_38(_tokenSet_38_data_,8); +const unsigned long modelica_parser::_tokenSet_39_data_[] = { 2752005120UL, 2772435076UL, 268435554UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "connect" "der" "end" "false" "for" "if" "initial" "not" "true" "unsigned_real" +// "when" LPAR LBRACK LBRACE PLUS MINUS IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_39(_tokenSet_39_data_,8); +const unsigned long modelica_parser::_tokenSet_40_data_[] = { 67649536UL, 2705326212UL, 268435554UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "der" "end" "false" "initial" "not" "true" "unsigned_real" LPAR LBRACK +// LBRACE PLUS MINUS IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_40(_tokenSet_40_data_,8); +const unsigned long modelica_parser::_tokenSet_41_data_[] = { 2701328448UL, 1075839008UL, 268567053UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "annotation" "else" "elseif" "extends" "for" "if" "loop" "then" RPAR +// RBRACK RBRACE EQUALS COMMA SEMICOLON IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_41(_tokenSet_41_data_,8); +const unsigned long modelica_parser::_tokenSet_42_data_[] = { 2752005376UL, 2772435076UL, 268435554UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "Code" "connect" "der" "end" "false" "for" "if" "initial" "not" "true" +// "unsigned_real" "when" LPAR LBRACK LBRACE PLUS MINUS IDENT UNSIGNED_INTEGER +// STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_42(_tokenSet_42_data_,8); +const unsigned long modelica_parser::_tokenSet_43_data_[] = { 2215133472UL, 3812623492UL, 268828134UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "Code" "der" "end" "false" "if" "initial" "not" "or" "true" "unsigned_real" +// "." LPAR RPAR LBRACK LBRACE RBRACE PLUS MINUS STAR SLASH LESS LESSEQ +// GREATER GREATEREQ EQEQ LESSGT COLON POWER IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_43(_tokenSet_43_data_,8); +const unsigned long modelica_parser::_tokenSet_44_data_[] = { 2349383936UL, 3779854468UL, 268435554UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "Code" "der" "each" "end" "false" "final" "if" "initial" "not" "redeclare" +// "replaceable" "true" "unsigned_real" LPAR RPAR LBRACK LBRACE PLUS MINUS +// IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_44(_tokenSet_44_data_,8); +const unsigned long modelica_parser::_tokenSet_45_data_[] = { 1505770112UL, 2190113112UL, 268435584UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "block" "class" "connector" "constant" "discrete" "encapsulated" "expandable" +// "extends" "final" "flow" "function" "inner" "input" "model" "outer" +// "output" "package" "parameter" "partial" "record" "replaceable" "type" +// "." LBRACK STAR IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_45(_tokenSet_45_data_,8); +const unsigned long modelica_parser::_tokenSet_46_data_[] = { 0UL, 1073741856UL, 268435972UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "loop" RPAR RBRACE COMMA IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_46(_tokenSet_46_data_,8); +const unsigned long modelica_parser::_tokenSet_47_data_[] = { 0UL, 1073741856UL, 268435460UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "loop" RPAR RBRACE IDENT +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_47(_tokenSet_47_data_,8); +const unsigned long modelica_parser::_tokenSet_48_data_[] = { 67649536UL, 2705326084UL, 268435554UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "der" "end" "false" "initial" "true" "unsigned_real" LPAR LBRACK LBRACE +// PLUS MINUS IDENT UNSIGNED_INTEGER STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_48(_tokenSet_48_data_,8); +const unsigned long modelica_parser::_tokenSet_49_data_[] = { 2701328480UL, 1075840032UL, 268632589UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "annotation" "else" "elseif" "extends" "for" "if" "loop" "or" +// "then" RPAR RBRACK RBRACE EQUALS COMMA COLON SEMICOLON IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_49(_tokenSet_49_data_,8); +const unsigned long modelica_parser::_tokenSet_50_data_[] = { 2701328480UL, 1075840032UL, 268697581UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "annotation" "else" "elseif" "extends" "for" "if" "loop" "or" +// "then" RPAR RBRACK RBRACE EQUALS PLUS MINUS STAR SLASH COMMA LESS LESSEQ +// GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_50(_tokenSet_50_data_,8); +const unsigned long modelica_parser::_tokenSet_51_data_[] = { 2701328480UL, 1075840032UL, 268959725UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "annotation" "else" "elseif" "extends" "for" "if" "loop" "or" +// "then" RPAR RBRACK RBRACE EQUALS PLUS MINUS STAR SLASH COMMA LESS LESSEQ +// GREATER GREATEREQ EQEQ LESSGT COLON SEMICOLON POWER IDENT STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_51(_tokenSet_51_data_,8); +const unsigned long modelica_parser::_tokenSet_52_data_[] = { 2752004384UL, 3812623492UL, 268828646UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "Code" "der" "end" "false" "for" "if" "initial" "not" "or" "true" +// "unsigned_real" "." LPAR RPAR LBRACK LBRACE RBRACE PLUS MINUS STAR SLASH +// COMMA LESS LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON POWER IDENT UNSIGNED_INTEGER +// STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_52(_tokenSet_52_data_,8); +const unsigned long modelica_parser::_tokenSet_53_data_[] = { 2215133472UL, 3812623492UL, 268828646UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "Code" "der" "end" "false" "if" "initial" "not" "or" "true" "unsigned_real" +// "." LPAR RPAR LBRACK LBRACE RBRACE PLUS MINUS STAR SLASH COMMA LESS +// LESSEQ GREATER GREATEREQ EQEQ LESSGT COLON POWER IDENT UNSIGNED_INTEGER +// STRING +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_parser::_tokenSet_53(_tokenSet_53_data_,8); + + diff --git a/tools/xml/modelicaxml/modelica_parser.g b/tools/xml/modelicaxml/modelica_parser.g new file mode 100644 index 00000000000..6f6befb7e32 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_parser.g @@ -0,0 +1,1069 @@ + +header "post_include_hpp" { +#define null 0 +#include "MyAST.h" + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; + +} + +options { + language = "Cpp"; +} + +class modelica_parser extends Parser; + +options { + codeGenMakeSwitchThreshold = 3; + codeGenBitsetTestThreshold = 4; + importVocab = modelica; + defaultErrorHandler = false; + k = 2; + buildAST = true; + ASTLabelType = "RefMyAST"; + +} + +tokens { + ALGORITHM_STATEMENT; + ARGUMENT_LIST; + BEGIN_DEFINITION; + CLASS_DEFINITION ; + CLASS_EXTENDS ; + CLASS_MODIFICATION; + CODE_EXPRESSION; + CODE_MODIFICATION; + CODE_ELEMENT; + CODE_EQUATION; + CODE_INITIALEQUATION; + CODE_ALGORITHM; + CODE_INITIALALGORITHM; + COMMENT; + COMPONENT_DEFINITION; + DECLARATION ; + DEFINITION ; + END_DEFINITION; + ENUMERATION_LITERAL; + ELEMENT ; + ELEMENT_MODIFICATION ; + ELEMENT_REDECLARATION ; + EQUATION_STATEMENT; + EXTERNAL_ANNOTATION ; + INITIAL_EQUATION; + INITIAL_ALGORITHM; + IMPORT_DEFINITION; + IDENT_LIST; + EXPRESSION_LIST; + EXTERNAL_FUNCTION_CALL; + FOR_INDICES ; + FOR_ITERATOR ; + FUNCTION_CALL ; + INITIAL_FUNCTION_CALL ; + FUNCTION_ARGUMENTS; + NAMED_ARGUMENTS; + QUALIFIED; + RANGE2 ; + RANGE3 ; + STORED_DEFINITION ; + STRING_COMMENT; + UNARY_MINUS ; + UNARY_PLUS ; + UNQUALIFIED; + +} + + +/* + * 2.2.1 Stored definition + */ + + +stored_definition : +// To handle split models into several evaluations, "package A", +// "model test end test", "end A;" as in MathModelica + ( (ENCAPSULATED)? + (PARTIAL)? + class_type + IDENT EOF ) => ( (ENCAPSULATED)? + (PARTIAL)? + class_type + IDENT EOF!) + { + #stored_definition = #([BEGIN_DEFINITION,"BEGIN_DEFINITION"], + #stored_definition); + } + | + END! IDENT SEMICOLON! EOF! { + #stored_definition = #([END_DEFINITION,"END_DEFINITION"], + #stored_definition); + } + | + (component_clause) => component_clause SEMICOLON! EOF! + { + #stored_definition = #([COMPONENT_DEFINITION,"COMPONENT_DEFINITION"], + #stored_definition); + } + | + import_clause SEMICOLON! EOF! + { + #stored_definition = #([IMPORT_DEFINITION,"IMPORT_DEFINITION"], + #stored_definition); + } + | +// End handle split models. + (within_clause SEMICOLON!)? + ((FINAL)? cd:class_definition s:SEMICOLON! + { + /* adrpo, fix the end of this AST node */ + if(#cd != NULL) + { + /* + std::cout << (#cd)->toString() << std::endl; + std::cout << s->getLine() << ":" << s->getColumn() << std::endl; + */ + RefMyAST(#cd)->setEndLine(s->getLine()); + RefMyAST(#cd)->setEndColumn(s->getColumn()); + } + } + )* + EOF! + { + #stored_definition = #([STORED_DEFINITION,"STORED_DEFINITION"], + #stored_definition); + } + ; + + +within_clause : + WITHIN^ (name_path)? + ; + +/* + * 2.2.2 Class definition + */ + +class_definition : + (ENCAPSULATED)? + (PARTIAL)? + class_type + class_specifier + { + #class_definition = #([CLASS_DEFINITION, "CLASS_DEFINITION"], + class_definition); + } + ; + +class_type : + ( CLASS | MODEL | RECORD | BLOCK | ( EXPANDABLE )? CONNECTOR | TYPE + | PACKAGE | FUNCTION + ) + ; + +class_specifier: + IDENT class_specifier2 + | EXTENDS! IDENT (class_modification)? string_comment composition + END! IDENT! + { + #class_specifier = #([CLASS_EXTENDS,"CLASS_EXTENDS"],#class_specifier); + } + ; + +class_specifier2 : + ( string_comment composition END! IDENT! + | EQUALS^ base_prefix name_path ( array_subscripts )? ( class_modification )? comment + | EQUALS^ enumeration + | EQUALS^ pder + | EQUALS^ overloading + ) + ; + +pder: DER^ LPAR! name_path COMMA! ident_list RPAR! comment ; + +ident_list : + IDENT + | IDENT COMMA! ident_list + { + #ident_list=#([IDENT_LIST,"IDENT_LIST"],#ident_list); + } + ; + + +overloading: + OVERLOAD^ LPAR! name_list RPAR! comment + ; + +base_prefix: + type_prefix + ; + +name_list: + name_path (COMMA! name_path)* + ; + +enumeration : + ENUMERATION^ LPAR! (enum_list | COLON ) RPAR! comment + ; +enum_list : + enumeration_literal ( COMMA! enumeration_literal)* + ; + +enumeration_literal : + IDENT comment + { + #enumeration_literal=#([ENUMERATION_LITERAL, + "ENUMERATION_LITERAL"],#enumeration_literal); + } + ; + +composition : + element_list + ( public_element_list + | protected_element_list + | initial_equation_clause + | initial_algorithm_clause + | equation_clause + | algorithm_clause + )* + ( external_clause )? + ; + +external_clause : + EXTERNAL^ + ( language_specification )? + ( external_function_call )? + ( annotation )? SEMICOLON! + ( external_annotation )? + ; + +external_annotation: + annotation SEMICOLON! + { + #external_annotation=#([EXTERNAL_ANNOTATION, + "EXTERNAL_ANNOTATION"],#external_annotation); + } + ; + +public_element_list : + PUBLIC^ element_list + ; + +protected_element_list : + PROTECTED^ element_list + ; + +language_specification : + STRING + ; + +external_function_call : + ( component_reference EQUALS^ )? + IDENT LPAR! ( expression_list )? RPAR! + { + #external_function_call=#([EXTERNAL_FUNCTION_CALL, + "EXTERNAL_FUNCTION_CALL"],#external_function_call); + } + ; + +element_list : + ((e:element | a:annotation ) s:SEMICOLON! + { + /* adrpo, fix the end of this AST node */ + if (#e) + { + /* + std::cout << (#e)->toString() << std::endl; + std::cout << s->getLine() << ":" << s->getColumn() << std::endl; + */ + RefMyAST(#e)->setEndLine(s->getLine()); + RefMyAST(#e)->setEndColumn(s->getColumn()); + if (#e->getFirstChild()) + { + /* + std::cout << (#e->getFirstChild())->toString() << std::endl; + std::cout << s->getLine() << ":" << s->getColumn() << std::endl; + */ + RefMyAST(#e->getFirstChild())->setEndLine(s->getLine()); + RefMyAST(#e->getFirstChild())->setEndColumn(s->getColumn()); + } + } + + } + )* + ; + /* + exception + catch [ANTLR_USE_NAMESPACE(antlr)RecognitionException &e] + { + BEFORE_SYNC; + + // Sync to {PUBLIC, PROTECTED, EQUATION, ALGORITHM, EXTERNAL, END} + while(LA(1) != PUBLIC && LA(1) != PROTECTED && LA(1) != EQUATION && LA(1) != ALGORITHM && LA(1) != EXTERNAL && LA(1) != END) + { + if(LA(1) == EOF_) + { + throw ANTLR_USE_NAMESPACE(antlr)RecognitionException("unexpected end of file", modelicafilename, LT(1)->getLine(), LT(1)->getColumn()); + } + consume(); + } + + AFTER_SYNC; + } + */ + +element : + ic:import_clause + | ec:extends_clause + | (REDECLARE)? + (FINAL)? + (INNER)? + (OUTER)? + ( (class_definition | cc:component_clause) + |(REPLACEABLE ( class_definition | cc2:component_clause ) + (constraining_clause comment)? + ) + ) + { + if(#cc != null || #cc2 != null) + { + #element = #([DECLARATION,"DECLARATION"], #element); + } + else + { + #element = #([DEFINITION,"DEFINITION"], #element); + } + } + ; + /* + exception + catch [ANTLR_USE_NAMESPACE(antlr)RecognitionException &e] + { + BEFORE_SYNC; + + // Sync to SEMICOLON + while(LA(1) != SEMICOLON) + { + if(LA(1) == EOF_) + { + throw ANTLR_USE_NAMESPACE(antlr)RecognitionException("unexpected end of file", modelicafilename, LT(1)->getLine(), LT(1)->getColumn()); + } + consume(); + } + + AFTER_SYNC; + } + */ + +import_clause : + IMPORT^ (explicit_import_name | implicit_import_name) comment + ; + +explicit_import_name: + IDENT EQUALS^ name_path + ; + +implicit_import_name! + { + bool has_star = false; + } + : + has_star = np:name_path_star + { + if (has_star) + { + #implicit_import_name = #([UNQUALIFIED,"UNQUALIFIED"],#np); + } + else + { + #implicit_import_name = #([QUALIFIED,"QUALIFIED"],#np); + } + }; +/* + * 2.2.3 Extends + */ + +// Note that this is a minor modification of the standard by +// allowing the comment. +extends_clause : + EXTENDS^ name_path ( class_modification )? + ; + +constraining_clause : + extends_clause + ; + +/* + * 2.2.4 Component clause + */ + +component_clause : + type_prefix type_specifier (array_subscripts)? component_list + ; + +type_prefix : + (FLOW)? + (DISCRETE + |PARAMETER + |CONSTANT + )? + (INPUT + |OUTPUT + )? + ; + +type_specifier : + name_path + ; + +component_list : + component_declaration (COMMA! component_declaration)* + ; + +component_declaration : + declaration (conditional_attribute)? comment + ; + +conditional_attribute: + IF^ expression + ; + +declaration : + IDENT^ (array_subscripts)? (modification)? + ; + +/* + * 2.2.5 Modification + */ + +modification : + ( class_modification ( EQUALS! expression )? + | EQUALS^ expression + | ASSIGN^ expression + ) + ; + +class_modification : + LPAR! ( argument_list )? RPAR! + { + #class_modification=#([CLASS_MODIFICATION,"CLASS_MODIFICATION"], + #class_modification); + } + ; + +argument_list : + argument ( COMMA! argument )* + { + #argument_list=#([ARGUMENT_LIST,"ARGUMENT_LIST"],#argument_list); + } + ; + +argument ! : + (em:element_modification_or_replaceable + { + #argument = #([ELEMENT_MODIFICATION,"ELEMENT_MODIFICATION"], #em); + } + | er:element_redeclaration + { + #argument = #([ELEMENT_REDECLARATION,"ELEMENT_REDECLARATION"], #er); } + ) + ; + +element_modification_or_replaceable: + (EACH)? (FINAL)? (element_modification | element_replaceable) + ; + +element_modification : + component_reference ( modification )? string_comment + ; + +element_redeclaration : + REDECLARE^ ( EACH )? (FINAL )? + ( (class_definition | component_clause1) | element_replaceable ) + ; + +element_replaceable: + REPLACEABLE^ ( class_definition | component_clause1 ) + (constraining_clause comment)? + ; +component_clause1 : + type_prefix type_specifier component_declaration1 + ; + +component_declaration1 : + declaration comment + ; + + +/* + * 2.2.6 Equations + */ + +initial_equation_clause : + { LA(2)==EQUATION}? + INITIAL! ec:equation_clause + { + #initial_equation_clause = #([INITIAL_EQUATION,"INTIAL_EQUATION"], ec); + } + + ; + +equation_clause : + EQUATION^ + equation_annotation_list + ; + +equation_annotation_list : + { LA(1) == END || LA(1) == EQUATION || LA(1) == ALGORITHM || LA(1)==INITIAL + || LA(1) == PROTECTED || LA(1) == PUBLIC }? + | + ( equation SEMICOLON! | annotation SEMICOLON!) equation_annotation_list + ; + /* + exception + catch [ANTLR_USE_NAMESPACE(antlr)RecognitionException &e] + { + BEFORE_SYNC; + + // Sync to {END, EQUATION, ALGORITHM, INITIAL, PROTECTED, PUBLIC} + while(LA(1) != END && LA(1) != EQUATION && LA(1) != ALGORITHM && LA(1) != INITIAL + && LA(1) != PROTECTED && LA(1) != PUBLIC) + { + if(LA(1) == EOF_) + { + throw ANTLR_USE_NAMESPACE(antlr)RecognitionException("unexpected end of file", modelicafilename, LT(1)->getLine(), LT(1)->getColumn()); + } + consume(); + } + + AFTER_SYNC; + } + */ + +algorithm_clause : + ALGORITHM^ + (algorithm SEMICOLON! + |annotation SEMICOLON! + )* + ; + /* + exception + catch [ANTLR_USE_NAMESPACE(antlr)RecognitionException &e] + { + BEFORE_SYNC; + + // Sync to {END, EQUATION, ALGORITHM, INITIAL, PROTECTED, PUBLIC} + while(LA(1) != END && LA(1) != EQUATION && LA(1) != ALGORITHM && LA(1) != INITIAL + && LA(1) != PROTECTED && LA(1) != PUBLIC) + { + if(LA(1) == EOF_) + { + throw ANTLR_USE_NAMESPACE(antlr)RecognitionException("unexpected end of file", modelicafilename, LT(1)->getLine(), LT(1)->getColumn()); + } + consume(); + } + + AFTER_SYNC; + } + */ + +initial_algorithm_clause : + { LA(2)==ALGORITHM}? + INITIAL! ALGORITHM^ + (algorithm SEMICOLON! + |annotation SEMICOLON! + )* + { + #initial_algorithm_clause = #([INITIAL_ALGORITHM,"INTIAL_ALGORITHM"], #initial_algorithm_clause); + } + ; + /* + exception + catch [ANTLR_USE_NAMESPACE(antlr)RecognitionException &e] + { + BEFORE_SYNC; + + // Sync to {END, EQUATION, ALGORITHM, INITIAL, PROTECTED, PUBLIC} + while(LA(1) != END && LA(1) != EQUATION && LA(1) != ALGORITHM && LA(1) != INITIAL + && LA(1) != PROTECTED && LA(1) != PUBLIC) + { + if(LA(1) == EOF_) + { + throw ANTLR_USE_NAMESPACE(antlr)RecognitionException("unexpected end of file", modelicafilename, LT(1)->getLine(), LT(1)->getColumn()); + } + consume(); + } + + AFTER_SYNC; + } + */ + +equation : + ( (simple_expression EQUALS) => equality_equation + | conditional_equation_e + | for_clause_e + | connect_clause + | when_clause_e + | IDENT function_call + ) + { + #equation = #([EQUATION_STATEMENT,"EQUATION_STATEMENT"], #equation); + } + comment + ; + /* + exception + catch [ANTLR_USE_NAMESPACE(antlr)RecognitionException &e] + { + BEFORE_SYNC; + + // Sync to SEMICOLON + while(LA(1) != SEMICOLON) + { + if(LA(1) == EOF_) + { + throw ANTLR_USE_NAMESPACE(antlr)RecognitionException("unexpected end of file", modelicafilename, LT(1)->getLine(), LT(1)->getColumn()); + } + consume(); + } + + AFTER_SYNC; + } + */ + +algorithm : + ( assign_clause_a + | multi_assign_clause_a + | conditional_equation_a + | for_clause_a + | while_clause + | when_clause_a + ) + comment + { + #algorithm = #([ALGORITHM_STATEMENT,"ALGORITHM_STATEMENT"], #algorithm); + } + ; + /* + exception + catch [ANTLR_USE_NAMESPACE(antlr)RecognitionException &e] + { + BEFORE_SYNC; + + // Sync to SEMICOLON + while(LA(1) != SEMICOLON) + { + if(LA(1) == EOF_) + { + throw ANTLR_USE_NAMESPACE(antlr)RecognitionException("unexpected end of file", modelicafilename, LT(1)->getLine(), LT(1)->getColumn()); + } + consume(); + } + + AFTER_SYNC; + } + */ + +assign_clause_a : component_reference ( ASSIGN^ expression | function_call ); + +multi_assign_clause_a : + LPAR! expression_list RPAR! ASSIGN^ component_reference function_call; + +equality_equation : + simple_expression EQUALS^ expression + ; + +conditional_equation_e : + IF^ expression THEN! equation_list + ( equation_elseif )* + ( ELSE equation_list )? + END! IF! + ; + +conditional_equation_a : + IF^ expression THEN! algorithm_list + ( algorithm_elseif )* + ( ELSE algorithm_list )? + END! IF! + ; + +for_clause_e : + FOR^ for_indices LOOP! + equation_list + END! FOR! + ; + +for_clause_a : + FOR^ for_indices LOOP! + algorithm_list + END! FOR! + ; + +while_clause : + WHILE^ expression LOOP! + algorithm_list + END! WHILE! + ; + +when_clause_e : + WHEN^ expression THEN! + equation_list + (else_when_e) * + END! WHEN! + ; + +else_when_e : + ELSEWHEN^ expression THEN! + equation_list + ; + +when_clause_a : + WHEN^ expression THEN! + algorithm_list + (else_when_a)* + END! WHEN! + ; + +else_when_a : + ELSEWHEN^ expression THEN! + algorithm_list + ; + +equation_elseif : + ELSEIF^ expression THEN! + equation_list + ; + +algorithm_elseif : + ELSEIF^ expression THEN! + algorithm_list + ; + +equation_list : + {LA(1) != END || (LA(1) == END && LA(2) != IDENT)}? + | + (equation SEMICOLON! equation_list) + ; + +algorithm_list : + ( algorithm SEMICOLON! )* + ; + +connect_clause : + CONNECT^ LPAR! connector_ref COMMA! connector_ref RPAR! + ; + +connector_ref : + IDENT^ ( array_subscripts )? ( DOT^ connector_ref_2 )? + ; + +connector_ref_2 : + IDENT^ ( array_subscripts )? + ; + +/* + * 2.2.7 Expressions + */ + +expression : + ( if_expression + | simple_expression + | code_expression + ) + ; + +if_expression : + IF^ expression THEN! expression (elseif_expression)* ELSE! expression + ; + +elseif_expression : + ELSEIF^ expression THEN! expression + ; + +for_indices : + for_index for_indices2 + ; +for_indices2 : + {LA(2) != IN}? + | + (COMMA! for_index) for_indices2 + ; + +for_index: + (IDENT (IN^ expression)?) +; + + +simple_expression ! : + l1:logical_expression + ( COLON l2:logical_expression + ( COLON l3:logical_expression + )? + )? + { + if (#l3 != null) + { + #simple_expression = #([RANGE3,"RANGE3"], l1, l2, l3); + } + else if (#l2 != null) + { + #simple_expression = #([RANGE2,"RANGE2"], l1, l2); + } + else + { + #simple_expression = #l1; + } + } + ; +/* Code quotation mechanism */ +code_expression ! : + CODE LPAR ((expression RPAR)=> e:expression | m:modification | el:element (SEMICOLON!)? + | eq:code_equation_clause | ieq:code_initial_equation_clause + | alg:code_algorithm_clause | ialg:code_initial_algorithm_clause + ) RPAR + { + if (#e) { + #code_expression = #([CODE_EXPRESSION, "CODE_EXPRESSION"],#e); + } else if (#m) { + #code_expression = #([CODE_MODIFICATION, "CODE_MODIFICATION"],#m); + } else if (#el) { + #code_expression = #([CODE_ELEMENT, "CODE_ELEMENT"],#el); + } else if (#eq) { + #code_expression = #([CODE_EQUATION, "CODE_EQUATION"],#eq); + } else if (#ieq) { + #code_expression = #([CODE_INITIALEQUATION, "CODE_EQUATION"],#ieq); + } else if (#alg) { + #code_expression = #([CODE_ALGORITHM, "CODE_ALGORITHM"],#alg); + } else if (#ialg) { + #code_expression = #([CODE_INITIALALGORITHM, "CODE_ALGORITHM"],#ialg); + } + } + ; + +code_equation_clause : + ( EQUATION^ (equation SEMICOLON! | annotation SEMICOLON! )* ) + ; + +code_initial_equation_clause : + { LA(2)==EQUATION}? + INITIAL! ec:code_equation_clause + { + #code_initial_equation_clause = #([INITIAL_EQUATION,"INTIAL_EQUATION"], ec); + } + ; + +code_algorithm_clause : + ALGORITHM^ (algorithm SEMICOLON! | annotation SEMICOLON!)* + ; +code_initial_algorithm_clause : + { LA(2) == ALGORITHM }? + INITIAL! ALGORITHM^ + (algorithm SEMICOLON! + |annotation SEMICOLON! + )* + { + #code_initial_algorithm_clause = #([INITIAL_ALGORITHM,"INTIAL_ALGORITHM"], #code_initial_algorithm_clause); + } + ; + +/* End Code quotation mechanism */ + +logical_expression : + logical_term ( OR^ logical_term )* + ; + +logical_term : + logical_factor ( AND^ logical_factor )* + ; + +logical_factor : + ( NOT^ )? + relation + ; + +relation : + arithmetic_expression ( ( LESS^ | LESSEQ^ | GREATER^ | GREATEREQ^ | EQEQ^ | LESSGT^ ) arithmetic_expression )? + ; + +rel_op : + ( LESS^ | LESSEQ^ | GREATER^ | GREATEREQ^ | EQEQ^ | LESSGT^ ) + ; + +arithmetic_expression : + unary_arithmetic_expression ( ( PLUS^ | MINUS^ ) term )* + ; + +unary_arithmetic_expression ! : + ( PLUS t1:term + { + #unary_arithmetic_expression = #([UNARY_PLUS,"PLUS"], #t1); + } + | MINUS t2:term + { + #unary_arithmetic_expression = #([UNARY_MINUS,"MINUS"], #t2); + } + | t3:term + { + #unary_arithmetic_expression = #t3; + } + ) + ; + +term : + factor ( ( STAR^ | SLASH^ ) factor )* + ; + +factor : + primary ( POWER^ primary )? + ; + +primary : + ( UNSIGNED_INTEGER + | UNSIGNED_REAL + | STRING + | FALSE + | TRUE + | component_reference__function_call + | DER^ function_call + | LPAR^ expression_list RPAR! + | LBRACK^ expression_list (SEMICOLON! expression_list)* RBRACK! + | LBRACE^ for_or_expression_list RBRACE! + | END + ) + ; + +component_reference__function_call ! : + cr:component_reference ( fc:function_call )? + { + if (#fc != null) + { + #component_reference__function_call = #([FUNCTION_CALL,"FUNCTION_CALL"], #cr, #fc); + } + else + { + #component_reference__function_call = #cr; + } + } + | i:INITIAL LPAR! RPAR! { + #component_reference__function_call = #([INITIAL_FUNCTION_CALL,"INITIAL_FUNCTION_CALL"],i); + } + ; + +name_path : + { LA(2)!=DOT }? IDENT | + IDENT DOT^ name_path + ; + +name_path_star returns [bool val=false] + : + { LA(2)!=DOT }? IDENT { val=false;}| + { LA(2)!=DOT }? STAR! { val=true;}| + i:IDENT DOT^ val = np:name_path_star + { + if(!(#np)) + { + #name_path_star = #i; + } + } + ; + +component_reference : + IDENT^ ( array_subscripts )? ( DOT^ component_reference )? + ; + +function_call : + LPAR! (function_arguments) RPAR! + { + #function_call = #([FUNCTION_ARGUMENTS,"FUNCTION_ARGUMENTS"],#function_call); + } + ; + +function_arguments : + (for_or_expression_list) + (named_arguments) ? + ; + +for_or_expression_list + : + ( + {LA(1)==IDENT && LA(2) == EQUALS|| LA(1) == RPAR}? + | + ( + e:expression + ( COMMA! explist:for_or_expression_list2 + | FOR^ forind:for_indices + )? + ) + { + if (#forind != null) { + #for_or_expression_list = + #([FOR_ITERATOR,"FOR_ITERATOR"], #for_or_expression_list); + } + else { + #for_or_expression_list = + #([EXPRESSION_LIST,"EXPRESSION_LIST"], #for_or_expression_list); + } + } + ) + ; + +for_or_expression_list2 : + {LA(2) == EQUALS}? + | + expression (COMMA! for_or_expression_list2)? + ; + +named_arguments : + named_arguments2 + { + #named_arguments=#([NAMED_ARGUMENTS,"NAMED_ARGUMENTS"],#named_arguments); + } + ; + +named_arguments2 : + named_argument ( COMMA! (COMMA IDENT EQUALS) => named_arguments2)? + ; + +named_argument : + IDENT EQUALS^ expression + ; + +expression_list : + expression_list2 + { + #expression_list=#([EXPRESSION_LIST,"EXPRESSION_LIST"],#expression_list); + } + ; +expression_list2 : + expression (COMMA! expression_list2)? + ; + +array_subscripts : + LBRACK^ subscript ( COMMA! subscript )* RBRACK! + ; + +subscript : + expression | COLON + ; + +comment : + ( + //string_comment ANNOTATION )=> annotation + string_comment (annotation)? + ) + { + #comment=#([COMMENT,"COMMENT"],#comment); + } + ; + +string_comment : + ( STRING ((PLUS STRING) => ( PLUS^ STRING )+ | ) )? + { + if (#string_comment) + { + #string_comment = #([STRING_COMMENT,"STRING_COMMENT"], #string_comment); + } + } +; + +annotation : + ANNOTATION^ class_modification + ; diff --git a/tools/xml/modelicaxml/modelica_parser.hpp b/tools/xml/modelicaxml/modelica_parser.hpp new file mode 100644 index 00000000000..2187b32cec4 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_parser.hpp @@ -0,0 +1,287 @@ +#ifndef INC_modelica_parser_hpp_ +#define INC_modelica_parser_hpp_ + +#include +/* $ANTLR 2.7.5rc2 (20050108): "modelica_parser.g" -> "modelica_parser.hpp"$ */ +#include +#include +#include "modelica_parserTokenTypes.hpp" +#include + +#line 2 "modelica_parser.g" + +#define null 0 +#include "MyAST.h" + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; + + +#line 20 "modelica_parser.hpp" +class CUSTOM_API modelica_parser : public ANTLR_USE_NAMESPACE(antlr)LLkParser, public modelica_parserTokenTypes +{ +#line 1 "modelica_parser.g" +#line 24 "modelica_parser.hpp" +public: + void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ); +protected: + modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k); +public: + modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf); +protected: + modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k); +public: + modelica_parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer); + modelica_parser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state); + int getNumTokens() const + { + return modelica_parser::NUM_TOKENS; + } + const char* getTokenName( int type ) const + { + if( type > getNumTokens() ) return 0; + return modelica_parser::tokenNames[type]; + } + const char* const* getTokenNames() const + { + return modelica_parser::tokenNames; + } + public: void stored_definition(); + public: void class_type(); + public: void component_clause(); + public: void import_clause(); + public: void within_clause(); + public: void class_definition(); + public: void name_path(); + public: void class_specifier(); + public: void class_specifier2(); + public: void class_modification(); + public: void string_comment(); + public: void composition(); + public: void base_prefix(); + public: void array_subscripts(); + public: void comment(); + public: void enumeration(); + public: void pder(); + public: void overloading(); + public: void ident_list(); + public: void name_list(); + public: void type_prefix(); + public: void enum_list(); + public: void enumeration_literal(); + public: void element_list(); + public: void public_element_list(); + public: void protected_element_list(); + public: void initial_equation_clause(); + public: void initial_algorithm_clause(); + public: void equation_clause(); + public: void algorithm_clause(); + public: void external_clause(); + public: void language_specification(); + public: void external_function_call(); + public: void annotation(); + public: void external_annotation(); + public: void component_reference(); + public: void expression_list(); + public: void element(); + public: void extends_clause(); + public: void constraining_clause(); + public: void explicit_import_name(); + public: void implicit_import_name(); + public: bool name_path_star(); + public: void type_specifier(); + public: void component_list(); + public: void component_declaration(); + public: void declaration(); + public: void conditional_attribute(); + public: void expression(); + public: void modification(); + public: void argument_list(); + public: void argument(); + public: void element_modification_or_replaceable(); + public: void element_redeclaration(); + public: void element_modification(); + public: void element_replaceable(); + public: void component_clause1(); + public: void component_declaration1(); + public: void equation_annotation_list(); + public: void equation(); + public: void algorithm(); + public: void simple_expression(); + public: void equality_equation(); + public: void conditional_equation_e(); + public: void for_clause_e(); + public: void connect_clause(); + public: void when_clause_e(); + public: void function_call(); + public: void assign_clause_a(); + public: void multi_assign_clause_a(); + public: void conditional_equation_a(); + public: void for_clause_a(); + public: void while_clause(); + public: void when_clause_a(); + public: void equation_list(); + public: void equation_elseif(); + public: void algorithm_list(); + public: void algorithm_elseif(); + public: void for_indices(); + public: void else_when_e(); + public: void else_when_a(); + public: void connector_ref(); + public: void connector_ref_2(); + public: void if_expression(); + public: void code_expression(); + public: void elseif_expression(); + public: void for_index(); + public: void for_indices2(); + public: void logical_expression(); + public: void code_equation_clause(); + public: void code_initial_equation_clause(); + public: void code_algorithm_clause(); + public: void code_initial_algorithm_clause(); + public: void logical_term(); + public: void logical_factor(); + public: void relation(); + public: void arithmetic_expression(); + public: void rel_op(); + public: void unary_arithmetic_expression(); + public: void term(); + public: void factor(); + public: void primary(); + public: void component_reference__function_call(); + public: void for_or_expression_list(); + public: void function_arguments(); + public: void named_arguments(); + public: void for_or_expression_list2(); + public: void named_arguments2(); + public: void named_argument(); + public: void expression_list2(); + public: void subscript(); +public: + ANTLR_USE_NAMESPACE(antlr)RefAST getAST() + { + return ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST); + } + +protected: + RefMyAST returnAST; +private: + static const char* tokenNames[]; +#ifndef NO_STATIC_CONSTS + static const int NUM_TOKENS = 147; +#else + enum { + NUM_TOKENS = 147 + }; +#endif + + static const unsigned long _tokenSet_0_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0; + static const unsigned long _tokenSet_1_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1; + static const unsigned long _tokenSet_2_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2; + static const unsigned long _tokenSet_3_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3; + static const unsigned long _tokenSet_4_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_4; + static const unsigned long _tokenSet_5_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_5; + static const unsigned long _tokenSet_6_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_6; + static const unsigned long _tokenSet_7_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_7; + static const unsigned long _tokenSet_8_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_8; + static const unsigned long _tokenSet_9_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_9; + static const unsigned long _tokenSet_10_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_10; + static const unsigned long _tokenSet_11_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_11; + static const unsigned long _tokenSet_12_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_12; + static const unsigned long _tokenSet_13_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_13; + static const unsigned long _tokenSet_14_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_14; + static const unsigned long _tokenSet_15_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_15; + static const unsigned long _tokenSet_16_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_16; + static const unsigned long _tokenSet_17_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_17; + static const unsigned long _tokenSet_18_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_18; + static const unsigned long _tokenSet_19_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_19; + static const unsigned long _tokenSet_20_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_20; + static const unsigned long _tokenSet_21_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_21; + static const unsigned long _tokenSet_22_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_22; + static const unsigned long _tokenSet_23_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_23; + static const unsigned long _tokenSet_24_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_24; + static const unsigned long _tokenSet_25_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_25; + static const unsigned long _tokenSet_26_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_26; + static const unsigned long _tokenSet_27_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_27; + static const unsigned long _tokenSet_28_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_28; + static const unsigned long _tokenSet_29_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_29; + static const unsigned long _tokenSet_30_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_30; + static const unsigned long _tokenSet_31_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_31; + static const unsigned long _tokenSet_32_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_32; + static const unsigned long _tokenSet_33_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_33; + static const unsigned long _tokenSet_34_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_34; + static const unsigned long _tokenSet_35_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_35; + static const unsigned long _tokenSet_36_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_36; + static const unsigned long _tokenSet_37_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_37; + static const unsigned long _tokenSet_38_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_38; + static const unsigned long _tokenSet_39_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_39; + static const unsigned long _tokenSet_40_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_40; + static const unsigned long _tokenSet_41_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_41; + static const unsigned long _tokenSet_42_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_42; + static const unsigned long _tokenSet_43_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_43; + static const unsigned long _tokenSet_44_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_44; + static const unsigned long _tokenSet_45_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_45; + static const unsigned long _tokenSet_46_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_46; + static const unsigned long _tokenSet_47_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_47; + static const unsigned long _tokenSet_48_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_48; + static const unsigned long _tokenSet_49_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_49; + static const unsigned long _tokenSet_50_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_50; + static const unsigned long _tokenSet_51_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_51; + static const unsigned long _tokenSet_52_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_52; + static const unsigned long _tokenSet_53_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_53; +}; + +#endif /*INC_modelica_parser_hpp_*/ diff --git a/tools/xml/modelicaxml/modelica_parserTokenTypes.hpp b/tools/xml/modelicaxml/modelica_parserTokenTypes.hpp new file mode 100644 index 00000000000..18c4be805fd --- /dev/null +++ b/tools/xml/modelicaxml/modelica_parserTokenTypes.hpp @@ -0,0 +1,163 @@ +#ifndef INC_modelica_parserTokenTypes_hpp_ +#define INC_modelica_parserTokenTypes_hpp_ + +/* $ANTLR 2.7.5rc2 (20050108): "modelica_parser.g" -> "modelica_parserTokenTypes.hpp"$ */ + +#ifndef CUSTOM_API +# define CUSTOM_API +#endif + +#ifdef __cplusplus +struct CUSTOM_API modelica_parserTokenTypes { +#endif + enum { + EOF_ = 1, + ALGORITHM = 4, + AND = 5, + ANNOTATION = 6, + BLOCK = 7, + CODE = 8, + CLASS = 9, + CONNECT = 10, + CONNECTOR = 11, + CONSTANT = 12, + DISCRETE = 13, + DER = 14, + EACH = 15, + ELSE = 16, + ELSEIF = 17, + ELSEWHEN = 18, + END = 19, + ENUMERATION = 20, + EQUATION = 21, + ENCAPSULATED = 22, + EXPANDABLE = 23, + EXTENDS = 24, + EXTERNAL = 25, + FALSE = 26, + FINAL = 27, + FLOW = 28, + FOR = 29, + FUNCTION = 30, + IF = 31, + IMPORT = 32, + IN = 33, + INITIAL = 34, + INNER = 35, + INPUT = 36, + LOOP = 37, + MODEL = 38, + NOT = 39, + OUTER = 40, + OVERLOAD = 41, + OR = 42, + OUTPUT = 43, + PACKAGE = 44, + PARAMETER = 45, + PARTIAL = 46, + PROTECTED = 47, + PUBLIC = 48, + RECORD = 49, + REDECLARE = 50, + REPLACEABLE = 51, + RESULTS = 52, + THEN = 53, + TRUE = 54, + TYPE = 55, + UNSIGNED_REAL = 56, + DOT = 57, + WHEN = 58, + WHILE = 59, + WITHIN = 60, + LPAR = 61, + RPAR = 62, + LBRACK = 63, + RBRACK = 64, + LBRACE = 65, + RBRACE = 66, + EQUALS = 67, + ASSIGN = 68, + PLUS = 69, + MINUS = 70, + STAR = 71, + SLASH = 72, + COMMA = 73, + LESS = 74, + LESSEQ = 75, + GREATER = 76, + GREATEREQ = 77, + EQEQ = 78, + LESSGT = 79, + COLON = 80, + SEMICOLON = 81, + POWER = 82, + YIELDS = 83, + AMPERSAND = 84, + PIPEBAR = 85, + COLONCOLON = 86, + DASHES = 87, + WS = 88, + ML_COMMENT = 89, + ML_COMMENT_CHAR = 90, + SL_COMMENT = 91, + IDENT = 92, + QIDENT = 93, + NONDIGIT = 94, + DIGIT = 95, + EXPONENT = 96, + UNSIGNED_INTEGER = 97, + STRING = 98, + SCHAR = 99, + QCHAR = 100, + SESCAPE = 101, + ESC = 102, + ALGORITHM_STATEMENT = 103, + ARGUMENT_LIST = 104, + BEGIN_DEFINITION = 105, + CLASS_DEFINITION = 106, + CLASS_EXTENDS = 107, + CLASS_MODIFICATION = 108, + CODE_EXPRESSION = 109, + CODE_MODIFICATION = 110, + CODE_ELEMENT = 111, + CODE_EQUATION = 112, + CODE_INITIALEQUATION = 113, + CODE_ALGORITHM = 114, + CODE_INITIALALGORITHM = 115, + COMMENT = 116, + COMPONENT_DEFINITION = 117, + DECLARATION = 118, + DEFINITION = 119, + END_DEFINITION = 120, + ENUMERATION_LITERAL = 121, + ELEMENT = 122, + ELEMENT_MODIFICATION = 123, + ELEMENT_REDECLARATION = 124, + EQUATION_STATEMENT = 125, + EXTERNAL_ANNOTATION = 126, + INITIAL_EQUATION = 127, + INITIAL_ALGORITHM = 128, + IMPORT_DEFINITION = 129, + IDENT_LIST = 130, + EXPRESSION_LIST = 131, + EXTERNAL_FUNCTION_CALL = 132, + FOR_INDICES = 133, + FOR_ITERATOR = 134, + FUNCTION_CALL = 135, + INITIAL_FUNCTION_CALL = 136, + FUNCTION_ARGUMENTS = 137, + NAMED_ARGUMENTS = 138, + QUALIFIED = 139, + RANGE2 = 140, + RANGE3 = 141, + STORED_DEFINITION = 142, + STRING_COMMENT = 143, + UNARY_MINUS = 144, + UNARY_PLUS = 145, + UNQUALIFIED = 146, + NULL_TREE_LOOKAHEAD = 3 + }; +#ifdef __cplusplus +}; +#endif +#endif /*INC_modelica_parserTokenTypes_hpp_*/ diff --git a/tools/xml/modelicaxml/modelica_parserTokenTypes.txt b/tools/xml/modelicaxml/modelica_parserTokenTypes.txt new file mode 100644 index 00000000000..0a7d389b230 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_parserTokenTypes.txt @@ -0,0 +1,145 @@ +// $ANTLR 2.7.5rc2 (20050108): modelica_parser.g -> modelica_parserTokenTypes.txt$ +modelica_parser // output token vocab name +ALGORITHM="algorithm"=4 +AND="and"=5 +ANNOTATION="annotation"=6 +BLOCK="block"=7 +CODE="Code"=8 +CLASS="class"=9 +CONNECT="connect"=10 +CONNECTOR="connector"=11 +CONSTANT="constant"=12 +DISCRETE="discrete"=13 +DER="der"=14 +EACH="each"=15 +ELSE="else"=16 +ELSEIF="elseif"=17 +ELSEWHEN="elsewhen"=18 +END="end"=19 +ENUMERATION="enumeration"=20 +EQUATION="equation"=21 +ENCAPSULATED="encapsulated"=22 +EXPANDABLE="expandable"=23 +EXTENDS="extends"=24 +EXTERNAL="external"=25 +FALSE="false"=26 +FINAL="final"=27 +FLOW="flow"=28 +FOR="for"=29 +FUNCTION="function"=30 +IF="if"=31 +IMPORT="import"=32 +IN="in"=33 +INITIAL="initial"=34 +INNER="inner"=35 +INPUT="input"=36 +LOOP="loop"=37 +MODEL="model"=38 +NOT="not"=39 +OUTER="outer"=40 +OVERLOAD="overload"=41 +OR="or"=42 +OUTPUT="output"=43 +PACKAGE="package"=44 +PARAMETER="parameter"=45 +PARTIAL="partial"=46 +PROTECTED="protected"=47 +PUBLIC="public"=48 +RECORD="record"=49 +REDECLARE="redeclare"=50 +REPLACEABLE="replaceable"=51 +RESULTS="results"=52 +THEN="then"=53 +TRUE="true"=54 +TYPE="type"=55 +UNSIGNED_REAL="unsigned_real"=56 +DOT="."=57 +WHEN="when"=58 +WHILE="while"=59 +WITHIN="within"=60 +LPAR=61 +RPAR=62 +LBRACK=63 +RBRACK=64 +LBRACE=65 +RBRACE=66 +EQUALS=67 +ASSIGN=68 +PLUS=69 +MINUS=70 +STAR=71 +SLASH=72 +COMMA=73 +LESS=74 +LESSEQ=75 +GREATER=76 +GREATEREQ=77 +EQEQ=78 +LESSGT=79 +COLON=80 +SEMICOLON=81 +POWER=82 +YIELDS=83 +AMPERSAND=84 +PIPEBAR=85 +COLONCOLON=86 +DASHES=87 +WS=88 +ML_COMMENT=89 +ML_COMMENT_CHAR=90 +SL_COMMENT=91 +IDENT("an identifier")=92 +QIDENT("an identifier")=93 +NONDIGIT=94 +DIGIT=95 +EXPONENT=96 +UNSIGNED_INTEGER=97 +STRING=98 +SCHAR=99 +QCHAR=100 +SESCAPE=101 +ESC=102 +ALGORITHM_STATEMENT=103 +ARGUMENT_LIST=104 +BEGIN_DEFINITION=105 +CLASS_DEFINITION=106 +CLASS_EXTENDS=107 +CLASS_MODIFICATION=108 +CODE_EXPRESSION=109 +CODE_MODIFICATION=110 +CODE_ELEMENT=111 +CODE_EQUATION=112 +CODE_INITIALEQUATION=113 +CODE_ALGORITHM=114 +CODE_INITIALALGORITHM=115 +COMMENT=116 +COMPONENT_DEFINITION=117 +DECLARATION=118 +DEFINITION=119 +END_DEFINITION=120 +ENUMERATION_LITERAL=121 +ELEMENT=122 +ELEMENT_MODIFICATION=123 +ELEMENT_REDECLARATION=124 +EQUATION_STATEMENT=125 +EXTERNAL_ANNOTATION=126 +INITIAL_EQUATION=127 +INITIAL_ALGORITHM=128 +IMPORT_DEFINITION=129 +IDENT_LIST=130 +EXPRESSION_LIST=131 +EXTERNAL_FUNCTION_CALL=132 +FOR_INDICES=133 +FOR_ITERATOR=134 +FUNCTION_CALL=135 +INITIAL_FUNCTION_CALL=136 +FUNCTION_ARGUMENTS=137 +NAMED_ARGUMENTS=138 +QUALIFIED=139 +RANGE2=140 +RANGE3=141 +STORED_DEFINITION=142 +STRING_COMMENT=143 +UNARY_MINUS=144 +UNARY_PLUS=145 +UNQUALIFIED=146 diff --git a/tools/xml/modelicaxml/modelica_tree_parser.cpp b/tools/xml/modelicaxml/modelica_tree_parser.cpp new file mode 100644 index 00000000000..e36c3696cf4 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_tree_parser.cpp @@ -0,0 +1,9801 @@ +/* $ANTLR 2.7.5rc2 (20050108): "walker.g" -> "modelica_tree_parser.cpp"$ */ +#include "modelica_tree_parser.hpp" +#include +#include +#include +#include +#include +#include +#line 47 "walker.g" + + +#line 13 "modelica_tree_parser.cpp" +#line 1 "walker.g" +#line 15 "modelica_tree_parser.cpp" +modelica_tree_parser::modelica_tree_parser() + : ANTLR_USE_NAMESPACE(antlr)TreeParser() { +} + +DOMElement * modelica_tree_parser::stored_definition(RefMyAST _t, + mstring moFilename, DOMDocument* pModelicaXMLDocParam +) { +#line 170 "walker.g" + DOMElement *ast; +#line 25 "modelica_tree_parser.cpp" + RefMyAST stored_definition_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST stored_definition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 170 "walker.g" + + DOMElement *within = 0; + l_stack el_stack; + pModelicaXMLDoc = pModelicaXMLDocParam; + + pRootElementModelicaXML = pModelicaXMLDoc->createElement(X("modelicaxml")); + // set the location of the .mo file we're representing in XML + pRootElementModelicaXML->setAttribute(X("file"), X(moFilename.c_str())); + + DOMElement* pDefinitionElement = 0; + +#line 44 "modelica_tree_parser.cpp" + + RefMyAST __t2 = _t; + RefMyAST tmp1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp1_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp1_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp1_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp1_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST2 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STORED_DEFINITION); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case WITHIN: + { + pRootElementModelicaXML=within_clause(_t,pRootElementModelicaXML); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case FINAL: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == FINAL || _t->getType() == CLASS_DEFINITION)) { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 185 "walker.g" + pDefinitionElement = pModelicaXMLDoc->createElement(X("definition")); +#line 111 "modelica_tree_parser.cpp" + pDefinitionElement=class_definition(_t,f != NULL, pDefinitionElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 187 "walker.g" + + if (pDefinitionElement /* adrpo modified 2004-10-27 && pDefinitionElement->hasChildNodes()*/) + { + el_stack.push_back(pDefinitionElement); + } + +#line 122 "modelica_tree_parser.cpp" + } + else { + goto _loop6; + } + + } + _loop6:; + } // ( ... )* + currentAST = __currentAST2; + _t = __t2; + _t = _t->getNextSibling(); +#line 195 "walker.g" + + //pRootElementModelicaXML = within; + pRootElementModelicaXML = (DOMElement*)appendKids(el_stack, pRootElementModelicaXML); + ast = pRootElementModelicaXML; + +#line 140 "modelica_tree_parser.cpp" + stored_definition_AST = RefMyAST(currentAST.root); + returnAST = stored_definition_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::within_clause(RefMyAST _t, + DOMElement* parent +) { +#line 205 "walker.g" + DOMElement* ast; +#line 152 "modelica_tree_parser.cpp" + RefMyAST within_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST within_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 205 "walker.g" + + void* pNamePath = 0; + +#line 161 "modelica_tree_parser.cpp" + + RefMyAST __t8 = _t; + RefMyAST tmp2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp2_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp2_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST8 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WITHIN); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT: + case IDENT: + { + pNamePath=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST8; + _t = __t8; + _t = _t->getNextSibling(); +#line 210 "walker.g" + + if (pNamePath) parent->setAttribute(X("within"), X(((mstring *)pNamePath)->c_str())); + ast = parent; + +#line 204 "modelica_tree_parser.cpp" + within_clause_AST = RefMyAST(currentAST.root); + returnAST = within_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::class_definition(RefMyAST _t, + bool final, DOMElement *definitionElement +) { +#line 219 "walker.g" + DOMElement* ast; +#line 216 "modelica_tree_parser.cpp" + RefMyAST class_definition_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_definition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST cd = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST cd_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ex = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ex_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 219 "walker.g" + + class_specifier_t sClassSpec; + sClassSpec.composition = definitionElement; + +#line 238 "modelica_tree_parser.cpp" + + RefMyAST __t11 = _t; + cd = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST cd_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + cd_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(cd)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(cd_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST11 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CLASS_DEFINITION); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ENCAPSULATED: + { + e = _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENCAPSULATED); + _t = _t->getNextSibling(); + break; + } + case BLOCK: + case CLASS: + case CONNECTOR: + case EXPANDABLE: + case FUNCTION: + case MODEL: + case PACKAGE: + case PARTIAL: + case RECORD: + case TYPE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PARTIAL: + { + p = _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PARTIAL); + _t = _t->getNextSibling(); + break; + } + case BLOCK: + case CLASS: + case CONNECTOR: + case EXPANDABLE: + case FUNCTION: + case MODEL: + case PACKAGE: + case RECORD: + case TYPE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXPANDABLE: + { + ex = _t; + RefMyAST ex_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ex_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ex)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ex_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXPANDABLE); + _t = _t->getNextSibling(); + break; + } + case BLOCK: + case CLASS: + case CONNECTOR: + case FUNCTION: + case MODEL: + case PACKAGE: + case RECORD: + case TYPE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + r = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + class_restriction(_t); + _t = _retTree; + r_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENT: + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + break; + } + case 3: + case ALGORITHM: + case ANNOTATION: + case EQUATION: + case EXTENDS: + case EXTERNAL: + case IMPORT: + case PROTECTED: + case PUBLIC: + case EQUALS: + case CLASS_EXTENDS: + case DECLARATION: + case DEFINITION: + case INITIAL_EQUATION: + case INITIAL_ALGORITHM: + case STRING_COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + class_specifier(_t,sClassSpec); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 230 "walker.g" + definitionElement=sClassSpec.composition; +#line 397 "modelica_tree_parser.cpp" + currentAST = __currentAST11; + _t = __t11; + _t = _t->getNextSibling(); +#line 232 "walker.g" + + definitionElement->setAttribute( + X("ident"), + X(i?i->getText().c_str():"_EXTENDED_")); + definitionElement->setAttribute(X("sline"), X(itoa(cd->getLine(),stmp,10))); + definitionElement->setAttribute(X("scolumn"), X(itoa(cd->getColumn(),stmp,10))); + + if (p != 0) definitionElement->setAttribute(X("partial"), X("true")); + if (final) definitionElement->setAttribute(X("final"), X("true")); + if (e != 0) definitionElement->setAttribute(X("encapsulated"), X("true")); + if (ex) definitionElement->setAttribute(X("restriction"), X("expandable")); + if (r) definitionElement->setAttribute(X("restriction"), str2xml(r)); + if (sClassSpec.string_comment) + { + definitionElement->appendChild(sClassSpec.string_comment); + } + if (sClassSpec.composition) + { + // nothing to do, already done at the lower level. + //definitionElement->appendChild(sClassSpec.composition); + //appendKids(definitionElement, sClassSpec.composition); + } + if (sClassSpec.derived) + { + definitionElement->appendChild(sClassSpec.derived); + } + if (sClassSpec.enumeration) + { + definitionElement->appendChild(sClassSpec.enumeration); + } + if (sClassSpec.overload) + { + definitionElement->appendChild(sClassSpec.overload); + } + if (sClassSpec.pder) + { + definitionElement->appendChild(sClassSpec.pder); + } + if (sClassSpec.classExtends) + { + definitionElement->appendChild(sClassSpec.classExtends); + } + ast = definitionElement; + +#line 446 "modelica_tree_parser.cpp" + class_definition_AST = RefMyAST(currentAST.root); + returnAST = class_definition_AST; + _retTree = _t; + return ast; +} + +void * modelica_tree_parser::name_path(RefMyAST _t) { +#line 2322 "walker.g" + void *ast; +#line 456 "modelica_tree_parser.cpp" + RefMyAST name_path_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST name_path_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2322 "walker.g" + + void *s1=0; + void *s2=0; + +#line 472 "modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENT: + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); +#line 2329 "walker.g" + + ast = (void*)new mstring(i->getText()); + +#line 489 "modelica_tree_parser.cpp" + name_path_AST = RefMyAST(currentAST.root); + break; + } + case DOT: + { + RefMyAST __t324 = _t; + d = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST d_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + d_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(d)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST324 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT); + _t = _t->getFirstChild(); + i2 = _t; + RefMyAST i2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i2_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + s2=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST324; + _t = __t324; + _t = _t->getNextSibling(); +#line 2333 "walker.g" + + s1 = (void*)new mstring(i2->getText()); + ast = (void*)new mstring(mstring(((mstring*)s1)->c_str())+mstring(".")+mstring(((mstring*)s2)->c_str())); + +#line 522 "modelica_tree_parser.cpp" + name_path_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = name_path_AST; + _retTree = _t; + return ast; +} + +void modelica_tree_parser::class_restriction(RefMyAST _t) { + RefMyAST class_restriction_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_restriction_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS: + { + RefMyAST tmp3_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp3_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp3_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp3_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp3_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CLASS); + _t = _t->getNextSibling(); + break; + } + case MODEL: + { + RefMyAST tmp4_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp4_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp4_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp4_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp4_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MODEL); + _t = _t->getNextSibling(); + break; + } + case RECORD: + { + RefMyAST tmp5_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp5_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp5_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp5_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp5_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RECORD); + _t = _t->getNextSibling(); + break; + } + case BLOCK: + { + RefMyAST tmp6_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp6_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp6_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp6_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp6_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BLOCK); + _t = _t->getNextSibling(); + break; + } + case CONNECTOR: + { + RefMyAST tmp7_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp7_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp7_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp7_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp7_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONNECTOR); + _t = _t->getNextSibling(); + break; + } + case TYPE: + { + RefMyAST tmp8_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp8_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp8_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp8_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp8_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TYPE); + _t = _t->getNextSibling(); + break; + } + case PACKAGE: + { + RefMyAST tmp9_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp9_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp9_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp9_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp9_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE); + _t = _t->getNextSibling(); + break; + } + case FUNCTION: + { + RefMyAST tmp10_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp10_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp10_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp10_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp10_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + class_restriction_AST = RefMyAST(currentAST.root); + returnAST = class_restriction_AST; + _retTree = _t; +} + +void modelica_tree_parser::class_specifier(RefMyAST _t, + class_specifier_t& sClassSpec +) { + RefMyAST class_specifier_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_specifier_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 299 "walker.g" + + DOMElement *comp = 0; + DOMElement *cmt = 0; + DOMElement *d = 0; + DOMElement *e = 0; + DOMElement *o = 0; + DOMElement *p = 0; + void *cmod = 0; + +#line 664 "modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case 3: + case ALGORITHM: + case ANNOTATION: + case EQUATION: + case EXTENDS: + case EXTERNAL: + case IMPORT: + case PROTECTED: + case PUBLIC: + case DECLARATION: + case DEFINITION: + case INITIAL_EQUATION: + case INITIAL_ALGORITHM: + case STRING_COMMENT: + { + { + { + cmt=string_comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + comp=composition(_t,sClassSpec.composition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 312 "walker.g" + + if (cmt) sClassSpec.string_comment = cmt; + sClassSpec.composition = comp; + +#line 698 "modelica_tree_parser.cpp" + } + class_specifier_AST = RefMyAST(currentAST.root); + break; + } + case EQUALS: + { + RefMyAST __t22 = _t; + RefMyAST tmp11_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp11_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp11_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp11_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp11_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST22 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { + d=derived_class(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ENUMERATION: + { + e=enumeration(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case OVERLOAD: + { + o=overloading(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case DER: + { + p=pder(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST22; + _t = __t22; + _t = _t->getNextSibling(); +#line 323 "walker.g" + + sClassSpec.derived = d; + sClassSpec.enumeration = e; + sClassSpec.overload = o; + sClassSpec.pder = p; + +#line 771 "modelica_tree_parser.cpp" + class_specifier_AST = RefMyAST(currentAST.root); + break; + } + case CLASS_EXTENDS: + { + RefMyAST __t24 = _t; + RefMyAST tmp12_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp12_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp12_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp12_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp12_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST24 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CLASS_EXTENDS); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_MODIFICATION: + { + cmod=class_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case ALGORITHM: + case ANNOTATION: + case EQUATION: + case EXTENDS: + case EXTERNAL: + case IMPORT: + case PROTECTED: + case PUBLIC: + case DECLARATION: + case DEFINITION: + case INITIAL_EQUATION: + case INITIAL_ALGORITHM: + case STRING_COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 330 "walker.g" + + sClassSpec.classExtends = pModelicaXMLDoc->createElement(X("extended_class")); + if (cmod) sClassSpec.classExtends = + (DOMElement*)appendKidsFromStack((l_stack *)cmod, sClassSpec.classExtends); + +#line 834 "modelica_tree_parser.cpp" + cmt=string_comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + comp=composition(_t,sClassSpec.classExtends); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST24; + _t = __t24; + _t = _t->getNextSibling(); +#line 336 "walker.g" + + sClassSpec.classExtends = pModelicaXMLDoc->createElement(X("extended_class")); + if (cmt) sClassSpec.classExtends->appendChild(cmt); + sClassSpec.classExtends->setAttribute( + X("ident"), + X(i->getText().c_str())); + +#line 852 "modelica_tree_parser.cpp" + class_specifier_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = class_specifier_AST; + _retTree = _t; +} + +DOMElement* modelica_tree_parser::string_comment(RefMyAST _t) { +#line 2574 "walker.g" + DOMElement* ast; +#line 868 "modelica_tree_parser.cpp" + RefMyAST string_comment_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST string_comment_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sc = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case STRING_COMMENT: + { +#line 2575 "walker.g" + + DOMElement* cmt=0; + ast = 0; + +#line 886 "modelica_tree_parser.cpp" + RefMyAST __t371 = _t; + sc = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST sc_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + sc_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(sc)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(sc_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST371 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING_COMMENT); + _t = _t->getFirstChild(); + cmt=string_concatenation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST371; + _t = __t371; + _t = _t->getNextSibling(); +#line 2580 "walker.g" + + DOMElement *pStringComment = pModelicaXMLDoc->createElement(X("string_comment")); + + pStringComment->setAttribute(X("sline"), X(itoa(sc->getLine(),stmp,10))); + pStringComment->setAttribute(X("scolumn"), X(itoa(sc->getColumn(),stmp,10))); + + pStringComment->appendChild(cmt); + ast = pStringComment; + +#line 913 "modelica_tree_parser.cpp" + string_comment_AST = RefMyAST(currentAST.root); + break; + } + case 3: + case ALGORITHM: + case ANNOTATION: + case EQUATION: + case EXTENDS: + case EXTERNAL: + case IMPORT: + case PROTECTED: + case PUBLIC: + case DECLARATION: + case DEFINITION: + case INITIAL_EQUATION: + case INITIAL_ALGORITHM: + { +#line 2590 "walker.g" + + ast = 0; + +#line 935 "modelica_tree_parser.cpp" + string_comment_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = string_comment_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::composition(RefMyAST _t, + DOMElement* definition +) { +#line 512 "walker.g" + DOMElement* ast; +#line 954 "modelica_tree_parser.cpp" + RefMyAST composition_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST composition_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 512 "walker.g" + + DOMElement* el = 0; + l_stack el_stack; + DOMElement* ann; + DOMElement* pExternalFunctionCall = 0; + +#line 966 "modelica_tree_parser.cpp" + + definition=element_list(_t,1 /* public */, definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_0.member(_t->getType()))) { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PUBLIC: + { + definition=public_element_list(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case PROTECTED: + { + definition=protected_element_list(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case EQUATION: + case INITIAL_EQUATION: + { + definition=equation_clause(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ALGORITHM: + case INITIAL_ALGORITHM: + { + definition=algorithm_clause(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + else { + goto _loop56; + } + + } + _loop56:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTERNAL: + { + RefMyAST __t58 = _t; + RefMyAST tmp13_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp13_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp13_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp13_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp13_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST58 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXTERNAL); + _t = _t->getFirstChild(); +#line 529 "walker.g" + pExternalFunctionCall = pModelicaXMLDoc->createElement(X("external")); +#line 1043 "modelica_tree_parser.cpp" + { + pExternalFunctionCall=external_function_call(_t,pExternalFunctionCall); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ANNOTATION: + { + pExternalFunctionCall=annotation(_t,0 /*none*/, pExternalFunctionCall, INSIDE_EXTERNAL); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case EXTERNAL_ANNOTATION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == EXTERNAL_ANNOTATION)) { +#line 533 "walker.g" + pExternalFunctionCall->appendChild(pModelicaXMLDoc->createElement(X("semicolon"))); +#line 1078 "modelica_tree_parser.cpp" + RefMyAST __t62 = _t; + RefMyAST tmp14_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp14_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp14_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp14_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp14_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST62 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXTERNAL_ANNOTATION); + _t = _t->getFirstChild(); + pExternalFunctionCall=annotation(_t,0 /*none*/, pExternalFunctionCall, INSIDE_EXTERNAL); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST62; + _t = __t62; + _t = _t->getNextSibling(); + } + else { + goto _loop63; + } + + } + _loop63:; + } // ( ... )* + currentAST = __currentAST58; + _t = __t58; + _t = _t->getNextSibling(); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 538 "walker.g" + + if (pExternalFunctionCall) definition->appendChild(pExternalFunctionCall); + ast = definition; + +#line 1124 "modelica_tree_parser.cpp" + composition_AST = RefMyAST(currentAST.root); + returnAST = composition_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::derived_class(RefMyAST _t) { +#line 388 "walker.g" + DOMElement* ast; +#line 1134 "modelica_tree_parser.cpp" + RefMyAST derived_class_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST derived_class_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 388 "walker.g" + + void* p = 0; + DOMElement* as = 0; + void *cmod = 0; + DOMElement* cmt = 0; + DOMElement* attr = 0; + type_prefix_t pfx; + DOMElement* pDerived = pModelicaXMLDoc->createElement(X("derived")); + +#line 1149 "modelica_tree_parser.cpp" + + { + type_prefix(_t,pDerived); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + p=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + as=array_subscripts(_t,0); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case CLASS_MODIFICATION: + case COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_MODIFICATION: + { + cmod=class_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 404 "walker.g" + + if (p) pDerived->setAttribute(X("type"), X(((mstring*)p)->c_str())); + if (as) pDerived->appendChild(as); + if (cmod) pDerived = (DOMElement*)appendKidsFromStack((l_stack *)cmod, pDerived); + if (cmt) pDerived->appendChild(cmt); + ast = pDerived; + +#line 1232 "modelica_tree_parser.cpp" + } + derived_class_AST = RefMyAST(currentAST.root); + returnAST = derived_class_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::enumeration(RefMyAST _t) { +#line 417 "walker.g" + DOMElement* ast; +#line 1243 "modelica_tree_parser.cpp" + RefMyAST enumeration_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enumeration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST en = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST en_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 417 "walker.g" + + l_stack el_stack; + DOMElement* el = 0; + DOMElement* cmt = 0; + +#line 1258 "modelica_tree_parser.cpp" + + RefMyAST __t39 = _t; + en = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST en_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + en_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(en)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(en_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST39 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENUMERATION); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ENUMERATION_LITERAL: + { + { + el=enumeration_literal(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 426 "walker.g" + el_stack.push_back(el); +#line 1282 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ENUMERATION_LITERAL)) { + el=enumeration_literal(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 429 "walker.g" + el_stack.push_back(el); +#line 1293 "modelica_tree_parser.cpp" + } + else { + goto _loop43; + } + + } + _loop43:; + } // ( ... )* + } + break; + } + case COLON: + { + c = _t; + RefMyAST c_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + c_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(c)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COLON); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST39; + _t = __t39; + _t = _t->getNextSibling(); +#line 437 "walker.g" + + DOMElement* pEnumeration = pModelicaXMLDoc->createElement(X("enumeration")); + pEnumeration->setAttribute(X("sline"), X(itoa(en->getLine(),stmp,10))); + pEnumeration->setAttribute(X("scolumn"), X(itoa(en->getColumn(),stmp,10))); + if (c) + { + pEnumeration->setAttribute(X("colon"), X("true")); + } + else + { + pEnumeration = (DOMElement*)appendKids(el_stack, pEnumeration); + } + if (cmt) pEnumeration->appendChild(cmt); + ast = pEnumeration; + +#line 1361 "modelica_tree_parser.cpp" + enumeration_AST = RefMyAST(currentAST.root); + returnAST = enumeration_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::overloading(RefMyAST _t) { +#line 480 "walker.g" + DOMElement* ast; +#line 1371 "modelica_tree_parser.cpp" + RefMyAST overloading_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST overloading_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ov = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ov_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 480 "walker.g" + + std::deque el_stack; + void* el = 0; + DOMElement* cmt = 0; + +#line 1384 "modelica_tree_parser.cpp" + + RefMyAST __t49 = _t; + ov = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST ov_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ov_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ov)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ov_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST49 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OVERLOAD); + _t = _t->getFirstChild(); + el=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 489 "walker.g" + el_stack.push_back(el); +#line 1401 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == DOT || _t->getType() == IDENT)) { + el=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 492 "walker.g" + el_stack.push_back(el); +#line 1412 "modelica_tree_parser.cpp" + } + else { + goto _loop51; + } + + } + _loop51:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST49; + _t = __t49; + _t = _t->getNextSibling(); +#line 497 "walker.g" + + DOMElement* pOverload = pModelicaXMLDoc->createElement(X("overload")); + if (cmt) pOverload->appendChild(cmt); + + pOverload->setAttribute(X("sline"), X(itoa(ov->getLine(),stmp,10))); + pOverload->setAttribute(X("scolumn"), X(itoa(ov->getColumn(),stmp,10))); + + ast = pOverload; + +#line 1455 "modelica_tree_parser.cpp" + overloading_AST = RefMyAST(currentAST.root); + returnAST = overloading_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::pder(RefMyAST _t) { +#line 345 "walker.g" + DOMElement* ast; +#line 1465 "modelica_tree_parser.cpp" + RefMyAST pder_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST pder_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 345 "walker.g" + + void* func=0; + DOMElement* var_lst=0; + +#line 1475 "modelica_tree_parser.cpp" + + RefMyAST __t27 = _t; + RefMyAST tmp15_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp15_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp15_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp15_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp15_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST27 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DER); + _t = _t->getFirstChild(); + func=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + var_lst=ident_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST27; + _t = __t27; + _t = _t->getNextSibling(); +#line 351 "walker.g" + + ast = pModelicaXMLDoc->createElement(X("pder")); + if (func) ast->setAttribute(X("type"), X(((mstring*)func)->c_str())); + ast->appendChild(var_lst); + +#line 1503 "modelica_tree_parser.cpp" + pder_AST = RefMyAST(currentAST.root); + returnAST = pder_AST; + _retTree = _t; + return ast; +} + +void * modelica_tree_parser::class_modification(RefMyAST _t) { +#line 1043 "walker.g" + void *stack; +#line 1513 "modelica_tree_parser.cpp" + RefMyAST class_modification_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST class_modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1043 "walker.g" + + stack = 0; + +#line 1522 "modelica_tree_parser.cpp" + + RefMyAST __t143 = _t; + RefMyAST tmp16_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp16_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp16_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp16_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp16_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST143 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CLASS_MODIFICATION); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ARGUMENT_LIST: + { + stack=argument_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST143; + _t = __t143; + _t = _t->getNextSibling(); + class_modification_AST = RefMyAST(currentAST.root); + returnAST = class_modification_AST; + _retTree = _t; + return stack; +} + +DOMElement* modelica_tree_parser::ident_list(RefMyAST _t) { +#line 358 "walker.g" + DOMElement* ast; +#line 1568 "modelica_tree_parser.cpp" + RefMyAST ident_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST ident_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 358 "walker.g" + + l_stack el_stack; + DOMElement* pIdent = 0; + +#line 1582 "modelica_tree_parser.cpp" + + RefMyAST __t29 = _t; + RefMyAST tmp17_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp17_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp17_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp17_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp17_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST29 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT_LIST); + _t = _t->getFirstChild(); + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); +#line 365 "walker.g" + + pIdent = pModelicaXMLDoc->createElement(X("pder_var")); + pIdent->setAttribute(X("ident"), X(i->getText().c_str())); + el_stack.push_back(pIdent); + +#line 1608 "modelica_tree_parser.cpp" + } + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IDENT)) { + i2 = _t; + RefMyAST i2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i2_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); +#line 371 "walker.g" + + pIdent = pModelicaXMLDoc->createElement(X("pder_var")); + pIdent->setAttribute(X("ident"), X(i2->getText().c_str())); + el_stack.push_back(pIdent); + +#line 1627 "modelica_tree_parser.cpp" + } + else { + goto _loop32; + } + + } + _loop32:; + } // ( ... )* + currentAST = __currentAST29; + _t = __t29; + _t = _t->getNextSibling(); +#line 377 "walker.g" + + + DOMElement* pIdentList = pModelicaXMLDoc->createElement(X("variables")); + pIdentList = (DOMElement*)appendKids(el_stack, pIdentList); + ast = pIdentList; + +#line 1646 "modelica_tree_parser.cpp" + ident_list_AST = RefMyAST(currentAST.root); + returnAST = ident_list_AST; + _retTree = _t; + return ast; +} + +void modelica_tree_parser::type_prefix(RefMyAST _t, + DOMElement* parent +) { + RefMyAST type_prefix_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST type_prefix_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FLOW: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FLOW); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DISCRETE: + { + d = _t; + RefMyAST d_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + d_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(d)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRETE); + _t = _t->getNextSibling(); + break; + } + case PARAMETER: + { + p = _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PARAMETER); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + { + c = _t; + RefMyAST c_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + c_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(c)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONSTANT); + _t = _t->getNextSibling(); + break; + } + case INPUT: + case OUTPUT: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case INPUT: + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INPUT); + _t = _t->getNextSibling(); + break; + } + case OUTPUT: + { + o = _t; + RefMyAST o_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + o_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(o)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(o_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OUTPUT); + _t = _t->getNextSibling(); + break; + } + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 907 "walker.g" + + if (f != NULL) { parent->setAttribute(X("flow"), X("true")); } + //else { parent->setAttribute(X("flow"), X("none")); } + if (d != NULL) { parent->setAttribute(X("variability"), X("discrete")); } + else if (p != NULL) { parent->setAttribute(X("variability"), X("parameter")); } + else if (c != NULL) { parent->setAttribute(X("variability"), X("constant")); } + //else { parent->setAttribute(X("variability"), X("variable")); } + if (i != NULL) { parent->setAttribute(X("direction"), X("input")); } + else if (o != NULL) { parent->setAttribute(X("direction"), X("output")); } + //else { parent->setAttribute(X("direction"), X("bidirectional")); } + +#line 1797 "modelica_tree_parser.cpp" + type_prefix_AST = RefMyAST(currentAST.root); + returnAST = type_prefix_AST; + _retTree = _t; +} + +DOMElement* modelica_tree_parser::array_subscripts(RefMyAST _t, + int kind +) { +#line 2507 "walker.g" + DOMElement* ast; +#line 1808 "modelica_tree_parser.cpp" + RefMyAST array_subscripts_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST array_subscripts_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbk = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbk_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2507 "walker.g" + + l_stack el_stack; + DOMElement* s = 0; + DOMElement *pArraySubscripts = 0; + if (kind) + pArraySubscripts = pModelicaXMLDoc->createElement(X("type_array_subscripts")); + else + pArraySubscripts = pModelicaXMLDoc->createElement(X("array_subscripts")); + +#line 1825 "modelica_tree_parser.cpp" + + RefMyAST __t362 = _t; + lbk = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lbk_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lbk_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lbk)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lbk_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST362 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LBRACK); + _t = _t->getFirstChild(); + pArraySubscripts=subscript(_t,pArraySubscripts); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_1.member(_t->getType()))) { + pArraySubscripts=subscript(_t,pArraySubscripts); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else { + goto _loop364; + } + + } + _loop364:; + } // ( ... )* + currentAST = __currentAST362; + _t = __t362; + _t = _t->getNextSibling(); +#line 2520 "walker.g" + + + pArraySubscripts->setAttribute(X("sline"), X(itoa(lbk->getLine(),stmp,10))); + pArraySubscripts->setAttribute(X("scolumn"), X(itoa(lbk->getColumn(),stmp,10))); + + ast = pArraySubscripts; + +#line 1867 "modelica_tree_parser.cpp" + array_subscripts_AST = RefMyAST(currentAST.root); + returnAST = array_subscripts_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::comment(RefMyAST _t) { +#line 2553 "walker.g" + DOMElement* ast; +#line 1877 "modelica_tree_parser.cpp" + RefMyAST comment_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST comment_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2553 "walker.g" + + DOMElement* ann=0; + DOMElement* cmt=0; + ast = 0; + DOMElement *pComment = pModelicaXMLDoc->createElement(X("comment")); + bool bAnno = false; + +#line 1892 "modelica_tree_parser.cpp" + + RefMyAST __t368 = _t; + c = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST c_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + c_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(c)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST368 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMMENT); + _t = _t->getFirstChild(); + cmt=string_comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2561 "walker.g" + if (cmt) pComment->appendChild(cmt); +#line 1909 "modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ANNOTATION: + { + pComment=annotation(_t,0 /* none */, pComment, INSIDE_COMMENT); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2562 "walker.g" + bAnno = true; +#line 1921 "modelica_tree_parser.cpp" + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST368; + _t = __t368; + _t = _t->getNextSibling(); +#line 2563 "walker.g" + + if (c) + { + pComment->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pComment->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + } + if ((cmt !=0) || bAnno) ast = pComment; + else ast = 0; + +#line 1947 "modelica_tree_parser.cpp" + comment_AST = RefMyAST(currentAST.root); + returnAST = comment_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::enumeration_literal(RefMyAST _t) { +#line 458 "walker.g" + DOMElement* ast; +#line 1957 "modelica_tree_parser.cpp" + RefMyAST enumeration_literal_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST enumeration_literal_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i1 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + +#line 459 "walker.g" + + DOMElement* c1=0; + +#line 1969 "modelica_tree_parser.cpp" + RefMyAST __t46 = _t; + RefMyAST tmp18_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp18_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp18_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp18_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp18_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST46 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENUMERATION_LITERAL); + _t = _t->getFirstChild(); + i1 = _t; + RefMyAST i1_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i1_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i1_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + c1=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST46; + _t = __t46; + _t = _t->getNextSibling(); +#line 463 "walker.g" + + DOMElement* pEnumerationLiteral = pModelicaXMLDoc->createElement(X("enumeration_literal")); + pEnumerationLiteral->setAttribute(X("ident"), str2xml(i1)); + + pEnumerationLiteral->setAttribute(X("sline"), X(itoa(i1->getLine(),stmp,10))); + pEnumerationLiteral->setAttribute(X("scolumn"), X(itoa(i1->getColumn(),stmp,10))); + + if (c1) pEnumerationLiteral->appendChild(c1); + ast = pEnumerationLiteral; + +#line 2022 "modelica_tree_parser.cpp" + enumeration_literal_AST = RefMyAST(currentAST.root); + returnAST = enumeration_literal_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::element_list(RefMyAST _t, + int iSwitch, DOMElement*definition +) { +#line 638 "walker.g" + DOMElement* ast; +#line 2034 "modelica_tree_parser.cpp" + RefMyAST element_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 638 "walker.g" + + DOMElement* e = 0; + l_stack el_stack; + DOMElement* ann = 0; + +#line 2045 "modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTENDS: + case IMPORT: + case DECLARATION: + case DEFINITION: + { + { + definition=element(_t,iSwitch, definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ANNOTATION: + { + { + definition=annotation(_t,iSwitch, definition, INSIDE_ELEMENT); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop81; + } + } + } + _loop81:; + } // ( ... )* +#line 647 "walker.g" + + ast = definition; + +#line 2085 "modelica_tree_parser.cpp" + element_list_AST = RefMyAST(currentAST.root); + returnAST = element_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::public_element_list(RefMyAST _t, + DOMElement* definition +) { +#line 544 "walker.g" + DOMElement* ast; +#line 2097 "modelica_tree_parser.cpp" + RefMyAST public_element_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST public_element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 544 "walker.g" + + DOMElement* el; + +#line 2108 "modelica_tree_parser.cpp" + + RefMyAST __t65 = _t; + p = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST65 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PUBLIC); + _t = _t->getFirstChild(); + definition=element_list(_t,1 /* public */, definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST65; + _t = __t65; + _t = _t->getNextSibling(); +#line 552 "walker.g" + + ast = definition; + +#line 2130 "modelica_tree_parser.cpp" + public_element_list_AST = RefMyAST(currentAST.root); + returnAST = public_element_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::protected_element_list(RefMyAST _t, + DOMElement* definition +) { +#line 557 "walker.g" + DOMElement* ast; +#line 2142 "modelica_tree_parser.cpp" + RefMyAST protected_element_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST protected_element_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 557 "walker.g" + + DOMElement* el; + +#line 2153 "modelica_tree_parser.cpp" + + RefMyAST __t67 = _t; + p = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST67 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED); + _t = _t->getFirstChild(); + definition=element_list(_t,2 /* protected */, definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST67; + _t = __t67; + _t = _t->getNextSibling(); +#line 566 "walker.g" + + ast = definition; + +#line 2175 "modelica_tree_parser.cpp" + protected_element_list_AST = RefMyAST(currentAST.root); + returnAST = protected_element_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::equation_clause(RefMyAST _t, + DOMElement *definition +) { +#line 1186 "walker.g" + DOMElement* ast; +#line 2187 "modelica_tree_parser.cpp" + RefMyAST equation_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1186 "walker.g" + + l_stack el_stack; + DOMElement* e = 0; + DOMElement* ann = 0; + +#line 2200 "modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUATION: + { + RefMyAST __t168 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST168 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUATION); + _t = _t->getFirstChild(); + { + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUATION_STATEMENT: + { + definition=equation(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ANNOTATION: + { + definition=annotation(_t,0 /*none*/, definition, INSIDE_EQUATION); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + goto _loop171; + } + } + } + _loop171:; + } // ( ... )* + } + currentAST = __currentAST168; + _t = __t168; + _t = _t->getNextSibling(); +#line 1200 "walker.g" + + ast = definition; + +#line 2253 "modelica_tree_parser.cpp" + equation_clause_AST = RefMyAST(currentAST.root); + break; + } + case INITIAL_EQUATION: + { + RefMyAST __t172 = _t; + RefMyAST tmp19_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp19_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp19_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp19_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp19_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST172 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INITIAL_EQUATION); + _t = _t->getFirstChild(); + RefMyAST __t173 = _t; + RefMyAST tmp20_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp20_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp20_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp20_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST173 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUATION); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUATION_STATEMENT: + { + definition=equation(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ANNOTATION: + { + definition=annotation(_t,0 /* none */, definition, INSIDE_EQUATION ); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + goto _loop175; + } + } + } + _loop175:; + } // ( ... )* + currentAST = __currentAST173; + _t = __t173; + _t = _t->getNextSibling(); +#line 1210 "walker.g" + + ast = definition; + +#line 2315 "modelica_tree_parser.cpp" + currentAST = __currentAST172; + _t = __t172; + _t = _t->getNextSibling(); + equation_clause_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = equation_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::algorithm_clause(RefMyAST _t, + DOMElement* definition +) { +#line 1216 "walker.g" + DOMElement* ast; +#line 2337 "modelica_tree_parser.cpp" + RefMyAST algorithm_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1216 "walker.g" + + l_stack el_stack; + DOMElement* e; + DOMElement* ann; + +#line 2348 "modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ALGORITHM: + { + RefMyAST __t177 = _t; + RefMyAST tmp21_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp21_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp21_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp21_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp21_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST177 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALGORITHM); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ALGORITHM_STATEMENT: + { + definition=algorithm(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ANNOTATION: + { + definition=annotation(_t,0 /* none */, definition, INSIDE_ALGORITHM); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + goto _loop179; + } + } + } + _loop179:; + } // ( ... )* + currentAST = __currentAST177; + _t = __t177; + _t = _t->getNextSibling(); +#line 1227 "walker.g" + + ast = definition; + +#line 2400 "modelica_tree_parser.cpp" + algorithm_clause_AST = RefMyAST(currentAST.root); + break; + } + case INITIAL_ALGORITHM: + { + RefMyAST __t180 = _t; + RefMyAST tmp22_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp22_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp22_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp22_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST180 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INITIAL_ALGORITHM); + _t = _t->getFirstChild(); + RefMyAST __t181 = _t; + RefMyAST tmp23_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp23_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp23_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp23_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST181 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALGORITHM); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ALGORITHM_STATEMENT: + { + definition=algorithm(_t,definition); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case ANNOTATION: + { + definition=annotation(_t,0 /* none */, definition, INSIDE_ALGORITHM); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + goto _loop183; + } + } + } + _loop183:; + } // ( ... )* + currentAST = __currentAST181; + _t = __t181; + _t = _t->getNextSibling(); +#line 1236 "walker.g" + + ast = definition; + +#line 2462 "modelica_tree_parser.cpp" + currentAST = __currentAST180; + _t = __t180; + _t = _t->getNextSibling(); + algorithm_clause_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = algorithm_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::external_function_call(RefMyAST _t, + DOMElement *pExternalFunctionCall +) { +#line 582 "walker.g" + DOMElement* ast; +#line 2484 "modelica_tree_parser.cpp" + RefMyAST external_function_call_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST external_function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 582 "walker.g" + + DOMElement* temp=0; + DOMElement* temp2=0; + DOMElement* temp3=0; + ast = 0; + DOMElement* pExternalEqual = pModelicaXMLDoc->createElement(X("external_equal")); + +#line 2505 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case STRING: + { + s = _t; + RefMyAST s_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + s_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(s)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING); + _t = _t->getNextSibling(); + break; + } + case 3: + case ANNOTATION: + case EXTERNAL_ANNOTATION: + case EXTERNAL_FUNCTION_CALL: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTERNAL_FUNCTION_CALL: + { + RefMyAST __t71 = _t; + RefMyAST tmp24_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp24_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp24_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp24_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST71 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXTERNAL_FUNCTION_CALL); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENT: + { + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXPRESSION_LIST: + { + temp=expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } +#line 595 "walker.g" + + if (s != NULL) pExternalFunctionCall->setAttribute(X("language_specification"), str2xml(s)); + if (i != NULL) pExternalFunctionCall->setAttribute(X("ident"), str2xml(i)); + if (temp) pExternalFunctionCall->appendChild(temp); + + pExternalFunctionCall->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pExternalFunctionCall->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pExternalFunctionCall; + +#line 2597 "modelica_tree_parser.cpp" + break; + } + case EQUALS: + { + RefMyAST __t75 = _t; + e = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST75 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + temp2=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + i2 = _t; + RefMyAST i2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i2_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXPRESSION_LIST: + { + temp3=expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST75; + _t = __t75; + _t = _t->getNextSibling(); +#line 606 "walker.g" + + if (s != NULL) pExternalFunctionCall->setAttribute(X("language_specification"), str2xml(s)); + if (i2 != NULL) pExternalFunctionCall->setAttribute(X("ident"), str2xml(i2)); + pExternalFunctionCall->setAttribute(X("sline"), X(itoa(i2->getLine(),stmp,10))); + pExternalFunctionCall->setAttribute(X("scolumn"), X(itoa(i2->getColumn(),stmp,10))); + DOMElement* pExternalEqual = + pModelicaXMLDoc->createElement(X("external_equal")); + if (temp2) pExternalEqual->appendChild(temp2); + pExternalFunctionCall->appendChild(pExternalEqual); + if (temp3) pExternalFunctionCall->appendChild(temp3); + ast = pExternalFunctionCall; + +#line 2658 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST71; + _t = __t71; + _t = _t->getNextSibling(); + break; + } + case 3: + case ANNOTATION: + case EXTERNAL_ANNOTATION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 620 "walker.g" + + if (!ast) + { + //parent->appendChild(ast); + ast = pExternalFunctionCall; + } + +#line 2692 "modelica_tree_parser.cpp" + external_function_call_AST = RefMyAST(currentAST.root); + returnAST = external_function_call_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::annotation(RefMyAST _t, + int iSwitch, DOMElement *parent, enum anno awhere +) { +#line 2634 "walker.g" + DOMElement* ast; +#line 2704 "modelica_tree_parser.cpp" + RefMyAST annotation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST annotation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST a = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2634 "walker.g" + + void* cmod=0; + +#line 2715 "modelica_tree_parser.cpp" + + RefMyAST __t375 = _t; + a = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST a_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + a_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(a)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST375 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ANNOTATION); + _t = _t->getFirstChild(); + cmod=class_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST375; + _t = __t375; + _t = _t->getNextSibling(); +#line 2640 "walker.g" + + DOMElement *pAnnotation = pModelicaXMLDoc->createElement(X("annotation")); + + pAnnotation->setAttribute(X("sline"), X(itoa(a->getLine(),stmp,10))); + pAnnotation->setAttribute(X("scolumn"), X(itoa(a->getColumn(),stmp,10))); + + switch (awhere) + { + case INSIDE_ELEMENT: + pAnnotation->setAttribute(X("inside"), X("element")); + break; + case INSIDE_EQUATION: + pAnnotation->setAttribute(X("inside"), X("equation")); + break; + case INSIDE_ALGORITHM: + pAnnotation->setAttribute(X("inside"), X("algorithm")); + break; + case INSIDE_COMMENT: + pAnnotation->setAttribute(X("inside"), X("comment")); + break; + default: + //pAnnotation->setAttribute(X("inside"), X("unspecified")); + ; + } + setVisibility(iSwitch, pAnnotation); + if (cmod) pAnnotation = (DOMElement*)appendKidsFromStack((l_stack *)cmod, pAnnotation); + parent->appendChild(pAnnotation); + ast = parent; + +#line 2763 "modelica_tree_parser.cpp" + annotation_AST = RefMyAST(currentAST.root); + returnAST = annotation_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::expression_list(RefMyAST _t) { +#line 2459 "walker.g" + DOMElement* ast; +#line 2773 "modelica_tree_parser.cpp" + RefMyAST expression_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2459 "walker.g" + + l_stack el_stack; + DOMElement* e; + //DOMElement* pComma = pModelicaXMLDoc->createElement(X("comma")); + +#line 2786 "modelica_tree_parser.cpp" + + { + RefMyAST __t353 = _t; + el = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST el_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + el_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(el)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(el_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST353 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXPRESSION_LIST); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2467 "walker.g" + el_stack.push_back(e); +#line 2804 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_2.member(_t->getType()))) { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2468 "walker.g" + el_stack.push_back(pModelicaXMLDoc->createElement(X("comma"))); el_stack.push_back(e); +#line 2815 "modelica_tree_parser.cpp" + } + else { + goto _loop355; + } + + } + _loop355:; + } // ( ... )* + currentAST = __currentAST353; + _t = __t353; + _t = _t->getNextSibling(); + } +#line 2471 "walker.g" + + ast = (DOMElement*)stack2DOMNode(el_stack, "expression_list"); + + ast->setAttribute(X("sline"), X(itoa(el->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(el->getColumn(),stmp,10))); + +#line 2835 "modelica_tree_parser.cpp" + expression_list_AST = RefMyAST(currentAST.root); + returnAST = expression_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::component_reference(RefMyAST _t) { +#line 2339 "walker.g" + DOMElement* ast; +#line 2845 "modelica_tree_parser.cpp" + RefMyAST component_reference_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_reference_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2339 "walker.g" + + DOMElement* arr = 0; + DOMElement* id = 0; + +#line 2859 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENT: + { + RefMyAST __t327 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST327 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + arr=array_subscripts(_t,0); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST327; + _t = __t327; + _t = _t->getNextSibling(); +#line 2346 "walker.g" + + DOMElement *pCref = pModelicaXMLDoc->createElement(X("component_reference")); + + pCref->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pCref->setAttribute(X("ident"), str2xml(i)); + if (arr) pCref->appendChild(arr); + ast = pCref; + +#line 2912 "modelica_tree_parser.cpp" + break; + } + case DOT: + { + RefMyAST __t329 = _t; + RefMyAST tmp25_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp25_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp25_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp25_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp25_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST329 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT); + _t = _t->getFirstChild(); + RefMyAST __t330 = _t; + i2 = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i2_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST330 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + arr=array_subscripts(_t,0); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST330; + _t = __t330; + _t = _t->getNextSibling(); + ast=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST329; + _t = __t329; + _t = _t->getNextSibling(); +#line 2358 "walker.g" + + DOMElement *pCref = pModelicaXMLDoc->createElement(X("component_reference")); + pCref->setAttribute(X("ident"), str2xml(i2)); + + pCref->setAttribute(X("sline"), X(itoa(i2->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i2->getColumn(),stmp,10))); + + if (arr) pCref->appendChild(arr); + pCref->appendChild(ast); + ast = pCref; + +#line 2980 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + component_reference_AST = RefMyAST(currentAST.root); + returnAST = component_reference_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::element(RefMyAST _t, + int iSwitch, DOMElement *parent +) { +#line 656 "walker.g" + DOMElement* ast; +#line 3000 "modelica_tree_parser.cpp" + RefMyAST element_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST re = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST re_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST re2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST re2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fd = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fd_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST id = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST id_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST od = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST od_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST rd = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST rd_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 656 "walker.g" + + DOMElement* class_def = 0; + DOMElement* e_spec = 0; + DOMElement* final = 0; + DOMElement* innerouter = 0; + DOMElement* constr = 0; + DOMElement* cmt = 0; + DOMElement* comp_clause = 0; + +#line 3035 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IMPORT: + { + parent=import_clause(_t,iSwitch, parent); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 668 "walker.g" + + ast = parent; + +#line 3050 "modelica_tree_parser.cpp" + break; + } + case EXTENDS: + { + parent=extends_clause(_t,iSwitch, parent); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 672 "walker.g" + + ast = parent; + +#line 3062 "modelica_tree_parser.cpp" + break; + } + case DECLARATION: + { + RefMyAST __t84 = _t; + RefMyAST tmp26_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp26_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp26_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp26_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp26_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST84 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DECLARATION); + _t = _t->getFirstChild(); + { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case REDELCARE: + { + re = _t; + RefMyAST re_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + re_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(re)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(re_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REDELCARE); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FINAL: + case FLOW: + case INNER: + case INPUT: + case OUTER: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 677 "walker.g" + + DOMElement* componentElement = pModelicaXMLDoc->createElement(X("component_clause")); + setVisibility(iSwitch, componentElement); + if (re) componentElement->setAttribute(X("redeclare"), X("true")); + +#line 3120 "modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INNER: + case INPUT: + case OUTER: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 682 "walker.g" + if (f) componentElement->setAttribute(X("final"), X("true")); +#line 3157 "modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case INNER: + { + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INNER); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTER: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case OUTER: + { + o = _t; + RefMyAST o_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + o_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(o)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(o_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OUTER); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 684 "walker.g" + + if (i && o) componentElement->setAttribute(X("innerouter"), X("innerouter")); + else + { + if (i) componentElement->setAttribute(X("innerouter"), X("inner")); + if (o) componentElement->setAttribute(X("innerouter"), X("outer")); + } + +#line 3232 "modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { + parent=component_clause(_t,parent, componentElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 693 "walker.g" + + ast = parent; + +#line 3253 "modelica_tree_parser.cpp" + break; + } + case REPLACEABLE: + { + r = _t; + RefMyAST r_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + r_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(r)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REPLACEABLE); + _t = _t->getNextSibling(); +#line 696 "walker.g" + if (r) componentElement->setAttribute(X("replaceable"), X("true")); +#line 3266 "modelica_tree_parser.cpp" + parent=component_clause(_t,parent, componentElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTENDS: + { + constr=constraining_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 699 "walker.g" + + if (constr) + { + // append the comment to the constraint + if (cmt) ((DOMElement*)constr)->appendChild(cmt); + parent->appendChild(constr); + } + ast = parent; + +#line 3304 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + currentAST = __currentAST84; + _t = __t84; + _t = _t->getNextSibling(); + break; + } + case DEFINITION: + { + RefMyAST __t92 = _t; + RefMyAST tmp27_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp27_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp27_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp27_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp27_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST92 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DEFINITION); + _t = _t->getFirstChild(); + { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case REDECLARE: + { + re2 = _t; + RefMyAST re2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + re2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(re2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(re2_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REDECLARE); + _t = _t->getNextSibling(); + break; + } + case FINAL: + case INNER: + case OUTER: + case REPLACEABLE: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 713 "walker.g" + + DOMElement* definitionElement = pModelicaXMLDoc->createElement(X("definition")); + setVisibility(iSwitch, definitionElement); + if (re2) definitionElement->setAttribute(X("redeclare"), X("true")); + +#line 3367 "modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + fd = _t; + RefMyAST fd_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + fd_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(fd)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(fd_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case INNER: + case OUTER: + case REPLACEABLE: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 718 "walker.g" + if (fd) definitionElement->setAttribute(X("final"), X("true")); +#line 3397 "modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case INNER: + { + id = _t; + RefMyAST id_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + id_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(id)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(id_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INNER); + _t = _t->getNextSibling(); + break; + } + case OUTER: + case REPLACEABLE: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case OUTER: + { + od = _t; + RefMyAST od_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + od_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(od)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(od_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OUTER); + _t = _t->getNextSibling(); + break; + } + case REPLACEABLE: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 720 "walker.g" + + if (i && o) definitionElement->setAttribute(X("innerouter"), X("outer")); + else + { + if (i) definitionElement->setAttribute(X("innerouter"), X("inner")); + if (o) definitionElement->setAttribute(X("innerouter"), X("outer")); + } + +#line 3458 "modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_DEFINITION: + { + definitionElement=class_definition(_t,fd != NULL, definitionElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 730 "walker.g" + + if (definitionElement && definitionElement->hasChildNodes()) + parent->appendChild(definitionElement); + ast = parent; + +#line 3474 "modelica_tree_parser.cpp" + break; + } + case REPLACEABLE: + { + { + rd = _t; + RefMyAST rd_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + rd_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(rd)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(rd_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REPLACEABLE); + _t = _t->getNextSibling(); + definitionElement=class_definition(_t,fd != NULL, definitionElement); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTENDS: + { + constr=constraining_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } +#line 740 "walker.g" + + if (definitionElement) + { + if (innerouter) definitionElement->appendChild(innerouter); + if (constr) + { + definitionElement->appendChild(constr); + // append the comment to the constraint + if (cmt) ((DOMElement*)constr)->appendChild(cmt); + } + if (rd) definitionElement->setAttribute(X("replaceable"), X("true")); + if (definitionElement->hasChildNodes()) + parent->appendChild(definitionElement); + } + ast = parent; + +#line 3531 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + currentAST = __currentAST92; + _t = __t92; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + element_AST = RefMyAST(currentAST.root); + returnAST = element_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::import_clause(RefMyAST _t, + int iSwitch, DOMElement *parent +) { +#line 765 "walker.g" + DOMElement* ast; +#line 3563 "modelica_tree_parser.cpp" + RefMyAST import_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST import_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 765 "walker.g" + + DOMElement* imp = 0; + DOMElement* cmt = 0; + +#line 3575 "modelica_tree_parser.cpp" + + RefMyAST __t102 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST102 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IMPORT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUALS: + { + imp=explicit_import_name(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case QUALIFIED: + case UNQUALIFIED: + { + imp=implicit_import_name(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST102; + _t = __t102; + _t = _t->getNextSibling(); +#line 777 "walker.g" + + DOMElement* pImport = pModelicaXMLDoc->createElement(X("import")); + setVisibility(iSwitch, pImport); + + pImport->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pImport->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pImport->appendChild(imp); + if (cmt) pImport->appendChild(cmt); + parent->appendChild(pImport); + ast = parent; + +#line 3649 "modelica_tree_parser.cpp" + import_clause_AST = RefMyAST(currentAST.root); + returnAST = import_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::extends_clause(RefMyAST _t, + int iSwitch, DOMElement* parent +) { +#line 846 "walker.g" + DOMElement* ast; +#line 3661 "modelica_tree_parser.cpp" + RefMyAST extends_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST extends_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 846 "walker.g" + + void *path = 0; + void *mod = 0; + +#line 3673 "modelica_tree_parser.cpp" + + { + RefMyAST __t113 = _t; + e = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST113 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXTENDS); + _t = _t->getFirstChild(); + path=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_MODIFICATION: + { + mod=class_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST113; + _t = __t113; + _t = _t->getNextSibling(); +#line 856 "walker.g" + + DOMElement* pExtends = pModelicaXMLDoc->createElement(X("extends")); + setVisibility(iSwitch, pExtends); + + pExtends->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pExtends->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + if (mod) pExtends = (DOMElement*)appendKidsFromStack((l_stack *)mod, pExtends); + if (path) pExtends->setAttribute(X("type"), X(((mstring*)path)->c_str())); + parent->appendChild(pExtends); + ast = parent; + +#line 3726 "modelica_tree_parser.cpp" + } + extends_clause_AST = RefMyAST(currentAST.root); + returnAST = extends_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::component_clause(RefMyAST _t, + DOMElement* parent, DOMElement* attributes +) { +#line 885 "walker.g" + DOMElement* ast; +#line 3739 "modelica_tree_parser.cpp" + RefMyAST component_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 885 "walker.g" + + type_prefix_t pfx; + void* path = 0; + DOMElement* arr = 0; + DOMElement* comp_list = 0; + +#line 3751 "modelica_tree_parser.cpp" + + type_prefix(_t,attributes); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + path=type_specifier(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 894 "walker.g" + if (path) attributes->setAttribute(X("type"), X(((mstring*)path)->c_str())); +#line 3761 "modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + arr=array_subscripts(_t,1); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + parent=component_list(_t,parent, attributes, arr); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 897 "walker.g" + + ast = parent; + +#line 3790 "modelica_tree_parser.cpp" + component_clause_AST = RefMyAST(currentAST.root); + returnAST = component_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::constraining_clause(RefMyAST _t) { +#line 874 "walker.g" + DOMElement* ast; +#line 3800 "modelica_tree_parser.cpp" + RefMyAST constraining_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST constraining_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 874 "walker.g" + + DOMElement* pConstrain = pModelicaXMLDoc->createElement(X("constrain")); + +#line 3809 "modelica_tree_parser.cpp" + + { + ast=extends_clause(_t,0, pConstrain); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + constraining_clause_AST = RefMyAST(currentAST.root); + returnAST = constraining_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::explicit_import_name(RefMyAST _t) { +#line 794 "walker.g" + DOMElement* ast; +#line 3825 "modelica_tree_parser.cpp" + RefMyAST explicit_import_name_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST explicit_import_name_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 794 "walker.g" + + void* path; + +#line 3836 "modelica_tree_parser.cpp" + + RefMyAST __t106 = _t; + RefMyAST tmp28_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp28_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp28_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp28_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST106 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + path=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST106; + _t = __t106; + _t = _t->getNextSibling(); +#line 800 "walker.g" + + DOMElement* pExplicitImport = pModelicaXMLDoc->createElement(X("named_import")); + pExplicitImport->setAttribute(X("ident"), str2xml(i)); + + pExplicitImport->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pExplicitImport->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (path) pExplicitImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + ast = pExplicitImport; + +#line 3872 "modelica_tree_parser.cpp" + explicit_import_name_AST = RefMyAST(currentAST.root); + returnAST = explicit_import_name_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::implicit_import_name(RefMyAST _t) { +#line 814 "walker.g" + DOMElement* ast; +#line 3882 "modelica_tree_parser.cpp" + RefMyAST implicit_import_name_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST implicit_import_name_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST unq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST unq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST qua = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST qua_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 814 "walker.g" + + void* path; + +#line 3895 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case UNQUALIFIED: + { + RefMyAST __t109 = _t; + unq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST unq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + unq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(unq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(unq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST109 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNQUALIFIED); + _t = _t->getFirstChild(); + path=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST109; + _t = __t109; + _t = _t->getNextSibling(); +#line 820 "walker.g" + + DOMElement* pUnqImport = pModelicaXMLDoc->createElement(X("unqualified_import")); + if (path) pUnqImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + + pUnqImport->setAttribute(X("sline"), X(itoa(unq->getLine(),stmp,10))); + pUnqImport->setAttribute(X("scolumn"), X(itoa(unq->getColumn(),stmp,10))); + + ast = pUnqImport; + +#line 3929 "modelica_tree_parser.cpp" + break; + } + case QUALIFIED: + { + RefMyAST __t110 = _t; + qua = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST qua_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + qua_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(qua)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(qua_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST110 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),QUALIFIED); + _t = _t->getFirstChild(); + path=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST110; + _t = __t110; + _t = _t->getNextSibling(); +#line 830 "walker.g" + + DOMElement* pQuaImport = pModelicaXMLDoc->createElement(X("qualified_import")); + if (path) pQuaImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + + pQuaImport->setAttribute(X("sline"), X(itoa(qua->getLine(),stmp,10))); + pQuaImport->setAttribute(X("scolumn"), X(itoa(qua->getColumn(),stmp,10))); + + ast = pQuaImport; + +#line 3960 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + implicit_import_name_AST = RefMyAST(currentAST.root); + returnAST = implicit_import_name_AST; + _retTree = _t; + return ast; +} + +void* modelica_tree_parser::type_specifier(RefMyAST _t) { +#line 921 "walker.g" + void* ast; +#line 3978 "modelica_tree_parser.cpp" + RefMyAST type_specifier_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST type_specifier_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + ast=name_path(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + type_specifier_AST = RefMyAST(currentAST.root); + returnAST = type_specifier_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::component_list(RefMyAST _t, + DOMElement* parent, DOMElement *attributes, DOMElement* type_array +) { +#line 927 "walker.g" + DOMElement* ast; +#line 3998 "modelica_tree_parser.cpp" + RefMyAST component_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 927 "walker.g" + + l_stack el_stack; + DOMElement* e=0; + +#line 4008 "modelica_tree_parser.cpp" + + parent=component_declaration(_t,parent, attributes, type_array); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IDENT)) { + parent=component_declaration(_t,parent, attributes, type_array); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else { + goto _loop126; + } + + } + _loop126:; + } // ( ... )* +#line 936 "walker.g" + + ast = parent; + +#line 4033 "modelica_tree_parser.cpp" + component_list_AST = RefMyAST(currentAST.root); + returnAST = component_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::component_declaration(RefMyAST _t, + DOMElement* parent, DOMElement *attributes, DOMElement *type_array +) { +#line 957 "walker.g" + DOMElement* ast; +#line 4045 "modelica_tree_parser.cpp" + RefMyAST component_declaration_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_declaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 957 "walker.g" + + DOMElement* cmt = 0; + DOMElement* dec = 0; + DOMElement* cda = 0; + +#line 4056 "modelica_tree_parser.cpp" + + { + dec=declaration(_t,attributes, type_array); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IF: + { + cda=conditional_attribute(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case EXTENDS: + case IDENT: + case COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case EXTENDS: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 968 "walker.g" + + if (cmt) dec->appendChild(cmt); + if (cda) dec->appendChild(cda); + parent->appendChild(dec); + ast = parent; + +#line 4117 "modelica_tree_parser.cpp" + component_declaration_AST = RefMyAST(currentAST.root); + returnAST = component_declaration_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::conditional_attribute(RefMyAST _t) { +#line 941 "walker.g" + DOMElement* ast; +#line 4127 "modelica_tree_parser.cpp" + RefMyAST conditional_attribute_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_attribute_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 941 "walker.g" + + DOMElement* cda = 0; + DOMElement* e = 0; + +#line 4139 "modelica_tree_parser.cpp" + + RefMyAST __t128 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST128 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST128; + _t = __t128; + _t = _t->getNextSibling(); +#line 947 "walker.g" + + cda = pModelicaXMLDoc->createElement(X("conditional")); + cda->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + cda->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + cda->appendChild(e); + ast = cda; + +#line 4165 "modelica_tree_parser.cpp" + conditional_attribute_AST = RefMyAST(currentAST.root); + returnAST = conditional_attribute_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::expression(RefMyAST _t) { +#line 1776 "walker.g" + DOMElement* ast; +#line 4175 "modelica_tree_parser.cpp" + RefMyAST expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case DER: + case END: + case FALSE: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case RANGE2: + case RANGE3: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=simple_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IF: + { + ast=if_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case CODE_EXPRESSION: + case CODE_MODIFICATION: + case CODE_ELEMENT: + case CODE_EQUATION: + case CODE_INITIALEQUATION: + case CODE_ALGORITHM: + case CODE_INITIALALGORITHM: + { + ast=code_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + expression_AST = RefMyAST(currentAST.root); + returnAST = expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::declaration(RefMyAST _t, + DOMElement* parent, DOMElement* type_array +) { +#line 978 "walker.g" + DOMElement* ast; +#line 4260 "modelica_tree_parser.cpp" + RefMyAST declaration_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST declaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 978 "walker.g" + + DOMElement* arr = 0; + DOMElement* mod = 0; + DOMElement* id = 0; + +#line 4273 "modelica_tree_parser.cpp" + + RefMyAST __t134 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST134 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LBRACK: + { + arr=array_subscripts(_t,0); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case EQUALS: + case ASSIGN: + case CLASS_MODIFICATION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUALS: + case ASSIGN: + case CLASS_MODIFICATION: + { + mod=modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST134; + _t = __t134; + _t = _t->getNextSibling(); +#line 986 "walker.g" + + DOMElement *pComponent = pModelicaXMLDoc->createElement(X("component")); + pComponent->setAttribute(X("ident"), str2xml(i)); + pComponent->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pComponent->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + setAttributes(pComponent, parent); + if (type_array) pComponent->appendChild(type_array); + if (arr) pComponent->appendChild(arr); + if (mod) pComponent->appendChild(mod); + ast = pComponent; + +#line 4347 "modelica_tree_parser.cpp" + declaration_AST = RefMyAST(currentAST.root); + returnAST = declaration_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::modification(RefMyAST _t) { +#line 999 "walker.g" + DOMElement* ast; +#line 4357 "modelica_tree_parser.cpp" + RefMyAST modification_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST as = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST as_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 999 "walker.g" + + DOMElement* e = 0; + void *cm = 0; + int iswitch = 0; + +#line 4372 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_MODIFICATION: + { + cm=class_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case DER: + case END: + case FALSE: + case IF: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case CODE_EXPRESSION: + case CODE_MODIFICATION: + case CODE_ELEMENT: + case CODE_EQUATION: + case CODE_INITIALEQUATION: + case CODE_ALGORITHM: + case CODE_INITIALALGORITHM: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case RANGE2: + case RANGE3: + case UNARY_MINUS: + case UNARY_PLUS: + { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case STRING_COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + break; + } + case EQUALS: + { + RefMyAST __t140 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST140 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST140; + _t = __t140; + _t = _t->getNextSibling(); +#line 1007 "walker.g" + iswitch = 1; +#line 4466 "modelica_tree_parser.cpp" + break; + } + case ASSIGN: + { + RefMyAST __t141 = _t; + as = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST as_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + as_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(as)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(as_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST141 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ASSIGN); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST141; + _t = __t141; + _t = _t->getNextSibling(); +#line 1008 "walker.g" + iswitch = 2; +#line 4489 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 1010 "walker.g" + + DOMElement *pModificationEQorASorARG = null; + if (iswitch == 1) pModificationEQorASorARG = pModelicaXMLDoc->createElement(X("modification_equals")); + if (iswitch == 2) pModificationEQorASorARG = pModelicaXMLDoc->createElement(X("modification_assign")); + if (iswitch == 0) pModificationEQorASorARG = pModelicaXMLDoc->createElement(X("modification_arguments")); + if (cm) pModificationEQorASorARG = (DOMElement*)appendKidsFromStack((l_stack*)cm, pModificationEQorASorARG); + if (e) + { + if (iswitch == 0) + { + DOMElement *z = pModelicaXMLDoc->createElement(X("modification_equals")); + z->appendChild(e); + pModificationEQorASorARG->appendChild(z); + } + else + { + pModificationEQorASorARG->appendChild(e); + } + } + if (eq) + { + pModificationEQorASorARG->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); + pModificationEQorASorARG->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); + } + if (as) + { + pModificationEQorASorARG->setAttribute(X("sline"), X(itoa(as->getLine(),stmp,10))); + pModificationEQorASorARG->setAttribute(X("scolumn"), X(itoa(as->getColumn(),stmp,10))); + } + ast = pModificationEQorASorARG; + +#line 4530 "modelica_tree_parser.cpp" + modification_AST = RefMyAST(currentAST.root); + returnAST = modification_AST; + _retTree = _t; + return ast; +} + +void * modelica_tree_parser::argument_list(RefMyAST _t) { +#line 1051 "walker.g" + void *stack; +#line 4540 "modelica_tree_parser.cpp" + RefMyAST argument_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST argument_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1051 "walker.g" + + l_stack *el_stack = new l_stack; + DOMElement* e; + +#line 4550 "modelica_tree_parser.cpp" + + RefMyAST __t146 = _t; + RefMyAST tmp29_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp29_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp29_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp29_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp29_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST146 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARGUMENT_LIST); + _t = _t->getFirstChild(); + e=argument(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1058 "walker.g" + el_stack->push_back(e); +#line 4568 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELEMENT_MODIFICATION || _t->getType() == ELEMENT_REDECLARATION)) { + e=argument(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1059 "walker.g" + el_stack->push_back(e); +#line 4579 "modelica_tree_parser.cpp" + } + else { + goto _loop148; + } + + } + _loop148:; + } // ( ... )* + currentAST = __currentAST146; + _t = __t146; + _t = _t->getNextSibling(); +#line 1061 "walker.g" + + if (el_stack->size()) stack = (void*)el_stack; + else (stack = 0); + +#line 4596 "modelica_tree_parser.cpp" + argument_list_AST = RefMyAST(currentAST.root); + returnAST = argument_list_AST; + _retTree = _t; + return stack; +} + +DOMElement* modelica_tree_parser::argument(RefMyAST _t) { +#line 1067 "walker.g" + DOMElement* ast; +#line 4606 "modelica_tree_parser.cpp" + RefMyAST argument_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST argument_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST em = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST em_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST er = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST er_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ELEMENT_MODIFICATION: + { + RefMyAST __t150 = _t; + em = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST em_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + em_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(em)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(em_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST150 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELEMENT_MODIFICATION); + _t = _t->getFirstChild(); + ast=element_modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST150; + _t = __t150; + _t = _t->getNextSibling(); +#line 1070 "walker.g" + + if (em) + { + ast->setAttribute(X("sline"), X(itoa(em->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(em->getColumn(),stmp,10))); + } + +#line 4645 "modelica_tree_parser.cpp" + argument_AST = RefMyAST(currentAST.root); + break; + } + case ELEMENT_REDECLARATION: + { + RefMyAST __t151 = _t; + er = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST er_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + er_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(er)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(er_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST151 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELEMENT_REDECLARATION); + _t = _t->getFirstChild(); + ast=element_redeclaration(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST151; + _t = __t151; + _t = _t->getNextSibling(); +#line 1078 "walker.g" + + if (er) + { + ast->setAttribute(X("sline"), X(itoa(er->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(er->getColumn(),stmp,10))); + } + +#line 4675 "modelica_tree_parser.cpp" + argument_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = argument_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::element_modification(RefMyAST _t) { +#line 1087 "walker.g" + DOMElement* ast; +#line 4692 "modelica_tree_parser.cpp" + RefMyAST element_modification_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_modification_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1087 "walker.g" + + DOMElement* cref; + DOMElement* mod=0; + DOMElement* cmt=0; + +#line 4707 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EACH: + { + e = _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EACH); + _t = _t->getNextSibling(); + break; + } + case FINAL: + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case DOT: + case IDENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUALS: + case ASSIGN: + case CLASS_MODIFICATION: + { + mod=modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case STRING_COMMENT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + cmt=string_comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1099 "walker.g" + + DOMElement *pModification = pModelicaXMLDoc->createElement(X("element_modification")); + if (f) pModification->setAttribute(X("final"), X("true")); + if (e) pModification->setAttribute(X("each"), X("true")); + pModification->appendChild(cref); + if (mod) pModification->appendChild(mod); + if (cmt) pModification->appendChild(cmt); + ast = pModification; + +#line 4800 "modelica_tree_parser.cpp" + element_modification_AST = RefMyAST(currentAST.root); + returnAST = element_modification_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::element_redeclaration(RefMyAST _t) { +#line 1110 "walker.g" + DOMElement* ast; +#line 4810 "modelica_tree_parser.cpp" + RefMyAST element_redeclaration_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST element_redeclaration_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST re = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST re_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1110 "walker.g" + + DOMElement* class_def = 0; + DOMElement* e_spec = 0; + DOMElement* constr = 0; + DOMElement* final = 0; + DOMElement* each = 0; + class_def = pModelicaXMLDoc->createElement(X("definition")); + +#line 4832 "modelica_tree_parser.cpp" + + { + RefMyAST __t158 = _t; + r = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST r_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + r_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(r)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST158 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REDECLARE); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EACH: + { + e = _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EACH); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FINAL: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FINAL: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FINAL); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case REPLACEABLE: + case DOT: + case IDENT: + case CLASS_DEFINITION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + case CLASS_DEFINITION: + { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_DEFINITION: + { + class_def=class_definition(_t,false, class_def); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1123 "walker.g" + + DOMElement *pElementRedeclaration = pModelicaXMLDoc->createElement(X("element_redeclaration")); + if (class_def && class_def->hasChildNodes()) + pElementRedeclaration->appendChild(class_def); + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (each) pElementRedeclaration->setAttribute(X("each"), X("true")); + ast = pElementRedeclaration; + +#line 4944 "modelica_tree_parser.cpp" + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { +#line 1131 "walker.g" + DOMElement *pElementRedeclaration = pModelicaXMLDoc->createElement(X("element_redeclaration")); +#line 4958 "modelica_tree_parser.cpp" + pElementRedeclaration=component_clause1(_t,pElementRedeclaration); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1133 "walker.g" + + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (each) pElementRedeclaration->setAttribute(X("each"), X("true")); + ast = pElementRedeclaration; + +#line 4968 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + break; + } + case REPLACEABLE: + { + { + re = _t; + RefMyAST re_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + re_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(re)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(re_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REPLACEABLE); + _t = _t->getNextSibling(); +#line 1141 "walker.g" + DOMElement *pElementRedeclaration = pModelicaXMLDoc->createElement(X("element_redeclaration")); +#line 4990 "modelica_tree_parser.cpp" + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CLASS_DEFINITION: + { + class_def=class_definition(_t,false, class_def); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case CONSTANT: + case DISCRETE: + case FLOW: + case INPUT: + case OUTPUT: + case PARAMETER: + case DOT: + case IDENT: + { + pElementRedeclaration=component_clause1(_t,pElementRedeclaration); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXTENDS: + { + constr=constraining_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 1146 "walker.g" + + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (re) pElementRedeclaration->setAttribute(X("replaceable"), X("true")); + if (class_def && class_def->hasChildNodes()) + { + pElementRedeclaration->appendChild(class_def); + if (constr) pElementRedeclaration->appendChild(constr); + } + else + { + if (constr) pElementRedeclaration->appendChild(constr); + } + ast = pElementRedeclaration; + +#line 5059 "modelica_tree_parser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST158; + _t = __t158; + _t = _t->getNextSibling(); + } + element_redeclaration_AST = RefMyAST(currentAST.root); + returnAST = element_redeclaration_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::component_clause1(RefMyAST _t, + DOMElement *parent +) { +#line 1167 "walker.g" + DOMElement* ast; +#line 5084 "modelica_tree_parser.cpp" + RefMyAST component_clause1_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_clause1_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1167 "walker.g" + + type_prefix_t pfx; + DOMElement* attr = pModelicaXMLDoc->createElement(X("tmp")); + void* path = 0; + DOMElement* arr = 0; + DOMElement* comp_decl = 0; + DOMElement* comp_list = 0; + +#line 5098 "modelica_tree_parser.cpp" + + type_prefix(_t,attr); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + path=type_specifier(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1178 "walker.g" + if (path) attr->setAttribute(X("type"), X(((mstring*)path)->c_str())); +#line 5108 "modelica_tree_parser.cpp" + parent=component_declaration(_t,parent, attr, null); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1180 "walker.g" + + ast = parent; + +#line 5116 "modelica_tree_parser.cpp" + component_clause1_AST = RefMyAST(currentAST.root); + returnAST = component_clause1_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::equation(RefMyAST _t, + DOMElement* definition +) { +#line 1242 "walker.g" + DOMElement* ast; +#line 5128 "modelica_tree_parser.cpp" + RefMyAST equation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST es = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST es_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1242 "walker.g" + + DOMElement* cmt = 0; + +#line 5139 "modelica_tree_parser.cpp" + + RefMyAST __t185 = _t; + es = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST es_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + es_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(es)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(es_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST185 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUATION_STATEMENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EQUALS: + { + ast=equality_equation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IF: + { + ast=conditional_equation_e(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case FOR: + { + ast=for_clause_e(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case WHEN: + { + ast=when_clause_e(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case CONNECT: + { + ast=connect_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IDENT: + { + ast=equation_funcall(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 1256 "walker.g" + + DOMElement* pEquation = pModelicaXMLDoc->createElement(X("equation")); + pEquation->appendChild(ast); + if (cmt) pEquation->appendChild(cmt); + if (es) + { + pEquation->setAttribute(X("sline"), X(itoa(es->getLine(),stmp,10))); + pEquation->setAttribute(X("scolumn"), X(itoa(es->getColumn(),stmp,10))); + } + definition->appendChild(pEquation); + ast = definition; + +#line 5237 "modelica_tree_parser.cpp" + currentAST = __currentAST185; + _t = __t185; + _t = _t->getNextSibling(); + equation_AST = RefMyAST(currentAST.root); + returnAST = equation_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::algorithm(RefMyAST _t, + DOMElement *definition +) { +#line 1287 "walker.g" + DOMElement* ast; +#line 5252 "modelica_tree_parser.cpp" + RefMyAST algorithm_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST as = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST as_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST az = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST az_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1287 "walker.g" + + DOMElement* cref; + DOMElement* expr; + DOMElement* tuple; + DOMElement* args; + DOMElement* cmt=0; + +#line 5269 "modelica_tree_parser.cpp" + + RefMyAST __t190 = _t; + as = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST as_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + as_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(as)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(as_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST190 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALGORITHM_STATEMENT); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ASSIGN: + { + RefMyAST __t192 = _t; + az = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST az_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + az_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(az)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(az_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST192 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ASSIGN); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT: + case IDENT: + { + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + expr=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1299 "walker.g" + + DOMElement* pAlgAssign = pModelicaXMLDoc->createElement(X("alg_assign")); + if (az) + { + pAlgAssign->setAttribute(X("sline"), X(itoa(az->getLine(),stmp,10))); + pAlgAssign->setAttribute(X("scolumn"), X(itoa(az->getColumn(),stmp,10))); + } + pAlgAssign->appendChild(cref); + pAlgAssign->appendChild(expr); + ast = pAlgAssign; + +#line 5322 "modelica_tree_parser.cpp" + break; + } + case EXPRESSION_LIST: + { + { + tuple=tuple_expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + args=function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } +#line 1311 "walker.g" + + DOMElement* pAlgAssign = pModelicaXMLDoc->createElement(X("alg_assign")); + DOMElement* pCall = pModelicaXMLDoc->createElement(X("call")); + + if (az) + { + pAlgAssign->setAttribute(X("sline"), X(itoa(az->getLine(),stmp,10))); + pAlgAssign->setAttribute(X("scolumn"), X(itoa(az->getColumn(),stmp,10))); + } + + pAlgAssign->appendChild(tuple); + + pCall->appendChild(cref); + pCall->appendChild(args); + + pAlgAssign->appendChild(pCall); + + ast = pAlgAssign; + /* + + + */ + +#line 5364 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST192; + _t = __t192; + _t = _t->getNextSibling(); + break; + } + case DOT: + case IDENT: + { + ast=algorithm_function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case IF: + { + ast=conditional_equation_a(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case FOR: + { + ast=for_clause_a(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case WHILE: + { + ast=while_clause(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case WHEN: + { + ast=when_clause_a(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMMENT: + { + cmt=comment(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 1345 "walker.g" + + DOMElement* pAlgorithm = pModelicaXMLDoc->createElement(X("algorithm")); + if (as) + { + pAlgorithm->setAttribute(X("sline"), X(itoa(as->getLine(),stmp,10))); + pAlgorithm->setAttribute(X("scolumn"), X(itoa(as->getColumn(),stmp,10))); + } + pAlgorithm->appendChild(ast); + if (cmt) pAlgorithm->appendChild(cmt); + definition->appendChild(pAlgorithm); + ast = definition; + /* + + + */ + +#line 5461 "modelica_tree_parser.cpp" + currentAST = __currentAST190; + _t = __t190; + _t = _t->getNextSibling(); + algorithm_AST = RefMyAST(currentAST.root); + returnAST = algorithm_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::equality_equation(RefMyAST _t) { +#line 1388 "walker.g" + DOMElement* ast; +#line 5474 "modelica_tree_parser.cpp" + RefMyAST equality_equation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equality_equation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1388 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 5486 "modelica_tree_parser.cpp" + + RefMyAST __t198 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST198 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + e1=simple_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST198; + _t = __t198; + _t = _t->getNextSibling(); +#line 1395 "walker.g" + + DOMElement* pEquEqual = pModelicaXMLDoc->createElement(X("equ_equal")); + pEquEqual->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); + pEquEqual->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); + pEquEqual->appendChild(e1); + pEquEqual->appendChild(e2); + ast = pEquEqual; + /* + + + */ + +#line 5522 "modelica_tree_parser.cpp" + equality_equation_AST = RefMyAST(currentAST.root); + returnAST = equality_equation_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::conditional_equation_e(RefMyAST _t) { +#line 1411 "walker.g" + DOMElement* ast; +#line 5532 "modelica_tree_parser.cpp" + RefMyAST conditional_equation_e_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_equation_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1411 "walker.g" + + DOMElement* e1; + DOMElement* then_b; + DOMElement* else_b = 0; + DOMElement* else_if_b; + l_stack el_stack; + DOMElement* e; + + DOMElement* pEquIf = pModelicaXMLDoc->createElement(X("equ_if")); + DOMElement* pEquThen = pModelicaXMLDoc->createElement(X("equ_then")); + DOMElement* pEquElse = pModelicaXMLDoc->createElement(X("equ_else")); + + bool fbElse = false; + +#line 5554 "modelica_tree_parser.cpp" + + RefMyAST __t200 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST200 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF); + _t = _t->getFirstChild(); + e1=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1428 "walker.g" + pEquIf->appendChild(e1); +#line 5571 "modelica_tree_parser.cpp" + pEquThen=equation_list(_t,pEquThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1429 "walker.g" + pEquIf->appendChild(pEquThen); +#line 5577 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEIF)) { + e=equation_elseif(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1430 "walker.g" + el_stack.push_back(e); +#line 5588 "modelica_tree_parser.cpp" + } + else { + goto _loop202; + } + + } + _loop202:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ELSE: + { + RefMyAST tmp30_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp30_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp30_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp30_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp30_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSE); + _t = _t->getNextSibling(); + pEquElse=equation_list(_t,pEquElse); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1431 "walker.g" + fbElse = true; +#line 5615 "modelica_tree_parser.cpp" + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST200; + _t = __t200; + _t = _t->getNextSibling(); +#line 1433 "walker.g" + + pEquIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (el_stack.size()>0) pEquIf = (DOMElement*)appendKids(el_stack, pEquIf); // ?? is this ok? + if (fbElse) pEquIf->appendChild(pEquElse); + ast = pEquIf; + +#line 5640 "modelica_tree_parser.cpp" + conditional_equation_e_AST = RefMyAST(currentAST.root); + returnAST = conditional_equation_e_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::for_clause_e(RefMyAST _t) { +#line 1484 "walker.g" + DOMElement* ast; +#line 5650 "modelica_tree_parser.cpp" + RefMyAST for_clause_e_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_clause_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1484 "walker.g" + + DOMElement* f; + DOMElement* eq; + DOMElement* pEquFor = pModelicaXMLDoc->createElement(X("equ_for")); + +#line 5663 "modelica_tree_parser.cpp" + + RefMyAST __t210 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST210 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR); + _t = _t->getFirstChild(); + f=for_indices(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1491 "walker.g" + pEquFor->appendChild(f); +#line 5680 "modelica_tree_parser.cpp" + pEquFor=equation_list(_t,pEquFor); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST210; + _t = __t210; + _t = _t->getNextSibling(); +#line 1493 "walker.g" + + pEquFor->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquFor->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pEquFor; + +#line 5694 "modelica_tree_parser.cpp" + for_clause_e_AST = RefMyAST(currentAST.root); + returnAST = for_clause_e_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::when_clause_e(RefMyAST _t) { +#line 1601 "walker.g" + DOMElement* ast; +#line 5704 "modelica_tree_parser.cpp" + RefMyAST when_clause_e_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST when_clause_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST wh = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST wh_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1601 "walker.g" + + l_stack el_stack; + DOMElement* e; + DOMElement* body; + DOMElement* el = 0; + DOMElement* pEquWhen = pModelicaXMLDoc->createElement(X("equ_when")); + DOMElement* pEquThen = pModelicaXMLDoc->createElement(X("equ_then")); + +#line 5720 "modelica_tree_parser.cpp" + + RefMyAST __t224 = _t; + wh = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST wh_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + wh_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(wh)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(wh_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST224 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHEN); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1612 "walker.g" + pEquWhen->appendChild(e); +#line 5737 "modelica_tree_parser.cpp" + pEquThen=equation_list(_t,pEquThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1613 "walker.g" + pEquWhen->appendChild(pEquThen); +#line 5743 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEWHEN)) { + el=else_when_e(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1614 "walker.g" + el_stack.push_back(el); +#line 5754 "modelica_tree_parser.cpp" + } + else { + goto _loop226; + } + + } + _loop226:; + } // ( ... )* + currentAST = __currentAST224; + _t = __t224; + _t = _t->getNextSibling(); +#line 1616 "walker.g" + + pEquWhen->setAttribute(X("sline"), X(itoa(wh->getLine(),stmp,10))); + pEquWhen->setAttribute(X("scolumn"), X(itoa(wh->getColumn(),stmp,10))); + + if (el_stack.size()>0) pEquWhen = (DOMElement*)appendKids(el_stack, pEquWhen); // ??is this ok? + ast = pEquWhen; + +#line 5774 "modelica_tree_parser.cpp" + when_clause_e_AST = RefMyAST(currentAST.root); + returnAST = when_clause_e_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::connect_clause(RefMyAST _t) { +#line 1753 "walker.g" + DOMElement* ast; +#line 5784 "modelica_tree_parser.cpp" + RefMyAST connect_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST connect_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1753 "walker.g" + + DOMElement* r1; + DOMElement* r2; + +#line 5796 "modelica_tree_parser.cpp" + + RefMyAST __t246 = _t; + c = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST c_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + c_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(c)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST246 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONNECT); + _t = _t->getFirstChild(); + r1=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + r2=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST246; + _t = __t246; + _t = _t->getNextSibling(); +#line 1763 "walker.g" + + DOMElement* pEquConnect = pModelicaXMLDoc->createElement(X("equ_connect")); + + pEquConnect->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pEquConnect->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + + pEquConnect->appendChild(r1); + pEquConnect->appendChild(r2); + ast = pEquConnect; + +#line 5828 "modelica_tree_parser.cpp" + connect_clause_AST = RefMyAST(currentAST.root); + returnAST = connect_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::equation_funcall(RefMyAST _t) { +#line 1271 "walker.g" + DOMElement* ast; +#line 5838 "modelica_tree_parser.cpp" + RefMyAST equation_funcall_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_funcall_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1271 "walker.g" + + DOMElement* fcall = 0; + +#line 5849 "modelica_tree_parser.cpp" + + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + fcall=function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1277 "walker.g" + + DOMElement* pEquCall = pModelicaXMLDoc->createElement(X("equ_call")); + pEquCall->setAttribute(X("ident"), str2xml(i)); + pEquCall->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquCall->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + pEquCall->appendChild(fcall); + ast = pEquCall; + +#line 5869 "modelica_tree_parser.cpp" + equation_funcall_AST = RefMyAST(currentAST.root); + returnAST = equation_funcall_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::function_call(RefMyAST _t) { +#line 2372 "walker.g" + DOMElement* ast; +#line 5879 "modelica_tree_parser.cpp" + RefMyAST function_call_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fa = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fa_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefMyAST __t333 = _t; + fa = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST fa_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + fa_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(fa)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(fa_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST333 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_ARGUMENTS); + _t = _t->getFirstChild(); + ast=function_arguments(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2375 "walker.g" + + ast->setAttribute(X("sline"), X(itoa(fa->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(fa->getColumn(),stmp,10))); + +#line 5905 "modelica_tree_parser.cpp" + currentAST = __currentAST333; + _t = __t333; + _t = _t->getNextSibling(); + function_call_AST = RefMyAST(currentAST.root); + returnAST = function_call_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::tuple_expression_list(RefMyAST _t) { +#line 2479 "walker.g" + DOMElement* ast; +#line 5918 "modelica_tree_parser.cpp" + RefMyAST tuple_expression_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST tuple_expression_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2479 "walker.g" + + l_stack el_stack; + DOMElement* e; + //DOMElement* pComma = pModelicaXMLDoc->createElement(X("comma")); + +#line 5931 "modelica_tree_parser.cpp" + + { + RefMyAST __t358 = _t; + el = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST el_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + el_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(el)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(el_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST358 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXPRESSION_LIST); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2487 "walker.g" + el_stack.push_back(e); +#line 5949 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_2.member(_t->getType()))) { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2488 "walker.g" + el_stack.push_back(pModelicaXMLDoc->createElement(X("comma"))); el_stack.push_back(e); +#line 5960 "modelica_tree_parser.cpp" + } + else { + goto _loop360; + } + + } + _loop360:; + } // ( ... )* + currentAST = __currentAST358; + _t = __t358; + _t = _t->getNextSibling(); + } +#line 2491 "walker.g" + + if (el_stack.size() == 1) + { + ast = el_stack.back(); + } + else + { + DOMElement *pTuple = pModelicaXMLDoc->createElement(X("output_expression_list")); + pTuple = (DOMElement*)appendKids(el_stack, pTuple); + pTuple->setAttribute(X("sline"), X(itoa(el->getLine(),stmp,10))); + pTuple->setAttribute(X("scolumn"), X(itoa(el->getColumn(),stmp,10))); + ast = pTuple; + } + +#line 5988 "modelica_tree_parser.cpp" + tuple_expression_list_AST = RefMyAST(currentAST.root); + returnAST = tuple_expression_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::algorithm_function_call(RefMyAST _t) { +#line 1367 "walker.g" + DOMElement* ast; +#line 5998 "modelica_tree_parser.cpp" + RefMyAST algorithm_function_call_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1367 "walker.g" + + DOMElement* cref; + DOMElement* args; + +#line 6008 "modelica_tree_parser.cpp" + + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + args=function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1374 "walker.g" + + DOMElement* pAlgCall = pModelicaXMLDoc->createElement(X("alg_call")); + pAlgCall->appendChild(cref); + pAlgCall->appendChild(args); + ast = pAlgCall; + /* + + + */ + +#line 6029 "modelica_tree_parser.cpp" + algorithm_function_call_AST = RefMyAST(currentAST.root); + returnAST = algorithm_function_call_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::conditional_equation_a(RefMyAST _t) { +#line 1443 "walker.g" + DOMElement* ast; +#line 6039 "modelica_tree_parser.cpp" + RefMyAST conditional_equation_a_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST conditional_equation_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1443 "walker.g" + + DOMElement* e1; + DOMElement* then_b; + DOMElement* else_b = 0; + DOMElement* else_if_b; + l_stack el_stack; + DOMElement* e; + DOMElement* pAlgIf = pModelicaXMLDoc->createElement(X("alg_if")); + DOMElement* pAlgThen = pModelicaXMLDoc->createElement(X("alg_then")); + DOMElement* pAlgElse = pModelicaXMLDoc->createElement(X("alg_else")); + bool fbElse = false; + +#line 6059 "modelica_tree_parser.cpp" + + RefMyAST __t205 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST205 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF); + _t = _t->getFirstChild(); + e1=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1458 "walker.g" + pAlgIf->appendChild(e1); +#line 6076 "modelica_tree_parser.cpp" + pAlgThen=algorithm_list(_t,pAlgThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1460 "walker.g" + + if (pAlgThen) + pAlgIf->appendChild(pAlgThen); + +#line 6085 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEIF)) { + e=algorithm_elseif(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1464 "walker.g" + el_stack.push_back(e); +#line 6096 "modelica_tree_parser.cpp" + } + else { + goto _loop207; + } + + } + _loop207:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ELSE: + { + RefMyAST tmp31_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp31_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp31_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp31_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp31_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSE); + _t = _t->getNextSibling(); + pAlgElse=algorithm_list(_t,pAlgElse); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1465 "walker.g" + fbElse = true; +#line 6123 "modelica_tree_parser.cpp" + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST205; + _t = __t205; + _t = _t->getNextSibling(); +#line 1467 "walker.g" + + pAlgIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pAlgIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + if (el_stack.size()>0) pAlgIf = (DOMElement*)appendKids(el_stack, pAlgIf); + if (fbElse) pAlgIf->appendChild(pAlgElse); + ast = pAlgIf; + +#line 6147 "modelica_tree_parser.cpp" + conditional_equation_a_AST = RefMyAST(currentAST.root); + returnAST = conditional_equation_a_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::for_clause_a(RefMyAST _t) { +#line 1502 "walker.g" + DOMElement* ast; +#line 6157 "modelica_tree_parser.cpp" + RefMyAST for_clause_a_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1502 "walker.g" + + DOMElement* f; + DOMElement* eq; + DOMElement* pAlgFor = pModelicaXMLDoc->createElement(X("alg_for")); + +#line 6170 "modelica_tree_parser.cpp" + + RefMyAST __t212 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST212 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR); + _t = _t->getFirstChild(); + f=for_indices(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1510 "walker.g" + + f->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + f->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + pAlgFor->appendChild(f); + +#line 6191 "modelica_tree_parser.cpp" + pAlgFor=algorithm_list(_t,pAlgFor); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST212; + _t = __t212; + _t = _t->getNextSibling(); +#line 1516 "walker.g" + + pAlgFor->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pAlgFor->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pAlgFor; + +#line 6205 "modelica_tree_parser.cpp" + for_clause_a_AST = RefMyAST(currentAST.root); + returnAST = for_clause_a_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::while_clause(RefMyAST _t) { +#line 1571 "walker.g" + DOMElement* ast; +#line 6215 "modelica_tree_parser.cpp" + RefMyAST while_clause_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST while_clause_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST w = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST w_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1571 "walker.g" + + DOMElement* e; + DOMElement* body; + DOMElement* pAlgWhile = pModelicaXMLDoc->createElement(X("alg_while")); + +#line 6228 "modelica_tree_parser.cpp" + + RefMyAST __t222 = _t; + w = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST w_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + w_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(w)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST222 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHILE); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1580 "walker.g" + + pAlgWhile->appendChild(e); + +#line 6247 "modelica_tree_parser.cpp" + pAlgWhile=algorithm_list(_t,pAlgWhile); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST222; + _t = __t222; + _t = _t->getNextSibling(); +#line 1584 "walker.g" + + pAlgWhile->setAttribute(X("sline"), X(itoa(w->getLine(),stmp,10))); + pAlgWhile->setAttribute(X("scolumn"), X(itoa(w->getColumn(),stmp,10))); + + ast = pAlgWhile; + +#line 6261 "modelica_tree_parser.cpp" + while_clause_AST = RefMyAST(currentAST.root); + returnAST = while_clause_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::when_clause_a(RefMyAST _t) { +#line 1644 "walker.g" + DOMElement* ast; +#line 6271 "modelica_tree_parser.cpp" + RefMyAST when_clause_a_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST when_clause_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST wh = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST wh_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1644 "walker.g" + + l_stack el_stack; + DOMElement* e; + DOMElement* body; + DOMElement* el = 0; + DOMElement* pAlgWhen = pModelicaXMLDoc->createElement(X("alg_when")); + DOMElement* pAlgThen = pModelicaXMLDoc->createElement(X("alg_then")); + +#line 6287 "modelica_tree_parser.cpp" + + RefMyAST __t230 = _t; + wh = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST wh_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + wh_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(wh)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(wh_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST230 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHEN); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1655 "walker.g" + pAlgWhen->appendChild(e); +#line 6304 "modelica_tree_parser.cpp" + pAlgThen=algorithm_list(_t,pAlgThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1656 "walker.g" + pAlgWhen->appendChild(pAlgThen); +#line 6310 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEWHEN)) { + el=else_when_a(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1657 "walker.g" + el_stack.push_back(el); +#line 6321 "modelica_tree_parser.cpp" + } + else { + goto _loop232; + } + + } + _loop232:; + } // ( ... )* + currentAST = __currentAST230; + _t = __t230; + _t = _t->getNextSibling(); +#line 1659 "walker.g" + + pAlgWhen->setAttribute(X("sline"), X(itoa(wh->getLine(),stmp,10))); + pAlgWhen->setAttribute(X("scolumn"), X(itoa(wh->getColumn(),stmp,10))); + + if (el_stack.size() > 0) pAlgWhen = (DOMElement*)appendKids(el_stack, pAlgWhen); + ast = pAlgWhen; + +#line 6341 "modelica_tree_parser.cpp" + when_clause_a_AST = RefMyAST(currentAST.root); + returnAST = when_clause_a_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::simple_expression(RefMyAST _t) { +#line 1837 "walker.g" + DOMElement* ast; +#line 6351 "modelica_tree_parser.cpp" + RefMyAST simple_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST simple_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r3 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r3_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST r2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1837 "walker.g" + + DOMElement* e1; + DOMElement* e2; + DOMElement* e3; + +#line 6366 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case RANGE3: + { + RefMyAST __t257 = _t; + r3 = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST r3_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + r3_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(r3)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r3_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST257 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE3); + _t = _t->getFirstChild(); + e1=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e3=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST257; + _t = __t257; + _t = _t->getNextSibling(); +#line 1847 "walker.g" + + DOMElement* pRange = pModelicaXMLDoc->createElement(X("range")); + + pRange->setAttribute(X("sline"), X(itoa(r3->getLine(),stmp,10))); + pRange->setAttribute(X("scolumn"), X(itoa(r3->getColumn(),stmp,10))); + + pRange->appendChild(e1); + pRange->appendChild(e2); + pRange->appendChild(e3); + ast = pRange; + /* + + + */ + +#line 6414 "modelica_tree_parser.cpp" + break; + } + case RANGE2: + { + RefMyAST __t258 = _t; + r2 = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST r2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + r2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(r2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r2_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST258 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE2); + _t = _t->getFirstChild(); + e1=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e3=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST258; + _t = __t258; + _t = _t->getNextSibling(); +#line 1865 "walker.g" + + DOMElement* pRange = pModelicaXMLDoc->createElement(X("range")); + + pRange->setAttribute(X("sline"), X(itoa(r2->getLine(),stmp,10))); + pRange->setAttribute(X("scolumn"), X(itoa(r2->getColumn(),stmp,10))); + + pRange->appendChild(e1); + pRange->appendChild(e3); + ast = pRange; + +#line 6449 "modelica_tree_parser.cpp" + break; + } + case AND: + case DER: + case END: + case FALSE: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + simple_expression_AST = RefMyAST(currentAST.root); + returnAST = simple_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::equation_list(RefMyAST _t, + DOMElement* pEquationList +) { +#line 1729 "walker.g" + DOMElement* ast; +#line 6505 "modelica_tree_parser.cpp" + RefMyAST equation_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1729 "walker.g" + + DOMElement* e; + l_stack el_stack; + +#line 6515 "modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == EQUATION_STATEMENT)) { + pEquationList=equation(_t,pEquationList); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else { + goto _loop241; + } + + } + _loop241:; + } // ( ... )* +#line 1736 "walker.g" + + ast = pEquationList; + +#line 6537 "modelica_tree_parser.cpp" + equation_list_AST = RefMyAST(currentAST.root); + returnAST = equation_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::equation_elseif(RefMyAST _t) { +#line 1687 "walker.g" + DOMElement* ast; +#line 6547 "modelica_tree_parser.cpp" + RefMyAST equation_elseif_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST equation_elseif_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1687 "walker.g" + + DOMElement* e; + DOMElement* eq; + DOMElement* pEquElseIf = pModelicaXMLDoc->createElement(X("equ_elseif")); + DOMElement* pEquThen = pModelicaXMLDoc->createElement(X("equ_then")); + +#line 6561 "modelica_tree_parser.cpp" + + RefMyAST __t236 = _t; + els = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST els_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + els_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(els)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(els_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST236 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEIF); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1696 "walker.g" + pEquElseIf->appendChild(e); +#line 6578 "modelica_tree_parser.cpp" + pEquThen=equation_list(_t,pEquThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST236; + _t = __t236; + _t = _t->getNextSibling(); +#line 1699 "walker.g" + + pEquElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pEquElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pEquElseIf->appendChild(pEquThen); + ast = pEquElseIf; + +#line 6593 "modelica_tree_parser.cpp" + equation_elseif_AST = RefMyAST(currentAST.root); + returnAST = equation_elseif_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::algorithm_list(RefMyAST _t, + DOMElement* pAlgorithmList +) { +#line 1741 "walker.g" + DOMElement* ast; +#line 6605 "modelica_tree_parser.cpp" + RefMyAST algorithm_list_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_list_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1741 "walker.g" + + DOMElement* e; + l_stack el_stack; + +#line 6615 "modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ALGORITHM_STATEMENT)) { + pAlgorithmList=algorithm(_t,pAlgorithmList); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else { + goto _loop244; + } + + } + _loop244:; + } // ( ... )* +#line 1748 "walker.g" + + ast = pAlgorithmList; + +#line 6637 "modelica_tree_parser.cpp" + algorithm_list_AST = RefMyAST(currentAST.root); + returnAST = algorithm_list_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::algorithm_elseif(RefMyAST _t) { +#line 1708 "walker.g" + DOMElement* ast; +#line 6647 "modelica_tree_parser.cpp" + RefMyAST algorithm_elseif_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST algorithm_elseif_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1708 "walker.g" + + DOMElement* e; + DOMElement* body; + DOMElement* pAlgElseIf = pModelicaXMLDoc->createElement(X("alg_elseif")); + DOMElement* pAlgThen = pModelicaXMLDoc->createElement(X("alg_then")); + +#line 6661 "modelica_tree_parser.cpp" + + RefMyAST __t238 = _t; + els = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST els_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + els_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(els)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(els_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST238 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEIF); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1717 "walker.g" + pAlgElseIf->appendChild(e); +#line 6678 "modelica_tree_parser.cpp" + pAlgThen=algorithm_list(_t,pAlgThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST238; + _t = __t238; + _t = _t->getNextSibling(); +#line 1720 "walker.g" + + pAlgElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pAlgElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pAlgElseIf->appendChild(pAlgThen); + ast = pAlgElseIf; + +#line 6693 "modelica_tree_parser.cpp" + algorithm_elseif_AST = RefMyAST(currentAST.root); + returnAST = algorithm_elseif_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::for_indices(RefMyAST _t) { +#line 1545 "walker.g" + DOMElement* ast; +#line 6703 "modelica_tree_parser.cpp" + RefMyAST for_indices_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_indices_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1545 "walker.g" + + DOMElement* f; + DOMElement* e; + l_stack el_stack; + +#line 6716 "modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IN)) { + RefMyAST __t218 = _t; + RefMyAST tmp32_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp32_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp32_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp32_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp32_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST218 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IN); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case DER: + case END: + case FALSE: + case IF: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case CODE_EXPRESSION: + case CODE_MODIFICATION: + case CODE_ELEMENT: + case CODE_EQUATION: + case CODE_INITIALEQUATION: + case CODE_ALGORITHM: + case CODE_INITIALALGORITHM: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case RANGE2: + case RANGE3: + case UNARY_MINUS: + case UNARY_PLUS: + { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST218; + _t = __t218; + _t = _t->getNextSibling(); +#line 1553 "walker.g" + + DOMElement* pForIndex = pModelicaXMLDoc->createElement(X("for_index")); + pForIndex->setAttribute(X("ident"), str2xml(i)); + + pForIndex->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pForIndex->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (e) pForIndex->appendChild(e); + el_stack.push_back(pForIndex); + +#line 6814 "modelica_tree_parser.cpp" + } + else { + goto _loop220; + } + + } + _loop220:; + } // ( ... )* +#line 1564 "walker.g" + + DOMElement* pForIndices = pModelicaXMLDoc->createElement(X("for_indices")); + pForIndices = (DOMElement*)appendKids(el_stack, pForIndices); + ast = pForIndices; + +#line 6829 "modelica_tree_parser.cpp" + for_indices_AST = RefMyAST(currentAST.root); + returnAST = for_indices_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::for_iterator(RefMyAST _t) { +#line 1525 "walker.g" + DOMElement* ast; +#line 6839 "modelica_tree_parser.cpp" + RefMyAST for_iterator_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST for_iterator_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1525 "walker.g" + + DOMElement* expr; + DOMElement* iter; + +#line 6853 "modelica_tree_parser.cpp" + + RefMyAST __t214 = _t; + f = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST214 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR); + _t = _t->getFirstChild(); + expr=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + RefMyAST __t215 = _t; + RefMyAST tmp33_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp33_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp33_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp33_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp33_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST215 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IN); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + iter=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST215; + _t = __t215; + _t = _t->getNextSibling(); + currentAST = __currentAST214; + _t = __t214; + _t = _t->getNextSibling(); +#line 1532 "walker.g" + + DOMElement* pForIter = pModelicaXMLDoc->createElement(X("for_iterator")); + pForIter->appendChild(expr); + DOMElement* pForIndex = pModelicaXMLDoc->createElement(X("for_index")); + pForIndex->setAttribute(X("ident"), str2xml(i)); + pForIndex->setAttribute(X("sline"), X(itoa(f->getLine(),stmp,10))); + pForIndex->setAttribute(X("scolumn"), X(itoa(f->getColumn(),stmp,10))); + if (iter) pForIndex->appendChild(iter); + pForIter->appendChild(pForIndex); + ast = pForIter; + +#line 6906 "modelica_tree_parser.cpp" + for_iterator_AST = RefMyAST(currentAST.root); + returnAST = for_iterator_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::else_when_e(RefMyAST _t) { +#line 1625 "walker.g" + DOMElement* ast; +#line 6916 "modelica_tree_parser.cpp" + RefMyAST else_when_e_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST else_when_e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1625 "walker.g" + + DOMElement* expr; + DOMElement* eqn; + DOMElement* pEquElseWhen = pModelicaXMLDoc->createElement(X("equ_elsewhen")); + DOMElement* pEquThen = pModelicaXMLDoc->createElement(X("equ_then")); + +#line 6930 "modelica_tree_parser.cpp" + + RefMyAST __t228 = _t; + e = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST228 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEWHEN); + _t = _t->getFirstChild(); + expr=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1633 "walker.g" + pEquElseWhen->appendChild(expr); +#line 6947 "modelica_tree_parser.cpp" + pEquThen=equation_list(_t,pEquThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST228; + _t = __t228; + _t = _t->getNextSibling(); +#line 1635 "walker.g" + + pEquElseWhen->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pEquElseWhen->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + pEquElseWhen->appendChild(pEquThen); + ast = pEquElseWhen; + +#line 6962 "modelica_tree_parser.cpp" + else_when_e_AST = RefMyAST(currentAST.root); + returnAST = else_when_e_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::else_when_a(RefMyAST _t) { +#line 1668 "walker.g" + DOMElement* ast; +#line 6972 "modelica_tree_parser.cpp" + RefMyAST else_when_a_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST else_when_a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST e_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1668 "walker.g" + + DOMElement* expr; + DOMElement* alg; + DOMElement* pAlgElseWhen = pModelicaXMLDoc->createElement(X("alg_elsewhen")); + DOMElement* pAlgThen = pModelicaXMLDoc->createElement(X("alg_then")); + +#line 6986 "modelica_tree_parser.cpp" + + RefMyAST __t234 = _t; + e = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST e_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + e_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(e)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST234 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEWHEN); + _t = _t->getFirstChild(); + expr=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1676 "walker.g" + pAlgElseWhen->appendChild(expr); +#line 7003 "modelica_tree_parser.cpp" + pAlgThen=algorithm_list(_t,pAlgThen); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST234; + _t = __t234; + _t = _t->getNextSibling(); +#line 1678 "walker.g" + + pAlgElseWhen->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pAlgElseWhen->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + pAlgElseWhen->appendChild(pAlgThen); + ast = pAlgElseWhen; + +#line 7018 "modelica_tree_parser.cpp" + else_when_a_AST = RefMyAST(currentAST.root); + returnAST = else_when_a_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::if_expression(RefMyAST _t) { +#line 1784 "walker.g" + DOMElement* ast; +#line 7028 "modelica_tree_parser.cpp" + RefMyAST if_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST if_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1784 "walker.g" + + DOMElement* cond; + DOMElement* thenPart; + DOMElement* elsePart; + DOMElement* e; + DOMElement* elseifPart; + l_stack el_stack; + +#line 7044 "modelica_tree_parser.cpp" + + RefMyAST __t250 = _t; + i = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST250 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF); + _t = _t->getFirstChild(); + cond=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + thenPart=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == ELSEIF)) { + e=elseif_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1795 "walker.g" + el_stack.push_back(e); +#line 7072 "modelica_tree_parser.cpp" + } + else { + goto _loop252; + } + + } + _loop252:; + } // ( ... )* + elsePart=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1796 "walker.g" + + DOMElement* pIf = pModelicaXMLDoc->createElement(X("if")); + DOMElement* pThen = pModelicaXMLDoc->createElement(X("then")); + DOMElement* pElse = pModelicaXMLDoc->createElement(X("else")); + + pIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pIf->appendChild(cond); + pThen->appendChild(thenPart); + pIf->appendChild(pThen); + if (el_stack.size()>0) pIf = (DOMElement*)appendKids(el_stack, pIf); //??is this ok?? + pElse->appendChild(elsePart); + pIf->appendChild(pElse); + ast = pIf; + +#line 7101 "modelica_tree_parser.cpp" + currentAST = __currentAST250; + _t = __t250; + _t = _t->getNextSibling(); + if_expression_AST = RefMyAST(currentAST.root); + returnAST = if_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::code_expression(RefMyAST _t) { +#line 1880 "walker.g" + DOMElement* ast; +#line 7114 "modelica_tree_parser.cpp" + RefMyAST code_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST code_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1880 "walker.g" + + DOMElement*pCode = pModelicaXMLDoc->createElement(X("code")); + +#line 7123 "modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CODE_MODIFICATION: + { + RefMyAST __t260 = _t; + RefMyAST tmp34_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp34_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp34_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp34_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp34_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST260 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_MODIFICATION); + _t = _t->getFirstChild(); + { + ast=modification(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST260; + _t = __t260; + _t = _t->getNextSibling(); +#line 1887 "walker.g" + + // ?? what the hack is this? + DOMElement* pModification = pModelicaXMLDoc->createElement(X("modification")); + pModification->appendChild(ast); + ast = pModification; + /* + ast = Absyn__CODE(Absyn__C_5fMODIFICATION(ast)); + */ + +#line 7159 "modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_EXPRESSION: + { + RefMyAST __t262 = _t; + RefMyAST tmp35_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp35_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp35_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp35_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp35_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST262 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_EXPRESSION); + _t = _t->getFirstChild(); + { + ast=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST262; + _t = __t262; + _t = _t->getNextSibling(); +#line 1898 "walker.g" + + // ?? what the hack is this? + DOMElement* pExpression = pModelicaXMLDoc->createElement(X("expression")); + pExpression->appendChild(ast); + ast = pExpression; + /* ast = Absyn__CODE(Absyn__C_5fEXPRESSION(ast)); */ + +#line 7192 "modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_ELEMENT: + { + RefMyAST __t264 = _t; + RefMyAST tmp36_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp36_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp36_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp36_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp36_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST264 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_ELEMENT); + _t = _t->getFirstChild(); + { + ast=element(_t,0 /* none */, pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST264; + _t = __t264; + _t = _t->getNextSibling(); +#line 1907 "walker.g" + + // ?? what the hack is this? + DOMElement* pElement = pModelicaXMLDoc->createElement(X("element")); + pElement->appendChild(ast); + ast = pElement; + /* ast = Absyn__CODE(Absyn__C_5fELEMENT(ast)); */ + +#line 7225 "modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_EQUATION: + { + RefMyAST __t266 = _t; + RefMyAST tmp37_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp37_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp37_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp37_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp37_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST266 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_EQUATION); + _t = _t->getFirstChild(); + { + ast=equation_clause(_t,pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST266; + _t = __t266; + _t = _t->getNextSibling(); +#line 1916 "walker.g" + + // ?? what the hack is this? + DOMElement* pEquationSection = pModelicaXMLDoc->createElement(X("equation_section")); + pEquationSection->appendChild(ast); + ast = pEquationSection; + /* ast = Absyn__CODE(Absyn__C_5fEQUATIONSECTION(RML_FALSE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); */ + +#line 7259 "modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_INITIALEQUATION: + { + RefMyAST __t268 = _t; + RefMyAST tmp38_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp38_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp38_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp38_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp38_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST268 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_INITIALEQUATION); + _t = _t->getFirstChild(); + { + ast=equation_clause(_t,pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST268; + _t = __t268; + _t = _t->getNextSibling(); +#line 1926 "walker.g" + + // ?? what the hack is this? + DOMElement* pEquationSection = pModelicaXMLDoc->createElement(X("equation_section")); + ((DOMElement*)ast)->setAttribute(X("initial"), X("true")); + pEquationSection->appendChild(ast); + ast = pEquationSection; + /* + ast = Absyn__CODE(Absyn__C_5fEQUATIONSECTION(RML_TRUE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + +#line 7296 "modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_ALGORITHM: + { + RefMyAST __t270 = _t; + RefMyAST tmp39_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp39_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp39_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp39_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp39_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST270 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_ALGORITHM); + _t = _t->getFirstChild(); + { + ast=algorithm_clause(_t,pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST270; + _t = __t270; + _t = _t->getNextSibling(); +#line 1938 "walker.g" + + // ?? what the hack is this? + DOMElement* pAlgorithmSection = pModelicaXMLDoc->createElement(X("algorithm_section")); + pAlgorithmSection->appendChild(ast); + ast = pAlgorithmSection; + /* + ast = Absyn__CODE(Absyn__C_5fALGORITHMSECTION(RML_FALSE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + +#line 7332 "modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + case CODE_INITIALALGORITHM: + { + RefMyAST __t272 = _t; + RefMyAST tmp40_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp40_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp40_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp40_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp40_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST272 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CODE_INITIALALGORITHM); + _t = _t->getFirstChild(); + { + ast=algorithm_clause(_t,pCode); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST272; + _t = __t272; + _t = _t->getNextSibling(); +#line 1949 "walker.g" + + // ?? what the hack is this? + DOMElement* pAlgorithmSection = pModelicaXMLDoc->createElement(X("algorithm_section")); + ((DOMElement*)ast)->setAttribute(X("initial"), X("true")); + pAlgorithmSection->appendChild(ast); + ast = pAlgorithmSection; + /* + ast = Absyn__CODE(Absyn__C_5fALGORITHMSECTION(RML_TRUE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + +#line 7369 "modelica_tree_parser.cpp" + code_expression_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = code_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::elseif_expression(RefMyAST _t) { +#line 1815 "walker.g" + DOMElement* ast; +#line 7386 "modelica_tree_parser.cpp" + RefMyAST elseif_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST elseif_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST els_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1815 "walker.g" + + DOMElement* cond; + DOMElement* thenPart; + +#line 7398 "modelica_tree_parser.cpp" + + RefMyAST __t254 = _t; + els = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST els_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + els_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(els)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(els_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST254 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSEIF); + _t = _t->getFirstChild(); + cond=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + thenPart=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 1822 "walker.g" + + DOMElement* pElseIf = pModelicaXMLDoc->createElement(X("elseif")); + + pElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pElseIf->appendChild(cond); + DOMElement* pThen = pModelicaXMLDoc->createElement(X("then")); + pThen->appendChild(thenPart); + pElseIf->appendChild(pThen); + ast = pElseIf; + +#line 7429 "modelica_tree_parser.cpp" + currentAST = __currentAST254; + _t = __t254; + _t = _t->getNextSibling(); + elseif_expression_AST = RefMyAST(currentAST.root); + returnAST = elseif_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::logical_expression(RefMyAST _t) { +#line 1962 "walker.g" + DOMElement* ast; +#line 7442 "modelica_tree_parser.cpp" + RefMyAST logical_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST o_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1962 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 7454 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case DER: + case END: + case FALSE: + case NOT: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=logical_term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case OR: + { + RefMyAST __t276 = _t; + o = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST o_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + o_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(o)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(o_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST276 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OR); + _t = _t->getFirstChild(); + e1=logical_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=logical_term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST276; + _t = __t276; + _t = _t->getNextSibling(); +#line 1970 "walker.g" + + DOMElement* pOr = pModelicaXMLDoc->createElement(X("or")); + + pOr->setAttribute(X("sline"), X(itoa(o->getLine(),stmp,10))); + pOr->setAttribute(X("scolumn"), X(itoa(o->getColumn(),stmp,10))); + + pOr->appendChild(e1); + pOr->appendChild(e2); + ast = pOr; + +#line 7527 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + logical_expression_AST = RefMyAST(currentAST.root); + returnAST = logical_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::logical_term(RefMyAST _t) { +#line 1984 "walker.g" + DOMElement* ast; +#line 7545 "modelica_tree_parser.cpp" + RefMyAST logical_term_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_term_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST a = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST a_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1984 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 7557 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DER: + case END: + case FALSE: + case NOT: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=logical_factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case AND: + { + RefMyAST __t279 = _t; + a = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST a_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + a_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(a)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST279 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AND); + _t = _t->getFirstChild(); + e1=logical_term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=logical_factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST279; + _t = __t279; + _t = _t->getNextSibling(); +#line 1992 "walker.g" + + DOMElement* pAnd = pModelicaXMLDoc->createElement(X("and")); + + pAnd->setAttribute(X("sline"), X(itoa(a->getLine(),stmp,10))); + pAnd->setAttribute(X("scolumn"), X(itoa(a->getColumn(),stmp,10))); + + pAnd->appendChild(e1); + pAnd->appendChild(e2); + ast = pAnd; + +#line 7629 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + logical_term_AST = RefMyAST(currentAST.root); + returnAST = logical_term_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::logical_factor(RefMyAST _t) { +#line 2005 "walker.g" + DOMElement* ast; +#line 7647 "modelica_tree_parser.cpp" + RefMyAST logical_factor_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST logical_factor_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST n = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST n_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case NOT: + { + RefMyAST __t281 = _t; + n = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST n_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + n_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(n)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST281 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NOT); + _t = _t->getFirstChild(); + ast=relation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2008 "walker.g" + + DOMElement* pNot = pModelicaXMLDoc->createElement(X("not")); + + pNot->setAttribute(X("sline"), X(itoa(n->getLine(),stmp,10))); + pNot->setAttribute(X("scolumn"), X(itoa(n->getColumn(),stmp,10))); + + pNot->appendChild(ast); + ast = pNot; + +#line 7683 "modelica_tree_parser.cpp" + currentAST = __currentAST281; + _t = __t281; + _t = _t->getNextSibling(); + logical_factor_AST = RefMyAST(currentAST.root); + break; + } + case DER: + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=relation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + logical_factor_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = logical_factor_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::relation(RefMyAST _t) { +#line 2019 "walker.g" + DOMElement* ast; +#line 7737 "modelica_tree_parser.cpp" + RefMyAST relation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST relation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lt = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lt_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lte = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lte_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST gt = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST gt_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST gte = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST gte_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ne = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ne_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2019 "walker.g" + + DOMElement* e1; + DOMElement* op = 0; + DOMElement* e2 = 0; + +#line 7760 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DER: + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LESS: + { + RefMyAST __t285 = _t; + lt = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lt_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lt_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lt)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lt_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST285 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LESS); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST285; + _t = __t285; + _t = _t->getNextSibling(); +#line 2029 "walker.g" + op = pModelicaXMLDoc->createElement(X("lt")); /* Absyn__LESS; */ +#line 7827 "modelica_tree_parser.cpp" + break; + } + case LESSEQ: + { + RefMyAST __t286 = _t; + lte = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lte_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lte_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lte)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lte_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST286 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LESSEQ); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST286; + _t = __t286; + _t = _t->getNextSibling(); +#line 2031 "walker.g" + op = pModelicaXMLDoc->createElement(X("lte")); /* Absyn__LESSEQ; */ +#line 7853 "modelica_tree_parser.cpp" + break; + } + case GREATER: + { + RefMyAST __t287 = _t; + gt = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST gt_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + gt_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(gt)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(gt_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST287 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GREATER); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST287; + _t = __t287; + _t = _t->getNextSibling(); +#line 2033 "walker.g" + op = pModelicaXMLDoc->createElement(X("gt")); /* Absyn__GREATER; */ +#line 7879 "modelica_tree_parser.cpp" + break; + } + case GREATEREQ: + { + RefMyAST __t288 = _t; + gte = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST gte_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + gte_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(gte)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(gte_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST288 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GREATEREQ); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST288; + _t = __t288; + _t = _t->getNextSibling(); +#line 2035 "walker.g" + op = pModelicaXMLDoc->createElement(X("gte")); /* Absyn__GREATEREQ; */ +#line 7905 "modelica_tree_parser.cpp" + break; + } + case EQEQ: + { + RefMyAST __t289 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST289 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQEQ); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST289; + _t = __t289; + _t = _t->getNextSibling(); +#line 2037 "walker.g" + op = pModelicaXMLDoc->createElement(X("eq")); /* Absyn__EQUAL; */ +#line 7931 "modelica_tree_parser.cpp" + break; + } + case LESSGT: + { + RefMyAST __t290 = _t; + ne = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST ne_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ne_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ne)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ne_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST290 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LESSGT); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST290; + _t = __t290; + _t = _t->getNextSibling(); +#line 2039 "walker.g" + op = pModelicaXMLDoc->createElement(X("ne")); /* op = Absyn__NEQUAL; */ +#line 7957 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 2041 "walker.g" + + op->appendChild(e1); + op->appendChild(e2); + if (lt) { op->setAttribute(X("sline"), X(itoa(lt->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(lt->getColumn(),stmp,10))); } + if (lte){ op->setAttribute(X("sline"), X(itoa(lte->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(lte->getColumn(),stmp,10))); } + if (gt) { op->setAttribute(X("sline"), X(itoa(gt->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(gt->getColumn(),stmp,10))); } + if (gte){ op->setAttribute(X("sline"), X(itoa(gte->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(gte->getColumn(),stmp,10))); } + if (eq) { op->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); } + if (ne) { op->setAttribute(X("sline"), X(itoa(ne->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(ne->getColumn(),stmp,10))); } + ast = op; + +#line 7978 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + relation_AST = RefMyAST(currentAST.root); + returnAST = relation_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::arithmetic_expression(RefMyAST _t) { +#line 2055 "walker.g" + DOMElement* ast; +#line 7996 "modelica_tree_parser.cpp" + RefMyAST arithmetic_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST arithmetic_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST add = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST add_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sub = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sub_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2055 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 8010 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DER: + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case STAR: + case SLASH: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case UNARY_MINUS: + case UNARY_PLUS: + { + ast=unary_arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case PLUS: + { + RefMyAST __t293 = _t; + add = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST add_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + add_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(add)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(add_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST293 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PLUS); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST293; + _t = __t293; + _t = _t->getNextSibling(); +#line 2063 "walker.g" + + DOMElement* pAdd = pModelicaXMLDoc->createElement(X("add")); + + pAdd->setAttribute(X("sline"), X(itoa(add->getLine(),stmp,10))); + pAdd->setAttribute(X("scolumn"), X(itoa(add->getColumn(),stmp,10))); + + pAdd->setAttribute(X("operation"), X("binary")); + pAdd->appendChild(e1); + pAdd->appendChild(e2); + ast = pAdd; + +#line 8074 "modelica_tree_parser.cpp" + break; + } + case MINUS: + { + RefMyAST __t294 = _t; + sub = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST sub_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + sub_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(sub)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(sub_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST294 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MINUS); + _t = _t->getFirstChild(); + e1=arithmetic_expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST294; + _t = __t294; + _t = _t->getNextSibling(); +#line 2075 "walker.g" + + DOMElement* pSub = pModelicaXMLDoc->createElement(X("sub")); + + pSub->setAttribute(X("sline"), X(itoa(sub->getLine(),stmp,10))); + pSub->setAttribute(X("scolumn"), X(itoa(sub->getColumn(),stmp,10))); + + pSub->setAttribute(X("operation"), X("binary")); + pSub->appendChild(e1); + pSub->appendChild(e2); + ast = pSub; + +#line 8110 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + arithmetic_expression_AST = RefMyAST(currentAST.root); + returnAST = arithmetic_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::unary_arithmetic_expression(RefMyAST _t) { +#line 2089 "walker.g" + DOMElement* ast; +#line 8128 "modelica_tree_parser.cpp" + RefMyAST unary_arithmetic_expression_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST unary_arithmetic_expression_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST add = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST add_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sub = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST sub_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case UNARY_PLUS: + { + RefMyAST __t297 = _t; + add = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST add_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + add_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(add)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(add_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST297 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNARY_PLUS); + _t = _t->getFirstChild(); + ast=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST297; + _t = __t297; + _t = _t->getNextSibling(); +#line 2092 "walker.g" + + DOMElement* pAdd = pModelicaXMLDoc->createElement(X("add")); + + pAdd->setAttribute(X("sline"), X(itoa(add->getLine(),stmp,10))); + pAdd->setAttribute(X("scolumn"), X(itoa(add->getColumn(),stmp,10))); + + pAdd->setAttribute(X("operation"), X("unary")); + pAdd->appendChild(ast); + ast = pAdd; + +#line 8171 "modelica_tree_parser.cpp" + break; + } + case UNARY_MINUS: + { + RefMyAST __t298 = _t; + sub = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST sub_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + sub_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(sub)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(sub_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST298 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNARY_MINUS); + _t = _t->getFirstChild(); + ast=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST298; + _t = __t298; + _t = _t->getNextSibling(); +#line 2103 "walker.g" + + DOMElement* pSub = pModelicaXMLDoc->createElement(X("sub")); + + pSub->setAttribute(X("sline"), X(itoa(sub->getLine(),stmp,10))); + pSub->setAttribute(X("scolumn"), X(itoa(sub->getColumn(),stmp,10))); + + pSub->setAttribute(X("operation"), X("unary")); + pSub->appendChild(ast); + ast = pSub; + +#line 8203 "modelica_tree_parser.cpp" + break; + } + case DER: + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case STAR: + case SLASH: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + { + ast=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + unary_arithmetic_expression_AST = RefMyAST(currentAST.root); + returnAST = unary_arithmetic_expression_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::term(RefMyAST _t) { +#line 2117 "walker.g" + DOMElement* ast; +#line 8244 "modelica_tree_parser.cpp" + RefMyAST term_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST term_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST mul = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST mul_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST div = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST div_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2117 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 8258 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DER: + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + { + ast=factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case STAR: + { + RefMyAST __t301 = _t; + mul = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST mul_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + mul_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(mul)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(mul_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST301 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STAR); + _t = _t->getFirstChild(); + e1=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST301; + _t = __t301; + _t = _t->getNextSibling(); +#line 2125 "walker.g" + + DOMElement* pMul = pModelicaXMLDoc->createElement(X("mul")); + + pMul->setAttribute(X("sline"), X(itoa(mul->getLine(),stmp,10))); + pMul->setAttribute(X("scolumn"), X(itoa(mul->getColumn(),stmp,10))); + + pMul->appendChild(e1); + pMul->appendChild(e2); + ast = pMul; + +#line 8317 "modelica_tree_parser.cpp" + break; + } + case SLASH: + { + RefMyAST __t302 = _t; + div = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST div_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + div_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(div)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(div_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST302 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SLASH); + _t = _t->getFirstChild(); + e1=term(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=factor(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST302; + _t = __t302; + _t = _t->getNextSibling(); +#line 2136 "walker.g" + + DOMElement* pDiv = pModelicaXMLDoc->createElement(X("div")); + + pDiv->setAttribute(X("sline"), X(itoa(div->getLine(),stmp,10))); + pDiv->setAttribute(X("scolumn"), X(itoa(div->getColumn(),stmp,10))); + + pDiv->appendChild(e1); + pDiv->appendChild(e2); + ast = pDiv; + +#line 8352 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + term_AST = RefMyAST(currentAST.root); + returnAST = term_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::factor(RefMyAST _t) { +#line 2149 "walker.g" + DOMElement* ast; +#line 8370 "modelica_tree_parser.cpp" + RefMyAST factor_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST factor_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST pw = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST pw_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2149 "walker.g" + + DOMElement* e1; + DOMElement* e2; + +#line 8382 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DER: + case END: + case FALSE: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + { + ast=primary(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case POWER: + { + RefMyAST __t305 = _t; + pw = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST pw_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + pw_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(pw)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pw_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST305 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),POWER); + _t = _t->getFirstChild(); + e1=primary(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + e2=primary(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST305; + _t = __t305; + _t = _t->getNextSibling(); +#line 2157 "walker.g" + + DOMElement* pPow = pModelicaXMLDoc->createElement(X("pow")); + + pPow->setAttribute(X("sline"), X(itoa(pw->getLine(),stmp,10))); + pPow->setAttribute(X("scolumn"), X(itoa(pw->getColumn(),stmp,10))); + + pPow->appendChild(e1); + pPow->appendChild(e2); + ast = pPow; + +#line 8440 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + factor_AST = RefMyAST(currentAST.root); + returnAST = factor_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::primary(RefMyAST _t) { +#line 2170 "walker.g" + DOMElement* ast; +#line 8458 "modelica_tree_parser.cpp" + RefMyAST primary_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST primary_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ui = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ui_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ur = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ur_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST str = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST str_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST f_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST t_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST d_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbk = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbk_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbr = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST lbr_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tend = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tend_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2170 "walker.g" + + l_stack* el_stack = new l_stack; + DOMElement* e; + DOMElement* exp = 0; + DOMElement* pSemicolon = pModelicaXMLDoc->createElement(X("semicolon")); + +#line 8488 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case UNSIGNED_INTEGER: + { + ui = _t; + RefMyAST ui_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ui_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ui)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ui_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNSIGNED_INTEGER); + _t = _t->getNextSibling(); +#line 2179 "walker.g" + + DOMElement* pIntegerLiteral = pModelicaXMLDoc->createElement(X("integer_literal")); + pIntegerLiteral->setAttribute(X("value"), str2xml(ui)); + + pIntegerLiteral->setAttribute(X("sline"), X(itoa(ui->getLine(),stmp,10))); + pIntegerLiteral->setAttribute(X("scolumn"), X(itoa(ui->getColumn(),stmp,10))); + + ast = pIntegerLiteral; + +#line 8512 "modelica_tree_parser.cpp" + break; + } + case UNSIGNED_REAL: + { + ur = _t; + RefMyAST ur_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ur_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ur)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ur_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNSIGNED_REAL); + _t = _t->getNextSibling(); +#line 2189 "walker.g" + + DOMElement* pRealLiteral = pModelicaXMLDoc->createElement(X("real_literal")); + pRealLiteral->setAttribute(X("value"), str2xml(ur)); + + pRealLiteral->setAttribute(X("sline"), X(itoa(ur->getLine(),stmp,10))); + pRealLiteral->setAttribute(X("scolumn"), X(itoa(ur->getColumn(),stmp,10))); + + ast = pRealLiteral; + +#line 8533 "modelica_tree_parser.cpp" + break; + } + case STRING: + { + str = _t; + RefMyAST str_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + str_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(str)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(str_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING); + _t = _t->getNextSibling(); +#line 2199 "walker.g" + + DOMElement* pStringLiteral = pModelicaXMLDoc->createElement(X("string_literal")); + pStringLiteral->setAttribute(X("value"), str2xml(str)); + + pStringLiteral->setAttribute(X("sline"), X(itoa(str->getLine(),stmp,10))); + pStringLiteral->setAttribute(X("scolumn"), X(itoa(str->getColumn(),stmp,10))); + + ast = pStringLiteral; + +#line 8554 "modelica_tree_parser.cpp" + break; + } + case FALSE: + { + f = _t; + RefMyAST f_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + f_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(f)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FALSE); + _t = _t->getNextSibling(); +#line 2209 "walker.g" + + DOMElement* pBoolLiteral = pModelicaXMLDoc->createElement(X("bool_literal")); + pBoolLiteral->setAttribute(X("value"), X("false")); + + pBoolLiteral->setAttribute(X("sline"), X(itoa(f->getLine(),stmp,10))); + pBoolLiteral->setAttribute(X("scolumn"), X(itoa(f->getColumn(),stmp,10))); + + ast = pBoolLiteral; + +#line 8575 "modelica_tree_parser.cpp" + break; + } + case TRUE: + { + t = _t; + RefMyAST t_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + t_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(t)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TRUE); + _t = _t->getNextSibling(); +#line 2219 "walker.g" + + DOMElement* pBoolLiteral = pModelicaXMLDoc->createElement(X("bool_literal")); + pBoolLiteral->setAttribute(X("value"), X("true")); + + pBoolLiteral->setAttribute(X("sline"), X(itoa(t->getLine(),stmp,10))); + pBoolLiteral->setAttribute(X("scolumn"), X(itoa(t->getColumn(),stmp,10))); + + ast = pBoolLiteral; + +#line 8596 "modelica_tree_parser.cpp" + break; + } + case DOT: + case IDENT: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + { + ast=component_reference__function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case DER: + { + RefMyAST __t308 = _t; + d = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST d_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + d_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(d)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST308 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DER); + _t = _t->getFirstChild(); + e=function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST308; + _t = __t308; + _t = _t->getNextSibling(); +#line 2230 "walker.g" + + DOMElement* pDer = pModelicaXMLDoc->createElement(X("der")); + pDer->setAttribute(X("sline"), X(itoa(d->getLine(),stmp,10))); + pDer->setAttribute(X("scolumn"), X(itoa(d->getColumn(),stmp,10))); + pDer->appendChild(e); + ast = pDer; + +#line 8635 "modelica_tree_parser.cpp" + break; + } + case LPAR: + { + RefMyAST __t309 = _t; + RefMyAST tmp41_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp41_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp41_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp41_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp41_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST309 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LPAR); + _t = _t->getFirstChild(); + ast=tuple_expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST309; + _t = __t309; + _t = _t->getNextSibling(); + break; + } + case LBRACK: + { + RefMyAST __t310 = _t; + lbk = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lbk_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lbk_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lbk)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lbk_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST310 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LBRACK); + _t = _t->getFirstChild(); + e=expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2238 "walker.g" + el_stack->push_back(e); +#line 8676 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == EXPRESSION_LIST)) { + e=expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2239 "walker.g" + el_stack->push_back(e); +#line 8687 "modelica_tree_parser.cpp" + } + else { + goto _loop312; + } + + } + _loop312:; + } // ( ... )* + currentAST = __currentAST310; + _t = __t310; + _t = _t->getNextSibling(); +#line 2240 "walker.g" + + DOMElement* pConcat = pModelicaXMLDoc->createElement(X("concat")); + + pConcat->setAttribute(X("sline"), X(itoa(lbk->getLine(),stmp,10))); + pConcat->setAttribute(X("scolumn"), X(itoa(lbk->getColumn(),stmp,10))); + + pConcat = (DOMElement*)appendKidsFromStack(el_stack, pConcat); + //if (el_stack) delete el_stack; + ast = pConcat; + +#line 8710 "modelica_tree_parser.cpp" + break; + } + case LBRACE: + { + RefMyAST __t313 = _t; + lbr = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST lbr_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + lbr_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(lbr)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lbr_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST313 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LBRACE); + _t = _t->getFirstChild(); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXPRESSION_LIST: + { + { + ast=expression_list(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR_ITERATOR: + { + RefMyAST __t316 = _t; + RefMyAST tmp42_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp42_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp42_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp42_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp42_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST316 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR_ITERATOR); + _t = _t->getFirstChild(); + { + ast=for_iterator(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST316; + _t = __t316; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST313; + _t = __t313; + _t = _t->getNextSibling(); +#line 2252 "walker.g" + + /* was before: ast = function_arguments */ + DOMElement* pArray = pModelicaXMLDoc->createElement(X("array")); + + pArray->setAttribute(X("sline"), X(itoa(lbr->getLine(),stmp,10))); + pArray->setAttribute(X("scolumn"), X(itoa(lbr->getColumn(),stmp,10))); + + if (!exp) pArray->appendChild(ast); + else + { + DOMElement* pFargs = pModelicaXMLDoc->createElement(X("function_arguments")); + pFargs->appendChild(exp); + pFargs->appendChild(ast); + pArray->appendChild(pFargs); + } + ast = pArray; + +#line 8788 "modelica_tree_parser.cpp" + break; + } + case END: + { + tend = _t; + RefMyAST tend_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tend_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(tend)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tend_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),END); + _t = _t->getNextSibling(); +#line 2270 "walker.g" + + DOMElement* pEnd = pModelicaXMLDoc->createElement(X("end")); + pEnd->setAttribute(X("sline"), X(itoa(tend->getLine(),stmp,10))); + pEnd->setAttribute(X("scolumn"), X(itoa(tend->getColumn(),stmp,10))); + ast = pEnd; + +#line 8806 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + primary_AST = RefMyAST(currentAST.root); + returnAST = primary_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::component_reference__function_call(RefMyAST _t) { +#line 2279 "walker.g" + DOMElement* ast; +#line 8824 "modelica_tree_parser.cpp" + RefMyAST component_reference__function_call_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST component_reference__function_call_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fc = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST fc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ifc = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST ifc_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2279 "walker.g" + + DOMElement* cref; + DOMElement* fnc = 0; + +#line 8840 "modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT: + case IDENT: + case FUNCTION_CALL: + { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FUNCTION_CALL: + { + RefMyAST __t320 = _t; + fc = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST fc_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + fc_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(fc)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(fc_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST320 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_CALL); + _t = _t->getFirstChild(); + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FUNCTION_ARGUMENTS: + { + fnc=function_call(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + currentAST = __currentAST320; + _t = __t320; + _t = _t->getNextSibling(); +#line 2286 "walker.g" + + DOMElement* pCall = pModelicaXMLDoc->createElement(X("call")); + + pCall->setAttribute(X("sline"), X(itoa(fc->getLine(),stmp,10))); + pCall->setAttribute(X("scolumn"), X(itoa(fc->getColumn(),stmp,10))); + + pCall->appendChild(cref); + if (fnc) pCall->appendChild(fnc); + ast = pCall; + +#line 8903 "modelica_tree_parser.cpp" + break; + } + case DOT: + case IDENT: + { + cref=component_reference(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2297 "walker.g" + + if (fnc && cref) cref->appendChild(fnc); + ast = cref; + +#line 8917 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + component_reference__function_call_AST = RefMyAST(currentAST.root); + break; + } + case INITIAL_FUNCTION_CALL: + { + RefMyAST __t322 = _t; + ifc = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST ifc_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ifc_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(ifc)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ifc_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST322 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INITIAL_FUNCTION_CALL); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INITIAL); + _t = _t->getNextSibling(); + currentAST = __currentAST322; + _t = __t322; + _t = _t->getNextSibling(); +#line 2304 "walker.g" + + // calling function initial + DOMElement* pCall = pModelicaXMLDoc->createElement(X("call")); + + DOMElement* pCref = pModelicaXMLDoc->createElement(X("component_reference")); + pCref->setAttribute(X("ident"), X("initial")); + pCref->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pCall->appendChild(pCref); + + pCall->setAttribute(X("sline"), X(itoa(ifc->getLine(),stmp,10))); + pCall->setAttribute(X("scolumn"), X(itoa(ifc->getColumn(),stmp,10))); + + ast = pCall; + +#line 8967 "modelica_tree_parser.cpp" + component_reference__function_call_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = component_reference__function_call_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::function_arguments(RefMyAST _t) { +#line 2403 "walker.g" + DOMElement* ast; +#line 8984 "modelica_tree_parser.cpp" + RefMyAST function_arguments_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST function_arguments_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2403 "walker.g" + + l_stack el_stack; + DOMElement* e=0; + DOMElement* namel=0; + DOMElement *pFunctionArguments = pModelicaXMLDoc->createElement(X("function_arguments")); + +#line 8996 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case 3: + case EXPRESSION_LIST: + case NAMED_ARGUMENTS: + { + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case EXPRESSION_LIST: + { + pFunctionArguments=expression_list2(_t,pFunctionArguments); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + case NAMED_ARGUMENTS: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case NAMED_ARGUMENTS: + { + pFunctionArguments=named_arguments(_t,pFunctionArguments); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 2414 "walker.g" + + ast = pFunctionArguments; + +#line 9053 "modelica_tree_parser.cpp" + break; + } + case FOR_ITERATOR: + { + RefMyAST __t343 = _t; + RefMyAST tmp43_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp43_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp43_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp43_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp43_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST343 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR_ITERATOR); + _t = _t->getFirstChild(); + ast=for_iterator(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST343; + _t = __t343; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + function_arguments_AST = RefMyAST(currentAST.root); + returnAST = function_arguments_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::expression_list2(RefMyAST _t, + DOMElement *parent +) { +#line 2383 "walker.g" + DOMElement* ast; +#line 9094 "modelica_tree_parser.cpp" + RefMyAST expression_list2_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST expression_list2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST el_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2383 "walker.g" + + l_stack el_stack; + DOMElement* e; + +#line 9106 "modelica_tree_parser.cpp" + + { + RefMyAST __t336 = _t; + el = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST el_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + el_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(el)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(el_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST336 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXPRESSION_LIST); + _t = _t->getFirstChild(); + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2390 "walker.g" + parent->appendChild(e); +#line 9124 "modelica_tree_parser.cpp" + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_2.member(_t->getType()))) { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2391 "walker.g" + parent->appendChild(e); +#line 9135 "modelica_tree_parser.cpp" + } + else { + goto _loop338; + } + + } + _loop338:; + } // ( ... )* + currentAST = __currentAST336; + _t = __t336; + _t = _t->getNextSibling(); + } +#line 2394 "walker.g" + + ast = parent; + +#line 9152 "modelica_tree_parser.cpp" + expression_list2_AST = RefMyAST(currentAST.root); + returnAST = expression_list2_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::named_arguments(RefMyAST _t, + DOMElement *parent +) { +#line 2424 "walker.g" + DOMElement* ast; +#line 9164 "modelica_tree_parser.cpp" + RefMyAST named_arguments_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_arguments_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST na = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST na_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2424 "walker.g" + + l_stack el_stack; + DOMElement* n; + +#line 9176 "modelica_tree_parser.cpp" + + RefMyAST __t345 = _t; + na = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST na_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + na_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(na)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(na_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST345 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NAMED_ARGUMENTS); + _t = _t->getFirstChild(); + { + n=named_argument(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2430 "walker.g" + parent->appendChild(n); +#line 9194 "modelica_tree_parser.cpp" + } + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == EQUALS)) { + n=named_argument(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2431 "walker.g" + parent->appendChild(n); +#line 9206 "modelica_tree_parser.cpp" + } + else { + goto _loop348; + } + + } + _loop348:; + } // ( ... )* + currentAST = __currentAST345; + _t = __t345; + _t = _t->getNextSibling(); +#line 2432 "walker.g" + + ast = parent; + +#line 9222 "modelica_tree_parser.cpp" + named_arguments_AST = RefMyAST(currentAST.root); + returnAST = named_arguments_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::named_argument(RefMyAST _t) { +#line 2437 "walker.g" + DOMElement* ast; +#line 9232 "modelica_tree_parser.cpp" + RefMyAST named_argument_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST named_argument_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST eq_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST i_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2437 "walker.g" + + DOMElement* temp; + +#line 9245 "modelica_tree_parser.cpp" + + RefMyAST __t350 = _t; + eq = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST eq_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + eq_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(eq)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(eq_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST350 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUALS); + _t = _t->getFirstChild(); + i = _t; + RefMyAST i_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + i_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(i)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT); + _t = _t->getNextSibling(); + temp=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + currentAST = __currentAST350; + _t = __t350; + _t = _t->getNextSibling(); +#line 2443 "walker.g" + + DOMElement *pNamedArgument = pModelicaXMLDoc->createElement(X("named_argument")); + pNamedArgument->setAttribute(X("ident"), str2xml(i)); + + pNamedArgument->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pNamedArgument->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pNamedArgument->appendChild(temp); + ast = pNamedArgument; + +#line 9280 "modelica_tree_parser.cpp" + named_argument_AST = RefMyAST(currentAST.root); + returnAST = named_argument_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::subscript(RefMyAST _t, + DOMElement* parent +) { +#line 2529 "walker.g" + DOMElement* ast; +#line 9292 "modelica_tree_parser.cpp" + RefMyAST subscript_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST subscript_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST c_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2529 "walker.g" + + DOMElement* e; + DOMElement* pColon = pModelicaXMLDoc->createElement(X("colon")); + +#line 9304 "modelica_tree_parser.cpp" + + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + case DER: + case END: + case FALSE: + case IF: + case NOT: + case OR: + case TRUE: + case UNSIGNED_REAL: + case DOT: + case LPAR: + case LBRACK: + case LBRACE: + case PLUS: + case MINUS: + case STAR: + case SLASH: + case LESS: + case LESSEQ: + case GREATER: + case GREATEREQ: + case EQEQ: + case LESSGT: + case POWER: + case IDENT: + case UNSIGNED_INTEGER: + case STRING: + case CODE_EXPRESSION: + case CODE_MODIFICATION: + case CODE_ELEMENT: + case CODE_EQUATION: + case CODE_INITIALEQUATION: + case CODE_ALGORITHM: + case CODE_INITIALALGORITHM: + case FUNCTION_CALL: + case INITIAL_FUNCTION_CALL: + case RANGE2: + case RANGE3: + case UNARY_MINUS: + case UNARY_PLUS: + { + e=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); +#line 2537 "walker.g" + + parent->appendChild(e); + ast = parent; + +#line 9359 "modelica_tree_parser.cpp" + break; + } + case COLON: + { + c = _t; + RefMyAST c_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + c_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(c)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COLON); + _t = _t->getNextSibling(); +#line 2542 "walker.g" + + + pColon->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pColon->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + + parent->appendChild(pColon); + ast = parent; + +#line 9379 "modelica_tree_parser.cpp" + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + subscript_AST = RefMyAST(currentAST.root); + returnAST = subscript_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::string_concatenation(RefMyAST _t) { +#line 2595 "walker.g" + DOMElement* ast; +#line 9397 "modelica_tree_parser.cpp" + RefMyAST string_concatenation_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST string_concatenation_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST p_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s2 = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s2_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2595 "walker.g" + + DOMElement*pString1; + l_stack el_stack; + +#line 9413 "modelica_tree_parser.cpp" + + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case STRING: + { + s = _t; + RefMyAST s_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + s_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(s)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING); + _t = _t->getNextSibling(); +#line 2602 "walker.g" + + DOMElement *pString = pModelicaXMLDoc->createElement(X("string_literal")); + pString->setAttribute(X("value"), str2xml(s)); + + pString->setAttribute(X("sline"), X(itoa(s->getLine(),stmp,10))); + pString->setAttribute(X("scolumn"), X(itoa(s->getColumn(),stmp,10))); + + ast=pString; + +#line 9436 "modelica_tree_parser.cpp" + string_concatenation_AST = RefMyAST(currentAST.root); + break; + } + case PLUS: + { + RefMyAST __t373 = _t; + p = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefMyAST p_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + p_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(p)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST373 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PLUS); + _t = _t->getFirstChild(); + pString1=string_concatenation(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + s2 = _t; + RefMyAST s2_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + s2_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(s2)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s2_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING); + _t = _t->getNextSibling(); + currentAST = __currentAST373; + _t = __t373; + _t = _t->getNextSibling(); +#line 2612 "walker.g" + + DOMElement *pString = pModelicaXMLDoc->createElement(X("add_string")); + + pString->setAttribute(X("sline"), X(itoa(p->getLine(),stmp,10))); + pString->setAttribute(X("scolumn"), X(itoa(p->getColumn(),stmp,10))); + + pString->appendChild(pString1); + DOMElement *pString2 = pModelicaXMLDoc->createElement(X("string_literal")); + pString2->setAttribute(X("value"), str2xml(s2)); + + pString2->setAttribute(X("sline"), X(itoa(s2->getLine(),stmp,10))); + pString2->setAttribute(X("scolumn"), X(itoa(s2->getColumn(),stmp,10))); + + pString->appendChild(pString2); + ast=pString; + +#line 9481 "modelica_tree_parser.cpp" + string_concatenation_AST = RefMyAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + returnAST = string_concatenation_AST; + _retTree = _t; + return ast; +} + +DOMElement* modelica_tree_parser::interactive_stmt(RefMyAST _t) { +#line 2672 "walker.g" + DOMElement* ast; +#line 9498 "modelica_tree_parser.cpp" + RefMyAST interactive_stmt_AST_in = (_t == ASTNULL) ? RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + returnAST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefMyAST interactive_stmt_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST s_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 2672 "walker.g" + + DOMElement* al=0; + DOMElement* el=0; + l_stack el_stack; + DOMElement *pInteractiveSTMT = pModelicaXMLDoc->createElement(X("ISTMT")); + DOMElement *pInteractiveALG = pModelicaXMLDoc->createElement(X("IALG")); + +#line 9513 "modelica_tree_parser.cpp" + + { // ( ... )* + for (;;) { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case INTERACTIVE_ALG: + { + RefMyAST __t378 = _t; + RefMyAST tmp44_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp44_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp44_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp44_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp44_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST378 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INTERACTIVE_ALG); + _t = _t->getFirstChild(); + { + pInteractiveALG=algorithm(_t,pInteractiveALG); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST378; + _t = __t378; + _t = _t->getNextSibling(); +#line 2683 "walker.g" + + //pInteractiveALG->appendChild(al); + el_stack.push_back(pInteractiveALG); + +#line 9546 "modelica_tree_parser.cpp" + break; + } + case INTERACTIVE_EXP: + { + RefMyAST __t380 = _t; + RefMyAST tmp45_AST = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefMyAST tmp45_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + tmp45_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + tmp45_AST_in = _t; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp45_AST)); + ANTLR_USE_NAMESPACE(antlr)ASTPair __currentAST380 = currentAST; + currentAST.root = currentAST.child; + currentAST.child = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INTERACTIVE_EXP); + _t = _t->getFirstChild(); + { + el=expression(_t); + _t = _retTree; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + currentAST = __currentAST380; + _t = __t380; + _t = _t->getNextSibling(); +#line 2689 "walker.g" + + DOMElement *pInteractiveEXP = pModelicaXMLDoc->createElement(X("IEXP")); + pInteractiveEXP->appendChild(el); + el_stack.push_back(pInteractiveEXP); + +#line 9576 "modelica_tree_parser.cpp" + break; + } + default: + { + goto _loop382; + } + } + } + _loop382:; + } // ( ... )* + { + if (_t == RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case SEMICOLON: + { + s = _t; + RefMyAST s_AST_in = RefMyAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + s_AST = astFactory->create(ANTLR_USE_NAMESPACE(antlr)RefAST(s)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SEMICOLON); + _t = _t->getNextSibling(); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 2696 "walker.g" + + pInteractiveSTMT = (DOMElement*)appendKids(el_stack, pInteractiveSTMT); + if (s) pInteractiveSTMT->setAttribute(X("semicolon"),X("true")); + ast = pInteractiveSTMT; + +#line 9617 "modelica_tree_parser.cpp" + interactive_stmt_AST = RefMyAST(currentAST.root); + returnAST = interactive_stmt_AST; + _retTree = _t; + return ast; +} + +void modelica_tree_parser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) +{ + factory.setMaxNodeType(150); +} +const char* modelica_tree_parser::tokenNames[] = { + "<0>", + "EOF", + "<2>", + "NULL_TREE_LOOKAHEAD", + "\"algorithm\"", + "\"and\"", + "\"annotation\"", + "\"block\"", + "\"Code\"", + "\"class\"", + "\"connect\"", + "\"connector\"", + "\"constant\"", + "\"discrete\"", + "\"der\"", + "\"each\"", + "\"else\"", + "\"elseif\"", + "\"elsewhen\"", + "\"end\"", + "\"enumeration\"", + "\"equation\"", + "\"encapsulated\"", + "\"expandable\"", + "\"extends\"", + "\"external\"", + "\"false\"", + "\"final\"", + "\"flow\"", + "\"for\"", + "\"function\"", + "\"if\"", + "\"import\"", + "\"in\"", + "\"initial\"", + "\"inner\"", + "\"input\"", + "\"loop\"", + "\"model\"", + "\"not\"", + "\"outer\"", + "\"overload\"", + "\"or\"", + "\"output\"", + "\"package\"", + "\"parameter\"", + "\"partial\"", + "\"protected\"", + "\"public\"", + "\"record\"", + "\"redeclare\"", + "\"replaceable\"", + "\"results\"", + "\"then\"", + "\"true\"", + "\"type\"", + "\"unsigned_real\"", + "\".\"", + "\"when\"", + "\"while\"", + "\"within\"", + "LPAR", + "RPAR", + "LBRACK", + "RBRACK", + "LBRACE", + "RBRACE", + "EQUALS", + "ASSIGN", + "PLUS", + "MINUS", + "STAR", + "SLASH", + "COMMA", + "LESS", + "LESSEQ", + "GREATER", + "GREATEREQ", + "EQEQ", + "LESSGT", + "COLON", + "SEMICOLON", + "POWER", + "YIELDS", + "AMPERSAND", + "PIPEBAR", + "COLONCOLON", + "DASHES", + "WS", + "ML_COMMENT", + "ML_COMMENT_CHAR", + "SL_COMMENT", + "an identifier", + "an identifier", + "NONDIGIT", + "DIGIT", + "EXPONENT", + "UNSIGNED_INTEGER", + "STRING", + "SCHAR", + "QCHAR", + "SESCAPE", + "ESC", + "ALGORITHM_STATEMENT", + "ARGUMENT_LIST", + "BEGIN_DEFINITION", + "CLASS_DEFINITION", + "CLASS_EXTENDS", + "CLASS_MODIFICATION", + "CODE_EXPRESSION", + "CODE_MODIFICATION", + "CODE_ELEMENT", + "CODE_EQUATION", + "CODE_INITIALEQUATION", + "CODE_ALGORITHM", + "CODE_INITIALALGORITHM", + "COMMENT", + "COMPONENT_DEFINITION", + "DECLARATION", + "DEFINITION", + "END_DEFINITION", + "ENUMERATION_LITERAL", + "ELEMENT", + "ELEMENT_MODIFICATION", + "ELEMENT_REDECLARATION", + "EQUATION_STATEMENT", + "EXTERNAL_ANNOTATION", + "INITIAL_EQUATION", + "INITIAL_ALGORITHM", + "IMPORT_DEFINITION", + "IDENT_LIST", + "EXPRESSION_LIST", + "EXTERNAL_FUNCTION_CALL", + "FOR_INDICES", + "FOR_ITERATOR", + "FUNCTION_CALL", + "INITIAL_FUNCTION_CALL", + "FUNCTION_ARGUMENTS", + "NAMED_ARGUMENTS", + "QUALIFIED", + "RANGE2", + "RANGE3", + "STORED_DEFINITION", + "STRING_COMMENT", + "UNARY_MINUS", + "UNARY_PLUS", + "UNQUALIFIED", + "INTERACTIVE_STMT", + "INTERACTIVE_ALG", + "INTERACTIVE_EXP", + "REDELCARE", + 0 +}; + +const unsigned long modelica_tree_parser::_tokenSet_0_data_[] = { 2097168UL, 98304UL, 0UL, 2147483648UL, 1UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "algorithm" "equation" "protected" "public" INITIAL_EQUATION INITIAL_ALGORITHM +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_tree_parser::_tokenSet_0(_tokenSet_0_data_,12); +const unsigned long modelica_tree_parser::_tokenSet_1_data_[] = { 2215133216UL, 2738881664UL, 268828130UL, 1040390UL, 209280UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "der" "end" "false" "if" "not" "or" "true" "unsigned_real" "." +// LPAR LBRACK LBRACE PLUS MINUS STAR SLASH LESS LESSEQ GREATER GREATEREQ +// EQEQ LESSGT COLON POWER IDENT UNSIGNED_INTEGER STRING CODE_EXPRESSION +// CODE_MODIFICATION CODE_ELEMENT CODE_EQUATION CODE_INITIALEQUATION CODE_ALGORITHM +// CODE_INITIALALGORITHM FUNCTION_CALL INITIAL_FUNCTION_CALL RANGE2 RANGE3 +// UNARY_MINUS UNARY_PLUS +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_tree_parser::_tokenSet_1(_tokenSet_1_data_,12); +const unsigned long modelica_tree_parser::_tokenSet_2_data_[] = { 2215133216UL, 2738881664UL, 268762594UL, 1040390UL, 209280UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "and" "der" "end" "false" "if" "not" "or" "true" "unsigned_real" "." +// LPAR LBRACK LBRACE PLUS MINUS STAR SLASH LESS LESSEQ GREATER GREATEREQ +// EQEQ LESSGT POWER IDENT UNSIGNED_INTEGER STRING CODE_EXPRESSION CODE_MODIFICATION +// CODE_ELEMENT CODE_EQUATION CODE_INITIALEQUATION CODE_ALGORITHM CODE_INITIALALGORITHM +// FUNCTION_CALL INITIAL_FUNCTION_CALL RANGE2 RANGE3 UNARY_MINUS UNARY_PLUS +const ANTLR_USE_NAMESPACE(antlr)BitSet modelica_tree_parser::_tokenSet_2(_tokenSet_2_data_,12); + + diff --git a/tools/xml/modelicaxml/modelica_tree_parser.hpp b/tools/xml/modelicaxml/modelica_tree_parser.hpp new file mode 100644 index 00000000000..0a8e4c7f471 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_tree_parser.hpp @@ -0,0 +1,340 @@ +#ifndef INC_modelica_tree_parser_hpp_ +#define INC_modelica_tree_parser_hpp_ + +#line 2 "walker.g" + +// adrpo disabling warnings +#pragma warning( disable : 4267) // Disable warning messages C4267 +// disable: 'initializing' : conversion from 'size_t' to 'int', possible loss of data + +#pragma warning( disable : 4231) // Disable warning messages C4231 +// disable: nonstandard extension used : 'extern' before template explicit instantiation + +#pragma warning( disable : 4101) // Disable warning messages C4101 +// disable: warning C4101: 'pe' : unreferenced local variable + +#line 17 "modelica_tree_parser.hpp" +#include +#include "modelica_tree_parserTokenTypes.hpp" +/* $ANTLR 2.7.5rc2 (20050108): "walker.g" -> "modelica_tree_parser.hpp"$ */ +#include + +#line 15 "walker.g" + +/************************************************************************ +File: walker.g +Created By: Adrian Pop adrpo@ida.liu.se +Date: 2003-06-10 +Revised on 2003-10-26 17:58:42 (write the definition even if has no childs) +Comments: we walk on the modelica tree, buil a XML DOM tree and serialize +************************************************************************/ + + #define null 0 + + extern "C" + { + #include + } + + #include + #include + #include + #include + +#ifndef __MODELICAXML_H_ +#include "ModelicaXml.h" +#endif + +#include "MyAST.h" + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; + + +#line 54 "modelica_tree_parser.hpp" +class CUSTOM_API modelica_tree_parser : public ANTLR_USE_NAMESPACE(antlr)TreeParser, public modelica_tree_parserTokenTypes +{ +#line 74 "walker.g" + + + /* some xml helpers declarations */ + DOMDocument* pModelicaXMLDoc; + DOMElement* pRootElementModelicaXML; + char stmp[500]; + + + typedef std::deque l_stack; + typedef std::string mstring; + enum anno {UNSPECIFIED, INSIDE_EXTERNAL, INSIDE_ELEMENT, INSIDE_EQUATION, INSIDE_ALGORITHM, INSIDE_COMMENT}; + + const XMLCh* str2xml(RefMyAST node) + { + return XMLString::transcode(node->getText().c_str()); + } + + DOMElement* stack2DOMNode(l_stack& s, mstring name) + { + DOMElement *pHoldingNode = pModelicaXMLDoc->createElement(X(name.c_str())); + std::deque::reverse_iterator itList; + for (itList=s.rbegin(); itList!=s.rend(); ++itList) + { + pHoldingNode->appendChild((DOMElement*)*itList); + } + return pHoldingNode; + } + + DOMElement* appendKids(l_stack& s, DOMElement* pParentNode) + { + std::deque::reverse_iterator itList; + for (itList=s.rbegin(); itList!=s.rend(); ++itList) + { + pParentNode->appendChild((DOMElement*)*itList); + } + return pParentNode; + } + + DOMElement* appendKidsFromStack(l_stack* s, DOMElement* pParentNode) + { + std::deque::reverse_iterator itList; + for (itList=s->rbegin(); itList!=s->rend(); ++itList) + { + pParentNode->appendChild((DOMElement*)*itList); + } + delete s; + return pParentNode; + } + + void setAttributes(DOMElement *pNodeTo, DOMElement *pNodeFrom) + { + DOMNamedNodeMap *pAttributes = pNodeFrom->getAttributes(); + for (XMLSize_t i=0; i < pAttributes->getLength(); i++) + { + DOMAttr *z = (DOMAttr*)pAttributes->item(i); + pNodeTo->setAttribute(z->getName(), z->getValue()); + } + } + + struct type_prefix_t + { + type_prefix_t():flow(0), variability(0),direction(0){} + DOMElement* flow; + DOMElement* variability; + DOMElement* direction; + }; + + struct class_specifier_t + { + class_specifier_t():string_comment(0), composition(0), enumeration(0), derived(0), overload(0), pder(0), classExtends(0){} + DOMElement* string_comment; + DOMElement *composition; + DOMElement* derived; + DOMElement* enumeration; + DOMElement* overload; + DOMElement* pder; + DOMElement* classExtends; + }; + + DOMAttr* getAttributeNode(DOMElement* pNode, mstring stdstr) + { + return ((DOMElement*)pNode)->getAttributeNode(X(stdstr.c_str())); + } + + + void setVisibility(int iSwitch, DOMElement* pNode) + { + if (iSwitch == 1) pNode->setAttribute(X("visibility"), X("public")); + else if (iSwitch == 2) pNode->setAttribute(X("visibility"), X("protected")); + else { /* error, shouldn't happen */ } + } +#line 58 "modelica_tree_parser.hpp" +public: + modelica_tree_parser(); + static void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ); + int getNumTokens() const + { + return modelica_tree_parser::NUM_TOKENS; + } + const char* getTokenName( int type ) const + { + if( type > getNumTokens() ) return 0; + return modelica_tree_parser::tokenNames[type]; + } + const char* const* getTokenNames() const + { + return modelica_tree_parser::tokenNames; + } + public: DOMElement * stored_definition(RefMyAST _t, + mstring moFilename, DOMDocument* pModelicaXMLDocParam + ); + public: DOMElement* within_clause(RefMyAST _t, + DOMElement* parent + ); + public: DOMElement* class_definition(RefMyAST _t, + bool final, DOMElement *definitionElement + ); + public: void * name_path(RefMyAST _t); + public: void class_restriction(RefMyAST _t); + public: void class_specifier(RefMyAST _t, + class_specifier_t& sClassSpec + ); + public: DOMElement* string_comment(RefMyAST _t); + public: DOMElement* composition(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* derived_class(RefMyAST _t); + public: DOMElement* enumeration(RefMyAST _t); + public: DOMElement* overloading(RefMyAST _t); + public: DOMElement* pder(RefMyAST _t); + public: void * class_modification(RefMyAST _t); + public: DOMElement* ident_list(RefMyAST _t); + public: void type_prefix(RefMyAST _t, + DOMElement* parent + ); + public: DOMElement* array_subscripts(RefMyAST _t, + int kind + ); + public: DOMElement* comment(RefMyAST _t); + public: DOMElement* enumeration_literal(RefMyAST _t); + public: DOMElement* element_list(RefMyAST _t, + int iSwitch, DOMElement*definition + ); + public: DOMElement* public_element_list(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* protected_element_list(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* equation_clause(RefMyAST _t, + DOMElement *definition + ); + public: DOMElement* algorithm_clause(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* external_function_call(RefMyAST _t, + DOMElement *pExternalFunctionCall + ); + public: DOMElement* annotation(RefMyAST _t, + int iSwitch, DOMElement *parent, enum anno awhere + ); + public: DOMElement* expression_list(RefMyAST _t); + public: DOMElement* component_reference(RefMyAST _t); + public: DOMElement* element(RefMyAST _t, + int iSwitch, DOMElement *parent + ); + public: DOMElement* import_clause(RefMyAST _t, + int iSwitch, DOMElement *parent + ); + public: DOMElement* extends_clause(RefMyAST _t, + int iSwitch, DOMElement* parent + ); + public: DOMElement* component_clause(RefMyAST _t, + DOMElement* parent, DOMElement* attributes + ); + public: DOMElement* constraining_clause(RefMyAST _t); + public: DOMElement* explicit_import_name(RefMyAST _t); + public: DOMElement* implicit_import_name(RefMyAST _t); + public: void* type_specifier(RefMyAST _t); + public: DOMElement* component_list(RefMyAST _t, + DOMElement* parent, DOMElement *attributes, DOMElement* type_array + ); + public: DOMElement* component_declaration(RefMyAST _t, + DOMElement* parent, DOMElement *attributes, DOMElement *type_array + ); + public: DOMElement* conditional_attribute(RefMyAST _t); + public: DOMElement* expression(RefMyAST _t); + public: DOMElement* declaration(RefMyAST _t, + DOMElement* parent, DOMElement* type_array + ); + public: DOMElement* modification(RefMyAST _t); + public: void * argument_list(RefMyAST _t); + public: DOMElement* argument(RefMyAST _t); + public: DOMElement* element_modification(RefMyAST _t); + public: DOMElement* element_redeclaration(RefMyAST _t); + public: DOMElement* component_clause1(RefMyAST _t, + DOMElement *parent + ); + public: DOMElement* equation(RefMyAST _t, + DOMElement* definition + ); + public: DOMElement* algorithm(RefMyAST _t, + DOMElement *definition + ); + public: DOMElement* equality_equation(RefMyAST _t); + public: DOMElement* conditional_equation_e(RefMyAST _t); + public: DOMElement* for_clause_e(RefMyAST _t); + public: DOMElement* when_clause_e(RefMyAST _t); + public: DOMElement* connect_clause(RefMyAST _t); + public: DOMElement* equation_funcall(RefMyAST _t); + public: DOMElement* function_call(RefMyAST _t); + public: DOMElement* tuple_expression_list(RefMyAST _t); + public: DOMElement* algorithm_function_call(RefMyAST _t); + public: DOMElement* conditional_equation_a(RefMyAST _t); + public: DOMElement* for_clause_a(RefMyAST _t); + public: DOMElement* while_clause(RefMyAST _t); + public: DOMElement* when_clause_a(RefMyAST _t); + public: DOMElement* simple_expression(RefMyAST _t); + public: DOMElement* equation_list(RefMyAST _t, + DOMElement* pEquationList + ); + public: DOMElement* equation_elseif(RefMyAST _t); + public: DOMElement* algorithm_list(RefMyAST _t, + DOMElement* pAlgorithmList + ); + public: DOMElement* algorithm_elseif(RefMyAST _t); + public: DOMElement* for_indices(RefMyAST _t); + public: DOMElement* for_iterator(RefMyAST _t); + public: DOMElement* else_when_e(RefMyAST _t); + public: DOMElement* else_when_a(RefMyAST _t); + public: DOMElement* if_expression(RefMyAST _t); + public: DOMElement* code_expression(RefMyAST _t); + public: DOMElement* elseif_expression(RefMyAST _t); + public: DOMElement* logical_expression(RefMyAST _t); + public: DOMElement* logical_term(RefMyAST _t); + public: DOMElement* logical_factor(RefMyAST _t); + public: DOMElement* relation(RefMyAST _t); + public: DOMElement* arithmetic_expression(RefMyAST _t); + public: DOMElement* unary_arithmetic_expression(RefMyAST _t); + public: DOMElement* term(RefMyAST _t); + public: DOMElement* factor(RefMyAST _t); + public: DOMElement* primary(RefMyAST _t); + public: DOMElement* component_reference__function_call(RefMyAST _t); + public: DOMElement* function_arguments(RefMyAST _t); + public: DOMElement* expression_list2(RefMyAST _t, + DOMElement *parent + ); + public: DOMElement* named_arguments(RefMyAST _t, + DOMElement *parent + ); + public: DOMElement* named_argument(RefMyAST _t); + public: DOMElement* subscript(RefMyAST _t, + DOMElement* parent + ); + public: DOMElement* string_concatenation(RefMyAST _t); + public: DOMElement* interactive_stmt(RefMyAST _t); +public: + ANTLR_USE_NAMESPACE(antlr)RefAST getAST() + { + return ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST); + } + +protected: + RefMyAST returnAST; + RefMyAST _retTree; +private: + static const char* tokenNames[]; +#ifndef NO_STATIC_CONSTS + static const int NUM_TOKENS = 151; +#else + enum { + NUM_TOKENS = 151 + }; +#endif + + static const unsigned long _tokenSet_0_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0; + static const unsigned long _tokenSet_1_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1; + static const unsigned long _tokenSet_2_data_[]; + static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2; +}; + +#endif /*INC_modelica_tree_parser_hpp_*/ diff --git a/tools/xml/modelicaxml/modelica_tree_parserTokenTypes.hpp b/tools/xml/modelicaxml/modelica_tree_parserTokenTypes.hpp new file mode 100644 index 00000000000..9411e1e3d7a --- /dev/null +++ b/tools/xml/modelicaxml/modelica_tree_parserTokenTypes.hpp @@ -0,0 +1,167 @@ +#ifndef INC_modelica_tree_parserTokenTypes_hpp_ +#define INC_modelica_tree_parserTokenTypes_hpp_ + +/* $ANTLR 2.7.5rc2 (20050108): "walker.g" -> "modelica_tree_parserTokenTypes.hpp"$ */ + +#ifndef CUSTOM_API +# define CUSTOM_API +#endif + +#ifdef __cplusplus +struct CUSTOM_API modelica_tree_parserTokenTypes { +#endif + enum { + EOF_ = 1, + ALGORITHM = 4, + AND = 5, + ANNOTATION = 6, + BLOCK = 7, + CODE = 8, + CLASS = 9, + CONNECT = 10, + CONNECTOR = 11, + CONSTANT = 12, + DISCRETE = 13, + DER = 14, + EACH = 15, + ELSE = 16, + ELSEIF = 17, + ELSEWHEN = 18, + END = 19, + ENUMERATION = 20, + EQUATION = 21, + ENCAPSULATED = 22, + EXPANDABLE = 23, + EXTENDS = 24, + EXTERNAL = 25, + FALSE = 26, + FINAL = 27, + FLOW = 28, + FOR = 29, + FUNCTION = 30, + IF = 31, + IMPORT = 32, + IN = 33, + INITIAL = 34, + INNER = 35, + INPUT = 36, + LOOP = 37, + MODEL = 38, + NOT = 39, + OUTER = 40, + OVERLOAD = 41, + OR = 42, + OUTPUT = 43, + PACKAGE = 44, + PARAMETER = 45, + PARTIAL = 46, + PROTECTED = 47, + PUBLIC = 48, + RECORD = 49, + REDECLARE = 50, + REPLACEABLE = 51, + RESULTS = 52, + THEN = 53, + TRUE = 54, + TYPE = 55, + UNSIGNED_REAL = 56, + DOT = 57, + WHEN = 58, + WHILE = 59, + WITHIN = 60, + LPAR = 61, + RPAR = 62, + LBRACK = 63, + RBRACK = 64, + LBRACE = 65, + RBRACE = 66, + EQUALS = 67, + ASSIGN = 68, + PLUS = 69, + MINUS = 70, + STAR = 71, + SLASH = 72, + COMMA = 73, + LESS = 74, + LESSEQ = 75, + GREATER = 76, + GREATEREQ = 77, + EQEQ = 78, + LESSGT = 79, + COLON = 80, + SEMICOLON = 81, + POWER = 82, + YIELDS = 83, + AMPERSAND = 84, + PIPEBAR = 85, + COLONCOLON = 86, + DASHES = 87, + WS = 88, + ML_COMMENT = 89, + ML_COMMENT_CHAR = 90, + SL_COMMENT = 91, + IDENT = 92, + QIDENT = 93, + NONDIGIT = 94, + DIGIT = 95, + EXPONENT = 96, + UNSIGNED_INTEGER = 97, + STRING = 98, + SCHAR = 99, + QCHAR = 100, + SESCAPE = 101, + ESC = 102, + ALGORITHM_STATEMENT = 103, + ARGUMENT_LIST = 104, + BEGIN_DEFINITION = 105, + CLASS_DEFINITION = 106, + CLASS_EXTENDS = 107, + CLASS_MODIFICATION = 108, + CODE_EXPRESSION = 109, + CODE_MODIFICATION = 110, + CODE_ELEMENT = 111, + CODE_EQUATION = 112, + CODE_INITIALEQUATION = 113, + CODE_ALGORITHM = 114, + CODE_INITIALALGORITHM = 115, + COMMENT = 116, + COMPONENT_DEFINITION = 117, + DECLARATION = 118, + DEFINITION = 119, + END_DEFINITION = 120, + ENUMERATION_LITERAL = 121, + ELEMENT = 122, + ELEMENT_MODIFICATION = 123, + ELEMENT_REDECLARATION = 124, + EQUATION_STATEMENT = 125, + EXTERNAL_ANNOTATION = 126, + INITIAL_EQUATION = 127, + INITIAL_ALGORITHM = 128, + IMPORT_DEFINITION = 129, + IDENT_LIST = 130, + EXPRESSION_LIST = 131, + EXTERNAL_FUNCTION_CALL = 132, + FOR_INDICES = 133, + FOR_ITERATOR = 134, + FUNCTION_CALL = 135, + INITIAL_FUNCTION_CALL = 136, + FUNCTION_ARGUMENTS = 137, + NAMED_ARGUMENTS = 138, + QUALIFIED = 139, + RANGE2 = 140, + RANGE3 = 141, + STORED_DEFINITION = 142, + STRING_COMMENT = 143, + UNARY_MINUS = 144, + UNARY_PLUS = 145, + UNQUALIFIED = 146, + INTERACTIVE_STMT = 147, + INTERACTIVE_ALG = 148, + INTERACTIVE_EXP = 149, + REDELCARE = 150, + NULL_TREE_LOOKAHEAD = 3 + }; +#ifdef __cplusplus +}; +#endif +#endif /*INC_modelica_tree_parserTokenTypes_hpp_*/ diff --git a/tools/xml/modelicaxml/modelica_tree_parserTokenTypes.txt b/tools/xml/modelicaxml/modelica_tree_parserTokenTypes.txt new file mode 100644 index 00000000000..e973b12cd80 --- /dev/null +++ b/tools/xml/modelicaxml/modelica_tree_parserTokenTypes.txt @@ -0,0 +1,149 @@ +// $ANTLR 2.7.5rc2 (20050108): walker.g -> modelica_tree_parserTokenTypes.txt$ +modelica_tree_parser // output token vocab name +ALGORITHM="algorithm"=4 +AND="and"=5 +ANNOTATION="annotation"=6 +BLOCK="block"=7 +CODE="Code"=8 +CLASS="class"=9 +CONNECT="connect"=10 +CONNECTOR="connector"=11 +CONSTANT="constant"=12 +DISCRETE="discrete"=13 +DER="der"=14 +EACH="each"=15 +ELSE="else"=16 +ELSEIF="elseif"=17 +ELSEWHEN="elsewhen"=18 +END="end"=19 +ENUMERATION="enumeration"=20 +EQUATION="equation"=21 +ENCAPSULATED="encapsulated"=22 +EXPANDABLE="expandable"=23 +EXTENDS="extends"=24 +EXTERNAL="external"=25 +FALSE="false"=26 +FINAL="final"=27 +FLOW="flow"=28 +FOR="for"=29 +FUNCTION="function"=30 +IF="if"=31 +IMPORT="import"=32 +IN="in"=33 +INITIAL="initial"=34 +INNER="inner"=35 +INPUT="input"=36 +LOOP="loop"=37 +MODEL="model"=38 +NOT="not"=39 +OUTER="outer"=40 +OVERLOAD="overload"=41 +OR="or"=42 +OUTPUT="output"=43 +PACKAGE="package"=44 +PARAMETER="parameter"=45 +PARTIAL="partial"=46 +PROTECTED="protected"=47 +PUBLIC="public"=48 +RECORD="record"=49 +REDECLARE="redeclare"=50 +REPLACEABLE="replaceable"=51 +RESULTS="results"=52 +THEN="then"=53 +TRUE="true"=54 +TYPE="type"=55 +UNSIGNED_REAL="unsigned_real"=56 +DOT="."=57 +WHEN="when"=58 +WHILE="while"=59 +WITHIN="within"=60 +LPAR=61 +RPAR=62 +LBRACK=63 +RBRACK=64 +LBRACE=65 +RBRACE=66 +EQUALS=67 +ASSIGN=68 +PLUS=69 +MINUS=70 +STAR=71 +SLASH=72 +COMMA=73 +LESS=74 +LESSEQ=75 +GREATER=76 +GREATEREQ=77 +EQEQ=78 +LESSGT=79 +COLON=80 +SEMICOLON=81 +POWER=82 +YIELDS=83 +AMPERSAND=84 +PIPEBAR=85 +COLONCOLON=86 +DASHES=87 +WS=88 +ML_COMMENT=89 +ML_COMMENT_CHAR=90 +SL_COMMENT=91 +IDENT("an identifier")=92 +QIDENT("an identifier")=93 +NONDIGIT=94 +DIGIT=95 +EXPONENT=96 +UNSIGNED_INTEGER=97 +STRING=98 +SCHAR=99 +QCHAR=100 +SESCAPE=101 +ESC=102 +ALGORITHM_STATEMENT=103 +ARGUMENT_LIST=104 +BEGIN_DEFINITION=105 +CLASS_DEFINITION=106 +CLASS_EXTENDS=107 +CLASS_MODIFICATION=108 +CODE_EXPRESSION=109 +CODE_MODIFICATION=110 +CODE_ELEMENT=111 +CODE_EQUATION=112 +CODE_INITIALEQUATION=113 +CODE_ALGORITHM=114 +CODE_INITIALALGORITHM=115 +COMMENT=116 +COMPONENT_DEFINITION=117 +DECLARATION=118 +DEFINITION=119 +END_DEFINITION=120 +ENUMERATION_LITERAL=121 +ELEMENT=122 +ELEMENT_MODIFICATION=123 +ELEMENT_REDECLARATION=124 +EQUATION_STATEMENT=125 +EXTERNAL_ANNOTATION=126 +INITIAL_EQUATION=127 +INITIAL_ALGORITHM=128 +IMPORT_DEFINITION=129 +IDENT_LIST=130 +EXPRESSION_LIST=131 +EXTERNAL_FUNCTION_CALL=132 +FOR_INDICES=133 +FOR_ITERATOR=134 +FUNCTION_CALL=135 +INITIAL_FUNCTION_CALL=136 +FUNCTION_ARGUMENTS=137 +NAMED_ARGUMENTS=138 +QUALIFIED=139 +RANGE2=140 +RANGE3=141 +STORED_DEFINITION=142 +STRING_COMMENT=143 +UNARY_MINUS=144 +UNARY_PLUS=145 +UNQUALIFIED=146 +INTERACTIVE_STMT=147 +INTERACTIVE_ALG=148 +INTERACTIVE_EXP=149 +REDELCARE=150 diff --git a/tools/xml/modelicaxml/modelicaxml-v2.dtd b/tools/xml/modelicaxml/modelicaxml-v2.dtd new file mode 100644 index 00000000000..750e2adb520 --- /dev/null +++ b/tools/xml/modelicaxml/modelicaxml-v2.dtd @@ -0,0 +1,538 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tools/xml/modelicaxml/parse_tree_dumper.cpp b/tools/xml/modelicaxml/parse_tree_dumper.cpp new file mode 100644 index 00000000000..a524f15c8f9 --- /dev/null +++ b/tools/xml/modelicaxml/parse_tree_dumper.cpp @@ -0,0 +1,10 @@ + +#include "parse_tree_dumper.hpp" + + + +char parse_tree_dumper::c1 = '|'; +char parse_tree_dumper::c2 = ' '; +char parse_tree_dumper::c; +char parse_tree_dumper::prefix[] = "+-"; +int parse_tree_dumper::indentSize = 2; diff --git a/tools/xml/modelicaxml/parse_tree_dumper.hpp b/tools/xml/modelicaxml/parse_tree_dumper.hpp new file mode 100644 index 00000000000..d2c3602bda0 --- /dev/null +++ b/tools/xml/modelicaxml/parse_tree_dumper.hpp @@ -0,0 +1,108 @@ +#ifndef PARSE_TREE_DUMPER_H_ +#define PARSE_TREE_DUMPER_H_ + +#include "antlr/CommonAST.hpp" +#include +#include "MyAST.h" + +class parse_tree_dumper +{ +private: + int fIndent; + static char c1; + static char c2; + + static char c; + static char prefix[]; + + static int indentSize; + + std::ostream &out; + +public: + parse_tree_dumper(std::ostream& os) : out(os){ + fIndent = 0; + } + + void flush() + { + out.flush(); + } + + void toIndent() + { + if (fIndent <= 0) + return; + for (int i=0; i"; + } + else + { + out << ast->toString(); + if (ast->getFirstChild() != 0) + { + out << " {" << std::endl; + indent(indentSize); + dump( RefMyAST(ast->getFirstChild()) ); + indent(-indentSize); + toIndent(); + out << "}" << std::endl; + } + else + { + out << std::endl; + } + if (ast->getNextSibling() != 0) + { + dump(RefMyAST(ast->getNextSibling())); + } + } + } + void dump_dot(RefMyAST ast) + { + out << "digraph G {\n"; + dump_dot_recursive(ast); + out << "}\n"; + } + + void dump_dot_recursive(RefMyAST ast) + { + if (ast == 0) + { + out << "\n"; + } + else + { + out << "\"" << ast.get() << "\" [label=\"" << ast->toString() << "\" shape=\"box\"];\n"; + RefMyAST current_ast = RefMyAST(ast->getFirstChild()); + + while (current_ast != 0) + { + dump_dot_recursive(current_ast); + out << "\t\"" << ast.get() << "\" -> \"" << current_ast.get() << "\";\n"; + + current_ast = current_ast->getNextSibling(); + } + } + } + +}; + +#endif diff --git a/tools/xml/modelicaxml/test.cpp b/tools/xml/modelicaxml/test.cpp new file mode 100644 index 00000000000..3d2390b4cf9 --- /dev/null +++ b/tools/xml/modelicaxml/test.cpp @@ -0,0 +1,37 @@ +#include +#include +#include "modelica_lexer.hpp" +#include "modelica_parser.hpp" +#include +#include "parse_tree_dumper.hpp" + +using namespace std; + + +int main(int argc, char **argv) { + + if (argc != 2) { + cerr << "Usage: " << argv[0] << " filename" << endl; + exit(1); + } + + ifstream is(argv[1]); + if (!is) { + cerr << "File \"" << argv[1] << "\" not found." << endl; + exit(1); + } + + modelica_lexer lexer(is); + lexer.setFilename(argv[1]); + modelica_parser parser(lexer); + parser.setFilename(argv[1]); + + antlr::ASTFactory ast_factory; + parser.initializeASTFactory(ast_factory); + parser.setASTFactory(&ast_factory); + + parser.stored_definition(); + RefMyAST ast = RefMyAST(parser.getAST()); + parse_tree_dumper dumper(cout); + dumper.dump(ast); +} diff --git a/tools/xml/modelicaxml/token_names.cpp b/tools/xml/modelicaxml/token_names.cpp new file mode 100644 index 00000000000..d172d645322 --- /dev/null +++ b/tools/xml/modelicaxml/token_names.cpp @@ -0,0 +1,79 @@ + +#include "token_names.hpp" +#include + +void token_names::read_token_names(std::istream& is) +{ + m_names.clear(); + std::string str; + int lineno=0; + + while (!is.eof()) + { + std::getline(is, str); + lineno++; + try + { + // cout << getId(str) << " = " << getName(str) << endl; + int id = extract_id(str); + m_names[id] = extract_name(str); + } + catch(int a) + { + // ignore the line, = was not found + //std::cerr << "ignoring line: " << lineno << std::endl; + } + } + +} + +int token_names::extract_id(const std::string& str) const +{ + std::string::size_type pos; + pos = str.rfind('='); + if (pos != std::string::npos) + { + return atoi(str.substr(pos+1).c_str()); + } + else + { + throw -1; + } +} + +std::string token_names::extract_name(const std::string& str) const +{ + std::string::size_type pos1, pos2; + pos1 = str.find('='); + pos2 = str.rfind('='); + if (pos1 == std::string::npos) + { + throw -1; + } + else + { + return str.substr(0,pos1); + } +} + +std::string token_names::extract_text(const std::string& str) const +{ + std::string::size_type pos1, pos2; + pos1 = str.find('='); + pos2 = str.rfind('='); + if (pos1 == std::string::npos) + { + throw -1; + } + else + { + if (pos1 == pos2) + { + return str.substr(0,pos1); + } + else + { + return str.substr(pos1+2,pos2-pos1-3); // 2 and 3 because of "" + } + } +} diff --git a/tools/xml/modelicaxml/token_names.hpp b/tools/xml/modelicaxml/token_names.hpp new file mode 100644 index 00000000000..50cd73bd658 --- /dev/null +++ b/tools/xml/modelicaxml/token_names.hpp @@ -0,0 +1,56 @@ +#ifndef TOKEN_NAMES_H_ +#define TOKEN_NAMES_H_ + +#include +#include +#include + +class token_names { + +public: + typedef std::map id_name_map; + typedef id_name_map::iterator iterator; + +public: + token_names() { } + + token_names(std::istream& is) + { + read_token_names(is); + } + + std::string& name(int i) + { + return m_names[i]; + } + + iterator begin() + { + return m_names.begin(); + } + + iterator end() + { + return m_names.end(); + } + + void add_name(int i, std::string const& s) + { + m_names[i] = s; + } + + void read_token_names(std::istream& is); + +private: + int extract_id(const std::string& str) const; + std::string extract_name(std::string const& str) const; + std::string extract_text(std::string const& str) const; + +private: + id_name_map m_names; + +}; + + + +#endif diff --git a/tools/xml/modelicaxml/walker.g b/tools/xml/modelicaxml/walker.g new file mode 100644 index 00000000000..e3736b19372 --- /dev/null +++ b/tools/xml/modelicaxml/walker.g @@ -0,0 +1,2701 @@ +header "pre_include_hpp" +{ +// adrpo disabling warnings +#pragma warning( disable : 4267) // Disable warning messages C4267 +// disable: 'initializing' : conversion from 'size_t' to 'int', possible loss of data + +#pragma warning( disable : 4231) // Disable warning messages C4231 +// disable: nonstandard extension used : 'extern' before template explicit instantiation + +#pragma warning( disable : 4101) // Disable warning messages C4101 +// disable: warning C4101: 'pe' : unreferenced local variable +} + +header "post_include_hpp" +{ +/************************************************************************ +File: walker.g +Created By: Adrian Pop adrpo@ida.liu.se +Date: 2003-06-10 +Revised on 2003-10-26 17:58:42 (write the definition even if has no childs) +Comments: we walk on the modelica tree, buil a XML DOM tree and serialize +************************************************************************/ + + #define null 0 + + extern "C" + { + #include + } + + #include + #include + #include + #include + +#ifndef __MODELICAXML_H_ +#include "ModelicaXml.h" +#endif + +#include "MyAST.h" + +typedef ANTLR_USE_NAMESPACE(antlr)ASTRefCount RefMyAST; + +} + +header "post_include_cpp" +{ +} + + +options +{ + language = "Cpp"; +} + + +class modelica_tree_parser extends TreeParser; + +options +{ + importVocab = modelica_parser; + k = 2; + buildAST = true; + defaultErrorHandler = false; + ASTLabelType = "RefMyAST"; +} + +tokens +{ + INTERACTIVE_STMT; + INTERACTIVE_ALG; + INTERACTIVE_EXP; +} +{ + + /* some xml helpers declarations */ + DOMDocument* pModelicaXMLDoc; + DOMElement* pRootElementModelicaXML; + char stmp[500]; + + + typedef std::deque l_stack; + typedef std::string mstring; + enum anno {UNSPECIFIED, INSIDE_EXTERNAL, INSIDE_ELEMENT, INSIDE_EQUATION, INSIDE_ALGORITHM, INSIDE_COMMENT}; + + const XMLCh* str2xml(RefMyAST node) + { + return XMLString::transcode(node->getText().c_str()); + } + + DOMElement* stack2DOMNode(l_stack& s, mstring name) + { + DOMElement *pHoldingNode = pModelicaXMLDoc->createElement(X(name.c_str())); + std::deque::reverse_iterator itList; + for (itList=s.rbegin(); itList!=s.rend(); ++itList) + { + pHoldingNode->appendChild((DOMElement*)*itList); + } + return pHoldingNode; + } + + DOMElement* appendKids(l_stack& s, DOMElement* pParentNode) + { + std::deque::reverse_iterator itList; + for (itList=s.rbegin(); itList!=s.rend(); ++itList) + { + pParentNode->appendChild((DOMElement*)*itList); + } + return pParentNode; + } + + DOMElement* appendKidsFromStack(l_stack* s, DOMElement* pParentNode) + { + std::deque::reverse_iterator itList; + for (itList=s->rbegin(); itList!=s->rend(); ++itList) + { + pParentNode->appendChild((DOMElement*)*itList); + } + delete s; + return pParentNode; + } + + void setAttributes(DOMElement *pNodeTo, DOMElement *pNodeFrom) + { + DOMNamedNodeMap *pAttributes = pNodeFrom->getAttributes(); + for (XMLSize_t i=0; i < pAttributes->getLength(); i++) + { + DOMAttr *z = (DOMAttr*)pAttributes->item(i); + pNodeTo->setAttribute(z->getName(), z->getValue()); + } + } + + struct type_prefix_t + { + type_prefix_t():flow(0), variability(0),direction(0){} + DOMElement* flow; + DOMElement* variability; + DOMElement* direction; + }; + + struct class_specifier_t + { + class_specifier_t():string_comment(0), composition(0), enumeration(0), derived(0), overload(0), pder(0), classExtends(0){} + DOMElement* string_comment; + DOMElement *composition; + DOMElement* derived; + DOMElement* enumeration; + DOMElement* overload; + DOMElement* pder; + DOMElement* classExtends; + }; + + DOMAttr* getAttributeNode(DOMElement* pNode, mstring stdstr) + { + return ((DOMElement*)pNode)->getAttributeNode(X(stdstr.c_str())); + } + + + void setVisibility(int iSwitch, DOMElement* pNode) + { + if (iSwitch == 1) pNode->setAttribute(X("visibility"), X("public")); + else if (iSwitch == 2) pNode->setAttribute(X("visibility"), X("protected")); + else { /* error, shouldn't happen */ } + } +} + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##modelicaxml +*/ +stored_definition [mstring moFilename, DOMDocument* pModelicaXMLDocParam] returns [DOMElement *ast] +{ + DOMElement *within = 0; + l_stack el_stack; + pModelicaXMLDoc = pModelicaXMLDocParam; + + pRootElementModelicaXML = pModelicaXMLDoc->createElement(X("modelicaxml")); + // set the location of the .mo file we're representing in XML + pRootElementModelicaXML->setAttribute(X("file"), X(moFilename.c_str())); + + DOMElement* pDefinitionElement = 0; +} + : + #(STORED_DEFINITION + ( pRootElementModelicaXML = within_clause[pRootElementModelicaXML] )? + ((f:FINAL )? { pDefinitionElement = pModelicaXMLDoc->createElement(X("definition")); } + pDefinitionElement = class_definition[f != NULL, pDefinitionElement] + { + if (pDefinitionElement /* adrpo modified 2004-10-27 && pDefinitionElement->hasChildNodes()*/) + { + el_stack.push_back(pDefinitionElement); + } + } + )* + ) + { + //pRootElementModelicaXML = within; + pRootElementModelicaXML = (DOMElement*)appendKids(el_stack, pRootElementModelicaXML); + ast = pRootElementModelicaXML; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##modelicaxml +*/ +within_clause[DOMElement* parent] returns [DOMElement* ast] +{ + void* pNamePath = 0; +} + : #(WITHIN (pNamePath = name_path)?) + { + if (pNamePath) parent->setAttribute(X("within"), X(((mstring *)pNamePath)->c_str())); + ast = parent; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##definition +*/ +class_definition [bool final, DOMElement *definitionElement] returns [DOMElement* ast] +{ + class_specifier_t sClassSpec; + sClassSpec.composition = definitionElement; +} +: #(cd:CLASS_DEFINITION + (e:ENCAPSULATED )? + (p:PARTIAL )? + (ex:EXPANDABLE)? + (r:class_restriction) + (i:IDENT)? + class_specifier[sClassSpec] { definitionElement=sClassSpec.composition; } + ) + { + definitionElement->setAttribute( + X("ident"), + X(i?i->getText().c_str():"_EXTENDED_")); + definitionElement->setAttribute(X("sline"), X(itoa(cd->getLine(),stmp,10))); + definitionElement->setAttribute(X("scolumn"), X(itoa(cd->getColumn(),stmp,10))); + + if (p != 0) definitionElement->setAttribute(X("partial"), X("true")); + if (final) definitionElement->setAttribute(X("final"), X("true")); + if (e != 0) definitionElement->setAttribute(X("encapsulated"), X("true")); + if (ex) definitionElement->setAttribute(X("restriction"), X("expandable")); + if (r) definitionElement->setAttribute(X("restriction"), str2xml(r)); + if (sClassSpec.string_comment) + { + definitionElement->appendChild(sClassSpec.string_comment); + } + if (sClassSpec.composition) + { + // nothing to do, already done at the lower level. + //definitionElement->appendChild(sClassSpec.composition); + //appendKids(definitionElement, sClassSpec.composition); + } + if (sClassSpec.derived) + { + definitionElement->appendChild(sClassSpec.derived); + } + if (sClassSpec.enumeration) + { + definitionElement->appendChild(sClassSpec.enumeration); + } + if (sClassSpec.overload) + { + definitionElement->appendChild(sClassSpec.overload); + } + if (sClassSpec.pder) + { + definitionElement->appendChild(sClassSpec.pder); + } + if (sClassSpec.classExtends) + { + definitionElement->appendChild(sClassSpec.classExtends); + } + ast = definitionElement; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##definition +see restriction +*/ +class_restriction /* returns [DOMElement* ast] */ + : + ( CLASS /*{ ast = Absyn__R_5fCLASS; }*/ + | MODEL /*{ ast = Absyn__R_5fMODEL; }*/ + | RECORD /*{ ast = Absyn__R_5fRECORD; }*/ + | BLOCK /*{ ast = Absyn__R_5fBLOCK; }*/ + | CONNECTOR /*{ ast = Absyn__R_5fCONNECTOR; }*/ + | TYPE /*{ ast = Absyn__R_5fTYPE; }*/ + | PACKAGE /*{ ast = Absyn__R_5fPACKAGE; }*/ + | FUNCTION /*{ ast = Absyn__R_5fFUNCTION; }*/ + ) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##class_specifier +*/ +/* ([comment] + composition | derived | enumeration | overloading)*/ +class_specifier [class_specifier_t& sClassSpec] +{ + DOMElement *comp = 0; + DOMElement *cmt = 0; + DOMElement *d = 0; + DOMElement *e = 0; + DOMElement *o = 0; + DOMElement *p = 0; + void *cmod = 0; +} + : + ( (cmt = string_comment) + comp = composition[sClassSpec.composition] + { + if (cmt) sClassSpec.string_comment = cmt; + sClassSpec.composition = comp; + } + ) + | #(EQUALS + ( + d = derived_class | + e = enumeration | + o = overloading | + p = pder)) + { + sClassSpec.derived = d; + sClassSpec.enumeration = e; + sClassSpec.overload = o; + sClassSpec.pder = p; + } + | #(CLASS_EXTENDS i:IDENT (cmod = class_modification)? + { + sClassSpec.classExtends = pModelicaXMLDoc->createElement(X("extended_class")); + if (cmod) sClassSpec.classExtends = + (DOMElement*)appendKidsFromStack((l_stack *)cmod, sClassSpec.classExtends); + } + cmt = string_comment comp = composition[sClassSpec.classExtends]) + { + sClassSpec.classExtends = pModelicaXMLDoc->createElement(X("extended_class")); + if (cmt) sClassSpec.classExtends->appendChild(cmt); + sClassSpec.classExtends->setAttribute( + X("ident"), + X(i->getText().c_str())); + } + ; + +pder returns [DOMElement* ast] +{ + void* func=0; + DOMElement* var_lst=0; +} + : #(DER func = name_path var_lst = ident_list) + { + ast = pModelicaXMLDoc->createElement(X("pder")); + if (func) ast->setAttribute(X("type"), X(((mstring*)func)->c_str())); + ast->appendChild(var_lst); + } + ; + +ident_list returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* pIdent = 0; +} + : #(IDENT_LIST + (i:IDENT + { + pIdent = pModelicaXMLDoc->createElement(X("pder_var")); + pIdent->setAttribute(X("ident"), X(i->getText().c_str())); + el_stack.push_back(pIdent); + } ) + (i2:IDENT + { + pIdent = pModelicaXMLDoc->createElement(X("pder_var")); + pIdent->setAttribute(X("ident"), X(i2->getText().c_str())); + el_stack.push_back(pIdent); + } )* + ) + { + + DOMElement* pIdentList = pModelicaXMLDoc->createElement(X("variables")); + pIdentList = (DOMElement*)appendKids(el_stack, pIdentList); + ast = pIdentList; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##derived +*/ +derived_class returns [DOMElement* ast] +{ + void* p = 0; + DOMElement* as = 0; + void *cmod = 0; + DOMElement* cmt = 0; + DOMElement* attr = 0; + type_prefix_t pfx; + DOMElement* pDerived = pModelicaXMLDoc->createElement(X("derived")); +} + : + ( type_prefix[pDerived] + p = name_path + ( as = array_subscripts[0] )? + ( cmod = class_modification )? + (cmt = comment)? + { + if (p) pDerived->setAttribute(X("type"), X(((mstring*)p)->c_str())); + if (as) pDerived->appendChild(as); + if (cmod) pDerived = (DOMElement*)appendKidsFromStack((l_stack *)cmod, pDerived); + if (cmt) pDerived->appendChild(cmt); + ast = pDerived; + } + ) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##enumeration +*/ +enumeration returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* el = 0; + DOMElement* cmt = 0; +} + : + #(en:ENUMERATION + ((el = enumeration_literal + { el_stack.push_back(el); } + ( + el = enumeration_literal + { el_stack.push_back(el); } + + )*) + | + c:COLON + ) + (cmt=comment)? + ) + { + DOMElement* pEnumeration = pModelicaXMLDoc->createElement(X("enumeration")); + pEnumeration->setAttribute(X("sline"), X(itoa(en->getLine(),stmp,10))); + pEnumeration->setAttribute(X("scolumn"), X(itoa(en->getColumn(),stmp,10))); + if (c) + { + pEnumeration->setAttribute(X("colon"), X("true")); + } + else + { + pEnumeration = (DOMElement*)appendKids(el_stack, pEnumeration); + } + if (cmt) pEnumeration->appendChild(cmt); + ast = pEnumeration; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##enumeration_literal +*/ + +enumeration_literal returns [DOMElement* ast] : +{ + DOMElement* c1=0; +} + #(ENUMERATION_LITERAL i1:IDENT (c1=comment)?) + { + DOMElement* pEnumerationLiteral = pModelicaXMLDoc->createElement(X("enumeration_literal")); + pEnumerationLiteral->setAttribute(X("ident"), str2xml(i1)); + + pEnumerationLiteral->setAttribute(X("sline"), X(itoa(i1->getLine(),stmp,10))); + pEnumerationLiteral->setAttribute(X("scolumn"), X(itoa(i1->getColumn(),stmp,10))); + + if (c1) pEnumerationLiteral->appendChild(c1); + ast = pEnumerationLiteral; + } + ; + +/* +Overloading is used internaly in the OpenModelica. +It shouldn't appear in the normal use of the ModelicaXML. +We leave it here for the future. +*/ +overloading returns [DOMElement* ast] +{ + std::deque el_stack; + void* el = 0; + DOMElement* cmt = 0; +} + : + #(ov:OVERLOAD + el = name_path + { el_stack.push_back(el); } + ( + el = name_path + { el_stack.push_back(el); } + + )* + (cmt=comment)? + ) + { + DOMElement* pOverload = pModelicaXMLDoc->createElement(X("overload")); + if (cmt) pOverload->appendChild(cmt); + + pOverload->setAttribute(X("sline"), X(itoa(ov->getLine(),stmp,10))); + pOverload->setAttribute(X("scolumn"), X(itoa(ov->getColumn(),stmp,10))); + + ast = pOverload; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##elements +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##composition +*/ +composition [DOMElement* definition] returns [DOMElement* ast] +{ + DOMElement* el = 0; + l_stack el_stack; + DOMElement* ann; + DOMElement* pExternalFunctionCall = 0; +} + : + definition = element_list[1 /* public */, definition] + ( + ( + definition = public_element_list[definition] + | definition = protected_element_list[definition] + | definition = equation_clause[definition] + | definition = algorithm_clause[definition] + ) + )* + ( #(EXTERNAL { pExternalFunctionCall = pModelicaXMLDoc->createElement(X("external")); } + ( pExternalFunctionCall = external_function_call[pExternalFunctionCall]) + (pExternalFunctionCall = annotation[0 /*none*/, pExternalFunctionCall, INSIDE_EXTERNAL])? + ( + { pExternalFunctionCall->appendChild(pModelicaXMLDoc->createElement(X("semicolon"))); } + #(EXTERNAL_ANNOTATION pExternalFunctionCall = annotation[0 /*none*/, pExternalFunctionCall, INSIDE_EXTERNAL]) + )* + ) + )? + { + if (pExternalFunctionCall) definition->appendChild(pExternalFunctionCall); + ast = definition; + } + ; + +public_element_list[DOMElement* definition] returns [DOMElement* ast] +{ + DOMElement* el; +} + : + #(p:PUBLIC + definition = element_list[1 /* public */, definition] + ) + { + ast = definition; + } + ; + +protected_element_list[DOMElement* definition] returns [DOMElement* ast] +{ + DOMElement* el; +} + : + + #(p:PROTECTED + definition = element_list[2 /* protected */, definition] + ) + { + ast = definition; + } + ; + +/* + + +*/ + +external_function_call[DOMElement *pExternalFunctionCall] returns [DOMElement* ast] +{ + DOMElement* temp=0; + DOMElement* temp2=0; + DOMElement* temp3=0; + ast = 0; + DOMElement* pExternalEqual = pModelicaXMLDoc->createElement(X("external_equal")); +} + : + (s:STRING)? + (#(EXTERNAL_FUNCTION_CALL + ( + (i:IDENT (temp = expression_list)?) + { + if (s != NULL) pExternalFunctionCall->setAttribute(X("language_specification"), str2xml(s)); + if (i != NULL) pExternalFunctionCall->setAttribute(X("ident"), str2xml(i)); + if (temp) pExternalFunctionCall->appendChild(temp); + + pExternalFunctionCall->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pExternalFunctionCall->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pExternalFunctionCall; + } + | #(e:EQUALS temp2 = component_reference i2:IDENT ( temp3 = expression_list)?) + { + if (s != NULL) pExternalFunctionCall->setAttribute(X("language_specification"), str2xml(s)); + if (i2 != NULL) pExternalFunctionCall->setAttribute(X("ident"), str2xml(i2)); + pExternalFunctionCall->setAttribute(X("sline"), X(itoa(i2->getLine(),stmp,10))); + pExternalFunctionCall->setAttribute(X("scolumn"), X(itoa(i2->getColumn(),stmp,10))); + DOMElement* pExternalEqual = + pModelicaXMLDoc->createElement(X("external_equal")); + if (temp2) pExternalEqual->appendChild(temp2); + pExternalFunctionCall->appendChild(pExternalEqual); + if (temp3) pExternalFunctionCall->appendChild(temp3); + ast = pExternalFunctionCall; + } + ) + ))? + { + if (!ast) + { + //parent->appendChild(ast); + ast = pExternalFunctionCall; + } + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##elements + + @HACK @FIXME add an enumeration type + parameter iSwitch: + 1 public element + 2 protected element +*/ + +element_list[int iSwitch, DOMElement*definition] returns [DOMElement* ast] +{ + DOMElement* e = 0; + l_stack el_stack; + DOMElement* ann = 0; +} + : + ((definition = element[iSwitch, definition]) + |(definition = annotation[iSwitch, definition, INSIDE_ELEMENT]))* + { + ast = definition; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##elements +*/ + +element[int iSwitch, DOMElement *parent] returns [DOMElement* ast] +{ + DOMElement* class_def = 0; + DOMElement* e_spec = 0; + DOMElement* final = 0; + DOMElement* innerouter = 0; + DOMElement* constr = 0; + DOMElement* cmt = 0; + DOMElement* comp_clause = 0; +} + : + ( parent = import_clause[iSwitch, parent] + { + ast = parent; + } + | parent = extends_clause[iSwitch, parent] + { + ast = parent; + } + | #(DECLARATION + ( (re:REDELCARE)? + { + DOMElement* componentElement = pModelicaXMLDoc->createElement(X("component_clause")); + setVisibility(iSwitch, componentElement); + if (re) componentElement->setAttribute(X("redeclare"), X("true")); + } + (f:FINAL)? { if (f) componentElement->setAttribute(X("final"), X("true")); } + (i:INNER)? (o:OUTER)? + { + if (i && o) componentElement->setAttribute(X("innerouter"), X("innerouter")); + else + { + if (i) componentElement->setAttribute(X("innerouter"), X("inner")); + if (o) componentElement->setAttribute(X("innerouter"), X("outer")); + } + } + (parent = component_clause[parent, componentElement] + { + ast = parent; + } + | r:REPLACEABLE {if (r) componentElement->setAttribute(X("replaceable"), X("true"));} + parent = component_clause[parent, componentElement] + (constr = constraining_clause cmt=comment)? + { + if (constr) + { + // append the comment to the constraint + if (cmt) ((DOMElement*)constr)->appendChild(cmt); + parent->appendChild(constr); + } + ast = parent; + } + ) + ) + ) + | #(DEFINITION + ( (re2:REDECLARE)? + { + DOMElement* definitionElement = pModelicaXMLDoc->createElement(X("definition")); + setVisibility(iSwitch, definitionElement); + if (re2) definitionElement->setAttribute(X("redeclare"), X("true")); + } + (fd:FINAL)? { if (fd) definitionElement->setAttribute(X("final"), X("true")); } + (id:INNER)? (od:OUTER)? + { + if (i && o) definitionElement->setAttribute(X("innerouter"), X("outer")); + else + { + if (i) definitionElement->setAttribute(X("innerouter"), X("inner")); + if (o) definitionElement->setAttribute(X("innerouter"), X("outer")); + } + } + ( + definitionElement = class_definition[fd != NULL, definitionElement] + { + if (definitionElement && definitionElement->hasChildNodes()) + parent->appendChild(definitionElement); + ast = parent; + } + | + (rd:REPLACEABLE + definitionElement = class_definition[fd != NULL, definitionElement] + (constr = constraining_clause cmt=comment)? + ) + { + if (definitionElement) + { + if (innerouter) definitionElement->appendChild(innerouter); + if (constr) + { + definitionElement->appendChild(constr); + // append the comment to the constraint + if (cmt) ((DOMElement*)constr)->appendChild(cmt); + } + if (rd) definitionElement->setAttribute(X("replaceable"), X("true")); + if (definitionElement->hasChildNodes()) + parent->appendChild(definitionElement); + } + ast = parent; + } + ) + ) + ) + ) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##import +*/ +import_clause[int iSwitch, DOMElement *parent] returns [DOMElement* ast] +{ + DOMElement* imp = 0; + DOMElement* cmt = 0; +} + : + #(i:IMPORT + (imp = explicit_import_name + |imp = implicit_import_name + ) + (cmt = comment)? + ) + { + DOMElement* pImport = pModelicaXMLDoc->createElement(X("import")); + setVisibility(iSwitch, pImport); + + pImport->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pImport->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pImport->appendChild(imp); + if (cmt) pImport->appendChild(cmt); + parent->appendChild(pImport); + ast = parent; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##import +*/ +explicit_import_name returns [DOMElement* ast] +{ + void* path; +} + : + #(EQUALS i:IDENT path = name_path) + { + DOMElement* pExplicitImport = pModelicaXMLDoc->createElement(X("named_import")); + pExplicitImport->setAttribute(X("ident"), str2xml(i)); + + pExplicitImport->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pExplicitImport->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (path) pExplicitImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + ast = pExplicitImport; + } + ; +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##import +*/ +implicit_import_name returns [DOMElement* ast] +{ + void* path; +} + : + (#(unq:UNQUALIFIED path = name_path) + { + DOMElement* pUnqImport = pModelicaXMLDoc->createElement(X("unqualified_import")); + if (path) pUnqImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + + pUnqImport->setAttribute(X("sline"), X(itoa(unq->getLine(),stmp,10))); + pUnqImport->setAttribute(X("scolumn"), X(itoa(unq->getColumn(),stmp,10))); + + ast = pUnqImport; + } + |#(qua:QUALIFIED path = name_path) + { + DOMElement* pQuaImport = pModelicaXMLDoc->createElement(X("qualified_import")); + if (path) pQuaImport->setAttribute(X("name"), X(((mstring*)path)->c_str())); + + pQuaImport->setAttribute(X("sline"), X(itoa(qua->getLine(),stmp,10))); + pQuaImport->setAttribute(X("scolumn"), X(itoa(qua->getColumn(),stmp,10))); + + ast = pQuaImport; + } + ) + ; + + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##extends +*/ +extends_clause[int iSwitch, DOMElement* parent] returns [DOMElement* ast] +{ + void *path = 0; + void *mod = 0; +} + : + (#(e:EXTENDS + path = name_path + ( mod = class_modification)? + ) + { + DOMElement* pExtends = pModelicaXMLDoc->createElement(X("extends")); + setVisibility(iSwitch, pExtends); + + pExtends->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pExtends->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + if (mod) pExtends = (DOMElement*)appendKidsFromStack((l_stack *)mod, pExtends); + if (path) pExtends->setAttribute(X("type"), X(((mstring*)path)->c_str())); + parent->appendChild(pExtends); + ast = parent; + } + ) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##constrain +*/ +constraining_clause returns [DOMElement* ast] +{ + DOMElement* pConstrain = pModelicaXMLDoc->createElement(X("constrain")); +} + : + (ast = extends_clause[0, pConstrain]) + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##component +*/ +component_clause[DOMElement* parent, DOMElement* attributes] returns [DOMElement* ast] +{ + type_prefix_t pfx; + void* path = 0; + DOMElement* arr = 0; + DOMElement* comp_list = 0; +} + : + type_prefix[attributes] + path = type_specifier { if (path) attributes->setAttribute(X("type"), X(((mstring*)path)->c_str())); } + (arr = array_subscripts[1])? + parent = component_list[parent, attributes, arr] + { + ast = parent; + } + ; + +type_prefix[DOMElement* parent] + : + (f:FLOW)? + (d:DISCRETE | p:PARAMETER | c:CONSTANT)? + (i:INPUT | o:OUTPUT)? + { + if (f != NULL) { parent->setAttribute(X("flow"), X("true")); } + //else { parent->setAttribute(X("flow"), X("none")); } + if (d != NULL) { parent->setAttribute(X("variability"), X("discrete")); } + else if (p != NULL) { parent->setAttribute(X("variability"), X("parameter")); } + else if (c != NULL) { parent->setAttribute(X("variability"), X("constant")); } + //else { parent->setAttribute(X("variability"), X("variable")); } + if (i != NULL) { parent->setAttribute(X("direction"), X("input")); } + else if (o != NULL) { parent->setAttribute(X("direction"), X("output")); } + //else { parent->setAttribute(X("direction"), X("bidirectional")); } + } + ; + +// returns datatype Path +type_specifier returns [void* ast] + : + ast = name_path; + + +// returns datatype Component list +component_list[DOMElement* parent, DOMElement *attributes, DOMElement* type_array] + returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e=0; +} + : + parent = component_declaration[parent, attributes, type_array] + (parent = component_declaration[parent, attributes, type_array])* + { + ast = parent; + } + ; + +conditional_attribute returns [DOMElement* ast] +{ + DOMElement* cda = 0; + DOMElement* e = 0; +} +: #(i:IF e=expression) +{ + cda = pModelicaXMLDoc->createElement(X("conditional")); + cda->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + cda->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + cda->appendChild(e); + ast = cda; +} +; + +// returns datatype Component +component_declaration[DOMElement* parent, DOMElement *attributes, DOMElement *type_array] + returns [DOMElement* ast] +{ + DOMElement* cmt = 0; + DOMElement* dec = 0; + DOMElement* cda = 0; +} + : + (dec = declaration[attributes, type_array]) + (cda = conditional_attribute)? + (cmt = comment)? + { + if (cmt) dec->appendChild(cmt); + if (cda) dec->appendChild(cda); + parent->appendChild(dec); + ast = parent; + } + ; + + +// returns datatype Component +declaration[DOMElement* parent, DOMElement* type_array] returns [DOMElement* ast] +{ + DOMElement* arr = 0; + DOMElement* mod = 0; + DOMElement* id = 0; +} + : + #(i:IDENT (arr = array_subscripts[0])? (mod = modification)?) + { + DOMElement *pComponent = pModelicaXMLDoc->createElement(X("component")); + pComponent->setAttribute(X("ident"), str2xml(i)); + pComponent->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pComponent->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + setAttributes(pComponent, parent); + if (type_array) pComponent->appendChild(type_array); + if (arr) pComponent->appendChild(arr); + if (mod) pComponent->appendChild(mod); + ast = pComponent; + } + ; + +modification returns [DOMElement* ast] +{ + DOMElement* e = 0; + void *cm = 0; + int iswitch = 0; +} + : + ( cm = class_modification (e = expression )? + |#(eq:EQUALS e = expression) { iswitch = 1; } + |#(as:ASSIGN e = expression) { iswitch = 2; } + ) + { + DOMElement *pModificationEQorASorARG = null; + if (iswitch == 1) pModificationEQorASorARG = pModelicaXMLDoc->createElement(X("modification_equals")); + if (iswitch == 2) pModificationEQorASorARG = pModelicaXMLDoc->createElement(X("modification_assign")); + if (iswitch == 0) pModificationEQorASorARG = pModelicaXMLDoc->createElement(X("modification_arguments")); + if (cm) pModificationEQorASorARG = (DOMElement*)appendKidsFromStack((l_stack*)cm, pModificationEQorASorARG); + if (e) + { + if (iswitch == 0) + { + DOMElement *z = pModelicaXMLDoc->createElement(X("modification_equals")); + z->appendChild(e); + pModificationEQorASorARG->appendChild(z); + } + else + { + pModificationEQorASorARG->appendChild(e); + } + } + if (eq) + { + pModificationEQorASorARG->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); + pModificationEQorASorARG->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); + } + if (as) + { + pModificationEQorASorARG->setAttribute(X("sline"), X(itoa(as->getLine(),stmp,10))); + pModificationEQorASorARG->setAttribute(X("scolumn"), X(itoa(as->getColumn(),stmp,10))); + } + ast = pModificationEQorASorARG; + } + ; + +class_modification returns [void *stack] +{ + stack = 0; +} + : + #(CLASS_MODIFICATION (stack = argument_list)?) + ; + +argument_list returns [void *stack] +{ + l_stack *el_stack = new l_stack; + DOMElement* e; +} + : + #(ARGUMENT_LIST + e = argument { el_stack->push_back(e); } + (e = argument { el_stack->push_back(e); } )* + ) + { + if (el_stack->size()) stack = (void*)el_stack; + else (stack = 0); + } + ; + +argument returns [DOMElement* ast] + : + #(em:ELEMENT_MODIFICATION ast = element_modification) + { + if (em) + { + ast->setAttribute(X("sline"), X(itoa(em->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(em->getColumn(),stmp,10))); + } + } + |#(er:ELEMENT_REDECLARATION ast = element_redeclaration) + { + if (er) + { + ast->setAttribute(X("sline"), X(itoa(er->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(er->getColumn(),stmp,10))); + } + } + ; + +element_modification returns [DOMElement* ast] +{ + DOMElement* cref; + DOMElement* mod=0; + DOMElement* cmt=0; +} + : + (e:EACH)? + (f:FINAL)? + cref = component_reference + (mod = modification)? + cmt = string_comment + { + DOMElement *pModification = pModelicaXMLDoc->createElement(X("element_modification")); + if (f) pModification->setAttribute(X("final"), X("true")); + if (e) pModification->setAttribute(X("each"), X("true")); + pModification->appendChild(cref); + if (mod) pModification->appendChild(mod); + if (cmt) pModification->appendChild(cmt); + ast = pModification; + } + ; + +element_redeclaration returns [DOMElement* ast] +{ + DOMElement* class_def = 0; + DOMElement* e_spec = 0; + DOMElement* constr = 0; + DOMElement* final = 0; + DOMElement* each = 0; + class_def = pModelicaXMLDoc->createElement(X("definition")); +} + : + (#(r:REDECLARE (e:EACH)? (f:FINAL)? + ( + (class_def = class_definition[false, class_def] + { + DOMElement *pElementRedeclaration = pModelicaXMLDoc->createElement(X("element_redeclaration")); + if (class_def && class_def->hasChildNodes()) + pElementRedeclaration->appendChild(class_def); + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (each) pElementRedeclaration->setAttribute(X("each"), X("true")); + ast = pElementRedeclaration; + } + | { DOMElement *pElementRedeclaration = pModelicaXMLDoc->createElement(X("element_redeclaration")); } + pElementRedeclaration = component_clause1[pElementRedeclaration] + { + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (each) pElementRedeclaration->setAttribute(X("each"), X("true")); + ast = pElementRedeclaration; + } + ) + | + ( re:REPLACEABLE + { DOMElement *pElementRedeclaration = pModelicaXMLDoc->createElement(X("element_redeclaration")); } + (class_def = class_definition[false, class_def] + | pElementRedeclaration = component_clause1[pElementRedeclaration] + ) + (constr = constraining_clause)? + { + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (f) pElementRedeclaration->setAttribute(X("final"), X("true")); + if (re) pElementRedeclaration->setAttribute(X("replaceable"), X("true")); + if (class_def && class_def->hasChildNodes()) + { + pElementRedeclaration->appendChild(class_def); + if (constr) pElementRedeclaration->appendChild(constr); + } + else + { + if (constr) pElementRedeclaration->appendChild(constr); + } + ast = pElementRedeclaration; + } + ) + ) + ) + ) + ; + +component_clause1[DOMElement *parent] returns [DOMElement* ast] +{ + type_prefix_t pfx; + DOMElement* attr = pModelicaXMLDoc->createElement(X("tmp")); + void* path = 0; + DOMElement* arr = 0; + DOMElement* comp_decl = 0; + DOMElement* comp_list = 0; +} + : + type_prefix[attr] + path = type_specifier { if (path) attr->setAttribute(X("type"), X(((mstring*)path)->c_str())); } + parent = component_declaration[parent, attr, null] + { + ast = parent; + } + ; + +// Return datatype ClassPart +equation_clause[DOMElement *definition] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e = 0; + DOMElement* ann = 0; +} + : + #(eq:EQUATION + ( + ( + definition = equation[definition] + | definition = annotation[0 /*none*/, definition, INSIDE_EQUATION])* + ) + ) + { + ast = definition; + } + | + #(INITIAL_EQUATION + #(EQUATION + ( + definition = equation[definition] + | definition = annotation [0 /* none */, definition, INSIDE_EQUATION ])* + ) + { + ast = definition; + } + ) + ; + +algorithm_clause[DOMElement* definition] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + DOMElement* ann; +} + : + #(ALGORITHM + (definition = algorithm[definition] + | definition = annotation [0 /* none */, definition, INSIDE_ALGORITHM])* + ) + { + ast = definition; + } + | + #(INITIAL_ALGORITHM + #(ALGORITHM + (definition = algorithm[definition] + | definition = annotation [0 /* none */, definition, INSIDE_ALGORITHM])* + ) + { + ast = definition; + } + ) + ; + +equation[DOMElement* definition] returns [DOMElement* ast] +{ + DOMElement* cmt = 0; +} + : + #(es:EQUATION_STATEMENT + ( ast = equality_equation + | ast = conditional_equation_e + | ast = for_clause_e + | ast = when_clause_e + | ast = connect_clause + | ast = equation_funcall + ) + (cmt = comment)? + { + DOMElement* pEquation = pModelicaXMLDoc->createElement(X("equation")); + pEquation->appendChild(ast); + if (cmt) pEquation->appendChild(cmt); + if (es) + { + pEquation->setAttribute(X("sline"), X(itoa(es->getLine(),stmp,10))); + pEquation->setAttribute(X("scolumn"), X(itoa(es->getColumn(),stmp,10))); + } + definition->appendChild(pEquation); + ast = definition; + } + ) + ; + +equation_funcall returns [DOMElement* ast] +{ + DOMElement* fcall = 0; +} + : + i:IDENT fcall = function_call + { + DOMElement* pEquCall = pModelicaXMLDoc->createElement(X("equ_call")); + pEquCall->setAttribute(X("ident"), str2xml(i)); + pEquCall->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquCall->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + pEquCall->appendChild(fcall); + ast = pEquCall; + } + ; + +algorithm[DOMElement *definition] returns [DOMElement* ast] +{ + DOMElement* cref; + DOMElement* expr; + DOMElement* tuple; + DOMElement* args; + DOMElement* cmt=0; +} + : + #(as:ALGORITHM_STATEMENT + (#(az:ASSIGN + (cref = component_reference expr = expression + { + DOMElement* pAlgAssign = pModelicaXMLDoc->createElement(X("alg_assign")); + if (az) + { + pAlgAssign->setAttribute(X("sline"), X(itoa(az->getLine(),stmp,10))); + pAlgAssign->setAttribute(X("scolumn"), X(itoa(az->getColumn(),stmp,10))); + } + pAlgAssign->appendChild(cref); + pAlgAssign->appendChild(expr); + ast = pAlgAssign; + } + | (tuple = tuple_expression_list cref = component_reference args = function_call) + { + DOMElement* pAlgAssign = pModelicaXMLDoc->createElement(X("alg_assign")); + DOMElement* pCall = pModelicaXMLDoc->createElement(X("call")); + + if (az) + { + pAlgAssign->setAttribute(X("sline"), X(itoa(az->getLine(),stmp,10))); + pAlgAssign->setAttribute(X("scolumn"), X(itoa(az->getColumn(),stmp,10))); + } + + pAlgAssign->appendChild(tuple); + + pCall->appendChild(cref); + pCall->appendChild(args); + + pAlgAssign->appendChild(pCall); + + ast = pAlgAssign; + /* + + + */ + } + ) + ) + | ast = algorithm_function_call + | ast = conditional_equation_a + | ast = for_clause_a + | ast = while_clause + | ast = when_clause_a + ) + (cmt = comment)? + { + DOMElement* pAlgorithm = pModelicaXMLDoc->createElement(X("algorithm")); + if (as) + { + pAlgorithm->setAttribute(X("sline"), X(itoa(as->getLine(),stmp,10))); + pAlgorithm->setAttribute(X("scolumn"), X(itoa(as->getColumn(),stmp,10))); + } + pAlgorithm->appendChild(ast); + if (cmt) pAlgorithm->appendChild(cmt); + definition->appendChild(pAlgorithm); + ast = definition; + /* + + + */ + } + ) + ; + +algorithm_function_call returns [DOMElement* ast] +{ + DOMElement* cref; + DOMElement* args; +} + : + cref = component_reference args = function_call + { + DOMElement* pAlgCall = pModelicaXMLDoc->createElement(X("alg_call")); + pAlgCall->appendChild(cref); + pAlgCall->appendChild(args); + ast = pAlgCall; + /* + + + */ + } + ; + +equality_equation returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + #(eq:EQUALS e1 = simple_expression e2 = expression) + { + DOMElement* pEquEqual = pModelicaXMLDoc->createElement(X("equ_equal")); + pEquEqual->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); + pEquEqual->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); + pEquEqual->appendChild(e1); + pEquEqual->appendChild(e2); + ast = pEquEqual; + /* + + + */ + } + ; + +conditional_equation_e returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* then_b; + DOMElement* else_b = 0; + DOMElement* else_if_b; + l_stack el_stack; + DOMElement* e; + + DOMElement* pEquIf = pModelicaXMLDoc->createElement(X("equ_if")); + DOMElement* pEquThen = pModelicaXMLDoc->createElement(X("equ_then")); + DOMElement* pEquElse = pModelicaXMLDoc->createElement(X("equ_else")); + + bool fbElse = false; +} + : + #(i:IF + e1 = expression { pEquIf->appendChild(e1); } + pEquThen = equation_list[pEquThen] { pEquIf->appendChild(pEquThen); } + ( e = equation_elseif { el_stack.push_back(e); } )* + (ELSE pEquElse = equation_list[pEquElse] { fbElse = true;} )? + ) + { + pEquIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (el_stack.size()>0) pEquIf = (DOMElement*)appendKids(el_stack, pEquIf); // ?? is this ok? + if (fbElse) pEquIf->appendChild(pEquElse); + ast = pEquIf; + } + ; + +conditional_equation_a returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* then_b; + DOMElement* else_b = 0; + DOMElement* else_if_b; + l_stack el_stack; + DOMElement* e; + DOMElement* pAlgIf = pModelicaXMLDoc->createElement(X("alg_if")); + DOMElement* pAlgThen = pModelicaXMLDoc->createElement(X("alg_then")); + DOMElement* pAlgElse = pModelicaXMLDoc->createElement(X("alg_else")); + bool fbElse = false; +} + : + #(i:IF + e1 = expression { pAlgIf->appendChild(e1); } + pAlgThen = algorithm_list[pAlgThen] + { + if (pAlgThen) + pAlgIf->appendChild(pAlgThen); + } + ( e = algorithm_elseif { el_stack.push_back(e); } )* + ( ELSE pAlgElse = algorithm_list[pAlgElse] {fbElse = true; } )? + ) + { + pAlgIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pAlgIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + if (el_stack.size()>0) pAlgIf = (DOMElement*)appendKids(el_stack, pAlgIf); + if (fbElse) pAlgIf->appendChild(pAlgElse); + ast = pAlgIf; + } + ; + +/* + + +*/ + + +for_clause_e returns [DOMElement* ast] +{ + DOMElement* f; + DOMElement* eq; + DOMElement* pEquFor = pModelicaXMLDoc->createElement(X("equ_for")); +} + : + #(i:FOR f=for_indices { pEquFor->appendChild(f); } + pEquFor=equation_list[pEquFor]) + { + pEquFor->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pEquFor->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pEquFor; + } + ; + + +for_clause_a returns [DOMElement* ast] +{ + DOMElement* f; + DOMElement* eq; + DOMElement* pAlgFor = pModelicaXMLDoc->createElement(X("alg_for")); +} + : + #(i:FOR f=for_indices + { + f->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + f->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + pAlgFor->appendChild(f); + } + pAlgFor = algorithm_list[pAlgFor]) + { + pAlgFor->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pAlgFor->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + ast = pAlgFor; + } + ; + + +for_iterator returns[DOMElement* ast] +{ + DOMElement* expr; + DOMElement* iter; +} + : + #(f:FOR expr = expression #(IN i:IDENT iter=expression)) + { + DOMElement* pForIter = pModelicaXMLDoc->createElement(X("for_iterator")); + pForIter->appendChild(expr); + DOMElement* pForIndex = pModelicaXMLDoc->createElement(X("for_index")); + pForIndex->setAttribute(X("ident"), str2xml(i)); + pForIndex->setAttribute(X("sline"), X(itoa(f->getLine(),stmp,10))); + pForIndex->setAttribute(X("scolumn"), X(itoa(f->getColumn(),stmp,10))); + if (iter) pForIndex->appendChild(iter); + pForIter->appendChild(pForIndex); + ast = pForIter; + } + ; + +for_indices returns [DOMElement* ast] +{ + DOMElement* f; + DOMElement* e; + l_stack el_stack; +} +: + (#(IN i:IDENT (e=expression)?) + { + DOMElement* pForIndex = pModelicaXMLDoc->createElement(X("for_index")); + pForIndex->setAttribute(X("ident"), str2xml(i)); + + pForIndex->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pForIndex->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + if (e) pForIndex->appendChild(e); + el_stack.push_back(pForIndex); + } + )* + { + DOMElement* pForIndices = pModelicaXMLDoc->createElement(X("for_indices")); + pForIndices = (DOMElement*)appendKids(el_stack, pForIndices); + ast = pForIndices; + } +; + +while_clause returns [DOMElement* ast] +{ + DOMElement* e; + DOMElement* body; + DOMElement* pAlgWhile = pModelicaXMLDoc->createElement(X("alg_while")); +} + : + #(w:WHILE + e = expression + { + pAlgWhile->appendChild(e); + } + pAlgWhile = algorithm_list[pAlgWhile]) + { + pAlgWhile->setAttribute(X("sline"), X(itoa(w->getLine(),stmp,10))); + pAlgWhile->setAttribute(X("scolumn"), X(itoa(w->getColumn(),stmp,10))); + + ast = pAlgWhile; + } + ; + + +/* + + +*/ + +when_clause_e returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + DOMElement* body; + DOMElement* el = 0; + DOMElement* pEquWhen = pModelicaXMLDoc->createElement(X("equ_when")); + DOMElement* pEquThen = pModelicaXMLDoc->createElement(X("equ_then")); +} + : + #(wh:WHEN + e = expression { pEquWhen->appendChild(e); } + pEquThen = equation_list[pEquThen] { pEquWhen->appendChild(pEquThen); } + (el = else_when_e { el_stack.push_back(el); } )* + ) + { + pEquWhen->setAttribute(X("sline"), X(itoa(wh->getLine(),stmp,10))); + pEquWhen->setAttribute(X("scolumn"), X(itoa(wh->getColumn(),stmp,10))); + + if (el_stack.size()>0) pEquWhen = (DOMElement*)appendKids(el_stack, pEquWhen); // ??is this ok? + ast = pEquWhen; + } + ; + +else_when_e returns [DOMElement* ast] +{ + DOMElement* expr; + DOMElement* eqn; + DOMElement* pEquElseWhen = pModelicaXMLDoc->createElement(X("equ_elsewhen")); + DOMElement* pEquThen = pModelicaXMLDoc->createElement(X("equ_then")); +} + : + #(e:ELSEWHEN expr = expression { pEquElseWhen->appendChild(expr); } + pEquThen = equation_list[pEquThen]) + { + pEquElseWhen->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pEquElseWhen->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + pEquElseWhen->appendChild(pEquThen); + ast = pEquElseWhen; + } + ; + +when_clause_a returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + DOMElement* body; + DOMElement* el = 0; + DOMElement* pAlgWhen = pModelicaXMLDoc->createElement(X("alg_when")); + DOMElement* pAlgThen = pModelicaXMLDoc->createElement(X("alg_then")); +} + : + #(wh:WHEN + e = expression { pAlgWhen->appendChild(e); } + pAlgThen = algorithm_list[pAlgThen] { pAlgWhen->appendChild(pAlgThen); } + (el = else_when_a {el_stack.push_back(el); })* + ) + { + pAlgWhen->setAttribute(X("sline"), X(itoa(wh->getLine(),stmp,10))); + pAlgWhen->setAttribute(X("scolumn"), X(itoa(wh->getColumn(),stmp,10))); + + if (el_stack.size() > 0) pAlgWhen = (DOMElement*)appendKids(el_stack, pAlgWhen); + ast = pAlgWhen; + } + ; + +else_when_a returns [DOMElement* ast] +{ + DOMElement* expr; + DOMElement* alg; + DOMElement* pAlgElseWhen = pModelicaXMLDoc->createElement(X("alg_elsewhen")); + DOMElement* pAlgThen = pModelicaXMLDoc->createElement(X("alg_then")); +} + : + #(e:ELSEWHEN expr = expression { pAlgElseWhen->appendChild(expr); } + pAlgThen = algorithm_list[pAlgThen]) + { + pAlgElseWhen->setAttribute(X("sline"), X(itoa(e->getLine(),stmp,10))); + pAlgElseWhen->setAttribute(X("scolumn"), X(itoa(e->getColumn(),stmp,10))); + + pAlgElseWhen->appendChild(pAlgThen); + ast = pAlgElseWhen; + } + ; + +equation_elseif returns [DOMElement* ast] +{ + DOMElement* e; + DOMElement* eq; + DOMElement* pEquElseIf = pModelicaXMLDoc->createElement(X("equ_elseif")); + DOMElement* pEquThen = pModelicaXMLDoc->createElement(X("equ_then")); +} + : + #(els:ELSEIF + e = expression { pEquElseIf->appendChild(e); } + pEquThen = equation_list[pEquThen] + ) + { + pEquElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pEquElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pEquElseIf->appendChild(pEquThen); + ast = pEquElseIf; + } + ; + +algorithm_elseif returns [DOMElement* ast] +{ + DOMElement* e; + DOMElement* body; + DOMElement* pAlgElseIf = pModelicaXMLDoc->createElement(X("alg_elseif")); + DOMElement* pAlgThen = pModelicaXMLDoc->createElement(X("alg_then")); +} + : + #(els:ELSEIF + e = expression { pAlgElseIf->appendChild(e); } + pAlgThen = algorithm_list[pAlgThen] + ) + { + pAlgElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pAlgElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pAlgElseIf->appendChild(pAlgThen); + ast = pAlgElseIf; + } + ; + +equation_list[DOMElement* pEquationList] returns [DOMElement* ast] +{ + DOMElement* e; + l_stack el_stack; +} + : + (pEquationList = equation[pEquationList])* + { + ast = pEquationList; + } + ; + +algorithm_list[DOMElement* pAlgorithmList] returns [DOMElement* ast] +{ + DOMElement* e; + l_stack el_stack; +} + : + (pAlgorithmList = algorithm[pAlgorithmList] )* + { + ast = pAlgorithmList; + } + ; + +connect_clause returns [DOMElement* ast] +{ + DOMElement* r1; + DOMElement* r2; +} + : + #(c:CONNECT + r1 = component_reference + r2 = component_reference + ) + { + DOMElement* pEquConnect = pModelicaXMLDoc->createElement(X("equ_connect")); + + pEquConnect->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pEquConnect->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + + pEquConnect->appendChild(r1); + pEquConnect->appendChild(r2); + ast = pEquConnect; + } + ; + + +expression returns [DOMElement* ast] + : + ( ast = simple_expression + | ast = if_expression + | ast = code_expression + ) + ; + +if_expression returns [DOMElement* ast] +{ + DOMElement* cond; + DOMElement* thenPart; + DOMElement* elsePart; + DOMElement* e; + DOMElement* elseifPart; + l_stack el_stack; +} + : + #(i:IF cond = expression + thenPart = expression (e=elseif_expression {el_stack.push_back(e);} )* elsePart = expression + { + DOMElement* pIf = pModelicaXMLDoc->createElement(X("if")); + DOMElement* pThen = pModelicaXMLDoc->createElement(X("then")); + DOMElement* pElse = pModelicaXMLDoc->createElement(X("else")); + + pIf->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pIf->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pIf->appendChild(cond); + pThen->appendChild(thenPart); + pIf->appendChild(pThen); + if (el_stack.size()>0) pIf = (DOMElement*)appendKids(el_stack, pIf); //??is this ok?? + pElse->appendChild(elsePart); + pIf->appendChild(pElse); + ast = pIf; + } + ) + ; + +elseif_expression returns [DOMElement* ast] +{ + DOMElement* cond; + DOMElement* thenPart; +} + : + #(els:ELSEIF cond = expression thenPart = expression + { + DOMElement* pElseIf = pModelicaXMLDoc->createElement(X("elseif")); + + pElseIf->setAttribute(X("sline"), X(itoa(els->getLine(),stmp,10))); + pElseIf->setAttribute(X("scolumn"), X(itoa(els->getColumn(),stmp,10))); + + pElseIf->appendChild(cond); + DOMElement* pThen = pModelicaXMLDoc->createElement(X("then")); + pThen->appendChild(thenPart); + pElseIf->appendChild(pThen); + ast = pElseIf; + } + ) + ; + +simple_expression returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; + DOMElement* e3; +} + : + (#(r3:RANGE3 e1 = logical_expression + e2 = logical_expression + e3 = logical_expression) + { + DOMElement* pRange = pModelicaXMLDoc->createElement(X("range")); + + pRange->setAttribute(X("sline"), X(itoa(r3->getLine(),stmp,10))); + pRange->setAttribute(X("scolumn"), X(itoa(r3->getColumn(),stmp,10))); + + pRange->appendChild(e1); + pRange->appendChild(e2); + pRange->appendChild(e3); + ast = pRange; + /* + + + */ + } + |#(r2:RANGE2 e1 = logical_expression e3 = logical_expression) + { + DOMElement* pRange = pModelicaXMLDoc->createElement(X("range")); + + pRange->setAttribute(X("sline"), X(itoa(r2->getLine(),stmp,10))); + pRange->setAttribute(X("scolumn"), X(itoa(r2->getColumn(),stmp,10))); + + pRange->appendChild(e1); + pRange->appendChild(e3); + ast = pRange; + } + | ast = logical_expression + ) + ; + +// ?? what the hack is this? +code_expression returns [DOMElement* ast] +{ + DOMElement*pCode = pModelicaXMLDoc->createElement(X("code")); +} + + : + #(CODE_MODIFICATION (ast = modification) ) + { + // ?? what the hack is this? + DOMElement* pModification = pModelicaXMLDoc->createElement(X("modification")); + pModification->appendChild(ast); + ast = pModification; + /* + ast = Absyn__CODE(Absyn__C_5fMODIFICATION(ast)); + */ + } + + | #(CODE_EXPRESSION (ast = expression) ) + { + // ?? what the hack is this? + DOMElement* pExpression = pModelicaXMLDoc->createElement(X("expression")); + pExpression->appendChild(ast); + ast = pExpression; + /* ast = Absyn__CODE(Absyn__C_5fEXPRESSION(ast)); */ + } + + | #(CODE_ELEMENT (ast = element[0 /* none */, pCode]) ) + { + // ?? what the hack is this? + DOMElement* pElement = pModelicaXMLDoc->createElement(X("element")); + pElement->appendChild(ast); + ast = pElement; + /* ast = Absyn__CODE(Absyn__C_5fELEMENT(ast)); */ + } + + | #(CODE_EQUATION (ast = equation_clause[pCode]) ) + { + // ?? what the hack is this? + DOMElement* pEquationSection = pModelicaXMLDoc->createElement(X("equation_section")); + pEquationSection->appendChild(ast); + ast = pEquationSection; + /* ast = Absyn__CODE(Absyn__C_5fEQUATIONSECTION(RML_FALSE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); */ + } + + | #(CODE_INITIALEQUATION (ast = equation_clause[pCode]) ) + { + // ?? what the hack is this? + DOMElement* pEquationSection = pModelicaXMLDoc->createElement(X("equation_section")); + ((DOMElement*)ast)->setAttribute(X("initial"), X("true")); + pEquationSection->appendChild(ast); + ast = pEquationSection; + /* + ast = Absyn__CODE(Absyn__C_5fEQUATIONSECTION(RML_TRUE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + } + | #(CODE_ALGORITHM (ast = algorithm_clause[pCode]) ) + { + // ?? what the hack is this? + DOMElement* pAlgorithmSection = pModelicaXMLDoc->createElement(X("algorithm_section")); + pAlgorithmSection->appendChild(ast); + ast = pAlgorithmSection; + /* + ast = Absyn__CODE(Absyn__C_5fALGORITHMSECTION(RML_FALSE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + } + | #(CODE_INITIALALGORITHM (ast = algorithm_clause[pCode]) ) + { + // ?? what the hack is this? + DOMElement* pAlgorithmSection = pModelicaXMLDoc->createElement(X("algorithm_section")); + ((DOMElement*)ast)->setAttribute(X("initial"), X("true")); + pAlgorithmSection->appendChild(ast); + ast = pAlgorithmSection; + /* + ast = Absyn__CODE(Absyn__C_5fALGORITHMSECTION(RML_TRUE, + RML_FETCH(RML_OFFSET(RML_UNTAGPTR(ast), 1)))); + */ + } + ; + +logical_expression returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = logical_term + | #(o:OR e1 = logical_expression e2 = logical_term) + { + DOMElement* pOr = pModelicaXMLDoc->createElement(X("or")); + + pOr->setAttribute(X("sline"), X(itoa(o->getLine(),stmp,10))); + pOr->setAttribute(X("scolumn"), X(itoa(o->getColumn(),stmp,10))); + + pOr->appendChild(e1); + pOr->appendChild(e2); + ast = pOr; + } + ) + + ; + +logical_term returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = logical_factor + | #(a:AND e1 = logical_term e2 = logical_factor) + { + DOMElement* pAnd = pModelicaXMLDoc->createElement(X("and")); + + pAnd->setAttribute(X("sline"), X(itoa(a->getLine(),stmp,10))); + pAnd->setAttribute(X("scolumn"), X(itoa(a->getColumn(),stmp,10))); + + pAnd->appendChild(e1); + pAnd->appendChild(e2); + ast = pAnd; + } + ) + ; + +logical_factor returns [DOMElement* ast] + : + #(n:NOT ast = relation + { + DOMElement* pNot = pModelicaXMLDoc->createElement(X("not")); + + pNot->setAttribute(X("sline"), X(itoa(n->getLine(),stmp,10))); + pNot->setAttribute(X("scolumn"), X(itoa(n->getColumn(),stmp,10))); + + pNot->appendChild(ast); + ast = pNot; + }) + | ast = relation; + +relation returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* op = 0; + DOMElement* e2 = 0; +} + : + ( ast = arithmetic_expression + | + ( #(lt:LESS e1=arithmetic_expression e2=arithmetic_expression) + { op = pModelicaXMLDoc->createElement(X("lt")); /* Absyn__LESS; */ } + | #(lte:LESSEQ e1=arithmetic_expression e2=arithmetic_expression) + { op = pModelicaXMLDoc->createElement(X("lte")); /* Absyn__LESSEQ; */ } + | #(gt:GREATER e1=arithmetic_expression e2=arithmetic_expression) + { op = pModelicaXMLDoc->createElement(X("gt")); /* Absyn__GREATER; */ } + | #(gte:GREATEREQ e1=arithmetic_expression e2=arithmetic_expression) + { op = pModelicaXMLDoc->createElement(X("gte")); /* Absyn__GREATEREQ; */ } + | #(eq:EQEQ e1=arithmetic_expression e2=arithmetic_expression) + { op = pModelicaXMLDoc->createElement(X("eq")); /* Absyn__EQUAL; */ } + | #(ne:LESSGT e1=arithmetic_expression e2=arithmetic_expression ) + { op = pModelicaXMLDoc->createElement(X("ne")); /* op = Absyn__NEQUAL; */ } + ) + { + op->appendChild(e1); + op->appendChild(e2); + if (lt) { op->setAttribute(X("sline"), X(itoa(lt->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(lt->getColumn(),stmp,10))); } + if (lte){ op->setAttribute(X("sline"), X(itoa(lte->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(lte->getColumn(),stmp,10))); } + if (gt) { op->setAttribute(X("sline"), X(itoa(gt->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(gt->getColumn(),stmp,10))); } + if (gte){ op->setAttribute(X("sline"), X(itoa(gte->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(gte->getColumn(),stmp,10))); } + if (eq) { op->setAttribute(X("sline"), X(itoa(eq->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(eq->getColumn(),stmp,10))); } + if (ne) { op->setAttribute(X("sline"), X(itoa(ne->getLine(),stmp,10))); op->setAttribute(X("scolumn"), X(itoa(ne->getColumn(),stmp,10))); } + ast = op; + } + ) + ; + +arithmetic_expression returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = unary_arithmetic_expression + |#(add:PLUS e1 = arithmetic_expression e2 = term) + { + DOMElement* pAdd = pModelicaXMLDoc->createElement(X("add")); + + pAdd->setAttribute(X("sline"), X(itoa(add->getLine(),stmp,10))); + pAdd->setAttribute(X("scolumn"), X(itoa(add->getColumn(),stmp,10))); + + pAdd->setAttribute(X("operation"), X("binary")); + pAdd->appendChild(e1); + pAdd->appendChild(e2); + ast = pAdd; + } + |#(sub:MINUS e1 = arithmetic_expression e2 = term) + { + DOMElement* pSub = pModelicaXMLDoc->createElement(X("sub")); + + pSub->setAttribute(X("sline"), X(itoa(sub->getLine(),stmp,10))); + pSub->setAttribute(X("scolumn"), X(itoa(sub->getColumn(),stmp,10))); + + pSub->setAttribute(X("operation"), X("binary")); + pSub->appendChild(e1); + pSub->appendChild(e2); + ast = pSub; + } + ) + ; + +unary_arithmetic_expression returns [DOMElement* ast] + : + (#(add:UNARY_PLUS ast = term) + { + DOMElement* pAdd = pModelicaXMLDoc->createElement(X("add")); + + pAdd->setAttribute(X("sline"), X(itoa(add->getLine(),stmp,10))); + pAdd->setAttribute(X("scolumn"), X(itoa(add->getColumn(),stmp,10))); + + pAdd->setAttribute(X("operation"), X("unary")); + pAdd->appendChild(ast); + ast = pAdd; + } + |#(sub:UNARY_MINUS ast = term) + { + DOMElement* pSub = pModelicaXMLDoc->createElement(X("sub")); + + pSub->setAttribute(X("sline"), X(itoa(sub->getLine(),stmp,10))); + pSub->setAttribute(X("scolumn"), X(itoa(sub->getColumn(),stmp,10))); + + pSub->setAttribute(X("operation"), X("unary")); + pSub->appendChild(ast); + ast = pSub; + } + | ast = term + ) + ; + +term returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = factor + |#(mul:STAR e1 = term e2 = factor) + { + DOMElement* pMul = pModelicaXMLDoc->createElement(X("mul")); + + pMul->setAttribute(X("sline"), X(itoa(mul->getLine(),stmp,10))); + pMul->setAttribute(X("scolumn"), X(itoa(mul->getColumn(),stmp,10))); + + pMul->appendChild(e1); + pMul->appendChild(e2); + ast = pMul; + } + |#(div:SLASH e1 = term e2 = factor) + { + DOMElement* pDiv = pModelicaXMLDoc->createElement(X("div")); + + pDiv->setAttribute(X("sline"), X(itoa(div->getLine(),stmp,10))); + pDiv->setAttribute(X("scolumn"), X(itoa(div->getColumn(),stmp,10))); + + pDiv->appendChild(e1); + pDiv->appendChild(e2); + ast = pDiv; + } + ) + ; + +factor returns [DOMElement* ast] +{ + DOMElement* e1; + DOMElement* e2; +} + : + (ast = primary + |#(pw:POWER e1 = primary e2 = primary) + { + DOMElement* pPow = pModelicaXMLDoc->createElement(X("pow")); + + pPow->setAttribute(X("sline"), X(itoa(pw->getLine(),stmp,10))); + pPow->setAttribute(X("scolumn"), X(itoa(pw->getColumn(),stmp,10))); + + pPow->appendChild(e1); + pPow->appendChild(e2); + ast = pPow; + } + ) + ; + +primary returns [DOMElement* ast] +{ + l_stack* el_stack = new l_stack; + DOMElement* e; + DOMElement* exp = 0; + DOMElement* pSemicolon = pModelicaXMLDoc->createElement(X("semicolon")); +} + : + ( ui:UNSIGNED_INTEGER + { + DOMElement* pIntegerLiteral = pModelicaXMLDoc->createElement(X("integer_literal")); + pIntegerLiteral->setAttribute(X("value"), str2xml(ui)); + + pIntegerLiteral->setAttribute(X("sline"), X(itoa(ui->getLine(),stmp,10))); + pIntegerLiteral->setAttribute(X("scolumn"), X(itoa(ui->getColumn(),stmp,10))); + + ast = pIntegerLiteral; + } + | ur:UNSIGNED_REAL + { + DOMElement* pRealLiteral = pModelicaXMLDoc->createElement(X("real_literal")); + pRealLiteral->setAttribute(X("value"), str2xml(ur)); + + pRealLiteral->setAttribute(X("sline"), X(itoa(ur->getLine(),stmp,10))); + pRealLiteral->setAttribute(X("scolumn"), X(itoa(ur->getColumn(),stmp,10))); + + ast = pRealLiteral; + } + | str:STRING + { + DOMElement* pStringLiteral = pModelicaXMLDoc->createElement(X("string_literal")); + pStringLiteral->setAttribute(X("value"), str2xml(str)); + + pStringLiteral->setAttribute(X("sline"), X(itoa(str->getLine(),stmp,10))); + pStringLiteral->setAttribute(X("scolumn"), X(itoa(str->getColumn(),stmp,10))); + + ast = pStringLiteral; + } + | f:FALSE + { + DOMElement* pBoolLiteral = pModelicaXMLDoc->createElement(X("bool_literal")); + pBoolLiteral->setAttribute(X("value"), X("false")); + + pBoolLiteral->setAttribute(X("sline"), X(itoa(f->getLine(),stmp,10))); + pBoolLiteral->setAttribute(X("scolumn"), X(itoa(f->getColumn(),stmp,10))); + + ast = pBoolLiteral; + } + | t:TRUE + { + DOMElement* pBoolLiteral = pModelicaXMLDoc->createElement(X("bool_literal")); + pBoolLiteral->setAttribute(X("value"), X("true")); + + pBoolLiteral->setAttribute(X("sline"), X(itoa(t->getLine(),stmp,10))); + pBoolLiteral->setAttribute(X("scolumn"), X(itoa(t->getColumn(),stmp,10))); + + ast = pBoolLiteral; + } + | ast = component_reference__function_call + | #(d:DER e = function_call) + { + DOMElement* pDer = pModelicaXMLDoc->createElement(X("der")); + pDer->setAttribute(X("sline"), X(itoa(d->getLine(),stmp,10))); + pDer->setAttribute(X("scolumn"), X(itoa(d->getColumn(),stmp,10))); + pDer->appendChild(e); + ast = pDer; + } + | #(LPAR ast = tuple_expression_list) + | #(lbk:LBRACK e = expression_list { el_stack->push_back(e); } + (e = expression_list { el_stack->push_back(e); } )* ) + { + DOMElement* pConcat = pModelicaXMLDoc->createElement(X("concat")); + + pConcat->setAttribute(X("sline"), X(itoa(lbk->getLine(),stmp,10))); + pConcat->setAttribute(X("scolumn"), X(itoa(lbk->getColumn(),stmp,10))); + + pConcat = (DOMElement*)appendKidsFromStack(el_stack, pConcat); + //if (el_stack) delete el_stack; + ast = pConcat; + } + | #(lbr:LBRACE ( (ast = expression_list) + | #(FOR_ITERATOR (ast = for_iterator) ))) + { + /* was before: ast = function_arguments */ + DOMElement* pArray = pModelicaXMLDoc->createElement(X("array")); + + pArray->setAttribute(X("sline"), X(itoa(lbr->getLine(),stmp,10))); + pArray->setAttribute(X("scolumn"), X(itoa(lbr->getColumn(),stmp,10))); + + if (!exp) pArray->appendChild(ast); + else + { + DOMElement* pFargs = pModelicaXMLDoc->createElement(X("function_arguments")); + pFargs->appendChild(exp); + pFargs->appendChild(ast); + pArray->appendChild(pFargs); + } + ast = pArray; + } + | tend:END + { + DOMElement* pEnd = pModelicaXMLDoc->createElement(X("end")); + pEnd->setAttribute(X("sline"), X(itoa(tend->getLine(),stmp,10))); + pEnd->setAttribute(X("scolumn"), X(itoa(tend->getColumn(),stmp,10))); + ast = pEnd; + } + ) + ; + +component_reference__function_call returns [DOMElement* ast] +{ + DOMElement* cref; + DOMElement* fnc = 0; +} + : + (#(fc:FUNCTION_CALL cref = component_reference (fnc = function_call)?) + { + DOMElement* pCall = pModelicaXMLDoc->createElement(X("call")); + + pCall->setAttribute(X("sline"), X(itoa(fc->getLine(),stmp,10))); + pCall->setAttribute(X("scolumn"), X(itoa(fc->getColumn(),stmp,10))); + + pCall->appendChild(cref); + if (fnc) pCall->appendChild(fnc); + ast = pCall; + } + | cref = component_reference + { + if (fnc && cref) cref->appendChild(fnc); + ast = cref; + } + ) + | + #(ifc:INITIAL_FUNCTION_CALL i:INITIAL ) + { + // calling function initial + DOMElement* pCall = pModelicaXMLDoc->createElement(X("call")); + + DOMElement* pCref = pModelicaXMLDoc->createElement(X("component_reference")); + pCref->setAttribute(X("ident"), X("initial")); + pCref->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pCall->appendChild(pCref); + + pCall->setAttribute(X("sline"), X(itoa(ifc->getLine(),stmp,10))); + pCall->setAttribute(X("scolumn"), X(itoa(ifc->getColumn(),stmp,10))); + + ast = pCall; + } + ; + +name_path returns [void *ast] +{ + void *s1=0; + void *s2=0; +} + : + i:IDENT + { + ast = (void*)new mstring(i->getText()); + } + |#(d:DOT i2:IDENT s2 = name_path) + { + s1 = (void*)new mstring(i2->getText()); + ast = (void*)new mstring(mstring(((mstring*)s1)->c_str())+mstring(".")+mstring(((mstring*)s2)->c_str())); + } + ; + +component_reference returns [DOMElement* ast] +{ + DOMElement* arr = 0; + DOMElement* id = 0; +} + : + (#(i:IDENT (arr = array_subscripts[0])?) + { + DOMElement *pCref = pModelicaXMLDoc->createElement(X("component_reference")); + + pCref->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pCref->setAttribute(X("ident"), str2xml(i)); + if (arr) pCref->appendChild(arr); + ast = pCref; + } + |#(DOT #(i2:IDENT (arr = array_subscripts[0])?) + ast = component_reference) + { + DOMElement *pCref = pModelicaXMLDoc->createElement(X("component_reference")); + pCref->setAttribute(X("ident"), str2xml(i2)); + + pCref->setAttribute(X("sline"), X(itoa(i2->getLine(),stmp,10))); + pCref->setAttribute(X("scolumn"), X(itoa(i2->getColumn(),stmp,10))); + + if (arr) pCref->appendChild(arr); + pCref->appendChild(ast); + ast = pCref; + } + ) + ; + +function_call returns [DOMElement* ast] + : + #(fa:FUNCTION_ARGUMENTS ast = function_arguments + { + ast->setAttribute(X("sline"), X(itoa(fa->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(fa->getColumn(),stmp,10))); + } + ) + ; + + +expression_list2[DOMElement *parent] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; +} + : + (#(el:EXPRESSION_LIST + e = expression { parent->appendChild(e); } + (e = expression { parent->appendChild(e); } )* + ) + ) + { + ast = parent; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##function_arguments +*/ + +function_arguments returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e=0; + DOMElement* namel=0; + DOMElement *pFunctionArguments = pModelicaXMLDoc->createElement(X("function_arguments")); +} + : + ( + (pFunctionArguments = expression_list2[pFunctionArguments])? + (pFunctionArguments = named_arguments[pFunctionArguments])? + { + ast = pFunctionArguments; + } + | #(FOR_ITERATOR ast = for_iterator) + ) + ; +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##named_arguments +*/ + +named_arguments[DOMElement *parent] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* n; +} + : + #(na:NAMED_ARGUMENTS (n = named_argument { parent->appendChild(n); }) + (n = named_argument { parent->appendChild(n); } )*) + { + ast = parent; + } + ; + +named_argument returns [DOMElement* ast] +{ + DOMElement* temp; +} + : + #(eq:EQUALS i:IDENT temp = expression) + { + DOMElement *pNamedArgument = pModelicaXMLDoc->createElement(X("named_argument")); + pNamedArgument->setAttribute(X("ident"), str2xml(i)); + + pNamedArgument->setAttribute(X("sline"), X(itoa(i->getLine(),stmp,10))); + pNamedArgument->setAttribute(X("scolumn"), X(itoa(i->getColumn(),stmp,10))); + + pNamedArgument->appendChild(temp); + ast = pNamedArgument; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##expression_list +*/ + +expression_list returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + //DOMElement* pComma = pModelicaXMLDoc->createElement(X("comma")); +} + : + (#(el:EXPRESSION_LIST + e = expression { el_stack.push_back(e); } + (e = expression { el_stack.push_back(pModelicaXMLDoc->createElement(X("comma"))); el_stack.push_back(e); } )* + ) + ) + { + ast = (DOMElement*)stack2DOMNode(el_stack, "expression_list"); + + ast->setAttribute(X("sline"), X(itoa(el->getLine(),stmp,10))); + ast->setAttribute(X("scolumn"), X(itoa(el->getColumn(),stmp,10))); + } + ; + +tuple_expression_list returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* e; + //DOMElement* pComma = pModelicaXMLDoc->createElement(X("comma")); +} + : + (#(el:EXPRESSION_LIST + e = expression { el_stack.push_back(e); } + (e = expression { el_stack.push_back(pModelicaXMLDoc->createElement(X("comma"))); el_stack.push_back(e); } )* + ) + ) + { + if (el_stack.size() == 1) + { + ast = el_stack.back(); + } + else + { + DOMElement *pTuple = pModelicaXMLDoc->createElement(X("output_expression_list")); + pTuple = (DOMElement*)appendKids(el_stack, pTuple); + pTuple->setAttribute(X("sline"), X(itoa(el->getLine(),stmp,10))); + pTuple->setAttribute(X("scolumn"), X(itoa(el->getColumn(),stmp,10))); + ast = pTuple; + } + } + ; + +array_subscripts[int kind] returns [DOMElement* ast] +{ + l_stack el_stack; + DOMElement* s = 0; + DOMElement *pArraySubscripts = 0; + if (kind) + pArraySubscripts = pModelicaXMLDoc->createElement(X("type_array_subscripts")); + else + pArraySubscripts = pModelicaXMLDoc->createElement(X("array_subscripts")); +} + : + #(lbk:LBRACK pArraySubscripts = subscript[pArraySubscripts] + (pArraySubscripts = subscript[pArraySubscripts])*) + { + + pArraySubscripts->setAttribute(X("sline"), X(itoa(lbk->getLine(),stmp,10))); + pArraySubscripts->setAttribute(X("scolumn"), X(itoa(lbk->getColumn(),stmp,10))); + + ast = pArraySubscripts; + } + ; + +subscript[DOMElement* parent] returns [DOMElement* ast] +{ + DOMElement* e; + DOMElement* pColon = pModelicaXMLDoc->createElement(X("colon")); +} + : + ( + e = expression + { + parent->appendChild(e); + ast = parent; + } + | c:COLON + { + + pColon->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pColon->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + + parent->appendChild(pColon); + ast = parent; + } + ) + ; + +comment returns [DOMElement* ast] +{ + DOMElement* ann=0; + DOMElement* cmt=0; + ast = 0; + DOMElement *pComment = pModelicaXMLDoc->createElement(X("comment")); + bool bAnno = false; +} : +#(c:COMMENT cmt=string_comment { if (cmt) pComment->appendChild(cmt); } +(pComment = annotation [0 /* none */, pComment, INSIDE_COMMENT] { bAnno = true; })?) + { + if (c) + { + pComment->setAttribute(X("sline"), X(itoa(c->getLine(),stmp,10))); + pComment->setAttribute(X("scolumn"), X(itoa(c->getColumn(),stmp,10))); + } + if ((cmt !=0) || bAnno) ast = pComment; + else ast = 0; + } + ; + +string_comment returns [DOMElement* ast] : + { + DOMElement* cmt=0; + ast = 0; + } + #(sc:STRING_COMMENT cmt=string_concatenation) + { + DOMElement *pStringComment = pModelicaXMLDoc->createElement(X("string_comment")); + + pStringComment->setAttribute(X("sline"), X(itoa(sc->getLine(),stmp,10))); + pStringComment->setAttribute(X("scolumn"), X(itoa(sc->getColumn(),stmp,10))); + + pStringComment->appendChild(cmt); + ast = pStringComment; + } + | + { + ast = 0; + } + ; + +string_concatenation returns [DOMElement* ast] + { + DOMElement*pString1; + l_stack el_stack; + } +: + s:STRING + { + DOMElement *pString = pModelicaXMLDoc->createElement(X("string_literal")); + pString->setAttribute(X("value"), str2xml(s)); + + pString->setAttribute(X("sline"), X(itoa(s->getLine(),stmp,10))); + pString->setAttribute(X("scolumn"), X(itoa(s->getColumn(),stmp,10))); + + ast=pString; + } + |#(p:PLUS pString1=string_concatenation s2:STRING) + { + DOMElement *pString = pModelicaXMLDoc->createElement(X("add_string")); + + pString->setAttribute(X("sline"), X(itoa(p->getLine(),stmp,10))); + pString->setAttribute(X("scolumn"), X(itoa(p->getColumn(),stmp,10))); + + pString->appendChild(pString1); + DOMElement *pString2 = pModelicaXMLDoc->createElement(X("string_literal")); + pString2->setAttribute(X("value"), str2xml(s2)); + + pString2->setAttribute(X("sline"), X(itoa(s2->getLine(),stmp,10))); + pString2->setAttribute(X("scolumn"), X(itoa(s2->getColumn(),stmp,10))); + + pString->appendChild(pString2); + ast=pString; + } + ; + +/* +http://www.ida.liu.se/~adrpo/modelica/xml/modelicaxml-v2.html##annotation +*/ + +annotation[int iSwitch, DOMElement *parent, enum anno awhere] returns [DOMElement* ast] +{ + void* cmod=0; +} + : + #(a:ANNOTATION cmod = class_modification) + { + DOMElement *pAnnotation = pModelicaXMLDoc->createElement(X("annotation")); + + pAnnotation->setAttribute(X("sline"), X(itoa(a->getLine(),stmp,10))); + pAnnotation->setAttribute(X("scolumn"), X(itoa(a->getColumn(),stmp,10))); + + switch (awhere) + { + case INSIDE_ELEMENT: + pAnnotation->setAttribute(X("inside"), X("element")); + break; + case INSIDE_EQUATION: + pAnnotation->setAttribute(X("inside"), X("equation")); + break; + case INSIDE_ALGORITHM: + pAnnotation->setAttribute(X("inside"), X("algorithm")); + break; + case INSIDE_COMMENT: + pAnnotation->setAttribute(X("inside"), X("comment")); + break; + default: + //pAnnotation->setAttribute(X("inside"), X("unspecified")); + ; + } + setVisibility(iSwitch, pAnnotation); + if (cmod) pAnnotation = (DOMElement*)appendKidsFromStack((l_stack *)cmod, pAnnotation); + parent->appendChild(pAnnotation); + ast = parent; + } + ; + + +interactive_stmt returns [DOMElement* ast] +{ + DOMElement* al=0; + DOMElement* el=0; + l_stack el_stack; + DOMElement *pInteractiveSTMT = pModelicaXMLDoc->createElement(X("ISTMT")); + DOMElement *pInteractiveALG = pModelicaXMLDoc->createElement(X("IALG")); +} + : + ( + #(INTERACTIVE_ALG (pInteractiveALG = algorithm[pInteractiveALG]) ) + { + //pInteractiveALG->appendChild(al); + el_stack.push_back(pInteractiveALG); + } + | + #(INTERACTIVE_EXP (el = expression )) + { + DOMElement *pInteractiveEXP = pModelicaXMLDoc->createElement(X("IEXP")); + pInteractiveEXP->appendChild(el); + el_stack.push_back(pInteractiveEXP); + } + + )* (s:SEMICOLON)? + { + pInteractiveSTMT = (DOMElement*)appendKids(el_stack, pInteractiveSTMT); + if (s) pInteractiveSTMT->setAttribute(X("semicolon"),X("true")); + ast = pInteractiveSTMT; + } + ; diff --git a/tools/xml/older/xml.tar.bz2 b/tools/xml/older/xml.tar.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..d9696835dacee26938c3fb6fd7e0ef3c0e299aca GIT binary patch literal 89456 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%0A<6TE9E^M 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