Add support for const operations (#44)

* Add support for const operations

* Patch up order of operations

9 files changed, 452 insertions, 526 deletions

diff --git a/qface/idl/listener.py b/qface/idl/listener.py
index 819b811..f708086 100644
--- a/qface/idl/listener.py
+++ b/qface/idl/listener.py
@@ -150,6 +150,9 @@ class DomainListener(TListener):
         assert self.interface
         name = ctx.name.text
         self.operation = Operation(name, self.interface)
+        modifier = ctx.operationModifierSymbol()
+        if modifier:
+            self.operation.const = bool(modifier.is_const)
         self.parse_annotations(ctx, self.operation)
         self.parse_type(ctx, self.operation.type)
         contextMap[ctx] = self.operation
diff --git a/qface/idl/parser/T.g4 b/qface/idl/parser/T.g4
index 97badde..210f5c6 100644
--- a/qface/idl/parser/T.g4
+++ b/qface/idl/parser/T.g4
@@ -39,7 +39,11 @@ interfaceMemberSymbol
     ;
 
 operationSymbol
-    : comment=DOCCOMMENT?  tagSymbol* (typeSymbol | 'void') name=IDENTIFIER '(' operationParameterSymbol* ')' ';'?
+    : comment=DOCCOMMENT?  tagSymbol* (typeSymbol | 'void') name=IDENTIFIER '(' operationParameterSymbol* ')' operationModifierSymbol? ';'?
+    ;
+
+operationModifierSymbol
+    : is_const='const'
     ;
 
 signalSymbol
diff --git a/qface/idl/parser/T.tokens b/qface/idl/parser/T.tokens
index d9b477d..51d7f1b 100644
--- a/qface/idl/parser/T.tokens
+++ b/qface/idl/parser/T.tokens
@@ -43,9 +43,9 @@ MULTICOMM=36
 'void'=7
 '('=8
 ')'=9
-'signal'=10
-'readonly'=11
-'const'=12
+'const'=10
+'signal'=11
+'readonly'=12
 ','=13
 '='=14
 'bool'=15
diff --git a/qface/idl/parser/TLexer.py b/qface/idl/parser/TLexer.py
index 760c329..168b0f9 100644
--- a/qface/idl/parser/TLexer.py
+++ b/qface/idl/parser/TLexer.py
@@ -15,8 +15,8 @@ def serializedATN():
         buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\3\4\3")
         buf.write("\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6")
         buf.write("\3\6\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\n\3\n\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f")
-        buf.write("\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\17\3")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f")
+        buf.write("\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\17\3")
         buf.write("\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\22")
         buf.write("\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23")
         buf.write("\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26")
@@ -46,8 +46,8 @@ def serializedATN():
         buf.write("A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2")
         buf.write("\3K\3\2\2\2\5R\3\2\2\2\7T\3\2\2\2\t[\3\2\2\2\13e\3\2\2")
         buf.write("\2\rg\3\2\2\2\17i\3\2\2\2\21n\3\2\2\2\23p\3\2\2\2\25r")
-        buf.write("\3\2\2\2\27y\3\2\2\2\31\u0082\3\2\2\2\33\u0088\3\2\2\2")
-        buf.write("\35\u008a\3\2\2\2\37\u008c\3\2\2\2!\u0091\3\2\2\2#\u0095")
+        buf.write("\3\2\2\2\27x\3\2\2\2\31\177\3\2\2\2\33\u0088\3\2\2\2\35")
+        buf.write("\u008a\3\2\2\2\37\u008c\3\2\2\2!\u0091\3\2\2\2#\u0095")
         buf.write("\3\2\2\2%\u009a\3\2\2\2\'\u00a1\3\2\2\2)\u00a5\3\2\2\2")
         buf.write("+\u00aa\3\2\2\2-\u00ac\3\2\2\2/\u00ae\3\2\2\2\61\u00b4")
         buf.write("\3\2\2\2\63\u00bb\3\2\2\2\65\u00c0\3\2\2\2\67\u00c5\3")
@@ -60,12 +60,12 @@ def serializedATN():
         buf.write("g\2\2_`\7t\2\2`a\7h\2\2ab\7c\2\2bc\7e\2\2cd\7g\2\2d\n")
         buf.write("\3\2\2\2ef\7}\2\2f\f\3\2\2\2gh\7\177\2\2h\16\3\2\2\2i")
         buf.write("j\7x\2\2jk\7q\2\2kl\7k\2\2lm\7f\2\2m\20\3\2\2\2no\7*\2")
-        buf.write("\2o\22\3\2\2\2pq\7+\2\2q\24\3\2\2\2rs\7u\2\2st\7k\2\2")
-        buf.write("tu\7i\2\2uv\7p\2\2vw\7c\2\2wx\7n\2\2x\26\3\2\2\2yz\7t")
-        buf.write("\2\2z{\7g\2\2{|\7c\2\2|}\7f\2\2}~\7q\2\2~\177\7p\2\2\177")
-        buf.write("\u0080\7n\2\2\u0080\u0081\7{\2\2\u0081\30\3\2\2\2\u0082")
-        buf.write("\u0083\7e\2\2\u0083\u0084\7q\2\2\u0084\u0085\7p\2\2\u0085")
-        buf.write("\u0086\7u\2\2\u0086\u0087\7v\2\2\u0087\32\3\2\2\2\u0088")
+        buf.write("\2o\22\3\2\2\2pq\7+\2\2q\24\3\2\2\2rs\7e\2\2st\7q\2\2")
+        buf.write("tu\7p\2\2uv\7u\2\2vw\7v\2\2w\26\3\2\2\2xy\7u\2\2yz\7k")
+        buf.write("\2\2z{\7i\2\2{|\7p\2\2|}\7c\2\2}~\7n\2\2~\30\3\2\2\2\177")
+        buf.write("\u0080\7t\2\2\u0080\u0081\7g\2\2\u0081\u0082\7c\2\2\u0082")
+        buf.write("\u0083\7f\2\2\u0083\u0084\7q\2\2\u0084\u0085\7p\2\2\u0085")
+        buf.write("\u0086\7n\2\2\u0086\u0087\7{\2\2\u0087\32\3\2\2\2\u0088")
         buf.write("\u0089\7.\2\2\u0089\34\3\2\2\2\u008a\u008b\7?\2\2\u008b")
         buf.write("\36\3\2\2\2\u008c\u008d\7d\2\2\u008d\u008e\7q\2\2\u008e")
         buf.write("\u008f\7q\2\2\u008f\u0090\7n\2\2\u0090 \3\2\2\2\u0091")
@@ -174,7 +174,7 @@ class TLexer(Lexer):
 
     literalNames = [ "<INVALID>",
             "'import'", "';'", "'module'", "'interface'", "'{'", "'}'", 
-            "'void'", "'('", "')'", "'signal'", "'readonly'", "'const'", 
+            "'void'", "'('", "')'", "'const'", "'signal'", "'readonly'", 
             "','", "'='", "'bool'", "'int'", "'real'", "'string'", "'var'", 
             "'list'", "'<'", "'>'", "'model'", "'struct'", "'enum'", "'flag'" ]
 
diff --git a/qface/idl/parser/TLexer.tokens b/qface/idl/parser/TLexer.tokens
index d9b477d..51d7f1b 100644
--- a/qface/idl/parser/TLexer.tokens
+++ b/qface/idl/parser/TLexer.tokens
@@ -43,9 +43,9 @@ MULTICOMM=36
 'void'=7
 '('=8
 ')'=9
-'signal'=10
-'readonly'=11
-'const'=12
+'const'=10
+'signal'=11
+'readonly'=12
 ','=13
 '='=14
 'bool'=15
diff --git a/qface/idl/parser/TListener.py b/qface/idl/parser/TListener.py
index 2899519..e908b46 100644
--- a/qface/idl/parser/TListener.py
+++ b/qface/idl/parser/TListener.py
@@ -80,6 +80,15 @@ class TListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by TParser#operationModifierSymbol.
+    def enterOperationModifierSymbol(self, ctx:TParser.OperationModifierSymbolContext):
+        pass
+
+    # Exit a parse tree produced by TParser#operationModifierSymbol.
+    def exitOperationModifierSymbol(self, ctx:TParser.OperationModifierSymbolContext):
+        pass
+
+
     # Enter a parse tree produced by TParser#signalSymbol.
     def enterSignalSymbol(self, ctx:TParser.SignalSymbolContext):
         pass
diff --git a/qface/idl/parser/TParser.py b/qface/idl/parser/TParser.py
index 770c655..52fb077 100644
--- a/qface/idl/parser/TParser.py
+++ b/qface/idl/parser/TParser.py
@@ -6,149 +6,153 @@ from io import StringIO
 def serializedATN():
     with StringIO() as buf:
         buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3&")
-        buf.write("\u0137\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\u013e\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
-        buf.write("\t\31\4\32\t\32\3\2\3\2\7\2\67\n\2\f\2\16\2:\13\2\3\3")
-        buf.write("\3\3\7\3>\n\3\f\3\16\3A\13\3\3\4\3\4\3\4\3\4\5\4G\n\4")
-        buf.write("\3\5\5\5J\n\5\3\5\7\5M\n\5\f\5\16\5P\13\5\3\5\3\5\3\5")
-        buf.write("\3\5\5\5V\n\5\3\6\3\6\3\6\5\6[\n\6\3\7\5\7^\n\7\3\7\7")
-        buf.write("\7a\n\7\f\7\16\7d\13\7\3\7\3\7\3\7\3\7\7\7j\n\7\f\7\16")
-        buf.write("\7m\13\7\3\7\3\7\5\7q\n\7\3\b\3\b\3\b\5\bv\n\b\3\t\5\t")
-        buf.write("y\n\t\3\t\7\t|\n\t\f\t\16\t\177\13\t\3\t\3\t\5\t\u0083")
-        buf.write("\n\t\3\t\3\t\3\t\7\t\u0088\n\t\f\t\16\t\u008b\13\t\3\t")
-        buf.write("\3\t\5\t\u008f\n\t\3\n\5\n\u0092\n\n\3\n\7\n\u0095\n\n")
-        buf.write("\f\n\16\n\u0098\13\n\3\n\3\n\3\n\3\n\7\n\u009e\n\n\f\n")
-        buf.write("\16\n\u00a1\13\n\3\n\3\n\5\n\u00a5\n\n\3\13\5\13\u00a8")
-        buf.write("\n\13\3\13\7\13\u00ab\n\13\f\13\16\13\u00ae\13\13\3\13")
-        buf.write("\5\13\u00b1\n\13\3\13\3\13\3\13\5\13\u00b6\n\13\3\f\3")
-        buf.write("\f\5\f\u00ba\n\f\3\r\3\r\3\r\5\r\u00bf\n\r\3\16\3\16\3")
-        buf.write("\17\3\17\3\17\5\17\u00c6\n\17\3\17\5\17\u00c9\n\17\3\20")
-        buf.write("\3\20\3\20\3\20\5\20\u00cf\n\20\3\21\3\21\3\22\3\22\3")
-        buf.write("\22\3\22\3\22\5\22\u00d8\n\22\3\23\3\23\3\23\3\23\3\23")
-        buf.write("\3\24\3\24\3\24\3\24\3\24\3\25\5\25\u00e5\n\25\3\25\7")
-        buf.write("\25\u00e8\n\25\f\25\16\25\u00eb\13\25\3\25\3\25\3\25\3")
-        buf.write("\25\7\25\u00f1\n\25\f\25\16\25\u00f4\13\25\3\25\3\25\5")
-        buf.write("\25\u00f8\n\25\3\26\5\26\u00fb\n\26\3\26\7\26\u00fe\n")
-        buf.write("\26\f\26\16\26\u0101\13\26\3\26\3\26\3\26\5\26\u0106\n")
-        buf.write("\26\3\27\5\27\u0109\n\27\3\27\7\27\u010c\n\27\f\27\16")
-        buf.write("\27\u010f\13\27\3\27\3\27\3\27\3\27\7\27\u0115\n\27\f")
-        buf.write("\27\16\27\u0118\13\27\3\27\3\27\5\27\u011c\n\27\3\30\3")
-        buf.write("\30\5\30\u0120\n\30\3\31\5\31\u0123\n\31\3\31\7\31\u0126")
-        buf.write("\n\31\f\31\16\31\u0129\13\31\3\31\3\31\3\31\5\31\u012e")
-        buf.write("\n\31\3\31\5\31\u0131\n\31\3\32\3\32\5\32\u0135\n\32\3")
-        buf.write("\32\2\2\33\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$")
-        buf.write("&(*,.\60\62\2\2\u0154\2\64\3\2\2\2\4;\3\2\2\2\6B\3\2\2")
-        buf.write("\2\bI\3\2\2\2\nZ\3\2\2\2\f]\3\2\2\2\16u\3\2\2\2\20x\3")
-        buf.write("\2\2\2\22\u0091\3\2\2\2\24\u00a7\3\2\2\2\26\u00b9\3\2")
-        buf.write("\2\2\30\u00bb\3\2\2\2\32\u00c0\3\2\2\2\34\u00c2\3\2\2")
-        buf.write("\2\36\u00ce\3\2\2\2 \u00d0\3\2\2\2\"\u00d7\3\2\2\2$\u00d9")
-        buf.write("\3\2\2\2&\u00de\3\2\2\2(\u00e4\3\2\2\2*\u00fa\3\2\2\2")
-        buf.write(",\u0108\3\2\2\2.\u011f\3\2\2\2\60\u0122\3\2\2\2\62\u0134")
-        buf.write("\3\2\2\2\648\5\4\3\2\65\67\5\n\6\2\66\65\3\2\2\2\67:\3")
-        buf.write("\2\2\28\66\3\2\2\289\3\2\2\29\3\3\2\2\2:8\3\2\2\2;?\5")
-        buf.write("\b\5\2<>\5\6\4\2=<\3\2\2\2>A\3\2\2\2?=\3\2\2\2?@\3\2\2")
-        buf.write("\2@\5\3\2\2\2A?\3\2\2\2BC\7\3\2\2CD\7!\2\2DF\7\"\2\2E")
-        buf.write("G\7\4\2\2FE\3\2\2\2FG\3\2\2\2G\7\3\2\2\2HJ\7#\2\2IH\3")
-        buf.write("\2\2\2IJ\3\2\2\2JN\3\2\2\2KM\5\32\16\2LK\3\2\2\2MP\3\2")
-        buf.write("\2\2NL\3\2\2\2NO\3\2\2\2OQ\3\2\2\2PN\3\2\2\2QR\7\5\2\2")
-        buf.write("RS\7!\2\2SU\7\"\2\2TV\7\4\2\2UT\3\2\2\2UV\3\2\2\2V\t\3")
-        buf.write("\2\2\2W[\5\f\7\2X[\5(\25\2Y[\5,\27\2ZW\3\2\2\2ZX\3\2\2")
-        buf.write("\2ZY\3\2\2\2[\13\3\2\2\2\\^\7#\2\2]\\\3\2\2\2]^\3\2\2")
-        buf.write("\2^b\3\2\2\2_a\5\32\16\2`_\3\2\2\2ad\3\2\2\2b`\3\2\2\2")
-        buf.write("bc\3\2\2\2ce\3\2\2\2db\3\2\2\2ef\7\6\2\2fg\7!\2\2gk\7")
-        buf.write("\7\2\2hj\5\16\b\2ih\3\2\2\2jm\3\2\2\2ki\3\2\2\2kl\3\2")
-        buf.write("\2\2ln\3\2\2\2mk\3\2\2\2np\7\b\2\2oq\7\4\2\2po\3\2\2\2")
-        buf.write("pq\3\2\2\2q\r\3\2\2\2rv\5\20\t\2sv\5\24\13\2tv\5\22\n")
-        buf.write("\2ur\3\2\2\2us\3\2\2\2ut\3\2\2\2v\17\3\2\2\2wy\7#\2\2")
-        buf.write("xw\3\2\2\2xy\3\2\2\2y}\3\2\2\2z|\5\32\16\2{z\3\2\2\2|")
-        buf.write("\177\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\u0082\3\2\2\2\177}\3")
-        buf.write("\2\2\2\u0080\u0083\5\36\20\2\u0081\u0083\7\t\2\2\u0082")
-        buf.write("\u0080\3\2\2\2\u0082\u0081\3\2\2\2\u0083\u0084\3\2\2\2")
-        buf.write("\u0084\u0085\7!\2\2\u0085\u0089\7\n\2\2\u0086\u0088\5")
-        buf.write("\30\r\2\u0087\u0086\3\2\2\2\u0088\u008b\3\2\2\2\u0089")
-        buf.write("\u0087\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008c\3\2\2\2")
-        buf.write("\u008b\u0089\3\2\2\2\u008c\u008e\7\13\2\2\u008d\u008f")
-        buf.write("\7\4\2\2\u008e\u008d\3\2\2\2\u008e\u008f\3\2\2\2\u008f")
-        buf.write("\21\3\2\2\2\u0090\u0092\7#\2\2\u0091\u0090\3\2\2\2\u0091")
-        buf.write("\u0092\3\2\2\2\u0092\u0096\3\2\2\2\u0093\u0095\5\32\16")
-        buf.write("\2\u0094\u0093\3\2\2\2\u0095\u0098\3\2\2\2\u0096\u0094")
-        buf.write("\3\2\2\2\u0096\u0097\3\2\2\2\u0097\u0099\3\2\2\2\u0098")
-        buf.write("\u0096\3\2\2\2\u0099\u009a\7\f\2\2\u009a\u009b\7!\2\2")
-        buf.write("\u009b\u009f\7\n\2\2\u009c\u009e\5\30\r\2\u009d\u009c")
-        buf.write("\3\2\2\2\u009e\u00a1\3\2\2\2\u009f\u009d\3\2\2\2\u009f")
-        buf.write("\u00a0\3\2\2\2\u00a0\u00a2\3\2\2\2\u00a1\u009f\3\2\2\2")
-        buf.write("\u00a2\u00a4\7\13\2\2\u00a3\u00a5\7\4\2\2\u00a4\u00a3")
-        buf.write("\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\23\3\2\2\2\u00a6\u00a8")
-        buf.write("\7#\2\2\u00a7\u00a6\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8")
-        buf.write("\u00ac\3\2\2\2\u00a9\u00ab\5\32\16\2\u00aa\u00a9\3\2\2")
-        buf.write("\2\u00ab\u00ae\3\2\2\2\u00ac\u00aa\3\2\2\2\u00ac\u00ad")
-        buf.write("\3\2\2\2\u00ad\u00b0\3\2\2\2\u00ae\u00ac\3\2\2\2\u00af")
-        buf.write("\u00b1\5\26\f\2\u00b0\u00af\3\2\2\2\u00b0\u00b1\3\2\2")
-        buf.write("\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\5\36\20\2\u00b3\u00b5")
-        buf.write("\7!\2\2\u00b4\u00b6\7\4\2\2\u00b5\u00b4\3\2\2\2\u00b5")
-        buf.write("\u00b6\3\2\2\2\u00b6\25\3\2\2\2\u00b7\u00ba\7\r\2\2\u00b8")
-        buf.write("\u00ba\7\16\2\2\u00b9\u00b7\3\2\2\2\u00b9\u00b8\3\2\2")
-        buf.write("\2\u00ba\27\3\2\2\2\u00bb\u00bc\5\36\20\2\u00bc\u00be")
-        buf.write("\7!\2\2\u00bd\u00bf\7\17\2\2\u00be\u00bd\3\2\2\2\u00be")
-        buf.write("\u00bf\3\2\2\2\u00bf\31\3\2\2\2\u00c0\u00c1\7\35\2\2\u00c1")
-        buf.write("\33\3\2\2\2\u00c2\u00c5\7!\2\2\u00c3\u00c4\7\20\2\2\u00c4")
-        buf.write("\u00c6\7!\2\2\u00c5\u00c3\3\2\2\2\u00c5\u00c6\3\2\2\2")
-        buf.write("\u00c6\u00c8\3\2\2\2\u00c7\u00c9\7\17\2\2\u00c8\u00c7")
-        buf.write("\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\35\3\2\2\2\u00ca\u00cf")
-        buf.write("\5\"\22\2\u00cb\u00cf\5 \21\2\u00cc\u00cf\5$\23\2\u00cd")
-        buf.write("\u00cf\5&\24\2\u00ce\u00ca\3\2\2\2\u00ce\u00cb\3\2\2\2")
-        buf.write("\u00ce\u00cc\3\2\2\2\u00ce\u00cd\3\2\2\2\u00cf\37\3\2")
-        buf.write("\2\2\u00d0\u00d1\7!\2\2\u00d1!\3\2\2\2\u00d2\u00d8\7\21")
-        buf.write("\2\2\u00d3\u00d8\7\22\2\2\u00d4\u00d8\7\23\2\2\u00d5\u00d8")
-        buf.write("\7\24\2\2\u00d6\u00d8\7\25\2\2\u00d7\u00d2\3\2\2\2\u00d7")
-        buf.write("\u00d3\3\2\2\2\u00d7\u00d4\3\2\2\2\u00d7\u00d5\3\2\2\2")
-        buf.write("\u00d7\u00d6\3\2\2\2\u00d8#\3\2\2\2\u00d9\u00da\7\26\2")
-        buf.write("\2\u00da\u00db\7\27\2\2\u00db\u00dc\5\36\20\2\u00dc\u00dd")
-        buf.write("\7\30\2\2\u00dd%\3\2\2\2\u00de\u00df\7\31\2\2\u00df\u00e0")
-        buf.write("\7\27\2\2\u00e0\u00e1\5\36\20\2\u00e1\u00e2\7\30\2\2\u00e2")
-        buf.write("\'\3\2\2\2\u00e3\u00e5\7#\2\2\u00e4\u00e3\3\2\2\2\u00e4")
-        buf.write("\u00e5\3\2\2\2\u00e5\u00e9\3\2\2\2\u00e6\u00e8\5\32\16")
-        buf.write("\2\u00e7\u00e6\3\2\2\2\u00e8\u00eb\3\2\2\2\u00e9\u00e7")
-        buf.write("\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00ec\3\2\2\2\u00eb")
-        buf.write("\u00e9\3\2\2\2\u00ec\u00ed\7\32\2\2\u00ed\u00ee\7!\2\2")
-        buf.write("\u00ee\u00f2\7\7\2\2\u00ef\u00f1\5*\26\2\u00f0\u00ef\3")
-        buf.write("\2\2\2\u00f1\u00f4\3\2\2\2\u00f2\u00f0\3\2\2\2\u00f2\u00f3")
-        buf.write("\3\2\2\2\u00f3\u00f5\3\2\2\2\u00f4\u00f2\3\2\2\2\u00f5")
-        buf.write("\u00f7\7\b\2\2\u00f6\u00f8\7\4\2\2\u00f7\u00f6\3\2\2\2")
-        buf.write("\u00f7\u00f8\3\2\2\2\u00f8)\3\2\2\2\u00f9\u00fb\7#\2\2")
-        buf.write("\u00fa\u00f9\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00ff\3")
-        buf.write("\2\2\2\u00fc\u00fe\5\32\16\2\u00fd\u00fc\3\2\2\2\u00fe")
-        buf.write("\u0101\3\2\2\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2")
-        buf.write("\u0100\u0102\3\2\2\2\u0101\u00ff\3\2\2\2\u0102\u0103\5")
-        buf.write("\36\20\2\u0103\u0105\7!\2\2\u0104\u0106\7\4\2\2\u0105")
-        buf.write("\u0104\3\2\2\2\u0105\u0106\3\2\2\2\u0106+\3\2\2\2\u0107")
-        buf.write("\u0109\7#\2\2\u0108\u0107\3\2\2\2\u0108\u0109\3\2\2\2")
-        buf.write("\u0109\u010d\3\2\2\2\u010a\u010c\5\32\16\2\u010b\u010a")
-        buf.write("\3\2\2\2\u010c\u010f\3\2\2\2\u010d\u010b\3\2\2\2\u010d")
-        buf.write("\u010e\3\2\2\2\u010e\u0110\3\2\2\2\u010f\u010d\3\2\2\2")
-        buf.write("\u0110\u0111\5.\30\2\u0111\u0112\7!\2\2\u0112\u0116\7")
-        buf.write("\7\2\2\u0113\u0115\5\60\31\2\u0114\u0113\3\2\2\2\u0115")
-        buf.write("\u0118\3\2\2\2\u0116\u0114\3\2\2\2\u0116\u0117\3\2\2\2")
-        buf.write("\u0117\u0119\3\2\2\2\u0118\u0116\3\2\2\2\u0119\u011b\7")
-        buf.write("\b\2\2\u011a\u011c\7\4\2\2\u011b\u011a\3\2\2\2\u011b\u011c")
-        buf.write("\3\2\2\2\u011c-\3\2\2\2\u011d\u0120\7\33\2\2\u011e\u0120")
-        buf.write("\7\34\2\2\u011f\u011d\3\2\2\2\u011f\u011e\3\2\2\2\u0120")
-        buf.write("/\3\2\2\2\u0121\u0123\7#\2\2\u0122\u0121\3\2\2\2\u0122")
-        buf.write("\u0123\3\2\2\2\u0123\u0127\3\2\2\2\u0124\u0126\5\32\16")
-        buf.write("\2\u0125\u0124\3\2\2\2\u0126\u0129\3\2\2\2\u0127\u0125")
-        buf.write("\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u012a\3\2\2\2\u0129")
-        buf.write("\u0127\3\2\2\2\u012a\u012d\7!\2\2\u012b\u012c\7\20\2\2")
-        buf.write("\u012c\u012e\5\62\32\2\u012d\u012b\3\2\2\2\u012d\u012e")
-        buf.write("\3\2\2\2\u012e\u0130\3\2\2\2\u012f\u0131\7\17\2\2\u0130")
-        buf.write("\u012f\3\2\2\2\u0130\u0131\3\2\2\2\u0131\61\3\2\2\2\u0132")
-        buf.write("\u0135\7\36\2\2\u0133\u0135\7\37\2\2\u0134\u0132\3\2\2")
-        buf.write("\2\u0134\u0133\3\2\2\2\u0135\63\3\2\2\2\628?FINUZ]bkp")
-        buf.write("ux}\u0082\u0089\u008e\u0091\u0096\u009f\u00a4\u00a7\u00ac")
-        buf.write("\u00b0\u00b5\u00b9\u00be\u00c5\u00c8\u00ce\u00d7\u00e4")
-        buf.write("\u00e9\u00f2\u00f7\u00fa\u00ff\u0105\u0108\u010d\u0116")
-        buf.write("\u011b\u011f\u0122\u0127\u012d\u0130\u0134")
+        buf.write("\t\31\4\32\t\32\4\33\t\33\3\2\3\2\7\29\n\2\f\2\16\2<\13")
+        buf.write("\2\3\3\3\3\7\3@\n\3\f\3\16\3C\13\3\3\4\3\4\3\4\3\4\5\4")
+        buf.write("I\n\4\3\5\5\5L\n\5\3\5\7\5O\n\5\f\5\16\5R\13\5\3\5\3\5")
+        buf.write("\3\5\3\5\5\5X\n\5\3\6\3\6\3\6\5\6]\n\6\3\7\5\7`\n\7\3")
+        buf.write("\7\7\7c\n\7\f\7\16\7f\13\7\3\7\3\7\3\7\3\7\7\7l\n\7\f")
+        buf.write("\7\16\7o\13\7\3\7\3\7\5\7s\n\7\3\b\3\b\3\b\5\bx\n\b\3")
+        buf.write("\t\5\t{\n\t\3\t\7\t~\n\t\f\t\16\t\u0081\13\t\3\t\3\t\5")
+        buf.write("\t\u0085\n\t\3\t\3\t\3\t\7\t\u008a\n\t\f\t\16\t\u008d")
+        buf.write("\13\t\3\t\3\t\5\t\u0091\n\t\3\t\5\t\u0094\n\t\3\n\3\n")
+        buf.write("\3\13\5\13\u0099\n\13\3\13\7\13\u009c\n\13\f\13\16\13")
+        buf.write("\u009f\13\13\3\13\3\13\3\13\3\13\7\13\u00a5\n\13\f\13")
+        buf.write("\16\13\u00a8\13\13\3\13\3\13\5\13\u00ac\n\13\3\f\5\f\u00af")
+        buf.write("\n\f\3\f\7\f\u00b2\n\f\f\f\16\f\u00b5\13\f\3\f\5\f\u00b8")
+        buf.write("\n\f\3\f\3\f\3\f\5\f\u00bd\n\f\3\r\3\r\5\r\u00c1\n\r\3")
+        buf.write("\16\3\16\3\16\5\16\u00c6\n\16\3\17\3\17\3\20\3\20\3\20")
+        buf.write("\5\20\u00cd\n\20\3\20\5\20\u00d0\n\20\3\21\3\21\3\21\3")
+        buf.write("\21\5\21\u00d6\n\21\3\22\3\22\3\23\3\23\3\23\3\23\3\23")
+        buf.write("\5\23\u00df\n\23\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3")
+        buf.write("\25\3\25\3\25\3\26\5\26\u00ec\n\26\3\26\7\26\u00ef\n\26")
+        buf.write("\f\26\16\26\u00f2\13\26\3\26\3\26\3\26\3\26\7\26\u00f8")
+        buf.write("\n\26\f\26\16\26\u00fb\13\26\3\26\3\26\5\26\u00ff\n\26")
+        buf.write("\3\27\5\27\u0102\n\27\3\27\7\27\u0105\n\27\f\27\16\27")
+        buf.write("\u0108\13\27\3\27\3\27\3\27\5\27\u010d\n\27\3\30\5\30")
+        buf.write("\u0110\n\30\3\30\7\30\u0113\n\30\f\30\16\30\u0116\13\30")
+        buf.write("\3\30\3\30\3\30\3\30\7\30\u011c\n\30\f\30\16\30\u011f")
+        buf.write("\13\30\3\30\3\30\5\30\u0123\n\30\3\31\3\31\5\31\u0127")
+        buf.write("\n\31\3\32\5\32\u012a\n\32\3\32\7\32\u012d\n\32\f\32\16")
+        buf.write("\32\u0130\13\32\3\32\3\32\3\32\5\32\u0135\n\32\3\32\5")
+        buf.write("\32\u0138\n\32\3\33\3\33\5\33\u013c\n\33\3\33\2\2\34\2")
+        buf.write("\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64")
+        buf.write("\2\2\u015b\2\66\3\2\2\2\4=\3\2\2\2\6D\3\2\2\2\bK\3\2\2")
+        buf.write("\2\n\\\3\2\2\2\f_\3\2\2\2\16w\3\2\2\2\20z\3\2\2\2\22\u0095")
+        buf.write("\3\2\2\2\24\u0098\3\2\2\2\26\u00ae\3\2\2\2\30\u00c0\3")
+        buf.write("\2\2\2\32\u00c2\3\2\2\2\34\u00c7\3\2\2\2\36\u00c9\3\2")
+        buf.write("\2\2 \u00d5\3\2\2\2\"\u00d7\3\2\2\2$\u00de\3\2\2\2&\u00e0")
+        buf.write("\3\2\2\2(\u00e5\3\2\2\2*\u00eb\3\2\2\2,\u0101\3\2\2\2")
+        buf.write(".\u010f\3\2\2\2\60\u0126\3\2\2\2\62\u0129\3\2\2\2\64\u013b")
+        buf.write("\3\2\2\2\66:\5\4\3\2\679\5\n\6\28\67\3\2\2\29<\3\2\2\2")
+        buf.write(":8\3\2\2\2:;\3\2\2\2;\3\3\2\2\2<:\3\2\2\2=A\5\b\5\2>@")
+        buf.write("\5\6\4\2?>\3\2\2\2@C\3\2\2\2A?\3\2\2\2AB\3\2\2\2B\5\3")
+        buf.write("\2\2\2CA\3\2\2\2DE\7\3\2\2EF\7!\2\2FH\7\"\2\2GI\7\4\2")
+        buf.write("\2HG\3\2\2\2HI\3\2\2\2I\7\3\2\2\2JL\7#\2\2KJ\3\2\2\2K")
+        buf.write("L\3\2\2\2LP\3\2\2\2MO\5\34\17\2NM\3\2\2\2OR\3\2\2\2PN")
+        buf.write("\3\2\2\2PQ\3\2\2\2QS\3\2\2\2RP\3\2\2\2ST\7\5\2\2TU\7!")
+        buf.write("\2\2UW\7\"\2\2VX\7\4\2\2WV\3\2\2\2WX\3\2\2\2X\t\3\2\2")
+        buf.write("\2Y]\5\f\7\2Z]\5*\26\2[]\5.\30\2\\Y\3\2\2\2\\Z\3\2\2\2")
+        buf.write("\\[\3\2\2\2]\13\3\2\2\2^`\7#\2\2_^\3\2\2\2_`\3\2\2\2`")
+        buf.write("d\3\2\2\2ac\5\34\17\2ba\3\2\2\2cf\3\2\2\2db\3\2\2\2de")
+        buf.write("\3\2\2\2eg\3\2\2\2fd\3\2\2\2gh\7\6\2\2hi\7!\2\2im\7\7")
+        buf.write("\2\2jl\5\16\b\2kj\3\2\2\2lo\3\2\2\2mk\3\2\2\2mn\3\2\2")
+        buf.write("\2np\3\2\2\2om\3\2\2\2pr\7\b\2\2qs\7\4\2\2rq\3\2\2\2r")
+        buf.write("s\3\2\2\2s\r\3\2\2\2tx\5\20\t\2ux\5\26\f\2vx\5\24\13\2")
+        buf.write("wt\3\2\2\2wu\3\2\2\2wv\3\2\2\2x\17\3\2\2\2y{\7#\2\2zy")
+        buf.write("\3\2\2\2z{\3\2\2\2{\177\3\2\2\2|~\5\34\17\2}|\3\2\2\2")
+        buf.write("~\u0081\3\2\2\2\177}\3\2\2\2\177\u0080\3\2\2\2\u0080\u0084")
+        buf.write("\3\2\2\2\u0081\177\3\2\2\2\u0082\u0085\5 \21\2\u0083\u0085")
+        buf.write("\7\t\2\2\u0084\u0082\3\2\2\2\u0084\u0083\3\2\2\2\u0085")
+        buf.write("\u0086\3\2\2\2\u0086\u0087\7!\2\2\u0087\u008b\7\n\2\2")
+        buf.write("\u0088\u008a\5\32\16\2\u0089\u0088\3\2\2\2\u008a\u008d")
+        buf.write("\3\2\2\2\u008b\u0089\3\2\2\2\u008b\u008c\3\2\2\2\u008c")
+        buf.write("\u008e\3\2\2\2\u008d\u008b\3\2\2\2\u008e\u0090\7\13\2")
+        buf.write("\2\u008f\u0091\5\22\n\2\u0090\u008f\3\2\2\2\u0090\u0091")
+        buf.write("\3\2\2\2\u0091\u0093\3\2\2\2\u0092\u0094\7\4\2\2\u0093")
+        buf.write("\u0092\3\2\2\2\u0093\u0094\3\2\2\2\u0094\21\3\2\2\2\u0095")
+        buf.write("\u0096\7\f\2\2\u0096\23\3\2\2\2\u0097\u0099\7#\2\2\u0098")
+        buf.write("\u0097\3\2\2\2\u0098\u0099\3\2\2\2\u0099\u009d\3\2\2\2")
+        buf.write("\u009a\u009c\5\34\17\2\u009b\u009a\3\2\2\2\u009c\u009f")
+        buf.write("\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2\u009e")
+        buf.write("\u00a0\3\2\2\2\u009f\u009d\3\2\2\2\u00a0\u00a1\7\r\2\2")
+        buf.write("\u00a1\u00a2\7!\2\2\u00a2\u00a6\7\n\2\2\u00a3\u00a5\5")
+        buf.write("\32\16\2\u00a4\u00a3\3\2\2\2\u00a5\u00a8\3\2\2\2\u00a6")
+        buf.write("\u00a4\3\2\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00a9\3\2\2\2")
+        buf.write("\u00a8\u00a6\3\2\2\2\u00a9\u00ab\7\13\2\2\u00aa\u00ac")
+        buf.write("\7\4\2\2\u00ab\u00aa\3\2\2\2\u00ab\u00ac\3\2\2\2\u00ac")
+        buf.write("\25\3\2\2\2\u00ad\u00af\7#\2\2\u00ae\u00ad\3\2\2\2\u00ae")
+        buf.write("\u00af\3\2\2\2\u00af\u00b3\3\2\2\2\u00b0\u00b2\5\34\17")
+        buf.write("\2\u00b1\u00b0\3\2\2\2\u00b2\u00b5\3\2\2\2\u00b3\u00b1")
+        buf.write("\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\u00b7\3\2\2\2\u00b5")
+        buf.write("\u00b3\3\2\2\2\u00b6\u00b8\5\30\r\2\u00b7\u00b6\3\2\2")
+        buf.write("\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\u00ba")
+        buf.write("\5 \21\2\u00ba\u00bc\7!\2\2\u00bb\u00bd\7\4\2\2\u00bc")
+        buf.write("\u00bb\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd\27\3\2\2\2\u00be")
+        buf.write("\u00c1\7\16\2\2\u00bf\u00c1\7\f\2\2\u00c0\u00be\3\2\2")
+        buf.write("\2\u00c0\u00bf\3\2\2\2\u00c1\31\3\2\2\2\u00c2\u00c3\5")
+        buf.write(" \21\2\u00c3\u00c5\7!\2\2\u00c4\u00c6\7\17\2\2\u00c5\u00c4")
+        buf.write("\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\33\3\2\2\2\u00c7\u00c8")
+        buf.write("\7\35\2\2\u00c8\35\3\2\2\2\u00c9\u00cc\7!\2\2\u00ca\u00cb")
+        buf.write("\7\20\2\2\u00cb\u00cd\7!\2\2\u00cc\u00ca\3\2\2\2\u00cc")
+        buf.write("\u00cd\3\2\2\2\u00cd\u00cf\3\2\2\2\u00ce\u00d0\7\17\2")
+        buf.write("\2\u00cf\u00ce\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0\37\3")
+        buf.write("\2\2\2\u00d1\u00d6\5$\23\2\u00d2\u00d6\5\"\22\2\u00d3")
+        buf.write("\u00d6\5&\24\2\u00d4\u00d6\5(\25\2\u00d5\u00d1\3\2\2\2")
+        buf.write("\u00d5\u00d2\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5\u00d4\3")
+        buf.write("\2\2\2\u00d6!\3\2\2\2\u00d7\u00d8\7!\2\2\u00d8#\3\2\2")
+        buf.write("\2\u00d9\u00df\7\21\2\2\u00da\u00df\7\22\2\2\u00db\u00df")
+        buf.write("\7\23\2\2\u00dc\u00df\7\24\2\2\u00dd\u00df\7\25\2\2\u00de")
+        buf.write("\u00d9\3\2\2\2\u00de\u00da\3\2\2\2\u00de\u00db\3\2\2\2")
+        buf.write("\u00de\u00dc\3\2\2\2\u00de\u00dd\3\2\2\2\u00df%\3\2\2")
+        buf.write("\2\u00e0\u00e1\7\26\2\2\u00e1\u00e2\7\27\2\2\u00e2\u00e3")
+        buf.write("\5 \21\2\u00e3\u00e4\7\30\2\2\u00e4\'\3\2\2\2\u00e5\u00e6")
+        buf.write("\7\31\2\2\u00e6\u00e7\7\27\2\2\u00e7\u00e8\5 \21\2\u00e8")
+        buf.write("\u00e9\7\30\2\2\u00e9)\3\2\2\2\u00ea\u00ec\7#\2\2\u00eb")
+        buf.write("\u00ea\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00f0\3\2\2\2")
+        buf.write("\u00ed\u00ef\5\34\17\2\u00ee\u00ed\3\2\2\2\u00ef\u00f2")
+        buf.write("\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1")
+        buf.write("\u00f3\3\2\2\2\u00f2\u00f0\3\2\2\2\u00f3\u00f4\7\32\2")
+        buf.write("\2\u00f4\u00f5\7!\2\2\u00f5\u00f9\7\7\2\2\u00f6\u00f8")
+        buf.write("\5,\27\2\u00f7\u00f6\3\2\2\2\u00f8\u00fb\3\2\2\2\u00f9")
+        buf.write("\u00f7\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fc\3\2\2\2")
+        buf.write("\u00fb\u00f9\3\2\2\2\u00fc\u00fe\7\b\2\2\u00fd\u00ff\7")
+        buf.write("\4\2\2\u00fe\u00fd\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff+")
+        buf.write("\3\2\2\2\u0100\u0102\7#\2\2\u0101\u0100\3\2\2\2\u0101")
+        buf.write("\u0102\3\2\2\2\u0102\u0106\3\2\2\2\u0103\u0105\5\34\17")
+        buf.write("\2\u0104\u0103\3\2\2\2\u0105\u0108\3\2\2\2\u0106\u0104")
+        buf.write("\3\2\2\2\u0106\u0107\3\2\2\2\u0107\u0109\3\2\2\2\u0108")
+        buf.write("\u0106\3\2\2\2\u0109\u010a\5 \21\2\u010a\u010c\7!\2\2")
+        buf.write("\u010b\u010d\7\4\2\2\u010c\u010b\3\2\2\2\u010c\u010d\3")
+        buf.write("\2\2\2\u010d-\3\2\2\2\u010e\u0110\7#\2\2\u010f\u010e\3")
+        buf.write("\2\2\2\u010f\u0110\3\2\2\2\u0110\u0114\3\2\2\2\u0111\u0113")
+        buf.write("\5\34\17\2\u0112\u0111\3\2\2\2\u0113\u0116\3\2\2\2\u0114")
+        buf.write("\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0117\3\2\2\2")
+        buf.write("\u0116\u0114\3\2\2\2\u0117\u0118\5\60\31\2\u0118\u0119")
+        buf.write("\7!\2\2\u0119\u011d\7\7\2\2\u011a\u011c\5\62\32\2\u011b")
+        buf.write("\u011a\3\2\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2")
+        buf.write("\u011d\u011e\3\2\2\2\u011e\u0120\3\2\2\2\u011f\u011d\3")
+        buf.write("\2\2\2\u0120\u0122\7\b\2\2\u0121\u0123\7\4\2\2\u0122\u0121")
+        buf.write("\3\2\2\2\u0122\u0123\3\2\2\2\u0123/\3\2\2\2\u0124\u0127")
+        buf.write("\7\33\2\2\u0125\u0127\7\34\2\2\u0126\u0124\3\2\2\2\u0126")
+        buf.write("\u0125\3\2\2\2\u0127\61\3\2\2\2\u0128\u012a\7#\2\2\u0129")
+        buf.write("\u0128\3\2\2\2\u0129\u012a\3\2\2\2\u012a\u012e\3\2\2\2")
+        buf.write("\u012b\u012d\5\34\17\2\u012c\u012b\3\2\2\2\u012d\u0130")
+        buf.write("\3\2\2\2\u012e\u012c\3\2\2\2\u012e\u012f\3\2\2\2\u012f")
+        buf.write("\u0131\3\2\2\2\u0130\u012e\3\2\2\2\u0131\u0134\7!\2\2")
+        buf.write("\u0132\u0133\7\20\2\2\u0133\u0135\5\64\33\2\u0134\u0132")
+        buf.write("\3\2\2\2\u0134\u0135\3\2\2\2\u0135\u0137\3\2\2\2\u0136")
+        buf.write("\u0138\7\17\2\2\u0137\u0136\3\2\2\2\u0137\u0138\3\2\2")
+        buf.write("\2\u0138\63\3\2\2\2\u0139\u013c\7\36\2\2\u013a\u013c\7")
+        buf.write("\37\2\2\u013b\u0139\3\2\2\2\u013b\u013a\3\2\2\2\u013c")
+        buf.write("\65\3\2\2\2\63:AHKPW\\_dmrwz\177\u0084\u008b\u0090\u0093")
+        buf.write("\u0098\u009d\u00a6\u00ab\u00ae\u00b3\u00b7\u00bc\u00c0")
+        buf.write("\u00c5\u00cc\u00cf\u00d5\u00de\u00eb\u00f0\u00f9\u00fe")
+        buf.write("\u0101\u0106\u010c\u010f\u0114\u011d\u0122\u0126\u0129")
+        buf.write("\u012e\u0134\u0137\u013b")
         return buf.getvalue()
 
 
@@ -163,8 +167,8 @@ class TParser ( Parser ):
     sharedContextCache = PredictionContextCache()
 
     literalNames = [ "<INVALID>", "'import'", "';'", "'module'", "'interface'", 
-                     "'{'", "'}'", "'void'", "'('", "')'", "'signal'", "'readonly'", 
-                     "'const'", "','", "'='", "'bool'", "'int'", "'real'", 
+                     "'{'", "'}'", "'void'", "'('", "')'", "'const'", "'signal'", 
+                     "'readonly'", "','", "'='", "'bool'", "'int'", "'real'", 
                      "'string'", "'var'", "'list'", "'<'", "'>'", "'model'", 
                      "'struct'", "'enum'", "'flag'" ]
 
@@ -187,28 +191,29 @@ class TParser ( Parser ):
     RULE_interfaceSymbol = 5
     RULE_interfaceMemberSymbol = 6
     RULE_operationSymbol = 7
-    RULE_signalSymbol = 8
-    RULE_propertySymbol = 9
-    RULE_propertyModifierSymbol = 10
-    RULE_operationParameterSymbol = 11
-    RULE_tagSymbol = 12
-    RULE_tagAttributeSymbol = 13
-    RULE_typeSymbol = 14
-    RULE_complexTypeSymbol = 15
-    RULE_primitiveTypeSymbol = 16
-    RULE_listTypeSymbol = 17
-    RULE_modelTypeSymbol = 18
-    RULE_structSymbol = 19
-    RULE_structFieldSymbol = 20
-    RULE_enumSymbol = 21
-    RULE_enumTypeSymbol = 22
-    RULE_enumMemberSymbol = 23
-    RULE_intSymbol = 24
+    RULE_operationModifierSymbol = 8
+    RULE_signalSymbol = 9
+    RULE_propertySymbol = 10
+    RULE_propertyModifierSymbol = 11
+    RULE_operationParameterSymbol = 12
+    RULE_tagSymbol = 13
+    RULE_tagAttributeSymbol = 14
+    RULE_typeSymbol = 15
+    RULE_complexTypeSymbol = 16
+    RULE_primitiveTypeSymbol = 17
+    RULE_listTypeSymbol = 18
+    RULE_modelTypeSymbol = 19
+    RULE_structSymbol = 20
+    RULE_structFieldSymbol = 21
+    RULE_enumSymbol = 22
+    RULE_enumTypeSymbol = 23
+    RULE_enumMemberSymbol = 24
+    RULE_intSymbol = 25
 
     ruleNames =  [ "documentSymbol", "headerSymbol", "importSymbol", "moduleSymbol", 
                    "definitionSymbol", "interfaceSymbol", "interfaceMemberSymbol", 
-                   "operationSymbol", "signalSymbol", "propertySymbol", 
-                   "propertyModifierSymbol", "operationParameterSymbol", 
+                   "operationSymbol", "operationModifierSymbol", "signalSymbol", 
+                   "propertySymbol", "propertyModifierSymbol", "operationParameterSymbol", 
                    "tagSymbol", "tagAttributeSymbol", "typeSymbol", "complexTypeSymbol", 
                    "primitiveTypeSymbol", "listTypeSymbol", "modelTypeSymbol", 
                    "structSymbol", "structFieldSymbol", "enumSymbol", "enumTypeSymbol", 
@@ -288,12 +293,6 @@ class TParser ( Parser ):
             if hasattr( listener, "exitDocumentSymbol" ):
                 listener.exitDocumentSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitDocumentSymbol" ):
-                return visitor.visitDocumentSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
@@ -304,15 +303,15 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 50
+            self.state = 52
             self.headerSymbol()
-            self.state = 54
+            self.state = 56
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__3) | (1 << TParser.T__23) | (1 << TParser.T__24) | (1 << TParser.T__25) | (1 << TParser.TAGLINE) | (1 << TParser.DOCCOMMENT))) != 0):
-                self.state = 51
+                self.state = 53
                 self.definitionSymbol()
-                self.state = 56
+                self.state = 58
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -352,12 +351,6 @@ class TParser ( Parser ):
             if hasattr( listener, "exitHeaderSymbol" ):
                 listener.exitHeaderSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitHeaderSymbol" ):
-                return visitor.visitHeaderSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
@@ -368,15 +361,15 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 57
+            self.state = 59
             self.moduleSymbol()
-            self.state = 61
+            self.state = 63
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.T__0:
-                self.state = 58
+                self.state = 60
                 self.importSymbol()
-                self.state = 63
+                self.state = 65
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -413,12 +406,6 @@ class TParser ( Parser ):
             if hasattr( listener, "exitImportSymbol" ):
                 listener.exitImportSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitImportSymbol" ):
-                return visitor.visitImportSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
@@ -429,17 +416,17 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 64
+            self.state = 66
             self.match(TParser.T__0)
-            self.state = 65
+            self.state = 67
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 66
-            localctx.version = self.match(TParser.VERSION)
             self.state = 68
+            localctx.version = self.match(TParser.VERSION)
+            self.state = 70
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 67
+                self.state = 69
                 self.match(TParser.T__1)
 
 
@@ -487,12 +474,6 @@ class TParser ( Parser ):
             if hasattr( listener, "exitModuleSymbol" ):
                 listener.exitModuleSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitModuleSymbol" ):
-                return visitor.visitModuleSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
@@ -503,35 +484,35 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 71
+            self.state = 73
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 70
+                self.state = 72
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 76
+            self.state = 78
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 73
+                self.state = 75
                 self.tagSymbol()
-                self.state = 78
+                self.state = 80
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 79
+            self.state = 81
             self.match(TParser.T__2)
-            self.state = 80
+            self.state = 82
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 81
-            localctx.version = self.match(TParser.VERSION)
             self.state = 83
+            localctx.version = self.match(TParser.VERSION)
+            self.state = 85
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 82
+                self.state = 84
                 self.match(TParser.T__1)
 
 
@@ -572,12 +553,6 @@ class TParser ( Parser ):
             if hasattr( listener, "exitDefinitionSymbol" ):
                 listener.exitDefinitionSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitDefinitionSymbol" ):
-                return visitor.visitDefinitionSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
@@ -586,24 +561,24 @@ class TParser ( Parser ):
         localctx = TParser.DefinitionSymbolContext(self, self._ctx, self.state)
         self.enterRule(localctx, 8, self.RULE_definitionSymbol)
         try:
-            self.state = 88
+            self.state = 90
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 85
+                self.state = 87
                 self.interfaceSymbol()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 86
+                self.state = 88
                 self.structSymbol()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 87
+                self.state = 89
                 self.enumSymbol()
                 pass
 
@@ -655,12 +630,6 @@ class TParser ( Parser ):
             if hasattr( listener, "exitInterfaceSymbol" ):
                 listener.exitInterfaceSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitInterfaceSymbol" ):
-                return visitor.visitInterfaceSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
@@ -671,47 +640,47 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 91
+            self.state = 93
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 90
+                self.state = 92
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 96
+            self.state = 98
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 93
+                self.state = 95
                 self.tagSymbol()
-                self.state = 98
+                self.state = 100
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 99
+            self.state = 101
             self.match(TParser.T__3)
-            self.state = 100
+            self.state = 102
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 101
+            self.state = 103
             self.match(TParser.T__4)
-            self.state = 105
+            self.state = 107
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__6) | (1 << TParser.T__9) | (1 << TParser.T__10) | (1 << TParser.T__11) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__19) | (1 << TParser.T__22) | (1 << TParser.TAGLINE) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
-                self.state = 102
+                self.state = 104
                 self.interfaceMemberSymbol()
-                self.state = 107
+                self.state = 109
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 108
-            self.match(TParser.T__5)
             self.state = 110
+            self.match(TParser.T__5)
+            self.state = 112
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 109
+                self.state = 111
                 self.match(TParser.T__1)
 
 
@@ -752,12 +721,6 @@ class TParser ( Parser ):
             if hasattr( listener, "exitInterfaceMemberSymbol" ):
                 listener.exitInterfaceMemberSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitInterfaceMemberSymbol" ):
-                return visitor.visitInterfaceMemberSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
@@ -766,24 +729,24 @@ class TParser ( Parser ):
         localctx = TParser.InterfaceMemberSymbolContext(self, self._ctx, self.state)
         self.enterRule(localctx, 12, self.RULE_interfaceMemberSymbol)
         try:
-            self.state = 115
+            self.state = 117
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 112
+                self.state = 114
                 self.operationSymbol()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 113
+                self.state = 115
                 self.propertySymbol()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 114
+                self.state = 116
                 self.signalSymbol()
                 pass
 
@@ -825,6 +788,10 @@ class TParser ( Parser ):
                 return self.getTypedRuleContext(TParser.OperationParameterSymbolContext,i)
 
 
+        def operationModifierSymbol(self):
+            return self.getTypedRuleContext(TParser.OperationModifierSymbolContext,0)
+
+
         def DOCCOMMENT(self):
             return self.getToken(TParser.DOCCOMMENT, 0)
 
@@ -839,12 +806,6 @@ class TParser ( Parser ):
             if hasattr( listener, "exitOperationSymbol" ):
                 listener.exitOperationSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitOperationSymbol" ):
-                return visitor.visitOperationSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
@@ -855,59 +816,67 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 118
+            self.state = 120
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 117
+                self.state = 119
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 123
+            self.state = 125
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 120
+                self.state = 122
                 self.tagSymbol()
-                self.state = 125
+                self.state = 127
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 128
+            self.state = 130
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [TParser.T__14, TParser.T__15, TParser.T__16, TParser.T__17, TParser.T__18, TParser.T__19, TParser.T__22, TParser.IDENTIFIER]:
-                self.state = 126
+                self.state = 128
                 self.typeSymbol()
                 pass
             elif token in [TParser.T__6]:
-                self.state = 127
+                self.state = 129
                 self.match(TParser.T__6)
                 pass
             else:
                 raise NoViableAltException(self)
 
-            self.state = 130
+            self.state = 132
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 131
+            self.state = 133
             self.match(TParser.T__7)
-            self.state = 135
+            self.state = 137
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__19) | (1 << TParser.T__22) | (1 << TParser.IDENTIFIER))) != 0):
-                self.state = 132
+                self.state = 134
                 self.operationParameterSymbol()
-                self.state = 137
+                self.state = 139
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 138
-            self.match(TParser.T__8)
             self.state = 140
+            self.match(TParser.T__8)
+            self.state = 142
+            self._errHandler.sync(self)
+            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
+            if la_ == 1:
+                self.state = 141
+                self.operationModifierSymbol()
+
+
+            self.state = 145
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 139
+                self.state = 144
                 self.match(TParser.T__1)
 
 
@@ -919,6 +888,44 @@ class TParser ( Parser ):
             self.exitRule()
         return localctx
 
+    class OperationModifierSymbolContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+            self.is_const = None # Token
+
+
+        def getRuleIndex(self):
+            return TParser.RULE_operationModifierSymbol
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterOperationModifierSymbol" ):
+                listener.enterOperationModifierSymbol(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitOperationModifierSymbol" ):
+                listener.exitOperationModifierSymbol(self)
+
+
+
+
+    def operationModifierSymbol(self):
+
+        localctx = TParser.OperationModifierSymbolContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 16, self.RULE_operationModifierSymbol)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 147
+            localctx.is_const = self.match(TParser.T__9)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
     class SignalSymbolContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -958,63 +965,57 @@ class TParser ( Parser ):
             if hasattr( listener, "exitSignalSymbol" ):
                 listener.exitSignalSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitSignalSymbol" ):
-                return visitor.visitSignalSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def signalSymbol(self):
 
         localctx = TParser.SignalSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 16, self.RULE_signalSymbol)
+        self.enterRule(localctx, 18, self.RULE_signalSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 143
+            self.state = 150
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 142
+                self.state = 149
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 148
+            self.state = 155
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 145
+                self.state = 152
                 self.tagSymbol()
-                self.state = 150
+                self.state = 157
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 151
-            self.match(TParser.T__9)
-            self.state = 152
+            self.state = 158
+            self.match(TParser.T__10)
+            self.state = 159
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 153
+            self.state = 160
             self.match(TParser.T__7)
-            self.state = 157
+            self.state = 164
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__19) | (1 << TParser.T__22) | (1 << TParser.IDENTIFIER))) != 0):
-                self.state = 154
+                self.state = 161
                 self.operationParameterSymbol()
-                self.state = 159
+                self.state = 166
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 160
+            self.state = 167
             self.match(TParser.T__8)
-            self.state = 162
+            self.state = 169
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 161
+                self.state = 168
                 self.match(TParser.T__1)
 
 
@@ -1066,57 +1067,51 @@ class TParser ( Parser ):
             if hasattr( listener, "exitPropertySymbol" ):
                 listener.exitPropertySymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitPropertySymbol" ):
-                return visitor.visitPropertySymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def propertySymbol(self):
 
         localctx = TParser.PropertySymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 18, self.RULE_propertySymbol)
+        self.enterRule(localctx, 20, self.RULE_propertySymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 165
+            self.state = 172
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 164
+                self.state = 171
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 170
+            self.state = 177
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 167
+                self.state = 174
                 self.tagSymbol()
-                self.state = 172
+                self.state = 179
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 174
+            self.state = 181
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==TParser.T__10 or _la==TParser.T__11:
-                self.state = 173
+            if _la==TParser.T__9 or _la==TParser.T__11:
+                self.state = 180
                 self.propertyModifierSymbol()
 
 
-            self.state = 176
+            self.state = 183
             self.typeSymbol()
-            self.state = 177
+            self.state = 184
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 179
+            self.state = 186
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 178
+                self.state = 185
                 self.match(TParser.T__1)
 
 
@@ -1148,32 +1143,26 @@ class TParser ( Parser ):
             if hasattr( listener, "exitPropertyModifierSymbol" ):
                 listener.exitPropertyModifierSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitPropertyModifierSymbol" ):
-                return visitor.visitPropertyModifierSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def propertyModifierSymbol(self):
 
         localctx = TParser.PropertyModifierSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 20, self.RULE_propertyModifierSymbol)
+        self.enterRule(localctx, 22, self.RULE_propertyModifierSymbol)
         try:
-            self.state = 183
+            self.state = 190
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [TParser.T__10]:
+            if token in [TParser.T__11]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 181
-                localctx.is_readonly = self.match(TParser.T__10)
+                self.state = 188
+                localctx.is_readonly = self.match(TParser.T__11)
                 pass
-            elif token in [TParser.T__11]:
+            elif token in [TParser.T__9]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 182
-                localctx.is_const = self.match(TParser.T__11)
+                self.state = 189
+                localctx.is_const = self.match(TParser.T__9)
                 pass
             else:
                 raise NoViableAltException(self)
@@ -1211,31 +1200,25 @@ class TParser ( Parser ):
             if hasattr( listener, "exitOperationParameterSymbol" ):
                 listener.exitOperationParameterSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitOperationParameterSymbol" ):
-                return visitor.visitOperationParameterSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def operationParameterSymbol(self):
 
         localctx = TParser.OperationParameterSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 22, self.RULE_operationParameterSymbol)
+        self.enterRule(localctx, 24, self.RULE_operationParameterSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 185
+            self.state = 192
             self.typeSymbol()
-            self.state = 186
+            self.state = 193
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 188
+            self.state = 195
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__12:
-                self.state = 187
+                self.state = 194
                 self.match(TParser.T__12)
 
 
@@ -1268,22 +1251,16 @@ class TParser ( Parser ):
             if hasattr( listener, "exitTagSymbol" ):
                 listener.exitTagSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitTagSymbol" ):
-                return visitor.visitTagSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def tagSymbol(self):
 
         localctx = TParser.TagSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 24, self.RULE_tagSymbol)
+        self.enterRule(localctx, 26, self.RULE_tagSymbol)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 190
+            self.state = 197
             localctx.line = self.match(TParser.TAGLINE)
         except RecognitionException as re:
             localctx.exception = re
@@ -1318,39 +1295,33 @@ class TParser ( Parser ):
             if hasattr( listener, "exitTagAttributeSymbol" ):
                 listener.exitTagAttributeSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitTagAttributeSymbol" ):
-                return visitor.visitTagAttributeSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def tagAttributeSymbol(self):
 
         localctx = TParser.TagAttributeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 26, self.RULE_tagAttributeSymbol)
+        self.enterRule(localctx, 28, self.RULE_tagAttributeSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 192
+            self.state = 199
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 195
+            self.state = 202
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__13:
-                self.state = 193
+                self.state = 200
                 self.match(TParser.T__13)
-                self.state = 194
+                self.state = 201
                 localctx.value = self.match(TParser.IDENTIFIER)
 
 
-            self.state = 198
+            self.state = 205
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__12:
-                self.state = 197
+                self.state = 204
                 self.match(TParser.T__12)
 
 
@@ -1395,41 +1366,35 @@ class TParser ( Parser ):
             if hasattr( listener, "exitTypeSymbol" ):
                 listener.exitTypeSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitTypeSymbol" ):
-                return visitor.visitTypeSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def typeSymbol(self):
 
         localctx = TParser.TypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 28, self.RULE_typeSymbol)
+        self.enterRule(localctx, 30, self.RULE_typeSymbol)
         try:
-            self.state = 204
+            self.state = 211
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [TParser.T__14, TParser.T__15, TParser.T__16, TParser.T__17, TParser.T__18]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 200
+                self.state = 207
                 self.primitiveTypeSymbol()
                 pass
             elif token in [TParser.IDENTIFIER]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 201
+                self.state = 208
                 self.complexTypeSymbol()
                 pass
             elif token in [TParser.T__19]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 202
+                self.state = 209
                 self.listTypeSymbol()
                 pass
             elif token in [TParser.T__22]:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 203
+                self.state = 210
                 self.modelTypeSymbol()
                 pass
             else:
@@ -1464,22 +1429,16 @@ class TParser ( Parser ):
             if hasattr( listener, "exitComplexTypeSymbol" ):
                 listener.exitComplexTypeSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitComplexTypeSymbol" ):
-                return visitor.visitComplexTypeSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def complexTypeSymbol(self):
 
         localctx = TParser.ComplexTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 30, self.RULE_complexTypeSymbol)
+        self.enterRule(localctx, 32, self.RULE_complexTypeSymbol)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 206
+            self.state = 213
             localctx.name = self.match(TParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -1508,46 +1467,40 @@ class TParser ( Parser ):
             if hasattr( listener, "exitPrimitiveTypeSymbol" ):
                 listener.exitPrimitiveTypeSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitPrimitiveTypeSymbol" ):
-                return visitor.visitPrimitiveTypeSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def primitiveTypeSymbol(self):
 
         localctx = TParser.PrimitiveTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 32, self.RULE_primitiveTypeSymbol)
+        self.enterRule(localctx, 34, self.RULE_primitiveTypeSymbol)
         try:
-            self.state = 213
+            self.state = 220
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [TParser.T__14]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 208
+                self.state = 215
                 localctx.name = self.match(TParser.T__14)
                 pass
             elif token in [TParser.T__15]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 209
+                self.state = 216
                 localctx.name = self.match(TParser.T__15)
                 pass
             elif token in [TParser.T__16]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 210
+                self.state = 217
                 localctx.name = self.match(TParser.T__16)
                 pass
             elif token in [TParser.T__17]:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 211
+                self.state = 218
                 localctx.name = self.match(TParser.T__17)
                 pass
             elif token in [TParser.T__18]:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 212
+                self.state = 219
                 localctx.name = self.match(TParser.T__18)
                 pass
             else:
@@ -1583,28 +1536,22 @@ class TParser ( Parser ):
             if hasattr( listener, "exitListTypeSymbol" ):
                 listener.exitListTypeSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitListTypeSymbol" ):
-                return visitor.visitListTypeSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def listTypeSymbol(self):
 
         localctx = TParser.ListTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 34, self.RULE_listTypeSymbol)
+        self.enterRule(localctx, 36, self.RULE_listTypeSymbol)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 215
+            self.state = 222
             self.match(TParser.T__19)
-            self.state = 216
+            self.state = 223
             self.match(TParser.T__20)
-            self.state = 217
+            self.state = 224
             localctx.valueType = self.typeSymbol()
-            self.state = 218
+            self.state = 225
             self.match(TParser.T__21)
         except RecognitionException as re:
             localctx.exception = re
@@ -1636,28 +1583,22 @@ class TParser ( Parser ):
             if hasattr( listener, "exitModelTypeSymbol" ):
                 listener.exitModelTypeSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitModelTypeSymbol" ):
-                return visitor.visitModelTypeSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def modelTypeSymbol(self):
 
         localctx = TParser.ModelTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 36, self.RULE_modelTypeSymbol)
+        self.enterRule(localctx, 38, self.RULE_modelTypeSymbol)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 220
+            self.state = 227
             self.match(TParser.T__22)
-            self.state = 221
+            self.state = 228
             self.match(TParser.T__20)
-            self.state = 222
+            self.state = 229
             localctx.valueType = self.typeSymbol()
-            self.state = 223
+            self.state = 230
             self.match(TParser.T__21)
         except RecognitionException as re:
             localctx.exception = re
@@ -1706,63 +1647,57 @@ class TParser ( Parser ):
             if hasattr( listener, "exitStructSymbol" ):
                 listener.exitStructSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitStructSymbol" ):
-                return visitor.visitStructSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def structSymbol(self):
 
         localctx = TParser.StructSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 38, self.RULE_structSymbol)
+        self.enterRule(localctx, 40, self.RULE_structSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 226
+            self.state = 233
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 225
+                self.state = 232
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 231
+            self.state = 238
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 228
+                self.state = 235
                 self.tagSymbol()
-                self.state = 233
+                self.state = 240
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 234
+            self.state = 241
             self.match(TParser.T__23)
-            self.state = 235
+            self.state = 242
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 236
+            self.state = 243
             self.match(TParser.T__4)
-            self.state = 240
+            self.state = 247
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__19) | (1 << TParser.T__22) | (1 << TParser.TAGLINE) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
-                self.state = 237
+                self.state = 244
                 self.structFieldSymbol()
-                self.state = 242
+                self.state = 249
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 243
+            self.state = 250
             self.match(TParser.T__5)
-            self.state = 245
+            self.state = 252
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 244
+                self.state = 251
                 self.match(TParser.T__1)
 
 
@@ -1810,49 +1745,43 @@ class TParser ( Parser ):
             if hasattr( listener, "exitStructFieldSymbol" ):
                 listener.exitStructFieldSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitStructFieldSymbol" ):
-                return visitor.visitStructFieldSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def structFieldSymbol(self):
 
         localctx = TParser.StructFieldSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 40, self.RULE_structFieldSymbol)
+        self.enterRule(localctx, 42, self.RULE_structFieldSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 248
+            self.state = 255
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 247
+                self.state = 254
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 253
+            self.state = 260
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 250
+                self.state = 257
                 self.tagSymbol()
-                self.state = 255
+                self.state = 262
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 256
+            self.state = 263
             self.typeSymbol()
-            self.state = 257
+            self.state = 264
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 259
+            self.state = 266
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 258
+                self.state = 265
                 self.match(TParser.T__1)
 
 
@@ -1907,63 +1836,57 @@ class TParser ( Parser ):
             if hasattr( listener, "exitEnumSymbol" ):
                 listener.exitEnumSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitEnumSymbol" ):
-                return visitor.visitEnumSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def enumSymbol(self):
 
         localctx = TParser.EnumSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 42, self.RULE_enumSymbol)
+        self.enterRule(localctx, 44, self.RULE_enumSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 262
+            self.state = 269
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 261
+                self.state = 268
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 267
+            self.state = 274
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 264
+                self.state = 271
                 self.tagSymbol()
-                self.state = 269
+                self.state = 276
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 270
+            self.state = 277
             self.enumTypeSymbol()
-            self.state = 271
+            self.state = 278
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 272
+            self.state = 279
             self.match(TParser.T__4)
-            self.state = 276
+            self.state = 283
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.TAGLINE) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
-                self.state = 273
+                self.state = 280
                 self.enumMemberSymbol()
-                self.state = 278
+                self.state = 285
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 279
+            self.state = 286
             self.match(TParser.T__5)
-            self.state = 281
+            self.state = 288
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 280
+                self.state = 287
                 self.match(TParser.T__1)
 
 
@@ -1995,31 +1918,25 @@ class TParser ( Parser ):
             if hasattr( listener, "exitEnumTypeSymbol" ):
                 listener.exitEnumTypeSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitEnumTypeSymbol" ):
-                return visitor.visitEnumTypeSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def enumTypeSymbol(self):
 
         localctx = TParser.EnumTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 44, self.RULE_enumTypeSymbol)
+        self.enterRule(localctx, 46, self.RULE_enumTypeSymbol)
         try:
-            self.state = 285
+            self.state = 292
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [TParser.T__24]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 283
+                self.state = 290
                 localctx.isEnum = self.match(TParser.T__24)
                 pass
             elif token in [TParser.T__25]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 284
+                self.state = 291
                 localctx.isFlag = self.match(TParser.T__25)
                 pass
             else:
@@ -2069,57 +1986,51 @@ class TParser ( Parser ):
             if hasattr( listener, "exitEnumMemberSymbol" ):
                 listener.exitEnumMemberSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitEnumMemberSymbol" ):
-                return visitor.visitEnumMemberSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def enumMemberSymbol(self):
 
         localctx = TParser.EnumMemberSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 46, self.RULE_enumMemberSymbol)
+        self.enterRule(localctx, 48, self.RULE_enumMemberSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 288
+            self.state = 295
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 287
+                self.state = 294
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 293
+            self.state = 300
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 290
+                self.state = 297
                 self.tagSymbol()
-                self.state = 295
+                self.state = 302
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 296
+            self.state = 303
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 299
+            self.state = 306
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__13:
-                self.state = 297
+                self.state = 304
                 self.match(TParser.T__13)
-                self.state = 298
+                self.state = 305
                 self.intSymbol()
 
 
-            self.state = 302
+            self.state = 309
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__12:
-                self.state = 301
+                self.state = 308
                 self.match(TParser.T__12)
 
 
@@ -2155,31 +2066,25 @@ class TParser ( Parser ):
             if hasattr( listener, "exitIntSymbol" ):
                 listener.exitIntSymbol(self)
 
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitIntSymbol" ):
-                return visitor.visitIntSymbol(self)
-            else:
-                return visitor.visitChildren(self)
-
 
 
 
     def intSymbol(self):
 
         localctx = TParser.IntSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 48, self.RULE_intSymbol)
+        self.enterRule(localctx, 50, self.RULE_intSymbol)
         try:
-            self.state = 306
+            self.state = 313
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [TParser.INTCONSTANT]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 304
+                self.state = 311
                 localctx.value = self.match(TParser.INTCONSTANT)
                 pass
             elif token in [TParser.HEXCONSTANT]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 305
+                self.state = 312
                 localctx.value = self.match(TParser.HEXCONSTANT)
                 pass
             else:
diff --git a/tests/in/com.pelagicore.ivi.tuner.qface b/tests/in/com.pelagicore.ivi.tuner.qface
index a85641f..d1f7882 100644
--- a/tests/in/com.pelagicore.ivi.tuner.qface
+++ b/tests/in/com.pelagicore.ivi.tuner.qface
@@ -12,6 +12,8 @@ interface Tuner {
     const Station defaultStation;
     /** operation nextStation */
     void nextStation();
+    /** operation numStations */
+    int numStations() const;
     /** operation previousStation */
     void previousStation();
     /** operation updateCurrentStation */
diff --git a/tests/test_parser.py b/tests/test_parser.py
index a7c2d23..601bd65 100644
--- a/tests/test_parser.py
+++ b/tests/test_parser.py
@@ -68,6 +68,9 @@ def test_operation():
     assert operation
     operation = interface._contentMap['previousStation']
     assert operation
+    operation = interface._contentMap['numStations']
+    assert operation
+    assert operation.const
 
 
 def test_signals():