From 196281330abefc66aa4949d97f76f22cf4053f7e Mon Sep 17 00:00:00 2001
From: Zizhe Wang <zizhe.wang@tu-dresden.de>
Date: Fri, 28 Jun 2024 17:01:10 +0200
Subject: [PATCH] docs rearrange
---
.../BouncingBall.mo | 0
.../README.md | 0
.../Simulate_BouncingBall.py | 0
src/{ => feature_model}/feature_model.py | 0
src/{ => feature_model}/modelica.g4 | 0
src/feature_model/modelicaLexer.py | 450 ++
src/feature_model/modelicaListener.py | 714 ++
src/feature_model/modelicaParser.py | 6334 +++++++++++++++++
src/{ => feature_model}/parse_modelica.py | 0
9 files changed, 7498 insertions(+)
rename src/{Example_BouncingBall => example_bouncing_ball}/BouncingBall.mo (100%)
rename src/{Example_BouncingBall => example_bouncing_ball}/README.md (100%)
rename src/{Example_BouncingBall => example_bouncing_ball}/Simulate_BouncingBall.py (100%)
rename src/{ => feature_model}/feature_model.py (100%)
rename src/{ => feature_model}/modelica.g4 (100%)
create mode 100644 src/feature_model/modelicaLexer.py
create mode 100644 src/feature_model/modelicaListener.py
create mode 100644 src/feature_model/modelicaParser.py
rename src/{ => feature_model}/parse_modelica.py (100%)
diff --git a/src/Example_BouncingBall/BouncingBall.mo b/src/example_bouncing_ball/BouncingBall.mo
similarity index 100%
rename from src/Example_BouncingBall/BouncingBall.mo
rename to src/example_bouncing_ball/BouncingBall.mo
diff --git a/src/Example_BouncingBall/README.md b/src/example_bouncing_ball/README.md
similarity index 100%
rename from src/Example_BouncingBall/README.md
rename to src/example_bouncing_ball/README.md
diff --git a/src/Example_BouncingBall/Simulate_BouncingBall.py b/src/example_bouncing_ball/Simulate_BouncingBall.py
similarity index 100%
rename from src/Example_BouncingBall/Simulate_BouncingBall.py
rename to src/example_bouncing_ball/Simulate_BouncingBall.py
diff --git a/src/feature_model.py b/src/feature_model/feature_model.py
similarity index 100%
rename from src/feature_model.py
rename to src/feature_model/feature_model.py
diff --git a/src/modelica.g4 b/src/feature_model/modelica.g4
similarity index 100%
rename from src/modelica.g4
rename to src/feature_model/modelica.g4
diff --git a/src/feature_model/modelicaLexer.py b/src/feature_model/modelicaLexer.py
new file mode 100644
index 0000000..bd4ab23
--- /dev/null
+++ b/src/feature_model/modelicaLexer.py
@@ -0,0 +1,450 @@
+# Generated from modelica.g4 by ANTLR 4.13.1
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+ from typing import TextIO
+else:
+ from typing.io import TextIO
+
+
+def serializedATN():
+ return [
+ 4,0,94,797,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,
+ 2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,
+ 13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,
+ 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,
+ 26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,
+ 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,
+ 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,
+ 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,
+ 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,
+ 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,
+ 65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,
+ 71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,
+ 78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,
+ 84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,
+ 91,7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,
+ 97,2,98,7,98,2,99,7,99,2,100,7,100,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,
+ 1,1,1,1,2,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,
+ 3,1,3,1,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,5,1,5,1,5,1,
+ 5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,
+ 7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,
+ 10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,
+ 11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,12,1,13,1,
+ 13,1,13,1,13,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,14,1,15,1,
+ 15,1,15,1,15,1,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,
+ 16,1,16,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,
+ 18,1,19,1,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,
+ 20,1,20,1,21,1,21,1,22,1,22,1,23,1,23,1,24,1,24,1,24,1,24,1,25,1,
+ 25,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,
+ 27,1,27,1,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,
+ 28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,30,1,30,1,
+ 30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,
+ 32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,
+ 33,1,33,1,33,1,34,1,34,1,34,1,35,1,35,1,35,1,36,1,36,1,37,1,37,1,
+ 37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,38,1,
+ 38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,40,1,40,1,
+ 40,1,40,1,40,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41,1,
+ 41,1,41,1,41,1,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,
+ 43,1,43,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,
+ 45,1,45,1,45,1,46,1,46,1,46,1,47,1,47,1,47,1,47,1,47,1,48,1,48,1,
+ 48,1,48,1,48,1,48,1,48,1,48,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,
+ 49,1,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,51,1,
+ 51,1,51,1,51,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,53,1,
+ 53,1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,55,1,55,1,
+ 55,1,55,1,55,1,56,1,56,1,56,1,56,1,57,1,57,1,57,1,57,1,57,1,58,1,
+ 58,1,58,1,59,1,59,1,59,1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,60,1,
+ 61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,
+ 62,1,62,1,62,1,62,1,63,1,63,1,63,1,64,1,64,1,64,1,64,1,65,1,65,1,
+ 65,1,65,1,66,1,66,1,67,1,67,1,67,1,68,1,68,1,69,1,69,1,69,1,70,1,
+ 70,1,70,1,71,1,71,1,71,1,72,1,72,1,73,1,73,1,74,1,74,1,74,1,75,1,
+ 75,1,75,1,76,1,76,1,77,1,77,1,78,1,78,1,78,1,79,1,79,1,80,1,80,1,
+ 80,1,81,1,81,1,81,1,81,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,83,1,
+ 83,1,84,1,84,1,85,1,85,1,86,1,86,1,87,1,87,1,87,1,87,1,87,1,87,1,
+ 87,1,87,1,87,1,87,1,87,1,88,1,88,1,88,5,88,699,8,88,10,88,12,88,
+ 702,9,88,1,88,3,88,705,8,88,1,89,1,89,1,89,3,89,710,8,89,1,89,1,
+ 89,5,89,714,8,89,10,89,12,89,717,9,89,1,89,1,89,1,90,1,90,1,91,1,
+ 91,1,92,1,92,1,92,5,92,728,8,92,10,92,12,92,731,9,92,1,92,1,92,1,
+ 93,1,93,1,93,3,93,738,8,93,1,94,1,94,1,94,1,95,1,95,1,96,1,96,5,
+ 96,747,8,96,10,96,12,96,750,9,96,1,97,1,97,1,97,3,97,755,8,97,3,
+ 97,757,8,97,1,97,1,97,3,97,761,8,97,1,97,3,97,764,8,97,1,98,4,98,
+ 767,8,98,11,98,12,98,768,1,98,1,98,1,99,1,99,1,99,1,99,5,99,777,
+ 8,99,10,99,12,99,780,9,99,1,99,1,99,1,99,1,99,1,99,1,100,1,100,1,
+ 100,1,100,5,100,791,8,100,10,100,12,100,794,9,100,1,100,1,100,1,
+ 778,0,101,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,
+ 12,25,13,27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,43,22,45,
+ 23,47,24,49,25,51,26,53,27,55,28,57,29,59,30,61,31,63,32,65,33,67,
+ 34,69,35,71,36,73,37,75,38,77,39,79,40,81,41,83,42,85,43,87,44,89,
+ 45,91,46,93,47,95,48,97,49,99,50,101,51,103,52,105,53,107,54,109,
+ 55,111,56,113,57,115,58,117,59,119,60,121,61,123,62,125,63,127,64,
+ 129,65,131,66,133,67,135,68,137,69,139,70,141,71,143,72,145,73,147,
+ 74,149,75,151,76,153,77,155,78,157,79,159,80,161,81,163,82,165,83,
+ 167,84,169,85,171,86,173,87,175,88,177,89,179,0,181,0,183,0,185,
+ 90,187,0,189,0,191,0,193,0,195,91,197,92,199,93,201,94,1,0,8,2,0,
+ 34,34,92,92,3,0,65,90,95,95,97,122,7,0,33,33,35,38,40,47,58,64,91,
+ 91,93,94,123,126,11,0,34,34,39,39,63,63,92,92,97,98,102,102,110,
+ 110,114,114,116,116,118,118,8217,8217,2,0,69,69,101,101,2,0,43,43,
+ 45,45,3,0,9,10,13,13,32,32,2,0,10,10,13,13,807,0,1,1,0,0,0,0,3,1,
+ 0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,
+ 0,0,0,15,1,0,0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,
+ 0,0,0,25,1,0,0,0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,
+ 0,0,0,35,1,0,0,0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,
+ 0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,
+ 0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,
+ 0,0,0,65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,
+ 0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,
+ 0,0,0,85,1,0,0,0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0,
+ 0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1,
+ 0,0,0,0,105,1,0,0,0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0,
+ 113,1,0,0,0,0,115,1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0,
+ 0,0,0,123,1,0,0,0,0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0,0,0,0,131,
+ 1,0,0,0,0,133,1,0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0,0,0,
+ 0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0,147,1,0,0,0,0,149,1,
+ 0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0,157,1,0,0,0,0,
+ 159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0,0,167,1,0,
+ 0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1,0,0,0,0,177,
+ 1,0,0,0,0,185,1,0,0,0,0,195,1,0,0,0,0,197,1,0,0,0,0,199,1,0,0,0,
+ 0,201,1,0,0,0,1,203,1,0,0,0,3,210,1,0,0,0,5,212,1,0,0,0,7,218,1,
+ 0,0,0,9,231,1,0,0,0,11,239,1,0,0,0,13,245,1,0,0,0,15,251,1,0,0,0,
+ 17,260,1,0,0,0,19,267,1,0,0,0,21,273,1,0,0,0,23,284,1,0,0,0,25,294,
+ 1,0,0,0,27,299,1,0,0,0,29,307,1,0,0,0,31,312,1,0,0,0,33,319,1,0,
+ 0,0,35,328,1,0,0,0,37,332,1,0,0,0,39,340,1,0,0,0,41,342,1,0,0,0,
+ 43,354,1,0,0,0,45,356,1,0,0,0,47,358,1,0,0,0,49,360,1,0,0,0,51,364,
+ 1,0,0,0,53,366,1,0,0,0,55,373,1,0,0,0,57,383,1,0,0,0,59,392,1,0,
+ 0,0,61,402,1,0,0,0,63,408,1,0,0,0,65,414,1,0,0,0,67,426,1,0,0,0,
+ 69,433,1,0,0,0,71,436,1,0,0,0,73,439,1,0,0,0,75,441,1,0,0,0,77,455,
+ 1,0,0,0,79,460,1,0,0,0,81,467,1,0,0,0,83,476,1,0,0,0,85,486,1,0,
+ 0,0,87,495,1,0,0,0,89,501,1,0,0,0,91,508,1,0,0,0,93,511,1,0,0,0,
+ 95,514,1,0,0,0,97,519,1,0,0,0,99,527,1,0,0,0,101,536,1,0,0,0,103,
+ 546,1,0,0,0,105,552,1,0,0,0,107,559,1,0,0,0,109,564,1,0,0,0,111,
+ 571,1,0,0,0,113,576,1,0,0,0,115,580,1,0,0,0,117,585,1,0,0,0,119,
+ 588,1,0,0,0,121,594,1,0,0,0,123,599,1,0,0,0,125,608,1,0,0,0,127,
+ 616,1,0,0,0,129,619,1,0,0,0,131,623,1,0,0,0,133,627,1,0,0,0,135,
+ 629,1,0,0,0,137,632,1,0,0,0,139,634,1,0,0,0,141,637,1,0,0,0,143,
+ 640,1,0,0,0,145,643,1,0,0,0,147,645,1,0,0,0,149,647,1,0,0,0,151,
+ 650,1,0,0,0,153,653,1,0,0,0,155,655,1,0,0,0,157,657,1,0,0,0,159,
+ 660,1,0,0,0,161,662,1,0,0,0,163,665,1,0,0,0,165,671,1,0,0,0,167,
+ 676,1,0,0,0,169,678,1,0,0,0,171,680,1,0,0,0,173,682,1,0,0,0,175,
+ 684,1,0,0,0,177,704,1,0,0,0,179,706,1,0,0,0,181,720,1,0,0,0,183,
+ 722,1,0,0,0,185,724,1,0,0,0,187,737,1,0,0,0,189,739,1,0,0,0,191,
+ 742,1,0,0,0,193,744,1,0,0,0,195,751,1,0,0,0,197,766,1,0,0,0,199,
+ 772,1,0,0,0,201,786,1,0,0,0,203,204,5,119,0,0,204,205,5,105,0,0,
+ 205,206,5,116,0,0,206,207,5,104,0,0,207,208,5,105,0,0,208,209,5,
+ 110,0,0,209,2,1,0,0,0,210,211,5,59,0,0,211,4,1,0,0,0,212,213,5,102,
+ 0,0,213,214,5,105,0,0,214,215,5,110,0,0,215,216,5,97,0,0,216,217,
+ 5,108,0,0,217,6,1,0,0,0,218,219,5,101,0,0,219,220,5,110,0,0,220,
+ 221,5,99,0,0,221,222,5,97,0,0,222,223,5,112,0,0,223,224,5,115,0,
+ 0,224,225,5,117,0,0,225,226,5,108,0,0,226,227,5,97,0,0,227,228,5,
+ 116,0,0,228,229,5,101,0,0,229,230,5,100,0,0,230,8,1,0,0,0,231,232,
+ 5,112,0,0,232,233,5,97,0,0,233,234,5,114,0,0,234,235,5,116,0,0,235,
+ 236,5,105,0,0,236,237,5,97,0,0,237,238,5,108,0,0,238,10,1,0,0,0,
+ 239,240,5,99,0,0,240,241,5,108,0,0,241,242,5,97,0,0,242,243,5,115,
+ 0,0,243,244,5,115,0,0,244,12,1,0,0,0,245,246,5,109,0,0,246,247,5,
+ 111,0,0,247,248,5,100,0,0,248,249,5,101,0,0,249,250,5,108,0,0,250,
+ 14,1,0,0,0,251,252,5,111,0,0,252,253,5,112,0,0,253,254,5,101,0,0,
+ 254,255,5,114,0,0,255,256,5,97,0,0,256,257,5,116,0,0,257,258,5,111,
+ 0,0,258,259,5,114,0,0,259,16,1,0,0,0,260,261,5,114,0,0,261,262,5,
+ 101,0,0,262,263,5,99,0,0,263,264,5,111,0,0,264,265,5,114,0,0,265,
+ 266,5,100,0,0,266,18,1,0,0,0,267,268,5,98,0,0,268,269,5,108,0,0,
+ 269,270,5,111,0,0,270,271,5,99,0,0,271,272,5,107,0,0,272,20,1,0,
+ 0,0,273,274,5,101,0,0,274,275,5,120,0,0,275,276,5,112,0,0,276,277,
+ 5,97,0,0,277,278,5,110,0,0,278,279,5,100,0,0,279,280,5,97,0,0,280,
+ 281,5,98,0,0,281,282,5,108,0,0,282,283,5,101,0,0,283,22,1,0,0,0,
+ 284,285,5,99,0,0,285,286,5,111,0,0,286,287,5,110,0,0,287,288,5,110,
+ 0,0,288,289,5,101,0,0,289,290,5,99,0,0,290,291,5,116,0,0,291,292,
+ 5,111,0,0,292,293,5,114,0,0,293,24,1,0,0,0,294,295,5,116,0,0,295,
+ 296,5,121,0,0,296,297,5,112,0,0,297,298,5,101,0,0,298,26,1,0,0,0,
+ 299,300,5,112,0,0,300,301,5,97,0,0,301,302,5,99,0,0,302,303,5,107,
+ 0,0,303,304,5,97,0,0,304,305,5,103,0,0,305,306,5,101,0,0,306,28,
+ 1,0,0,0,307,308,5,112,0,0,308,309,5,117,0,0,309,310,5,114,0,0,310,
+ 311,5,101,0,0,311,30,1,0,0,0,312,313,5,105,0,0,313,314,5,109,0,0,
+ 314,315,5,112,0,0,315,316,5,117,0,0,316,317,5,114,0,0,317,318,5,
+ 101,0,0,318,32,1,0,0,0,319,320,5,102,0,0,320,321,5,117,0,0,321,322,
+ 5,110,0,0,322,323,5,99,0,0,323,324,5,116,0,0,324,325,5,105,0,0,325,
+ 326,5,111,0,0,326,327,5,110,0,0,327,34,1,0,0,0,328,329,5,101,0,0,
+ 329,330,5,110,0,0,330,331,5,100,0,0,331,36,1,0,0,0,332,333,5,101,
+ 0,0,333,334,5,120,0,0,334,335,5,116,0,0,335,336,5,101,0,0,336,337,
+ 5,110,0,0,337,338,5,100,0,0,338,339,5,115,0,0,339,38,1,0,0,0,340,
+ 341,5,61,0,0,341,40,1,0,0,0,342,343,5,101,0,0,343,344,5,110,0,0,
+ 344,345,5,117,0,0,345,346,5,109,0,0,346,347,5,101,0,0,347,348,5,
+ 114,0,0,348,349,5,97,0,0,349,350,5,116,0,0,350,351,5,105,0,0,351,
+ 352,5,111,0,0,352,353,5,110,0,0,353,42,1,0,0,0,354,355,5,40,0,0,
+ 355,44,1,0,0,0,356,357,5,58,0,0,357,46,1,0,0,0,358,359,5,41,0,0,
+ 359,48,1,0,0,0,360,361,5,100,0,0,361,362,5,101,0,0,362,363,5,114,
+ 0,0,363,50,1,0,0,0,364,365,5,44,0,0,365,52,1,0,0,0,366,367,5,112,
+ 0,0,367,368,5,117,0,0,368,369,5,98,0,0,369,370,5,108,0,0,370,371,
+ 5,105,0,0,371,372,5,99,0,0,372,54,1,0,0,0,373,374,5,112,0,0,374,
+ 375,5,114,0,0,375,376,5,111,0,0,376,377,5,116,0,0,377,378,5,101,
+ 0,0,378,379,5,99,0,0,379,380,5,116,0,0,380,381,5,101,0,0,381,382,
+ 5,100,0,0,382,56,1,0,0,0,383,384,5,101,0,0,384,385,5,120,0,0,385,
+ 386,5,116,0,0,386,387,5,101,0,0,387,388,5,114,0,0,388,389,5,110,
+ 0,0,389,390,5,97,0,0,390,391,5,108,0,0,391,58,1,0,0,0,392,393,5,
+ 114,0,0,393,394,5,101,0,0,394,395,5,100,0,0,395,396,5,101,0,0,396,
+ 397,5,99,0,0,397,398,5,108,0,0,398,399,5,97,0,0,399,400,5,114,0,
+ 0,400,401,5,101,0,0,401,60,1,0,0,0,402,403,5,105,0,0,403,404,5,110,
+ 0,0,404,405,5,110,0,0,405,406,5,101,0,0,406,407,5,114,0,0,407,62,
+ 1,0,0,0,408,409,5,111,0,0,409,410,5,117,0,0,410,411,5,116,0,0,411,
+ 412,5,101,0,0,412,413,5,114,0,0,413,64,1,0,0,0,414,415,5,114,0,0,
+ 415,416,5,101,0,0,416,417,5,112,0,0,417,418,5,108,0,0,418,419,5,
+ 97,0,0,419,420,5,99,0,0,420,421,5,101,0,0,421,422,5,97,0,0,422,423,
+ 5,98,0,0,423,424,5,108,0,0,424,425,5,101,0,0,425,66,1,0,0,0,426,
+ 427,5,105,0,0,427,428,5,109,0,0,428,429,5,112,0,0,429,430,5,111,
+ 0,0,430,431,5,114,0,0,431,432,5,116,0,0,432,68,1,0,0,0,433,434,5,
+ 46,0,0,434,435,5,42,0,0,435,70,1,0,0,0,436,437,5,46,0,0,437,438,
+ 5,123,0,0,438,72,1,0,0,0,439,440,5,125,0,0,440,74,1,0,0,0,441,442,
+ 5,99,0,0,442,443,5,111,0,0,443,444,5,110,0,0,444,445,5,115,0,0,445,
+ 446,5,116,0,0,446,447,5,114,0,0,447,448,5,97,0,0,448,449,5,105,0,
+ 0,449,450,5,110,0,0,450,451,5,101,0,0,451,452,5,100,0,0,452,453,
+ 5,98,0,0,453,454,5,121,0,0,454,76,1,0,0,0,455,456,5,102,0,0,456,
+ 457,5,108,0,0,457,458,5,111,0,0,458,459,5,119,0,0,459,78,1,0,0,0,
+ 460,461,5,115,0,0,461,462,5,116,0,0,462,463,5,114,0,0,463,464,5,
+ 101,0,0,464,465,5,97,0,0,465,466,5,109,0,0,466,80,1,0,0,0,467,468,
+ 5,100,0,0,468,469,5,105,0,0,469,470,5,115,0,0,470,471,5,99,0,0,471,
+ 472,5,114,0,0,472,473,5,101,0,0,473,474,5,116,0,0,474,475,5,101,
+ 0,0,475,82,1,0,0,0,476,477,5,112,0,0,477,478,5,97,0,0,478,479,5,
+ 114,0,0,479,480,5,97,0,0,480,481,5,109,0,0,481,482,5,101,0,0,482,
+ 483,5,116,0,0,483,484,5,101,0,0,484,485,5,114,0,0,485,84,1,0,0,0,
+ 486,487,5,99,0,0,487,488,5,111,0,0,488,489,5,110,0,0,489,490,5,115,
+ 0,0,490,491,5,116,0,0,491,492,5,97,0,0,492,493,5,110,0,0,493,494,
+ 5,116,0,0,494,86,1,0,0,0,495,496,5,105,0,0,496,497,5,110,0,0,497,
+ 498,5,112,0,0,498,499,5,117,0,0,499,500,5,116,0,0,500,88,1,0,0,0,
+ 501,502,5,111,0,0,502,503,5,117,0,0,503,504,5,116,0,0,504,505,5,
+ 112,0,0,505,506,5,117,0,0,506,507,5,116,0,0,507,90,1,0,0,0,508,509,
+ 5,105,0,0,509,510,5,102,0,0,510,92,1,0,0,0,511,512,5,58,0,0,512,
+ 513,5,61,0,0,513,94,1,0,0,0,514,515,5,101,0,0,515,516,5,97,0,0,516,
+ 517,5,99,0,0,517,518,5,104,0,0,518,96,1,0,0,0,519,520,5,105,0,0,
+ 520,521,5,110,0,0,521,522,5,105,0,0,522,523,5,116,0,0,523,524,5,
+ 105,0,0,524,525,5,97,0,0,525,526,5,108,0,0,526,98,1,0,0,0,527,528,
+ 5,101,0,0,528,529,5,113,0,0,529,530,5,117,0,0,530,531,5,97,0,0,531,
+ 532,5,116,0,0,532,533,5,105,0,0,533,534,5,111,0,0,534,535,5,110,
+ 0,0,535,100,1,0,0,0,536,537,5,97,0,0,537,538,5,108,0,0,538,539,5,
+ 103,0,0,539,540,5,111,0,0,540,541,5,114,0,0,541,542,5,105,0,0,542,
+ 543,5,116,0,0,543,544,5,104,0,0,544,545,5,109,0,0,545,102,1,0,0,
+ 0,546,547,5,98,0,0,547,548,5,114,0,0,548,549,5,101,0,0,549,550,5,
+ 97,0,0,550,551,5,107,0,0,551,104,1,0,0,0,552,553,5,114,0,0,553,554,
+ 5,101,0,0,554,555,5,116,0,0,555,556,5,117,0,0,556,557,5,114,0,0,
+ 557,558,5,110,0,0,558,106,1,0,0,0,559,560,5,116,0,0,560,561,5,104,
+ 0,0,561,562,5,101,0,0,562,563,5,110,0,0,563,108,1,0,0,0,564,565,
+ 5,101,0,0,565,566,5,108,0,0,566,567,5,115,0,0,567,568,5,101,0,0,
+ 568,569,5,105,0,0,569,570,5,102,0,0,570,110,1,0,0,0,571,572,5,101,
+ 0,0,572,573,5,108,0,0,573,574,5,115,0,0,574,575,5,101,0,0,575,112,
+ 1,0,0,0,576,577,5,102,0,0,577,578,5,111,0,0,578,579,5,114,0,0,579,
+ 114,1,0,0,0,580,581,5,108,0,0,581,582,5,111,0,0,582,583,5,111,0,
+ 0,583,584,5,112,0,0,584,116,1,0,0,0,585,586,5,105,0,0,586,587,5,
+ 110,0,0,587,118,1,0,0,0,588,589,5,119,0,0,589,590,5,104,0,0,590,
+ 591,5,105,0,0,591,592,5,108,0,0,592,593,5,101,0,0,593,120,1,0,0,
+ 0,594,595,5,119,0,0,595,596,5,104,0,0,596,597,5,101,0,0,597,598,
+ 5,110,0,0,598,122,1,0,0,0,599,600,5,101,0,0,600,601,5,108,0,0,601,
+ 602,5,115,0,0,602,603,5,101,0,0,603,604,5,119,0,0,604,605,5,104,
+ 0,0,605,606,5,101,0,0,606,607,5,110,0,0,607,124,1,0,0,0,608,609,
+ 5,99,0,0,609,610,5,111,0,0,610,611,5,110,0,0,611,612,5,110,0,0,612,
+ 613,5,101,0,0,613,614,5,99,0,0,614,615,5,116,0,0,615,126,1,0,0,0,
+ 616,617,5,111,0,0,617,618,5,114,0,0,618,128,1,0,0,0,619,620,5,97,
+ 0,0,620,621,5,110,0,0,621,622,5,100,0,0,622,130,1,0,0,0,623,624,
+ 5,110,0,0,624,625,5,111,0,0,625,626,5,116,0,0,626,132,1,0,0,0,627,
+ 628,5,60,0,0,628,134,1,0,0,0,629,630,5,60,0,0,630,631,5,61,0,0,631,
+ 136,1,0,0,0,632,633,5,62,0,0,633,138,1,0,0,0,634,635,5,62,0,0,635,
+ 636,5,61,0,0,636,140,1,0,0,0,637,638,5,61,0,0,638,639,5,61,0,0,639,
+ 142,1,0,0,0,640,641,5,60,0,0,641,642,5,62,0,0,642,144,1,0,0,0,643,
+ 644,5,43,0,0,644,146,1,0,0,0,645,646,5,45,0,0,646,148,1,0,0,0,647,
+ 648,5,46,0,0,648,649,5,43,0,0,649,150,1,0,0,0,650,651,5,46,0,0,651,
+ 652,5,45,0,0,652,152,1,0,0,0,653,654,5,42,0,0,654,154,1,0,0,0,655,
+ 656,5,47,0,0,656,156,1,0,0,0,657,658,5,46,0,0,658,659,5,47,0,0,659,
+ 158,1,0,0,0,660,661,5,94,0,0,661,160,1,0,0,0,662,663,5,46,0,0,663,
+ 664,5,94,0,0,664,162,1,0,0,0,665,666,5,102,0,0,666,667,5,97,0,0,
+ 667,668,5,108,0,0,668,669,5,115,0,0,669,670,5,101,0,0,670,164,1,
+ 0,0,0,671,672,5,116,0,0,672,673,5,114,0,0,673,674,5,117,0,0,674,
+ 675,5,101,0,0,675,166,1,0,0,0,676,677,5,91,0,0,677,168,1,0,0,0,678,
+ 679,5,93,0,0,679,170,1,0,0,0,680,681,5,123,0,0,681,172,1,0,0,0,682,
+ 683,5,46,0,0,683,174,1,0,0,0,684,685,5,97,0,0,685,686,5,110,0,0,
+ 686,687,5,110,0,0,687,688,5,111,0,0,688,689,5,116,0,0,689,690,5,
+ 97,0,0,690,691,5,116,0,0,691,692,5,105,0,0,692,693,5,111,0,0,693,
+ 694,5,110,0,0,694,176,1,0,0,0,695,700,3,183,91,0,696,699,3,191,95,
+ 0,697,699,3,183,91,0,698,696,1,0,0,0,698,697,1,0,0,0,699,702,1,0,
+ 0,0,700,698,1,0,0,0,700,701,1,0,0,0,701,705,1,0,0,0,702,700,1,0,
+ 0,0,703,705,3,179,89,0,704,695,1,0,0,0,704,703,1,0,0,0,705,178,1,
+ 0,0,0,706,709,5,39,0,0,707,710,3,187,93,0,708,710,3,189,94,0,709,
+ 707,1,0,0,0,709,708,1,0,0,0,710,715,1,0,0,0,711,714,3,187,93,0,712,
+ 714,3,189,94,0,713,711,1,0,0,0,713,712,1,0,0,0,714,717,1,0,0,0,715,
+ 713,1,0,0,0,715,716,1,0,0,0,716,718,1,0,0,0,717,715,1,0,0,0,718,
+ 719,5,39,0,0,719,180,1,0,0,0,720,721,8,0,0,0,721,182,1,0,0,0,722,
+ 723,7,1,0,0,723,184,1,0,0,0,724,729,5,34,0,0,725,728,3,181,90,0,
+ 726,728,3,189,94,0,727,725,1,0,0,0,727,726,1,0,0,0,728,731,1,0,0,
+ 0,729,727,1,0,0,0,729,730,1,0,0,0,730,732,1,0,0,0,731,729,1,0,0,
+ 0,732,733,5,34,0,0,733,186,1,0,0,0,734,738,3,183,91,0,735,738,3,
+ 191,95,0,736,738,7,2,0,0,737,734,1,0,0,0,737,735,1,0,0,0,737,736,
+ 1,0,0,0,738,188,1,0,0,0,739,740,5,92,0,0,740,741,7,3,0,0,741,190,
+ 1,0,0,0,742,743,2,48,57,0,743,192,1,0,0,0,744,748,3,191,95,0,745,
+ 747,3,191,95,0,746,745,1,0,0,0,747,750,1,0,0,0,748,746,1,0,0,0,748,
+ 749,1,0,0,0,749,194,1,0,0,0,750,748,1,0,0,0,751,756,3,193,96,0,752,
+ 754,5,46,0,0,753,755,3,193,96,0,754,753,1,0,0,0,754,755,1,0,0,0,
+ 755,757,1,0,0,0,756,752,1,0,0,0,756,757,1,0,0,0,757,763,1,0,0,0,
+ 758,760,7,4,0,0,759,761,7,5,0,0,760,759,1,0,0,0,760,761,1,0,0,0,
+ 761,762,1,0,0,0,762,764,3,193,96,0,763,758,1,0,0,0,763,764,1,0,0,
+ 0,764,196,1,0,0,0,765,767,7,6,0,0,766,765,1,0,0,0,767,768,1,0,0,
+ 0,768,766,1,0,0,0,768,769,1,0,0,0,769,770,1,0,0,0,770,771,6,98,0,
+ 0,771,198,1,0,0,0,772,773,5,47,0,0,773,774,5,42,0,0,774,778,1,0,
+ 0,0,775,777,9,0,0,0,776,775,1,0,0,0,777,780,1,0,0,0,778,779,1,0,
+ 0,0,778,776,1,0,0,0,779,781,1,0,0,0,780,778,1,0,0,0,781,782,5,42,
+ 0,0,782,783,5,47,0,0,783,784,1,0,0,0,784,785,6,99,0,0,785,200,1,
+ 0,0,0,786,787,5,47,0,0,787,788,5,47,0,0,788,792,1,0,0,0,789,791,
+ 8,7,0,0,790,789,1,0,0,0,791,794,1,0,0,0,792,790,1,0,0,0,792,793,
+ 1,0,0,0,793,795,1,0,0,0,794,792,1,0,0,0,795,796,6,100,0,0,796,202,
+ 1,0,0,0,18,0,698,700,704,709,713,715,727,729,737,748,754,756,760,
+ 763,768,778,792,1,0,1,0
+ ]
+
+class modelicaLexer(Lexer):
+
+ atn = ATNDeserializer().deserialize(serializedATN())
+
+ decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+ T__0 = 1
+ T__1 = 2
+ T__2 = 3
+ T__3 = 4
+ T__4 = 5
+ T__5 = 6
+ T__6 = 7
+ T__7 = 8
+ T__8 = 9
+ T__9 = 10
+ T__10 = 11
+ T__11 = 12
+ T__12 = 13
+ T__13 = 14
+ T__14 = 15
+ T__15 = 16
+ T__16 = 17
+ T__17 = 18
+ T__18 = 19
+ T__19 = 20
+ T__20 = 21
+ T__21 = 22
+ T__22 = 23
+ T__23 = 24
+ T__24 = 25
+ T__25 = 26
+ T__26 = 27
+ T__27 = 28
+ T__28 = 29
+ T__29 = 30
+ T__30 = 31
+ T__31 = 32
+ T__32 = 33
+ T__33 = 34
+ T__34 = 35
+ T__35 = 36
+ T__36 = 37
+ T__37 = 38
+ T__38 = 39
+ T__39 = 40
+ T__40 = 41
+ T__41 = 42
+ T__42 = 43
+ T__43 = 44
+ T__44 = 45
+ T__45 = 46
+ T__46 = 47
+ T__47 = 48
+ T__48 = 49
+ T__49 = 50
+ T__50 = 51
+ T__51 = 52
+ T__52 = 53
+ T__53 = 54
+ T__54 = 55
+ T__55 = 56
+ T__56 = 57
+ T__57 = 58
+ T__58 = 59
+ T__59 = 60
+ T__60 = 61
+ T__61 = 62
+ T__62 = 63
+ T__63 = 64
+ T__64 = 65
+ T__65 = 66
+ T__66 = 67
+ T__67 = 68
+ T__68 = 69
+ T__69 = 70
+ T__70 = 71
+ T__71 = 72
+ T__72 = 73
+ T__73 = 74
+ T__74 = 75
+ T__75 = 76
+ T__76 = 77
+ T__77 = 78
+ T__78 = 79
+ T__79 = 80
+ T__80 = 81
+ T__81 = 82
+ T__82 = 83
+ T__83 = 84
+ T__84 = 85
+ T__85 = 86
+ T__86 = 87
+ T__87 = 88
+ IDENT = 89
+ STRING = 90
+ UNSIGNED_NUMBER = 91
+ WS = 92
+ COMMENT = 93
+ LINE_COMMENT = 94
+
+ channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+ modeNames = [ "DEFAULT_MODE" ]
+
+ literalNames = [ "<INVALID>",
+ "'within'", "';'", "'final'", "'encapsulated'", "'partial'",
+ "'class'", "'model'", "'operator'", "'record'", "'block'", "'expandable'",
+ "'connector'", "'type'", "'package'", "'pure'", "'impure'",
+ "'function'", "'end'", "'extends'", "'='", "'enumeration'",
+ "'('", "':'", "')'", "'der'", "','", "'public'", "'protected'",
+ "'external'", "'redeclare'", "'inner'", "'outer'", "'replaceable'",
+ "'import'", "'.*'", "'.{'", "'}'", "'constrainedby'", "'flow'",
+ "'stream'", "'discrete'", "'parameter'", "'constant'", "'input'",
+ "'output'", "'if'", "':='", "'each'", "'initial'", "'equation'",
+ "'algorithm'", "'break'", "'return'", "'then'", "'elseif'",
+ "'else'", "'for'", "'loop'", "'in'", "'while'", "'when'", "'elsewhen'",
+ "'connect'", "'or'", "'and'", "'not'", "'<'", "'<='", "'>'",
+ "'>='", "'=='", "'<>'", "'+'", "'-'", "'.+'", "'.-'", "'*'",
+ "'/'", "'./'", "'^'", "'.^'", "'false'", "'true'", "'['", "']'",
+ "'{'", "'.'", "'annotation'" ]
+
+ symbolicNames = [ "<INVALID>",
+ "IDENT", "STRING", "UNSIGNED_NUMBER", "WS", "COMMENT", "LINE_COMMENT" ]
+
+ ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6",
+ "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13",
+ "T__14", "T__15", "T__16", "T__17", "T__18", "T__19",
+ "T__20", "T__21", "T__22", "T__23", "T__24", "T__25",
+ "T__26", "T__27", "T__28", "T__29", "T__30", "T__31",
+ "T__32", "T__33", "T__34", "T__35", "T__36", "T__37",
+ "T__38", "T__39", "T__40", "T__41", "T__42", "T__43",
+ "T__44", "T__45", "T__46", "T__47", "T__48", "T__49",
+ "T__50", "T__51", "T__52", "T__53", "T__54", "T__55",
+ "T__56", "T__57", "T__58", "T__59", "T__60", "T__61",
+ "T__62", "T__63", "T__64", "T__65", "T__66", "T__67",
+ "T__68", "T__69", "T__70", "T__71", "T__72", "T__73",
+ "T__74", "T__75", "T__76", "T__77", "T__78", "T__79",
+ "T__80", "T__81", "T__82", "T__83", "T__84", "T__85",
+ "T__86", "T__87", "IDENT", "Q_IDENT", "S_CHAR", "NONDIGIT",
+ "STRING", "Q_CHAR", "S_ESCAPE", "DIGIT", "UNSIGNED_INTEGER",
+ "UNSIGNED_NUMBER", "WS", "COMMENT", "LINE_COMMENT" ]
+
+ grammarFileName = "modelica.g4"
+
+ def __init__(self, input=None, output:TextIO = sys.stdout):
+ super().__init__(input, output)
+ self.checkVersion("4.13.1")
+ self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+ self._actions = None
+ self._predicates = None
+
+
diff --git a/src/feature_model/modelicaListener.py b/src/feature_model/modelicaListener.py
new file mode 100644
index 0000000..a5ce594
--- /dev/null
+++ b/src/feature_model/modelicaListener.py
@@ -0,0 +1,714 @@
+# Generated from modelica.g4 by ANTLR 4.13.1
+from antlr4 import *
+if "." in __name__:
+ from .modelicaParser import modelicaParser
+else:
+ from modelicaParser import modelicaParser
+
+# This class defines a complete listener for a parse tree produced by modelicaParser.
+class modelicaListener(ParseTreeListener):
+
+ # Enter a parse tree produced by modelicaParser#stored_definition.
+ def enterStored_definition(self, ctx:modelicaParser.Stored_definitionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#stored_definition.
+ def exitStored_definition(self, ctx:modelicaParser.Stored_definitionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#class_definition.
+ def enterClass_definition(self, ctx:modelicaParser.Class_definitionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#class_definition.
+ def exitClass_definition(self, ctx:modelicaParser.Class_definitionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#class_specifier.
+ def enterClass_specifier(self, ctx:modelicaParser.Class_specifierContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#class_specifier.
+ def exitClass_specifier(self, ctx:modelicaParser.Class_specifierContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#class_prefixes.
+ def enterClass_prefixes(self, ctx:modelicaParser.Class_prefixesContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#class_prefixes.
+ def exitClass_prefixes(self, ctx:modelicaParser.Class_prefixesContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#long_class_specifier.
+ def enterLong_class_specifier(self, ctx:modelicaParser.Long_class_specifierContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#long_class_specifier.
+ def exitLong_class_specifier(self, ctx:modelicaParser.Long_class_specifierContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#short_class_specifier.
+ def enterShort_class_specifier(self, ctx:modelicaParser.Short_class_specifierContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#short_class_specifier.
+ def exitShort_class_specifier(self, ctx:modelicaParser.Short_class_specifierContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#der_class_specifier.
+ def enterDer_class_specifier(self, ctx:modelicaParser.Der_class_specifierContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#der_class_specifier.
+ def exitDer_class_specifier(self, ctx:modelicaParser.Der_class_specifierContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#base_prefix.
+ def enterBase_prefix(self, ctx:modelicaParser.Base_prefixContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#base_prefix.
+ def exitBase_prefix(self, ctx:modelicaParser.Base_prefixContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#enum_list.
+ def enterEnum_list(self, ctx:modelicaParser.Enum_listContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#enum_list.
+ def exitEnum_list(self, ctx:modelicaParser.Enum_listContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#enumeration_literal.
+ def enterEnumeration_literal(self, ctx:modelicaParser.Enumeration_literalContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#enumeration_literal.
+ def exitEnumeration_literal(self, ctx:modelicaParser.Enumeration_literalContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#composition.
+ def enterComposition(self, ctx:modelicaParser.CompositionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#composition.
+ def exitComposition(self, ctx:modelicaParser.CompositionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#language_specification.
+ def enterLanguage_specification(self, ctx:modelicaParser.Language_specificationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#language_specification.
+ def exitLanguage_specification(self, ctx:modelicaParser.Language_specificationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#external_function_call.
+ def enterExternal_function_call(self, ctx:modelicaParser.External_function_callContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#external_function_call.
+ def exitExternal_function_call(self, ctx:modelicaParser.External_function_callContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#element_list.
+ def enterElement_list(self, ctx:modelicaParser.Element_listContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#element_list.
+ def exitElement_list(self, ctx:modelicaParser.Element_listContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#element.
+ def enterElement(self, ctx:modelicaParser.ElementContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#element.
+ def exitElement(self, ctx:modelicaParser.ElementContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#import_clause.
+ def enterImport_clause(self, ctx:modelicaParser.Import_clauseContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#import_clause.
+ def exitImport_clause(self, ctx:modelicaParser.Import_clauseContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#import_list.
+ def enterImport_list(self, ctx:modelicaParser.Import_listContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#import_list.
+ def exitImport_list(self, ctx:modelicaParser.Import_listContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#extends_clause.
+ def enterExtends_clause(self, ctx:modelicaParser.Extends_clauseContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#extends_clause.
+ def exitExtends_clause(self, ctx:modelicaParser.Extends_clauseContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#constraining_clause.
+ def enterConstraining_clause(self, ctx:modelicaParser.Constraining_clauseContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#constraining_clause.
+ def exitConstraining_clause(self, ctx:modelicaParser.Constraining_clauseContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#component_clause.
+ def enterComponent_clause(self, ctx:modelicaParser.Component_clauseContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#component_clause.
+ def exitComponent_clause(self, ctx:modelicaParser.Component_clauseContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#type_prefix.
+ def enterType_prefix(self, ctx:modelicaParser.Type_prefixContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#type_prefix.
+ def exitType_prefix(self, ctx:modelicaParser.Type_prefixContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#type_specifier.
+ def enterType_specifier(self, ctx:modelicaParser.Type_specifierContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#type_specifier.
+ def exitType_specifier(self, ctx:modelicaParser.Type_specifierContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#component_list.
+ def enterComponent_list(self, ctx:modelicaParser.Component_listContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#component_list.
+ def exitComponent_list(self, ctx:modelicaParser.Component_listContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#component_declaration.
+ def enterComponent_declaration(self, ctx:modelicaParser.Component_declarationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#component_declaration.
+ def exitComponent_declaration(self, ctx:modelicaParser.Component_declarationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#condition_attribute.
+ def enterCondition_attribute(self, ctx:modelicaParser.Condition_attributeContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#condition_attribute.
+ def exitCondition_attribute(self, ctx:modelicaParser.Condition_attributeContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#declaration.
+ def enterDeclaration(self, ctx:modelicaParser.DeclarationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#declaration.
+ def exitDeclaration(self, ctx:modelicaParser.DeclarationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#modification.
+ def enterModification(self, ctx:modelicaParser.ModificationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#modification.
+ def exitModification(self, ctx:modelicaParser.ModificationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#class_modification.
+ def enterClass_modification(self, ctx:modelicaParser.Class_modificationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#class_modification.
+ def exitClass_modification(self, ctx:modelicaParser.Class_modificationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#argument_list.
+ def enterArgument_list(self, ctx:modelicaParser.Argument_listContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#argument_list.
+ def exitArgument_list(self, ctx:modelicaParser.Argument_listContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#argument.
+ def enterArgument(self, ctx:modelicaParser.ArgumentContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#argument.
+ def exitArgument(self, ctx:modelicaParser.ArgumentContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#element_modification_or_replaceable.
+ def enterElement_modification_or_replaceable(self, ctx:modelicaParser.Element_modification_or_replaceableContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#element_modification_or_replaceable.
+ def exitElement_modification_or_replaceable(self, ctx:modelicaParser.Element_modification_or_replaceableContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#element_modification.
+ def enterElement_modification(self, ctx:modelicaParser.Element_modificationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#element_modification.
+ def exitElement_modification(self, ctx:modelicaParser.Element_modificationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#element_redeclaration.
+ def enterElement_redeclaration(self, ctx:modelicaParser.Element_redeclarationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#element_redeclaration.
+ def exitElement_redeclaration(self, ctx:modelicaParser.Element_redeclarationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#element_replaceable.
+ def enterElement_replaceable(self, ctx:modelicaParser.Element_replaceableContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#element_replaceable.
+ def exitElement_replaceable(self, ctx:modelicaParser.Element_replaceableContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#component_clause1.
+ def enterComponent_clause1(self, ctx:modelicaParser.Component_clause1Context):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#component_clause1.
+ def exitComponent_clause1(self, ctx:modelicaParser.Component_clause1Context):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#component_declaration1.
+ def enterComponent_declaration1(self, ctx:modelicaParser.Component_declaration1Context):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#component_declaration1.
+ def exitComponent_declaration1(self, ctx:modelicaParser.Component_declaration1Context):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#short_class_definition.
+ def enterShort_class_definition(self, ctx:modelicaParser.Short_class_definitionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#short_class_definition.
+ def exitShort_class_definition(self, ctx:modelicaParser.Short_class_definitionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#equation_section.
+ def enterEquation_section(self, ctx:modelicaParser.Equation_sectionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#equation_section.
+ def exitEquation_section(self, ctx:modelicaParser.Equation_sectionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#algorithm_section.
+ def enterAlgorithm_section(self, ctx:modelicaParser.Algorithm_sectionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#algorithm_section.
+ def exitAlgorithm_section(self, ctx:modelicaParser.Algorithm_sectionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#equation.
+ def enterEquation(self, ctx:modelicaParser.EquationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#equation.
+ def exitEquation(self, ctx:modelicaParser.EquationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#statement.
+ def enterStatement(self, ctx:modelicaParser.StatementContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#statement.
+ def exitStatement(self, ctx:modelicaParser.StatementContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#if_equation.
+ def enterIf_equation(self, ctx:modelicaParser.If_equationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#if_equation.
+ def exitIf_equation(self, ctx:modelicaParser.If_equationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#if_statement.
+ def enterIf_statement(self, ctx:modelicaParser.If_statementContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#if_statement.
+ def exitIf_statement(self, ctx:modelicaParser.If_statementContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#for_equation.
+ def enterFor_equation(self, ctx:modelicaParser.For_equationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#for_equation.
+ def exitFor_equation(self, ctx:modelicaParser.For_equationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#for_statement.
+ def enterFor_statement(self, ctx:modelicaParser.For_statementContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#for_statement.
+ def exitFor_statement(self, ctx:modelicaParser.For_statementContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#for_indices.
+ def enterFor_indices(self, ctx:modelicaParser.For_indicesContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#for_indices.
+ def exitFor_indices(self, ctx:modelicaParser.For_indicesContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#for_index.
+ def enterFor_index(self, ctx:modelicaParser.For_indexContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#for_index.
+ def exitFor_index(self, ctx:modelicaParser.For_indexContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#while_statement.
+ def enterWhile_statement(self, ctx:modelicaParser.While_statementContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#while_statement.
+ def exitWhile_statement(self, ctx:modelicaParser.While_statementContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#when_equation.
+ def enterWhen_equation(self, ctx:modelicaParser.When_equationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#when_equation.
+ def exitWhen_equation(self, ctx:modelicaParser.When_equationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#when_statement.
+ def enterWhen_statement(self, ctx:modelicaParser.When_statementContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#when_statement.
+ def exitWhen_statement(self, ctx:modelicaParser.When_statementContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#connect_clause.
+ def enterConnect_clause(self, ctx:modelicaParser.Connect_clauseContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#connect_clause.
+ def exitConnect_clause(self, ctx:modelicaParser.Connect_clauseContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#expression.
+ def enterExpression(self, ctx:modelicaParser.ExpressionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#expression.
+ def exitExpression(self, ctx:modelicaParser.ExpressionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#simple_expression.
+ def enterSimple_expression(self, ctx:modelicaParser.Simple_expressionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#simple_expression.
+ def exitSimple_expression(self, ctx:modelicaParser.Simple_expressionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#logical_expression.
+ def enterLogical_expression(self, ctx:modelicaParser.Logical_expressionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#logical_expression.
+ def exitLogical_expression(self, ctx:modelicaParser.Logical_expressionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#logical_term.
+ def enterLogical_term(self, ctx:modelicaParser.Logical_termContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#logical_term.
+ def exitLogical_term(self, ctx:modelicaParser.Logical_termContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#logical_factor.
+ def enterLogical_factor(self, ctx:modelicaParser.Logical_factorContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#logical_factor.
+ def exitLogical_factor(self, ctx:modelicaParser.Logical_factorContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#relation.
+ def enterRelation(self, ctx:modelicaParser.RelationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#relation.
+ def exitRelation(self, ctx:modelicaParser.RelationContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#rel_op.
+ def enterRel_op(self, ctx:modelicaParser.Rel_opContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#rel_op.
+ def exitRel_op(self, ctx:modelicaParser.Rel_opContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#arithmetic_expression.
+ def enterArithmetic_expression(self, ctx:modelicaParser.Arithmetic_expressionContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#arithmetic_expression.
+ def exitArithmetic_expression(self, ctx:modelicaParser.Arithmetic_expressionContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#add_op.
+ def enterAdd_op(self, ctx:modelicaParser.Add_opContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#add_op.
+ def exitAdd_op(self, ctx:modelicaParser.Add_opContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#term.
+ def enterTerm(self, ctx:modelicaParser.TermContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#term.
+ def exitTerm(self, ctx:modelicaParser.TermContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#mul_op.
+ def enterMul_op(self, ctx:modelicaParser.Mul_opContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#mul_op.
+ def exitMul_op(self, ctx:modelicaParser.Mul_opContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#factor.
+ def enterFactor(self, ctx:modelicaParser.FactorContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#factor.
+ def exitFactor(self, ctx:modelicaParser.FactorContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#primary.
+ def enterPrimary(self, ctx:modelicaParser.PrimaryContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#primary.
+ def exitPrimary(self, ctx:modelicaParser.PrimaryContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#name.
+ def enterName(self, ctx:modelicaParser.NameContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#name.
+ def exitName(self, ctx:modelicaParser.NameContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#component_reference.
+ def enterComponent_reference(self, ctx:modelicaParser.Component_referenceContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#component_reference.
+ def exitComponent_reference(self, ctx:modelicaParser.Component_referenceContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#function_call_args.
+ def enterFunction_call_args(self, ctx:modelicaParser.Function_call_argsContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#function_call_args.
+ def exitFunction_call_args(self, ctx:modelicaParser.Function_call_argsContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#function_arguments.
+ def enterFunction_arguments(self, ctx:modelicaParser.Function_argumentsContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#function_arguments.
+ def exitFunction_arguments(self, ctx:modelicaParser.Function_argumentsContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#named_arguments.
+ def enterNamed_arguments(self, ctx:modelicaParser.Named_argumentsContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#named_arguments.
+ def exitNamed_arguments(self, ctx:modelicaParser.Named_argumentsContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#named_argument.
+ def enterNamed_argument(self, ctx:modelicaParser.Named_argumentContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#named_argument.
+ def exitNamed_argument(self, ctx:modelicaParser.Named_argumentContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#function_argument.
+ def enterFunction_argument(self, ctx:modelicaParser.Function_argumentContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#function_argument.
+ def exitFunction_argument(self, ctx:modelicaParser.Function_argumentContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#output_expression_list.
+ def enterOutput_expression_list(self, ctx:modelicaParser.Output_expression_listContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#output_expression_list.
+ def exitOutput_expression_list(self, ctx:modelicaParser.Output_expression_listContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#expression_list.
+ def enterExpression_list(self, ctx:modelicaParser.Expression_listContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#expression_list.
+ def exitExpression_list(self, ctx:modelicaParser.Expression_listContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#array_subscripts.
+ def enterArray_subscripts(self, ctx:modelicaParser.Array_subscriptsContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#array_subscripts.
+ def exitArray_subscripts(self, ctx:modelicaParser.Array_subscriptsContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#subscript_.
+ def enterSubscript_(self, ctx:modelicaParser.Subscript_Context):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#subscript_.
+ def exitSubscript_(self, ctx:modelicaParser.Subscript_Context):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#comment.
+ def enterComment(self, ctx:modelicaParser.CommentContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#comment.
+ def exitComment(self, ctx:modelicaParser.CommentContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#string_comment.
+ def enterString_comment(self, ctx:modelicaParser.String_commentContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#string_comment.
+ def exitString_comment(self, ctx:modelicaParser.String_commentContext):
+ pass
+
+
+ # Enter a parse tree produced by modelicaParser#annotation.
+ def enterAnnotation(self, ctx:modelicaParser.AnnotationContext):
+ pass
+
+ # Exit a parse tree produced by modelicaParser#annotation.
+ def exitAnnotation(self, ctx:modelicaParser.AnnotationContext):
+ pass
+
+
+
+del modelicaParser
\ No newline at end of file
diff --git a/src/feature_model/modelicaParser.py b/src/feature_model/modelicaParser.py
new file mode 100644
index 0000000..493af1a
--- /dev/null
+++ b/src/feature_model/modelicaParser.py
@@ -0,0 +1,6334 @@
+# Generated from modelica.g4 by ANTLR 4.13.1
+# encoding: utf-8
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+ from typing import TextIO
+else:
+ from typing.io import TextIO
+
+def serializedATN():
+ return [
+ 4,1,94,1035,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
+ 7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
+ 13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
+ 20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
+ 26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
+ 33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
+ 39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
+ 46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
+ 52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
+ 59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
+ 65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
+ 72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,1,0,1,
+ 0,3,0,159,8,0,1,0,5,0,162,8,0,10,0,12,0,165,9,0,1,0,3,0,168,8,0,
+ 1,0,1,0,1,0,5,0,173,8,0,10,0,12,0,176,9,0,1,0,1,0,1,1,3,1,181,8,
+ 1,1,1,1,1,1,1,1,2,1,2,1,2,3,2,189,8,2,1,3,3,3,192,8,3,1,3,1,3,1,
+ 3,3,3,197,8,3,1,3,1,3,1,3,3,3,202,8,3,1,3,1,3,1,3,1,3,3,3,208,8,
+ 3,1,3,3,3,211,8,3,1,3,1,3,3,3,215,8,3,1,4,1,4,1,4,1,4,1,4,1,4,1,
+ 4,1,4,1,4,3,4,226,8,4,1,4,1,4,1,4,1,4,1,4,3,4,233,8,4,1,5,1,5,1,
+ 5,1,5,1,5,3,5,240,8,5,1,5,3,5,243,8,5,1,5,1,5,1,5,1,5,1,5,1,5,1,
+ 5,3,5,252,8,5,1,5,3,5,255,8,5,1,5,1,5,3,5,259,8,5,1,6,1,6,1,6,1,
+ 6,1,6,1,6,1,6,1,6,1,6,5,6,270,8,6,10,6,12,6,273,9,6,1,6,1,6,1,6,
+ 1,7,1,7,1,8,1,8,1,8,5,8,283,8,8,10,8,12,8,286,9,8,1,9,1,9,1,9,1,
+ 10,1,10,1,10,1,10,1,10,1,10,1,10,5,10,298,8,10,10,10,12,10,301,9,
+ 10,1,10,1,10,3,10,305,8,10,1,10,3,10,308,8,10,1,10,3,10,311,8,10,
+ 1,10,3,10,314,8,10,1,10,1,10,1,10,3,10,319,8,10,1,11,1,11,1,12,1,
+ 12,1,12,3,12,326,8,12,1,12,1,12,1,12,3,12,331,8,12,1,12,1,12,1,13,
+ 1,13,1,13,5,13,338,8,13,10,13,12,13,341,9,13,1,14,1,14,1,14,3,14,
+ 346,8,14,1,14,3,14,349,8,14,1,14,3,14,352,8,14,1,14,3,14,355,8,14,
+ 1,14,1,14,3,14,359,8,14,1,14,1,14,1,14,3,14,364,8,14,1,14,1,14,1,
+ 14,3,14,369,8,14,3,14,371,8,14,3,14,373,8,14,1,15,1,15,1,15,1,15,
+ 1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,388,8,15,1,15,
+ 1,15,1,16,1,16,1,16,5,16,395,8,16,10,16,12,16,398,9,16,1,17,1,17,
+ 1,17,3,17,403,8,17,1,17,3,17,406,8,17,1,18,1,18,1,18,3,18,411,8,
+ 18,1,19,1,19,1,19,3,19,416,8,19,1,19,1,19,1,20,3,20,421,8,20,1,20,
+ 3,20,424,8,20,1,20,3,20,427,8,20,1,21,1,21,1,22,1,22,1,22,5,22,434,
+ 8,22,10,22,12,22,437,9,22,1,23,1,23,3,23,441,8,23,1,23,1,23,1,24,
+ 1,24,1,24,1,25,1,25,3,25,450,8,25,1,25,3,25,453,8,25,1,26,1,26,1,
+ 26,3,26,458,8,26,1,26,1,26,1,26,1,26,3,26,464,8,26,1,27,1,27,3,27,
+ 468,8,27,1,27,1,27,1,28,1,28,1,28,5,28,475,8,28,10,28,12,28,478,
+ 9,28,1,29,1,29,3,29,482,8,29,1,30,3,30,485,8,30,1,30,3,30,488,8,
+ 30,1,30,1,30,3,30,492,8,30,1,31,1,31,3,31,496,8,31,1,31,1,31,1,32,
+ 1,32,3,32,502,8,32,1,32,3,32,505,8,32,1,32,1,32,3,32,509,8,32,1,
+ 32,3,32,512,8,32,1,33,1,33,1,33,3,33,517,8,33,1,33,3,33,520,8,33,
+ 1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,36,1,36,1,36,1,37,3,37,533,
+ 8,37,1,37,1,37,1,37,1,37,5,37,539,8,37,10,37,12,37,542,9,37,1,38,
+ 3,38,545,8,38,1,38,1,38,1,38,1,38,5,38,551,8,38,10,38,12,38,554,
+ 9,38,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,3,39,
+ 567,8,39,1,39,1,39,1,40,1,40,1,40,1,40,3,40,575,8,40,1,40,1,40,1,
+ 40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,3,40,590,8,
+ 40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41,5,41,600,8,41,10,41,12,
+ 41,603,9,41,1,41,1,41,1,41,1,41,1,41,1,41,5,41,611,8,41,10,41,12,
+ 41,614,9,41,5,41,616,8,41,10,41,12,41,619,9,41,1,41,1,41,1,41,1,
+ 41,5,41,625,8,41,10,41,12,41,628,9,41,3,41,630,8,41,1,41,1,41,1,
+ 41,1,42,1,42,1,42,1,42,1,42,1,42,5,42,641,8,42,10,42,12,42,644,9,
+ 42,1,42,1,42,1,42,1,42,1,42,1,42,5,42,652,8,42,10,42,12,42,655,9,
+ 42,5,42,657,8,42,10,42,12,42,660,9,42,1,42,1,42,1,42,1,42,5,42,666,
+ 8,42,10,42,12,42,669,9,42,3,42,671,8,42,1,42,1,42,1,42,1,43,1,43,
+ 1,43,1,43,1,43,1,43,5,43,682,8,43,10,43,12,43,685,9,43,1,43,1,43,
+ 1,43,1,44,1,44,1,44,1,44,1,44,1,44,5,44,696,8,44,10,44,12,44,699,
+ 9,44,1,44,1,44,1,44,1,45,1,45,1,45,5,45,707,8,45,10,45,12,45,710,
+ 9,45,1,46,1,46,1,46,3,46,715,8,46,1,47,1,47,1,47,1,47,1,47,1,47,
+ 5,47,723,8,47,10,47,12,47,726,9,47,1,47,1,47,1,47,1,48,1,48,1,48,
+ 1,48,1,48,1,48,5,48,737,8,48,10,48,12,48,740,9,48,1,48,1,48,1,48,
+ 1,48,1,48,1,48,5,48,748,8,48,10,48,12,48,751,9,48,5,48,753,8,48,
+ 10,48,12,48,756,9,48,1,48,1,48,1,48,1,49,1,49,1,49,1,49,1,49,1,49,
+ 5,49,767,8,49,10,49,12,49,770,9,49,1,49,1,49,1,49,1,49,1,49,1,49,
+ 5,49,778,8,49,10,49,12,49,781,9,49,5,49,783,8,49,10,49,12,49,786,
+ 9,49,1,49,1,49,1,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,51,1,51,
+ 1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,5,51,808,8,51,10,51,12,51,
+ 811,9,51,1,51,1,51,1,51,3,51,816,8,51,1,52,1,52,1,52,1,52,1,52,3,
+ 52,823,8,52,3,52,825,8,52,1,53,1,53,1,53,5,53,830,8,53,10,53,12,
+ 53,833,9,53,1,54,1,54,1,54,5,54,838,8,54,10,54,12,54,841,9,54,1,
+ 55,3,55,844,8,55,1,55,1,55,1,56,1,56,1,56,1,56,3,56,852,8,56,1,57,
+ 1,57,1,58,3,58,857,8,58,1,58,1,58,1,58,1,58,5,58,863,8,58,10,58,
+ 12,58,866,9,58,1,59,1,59,1,60,1,60,1,60,1,60,5,60,874,8,60,10,60,
+ 12,60,877,9,60,1,61,1,61,1,62,1,62,1,62,3,62,884,8,62,1,63,1,63,
+ 1,63,1,63,1,63,1,63,1,63,3,63,893,8,63,1,63,1,63,1,63,1,63,1,63,
+ 1,63,1,63,1,63,1,63,1,63,5,63,905,8,63,10,63,12,63,908,9,63,1,63,
+ 1,63,1,63,1,63,1,63,1,63,1,63,3,63,917,8,63,1,64,3,64,920,8,64,1,
+ 64,1,64,1,64,5,64,925,8,64,10,64,12,64,928,9,64,1,65,3,65,931,8,
+ 65,1,65,1,65,3,65,935,8,65,1,65,1,65,1,65,3,65,940,8,65,5,65,942,
+ 8,65,10,65,12,65,945,9,65,1,66,1,66,3,66,949,8,66,1,66,1,66,1,67,
+ 1,67,1,67,1,67,1,67,3,67,958,8,67,1,67,3,67,961,8,67,1,68,1,68,1,
+ 68,3,68,966,8,68,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,3,70,976,
+ 8,70,1,70,1,70,1,70,3,70,981,8,70,1,71,3,71,984,8,71,1,71,1,71,3,
+ 71,988,8,71,5,71,990,8,71,10,71,12,71,993,9,71,1,72,1,72,1,72,5,
+ 72,998,8,72,10,72,12,72,1001,9,72,1,73,1,73,1,73,1,73,5,73,1007,
+ 8,73,10,73,12,73,1010,9,73,1,73,1,73,1,74,1,74,3,74,1016,8,74,1,
+ 75,1,75,3,75,1020,8,75,1,76,1,76,1,76,5,76,1025,8,76,10,76,12,76,
+ 1028,9,76,3,76,1030,8,76,1,77,1,77,1,77,1,77,0,0,78,0,2,4,6,8,10,
+ 12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,
+ 56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,
+ 100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,
+ 132,134,136,138,140,142,144,146,148,150,152,154,0,8,1,0,15,16,1,
+ 0,39,40,1,0,41,43,1,0,44,45,1,0,67,72,1,0,73,76,2,0,35,35,77,79,
+ 1,0,80,81,1122,0,163,1,0,0,0,2,180,1,0,0,0,4,188,1,0,0,0,6,191,1,
+ 0,0,0,8,232,1,0,0,0,10,258,1,0,0,0,12,260,1,0,0,0,14,277,1,0,0,0,
+ 16,279,1,0,0,0,18,287,1,0,0,0,20,290,1,0,0,0,22,320,1,0,0,0,24,325,
+ 1,0,0,0,26,339,1,0,0,0,28,372,1,0,0,0,30,374,1,0,0,0,32,391,1,0,
+ 0,0,34,399,1,0,0,0,36,407,1,0,0,0,38,412,1,0,0,0,40,420,1,0,0,0,
+ 42,428,1,0,0,0,44,430,1,0,0,0,46,438,1,0,0,0,48,444,1,0,0,0,50,447,
+ 1,0,0,0,52,463,1,0,0,0,54,465,1,0,0,0,56,471,1,0,0,0,58,481,1,0,
+ 0,0,60,484,1,0,0,0,62,493,1,0,0,0,64,499,1,0,0,0,66,513,1,0,0,0,
+ 68,521,1,0,0,0,70,525,1,0,0,0,72,528,1,0,0,0,74,532,1,0,0,0,76,544,
+ 1,0,0,0,78,566,1,0,0,0,80,589,1,0,0,0,82,593,1,0,0,0,84,634,1,0,
+ 0,0,86,675,1,0,0,0,88,689,1,0,0,0,90,703,1,0,0,0,92,711,1,0,0,0,
+ 94,716,1,0,0,0,96,730,1,0,0,0,98,760,1,0,0,0,100,790,1,0,0,0,102,
+ 815,1,0,0,0,104,817,1,0,0,0,106,826,1,0,0,0,108,834,1,0,0,0,110,
+ 843,1,0,0,0,112,847,1,0,0,0,114,853,1,0,0,0,116,856,1,0,0,0,118,
+ 867,1,0,0,0,120,869,1,0,0,0,122,878,1,0,0,0,124,880,1,0,0,0,126,
+ 916,1,0,0,0,128,919,1,0,0,0,130,930,1,0,0,0,132,946,1,0,0,0,134,
+ 960,1,0,0,0,136,962,1,0,0,0,138,967,1,0,0,0,140,980,1,0,0,0,142,
+ 983,1,0,0,0,144,994,1,0,0,0,146,1002,1,0,0,0,148,1015,1,0,0,0,150,
+ 1017,1,0,0,0,152,1029,1,0,0,0,154,1031,1,0,0,0,156,158,5,1,0,0,157,
+ 159,3,128,64,0,158,157,1,0,0,0,158,159,1,0,0,0,159,160,1,0,0,0,160,
+ 162,5,2,0,0,161,156,1,0,0,0,162,165,1,0,0,0,163,161,1,0,0,0,163,
+ 164,1,0,0,0,164,174,1,0,0,0,165,163,1,0,0,0,166,168,5,3,0,0,167,
+ 166,1,0,0,0,167,168,1,0,0,0,168,169,1,0,0,0,169,170,3,2,1,0,170,
+ 171,5,2,0,0,171,173,1,0,0,0,172,167,1,0,0,0,173,176,1,0,0,0,174,
+ 172,1,0,0,0,174,175,1,0,0,0,175,177,1,0,0,0,176,174,1,0,0,0,177,
+ 178,5,0,0,1,178,1,1,0,0,0,179,181,5,4,0,0,180,179,1,0,0,0,180,181,
+ 1,0,0,0,181,182,1,0,0,0,182,183,3,6,3,0,183,184,3,4,2,0,184,3,1,
+ 0,0,0,185,189,3,8,4,0,186,189,3,10,5,0,187,189,3,12,6,0,188,185,
+ 1,0,0,0,188,186,1,0,0,0,188,187,1,0,0,0,189,5,1,0,0,0,190,192,5,
+ 5,0,0,191,190,1,0,0,0,191,192,1,0,0,0,192,214,1,0,0,0,193,215,5,
+ 6,0,0,194,215,5,7,0,0,195,197,5,8,0,0,196,195,1,0,0,0,196,197,1,
+ 0,0,0,197,198,1,0,0,0,198,215,5,9,0,0,199,215,5,10,0,0,200,202,5,
+ 11,0,0,201,200,1,0,0,0,201,202,1,0,0,0,202,203,1,0,0,0,203,215,5,
+ 12,0,0,204,215,5,13,0,0,205,215,5,14,0,0,206,208,7,0,0,0,207,206,
+ 1,0,0,0,207,208,1,0,0,0,208,210,1,0,0,0,209,211,5,8,0,0,210,209,
+ 1,0,0,0,210,211,1,0,0,0,211,212,1,0,0,0,212,215,5,17,0,0,213,215,
+ 5,8,0,0,214,193,1,0,0,0,214,194,1,0,0,0,214,196,1,0,0,0,214,199,
+ 1,0,0,0,214,201,1,0,0,0,214,204,1,0,0,0,214,205,1,0,0,0,214,207,
+ 1,0,0,0,214,213,1,0,0,0,215,7,1,0,0,0,216,217,5,89,0,0,217,218,3,
+ 152,76,0,218,219,3,20,10,0,219,220,5,18,0,0,220,221,5,89,0,0,221,
+ 233,1,0,0,0,222,223,5,19,0,0,223,225,5,89,0,0,224,226,3,54,27,0,
+ 225,224,1,0,0,0,225,226,1,0,0,0,226,227,1,0,0,0,227,228,3,152,76,
+ 0,228,229,3,20,10,0,229,230,5,18,0,0,230,231,5,89,0,0,231,233,1,
+ 0,0,0,232,216,1,0,0,0,232,222,1,0,0,0,233,9,1,0,0,0,234,235,5,89,
+ 0,0,235,236,5,20,0,0,236,237,3,14,7,0,237,239,3,128,64,0,238,240,
+ 3,146,73,0,239,238,1,0,0,0,239,240,1,0,0,0,240,242,1,0,0,0,241,243,
+ 3,54,27,0,242,241,1,0,0,0,242,243,1,0,0,0,243,244,1,0,0,0,244,245,
+ 3,150,75,0,245,259,1,0,0,0,246,247,5,89,0,0,247,248,5,20,0,0,248,
+ 249,5,21,0,0,249,254,5,22,0,0,250,252,3,16,8,0,251,250,1,0,0,0,251,
+ 252,1,0,0,0,252,255,1,0,0,0,253,255,5,23,0,0,254,251,1,0,0,0,254,
+ 253,1,0,0,0,255,256,1,0,0,0,256,257,5,24,0,0,257,259,3,150,75,0,
+ 258,234,1,0,0,0,258,246,1,0,0,0,259,11,1,0,0,0,260,261,5,89,0,0,
+ 261,262,5,20,0,0,262,263,5,25,0,0,263,264,5,22,0,0,264,265,3,128,
+ 64,0,265,266,5,26,0,0,266,271,5,89,0,0,267,268,5,26,0,0,268,270,
+ 5,89,0,0,269,267,1,0,0,0,270,273,1,0,0,0,271,269,1,0,0,0,271,272,
+ 1,0,0,0,272,274,1,0,0,0,273,271,1,0,0,0,274,275,5,24,0,0,275,276,
+ 3,150,75,0,276,13,1,0,0,0,277,278,3,40,20,0,278,15,1,0,0,0,279,284,
+ 3,18,9,0,280,281,5,26,0,0,281,283,3,18,9,0,282,280,1,0,0,0,283,286,
+ 1,0,0,0,284,282,1,0,0,0,284,285,1,0,0,0,285,17,1,0,0,0,286,284,1,
+ 0,0,0,287,288,5,89,0,0,288,289,3,150,75,0,289,19,1,0,0,0,290,299,
+ 3,26,13,0,291,292,5,27,0,0,292,298,3,26,13,0,293,294,5,28,0,0,294,
+ 298,3,26,13,0,295,298,3,74,37,0,296,298,3,76,38,0,297,291,1,0,0,
+ 0,297,293,1,0,0,0,297,295,1,0,0,0,297,296,1,0,0,0,298,301,1,0,0,
+ 0,299,297,1,0,0,0,299,300,1,0,0,0,300,313,1,0,0,0,301,299,1,0,0,
+ 0,302,304,5,29,0,0,303,305,3,22,11,0,304,303,1,0,0,0,304,305,1,0,
+ 0,0,305,307,1,0,0,0,306,308,3,24,12,0,307,306,1,0,0,0,307,308,1,
+ 0,0,0,308,310,1,0,0,0,309,311,3,154,77,0,310,309,1,0,0,0,310,311,
+ 1,0,0,0,311,312,1,0,0,0,312,314,5,2,0,0,313,302,1,0,0,0,313,314,
+ 1,0,0,0,314,318,1,0,0,0,315,316,3,154,77,0,316,317,5,2,0,0,317,319,
+ 1,0,0,0,318,315,1,0,0,0,318,319,1,0,0,0,319,21,1,0,0,0,320,321,5,
+ 90,0,0,321,23,1,0,0,0,322,323,3,130,65,0,323,324,5,20,0,0,324,326,
+ 1,0,0,0,325,322,1,0,0,0,325,326,1,0,0,0,326,327,1,0,0,0,327,328,
+ 5,89,0,0,328,330,5,22,0,0,329,331,3,144,72,0,330,329,1,0,0,0,330,
+ 331,1,0,0,0,331,332,1,0,0,0,332,333,5,24,0,0,333,25,1,0,0,0,334,
+ 335,3,28,14,0,335,336,5,2,0,0,336,338,1,0,0,0,337,334,1,0,0,0,338,
+ 341,1,0,0,0,339,337,1,0,0,0,339,340,1,0,0,0,340,27,1,0,0,0,341,339,
+ 1,0,0,0,342,373,3,30,15,0,343,373,3,34,17,0,344,346,5,30,0,0,345,
+ 344,1,0,0,0,345,346,1,0,0,0,346,348,1,0,0,0,347,349,5,3,0,0,348,
+ 347,1,0,0,0,348,349,1,0,0,0,349,351,1,0,0,0,350,352,5,31,0,0,351,
+ 350,1,0,0,0,351,352,1,0,0,0,352,354,1,0,0,0,353,355,5,32,0,0,354,
+ 353,1,0,0,0,354,355,1,0,0,0,355,370,1,0,0,0,356,359,3,2,1,0,357,
+ 359,3,38,19,0,358,356,1,0,0,0,358,357,1,0,0,0,359,371,1,0,0,0,360,
+ 363,5,33,0,0,361,364,3,2,1,0,362,364,3,38,19,0,363,361,1,0,0,0,363,
+ 362,1,0,0,0,364,368,1,0,0,0,365,366,3,36,18,0,366,367,3,150,75,0,
+ 367,369,1,0,0,0,368,365,1,0,0,0,368,369,1,0,0,0,369,371,1,0,0,0,
+ 370,358,1,0,0,0,370,360,1,0,0,0,371,373,1,0,0,0,372,342,1,0,0,0,
+ 372,343,1,0,0,0,372,345,1,0,0,0,373,29,1,0,0,0,374,387,5,34,0,0,
+ 375,376,5,89,0,0,376,377,5,20,0,0,377,388,3,128,64,0,378,379,3,128,
+ 64,0,379,380,5,35,0,0,380,388,1,0,0,0,381,382,3,128,64,0,382,383,
+ 5,36,0,0,383,384,3,32,16,0,384,385,5,37,0,0,385,388,1,0,0,0,386,
+ 388,3,128,64,0,387,375,1,0,0,0,387,378,1,0,0,0,387,381,1,0,0,0,387,
+ 386,1,0,0,0,388,389,1,0,0,0,389,390,3,150,75,0,390,31,1,0,0,0,391,
+ 396,5,89,0,0,392,393,5,26,0,0,393,395,5,89,0,0,394,392,1,0,0,0,395,
+ 398,1,0,0,0,396,394,1,0,0,0,396,397,1,0,0,0,397,33,1,0,0,0,398,396,
+ 1,0,0,0,399,400,5,19,0,0,400,402,3,128,64,0,401,403,3,54,27,0,402,
+ 401,1,0,0,0,402,403,1,0,0,0,403,405,1,0,0,0,404,406,3,154,77,0,405,
+ 404,1,0,0,0,405,406,1,0,0,0,406,35,1,0,0,0,407,408,5,38,0,0,408,
+ 410,3,128,64,0,409,411,3,54,27,0,410,409,1,0,0,0,410,411,1,0,0,0,
+ 411,37,1,0,0,0,412,413,3,40,20,0,413,415,3,42,21,0,414,416,3,146,
+ 73,0,415,414,1,0,0,0,415,416,1,0,0,0,416,417,1,0,0,0,417,418,3,44,
+ 22,0,418,39,1,0,0,0,419,421,7,1,0,0,420,419,1,0,0,0,420,421,1,0,
+ 0,0,421,423,1,0,0,0,422,424,7,2,0,0,423,422,1,0,0,0,423,424,1,0,
+ 0,0,424,426,1,0,0,0,425,427,7,3,0,0,426,425,1,0,0,0,426,427,1,0,
+ 0,0,427,41,1,0,0,0,428,429,3,128,64,0,429,43,1,0,0,0,430,435,3,46,
+ 23,0,431,432,5,26,0,0,432,434,3,46,23,0,433,431,1,0,0,0,434,437,
+ 1,0,0,0,435,433,1,0,0,0,435,436,1,0,0,0,436,45,1,0,0,0,437,435,1,
+ 0,0,0,438,440,3,50,25,0,439,441,3,48,24,0,440,439,1,0,0,0,440,441,
+ 1,0,0,0,441,442,1,0,0,0,442,443,3,150,75,0,443,47,1,0,0,0,444,445,
+ 5,46,0,0,445,446,3,102,51,0,446,49,1,0,0,0,447,449,5,89,0,0,448,
+ 450,3,146,73,0,449,448,1,0,0,0,449,450,1,0,0,0,450,452,1,0,0,0,451,
+ 453,3,52,26,0,452,451,1,0,0,0,452,453,1,0,0,0,453,51,1,0,0,0,454,
+ 457,3,54,27,0,455,456,5,20,0,0,456,458,3,102,51,0,457,455,1,0,0,
+ 0,457,458,1,0,0,0,458,464,1,0,0,0,459,460,5,20,0,0,460,464,3,102,
+ 51,0,461,462,5,47,0,0,462,464,3,102,51,0,463,454,1,0,0,0,463,459,
+ 1,0,0,0,463,461,1,0,0,0,464,53,1,0,0,0,465,467,5,22,0,0,466,468,
+ 3,56,28,0,467,466,1,0,0,0,467,468,1,0,0,0,468,469,1,0,0,0,469,470,
+ 5,24,0,0,470,55,1,0,0,0,471,476,3,58,29,0,472,473,5,26,0,0,473,475,
+ 3,58,29,0,474,472,1,0,0,0,475,478,1,0,0,0,476,474,1,0,0,0,476,477,
+ 1,0,0,0,477,57,1,0,0,0,478,476,1,0,0,0,479,482,3,60,30,0,480,482,
+ 3,64,32,0,481,479,1,0,0,0,481,480,1,0,0,0,482,59,1,0,0,0,483,485,
+ 5,48,0,0,484,483,1,0,0,0,484,485,1,0,0,0,485,487,1,0,0,0,486,488,
+ 5,3,0,0,487,486,1,0,0,0,487,488,1,0,0,0,488,491,1,0,0,0,489,492,
+ 3,62,31,0,490,492,3,66,33,0,491,489,1,0,0,0,491,490,1,0,0,0,492,
+ 61,1,0,0,0,493,495,3,128,64,0,494,496,3,52,26,0,495,494,1,0,0,0,
+ 495,496,1,0,0,0,496,497,1,0,0,0,497,498,3,152,76,0,498,63,1,0,0,
+ 0,499,501,5,30,0,0,500,502,5,48,0,0,501,500,1,0,0,0,501,502,1,0,
+ 0,0,502,504,1,0,0,0,503,505,5,3,0,0,504,503,1,0,0,0,504,505,1,0,
+ 0,0,505,511,1,0,0,0,506,509,3,72,36,0,507,509,3,68,34,0,508,506,
+ 1,0,0,0,508,507,1,0,0,0,509,512,1,0,0,0,510,512,3,66,33,0,511,508,
+ 1,0,0,0,511,510,1,0,0,0,512,65,1,0,0,0,513,516,5,33,0,0,514,517,
+ 3,72,36,0,515,517,3,68,34,0,516,514,1,0,0,0,516,515,1,0,0,0,517,
+ 519,1,0,0,0,518,520,3,36,18,0,519,518,1,0,0,0,519,520,1,0,0,0,520,
+ 67,1,0,0,0,521,522,3,40,20,0,522,523,3,42,21,0,523,524,3,70,35,0,
+ 524,69,1,0,0,0,525,526,3,50,25,0,526,527,3,150,75,0,527,71,1,0,0,
+ 0,528,529,3,6,3,0,529,530,3,10,5,0,530,73,1,0,0,0,531,533,5,49,0,
+ 0,532,531,1,0,0,0,532,533,1,0,0,0,533,534,1,0,0,0,534,540,5,50,0,
+ 0,535,536,3,78,39,0,536,537,5,2,0,0,537,539,1,0,0,0,538,535,1,0,
+ 0,0,539,542,1,0,0,0,540,538,1,0,0,0,540,541,1,0,0,0,541,75,1,0,0,
+ 0,542,540,1,0,0,0,543,545,5,49,0,0,544,543,1,0,0,0,544,545,1,0,0,
+ 0,545,546,1,0,0,0,546,552,5,51,0,0,547,548,3,80,40,0,548,549,5,2,
+ 0,0,549,551,1,0,0,0,550,547,1,0,0,0,551,554,1,0,0,0,552,550,1,0,
+ 0,0,552,553,1,0,0,0,553,77,1,0,0,0,554,552,1,0,0,0,555,556,3,104,
+ 52,0,556,557,5,20,0,0,557,558,3,102,51,0,558,567,1,0,0,0,559,567,
+ 3,82,41,0,560,567,3,86,43,0,561,567,3,100,50,0,562,567,3,96,48,0,
+ 563,564,3,128,64,0,564,565,3,132,66,0,565,567,1,0,0,0,566,555,1,
+ 0,0,0,566,559,1,0,0,0,566,560,1,0,0,0,566,561,1,0,0,0,566,562,1,
+ 0,0,0,566,563,1,0,0,0,567,568,1,0,0,0,568,569,3,150,75,0,569,79,
+ 1,0,0,0,570,574,3,130,65,0,571,572,5,47,0,0,572,575,3,102,51,0,573,
+ 575,3,132,66,0,574,571,1,0,0,0,574,573,1,0,0,0,575,590,1,0,0,0,576,
+ 577,5,22,0,0,577,578,3,142,71,0,578,579,5,24,0,0,579,580,5,47,0,
+ 0,580,581,3,130,65,0,581,582,3,132,66,0,582,590,1,0,0,0,583,590,
+ 5,52,0,0,584,590,5,53,0,0,585,590,3,84,42,0,586,590,3,88,44,0,587,
+ 590,3,94,47,0,588,590,3,98,49,0,589,570,1,0,0,0,589,576,1,0,0,0,
+ 589,583,1,0,0,0,589,584,1,0,0,0,589,585,1,0,0,0,589,586,1,0,0,0,
+ 589,587,1,0,0,0,589,588,1,0,0,0,590,591,1,0,0,0,591,592,3,150,75,
+ 0,592,81,1,0,0,0,593,594,5,46,0,0,594,595,3,102,51,0,595,601,5,54,
+ 0,0,596,597,3,78,39,0,597,598,5,2,0,0,598,600,1,0,0,0,599,596,1,
+ 0,0,0,600,603,1,0,0,0,601,599,1,0,0,0,601,602,1,0,0,0,602,617,1,
+ 0,0,0,603,601,1,0,0,0,604,605,5,55,0,0,605,606,3,102,51,0,606,612,
+ 5,54,0,0,607,608,3,78,39,0,608,609,5,2,0,0,609,611,1,0,0,0,610,607,
+ 1,0,0,0,611,614,1,0,0,0,612,610,1,0,0,0,612,613,1,0,0,0,613,616,
+ 1,0,0,0,614,612,1,0,0,0,615,604,1,0,0,0,616,619,1,0,0,0,617,615,
+ 1,0,0,0,617,618,1,0,0,0,618,629,1,0,0,0,619,617,1,0,0,0,620,626,
+ 5,56,0,0,621,622,3,78,39,0,622,623,5,2,0,0,623,625,1,0,0,0,624,621,
+ 1,0,0,0,625,628,1,0,0,0,626,624,1,0,0,0,626,627,1,0,0,0,627,630,
+ 1,0,0,0,628,626,1,0,0,0,629,620,1,0,0,0,629,630,1,0,0,0,630,631,
+ 1,0,0,0,631,632,5,18,0,0,632,633,5,46,0,0,633,83,1,0,0,0,634,635,
+ 5,46,0,0,635,636,3,102,51,0,636,642,5,54,0,0,637,638,3,80,40,0,638,
+ 639,5,2,0,0,639,641,1,0,0,0,640,637,1,0,0,0,641,644,1,0,0,0,642,
+ 640,1,0,0,0,642,643,1,0,0,0,643,658,1,0,0,0,644,642,1,0,0,0,645,
+ 646,5,55,0,0,646,647,3,102,51,0,647,653,5,54,0,0,648,649,3,80,40,
+ 0,649,650,5,2,0,0,650,652,1,0,0,0,651,648,1,0,0,0,652,655,1,0,0,
+ 0,653,651,1,0,0,0,653,654,1,0,0,0,654,657,1,0,0,0,655,653,1,0,0,
+ 0,656,645,1,0,0,0,657,660,1,0,0,0,658,656,1,0,0,0,658,659,1,0,0,
+ 0,659,670,1,0,0,0,660,658,1,0,0,0,661,667,5,56,0,0,662,663,3,80,
+ 40,0,663,664,5,2,0,0,664,666,1,0,0,0,665,662,1,0,0,0,666,669,1,0,
+ 0,0,667,665,1,0,0,0,667,668,1,0,0,0,668,671,1,0,0,0,669,667,1,0,
+ 0,0,670,661,1,0,0,0,670,671,1,0,0,0,671,672,1,0,0,0,672,673,5,18,
+ 0,0,673,674,5,46,0,0,674,85,1,0,0,0,675,676,5,57,0,0,676,677,3,90,
+ 45,0,677,683,5,58,0,0,678,679,3,78,39,0,679,680,5,2,0,0,680,682,
+ 1,0,0,0,681,678,1,0,0,0,682,685,1,0,0,0,683,681,1,0,0,0,683,684,
+ 1,0,0,0,684,686,1,0,0,0,685,683,1,0,0,0,686,687,5,18,0,0,687,688,
+ 5,57,0,0,688,87,1,0,0,0,689,690,5,57,0,0,690,691,3,90,45,0,691,697,
+ 5,58,0,0,692,693,3,80,40,0,693,694,5,2,0,0,694,696,1,0,0,0,695,692,
+ 1,0,0,0,696,699,1,0,0,0,697,695,1,0,0,0,697,698,1,0,0,0,698,700,
+ 1,0,0,0,699,697,1,0,0,0,700,701,5,18,0,0,701,702,5,57,0,0,702,89,
+ 1,0,0,0,703,708,3,92,46,0,704,705,5,26,0,0,705,707,3,92,46,0,706,
+ 704,1,0,0,0,707,710,1,0,0,0,708,706,1,0,0,0,708,709,1,0,0,0,709,
+ 91,1,0,0,0,710,708,1,0,0,0,711,714,5,89,0,0,712,713,5,59,0,0,713,
+ 715,3,102,51,0,714,712,1,0,0,0,714,715,1,0,0,0,715,93,1,0,0,0,716,
+ 717,5,60,0,0,717,718,3,102,51,0,718,724,5,58,0,0,719,720,3,80,40,
+ 0,720,721,5,2,0,0,721,723,1,0,0,0,722,719,1,0,0,0,723,726,1,0,0,
+ 0,724,722,1,0,0,0,724,725,1,0,0,0,725,727,1,0,0,0,726,724,1,0,0,
+ 0,727,728,5,18,0,0,728,729,5,60,0,0,729,95,1,0,0,0,730,731,5,61,
+ 0,0,731,732,3,102,51,0,732,738,5,54,0,0,733,734,3,78,39,0,734,735,
+ 5,2,0,0,735,737,1,0,0,0,736,733,1,0,0,0,737,740,1,0,0,0,738,736,
+ 1,0,0,0,738,739,1,0,0,0,739,754,1,0,0,0,740,738,1,0,0,0,741,742,
+ 5,62,0,0,742,743,3,102,51,0,743,749,5,54,0,0,744,745,3,78,39,0,745,
+ 746,5,2,0,0,746,748,1,0,0,0,747,744,1,0,0,0,748,751,1,0,0,0,749,
+ 747,1,0,0,0,749,750,1,0,0,0,750,753,1,0,0,0,751,749,1,0,0,0,752,
+ 741,1,0,0,0,753,756,1,0,0,0,754,752,1,0,0,0,754,755,1,0,0,0,755,
+ 757,1,0,0,0,756,754,1,0,0,0,757,758,5,18,0,0,758,759,5,61,0,0,759,
+ 97,1,0,0,0,760,761,5,61,0,0,761,762,3,102,51,0,762,768,5,54,0,0,
+ 763,764,3,80,40,0,764,765,5,2,0,0,765,767,1,0,0,0,766,763,1,0,0,
+ 0,767,770,1,0,0,0,768,766,1,0,0,0,768,769,1,0,0,0,769,784,1,0,0,
+ 0,770,768,1,0,0,0,771,772,5,62,0,0,772,773,3,102,51,0,773,779,5,
+ 54,0,0,774,775,3,80,40,0,775,776,5,2,0,0,776,778,1,0,0,0,777,774,
+ 1,0,0,0,778,781,1,0,0,0,779,777,1,0,0,0,779,780,1,0,0,0,780,783,
+ 1,0,0,0,781,779,1,0,0,0,782,771,1,0,0,0,783,786,1,0,0,0,784,782,
+ 1,0,0,0,784,785,1,0,0,0,785,787,1,0,0,0,786,784,1,0,0,0,787,788,
+ 5,18,0,0,788,789,5,61,0,0,789,99,1,0,0,0,790,791,5,63,0,0,791,792,
+ 5,22,0,0,792,793,3,130,65,0,793,794,5,26,0,0,794,795,3,130,65,0,
+ 795,796,5,24,0,0,796,101,1,0,0,0,797,816,3,104,52,0,798,799,5,46,
+ 0,0,799,800,3,102,51,0,800,801,5,54,0,0,801,809,3,102,51,0,802,803,
+ 5,55,0,0,803,804,3,102,51,0,804,805,5,54,0,0,805,806,3,102,51,0,
+ 806,808,1,0,0,0,807,802,1,0,0,0,808,811,1,0,0,0,809,807,1,0,0,0,
+ 809,810,1,0,0,0,810,812,1,0,0,0,811,809,1,0,0,0,812,813,5,56,0,0,
+ 813,814,3,102,51,0,814,816,1,0,0,0,815,797,1,0,0,0,815,798,1,0,0,
+ 0,816,103,1,0,0,0,817,824,3,106,53,0,818,819,5,23,0,0,819,822,3,
+ 106,53,0,820,821,5,23,0,0,821,823,3,106,53,0,822,820,1,0,0,0,822,
+ 823,1,0,0,0,823,825,1,0,0,0,824,818,1,0,0,0,824,825,1,0,0,0,825,
+ 105,1,0,0,0,826,831,3,108,54,0,827,828,5,64,0,0,828,830,3,108,54,
+ 0,829,827,1,0,0,0,830,833,1,0,0,0,831,829,1,0,0,0,831,832,1,0,0,
+ 0,832,107,1,0,0,0,833,831,1,0,0,0,834,839,3,110,55,0,835,836,5,65,
+ 0,0,836,838,3,110,55,0,837,835,1,0,0,0,838,841,1,0,0,0,839,837,1,
+ 0,0,0,839,840,1,0,0,0,840,109,1,0,0,0,841,839,1,0,0,0,842,844,5,
+ 66,0,0,843,842,1,0,0,0,843,844,1,0,0,0,844,845,1,0,0,0,845,846,3,
+ 112,56,0,846,111,1,0,0,0,847,851,3,116,58,0,848,849,3,114,57,0,849,
+ 850,3,116,58,0,850,852,1,0,0,0,851,848,1,0,0,0,851,852,1,0,0,0,852,
+ 113,1,0,0,0,853,854,7,4,0,0,854,115,1,0,0,0,855,857,3,118,59,0,856,
+ 855,1,0,0,0,856,857,1,0,0,0,857,858,1,0,0,0,858,864,3,120,60,0,859,
+ 860,3,118,59,0,860,861,3,120,60,0,861,863,1,0,0,0,862,859,1,0,0,
+ 0,863,866,1,0,0,0,864,862,1,0,0,0,864,865,1,0,0,0,865,117,1,0,0,
+ 0,866,864,1,0,0,0,867,868,7,5,0,0,868,119,1,0,0,0,869,875,3,124,
+ 62,0,870,871,3,122,61,0,871,872,3,124,62,0,872,874,1,0,0,0,873,870,
+ 1,0,0,0,874,877,1,0,0,0,875,873,1,0,0,0,875,876,1,0,0,0,876,121,
+ 1,0,0,0,877,875,1,0,0,0,878,879,7,6,0,0,879,123,1,0,0,0,880,883,
+ 3,126,63,0,881,882,7,7,0,0,882,884,3,126,63,0,883,881,1,0,0,0,883,
+ 884,1,0,0,0,884,125,1,0,0,0,885,917,5,91,0,0,886,917,5,90,0,0,887,
+ 917,5,82,0,0,888,917,5,83,0,0,889,893,3,128,64,0,890,893,5,25,0,
+ 0,891,893,5,49,0,0,892,889,1,0,0,0,892,890,1,0,0,0,892,891,1,0,0,
+ 0,893,894,1,0,0,0,894,917,3,132,66,0,895,917,3,130,65,0,896,897,
+ 5,22,0,0,897,898,3,142,71,0,898,899,5,24,0,0,899,917,1,0,0,0,900,
+ 901,5,84,0,0,901,906,3,144,72,0,902,903,5,2,0,0,903,905,3,144,72,
+ 0,904,902,1,0,0,0,905,908,1,0,0,0,906,904,1,0,0,0,906,907,1,0,0,
+ 0,907,909,1,0,0,0,908,906,1,0,0,0,909,910,5,85,0,0,910,917,1,0,0,
+ 0,911,912,5,86,0,0,912,913,3,134,67,0,913,914,5,37,0,0,914,917,1,
+ 0,0,0,915,917,5,18,0,0,916,885,1,0,0,0,916,886,1,0,0,0,916,887,1,
+ 0,0,0,916,888,1,0,0,0,916,892,1,0,0,0,916,895,1,0,0,0,916,896,1,
+ 0,0,0,916,900,1,0,0,0,916,911,1,0,0,0,916,915,1,0,0,0,917,127,1,
+ 0,0,0,918,920,5,87,0,0,919,918,1,0,0,0,919,920,1,0,0,0,920,921,1,
+ 0,0,0,921,926,5,89,0,0,922,923,5,87,0,0,923,925,5,89,0,0,924,922,
+ 1,0,0,0,925,928,1,0,0,0,926,924,1,0,0,0,926,927,1,0,0,0,927,129,
+ 1,0,0,0,928,926,1,0,0,0,929,931,5,87,0,0,930,929,1,0,0,0,930,931,
+ 1,0,0,0,931,932,1,0,0,0,932,934,5,89,0,0,933,935,3,146,73,0,934,
+ 933,1,0,0,0,934,935,1,0,0,0,935,943,1,0,0,0,936,937,5,87,0,0,937,
+ 939,5,89,0,0,938,940,3,146,73,0,939,938,1,0,0,0,939,940,1,0,0,0,
+ 940,942,1,0,0,0,941,936,1,0,0,0,942,945,1,0,0,0,943,941,1,0,0,0,
+ 943,944,1,0,0,0,944,131,1,0,0,0,945,943,1,0,0,0,946,948,5,22,0,0,
+ 947,949,3,134,67,0,948,947,1,0,0,0,948,949,1,0,0,0,949,950,1,0,0,
+ 0,950,951,5,24,0,0,951,133,1,0,0,0,952,957,3,140,70,0,953,954,5,
+ 26,0,0,954,958,3,134,67,0,955,956,5,57,0,0,956,958,3,90,45,0,957,
+ 953,1,0,0,0,957,955,1,0,0,0,957,958,1,0,0,0,958,961,1,0,0,0,959,
+ 961,3,136,68,0,960,952,1,0,0,0,960,959,1,0,0,0,961,135,1,0,0,0,962,
+ 965,3,138,69,0,963,964,5,26,0,0,964,966,3,136,68,0,965,963,1,0,0,
+ 0,965,966,1,0,0,0,966,137,1,0,0,0,967,968,5,89,0,0,968,969,5,20,
+ 0,0,969,970,3,140,70,0,970,139,1,0,0,0,971,972,5,17,0,0,972,973,
+ 3,128,64,0,973,975,5,22,0,0,974,976,3,136,68,0,975,974,1,0,0,0,975,
+ 976,1,0,0,0,976,977,1,0,0,0,977,978,5,24,0,0,978,981,1,0,0,0,979,
+ 981,3,102,51,0,980,971,1,0,0,0,980,979,1,0,0,0,981,141,1,0,0,0,982,
+ 984,3,102,51,0,983,982,1,0,0,0,983,984,1,0,0,0,984,991,1,0,0,0,985,
+ 987,5,26,0,0,986,988,3,102,51,0,987,986,1,0,0,0,987,988,1,0,0,0,
+ 988,990,1,0,0,0,989,985,1,0,0,0,990,993,1,0,0,0,991,989,1,0,0,0,
+ 991,992,1,0,0,0,992,143,1,0,0,0,993,991,1,0,0,0,994,999,3,102,51,
+ 0,995,996,5,26,0,0,996,998,3,102,51,0,997,995,1,0,0,0,998,1001,1,
+ 0,0,0,999,997,1,0,0,0,999,1000,1,0,0,0,1000,145,1,0,0,0,1001,999,
+ 1,0,0,0,1002,1003,5,84,0,0,1003,1008,3,148,74,0,1004,1005,5,26,0,
+ 0,1005,1007,3,148,74,0,1006,1004,1,0,0,0,1007,1010,1,0,0,0,1008,
+ 1006,1,0,0,0,1008,1009,1,0,0,0,1009,1011,1,0,0,0,1010,1008,1,0,0,
+ 0,1011,1012,5,85,0,0,1012,147,1,0,0,0,1013,1016,5,23,0,0,1014,1016,
+ 3,102,51,0,1015,1013,1,0,0,0,1015,1014,1,0,0,0,1016,149,1,0,0,0,
+ 1017,1019,3,152,76,0,1018,1020,3,154,77,0,1019,1018,1,0,0,0,1019,
+ 1020,1,0,0,0,1020,151,1,0,0,0,1021,1026,5,90,0,0,1022,1023,5,73,
+ 0,0,1023,1025,5,90,0,0,1024,1022,1,0,0,0,1025,1028,1,0,0,0,1026,
+ 1024,1,0,0,0,1026,1027,1,0,0,0,1027,1030,1,0,0,0,1028,1026,1,0,0,
+ 0,1029,1021,1,0,0,0,1029,1030,1,0,0,0,1030,153,1,0,0,0,1031,1032,
+ 5,88,0,0,1032,1033,3,54,27,0,1033,155,1,0,0,0,132,158,163,167,174,
+ 180,188,191,196,201,207,210,214,225,232,239,242,251,254,258,271,
+ 284,297,299,304,307,310,313,318,325,330,339,345,348,351,354,358,
+ 363,368,370,372,387,396,402,405,410,415,420,423,426,435,440,449,
+ 452,457,463,467,476,481,484,487,491,495,501,504,508,511,516,519,
+ 532,540,544,552,566,574,589,601,612,617,626,629,642,653,658,667,
+ 670,683,697,708,714,724,738,749,754,768,779,784,809,815,822,824,
+ 831,839,843,851,856,864,875,883,892,906,916,919,926,930,934,939,
+ 943,948,957,960,965,975,980,983,987,991,999,1008,1015,1019,1026,
+ 1029
+ ]
+
+class modelicaParser ( Parser ):
+
+ grammarFileName = "modelica.g4"
+
+ atn = ATNDeserializer().deserialize(serializedATN())
+
+ decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+ sharedContextCache = PredictionContextCache()
+
+ literalNames = [ "<INVALID>", "'within'", "';'", "'final'", "'encapsulated'",
+ "'partial'", "'class'", "'model'", "'operator'", "'record'",
+ "'block'", "'expandable'", "'connector'", "'type'",
+ "'package'", "'pure'", "'impure'", "'function'", "'end'",
+ "'extends'", "'='", "'enumeration'", "'('", "':'",
+ "')'", "'der'", "','", "'public'", "'protected'", "'external'",
+ "'redeclare'", "'inner'", "'outer'", "'replaceable'",
+ "'import'", "'.*'", "'.{'", "'}'", "'constrainedby'",
+ "'flow'", "'stream'", "'discrete'", "'parameter'",
+ "'constant'", "'input'", "'output'", "'if'", "':='",
+ "'each'", "'initial'", "'equation'", "'algorithm'",
+ "'break'", "'return'", "'then'", "'elseif'", "'else'",
+ "'for'", "'loop'", "'in'", "'while'", "'when'", "'elsewhen'",
+ "'connect'", "'or'", "'and'", "'not'", "'<'", "'<='",
+ "'>'", "'>='", "'=='", "'<>'", "'+'", "'-'", "'.+'",
+ "'.-'", "'*'", "'/'", "'./'", "'^'", "'.^'", "'false'",
+ "'true'", "'['", "']'", "'{'", "'.'", "'annotation'" ]
+
+ symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "IDENT", "STRING", "UNSIGNED_NUMBER",
+ "WS", "COMMENT", "LINE_COMMENT" ]
+
+ RULE_stored_definition = 0
+ RULE_class_definition = 1
+ RULE_class_specifier = 2
+ RULE_class_prefixes = 3
+ RULE_long_class_specifier = 4
+ RULE_short_class_specifier = 5
+ RULE_der_class_specifier = 6
+ RULE_base_prefix = 7
+ RULE_enum_list = 8
+ RULE_enumeration_literal = 9
+ RULE_composition = 10
+ RULE_language_specification = 11
+ RULE_external_function_call = 12
+ RULE_element_list = 13
+ RULE_element = 14
+ RULE_import_clause = 15
+ RULE_import_list = 16
+ RULE_extends_clause = 17
+ RULE_constraining_clause = 18
+ RULE_component_clause = 19
+ RULE_type_prefix = 20
+ RULE_type_specifier = 21
+ RULE_component_list = 22
+ RULE_component_declaration = 23
+ RULE_condition_attribute = 24
+ RULE_declaration = 25
+ RULE_modification = 26
+ RULE_class_modification = 27
+ RULE_argument_list = 28
+ RULE_argument = 29
+ RULE_element_modification_or_replaceable = 30
+ RULE_element_modification = 31
+ RULE_element_redeclaration = 32
+ RULE_element_replaceable = 33
+ RULE_component_clause1 = 34
+ RULE_component_declaration1 = 35
+ RULE_short_class_definition = 36
+ RULE_equation_section = 37
+ RULE_algorithm_section = 38
+ RULE_equation = 39
+ RULE_statement = 40
+ RULE_if_equation = 41
+ RULE_if_statement = 42
+ RULE_for_equation = 43
+ RULE_for_statement = 44
+ RULE_for_indices = 45
+ RULE_for_index = 46
+ RULE_while_statement = 47
+ RULE_when_equation = 48
+ RULE_when_statement = 49
+ RULE_connect_clause = 50
+ RULE_expression = 51
+ RULE_simple_expression = 52
+ RULE_logical_expression = 53
+ RULE_logical_term = 54
+ RULE_logical_factor = 55
+ RULE_relation = 56
+ RULE_rel_op = 57
+ RULE_arithmetic_expression = 58
+ RULE_add_op = 59
+ RULE_term = 60
+ RULE_mul_op = 61
+ RULE_factor = 62
+ RULE_primary = 63
+ RULE_name = 64
+ RULE_component_reference = 65
+ RULE_function_call_args = 66
+ RULE_function_arguments = 67
+ RULE_named_arguments = 68
+ RULE_named_argument = 69
+ RULE_function_argument = 70
+ RULE_output_expression_list = 71
+ RULE_expression_list = 72
+ RULE_array_subscripts = 73
+ RULE_subscript_ = 74
+ RULE_comment = 75
+ RULE_string_comment = 76
+ RULE_annotation = 77
+
+ ruleNames = [ "stored_definition", "class_definition", "class_specifier",
+ "class_prefixes", "long_class_specifier", "short_class_specifier",
+ "der_class_specifier", "base_prefix", "enum_list", "enumeration_literal",
+ "composition", "language_specification", "external_function_call",
+ "element_list", "element", "import_clause", "import_list",
+ "extends_clause", "constraining_clause", "component_clause",
+ "type_prefix", "type_specifier", "component_list", "component_declaration",
+ "condition_attribute", "declaration", "modification",
+ "class_modification", "argument_list", "argument", "element_modification_or_replaceable",
+ "element_modification", "element_redeclaration", "element_replaceable",
+ "component_clause1", "component_declaration1", "short_class_definition",
+ "equation_section", "algorithm_section", "equation",
+ "statement", "if_equation", "if_statement", "for_equation",
+ "for_statement", "for_indices", "for_index", "while_statement",
+ "when_equation", "when_statement", "connect_clause",
+ "expression", "simple_expression", "logical_expression",
+ "logical_term", "logical_factor", "relation", "rel_op",
+ "arithmetic_expression", "add_op", "term", "mul_op",
+ "factor", "primary", "name", "component_reference", "function_call_args",
+ "function_arguments", "named_arguments", "named_argument",
+ "function_argument", "output_expression_list", "expression_list",
+ "array_subscripts", "subscript_", "comment", "string_comment",
+ "annotation" ]
+
+ EOF = Token.EOF
+ T__0=1
+ T__1=2
+ T__2=3
+ T__3=4
+ T__4=5
+ T__5=6
+ T__6=7
+ T__7=8
+ T__8=9
+ T__9=10
+ T__10=11
+ T__11=12
+ T__12=13
+ T__13=14
+ T__14=15
+ T__15=16
+ T__16=17
+ T__17=18
+ T__18=19
+ T__19=20
+ T__20=21
+ T__21=22
+ T__22=23
+ T__23=24
+ T__24=25
+ T__25=26
+ T__26=27
+ T__27=28
+ T__28=29
+ T__29=30
+ T__30=31
+ T__31=32
+ T__32=33
+ T__33=34
+ T__34=35
+ T__35=36
+ T__36=37
+ T__37=38
+ T__38=39
+ T__39=40
+ T__40=41
+ T__41=42
+ T__42=43
+ T__43=44
+ T__44=45
+ T__45=46
+ T__46=47
+ T__47=48
+ T__48=49
+ T__49=50
+ T__50=51
+ T__51=52
+ T__52=53
+ T__53=54
+ T__54=55
+ T__55=56
+ T__56=57
+ T__57=58
+ T__58=59
+ T__59=60
+ T__60=61
+ T__61=62
+ T__62=63
+ T__63=64
+ T__64=65
+ T__65=66
+ T__66=67
+ T__67=68
+ T__68=69
+ T__69=70
+ T__70=71
+ T__71=72
+ T__72=73
+ T__73=74
+ T__74=75
+ T__75=76
+ T__76=77
+ T__77=78
+ T__78=79
+ T__79=80
+ T__80=81
+ T__81=82
+ T__82=83
+ T__83=84
+ T__84=85
+ T__85=86
+ T__86=87
+ T__87=88
+ IDENT=89
+ STRING=90
+ UNSIGNED_NUMBER=91
+ WS=92
+ COMMENT=93
+ LINE_COMMENT=94
+
+ def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+ super().__init__(input, output)
+ self.checkVersion("4.13.1")
+ self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+ self._predicates = None
+
+
+
+
+ class Stored_definitionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def EOF(self):
+ return self.getToken(modelicaParser.EOF, 0)
+
+ def class_definition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Class_definitionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Class_definitionContext,i)
+
+
+ def name(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.NameContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.NameContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_stored_definition
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterStored_definition" ):
+ listener.enterStored_definition(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitStored_definition" ):
+ listener.exitStored_definition(self)
+
+
+
+
+ def stored_definition(self):
+
+ localctx = modelicaParser.Stored_definitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 0, self.RULE_stored_definition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 163
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==1:
+ self.state = 156
+ self.match(modelicaParser.T__0)
+ self.state = 158
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==87 or _la==89:
+ self.state = 157
+ self.name()
+
+
+ self.state = 160
+ self.match(modelicaParser.T__1)
+ self.state = 165
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 174
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 262136) != 0):
+ self.state = 167
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==3:
+ self.state = 166
+ self.match(modelicaParser.T__2)
+
+
+ self.state = 169
+ self.class_definition()
+ self.state = 170
+ self.match(modelicaParser.T__1)
+ self.state = 176
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 177
+ self.match(modelicaParser.EOF)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Class_definitionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def class_prefixes(self):
+ return self.getTypedRuleContext(modelicaParser.Class_prefixesContext,0)
+
+
+ def class_specifier(self):
+ return self.getTypedRuleContext(modelicaParser.Class_specifierContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_class_definition
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterClass_definition" ):
+ listener.enterClass_definition(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitClass_definition" ):
+ listener.exitClass_definition(self)
+
+
+
+
+ def class_definition(self):
+
+ localctx = modelicaParser.Class_definitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 2, self.RULE_class_definition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 180
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==4:
+ self.state = 179
+ self.match(modelicaParser.T__3)
+
+
+ self.state = 182
+ self.class_prefixes()
+ self.state = 183
+ self.class_specifier()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Class_specifierContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def long_class_specifier(self):
+ return self.getTypedRuleContext(modelicaParser.Long_class_specifierContext,0)
+
+
+ def short_class_specifier(self):
+ return self.getTypedRuleContext(modelicaParser.Short_class_specifierContext,0)
+
+
+ def der_class_specifier(self):
+ return self.getTypedRuleContext(modelicaParser.Der_class_specifierContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_class_specifier
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterClass_specifier" ):
+ listener.enterClass_specifier(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitClass_specifier" ):
+ listener.exitClass_specifier(self)
+
+
+
+
+ def class_specifier(self):
+
+ localctx = modelicaParser.Class_specifierContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 4, self.RULE_class_specifier)
+ try:
+ self.state = 188
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
+ if la_ == 1:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 185
+ self.long_class_specifier()
+ pass
+
+ elif la_ == 2:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 186
+ self.short_class_specifier()
+ pass
+
+ elif la_ == 3:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 187
+ self.der_class_specifier()
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Class_prefixesContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_class_prefixes
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterClass_prefixes" ):
+ listener.enterClass_prefixes(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitClass_prefixes" ):
+ listener.exitClass_prefixes(self)
+
+
+
+
+ def class_prefixes(self):
+
+ localctx = modelicaParser.Class_prefixesContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 6, self.RULE_class_prefixes)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 191
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==5:
+ self.state = 190
+ self.match(modelicaParser.T__4)
+
+
+ self.state = 214
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
+ if la_ == 1:
+ self.state = 193
+ self.match(modelicaParser.T__5)
+ pass
+
+ elif la_ == 2:
+ self.state = 194
+ self.match(modelicaParser.T__6)
+ pass
+
+ elif la_ == 3:
+ self.state = 196
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==8:
+ self.state = 195
+ self.match(modelicaParser.T__7)
+
+
+ self.state = 198
+ self.match(modelicaParser.T__8)
+ pass
+
+ elif la_ == 4:
+ self.state = 199
+ self.match(modelicaParser.T__9)
+ pass
+
+ elif la_ == 5:
+ self.state = 201
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==11:
+ self.state = 200
+ self.match(modelicaParser.T__10)
+
+
+ self.state = 203
+ self.match(modelicaParser.T__11)
+ pass
+
+ elif la_ == 6:
+ self.state = 204
+ self.match(modelicaParser.T__12)
+ pass
+
+ elif la_ == 7:
+ self.state = 205
+ self.match(modelicaParser.T__13)
+ pass
+
+ elif la_ == 8:
+ self.state = 207
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==15 or _la==16:
+ self.state = 206
+ _la = self._input.LA(1)
+ if not(_la==15 or _la==16):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+
+
+ self.state = 210
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==8:
+ self.state = 209
+ self.match(modelicaParser.T__7)
+
+
+ self.state = 212
+ self.match(modelicaParser.T__16)
+ pass
+
+ elif la_ == 9:
+ self.state = 213
+ self.match(modelicaParser.T__7)
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Long_class_specifierContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self, i:int=None):
+ if i is None:
+ return self.getTokens(modelicaParser.IDENT)
+ else:
+ return self.getToken(modelicaParser.IDENT, i)
+
+ def string_comment(self):
+ return self.getTypedRuleContext(modelicaParser.String_commentContext,0)
+
+
+ def composition(self):
+ return self.getTypedRuleContext(modelicaParser.CompositionContext,0)
+
+
+ def class_modification(self):
+ return self.getTypedRuleContext(modelicaParser.Class_modificationContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_long_class_specifier
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterLong_class_specifier" ):
+ listener.enterLong_class_specifier(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitLong_class_specifier" ):
+ listener.exitLong_class_specifier(self)
+
+
+
+
+ def long_class_specifier(self):
+
+ localctx = modelicaParser.Long_class_specifierContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 8, self.RULE_long_class_specifier)
+ self._la = 0 # Token type
+ try:
+ self.state = 232
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [89]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 216
+ self.match(modelicaParser.IDENT)
+ self.state = 217
+ self.string_comment()
+ self.state = 218
+ self.composition()
+ self.state = 219
+ self.match(modelicaParser.T__17)
+ self.state = 220
+ self.match(modelicaParser.IDENT)
+ pass
+ elif token in [19]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 222
+ self.match(modelicaParser.T__18)
+ self.state = 223
+ self.match(modelicaParser.IDENT)
+ self.state = 225
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==22:
+ self.state = 224
+ self.class_modification()
+
+
+ self.state = 227
+ self.string_comment()
+ self.state = 228
+ self.composition()
+ self.state = 229
+ self.match(modelicaParser.T__17)
+ self.state = 230
+ self.match(modelicaParser.IDENT)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Short_class_specifierContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self):
+ return self.getToken(modelicaParser.IDENT, 0)
+
+ def base_prefix(self):
+ return self.getTypedRuleContext(modelicaParser.Base_prefixContext,0)
+
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def comment(self):
+ return self.getTypedRuleContext(modelicaParser.CommentContext,0)
+
+
+ def array_subscripts(self):
+ return self.getTypedRuleContext(modelicaParser.Array_subscriptsContext,0)
+
+
+ def class_modification(self):
+ return self.getTypedRuleContext(modelicaParser.Class_modificationContext,0)
+
+
+ def enum_list(self):
+ return self.getTypedRuleContext(modelicaParser.Enum_listContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_short_class_specifier
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterShort_class_specifier" ):
+ listener.enterShort_class_specifier(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitShort_class_specifier" ):
+ listener.exitShort_class_specifier(self)
+
+
+
+
+ def short_class_specifier(self):
+
+ localctx = modelicaParser.Short_class_specifierContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 10, self.RULE_short_class_specifier)
+ self._la = 0 # Token type
+ try:
+ self.state = 258
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
+ if la_ == 1:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 234
+ self.match(modelicaParser.IDENT)
+ self.state = 235
+ self.match(modelicaParser.T__19)
+ self.state = 236
+ self.base_prefix()
+ self.state = 237
+ self.name()
+ self.state = 239
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==84:
+ self.state = 238
+ self.array_subscripts()
+
+
+ self.state = 242
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==22:
+ self.state = 241
+ self.class_modification()
+
+
+ self.state = 244
+ self.comment()
+ pass
+
+ elif la_ == 2:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 246
+ self.match(modelicaParser.IDENT)
+ self.state = 247
+ self.match(modelicaParser.T__19)
+ self.state = 248
+ self.match(modelicaParser.T__20)
+ self.state = 249
+ self.match(modelicaParser.T__21)
+ self.state = 254
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [24, 89]:
+ self.state = 251
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==89:
+ self.state = 250
+ self.enum_list()
+
+
+ pass
+ elif token in [23]:
+ self.state = 253
+ self.match(modelicaParser.T__22)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 256
+ self.match(modelicaParser.T__23)
+ self.state = 257
+ self.comment()
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Der_class_specifierContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self, i:int=None):
+ if i is None:
+ return self.getTokens(modelicaParser.IDENT)
+ else:
+ return self.getToken(modelicaParser.IDENT, i)
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def comment(self):
+ return self.getTypedRuleContext(modelicaParser.CommentContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_der_class_specifier
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterDer_class_specifier" ):
+ listener.enterDer_class_specifier(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitDer_class_specifier" ):
+ listener.exitDer_class_specifier(self)
+
+
+
+
+ def der_class_specifier(self):
+
+ localctx = modelicaParser.Der_class_specifierContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 12, self.RULE_der_class_specifier)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 260
+ self.match(modelicaParser.IDENT)
+ self.state = 261
+ self.match(modelicaParser.T__19)
+ self.state = 262
+ self.match(modelicaParser.T__24)
+ self.state = 263
+ self.match(modelicaParser.T__21)
+ self.state = 264
+ self.name()
+ self.state = 265
+ self.match(modelicaParser.T__25)
+ self.state = 266
+ self.match(modelicaParser.IDENT)
+ self.state = 271
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==26:
+ self.state = 267
+ self.match(modelicaParser.T__25)
+ self.state = 268
+ self.match(modelicaParser.IDENT)
+ self.state = 273
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 274
+ self.match(modelicaParser.T__23)
+ self.state = 275
+ self.comment()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Base_prefixContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def type_prefix(self):
+ return self.getTypedRuleContext(modelicaParser.Type_prefixContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_base_prefix
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterBase_prefix" ):
+ listener.enterBase_prefix(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitBase_prefix" ):
+ listener.exitBase_prefix(self)
+
+
+
+
+ def base_prefix(self):
+
+ localctx = modelicaParser.Base_prefixContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 14, self.RULE_base_prefix)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 277
+ self.type_prefix()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Enum_listContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def enumeration_literal(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Enumeration_literalContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Enumeration_literalContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_enum_list
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterEnum_list" ):
+ listener.enterEnum_list(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitEnum_list" ):
+ listener.exitEnum_list(self)
+
+
+
+
+ def enum_list(self):
+
+ localctx = modelicaParser.Enum_listContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 16, self.RULE_enum_list)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 279
+ self.enumeration_literal()
+ self.state = 284
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==26:
+ self.state = 280
+ self.match(modelicaParser.T__25)
+ self.state = 281
+ self.enumeration_literal()
+ self.state = 286
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Enumeration_literalContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self):
+ return self.getToken(modelicaParser.IDENT, 0)
+
+ def comment(self):
+ return self.getTypedRuleContext(modelicaParser.CommentContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_enumeration_literal
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterEnumeration_literal" ):
+ listener.enterEnumeration_literal(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitEnumeration_literal" ):
+ listener.exitEnumeration_literal(self)
+
+
+
+
+ def enumeration_literal(self):
+
+ localctx = modelicaParser.Enumeration_literalContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 18, self.RULE_enumeration_literal)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 287
+ self.match(modelicaParser.IDENT)
+ self.state = 288
+ self.comment()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CompositionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def element_list(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Element_listContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Element_listContext,i)
+
+
+ def equation_section(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Equation_sectionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Equation_sectionContext,i)
+
+
+ def algorithm_section(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Algorithm_sectionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Algorithm_sectionContext,i)
+
+
+ def annotation(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.AnnotationContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.AnnotationContext,i)
+
+
+ def language_specification(self):
+ return self.getTypedRuleContext(modelicaParser.Language_specificationContext,0)
+
+
+ def external_function_call(self):
+ return self.getTypedRuleContext(modelicaParser.External_function_callContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_composition
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterComposition" ):
+ listener.enterComposition(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitComposition" ):
+ listener.exitComposition(self)
+
+
+
+
+ def composition(self):
+
+ localctx = modelicaParser.CompositionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 20, self.RULE_composition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 290
+ self.element_list()
+ self.state = 299
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3940650076602368) != 0):
+ self.state = 297
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
+ if la_ == 1:
+ self.state = 291
+ self.match(modelicaParser.T__26)
+ self.state = 292
+ self.element_list()
+ pass
+
+ elif la_ == 2:
+ self.state = 293
+ self.match(modelicaParser.T__27)
+ self.state = 294
+ self.element_list()
+ pass
+
+ elif la_ == 3:
+ self.state = 295
+ self.equation_section()
+ pass
+
+ elif la_ == 4:
+ self.state = 296
+ self.algorithm_section()
+ pass
+
+
+ self.state = 301
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 313
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==29:
+ self.state = 302
+ self.match(modelicaParser.T__28)
+ self.state = 304
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==90:
+ self.state = 303
+ self.language_specification()
+
+
+ self.state = 307
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==87 or _la==89:
+ self.state = 306
+ self.external_function_call()
+
+
+ self.state = 310
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==88:
+ self.state = 309
+ self.annotation()
+
+
+ self.state = 312
+ self.match(modelicaParser.T__1)
+
+
+ self.state = 318
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==88:
+ self.state = 315
+ self.annotation()
+ self.state = 316
+ self.match(modelicaParser.T__1)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Language_specificationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def STRING(self):
+ return self.getToken(modelicaParser.STRING, 0)
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_language_specification
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterLanguage_specification" ):
+ listener.enterLanguage_specification(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitLanguage_specification" ):
+ listener.exitLanguage_specification(self)
+
+
+
+
+ def language_specification(self):
+
+ localctx = modelicaParser.Language_specificationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 22, self.RULE_language_specification)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 320
+ self.match(modelicaParser.STRING)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class External_function_callContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self):
+ return self.getToken(modelicaParser.IDENT, 0)
+
+ def component_reference(self):
+ return self.getTypedRuleContext(modelicaParser.Component_referenceContext,0)
+
+
+ def expression_list(self):
+ return self.getTypedRuleContext(modelicaParser.Expression_listContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_external_function_call
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterExternal_function_call" ):
+ listener.enterExternal_function_call(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitExternal_function_call" ):
+ listener.exitExternal_function_call(self)
+
+
+
+
+ def external_function_call(self):
+
+ localctx = modelicaParser.External_function_callContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 24, self.RULE_external_function_call)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 325
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
+ if la_ == 1:
+ self.state = 322
+ self.component_reference()
+ self.state = 323
+ self.match(modelicaParser.T__19)
+
+
+ self.state = 327
+ self.match(modelicaParser.IDENT)
+ self.state = 328
+ self.match(modelicaParser.T__21)
+ self.state = 330
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if (((_la) & ~0x3f) == 0 and ((1 << _la) & 633318735609856) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 62326657) != 0):
+ self.state = 329
+ self.expression_list()
+
+
+ self.state = 332
+ self.match(modelicaParser.T__23)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Element_listContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def element(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.ElementContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.ElementContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_element_list
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterElement_list" ):
+ listener.enterElement_list(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitElement_list" ):
+ listener.exitElement_list(self)
+
+
+
+
+ def element_list(self):
+
+ localctx = modelicaParser.Element_listContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 26, self.RULE_element_list)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 339
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 69852275146744) != 0) or _la==87 or _la==89:
+ self.state = 334
+ self.element()
+ self.state = 335
+ self.match(modelicaParser.T__1)
+ self.state = 341
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ElementContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def import_clause(self):
+ return self.getTypedRuleContext(modelicaParser.Import_clauseContext,0)
+
+
+ def extends_clause(self):
+ return self.getTypedRuleContext(modelicaParser.Extends_clauseContext,0)
+
+
+ def class_definition(self):
+ return self.getTypedRuleContext(modelicaParser.Class_definitionContext,0)
+
+
+ def component_clause(self):
+ return self.getTypedRuleContext(modelicaParser.Component_clauseContext,0)
+
+
+ def constraining_clause(self):
+ return self.getTypedRuleContext(modelicaParser.Constraining_clauseContext,0)
+
+
+ def comment(self):
+ return self.getTypedRuleContext(modelicaParser.CommentContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_element
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterElement" ):
+ listener.enterElement(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitElement" ):
+ listener.exitElement(self)
+
+
+
+
+ def element(self):
+
+ localctx = modelicaParser.ElementContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 28, self.RULE_element)
+ self._la = 0 # Token type
+ try:
+ self.state = 372
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [34]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 342
+ self.import_clause()
+ pass
+ elif token in [19]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 343
+ self.extends_clause()
+ pass
+ elif token in [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 30, 31, 32, 33, 39, 40, 41, 42, 43, 44, 45, 87, 89]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 345
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==30:
+ self.state = 344
+ self.match(modelicaParser.T__29)
+
+
+ self.state = 348
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==3:
+ self.state = 347
+ self.match(modelicaParser.T__2)
+
+
+ self.state = 351
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==31:
+ self.state = 350
+ self.match(modelicaParser.T__30)
+
+
+ self.state = 354
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==32:
+ self.state = 353
+ self.match(modelicaParser.T__31)
+
+
+ self.state = 370
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 39, 40, 41, 42, 43, 44, 45, 87, 89]:
+ self.state = 358
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]:
+ self.state = 356
+ self.class_definition()
+ pass
+ elif token in [39, 40, 41, 42, 43, 44, 45, 87, 89]:
+ self.state = 357
+ self.component_clause()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ pass
+ elif token in [33]:
+ self.state = 360
+ self.match(modelicaParser.T__32)
+ self.state = 363
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]:
+ self.state = 361
+ self.class_definition()
+ pass
+ elif token in [39, 40, 41, 42, 43, 44, 45, 87, 89]:
+ self.state = 362
+ self.component_clause()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 368
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==38:
+ self.state = 365
+ self.constraining_clause()
+ self.state = 366
+ self.comment()
+
+
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Import_clauseContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def comment(self):
+ return self.getTypedRuleContext(modelicaParser.CommentContext,0)
+
+
+ def IDENT(self):
+ return self.getToken(modelicaParser.IDENT, 0)
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def import_list(self):
+ return self.getTypedRuleContext(modelicaParser.Import_listContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_import_clause
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterImport_clause" ):
+ listener.enterImport_clause(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitImport_clause" ):
+ listener.exitImport_clause(self)
+
+
+
+
+ def import_clause(self):
+
+ localctx = modelicaParser.Import_clauseContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 30, self.RULE_import_clause)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 374
+ self.match(modelicaParser.T__33)
+ self.state = 387
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
+ if la_ == 1:
+ self.state = 375
+ self.match(modelicaParser.IDENT)
+ self.state = 376
+ self.match(modelicaParser.T__19)
+ self.state = 377
+ self.name()
+ pass
+
+ elif la_ == 2:
+ self.state = 378
+ self.name()
+ self.state = 379
+ self.match(modelicaParser.T__34)
+ pass
+
+ elif la_ == 3:
+ self.state = 381
+ self.name()
+ self.state = 382
+ self.match(modelicaParser.T__35)
+ self.state = 383
+ self.import_list()
+ self.state = 384
+ self.match(modelicaParser.T__36)
+ pass
+
+ elif la_ == 4:
+ self.state = 386
+ self.name()
+ pass
+
+
+ self.state = 389
+ self.comment()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Import_listContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self, i:int=None):
+ if i is None:
+ return self.getTokens(modelicaParser.IDENT)
+ else:
+ return self.getToken(modelicaParser.IDENT, i)
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_import_list
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterImport_list" ):
+ listener.enterImport_list(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitImport_list" ):
+ listener.exitImport_list(self)
+
+
+
+
+ def import_list(self):
+
+ localctx = modelicaParser.Import_listContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 32, self.RULE_import_list)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 391
+ self.match(modelicaParser.IDENT)
+ self.state = 396
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==26:
+ self.state = 392
+ self.match(modelicaParser.T__25)
+ self.state = 393
+ self.match(modelicaParser.IDENT)
+ self.state = 398
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Extends_clauseContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def class_modification(self):
+ return self.getTypedRuleContext(modelicaParser.Class_modificationContext,0)
+
+
+ def annotation(self):
+ return self.getTypedRuleContext(modelicaParser.AnnotationContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_extends_clause
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterExtends_clause" ):
+ listener.enterExtends_clause(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitExtends_clause" ):
+ listener.exitExtends_clause(self)
+
+
+
+
+ def extends_clause(self):
+
+ localctx = modelicaParser.Extends_clauseContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 34, self.RULE_extends_clause)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 399
+ self.match(modelicaParser.T__18)
+ self.state = 400
+ self.name()
+ self.state = 402
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==22:
+ self.state = 401
+ self.class_modification()
+
+
+ self.state = 405
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==88:
+ self.state = 404
+ self.annotation()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Constraining_clauseContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def class_modification(self):
+ return self.getTypedRuleContext(modelicaParser.Class_modificationContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_constraining_clause
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterConstraining_clause" ):
+ listener.enterConstraining_clause(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitConstraining_clause" ):
+ listener.exitConstraining_clause(self)
+
+
+
+
+ def constraining_clause(self):
+
+ localctx = modelicaParser.Constraining_clauseContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 36, self.RULE_constraining_clause)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 407
+ self.match(modelicaParser.T__37)
+ self.state = 408
+ self.name()
+ self.state = 410
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==22:
+ self.state = 409
+ self.class_modification()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Component_clauseContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def type_prefix(self):
+ return self.getTypedRuleContext(modelicaParser.Type_prefixContext,0)
+
+
+ def type_specifier(self):
+ return self.getTypedRuleContext(modelicaParser.Type_specifierContext,0)
+
+
+ def component_list(self):
+ return self.getTypedRuleContext(modelicaParser.Component_listContext,0)
+
+
+ def array_subscripts(self):
+ return self.getTypedRuleContext(modelicaParser.Array_subscriptsContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_component_clause
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterComponent_clause" ):
+ listener.enterComponent_clause(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitComponent_clause" ):
+ listener.exitComponent_clause(self)
+
+
+
+
+ def component_clause(self):
+
+ localctx = modelicaParser.Component_clauseContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 38, self.RULE_component_clause)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 412
+ self.type_prefix()
+ self.state = 413
+ self.type_specifier()
+ self.state = 415
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==84:
+ self.state = 414
+ self.array_subscripts()
+
+
+ self.state = 417
+ self.component_list()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Type_prefixContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_type_prefix
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterType_prefix" ):
+ listener.enterType_prefix(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitType_prefix" ):
+ listener.exitType_prefix(self)
+
+
+
+
+ def type_prefix(self):
+
+ localctx = modelicaParser.Type_prefixContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 40, self.RULE_type_prefix)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 420
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==39 or _la==40:
+ self.state = 419
+ _la = self._input.LA(1)
+ if not(_la==39 or _la==40):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+
+
+ self.state = 423
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if (((_la) & ~0x3f) == 0 and ((1 << _la) & 15393162788864) != 0):
+ self.state = 422
+ _la = self._input.LA(1)
+ if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 15393162788864) != 0)):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+
+
+ self.state = 426
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==44 or _la==45:
+ self.state = 425
+ _la = self._input.LA(1)
+ if not(_la==44 or _la==45):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Type_specifierContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_type_specifier
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterType_specifier" ):
+ listener.enterType_specifier(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitType_specifier" ):
+ listener.exitType_specifier(self)
+
+
+
+
+ def type_specifier(self):
+
+ localctx = modelicaParser.Type_specifierContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 42, self.RULE_type_specifier)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 428
+ self.name()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Component_listContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def component_declaration(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Component_declarationContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Component_declarationContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_component_list
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterComponent_list" ):
+ listener.enterComponent_list(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitComponent_list" ):
+ listener.exitComponent_list(self)
+
+
+
+
+ def component_list(self):
+
+ localctx = modelicaParser.Component_listContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 44, self.RULE_component_list)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 430
+ self.component_declaration()
+ self.state = 435
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==26:
+ self.state = 431
+ self.match(modelicaParser.T__25)
+ self.state = 432
+ self.component_declaration()
+ self.state = 437
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Component_declarationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def declaration(self):
+ return self.getTypedRuleContext(modelicaParser.DeclarationContext,0)
+
+
+ def comment(self):
+ return self.getTypedRuleContext(modelicaParser.CommentContext,0)
+
+
+ def condition_attribute(self):
+ return self.getTypedRuleContext(modelicaParser.Condition_attributeContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_component_declaration
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterComponent_declaration" ):
+ listener.enterComponent_declaration(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitComponent_declaration" ):
+ listener.exitComponent_declaration(self)
+
+
+
+
+ def component_declaration(self):
+
+ localctx = modelicaParser.Component_declarationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 46, self.RULE_component_declaration)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 438
+ self.declaration()
+ self.state = 440
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==46:
+ self.state = 439
+ self.condition_attribute()
+
+
+ self.state = 442
+ self.comment()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Condition_attributeContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def expression(self):
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_condition_attribute
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterCondition_attribute" ):
+ listener.enterCondition_attribute(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitCondition_attribute" ):
+ listener.exitCondition_attribute(self)
+
+
+
+
+ def condition_attribute(self):
+
+ localctx = modelicaParser.Condition_attributeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 48, self.RULE_condition_attribute)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 444
+ self.match(modelicaParser.T__45)
+ self.state = 445
+ self.expression()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DeclarationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self):
+ return self.getToken(modelicaParser.IDENT, 0)
+
+ def array_subscripts(self):
+ return self.getTypedRuleContext(modelicaParser.Array_subscriptsContext,0)
+
+
+ def modification(self):
+ return self.getTypedRuleContext(modelicaParser.ModificationContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_declaration
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterDeclaration" ):
+ listener.enterDeclaration(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitDeclaration" ):
+ listener.exitDeclaration(self)
+
+
+
+
+ def declaration(self):
+
+ localctx = modelicaParser.DeclarationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 50, self.RULE_declaration)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 447
+ self.match(modelicaParser.IDENT)
+ self.state = 449
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==84:
+ self.state = 448
+ self.array_subscripts()
+
+
+ self.state = 452
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if (((_la) & ~0x3f) == 0 and ((1 << _la) & 140737493598208) != 0):
+ self.state = 451
+ self.modification()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ModificationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def class_modification(self):
+ return self.getTypedRuleContext(modelicaParser.Class_modificationContext,0)
+
+
+ def expression(self):
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_modification
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterModification" ):
+ listener.enterModification(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitModification" ):
+ listener.exitModification(self)
+
+
+
+
+ def modification(self):
+
+ localctx = modelicaParser.ModificationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 52, self.RULE_modification)
+ self._la = 0 # Token type
+ try:
+ self.state = 463
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [22]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 454
+ self.class_modification()
+ self.state = 457
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==20:
+ self.state = 455
+ self.match(modelicaParser.T__19)
+ self.state = 456
+ self.expression()
+
+
+ pass
+ elif token in [20]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 459
+ self.match(modelicaParser.T__19)
+ self.state = 460
+ self.expression()
+ pass
+ elif token in [47]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 461
+ self.match(modelicaParser.T__46)
+ self.state = 462
+ self.expression()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Class_modificationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def argument_list(self):
+ return self.getTypedRuleContext(modelicaParser.Argument_listContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_class_modification
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterClass_modification" ):
+ listener.enterClass_modification(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitClass_modification" ):
+ listener.exitClass_modification(self)
+
+
+
+
+ def class_modification(self):
+
+ localctx = modelicaParser.Class_modificationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 54, self.RULE_class_modification)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 465
+ self.match(modelicaParser.T__21)
+ self.state = 467
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if (((_la) & ~0x3f) == 0 and ((1 << _la) & 281484640387080) != 0) or _la==87 or _la==89:
+ self.state = 466
+ self.argument_list()
+
+
+ self.state = 469
+ self.match(modelicaParser.T__23)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Argument_listContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def argument(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.ArgumentContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.ArgumentContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_argument_list
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterArgument_list" ):
+ listener.enterArgument_list(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitArgument_list" ):
+ listener.exitArgument_list(self)
+
+
+
+
+ def argument_list(self):
+
+ localctx = modelicaParser.Argument_listContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 56, self.RULE_argument_list)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 471
+ self.argument()
+ self.state = 476
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==26:
+ self.state = 472
+ self.match(modelicaParser.T__25)
+ self.state = 473
+ self.argument()
+ self.state = 478
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ArgumentContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def element_modification_or_replaceable(self):
+ return self.getTypedRuleContext(modelicaParser.Element_modification_or_replaceableContext,0)
+
+
+ def element_redeclaration(self):
+ return self.getTypedRuleContext(modelicaParser.Element_redeclarationContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_argument
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterArgument" ):
+ listener.enterArgument(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitArgument" ):
+ listener.exitArgument(self)
+
+
+
+
+ def argument(self):
+
+ localctx = modelicaParser.ArgumentContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 58, self.RULE_argument)
+ try:
+ self.state = 481
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [3, 33, 48, 87, 89]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 479
+ self.element_modification_or_replaceable()
+ pass
+ elif token in [30]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 480
+ self.element_redeclaration()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Element_modification_or_replaceableContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def element_modification(self):
+ return self.getTypedRuleContext(modelicaParser.Element_modificationContext,0)
+
+
+ def element_replaceable(self):
+ return self.getTypedRuleContext(modelicaParser.Element_replaceableContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_element_modification_or_replaceable
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterElement_modification_or_replaceable" ):
+ listener.enterElement_modification_or_replaceable(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitElement_modification_or_replaceable" ):
+ listener.exitElement_modification_or_replaceable(self)
+
+
+
+
+ def element_modification_or_replaceable(self):
+
+ localctx = modelicaParser.Element_modification_or_replaceableContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 60, self.RULE_element_modification_or_replaceable)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 484
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==48:
+ self.state = 483
+ self.match(modelicaParser.T__47)
+
+
+ self.state = 487
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==3:
+ self.state = 486
+ self.match(modelicaParser.T__2)
+
+
+ self.state = 491
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [87, 89]:
+ self.state = 489
+ self.element_modification()
+ pass
+ elif token in [33]:
+ self.state = 490
+ self.element_replaceable()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Element_modificationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def string_comment(self):
+ return self.getTypedRuleContext(modelicaParser.String_commentContext,0)
+
+
+ def modification(self):
+ return self.getTypedRuleContext(modelicaParser.ModificationContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_element_modification
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterElement_modification" ):
+ listener.enterElement_modification(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitElement_modification" ):
+ listener.exitElement_modification(self)
+
+
+
+
+ def element_modification(self):
+
+ localctx = modelicaParser.Element_modificationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 62, self.RULE_element_modification)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 493
+ self.name()
+ self.state = 495
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if (((_la) & ~0x3f) == 0 and ((1 << _la) & 140737493598208) != 0):
+ self.state = 494
+ self.modification()
+
+
+ self.state = 497
+ self.string_comment()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Element_redeclarationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def element_replaceable(self):
+ return self.getTypedRuleContext(modelicaParser.Element_replaceableContext,0)
+
+
+ def short_class_definition(self):
+ return self.getTypedRuleContext(modelicaParser.Short_class_definitionContext,0)
+
+
+ def component_clause1(self):
+ return self.getTypedRuleContext(modelicaParser.Component_clause1Context,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_element_redeclaration
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterElement_redeclaration" ):
+ listener.enterElement_redeclaration(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitElement_redeclaration" ):
+ listener.exitElement_redeclaration(self)
+
+
+
+
+ def element_redeclaration(self):
+
+ localctx = modelicaParser.Element_redeclarationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 64, self.RULE_element_redeclaration)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 499
+ self.match(modelicaParser.T__29)
+ self.state = 501
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==48:
+ self.state = 500
+ self.match(modelicaParser.T__47)
+
+
+ self.state = 504
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==3:
+ self.state = 503
+ self.match(modelicaParser.T__2)
+
+
+ self.state = 511
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 39, 40, 41, 42, 43, 44, 45, 87, 89]:
+ self.state = 508
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]:
+ self.state = 506
+ self.short_class_definition()
+ pass
+ elif token in [39, 40, 41, 42, 43, 44, 45, 87, 89]:
+ self.state = 507
+ self.component_clause1()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ pass
+ elif token in [33]:
+ self.state = 510
+ self.element_replaceable()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Element_replaceableContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def short_class_definition(self):
+ return self.getTypedRuleContext(modelicaParser.Short_class_definitionContext,0)
+
+
+ def component_clause1(self):
+ return self.getTypedRuleContext(modelicaParser.Component_clause1Context,0)
+
+
+ def constraining_clause(self):
+ return self.getTypedRuleContext(modelicaParser.Constraining_clauseContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_element_replaceable
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterElement_replaceable" ):
+ listener.enterElement_replaceable(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitElement_replaceable" ):
+ listener.exitElement_replaceable(self)
+
+
+
+
+ def element_replaceable(self):
+
+ localctx = modelicaParser.Element_replaceableContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 66, self.RULE_element_replaceable)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 513
+ self.match(modelicaParser.T__32)
+ self.state = 516
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]:
+ self.state = 514
+ self.short_class_definition()
+ pass
+ elif token in [39, 40, 41, 42, 43, 44, 45, 87, 89]:
+ self.state = 515
+ self.component_clause1()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 519
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==38:
+ self.state = 518
+ self.constraining_clause()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Component_clause1Context(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def type_prefix(self):
+ return self.getTypedRuleContext(modelicaParser.Type_prefixContext,0)
+
+
+ def type_specifier(self):
+ return self.getTypedRuleContext(modelicaParser.Type_specifierContext,0)
+
+
+ def component_declaration1(self):
+ return self.getTypedRuleContext(modelicaParser.Component_declaration1Context,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_component_clause1
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterComponent_clause1" ):
+ listener.enterComponent_clause1(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitComponent_clause1" ):
+ listener.exitComponent_clause1(self)
+
+
+
+
+ def component_clause1(self):
+
+ localctx = modelicaParser.Component_clause1Context(self, self._ctx, self.state)
+ self.enterRule(localctx, 68, self.RULE_component_clause1)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 521
+ self.type_prefix()
+ self.state = 522
+ self.type_specifier()
+ self.state = 523
+ self.component_declaration1()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Component_declaration1Context(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def declaration(self):
+ return self.getTypedRuleContext(modelicaParser.DeclarationContext,0)
+
+
+ def comment(self):
+ return self.getTypedRuleContext(modelicaParser.CommentContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_component_declaration1
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterComponent_declaration1" ):
+ listener.enterComponent_declaration1(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitComponent_declaration1" ):
+ listener.exitComponent_declaration1(self)
+
+
+
+
+ def component_declaration1(self):
+
+ localctx = modelicaParser.Component_declaration1Context(self, self._ctx, self.state)
+ self.enterRule(localctx, 70, self.RULE_component_declaration1)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 525
+ self.declaration()
+ self.state = 526
+ self.comment()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Short_class_definitionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def class_prefixes(self):
+ return self.getTypedRuleContext(modelicaParser.Class_prefixesContext,0)
+
+
+ def short_class_specifier(self):
+ return self.getTypedRuleContext(modelicaParser.Short_class_specifierContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_short_class_definition
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterShort_class_definition" ):
+ listener.enterShort_class_definition(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitShort_class_definition" ):
+ listener.exitShort_class_definition(self)
+
+
+
+
+ def short_class_definition(self):
+
+ localctx = modelicaParser.Short_class_definitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 72, self.RULE_short_class_definition)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 528
+ self.class_prefixes()
+ self.state = 529
+ self.short_class_specifier()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Equation_sectionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def equation(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.EquationContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.EquationContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_equation_section
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterEquation_section" ):
+ listener.enterEquation_section(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitEquation_section" ):
+ listener.exitEquation_section(self)
+
+
+
+
+ def equation_section(self):
+
+ localctx = modelicaParser.Equation_sectionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 74, self.RULE_equation_section)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 532
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==49:
+ self.state = 531
+ self.match(modelicaParser.T__48)
+
+
+ self.state = 534
+ self.match(modelicaParser.T__49)
+ self.state = 540
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,69,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 535
+ self.equation()
+ self.state = 536
+ self.match(modelicaParser.T__1)
+ self.state = 542
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,69,self._ctx)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Algorithm_sectionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def statement(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.StatementContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.StatementContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_algorithm_section
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterAlgorithm_section" ):
+ listener.enterAlgorithm_section(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitAlgorithm_section" ):
+ listener.exitAlgorithm_section(self)
+
+
+
+
+ def algorithm_section(self):
+
+ localctx = modelicaParser.Algorithm_sectionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 76, self.RULE_algorithm_section)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 544
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==49:
+ self.state = 543
+ self.match(modelicaParser.T__48)
+
+
+ self.state = 546
+ self.match(modelicaParser.T__50)
+ self.state = 552
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3616460869526880256) != 0) or _la==87 or _la==89:
+ self.state = 547
+ self.statement()
+ self.state = 548
+ self.match(modelicaParser.T__1)
+ self.state = 554
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class EquationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def comment(self):
+ return self.getTypedRuleContext(modelicaParser.CommentContext,0)
+
+
+ def simple_expression(self):
+ return self.getTypedRuleContext(modelicaParser.Simple_expressionContext,0)
+
+
+ def expression(self):
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,0)
+
+
+ def if_equation(self):
+ return self.getTypedRuleContext(modelicaParser.If_equationContext,0)
+
+
+ def for_equation(self):
+ return self.getTypedRuleContext(modelicaParser.For_equationContext,0)
+
+
+ def connect_clause(self):
+ return self.getTypedRuleContext(modelicaParser.Connect_clauseContext,0)
+
+
+ def when_equation(self):
+ return self.getTypedRuleContext(modelicaParser.When_equationContext,0)
+
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def function_call_args(self):
+ return self.getTypedRuleContext(modelicaParser.Function_call_argsContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_equation
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterEquation" ):
+ listener.enterEquation(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitEquation" ):
+ listener.exitEquation(self)
+
+
+
+
+ def equation(self):
+
+ localctx = modelicaParser.EquationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 78, self.RULE_equation)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 566
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
+ if la_ == 1:
+ self.state = 555
+ self.simple_expression()
+ self.state = 556
+ self.match(modelicaParser.T__19)
+ self.state = 557
+ self.expression()
+ pass
+
+ elif la_ == 2:
+ self.state = 559
+ self.if_equation()
+ pass
+
+ elif la_ == 3:
+ self.state = 560
+ self.for_equation()
+ pass
+
+ elif la_ == 4:
+ self.state = 561
+ self.connect_clause()
+ pass
+
+ elif la_ == 5:
+ self.state = 562
+ self.when_equation()
+ pass
+
+ elif la_ == 6:
+ self.state = 563
+ self.name()
+ self.state = 564
+ self.function_call_args()
+ pass
+
+
+ self.state = 568
+ self.comment()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class StatementContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def comment(self):
+ return self.getTypedRuleContext(modelicaParser.CommentContext,0)
+
+
+ def component_reference(self):
+ return self.getTypedRuleContext(modelicaParser.Component_referenceContext,0)
+
+
+ def output_expression_list(self):
+ return self.getTypedRuleContext(modelicaParser.Output_expression_listContext,0)
+
+
+ def function_call_args(self):
+ return self.getTypedRuleContext(modelicaParser.Function_call_argsContext,0)
+
+
+ def if_statement(self):
+ return self.getTypedRuleContext(modelicaParser.If_statementContext,0)
+
+
+ def for_statement(self):
+ return self.getTypedRuleContext(modelicaParser.For_statementContext,0)
+
+
+ def while_statement(self):
+ return self.getTypedRuleContext(modelicaParser.While_statementContext,0)
+
+
+ def when_statement(self):
+ return self.getTypedRuleContext(modelicaParser.When_statementContext,0)
+
+
+ def expression(self):
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_statement
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterStatement" ):
+ listener.enterStatement(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitStatement" ):
+ listener.exitStatement(self)
+
+
+
+
+ def statement(self):
+
+ localctx = modelicaParser.StatementContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 80, self.RULE_statement)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 589
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [87, 89]:
+ self.state = 570
+ self.component_reference()
+ self.state = 574
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [47]:
+ self.state = 571
+ self.match(modelicaParser.T__46)
+ self.state = 572
+ self.expression()
+ pass
+ elif token in [22]:
+ self.state = 573
+ self.function_call_args()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ pass
+ elif token in [22]:
+ self.state = 576
+ self.match(modelicaParser.T__21)
+ self.state = 577
+ self.output_expression_list()
+ self.state = 578
+ self.match(modelicaParser.T__23)
+ self.state = 579
+ self.match(modelicaParser.T__46)
+ self.state = 580
+ self.component_reference()
+ self.state = 581
+ self.function_call_args()
+ pass
+ elif token in [52]:
+ self.state = 583
+ self.match(modelicaParser.T__51)
+ pass
+ elif token in [53]:
+ self.state = 584
+ self.match(modelicaParser.T__52)
+ pass
+ elif token in [46]:
+ self.state = 585
+ self.if_statement()
+ pass
+ elif token in [57]:
+ self.state = 586
+ self.for_statement()
+ pass
+ elif token in [60]:
+ self.state = 587
+ self.while_statement()
+ pass
+ elif token in [61]:
+ self.state = 588
+ self.when_statement()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 591
+ self.comment()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class If_equationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def expression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.ExpressionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,i)
+
+
+ def equation(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.EquationContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.EquationContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_if_equation
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterIf_equation" ):
+ listener.enterIf_equation(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitIf_equation" ):
+ listener.exitIf_equation(self)
+
+
+
+
+ def if_equation(self):
+
+ localctx = modelicaParser.If_equationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 82, self.RULE_if_equation)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 593
+ self.match(modelicaParser.T__45)
+ self.state = 594
+ self.expression()
+ self.state = 595
+ self.match(modelicaParser.T__53)
+ self.state = 601
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,75,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 596
+ self.equation()
+ self.state = 597
+ self.match(modelicaParser.T__1)
+ self.state = 603
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,75,self._ctx)
+
+ self.state = 617
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==55:
+ self.state = 604
+ self.match(modelicaParser.T__54)
+ self.state = 605
+ self.expression()
+ self.state = 606
+ self.match(modelicaParser.T__53)
+ self.state = 612
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,76,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 607
+ self.equation()
+ self.state = 608
+ self.match(modelicaParser.T__1)
+ self.state = 614
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,76,self._ctx)
+
+ self.state = 619
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 629
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==56:
+ self.state = 620
+ self.match(modelicaParser.T__55)
+ self.state = 626
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,78,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 621
+ self.equation()
+ self.state = 622
+ self.match(modelicaParser.T__1)
+ self.state = 628
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,78,self._ctx)
+
+
+
+ self.state = 631
+ self.match(modelicaParser.T__17)
+ self.state = 632
+ self.match(modelicaParser.T__45)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class If_statementContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def expression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.ExpressionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,i)
+
+
+ def statement(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.StatementContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.StatementContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_if_statement
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterIf_statement" ):
+ listener.enterIf_statement(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitIf_statement" ):
+ listener.exitIf_statement(self)
+
+
+
+
+ def if_statement(self):
+
+ localctx = modelicaParser.If_statementContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 84, self.RULE_if_statement)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 634
+ self.match(modelicaParser.T__45)
+ self.state = 635
+ self.expression()
+ self.state = 636
+ self.match(modelicaParser.T__53)
+ self.state = 642
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3616460869526880256) != 0) or _la==87 or _la==89:
+ self.state = 637
+ self.statement()
+ self.state = 638
+ self.match(modelicaParser.T__1)
+ self.state = 644
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 658
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==55:
+ self.state = 645
+ self.match(modelicaParser.T__54)
+ self.state = 646
+ self.expression()
+ self.state = 647
+ self.match(modelicaParser.T__53)
+ self.state = 653
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3616460869526880256) != 0) or _la==87 or _la==89:
+ self.state = 648
+ self.statement()
+ self.state = 649
+ self.match(modelicaParser.T__1)
+ self.state = 655
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 660
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 670
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==56:
+ self.state = 661
+ self.match(modelicaParser.T__55)
+ self.state = 667
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3616460869526880256) != 0) or _la==87 or _la==89:
+ self.state = 662
+ self.statement()
+ self.state = 663
+ self.match(modelicaParser.T__1)
+ self.state = 669
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+
+
+ self.state = 672
+ self.match(modelicaParser.T__17)
+ self.state = 673
+ self.match(modelicaParser.T__45)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class For_equationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def for_indices(self):
+ return self.getTypedRuleContext(modelicaParser.For_indicesContext,0)
+
+
+ def equation(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.EquationContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.EquationContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_for_equation
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterFor_equation" ):
+ listener.enterFor_equation(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitFor_equation" ):
+ listener.exitFor_equation(self)
+
+
+
+
+ def for_equation(self):
+
+ localctx = modelicaParser.For_equationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 86, self.RULE_for_equation)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 675
+ self.match(modelicaParser.T__56)
+ self.state = 676
+ self.for_indices()
+ self.state = 677
+ self.match(modelicaParser.T__57)
+ self.state = 683
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,85,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 678
+ self.equation()
+ self.state = 679
+ self.match(modelicaParser.T__1)
+ self.state = 685
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,85,self._ctx)
+
+ self.state = 686
+ self.match(modelicaParser.T__17)
+ self.state = 687
+ self.match(modelicaParser.T__56)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class For_statementContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def for_indices(self):
+ return self.getTypedRuleContext(modelicaParser.For_indicesContext,0)
+
+
+ def statement(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.StatementContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.StatementContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_for_statement
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterFor_statement" ):
+ listener.enterFor_statement(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitFor_statement" ):
+ listener.exitFor_statement(self)
+
+
+
+
+ def for_statement(self):
+
+ localctx = modelicaParser.For_statementContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 88, self.RULE_for_statement)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 689
+ self.match(modelicaParser.T__56)
+ self.state = 690
+ self.for_indices()
+ self.state = 691
+ self.match(modelicaParser.T__57)
+ self.state = 697
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3616460869526880256) != 0) or _la==87 or _la==89:
+ self.state = 692
+ self.statement()
+ self.state = 693
+ self.match(modelicaParser.T__1)
+ self.state = 699
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 700
+ self.match(modelicaParser.T__17)
+ self.state = 701
+ self.match(modelicaParser.T__56)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class For_indicesContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def for_index(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.For_indexContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.For_indexContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_for_indices
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterFor_indices" ):
+ listener.enterFor_indices(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitFor_indices" ):
+ listener.exitFor_indices(self)
+
+
+
+
+ def for_indices(self):
+
+ localctx = modelicaParser.For_indicesContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 90, self.RULE_for_indices)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 703
+ self.for_index()
+ self.state = 708
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==26:
+ self.state = 704
+ self.match(modelicaParser.T__25)
+ self.state = 705
+ self.for_index()
+ self.state = 710
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class For_indexContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self):
+ return self.getToken(modelicaParser.IDENT, 0)
+
+ def expression(self):
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_for_index
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterFor_index" ):
+ listener.enterFor_index(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitFor_index" ):
+ listener.exitFor_index(self)
+
+
+
+
+ def for_index(self):
+
+ localctx = modelicaParser.For_indexContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 92, self.RULE_for_index)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 711
+ self.match(modelicaParser.IDENT)
+ self.state = 714
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==59:
+ self.state = 712
+ self.match(modelicaParser.T__58)
+ self.state = 713
+ self.expression()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class While_statementContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def expression(self):
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,0)
+
+
+ def statement(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.StatementContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.StatementContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_while_statement
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterWhile_statement" ):
+ listener.enterWhile_statement(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitWhile_statement" ):
+ listener.exitWhile_statement(self)
+
+
+
+
+ def while_statement(self):
+
+ localctx = modelicaParser.While_statementContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 94, self.RULE_while_statement)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 716
+ self.match(modelicaParser.T__59)
+ self.state = 717
+ self.expression()
+ self.state = 718
+ self.match(modelicaParser.T__57)
+ self.state = 724
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3616460869526880256) != 0) or _la==87 or _la==89:
+ self.state = 719
+ self.statement()
+ self.state = 720
+ self.match(modelicaParser.T__1)
+ self.state = 726
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 727
+ self.match(modelicaParser.T__17)
+ self.state = 728
+ self.match(modelicaParser.T__59)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class When_equationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def expression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.ExpressionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,i)
+
+
+ def equation(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.EquationContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.EquationContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_when_equation
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterWhen_equation" ):
+ listener.enterWhen_equation(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitWhen_equation" ):
+ listener.exitWhen_equation(self)
+
+
+
+
+ def when_equation(self):
+
+ localctx = modelicaParser.When_equationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 96, self.RULE_when_equation)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 730
+ self.match(modelicaParser.T__60)
+ self.state = 731
+ self.expression()
+ self.state = 732
+ self.match(modelicaParser.T__53)
+ self.state = 738
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,90,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 733
+ self.equation()
+ self.state = 734
+ self.match(modelicaParser.T__1)
+ self.state = 740
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,90,self._ctx)
+
+ self.state = 754
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==62:
+ self.state = 741
+ self.match(modelicaParser.T__61)
+ self.state = 742
+ self.expression()
+ self.state = 743
+ self.match(modelicaParser.T__53)
+ self.state = 749
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,91,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 744
+ self.equation()
+ self.state = 745
+ self.match(modelicaParser.T__1)
+ self.state = 751
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,91,self._ctx)
+
+ self.state = 756
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 757
+ self.match(modelicaParser.T__17)
+ self.state = 758
+ self.match(modelicaParser.T__60)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class When_statementContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def expression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.ExpressionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,i)
+
+
+ def statement(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.StatementContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.StatementContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_when_statement
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterWhen_statement" ):
+ listener.enterWhen_statement(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitWhen_statement" ):
+ listener.exitWhen_statement(self)
+
+
+
+
+ def when_statement(self):
+
+ localctx = modelicaParser.When_statementContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 98, self.RULE_when_statement)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 760
+ self.match(modelicaParser.T__60)
+ self.state = 761
+ self.expression()
+ self.state = 762
+ self.match(modelicaParser.T__53)
+ self.state = 768
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3616460869526880256) != 0) or _la==87 or _la==89:
+ self.state = 763
+ self.statement()
+ self.state = 764
+ self.match(modelicaParser.T__1)
+ self.state = 770
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 784
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==62:
+ self.state = 771
+ self.match(modelicaParser.T__61)
+ self.state = 772
+ self.expression()
+ self.state = 773
+ self.match(modelicaParser.T__53)
+ self.state = 779
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3616460869526880256) != 0) or _la==87 or _la==89:
+ self.state = 774
+ self.statement()
+ self.state = 775
+ self.match(modelicaParser.T__1)
+ self.state = 781
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 786
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 787
+ self.match(modelicaParser.T__17)
+ self.state = 788
+ self.match(modelicaParser.T__60)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Connect_clauseContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def component_reference(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Component_referenceContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Component_referenceContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_connect_clause
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterConnect_clause" ):
+ listener.enterConnect_clause(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitConnect_clause" ):
+ listener.exitConnect_clause(self)
+
+
+
+
+ def connect_clause(self):
+
+ localctx = modelicaParser.Connect_clauseContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 100, self.RULE_connect_clause)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 790
+ self.match(modelicaParser.T__62)
+ self.state = 791
+ self.match(modelicaParser.T__21)
+ self.state = 792
+ self.component_reference()
+ self.state = 793
+ self.match(modelicaParser.T__25)
+ self.state = 794
+ self.component_reference()
+ self.state = 795
+ self.match(modelicaParser.T__23)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ExpressionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def simple_expression(self):
+ return self.getTypedRuleContext(modelicaParser.Simple_expressionContext,0)
+
+
+ def expression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.ExpressionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_expression
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterExpression" ):
+ listener.enterExpression(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitExpression" ):
+ listener.exitExpression(self)
+
+
+
+
+ def expression(self):
+
+ localctx = modelicaParser.ExpressionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 102, self.RULE_expression)
+ self._la = 0 # Token type
+ try:
+ self.state = 815
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [18, 22, 25, 49, 66, 73, 74, 75, 76, 82, 83, 84, 86, 87, 89, 90, 91]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 797
+ self.simple_expression()
+ pass
+ elif token in [46]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 798
+ self.match(modelicaParser.T__45)
+ self.state = 799
+ self.expression()
+ self.state = 800
+ self.match(modelicaParser.T__53)
+ self.state = 801
+ self.expression()
+ self.state = 809
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==55:
+ self.state = 802
+ self.match(modelicaParser.T__54)
+ self.state = 803
+ self.expression()
+ self.state = 804
+ self.match(modelicaParser.T__53)
+ self.state = 805
+ self.expression()
+ self.state = 811
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 812
+ self.match(modelicaParser.T__55)
+ self.state = 813
+ self.expression()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Simple_expressionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def logical_expression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Logical_expressionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Logical_expressionContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_simple_expression
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterSimple_expression" ):
+ listener.enterSimple_expression(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitSimple_expression" ):
+ listener.exitSimple_expression(self)
+
+
+
+
+ def simple_expression(self):
+
+ localctx = modelicaParser.Simple_expressionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 104, self.RULE_simple_expression)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 817
+ self.logical_expression()
+ self.state = 824
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==23:
+ self.state = 818
+ self.match(modelicaParser.T__22)
+ self.state = 819
+ self.logical_expression()
+ self.state = 822
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==23:
+ self.state = 820
+ self.match(modelicaParser.T__22)
+ self.state = 821
+ self.logical_expression()
+
+
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Logical_expressionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def logical_term(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Logical_termContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Logical_termContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_logical_expression
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterLogical_expression" ):
+ listener.enterLogical_expression(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitLogical_expression" ):
+ listener.exitLogical_expression(self)
+
+
+
+
+ def logical_expression(self):
+
+ localctx = modelicaParser.Logical_expressionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 106, self.RULE_logical_expression)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 826
+ self.logical_term()
+ self.state = 831
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==64:
+ self.state = 827
+ self.match(modelicaParser.T__63)
+ self.state = 828
+ self.logical_term()
+ self.state = 833
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Logical_termContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def logical_factor(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Logical_factorContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Logical_factorContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_logical_term
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterLogical_term" ):
+ listener.enterLogical_term(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitLogical_term" ):
+ listener.exitLogical_term(self)
+
+
+
+
+ def logical_term(self):
+
+ localctx = modelicaParser.Logical_termContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 108, self.RULE_logical_term)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 834
+ self.logical_factor()
+ self.state = 839
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==65:
+ self.state = 835
+ self.match(modelicaParser.T__64)
+ self.state = 836
+ self.logical_factor()
+ self.state = 841
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Logical_factorContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def relation(self):
+ return self.getTypedRuleContext(modelicaParser.RelationContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_logical_factor
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterLogical_factor" ):
+ listener.enterLogical_factor(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitLogical_factor" ):
+ listener.exitLogical_factor(self)
+
+
+
+
+ def logical_factor(self):
+
+ localctx = modelicaParser.Logical_factorContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 110, self.RULE_logical_factor)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 843
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==66:
+ self.state = 842
+ self.match(modelicaParser.T__65)
+
+
+ self.state = 845
+ self.relation()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class RelationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def arithmetic_expression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Arithmetic_expressionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Arithmetic_expressionContext,i)
+
+
+ def rel_op(self):
+ return self.getTypedRuleContext(modelicaParser.Rel_opContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_relation
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterRelation" ):
+ listener.enterRelation(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitRelation" ):
+ listener.exitRelation(self)
+
+
+
+
+ def relation(self):
+
+ localctx = modelicaParser.RelationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 112, self.RULE_relation)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 847
+ self.arithmetic_expression()
+ self.state = 851
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & 63) != 0):
+ self.state = 848
+ self.rel_op()
+ self.state = 849
+ self.arithmetic_expression()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Rel_opContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_rel_op
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterRel_op" ):
+ listener.enterRel_op(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitRel_op" ):
+ listener.exitRel_op(self)
+
+
+
+
+ def rel_op(self):
+
+ localctx = modelicaParser.Rel_opContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 114, self.RULE_rel_op)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 853
+ _la = self._input.LA(1)
+ if not(((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & 63) != 0)):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Arithmetic_expressionContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def term(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.TermContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.TermContext,i)
+
+
+ def add_op(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Add_opContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Add_opContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_arithmetic_expression
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterArithmetic_expression" ):
+ listener.enterArithmetic_expression(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitArithmetic_expression" ):
+ listener.exitArithmetic_expression(self)
+
+
+
+
+ def arithmetic_expression(self):
+
+ localctx = modelicaParser.Arithmetic_expressionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 116, self.RULE_arithmetic_expression)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 856
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if ((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & 15) != 0):
+ self.state = 855
+ self.add_op()
+
+
+ self.state = 858
+ self.term()
+ self.state = 864
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & 15) != 0):
+ self.state = 859
+ self.add_op()
+ self.state = 860
+ self.term()
+ self.state = 866
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Add_opContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_add_op
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterAdd_op" ):
+ listener.enterAdd_op(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitAdd_op" ):
+ listener.exitAdd_op(self)
+
+
+
+
+ def add_op(self):
+
+ localctx = modelicaParser.Add_opContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 118, self.RULE_add_op)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 867
+ _la = self._input.LA(1)
+ if not(((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & 15) != 0)):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class TermContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def factor(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.FactorContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.FactorContext,i)
+
+
+ def mul_op(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Mul_opContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Mul_opContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_term
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterTerm" ):
+ listener.enterTerm(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitTerm" ):
+ listener.exitTerm(self)
+
+
+
+
+ def term(self):
+
+ localctx = modelicaParser.TermContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 120, self.RULE_term)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 869
+ self.factor()
+ self.state = 875
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 35)) & ~0x3f) == 0 and ((1 << (_la - 35)) & 30786325577729) != 0):
+ self.state = 870
+ self.mul_op()
+ self.state = 871
+ self.factor()
+ self.state = 877
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Mul_opContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_mul_op
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterMul_op" ):
+ listener.enterMul_op(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitMul_op" ):
+ listener.exitMul_op(self)
+
+
+
+
+ def mul_op(self):
+
+ localctx = modelicaParser.Mul_opContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 122, self.RULE_mul_op)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 878
+ _la = self._input.LA(1)
+ if not(((((_la - 35)) & ~0x3f) == 0 and ((1 << (_la - 35)) & 30786325577729) != 0)):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class FactorContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def primary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.PrimaryContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.PrimaryContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_factor
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterFactor" ):
+ listener.enterFactor(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitFactor" ):
+ listener.exitFactor(self)
+
+
+
+
+ def factor(self):
+
+ localctx = modelicaParser.FactorContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 124, self.RULE_factor)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 880
+ self.primary()
+ self.state = 883
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==80 or _la==81:
+ self.state = 881
+ _la = self._input.LA(1)
+ if not(_la==80 or _la==81):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ self.state = 882
+ self.primary()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PrimaryContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def UNSIGNED_NUMBER(self):
+ return self.getToken(modelicaParser.UNSIGNED_NUMBER, 0)
+
+ def STRING(self):
+ return self.getToken(modelicaParser.STRING, 0)
+
+ def function_call_args(self):
+ return self.getTypedRuleContext(modelicaParser.Function_call_argsContext,0)
+
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def component_reference(self):
+ return self.getTypedRuleContext(modelicaParser.Component_referenceContext,0)
+
+
+ def output_expression_list(self):
+ return self.getTypedRuleContext(modelicaParser.Output_expression_listContext,0)
+
+
+ def expression_list(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Expression_listContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Expression_listContext,i)
+
+
+ def function_arguments(self):
+ return self.getTypedRuleContext(modelicaParser.Function_argumentsContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_primary
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterPrimary" ):
+ listener.enterPrimary(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitPrimary" ):
+ listener.exitPrimary(self)
+
+
+
+
+ def primary(self):
+
+ localctx = modelicaParser.PrimaryContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 126, self.RULE_primary)
+ self._la = 0 # Token type
+ try:
+ self.state = 916
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
+ if la_ == 1:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 885
+ self.match(modelicaParser.UNSIGNED_NUMBER)
+ pass
+
+ elif la_ == 2:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 886
+ self.match(modelicaParser.STRING)
+ pass
+
+ elif la_ == 3:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 887
+ self.match(modelicaParser.T__81)
+ pass
+
+ elif la_ == 4:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 888
+ self.match(modelicaParser.T__82)
+ pass
+
+ elif la_ == 5:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 892
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [87, 89]:
+ self.state = 889
+ self.name()
+ pass
+ elif token in [25]:
+ self.state = 890
+ self.match(modelicaParser.T__24)
+ pass
+ elif token in [49]:
+ self.state = 891
+ self.match(modelicaParser.T__48)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 894
+ self.function_call_args()
+ pass
+
+ elif la_ == 6:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 895
+ self.component_reference()
+ pass
+
+ elif la_ == 7:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 896
+ self.match(modelicaParser.T__21)
+ self.state = 897
+ self.output_expression_list()
+ self.state = 898
+ self.match(modelicaParser.T__23)
+ pass
+
+ elif la_ == 8:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 900
+ self.match(modelicaParser.T__83)
+ self.state = 901
+ self.expression_list()
+ self.state = 906
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==2:
+ self.state = 902
+ self.match(modelicaParser.T__1)
+ self.state = 903
+ self.expression_list()
+ self.state = 908
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 909
+ self.match(modelicaParser.T__84)
+ pass
+
+ elif la_ == 9:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 911
+ self.match(modelicaParser.T__85)
+ self.state = 912
+ self.function_arguments()
+ self.state = 913
+ self.match(modelicaParser.T__36)
+ pass
+
+ elif la_ == 10:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 915
+ self.match(modelicaParser.T__17)
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class NameContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self, i:int=None):
+ if i is None:
+ return self.getTokens(modelicaParser.IDENT)
+ else:
+ return self.getToken(modelicaParser.IDENT, i)
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_name
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterName" ):
+ listener.enterName(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitName" ):
+ listener.exitName(self)
+
+
+
+
+ def name(self):
+
+ localctx = modelicaParser.NameContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 128, self.RULE_name)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 919
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==87:
+ self.state = 918
+ self.match(modelicaParser.T__86)
+
+
+ self.state = 921
+ self.match(modelicaParser.IDENT)
+ self.state = 926
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==87:
+ self.state = 922
+ self.match(modelicaParser.T__86)
+ self.state = 923
+ self.match(modelicaParser.IDENT)
+ self.state = 928
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Component_referenceContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self, i:int=None):
+ if i is None:
+ return self.getTokens(modelicaParser.IDENT)
+ else:
+ return self.getToken(modelicaParser.IDENT, i)
+
+ def array_subscripts(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Array_subscriptsContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Array_subscriptsContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_component_reference
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterComponent_reference" ):
+ listener.enterComponent_reference(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitComponent_reference" ):
+ listener.exitComponent_reference(self)
+
+
+
+
+ def component_reference(self):
+
+ localctx = modelicaParser.Component_referenceContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 130, self.RULE_component_reference)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 930
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==87:
+ self.state = 929
+ self.match(modelicaParser.T__86)
+
+
+ self.state = 932
+ self.match(modelicaParser.IDENT)
+ self.state = 934
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==84:
+ self.state = 933
+ self.array_subscripts()
+
+
+ self.state = 943
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==87:
+ self.state = 936
+ self.match(modelicaParser.T__86)
+ self.state = 937
+ self.match(modelicaParser.IDENT)
+ self.state = 939
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==84:
+ self.state = 938
+ self.array_subscripts()
+
+
+ self.state = 945
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Function_call_argsContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def function_arguments(self):
+ return self.getTypedRuleContext(modelicaParser.Function_argumentsContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_function_call_args
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterFunction_call_args" ):
+ listener.enterFunction_call_args(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitFunction_call_args" ):
+ listener.exitFunction_call_args(self)
+
+
+
+
+ def function_call_args(self):
+
+ localctx = modelicaParser.Function_call_argsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 132, self.RULE_function_call_args)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 946
+ self.match(modelicaParser.T__21)
+ self.state = 948
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if (((_la) & ~0x3f) == 0 and ((1 << _la) & 633318735740928) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 62326657) != 0):
+ self.state = 947
+ self.function_arguments()
+
+
+ self.state = 950
+ self.match(modelicaParser.T__23)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Function_argumentsContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def function_argument(self):
+ return self.getTypedRuleContext(modelicaParser.Function_argumentContext,0)
+
+
+ def function_arguments(self):
+ return self.getTypedRuleContext(modelicaParser.Function_argumentsContext,0)
+
+
+ def for_indices(self):
+ return self.getTypedRuleContext(modelicaParser.For_indicesContext,0)
+
+
+ def named_arguments(self):
+ return self.getTypedRuleContext(modelicaParser.Named_argumentsContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_function_arguments
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterFunction_arguments" ):
+ listener.enterFunction_arguments(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitFunction_arguments" ):
+ listener.exitFunction_arguments(self)
+
+
+
+
+ def function_arguments(self):
+
+ localctx = modelicaParser.Function_argumentsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 134, self.RULE_function_arguments)
+ try:
+ self.state = 960
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
+ if la_ == 1:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 952
+ self.function_argument()
+ self.state = 957
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [26]:
+ self.state = 953
+ self.match(modelicaParser.T__25)
+ self.state = 954
+ self.function_arguments()
+ pass
+ elif token in [57]:
+ self.state = 955
+ self.match(modelicaParser.T__56)
+ self.state = 956
+ self.for_indices()
+ pass
+ elif token in [24, 37]:
+ pass
+ else:
+ pass
+ pass
+
+ elif la_ == 2:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 959
+ self.named_arguments()
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Named_argumentsContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def named_argument(self):
+ return self.getTypedRuleContext(modelicaParser.Named_argumentContext,0)
+
+
+ def named_arguments(self):
+ return self.getTypedRuleContext(modelicaParser.Named_argumentsContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_named_arguments
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterNamed_arguments" ):
+ listener.enterNamed_arguments(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitNamed_arguments" ):
+ listener.exitNamed_arguments(self)
+
+
+
+
+ def named_arguments(self):
+
+ localctx = modelicaParser.Named_argumentsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 136, self.RULE_named_arguments)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 962
+ self.named_argument()
+ self.state = 965
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==26:
+ self.state = 963
+ self.match(modelicaParser.T__25)
+ self.state = 964
+ self.named_arguments()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Named_argumentContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def IDENT(self):
+ return self.getToken(modelicaParser.IDENT, 0)
+
+ def function_argument(self):
+ return self.getTypedRuleContext(modelicaParser.Function_argumentContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_named_argument
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterNamed_argument" ):
+ listener.enterNamed_argument(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitNamed_argument" ):
+ listener.exitNamed_argument(self)
+
+
+
+
+ def named_argument(self):
+
+ localctx = modelicaParser.Named_argumentContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 138, self.RULE_named_argument)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 967
+ self.match(modelicaParser.IDENT)
+ self.state = 968
+ self.match(modelicaParser.T__19)
+ self.state = 969
+ self.function_argument()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Function_argumentContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def name(self):
+ return self.getTypedRuleContext(modelicaParser.NameContext,0)
+
+
+ def named_arguments(self):
+ return self.getTypedRuleContext(modelicaParser.Named_argumentsContext,0)
+
+
+ def expression(self):
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_function_argument
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterFunction_argument" ):
+ listener.enterFunction_argument(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitFunction_argument" ):
+ listener.exitFunction_argument(self)
+
+
+
+
+ def function_argument(self):
+
+ localctx = modelicaParser.Function_argumentContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 140, self.RULE_function_argument)
+ self._la = 0 # Token type
+ try:
+ self.state = 980
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [17]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 971
+ self.match(modelicaParser.T__16)
+ self.state = 972
+ self.name()
+ self.state = 973
+ self.match(modelicaParser.T__21)
+ self.state = 975
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==89:
+ self.state = 974
+ self.named_arguments()
+
+
+ self.state = 977
+ self.match(modelicaParser.T__23)
+ pass
+ elif token in [18, 22, 25, 46, 49, 66, 73, 74, 75, 76, 82, 83, 84, 86, 87, 89, 90, 91]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 979
+ self.expression()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Output_expression_listContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def expression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.ExpressionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_output_expression_list
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterOutput_expression_list" ):
+ listener.enterOutput_expression_list(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitOutput_expression_list" ):
+ listener.exitOutput_expression_list(self)
+
+
+
+
+ def output_expression_list(self):
+
+ localctx = modelicaParser.Output_expression_listContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 142, self.RULE_output_expression_list)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 983
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if (((_la) & ~0x3f) == 0 and ((1 << _la) & 633318735609856) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 62326657) != 0):
+ self.state = 982
+ self.expression()
+
+
+ self.state = 991
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==26:
+ self.state = 985
+ self.match(modelicaParser.T__25)
+ self.state = 987
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if (((_la) & ~0x3f) == 0 and ((1 << _la) & 633318735609856) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 62326657) != 0):
+ self.state = 986
+ self.expression()
+
+
+ self.state = 993
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Expression_listContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def expression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.ExpressionContext)
+ else:
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_expression_list
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterExpression_list" ):
+ listener.enterExpression_list(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitExpression_list" ):
+ listener.exitExpression_list(self)
+
+
+
+
+ def expression_list(self):
+
+ localctx = modelicaParser.Expression_listContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 144, self.RULE_expression_list)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 994
+ self.expression()
+ self.state = 999
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==26:
+ self.state = 995
+ self.match(modelicaParser.T__25)
+ self.state = 996
+ self.expression()
+ self.state = 1001
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Array_subscriptsContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def subscript_(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(modelicaParser.Subscript_Context)
+ else:
+ return self.getTypedRuleContext(modelicaParser.Subscript_Context,i)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_array_subscripts
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterArray_subscripts" ):
+ listener.enterArray_subscripts(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitArray_subscripts" ):
+ listener.exitArray_subscripts(self)
+
+
+
+
+ def array_subscripts(self):
+
+ localctx = modelicaParser.Array_subscriptsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 146, self.RULE_array_subscripts)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1002
+ self.match(modelicaParser.T__83)
+ self.state = 1003
+ self.subscript_()
+ self.state = 1008
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==26:
+ self.state = 1004
+ self.match(modelicaParser.T__25)
+ self.state = 1005
+ self.subscript_()
+ self.state = 1010
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1011
+ self.match(modelicaParser.T__84)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Subscript_Context(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def expression(self):
+ return self.getTypedRuleContext(modelicaParser.ExpressionContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_subscript_
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterSubscript_" ):
+ listener.enterSubscript_(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitSubscript_" ):
+ listener.exitSubscript_(self)
+
+
+
+
+ def subscript_(self):
+
+ localctx = modelicaParser.Subscript_Context(self, self._ctx, self.state)
+ self.enterRule(localctx, 148, self.RULE_subscript_)
+ try:
+ self.state = 1015
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [23]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1013
+ self.match(modelicaParser.T__22)
+ pass
+ elif token in [18, 22, 25, 46, 49, 66, 73, 74, 75, 76, 82, 83, 84, 86, 87, 89, 90, 91]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1014
+ self.expression()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CommentContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def string_comment(self):
+ return self.getTypedRuleContext(modelicaParser.String_commentContext,0)
+
+
+ def annotation(self):
+ return self.getTypedRuleContext(modelicaParser.AnnotationContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_comment
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterComment" ):
+ listener.enterComment(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitComment" ):
+ listener.exitComment(self)
+
+
+
+
+ def comment(self):
+
+ localctx = modelicaParser.CommentContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 150, self.RULE_comment)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1017
+ self.string_comment()
+ self.state = 1019
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==88:
+ self.state = 1018
+ self.annotation()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class String_commentContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def STRING(self, i:int=None):
+ if i is None:
+ return self.getTokens(modelicaParser.STRING)
+ else:
+ return self.getToken(modelicaParser.STRING, i)
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_string_comment
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterString_comment" ):
+ listener.enterString_comment(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitString_comment" ):
+ listener.exitString_comment(self)
+
+
+
+
+ def string_comment(self):
+
+ localctx = modelicaParser.String_commentContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 152, self.RULE_string_comment)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1029
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==90:
+ self.state = 1021
+ self.match(modelicaParser.STRING)
+ self.state = 1026
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==73:
+ self.state = 1022
+ self.match(modelicaParser.T__72)
+ self.state = 1023
+ self.match(modelicaParser.STRING)
+ self.state = 1028
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class AnnotationContext(ParserRuleContext):
+ __slots__ = 'parser'
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def class_modification(self):
+ return self.getTypedRuleContext(modelicaParser.Class_modificationContext,0)
+
+
+ def getRuleIndex(self):
+ return modelicaParser.RULE_annotation
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterAnnotation" ):
+ listener.enterAnnotation(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "exitAnnotation" ):
+ listener.exitAnnotation(self)
+
+
+
+
+ def annotation(self):
+
+ localctx = modelicaParser.AnnotationContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 154, self.RULE_annotation)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1031
+ self.match(modelicaParser.T__87)
+ self.state = 1032
+ self.class_modification()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+
+
+
diff --git a/src/parse_modelica.py b/src/feature_model/parse_modelica.py
similarity index 100%
rename from src/parse_modelica.py
rename to src/feature_model/parse_modelica.py
--
GitLab