Revision: 1904
Author: jsuijs
Date: Fri Apr 9 12:51:17 2010
Log: updated grammar
http://code.google.com/p/jallib/source/detail?r=1904
Added:
/trunk/grammar/antlr-3.1.2.jar
/trunk/grammar/jal.tokens
/trunk/grammar/jalLexer.py
/trunk/grammar/jalParser.py
Modified:
/trunk/grammar/jal.g
=======================================
--- /dev/null
+++ /trunk/grammar/antlr-3.1.2.jar Fri Apr 9 12:51:17 2010
File is too large to display a diff.
=======================================
--- /dev/null
+++ /trunk/grammar/jal.tokens Fri Apr 9 12:51:17 2010
@@ -0,0 +1,141 @@
+T__68=68
+T__69=69
+T__66=66
+T__67=67
+T__64=64
+T__29=29
+T__65=65
+T__28=28
+T__62=62
+T__27=27
+T__63=63
+T__26=26
+T__25=25
+T__24=24
+LETTER=9
+T__23=23
+T__22=22
+T__21=21
+T__20=20
+PRAGMA=8
+T__61=61
+T__60=60
+HexDigit=14
+T__55=55
+T__19=19
+T__56=56
+T__57=57
+T__58=58
+STRING_LITERAL=5
+T__51=51
+IN=6
+T__52=52
+T__53=53
+T__54=54
+IDENTIFIER=4
+T__59=59
+BIN_LITERAL=10
+HEX_LITERAL=11
+T__50=50
+T__42=42
+T__43=43
+T__40=40
+T__41=41
+T__80=80
+T__46=46
+T__81=81
+T__47=47
+T__44=44
+T__45=45
+LINE_COMMENT=18
+T__48=48
+T__49=49
+OCTAL_LITERAL=12
+CHARACTER_LITERAL=7
+T__30=30
+T__31=31
+T__32=32
+WS=17
+T__71=71
+T__33=33
+T__72=72
+T__34=34
+T__35=35
+T__70=70
+T__36=36
+T__37=37
+T__38=38
+T__39=39
+T__76=76
+T__75=75
+T__74=74
+OctalEscape=16
+EscapeSequence=15
+DECIMAL_LITERAL=13
+T__73=73
+T__79=79
+T__78=78
+T__77=77
+'bit'=65
+'end'=33
+'out'=53
+'~'=81
+'/'=79
+'then'=39
+'include'=21
+'volatile'=52
+'return'=19
+'for'=29
+'+'=77
+'procedure'=47
+'elsif'=40
+'function'=51
+'loop'=31
+'^'=73
+'is'=50
+'byte'=66
+'_error'=23
+'>>'=76
+'else'=41
+'{'=26
+'\''=54
+'until'=37
+'shared'=63
+'var'=61
+'put'=55
+'if'=38
+':'=44
+'('=48
+'-'=78
+'while'=35
+'exit'=32
+'of'=43
+','=27
+'forever'=34
+'get'=56
+'using'=30
+']'=60
+'_debug'=22
+'|'=72
+'assert'=20
+'dword'=68
+'at'=64
+'const'=58
+'alias'=57
+'repeat'=36
+'sdword'=71
+'='=25
+'word'=67
+')'=49
+'%'=80
+'case'=42
+'}'=28
+'sbyte'=69
+'block'=46
+'<<'=75
+'otherwise'=45
+'_warn'=24
+'['=59
+'*'=62
+'&'=74
+'sword'=70
=======================================
--- /dev/null
+++ /trunk/grammar/jalLexer.py Fri Apr 9 12:51:17 2010
@@ -0,0 +1,3532 @@
+# $ANTLR 3.1.2 jal.g 2010-04-09 21:39:31
+
+import sys
+from antlr3 import *
+from antlr3.compat import set, frozenset
+
+
+# for convenience in actions
+HIDDEN = BaseRecognizer.HIDDEN
+
+# token types
+T__68=68
+T__69=69
+T__66=66
+T__67=67
+T__29=29
+T__64=64
+T__28=28
+T__65=65
+T__27=27
+T__62=62
+T__26=26
+T__63=63
+T__25=25
+T__24=24
+T__23=23
+LETTER=9
+T__22=22
+T__21=21
+T__20=20
+PRAGMA=8
+T__61=61
+EOF=-1
+T__60=60
+HexDigit=14
+T__55=55
+T__19=19
+T__56=56
+T__57=57
+T__58=58
+STRING_LITERAL=5
+T__51=51
+IN=6
+T__52=52
+T__53=53
+T__54=54
+IDENTIFIER=4
+T__59=59
+BIN_LITERAL=10
+HEX_LITERAL=11
+T__50=50
+T__42=42
+T__43=43
+T__40=40
+T__41=41
+T__46=46
+T__80=80
+T__47=47
+T__81=81
+T__44=44
+T__45=45
+LINE_COMMENT=18
+T__48=48
+T__49=49
+CHARACTER_LITERAL=7
+OCTAL_LITERAL=12
+T__30=30
+T__31=31
+T__32=32
+T__33=33
+T__71=71
+WS=17
+T__34=34
+T__72=72
+T__35=35
+T__36=36
+T__70=70
+T__37=37
+T__38=38
+T__39=39
+T__76=76
+T__75=75
+T__74=74
+T__73=73
+DECIMAL_LITERAL=13
+EscapeSequence=15
+OctalEscape=16
+T__79=79
+T__78=78
+T__77=77
+
+
+class jalLexer(Lexer):
+
+ grammarFileName = "jal.g"
+ antlr_version = version_str_to_tuple("3.1.2")
+ antlr_version_str = "3.1.2"
+
+ def __init__(self, input=None, state=None):
+ if state is None:
+ state = RecognizerSharedState()
+ Lexer.__init__(self, input, state)
+
+ self.dfa16 = self.DFA16(
+ self, 16,
+ eot = self.DFA16_eot,
+ eof = self.DFA16_eof,
+ min = self.DFA16_min,
+ max = self.DFA16_max,
+ accept = self.DFA16_accept,
+ special = self.DFA16_special,
+ transition = self.DFA16_transition
+ )
+
+
+
+
+
+
+ # $ANTLR start "T__19"
+ def mT__19(self, ):
+
+ try:
+ _type = T__19
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:7:7: ( 'return' )
+ # jal.g:7:9: 'return'
+ pass
+ self.match("return")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__19"
+
+
+
+ # $ANTLR start "T__20"
+ def mT__20(self, ):
+
+ try:
+ _type = T__20
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:8:7: ( 'assert' )
+ # jal.g:8:9: 'assert'
+ pass
+ self.match("assert")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__20"
+
+
+
+ # $ANTLR start "T__21"
+ def mT__21(self, ):
+
+ try:
+ _type = T__21
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:9:7: ( 'include' )
+ # jal.g:9:9: 'include'
+ pass
+ self.match("include")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__21"
+
+
+
+ # $ANTLR start "T__22"
+ def mT__22(self, ):
+
+ try:
+ _type = T__22
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:10:7: ( '_debug' )
+ # jal.g:10:9: '_debug'
+ pass
+ self.match("_debug")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__22"
+
+
+
+ # $ANTLR start "T__23"
+ def mT__23(self, ):
+
+ try:
+ _type = T__23
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:11:7: ( '_error' )
+ # jal.g:11:9: '_error'
+ pass
+ self.match("_error")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__23"
+
+
+
+ # $ANTLR start "T__24"
+ def mT__24(self, ):
+
+ try:
+ _type = T__24
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:12:7: ( '_warn' )
+ # jal.g:12:9: '_warn'
+ pass
+ self.match("_warn")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__24"
+
+
+
+ # $ANTLR start "T__25"
+ def mT__25(self, ):
+
+ try:
+ _type = T__25
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:13:7: ( '=' )
+ # jal.g:13:9: '='
+ pass
+ self.match(61)
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__25"
+
+
+
+ # $ANTLR start "T__26"
+ def mT__26(self, ):
+
+ try:
+ _type = T__26
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:14:7: ( '{' )
+ # jal.g:14:9: '{'
+ pass
+ self.match(123)
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__26"
+
+
+
+ # $ANTLR start "T__27"
+ def mT__27(self, ):
+
+ try:
+ _type = T__27
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:15:7: ( ',' )
+ # jal.g:15:9: ','
+ pass
+ self.match(44)
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__27"
+
+
+
+ # $ANTLR start "T__28"
+ def mT__28(self, ):
+
+ try:
+ _type = T__28
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:16:7: ( '}' )
+ # jal.g:16:9: '}'
+ pass
+ self.match(125)
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__28"
+
+
+
+ # $ANTLR start "T__29"
+ def mT__29(self, ):
+
+ try:
+ _type = T__29
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:17:7: ( 'for' )
+ # jal.g:17:9: 'for'
+ pass
+ self.match("for")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__29"
+
+
+
+ # $ANTLR start "T__30"
+ def mT__30(self, ):
+
+ try:
+ _type = T__30
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:18:7: ( 'using' )
+ # jal.g:18:9: 'using'
+ pass
+ self.match("using")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__30"
+
+
+
+ # $ANTLR start "T__31"
+ def mT__31(self, ):
+
+ try:
+ _type = T__31
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:19:7: ( 'loop' )
+ # jal.g:19:9: 'loop'
+ pass
+ self.match("loop")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__31"
+
+
+
+ # $ANTLR start "T__32"
+ def mT__32(self, ):
+
+ try:
+ _type = T__32
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:20:7: ( 'exit' )
+ # jal.g:20:9: 'exit'
+ pass
+ self.match("exit")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__32"
+
+
+
+ # $ANTLR start "T__33"
+ def mT__33(self, ):
+
+ try:
+ _type = T__33
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:21:7: ( 'end' )
+ # jal.g:21:9: 'end'
+ pass
+ self.match("end")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__33"
+
+
+
+ # $ANTLR start "T__34"
+ def mT__34(self, ):
+
+ try:
+ _type = T__34
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:22:7: ( 'forever' )
+ # jal.g:22:9: 'forever'
+ pass
+ self.match("forever")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__34"
+
+
+
+ # $ANTLR start "T__35"
+ def mT__35(self, ):
+
+ try:
+ _type = T__35
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:23:7: ( 'while' )
+ # jal.g:23:9: 'while'
+ pass
+ self.match("while")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__35"
+
+
+
+ # $ANTLR start "T__36"
+ def mT__36(self, ):
+
+ try:
+ _type = T__36
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:24:7: ( 'repeat' )
+ # jal.g:24:9: 'repeat'
+ pass
+ self.match("repeat")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__36"
+
+
+
+ # $ANTLR start "T__37"
+ def mT__37(self, ):
+
+ try:
+ _type = T__37
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:25:7: ( 'until' )
+ # jal.g:25:9: 'until'
+ pass
+ self.match("until")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__37"
+
+
+
+ # $ANTLR start "T__38"
+ def mT__38(self, ):
+
+ try:
+ _type = T__38
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:26:7: ( 'if' )
+ # jal.g:26:9: 'if'
+ pass
+ self.match("if")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__38"
+
+
+
+ # $ANTLR start "T__39"
+ def mT__39(self, ):
+
+ try:
+ _type = T__39
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:27:7: ( 'then' )
+ # jal.g:27:9: 'then'
+ pass
+ self.match("then")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__39"
+
+
+
+ # $ANTLR start "T__40"
+ def mT__40(self, ):
+
+ try:
+ _type = T__40
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:28:7: ( 'elsif' )
+ # jal.g:28:9: 'elsif'
+ pass
+ self.match("elsif")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__40"
+
+
+
+ # $ANTLR start "T__41"
+ def mT__41(self, ):
+
+ try:
+ _type = T__41
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:29:7: ( 'else' )
+ # jal.g:29:9: 'else'
+ pass
+ self.match("else")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__41"
+
+
+
+ # $ANTLR start "T__42"
+ def mT__42(self, ):
+
+ try:
+ _type = T__42
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:30:7: ( 'case' )
+ # jal.g:30:9: 'case'
+ pass
+ self.match("case")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__42"
+
+
+
+ # $ANTLR start "T__43"
+ def mT__43(self, ):
+
+ try:
+ _type = T__43
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:31:7: ( 'of' )
+ # jal.g:31:9: 'of'
+ pass
+ self.match("of")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__43"
+
+
+
+ # $ANTLR start "T__44"
+ def mT__44(self, ):
+
+ try:
+ _type = T__44
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:32:7: ( ':' )
+ # jal.g:32:9: ':'
+ pass
+ self.match(58)
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__44"
+
+
+
+ # $ANTLR start "T__45"
+ def mT__45(self, ):
+
+ try:
+ _type = T__45
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:33:7: ( 'otherwise' )
+ # jal.g:33:9: 'otherwise'
+ pass
+ self.match("otherwise")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__45"
+
+
+
+ # $ANTLR start "T__46"
+ def mT__46(self, ):
+
+ try:
+ _type = T__46
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:34:7: ( 'block' )
+ # jal.g:34:9: 'block'
+ pass
+ self.match("block")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__46"
+
+
+
+ # $ANTLR start "T__47"
+ def mT__47(self, ):
+
+ try:
+ _type = T__47
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:35:7: ( 'procedure' )
+ # jal.g:35:9: 'procedure'
+ pass
+ self.match("procedure")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__47"
+
+
+
+ # $ANTLR start "T__48"
+ def mT__48(self, ):
+
+ try:
+ _type = T__48
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:36:7: ( '(' )
+ # jal.g:36:9: '('
+ pass
+ self.match(40)
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__48"
+
+
+
+ # $ANTLR start "T__49"
+ def mT__49(self, ):
+
+ try:
+ _type = T__49
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:37:7: ( ')' )
+ # jal.g:37:9: ')'
+ pass
+ self.match(41)
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__49"
+
+
+
+ # $ANTLR start "T__50"
+ def mT__50(self, ):
+
+ try:
+ _type = T__50
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:38:7: ( 'is' )
+ # jal.g:38:9: 'is'
+ pass
+ self.match("is")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__50"
+
+
+
+ # $ANTLR start "T__51"
+ def mT__51(self, ):
+
+ try:
+ _type = T__51
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:39:7: ( 'function' )
+ # jal.g:39:9: 'function'
+ pass
+ self.match("function")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__51"
+
+
+
+ # $ANTLR start "T__52"
+ def mT__52(self, ):
+
+ try:
+ _type = T__52
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:40:7: ( 'volatile' )
+ # jal.g:40:9: 'volatile'
+ pass
+ self.match("volatile")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__52"
+
+
+
+ # $ANTLR start "T__53"
+ def mT__53(self, ):
+
+ try:
+ _type = T__53
+ _channel = DEFAULT_CHANNEL
+
+ # jal.g:41:7: ( 'out' )
+ # jal.g:41:9: 'out'
+ pass
+ self.match("out")
+
+
+
+ self._state.type = _type
+ self._state.channel = _channel
+
+ finally:
+
+ pass
+
+ # $ANTLR end "T__53"
+
+
+
+ # $ANTLR start "T__54"
+ def mT__54(self, ):
+
+ try:
***The diff for this file has been truncated for email.***
=======================================
--- /dev/null
+++ /trunk/grammar/jalParser.py Fri Apr 9 12:51:17 2010
@@ -0,0 +1,6204 @@
+# $ANTLR 3.1.2 jal.g 2010-04-09 21:39:30
+
+import sys
+from antlr3 import *
+from antlr3.compat import set, frozenset
+
+from antlr3.tree import *
+
+
+
+# for convenience in actions
+HIDDEN = BaseRecognizer.HIDDEN
+
+# token types
+T__68=68
+T__69=69
+T__66=66
+T__67=67
+T__64=64
+T__29=29
+T__65=65
+T__28=28
+T__62=62
+T__27=27
+T__63=63
+T__26=26
+T__25=25
+T__24=24
+LETTER=9
+T__23=23
+T__22=22
+T__21=21
+T__20=20
+PRAGMA=8
+T__61=61
+T__60=60
+EOF=-1
+HexDigit=14
+T__55=55
+T__19=19
+T__56=56
+T__57=57
+T__58=58
+STRING_LITERAL=5
+T__51=51
+IN=6
+T__52=52
+T__53=53
+T__54=54
+IDENTIFIER=4
+T__59=59
+BIN_LITERAL=10
+HEX_LITERAL=11
+T__50=50
+T__42=42
+T__43=43
+T__40=40
+T__41=41
+T__80=80
+T__46=46
+T__81=81
+T__47=47
+T__44=44
+T__45=45
+LINE_COMMENT=18
+T__48=48
+T__49=49
+OCTAL_LITERAL=12
+CHARACTER_LITERAL=7
+T__30=30
+T__31=31
+T__32=32
+WS=17
+T__71=71
+T__33=33
+T__72=72
+T__34=34
+T__35=35
+T__70=70
+T__36=36
+T__37=37
+T__38=38
+T__39=39
+T__76=76
+T__75=75
+T__74=74
+OctalEscape=16
+EscapeSequence=15
+DECIMAL_LITERAL=13
+T__73=73
+T__79=79
+T__78=78
+T__77=77
+
+# token names
+tokenNames = [
+ "<invalid>", "<EOR>", "<DOWN>", "<UP>",
+ "IDENTIFIER", "STRING_LITERAL", "IN", "CHARACTER_LITERAL", "PRAGMA",
+ "LETTER", "BIN_LITERAL", "HEX_LITERAL", "OCTAL_LITERAL", "DECIMAL_LITERAL",
+ "HexDigit", "EscapeSequence", "OctalEscape", "WS", "LINE_COMMENT",
"'return'",
+ "'assert'", "'include'", "'_debug'", "'_error'", "'_warn'", "'='", "'{'",
+ "','", "'}'", "'for'", "'using'", "'loop'", "'exit'", "'end'", "'forever'",
+ "'while'", "'repeat'", "'until'", "'if'", "'then'", "'elsif'", "'else'",
+ "'case'", "'of'", "':'", "'otherwise'", "'block'", "'procedure'", "'('",
+ "')'", "'is'", "'function'", "'volatile'", "'out'", "'\\''", "'put'",
+ "'get'", "'alias'", "'const'", "'['", "']'", "'var'", "'*'", "'shared'",
+ "'at'", "'bit'", "'byte'", "'word'", "'dword'", "'sbyte'", "'sword'",
+ "'sdword'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'+'", "'-'", "'/'",
+ "'%'", "'~'"
+]
+
+
+
+
+class jalParser(Parser):
+ grammarFileName = "jal.g"
+ antlr_version = version_str_to_tuple("3.1.2")
+ antlr_version_str = "3.1.2"
+ tokenNames = tokenNames
+
+ def __init__(self, input, state=None):
+ if state is None:
+ state = RecognizerSharedState()
+
+ Parser.__init__(self, input, state)
+
+
+ self.dfa2 = self.DFA2(
+ self, 2,
+ eot = self.DFA2_eot,
+ eof = self.DFA2_eof,
+ min = self.DFA2_min,
+ max = self.DFA2_max,
+ accept = self.DFA2_accept,
+ special = self.DFA2_special,
+ transition = self.DFA2_transition
+ )
+
+ self.dfa57 = self.DFA57(
+ self, 57,
+ eot = self.DFA57_eot,
+ eof = self.DFA57_eof,
+ min = self.DFA57_min,
+ max = self.DFA57_max,
+ accept = self.DFA57_accept,
+ special = self.DFA57_special,
+ transition = self.DFA57_transition
+ )
+
+
+
+
+
+
+
+ self._adaptor = CommonTreeAdaptor()
+
+
+
+ def getTreeAdaptor(self):
+ return self._adaptor
+
+ def setTreeAdaptor(self, adaptor):
+ self._adaptor = adaptor
+
+ adaptor = property(getTreeAdaptor, setTreeAdaptor)
+
+
+ class program_return(ParserRuleReturnScope):
+ def __init__(self):
+ ParserRuleReturnScope.__init__(self)
+
+ self.tree = None
+
+
+
+
+ # $ANTLR start "program"
+ # jal.g:22:1: program : ( statement )+ ;
+ def program(self, ):
+
+ retval = self.program_return()
+ retval.start = self.input.LT(1)
+
+ root_0 = None
+
+ statement1 = None
+
+
+
+ try:
+ try:
+ # jal.g:22:9: ( ( statement )+ )
+ # jal.g:22:11: ( statement )+
+ pass
+ root_0 = self._adaptor.nil()
+
+ # jal.g:22:11: ( statement )+
+ cnt1 = 0
+ while True: #loop1
+ alt1 = 2
+ LA1_0 = self.input.LA(1)
+
+ if (LA1_0 == IDENTIFIER or (19 <= LA1_0 <= 24) or
LA1_0 == 29 or (34 <= LA1_0 <= 36) or LA1_0 == 38 or LA1_0 == 42 or (46 <=
LA1_0 <= 47) or LA1_0 == 51 or (57 <= LA1_0 <= 58) or LA1_0 == 61) :
+ alt1 = 1
+
+
+ if alt1 == 1:
+ # jal.g:22:13: statement
+ pass
+
self._state.following.append(self.FOLLOW_statement_in_program59)
+ statement1 = self.statement()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, statement1.tree)
+ if self._state.backtracking == 0:
+ print statement1.tree.toStringTree();
+
+
+
+ else:
+ if cnt1 >= 1:
+ break #loop1
+
+ if self._state.backtracking > 0:
+ raise BacktrackingFailed
+
+ eee = EarlyExitException(1, self.input)
+ raise eee
+
+ cnt1 += 1
+
+
+
+
+
+ retval.stop = self.input.LT(-1)
+
+ if self._state.backtracking == 0:
+
+ retval.tree = self._adaptor.rulePostProcessing(root_0)
+ self._adaptor.setTokenBoundaries(retval.tree,
retval.start, retval.stop)
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ retval.tree = self._adaptor.errorNode(self.input,
retval.start, self.input.LT(-1), re)
+ finally:
+
+ pass
+
+ return retval
+
+ # $ANTLR end "program"
+
+ class statement_return(ParserRuleReturnScope):
+ def __init__(self):
+ ParserRuleReturnScope.__init__(self)
+
+ self.tree = None
+
+
+
+
+ # $ANTLR start "statement"
+ # jal.g:24:1: statement : ( block_stmt | for_stmt | forever_stmt |
if_stmt | repeat_stmt | while_stmt | case_stmt | var_def | const_def |
alias_def | proc_def | pseudo_proc_def | func_def | pseudo_func_def
| 'return' expr | 'assert' expr | 'include' IDENTIFIER | '_debug'
STRING_LITERAL | '_error' STRING_LITERAL | '_warn' STRING_LITERAL |
IDENTIFIER '=' expr | proc_func_call );
+ def statement(self, ):
+
+ retval = self.statement_return()
+ retval.start = self.input.LT(1)
+
+ root_0 = None
+
+ string_literal16 = None
+ string_literal18 = None
+ string_literal20 = None
+ IDENTIFIER21 = None
+ string_literal22 = None
+ STRING_LITERAL23 = None
+ string_literal24 = None
+ STRING_LITERAL25 = None
+ string_literal26 = None
+ STRING_LITERAL27 = None
+ IDENTIFIER28 = None
+ char_literal29 = None
+ block_stmt2 = None
+
+ for_stmt3 = None
+
+ forever_stmt4 = None
+
+ if_stmt5 = None
+
+ repeat_stmt6 = None
+
+ while_stmt7 = None
+
+ case_stmt8 = None
+
+ var_def9 = None
+
+ const_def10 = None
+
+ alias_def11 = None
+
+ proc_def12 = None
+
+ pseudo_proc_def13 = None
+
+ func_def14 = None
+
+ pseudo_func_def15 = None
+
+ expr17 = None
+
+ expr19 = None
+
+ expr30 = None
+
+ proc_func_call31 = None
+
+
+ string_literal16_tree = None
+ string_literal18_tree = None
+ string_literal20_tree = None
+ IDENTIFIER21_tree = None
+ string_literal22_tree = None
+ STRING_LITERAL23_tree = None
+ string_literal24_tree = None
+ STRING_LITERAL25_tree = None
+ string_literal26_tree = None
+ STRING_LITERAL27_tree = None
+ IDENTIFIER28_tree = None
+ char_literal29_tree = None
+
+ try:
+ try:
+ # jal.g:24:11: ( block_stmt | for_stmt | forever_stmt |
if_stmt | repeat_stmt | while_stmt | case_stmt | var_def | const_def |
alias_def | proc_def | pseudo_proc_def | func_def | pseudo_func_def
| 'return' expr | 'assert' expr | 'include' IDENTIFIER | '_debug'
STRING_LITERAL | '_error' STRING_LITERAL | '_warn' STRING_LITERAL |
IDENTIFIER '=' expr | proc_func_call )
+ alt2 = 22
+ alt2 = self.dfa2.predict(self.input)
+ if alt2 == 1:
+ # jal.g:25:9: block_stmt
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_block_stmt_in_statement82)
+ block_stmt2 = self.block_stmt()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, block_stmt2.tree)
+
+
+ elif alt2 == 2:
+ # jal.g:25:22: for_stmt
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_for_stmt_in_statement86)
+ for_stmt3 = self.for_stmt()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, for_stmt3.tree)
+
+
+ elif alt2 == 3:
+ # jal.g:25:33: forever_stmt
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_forever_stmt_in_statement90)
+ forever_stmt4 = self.forever_stmt()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, forever_stmt4.tree)
+
+
+ elif alt2 == 4:
+ # jal.g:25:48: if_stmt
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_if_stmt_in_statement94)
+ if_stmt5 = self.if_stmt()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, if_stmt5.tree)
+
+
+ elif alt2 == 5:
+ # jal.g:26:11: repeat_stmt
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_repeat_stmt_in_statement107)
+ repeat_stmt6 = self.repeat_stmt()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, repeat_stmt6.tree)
+
+
+ elif alt2 == 6:
+ # jal.g:26:25: while_stmt
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_while_stmt_in_statement111)
+ while_stmt7 = self.while_stmt()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, while_stmt7.tree)
+
+
+ elif alt2 == 7:
+ # jal.g:26:38: case_stmt
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_case_stmt_in_statement115)
+ case_stmt8 = self.case_stmt()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, case_stmt8.tree)
+
+
+ elif alt2 == 8:
+ # jal.g:27:11: var_def
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_var_def_in_statement127)
+ var_def9 = self.var_def()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, var_def9.tree)
+
+
+ elif alt2 == 9:
+ # jal.g:27:21: const_def
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_const_def_in_statement131)
+ const_def10 = self.const_def()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, const_def10.tree)
+
+
+ elif alt2 == 10:
+ # jal.g:27:33: alias_def
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_alias_def_in_statement135)
+ alias_def11 = self.alias_def()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, alias_def11.tree)
+
+
+ elif alt2 == 11:
+ # jal.g:28:11: proc_def
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_proc_def_in_statement147)
+ proc_def12 = self.proc_def()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, proc_def12.tree)
+
+
+ elif alt2 == 12:
+ # jal.g:28:22: pseudo_proc_def
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_pseudo_proc_def_in_statement151)
+ pseudo_proc_def13 = self.pseudo_proc_def()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0,
pseudo_proc_def13.tree)
+
+
+ elif alt2 == 13:
+ # jal.g:29:11: func_def
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_func_def_in_statement163)
+ func_def14 = self.func_def()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, func_def14.tree)
+
+
+ elif alt2 == 14:
+ # jal.g:29:22: pseudo_func_def
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_pseudo_func_def_in_statement167)
+ pseudo_func_def15 = self.pseudo_func_def()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0,
pseudo_func_def15.tree)
+
+
+ elif alt2 == 15:
+ # jal.g:30:11: 'return' expr
+ pass
+ root_0 = self._adaptor.nil()
+
+ string_literal16=self.match(self.input, 19,
self.FOLLOW_19_in_statement179)
+ if self._state.backtracking == 0:
+
+ string_literal16_tree =
self._adaptor.createWithPayload(string_literal16)
+ self._adaptor.addChild(root_0,
string_literal16_tree)
+
+
self._state.following.append(self.FOLLOW_expr_in_statement181)
+ expr17 = self.expr()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, expr17.tree)
+
+
+ elif alt2 == 16:
+ # jal.g:31:11: 'assert' expr
+ pass
+ root_0 = self._adaptor.nil()
+
+ string_literal18=self.match(self.input, 20,
self.FOLLOW_20_in_statement193)
+ if self._state.backtracking == 0:
+
+ string_literal18_tree =
self._adaptor.createWithPayload(string_literal18)
+ self._adaptor.addChild(root_0,
string_literal18_tree)
+
+
self._state.following.append(self.FOLLOW_expr_in_statement195)
+ expr19 = self.expr()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, expr19.tree)
+
+
+ elif alt2 == 17:
+ # jal.g:32:11: 'include' IDENTIFIER
+ pass
+ root_0 = self._adaptor.nil()
+
+ string_literal20=self.match(self.input, 21,
self.FOLLOW_21_in_statement207)
+ if self._state.backtracking == 0:
+
+ string_literal20_tree =
self._adaptor.createWithPayload(string_literal20)
+ self._adaptor.addChild(root_0,
string_literal20_tree)
+
+ IDENTIFIER21=self.match(self.input, IDENTIFIER,
self.FOLLOW_IDENTIFIER_in_statement209)
+ if self._state.backtracking == 0:
+
+ IDENTIFIER21_tree =
self._adaptor.createWithPayload(IDENTIFIER21)
+ self._adaptor.addChild(root_0, IDENTIFIER21_tree)
+
+
+
+ elif alt2 == 18:
+ # jal.g:33:11: '_debug' STRING_LITERAL
+ pass
+ root_0 = self._adaptor.nil()
+
+ string_literal22=self.match(self.input, 22,
self.FOLLOW_22_in_statement221)
+ if self._state.backtracking == 0:
+
+ string_literal22_tree =
self._adaptor.createWithPayload(string_literal22)
+ self._adaptor.addChild(root_0,
string_literal22_tree)
+
+ STRING_LITERAL23=self.match(self.input,
STRING_LITERAL, self.FOLLOW_STRING_LITERAL_in_statement223)
+ if self._state.backtracking == 0:
+
+ STRING_LITERAL23_tree =
self._adaptor.createWithPayload(STRING_LITERAL23)
+ self._adaptor.addChild(root_0,
STRING_LITERAL23_tree)
+
+
+
+ elif alt2 == 19:
+ # jal.g:34:11: '_error' STRING_LITERAL
+ pass
+ root_0 = self._adaptor.nil()
+
+ string_literal24=self.match(self.input, 23,
self.FOLLOW_23_in_statement235)
+ if self._state.backtracking == 0:
+
+ string_literal24_tree =
self._adaptor.createWithPayload(string_literal24)
+ self._adaptor.addChild(root_0,
string_literal24_tree)
+
+ STRING_LITERAL25=self.match(self.input,
STRING_LITERAL, self.FOLLOW_STRING_LITERAL_in_statement237)
+ if self._state.backtracking == 0:
+
+ STRING_LITERAL25_tree =
self._adaptor.createWithPayload(STRING_LITERAL25)
+ self._adaptor.addChild(root_0,
STRING_LITERAL25_tree)
+
+
+
+ elif alt2 == 20:
+ # jal.g:35:11: '_warn' STRING_LITERAL
+ pass
+ root_0 = self._adaptor.nil()
+
+ string_literal26=self.match(self.input, 24,
self.FOLLOW_24_in_statement249)
+ if self._state.backtracking == 0:
+
+ string_literal26_tree =
self._adaptor.createWithPayload(string_literal26)
+ self._adaptor.addChild(root_0,
string_literal26_tree)
+
+ STRING_LITERAL27=self.match(self.input,
STRING_LITERAL, self.FOLLOW_STRING_LITERAL_in_statement251)
+ if self._state.backtracking == 0:
+
+ STRING_LITERAL27_tree =
self._adaptor.createWithPayload(STRING_LITERAL27)
+ self._adaptor.addChild(root_0,
STRING_LITERAL27_tree)
+
+
+
+ elif alt2 == 21:
+ # jal.g:36:4: IDENTIFIER '=' expr
+ pass
+ root_0 = self._adaptor.nil()
+
+ IDENTIFIER28=self.match(self.input, IDENTIFIER,
self.FOLLOW_IDENTIFIER_in_statement256)
+ if self._state.backtracking == 0:
+
+ IDENTIFIER28_tree =
self._adaptor.createWithPayload(IDENTIFIER28)
+ self._adaptor.addChild(root_0, IDENTIFIER28_tree)
+
+ char_literal29=self.match(self.input, 25,
self.FOLLOW_25_in_statement258)
+ if self._state.backtracking == 0:
+
+ char_literal29_tree =
self._adaptor.createWithPayload(char_literal29)
+ self._adaptor.addChild(root_0, char_literal29_tree)
+
+
self._state.following.append(self.FOLLOW_expr_in_statement260)
+ expr30 = self.expr()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, expr30.tree)
+
+
+ elif alt2 == 22:
+ # jal.g:37:4: proc_func_call
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_proc_func_call_in_statement265)
+ proc_func_call31 = self.proc_func_call()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0,
proc_func_call31.tree)
+
+
+ retval.stop = self.input.LT(-1)
+
+ if self._state.backtracking == 0:
+
+ retval.tree = self._adaptor.rulePostProcessing(root_0)
+ self._adaptor.setTokenBoundaries(retval.tree,
retval.start, retval.stop)
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ retval.tree = self._adaptor.errorNode(self.input,
retval.start, self.input.LT(-1), re)
+ finally:
+
+ pass
+
+ return retval
+
+ # $ANTLR end "statement"
+
+ class cexpr_return(ParserRuleReturnScope):
+ def __init__(self):
+ ParserRuleReturnScope.__init__(self)
+
+ self.tree = None
+
+
+
+
+ # $ANTLR start "cexpr"
+ # jal.g:41:1: cexpr : constant ;
+ def cexpr(self, ):
+
+ retval = self.cexpr_return()
+ retval.start = self.input.LT(1)
+
+ root_0 = None
+
+ constant32 = None
+
+
+
+ try:
+ try:
+ # jal.g:41:9: ( constant )
+ # jal.g:41:13: constant
+ pass
+ root_0 = self._adaptor.nil()
+
+
self._state.following.append(self.FOLLOW_constant_in_cexpr280)
+ constant32 = self.constant()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, constant32.tree)
+
+
+
+ retval.stop = self.input.LT(-1)
+
+ if self._state.backtracking == 0:
+
+ retval.tree = self._adaptor.rulePostProcessing(root_0)
+ self._adaptor.setTokenBoundaries(retval.tree,
retval.start, retval.stop)
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ retval.tree = self._adaptor.errorNode(self.input,
retval.start, self.input.LT(-1), re)
+ finally:
+
+ pass
+
+ return retval
+
+ # $ANTLR end "cexpr"
+
+ class cexpr_list_return(ParserRuleReturnScope):
+ def __init__(self):
+ ParserRuleReturnScope.__init__(self)
+
+ self.tree = None
+
+
+
+
+ # $ANTLR start "cexpr_list"
+ # jal.g:44:1: cexpr_list : '{' cexpr ( ',' cexpr )* '}' ;
+ def cexpr_list(self, ):
+
+ retval = self.cexpr_list_return()
+ retval.start = self.input.LT(1)
+
+ root_0 = None
+
+ char_literal33 = None
+ char_literal35 = None
+ char_literal37 = None
+ cexpr34 = None
+
+ cexpr36 = None
+
+
+ char_literal33_tree = None
+ char_literal35_tree = None
+ char_literal37_tree = None
+
+ try:
+ try:
+ # jal.g:44:12: ( '{' cexpr ( ',' cexpr )* '}' )
+ # jal.g:44:14: '{' cexpr ( ',' cexpr )* '}'
+ pass
+ root_0 = self._adaptor.nil()
+
+ char_literal33=self.match(self.input, 26,
self.FOLLOW_26_in_cexpr_list297)
+ if self._state.backtracking == 0:
+
+ char_literal33_tree =
self._adaptor.createWithPayload(char_literal33)
+ self._adaptor.addChild(root_0, char_literal33_tree)
+
+
self._state.following.append(self.FOLLOW_cexpr_in_cexpr_list299)
+ cexpr34 = self.cexpr()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, cexpr34.tree)
+ # jal.g:44:24: ( ',' cexpr )*
+ while True: #loop3
+ alt3 = 2
+ LA3_0 = self.input.LA(1)
+
+ if (LA3_0 == 27) :
+ alt3 = 1
+
+
+ if alt3 == 1:
+ # jal.g:44:26: ',' cexpr
+ pass
+ char_literal35=self.match(self.input, 27,
self.FOLLOW_27_in_cexpr_list303)
+ if self._state.backtracking == 0:
+
+ char_literal35_tree =
self._adaptor.createWithPayload(char_literal35)
+ self._adaptor.addChild(root_0,
char_literal35_tree)
+
+
self._state.following.append(self.FOLLOW_cexpr_in_cexpr_list305)
+ cexpr36 = self.cexpr()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, cexpr36.tree)
+
+
+ else:
+ break #loop3
+
+
+ char_literal37=self.match(self.input, 28,
self.FOLLOW_28_in_cexpr_list310)
+ if self._state.backtracking == 0:
+
+ char_literal37_tree =
self._adaptor.createWithPayload(char_literal37)
+ self._adaptor.addChild(root_0, char_literal37_tree)
+
+
+
+
+ retval.stop = self.input.LT(-1)
+
+ if self._state.backtracking == 0:
+
+ retval.tree = self._adaptor.rulePostProcessing(root_0)
+ self._adaptor.setTokenBoundaries(retval.tree,
retval.start, retval.stop)
+
+
+ except RecognitionException, re:
+ self.reportError(re)
+ self.recover(self.input, re)
+ retval.tree = self._adaptor.errorNode(self.input,
retval.start, self.input.LT(-1), re)
+ finally:
+
+ pass
+
+ return retval
+
+ # $ANTLR end "cexpr_list"
+
+ class for_stmt_return(ParserRuleReturnScope):
+ def __init__(self):
+ ParserRuleReturnScope.__init__(self)
+
+ self.tree = None
+
+
+
+
+ # $ANTLR start "for_stmt"
+ # jal.g:47:1: for_stmt : 'for' expr ( 'using' IDENTIFIER )* 'loop' (
statement )+ ( 'exit' 'loop' )* 'end' 'loop' ;
+ def for_stmt(self, ):
+
+ retval = self.for_stmt_return()
+ retval.start = self.input.LT(1)
+
+ root_0 = None
+
+ string_literal38 = None
+ string_literal40 = None
+ IDENTIFIER41 = None
+ string_literal42 = None
+ string_literal44 = None
+ string_literal45 = None
+ string_literal46 = None
+ string_literal47 = None
+ expr39 = None
+
+ statement43 = None
+
+
+ string_literal38_tree = None
+ string_literal40_tree = None
+ IDENTIFIER41_tree = None
+ string_literal42_tree = None
+ string_literal44_tree = None
+ string_literal45_tree = None
+ string_literal46_tree = None
+ string_literal47_tree = None
+
+ try:
+ try:
+ # jal.g:47:10: ( 'for' expr ( 'using' IDENTIFIER )* 'loop'
( statement )+ ( 'exit' 'loop' )* 'end' 'loop' )
+ # jal.g:47:12: 'for' expr ( 'using' IDENTIFIER )* 'loop' (
statement )+ ( 'exit' 'loop' )* 'end' 'loop'
+ pass
+ root_0 = self._adaptor.nil()
+
+ string_literal38=self.match(self.input, 29,
self.FOLLOW_29_in_for_stmt321)
+ if self._state.backtracking == 0:
+
+ string_literal38_tree =
self._adaptor.createWithPayload(string_literal38)
+ self._adaptor.addChild(root_0, string_literal38_tree)
+
+
self._state.following.append(self.FOLLOW_expr_in_for_stmt323)
+ expr39 = self.expr()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0, expr39.tree)
+ # jal.g:47:23: ( 'using' IDENTIFIER )*
+ while True: #loop4
+ alt4 = 2
+ LA4_0 = self.input.LA(1)
+
+ if (LA4_0 == 30) :
+ alt4 = 1
+
+
+ if alt4 == 1:
+ # jal.g:47:25: 'using' IDENTIFIER
+ pass
+ string_literal40=self.match(self.input, 30,
self.FOLLOW_30_in_for_stmt327)
+ if self._state.backtracking == 0:
+
+ string_literal40_tree =
self._adaptor.createWithPayload(string_literal40)
+ self._adaptor.addChild(root_0,
string_literal40_tree)
+
+ IDENTIFIER41=self.match(self.input, IDENTIFIER,
self.FOLLOW_IDENTIFIER_in_for_stmt329)
+ if self._state.backtracking == 0:
+
+ IDENTIFIER41_tree =
self._adaptor.createWithPayload(IDENTIFIER41)
+ self._adaptor.addChild(root_0,
IDENTIFIER41_tree)
+
+
+
+ else:
+ break #loop4
+
+
+ string_literal42=self.match(self.input, 31,
self.FOLLOW_31_in_for_stmt334)
+ if self._state.backtracking == 0:
+
+ string_literal42_tree =
self._adaptor.createWithPayload(string_literal42)
+ self._adaptor.addChild(root_0, string_literal42_tree)
+
+ # jal.g:48:17: ( statement )+
+ cnt5 = 0
+ while True: #loop5
+ alt5 = 2
+ LA5_0 = self.input.LA(1)
+
+ if (LA5_0 == IDENTIFIER or (19 <= LA5_0 <= 24) or
LA5_0 == 29 or (34 <= LA5_0 <= 36) or LA5_0 == 38 or LA5_0 == 42 or (46 <=
LA5_0 <= 47) or LA5_0 == 51 or (57 <= LA5_0 <= 58) or LA5_0 == 61) :
+ alt5 = 1
+
+
+ if alt5 == 1:
+ # jal.g:0:0: statement
+ pass
+
self._state.following.append(self.FOLLOW_statement_in_for_stmt353)
+ statement43 = self.statement()
+
+ self._state.following.pop()
+ if self._state.backtracking == 0:
+ self._adaptor.addChild(root_0,
statement43.tree)
+
+
+ else:
+ if cnt5 >= 1:
+ break #loop5
+
+ if self._state.backtracking > 0:
+ raise BacktrackingFailed
+
+ eee = EarlyExitException(5, self.input)
+ raise eee
+
+ cnt5 += 1
+
+
+ # jal.g:49:17: ( 'exit' 'loop' )*
+ while True: #loop6
+ alt6 = 2
+ LA6_0 = self.input.LA(1)
+
+ if (LA6_0 == 32) :
+ alt6 = 1
***The diff for this file has been truncated for email.***
=======================================
--- /trunk/grammar/jal.g Fri Apr 9 08:26:10 2010
+++ /trunk/grammar/jal.g Fri Apr 9 12:51:17 2010
@@ -16,6 +16,7 @@
language=Python;
output=AST;
ASTLabelType=CommonTree;
+ backtrack = true;
}
program : ( statement {print $statement.tree.toStringTree();} )+ ;
@@ -33,13 +34,14 @@
| '_error' STRING_LITERAL
| '_warn' STRING_LITERAL
| IDENTIFIER '=' expr
+ | proc_func_call
;
// FIXME
cexpr : constant
;
-cexpr_list : '{' cexpr ( ',' cexpr ) '}'
+cexpr_list : '{' cexpr ( ',' cexpr )* '}'
;
for_stmt : 'for' expr ( 'using' IDENTIFIER )* 'loop'
@@ -87,20 +89,20 @@
;
func_def : 'function' IDENTIFIER '(' proc_parm (',' proc_parm)* ')' 'is'
- statement+
+ statement*
'end' 'function'
;
-proc_parm : 'volatile'* type ( IN | 'out' | IN 'out' ) IDENTIFIER
+proc_parm : 'volatile'* type ( IN | 'out' | IN 'out' ) IDENTIFIER at_decl?
;
-pseudo_proc_def : 'procedure' IDENTIFIER '\'' 'put' '(' type IN
IDENTIFIER ')' 'is'
- statement+
+pseudo_proc_def : 'procedure' IDENTIFIER '\'' 'put' '(' proc_parm? (','
proc_parm)* ')' 'is'
+ statement*
'end' 'procedure'
;
-pseudo_func_def : 'function' IDENTIFIER '\'' 'get' 'return' type 'is'
- statement+
+pseudo_func_def : 'function' IDENTIFIER '\'' 'get' '(' proc_parm? (','
proc_parm)* ')' 'return' type 'is'
+ statement*
'end' 'function'
;
@@ -141,7 +143,8 @@
;
//FIXME: this is wrong-- add proc/func calls to the expr handler instead
-proc_func_call : IDENTIFIER '(' IDENTIFIER* ')'
+//proc_func_call : IDENTIFIER ('(' IDENTIFIER* ')') ? // jal permits
procedure call without parenthesis, but this can't be distinquished from
the start of an assignment...
+proc_func_call : IDENTIFIER ('(' IDENTIFIER* ')')?
;
var_init : proc_func_call | cexpr | cexpr_list | STRING_LITERAL |
CHARACTER_LITERAL | IDENTIFIER
@@ -173,13 +176,17 @@
//comp_op : '<' | '>' | '==' | '>=' | '<=' | '!='
// ;
//
-expr : xor_expr ('|' xor_expr)*
+
+
+expr : xor_expr ('|' xor_expr)*
;
xor_expr : and_expr ('^' and_expr)*
+ | '(' xor_expr ')'
;
-and_expr : shift_expr ('&' shift_expr)*
+and_expr : shift_expr ('&' shift_expr)*
+ | '(' and_expr ')'
;
shift_expr : arith_expr (('<<'|'>>') arith_expr)*
--
You received this message because you are subscribed to the Google Groups
"jallib" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/jallib?hl=en.
