feature constant properties (#38)

* A first version of supporting constant properties. The grammar god a little bit more complicated and might be cleaned up at some point. Also the cpp property generation is more coplicated and should also be simplified again. Maybe by providing some JINJA macros or C++ helpers.

* Updated cont property feature. The keyword used now is ‘const’. Also updated the grammar in this respect.

* removed the is_ prefix from the bool variables for properties (is_readonly => readonly, is_const=>const)

9 files changed, 674 insertions, 575 deletions

diff --git a/qface/idl/domain.py b/qface/idl/domain.py
index c774c16..894c9b0 100644
--- a/qface/idl/domain.py
+++ b/qface/idl/domain.py
@@ -357,7 +357,8 @@ class Property(Symbol):
         log.debug('Property()')
         self.interface = interface
         self.interface._propertyMap[name] = self
-        self.is_readonly = False
+        self.readonly = False
+        self.const = False
 
 
 class Struct(Symbol):
@@ -366,7 +367,7 @@ class Struct(Symbol):
         super().__init__(name, module)
         log.debug('Struct()')
         self.module._structMap[name] = self
-        self._fieldMap = self._contentMap = OrderedDict()  # type: dict[str, Field]
+        self._fieldMap = self._contentMap = OrderedDict()
 
     @property
     def fields(self):
diff --git a/qface/idl/listener.py b/qface/idl/listener.py
index fc5781a..3f3ff5a 100644
--- a/qface/idl/listener.py
+++ b/qface/idl/listener.py
@@ -181,7 +181,10 @@ class DomainListener(TListener):
         assert self.interface
         name = ctx.name.text
         self.property = Property(name, self.interface)
-        self.property.is_readonly = bool(ctx.isReadOnly)
+        modifier = ctx.propertyModifierSymbol()
+        if modifier:
+            self.property.readonly = bool(modifier.is_readonly)
+            self.property.const = bool(modifier.is_const)
         self.parse_annotations(ctx, self.property)
         self.parse_type(ctx, self.property.type)
         contextMap[ctx] = self.property
diff --git a/qface/idl/parser/T.g4 b/qface/idl/parser/T.g4
index 4ec68c8..97badde 100644
--- a/qface/idl/parser/T.g4
+++ b/qface/idl/parser/T.g4
@@ -48,7 +48,12 @@ signalSymbol
 
 
 propertySymbol
-    : comment=DOCCOMMENT? tagSymbol* isReadOnly='readonly'? typeSymbol name=IDENTIFIER ';'?
+    : comment=DOCCOMMENT? tagSymbol* propertyModifierSymbol? typeSymbol name=IDENTIFIER ';'?
+    ;
+
+propertyModifierSymbol
+    : is_readonly='readonly'
+    | is_const='const'
     ;
 
 operationParameterSymbol
diff --git a/qface/idl/parser/T.tokens b/qface/idl/parser/T.tokens
index 86bf74a..d9b477d 100644
--- a/qface/idl/parser/T.tokens
+++ b/qface/idl/parser/T.tokens
@@ -23,16 +23,17 @@ T__21=22
 T__22=23
 T__23=24
 T__24=25
-TAGLINE=26
-INTCONSTANT=27
-HEXCONSTANT=28
-TAGIDENTIFIER=29
-IDENTIFIER=30
-VERSION=31
-DOCCOMMENT=32
-WHITESPACE=33
-COMMENT=34
-MULTICOMM=35
+T__25=26
+TAGLINE=27
+INTCONSTANT=28
+HEXCONSTANT=29
+TAGIDENTIFIER=30
+IDENTIFIER=31
+VERSION=32
+DOCCOMMENT=33
+WHITESPACE=34
+COMMENT=35
+MULTICOMM=36
 'import'=1
 ';'=2
 'module'=3
@@ -44,17 +45,18 @@ MULTICOMM=35
 ')'=9
 'signal'=10
 'readonly'=11
-','=12
-'='=13
-'bool'=14
-'int'=15
-'real'=16
-'string'=17
-'var'=18
-'list'=19
-'<'=20
-'>'=21
-'model'=22
-'struct'=23
-'enum'=24
-'flag'=25
+'const'=12
+','=13
+'='=14
+'bool'=15
+'int'=16
+'real'=17
+'string'=18
+'var'=19
+'list'=20
+'<'=21
+'>'=22
+'model'=23
+'struct'=24
+'enum'=25
+'flag'=26
diff --git a/qface/idl/parser/TLexer.py b/qface/idl/parser/TLexer.py
index 59f1fcb..760c329 100644
--- a/qface/idl/parser/TLexer.py
+++ b/qface/idl/parser/TLexer.py
@@ -5,121 +5,124 @@ from io import StringIO
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2%")
-        buf.write("\u0114\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2&")
+        buf.write("\u011c\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
         buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36")
-        buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\3\2\3")
-        buf.write("\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4")
-        buf.write("\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3")
-        buf.write("\7\3\7\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3")
-        buf.write("\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3")
-        buf.write("\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\20")
-        buf.write("\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\22")
-        buf.write("\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\24\3\24\3\24")
-        buf.write("\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\27\3\27\3\27")
-        buf.write("\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31")
-        buf.write("\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\33\3\33\7\33\u00c0")
-        buf.write("\n\33\f\33\16\33\u00c3\13\33\3\34\5\34\u00c6\n\34\3\34")
-        buf.write("\6\34\u00c9\n\34\r\34\16\34\u00ca\3\35\3\35\3\35\3\35")
-        buf.write("\6\35\u00d1\n\35\r\35\16\35\u00d2\3\36\3\36\3\36\7\36")
-        buf.write("\u00d8\n\36\f\36\16\36\u00db\13\36\3\37\3\37\7\37\u00df")
-        buf.write("\n\37\f\37\16\37\u00e2\13\37\3 \3 \3 \3 \3!\3!\3!\3!\3")
-        buf.write("!\7!\u00ed\n!\f!\16!\u00f0\13!\3!\3!\3!\3\"\6\"\u00f6")
-        buf.write("\n\"\r\"\16\"\u00f7\3\"\3\"\3#\3#\3#\3#\7#\u0100\n#\f")
-        buf.write("#\16#\u0103\13#\3#\3#\3$\3$\3$\3$\7$\u010b\n$\f$\16$\u010e")
-        buf.write("\13$\3$\3$\3$\3$\3$\4\u00ee\u010c\2%\3\3\5\4\7\5\t\6\13")
-        buf.write("\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37")
-        buf.write("\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34")
-        buf.write("\67\359\36;\37= ?!A\"C#E$G%\3\2\t\4\2\f\f\17\17\4\2--")
-        buf.write("//\5\2\62;CHch\5\2C\\aac|\7\2\60\60\62;C\\aac|\3\2\62")
-        buf.write(";\5\2\13\f\17\17\"\"\u011d\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
-        buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2")
-        buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2")
-        buf.write("\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2")
-        buf.write("\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2")
-        buf.write("\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63")
-        buf.write("\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2")
-        buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2")
-        buf.write("\2\2\2G\3\2\2\2\3I\3\2\2\2\5P\3\2\2\2\7R\3\2\2\2\tY\3")
-        buf.write("\2\2\2\13c\3\2\2\2\re\3\2\2\2\17g\3\2\2\2\21l\3\2\2\2")
-        buf.write("\23n\3\2\2\2\25p\3\2\2\2\27w\3\2\2\2\31\u0080\3\2\2\2")
-        buf.write("\33\u0082\3\2\2\2\35\u0084\3\2\2\2\37\u0089\3\2\2\2!\u008d")
-        buf.write("\3\2\2\2#\u0092\3\2\2\2%\u0099\3\2\2\2\'\u009d\3\2\2\2")
-        buf.write(")\u00a2\3\2\2\2+\u00a4\3\2\2\2-\u00a6\3\2\2\2/\u00ac\3")
-        buf.write("\2\2\2\61\u00b3\3\2\2\2\63\u00b8\3\2\2\2\65\u00bd\3\2")
-        buf.write("\2\2\67\u00c5\3\2\2\29\u00cc\3\2\2\2;\u00d4\3\2\2\2=\u00dc")
-        buf.write("\3\2\2\2?\u00e3\3\2\2\2A\u00e7\3\2\2\2C\u00f5\3\2\2\2")
-        buf.write("E\u00fb\3\2\2\2G\u0106\3\2\2\2IJ\7k\2\2JK\7o\2\2KL\7r")
-        buf.write("\2\2LM\7q\2\2MN\7t\2\2NO\7v\2\2O\4\3\2\2\2PQ\7=\2\2Q\6")
-        buf.write("\3\2\2\2RS\7o\2\2ST\7q\2\2TU\7f\2\2UV\7w\2\2VW\7n\2\2")
-        buf.write("WX\7g\2\2X\b\3\2\2\2YZ\7k\2\2Z[\7p\2\2[\\\7v\2\2\\]\7")
-        buf.write("g\2\2]^\7t\2\2^_\7h\2\2_`\7c\2\2`a\7e\2\2ab\7g\2\2b\n")
-        buf.write("\3\2\2\2cd\7}\2\2d\f\3\2\2\2ef\7\177\2\2f\16\3\2\2\2g")
-        buf.write("h\7x\2\2hi\7q\2\2ij\7k\2\2jk\7f\2\2k\20\3\2\2\2lm\7*\2")
-        buf.write("\2m\22\3\2\2\2no\7+\2\2o\24\3\2\2\2pq\7u\2\2qr\7k\2\2")
-        buf.write("rs\7i\2\2st\7p\2\2tu\7c\2\2uv\7n\2\2v\26\3\2\2\2wx\7t")
-        buf.write("\2\2xy\7g\2\2yz\7c\2\2z{\7f\2\2{|\7q\2\2|}\7p\2\2}~\7")
-        buf.write("n\2\2~\177\7{\2\2\177\30\3\2\2\2\u0080\u0081\7.\2\2\u0081")
-        buf.write("\32\3\2\2\2\u0082\u0083\7?\2\2\u0083\34\3\2\2\2\u0084")
-        buf.write("\u0085\7d\2\2\u0085\u0086\7q\2\2\u0086\u0087\7q\2\2\u0087")
-        buf.write("\u0088\7n\2\2\u0088\36\3\2\2\2\u0089\u008a\7k\2\2\u008a")
-        buf.write("\u008b\7p\2\2\u008b\u008c\7v\2\2\u008c \3\2\2\2\u008d")
-        buf.write("\u008e\7t\2\2\u008e\u008f\7g\2\2\u008f\u0090\7c\2\2\u0090")
-        buf.write("\u0091\7n\2\2\u0091\"\3\2\2\2\u0092\u0093\7u\2\2\u0093")
-        buf.write("\u0094\7v\2\2\u0094\u0095\7t\2\2\u0095\u0096\7k\2\2\u0096")
-        buf.write("\u0097\7p\2\2\u0097\u0098\7i\2\2\u0098$\3\2\2\2\u0099")
-        buf.write("\u009a\7x\2\2\u009a\u009b\7c\2\2\u009b\u009c\7t\2\2\u009c")
-        buf.write("&\3\2\2\2\u009d\u009e\7n\2\2\u009e\u009f\7k\2\2\u009f")
-        buf.write("\u00a0\7u\2\2\u00a0\u00a1\7v\2\2\u00a1(\3\2\2\2\u00a2")
-        buf.write("\u00a3\7>\2\2\u00a3*\3\2\2\2\u00a4\u00a5\7@\2\2\u00a5")
-        buf.write(",\3\2\2\2\u00a6\u00a7\7o\2\2\u00a7\u00a8\7q\2\2\u00a8")
-        buf.write("\u00a9\7f\2\2\u00a9\u00aa\7g\2\2\u00aa\u00ab\7n\2\2\u00ab")
-        buf.write(".\3\2\2\2\u00ac\u00ad\7u\2\2\u00ad\u00ae\7v\2\2\u00ae")
-        buf.write("\u00af\7t\2\2\u00af\u00b0\7w\2\2\u00b0\u00b1\7e\2\2\u00b1")
-        buf.write("\u00b2\7v\2\2\u00b2\60\3\2\2\2\u00b3\u00b4\7g\2\2\u00b4")
-        buf.write("\u00b5\7p\2\2\u00b5\u00b6\7w\2\2\u00b6\u00b7\7o\2\2\u00b7")
-        buf.write("\62\3\2\2\2\u00b8\u00b9\7h\2\2\u00b9\u00ba\7n\2\2\u00ba")
-        buf.write("\u00bb\7c\2\2\u00bb\u00bc\7i\2\2\u00bc\64\3\2\2\2\u00bd")
-        buf.write("\u00c1\7B\2\2\u00be\u00c0\n\2\2\2\u00bf\u00be\3\2\2\2")
-        buf.write("\u00c0\u00c3\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c1\u00c2\3")
-        buf.write("\2\2\2\u00c2\66\3\2\2\2\u00c3\u00c1\3\2\2\2\u00c4\u00c6")
-        buf.write("\t\3\2\2\u00c5\u00c4\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6")
-        buf.write("\u00c8\3\2\2\2\u00c7\u00c9\4\62;\2\u00c8\u00c7\3\2\2\2")
-        buf.write("\u00c9\u00ca\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00cb\3")
-        buf.write("\2\2\2\u00cb8\3\2\2\2\u00cc\u00cd\7\62\2\2\u00cd\u00ce")
-        buf.write("\7z\2\2\u00ce\u00d0\3\2\2\2\u00cf\u00d1\t\4\2\2\u00d0")
+        buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
+        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("\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")
+        buf.write("\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31")
+        buf.write("\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\33\3\33")
+        buf.write("\3\33\3\33\3\33\3\34\3\34\7\34\u00c8\n\34\f\34\16\34\u00cb")
+        buf.write("\13\34\3\35\5\35\u00ce\n\35\3\35\6\35\u00d1\n\35\r\35")
+        buf.write("\16\35\u00d2\3\36\3\36\3\36\3\36\6\36\u00d9\n\36\r\36")
+        buf.write("\16\36\u00da\3\37\3\37\3\37\7\37\u00e0\n\37\f\37\16\37")
+        buf.write("\u00e3\13\37\3 \3 \7 \u00e7\n \f \16 \u00ea\13 \3!\3!")
+        buf.write("\3!\3!\3\"\3\"\3\"\3\"\3\"\7\"\u00f5\n\"\f\"\16\"\u00f8")
+        buf.write("\13\"\3\"\3\"\3\"\3#\6#\u00fe\n#\r#\16#\u00ff\3#\3#\3")
+        buf.write("$\3$\3$\3$\7$\u0108\n$\f$\16$\u010b\13$\3$\3$\3%\3%\3")
+        buf.write("%\3%\7%\u0113\n%\f%\16%\u0116\13%\3%\3%\3%\3%\3%\4\u00f6")
+        buf.write("\u0114\2&\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25")
+        buf.write("\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+")
+        buf.write("\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E")
+        buf.write("$G%I&\3\2\t\4\2\f\f\17\17\4\2--//\5\2\62;CHch\5\2C\\a")
+        buf.write("ac|\7\2\60\60\62;C\\aac|\3\2\62;\5\2\13\f\17\17\"\"\u0125")
+        buf.write("\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13")
+        buf.write("\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3")
+        buf.write("\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2")
+        buf.write("\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2")
+        buf.write("%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2")
+        buf.write("\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67")
+        buf.write("\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2")
+        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%\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")
+        buf.write("\2\2\29\u00cd\3\2\2\2;\u00d4\3\2\2\2=\u00dc\3\2\2\2?\u00e4")
+        buf.write("\3\2\2\2A\u00eb\3\2\2\2C\u00ef\3\2\2\2E\u00fd\3\2\2\2")
+        buf.write("G\u0103\3\2\2\2I\u010e\3\2\2\2KL\7k\2\2LM\7o\2\2MN\7r")
+        buf.write("\2\2NO\7q\2\2OP\7t\2\2PQ\7v\2\2Q\4\3\2\2\2RS\7=\2\2S\6")
+        buf.write("\3\2\2\2TU\7o\2\2UV\7q\2\2VW\7f\2\2WX\7w\2\2XY\7n\2\2")
+        buf.write("YZ\7g\2\2Z\b\3\2\2\2[\\\7k\2\2\\]\7p\2\2]^\7v\2\2^_\7")
+        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("\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")
+        buf.write("\u0092\7k\2\2\u0092\u0093\7p\2\2\u0093\u0094\7v\2\2\u0094")
+        buf.write("\"\3\2\2\2\u0095\u0096\7t\2\2\u0096\u0097\7g\2\2\u0097")
+        buf.write("\u0098\7c\2\2\u0098\u0099\7n\2\2\u0099$\3\2\2\2\u009a")
+        buf.write("\u009b\7u\2\2\u009b\u009c\7v\2\2\u009c\u009d\7t\2\2\u009d")
+        buf.write("\u009e\7k\2\2\u009e\u009f\7p\2\2\u009f\u00a0\7i\2\2\u00a0")
+        buf.write("&\3\2\2\2\u00a1\u00a2\7x\2\2\u00a2\u00a3\7c\2\2\u00a3")
+        buf.write("\u00a4\7t\2\2\u00a4(\3\2\2\2\u00a5\u00a6\7n\2\2\u00a6")
+        buf.write("\u00a7\7k\2\2\u00a7\u00a8\7u\2\2\u00a8\u00a9\7v\2\2\u00a9")
+        buf.write("*\3\2\2\2\u00aa\u00ab\7>\2\2\u00ab,\3\2\2\2\u00ac\u00ad")
+        buf.write("\7@\2\2\u00ad.\3\2\2\2\u00ae\u00af\7o\2\2\u00af\u00b0")
+        buf.write("\7q\2\2\u00b0\u00b1\7f\2\2\u00b1\u00b2\7g\2\2\u00b2\u00b3")
+        buf.write("\7n\2\2\u00b3\60\3\2\2\2\u00b4\u00b5\7u\2\2\u00b5\u00b6")
+        buf.write("\7v\2\2\u00b6\u00b7\7t\2\2\u00b7\u00b8\7w\2\2\u00b8\u00b9")
+        buf.write("\7e\2\2\u00b9\u00ba\7v\2\2\u00ba\62\3\2\2\2\u00bb\u00bc")
+        buf.write("\7g\2\2\u00bc\u00bd\7p\2\2\u00bd\u00be\7w\2\2\u00be\u00bf")
+        buf.write("\7o\2\2\u00bf\64\3\2\2\2\u00c0\u00c1\7h\2\2\u00c1\u00c2")
+        buf.write("\7n\2\2\u00c2\u00c3\7c\2\2\u00c3\u00c4\7i\2\2\u00c4\66")
+        buf.write("\3\2\2\2\u00c5\u00c9\7B\2\2\u00c6\u00c8\n\2\2\2\u00c7")
+        buf.write("\u00c6\3\2\2\2\u00c8\u00cb\3\2\2\2\u00c9\u00c7\3\2\2\2")
+        buf.write("\u00c9\u00ca\3\2\2\2\u00ca8\3\2\2\2\u00cb\u00c9\3\2\2")
+        buf.write("\2\u00cc\u00ce\t\3\2\2\u00cd\u00cc\3\2\2\2\u00cd\u00ce")
+        buf.write("\3\2\2\2\u00ce\u00d0\3\2\2\2\u00cf\u00d1\4\62;\2\u00d0")
         buf.write("\u00cf\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d0\3\2\2\2")
-        buf.write("\u00d2\u00d3\3\2\2\2\u00d3:\3\2\2\2\u00d4\u00d5\7B\2\2")
-        buf.write("\u00d5\u00d9\t\5\2\2\u00d6\u00d8\t\6\2\2\u00d7\u00d6\3")
-        buf.write("\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da")
-        buf.write("\3\2\2\2\u00da<\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00e0")
-        buf.write("\t\5\2\2\u00dd\u00df\t\6\2\2\u00de\u00dd\3\2\2\2\u00df")
-        buf.write("\u00e2\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2")
-        buf.write("\u00e1>\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3\u00e4\t\7\2")
-        buf.write("\2\u00e4\u00e5\7\60\2\2\u00e5\u00e6\t\7\2\2\u00e6@\3\2")
-        buf.write("\2\2\u00e7\u00e8\7\61\2\2\u00e8\u00e9\7,\2\2\u00e9\u00ea")
-        buf.write("\7,\2\2\u00ea\u00ee\3\2\2\2\u00eb\u00ed\13\2\2\2\u00ec")
-        buf.write("\u00eb\3\2\2\2\u00ed\u00f0\3\2\2\2\u00ee\u00ef\3\2\2\2")
-        buf.write("\u00ee\u00ec\3\2\2\2\u00ef\u00f1\3\2\2\2\u00f0\u00ee\3")
-        buf.write("\2\2\2\u00f1\u00f2\7,\2\2\u00f2\u00f3\7\61\2\2\u00f3B")
-        buf.write("\3\2\2\2\u00f4\u00f6\t\b\2\2\u00f5\u00f4\3\2\2\2\u00f6")
-        buf.write("\u00f7\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f7\u00f8\3\2\2\2")
-        buf.write("\u00f8\u00f9\3\2\2\2\u00f9\u00fa\b\"\2\2\u00faD\3\2\2")
-        buf.write("\2\u00fb\u00fc\7\61\2\2\u00fc\u00fd\7\61\2\2\u00fd\u0101")
-        buf.write("\3\2\2\2\u00fe\u0100\n\2\2\2\u00ff\u00fe\3\2\2\2\u0100")
-        buf.write("\u0103\3\2\2\2\u0101\u00ff\3\2\2\2\u0101\u0102\3\2\2\2")
-        buf.write("\u0102\u0104\3\2\2\2\u0103\u0101\3\2\2\2\u0104\u0105\b")
-        buf.write("#\2\2\u0105F\3\2\2\2\u0106\u0107\7\61\2\2\u0107\u0108")
-        buf.write("\7,\2\2\u0108\u010c\3\2\2\2\u0109\u010b\13\2\2\2\u010a")
-        buf.write("\u0109\3\2\2\2\u010b\u010e\3\2\2\2\u010c\u010d\3\2\2\2")
-        buf.write("\u010c\u010a\3\2\2\2\u010d\u010f\3\2\2\2\u010e\u010c\3")
-        buf.write("\2\2\2\u010f\u0110\7,\2\2\u0110\u0111\7\61\2\2\u0111\u0112")
-        buf.write("\3\2\2\2\u0112\u0113\b$\2\2\u0113H\3\2\2\2\r\2\u00c1\u00c5")
-        buf.write("\u00ca\u00d2\u00d9\u00e0\u00ee\u00f7\u0101\u010c\3\b\2")
-        buf.write("\2")
+        buf.write("\u00d2\u00d3\3\2\2\2\u00d3:\3\2\2\2\u00d4\u00d5\7\62\2")
+        buf.write("\2\u00d5\u00d6\7z\2\2\u00d6\u00d8\3\2\2\2\u00d7\u00d9")
+        buf.write("\t\4\2\2\u00d8\u00d7\3\2\2\2\u00d9\u00da\3\2\2\2\u00da")
+        buf.write("\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db<\3\2\2\2\u00dc")
+        buf.write("\u00dd\7B\2\2\u00dd\u00e1\t\5\2\2\u00de\u00e0\t\6\2\2")
+        buf.write("\u00df\u00de\3\2\2\2\u00e0\u00e3\3\2\2\2\u00e1\u00df\3")
+        buf.write("\2\2\2\u00e1\u00e2\3\2\2\2\u00e2>\3\2\2\2\u00e3\u00e1")
+        buf.write("\3\2\2\2\u00e4\u00e8\t\5\2\2\u00e5\u00e7\t\6\2\2\u00e6")
+        buf.write("\u00e5\3\2\2\2\u00e7\u00ea\3\2\2\2\u00e8\u00e6\3\2\2\2")
+        buf.write("\u00e8\u00e9\3\2\2\2\u00e9@\3\2\2\2\u00ea\u00e8\3\2\2")
+        buf.write("\2\u00eb\u00ec\t\7\2\2\u00ec\u00ed\7\60\2\2\u00ed\u00ee")
+        buf.write("\t\7\2\2\u00eeB\3\2\2\2\u00ef\u00f0\7\61\2\2\u00f0\u00f1")
+        buf.write("\7,\2\2\u00f1\u00f2\7,\2\2\u00f2\u00f6\3\2\2\2\u00f3\u00f5")
+        buf.write("\13\2\2\2\u00f4\u00f3\3\2\2\2\u00f5\u00f8\3\2\2\2\u00f6")
+        buf.write("\u00f7\3\2\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00f9\3\2\2\2")
+        buf.write("\u00f8\u00f6\3\2\2\2\u00f9\u00fa\7,\2\2\u00fa\u00fb\7")
+        buf.write("\61\2\2\u00fbD\3\2\2\2\u00fc\u00fe\t\b\2\2\u00fd\u00fc")
+        buf.write("\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff\u00fd\3\2\2\2\u00ff")
+        buf.write("\u0100\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\b#\2\2")
+        buf.write("\u0102F\3\2\2\2\u0103\u0104\7\61\2\2\u0104\u0105\7\61")
+        buf.write("\2\2\u0105\u0109\3\2\2\2\u0106\u0108\n\2\2\2\u0107\u0106")
+        buf.write("\3\2\2\2\u0108\u010b\3\2\2\2\u0109\u0107\3\2\2\2\u0109")
+        buf.write("\u010a\3\2\2\2\u010a\u010c\3\2\2\2\u010b\u0109\3\2\2\2")
+        buf.write("\u010c\u010d\b$\2\2\u010dH\3\2\2\2\u010e\u010f\7\61\2")
+        buf.write("\2\u010f\u0110\7,\2\2\u0110\u0114\3\2\2\2\u0111\u0113")
+        buf.write("\13\2\2\2\u0112\u0111\3\2\2\2\u0113\u0116\3\2\2\2\u0114")
+        buf.write("\u0115\3\2\2\2\u0114\u0112\3\2\2\2\u0115\u0117\3\2\2\2")
+        buf.write("\u0116\u0114\3\2\2\2\u0117\u0118\7,\2\2\u0118\u0119\7")
+        buf.write("\61\2\2\u0119\u011a\3\2\2\2\u011a\u011b\b%\2\2\u011bJ")
+        buf.write("\3\2\2\2\r\2\u00c9\u00cd\u00d2\u00da\u00e1\u00e8\u00f6")
+        buf.write("\u00ff\u0109\u0114\3\b\2\2")
         return buf.getvalue()
 
 
@@ -155,24 +158,25 @@ class TLexer(Lexer):
     T__22 = 23
     T__23 = 24
     T__24 = 25
-    TAGLINE = 26
-    INTCONSTANT = 27
-    HEXCONSTANT = 28
-    TAGIDENTIFIER = 29
-    IDENTIFIER = 30
-    VERSION = 31
-    DOCCOMMENT = 32
-    WHITESPACE = 33
-    COMMENT = 34
-    MULTICOMM = 35
+    T__25 = 26
+    TAGLINE = 27
+    INTCONSTANT = 28
+    HEXCONSTANT = 29
+    TAGIDENTIFIER = 30
+    IDENTIFIER = 31
+    VERSION = 32
+    DOCCOMMENT = 33
+    WHITESPACE = 34
+    COMMENT = 35
+    MULTICOMM = 36
 
     modeNames = [ "DEFAULT_MODE" ]
 
     literalNames = [ "<INVALID>",
             "'import'", "';'", "'module'", "'interface'", "'{'", "'}'", 
-            "'void'", "'('", "')'", "'signal'", "'readonly'", "','", "'='", 
-            "'bool'", "'int'", "'real'", "'string'", "'var'", "'list'", 
-            "'<'", "'>'", "'model'", "'struct'", "'enum'", "'flag'" ]
+            "'void'", "'('", "')'", "'signal'", "'readonly'", "'const'", 
+            "','", "'='", "'bool'", "'int'", "'real'", "'string'", "'var'", 
+            "'list'", "'<'", "'>'", "'model'", "'struct'", "'enum'", "'flag'" ]
 
     symbolicNames = [ "<INVALID>",
             "TAGLINE", "INTCONSTANT", "HEXCONSTANT", "TAGIDENTIFIER", "IDENTIFIER", 
@@ -181,9 +185,10 @@ class TLexer(Lexer):
     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", "TAGLINE", 
-                  "INTCONSTANT", "HEXCONSTANT", "TAGIDENTIFIER", "IDENTIFIER", 
-                  "VERSION", "DOCCOMMENT", "WHITESPACE", "COMMENT", "MULTICOMM" ]
+                  "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", 
+                  "TAGLINE", "INTCONSTANT", "HEXCONSTANT", "TAGIDENTIFIER", 
+                  "IDENTIFIER", "VERSION", "DOCCOMMENT", "WHITESPACE", "COMMENT", 
+                  "MULTICOMM" ]
 
     grammarFileName = "T.g4"
 
diff --git a/qface/idl/parser/TLexer.tokens b/qface/idl/parser/TLexer.tokens
index 86bf74a..d9b477d 100644
--- a/qface/idl/parser/TLexer.tokens
+++ b/qface/idl/parser/TLexer.tokens
@@ -23,16 +23,17 @@ T__21=22
 T__22=23
 T__23=24
 T__24=25
-TAGLINE=26
-INTCONSTANT=27
-HEXCONSTANT=28
-TAGIDENTIFIER=29
-IDENTIFIER=30
-VERSION=31
-DOCCOMMENT=32
-WHITESPACE=33
-COMMENT=34
-MULTICOMM=35
+T__25=26
+TAGLINE=27
+INTCONSTANT=28
+HEXCONSTANT=29
+TAGIDENTIFIER=30
+IDENTIFIER=31
+VERSION=32
+DOCCOMMENT=33
+WHITESPACE=34
+COMMENT=35
+MULTICOMM=36
 'import'=1
 ';'=2
 'module'=3
@@ -44,17 +45,18 @@ MULTICOMM=35
 ')'=9
 'signal'=10
 'readonly'=11
-','=12
-'='=13
-'bool'=14
-'int'=15
-'real'=16
-'string'=17
-'var'=18
-'list'=19
-'<'=20
-'>'=21
-'model'=22
-'struct'=23
-'enum'=24
-'flag'=25
+'const'=12
+','=13
+'='=14
+'bool'=15
+'int'=16
+'real'=17
+'string'=18
+'var'=19
+'list'=20
+'<'=21
+'>'=22
+'model'=23
+'struct'=24
+'enum'=25
+'flag'=26
diff --git a/qface/idl/parser/TListener.py b/qface/idl/parser/TListener.py
index 07d41ad..2899519 100644
--- a/qface/idl/parser/TListener.py
+++ b/qface/idl/parser/TListener.py
@@ -98,6 +98,15 @@ class TListener(ParseTreeListener):
         pass
 
 
+    # Enter a parse tree produced by TParser#propertyModifierSymbol.
+    def enterPropertyModifierSymbol(self, ctx:TParser.PropertyModifierSymbolContext):
+        pass
+
+    # Exit a parse tree produced by TParser#propertyModifierSymbol.
+    def exitPropertyModifierSymbol(self, ctx:TParser.PropertyModifierSymbolContext):
+        pass
+
+
     # Enter a parse tree produced by TParser#operationParameterSymbol.
     def enterOperationParameterSymbol(self, ctx:TParser.OperationParameterSymbolContext):
         pass
diff --git a/qface/idl/parser/TParser.py b/qface/idl/parser/TParser.py
index 15eadd6..770c655 100644
--- a/qface/idl/parser/TParser.py
+++ b/qface/idl/parser/TParser.py
@@ -5,147 +5,150 @@ from io import StringIO
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3%")
-        buf.write("\u0131\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("\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("\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\3\2\3\2\7\2\65\n\2\f\2\16\28\13\2\3\3\3\3\7\3<\n")
-        buf.write("\3\f\3\16\3?\13\3\3\4\3\4\3\4\3\4\5\4E\n\4\3\5\5\5H\n")
-        buf.write("\5\3\5\7\5K\n\5\f\5\16\5N\13\5\3\5\3\5\3\5\3\5\5\5T\n")
-        buf.write("\5\3\6\3\6\3\6\5\6Y\n\6\3\7\5\7\\\n\7\3\7\7\7_\n\7\f\7")
-        buf.write("\16\7b\13\7\3\7\3\7\3\7\3\7\7\7h\n\7\f\7\16\7k\13\7\3")
-        buf.write("\7\3\7\5\7o\n\7\3\b\3\b\3\b\5\bt\n\b\3\t\5\tw\n\t\3\t")
-        buf.write("\7\tz\n\t\f\t\16\t}\13\t\3\t\3\t\5\t\u0081\n\t\3\t\3\t")
-        buf.write("\3\t\7\t\u0086\n\t\f\t\16\t\u0089\13\t\3\t\3\t\5\t\u008d")
-        buf.write("\n\t\3\n\5\n\u0090\n\n\3\n\7\n\u0093\n\n\f\n\16\n\u0096")
-        buf.write("\13\n\3\n\3\n\3\n\3\n\7\n\u009c\n\n\f\n\16\n\u009f\13")
-        buf.write("\n\3\n\3\n\5\n\u00a3\n\n\3\13\5\13\u00a6\n\13\3\13\7\13")
-        buf.write("\u00a9\n\13\f\13\16\13\u00ac\13\13\3\13\5\13\u00af\n\13")
-        buf.write("\3\13\3\13\3\13\5\13\u00b4\n\13\3\f\3\f\3\f\5\f\u00b9")
-        buf.write("\n\f\3\r\3\r\3\16\3\16\3\16\5\16\u00c0\n\16\3\16\5\16")
-        buf.write("\u00c3\n\16\3\17\3\17\3\17\3\17\5\17\u00c9\n\17\3\20\3")
-        buf.write("\20\3\21\3\21\3\21\3\21\3\21\5\21\u00d2\n\21\3\22\3\22")
-        buf.write("\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\24\5\24\u00df")
-        buf.write("\n\24\3\24\7\24\u00e2\n\24\f\24\16\24\u00e5\13\24\3\24")
-        buf.write("\3\24\3\24\3\24\7\24\u00eb\n\24\f\24\16\24\u00ee\13\24")
-        buf.write("\3\24\3\24\5\24\u00f2\n\24\3\25\5\25\u00f5\n\25\3\25\7")
-        buf.write("\25\u00f8\n\25\f\25\16\25\u00fb\13\25\3\25\3\25\3\25\5")
-        buf.write("\25\u0100\n\25\3\26\5\26\u0103\n\26\3\26\7\26\u0106\n")
-        buf.write("\26\f\26\16\26\u0109\13\26\3\26\3\26\3\26\3\26\7\26\u010f")
-        buf.write("\n\26\f\26\16\26\u0112\13\26\3\26\3\26\5\26\u0116\n\26")
-        buf.write("\3\27\3\27\5\27\u011a\n\27\3\30\5\30\u011d\n\30\3\30\7")
-        buf.write("\30\u0120\n\30\f\30\16\30\u0123\13\30\3\30\3\30\3\30\5")
-        buf.write("\30\u0128\n\30\3\30\5\30\u012b\n\30\3\31\3\31\5\31\u012f")
-        buf.write("\n\31\3\31\2\2\32\2\4\6\b\n\f\16\20\22\24\26\30\32\34")
-        buf.write("\36 \"$&(*,.\60\2\2\u014e\2\62\3\2\2\2\49\3\2\2\2\6@\3")
-        buf.write("\2\2\2\bG\3\2\2\2\nX\3\2\2\2\f[\3\2\2\2\16s\3\2\2\2\20")
-        buf.write("v\3\2\2\2\22\u008f\3\2\2\2\24\u00a5\3\2\2\2\26\u00b5\3")
-        buf.write("\2\2\2\30\u00ba\3\2\2\2\32\u00bc\3\2\2\2\34\u00c8\3\2")
-        buf.write("\2\2\36\u00ca\3\2\2\2 \u00d1\3\2\2\2\"\u00d3\3\2\2\2$")
-        buf.write("\u00d8\3\2\2\2&\u00de\3\2\2\2(\u00f4\3\2\2\2*\u0102\3")
-        buf.write("\2\2\2,\u0119\3\2\2\2.\u011c\3\2\2\2\60\u012e\3\2\2\2")
-        buf.write("\62\66\5\4\3\2\63\65\5\n\6\2\64\63\3\2\2\2\658\3\2\2\2")
-        buf.write("\66\64\3\2\2\2\66\67\3\2\2\2\67\3\3\2\2\28\66\3\2\2\2")
-        buf.write("9=\5\b\5\2:<\5\6\4\2;:\3\2\2\2<?\3\2\2\2=;\3\2\2\2=>\3")
-        buf.write("\2\2\2>\5\3\2\2\2?=\3\2\2\2@A\7\3\2\2AB\7 \2\2BD\7!\2")
-        buf.write("\2CE\7\4\2\2DC\3\2\2\2DE\3\2\2\2E\7\3\2\2\2FH\7\"\2\2")
-        buf.write("GF\3\2\2\2GH\3\2\2\2HL\3\2\2\2IK\5\30\r\2JI\3\2\2\2KN")
-        buf.write("\3\2\2\2LJ\3\2\2\2LM\3\2\2\2MO\3\2\2\2NL\3\2\2\2OP\7\5")
-        buf.write("\2\2PQ\7 \2\2QS\7!\2\2RT\7\4\2\2SR\3\2\2\2ST\3\2\2\2T")
-        buf.write("\t\3\2\2\2UY\5\f\7\2VY\5&\24\2WY\5*\26\2XU\3\2\2\2XV\3")
-        buf.write("\2\2\2XW\3\2\2\2Y\13\3\2\2\2Z\\\7\"\2\2[Z\3\2\2\2[\\\3")
-        buf.write("\2\2\2\\`\3\2\2\2]_\5\30\r\2^]\3\2\2\2_b\3\2\2\2`^\3\2")
-        buf.write("\2\2`a\3\2\2\2ac\3\2\2\2b`\3\2\2\2cd\7\6\2\2de\7 \2\2")
-        buf.write("ei\7\7\2\2fh\5\16\b\2gf\3\2\2\2hk\3\2\2\2ig\3\2\2\2ij")
-        buf.write("\3\2\2\2jl\3\2\2\2ki\3\2\2\2ln\7\b\2\2mo\7\4\2\2nm\3\2")
-        buf.write("\2\2no\3\2\2\2o\r\3\2\2\2pt\5\20\t\2qt\5\24\13\2rt\5\22")
-        buf.write("\n\2sp\3\2\2\2sq\3\2\2\2sr\3\2\2\2t\17\3\2\2\2uw\7\"\2")
-        buf.write("\2vu\3\2\2\2vw\3\2\2\2w{\3\2\2\2xz\5\30\r\2yx\3\2\2\2")
-        buf.write("z}\3\2\2\2{y\3\2\2\2{|\3\2\2\2|\u0080\3\2\2\2}{\3\2\2")
-        buf.write("\2~\u0081\5\34\17\2\177\u0081\7\t\2\2\u0080~\3\2\2\2\u0080")
-        buf.write("\177\3\2\2\2\u0081\u0082\3\2\2\2\u0082\u0083\7 \2\2\u0083")
-        buf.write("\u0087\7\n\2\2\u0084\u0086\5\26\f\2\u0085\u0084\3\2\2")
-        buf.write("\2\u0086\u0089\3\2\2\2\u0087\u0085\3\2\2\2\u0087\u0088")
-        buf.write("\3\2\2\2\u0088\u008a\3\2\2\2\u0089\u0087\3\2\2\2\u008a")
-        buf.write("\u008c\7\13\2\2\u008b\u008d\7\4\2\2\u008c\u008b\3\2\2")
-        buf.write("\2\u008c\u008d\3\2\2\2\u008d\21\3\2\2\2\u008e\u0090\7")
-        buf.write("\"\2\2\u008f\u008e\3\2\2\2\u008f\u0090\3\2\2\2\u0090\u0094")
-        buf.write("\3\2\2\2\u0091\u0093\5\30\r\2\u0092\u0091\3\2\2\2\u0093")
-        buf.write("\u0096\3\2\2\2\u0094\u0092\3\2\2\2\u0094\u0095\3\2\2\2")
-        buf.write("\u0095\u0097\3\2\2\2\u0096\u0094\3\2\2\2\u0097\u0098\7")
-        buf.write("\f\2\2\u0098\u0099\7 \2\2\u0099\u009d\7\n\2\2\u009a\u009c")
-        buf.write("\5\26\f\2\u009b\u009a\3\2\2\2\u009c\u009f\3\2\2\2\u009d")
-        buf.write("\u009b\3\2\2\2\u009d\u009e\3\2\2\2\u009e\u00a0\3\2\2\2")
-        buf.write("\u009f\u009d\3\2\2\2\u00a0\u00a2\7\13\2\2\u00a1\u00a3")
-        buf.write("\7\4\2\2\u00a2\u00a1\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3")
-        buf.write("\23\3\2\2\2\u00a4\u00a6\7\"\2\2\u00a5\u00a4\3\2\2\2\u00a5")
-        buf.write("\u00a6\3\2\2\2\u00a6\u00aa\3\2\2\2\u00a7\u00a9\5\30\r")
-        buf.write("\2\u00a8\u00a7\3\2\2\2\u00a9\u00ac\3\2\2\2\u00aa\u00a8")
-        buf.write("\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\u00ae\3\2\2\2\u00ac")
-        buf.write("\u00aa\3\2\2\2\u00ad\u00af\7\r\2\2\u00ae\u00ad\3\2\2\2")
-        buf.write("\u00ae\u00af\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1\5")
-        buf.write("\34\17\2\u00b1\u00b3\7 \2\2\u00b2\u00b4\7\4\2\2\u00b3")
-        buf.write("\u00b2\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\25\3\2\2\2\u00b5")
-        buf.write("\u00b6\5\34\17\2\u00b6\u00b8\7 \2\2\u00b7\u00b9\7\16\2")
-        buf.write("\2\u00b8\u00b7\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\27\3")
-        buf.write("\2\2\2\u00ba\u00bb\7\34\2\2\u00bb\31\3\2\2\2\u00bc\u00bf")
-        buf.write("\7 \2\2\u00bd\u00be\7\17\2\2\u00be\u00c0\7 \2\2\u00bf")
-        buf.write("\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c2\3\2\2\2")
-        buf.write("\u00c1\u00c3\7\16\2\2\u00c2\u00c1\3\2\2\2\u00c2\u00c3")
-        buf.write("\3\2\2\2\u00c3\33\3\2\2\2\u00c4\u00c9\5 \21\2\u00c5\u00c9")
-        buf.write("\5\36\20\2\u00c6\u00c9\5\"\22\2\u00c7\u00c9\5$\23\2\u00c8")
-        buf.write("\u00c4\3\2\2\2\u00c8\u00c5\3\2\2\2\u00c8\u00c6\3\2\2\2")
-        buf.write("\u00c8\u00c7\3\2\2\2\u00c9\35\3\2\2\2\u00ca\u00cb\7 \2")
-        buf.write("\2\u00cb\37\3\2\2\2\u00cc\u00d2\7\20\2\2\u00cd\u00d2\7")
-        buf.write("\21\2\2\u00ce\u00d2\7\22\2\2\u00cf\u00d2\7\23\2\2\u00d0")
-        buf.write("\u00d2\7\24\2\2\u00d1\u00cc\3\2\2\2\u00d1\u00cd\3\2\2")
-        buf.write("\2\u00d1\u00ce\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1\u00d0")
-        buf.write("\3\2\2\2\u00d2!\3\2\2\2\u00d3\u00d4\7\25\2\2\u00d4\u00d5")
-        buf.write("\7\26\2\2\u00d5\u00d6\5\34\17\2\u00d6\u00d7\7\27\2\2\u00d7")
-        buf.write("#\3\2\2\2\u00d8\u00d9\7\30\2\2\u00d9\u00da\7\26\2\2\u00da")
-        buf.write("\u00db\5\34\17\2\u00db\u00dc\7\27\2\2\u00dc%\3\2\2\2\u00dd")
-        buf.write("\u00df\7\"\2\2\u00de\u00dd\3\2\2\2\u00de\u00df\3\2\2\2")
-        buf.write("\u00df\u00e3\3\2\2\2\u00e0\u00e2\5\30\r\2\u00e1\u00e0")
-        buf.write("\3\2\2\2\u00e2\u00e5\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e3")
-        buf.write("\u00e4\3\2\2\2\u00e4\u00e6\3\2\2\2\u00e5\u00e3\3\2\2\2")
-        buf.write("\u00e6\u00e7\7\31\2\2\u00e7\u00e8\7 \2\2\u00e8\u00ec\7")
-        buf.write("\7\2\2\u00e9\u00eb\5(\25\2\u00ea\u00e9\3\2\2\2\u00eb\u00ee")
-        buf.write("\3\2\2\2\u00ec\u00ea\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed")
-        buf.write("\u00ef\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ef\u00f1\7\b\2\2")
-        buf.write("\u00f0\u00f2\7\4\2\2\u00f1\u00f0\3\2\2\2\u00f1\u00f2\3")
-        buf.write("\2\2\2\u00f2\'\3\2\2\2\u00f3\u00f5\7\"\2\2\u00f4\u00f3")
-        buf.write("\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5\u00f9\3\2\2\2\u00f6")
-        buf.write("\u00f8\5\30\r\2\u00f7\u00f6\3\2\2\2\u00f8\u00fb\3\2\2")
-        buf.write("\2\u00f9\u00f7\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fc")
-        buf.write("\3\2\2\2\u00fb\u00f9\3\2\2\2\u00fc\u00fd\5\34\17\2\u00fd")
-        buf.write("\u00ff\7 \2\2\u00fe\u0100\7\4\2\2\u00ff\u00fe\3\2\2\2")
-        buf.write("\u00ff\u0100\3\2\2\2\u0100)\3\2\2\2\u0101\u0103\7\"\2")
-        buf.write("\2\u0102\u0101\3\2\2\2\u0102\u0103\3\2\2\2\u0103\u0107")
-        buf.write("\3\2\2\2\u0104\u0106\5\30\r\2\u0105\u0104\3\2\2\2\u0106")
-        buf.write("\u0109\3\2\2\2\u0107\u0105\3\2\2\2\u0107\u0108\3\2\2\2")
-        buf.write("\u0108\u010a\3\2\2\2\u0109\u0107\3\2\2\2\u010a\u010b\5")
-        buf.write(",\27\2\u010b\u010c\7 \2\2\u010c\u0110\7\7\2\2\u010d\u010f")
-        buf.write("\5.\30\2\u010e\u010d\3\2\2\2\u010f\u0112\3\2\2\2\u0110")
-        buf.write("\u010e\3\2\2\2\u0110\u0111\3\2\2\2\u0111\u0113\3\2\2\2")
-        buf.write("\u0112\u0110\3\2\2\2\u0113\u0115\7\b\2\2\u0114\u0116\7")
-        buf.write("\4\2\2\u0115\u0114\3\2\2\2\u0115\u0116\3\2\2\2\u0116+")
-        buf.write("\3\2\2\2\u0117\u011a\7\32\2\2\u0118\u011a\7\33\2\2\u0119")
-        buf.write("\u0117\3\2\2\2\u0119\u0118\3\2\2\2\u011a-\3\2\2\2\u011b")
-        buf.write("\u011d\7\"\2\2\u011c\u011b\3\2\2\2\u011c\u011d\3\2\2\2")
-        buf.write("\u011d\u0121\3\2\2\2\u011e\u0120\5\30\r\2\u011f\u011e")
-        buf.write("\3\2\2\2\u0120\u0123\3\2\2\2\u0121\u011f\3\2\2\2\u0121")
-        buf.write("\u0122\3\2\2\2\u0122\u0124\3\2\2\2\u0123\u0121\3\2\2\2")
-        buf.write("\u0124\u0127\7 \2\2\u0125\u0126\7\17\2\2\u0126\u0128\5")
-        buf.write("\60\31\2\u0127\u0125\3\2\2\2\u0127\u0128\3\2\2\2\u0128")
-        buf.write("\u012a\3\2\2\2\u0129\u012b\7\16\2\2\u012a\u0129\3\2\2")
-        buf.write("\2\u012a\u012b\3\2\2\2\u012b/\3\2\2\2\u012c\u012f\7\35")
-        buf.write("\2\2\u012d\u012f\7\36\2\2\u012e\u012c\3\2\2\2\u012e\u012d")
-        buf.write("\3\2\2\2\u012f\61\3\2\2\2\61\66=DGLSX[`insv{\u0080\u0087")
-        buf.write("\u008c\u008f\u0094\u009d\u00a2\u00a5\u00aa\u00ae\u00b3")
-        buf.write("\u00b8\u00bf\u00c2\u00c8\u00d1\u00de\u00e3\u00ec\u00f1")
-        buf.write("\u00f4\u00f9\u00ff\u0102\u0107\u0110\u0115\u0119\u011c")
-        buf.write("\u0121\u0127\u012a\u012e")
+        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")
         return buf.getvalue()
 
 
@@ -161,9 +164,9 @@ class TParser ( Parser ):
 
     literalNames = [ "<INVALID>", "'import'", "';'", "'module'", "'interface'", 
                      "'{'", "'}'", "'void'", "'('", "')'", "'signal'", "'readonly'", 
-                     "','", "'='", "'bool'", "'int'", "'real'", "'string'", 
-                     "'var'", "'list'", "'<'", "'>'", "'model'", "'struct'", 
-                     "'enum'", "'flag'" ]
+                     "'const'", "','", "'='", "'bool'", "'int'", "'real'", 
+                     "'string'", "'var'", "'list'", "'<'", "'>'", "'model'", 
+                     "'struct'", "'enum'", "'flag'" ]
 
     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
@@ -171,9 +174,10 @@ class TParser ( Parser ):
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "<INVALID>", "TAGLINE", "INTCONSTANT", 
-                      "HEXCONSTANT", "TAGIDENTIFIER", "IDENTIFIER", "VERSION", 
-                      "DOCCOMMENT", "WHITESPACE", "COMMENT", "MULTICOMM" ]
+                      "<INVALID>", "<INVALID>", "<INVALID>", "TAGLINE", 
+                      "INTCONSTANT", "HEXCONSTANT", "TAGIDENTIFIER", "IDENTIFIER", 
+                      "VERSION", "DOCCOMMENT", "WHITESPACE", "COMMENT", 
+                      "MULTICOMM" ]
 
     RULE_documentSymbol = 0
     RULE_headerSymbol = 1
@@ -185,28 +189,29 @@ class TParser ( Parser ):
     RULE_operationSymbol = 7
     RULE_signalSymbol = 8
     RULE_propertySymbol = 9
-    RULE_operationParameterSymbol = 10
-    RULE_tagSymbol = 11
-    RULE_tagAttributeSymbol = 12
-    RULE_typeSymbol = 13
-    RULE_complexTypeSymbol = 14
-    RULE_primitiveTypeSymbol = 15
-    RULE_listTypeSymbol = 16
-    RULE_modelTypeSymbol = 17
-    RULE_structSymbol = 18
-    RULE_structFieldSymbol = 19
-    RULE_enumSymbol = 20
-    RULE_enumTypeSymbol = 21
-    RULE_enumMemberSymbol = 22
-    RULE_intSymbol = 23
+    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
 
     ruleNames =  [ "documentSymbol", "headerSymbol", "importSymbol", "moduleSymbol", 
                    "definitionSymbol", "interfaceSymbol", "interfaceMemberSymbol", 
                    "operationSymbol", "signalSymbol", "propertySymbol", 
-                   "operationParameterSymbol", "tagSymbol", "tagAttributeSymbol", 
-                   "typeSymbol", "complexTypeSymbol", "primitiveTypeSymbol", 
-                   "listTypeSymbol", "modelTypeSymbol", "structSymbol", 
-                   "structFieldSymbol", "enumSymbol", "enumTypeSymbol", 
+                   "propertyModifierSymbol", "operationParameterSymbol", 
+                   "tagSymbol", "tagAttributeSymbol", "typeSymbol", "complexTypeSymbol", 
+                   "primitiveTypeSymbol", "listTypeSymbol", "modelTypeSymbol", 
+                   "structSymbol", "structFieldSymbol", "enumSymbol", "enumTypeSymbol", 
                    "enumMemberSymbol", "intSymbol" ]
 
     EOF = Token.EOF
@@ -235,16 +240,17 @@ class TParser ( Parser ):
     T__22=23
     T__23=24
     T__24=25
-    TAGLINE=26
-    INTCONSTANT=27
-    HEXCONSTANT=28
-    TAGIDENTIFIER=29
-    IDENTIFIER=30
-    VERSION=31
-    DOCCOMMENT=32
-    WHITESPACE=33
-    COMMENT=34
-    MULTICOMM=35
+    T__25=26
+    TAGLINE=27
+    INTCONSTANT=28
+    HEXCONSTANT=29
+    TAGIDENTIFIER=30
+    IDENTIFIER=31
+    VERSION=32
+    DOCCOMMENT=33
+    WHITESPACE=34
+    COMMENT=35
+    MULTICOMM=36
 
     def __init__(self, input:TokenStream):
         super().__init__(input)
@@ -298,15 +304,15 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 48
+            self.state = 50
             self.headerSymbol()
-            self.state = 52
+            self.state = 54
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__3) | (1 << TParser.T__22) | (1 << TParser.T__23) | (1 << TParser.T__24) | (1 << TParser.TAGLINE) | (1 << TParser.DOCCOMMENT))) != 0):
-                self.state = 49
+            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.definitionSymbol()
-                self.state = 54
+                self.state = 56
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -362,15 +368,15 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 55
+            self.state = 57
             self.moduleSymbol()
-            self.state = 59
+            self.state = 61
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.T__0:
-                self.state = 56
+                self.state = 58
                 self.importSymbol()
-                self.state = 61
+                self.state = 63
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -423,17 +429,17 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 62
+            self.state = 64
             self.match(TParser.T__0)
-            self.state = 63
+            self.state = 65
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 64
-            localctx.version = self.match(TParser.VERSION)
             self.state = 66
+            localctx.version = self.match(TParser.VERSION)
+            self.state = 68
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 65
+                self.state = 67
                 self.match(TParser.T__1)
 
 
@@ -497,35 +503,35 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 69
+            self.state = 71
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 68
+                self.state = 70
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 74
+            self.state = 76
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 71
+                self.state = 73
                 self.tagSymbol()
-                self.state = 76
+                self.state = 78
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 77
+            self.state = 79
             self.match(TParser.T__2)
-            self.state = 78
+            self.state = 80
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 79
-            localctx.version = self.match(TParser.VERSION)
             self.state = 81
+            localctx.version = self.match(TParser.VERSION)
+            self.state = 83
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 80
+                self.state = 82
                 self.match(TParser.T__1)
 
 
@@ -580,24 +586,24 @@ class TParser ( Parser ):
         localctx = TParser.DefinitionSymbolContext(self, self._ctx, self.state)
         self.enterRule(localctx, 8, self.RULE_definitionSymbol)
         try:
-            self.state = 86
+            self.state = 88
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 83
+                self.state = 85
                 self.interfaceSymbol()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 84
+                self.state = 86
                 self.structSymbol()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 85
+                self.state = 87
                 self.enumSymbol()
                 pass
 
@@ -665,47 +671,47 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 89
+            self.state = 91
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 88
+                self.state = 90
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 94
+            self.state = 96
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 91
+                self.state = 93
                 self.tagSymbol()
-                self.state = 96
+                self.state = 98
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 97
+            self.state = 99
             self.match(TParser.T__3)
-            self.state = 98
+            self.state = 100
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 99
+            self.state = 101
             self.match(TParser.T__4)
-            self.state = 103
+            self.state = 105
             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__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__21) | (1 << TParser.TAGLINE) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
-                self.state = 100
+            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.interfaceMemberSymbol()
-                self.state = 105
+                self.state = 107
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 106
-            self.match(TParser.T__5)
             self.state = 108
+            self.match(TParser.T__5)
+            self.state = 110
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 107
+                self.state = 109
                 self.match(TParser.T__1)
 
 
@@ -760,24 +766,24 @@ class TParser ( Parser ):
         localctx = TParser.InterfaceMemberSymbolContext(self, self._ctx, self.state)
         self.enterRule(localctx, 12, self.RULE_interfaceMemberSymbol)
         try:
-            self.state = 113
+            self.state = 115
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 110
+                self.state = 112
                 self.operationSymbol()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 111
+                self.state = 113
                 self.propertySymbol()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 112
+                self.state = 114
                 self.signalSymbol()
                 pass
 
@@ -849,59 +855,59 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 116
+            self.state = 118
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 115
+                self.state = 117
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 121
+            self.state = 123
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 118
+                self.state = 120
                 self.tagSymbol()
-                self.state = 123
+                self.state = 125
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 126
+            self.state = 128
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [TParser.T__13, TParser.T__14, TParser.T__15, TParser.T__16, TParser.T__17, TParser.T__18, TParser.T__21, TParser.IDENTIFIER]:
-                self.state = 124
+            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.typeSymbol()
                 pass
             elif token in [TParser.T__6]:
-                self.state = 125
+                self.state = 127
                 self.match(TParser.T__6)
                 pass
             else:
                 raise NoViableAltException(self)
 
-            self.state = 128
+            self.state = 130
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 129
+            self.state = 131
             self.match(TParser.T__7)
-            self.state = 133
+            self.state = 135
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__21) | (1 << TParser.IDENTIFIER))) != 0):
-                self.state = 130
+            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.operationParameterSymbol()
-                self.state = 135
+                self.state = 137
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 136
-            self.match(TParser.T__8)
             self.state = 138
+            self.match(TParser.T__8)
+            self.state = 140
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 137
+                self.state = 139
                 self.match(TParser.T__1)
 
 
@@ -968,47 +974,47 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 141
+            self.state = 143
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 140
+                self.state = 142
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 146
+            self.state = 148
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 143
+                self.state = 145
                 self.tagSymbol()
-                self.state = 148
+                self.state = 150
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 149
+            self.state = 151
             self.match(TParser.T__9)
-            self.state = 150
+            self.state = 152
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 151
+            self.state = 153
             self.match(TParser.T__7)
-            self.state = 155
+            self.state = 157
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__21) | (1 << TParser.IDENTIFIER))) != 0):
-                self.state = 152
+            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.operationParameterSymbol()
-                self.state = 157
+                self.state = 159
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 158
-            self.match(TParser.T__8)
             self.state = 160
+            self.match(TParser.T__8)
+            self.state = 162
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 159
+                self.state = 161
                 self.match(TParser.T__1)
 
 
@@ -1026,7 +1032,6 @@ class TParser ( Parser ):
             super().__init__(parent, invokingState)
             self.parser = parser
             self.comment = None # Token
-            self.isReadOnly = None # Token
             self.name = None # Token
 
         def typeSymbol(self):
@@ -1043,6 +1048,10 @@ class TParser ( Parser ):
                 return self.getTypedRuleContext(TParser.TagSymbolContext,i)
 
 
+        def propertyModifierSymbol(self):
+            return self.getTypedRuleContext(TParser.PropertyModifierSymbolContext,0)
+
+
         def DOCCOMMENT(self):
             return self.getToken(TParser.DOCCOMMENT, 0)
 
@@ -1073,41 +1082,41 @@ class TParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 163
+            self.state = 165
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 162
+                self.state = 164
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 168
+            self.state = 170
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 165
+                self.state = 167
                 self.tagSymbol()
-                self.state = 170
+                self.state = 172
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 172
+            self.state = 174
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==TParser.T__10:
-                self.state = 171
-                localctx.isReadOnly = self.match(TParser.T__10)
+            if _la==TParser.T__10 or _la==TParser.T__11:
+                self.state = 173
+                self.propertyModifierSymbol()
 
 
-            self.state = 174
+            self.state = 176
             self.typeSymbol()
-            self.state = 175
-            localctx.name = self.match(TParser.IDENTIFIER)
             self.state = 177
+            localctx.name = self.match(TParser.IDENTIFIER)
+            self.state = 179
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 176
+                self.state = 178
                 self.match(TParser.T__1)
 
 
@@ -1119,6 +1128,64 @@ class TParser ( Parser ):
             self.exitRule()
         return localctx
 
+    class PropertyModifierSymbolContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+            self.is_readonly = None # Token
+            self.is_const = None # Token
+
+
+        def getRuleIndex(self):
+            return TParser.RULE_propertyModifierSymbol
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPropertyModifierSymbol" ):
+                listener.enterPropertyModifierSymbol(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            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)
+        try:
+            self.state = 183
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [TParser.T__10]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 181
+                localctx.is_readonly = self.match(TParser.T__10)
+                pass
+            elif token in [TParser.T__11]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 182
+                localctx.is_const = self.match(TParser.T__11)
+                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 OperationParameterSymbolContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -1156,20 +1223,20 @@ class TParser ( Parser ):
     def operationParameterSymbol(self):
 
         localctx = TParser.OperationParameterSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 20, self.RULE_operationParameterSymbol)
+        self.enterRule(localctx, 22, self.RULE_operationParameterSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 179
+            self.state = 185
             self.typeSymbol()
-            self.state = 180
+            self.state = 186
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 182
+            self.state = 188
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==TParser.T__11:
-                self.state = 181
-                self.match(TParser.T__11)
+            if _la==TParser.T__12:
+                self.state = 187
+                self.match(TParser.T__12)
 
 
         except RecognitionException as re:
@@ -1213,10 +1280,10 @@ class TParser ( Parser ):
     def tagSymbol(self):
 
         localctx = TParser.TagSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 22, self.RULE_tagSymbol)
+        self.enterRule(localctx, 24, self.RULE_tagSymbol)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 184
+            self.state = 190
             localctx.line = self.match(TParser.TAGLINE)
         except RecognitionException as re:
             localctx.exception = re
@@ -1263,28 +1330,28 @@ class TParser ( Parser ):
     def tagAttributeSymbol(self):
 
         localctx = TParser.TagAttributeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 24, self.RULE_tagAttributeSymbol)
+        self.enterRule(localctx, 26, self.RULE_tagAttributeSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 186
+            self.state = 192
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 189
+            self.state = 195
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==TParser.T__12:
-                self.state = 187
-                self.match(TParser.T__12)
-                self.state = 188
+            if _la==TParser.T__13:
+                self.state = 193
+                self.match(TParser.T__13)
+                self.state = 194
                 localctx.value = self.match(TParser.IDENTIFIER)
 
 
-            self.state = 192
+            self.state = 198
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==TParser.T__11:
-                self.state = 191
-                self.match(TParser.T__11)
+            if _la==TParser.T__12:
+                self.state = 197
+                self.match(TParser.T__12)
 
 
         except RecognitionException as re:
@@ -1340,29 +1407,29 @@ class TParser ( Parser ):
     def typeSymbol(self):
 
         localctx = TParser.TypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 26, self.RULE_typeSymbol)
+        self.enterRule(localctx, 28, self.RULE_typeSymbol)
         try:
-            self.state = 198
+            self.state = 204
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [TParser.T__13, TParser.T__14, TParser.T__15, TParser.T__16, TParser.T__17]:
+            if token in [TParser.T__14, TParser.T__15, TParser.T__16, TParser.T__17, TParser.T__18]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 194
+                self.state = 200
                 self.primitiveTypeSymbol()
                 pass
             elif token in [TParser.IDENTIFIER]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 195
+                self.state = 201
                 self.complexTypeSymbol()
                 pass
-            elif token in [TParser.T__18]:
+            elif token in [TParser.T__19]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 196
+                self.state = 202
                 self.listTypeSymbol()
                 pass
-            elif token in [TParser.T__21]:
+            elif token in [TParser.T__22]:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 197
+                self.state = 203
                 self.modelTypeSymbol()
                 pass
             else:
@@ -1409,10 +1476,10 @@ class TParser ( Parser ):
     def complexTypeSymbol(self):
 
         localctx = TParser.ComplexTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 28, self.RULE_complexTypeSymbol)
+        self.enterRule(localctx, 30, self.RULE_complexTypeSymbol)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 200
+            self.state = 206
             localctx.name = self.match(TParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -1453,36 +1520,36 @@ class TParser ( Parser ):
     def primitiveTypeSymbol(self):
 
         localctx = TParser.PrimitiveTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 30, self.RULE_primitiveTypeSymbol)
+        self.enterRule(localctx, 32, self.RULE_primitiveTypeSymbol)
         try:
-            self.state = 207
+            self.state = 213
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [TParser.T__13]:
+            if token in [TParser.T__14]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 202
-                localctx.name = self.match(TParser.T__13)
-                pass
-            elif token in [TParser.T__14]:
-                self.enterOuterAlt(localctx, 2)
-                self.state = 203
+                self.state = 208
                 localctx.name = self.match(TParser.T__14)
                 pass
             elif token in [TParser.T__15]:
-                self.enterOuterAlt(localctx, 3)
-                self.state = 204
+                self.enterOuterAlt(localctx, 2)
+                self.state = 209
                 localctx.name = self.match(TParser.T__15)
                 pass
             elif token in [TParser.T__16]:
-                self.enterOuterAlt(localctx, 4)
-                self.state = 205
+                self.enterOuterAlt(localctx, 3)
+                self.state = 210
                 localctx.name = self.match(TParser.T__16)
                 pass
             elif token in [TParser.T__17]:
-                self.enterOuterAlt(localctx, 5)
-                self.state = 206
+                self.enterOuterAlt(localctx, 4)
+                self.state = 211
                 localctx.name = self.match(TParser.T__17)
                 pass
+            elif token in [TParser.T__18]:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 212
+                localctx.name = self.match(TParser.T__18)
+                pass
             else:
                 raise NoViableAltException(self)
 
@@ -1528,17 +1595,17 @@ class TParser ( Parser ):
     def listTypeSymbol(self):
 
         localctx = TParser.ListTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 32, self.RULE_listTypeSymbol)
+        self.enterRule(localctx, 34, self.RULE_listTypeSymbol)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 209
-            self.match(TParser.T__18)
-            self.state = 210
+            self.state = 215
             self.match(TParser.T__19)
-            self.state = 211
-            localctx.valueType = self.typeSymbol()
-            self.state = 212
+            self.state = 216
             self.match(TParser.T__20)
+            self.state = 217
+            localctx.valueType = self.typeSymbol()
+            self.state = 218
+            self.match(TParser.T__21)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1581,17 +1648,17 @@ class TParser ( Parser ):
     def modelTypeSymbol(self):
 
         localctx = TParser.ModelTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 34, self.RULE_modelTypeSymbol)
+        self.enterRule(localctx, 36, self.RULE_modelTypeSymbol)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 214
-            self.match(TParser.T__21)
-            self.state = 215
-            self.match(TParser.T__19)
-            self.state = 216
-            localctx.valueType = self.typeSymbol()
-            self.state = 217
+            self.state = 220
+            self.match(TParser.T__22)
+            self.state = 221
             self.match(TParser.T__20)
+            self.state = 222
+            localctx.valueType = self.typeSymbol()
+            self.state = 223
+            self.match(TParser.T__21)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1651,51 +1718,51 @@ class TParser ( Parser ):
     def structSymbol(self):
 
         localctx = TParser.StructSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 36, self.RULE_structSymbol)
+        self.enterRule(localctx, 38, self.RULE_structSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 220
+            self.state = 226
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 219
+                self.state = 225
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 225
+            self.state = 231
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 222
+                self.state = 228
                 self.tagSymbol()
-                self.state = 227
+                self.state = 233
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 228
-            self.match(TParser.T__22)
-            self.state = 229
+            self.state = 234
+            self.match(TParser.T__23)
+            self.state = 235
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 230
+            self.state = 236
             self.match(TParser.T__4)
-            self.state = 234
+            self.state = 240
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__21) | (1 << TParser.TAGLINE) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
-                self.state = 231
+            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.structFieldSymbol()
-                self.state = 236
+                self.state = 242
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 237
+            self.state = 243
             self.match(TParser.T__5)
-            self.state = 239
+            self.state = 245
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 238
+                self.state = 244
                 self.match(TParser.T__1)
 
 
@@ -1755,37 +1822,37 @@ class TParser ( Parser ):
     def structFieldSymbol(self):
 
         localctx = TParser.StructFieldSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 38, self.RULE_structFieldSymbol)
+        self.enterRule(localctx, 40, self.RULE_structFieldSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 242
+            self.state = 248
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 241
+                self.state = 247
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 247
+            self.state = 253
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 244
+                self.state = 250
                 self.tagSymbol()
-                self.state = 249
+                self.state = 255
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 250
+            self.state = 256
             self.typeSymbol()
-            self.state = 251
+            self.state = 257
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 253
+            self.state = 259
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 252
+                self.state = 258
                 self.match(TParser.T__1)
 
 
@@ -1852,51 +1919,51 @@ class TParser ( Parser ):
     def enumSymbol(self):
 
         localctx = TParser.EnumSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 40, self.RULE_enumSymbol)
+        self.enterRule(localctx, 42, self.RULE_enumSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 256
+            self.state = 262
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 255
+                self.state = 261
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 261
+            self.state = 267
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 258
+                self.state = 264
                 self.tagSymbol()
-                self.state = 263
+                self.state = 269
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 264
+            self.state = 270
             self.enumTypeSymbol()
-            self.state = 265
+            self.state = 271
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 266
+            self.state = 272
             self.match(TParser.T__4)
-            self.state = 270
+            self.state = 276
             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 = 267
+                self.state = 273
                 self.enumMemberSymbol()
-                self.state = 272
+                self.state = 278
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 273
+            self.state = 279
             self.match(TParser.T__5)
-            self.state = 275
+            self.state = 281
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.T__1:
-                self.state = 274
+                self.state = 280
                 self.match(TParser.T__1)
 
 
@@ -1940,20 +2007,20 @@ class TParser ( Parser ):
     def enumTypeSymbol(self):
 
         localctx = TParser.EnumTypeSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 42, self.RULE_enumTypeSymbol)
+        self.enterRule(localctx, 44, self.RULE_enumTypeSymbol)
         try:
-            self.state = 279
+            self.state = 285
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [TParser.T__23]:
+            if token in [TParser.T__24]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 277
-                localctx.isEnum = self.match(TParser.T__23)
+                self.state = 283
+                localctx.isEnum = self.match(TParser.T__24)
                 pass
-            elif token in [TParser.T__24]:
+            elif token in [TParser.T__25]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 278
-                localctx.isFlag = self.match(TParser.T__24)
+                self.state = 284
+                localctx.isFlag = self.match(TParser.T__25)
                 pass
             else:
                 raise NoViableAltException(self)
@@ -2014,46 +2081,46 @@ class TParser ( Parser ):
     def enumMemberSymbol(self):
 
         localctx = TParser.EnumMemberSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 44, self.RULE_enumMemberSymbol)
+        self.enterRule(localctx, 46, self.RULE_enumMemberSymbol)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 282
+            self.state = 288
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==TParser.DOCCOMMENT:
-                self.state = 281
+                self.state = 287
                 localctx.comment = self.match(TParser.DOCCOMMENT)
 
 
-            self.state = 287
+            self.state = 293
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==TParser.TAGLINE:
-                self.state = 284
+                self.state = 290
                 self.tagSymbol()
-                self.state = 289
+                self.state = 295
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 290
+            self.state = 296
             localctx.name = self.match(TParser.IDENTIFIER)
-            self.state = 293
+            self.state = 299
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==TParser.T__12:
-                self.state = 291
-                self.match(TParser.T__12)
-                self.state = 292
+            if _la==TParser.T__13:
+                self.state = 297
+                self.match(TParser.T__13)
+                self.state = 298
                 self.intSymbol()
 
 
-            self.state = 296
+            self.state = 302
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==TParser.T__11:
-                self.state = 295
-                self.match(TParser.T__11)
+            if _la==TParser.T__12:
+                self.state = 301
+                self.match(TParser.T__12)
 
 
         except RecognitionException as re:
@@ -2100,19 +2167,19 @@ class TParser ( Parser ):
     def intSymbol(self):
 
         localctx = TParser.IntSymbolContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 46, self.RULE_intSymbol)
+        self.enterRule(localctx, 48, self.RULE_intSymbol)
         try:
-            self.state = 300
+            self.state = 306
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [TParser.INTCONSTANT]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 298
+                self.state = 304
                 localctx.value = self.match(TParser.INTCONSTANT)
                 pass
             elif token in [TParser.HEXCONSTANT]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 299
+                self.state = 305
                 localctx.value = self.match(TParser.HEXCONSTANT)
                 pass
             else:
diff --git a/qface/idl/parser/TVisitor.py b/qface/idl/parser/TVisitor.py
index 537146c..d30a617 100644
--- a/qface/idl/parser/TVisitor.py
+++ b/qface/idl/parser/TVisitor.py
@@ -59,6 +59,11 @@ class TVisitor(ParseTreeVisitor):
         return self.visitChildren(ctx)
 
 
+    # Visit a parse tree produced by TParser#propertyModifierSymbol.
+    def visitPropertyModifierSymbol(self, ctx:TParser.PropertyModifierSymbolContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by TParser#operationParameterSymbol.
     def visitOperationParameterSymbol(self, ctx:TParser.OperationParameterSymbolContext):
         return self.visitChildren(ctx)