summaryrefslogtreecommitdiff
path: root/qface/idl
diff options
context:
space:
mode:
Diffstat (limited to 'qface/idl')
-rw-r--r--qface/idl/__init__.py0
-rw-r--r--qface/idl/domain.py348
-rw-r--r--qface/idl/listener.py197
-rw-r--r--qface/idl/parser/T.g4112
-rw-r--r--qface/idl/parser/T.tokens58
-rw-r--r--qface/idl/parser/TLexer.py185
-rw-r--r--qface/idl/parser/TLexer.tokens58
-rw-r--r--qface/idl/parser/TListener.py199
-rw-r--r--qface/idl/parser/TParser.py1669
-rw-r--r--qface/idl/parser/TVisitor.py118
-rw-r--r--qface/idl/parser/__init__.py0
11 files changed, 2944 insertions, 0 deletions
diff --git a/qface/idl/__init__.py b/qface/idl/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/qface/idl/__init__.py
diff --git a/qface/idl/domain.py b/qface/idl/domain.py
new file mode 100644
index 0000000..e726a7b
--- /dev/null
+++ b/qface/idl/domain.py
@@ -0,0 +1,348 @@
+# Copyright (c) Pelagicore AB 2016
+
+'''The domian module contains an object hierachy which resembles the
+QDL grammar as a domain model. It is created from the QDL and the main
+input for the code generation templates.
+
+.. note:: Changes on this API will result into broken templates
+
+.. code-block:: text
+
+ System
+ +- Module
+ +- Import
+ +- Interface
+ +- Property
+ +- Operation
+ +- Event
+ +- Struct (has attributes)
+ +- Enum (has values)
+
+.. note:: When the API talks about an order list, the order is by appearance in the QDL file.
+'''
+
+from collections import OrderedDict, ChainMap
+import logging
+
+log = logging.getLogger(__name__)
+
+
+
+class System(object):
+ """The root entity which consist of modules"""
+ def __init__(self):
+ log.debug('System()')
+ self._moduleMap = OrderedDict() # type: dict[str, Module]
+
+ def __unicode__(self):
+ return 'system'
+
+ def __repr__(self):
+ return '<System>'
+
+ @property
+ def modules(self):
+ '''returns ordered list of module symbols'''
+ return self._moduleMap.values()
+
+ def lookup(self, name: str):
+ '''lookup a symbol by fully qualified name.'''
+ # <module>
+ print('lookup: ' + name)
+ if name in self._moduleMap:
+ return self._moduleMap[name]
+ # <module>.<Symbol>
+ (module_name, type_name) = self.split_typename(name)
+ if not module_name and type_name:
+ print('not able to lookup symbol: {0}'.format(name))
+ return None
+ module = self._moduleMap[module_name]
+ return module.lookup(type_name)
+
+ @staticmethod
+ def split_typename(name):
+ parts = name.rsplit('.', 1)
+ if len(parts) == 1:
+ return ('', parts[0])
+ if len(parts) == 2:
+ return parts
+ return ('', '')
+
+
+
+class Symbol(object):
+ """A symbol represents a base class for names elements"""
+ def __init__(self, name: str, module: 'Module'):
+ self.name = name
+ """symbol name"""
+ self.module = module
+ """module the symbol belongs to"""
+ self.comment = ''
+ """comment which appeared in QDL right before symbol"""
+
+ @property
+ def system(self):
+ '''returns reference to system'''
+ return self.module._system
+
+ @property
+ def qualified_name(self):
+ '''return the fully qualified name (`module + "." + name`)'''
+ return '{0}.{1}'.format(self.module.name, self.name)
+
+ def __unicode__(self):
+ return self.name
+
+ def __str__(self):
+ return self.name
+
+ def __repr__(self):
+ return '<{0} name={1}>'.format(type(self), self.name)
+
+
+
+class TypedSymbol(Symbol):
+ """A symbol which has a type, like an operation or property."""
+ def __init__(self, name: str, module: 'Module'):
+ super().__init__(name, module)
+ self.type = TypeSymbol("", self)
+ """type object of the symbol"""
+
+
+class TypeSymbol(Symbol):
+ """Defines a type in the system"""
+ def __init__(self, name: str, parent: Symbol):
+ super().__init__(name, parent.module)
+ log.debug('TypeSymbol()')
+ self.parent = parent
+ self.is_void = False # type:bool
+ self.is_primitive = False # type:bool
+ self.is_complex = False # type:bool
+ self.is_list = False # type:bool
+ self.is_model = False # type:bool
+ self.nested = None
+ """nested type if symbol is list or model"""
+ self.__reference = None
+ self.__is_resolved = False
+
+ @property
+ def is_bool(self):
+ '''checks if type is primitive and bool'''
+ return self.is_primitive and self.name == 'bool'
+
+ @property
+ def is_int(self):
+ '''checks if type is primitive and int'''
+ return self.is_primitive and self.name == 'int'
+
+ @property
+ def is_real(self):
+ '''checks if type is primitive and real'''
+ return self.is_primitive and self.name == 'real'
+
+ @property
+ def is_string(self):
+ '''checks if type is primitive and string'''
+ return self.is_primitive and self.name == 'string'
+
+ @property
+ def is_enum(self):
+ '''checks if type is complex and enum'''
+ return self.is_complex and isinstance(self.reference, Enum)
+
+ @property
+ def is_struct(self):
+ '''checks if type is complex and struct'''
+ return self.is_complex and isinstance(self.reference, Struct)
+
+ @property
+ def is_variant(self):
+ '''checks if type is primitive and string'''
+ return self.is_primitive and self.name == 'var'
+
+ @property
+ def reference(self):
+ """returns the symbol reference of the type name"""
+ if not self.__is_resolved:
+ self._resolve()
+ return self.__reference
+
+ def _resolve(self):
+ """resolve the type symbol from name by doing a lookup"""
+ self.__is_resolved = True
+ if self.is_complex:
+ type = self.nested if self.nested else self
+ type.__reference = self.module.lookup(type.name)
+
+
+class Module(Symbol):
+ """Module is a namespace for types, e.g. interfaces, enums, structs"""
+ def __init__(self, name: str, system: System):
+ """init"""
+ super().__init__(name, self)
+ log.debug('Module()')
+ self.version = '1.0'
+ self._system = system
+ self._system._moduleMap[name] = self
+ self._interfaceMap = OrderedDict() # type: dict[str, Interface]
+ self._structMap = OrderedDict() # type: dict[str, Struct]
+ self._enumMap = OrderedDict() # type: dict[str, Enum]
+ self._definitionMap = ChainMap(self._interfaceMap, self._structMap, self._enumMap)
+ self._importMap = OrderedDict() # type: dict[str, Module]
+
+ @property
+ def interfaces(self):
+ '''returns ordered list of interface symbols'''
+ return self._interfaceMap.values()
+
+ @property
+ def structs(self):
+ '''returns ordered list of struct symbols'''
+ return self._structMap.values()
+
+ @property
+ def enums(self):
+ '''returns ordered list of enum symbols'''
+ return self._enumMap.values()
+
+ @property
+ def imports(self):
+ '''returns ordered list of import symbols'''
+ return self._importMap.values()
+
+ def checkType(self, type: str):
+ if type.is_primitive:
+ return True
+ (module_name, type_name) = System.split_typename(type.name)
+ if module_name and module_name not in self._importMap:
+ return False
+ return True
+
+ @property
+ def name_parts(self):
+ '''return module name splitted by '.' in parts'''
+ return self.name.split('.')
+
+ @property
+ def module_name(self):
+ return self.name.split('.')[-1].capitalize()
+
+ def lookup(self, name: str):
+ '''lookup a symbol by name. If symbol is not local
+ it will be looked up system wide'''
+ if name in self._definitionMap:
+ return self._definitionMap[name]
+ return self.system.lookup(name)
+
+
+class Interface(Symbol):
+ """A interface is an object with operations, properties and events"""
+ def __init__(self, name: str, module: Module):
+ super().__init__(name, module)
+ log.debug('Interface()')
+ self.module._interfaceMap[name] = self
+ self._propertyMap = OrderedDict() # type: dict[str, Property]
+ self._operationMap = OrderedDict() # type: dict[str, Operation]
+ self._eventMap = OrderedDict() # type: dict[str, Operation]
+
+ @property
+ def properties(self):
+ '''returns ordered list of properties'''
+ return self._propertyMap.values()
+
+ @property
+ def operations(self):
+ '''returns ordered list of operations'''
+ return self._operationMap.values()
+
+ @property
+ def events(self):
+ '''returns ordered list of events'''
+ return self._eventMap.values()
+
+
+class Operation(TypedSymbol):
+ """An operation inside a interface"""
+ def __init__(self, name: str, interface: Interface, is_event=False):
+ super().__init__(name, interface.module)
+ log.debug('Operation()')
+ self.interface = interface
+ self.is_event = is_event
+ if is_event:
+ self.interface._eventMap[name] = self
+ else:
+ self.interface._operationMap[name] = self
+ self._parameterMap = OrderedDict() # type: dict[Parameter]
+
+ @property
+ def parameters(self):
+ '''returns ordered list of parameters'''
+ return self._parameterMap.values()
+
+
+class Parameter(TypedSymbol):
+ """An operation parameter"""
+ def __init__(self, name: str, operation: Operation):
+ super().__init__(name, operation.module)
+ log.debug('Parameter()')
+ self.operation = operation
+ self.operation._parameterMap[name] = self
+
+
+class Property(TypedSymbol):
+ """A typed property inside a interface"""
+ def __init__(self, name: str, interface: Interface):
+ super().__init__(name, interface.module)
+ log.debug('Property()')
+ self.interface = interface
+ self.interface._propertyMap[name] = self
+ self.is_readonly = False
+
+
+class Struct(Symbol):
+ """Represents a data container"""
+ def __init__(self, name: str, module: Module):
+ super().__init__(name, module)
+ log.debug('Struct()')
+ self.module._structMap[name] = self
+ self._fieldMap = OrderedDict() # type: dict[str, Field]
+
+ @property
+ def fields(self):
+ '''returns ordered list of members'''
+ return self._fieldMap.values()
+
+
+class Field(TypedSymbol):
+ """A member in a struct"""
+ def __init__(self, name: str, struct: Struct):
+ super().__init__(name, struct.module)
+ log.debug('Field()')
+ self.struct = struct # type:Struct
+ self.struct._fieldMap[name] = self
+
+
+class Enum(Symbol):
+ """An enum (flag) inside a module"""
+ def __init__(self, name: str, module: Module):
+ super().__init__(name, module)
+ log.debug('Enum()')
+ self.is_enum = True
+ self.is_flag = False
+ self.module._enumMap[name] = self
+ self._memberMap = OrderedDict() # type: dict[EnumMember]
+
+ @property
+ def members(self):
+ '''returns ordered list of members'''
+ return self._memberMap.values()
+
+
+class EnumMember(Symbol):
+ """A enum value"""
+ def __init__(self, name: str, enum: Enum):
+ super().__init__(name, enum.module)
+ log.debug('EnumMember()')
+ self.enum = enum
+ self.enum._memberMap[name] = self
+ self.value = 0
diff --git a/qface/idl/listener.py b/qface/idl/listener.py
new file mode 100644
index 0000000..b257005
--- /dev/null
+++ b/qface/idl/listener.py
@@ -0,0 +1,197 @@
+# Copyright (c) Pelagicore AB 2016
+import logging
+from _operator import concat
+
+from .parser.TListener import TListener
+from .parser.TParser import TParser
+from .domain import *
+from antlr4 import ParserRuleContext
+
+
+log = logging.getLogger(__name__)
+
+# associates parser context to domain objects
+contextMap = {}
+
+class DomainListener(TListener):
+ """The domain listener is called by the parser to fill the
+ domain data struture. As a result a system is passed
+ back"""
+ def __init__(self, system):
+ super(DomainListener, self).__init__()
+ contextMap.clear()
+ self.system = system or System() # type:System
+ self.module = None # type:Module
+ self.interface = None # type:Interface
+ self.struct = None # type:Struct
+ self.enum = None # type:Enum
+ self.enumCounter = 0 # int
+ self.operation = None # type:Operation
+ self.parameter = None # type:Parameter
+ self.property = None # type:Property
+ self.field = None # type:Field
+
+ def parse_type(self, ctx: ParserRuleContext, type: TypeSymbol):
+ if not ctx.typeSymbol():
+ # import pdb; pdb.set_trace()
+ type.is_void = True
+ type.name = 'void'
+ else:
+ if ctx.typeSymbol().primitiveTypeSymbol():
+ ctxSymbol = ctx.typeSymbol().primitiveTypeSymbol() # type:TParser.PrimitiveTypeSymbolContext
+ type.is_primitive = True
+ type.name = ctxSymbol.name.text
+ elif ctx.typeSymbol().complexTypeSymbol():
+ ctxSymbol = ctx.typeSymbol().complexTypeSymbol() # type:TParser.ComplexTypeSymbolContext
+ type.is_complex = True
+ type.name = ctxSymbol.name.text
+ elif ctx.typeSymbol().listTypeSymbol():
+ ctxSymbol = ctx.typeSymbol().listTypeSymbol() # type:TParser.ListTypeSymbolContext
+ type.is_list = True
+ type.name = 'list'
+ type.nested = TypeSymbol("", type)
+ self.parse_type(ctxSymbol, type.nested)
+ elif ctx.typeSymbol().modelTypeSymbol():
+ ctxSymbol = ctx.typeSymbol().modelTypeSymbol() # type:TParser.ModelTypeSymbolContext
+ type.is_model = True
+ type.name = 'model'
+ type.nested = TypeSymbol("", type)
+ self.parse_type(ctxSymbol, type.nested)
+ if not type.module.checkType(type):
+ log.warn('Unknown type: {0}. Missing import?'.format(type.name))
+
+ def parse_comment(self, ctx, symbol):
+ if ctx.comment:
+ comment = ctx.comment.text
+ symbol.comment = comment
+
+ def enterEveryRule(self, ctx):
+ log.debug('enter ' + ctx.__class__.__name__)
+
+ def exitEveryRule(self, ctx):
+ log.debug('exit ' + ctx.__class__.__name__)
+
+ def enterModuleSymbol(self, ctx: TParser.ModuleSymbolContext):
+ assert self.system
+ name = ctx.name.text
+ version = ctx.version.text
+ self.module = Module(name, self.system)
+ self.module.version = version
+ contextMap[ctx] = self.module
+
+ def exitModuleSymbol(self, ctx: TParser.ModuleSymbolContext):
+ pass
+
+ def enterInterfaceSymbol(self, ctx: TParser.InterfaceSymbolContext):
+ assert self.module
+ name = ctx.name.text
+ self.interface = Interface(name, self.module)
+ self.parse_comment(ctx, self.interface)
+ contextMap[ctx] = self.interface
+
+ def exitInterfaceSymbol(self, ctx: TParser.InterfaceSymbolContext):
+ self.interface = None
+
+ def enterStructSymbol(self, ctx: TParser.StructSymbolContext):
+ assert self.module
+ name = ctx.name.text
+ self.struct = Struct(name, self.module)
+ self.parse_comment(ctx, self.struct)
+ contextMap[ctx] = self.struct
+
+ def exitStructSymbol(self, ctx: TParser.StructSymbolContext):
+ self.struct = None
+
+ def enterEnumSymbol(self, ctx: TParser.EnumSymbolContext):
+ assert self.module
+ name = ctx.name.text
+ # import ipdb; ipdb.set_trace()
+ self.enum = Enum(name, self.module)
+ self.parse_comment(ctx, self.enum)
+ contextMap[ctx] = self.enum
+
+ def exitEnumSymbol(self, ctx: TParser.EnumSymbolContext):
+ self.enum = None
+ self.enumCounter = 0
+
+ def enterEnumTypeSymbol(self, ctx: TParser.EnumTypeSymbolContext):
+ assert self.enum
+ self.enumCounter = 0
+ if ctx.isFlag:
+ self.enum.is_enum = False
+ self.enum.is_flag = True
+ self.enumCounter = 1
+
+ def exitEnumTypeSymbol(self, ctx: TParser.EnumTypeSymbolContext):
+ pass
+
+ def enterOperationSymbol(self, ctx: TParser.OperationSymbolContext):
+ assert self.interface
+ name = ctx.name.text
+ is_event = bool(ctx.isEvent)
+ self.operation = Operation(name, self.interface, is_event)
+ self.parse_comment(ctx, self.operation)
+ self.parse_type(ctx, self.operation.type)
+ contextMap[ctx] = self.operation
+
+ def exitOperationSymbol(self, ctx: TParser.OperationSymbolContext):
+ self.operation = None
+
+ def enterOperationParameterSymbol(self, ctx: TParser.OperationParameterSymbolContext):
+ name = ctx.name.text
+ self.parameter = Parameter(name, self.operation)
+ contextMap[ctx] = self.parameter
+
+ def exitOperationParameterSymbol(self, ctx: TParser.OperationParameterSymbolContext):
+ self.parse_type(ctx, self.parameter.type)
+
+ def enterPropertySymbol(self, ctx: TParser.PropertySymbolContext):
+ assert self.interface
+ name = ctx.name.text
+ self.property = Property(name, self.interface)
+ self.property.is_readonly = bool(ctx.isReadOnly)
+ self.parse_comment(ctx, self.property)
+ self.parse_type(ctx, self.property.type)
+ contextMap[ctx] = self.property
+
+ def exitPropertySymbol(self, ctx: TParser.PropertySymbolContext):
+ self.property = None
+
+ def enterStructFieldSymbol(self, ctx: TParser.StructFieldSymbolContext):
+ assert self.struct
+ name = ctx.name.text
+ self.field = Field(name, self.struct)
+ contextMap[ctx] = self.field
+
+ def exitStructFieldSymbol(self, ctx: TParser.StructFieldSymbolContext):
+ self.parse_type(ctx, self.field.type)
+ self.field = None
+
+ def enterEnumMemberSymbol(self, ctx: TParser.EnumMemberSymbolContext):
+ assert self.enum
+ name = ctx.name.text
+ self.field = EnumMember(name, self.enum)
+ value = self.enumCounter
+ if ctx.intSymbol():
+ value = int(ctx.intSymbol().value.text, 0)
+ self.field.value = value
+ contextMap[ctx] = self.field
+ # import ipdb; ipdb.set_trace()
+ if self.enum.is_flag:
+ self.enumCounter <<= 1
+ else:
+ self.enumCounter += 1
+
+ def exitEnumMemberSymbol(self, ctx: TParser.EnumMemberSymbolContext):
+ self.field = None
+
+ def enterImportSymbol(self, ctx: TParser.ImportSymbolContext):
+ assert self.module
+ name = ctx.name.text
+ version = ctx.version.text
+ # import ipdb; ipdb.set_trace()
+ self.module._importMap[name] = '{0} {1}'.format(name, version)
+
+ def exitImportSymbol(self, ctx: TParser.ImportSymbolContext):
+ pass
+
diff --git a/qface/idl/parser/T.g4 b/qface/idl/parser/T.g4
new file mode 100644
index 0000000..292dd59
--- /dev/null
+++ b/qface/idl/parser/T.g4
@@ -0,0 +1,112 @@
+// Copyright (c) Pelagicore AB 2016
+grammar T;
+
+
+documentSymbol
+ : headerSymbol definitionSymbol*
+ ;
+
+/**
+module name;
+import name;
+*/
+headerSymbol
+ : moduleSymbol importSymbol*
+ ;
+
+importSymbol
+ : 'import' name=IDENTIFIER version=VERSION ';'?
+ ;
+
+moduleSymbol
+ : comment=DOCCOMMENT? 'module' name=IDENTIFIER version=VERSION ';'?
+ ;
+
+definitionSymbol
+ : interfaceSymbol
+ | structSymbol
+ | enumSymbol
+ ;
+
+interfaceSymbol
+ : comment=DOCCOMMENT? 'interface' name=IDENTIFIER '{' interfaceMemberSymbol* '}'
+ ;
+
+interfaceMemberSymbol
+ : operationSymbol
+ | propertySymbol
+ ;
+
+operationSymbol
+ : comment=DOCCOMMENT? isEvent='event'? (typeSymbol | 'void') name=IDENTIFIER '(' operationParameterSymbol* ')' ';'?
+ ;
+
+propertySymbol
+ : comment=DOCCOMMENT? isReadOnly='readonly'? typeSymbol name=IDENTIFIER ';'?
+ ;
+
+operationParameterSymbol
+ : typeSymbol name=IDENTIFIER ','?
+ ;
+
+typeSymbol
+ : primitiveTypeSymbol
+ | complexTypeSymbol
+ | listTypeSymbol
+ | modelTypeSymbol
+ ;
+
+complexTypeSymbol
+ : name=IDENTIFIER
+ ;
+
+primitiveTypeSymbol
+ : name='bool'
+ | name='int'
+ | name='real'
+ | name='string'
+ | name='var'
+ ;
+
+listTypeSymbol
+ : 'list' '<' valueType=typeSymbol '>'
+ ;
+
+modelTypeSymbol
+ : 'model' '<' valueType=typeSymbol '>'
+ ;
+
+structSymbol
+ : comment=DOCCOMMENT? 'struct' name=IDENTIFIER '{' structFieldSymbol* '}'
+ ;
+
+structFieldSymbol
+ : comment=DOCCOMMENT? typeSymbol name=IDENTIFIER ';'?
+ ;
+
+enumSymbol
+ : comment=DOCCOMMENT? enumTypeSymbol name=IDENTIFIER '{' enumMemberSymbol* '}'
+ ;
+
+enumTypeSymbol
+ : isEnum = 'enum'
+ | isFlag = 'flag'
+ ;
+
+enumMemberSymbol
+ : comment=DOCCOMMENT? name=IDENTIFIER ('=' intSymbol)? ','?
+ ;
+
+intSymbol
+ : value=INTCONSTANT
+ | value=HEXCONSTANT
+ ;
+
+INTCONSTANT : ('+' | '-')? '0'..'9'+;
+HEXCONSTANT : '0x' ('0'..'9' | 'a'..'f' | 'A'..'F')+;
+IDENTIFIER : [a-zA-Z_][a-zA-Z0-9_\.]*;
+VERSION : [0-9]'.'[0-9];
+DOCCOMMENT : '/*!' .*? '*/';
+WHITESPACE : [ \t\r\n]+ -> skip;
+COMMENT : '//' ~[\r\n]* -> skip;
+MULTICOMM : '/*' .*? '*/' -> skip;
diff --git a/qface/idl/parser/T.tokens b/qface/idl/parser/T.tokens
new file mode 100644
index 0000000..505f1e4
--- /dev/null
+++ b/qface/idl/parser/T.tokens
@@ -0,0 +1,58 @@
+T__0=1
+T__1=2
+T__2=3
+T__3=4
+T__4=5
+T__5=6
+T__6=7
+T__7=8
+T__8=9
+T__9=10
+T__10=11
+T__11=12
+T__12=13
+T__13=14
+T__14=15
+T__15=16
+T__16=17
+T__17=18
+T__18=19
+T__19=20
+T__20=21
+T__21=22
+T__22=23
+T__23=24
+T__24=25
+INTCONSTANT=26
+HEXCONSTANT=27
+IDENTIFIER=28
+VERSION=29
+DOCCOMMENT=30
+WHITESPACE=31
+COMMENT=32
+MULTICOMM=33
+'import'=1
+';'=2
+'module'=3
+'interface'=4
+'{'=5
+'}'=6
+'event'=7
+'void'=8
+'('=9
+')'=10
+'readonly'=11
+','=12
+'bool'=13
+'int'=14
+'real'=15
+'string'=16
+'var'=17
+'list'=18
+'<'=19
+'>'=20
+'model'=21
+'struct'=22
+'enum'=23
+'flag'=24
+'='=25
diff --git a/qface/idl/parser/TLexer.py b/qface/idl/parser/TLexer.py
new file mode 100644
index 0000000..643b680
--- /dev/null
+++ b/qface/idl/parser/TLexer.py
@@ -0,0 +1,185 @@
+# Generated from T.g4 by ANTLR 4.5.3
+from antlr4 import *
+from io import StringIO
+
+
+def serializedATN():
+ with StringIO() as buf:
+ buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2#")
+ buf.write("\u0100\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\"\3\2\3\2\3\2\3\2\3")
+ buf.write("\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5")
+ buf.write("\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3")
+ buf.write("\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\13\3")
+ buf.write("\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\16\3")
+ buf.write("\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20\3\20")
+ buf.write("\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\22\3\22")
+ buf.write("\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\25\3\25")
+ buf.write("\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27")
+ buf.write("\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31")
+ buf.write("\3\31\3\32\3\32\3\33\5\33\u00ba\n\33\3\33\6\33\u00bd\n")
+ buf.write("\33\r\33\16\33\u00be\3\34\3\34\3\34\3\34\6\34\u00c5\n")
+ buf.write("\34\r\34\16\34\u00c6\3\35\3\35\7\35\u00cb\n\35\f\35\16")
+ buf.write("\35\u00ce\13\35\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37")
+ buf.write("\3\37\7\37\u00d9\n\37\f\37\16\37\u00dc\13\37\3\37\3\37")
+ buf.write("\3\37\3 \6 \u00e2\n \r \16 \u00e3\3 \3 \3!\3!\3!\3!\7")
+ buf.write("!\u00ec\n!\f!\16!\u00ef\13!\3!\3!\3\"\3\"\3\"\3\"\7\"")
+ buf.write("\u00f7\n\"\f\"\16\"\u00fa\13\"\3\"\3\"\3\"\3\"\3\"\4\u00da")
+ buf.write("\u00f8\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#\3")
+ buf.write("\2\t\4\2--//\5\2\62;CHch\5\2C\\aac|\b\2\60\60\62;C\\^")
+ buf.write("^aac|\3\2\62;\5\2\13\f\17\17\"\"\4\2\f\f\17\17\u0107\2")
+ buf.write("\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\3")
+ buf.write("\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2")
+ buf.write("\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2")
+ buf.write("\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\3E\3\2\2\2\5L\3\2\2\2\7N\3\2\2\2")
+ buf.write("\tU\3\2\2\2\13_\3\2\2\2\ra\3\2\2\2\17c\3\2\2\2\21i\3\2")
+ buf.write("\2\2\23n\3\2\2\2\25p\3\2\2\2\27r\3\2\2\2\31{\3\2\2\2\33")
+ buf.write("}\3\2\2\2\35\u0082\3\2\2\2\37\u0086\3\2\2\2!\u008b\3\2")
+ buf.write("\2\2#\u0092\3\2\2\2%\u0096\3\2\2\2\'\u009b\3\2\2\2)\u009d")
+ buf.write("\3\2\2\2+\u009f\3\2\2\2-\u00a5\3\2\2\2/\u00ac\3\2\2\2")
+ buf.write("\61\u00b1\3\2\2\2\63\u00b6\3\2\2\2\65\u00b9\3\2\2\2\67")
+ buf.write("\u00c0\3\2\2\29\u00c8\3\2\2\2;\u00cf\3\2\2\2=\u00d3\3")
+ buf.write("\2\2\2?\u00e1\3\2\2\2A\u00e7\3\2\2\2C\u00f2\3\2\2\2EF")
+ buf.write("\7k\2\2FG\7o\2\2GH\7r\2\2HI\7q\2\2IJ\7t\2\2JK\7v\2\2K")
+ buf.write("\4\3\2\2\2LM\7=\2\2M\6\3\2\2\2NO\7o\2\2OP\7q\2\2PQ\7f")
+ buf.write("\2\2QR\7w\2\2RS\7n\2\2ST\7g\2\2T\b\3\2\2\2UV\7k\2\2VW")
+ buf.write("\7p\2\2WX\7v\2\2XY\7g\2\2YZ\7t\2\2Z[\7h\2\2[\\\7c\2\2")
+ buf.write("\\]\7e\2\2]^\7g\2\2^\n\3\2\2\2_`\7}\2\2`\f\3\2\2\2ab\7")
+ buf.write("\177\2\2b\16\3\2\2\2cd\7g\2\2de\7x\2\2ef\7g\2\2fg\7p\2")
+ buf.write("\2gh\7v\2\2h\20\3\2\2\2ij\7x\2\2jk\7q\2\2kl\7k\2\2lm\7")
+ buf.write("f\2\2m\22\3\2\2\2no\7*\2\2o\24\3\2\2\2pq\7+\2\2q\26\3")
+ buf.write("\2\2\2rs\7t\2\2st\7g\2\2tu\7c\2\2uv\7f\2\2vw\7q\2\2wx")
+ buf.write("\7p\2\2xy\7n\2\2yz\7{\2\2z\30\3\2\2\2{|\7.\2\2|\32\3\2")
+ buf.write("\2\2}~\7d\2\2~\177\7q\2\2\177\u0080\7q\2\2\u0080\u0081")
+ buf.write("\7n\2\2\u0081\34\3\2\2\2\u0082\u0083\7k\2\2\u0083\u0084")
+ buf.write("\7p\2\2\u0084\u0085\7v\2\2\u0085\36\3\2\2\2\u0086\u0087")
+ buf.write("\7t\2\2\u0087\u0088\7g\2\2\u0088\u0089\7c\2\2\u0089\u008a")
+ buf.write("\7n\2\2\u008a \3\2\2\2\u008b\u008c\7u\2\2\u008c\u008d")
+ buf.write("\7v\2\2\u008d\u008e\7t\2\2\u008e\u008f\7k\2\2\u008f\u0090")
+ buf.write("\7p\2\2\u0090\u0091\7i\2\2\u0091\"\3\2\2\2\u0092\u0093")
+ buf.write("\7x\2\2\u0093\u0094\7c\2\2\u0094\u0095\7t\2\2\u0095$\3")
+ buf.write("\2\2\2\u0096\u0097\7n\2\2\u0097\u0098\7k\2\2\u0098\u0099")
+ buf.write("\7u\2\2\u0099\u009a\7v\2\2\u009a&\3\2\2\2\u009b\u009c")
+ buf.write("\7>\2\2\u009c(\3\2\2\2\u009d\u009e\7@\2\2\u009e*\3\2\2")
+ buf.write("\2\u009f\u00a0\7o\2\2\u00a0\u00a1\7q\2\2\u00a1\u00a2\7")
+ buf.write("f\2\2\u00a2\u00a3\7g\2\2\u00a3\u00a4\7n\2\2\u00a4,\3\2")
+ buf.write("\2\2\u00a5\u00a6\7u\2\2\u00a6\u00a7\7v\2\2\u00a7\u00a8")
+ buf.write("\7t\2\2\u00a8\u00a9\7w\2\2\u00a9\u00aa\7e\2\2\u00aa\u00ab")
+ buf.write("\7v\2\2\u00ab.\3\2\2\2\u00ac\u00ad\7g\2\2\u00ad\u00ae")
+ buf.write("\7p\2\2\u00ae\u00af\7w\2\2\u00af\u00b0\7o\2\2\u00b0\60")
+ buf.write("\3\2\2\2\u00b1\u00b2\7h\2\2\u00b2\u00b3\7n\2\2\u00b3\u00b4")
+ buf.write("\7c\2\2\u00b4\u00b5\7i\2\2\u00b5\62\3\2\2\2\u00b6\u00b7")
+ buf.write("\7?\2\2\u00b7\64\3\2\2\2\u00b8\u00ba\t\2\2\2\u00b9\u00b8")
+ buf.write("\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bc\3\2\2\2\u00bb")
+ buf.write("\u00bd\4\62;\2\u00bc\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2")
+ buf.write("\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\66\3\2")
+ buf.write("\2\2\u00c0\u00c1\7\62\2\2\u00c1\u00c2\7z\2\2\u00c2\u00c4")
+ buf.write("\3\2\2\2\u00c3\u00c5\t\3\2\2\u00c4\u00c3\3\2\2\2\u00c5")
+ buf.write("\u00c6\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c6\u00c7\3\2\2\2")
+ buf.write("\u00c78\3\2\2\2\u00c8\u00cc\t\4\2\2\u00c9\u00cb\t\5\2")
+ buf.write("\2\u00ca\u00c9\3\2\2\2\u00cb\u00ce\3\2\2\2\u00cc\u00ca")
+ buf.write("\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd:\3\2\2\2\u00ce\u00cc")
+ buf.write("\3\2\2\2\u00cf\u00d0\t\6\2\2\u00d0\u00d1\7\60\2\2\u00d1")
+ buf.write("\u00d2\t\6\2\2\u00d2<\3\2\2\2\u00d3\u00d4\7\61\2\2\u00d4")
+ buf.write("\u00d5\7,\2\2\u00d5\u00d6\7#\2\2\u00d6\u00da\3\2\2\2\u00d7")
+ buf.write("\u00d9\13\2\2\2\u00d8\u00d7\3\2\2\2\u00d9\u00dc\3\2\2")
+ buf.write("\2\u00da\u00db\3\2\2\2\u00da\u00d8\3\2\2\2\u00db\u00dd")
+ buf.write("\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00de\7,\2\2\u00de")
+ buf.write("\u00df\7\61\2\2\u00df>\3\2\2\2\u00e0\u00e2\t\7\2\2\u00e1")
+ buf.write("\u00e0\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\u00e1\3\2\2\2")
+ buf.write("\u00e3\u00e4\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00e6\b")
+ buf.write(" \2\2\u00e6@\3\2\2\2\u00e7\u00e8\7\61\2\2\u00e8\u00e9")
+ buf.write("\7\61\2\2\u00e9\u00ed\3\2\2\2\u00ea\u00ec\n\b\2\2\u00eb")
+ buf.write("\u00ea\3\2\2\2\u00ec\u00ef\3\2\2\2\u00ed\u00eb\3\2\2\2")
+ buf.write("\u00ed\u00ee\3\2\2\2\u00ee\u00f0\3\2\2\2\u00ef\u00ed\3")
+ buf.write("\2\2\2\u00f0\u00f1\b!\2\2\u00f1B\3\2\2\2\u00f2\u00f3\7")
+ buf.write("\61\2\2\u00f3\u00f4\7,\2\2\u00f4\u00f8\3\2\2\2\u00f5\u00f7")
+ buf.write("\13\2\2\2\u00f6\u00f5\3\2\2\2\u00f7\u00fa\3\2\2\2\u00f8")
+ buf.write("\u00f9\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f9\u00fb\3\2\2\2")
+ buf.write("\u00fa\u00f8\3\2\2\2\u00fb\u00fc\7,\2\2\u00fc\u00fd\7")
+ buf.write("\61\2\2\u00fd\u00fe\3\2\2\2\u00fe\u00ff\b\"\2\2\u00ff")
+ buf.write("D\3\2\2\2\13\2\u00b9\u00be\u00c6\u00cc\u00da\u00e3\u00ed")
+ buf.write("\u00f8\3\b\2\2")
+ return buf.getvalue()
+
+
+class TLexer(Lexer):
+
+ atn = ATNDeserializer().deserialize(serializedATN())
+
+ decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+
+ T__0 = 1
+ T__1 = 2
+ T__2 = 3
+ T__3 = 4
+ T__4 = 5
+ T__5 = 6
+ T__6 = 7
+ T__7 = 8
+ T__8 = 9
+ T__9 = 10
+ T__10 = 11
+ T__11 = 12
+ T__12 = 13
+ T__13 = 14
+ T__14 = 15
+ T__15 = 16
+ T__16 = 17
+ T__17 = 18
+ T__18 = 19
+ T__19 = 20
+ T__20 = 21
+ T__21 = 22
+ T__22 = 23
+ T__23 = 24
+ T__24 = 25
+ INTCONSTANT = 26
+ HEXCONSTANT = 27
+ IDENTIFIER = 28
+ VERSION = 29
+ DOCCOMMENT = 30
+ WHITESPACE = 31
+ COMMENT = 32
+ MULTICOMM = 33
+
+ modeNames = [ "DEFAULT_MODE" ]
+
+ literalNames = [ "<INVALID>",
+ "'import'", "';'", "'module'", "'interface'", "'{'", "'}'",
+ "'event'", "'void'", "'('", "')'", "'readonly'", "','", "'bool'",
+ "'int'", "'real'", "'string'", "'var'", "'list'", "'<'", "'>'",
+ "'model'", "'struct'", "'enum'", "'flag'", "'='" ]
+
+ symbolicNames = [ "<INVALID>",
+ "INTCONSTANT", "HEXCONSTANT", "IDENTIFIER", "VERSION", "DOCCOMMENT",
+ "WHITESPACE", "COMMENT", "MULTICOMM" ]
+
+ 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", "INTCONSTANT",
+ "HEXCONSTANT", "IDENTIFIER", "VERSION", "DOCCOMMENT",
+ "WHITESPACE", "COMMENT", "MULTICOMM" ]
+
+ grammarFileName = "T.g4"
+
+ def __init__(self, input=None):
+ super().__init__(input)
+ self.checkVersion("4.5.3")
+ self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+ self._actions = None
+ self._predicates = None
+
+
diff --git a/qface/idl/parser/TLexer.tokens b/qface/idl/parser/TLexer.tokens
new file mode 100644
index 0000000..505f1e4
--- /dev/null
+++ b/qface/idl/parser/TLexer.tokens
@@ -0,0 +1,58 @@
+T__0=1
+T__1=2
+T__2=3
+T__3=4
+T__4=5
+T__5=6
+T__6=7
+T__7=8
+T__8=9
+T__9=10
+T__10=11
+T__11=12
+T__12=13
+T__13=14
+T__14=15
+T__15=16
+T__16=17
+T__17=18
+T__18=19
+T__19=20
+T__20=21
+T__21=22
+T__22=23
+T__23=24
+T__24=25
+INTCONSTANT=26
+HEXCONSTANT=27
+IDENTIFIER=28
+VERSION=29
+DOCCOMMENT=30
+WHITESPACE=31
+COMMENT=32
+MULTICOMM=33
+'import'=1
+';'=2
+'module'=3
+'interface'=4
+'{'=5
+'}'=6
+'event'=7
+'void'=8
+'('=9
+')'=10
+'readonly'=11
+','=12
+'bool'=13
+'int'=14
+'real'=15
+'string'=16
+'var'=17
+'list'=18
+'<'=19
+'>'=20
+'model'=21
+'struct'=22
+'enum'=23
+'flag'=24
+'='=25
diff --git a/qface/idl/parser/TListener.py b/qface/idl/parser/TListener.py
new file mode 100644
index 0000000..10f5a3a
--- /dev/null
+++ b/qface/idl/parser/TListener.py
@@ -0,0 +1,199 @@
+# Generated from T.g4 by ANTLR 4.5.3
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+ from .TParser import TParser
+else:
+ from TParser import TParser
+
+# This class defines a complete listener for a parse tree produced by TParser.
+class TListener(ParseTreeListener):
+
+ # Enter a parse tree produced by TParser#documentSymbol.
+ def enterDocumentSymbol(self, ctx:TParser.DocumentSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#documentSymbol.
+ def exitDocumentSymbol(self, ctx:TParser.DocumentSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#headerSymbol.
+ def enterHeaderSymbol(self, ctx:TParser.HeaderSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#headerSymbol.
+ def exitHeaderSymbol(self, ctx:TParser.HeaderSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#importSymbol.
+ def enterImportSymbol(self, ctx:TParser.ImportSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#importSymbol.
+ def exitImportSymbol(self, ctx:TParser.ImportSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#moduleSymbol.
+ def enterModuleSymbol(self, ctx:TParser.ModuleSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#moduleSymbol.
+ def exitModuleSymbol(self, ctx:TParser.ModuleSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#definitionSymbol.
+ def enterDefinitionSymbol(self, ctx:TParser.DefinitionSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#definitionSymbol.
+ def exitDefinitionSymbol(self, ctx:TParser.DefinitionSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#interfaceSymbol.
+ def enterInterfaceSymbol(self, ctx:TParser.InterfaceSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#interfaceSymbol.
+ def exitInterfaceSymbol(self, ctx:TParser.InterfaceSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#interfaceMemberSymbol.
+ def enterInterfaceMemberSymbol(self, ctx:TParser.InterfaceMemberSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#interfaceMemberSymbol.
+ def exitInterfaceMemberSymbol(self, ctx:TParser.InterfaceMemberSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#operationSymbol.
+ def enterOperationSymbol(self, ctx:TParser.OperationSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#operationSymbol.
+ def exitOperationSymbol(self, ctx:TParser.OperationSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#propertySymbol.
+ def enterPropertySymbol(self, ctx:TParser.PropertySymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#propertySymbol.
+ def exitPropertySymbol(self, ctx:TParser.PropertySymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#operationParameterSymbol.
+ def enterOperationParameterSymbol(self, ctx:TParser.OperationParameterSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#operationParameterSymbol.
+ def exitOperationParameterSymbol(self, ctx:TParser.OperationParameterSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#typeSymbol.
+ def enterTypeSymbol(self, ctx:TParser.TypeSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#typeSymbol.
+ def exitTypeSymbol(self, ctx:TParser.TypeSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#complexTypeSymbol.
+ def enterComplexTypeSymbol(self, ctx:TParser.ComplexTypeSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#complexTypeSymbol.
+ def exitComplexTypeSymbol(self, ctx:TParser.ComplexTypeSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#primitiveTypeSymbol.
+ def enterPrimitiveTypeSymbol(self, ctx:TParser.PrimitiveTypeSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#primitiveTypeSymbol.
+ def exitPrimitiveTypeSymbol(self, ctx:TParser.PrimitiveTypeSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#listTypeSymbol.
+ def enterListTypeSymbol(self, ctx:TParser.ListTypeSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#listTypeSymbol.
+ def exitListTypeSymbol(self, ctx:TParser.ListTypeSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#modelTypeSymbol.
+ def enterModelTypeSymbol(self, ctx:TParser.ModelTypeSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#modelTypeSymbol.
+ def exitModelTypeSymbol(self, ctx:TParser.ModelTypeSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#structSymbol.
+ def enterStructSymbol(self, ctx:TParser.StructSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#structSymbol.
+ def exitStructSymbol(self, ctx:TParser.StructSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#structFieldSymbol.
+ def enterStructFieldSymbol(self, ctx:TParser.StructFieldSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#structFieldSymbol.
+ def exitStructFieldSymbol(self, ctx:TParser.StructFieldSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#enumSymbol.
+ def enterEnumSymbol(self, ctx:TParser.EnumSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#enumSymbol.
+ def exitEnumSymbol(self, ctx:TParser.EnumSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#enumTypeSymbol.
+ def enterEnumTypeSymbol(self, ctx:TParser.EnumTypeSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#enumTypeSymbol.
+ def exitEnumTypeSymbol(self, ctx:TParser.EnumTypeSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#enumMemberSymbol.
+ def enterEnumMemberSymbol(self, ctx:TParser.EnumMemberSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#enumMemberSymbol.
+ def exitEnumMemberSymbol(self, ctx:TParser.EnumMemberSymbolContext):
+ pass
+
+
+ # Enter a parse tree produced by TParser#intSymbol.
+ def enterIntSymbol(self, ctx:TParser.IntSymbolContext):
+ pass
+
+ # Exit a parse tree produced by TParser#intSymbol.
+ def exitIntSymbol(self, ctx:TParser.IntSymbolContext):
+ pass
+
+
diff --git a/qface/idl/parser/TParser.py b/qface/idl/parser/TParser.py
new file mode 100644
index 0000000..a1b0c4e
--- /dev/null
+++ b/qface/idl/parser/TParser.py
@@ -0,0 +1,1669 @@
+# Generated from T.g4 by ANTLR 4.5.3
+# encoding: utf-8
+from antlr4 import *
+from io import StringIO
+
+def serializedATN():
+ with StringIO() as buf:
+ buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3#")
+ buf.write("\u00d7\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\3\2\3\2\7\2/\n\2\f\2\16")
+ buf.write("\2\62\13\2\3\3\3\3\7\3\66\n\3\f\3\16\39\13\3\3\4\3\4\3")
+ buf.write("\4\3\4\5\4?\n\4\3\5\5\5B\n\5\3\5\3\5\3\5\3\5\5\5H\n\5")
+ buf.write("\3\6\3\6\3\6\5\6M\n\6\3\7\5\7P\n\7\3\7\3\7\3\7\3\7\7\7")
+ buf.write("V\n\7\f\7\16\7Y\13\7\3\7\3\7\3\b\3\b\5\b_\n\b\3\t\5\t")
+ buf.write("b\n\t\3\t\5\te\n\t\3\t\3\t\5\ti\n\t\3\t\3\t\3\t\7\tn\n")
+ buf.write("\t\f\t\16\tq\13\t\3\t\3\t\5\tu\n\t\3\n\5\nx\n\n\3\n\5")
+ buf.write("\n{\n\n\3\n\3\n\3\n\5\n\u0080\n\n\3\13\3\13\3\13\5\13")
+ buf.write("\u0085\n\13\3\f\3\f\3\f\3\f\5\f\u008b\n\f\3\r\3\r\3\16")
+ buf.write("\3\16\3\16\3\16\3\16\5\16\u0094\n\16\3\17\3\17\3\17\3")
+ buf.write("\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\5\21\u00a1\n\21")
+ buf.write("\3\21\3\21\3\21\3\21\7\21\u00a7\n\21\f\21\16\21\u00aa")
+ buf.write("\13\21\3\21\3\21\3\22\5\22\u00af\n\22\3\22\3\22\3\22\5")
+ buf.write("\22\u00b4\n\22\3\23\5\23\u00b7\n\23\3\23\3\23\3\23\3\23")
+ buf.write("\7\23\u00bd\n\23\f\23\16\23\u00c0\13\23\3\23\3\23\3\24")
+ buf.write("\3\24\5\24\u00c6\n\24\3\25\5\25\u00c9\n\25\3\25\3\25\3")
+ buf.write("\25\5\25\u00ce\n\25\3\25\5\25\u00d1\n\25\3\26\3\26\5\26")
+ buf.write("\u00d5\n\26\3\26\2\2\27\2\4\6\b\n\f\16\20\22\24\26\30")
+ buf.write("\32\34\36 \"$&(*\2\2\u00e6\2,\3\2\2\2\4\63\3\2\2\2\6:")
+ buf.write("\3\2\2\2\bA\3\2\2\2\nL\3\2\2\2\fO\3\2\2\2\16^\3\2\2\2")
+ buf.write("\20a\3\2\2\2\22w\3\2\2\2\24\u0081\3\2\2\2\26\u008a\3\2")
+ buf.write("\2\2\30\u008c\3\2\2\2\32\u0093\3\2\2\2\34\u0095\3\2\2")
+ buf.write("\2\36\u009a\3\2\2\2 \u00a0\3\2\2\2\"\u00ae\3\2\2\2$\u00b6")
+ buf.write("\3\2\2\2&\u00c5\3\2\2\2(\u00c8\3\2\2\2*\u00d4\3\2\2\2")
+ buf.write(",\60\5\4\3\2-/\5\n\6\2.-\3\2\2\2/\62\3\2\2\2\60.\3\2\2")
+ buf.write("\2\60\61\3\2\2\2\61\3\3\2\2\2\62\60\3\2\2\2\63\67\5\b")
+ buf.write("\5\2\64\66\5\6\4\2\65\64\3\2\2\2\669\3\2\2\2\67\65\3\2")
+ buf.write("\2\2\678\3\2\2\28\5\3\2\2\29\67\3\2\2\2:;\7\3\2\2;<\7")
+ buf.write("\36\2\2<>\7\37\2\2=?\7\4\2\2>=\3\2\2\2>?\3\2\2\2?\7\3")
+ buf.write("\2\2\2@B\7 \2\2A@\3\2\2\2AB\3\2\2\2BC\3\2\2\2CD\7\5\2")
+ buf.write("\2DE\7\36\2\2EG\7\37\2\2FH\7\4\2\2GF\3\2\2\2GH\3\2\2\2")
+ buf.write("H\t\3\2\2\2IM\5\f\7\2JM\5 \21\2KM\5$\23\2LI\3\2\2\2LJ")
+ buf.write("\3\2\2\2LK\3\2\2\2M\13\3\2\2\2NP\7 \2\2ON\3\2\2\2OP\3")
+ buf.write("\2\2\2PQ\3\2\2\2QR\7\6\2\2RS\7\36\2\2SW\7\7\2\2TV\5\16")
+ buf.write("\b\2UT\3\2\2\2VY\3\2\2\2WU\3\2\2\2WX\3\2\2\2XZ\3\2\2\2")
+ buf.write("YW\3\2\2\2Z[\7\b\2\2[\r\3\2\2\2\\_\5\20\t\2]_\5\22\n\2")
+ buf.write("^\\\3\2\2\2^]\3\2\2\2_\17\3\2\2\2`b\7 \2\2a`\3\2\2\2a")
+ buf.write("b\3\2\2\2bd\3\2\2\2ce\7\t\2\2dc\3\2\2\2de\3\2\2\2eh\3")
+ buf.write("\2\2\2fi\5\26\f\2gi\7\n\2\2hf\3\2\2\2hg\3\2\2\2ij\3\2")
+ buf.write("\2\2jk\7\36\2\2ko\7\13\2\2ln\5\24\13\2ml\3\2\2\2nq\3\2")
+ buf.write("\2\2om\3\2\2\2op\3\2\2\2pr\3\2\2\2qo\3\2\2\2rt\7\f\2\2")
+ buf.write("su\7\4\2\2ts\3\2\2\2tu\3\2\2\2u\21\3\2\2\2vx\7 \2\2wv")
+ buf.write("\3\2\2\2wx\3\2\2\2xz\3\2\2\2y{\7\r\2\2zy\3\2\2\2z{\3\2")
+ buf.write("\2\2{|\3\2\2\2|}\5\26\f\2}\177\7\36\2\2~\u0080\7\4\2\2")
+ buf.write("\177~\3\2\2\2\177\u0080\3\2\2\2\u0080\23\3\2\2\2\u0081")
+ buf.write("\u0082\5\26\f\2\u0082\u0084\7\36\2\2\u0083\u0085\7\16")
+ buf.write("\2\2\u0084\u0083\3\2\2\2\u0084\u0085\3\2\2\2\u0085\25")
+ buf.write("\3\2\2\2\u0086\u008b\5\32\16\2\u0087\u008b\5\30\r\2\u0088")
+ buf.write("\u008b\5\34\17\2\u0089\u008b\5\36\20\2\u008a\u0086\3\2")
+ buf.write("\2\2\u008a\u0087\3\2\2\2\u008a\u0088\3\2\2\2\u008a\u0089")
+ buf.write("\3\2\2\2\u008b\27\3\2\2\2\u008c\u008d\7\36\2\2\u008d\31")
+ buf.write("\3\2\2\2\u008e\u0094\7\17\2\2\u008f\u0094\7\20\2\2\u0090")
+ buf.write("\u0094\7\21\2\2\u0091\u0094\7\22\2\2\u0092\u0094\7\23")
+ buf.write("\2\2\u0093\u008e\3\2\2\2\u0093\u008f\3\2\2\2\u0093\u0090")
+ buf.write("\3\2\2\2\u0093\u0091\3\2\2\2\u0093\u0092\3\2\2\2\u0094")
+ buf.write("\33\3\2\2\2\u0095\u0096\7\24\2\2\u0096\u0097\7\25\2\2")
+ buf.write("\u0097\u0098\5\26\f\2\u0098\u0099\7\26\2\2\u0099\35\3")
+ buf.write("\2\2\2\u009a\u009b\7\27\2\2\u009b\u009c\7\25\2\2\u009c")
+ buf.write("\u009d\5\26\f\2\u009d\u009e\7\26\2\2\u009e\37\3\2\2\2")
+ buf.write("\u009f\u00a1\7 \2\2\u00a0\u009f\3\2\2\2\u00a0\u00a1\3")
+ buf.write("\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\u00a3\7\30\2\2\u00a3")
+ buf.write("\u00a4\7\36\2\2\u00a4\u00a8\7\7\2\2\u00a5\u00a7\5\"\22")
+ buf.write("\2\u00a6\u00a5\3\2\2\2\u00a7\u00aa\3\2\2\2\u00a8\u00a6")
+ buf.write("\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00ab\3\2\2\2\u00aa")
+ buf.write("\u00a8\3\2\2\2\u00ab\u00ac\7\b\2\2\u00ac!\3\2\2\2\u00ad")
+ buf.write("\u00af\7 \2\2\u00ae\u00ad\3\2\2\2\u00ae\u00af\3\2\2\2")
+ buf.write("\u00af\u00b0\3\2\2\2\u00b0\u00b1\5\26\f\2\u00b1\u00b3")
+ buf.write("\7\36\2\2\u00b2\u00b4\7\4\2\2\u00b3\u00b2\3\2\2\2\u00b3")
+ buf.write("\u00b4\3\2\2\2\u00b4#\3\2\2\2\u00b5\u00b7\7 \2\2\u00b6")
+ buf.write("\u00b5\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00b8\3\2\2\2")
+ buf.write("\u00b8\u00b9\5&\24\2\u00b9\u00ba\7\36\2\2\u00ba\u00be")
+ buf.write("\7\7\2\2\u00bb\u00bd\5(\25\2\u00bc\u00bb\3\2\2\2\u00bd")
+ buf.write("\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2")
+ buf.write("\u00bf\u00c1\3\2\2\2\u00c0\u00be\3\2\2\2\u00c1\u00c2\7")
+ buf.write("\b\2\2\u00c2%\3\2\2\2\u00c3\u00c6\7\31\2\2\u00c4\u00c6")
+ buf.write("\7\32\2\2\u00c5\u00c3\3\2\2\2\u00c5\u00c4\3\2\2\2\u00c6")
+ buf.write("\'\3\2\2\2\u00c7\u00c9\7 \2\2\u00c8\u00c7\3\2\2\2\u00c8")
+ buf.write("\u00c9\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cd\7\36\2")
+ buf.write("\2\u00cb\u00cc\7\33\2\2\u00cc\u00ce\5*\26\2\u00cd\u00cb")
+ buf.write("\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00d0\3\2\2\2\u00cf")
+ buf.write("\u00d1\7\16\2\2\u00d0\u00cf\3\2\2\2\u00d0\u00d1\3\2\2")
+ buf.write("\2\u00d1)\3\2\2\2\u00d2\u00d5\7\34\2\2\u00d3\u00d5\7\35")
+ buf.write("\2\2\u00d4\u00d2\3\2\2\2\u00d4\u00d3\3\2\2\2\u00d5+\3")
+ buf.write("\2\2\2!\60\67>AGLOW^adhotwz\177\u0084\u008a\u0093\u00a0")
+ buf.write("\u00a8\u00ae\u00b3\u00b6\u00be\u00c5\u00c8\u00cd\u00d0")
+ buf.write("\u00d4")
+ return buf.getvalue()
+
+
+class TParser ( Parser ):
+
+ grammarFileName = "T.g4"
+
+ atn = ATNDeserializer().deserialize(serializedATN())
+
+ decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+ sharedContextCache = PredictionContextCache()
+
+ literalNames = [ "<INVALID>", "'import'", "';'", "'module'", "'interface'",
+ "'{'", "'}'", "'event'", "'void'", "'('", "')'", "'readonly'",
+ "','", "'bool'", "'int'", "'real'", "'string'", "'var'",
+ "'list'", "'<'", "'>'", "'model'", "'struct'", "'enum'",
+ "'flag'", "'='" ]
+
+ symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "INTCONSTANT", "HEXCONSTANT",
+ "IDENTIFIER", "VERSION", "DOCCOMMENT", "WHITESPACE",
+ "COMMENT", "MULTICOMM" ]
+
+ RULE_documentSymbol = 0
+ RULE_headerSymbol = 1
+ RULE_importSymbol = 2
+ RULE_moduleSymbol = 3
+ RULE_definitionSymbol = 4
+ RULE_interfaceSymbol = 5
+ RULE_interfaceMemberSymbol = 6
+ RULE_operationSymbol = 7
+ RULE_propertySymbol = 8
+ RULE_operationParameterSymbol = 9
+ RULE_typeSymbol = 10
+ RULE_complexTypeSymbol = 11
+ RULE_primitiveTypeSymbol = 12
+ RULE_listTypeSymbol = 13
+ RULE_modelTypeSymbol = 14
+ RULE_structSymbol = 15
+ RULE_structFieldSymbol = 16
+ RULE_enumSymbol = 17
+ RULE_enumTypeSymbol = 18
+ RULE_enumMemberSymbol = 19
+ RULE_intSymbol = 20
+
+ ruleNames = [ "documentSymbol", "headerSymbol", "importSymbol", "moduleSymbol",
+ "definitionSymbol", "interfaceSymbol", "interfaceMemberSymbol",
+ "operationSymbol", "propertySymbol", "operationParameterSymbol",
+ "typeSymbol", "complexTypeSymbol", "primitiveTypeSymbol",
+ "listTypeSymbol", "modelTypeSymbol", "structSymbol",
+ "structFieldSymbol", "enumSymbol", "enumTypeSymbol",
+ "enumMemberSymbol", "intSymbol" ]
+
+ EOF = Token.EOF
+ T__0=1
+ T__1=2
+ T__2=3
+ T__3=4
+ T__4=5
+ T__5=6
+ T__6=7
+ T__7=8
+ T__8=9
+ T__9=10
+ T__10=11
+ T__11=12
+ T__12=13
+ T__13=14
+ T__14=15
+ T__15=16
+ T__16=17
+ T__17=18
+ T__18=19
+ T__19=20
+ T__20=21
+ T__21=22
+ T__22=23
+ T__23=24
+ T__24=25
+ INTCONSTANT=26
+ HEXCONSTANT=27
+ IDENTIFIER=28
+ VERSION=29
+ DOCCOMMENT=30
+ WHITESPACE=31
+ COMMENT=32
+ MULTICOMM=33
+
+ def __init__(self, input:TokenStream):
+ super().__init__(input)
+ self.checkVersion("4.5.3")
+ self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+ self._predicates = None
+
+
+
+ class DocumentSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def headerSymbol(self):
+ return self.getTypedRuleContext(TParser.HeaderSymbolContext,0)
+
+
+ def definitionSymbol(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(TParser.DefinitionSymbolContext)
+ else:
+ return self.getTypedRuleContext(TParser.DefinitionSymbolContext,i)
+
+
+ def getRuleIndex(self):
+ return TParser.RULE_documentSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterDocumentSymbol" ):
+ listener.enterDocumentSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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)
+
+
+
+
+ def documentSymbol(self):
+
+ localctx = TParser.DocumentSymbolContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 0, self.RULE_documentSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 42
+ self.headerSymbol()
+ self.state = 46
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__3) | (1 << TParser.T__21) | (1 << TParser.T__22) | (1 << TParser.T__23) | (1 << TParser.DOCCOMMENT))) != 0):
+ self.state = 43
+ self.definitionSymbol()
+ self.state = 48
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class HeaderSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def moduleSymbol(self):
+ return self.getTypedRuleContext(TParser.ModuleSymbolContext,0)
+
+
+ def importSymbol(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(TParser.ImportSymbolContext)
+ else:
+ return self.getTypedRuleContext(TParser.ImportSymbolContext,i)
+
+
+ def getRuleIndex(self):
+ return TParser.RULE_headerSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterHeaderSymbol" ):
+ listener.enterHeaderSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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)
+
+
+
+
+ def headerSymbol(self):
+
+ localctx = TParser.HeaderSymbolContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 2, self.RULE_headerSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 49
+ self.moduleSymbol()
+ self.state = 53
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==TParser.T__0:
+ self.state = 50
+ self.importSymbol()
+ self.state = 55
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class ImportSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.name = None # Token
+ self.version = None # Token
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def VERSION(self):
+ return self.getToken(TParser.VERSION, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_importSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterImportSymbol" ):
+ listener.enterImportSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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)
+
+
+
+
+ def importSymbol(self):
+
+ localctx = TParser.ImportSymbolContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 4, self.RULE_importSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 56
+ self.match(TParser.T__0)
+ self.state = 57
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 58
+ localctx.version = self.match(TParser.VERSION)
+ self.state = 60
+ _la = self._input.LA(1)
+ if _la==TParser.T__1:
+ self.state = 59
+ self.match(TParser.T__1)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class ModuleSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.comment = None # Token
+ self.name = None # Token
+ self.version = None # Token
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def VERSION(self):
+ return self.getToken(TParser.VERSION, 0)
+
+ def DOCCOMMENT(self):
+ return self.getToken(TParser.DOCCOMMENT, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_moduleSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterModuleSymbol" ):
+ listener.enterModuleSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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)
+
+
+
+
+ def moduleSymbol(self):
+
+ localctx = TParser.ModuleSymbolContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 6, self.RULE_moduleSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 63
+ _la = self._input.LA(1)
+ if _la==TParser.DOCCOMMENT:
+ self.state = 62
+ localctx.comment = self.match(TParser.DOCCOMMENT)
+
+
+ self.state = 65
+ self.match(TParser.T__2)
+ self.state = 66
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 67
+ localctx.version = self.match(TParser.VERSION)
+ self.state = 69
+ _la = self._input.LA(1)
+ if _la==TParser.T__1:
+ self.state = 68
+ self.match(TParser.T__1)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class DefinitionSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def interfaceSymbol(self):
+ return self.getTypedRuleContext(TParser.InterfaceSymbolContext,0)
+
+
+ def structSymbol(self):
+ return self.getTypedRuleContext(TParser.StructSymbolContext,0)
+
+
+ def enumSymbol(self):
+ return self.getTypedRuleContext(TParser.EnumSymbolContext,0)
+
+
+ def getRuleIndex(self):
+ return TParser.RULE_definitionSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterDefinitionSymbol" ):
+ listener.enterDefinitionSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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)
+
+
+
+
+ def definitionSymbol(self):
+
+ localctx = TParser.DefinitionSymbolContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 8, self.RULE_definitionSymbol)
+ try:
+ self.state = 74
+ self._errHandler.sync(self);
+ la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
+ if la_ == 1:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 71
+ self.interfaceSymbol()
+ pass
+
+ elif la_ == 2:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 72
+ self.structSymbol()
+ pass
+
+ elif la_ == 3:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 73
+ self.enumSymbol()
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class InterfaceSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.comment = None # Token
+ self.name = None # Token
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def interfaceMemberSymbol(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(TParser.InterfaceMemberSymbolContext)
+ else:
+ return self.getTypedRuleContext(TParser.InterfaceMemberSymbolContext,i)
+
+
+ def DOCCOMMENT(self):
+ return self.getToken(TParser.DOCCOMMENT, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_interfaceSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterInterfaceSymbol" ):
+ listener.enterInterfaceSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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)
+
+
+
+
+ def interfaceSymbol(self):
+
+ localctx = TParser.InterfaceSymbolContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 10, self.RULE_interfaceSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 77
+ _la = self._input.LA(1)
+ if _la==TParser.DOCCOMMENT:
+ self.state = 76
+ localctx.comment = self.match(TParser.DOCCOMMENT)
+
+
+ self.state = 79
+ self.match(TParser.T__3)
+ self.state = 80
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 81
+ self.match(TParser.T__4)
+ self.state = 85
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__6) | (1 << TParser.T__7) | (1 << TParser.T__10) | (1 << TParser.T__12) | (1 << TParser.T__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__20) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
+ self.state = 82
+ self.interfaceMemberSymbol()
+ self.state = 87
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 88
+ self.match(TParser.T__5)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class InterfaceMemberSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def operationSymbol(self):
+ return self.getTypedRuleContext(TParser.OperationSymbolContext,0)
+
+
+ def propertySymbol(self):
+ return self.getTypedRuleContext(TParser.PropertySymbolContext,0)
+
+
+ def getRuleIndex(self):
+ return TParser.RULE_interfaceMemberSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterInterfaceMemberSymbol" ):
+ listener.enterInterfaceMemberSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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)
+
+
+
+
+ def interfaceMemberSymbol(self):
+
+ localctx = TParser.InterfaceMemberSymbolContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 12, self.RULE_interfaceMemberSymbol)
+ try:
+ self.state = 92
+ self._errHandler.sync(self);
+ la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
+ if la_ == 1:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 90
+ self.operationSymbol()
+ pass
+
+ elif la_ == 2:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 91
+ self.propertySymbol()
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class OperationSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.comment = None # Token
+ self.isEvent = None # Token
+ self.name = None # Token
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def typeSymbol(self):
+ return self.getTypedRuleContext(TParser.TypeSymbolContext,0)
+
+
+ def operationParameterSymbol(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(TParser.OperationParameterSymbolContext)
+ else:
+ return self.getTypedRuleContext(TParser.OperationParameterSymbolContext,i)
+
+
+ def DOCCOMMENT(self):
+ return self.getToken(TParser.DOCCOMMENT, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_operationSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterOperationSymbol" ):
+ listener.enterOperationSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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)
+
+
+
+
+ def operationSymbol(self):
+
+ localctx = TParser.OperationSymbolContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 14, self.RULE_operationSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 95
+ _la = self._input.LA(1)
+ if _la==TParser.DOCCOMMENT:
+ self.state = 94
+ localctx.comment = self.match(TParser.DOCCOMMENT)
+
+
+ self.state = 98
+ _la = self._input.LA(1)
+ if _la==TParser.T__6:
+ self.state = 97
+ localctx.isEvent = self.match(TParser.T__6)
+
+
+ self.state = 102
+ token = self._input.LA(1)
+ if token in [TParser.T__12, TParser.T__13, TParser.T__14, TParser.T__15, TParser.T__16, TParser.T__17, TParser.T__20, TParser.IDENTIFIER]:
+ self.state = 100
+ self.typeSymbol()
+
+ elif token in [TParser.T__7]:
+ self.state = 101
+ self.match(TParser.T__7)
+
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 104
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 105
+ self.match(TParser.T__8)
+ self.state = 109
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__12) | (1 << TParser.T__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__20) | (1 << TParser.IDENTIFIER))) != 0):
+ self.state = 106
+ self.operationParameterSymbol()
+ self.state = 111
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 112
+ self.match(TParser.T__9)
+ self.state = 114
+ _la = self._input.LA(1)
+ if _la==TParser.T__1:
+ self.state = 113
+ self.match(TParser.T__1)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class PropertySymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.comment = None # Token
+ self.isReadOnly = None # Token
+ self.name = None # Token
+
+ def typeSymbol(self):
+ return self.getTypedRuleContext(TParser.TypeSymbolContext,0)
+
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def DOCCOMMENT(self):
+ return self.getToken(TParser.DOCCOMMENT, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_propertySymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterPropertySymbol" ):
+ listener.enterPropertySymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 16, self.RULE_propertySymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 117
+ _la = self._input.LA(1)
+ if _la==TParser.DOCCOMMENT:
+ self.state = 116
+ localctx.comment = self.match(TParser.DOCCOMMENT)
+
+
+ self.state = 120
+ _la = self._input.LA(1)
+ if _la==TParser.T__10:
+ self.state = 119
+ localctx.isReadOnly = self.match(TParser.T__10)
+
+
+ self.state = 122
+ self.typeSymbol()
+ self.state = 123
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 125
+ _la = self._input.LA(1)
+ if _la==TParser.T__1:
+ self.state = 124
+ self.match(TParser.T__1)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class OperationParameterSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.name = None # Token
+
+ def typeSymbol(self):
+ return self.getTypedRuleContext(TParser.TypeSymbolContext,0)
+
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_operationParameterSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterOperationParameterSymbol" ):
+ listener.enterOperationParameterSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 18, self.RULE_operationParameterSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 127
+ self.typeSymbol()
+ self.state = 128
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 130
+ _la = self._input.LA(1)
+ if _la==TParser.T__11:
+ self.state = 129
+ self.match(TParser.T__11)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class TypeSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def primitiveTypeSymbol(self):
+ return self.getTypedRuleContext(TParser.PrimitiveTypeSymbolContext,0)
+
+
+ def complexTypeSymbol(self):
+ return self.getTypedRuleContext(TParser.ComplexTypeSymbolContext,0)
+
+
+ def listTypeSymbol(self):
+ return self.getTypedRuleContext(TParser.ListTypeSymbolContext,0)
+
+
+ def modelTypeSymbol(self):
+ return self.getTypedRuleContext(TParser.ModelTypeSymbolContext,0)
+
+
+ def getRuleIndex(self):
+ return TParser.RULE_typeSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterTypeSymbol" ):
+ listener.enterTypeSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 20, self.RULE_typeSymbol)
+ try:
+ self.state = 136
+ token = self._input.LA(1)
+ if token in [TParser.T__12, TParser.T__13, TParser.T__14, TParser.T__15, TParser.T__16]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 132
+ self.primitiveTypeSymbol()
+
+ elif token in [TParser.IDENTIFIER]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 133
+ self.complexTypeSymbol()
+
+ elif token in [TParser.T__17]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 134
+ self.listTypeSymbol()
+
+ elif token in [TParser.T__20]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 135
+ self.modelTypeSymbol()
+
+ 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 ComplexTypeSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.name = None # Token
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_complexTypeSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterComplexTypeSymbol" ):
+ listener.enterComplexTypeSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 22, self.RULE_complexTypeSymbol)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 138
+ localctx.name = self.match(TParser.IDENTIFIER)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class PrimitiveTypeSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.name = None # Token
+
+
+ def getRuleIndex(self):
+ return TParser.RULE_primitiveTypeSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterPrimitiveTypeSymbol" ):
+ listener.enterPrimitiveTypeSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 24, self.RULE_primitiveTypeSymbol)
+ try:
+ self.state = 145
+ token = self._input.LA(1)
+ if token in [TParser.T__12]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 140
+ localctx.name = self.match(TParser.T__12)
+
+ elif token in [TParser.T__13]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 141
+ localctx.name = self.match(TParser.T__13)
+
+ elif token in [TParser.T__14]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 142
+ localctx.name = self.match(TParser.T__14)
+
+ elif token in [TParser.T__15]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 143
+ localctx.name = self.match(TParser.T__15)
+
+ elif token in [TParser.T__16]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 144
+ localctx.name = self.match(TParser.T__16)
+
+ 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 ListTypeSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.valueType = None # TypeSymbolContext
+
+ def typeSymbol(self):
+ return self.getTypedRuleContext(TParser.TypeSymbolContext,0)
+
+
+ def getRuleIndex(self):
+ return TParser.RULE_listTypeSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterListTypeSymbol" ):
+ listener.enterListTypeSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 26, self.RULE_listTypeSymbol)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 147
+ self.match(TParser.T__17)
+ self.state = 148
+ self.match(TParser.T__18)
+ self.state = 149
+ localctx.valueType = self.typeSymbol()
+ self.state = 150
+ self.match(TParser.T__19)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class ModelTypeSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.valueType = None # TypeSymbolContext
+
+ def typeSymbol(self):
+ return self.getTypedRuleContext(TParser.TypeSymbolContext,0)
+
+
+ def getRuleIndex(self):
+ return TParser.RULE_modelTypeSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterModelTypeSymbol" ):
+ listener.enterModelTypeSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 28, self.RULE_modelTypeSymbol)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 152
+ self.match(TParser.T__20)
+ self.state = 153
+ self.match(TParser.T__18)
+ self.state = 154
+ localctx.valueType = self.typeSymbol()
+ self.state = 155
+ self.match(TParser.T__19)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class StructSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.comment = None # Token
+ self.name = None # Token
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def structFieldSymbol(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(TParser.StructFieldSymbolContext)
+ else:
+ return self.getTypedRuleContext(TParser.StructFieldSymbolContext,i)
+
+
+ def DOCCOMMENT(self):
+ return self.getToken(TParser.DOCCOMMENT, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_structSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterStructSymbol" ):
+ listener.enterStructSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 30, self.RULE_structSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 158
+ _la = self._input.LA(1)
+ if _la==TParser.DOCCOMMENT:
+ self.state = 157
+ localctx.comment = self.match(TParser.DOCCOMMENT)
+
+
+ self.state = 160
+ self.match(TParser.T__21)
+ self.state = 161
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 162
+ self.match(TParser.T__4)
+ self.state = 166
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__12) | (1 << TParser.T__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__20) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
+ self.state = 163
+ self.structFieldSymbol()
+ self.state = 168
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 169
+ self.match(TParser.T__5)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class StructFieldSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.comment = None # Token
+ self.name = None # Token
+
+ def typeSymbol(self):
+ return self.getTypedRuleContext(TParser.TypeSymbolContext,0)
+
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def DOCCOMMENT(self):
+ return self.getToken(TParser.DOCCOMMENT, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_structFieldSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterStructFieldSymbol" ):
+ listener.enterStructFieldSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 32, self.RULE_structFieldSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 172
+ _la = self._input.LA(1)
+ if _la==TParser.DOCCOMMENT:
+ self.state = 171
+ localctx.comment = self.match(TParser.DOCCOMMENT)
+
+
+ self.state = 174
+ self.typeSymbol()
+ self.state = 175
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 177
+ _la = self._input.LA(1)
+ if _la==TParser.T__1:
+ self.state = 176
+ self.match(TParser.T__1)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class EnumSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.comment = None # Token
+ self.name = None # Token
+
+ def enumTypeSymbol(self):
+ return self.getTypedRuleContext(TParser.EnumTypeSymbolContext,0)
+
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def enumMemberSymbol(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(TParser.EnumMemberSymbolContext)
+ else:
+ return self.getTypedRuleContext(TParser.EnumMemberSymbolContext,i)
+
+
+ def DOCCOMMENT(self):
+ return self.getToken(TParser.DOCCOMMENT, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_enumSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterEnumSymbol" ):
+ listener.enterEnumSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 34, self.RULE_enumSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 180
+ _la = self._input.LA(1)
+ if _la==TParser.DOCCOMMENT:
+ self.state = 179
+ localctx.comment = self.match(TParser.DOCCOMMENT)
+
+
+ self.state = 182
+ self.enumTypeSymbol()
+ self.state = 183
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 184
+ self.match(TParser.T__4)
+ self.state = 188
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==TParser.IDENTIFIER or _la==TParser.DOCCOMMENT:
+ self.state = 185
+ self.enumMemberSymbol()
+ self.state = 190
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 191
+ self.match(TParser.T__5)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class EnumTypeSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.isEnum = None # Token
+ self.isFlag = None # Token
+
+
+ def getRuleIndex(self):
+ return TParser.RULE_enumTypeSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterEnumTypeSymbol" ):
+ listener.enterEnumTypeSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 36, self.RULE_enumTypeSymbol)
+ try:
+ self.state = 195
+ token = self._input.LA(1)
+ if token in [TParser.T__22]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 193
+ localctx.isEnum = self.match(TParser.T__22)
+
+ elif token in [TParser.T__23]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 194
+ localctx.isFlag = self.match(TParser.T__23)
+
+ 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 EnumMemberSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.comment = None # Token
+ self.name = None # Token
+
+ def IDENTIFIER(self):
+ return self.getToken(TParser.IDENTIFIER, 0)
+
+ def intSymbol(self):
+ return self.getTypedRuleContext(TParser.IntSymbolContext,0)
+
+
+ def DOCCOMMENT(self):
+ return self.getToken(TParser.DOCCOMMENT, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_enumMemberSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterEnumMemberSymbol" ):
+ listener.enterEnumMemberSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 38, self.RULE_enumMemberSymbol)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 198
+ _la = self._input.LA(1)
+ if _la==TParser.DOCCOMMENT:
+ self.state = 197
+ localctx.comment = self.match(TParser.DOCCOMMENT)
+
+
+ self.state = 200
+ localctx.name = self.match(TParser.IDENTIFIER)
+ self.state = 203
+ _la = self._input.LA(1)
+ if _la==TParser.T__24:
+ self.state = 201
+ self.match(TParser.T__24)
+ self.state = 202
+ self.intSymbol()
+
+
+ self.state = 206
+ _la = self._input.LA(1)
+ if _la==TParser.T__11:
+ self.state = 205
+ self.match(TParser.T__11)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+ class IntSymbolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.value = None # Token
+
+ def INTCONSTANT(self):
+ return self.getToken(TParser.INTCONSTANT, 0)
+
+ def HEXCONSTANT(self):
+ return self.getToken(TParser.HEXCONSTANT, 0)
+
+ def getRuleIndex(self):
+ return TParser.RULE_intSymbol
+
+ def enterRule(self, listener:ParseTreeListener):
+ if hasattr( listener, "enterIntSymbol" ):
+ listener.enterIntSymbol(self)
+
+ def exitRule(self, listener:ParseTreeListener):
+ 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, 40, self.RULE_intSymbol)
+ try:
+ self.state = 210
+ token = self._input.LA(1)
+ if token in [TParser.INTCONSTANT]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 208
+ localctx.value = self.match(TParser.INTCONSTANT)
+
+ elif token in [TParser.HEXCONSTANT]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 209
+ localctx.value = self.match(TParser.HEXCONSTANT)
+
+ 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
+
+
+
+
+
diff --git a/qface/idl/parser/TVisitor.py b/qface/idl/parser/TVisitor.py
new file mode 100644
index 0000000..dee7f69
--- /dev/null
+++ b/qface/idl/parser/TVisitor.py
@@ -0,0 +1,118 @@
+# Generated from T.g4 by ANTLR 4.5.3
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+ from .TParser import TParser
+else:
+ from TParser import TParser
+
+# This class defines a complete generic visitor for a parse tree produced by TParser.
+
+class TVisitor(ParseTreeVisitor):
+
+ # Visit a parse tree produced by TParser#documentSymbol.
+ def visitDocumentSymbol(self, ctx:TParser.DocumentSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#headerSymbol.
+ def visitHeaderSymbol(self, ctx:TParser.HeaderSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#importSymbol.
+ def visitImportSymbol(self, ctx:TParser.ImportSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#moduleSymbol.
+ def visitModuleSymbol(self, ctx:TParser.ModuleSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#definitionSymbol.
+ def visitDefinitionSymbol(self, ctx:TParser.DefinitionSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#interfaceSymbol.
+ def visitInterfaceSymbol(self, ctx:TParser.InterfaceSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#interfaceMemberSymbol.
+ def visitInterfaceMemberSymbol(self, ctx:TParser.InterfaceMemberSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#operationSymbol.
+ def visitOperationSymbol(self, ctx:TParser.OperationSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#propertySymbol.
+ def visitPropertySymbol(self, ctx:TParser.PropertySymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#operationParameterSymbol.
+ def visitOperationParameterSymbol(self, ctx:TParser.OperationParameterSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#typeSymbol.
+ def visitTypeSymbol(self, ctx:TParser.TypeSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#complexTypeSymbol.
+ def visitComplexTypeSymbol(self, ctx:TParser.ComplexTypeSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#primitiveTypeSymbol.
+ def visitPrimitiveTypeSymbol(self, ctx:TParser.PrimitiveTypeSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#listTypeSymbol.
+ def visitListTypeSymbol(self, ctx:TParser.ListTypeSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#modelTypeSymbol.
+ def visitModelTypeSymbol(self, ctx:TParser.ModelTypeSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#structSymbol.
+ def visitStructSymbol(self, ctx:TParser.StructSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#structFieldSymbol.
+ def visitStructFieldSymbol(self, ctx:TParser.StructFieldSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#enumSymbol.
+ def visitEnumSymbol(self, ctx:TParser.EnumSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#enumTypeSymbol.
+ def visitEnumTypeSymbol(self, ctx:TParser.EnumTypeSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#enumMemberSymbol.
+ def visitEnumMemberSymbol(self, ctx:TParser.EnumMemberSymbolContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by TParser#intSymbol.
+ def visitIntSymbol(self, ctx:TParser.IntSymbolContext):
+ return self.visitChildren(ctx)
+
+
+
+del TParser \ No newline at end of file
diff --git a/qface/idl/parser/__init__.py b/qface/idl/parser/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/qface/idl/parser/__init__.py
View Lorry Controller Status