| | | 1 | | //------------------------------------------------------------------------------ |
| | | 2 | | // <auto-generated> |
| | | 3 | | // This code was generated by a tool. |
| | | 4 | | // ANTLR Version: 4.9 |
| | | 5 | | // |
| | | 6 | | // Changes to this file may cause incorrect behavior and will be lost if |
| | | 7 | | // the code is regenerated. |
| | | 8 | | // </auto-generated> |
| | | 9 | | //------------------------------------------------------------------------------ |
| | | 10 | | |
| | | 11 | | // Generated from NanoCParser.g4 by ANTLR 4.9 |
| | | 12 | | |
| | | 13 | | // Unreachable code detected |
| | | 14 | | #pragma warning disable 0162 |
| | | 15 | | // The variable '...' is assigned but its value is never used |
| | | 16 | | #pragma warning disable 0219 |
| | | 17 | | // Missing XML comment for publicly visible type or member '...' |
| | | 18 | | #pragma warning disable 1591 |
| | | 19 | | // Ambiguous reference in cref attribute |
| | | 20 | | #pragma warning disable 419 |
| | | 21 | | |
| | | 22 | | namespace NanoCLang { |
| | | 23 | | |
| | | 24 | | using System.Linq; |
| | | 25 | | using NanoCLang.Entities; |
| | | 26 | | #nullable disable |
| | | 27 | | #pragma warning disable CS3021 |
| | | 28 | | |
| | | 29 | | using System; |
| | | 30 | | using System.IO; |
| | | 31 | | using System.Text; |
| | | 32 | | using System.Diagnostics; |
| | | 33 | | using System.Collections.Generic; |
| | | 34 | | using Antlr4.Runtime; |
| | | 35 | | using Antlr4.Runtime.Atn; |
| | | 36 | | using Antlr4.Runtime.Misc; |
| | | 37 | | using Antlr4.Runtime.Tree; |
| | | 38 | | using DFA = Antlr4.Runtime.Dfa.DFA; |
| | | 39 | | |
| | | 40 | | [System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.9")] |
| | | 41 | | [System.CLSCompliant(false)] |
| | | 42 | | public partial class NanoCParser : Parser { |
| | | 43 | | protected static DFA[] decisionToDFA; |
| | 1 | 44 | | protected static PredictionContextCache sharedContextCache = new PredictionContextCache(); |
| | | 45 | | public const int |
| | | 46 | | LET=1, LETF=2, LETS=3, LETU=4, FOLD=5, UNFOLD=6, FUN=7, STRUCT=8, IF=9, |
| | | 47 | | THEN=10, ELSE=11, ANY=12, ASSERT=13, MALLOC=14, INT=15, CHAR=16, VOID=17, |
| | | 48 | | RETURN=18, EMP=19, IN=20, REF=21, AT=22, PLUS=23, MINUS=24, EQUALS=25, |
| | | 49 | | UNEQUAL=26, GREATEREQUAL=27, LESSEQUAL=28, AND=29, OR=30, GREATER=31, |
| | | 50 | | LESS=32, ASSIGN=33, LB=34, RB=35, LBC=36, RBC=37, LBA=38, RBA=39, DEREF=40, |
| | | 51 | | COMMA=41, TARROW=42, TILDE=43, UNDERSCORE=44, COLON=45, SLASH=46, PIPE=47, |
| | | 52 | | ARROW=48, IDENTIFIER=49, INTEGER=50, BLOCKCOMMENT=51, LINECOMMENT=52, |
| | | 53 | | WHITESPACE=53, ERROR=54; |
| | | 54 | | public const int |
| | | 55 | | RULE_location = 0, RULE_singleLocation = 1, RULE_index = 2, RULE_singleIndex = 3, |
| | | 56 | | RULE_pureExpression = 4, RULE_singlePureExpression = 5, RULE_basicType = 6, |
| | | 57 | | RULE_singleBasicType = 7, RULE_refinedType = 8, RULE_singleRefinedType = 9, |
| | | 58 | | RULE_functionCall = 10, RULE_expression = 11, RULE_singleExpression = 12, |
| | | 59 | | RULE_blockBinding = 13, RULE_block = 14, RULE_singleBlock = 15, RULE_locationBinding = 16, |
| | | 60 | | RULE_heapElement = 17, RULE_heap = 18, RULE_singleHeap = 19, RULE_typeArg = 20, |
| | | 61 | | RULE_typeArgList = 21, RULE_world = 22, RULE_identifierList = 23, RULE_functionSchema = 24, |
| | | 62 | | RULE_singleFunctionSchema = 25, RULE_functionDefinition = 26, RULE_singleFunctionDefinition = 27, |
| | | 63 | | RULE_structField = 28, RULE_structDefinition = 29, RULE_program = 30, |
| | | 64 | | RULE_singleProgram = 31; |
| | 1 | 65 | | public static readonly string[] ruleNames = { |
| | 1 | 66 | | "location", "singleLocation", "index", "singleIndex", "pureExpression", |
| | 1 | 67 | | "singlePureExpression", "basicType", "singleBasicType", "refinedType", |
| | 1 | 68 | | "singleRefinedType", "functionCall", "expression", "singleExpression", |
| | 1 | 69 | | "blockBinding", "block", "singleBlock", "locationBinding", "heapElement", |
| | 1 | 70 | | "heap", "singleHeap", "typeArg", "typeArgList", "world", "identifierList", |
| | 1 | 71 | | "functionSchema", "singleFunctionSchema", "functionDefinition", "singleFunctionDefinition", |
| | 1 | 72 | | "structField", "structDefinition", "program", "singleProgram" |
| | 1 | 73 | | }; |
| | | 74 | | |
| | 1 | 75 | | private static readonly string[] _LiteralNames = { |
| | 1 | 76 | | null, "'let'", "'letf'", "'lets'", "'letu'", "'fold'", "'unfold'", "'fun'", |
| | 1 | 77 | | "'struct'", "'if'", "'then'", "'else'", "'any'", "'assert'", "'malloc'", |
| | 1 | 78 | | "'int'", "'char'", "'void'", "'return'", "'emp'", "'in'", "'ref'", "'@'", |
| | 1 | 79 | | "'+'", "'-'", "'=='", "'!='", "'>='", "'<='", "'&&'", "'||'", "'>'", "'<'", |
| | 1 | 80 | | "'='", "'('", "')'", "'{'", "'}'", "'['", "']'", "'*'", "','", "'~>'", |
| | 1 | 81 | | "'~'", "'_'", "':'", "'/'", "'|'", "'->'" |
| | 1 | 82 | | }; |
| | 1 | 83 | | private static readonly string[] _SymbolicNames = { |
| | 1 | 84 | | null, "LET", "LETF", "LETS", "LETU", "FOLD", "UNFOLD", "FUN", "STRUCT", |
| | 1 | 85 | | "IF", "THEN", "ELSE", "ANY", "ASSERT", "MALLOC", "INT", "CHAR", "VOID", |
| | 1 | 86 | | "RETURN", "EMP", "IN", "REF", "AT", "PLUS", "MINUS", "EQUALS", "UNEQUAL", |
| | 1 | 87 | | "GREATEREQUAL", "LESSEQUAL", "AND", "OR", "GREATER", "LESS", "ASSIGN", |
| | 1 | 88 | | "LB", "RB", "LBC", "RBC", "LBA", "RBA", "DEREF", "COMMA", "TARROW", "TILDE", |
| | 1 | 89 | | "UNDERSCORE", "COLON", "SLASH", "PIPE", "ARROW", "IDENTIFIER", "INTEGER", |
| | 1 | 90 | | "BLOCKCOMMENT", "LINECOMMENT", "WHITESPACE", "ERROR" |
| | 1 | 91 | | }; |
| | 1 | 92 | | public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames); |
| | | 93 | | |
| | | 94 | | [NotNull] |
| | | 95 | | public override IVocabulary Vocabulary |
| | | 96 | | { |
| | | 97 | | get |
| | 0 | 98 | | { |
| | 0 | 99 | | return DefaultVocabulary; |
| | 0 | 100 | | } |
| | | 101 | | } |
| | | 102 | | |
| | 0 | 103 | | public override string GrammarFileName { get { return "NanoCParser.g4"; } } |
| | | 104 | | |
| | 0 | 105 | | public override string[] RuleNames { get { return ruleNames; } } |
| | | 106 | | |
| | 0 | 107 | | public override string SerializedAtn { get { return new string(_serializedATN); } } |
| | | 108 | | |
| | 1 | 109 | | static NanoCParser() { |
| | 1 | 110 | | decisionToDFA = new DFA[_ATN.NumberOfDecisions]; |
| | 86 | 111 | | for (int i = 0; i < _ATN.NumberOfDecisions; i++) { |
| | 28 | 112 | | decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i); |
| | 28 | 113 | | } |
| | 1 | 114 | | } |
| | | 115 | | |
| | 0 | 116 | | public NanoCParser(ITokenStream input) : this(input, Console.Out, Console.Error) { } |
| | | 117 | | |
| | | 118 | | public NanoCParser(ITokenStream input, TextWriter output, TextWriter errorOutput) |
| | 123 | 119 | | : base(input, output, errorOutput) |
| | 123 | 120 | | { |
| | 123 | 121 | | Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache); |
| | 123 | 122 | | } |
| | | 123 | | |
| | | 124 | | public partial class LocationContext : ParserRuleContext { |
| | | 125 | | public Location res; |
| | | 126 | | public LocationContext(ParserRuleContext parent, int invokingState) |
| | 131 | 127 | | : base(parent, invokingState) |
| | 131 | 128 | | { |
| | 131 | 129 | | } |
| | 0 | 130 | | public override int RuleIndex { get { return RULE_location; } } |
| | | 131 | | |
| | 393 | 132 | | public LocationContext() { } |
| | 131 | 133 | | public virtual void CopyFrom(LocationContext context) { |
| | 131 | 134 | | base.CopyFrom(context); |
| | 131 | 135 | | this.res = context.res; |
| | 131 | 136 | | } |
| | | 137 | | } |
| | | 138 | | public partial class ConcreteLocationContext : LocationContext { |
| | | 139 | | public IToken name; |
| | 0 | 140 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 208 | 141 | | public ConcreteLocationContext(LocationContext context) { CopyFrom(context); } |
| | | 142 | | } |
| | | 143 | | public partial class AbstractLocationContext : LocationContext { |
| | | 144 | | public IToken name; |
| | 0 | 145 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TILDE() { return GetToken(NanoCParser.TILDE, 0); } |
| | 0 | 146 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 316 | 147 | | public AbstractLocationContext(LocationContext context) { CopyFrom(context); } |
| | | 148 | | } |
| | | 149 | | |
| | | 150 | | [RuleVersion(0)] |
| | 131 | 151 | | public LocationContext location() { |
| | 131 | 152 | | LocationContext _localctx = new LocationContext(Context, State); |
| | 131 | 153 | | EnterRule(_localctx, 0, RULE_location); |
| | 131 | 154 | | try { |
| | 131 | 155 | | State = 69; |
| | 131 | 156 | | ErrorHandler.Sync(this); |
| | 131 | 157 | | switch (TokenStream.LA(1)) { |
| | | 158 | | case IDENTIFIER: |
| | 52 | 159 | | _localctx = new ConcreteLocationContext(_localctx); |
| | 52 | 160 | | EnterOuterAlt(_localctx, 1); |
| | 52 | 161 | | { |
| | 104 | 162 | | State = 64; ((ConcreteLocationContext)_localctx).name = Match(IDENTIFIER); |
| | 52 | 163 | | ((ConcreteLocationContext)_localctx).res = new Location((((ConcreteLocationContext)_localctx).name!=null?((Con |
| | 52 | 164 | | } |
| | 52 | 165 | | break; |
| | | 166 | | case TILDE: |
| | 79 | 167 | | _localctx = new AbstractLocationContext(_localctx); |
| | 79 | 168 | | EnterOuterAlt(_localctx, 2); |
| | 79 | 169 | | { |
| | 158 | 170 | | State = 66; Match(TILDE); |
| | 158 | 171 | | State = 67; ((AbstractLocationContext)_localctx).name = Match(IDENTIFIER); |
| | 79 | 172 | | ((AbstractLocationContext)_localctx).res = new Location((((AbstractLocationContext)_localctx).name!=null?((Abs |
| | 79 | 173 | | } |
| | 79 | 174 | | break; |
| | | 175 | | default: |
| | 0 | 176 | | throw new NoViableAltException(this); |
| | | 177 | | } |
| | 131 | 178 | | } |
| | 0 | 179 | | catch (RecognitionException re) { |
| | 0 | 180 | | _localctx.exception = re; |
| | 0 | 181 | | ErrorHandler.ReportError(this, re); |
| | 0 | 182 | | ErrorHandler.Recover(this, re); |
| | 0 | 183 | | } |
| | 131 | 184 | | finally { |
| | 131 | 185 | | ExitRule(); |
| | 131 | 186 | | } |
| | 131 | 187 | | return _localctx; |
| | 131 | 188 | | } |
| | | 189 | | |
| | | 190 | | public partial class SingleLocationContext : ParserRuleContext { |
| | | 191 | | public Location res; |
| | | 192 | | public LocationContext entrypoint; |
| | 0 | 193 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 194 | | [System.Diagnostics.DebuggerNonUserCode] public LocationContext location() { |
| | 0 | 195 | | return GetRuleContext<LocationContext>(0); |
| | 0 | 196 | | } |
| | | 197 | | public SingleLocationContext(ParserRuleContext parent, int invokingState) |
| | 0 | 198 | | : base(parent, invokingState) |
| | 0 | 199 | | { |
| | 0 | 200 | | } |
| | 0 | 201 | | public override int RuleIndex { get { return RULE_singleLocation; } } |
| | | 202 | | } |
| | | 203 | | |
| | | 204 | | [RuleVersion(0)] |
| | 0 | 205 | | public SingleLocationContext singleLocation() { |
| | 0 | 206 | | SingleLocationContext _localctx = new SingleLocationContext(Context, State); |
| | 0 | 207 | | EnterRule(_localctx, 2, RULE_singleLocation); |
| | 0 | 208 | | try { |
| | 0 | 209 | | EnterOuterAlt(_localctx, 1); |
| | 0 | 210 | | { |
| | 0 | 211 | | State = 71; _localctx.entrypoint = location(); |
| | 0 | 212 | | State = 72; Match(Eof); |
| | 0 | 213 | | _localctx.res = _localctx.entrypoint.res; |
| | 0 | 214 | | } |
| | 0 | 215 | | } |
| | 0 | 216 | | catch (RecognitionException re) { |
| | 0 | 217 | | _localctx.exception = re; |
| | 0 | 218 | | ErrorHandler.ReportError(this, re); |
| | 0 | 219 | | ErrorHandler.Recover(this, re); |
| | 0 | 220 | | } |
| | 0 | 221 | | finally { |
| | 0 | 222 | | ExitRule(); |
| | 0 | 223 | | } |
| | 0 | 224 | | return _localctx; |
| | 0 | 225 | | } |
| | | 226 | | |
| | | 227 | | public partial class IndexContext : ParserRuleContext { |
| | | 228 | | public Entities.Index res; |
| | | 229 | | public IndexContext(ParserRuleContext parent, int invokingState) |
| | 245 | 230 | | : base(parent, invokingState) |
| | 245 | 231 | | { |
| | 245 | 232 | | } |
| | 0 | 233 | | public override int RuleIndex { get { return RULE_index; } } |
| | | 234 | | |
| | 735 | 235 | | public IndexContext() { } |
| | 245 | 236 | | public virtual void CopyFrom(IndexContext context) { |
| | 245 | 237 | | base.CopyFrom(context); |
| | 245 | 238 | | this.res = context.res; |
| | 245 | 239 | | } |
| | | 240 | | } |
| | | 241 | | public partial class SingletonContext : IndexContext { |
| | | 242 | | public IToken value; |
| | 0 | 243 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER() { return GetToken(NanoCParser.INTEGER, 0); } |
| | 308 | 244 | | public SingletonContext(IndexContext context) { CopyFrom(context); } |
| | | 245 | | } |
| | | 246 | | public partial class SequenceContext : IndexContext { |
| | | 247 | | public IToken value; |
| | | 248 | | public IToken step; |
| | 0 | 249 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS() { return GetToken(NanoCParser.PLUS, 0); } |
| | 0 | 250 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] INTEGER() { return GetTokens(NanoCParser.INTEGER); } |
| | 0 | 251 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER(int i) { |
| | 0 | 252 | | return GetToken(NanoCParser.INTEGER, i); |
| | 0 | 253 | | } |
| | 396 | 254 | | public SequenceContext(IndexContext context) { CopyFrom(context); } |
| | | 255 | | } |
| | | 256 | | public partial class ArbitraryIndexContext : IndexContext { |
| | 0 | 257 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANY() { return GetToken(NanoCParser.ANY, 0); } |
| | 276 | 258 | | public ArbitraryIndexContext(IndexContext context) { CopyFrom(context); } |
| | | 259 | | } |
| | | 260 | | |
| | | 261 | | [RuleVersion(0)] |
| | 245 | 262 | | public IndexContext index() { |
| | 245 | 263 | | IndexContext _localctx = new IndexContext(Context, State); |
| | 245 | 264 | | EnterRule(_localctx, 4, RULE_index); |
| | 245 | 265 | | try { |
| | 245 | 266 | | State = 83; |
| | 245 | 267 | | ErrorHandler.Sync(this); |
| | 245 | 268 | | switch ( Interpreter.AdaptivePredict(TokenStream,1,Context) ) { |
| | | 269 | | case 1: |
| | 77 | 270 | | _localctx = new SingletonContext(_localctx); |
| | 77 | 271 | | EnterOuterAlt(_localctx, 1); |
| | 77 | 272 | | { |
| | 154 | 273 | | State = 75; ((SingletonContext)_localctx).value = Match(INTEGER); |
| | 77 | 274 | | ((SingletonContext)_localctx).res = new SingletonIndex(int.Parse((((SingletonContext)_localctx).value!=null?(( |
| | 77 | 275 | | } |
| | 77 | 276 | | break; |
| | | 277 | | case 2: |
| | 99 | 278 | | _localctx = new SequenceContext(_localctx); |
| | 99 | 279 | | EnterOuterAlt(_localctx, 2); |
| | 99 | 280 | | { |
| | 198 | 281 | | State = 77; ((SequenceContext)_localctx).value = Match(INTEGER); |
| | 198 | 282 | | State = 78; Match(PLUS); |
| | 198 | 283 | | State = 79; ((SequenceContext)_localctx).step = Match(INTEGER); |
| | 99 | 284 | | ((SequenceContext)_localctx).res = new SequenceIndex(int.Parse((((SequenceContext)_localctx).value!=null?((Seq |
| | 99 | 285 | | } |
| | 99 | 286 | | break; |
| | | 287 | | case 3: |
| | 69 | 288 | | _localctx = new ArbitraryIndexContext(_localctx); |
| | 69 | 289 | | EnterOuterAlt(_localctx, 3); |
| | 69 | 290 | | { |
| | 138 | 291 | | State = 81; Match(ANY); |
| | 69 | 292 | | ((ArbitraryIndexContext)_localctx).res = new ArbitraryIndex(); |
| | 69 | 293 | | } |
| | 69 | 294 | | break; |
| | | 295 | | } |
| | 245 | 296 | | } |
| | 0 | 297 | | catch (RecognitionException re) { |
| | 0 | 298 | | _localctx.exception = re; |
| | 0 | 299 | | ErrorHandler.ReportError(this, re); |
| | 0 | 300 | | ErrorHandler.Recover(this, re); |
| | 0 | 301 | | } |
| | 245 | 302 | | finally { |
| | 245 | 303 | | ExitRule(); |
| | 245 | 304 | | } |
| | 245 | 305 | | return _localctx; |
| | 245 | 306 | | } |
| | | 307 | | |
| | | 308 | | public partial class SingleIndexContext : ParserRuleContext { |
| | | 309 | | public Entities.Index res; |
| | | 310 | | public IndexContext entrypoint; |
| | 0 | 311 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 312 | | [System.Diagnostics.DebuggerNonUserCode] public IndexContext index() { |
| | 0 | 313 | | return GetRuleContext<IndexContext>(0); |
| | 0 | 314 | | } |
| | | 315 | | public SingleIndexContext(ParserRuleContext parent, int invokingState) |
| | 0 | 316 | | : base(parent, invokingState) |
| | 0 | 317 | | { |
| | 0 | 318 | | } |
| | 0 | 319 | | public override int RuleIndex { get { return RULE_singleIndex; } } |
| | | 320 | | } |
| | | 321 | | |
| | | 322 | | [RuleVersion(0)] |
| | 0 | 323 | | public SingleIndexContext singleIndex() { |
| | 0 | 324 | | SingleIndexContext _localctx = new SingleIndexContext(Context, State); |
| | 0 | 325 | | EnterRule(_localctx, 6, RULE_singleIndex); |
| | 0 | 326 | | try { |
| | 0 | 327 | | EnterOuterAlt(_localctx, 1); |
| | 0 | 328 | | { |
| | 0 | 329 | | State = 85; _localctx.entrypoint = index(); |
| | 0 | 330 | | State = 86; Match(Eof); |
| | 0 | 331 | | _localctx.res = _localctx.entrypoint.res; |
| | 0 | 332 | | } |
| | 0 | 333 | | } |
| | 0 | 334 | | catch (RecognitionException re) { |
| | 0 | 335 | | _localctx.exception = re; |
| | 0 | 336 | | ErrorHandler.ReportError(this, re); |
| | 0 | 337 | | ErrorHandler.Recover(this, re); |
| | 0 | 338 | | } |
| | 0 | 339 | | finally { |
| | 0 | 340 | | ExitRule(); |
| | 0 | 341 | | } |
| | 0 | 342 | | return _localctx; |
| | 0 | 343 | | } |
| | | 344 | | |
| | | 345 | | public partial class PureExpressionContext : ParserRuleContext { |
| | | 346 | | public PureExpression res; |
| | | 347 | | public PureExpressionContext(ParserRuleContext parent, int invokingState) |
| | 1307 | 348 | | : base(parent, invokingState) |
| | 1307 | 349 | | { |
| | 1307 | 350 | | } |
| | 0 | 351 | | public override int RuleIndex { get { return RULE_pureExpression; } } |
| | | 352 | | |
| | 3921 | 353 | | public PureExpressionContext() { } |
| | 1307 | 354 | | public virtual void CopyFrom(PureExpressionContext context) { |
| | 1307 | 355 | | base.CopyFrom(context); |
| | 1307 | 356 | | this.res = context.res; |
| | 1307 | 357 | | } |
| | | 358 | | } |
| | | 359 | | public partial class BracedExpressionContext : PureExpressionContext { |
| | | 360 | | public PureExpressionContext body; |
| | 0 | 361 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 362 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 363 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 364 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 365 | | } |
| | 724 | 366 | | public BracedExpressionContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 367 | | } |
| | | 368 | | public partial class VoidReturnContext : PureExpressionContext { |
| | 0 | 369 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RETURN() { return GetToken(NanoCParser.RETURN, 0); } |
| | 52 | 370 | | public VoidReturnContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 371 | | } |
| | | 372 | | public partial class VariableContext : PureExpressionContext { |
| | | 373 | | public IToken name; |
| | 0 | 374 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 2024 | 375 | | public VariableContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 376 | | } |
| | | 377 | | public partial class RelationalComparisonContext : PureExpressionContext { |
| | | 378 | | public PureExpressionContext left; |
| | | 379 | | public IToken op; |
| | | 380 | | public PureExpressionContext right; |
| | 0 | 381 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 382 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 383 | | } |
| | 0 | 384 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 385 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 386 | | } |
| | 0 | 387 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LESS() { return GetToken(NanoCParser.LESS, 0); } |
| | 0 | 388 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LESSEQUAL() { return GetToken(NanoCParser.LESSEQUAL, 0 |
| | 0 | 389 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode GREATER() { return GetToken(NanoCParser.GREATER, 0); } |
| | 0 | 390 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode GREATEREQUAL() { return GetToken(NanoCParser.GREATEREQ |
| | 344 | 391 | | public RelationalComparisonContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 392 | | } |
| | | 393 | | public partial class DisjunctionExpressionContext : PureExpressionContext { |
| | | 394 | | public PureExpressionContext left; |
| | | 395 | | public IToken op; |
| | | 396 | | public PureExpressionContext right; |
| | 0 | 397 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 398 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 399 | | } |
| | 0 | 400 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 401 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 402 | | } |
| | 0 | 403 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OR() { return GetToken(NanoCParser.OR, 0); } |
| | 16 | 404 | | public DisjunctionExpressionContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 405 | | } |
| | | 406 | | public partial class UnintApplicationContext : PureExpressionContext { |
| | | 407 | | public IToken name; |
| | | 408 | | public PureExpressionContext _pureExpression; |
| | 90 | 409 | | public IList<PureExpressionContext> _a = new List<PureExpressionContext>(); |
| | 0 | 410 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 411 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 412 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 0 | 413 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 414 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 415 | | } |
| | 0 | 416 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 417 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 418 | | } |
| | 0 | 419 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(NanoCParser.COMMA); } |
| | 0 | 420 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) { |
| | 0 | 421 | | return GetToken(NanoCParser.COMMA, i); |
| | 0 | 422 | | } |
| | 360 | 423 | | public UnintApplicationContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 424 | | } |
| | | 425 | | public partial class AssertionContext : PureExpressionContext { |
| | | 426 | | public PureExpressionContext body; |
| | 0 | 427 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSERT() { return GetToken(NanoCParser.ASSERT, 0); } |
| | 0 | 428 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 429 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 430 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 431 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 432 | | } |
| | 52 | 433 | | public AssertionContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 434 | | } |
| | | 435 | | public partial class EqualityComparisonContext : PureExpressionContext { |
| | | 436 | | public PureExpressionContext left; |
| | | 437 | | public IToken op; |
| | | 438 | | public PureExpressionContext right; |
| | 0 | 439 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 440 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 441 | | } |
| | 0 | 442 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 443 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 444 | | } |
| | 0 | 445 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EQUALS() { return GetToken(NanoCParser.EQUALS, 0); } |
| | 0 | 446 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNEQUAL() { return GetToken(NanoCParser.UNEQUAL, 0); } |
| | 140 | 447 | | public EqualityComparisonContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 448 | | } |
| | | 449 | | public partial class IntegerConstantContext : PureExpressionContext { |
| | | 450 | | public IToken value; |
| | | 451 | | public IToken size; |
| | 0 | 452 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNDERSCORE() { return GetToken(NanoCParser.UNDERSCORE, |
| | 0 | 453 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] INTEGER() { return GetTokens(NanoCParser.INTEGER); } |
| | 0 | 454 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER(int i) { |
| | 0 | 455 | | return GetToken(NanoCParser.INTEGER, i); |
| | 0 | 456 | | } |
| | 1000 | 457 | | public IntegerConstantContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 458 | | } |
| | | 459 | | public partial class ConjunctionExpressionContext : PureExpressionContext { |
| | | 460 | | public PureExpressionContext left; |
| | | 461 | | public IToken op; |
| | | 462 | | public PureExpressionContext right; |
| | 0 | 463 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 464 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 465 | | } |
| | 0 | 466 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 467 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 468 | | } |
| | 0 | 469 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode AND() { return GetToken(NanoCParser.AND, 0); } |
| | 248 | 470 | | public ConjunctionExpressionContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 471 | | } |
| | | 472 | | public partial class BlockOffsetContext : PureExpressionContext { |
| | | 473 | | public IToken offset; |
| | 0 | 474 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode AT() { return GetToken(NanoCParser.AT, 0); } |
| | 0 | 475 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER() { return GetToken(NanoCParser.INTEGER, 0); } |
| | 36 | 476 | | public BlockOffsetContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 477 | | } |
| | | 478 | | public partial class IntegerAdditiveContext : PureExpressionContext { |
| | | 479 | | public PureExpressionContext left; |
| | | 480 | | public IToken op; |
| | | 481 | | public PureExpressionContext right; |
| | 0 | 482 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 483 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 484 | | } |
| | 0 | 485 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 486 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 487 | | } |
| | 0 | 488 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS() { return GetToken(NanoCParser.PLUS, 0); } |
| | 0 | 489 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MINUS() { return GetToken(NanoCParser.MINUS, 0); } |
| | 232 | 490 | | public IntegerAdditiveContext(PureExpressionContext context) { CopyFrom(context); } |
| | | 491 | | } |
| | | 492 | | |
| | | 493 | | [RuleVersion(0)] |
| | 0 | 494 | | public PureExpressionContext pureExpression() { |
| | 0 | 495 | | return pureExpression(0); |
| | 0 | 496 | | } |
| | | 497 | | |
| | 1062 | 498 | | private PureExpressionContext pureExpression(int _p) { |
| | 1062 | 499 | | ParserRuleContext _parentctx = Context; |
| | 1062 | 500 | | int _parentState = State; |
| | 1062 | 501 | | PureExpressionContext _localctx = new PureExpressionContext(Context, _parentState); |
| | 1062 | 502 | | PureExpressionContext _prevctx = _localctx; |
| | 1062 | 503 | | int _startState = 8; |
| | 1062 | 504 | | EnterRecursionRule(_localctx, 8, RULE_pureExpression, _p); |
| | | 505 | | int _la; |
| | 1062 | 506 | | try { |
| | | 507 | | int _alt; |
| | 1062 | 508 | | EnterOuterAlt(_localctx, 1); |
| | 1062 | 509 | | { |
| | 1062 | 510 | | State = 126; |
| | 1062 | 511 | | ErrorHandler.Sync(this); |
| | 1062 | 512 | | switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) { |
| | | 513 | | case 1: |
| | 13 | 514 | | { |
| | 13 | 515 | | _localctx = new VoidReturnContext(_localctx); |
| | 13 | 516 | | Context = _localctx; |
| | 13 | 517 | | _prevctx = _localctx; |
| | | 518 | | |
| | 26 | 519 | | State = 90; Match(RETURN); |
| | 13 | 520 | | ((VoidReturnContext)_localctx).res = new IntegerConstant(0, 0); |
| | 13 | 521 | | } |
| | 13 | 522 | | break; |
| | | 523 | | case 2: |
| | 181 | 524 | | { |
| | 181 | 525 | | _localctx = new BracedExpressionContext(_localctx); |
| | 181 | 526 | | Context = _localctx; |
| | 181 | 527 | | _prevctx = _localctx; |
| | 362 | 528 | | State = 92; Match(LB); |
| | 362 | 529 | | State = 93; ((BracedExpressionContext)_localctx).body = pureExpression(0); |
| | 362 | 530 | | State = 94; Match(RB); |
| | 181 | 531 | | ((BracedExpressionContext)_localctx).res = ((BracedExpressionContext)_localctx).body.res; |
| | 181 | 532 | | } |
| | 181 | 533 | | break; |
| | | 534 | | case 3: |
| | 13 | 535 | | { |
| | 13 | 536 | | _localctx = new AssertionContext(_localctx); |
| | 13 | 537 | | Context = _localctx; |
| | 13 | 538 | | _prevctx = _localctx; |
| | 26 | 539 | | State = 97; Match(ASSERT); |
| | 26 | 540 | | State = 98; Match(LB); |
| | 26 | 541 | | State = 99; ((AssertionContext)_localctx).body = pureExpression(0); |
| | 26 | 542 | | State = 100; Match(RB); |
| | 13 | 543 | | ((AssertionContext)_localctx).res = new AssertionExpression(((AssertionContext)_localctx).body.res); |
| | 13 | 544 | | } |
| | 13 | 545 | | break; |
| | | 546 | | case 4: |
| | 9 | 547 | | { |
| | 9 | 548 | | _localctx = new BlockOffsetContext(_localctx); |
| | 9 | 549 | | Context = _localctx; |
| | 9 | 550 | | _prevctx = _localctx; |
| | 18 | 551 | | State = 103; Match(AT); |
| | 18 | 552 | | State = 104; ((BlockOffsetContext)_localctx).offset = Match(INTEGER); |
| | 9 | 553 | | ((BlockOffsetContext)_localctx).res = new BlockOffset(int.Parse((((BlockOffsetContext)_localctx).offset!=null? |
| | 9 | 554 | | } |
| | 9 | 555 | | break; |
| | | 556 | | case 5: |
| | 90 | 557 | | { |
| | 90 | 558 | | _localctx = new UnintApplicationContext(_localctx); |
| | 90 | 559 | | Context = _localctx; |
| | 90 | 560 | | _prevctx = _localctx; |
| | 180 | 561 | | State = 106; ((UnintApplicationContext)_localctx).name = Match(IDENTIFIER); |
| | 180 | 562 | | State = 107; Match(LB); |
| | 90 | 563 | | State = 116; |
| | 90 | 564 | | ErrorHandler.Sync(this); |
| | 90 | 565 | | _la = TokenStream.LA(1); |
| | 180 | 566 | | if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASSERT) | (1L << RETURN) | (1L << AT) | (1L << LB) | (1L << |
| | 90 | 567 | | { |
| | 180 | 568 | | State = 108; ((UnintApplicationContext)_localctx)._pureExpression = pureExpression(0); |
| | 90 | 569 | | ((UnintApplicationContext)_localctx)._a.Add(((UnintApplicationContext)_localctx)._pureExpression); |
| | 90 | 570 | | State = 113; |
| | 90 | 571 | | ErrorHandler.Sync(this); |
| | 90 | 572 | | _la = TokenStream.LA(1); |
| | 184 | 573 | | while (_la==COMMA) { |
| | 47 | 574 | | { |
| | 47 | 575 | | { |
| | 94 | 576 | | State = 109; Match(COMMA); |
| | 94 | 577 | | State = 110; ((UnintApplicationContext)_localctx)._pureExpression = pureExpression(0); |
| | 47 | 578 | | ((UnintApplicationContext)_localctx)._a.Add(((UnintApplicationContext)_localctx)._pureExpression); |
| | 47 | 579 | | } |
| | 47 | 580 | | } |
| | 47 | 581 | | State = 115; |
| | 47 | 582 | | ErrorHandler.Sync(this); |
| | 47 | 583 | | _la = TokenStream.LA(1); |
| | 47 | 584 | | } |
| | 90 | 585 | | } |
| | 90 | 586 | | } |
| | | 587 | | |
| | 180 | 588 | | State = 118; Match(RB); |
| | 227 | 589 | | ((UnintApplicationContext)_localctx).res = new UninterpretedApplicationExpression((((UnintApplicationContext)_ |
| | 90 | 590 | | } |
| | 90 | 591 | | break; |
| | | 592 | | case 6: |
| | 250 | 593 | | { |
| | 250 | 594 | | _localctx = new IntegerConstantContext(_localctx); |
| | 250 | 595 | | Context = _localctx; |
| | 250 | 596 | | _prevctx = _localctx; |
| | 500 | 597 | | State = 120; ((IntegerConstantContext)_localctx).value = Match(INTEGER); |
| | 500 | 598 | | State = 121; Match(UNDERSCORE); |
| | 500 | 599 | | State = 122; ((IntegerConstantContext)_localctx).size = Match(INTEGER); |
| | 250 | 600 | | ((IntegerConstantContext)_localctx).res = new IntegerConstant(int.Parse((((IntegerConstantContext)_localctx).v |
| | 250 | 601 | | } |
| | 250 | 602 | | break; |
| | | 603 | | case 7: |
| | 506 | 604 | | { |
| | 506 | 605 | | _localctx = new VariableContext(_localctx); |
| | 506 | 606 | | Context = _localctx; |
| | 506 | 607 | | _prevctx = _localctx; |
| | 1012 | 608 | | State = 124; ((VariableContext)_localctx).name = Match(IDENTIFIER); |
| | 506 | 609 | | ((VariableContext)_localctx).res = new VariableExpression((((VariableContext)_localctx).name!=null?((VariableC |
| | 506 | 610 | | } |
| | 506 | 611 | | break; |
| | | 612 | | } |
| | 1062 | 613 | | Context.Stop = TokenStream.LT(-1); |
| | 1062 | 614 | | State = 155; |
| | 1062 | 615 | | ErrorHandler.Sync(this); |
| | 1062 | 616 | | _alt = Interpreter.AdaptivePredict(TokenStream,6,Context); |
| | 1552 | 617 | | while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { |
| | 490 | 618 | | if ( _alt==1 ) { |
| | 245 | 619 | | if ( ParseListeners!=null ) |
| | 245 | 620 | | TriggerExitRuleEvent(); |
| | 245 | 621 | | _prevctx = _localctx; |
| | 245 | 622 | | { |
| | 245 | 623 | | State = 153; |
| | 245 | 624 | | ErrorHandler.Sync(this); |
| | 245 | 625 | | switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) { |
| | | 626 | | case 1: |
| | 58 | 627 | | { |
| | 58 | 628 | | _localctx = new IntegerAdditiveContext(new PureExpressionContext(_parentctx, _parentState)); |
| | 58 | 629 | | ((IntegerAdditiveContext)_localctx).left = _prevctx; |
| | 58 | 630 | | PushNewRecursionContext(_localctx, _startState, RULE_pureExpression); |
| | 58 | 631 | | State = 128; |
| | 58 | 632 | | if (!(Precpred(Context, 12))) throw new FailedPredicateException(this, "Precpred(Context, 12)"); |
| | 58 | 633 | | State = 129; |
| | 58 | 634 | | ((IntegerAdditiveContext)_localctx).op = TokenStream.LT(1); |
| | 58 | 635 | | _la = TokenStream.LA(1); |
| | 58 | 636 | | if ( !(_la==PLUS || _la==MINUS) ) { |
| | 0 | 637 | | ((IntegerAdditiveContext)_localctx).op = ErrorHandler.RecoverInline(this); |
| | 0 | 638 | | } |
| | 58 | 639 | | else { |
| | 58 | 640 | | ErrorHandler.ReportMatch(this); |
| | 58 | 641 | | Consume(); |
| | 58 | 642 | | } |
| | 116 | 643 | | State = 130; ((IntegerAdditiveContext)_localctx).right = pureExpression(13); |
| | 58 | 644 | | ((IntegerAdditiveContext)_localctx).res = (((IntegerAdditiveContext)_localctx).op!=null?((IntegerAdditiveC |
| | 37 | 645 | | "+" => new AdditionExpression(((IntegerAdditiveContext)_localctx).left.res, ((IntegerA |
| | 21 | 646 | | "-" => new SubtractionExpression(((IntegerAdditiveContext)_localctx).left.res, ((Integ |
| | 0 | 647 | | _ => throw new ArgumentOutOfRangeException("Invalid additive operator!") |
| | 58 | 648 | | }; |
| | 58 | 649 | | } |
| | 58 | 650 | | break; |
| | | 651 | | case 2: |
| | 86 | 652 | | { |
| | 86 | 653 | | _localctx = new RelationalComparisonContext(new PureExpressionContext(_parentctx, _parentState)); |
| | 86 | 654 | | ((RelationalComparisonContext)_localctx).left = _prevctx; |
| | 86 | 655 | | PushNewRecursionContext(_localctx, _startState, RULE_pureExpression); |
| | 86 | 656 | | State = 133; |
| | 86 | 657 | | if (!(Precpred(Context, 10))) throw new FailedPredicateException(this, "Precpred(Context, 10)"); |
| | 86 | 658 | | State = 134; |
| | 86 | 659 | | ((RelationalComparisonContext)_localctx).op = TokenStream.LT(1); |
| | 86 | 660 | | _la = TokenStream.LA(1); |
| | 86 | 661 | | if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GREATEREQUAL) | (1L << LESSEQUAL) | (1L << GREATER) | |
| | 0 | 662 | | ((RelationalComparisonContext)_localctx).op = ErrorHandler.RecoverInline(this); |
| | 0 | 663 | | } |
| | 86 | 664 | | else { |
| | 86 | 665 | | ErrorHandler.ReportMatch(this); |
| | 86 | 666 | | Consume(); |
| | 86 | 667 | | } |
| | 172 | 668 | | State = 135; ((RelationalComparisonContext)_localctx).right = pureExpression(11); |
| | 86 | 669 | | ((RelationalComparisonContext)_localctx).res = new RelationalExpression(((RelationalComparisonContext)_loc |
| | 86 | 670 | | } |
| | 86 | 671 | | break; |
| | | 672 | | case 3: |
| | 35 | 673 | | { |
| | 35 | 674 | | _localctx = new EqualityComparisonContext(new PureExpressionContext(_parentctx, _parentState)); |
| | 35 | 675 | | ((EqualityComparisonContext)_localctx).left = _prevctx; |
| | 35 | 676 | | PushNewRecursionContext(_localctx, _startState, RULE_pureExpression); |
| | 35 | 677 | | State = 138; |
| | 35 | 678 | | if (!(Precpred(Context, 9))) throw new FailedPredicateException(this, "Precpred(Context, 9)"); |
| | 35 | 679 | | State = 139; |
| | 35 | 680 | | ((EqualityComparisonContext)_localctx).op = TokenStream.LT(1); |
| | 35 | 681 | | _la = TokenStream.LA(1); |
| | 35 | 682 | | if ( !(_la==EQUALS || _la==UNEQUAL) ) { |
| | 0 | 683 | | ((EqualityComparisonContext)_localctx).op = ErrorHandler.RecoverInline(this); |
| | 0 | 684 | | } |
| | 35 | 685 | | else { |
| | 35 | 686 | | ErrorHandler.ReportMatch(this); |
| | 35 | 687 | | Consume(); |
| | 35 | 688 | | } |
| | 70 | 689 | | State = 140; ((EqualityComparisonContext)_localctx).right = pureExpression(10); |
| | 35 | 690 | | ((EqualityComparisonContext)_localctx).res = new RelationalExpression(((EqualityComparisonContext)_localct |
| | 35 | 691 | | } |
| | 35 | 692 | | break; |
| | | 693 | | case 4: |
| | 62 | 694 | | { |
| | 62 | 695 | | _localctx = new ConjunctionExpressionContext(new PureExpressionContext(_parentctx, _parentState)); |
| | 62 | 696 | | ((ConjunctionExpressionContext)_localctx).left = _prevctx; |
| | 62 | 697 | | PushNewRecursionContext(_localctx, _startState, RULE_pureExpression); |
| | 62 | 698 | | State = 143; |
| | 62 | 699 | | if (!(Precpred(Context, 8))) throw new FailedPredicateException(this, "Precpred(Context, 8)"); |
| | 124 | 700 | | State = 144; ((ConjunctionExpressionContext)_localctx).op = Match(AND); |
| | 124 | 701 | | State = 145; ((ConjunctionExpressionContext)_localctx).right = pureExpression(9); |
| | 62 | 702 | | ((ConjunctionExpressionContext)_localctx).res = new BooleanExpression(((ConjunctionExpressionContext)_loca |
| | 62 | 703 | | } |
| | 62 | 704 | | break; |
| | | 705 | | case 5: |
| | 4 | 706 | | { |
| | 4 | 707 | | _localctx = new DisjunctionExpressionContext(new PureExpressionContext(_parentctx, _parentState)); |
| | 4 | 708 | | ((DisjunctionExpressionContext)_localctx).left = _prevctx; |
| | 4 | 709 | | PushNewRecursionContext(_localctx, _startState, RULE_pureExpression); |
| | 4 | 710 | | State = 148; |
| | 4 | 711 | | if (!(Precpred(Context, 7))) throw new FailedPredicateException(this, "Precpred(Context, 7)"); |
| | 8 | 712 | | State = 149; ((DisjunctionExpressionContext)_localctx).op = Match(OR); |
| | 8 | 713 | | State = 150; ((DisjunctionExpressionContext)_localctx).right = pureExpression(8); |
| | 4 | 714 | | ((DisjunctionExpressionContext)_localctx).res = new BooleanExpression(((DisjunctionExpressionContext)_loca |
| | 4 | 715 | | } |
| | 4 | 716 | | break; |
| | | 717 | | } |
| | 245 | 718 | | } |
| | 245 | 719 | | } |
| | 245 | 720 | | State = 157; |
| | 245 | 721 | | ErrorHandler.Sync(this); |
| | 245 | 722 | | _alt = Interpreter.AdaptivePredict(TokenStream,6,Context); |
| | 245 | 723 | | } |
| | 1062 | 724 | | } |
| | 1062 | 725 | | } |
| | 0 | 726 | | catch (RecognitionException re) { |
| | 0 | 727 | | _localctx.exception = re; |
| | 0 | 728 | | ErrorHandler.ReportError(this, re); |
| | 0 | 729 | | ErrorHandler.Recover(this, re); |
| | 0 | 730 | | } |
| | 1062 | 731 | | finally { |
| | 1062 | 732 | | UnrollRecursionContexts(_parentctx); |
| | 1062 | 733 | | } |
| | 1062 | 734 | | return _localctx; |
| | 1062 | 735 | | } |
| | | 736 | | |
| | | 737 | | public partial class SinglePureExpressionContext : ParserRuleContext { |
| | | 738 | | public PureExpression res; |
| | | 739 | | public PureExpressionContext entrypoint; |
| | 0 | 740 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 741 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 742 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 743 | | } |
| | | 744 | | public SinglePureExpressionContext(ParserRuleContext parent, int invokingState) |
| | 25 | 745 | | : base(parent, invokingState) |
| | 25 | 746 | | { |
| | 25 | 747 | | } |
| | 0 | 748 | | public override int RuleIndex { get { return RULE_singlePureExpression; } } |
| | | 749 | | } |
| | | 750 | | |
| | | 751 | | [RuleVersion(0)] |
| | 25 | 752 | | public SinglePureExpressionContext singlePureExpression() { |
| | 25 | 753 | | SinglePureExpressionContext _localctx = new SinglePureExpressionContext(Context, State); |
| | 25 | 754 | | EnterRule(_localctx, 10, RULE_singlePureExpression); |
| | 25 | 755 | | try { |
| | 25 | 756 | | EnterOuterAlt(_localctx, 1); |
| | 25 | 757 | | { |
| | 50 | 758 | | State = 158; _localctx.entrypoint = pureExpression(0); |
| | 50 | 759 | | State = 159; Match(Eof); |
| | 25 | 760 | | _localctx.res = _localctx.entrypoint.res; |
| | 25 | 761 | | } |
| | 25 | 762 | | } |
| | 0 | 763 | | catch (RecognitionException re) { |
| | 0 | 764 | | _localctx.exception = re; |
| | 0 | 765 | | ErrorHandler.ReportError(this, re); |
| | 0 | 766 | | ErrorHandler.Recover(this, re); |
| | 0 | 767 | | } |
| | 25 | 768 | | finally { |
| | 25 | 769 | | ExitRule(); |
| | 25 | 770 | | } |
| | 25 | 771 | | return _localctx; |
| | 25 | 772 | | } |
| | | 773 | | |
| | | 774 | | public partial class BasicTypeContext : ParserRuleContext { |
| | | 775 | | public BasicType res; |
| | | 776 | | public BasicTypeContext(ParserRuleContext parent, int invokingState) |
| | 237 | 777 | | : base(parent, invokingState) |
| | 237 | 778 | | { |
| | 237 | 779 | | } |
| | 0 | 780 | | public override int RuleIndex { get { return RULE_basicType; } } |
| | | 781 | | |
| | 711 | 782 | | public BasicTypeContext() { } |
| | 237 | 783 | | public virtual void CopyFrom(BasicTypeContext context) { |
| | 237 | 784 | | base.CopyFrom(context); |
| | 237 | 785 | | this.res = context.res; |
| | 237 | 786 | | } |
| | | 787 | | } |
| | | 788 | | public partial class SinglebyteIntContext : BasicTypeContext { |
| | 0 | 789 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CHAR() { return GetToken(NanoCParser.CHAR, 0); } |
| | 0 | 790 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VOID() { return GetToken(NanoCParser.VOID, 0); } |
| | 232 | 791 | | public SinglebyteIntContext(BasicTypeContext context) { CopyFrom(context); } |
| | | 792 | | } |
| | | 793 | | public partial class FourbyteIntContext : BasicTypeContext { |
| | 0 | 794 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(NanoCParser.INT, 0); } |
| | 144 | 795 | | public FourbyteIntContext(BasicTypeContext context) { CopyFrom(context); } |
| | | 796 | | } |
| | | 797 | | public partial class IntegerTypeContext : BasicTypeContext { |
| | | 798 | | public IToken size; |
| | | 799 | | public IndexContext typeIndex; |
| | 0 | 800 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBA() { return GetToken(NanoCParser.LBA, 0); } |
| | 0 | 801 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBA() { return GetToken(NanoCParser.RBA, 0); } |
| | 0 | 802 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER() { return GetToken(NanoCParser.INTEGER, 0); } |
| | 0 | 803 | | [System.Diagnostics.DebuggerNonUserCode] public IndexContext index() { |
| | 0 | 804 | | return GetRuleContext<IndexContext>(0); |
| | 0 | 805 | | } |
| | 364 | 806 | | public IntegerTypeContext(BasicTypeContext context) { CopyFrom(context); } |
| | | 807 | | } |
| | | 808 | | public partial class ReferenceTypeContext : BasicTypeContext { |
| | | 809 | | public LocationContext locationName; |
| | | 810 | | public IndexContext typeIndex; |
| | 0 | 811 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode REF() { return GetToken(NanoCParser.REF, 0); } |
| | 0 | 812 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 813 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA() { return GetToken(NanoCParser.COMMA, 0); } |
| | 0 | 814 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 815 | | [System.Diagnostics.DebuggerNonUserCode] public LocationContext location() { |
| | 0 | 816 | | return GetRuleContext<LocationContext>(0); |
| | 0 | 817 | | } |
| | 0 | 818 | | [System.Diagnostics.DebuggerNonUserCode] public IndexContext index() { |
| | 0 | 819 | | return GetRuleContext<IndexContext>(0); |
| | 0 | 820 | | } |
| | 208 | 821 | | public ReferenceTypeContext(BasicTypeContext context) { CopyFrom(context); } |
| | | 822 | | } |
| | | 823 | | |
| | | 824 | | [RuleVersion(0)] |
| | 237 | 825 | | public BasicTypeContext basicType() { |
| | 237 | 826 | | BasicTypeContext _localctx = new BasicTypeContext(Context, State); |
| | 237 | 827 | | EnterRule(_localctx, 12, RULE_basicType); |
| | 237 | 828 | | try { |
| | 237 | 829 | | State = 182; |
| | 237 | 830 | | ErrorHandler.Sync(this); |
| | 237 | 831 | | switch (TokenStream.LA(1)) { |
| | | 832 | | case INTEGER: |
| | 91 | 833 | | _localctx = new IntegerTypeContext(_localctx); |
| | 91 | 834 | | EnterOuterAlt(_localctx, 1); |
| | 91 | 835 | | { |
| | 182 | 836 | | State = 162; ((IntegerTypeContext)_localctx).size = Match(INTEGER); |
| | 182 | 837 | | State = 163; Match(LBA); |
| | 182 | 838 | | State = 164; ((IntegerTypeContext)_localctx).typeIndex = index(); |
| | 182 | 839 | | State = 165; Match(RBA); |
| | 91 | 840 | | ((IntegerTypeContext)_localctx).res = new IntegerType(int.Parse((((IntegerTypeContext)_localctx).size!=null?(( |
| | 91 | 841 | | } |
| | 91 | 842 | | break; |
| | | 843 | | case REF: |
| | 52 | 844 | | _localctx = new ReferenceTypeContext(_localctx); |
| | 52 | 845 | | EnterOuterAlt(_localctx, 2); |
| | 52 | 846 | | { |
| | 104 | 847 | | State = 168; Match(REF); |
| | 104 | 848 | | State = 169; Match(LB); |
| | 104 | 849 | | State = 170; ((ReferenceTypeContext)_localctx).locationName = location(); |
| | 104 | 850 | | State = 171; Match(COMMA); |
| | 104 | 851 | | State = 172; ((ReferenceTypeContext)_localctx).typeIndex = index(); |
| | 104 | 852 | | State = 173; Match(RB); |
| | 52 | 853 | | ((ReferenceTypeContext)_localctx).res = new ReferenceType(((ReferenceTypeContext)_localctx).locationName.res, |
| | 52 | 854 | | } |
| | 52 | 855 | | break; |
| | | 856 | | case INT: |
| | 36 | 857 | | _localctx = new FourbyteIntContext(_localctx); |
| | 36 | 858 | | EnterOuterAlt(_localctx, 3); |
| | 36 | 859 | | { |
| | 72 | 860 | | State = 176; Match(INT); |
| | 36 | 861 | | ((FourbyteIntContext)_localctx).res = new IntegerType(4); |
| | 36 | 862 | | } |
| | 36 | 863 | | break; |
| | | 864 | | case CHAR: |
| | 44 | 865 | | _localctx = new SinglebyteIntContext(_localctx); |
| | 44 | 866 | | EnterOuterAlt(_localctx, 4); |
| | 44 | 867 | | { |
| | 88 | 868 | | State = 178; Match(CHAR); |
| | 44 | 869 | | ((SinglebyteIntContext)_localctx).res = new IntegerType(1); |
| | 44 | 870 | | } |
| | 44 | 871 | | break; |
| | | 872 | | case VOID: |
| | 14 | 873 | | _localctx = new SinglebyteIntContext(_localctx); |
| | 14 | 874 | | EnterOuterAlt(_localctx, 5); |
| | 14 | 875 | | { |
| | 28 | 876 | | State = 180; Match(VOID); |
| | 14 | 877 | | ((SinglebyteIntContext)_localctx).res = IntegerType.Void; |
| | 14 | 878 | | } |
| | 14 | 879 | | break; |
| | | 880 | | default: |
| | 0 | 881 | | throw new NoViableAltException(this); |
| | | 882 | | } |
| | 237 | 883 | | } |
| | 0 | 884 | | catch (RecognitionException re) { |
| | 0 | 885 | | _localctx.exception = re; |
| | 0 | 886 | | ErrorHandler.ReportError(this, re); |
| | 0 | 887 | | ErrorHandler.Recover(this, re); |
| | 0 | 888 | | } |
| | 237 | 889 | | finally { |
| | 237 | 890 | | ExitRule(); |
| | 237 | 891 | | } |
| | 237 | 892 | | return _localctx; |
| | 237 | 893 | | } |
| | | 894 | | |
| | | 895 | | public partial class SingleBasicTypeContext : ParserRuleContext { |
| | | 896 | | public BasicType res; |
| | | 897 | | public BasicTypeContext entrypoint; |
| | 0 | 898 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 899 | | [System.Diagnostics.DebuggerNonUserCode] public BasicTypeContext basicType() { |
| | 0 | 900 | | return GetRuleContext<BasicTypeContext>(0); |
| | 0 | 901 | | } |
| | | 902 | | public SingleBasicTypeContext(ParserRuleContext parent, int invokingState) |
| | 5 | 903 | | : base(parent, invokingState) |
| | 5 | 904 | | { |
| | 5 | 905 | | } |
| | 0 | 906 | | public override int RuleIndex { get { return RULE_singleBasicType; } } |
| | | 907 | | } |
| | | 908 | | |
| | | 909 | | [RuleVersion(0)] |
| | 5 | 910 | | public SingleBasicTypeContext singleBasicType() { |
| | 5 | 911 | | SingleBasicTypeContext _localctx = new SingleBasicTypeContext(Context, State); |
| | 5 | 912 | | EnterRule(_localctx, 14, RULE_singleBasicType); |
| | 5 | 913 | | try { |
| | 5 | 914 | | EnterOuterAlt(_localctx, 1); |
| | 5 | 915 | | { |
| | 10 | 916 | | State = 184; _localctx.entrypoint = basicType(); |
| | 10 | 917 | | State = 185; Match(Eof); |
| | 5 | 918 | | _localctx.res = _localctx.entrypoint.res; |
| | 5 | 919 | | } |
| | 5 | 920 | | } |
| | 0 | 921 | | catch (RecognitionException re) { |
| | 0 | 922 | | _localctx.exception = re; |
| | 0 | 923 | | ErrorHandler.ReportError(this, re); |
| | 0 | 924 | | ErrorHandler.Recover(this, re); |
| | 0 | 925 | | } |
| | 5 | 926 | | finally { |
| | 5 | 927 | | ExitRule(); |
| | 5 | 928 | | } |
| | 5 | 929 | | return _localctx; |
| | 5 | 930 | | } |
| | | 931 | | |
| | | 932 | | public partial class RefinedTypeContext : ParserRuleContext { |
| | | 933 | | public Entities.Type res; |
| | | 934 | | public RefinedTypeContext(ParserRuleContext parent, int invokingState) |
| | 232 | 935 | | : base(parent, invokingState) |
| | 232 | 936 | | { |
| | 232 | 937 | | } |
| | 0 | 938 | | public override int RuleIndex { get { return RULE_refinedType; } } |
| | | 939 | | |
| | 696 | 940 | | public RefinedTypeContext() { } |
| | 232 | 941 | | public virtual void CopyFrom(RefinedTypeContext context) { |
| | 232 | 942 | | base.CopyFrom(context); |
| | 232 | 943 | | this.res = context.res; |
| | 232 | 944 | | } |
| | | 945 | | } |
| | | 946 | | public partial class TriviallyRefinedTypeContext : RefinedTypeContext { |
| | | 947 | | public BasicTypeContext trivial; |
| | 0 | 948 | | [System.Diagnostics.DebuggerNonUserCode] public BasicTypeContext basicType() { |
| | 0 | 949 | | return GetRuleContext<BasicTypeContext>(0); |
| | 0 | 950 | | } |
| | 404 | 951 | | public TriviallyRefinedTypeContext(RefinedTypeContext context) { CopyFrom(context); } |
| | | 952 | | } |
| | | 953 | | public partial class RefinedBasicTypeContext : RefinedTypeContext { |
| | | 954 | | public IToken variable; |
| | | 955 | | public BasicTypeContext baseType; |
| | | 956 | | public PureExpressionContext refinement; |
| | 0 | 957 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBC() { return GetToken(NanoCParser.LBC, 0); } |
| | 0 | 958 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COLON() { return GetToken(NanoCParser.COLON, 0); } |
| | 0 | 959 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PIPE() { return GetToken(NanoCParser.PIPE, 0); } |
| | 0 | 960 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBC() { return GetToken(NanoCParser.RBC, 0); } |
| | 0 | 961 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 0 | 962 | | [System.Diagnostics.DebuggerNonUserCode] public BasicTypeContext basicType() { |
| | 0 | 963 | | return GetRuleContext<BasicTypeContext>(0); |
| | 0 | 964 | | } |
| | 0 | 965 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 966 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 967 | | } |
| | 524 | 968 | | public RefinedBasicTypeContext(RefinedTypeContext context) { CopyFrom(context); } |
| | | 969 | | } |
| | | 970 | | |
| | | 971 | | [RuleVersion(0)] |
| | 232 | 972 | | public RefinedTypeContext refinedType() { |
| | 232 | 973 | | RefinedTypeContext _localctx = new RefinedTypeContext(Context, State); |
| | 232 | 974 | | EnterRule(_localctx, 16, RULE_refinedType); |
| | 232 | 975 | | try { |
| | 232 | 976 | | State = 200; |
| | 232 | 977 | | ErrorHandler.Sync(this); |
| | 232 | 978 | | switch (TokenStream.LA(1)) { |
| | | 979 | | case LBC: |
| | 131 | 980 | | _localctx = new RefinedBasicTypeContext(_localctx); |
| | 131 | 981 | | EnterOuterAlt(_localctx, 1); |
| | 131 | 982 | | { |
| | 262 | 983 | | State = 188; Match(LBC); |
| | 262 | 984 | | State = 189; ((RefinedBasicTypeContext)_localctx).variable = Match(IDENTIFIER); |
| | 262 | 985 | | State = 190; Match(COLON); |
| | 262 | 986 | | State = 191; ((RefinedBasicTypeContext)_localctx).baseType = basicType(); |
| | 262 | 987 | | State = 192; Match(PIPE); |
| | 262 | 988 | | State = 193; ((RefinedBasicTypeContext)_localctx).refinement = pureExpression(0); |
| | 262 | 989 | | State = 194; Match(RBC); |
| | 131 | 990 | | ((RefinedBasicTypeContext)_localctx).res = new RefinedType((((RefinedBasicTypeContext)_localctx).variable!=nul |
| | 131 | 991 | | } |
| | 131 | 992 | | break; |
| | | 993 | | case INT: |
| | | 994 | | case CHAR: |
| | | 995 | | case VOID: |
| | | 996 | | case REF: |
| | | 997 | | case INTEGER: |
| | 101 | 998 | | _localctx = new TriviallyRefinedTypeContext(_localctx); |
| | 101 | 999 | | EnterOuterAlt(_localctx, 2); |
| | 101 | 1000 | | { |
| | 202 | 1001 | | State = 197; ((TriviallyRefinedTypeContext)_localctx).trivial = basicType(); |
| | 101 | 1002 | | ((TriviallyRefinedTypeContext)_localctx).res = ((TriviallyRefinedTypeContext)_localctx).trivial.res; |
| | 101 | 1003 | | } |
| | 101 | 1004 | | break; |
| | | 1005 | | default: |
| | 0 | 1006 | | throw new NoViableAltException(this); |
| | | 1007 | | } |
| | 232 | 1008 | | } |
| | 0 | 1009 | | catch (RecognitionException re) { |
| | 0 | 1010 | | _localctx.exception = re; |
| | 0 | 1011 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1012 | | ErrorHandler.Recover(this, re); |
| | 0 | 1013 | | } |
| | 232 | 1014 | | finally { |
| | 232 | 1015 | | ExitRule(); |
| | 232 | 1016 | | } |
| | 232 | 1017 | | return _localctx; |
| | 232 | 1018 | | } |
| | | 1019 | | |
| | | 1020 | | public partial class SingleRefinedTypeContext : ParserRuleContext { |
| | | 1021 | | public RefinedType res; |
| | | 1022 | | public RefinedTypeContext entrypoint; |
| | 0 | 1023 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 1024 | | [System.Diagnostics.DebuggerNonUserCode] public RefinedTypeContext refinedType() { |
| | 0 | 1025 | | return GetRuleContext<RefinedTypeContext>(0); |
| | 0 | 1026 | | } |
| | | 1027 | | public SingleRefinedTypeContext(ParserRuleContext parent, int invokingState) |
| | 19 | 1028 | | : base(parent, invokingState) |
| | 19 | 1029 | | { |
| | 19 | 1030 | | } |
| | 0 | 1031 | | public override int RuleIndex { get { return RULE_singleRefinedType; } } |
| | | 1032 | | } |
| | | 1033 | | |
| | | 1034 | | [RuleVersion(0)] |
| | 19 | 1035 | | public SingleRefinedTypeContext singleRefinedType() { |
| | 19 | 1036 | | SingleRefinedTypeContext _localctx = new SingleRefinedTypeContext(Context, State); |
| | 19 | 1037 | | EnterRule(_localctx, 18, RULE_singleRefinedType); |
| | 19 | 1038 | | try { |
| | 19 | 1039 | | EnterOuterAlt(_localctx, 1); |
| | 19 | 1040 | | { |
| | 38 | 1041 | | State = 202; _localctx.entrypoint = refinedType(); |
| | 38 | 1042 | | State = 203; Match(Eof); |
| | 19 | 1043 | | _localctx.res = _localctx.entrypoint.res as RefinedType; |
| | 19 | 1044 | | } |
| | 19 | 1045 | | } |
| | 0 | 1046 | | catch (RecognitionException re) { |
| | 0 | 1047 | | _localctx.exception = re; |
| | 0 | 1048 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1049 | | ErrorHandler.Recover(this, re); |
| | 0 | 1050 | | } |
| | 19 | 1051 | | finally { |
| | 19 | 1052 | | ExitRule(); |
| | 19 | 1053 | | } |
| | 19 | 1054 | | return _localctx; |
| | 19 | 1055 | | } |
| | | 1056 | | |
| | | 1057 | | public partial class FunctionCallContext : ParserRuleContext { |
| | | 1058 | | public FunctionCallExpression res; |
| | | 1059 | | public IdentifierListContext locations; |
| | | 1060 | | public IToken name; |
| | | 1061 | | public PureExpressionContext _pureExpression; |
| | 64 | 1062 | | public IList<PureExpressionContext> _a = new List<PureExpressionContext>(); |
| | 0 | 1063 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBA() { return GetToken(NanoCParser.LBA, 0); } |
| | 0 | 1064 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBA() { return GetToken(NanoCParser.RBA, 0); } |
| | 0 | 1065 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 1066 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 1067 | | [System.Diagnostics.DebuggerNonUserCode] public IdentifierListContext identifierList() { |
| | 0 | 1068 | | return GetRuleContext<IdentifierListContext>(0); |
| | 0 | 1069 | | } |
| | 0 | 1070 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 0 | 1071 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 1072 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 1073 | | } |
| | 0 | 1074 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 1075 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 1076 | | } |
| | 0 | 1077 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(NanoCParser.COMMA); } |
| | 0 | 1078 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) { |
| | 0 | 1079 | | return GetToken(NanoCParser.COMMA, i); |
| | 0 | 1080 | | } |
| | | 1081 | | public FunctionCallContext(ParserRuleContext parent, int invokingState) |
| | 64 | 1082 | | : base(parent, invokingState) |
| | 64 | 1083 | | { |
| | 64 | 1084 | | } |
| | 0 | 1085 | | public override int RuleIndex { get { return RULE_functionCall; } } |
| | | 1086 | | } |
| | | 1087 | | |
| | | 1088 | | [RuleVersion(0)] |
| | 64 | 1089 | | public FunctionCallContext functionCall() { |
| | 64 | 1090 | | FunctionCallContext _localctx = new FunctionCallContext(Context, State); |
| | 64 | 1091 | | EnterRule(_localctx, 20, RULE_functionCall); |
| | | 1092 | | int _la; |
| | 64 | 1093 | | try { |
| | 64 | 1094 | | EnterOuterAlt(_localctx, 1); |
| | 64 | 1095 | | { |
| | 128 | 1096 | | State = 206; Match(LBA); |
| | 128 | 1097 | | State = 207; _localctx.locations = identifierList(); |
| | 128 | 1098 | | State = 208; Match(RBA); |
| | 128 | 1099 | | State = 209; _localctx.name = Match(IDENTIFIER); |
| | 128 | 1100 | | State = 210; Match(LB); |
| | 64 | 1101 | | State = 219; |
| | 64 | 1102 | | ErrorHandler.Sync(this); |
| | 64 | 1103 | | _la = TokenStream.LA(1); |
| | 108 | 1104 | | if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASSERT) | (1L << RETURN) | (1L << AT) | (1L << LB) | (1L << ID |
| | 44 | 1105 | | { |
| | 88 | 1106 | | State = 211; _localctx._pureExpression = pureExpression(0); |
| | 44 | 1107 | | _localctx._a.Add(_localctx._pureExpression); |
| | 44 | 1108 | | State = 216; |
| | 44 | 1109 | | ErrorHandler.Sync(this); |
| | 44 | 1110 | | _la = TokenStream.LA(1); |
| | 140 | 1111 | | while (_la==COMMA) { |
| | 48 | 1112 | | { |
| | 48 | 1113 | | { |
| | 96 | 1114 | | State = 212; Match(COMMA); |
| | 96 | 1115 | | State = 213; _localctx._pureExpression = pureExpression(0); |
| | 48 | 1116 | | _localctx._a.Add(_localctx._pureExpression); |
| | 48 | 1117 | | } |
| | 48 | 1118 | | } |
| | 48 | 1119 | | State = 218; |
| | 48 | 1120 | | ErrorHandler.Sync(this); |
| | 48 | 1121 | | _la = TokenStream.LA(1); |
| | 48 | 1122 | | } |
| | 44 | 1123 | | } |
| | 44 | 1124 | | } |
| | | 1125 | | |
| | 128 | 1126 | | State = 221; Match(RB); |
| | 156 | 1127 | | _localctx.res = new FunctionCallExpression((_localctx.name!=null?_localctx.name.Text:null), _localctx.locations. |
| | 64 | 1128 | | } |
| | 64 | 1129 | | } |
| | 0 | 1130 | | catch (RecognitionException re) { |
| | 0 | 1131 | | _localctx.exception = re; |
| | 0 | 1132 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1133 | | ErrorHandler.Recover(this, re); |
| | 0 | 1134 | | } |
| | 64 | 1135 | | finally { |
| | 64 | 1136 | | ExitRule(); |
| | 64 | 1137 | | } |
| | 64 | 1138 | | return _localctx; |
| | 64 | 1139 | | } |
| | | 1140 | | |
| | | 1141 | | public partial class ExpressionContext : ParserRuleContext { |
| | | 1142 | | public Expression res; |
| | | 1143 | | public ExpressionContext(ParserRuleContext parent, int invokingState) |
| | 362 | 1144 | | : base(parent, invokingState) |
| | 362 | 1145 | | { |
| | 362 | 1146 | | } |
| | 0 | 1147 | | public override int RuleIndex { get { return RULE_expression; } } |
| | | 1148 | | |
| | 1086 | 1149 | | public ExpressionContext() { } |
| | 362 | 1150 | | public virtual void CopyFrom(ExpressionContext context) { |
| | 362 | 1151 | | base.CopyFrom(context); |
| | 362 | 1152 | | this.res = context.res; |
| | 362 | 1153 | | } |
| | | 1154 | | } |
| | | 1155 | | public partial class LocationUnfoldContext : ExpressionContext { |
| | | 1156 | | public IToken name; |
| | | 1157 | | public IToken locationName; |
| | | 1158 | | public PureExpressionContext definition; |
| | | 1159 | | public ExpressionContext body; |
| | 0 | 1160 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LETU() { return GetToken(NanoCParser.LETU, 0); } |
| | 0 | 1161 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(NanoCParser.ASSIGN, 0); } |
| | 0 | 1162 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBA() { return GetToken(NanoCParser.LBA, 0); } |
| | 0 | 1163 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNFOLD() { return GetToken(NanoCParser.UNFOLD, 0); } |
| | 0 | 1164 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBA() { return GetToken(NanoCParser.RBA, 0); } |
| | 0 | 1165 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IN() { return GetToken(NanoCParser.IN, 0); } |
| | 0 | 1166 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] IDENTIFIER() { return GetTokens(NanoCParser.IDENTIFI |
| | 0 | 1167 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER(int i) { |
| | 0 | 1168 | | return GetToken(NanoCParser.IDENTIFIER, i); |
| | 0 | 1169 | | } |
| | 0 | 1170 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 1171 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 1172 | | } |
| | 0 | 1173 | | [System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() { |
| | 0 | 1174 | | return GetRuleContext<ExpressionContext>(0); |
| | 0 | 1175 | | } |
| | 56 | 1176 | | public LocationUnfoldContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1177 | | } |
| | | 1178 | | public partial class PointerReadContext : ExpressionContext { |
| | | 1179 | | public PureExpressionContext ptr; |
| | 0 | 1180 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DEREF() { return GetToken(NanoCParser.DEREF, 0); } |
| | 0 | 1181 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 1182 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 1183 | | } |
| | 56 | 1184 | | public PointerReadContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1185 | | } |
| | | 1186 | | public partial class AllocationContext : ExpressionContext { |
| | | 1187 | | public IToken locationName; |
| | | 1188 | | public PureExpressionContext size; |
| | 0 | 1189 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MALLOC() { return GetToken(NanoCParser.MALLOC, 0); } |
| | 0 | 1190 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 1191 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA() { return GetToken(NanoCParser.COMMA, 0); } |
| | 0 | 1192 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 1193 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 0 | 1194 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 1195 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 1196 | | } |
| | 80 | 1197 | | public AllocationContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1198 | | } |
| | | 1199 | | public partial class IfThenElseContext : ExpressionContext { |
| | | 1200 | | public PureExpressionContext condition; |
| | | 1201 | | public ExpressionContext bodyThen; |
| | | 1202 | | public ExpressionContext bodyElse; |
| | 0 | 1203 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IF() { return GetToken(NanoCParser.IF, 0); } |
| | 0 | 1204 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode THEN() { return GetToken(NanoCParser.THEN, 0); } |
| | 0 | 1205 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ELSE() { return GetToken(NanoCParser.ELSE, 0); } |
| | 0 | 1206 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 1207 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 1208 | | } |
| | 0 | 1209 | | [System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() { |
| | 0 | 1210 | | return GetRuleContexts<ExpressionContext>(); |
| | 0 | 1211 | | } |
| | 0 | 1212 | | [System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) { |
| | 0 | 1213 | | return GetRuleContext<ExpressionContext>(i); |
| | 0 | 1214 | | } |
| | 52 | 1215 | | public IfThenElseContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1216 | | } |
| | | 1217 | | public partial class BindingContext : ExpressionContext { |
| | | 1218 | | public IToken name; |
| | | 1219 | | public ExpressionContext definition; |
| | | 1220 | | public ExpressionContext body; |
| | 0 | 1221 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LET() { return GetToken(NanoCParser.LET, 0); } |
| | 0 | 1222 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(NanoCParser.ASSIGN, 0); } |
| | 0 | 1223 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IN() { return GetToken(NanoCParser.IN, 0); } |
| | 0 | 1224 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 0 | 1225 | | [System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() { |
| | 0 | 1226 | | return GetRuleContexts<ExpressionContext>(); |
| | 0 | 1227 | | } |
| | 0 | 1228 | | [System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) { |
| | 0 | 1229 | | return GetRuleContext<ExpressionContext>(i); |
| | 0 | 1230 | | } |
| | 208 | 1231 | | public BindingContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1232 | | } |
| | | 1233 | | public partial class StructWriteContext : ExpressionContext { |
| | | 1234 | | public PureExpressionContext ptr; |
| | | 1235 | | public IToken member; |
| | | 1236 | | public PureExpressionContext value; |
| | 0 | 1237 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARROW() { return GetToken(NanoCParser.ARROW, 0); } |
| | 0 | 1238 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(NanoCParser.ASSIGN, 0); } |
| | 0 | 1239 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 1240 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 1241 | | } |
| | 0 | 1242 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 1243 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 1244 | | } |
| | 0 | 1245 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 52 | 1246 | | public StructWriteContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1247 | | } |
| | | 1248 | | public partial class PointerWriteContext : ExpressionContext { |
| | | 1249 | | public PureExpressionContext ptr; |
| | | 1250 | | public PureExpressionContext value; |
| | 0 | 1251 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DEREF() { return GetToken(NanoCParser.DEREF, 0); } |
| | 0 | 1252 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(NanoCParser.ASSIGN, 0); } |
| | 0 | 1253 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 1254 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 1255 | | } |
| | 0 | 1256 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 1257 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 1258 | | } |
| | 64 | 1259 | | public PointerWriteContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1260 | | } |
| | | 1261 | | public partial class ArrayWriteContext : ExpressionContext { |
| | | 1262 | | public PureExpressionContext ptr; |
| | | 1263 | | public PureExpressionContext offset; |
| | | 1264 | | public PureExpressionContext value; |
| | 0 | 1265 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBA() { return GetToken(NanoCParser.LBA, 0); } |
| | 0 | 1266 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBA() { return GetToken(NanoCParser.RBA, 0); } |
| | 0 | 1267 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(NanoCParser.ASSIGN, 0); } |
| | 0 | 1268 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 1269 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 1270 | | } |
| | 0 | 1271 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 1272 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 1273 | | } |
| | 40 | 1274 | | public ArrayWriteContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1275 | | } |
| | | 1276 | | public partial class PureExpAsExpContext : ExpressionContext { |
| | | 1277 | | public PureExpressionContext body; |
| | 0 | 1278 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 1279 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 1280 | | } |
| | 268 | 1281 | | public PureExpAsExpContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1282 | | } |
| | | 1283 | | public partial class ConcatenationContext : ExpressionContext { |
| | | 1284 | | public ExpressionContext value; |
| | | 1285 | | public ExpressionContext body; |
| | 0 | 1286 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LET() { return GetToken(NanoCParser.LET, 0); } |
| | 0 | 1287 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IN() { return GetToken(NanoCParser.IN, 0); } |
| | 0 | 1288 | | [System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() { |
| | 0 | 1289 | | return GetRuleContexts<ExpressionContext>(); |
| | 0 | 1290 | | } |
| | 0 | 1291 | | [System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) { |
| | 0 | 1292 | | return GetRuleContext<ExpressionContext>(i); |
| | 0 | 1293 | | } |
| | 252 | 1294 | | public ConcatenationContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1295 | | } |
| | | 1296 | | public partial class StructReadContext : ExpressionContext { |
| | | 1297 | | public PureExpressionContext ptr; |
| | | 1298 | | public IToken member; |
| | 0 | 1299 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARROW() { return GetToken(NanoCParser.ARROW, 0); } |
| | 0 | 1300 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression() { |
| | 0 | 1301 | | return GetRuleContext<PureExpressionContext>(0); |
| | 0 | 1302 | | } |
| | 0 | 1303 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 40 | 1304 | | public StructReadContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1305 | | } |
| | | 1306 | | public partial class LocationFoldContext : ExpressionContext { |
| | | 1307 | | public IToken locationName; |
| | 0 | 1308 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBA() { return GetToken(NanoCParser.LBA, 0); } |
| | 0 | 1309 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FOLD() { return GetToken(NanoCParser.FOLD, 0); } |
| | 0 | 1310 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBA() { return GetToken(NanoCParser.RBA, 0); } |
| | 0 | 1311 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 128 | 1312 | | public LocationFoldContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1313 | | } |
| | | 1314 | | public partial class FunctionCallExpressionContext : ExpressionContext { |
| | | 1315 | | public FunctionCallContext call; |
| | 0 | 1316 | | [System.Diagnostics.DebuggerNonUserCode] public FunctionCallContext functionCall() { |
| | 0 | 1317 | | return GetRuleContext<FunctionCallContext>(0); |
| | 0 | 1318 | | } |
| | 128 | 1319 | | public FunctionCallExpressionContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1320 | | } |
| | | 1321 | | public partial class ArrayReadContext : ExpressionContext { |
| | | 1322 | | public PureExpressionContext ptr; |
| | | 1323 | | public PureExpressionContext offset; |
| | 0 | 1324 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBA() { return GetToken(NanoCParser.LBA, 0); } |
| | 0 | 1325 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBA() { return GetToken(NanoCParser.RBA, 0); } |
| | 0 | 1326 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext[] pureExpression() { |
| | 0 | 1327 | | return GetRuleContexts<PureExpressionContext>(); |
| | 0 | 1328 | | } |
| | 0 | 1329 | | [System.Diagnostics.DebuggerNonUserCode] public PureExpressionContext pureExpression(int i) { |
| | 0 | 1330 | | return GetRuleContext<PureExpressionContext>(i); |
| | 0 | 1331 | | } |
| | 24 | 1332 | | public ArrayReadContext(ExpressionContext context) { CopyFrom(context); } |
| | | 1333 | | } |
| | | 1334 | | |
| | | 1335 | | [RuleVersion(0)] |
| | 362 | 1336 | | public ExpressionContext expression() { |
| | 362 | 1337 | | ExpressionContext _localctx = new ExpressionContext(Context, State); |
| | 362 | 1338 | | EnterRule(_localctx, 22, RULE_expression); |
| | 362 | 1339 | | try { |
| | 362 | 1340 | | State = 313; |
| | 362 | 1341 | | ErrorHandler.Sync(this); |
| | 362 | 1342 | | switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) { |
| | | 1343 | | case 1: |
| | 13 | 1344 | | _localctx = new IfThenElseContext(_localctx); |
| | 13 | 1345 | | EnterOuterAlt(_localctx, 1); |
| | 13 | 1346 | | { |
| | 26 | 1347 | | State = 224; Match(IF); |
| | 26 | 1348 | | State = 225; ((IfThenElseContext)_localctx).condition = pureExpression(0); |
| | 26 | 1349 | | State = 226; Match(THEN); |
| | 26 | 1350 | | State = 227; ((IfThenElseContext)_localctx).bodyThen = expression(); |
| | 26 | 1351 | | State = 228; Match(ELSE); |
| | 26 | 1352 | | State = 229; ((IfThenElseContext)_localctx).bodyElse = expression(); |
| | 13 | 1353 | | ((IfThenElseContext)_localctx).res = new TernaryExpression(((IfThenElseContext)_localctx).condition.res, ((IfT |
| | 13 | 1354 | | } |
| | 13 | 1355 | | break; |
| | | 1356 | | case 2: |
| | 52 | 1357 | | _localctx = new BindingContext(_localctx); |
| | 52 | 1358 | | EnterOuterAlt(_localctx, 2); |
| | 52 | 1359 | | { |
| | 104 | 1360 | | State = 232; Match(LET); |
| | 104 | 1361 | | State = 233; ((BindingContext)_localctx).name = Match(IDENTIFIER); |
| | 104 | 1362 | | State = 234; Match(ASSIGN); |
| | 104 | 1363 | | State = 235; ((BindingContext)_localctx).definition = expression(); |
| | 104 | 1364 | | State = 236; Match(IN); |
| | 104 | 1365 | | State = 237; ((BindingContext)_localctx).body = expression(); |
| | 52 | 1366 | | ((BindingContext)_localctx).res = new BindingExpression((((BindingContext)_localctx).name!=null?((BindingConte |
| | 52 | 1367 | | } |
| | 52 | 1368 | | break; |
| | | 1369 | | case 3: |
| | 63 | 1370 | | _localctx = new ConcatenationContext(_localctx); |
| | 63 | 1371 | | EnterOuterAlt(_localctx, 3); |
| | 63 | 1372 | | { |
| | 126 | 1373 | | State = 240; Match(LET); |
| | 126 | 1374 | | State = 241; ((ConcatenationContext)_localctx).value = expression(); |
| | 126 | 1375 | | State = 242; Match(IN); |
| | 126 | 1376 | | State = 243; ((ConcatenationContext)_localctx).body = expression(); |
| | 63 | 1377 | | ((ConcatenationContext)_localctx).res = new ConcatenationExpression(((ConcatenationContext)_localctx).value.re |
| | 63 | 1378 | | } |
| | 63 | 1379 | | break; |
| | | 1380 | | case 4: |
| | 14 | 1381 | | _localctx = new LocationUnfoldContext(_localctx); |
| | 14 | 1382 | | EnterOuterAlt(_localctx, 4); |
| | 14 | 1383 | | { |
| | 28 | 1384 | | State = 246; Match(LETU); |
| | 28 | 1385 | | State = 247; ((LocationUnfoldContext)_localctx).name = Match(IDENTIFIER); |
| | 28 | 1386 | | State = 248; Match(ASSIGN); |
| | 28 | 1387 | | State = 249; Match(LBA); |
| | 28 | 1388 | | State = 250; Match(UNFOLD); |
| | 28 | 1389 | | State = 251; ((LocationUnfoldContext)_localctx).locationName = Match(IDENTIFIER); |
| | 28 | 1390 | | State = 252; Match(RBA); |
| | 28 | 1391 | | State = 253; ((LocationUnfoldContext)_localctx).definition = pureExpression(0); |
| | 28 | 1392 | | State = 254; Match(IN); |
| | 28 | 1393 | | State = 255; ((LocationUnfoldContext)_localctx).body = expression(); |
| | 14 | 1394 | | ((LocationUnfoldContext)_localctx).res = new UnfoldExpression((((LocationUnfoldContext)_localctx).name!=null?( |
| | 14 | 1395 | | } |
| | 14 | 1396 | | break; |
| | | 1397 | | case 5: |
| | 32 | 1398 | | _localctx = new LocationFoldContext(_localctx); |
| | 32 | 1399 | | EnterOuterAlt(_localctx, 5); |
| | 32 | 1400 | | { |
| | 64 | 1401 | | State = 258; Match(LBA); |
| | 64 | 1402 | | State = 259; Match(FOLD); |
| | 64 | 1403 | | State = 260; ((LocationFoldContext)_localctx).locationName = Match(IDENTIFIER); |
| | 64 | 1404 | | State = 261; Match(RBA); |
| | 32 | 1405 | | ((LocationFoldContext)_localctx).res = new FoldExpression((((LocationFoldContext)_localctx).locationName!=null |
| | 32 | 1406 | | } |
| | 32 | 1407 | | break; |
| | | 1408 | | case 6: |
| | 16 | 1409 | | _localctx = new PointerWriteContext(_localctx); |
| | 16 | 1410 | | EnterOuterAlt(_localctx, 6); |
| | 16 | 1411 | | { |
| | 32 | 1412 | | State = 263; Match(DEREF); |
| | 32 | 1413 | | State = 264; ((PointerWriteContext)_localctx).ptr = pureExpression(0); |
| | 32 | 1414 | | State = 265; Match(ASSIGN); |
| | 32 | 1415 | | State = 266; ((PointerWriteContext)_localctx).value = pureExpression(0); |
| | 16 | 1416 | | ((PointerWriteContext)_localctx).res = new PointerWriteExpression(((PointerWriteContext)_localctx).ptr.res, (( |
| | 16 | 1417 | | } |
| | 16 | 1418 | | break; |
| | | 1419 | | case 7: |
| | 14 | 1420 | | _localctx = new PointerReadContext(_localctx); |
| | 14 | 1421 | | EnterOuterAlt(_localctx, 7); |
| | 14 | 1422 | | { |
| | 28 | 1423 | | State = 269; Match(DEREF); |
| | 28 | 1424 | | State = 270; ((PointerReadContext)_localctx).ptr = pureExpression(0); |
| | 14 | 1425 | | ((PointerReadContext)_localctx).res = new PointerReadExpression(((PointerReadContext)_localctx).ptr.res); |
| | 14 | 1426 | | } |
| | 14 | 1427 | | break; |
| | | 1428 | | case 8: |
| | 13 | 1429 | | _localctx = new StructWriteContext(_localctx); |
| | 13 | 1430 | | EnterOuterAlt(_localctx, 8); |
| | 13 | 1431 | | { |
| | 26 | 1432 | | State = 273; ((StructWriteContext)_localctx).ptr = pureExpression(0); |
| | 26 | 1433 | | State = 274; Match(ARROW); |
| | 26 | 1434 | | State = 275; ((StructWriteContext)_localctx).member = Match(IDENTIFIER); |
| | 26 | 1435 | | State = 276; Match(ASSIGN); |
| | 26 | 1436 | | State = 277; ((StructWriteContext)_localctx).value = pureExpression(0); |
| | 13 | 1437 | | ((StructWriteContext)_localctx).res = new StructWriteExpression(((StructWriteContext)_localctx).ptr.res, (((St |
| | 13 | 1438 | | } |
| | 13 | 1439 | | break; |
| | | 1440 | | case 9: |
| | 10 | 1441 | | _localctx = new StructReadContext(_localctx); |
| | 10 | 1442 | | EnterOuterAlt(_localctx, 9); |
| | 10 | 1443 | | { |
| | 20 | 1444 | | State = 280; ((StructReadContext)_localctx).ptr = pureExpression(0); |
| | 20 | 1445 | | State = 281; Match(ARROW); |
| | 20 | 1446 | | State = 282; ((StructReadContext)_localctx).member = Match(IDENTIFIER); |
| | 10 | 1447 | | ((StructReadContext)_localctx).res = new StructReadExpression(((StructReadContext)_localctx).ptr.res, (((Struc |
| | 10 | 1448 | | } |
| | 10 | 1449 | | break; |
| | | 1450 | | case 10: |
| | 10 | 1451 | | _localctx = new ArrayWriteContext(_localctx); |
| | 10 | 1452 | | EnterOuterAlt(_localctx, 10); |
| | 10 | 1453 | | { |
| | 20 | 1454 | | State = 285; ((ArrayWriteContext)_localctx).ptr = pureExpression(0); |
| | 20 | 1455 | | State = 286; Match(LBA); |
| | 20 | 1456 | | State = 287; ((ArrayWriteContext)_localctx).offset = pureExpression(0); |
| | 20 | 1457 | | State = 288; Match(RBA); |
| | 20 | 1458 | | State = 289; Match(ASSIGN); |
| | 20 | 1459 | | State = 290; ((ArrayWriteContext)_localctx).value = pureExpression(0); |
| | 10 | 1460 | | ((ArrayWriteContext)_localctx).res = new ArrayWriteExpression(((ArrayWriteContext)_localctx).ptr.res, ((ArrayW |
| | 10 | 1461 | | } |
| | 10 | 1462 | | break; |
| | | 1463 | | case 11: |
| | 6 | 1464 | | _localctx = new ArrayReadContext(_localctx); |
| | 6 | 1465 | | EnterOuterAlt(_localctx, 11); |
| | 6 | 1466 | | { |
| | 12 | 1467 | | State = 293; ((ArrayReadContext)_localctx).ptr = pureExpression(0); |
| | 12 | 1468 | | State = 294; Match(LBA); |
| | 12 | 1469 | | State = 295; ((ArrayReadContext)_localctx).offset = pureExpression(0); |
| | 12 | 1470 | | State = 296; Match(RBA); |
| | 6 | 1471 | | ((ArrayReadContext)_localctx).res = new ArrayReadExpression(((ArrayReadContext)_localctx).ptr.res, ((ArrayRead |
| | 6 | 1472 | | } |
| | 6 | 1473 | | break; |
| | | 1474 | | case 12: |
| | 20 | 1475 | | _localctx = new AllocationContext(_localctx); |
| | 20 | 1476 | | EnterOuterAlt(_localctx, 12); |
| | 20 | 1477 | | { |
| | 40 | 1478 | | State = 299; Match(MALLOC); |
| | 40 | 1479 | | State = 300; Match(LB); |
| | 40 | 1480 | | State = 301; ((AllocationContext)_localctx).locationName = Match(IDENTIFIER); |
| | 40 | 1481 | | State = 302; Match(COMMA); |
| | 40 | 1482 | | State = 303; ((AllocationContext)_localctx).size = pureExpression(0); |
| | 40 | 1483 | | State = 304; Match(RB); |
| | 20 | 1484 | | ((AllocationContext)_localctx).res = new AllocationExpression((((AllocationContext)_localctx).locationName!=nu |
| | 20 | 1485 | | } |
| | 20 | 1486 | | break; |
| | | 1487 | | case 13: |
| | 32 | 1488 | | _localctx = new FunctionCallExpressionContext(_localctx); |
| | 32 | 1489 | | EnterOuterAlt(_localctx, 13); |
| | 32 | 1490 | | { |
| | 64 | 1491 | | State = 307; ((FunctionCallExpressionContext)_localctx).call = functionCall(); |
| | 32 | 1492 | | ((FunctionCallExpressionContext)_localctx).res = ((FunctionCallExpressionContext)_localctx).call.res; |
| | 32 | 1493 | | } |
| | 32 | 1494 | | break; |
| | | 1495 | | case 14: |
| | 67 | 1496 | | _localctx = new PureExpAsExpContext(_localctx); |
| | 67 | 1497 | | EnterOuterAlt(_localctx, 14); |
| | 67 | 1498 | | { |
| | 134 | 1499 | | State = 310; ((PureExpAsExpContext)_localctx).body = pureExpression(0); |
| | 67 | 1500 | | ((PureExpAsExpContext)_localctx).res = ((PureExpAsExpContext)_localctx).body.res; |
| | 67 | 1501 | | } |
| | 67 | 1502 | | break; |
| | | 1503 | | } |
| | 362 | 1504 | | } |
| | 0 | 1505 | | catch (RecognitionException re) { |
| | 0 | 1506 | | _localctx.exception = re; |
| | 0 | 1507 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1508 | | ErrorHandler.Recover(this, re); |
| | 0 | 1509 | | } |
| | 362 | 1510 | | finally { |
| | 362 | 1511 | | ExitRule(); |
| | 362 | 1512 | | } |
| | 362 | 1513 | | return _localctx; |
| | 362 | 1514 | | } |
| | | 1515 | | |
| | | 1516 | | public partial class SingleExpressionContext : ParserRuleContext { |
| | | 1517 | | public Expression res; |
| | | 1518 | | public ExpressionContext entrypoint; |
| | 0 | 1519 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 1520 | | [System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() { |
| | 0 | 1521 | | return GetRuleContext<ExpressionContext>(0); |
| | 0 | 1522 | | } |
| | | 1523 | | public SingleExpressionContext(ParserRuleContext parent, int invokingState) |
| | 49 | 1524 | | : base(parent, invokingState) |
| | 49 | 1525 | | { |
| | 49 | 1526 | | } |
| | 0 | 1527 | | public override int RuleIndex { get { return RULE_singleExpression; } } |
| | | 1528 | | } |
| | | 1529 | | |
| | | 1530 | | [RuleVersion(0)] |
| | 49 | 1531 | | public SingleExpressionContext singleExpression() { |
| | 49 | 1532 | | SingleExpressionContext _localctx = new SingleExpressionContext(Context, State); |
| | 49 | 1533 | | EnterRule(_localctx, 24, RULE_singleExpression); |
| | 49 | 1534 | | try { |
| | 49 | 1535 | | EnterOuterAlt(_localctx, 1); |
| | 49 | 1536 | | { |
| | 98 | 1537 | | State = 315; _localctx.entrypoint = expression(); |
| | 98 | 1538 | | State = 316; Match(Eof); |
| | 49 | 1539 | | _localctx.res = _localctx.entrypoint.res; |
| | 49 | 1540 | | } |
| | 49 | 1541 | | } |
| | 0 | 1542 | | catch (RecognitionException re) { |
| | 0 | 1543 | | _localctx.exception = re; |
| | 0 | 1544 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1545 | | ErrorHandler.Recover(this, re); |
| | 0 | 1546 | | } |
| | 49 | 1547 | | finally { |
| | 49 | 1548 | | ExitRule(); |
| | 49 | 1549 | | } |
| | 49 | 1550 | | return _localctx; |
| | 49 | 1551 | | } |
| | | 1552 | | |
| | | 1553 | | public partial class BlockBindingContext : ParserRuleContext { |
| | | 1554 | | public BlockType res; |
| | | 1555 | | public IndexContext offset; |
| | | 1556 | | public RefinedTypeContext type; |
| | 0 | 1557 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COLON() { return GetToken(NanoCParser.COLON, 0); } |
| | 0 | 1558 | | [System.Diagnostics.DebuggerNonUserCode] public IndexContext index() { |
| | 0 | 1559 | | return GetRuleContext<IndexContext>(0); |
| | 0 | 1560 | | } |
| | 0 | 1561 | | [System.Diagnostics.DebuggerNonUserCode] public RefinedTypeContext refinedType() { |
| | 0 | 1562 | | return GetRuleContext<RefinedTypeContext>(0); |
| | 0 | 1563 | | } |
| | | 1564 | | public BlockBindingContext(ParserRuleContext parent, int invokingState) |
| | 102 | 1565 | | : base(parent, invokingState) |
| | 102 | 1566 | | { |
| | 102 | 1567 | | } |
| | 0 | 1568 | | public override int RuleIndex { get { return RULE_blockBinding; } } |
| | | 1569 | | } |
| | | 1570 | | |
| | | 1571 | | [RuleVersion(0)] |
| | 102 | 1572 | | public BlockBindingContext blockBinding() { |
| | 102 | 1573 | | BlockBindingContext _localctx = new BlockBindingContext(Context, State); |
| | 102 | 1574 | | EnterRule(_localctx, 26, RULE_blockBinding); |
| | 102 | 1575 | | try { |
| | 102 | 1576 | | EnterOuterAlt(_localctx, 1); |
| | 102 | 1577 | | { |
| | 204 | 1578 | | State = 319; _localctx.offset = index(); |
| | 204 | 1579 | | State = 320; Match(COLON); |
| | 204 | 1580 | | State = 321; _localctx.type = refinedType(); |
| | 102 | 1581 | | _localctx.res = new BlockType(_localctx.offset.res, _localctx.type.res); |
| | 102 | 1582 | | } |
| | 102 | 1583 | | } |
| | 0 | 1584 | | catch (RecognitionException re) { |
| | 0 | 1585 | | _localctx.exception = re; |
| | 0 | 1586 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1587 | | ErrorHandler.Recover(this, re); |
| | 0 | 1588 | | } |
| | 102 | 1589 | | finally { |
| | 102 | 1590 | | ExitRule(); |
| | 102 | 1591 | | } |
| | 102 | 1592 | | return _localctx; |
| | 102 | 1593 | | } |
| | | 1594 | | |
| | | 1595 | | public partial class BlockContext : ParserRuleContext { |
| | | 1596 | | public BlockType[] res; |
| | | 1597 | | public BlockBindingContext _blockBinding; |
| | 79 | 1598 | | public IList<BlockBindingContext> _bindings = new List<BlockBindingContext>(); |
| | 0 | 1599 | | [System.Diagnostics.DebuggerNonUserCode] public BlockBindingContext[] blockBinding() { |
| | 0 | 1600 | | return GetRuleContexts<BlockBindingContext>(); |
| | 0 | 1601 | | } |
| | 0 | 1602 | | [System.Diagnostics.DebuggerNonUserCode] public BlockBindingContext blockBinding(int i) { |
| | 0 | 1603 | | return GetRuleContext<BlockBindingContext>(i); |
| | 0 | 1604 | | } |
| | 0 | 1605 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(NanoCParser.COMMA); } |
| | 0 | 1606 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) { |
| | 0 | 1607 | | return GetToken(NanoCParser.COMMA, i); |
| | 0 | 1608 | | } |
| | | 1609 | | public BlockContext(ParserRuleContext parent, int invokingState) |
| | 79 | 1610 | | : base(parent, invokingState) |
| | 79 | 1611 | | { |
| | 79 | 1612 | | } |
| | 0 | 1613 | | public override int RuleIndex { get { return RULE_block; } } |
| | | 1614 | | } |
| | | 1615 | | |
| | | 1616 | | [RuleVersion(0)] |
| | 79 | 1617 | | public BlockContext block() { |
| | 79 | 1618 | | BlockContext _localctx = new BlockContext(Context, State); |
| | 79 | 1619 | | EnterRule(_localctx, 28, RULE_block); |
| | | 1620 | | int _la; |
| | 79 | 1621 | | try { |
| | 79 | 1622 | | EnterOuterAlt(_localctx, 1); |
| | 79 | 1623 | | { |
| | 79 | 1624 | | State = 332; |
| | 79 | 1625 | | ErrorHandler.Sync(this); |
| | 79 | 1626 | | _la = TokenStream.LA(1); |
| | 158 | 1627 | | if (_la==ANY || _la==INTEGER) { |
| | 79 | 1628 | | { |
| | 158 | 1629 | | State = 324; _localctx._blockBinding = blockBinding(); |
| | 79 | 1630 | | _localctx._bindings.Add(_localctx._blockBinding); |
| | 79 | 1631 | | State = 329; |
| | 79 | 1632 | | ErrorHandler.Sync(this); |
| | 79 | 1633 | | _la = TokenStream.LA(1); |
| | 97 | 1634 | | while (_la==COMMA) { |
| | 9 | 1635 | | { |
| | 9 | 1636 | | { |
| | 18 | 1637 | | State = 325; Match(COMMA); |
| | 18 | 1638 | | State = 326; _localctx._blockBinding = blockBinding(); |
| | 9 | 1639 | | _localctx._bindings.Add(_localctx._blockBinding); |
| | 9 | 1640 | | } |
| | 9 | 1641 | | } |
| | 9 | 1642 | | State = 331; |
| | 9 | 1643 | | ErrorHandler.Sync(this); |
| | 9 | 1644 | | _la = TokenStream.LA(1); |
| | 9 | 1645 | | } |
| | 79 | 1646 | | } |
| | 79 | 1647 | | } |
| | | 1648 | | |
| | 167 | 1649 | | _localctx.res = _localctx._bindings.Select(i => i.res).ToArray(); |
| | 79 | 1650 | | } |
| | 79 | 1651 | | } |
| | 0 | 1652 | | catch (RecognitionException re) { |
| | 0 | 1653 | | _localctx.exception = re; |
| | 0 | 1654 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1655 | | ErrorHandler.Recover(this, re); |
| | 0 | 1656 | | } |
| | 79 | 1657 | | finally { |
| | 79 | 1658 | | ExitRule(); |
| | 79 | 1659 | | } |
| | 79 | 1660 | | return _localctx; |
| | 79 | 1661 | | } |
| | | 1662 | | |
| | | 1663 | | public partial class SingleBlockContext : ParserRuleContext { |
| | | 1664 | | public BlockType[] res; |
| | | 1665 | | public BlockContext entrypoint; |
| | 0 | 1666 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 1667 | | [System.Diagnostics.DebuggerNonUserCode] public BlockContext block() { |
| | 0 | 1668 | | return GetRuleContext<BlockContext>(0); |
| | 0 | 1669 | | } |
| | | 1670 | | public SingleBlockContext(ParserRuleContext parent, int invokingState) |
| | 0 | 1671 | | : base(parent, invokingState) |
| | 0 | 1672 | | { |
| | 0 | 1673 | | } |
| | 0 | 1674 | | public override int RuleIndex { get { return RULE_singleBlock; } } |
| | | 1675 | | } |
| | | 1676 | | |
| | | 1677 | | [RuleVersion(0)] |
| | 0 | 1678 | | public SingleBlockContext singleBlock() { |
| | 0 | 1679 | | SingleBlockContext _localctx = new SingleBlockContext(Context, State); |
| | 0 | 1680 | | EnterRule(_localctx, 30, RULE_singleBlock); |
| | 0 | 1681 | | try { |
| | 0 | 1682 | | EnterOuterAlt(_localctx, 1); |
| | 0 | 1683 | | { |
| | 0 | 1684 | | State = 336; _localctx.entrypoint = block(); |
| | 0 | 1685 | | State = 337; Match(Eof); |
| | 0 | 1686 | | _localctx.res = _localctx.entrypoint.res; |
| | 0 | 1687 | | } |
| | 0 | 1688 | | } |
| | 0 | 1689 | | catch (RecognitionException re) { |
| | 0 | 1690 | | _localctx.exception = re; |
| | 0 | 1691 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1692 | | ErrorHandler.Recover(this, re); |
| | 0 | 1693 | | } |
| | 0 | 1694 | | finally { |
| | 0 | 1695 | | ExitRule(); |
| | 0 | 1696 | | } |
| | 0 | 1697 | | return _localctx; |
| | 0 | 1698 | | } |
| | | 1699 | | |
| | | 1700 | | public partial class LocationBindingContext : ParserRuleContext { |
| | | 1701 | | public LocationBinding res; |
| | | 1702 | | public LocationContext atLocation; |
| | | 1703 | | public BlockContext bound; |
| | 0 | 1704 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TARROW() { return GetToken(NanoCParser.TARROW, 0); } |
| | 0 | 1705 | | [System.Diagnostics.DebuggerNonUserCode] public LocationContext location() { |
| | 0 | 1706 | | return GetRuleContext<LocationContext>(0); |
| | 0 | 1707 | | } |
| | 0 | 1708 | | [System.Diagnostics.DebuggerNonUserCode] public BlockContext block() { |
| | 0 | 1709 | | return GetRuleContext<BlockContext>(0); |
| | 0 | 1710 | | } |
| | | 1711 | | public LocationBindingContext(ParserRuleContext parent, int invokingState) |
| | 79 | 1712 | | : base(parent, invokingState) |
| | 79 | 1713 | | { |
| | 79 | 1714 | | } |
| | 0 | 1715 | | public override int RuleIndex { get { return RULE_locationBinding; } } |
| | | 1716 | | } |
| | | 1717 | | |
| | | 1718 | | [RuleVersion(0)] |
| | 79 | 1719 | | public LocationBindingContext locationBinding() { |
| | 79 | 1720 | | LocationBindingContext _localctx = new LocationBindingContext(Context, State); |
| | 79 | 1721 | | EnterRule(_localctx, 32, RULE_locationBinding); |
| | 79 | 1722 | | try { |
| | 79 | 1723 | | EnterOuterAlt(_localctx, 1); |
| | 79 | 1724 | | { |
| | 158 | 1725 | | State = 340; _localctx.atLocation = location(); |
| | 158 | 1726 | | State = 341; Match(TARROW); |
| | 158 | 1727 | | State = 342; _localctx.bound = block(); |
| | 79 | 1728 | | _localctx.res = new LocationBinding(_localctx.atLocation.res, _localctx.bound.res); |
| | 79 | 1729 | | } |
| | 79 | 1730 | | } |
| | 0 | 1731 | | catch (RecognitionException re) { |
| | 0 | 1732 | | _localctx.exception = re; |
| | 0 | 1733 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1734 | | ErrorHandler.Recover(this, re); |
| | 0 | 1735 | | } |
| | 79 | 1736 | | finally { |
| | 79 | 1737 | | ExitRule(); |
| | 79 | 1738 | | } |
| | 79 | 1739 | | return _localctx; |
| | 79 | 1740 | | } |
| | | 1741 | | |
| | | 1742 | | public partial class HeapElementContext : ParserRuleContext { |
| | | 1743 | | public IHeapElement res; |
| | | 1744 | | public LocationBindingContext binding; |
| | | 1745 | | public FunctionCallContext structheap; |
| | 0 | 1746 | | [System.Diagnostics.DebuggerNonUserCode] public LocationBindingContext locationBinding() { |
| | 0 | 1747 | | return GetRuleContext<LocationBindingContext>(0); |
| | 0 | 1748 | | } |
| | 0 | 1749 | | [System.Diagnostics.DebuggerNonUserCode] public FunctionCallContext functionCall() { |
| | 0 | 1750 | | return GetRuleContext<FunctionCallContext>(0); |
| | 0 | 1751 | | } |
| | | 1752 | | public HeapElementContext(ParserRuleContext parent, int invokingState) |
| | 107 | 1753 | | : base(parent, invokingState) |
| | 107 | 1754 | | { |
| | 107 | 1755 | | } |
| | 0 | 1756 | | public override int RuleIndex { get { return RULE_heapElement; } } |
| | | 1757 | | } |
| | | 1758 | | |
| | | 1759 | | [RuleVersion(0)] |
| | 107 | 1760 | | public HeapElementContext heapElement() { |
| | 107 | 1761 | | HeapElementContext _localctx = new HeapElementContext(Context, State); |
| | 107 | 1762 | | EnterRule(_localctx, 34, RULE_heapElement); |
| | 107 | 1763 | | try { |
| | 107 | 1764 | | State = 351; |
| | 107 | 1765 | | ErrorHandler.Sync(this); |
| | 107 | 1766 | | switch (TokenStream.LA(1)) { |
| | | 1767 | | case TILDE: |
| | | 1768 | | case IDENTIFIER: |
| | 79 | 1769 | | EnterOuterAlt(_localctx, 1); |
| | 79 | 1770 | | { |
| | 158 | 1771 | | State = 345; _localctx.binding = locationBinding(); |
| | 79 | 1772 | | _localctx.res = _localctx.binding.res; |
| | 79 | 1773 | | } |
| | 79 | 1774 | | break; |
| | | 1775 | | case LBA: |
| | 28 | 1776 | | EnterOuterAlt(_localctx, 2); |
| | 28 | 1777 | | { |
| | 56 | 1778 | | State = 348; _localctx.structheap = functionCall(); |
| | 28 | 1779 | | _localctx.res = _localctx.structheap.res; |
| | 28 | 1780 | | } |
| | 28 | 1781 | | break; |
| | | 1782 | | default: |
| | 0 | 1783 | | throw new NoViableAltException(this); |
| | | 1784 | | } |
| | 107 | 1785 | | } |
| | 0 | 1786 | | catch (RecognitionException re) { |
| | 0 | 1787 | | _localctx.exception = re; |
| | 0 | 1788 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1789 | | ErrorHandler.Recover(this, re); |
| | 0 | 1790 | | } |
| | 107 | 1791 | | finally { |
| | 107 | 1792 | | ExitRule(); |
| | 107 | 1793 | | } |
| | 107 | 1794 | | return _localctx; |
| | 107 | 1795 | | } |
| | | 1796 | | |
| | | 1797 | | public partial class HeapContext : ParserRuleContext { |
| | | 1798 | | public IHeapElement[] res; |
| | | 1799 | | public HeapElementContext _heapElement; |
| | 92 | 1800 | | public IList<HeapElementContext> _elems = new List<HeapElementContext>(); |
| | 0 | 1801 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EMP() { return GetToken(NanoCParser.EMP, 0); } |
| | 0 | 1802 | | [System.Diagnostics.DebuggerNonUserCode] public HeapElementContext[] heapElement() { |
| | 0 | 1803 | | return GetRuleContexts<HeapElementContext>(); |
| | 0 | 1804 | | } |
| | 0 | 1805 | | [System.Diagnostics.DebuggerNonUserCode] public HeapElementContext heapElement(int i) { |
| | 0 | 1806 | | return GetRuleContext<HeapElementContext>(i); |
| | 0 | 1807 | | } |
| | 0 | 1808 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] DEREF() { return GetTokens(NanoCParser.DEREF); } |
| | 0 | 1809 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DEREF(int i) { |
| | 0 | 1810 | | return GetToken(NanoCParser.DEREF, i); |
| | 0 | 1811 | | } |
| | | 1812 | | public HeapContext(ParserRuleContext parent, int invokingState) |
| | 92 | 1813 | | : base(parent, invokingState) |
| | 92 | 1814 | | { |
| | 92 | 1815 | | } |
| | 0 | 1816 | | public override int RuleIndex { get { return RULE_heap; } } |
| | | 1817 | | } |
| | | 1818 | | |
| | | 1819 | | [RuleVersion(0)] |
| | 92 | 1820 | | public HeapContext heap() { |
| | 92 | 1821 | | HeapContext _localctx = new HeapContext(Context, State); |
| | 92 | 1822 | | EnterRule(_localctx, 36, RULE_heap); |
| | | 1823 | | int _la; |
| | 92 | 1824 | | try { |
| | 92 | 1825 | | State = 365; |
| | 92 | 1826 | | ErrorHandler.Sync(this); |
| | 92 | 1827 | | switch (TokenStream.LA(1)) { |
| | | 1828 | | case EMP: |
| | 22 | 1829 | | EnterOuterAlt(_localctx, 1); |
| | 22 | 1830 | | { |
| | 44 | 1831 | | State = 353; Match(EMP); |
| | 22 | 1832 | | _localctx.res = new IHeapElement[] { }; |
| | 22 | 1833 | | } |
| | 22 | 1834 | | break; |
| | | 1835 | | case LBA: |
| | | 1836 | | case TILDE: |
| | | 1837 | | case IDENTIFIER: |
| | 70 | 1838 | | EnterOuterAlt(_localctx, 2); |
| | 70 | 1839 | | { |
| | 140 | 1840 | | State = 355; _localctx._heapElement = heapElement(); |
| | 70 | 1841 | | _localctx._elems.Add(_localctx._heapElement); |
| | 70 | 1842 | | State = 360; |
| | 70 | 1843 | | ErrorHandler.Sync(this); |
| | 70 | 1844 | | _la = TokenStream.LA(1); |
| | 144 | 1845 | | while (_la==DEREF) { |
| | 37 | 1846 | | { |
| | 37 | 1847 | | { |
| | 74 | 1848 | | State = 356; Match(DEREF); |
| | 74 | 1849 | | State = 357; _localctx._heapElement = heapElement(); |
| | 37 | 1850 | | _localctx._elems.Add(_localctx._heapElement); |
| | 37 | 1851 | | } |
| | 37 | 1852 | | } |
| | 37 | 1853 | | State = 362; |
| | 37 | 1854 | | ErrorHandler.Sync(this); |
| | 37 | 1855 | | _la = TokenStream.LA(1); |
| | 37 | 1856 | | } |
| | 177 | 1857 | | _localctx.res = _localctx._elems.Select(i => i.res).ToArray(); |
| | 70 | 1858 | | } |
| | 70 | 1859 | | break; |
| | | 1860 | | default: |
| | 0 | 1861 | | throw new NoViableAltException(this); |
| | | 1862 | | } |
| | 92 | 1863 | | } |
| | 0 | 1864 | | catch (RecognitionException re) { |
| | 0 | 1865 | | _localctx.exception = re; |
| | 0 | 1866 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1867 | | ErrorHandler.Recover(this, re); |
| | 0 | 1868 | | } |
| | 92 | 1869 | | finally { |
| | 92 | 1870 | | ExitRule(); |
| | 92 | 1871 | | } |
| | 92 | 1872 | | return _localctx; |
| | 92 | 1873 | | } |
| | | 1874 | | |
| | | 1875 | | public partial class SingleHeapContext : ParserRuleContext { |
| | | 1876 | | public IHeapElement[] res; |
| | | 1877 | | public HeapContext entrypoint; |
| | 0 | 1878 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 1879 | | [System.Diagnostics.DebuggerNonUserCode] public HeapContext heap() { |
| | 0 | 1880 | | return GetRuleContext<HeapContext>(0); |
| | 0 | 1881 | | } |
| | | 1882 | | public SingleHeapContext(ParserRuleContext parent, int invokingState) |
| | 3 | 1883 | | : base(parent, invokingState) |
| | 3 | 1884 | | { |
| | 3 | 1885 | | } |
| | 0 | 1886 | | public override int RuleIndex { get { return RULE_singleHeap; } } |
| | | 1887 | | } |
| | | 1888 | | |
| | | 1889 | | [RuleVersion(0)] |
| | 3 | 1890 | | public SingleHeapContext singleHeap() { |
| | 3 | 1891 | | SingleHeapContext _localctx = new SingleHeapContext(Context, State); |
| | 3 | 1892 | | EnterRule(_localctx, 38, RULE_singleHeap); |
| | 3 | 1893 | | try { |
| | 3 | 1894 | | EnterOuterAlt(_localctx, 1); |
| | 3 | 1895 | | { |
| | 6 | 1896 | | State = 367; _localctx.entrypoint = heap(); |
| | 6 | 1897 | | State = 368; Match(Eof); |
| | 3 | 1898 | | _localctx.res = _localctx.entrypoint.res; |
| | 3 | 1899 | | } |
| | 3 | 1900 | | } |
| | 0 | 1901 | | catch (RecognitionException re) { |
| | 0 | 1902 | | _localctx.exception = re; |
| | 0 | 1903 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1904 | | ErrorHandler.Recover(this, re); |
| | 0 | 1905 | | } |
| | 3 | 1906 | | finally { |
| | 3 | 1907 | | ExitRule(); |
| | 3 | 1908 | | } |
| | 3 | 1909 | | return _localctx; |
| | 3 | 1910 | | } |
| | | 1911 | | |
| | | 1912 | | public partial class TypeArgContext : ParserRuleContext { |
| | | 1913 | | public TypeParameter res; |
| | | 1914 | | public IToken name; |
| | | 1915 | | public RefinedTypeContext type; |
| | 0 | 1916 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COLON() { return GetToken(NanoCParser.COLON, 0); } |
| | 0 | 1917 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 0 | 1918 | | [System.Diagnostics.DebuggerNonUserCode] public RefinedTypeContext refinedType() { |
| | 0 | 1919 | | return GetRuleContext<RefinedTypeContext>(0); |
| | 0 | 1920 | | } |
| | | 1921 | | public TypeArgContext(ParserRuleContext parent, int invokingState) |
| | 68 | 1922 | | : base(parent, invokingState) |
| | 68 | 1923 | | { |
| | 68 | 1924 | | } |
| | 0 | 1925 | | public override int RuleIndex { get { return RULE_typeArg; } } |
| | | 1926 | | } |
| | | 1927 | | |
| | | 1928 | | [RuleVersion(0)] |
| | 68 | 1929 | | public TypeArgContext typeArg() { |
| | 68 | 1930 | | TypeArgContext _localctx = new TypeArgContext(Context, State); |
| | 68 | 1931 | | EnterRule(_localctx, 40, RULE_typeArg); |
| | 68 | 1932 | | try { |
| | 68 | 1933 | | EnterOuterAlt(_localctx, 1); |
| | 68 | 1934 | | { |
| | 136 | 1935 | | State = 371; _localctx.name = Match(IDENTIFIER); |
| | 136 | 1936 | | State = 372; Match(COLON); |
| | 136 | 1937 | | State = 373; _localctx.type = refinedType(); |
| | 68 | 1938 | | _localctx.res = new TypeParameter((_localctx.name!=null?_localctx.name.Text:null), _localctx.type.res); |
| | 68 | 1939 | | } |
| | 68 | 1940 | | } |
| | 0 | 1941 | | catch (RecognitionException re) { |
| | 0 | 1942 | | _localctx.exception = re; |
| | 0 | 1943 | | ErrorHandler.ReportError(this, re); |
| | 0 | 1944 | | ErrorHandler.Recover(this, re); |
| | 0 | 1945 | | } |
| | 68 | 1946 | | finally { |
| | 68 | 1947 | | ExitRule(); |
| | 68 | 1948 | | } |
| | 68 | 1949 | | return _localctx; |
| | 68 | 1950 | | } |
| | | 1951 | | |
| | | 1952 | | public partial class TypeArgListContext : ParserRuleContext { |
| | | 1953 | | public TypeParameter[] res; |
| | | 1954 | | public TypeArgContext _typeArg; |
| | 56 | 1955 | | public IList<TypeArgContext> _typeArgs = new List<TypeArgContext>(); |
| | 0 | 1956 | | [System.Diagnostics.DebuggerNonUserCode] public TypeArgContext[] typeArg() { |
| | 0 | 1957 | | return GetRuleContexts<TypeArgContext>(); |
| | 0 | 1958 | | } |
| | 0 | 1959 | | [System.Diagnostics.DebuggerNonUserCode] public TypeArgContext typeArg(int i) { |
| | 0 | 1960 | | return GetRuleContext<TypeArgContext>(i); |
| | 0 | 1961 | | } |
| | 0 | 1962 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(NanoCParser.COMMA); } |
| | 0 | 1963 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) { |
| | 0 | 1964 | | return GetToken(NanoCParser.COMMA, i); |
| | 0 | 1965 | | } |
| | | 1966 | | public TypeArgListContext(ParserRuleContext parent, int invokingState) |
| | 56 | 1967 | | : base(parent, invokingState) |
| | 56 | 1968 | | { |
| | 56 | 1969 | | } |
| | 0 | 1970 | | public override int RuleIndex { get { return RULE_typeArgList; } } |
| | | 1971 | | } |
| | | 1972 | | |
| | | 1973 | | [RuleVersion(0)] |
| | 56 | 1974 | | public TypeArgListContext typeArgList() { |
| | 56 | 1975 | | TypeArgListContext _localctx = new TypeArgListContext(Context, State); |
| | 56 | 1976 | | EnterRule(_localctx, 42, RULE_typeArgList); |
| | | 1977 | | int _la; |
| | 56 | 1978 | | try { |
| | 56 | 1979 | | EnterOuterAlt(_localctx, 1); |
| | 56 | 1980 | | { |
| | 56 | 1981 | | State = 384; |
| | 56 | 1982 | | ErrorHandler.Sync(this); |
| | 56 | 1983 | | _la = TokenStream.LA(1); |
| | 89 | 1984 | | if (_la==IDENTIFIER) { |
| | 33 | 1985 | | { |
| | 66 | 1986 | | State = 376; _localctx._typeArg = typeArg(); |
| | 33 | 1987 | | _localctx._typeArgs.Add(_localctx._typeArg); |
| | 33 | 1988 | | State = 381; |
| | 33 | 1989 | | ErrorHandler.Sync(this); |
| | 33 | 1990 | | _la = TokenStream.LA(1); |
| | 103 | 1991 | | while (_la==COMMA) { |
| | 35 | 1992 | | { |
| | 35 | 1993 | | { |
| | 70 | 1994 | | State = 377; Match(COMMA); |
| | 70 | 1995 | | State = 378; _localctx._typeArg = typeArg(); |
| | 35 | 1996 | | _localctx._typeArgs.Add(_localctx._typeArg); |
| | 35 | 1997 | | } |
| | 35 | 1998 | | } |
| | 35 | 1999 | | State = 383; |
| | 35 | 2000 | | ErrorHandler.Sync(this); |
| | 35 | 2001 | | _la = TokenStream.LA(1); |
| | 35 | 2002 | | } |
| | 33 | 2003 | | } |
| | 33 | 2004 | | } |
| | | 2005 | | |
| | 124 | 2006 | | _localctx.res = _localctx._typeArgs.Select(i => i.res).ToArray(); |
| | 56 | 2007 | | } |
| | 56 | 2008 | | } |
| | 0 | 2009 | | catch (RecognitionException re) { |
| | 0 | 2010 | | _localctx.exception = re; |
| | 0 | 2011 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2012 | | ErrorHandler.Recover(this, re); |
| | 0 | 2013 | | } |
| | 56 | 2014 | | finally { |
| | 56 | 2015 | | ExitRule(); |
| | 56 | 2016 | | } |
| | 56 | 2017 | | return _localctx; |
| | 56 | 2018 | | } |
| | | 2019 | | |
| | | 2020 | | public partial class WorldContext : ParserRuleContext { |
| | | 2021 | | public RawWorld res; |
| | | 2022 | | public RefinedTypeContext returnType; |
| | | 2023 | | public HeapContext outHeap; |
| | 0 | 2024 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARROW() { return GetToken(NanoCParser.ARROW, 0); } |
| | 0 | 2025 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SLASH() { return GetToken(NanoCParser.SLASH, 0); } |
| | 0 | 2026 | | [System.Diagnostics.DebuggerNonUserCode] public RefinedTypeContext refinedType() { |
| | 0 | 2027 | | return GetRuleContext<RefinedTypeContext>(0); |
| | 0 | 2028 | | } |
| | 0 | 2029 | | [System.Diagnostics.DebuggerNonUserCode] public HeapContext heap() { |
| | 0 | 2030 | | return GetRuleContext<HeapContext>(0); |
| | 0 | 2031 | | } |
| | | 2032 | | public WorldContext(ParserRuleContext parent, int invokingState) |
| | 46 | 2033 | | : base(parent, invokingState) |
| | 46 | 2034 | | { |
| | 46 | 2035 | | } |
| | 0 | 2036 | | public override int RuleIndex { get { return RULE_world; } } |
| | | 2037 | | } |
| | | 2038 | | |
| | | 2039 | | [RuleVersion(0)] |
| | 46 | 2040 | | public WorldContext world() { |
| | 46 | 2041 | | WorldContext _localctx = new WorldContext(Context, State); |
| | 46 | 2042 | | EnterRule(_localctx, 44, RULE_world); |
| | 46 | 2043 | | try { |
| | 46 | 2044 | | State = 395; |
| | 46 | 2045 | | ErrorHandler.Sync(this); |
| | 46 | 2046 | | switch (TokenStream.LA(1)) { |
| | | 2047 | | case ARROW: |
| | 43 | 2048 | | EnterOuterAlt(_localctx, 1); |
| | 43 | 2049 | | { |
| | 86 | 2050 | | State = 388; Match(ARROW); |
| | 86 | 2051 | | State = 389; _localctx.returnType = refinedType(); |
| | 86 | 2052 | | State = 390; Match(SLASH); |
| | 86 | 2053 | | State = 391; _localctx.outHeap = heap(); |
| | 43 | 2054 | | _localctx.res = new RawWorld(_localctx.returnType.res, _localctx.outHeap.res); |
| | 43 | 2055 | | } |
| | 43 | 2056 | | break; |
| | | 2057 | | case Eof: |
| | | 2058 | | case IN: |
| | 3 | 2059 | | EnterOuterAlt(_localctx, 2); |
| | 3 | 2060 | | { |
| | 3 | 2061 | | _localctx.res = null; |
| | 3 | 2062 | | } |
| | 3 | 2063 | | break; |
| | | 2064 | | default: |
| | 0 | 2065 | | throw new NoViableAltException(this); |
| | | 2066 | | } |
| | 46 | 2067 | | } |
| | 0 | 2068 | | catch (RecognitionException re) { |
| | 0 | 2069 | | _localctx.exception = re; |
| | 0 | 2070 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2071 | | ErrorHandler.Recover(this, re); |
| | 0 | 2072 | | } |
| | 46 | 2073 | | finally { |
| | 46 | 2074 | | ExitRule(); |
| | 46 | 2075 | | } |
| | 46 | 2076 | | return _localctx; |
| | 46 | 2077 | | } |
| | | 2078 | | |
| | | 2079 | | public partial class IdentifierListContext : ParserRuleContext { |
| | | 2080 | | public string[] res; |
| | | 2081 | | public IToken _IDENTIFIER; |
| | 120 | 2082 | | public IList<IToken> _idents = new List<IToken>(); |
| | 0 | 2083 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] IDENTIFIER() { return GetTokens(NanoCParser.IDENTIFI |
| | 0 | 2084 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER(int i) { |
| | 0 | 2085 | | return GetToken(NanoCParser.IDENTIFIER, i); |
| | 0 | 2086 | | } |
| | 0 | 2087 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(NanoCParser.COMMA); } |
| | 0 | 2088 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) { |
| | 0 | 2089 | | return GetToken(NanoCParser.COMMA, i); |
| | 0 | 2090 | | } |
| | | 2091 | | public IdentifierListContext(ParserRuleContext parent, int invokingState) |
| | 120 | 2092 | | : base(parent, invokingState) |
| | 120 | 2093 | | { |
| | 120 | 2094 | | } |
| | 0 | 2095 | | public override int RuleIndex { get { return RULE_identifierList; } } |
| | | 2096 | | } |
| | | 2097 | | |
| | | 2098 | | [RuleVersion(0)] |
| | 120 | 2099 | | public IdentifierListContext identifierList() { |
| | 120 | 2100 | | IdentifierListContext _localctx = new IdentifierListContext(Context, State); |
| | 120 | 2101 | | EnterRule(_localctx, 46, RULE_identifierList); |
| | | 2102 | | int _la; |
| | 120 | 2103 | | try { |
| | 120 | 2104 | | EnterOuterAlt(_localctx, 1); |
| | 120 | 2105 | | { |
| | 120 | 2106 | | State = 405; |
| | 120 | 2107 | | ErrorHandler.Sync(this); |
| | 120 | 2108 | | _la = TokenStream.LA(1); |
| | 225 | 2109 | | if (_la==IDENTIFIER) { |
| | 105 | 2110 | | { |
| | 210 | 2111 | | State = 397; _localctx._IDENTIFIER = Match(IDENTIFIER); |
| | 105 | 2112 | | _localctx._idents.Add(_localctx._IDENTIFIER); |
| | 105 | 2113 | | State = 402; |
| | 105 | 2114 | | ErrorHandler.Sync(this); |
| | 105 | 2115 | | _la = TokenStream.LA(1); |
| | 177 | 2116 | | while (_la==COMMA) { |
| | 36 | 2117 | | { |
| | 36 | 2118 | | { |
| | 72 | 2119 | | State = 398; Match(COMMA); |
| | 72 | 2120 | | State = 399; _localctx._IDENTIFIER = Match(IDENTIFIER); |
| | 36 | 2121 | | _localctx._idents.Add(_localctx._IDENTIFIER); |
| | 36 | 2122 | | } |
| | 36 | 2123 | | } |
| | 36 | 2124 | | State = 404; |
| | 36 | 2125 | | ErrorHandler.Sync(this); |
| | 36 | 2126 | | _la = TokenStream.LA(1); |
| | 36 | 2127 | | } |
| | 105 | 2128 | | } |
| | 105 | 2129 | | } |
| | | 2130 | | |
| | 261 | 2131 | | _localctx.res = _localctx._idents.Select(i => i.Text).ToArray(); |
| | 120 | 2132 | | } |
| | 120 | 2133 | | } |
| | 0 | 2134 | | catch (RecognitionException re) { |
| | 0 | 2135 | | _localctx.exception = re; |
| | 0 | 2136 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2137 | | ErrorHandler.Recover(this, re); |
| | 0 | 2138 | | } |
| | 120 | 2139 | | finally { |
| | 120 | 2140 | | ExitRule(); |
| | 120 | 2141 | | } |
| | 120 | 2142 | | return _localctx; |
| | 120 | 2143 | | } |
| | | 2144 | | |
| | | 2145 | | public partial class FunctionSchemaContext : ParserRuleContext { |
| | | 2146 | | public RawFunctionSchema res; |
| | | 2147 | | public IdentifierListContext locations; |
| | | 2148 | | public TypeArgListContext typeArgs; |
| | | 2149 | | public HeapContext inHeap; |
| | | 2150 | | public WorldContext type; |
| | 0 | 2151 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBA() { return GetToken(NanoCParser.LBA, 0); } |
| | 0 | 2152 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBA() { return GetToken(NanoCParser.RBA, 0); } |
| | 0 | 2153 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 2154 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 2155 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SLASH() { return GetToken(NanoCParser.SLASH, 0); } |
| | 0 | 2156 | | [System.Diagnostics.DebuggerNonUserCode] public IdentifierListContext identifierList() { |
| | 0 | 2157 | | return GetRuleContext<IdentifierListContext>(0); |
| | 0 | 2158 | | } |
| | 0 | 2159 | | [System.Diagnostics.DebuggerNonUserCode] public TypeArgListContext typeArgList() { |
| | 0 | 2160 | | return GetRuleContext<TypeArgListContext>(0); |
| | 0 | 2161 | | } |
| | 0 | 2162 | | [System.Diagnostics.DebuggerNonUserCode] public HeapContext heap() { |
| | 0 | 2163 | | return GetRuleContext<HeapContext>(0); |
| | 0 | 2164 | | } |
| | 0 | 2165 | | [System.Diagnostics.DebuggerNonUserCode] public WorldContext world() { |
| | 0 | 2166 | | return GetRuleContext<WorldContext>(0); |
| | 0 | 2167 | | } |
| | | 2168 | | public FunctionSchemaContext(ParserRuleContext parent, int invokingState) |
| | 46 | 2169 | | : base(parent, invokingState) |
| | 46 | 2170 | | { |
| | 46 | 2171 | | } |
| | 0 | 2172 | | public override int RuleIndex { get { return RULE_functionSchema; } } |
| | | 2173 | | } |
| | | 2174 | | |
| | | 2175 | | [RuleVersion(0)] |
| | 46 | 2176 | | public FunctionSchemaContext functionSchema() { |
| | 46 | 2177 | | FunctionSchemaContext _localctx = new FunctionSchemaContext(Context, State); |
| | 46 | 2178 | | EnterRule(_localctx, 48, RULE_functionSchema); |
| | 46 | 2179 | | try { |
| | 46 | 2180 | | EnterOuterAlt(_localctx, 1); |
| | 46 | 2181 | | { |
| | 92 | 2182 | | State = 409; Match(LBA); |
| | 92 | 2183 | | State = 410; _localctx.locations = identifierList(); |
| | 92 | 2184 | | State = 411; Match(RBA); |
| | 92 | 2185 | | State = 412; Match(LB); |
| | 92 | 2186 | | State = 413; _localctx.typeArgs = typeArgList(); |
| | 92 | 2187 | | State = 414; Match(RB); |
| | 92 | 2188 | | State = 415; Match(SLASH); |
| | 92 | 2189 | | State = 416; _localctx.inHeap = heap(); |
| | 92 | 2190 | | State = 417; _localctx.type = world(); |
| | 46 | 2191 | | _localctx.res = new RawFunctionSchema(_localctx.locations.res, _localctx.typeArgs.res, _localctx.inHeap.res, _lo |
| | 46 | 2192 | | } |
| | 46 | 2193 | | } |
| | 0 | 2194 | | catch (RecognitionException re) { |
| | 0 | 2195 | | _localctx.exception = re; |
| | 0 | 2196 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2197 | | ErrorHandler.Recover(this, re); |
| | 0 | 2198 | | } |
| | 46 | 2199 | | finally { |
| | 46 | 2200 | | ExitRule(); |
| | 46 | 2201 | | } |
| | 46 | 2202 | | return _localctx; |
| | 46 | 2203 | | } |
| | | 2204 | | |
| | | 2205 | | public partial class SingleFunctionSchemaContext : ParserRuleContext { |
| | | 2206 | | public RawFunctionSchema res; |
| | | 2207 | | public FunctionSchemaContext entrypoint; |
| | 0 | 2208 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 2209 | | [System.Diagnostics.DebuggerNonUserCode] public FunctionSchemaContext functionSchema() { |
| | 0 | 2210 | | return GetRuleContext<FunctionSchemaContext>(0); |
| | 0 | 2211 | | } |
| | | 2212 | | public SingleFunctionSchemaContext(ParserRuleContext parent, int invokingState) |
| | 3 | 2213 | | : base(parent, invokingState) |
| | 3 | 2214 | | { |
| | 3 | 2215 | | } |
| | 0 | 2216 | | public override int RuleIndex { get { return RULE_singleFunctionSchema; } } |
| | | 2217 | | } |
| | | 2218 | | |
| | | 2219 | | [RuleVersion(0)] |
| | 3 | 2220 | | public SingleFunctionSchemaContext singleFunctionSchema() { |
| | 3 | 2221 | | SingleFunctionSchemaContext _localctx = new SingleFunctionSchemaContext(Context, State); |
| | 3 | 2222 | | EnterRule(_localctx, 50, RULE_singleFunctionSchema); |
| | 3 | 2223 | | try { |
| | 3 | 2224 | | EnterOuterAlt(_localctx, 1); |
| | 3 | 2225 | | { |
| | 6 | 2226 | | State = 420; _localctx.entrypoint = functionSchema(); |
| | 6 | 2227 | | State = 421; Match(Eof); |
| | 3 | 2228 | | _localctx.res = _localctx.entrypoint.res; |
| | 3 | 2229 | | } |
| | 3 | 2230 | | } |
| | 0 | 2231 | | catch (RecognitionException re) { |
| | 0 | 2232 | | _localctx.exception = re; |
| | 0 | 2233 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2234 | | ErrorHandler.Recover(this, re); |
| | 0 | 2235 | | } |
| | 3 | 2236 | | finally { |
| | 3 | 2237 | | ExitRule(); |
| | 3 | 2238 | | } |
| | 3 | 2239 | | return _localctx; |
| | 3 | 2240 | | } |
| | | 2241 | | |
| | | 2242 | | public partial class FunctionDefinitionContext : ParserRuleContext { |
| | | 2243 | | public FunctionDefinition res; |
| | | 2244 | | public IToken _IDENTIFIER; |
| | 43 | 2245 | | public IList<IToken> _x = new List<IToken>(); |
| | | 2246 | | public ExpressionContext body; |
| | | 2247 | | public FunctionSchemaContext schema; |
| | 0 | 2248 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FUN() { return GetToken(NanoCParser.FUN, 0); } |
| | 0 | 2249 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 2250 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 2251 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBC() { return GetToken(NanoCParser.LBC, 0); } |
| | 0 | 2252 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBC() { return GetToken(NanoCParser.RBC, 0); } |
| | 0 | 2253 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COLON() { return GetToken(NanoCParser.COLON, 0); } |
| | 0 | 2254 | | [System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() { |
| | 0 | 2255 | | return GetRuleContext<ExpressionContext>(0); |
| | 0 | 2256 | | } |
| | 0 | 2257 | | [System.Diagnostics.DebuggerNonUserCode] public FunctionSchemaContext functionSchema() { |
| | 0 | 2258 | | return GetRuleContext<FunctionSchemaContext>(0); |
| | 0 | 2259 | | } |
| | 0 | 2260 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] IDENTIFIER() { return GetTokens(NanoCParser.IDENTIFI |
| | 0 | 2261 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER(int i) { |
| | 0 | 2262 | | return GetToken(NanoCParser.IDENTIFIER, i); |
| | 0 | 2263 | | } |
| | 0 | 2264 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(NanoCParser.COMMA); } |
| | 0 | 2265 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) { |
| | 0 | 2266 | | return GetToken(NanoCParser.COMMA, i); |
| | 0 | 2267 | | } |
| | | 2268 | | public FunctionDefinitionContext(ParserRuleContext parent, int invokingState) |
| | 43 | 2269 | | : base(parent, invokingState) |
| | 43 | 2270 | | { |
| | 43 | 2271 | | } |
| | 0 | 2272 | | public override int RuleIndex { get { return RULE_functionDefinition; } } |
| | | 2273 | | } |
| | | 2274 | | |
| | | 2275 | | [RuleVersion(0)] |
| | 43 | 2276 | | public FunctionDefinitionContext functionDefinition() { |
| | 43 | 2277 | | FunctionDefinitionContext _localctx = new FunctionDefinitionContext(Context, State); |
| | 43 | 2278 | | EnterRule(_localctx, 52, RULE_functionDefinition); |
| | | 2279 | | int _la; |
| | 43 | 2280 | | try { |
| | 43 | 2281 | | EnterOuterAlt(_localctx, 1); |
| | 43 | 2282 | | { |
| | 86 | 2283 | | State = 424; Match(FUN); |
| | 86 | 2284 | | State = 425; Match(LB); |
| | 43 | 2285 | | State = 434; |
| | 43 | 2286 | | ErrorHandler.Sync(this); |
| | 43 | 2287 | | _la = TokenStream.LA(1); |
| | 69 | 2288 | | if (_la==IDENTIFIER) { |
| | 26 | 2289 | | { |
| | 52 | 2290 | | State = 426; _localctx._IDENTIFIER = Match(IDENTIFIER); |
| | 26 | 2291 | | _localctx._x.Add(_localctx._IDENTIFIER); |
| | 26 | 2292 | | State = 431; |
| | 26 | 2293 | | ErrorHandler.Sync(this); |
| | 26 | 2294 | | _la = TokenStream.LA(1); |
| | 78 | 2295 | | while (_la==COMMA) { |
| | 26 | 2296 | | { |
| | 26 | 2297 | | { |
| | 52 | 2298 | | State = 427; Match(COMMA); |
| | 52 | 2299 | | State = 428; _localctx._IDENTIFIER = Match(IDENTIFIER); |
| | 26 | 2300 | | _localctx._x.Add(_localctx._IDENTIFIER); |
| | 26 | 2301 | | } |
| | 26 | 2302 | | } |
| | 26 | 2303 | | State = 433; |
| | 26 | 2304 | | ErrorHandler.Sync(this); |
| | 26 | 2305 | | _la = TokenStream.LA(1); |
| | 26 | 2306 | | } |
| | 26 | 2307 | | } |
| | 26 | 2308 | | } |
| | | 2309 | | |
| | 86 | 2310 | | State = 436; Match(RB); |
| | 86 | 2311 | | State = 437; Match(LBC); |
| | 86 | 2312 | | State = 438; _localctx.body = expression(); |
| | 86 | 2313 | | State = 439; Match(RBC); |
| | 86 | 2314 | | State = 440; Match(COLON); |
| | 86 | 2315 | | State = 441; _localctx.schema = functionSchema(); |
| | 43 | 2316 | | _localctx.res = new FunctionDefinition(_localctx.body.res, _localctx.schema.res); |
| | 43 | 2317 | | } |
| | 43 | 2318 | | } |
| | 0 | 2319 | | catch (RecognitionException re) { |
| | 0 | 2320 | | _localctx.exception = re; |
| | 0 | 2321 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2322 | | ErrorHandler.Recover(this, re); |
| | 0 | 2323 | | } |
| | 43 | 2324 | | finally { |
| | 43 | 2325 | | ExitRule(); |
| | 43 | 2326 | | } |
| | 43 | 2327 | | return _localctx; |
| | 43 | 2328 | | } |
| | | 2329 | | |
| | | 2330 | | public partial class SingleFunctionDefinitionContext : ParserRuleContext { |
| | | 2331 | | public FunctionDefinition res; |
| | | 2332 | | public FunctionDefinitionContext entrypoint; |
| | 0 | 2333 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 2334 | | [System.Diagnostics.DebuggerNonUserCode] public FunctionDefinitionContext functionDefinition() { |
| | 0 | 2335 | | return GetRuleContext<FunctionDefinitionContext>(0); |
| | 0 | 2336 | | } |
| | | 2337 | | public SingleFunctionDefinitionContext(ParserRuleContext parent, int invokingState) |
| | 0 | 2338 | | : base(parent, invokingState) |
| | 0 | 2339 | | { |
| | 0 | 2340 | | } |
| | 0 | 2341 | | public override int RuleIndex { get { return RULE_singleFunctionDefinition; } } |
| | | 2342 | | } |
| | | 2343 | | |
| | | 2344 | | [RuleVersion(0)] |
| | 0 | 2345 | | public SingleFunctionDefinitionContext singleFunctionDefinition() { |
| | 0 | 2346 | | SingleFunctionDefinitionContext _localctx = new SingleFunctionDefinitionContext(Context, State); |
| | 0 | 2347 | | EnterRule(_localctx, 54, RULE_singleFunctionDefinition); |
| | 0 | 2348 | | try { |
| | 0 | 2349 | | EnterOuterAlt(_localctx, 1); |
| | 0 | 2350 | | { |
| | 0 | 2351 | | State = 444; _localctx.entrypoint = functionDefinition(); |
| | 0 | 2352 | | State = 445; Match(Eof); |
| | 0 | 2353 | | _localctx.res = _localctx.entrypoint.res; |
| | 0 | 2354 | | } |
| | 0 | 2355 | | } |
| | 0 | 2356 | | catch (RecognitionException re) { |
| | 0 | 2357 | | _localctx.exception = re; |
| | 0 | 2358 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2359 | | ErrorHandler.Recover(this, re); |
| | 0 | 2360 | | } |
| | 0 | 2361 | | finally { |
| | 0 | 2362 | | ExitRule(); |
| | 0 | 2363 | | } |
| | 0 | 2364 | | return _localctx; |
| | 0 | 2365 | | } |
| | | 2366 | | |
| | | 2367 | | public partial class StructFieldContext : ParserRuleContext { |
| | | 2368 | | public StructField res; |
| | | 2369 | | public IToken name; |
| | | 2370 | | public BlockBindingContext fieldtype; |
| | 0 | 2371 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(NanoCParser.ASSIGN, 0); } |
| | 0 | 2372 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 0 | 2373 | | [System.Diagnostics.DebuggerNonUserCode] public BlockBindingContext blockBinding() { |
| | 0 | 2374 | | return GetRuleContext<BlockBindingContext>(0); |
| | 0 | 2375 | | } |
| | | 2376 | | public StructFieldContext(ParserRuleContext parent, int invokingState) |
| | 14 | 2377 | | : base(parent, invokingState) |
| | 14 | 2378 | | { |
| | 14 | 2379 | | } |
| | 0 | 2380 | | public override int RuleIndex { get { return RULE_structField; } } |
| | | 2381 | | } |
| | | 2382 | | |
| | | 2383 | | [RuleVersion(0)] |
| | 14 | 2384 | | public StructFieldContext structField() { |
| | 14 | 2385 | | StructFieldContext _localctx = new StructFieldContext(Context, State); |
| | 14 | 2386 | | EnterRule(_localctx, 56, RULE_structField); |
| | 14 | 2387 | | try { |
| | 14 | 2388 | | EnterOuterAlt(_localctx, 1); |
| | 14 | 2389 | | { |
| | 28 | 2390 | | State = 448; _localctx.name = Match(IDENTIFIER); |
| | 28 | 2391 | | State = 449; Match(ASSIGN); |
| | 28 | 2392 | | State = 450; _localctx.fieldtype = blockBinding(); |
| | 14 | 2393 | | _localctx.res = new StructField((_localctx.name!=null?_localctx.name.Text:null), _localctx.fieldtype.res); |
| | 14 | 2394 | | } |
| | 14 | 2395 | | } |
| | 0 | 2396 | | catch (RecognitionException re) { |
| | 0 | 2397 | | _localctx.exception = re; |
| | 0 | 2398 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2399 | | ErrorHandler.Recover(this, re); |
| | 0 | 2400 | | } |
| | 14 | 2401 | | finally { |
| | 14 | 2402 | | ExitRule(); |
| | 14 | 2403 | | } |
| | 14 | 2404 | | return _localctx; |
| | 14 | 2405 | | } |
| | | 2406 | | |
| | | 2407 | | public partial class StructDefinitionContext : ParserRuleContext { |
| | | 2408 | | public StructDefinition res; |
| | | 2409 | | public TypeArgListContext typeArgs; |
| | | 2410 | | public FunctionCallContext _functionCall; |
| | 10 | 2411 | | public IList<FunctionCallContext> _depends = new List<FunctionCallContext>(); |
| | | 2412 | | public StructFieldContext _structField; |
| | 10 | 2413 | | public IList<StructFieldContext> _fields = new List<StructFieldContext>(); |
| | | 2414 | | public IdentifierListContext locations; |
| | 0 | 2415 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRUCT() { return GetToken(NanoCParser.STRUCT, 0); } |
| | 0 | 2416 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 2417 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 2418 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBC() { return GetToken(NanoCParser.LBC, 0); } |
| | 0 | 2419 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBC() { return GetToken(NanoCParser.RBC, 0); } |
| | 0 | 2420 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COLON() { return GetTokens(NanoCParser.COLON); } |
| | 0 | 2421 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COLON(int i) { |
| | 0 | 2422 | | return GetToken(NanoCParser.COLON, i); |
| | 0 | 2423 | | } |
| | 0 | 2424 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBA() { return GetToken(NanoCParser.LBA, 0); } |
| | 0 | 2425 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBA() { return GetToken(NanoCParser.RBA, 0); } |
| | 0 | 2426 | | [System.Diagnostics.DebuggerNonUserCode] public TypeArgListContext typeArgList() { |
| | 0 | 2427 | | return GetRuleContext<TypeArgListContext>(0); |
| | 0 | 2428 | | } |
| | 0 | 2429 | | [System.Diagnostics.DebuggerNonUserCode] public IdentifierListContext identifierList() { |
| | 0 | 2430 | | return GetRuleContext<IdentifierListContext>(0); |
| | 0 | 2431 | | } |
| | 0 | 2432 | | [System.Diagnostics.DebuggerNonUserCode] public FunctionCallContext[] functionCall() { |
| | 0 | 2433 | | return GetRuleContexts<FunctionCallContext>(); |
| | 0 | 2434 | | } |
| | 0 | 2435 | | [System.Diagnostics.DebuggerNonUserCode] public FunctionCallContext functionCall(int i) { |
| | 0 | 2436 | | return GetRuleContext<FunctionCallContext>(i); |
| | 0 | 2437 | | } |
| | 0 | 2438 | | [System.Diagnostics.DebuggerNonUserCode] public StructFieldContext[] structField() { |
| | 0 | 2439 | | return GetRuleContexts<StructFieldContext>(); |
| | 0 | 2440 | | } |
| | 0 | 2441 | | [System.Diagnostics.DebuggerNonUserCode] public StructFieldContext structField(int i) { |
| | 0 | 2442 | | return GetRuleContext<StructFieldContext>(i); |
| | 0 | 2443 | | } |
| | 0 | 2444 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(NanoCParser.COMMA); } |
| | 0 | 2445 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) { |
| | 0 | 2446 | | return GetToken(NanoCParser.COMMA, i); |
| | 0 | 2447 | | } |
| | | 2448 | | public StructDefinitionContext(ParserRuleContext parent, int invokingState) |
| | 10 | 2449 | | : base(parent, invokingState) |
| | 10 | 2450 | | { |
| | 10 | 2451 | | } |
| | 0 | 2452 | | public override int RuleIndex { get { return RULE_structDefinition; } } |
| | | 2453 | | } |
| | | 2454 | | |
| | | 2455 | | [RuleVersion(0)] |
| | 10 | 2456 | | public StructDefinitionContext structDefinition() { |
| | 10 | 2457 | | StructDefinitionContext _localctx = new StructDefinitionContext(Context, State); |
| | 10 | 2458 | | EnterRule(_localctx, 58, RULE_structDefinition); |
| | | 2459 | | int _la; |
| | 10 | 2460 | | try { |
| | 10 | 2461 | | EnterOuterAlt(_localctx, 1); |
| | 10 | 2462 | | { |
| | 20 | 2463 | | State = 453; Match(STRUCT); |
| | 20 | 2464 | | State = 454; Match(LB); |
| | 20 | 2465 | | State = 455; _localctx.typeArgs = typeArgList(); |
| | 20 | 2466 | | State = 456; Match(RB); |
| | 10 | 2467 | | State = 466; |
| | 10 | 2468 | | ErrorHandler.Sync(this); |
| | 10 | 2469 | | _la = TokenStream.LA(1); |
| | 14 | 2470 | | if (_la==COLON) { |
| | 4 | 2471 | | { |
| | 8 | 2472 | | State = 457; Match(COLON); |
| | 8 | 2473 | | State = 458; _localctx._functionCall = functionCall(); |
| | 4 | 2474 | | _localctx._depends.Add(_localctx._functionCall); |
| | 4 | 2475 | | State = 463; |
| | 4 | 2476 | | ErrorHandler.Sync(this); |
| | 4 | 2477 | | _la = TokenStream.LA(1); |
| | 4 | 2478 | | while (_la==COMMA) { |
| | 0 | 2479 | | { |
| | 0 | 2480 | | { |
| | 0 | 2481 | | State = 459; Match(COMMA); |
| | 0 | 2482 | | State = 460; _localctx._functionCall = functionCall(); |
| | 0 | 2483 | | _localctx._depends.Add(_localctx._functionCall); |
| | 0 | 2484 | | } |
| | 0 | 2485 | | } |
| | 0 | 2486 | | State = 465; |
| | 0 | 2487 | | ErrorHandler.Sync(this); |
| | 0 | 2488 | | _la = TokenStream.LA(1); |
| | 0 | 2489 | | } |
| | 4 | 2490 | | } |
| | 4 | 2491 | | } |
| | | 2492 | | |
| | 20 | 2493 | | State = 468; Match(LBC); |
| | 10 | 2494 | | State = 470; |
| | 10 | 2495 | | ErrorHandler.Sync(this); |
| | 10 | 2496 | | _la = TokenStream.LA(1); |
| | 14 | 2497 | | do { |
| | 14 | 2498 | | { |
| | 14 | 2499 | | { |
| | 28 | 2500 | | State = 469; _localctx._structField = structField(); |
| | 14 | 2501 | | _localctx._fields.Add(_localctx._structField); |
| | 14 | 2502 | | } |
| | 14 | 2503 | | } |
| | 14 | 2504 | | State = 472; |
| | 14 | 2505 | | ErrorHandler.Sync(this); |
| | 14 | 2506 | | _la = TokenStream.LA(1); |
| | 28 | 2507 | | } while ( _la==IDENTIFIER ); |
| | 20 | 2508 | | State = 474; Match(RBC); |
| | 20 | 2509 | | State = 475; Match(COLON); |
| | 20 | 2510 | | State = 476; Match(LBA); |
| | 20 | 2511 | | State = 477; _localctx.locations = identifierList(); |
| | 20 | 2512 | | State = 478; Match(RBA); |
| | 28 | 2513 | | _localctx.res = new StructDefinition(_localctx.locations.res, _localctx.typeArgs.res, _localctx._depends.Select( |
| | 10 | 2514 | | } |
| | 10 | 2515 | | } |
| | 0 | 2516 | | catch (RecognitionException re) { |
| | 0 | 2517 | | _localctx.exception = re; |
| | 0 | 2518 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2519 | | ErrorHandler.Recover(this, re); |
| | 0 | 2520 | | } |
| | 10 | 2521 | | finally { |
| | 10 | 2522 | | ExitRule(); |
| | 10 | 2523 | | } |
| | 10 | 2524 | | return _localctx; |
| | 10 | 2525 | | } |
| | | 2526 | | |
| | | 2527 | | public partial class ProgramContext : ParserRuleContext { |
| | | 2528 | | public Program res; |
| | | 2529 | | public ProgramContext(ParserRuleContext parent, int invokingState) |
| | 72 | 2530 | | : base(parent, invokingState) |
| | 72 | 2531 | | { |
| | 72 | 2532 | | } |
| | 0 | 2533 | | public override int RuleIndex { get { return RULE_program; } } |
| | | 2534 | | |
| | 216 | 2535 | | public ProgramContext() { } |
| | 72 | 2536 | | public virtual void CopyFrom(ProgramContext context) { |
| | 72 | 2537 | | base.CopyFrom(context); |
| | 72 | 2538 | | this.res = context.res; |
| | 72 | 2539 | | } |
| | | 2540 | | } |
| | | 2541 | | public partial class MainCallContext : ProgramContext { |
| | | 2542 | | public IToken name; |
| | 0 | 2543 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LB() { return GetToken(NanoCParser.LB, 0); } |
| | 0 | 2544 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RB() { return GetToken(NanoCParser.RB, 0); } |
| | 0 | 2545 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 76 | 2546 | | public MainCallContext(ProgramContext context) { CopyFrom(context); } |
| | | 2547 | | } |
| | | 2548 | | public partial class FunctionBindingContext : ProgramContext { |
| | | 2549 | | public IToken name; |
| | | 2550 | | public FunctionDefinitionContext definition; |
| | | 2551 | | public ProgramContext body; |
| | 0 | 2552 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LETF() { return GetToken(NanoCParser.LETF, 0); } |
| | 0 | 2553 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(NanoCParser.ASSIGN, 0); } |
| | 0 | 2554 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IN() { return GetToken(NanoCParser.IN, 0); } |
| | 0 | 2555 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 0 | 2556 | | [System.Diagnostics.DebuggerNonUserCode] public FunctionDefinitionContext functionDefinition() { |
| | 0 | 2557 | | return GetRuleContext<FunctionDefinitionContext>(0); |
| | 0 | 2558 | | } |
| | 0 | 2559 | | [System.Diagnostics.DebuggerNonUserCode] public ProgramContext program() { |
| | 0 | 2560 | | return GetRuleContext<ProgramContext>(0); |
| | 0 | 2561 | | } |
| | 172 | 2562 | | public FunctionBindingContext(ProgramContext context) { CopyFrom(context); } |
| | | 2563 | | } |
| | | 2564 | | public partial class StructBindingContext : ProgramContext { |
| | | 2565 | | public IToken name; |
| | | 2566 | | public StructDefinitionContext definition; |
| | | 2567 | | public ProgramContext body; |
| | 0 | 2568 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LETS() { return GetToken(NanoCParser.LETS, 0); } |
| | 0 | 2569 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(NanoCParser.ASSIGN, 0); } |
| | 0 | 2570 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IN() { return GetToken(NanoCParser.IN, 0); } |
| | 0 | 2571 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(NanoCParser.IDENTIFIER, |
| | 0 | 2572 | | [System.Diagnostics.DebuggerNonUserCode] public StructDefinitionContext structDefinition() { |
| | 0 | 2573 | | return GetRuleContext<StructDefinitionContext>(0); |
| | 0 | 2574 | | } |
| | 0 | 2575 | | [System.Diagnostics.DebuggerNonUserCode] public ProgramContext program() { |
| | 0 | 2576 | | return GetRuleContext<ProgramContext>(0); |
| | 0 | 2577 | | } |
| | 40 | 2578 | | public StructBindingContext(ProgramContext context) { CopyFrom(context); } |
| | | 2579 | | } |
| | | 2580 | | |
| | | 2581 | | [RuleVersion(0)] |
| | 72 | 2582 | | public ProgramContext program() { |
| | 72 | 2583 | | ProgramContext _localctx = new ProgramContext(Context, State); |
| | 72 | 2584 | | EnterRule(_localctx, 60, RULE_program); |
| | 72 | 2585 | | try { |
| | 72 | 2586 | | State = 501; |
| | 72 | 2587 | | ErrorHandler.Sync(this); |
| | 72 | 2588 | | switch (TokenStream.LA(1)) { |
| | | 2589 | | case LETF: |
| | 43 | 2590 | | _localctx = new FunctionBindingContext(_localctx); |
| | 43 | 2591 | | EnterOuterAlt(_localctx, 1); |
| | 43 | 2592 | | { |
| | 86 | 2593 | | State = 481; Match(LETF); |
| | 86 | 2594 | | State = 482; ((FunctionBindingContext)_localctx).name = Match(IDENTIFIER); |
| | 86 | 2595 | | State = 483; Match(ASSIGN); |
| | 86 | 2596 | | State = 484; ((FunctionBindingContext)_localctx).definition = functionDefinition(); |
| | 86 | 2597 | | State = 485; Match(IN); |
| | 86 | 2598 | | State = 486; ((FunctionBindingContext)_localctx).body = program(); |
| | 43 | 2599 | | ((FunctionBindingContext)_localctx).res = new FunctionBinding((((FunctionBindingContext)_localctx).name!=null? |
| | 43 | 2600 | | } |
| | 43 | 2601 | | break; |
| | | 2602 | | case LETS: |
| | 10 | 2603 | | _localctx = new StructBindingContext(_localctx); |
| | 10 | 2604 | | EnterOuterAlt(_localctx, 2); |
| | 10 | 2605 | | { |
| | 20 | 2606 | | State = 489; Match(LETS); |
| | 20 | 2607 | | State = 490; ((StructBindingContext)_localctx).name = Match(IDENTIFIER); |
| | 20 | 2608 | | State = 491; Match(ASSIGN); |
| | 20 | 2609 | | State = 492; ((StructBindingContext)_localctx).definition = structDefinition(); |
| | 20 | 2610 | | State = 493; Match(IN); |
| | 20 | 2611 | | State = 494; ((StructBindingContext)_localctx).body = program(); |
| | 10 | 2612 | | ((StructBindingContext)_localctx).res = new StructBinding((((StructBindingContext)_localctx).name!=null?((Stru |
| | 10 | 2613 | | } |
| | 10 | 2614 | | break; |
| | | 2615 | | case IDENTIFIER: |
| | 19 | 2616 | | _localctx = new MainCallContext(_localctx); |
| | 19 | 2617 | | EnterOuterAlt(_localctx, 3); |
| | 19 | 2618 | | { |
| | 38 | 2619 | | State = 497; ((MainCallContext)_localctx).name = Match(IDENTIFIER); |
| | 38 | 2620 | | State = 498; Match(LB); |
| | 38 | 2621 | | State = 499; Match(RB); |
| | 19 | 2622 | | ((MainCallContext)_localctx).res = new MainCall((((MainCallContext)_localctx).name!=null?((MainCallContext)_lo |
| | 19 | 2623 | | } |
| | 19 | 2624 | | break; |
| | | 2625 | | default: |
| | 0 | 2626 | | throw new NoViableAltException(this); |
| | | 2627 | | } |
| | 72 | 2628 | | } |
| | 0 | 2629 | | catch (RecognitionException re) { |
| | 0 | 2630 | | _localctx.exception = re; |
| | 0 | 2631 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2632 | | ErrorHandler.Recover(this, re); |
| | 0 | 2633 | | } |
| | 72 | 2634 | | finally { |
| | 72 | 2635 | | ExitRule(); |
| | 72 | 2636 | | } |
| | 72 | 2637 | | return _localctx; |
| | 72 | 2638 | | } |
| | | 2639 | | |
| | | 2640 | | public partial class SingleProgramContext : ParserRuleContext { |
| | | 2641 | | public Program res; |
| | | 2642 | | public ProgramContext entrypoint; |
| | 0 | 2643 | | [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(NanoCParser.Eof, 0); } |
| | 0 | 2644 | | [System.Diagnostics.DebuggerNonUserCode] public ProgramContext program() { |
| | 0 | 2645 | | return GetRuleContext<ProgramContext>(0); |
| | 0 | 2646 | | } |
| | | 2647 | | public SingleProgramContext(ParserRuleContext parent, int invokingState) |
| | 19 | 2648 | | : base(parent, invokingState) |
| | 19 | 2649 | | { |
| | 19 | 2650 | | } |
| | 0 | 2651 | | public override int RuleIndex { get { return RULE_singleProgram; } } |
| | | 2652 | | } |
| | | 2653 | | |
| | | 2654 | | [RuleVersion(0)] |
| | 19 | 2655 | | public SingleProgramContext singleProgram() { |
| | 19 | 2656 | | SingleProgramContext _localctx = new SingleProgramContext(Context, State); |
| | 19 | 2657 | | EnterRule(_localctx, 62, RULE_singleProgram); |
| | 19 | 2658 | | try { |
| | 19 | 2659 | | EnterOuterAlt(_localctx, 1); |
| | 19 | 2660 | | { |
| | 38 | 2661 | | State = 503; _localctx.entrypoint = program(); |
| | 38 | 2662 | | State = 504; Match(Eof); |
| | 19 | 2663 | | _localctx.res = _localctx.entrypoint.res; |
| | 19 | 2664 | | } |
| | 19 | 2665 | | } |
| | 0 | 2666 | | catch (RecognitionException re) { |
| | 0 | 2667 | | _localctx.exception = re; |
| | 0 | 2668 | | ErrorHandler.ReportError(this, re); |
| | 0 | 2669 | | ErrorHandler.Recover(this, re); |
| | 0 | 2670 | | } |
| | 19 | 2671 | | finally { |
| | 19 | 2672 | | ExitRule(); |
| | 19 | 2673 | | } |
| | 19 | 2674 | | return _localctx; |
| | 19 | 2675 | | } |
| | | 2676 | | |
| | 0 | 2677 | | public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) { |
| | 0 | 2678 | | switch (ruleIndex) { |
| | 0 | 2679 | | case 4: return pureExpression_sempred((PureExpressionContext)_localctx, predIndex); |
| | | 2680 | | } |
| | 0 | 2681 | | return true; |
| | 0 | 2682 | | } |
| | 0 | 2683 | | private bool pureExpression_sempred(PureExpressionContext _localctx, int predIndex) { |
| | 0 | 2684 | | switch (predIndex) { |
| | 0 | 2685 | | case 0: return Precpred(Context, 12); |
| | 0 | 2686 | | case 1: return Precpred(Context, 10); |
| | 0 | 2687 | | case 2: return Precpred(Context, 9); |
| | 0 | 2688 | | case 3: return Precpred(Context, 8); |
| | 0 | 2689 | | case 4: return Precpred(Context, 7); |
| | | 2690 | | } |
| | 0 | 2691 | | return true; |
| | 0 | 2692 | | } |
| | | 2693 | | |
| | 1 | 2694 | | private static char[] _serializedATN = { |
| | 1 | 2695 | | '\x3', '\x608B', '\xA72A', '\x8133', '\xB9ED', '\x417C', '\x3BE7', '\x7786', |
| | 1 | 2696 | | '\x5964', '\x3', '\x38', '\x1FE', '\x4', '\x2', '\t', '\x2', '\x4', '\x3', |
| | 1 | 2697 | | '\t', '\x3', '\x4', '\x4', '\t', '\x4', '\x4', '\x5', '\t', '\x5', '\x4', |
| | 1 | 2698 | | '\x6', '\t', '\x6', '\x4', '\a', '\t', '\a', '\x4', '\b', '\t', '\b', |
| | 1 | 2699 | | '\x4', '\t', '\t', '\t', '\x4', '\n', '\t', '\n', '\x4', '\v', '\t', '\v', |
| | 1 | 2700 | | '\x4', '\f', '\t', '\f', '\x4', '\r', '\t', '\r', '\x4', '\xE', '\t', |
| | 1 | 2701 | | '\xE', '\x4', '\xF', '\t', '\xF', '\x4', '\x10', '\t', '\x10', '\x4', |
| | 1 | 2702 | | '\x11', '\t', '\x11', '\x4', '\x12', '\t', '\x12', '\x4', '\x13', '\t', |
| | 1 | 2703 | | '\x13', '\x4', '\x14', '\t', '\x14', '\x4', '\x15', '\t', '\x15', '\x4', |
| | 1 | 2704 | | '\x16', '\t', '\x16', '\x4', '\x17', '\t', '\x17', '\x4', '\x18', '\t', |
| | 1 | 2705 | | '\x18', '\x4', '\x19', '\t', '\x19', '\x4', '\x1A', '\t', '\x1A', '\x4', |
| | 1 | 2706 | | '\x1B', '\t', '\x1B', '\x4', '\x1C', '\t', '\x1C', '\x4', '\x1D', '\t', |
| | 1 | 2707 | | '\x1D', '\x4', '\x1E', '\t', '\x1E', '\x4', '\x1F', '\t', '\x1F', '\x4', |
| | 1 | 2708 | | ' ', '\t', ' ', '\x4', '!', '\t', '!', '\x3', '\x2', '\x3', '\x2', '\x3', |
| | 1 | 2709 | | '\x2', '\x3', '\x2', '\x3', '\x2', '\x5', '\x2', 'H', '\n', '\x2', '\x3', |
| | 1 | 2710 | | '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x3', '\x4', '\x3', |
| | 1 | 2711 | | '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', |
| | 1 | 2712 | | '\x4', '\x3', '\x4', '\x5', '\x4', 'V', '\n', '\x4', '\x3', '\x5', '\x3', |
| | 1 | 2713 | | '\x5', '\x3', '\x5', '\x3', '\x5', '\x3', '\x6', '\x3', '\x6', '\x3', |
| | 1 | 2714 | | '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', |
| | 1 | 2715 | | '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', |
| | 1 | 2716 | | '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', |
| | 1 | 2717 | | '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\a', '\x6', |
| | 1 | 2718 | | 'r', '\n', '\x6', '\f', '\x6', '\xE', '\x6', 'u', '\v', '\x6', '\x5', |
| | 1 | 2719 | | '\x6', 'w', '\n', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', |
| | 1 | 2720 | | '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x5', |
| | 1 | 2721 | | '\x6', '\x81', '\n', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', |
| | 1 | 2722 | | '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', |
| | 1 | 2723 | | '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', |
| | 1 | 2724 | | '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', |
| | 1 | 2725 | | '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', '\x3', '\x6', |
| | 1 | 2726 | | '\x3', '\x6', '\x3', '\x6', '\a', '\x6', '\x9C', '\n', '\x6', '\f', '\x6', |
| | 1 | 2727 | | '\xE', '\x6', '\x9F', '\v', '\x6', '\x3', '\a', '\x3', '\a', '\x3', '\a', |
| | 1 | 2728 | | '\x3', '\a', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', |
| | 1 | 2729 | | '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', |
| | 1 | 2730 | | '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', |
| | 1 | 2731 | | '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x3', '\b', '\x5', '\b', |
| | 1 | 2732 | | '\xB9', '\n', '\b', '\x3', '\t', '\x3', '\t', '\x3', '\t', '\x3', '\t', |
| | 1 | 2733 | | '\x3', '\n', '\x3', '\n', '\x3', '\n', '\x3', '\n', '\x3', '\n', '\x3', |
| | 1 | 2734 | | '\n', '\x3', '\n', '\x3', '\n', '\x3', '\n', '\x3', '\n', '\x3', '\n', |
| | 1 | 2735 | | '\x3', '\n', '\x5', '\n', '\xCB', '\n', '\n', '\x3', '\v', '\x3', '\v', |
| | 1 | 2736 | | '\x3', '\v', '\x3', '\v', '\x3', '\f', '\x3', '\f', '\x3', '\f', '\x3', |
| | 1 | 2737 | | '\f', '\x3', '\f', '\x3', '\f', '\x3', '\f', '\x3', '\f', '\a', '\f', |
| | 1 | 2738 | | '\xD9', '\n', '\f', '\f', '\f', '\xE', '\f', '\xDC', '\v', '\f', '\x5', |
| | 1 | 2739 | | '\f', '\xDE', '\n', '\f', '\x3', '\f', '\x3', '\f', '\x3', '\f', '\x3', |
| | 1 | 2740 | | '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', |
| | 1 | 2741 | | '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', |
| | 1 | 2742 | | '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', |
| | 1 | 2743 | | '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', |
| | 1 | 2744 | | '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', |
| | 1 | 2745 | | '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', |
| | 1 | 2746 | | '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', |
| | 1 | 2747 | | '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', |
| | 1 | 2748 | | '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', |
| | 1 | 2749 | | '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', |
| | 1 | 2750 | | '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', |
| | 1 | 2751 | | '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', |
| | 1 | 2752 | | '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', |
| | 1 | 2753 | | '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', |
| | 1 | 2754 | | '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', |
| | 1 | 2755 | | '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', '\r', '\x3', |
| | 1 | 2756 | | '\r', '\x5', '\r', '\x13C', '\n', '\r', '\x3', '\xE', '\x3', '\xE', '\x3', |
| | 1 | 2757 | | '\xE', '\x3', '\xE', '\x3', '\xF', '\x3', '\xF', '\x3', '\xF', '\x3', |
| | 1 | 2758 | | '\xF', '\x3', '\xF', '\x3', '\x10', '\x3', '\x10', '\x3', '\x10', '\a', |
| | 1 | 2759 | | '\x10', '\x14A', '\n', '\x10', '\f', '\x10', '\xE', '\x10', '\x14D', '\v', |
| | 1 | 2760 | | '\x10', '\x5', '\x10', '\x14F', '\n', '\x10', '\x3', '\x10', '\x3', '\x10', |
| | 1 | 2761 | | '\x3', '\x11', '\x3', '\x11', '\x3', '\x11', '\x3', '\x11', '\x3', '\x12', |
| | 1 | 2762 | | '\x3', '\x12', '\x3', '\x12', '\x3', '\x12', '\x3', '\x12', '\x3', '\x13', |
| | 1 | 2763 | | '\x3', '\x13', '\x3', '\x13', '\x3', '\x13', '\x3', '\x13', '\x3', '\x13', |
| | 1 | 2764 | | '\x5', '\x13', '\x162', '\n', '\x13', '\x3', '\x14', '\x3', '\x14', '\x3', |
| | 1 | 2765 | | '\x14', '\x3', '\x14', '\x3', '\x14', '\a', '\x14', '\x169', '\n', '\x14', |
| | 1 | 2766 | | '\f', '\x14', '\xE', '\x14', '\x16C', '\v', '\x14', '\x3', '\x14', '\x3', |
| | 1 | 2767 | | '\x14', '\x5', '\x14', '\x170', '\n', '\x14', '\x3', '\x15', '\x3', '\x15', |
| | 1 | 2768 | | '\x3', '\x15', '\x3', '\x15', '\x3', '\x16', '\x3', '\x16', '\x3', '\x16', |
| | 1 | 2769 | | '\x3', '\x16', '\x3', '\x16', '\x3', '\x17', '\x3', '\x17', '\x3', '\x17', |
| | 1 | 2770 | | '\a', '\x17', '\x17E', '\n', '\x17', '\f', '\x17', '\xE', '\x17', '\x181', |
| | 1 | 2771 | | '\v', '\x17', '\x5', '\x17', '\x183', '\n', '\x17', '\x3', '\x17', '\x3', |
| | 1 | 2772 | | '\x17', '\x3', '\x18', '\x3', '\x18', '\x3', '\x18', '\x3', '\x18', '\x3', |
| | 1 | 2773 | | '\x18', '\x3', '\x18', '\x3', '\x18', '\x5', '\x18', '\x18E', '\n', '\x18', |
| | 1 | 2774 | | '\x3', '\x19', '\x3', '\x19', '\x3', '\x19', '\a', '\x19', '\x193', '\n', |
| | 1 | 2775 | | '\x19', '\f', '\x19', '\xE', '\x19', '\x196', '\v', '\x19', '\x5', '\x19', |
| | 1 | 2776 | | '\x198', '\n', '\x19', '\x3', '\x19', '\x3', '\x19', '\x3', '\x1A', '\x3', |
| | 1 | 2777 | | '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', |
| | 1 | 2778 | | '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', '\x1A', '\x3', |
| | 1 | 2779 | | '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1C', '\x3', |
| | 1 | 2780 | | '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\a', '\x1C', '\x1B0', |
| | 1 | 2781 | | '\n', '\x1C', '\f', '\x1C', '\xE', '\x1C', '\x1B3', '\v', '\x1C', '\x5', |
| | 1 | 2782 | | '\x1C', '\x1B5', '\n', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', |
| | 1 | 2783 | | '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', |
| | 1 | 2784 | | '\x3', '\x1D', '\x3', '\x1D', '\x3', '\x1D', '\x3', '\x1D', '\x3', '\x1E', |
| | 1 | 2785 | | '\x3', '\x1E', '\x3', '\x1E', '\x3', '\x1E', '\x3', '\x1E', '\x3', '\x1F', |
| | 1 | 2786 | | '\x3', '\x1F', '\x3', '\x1F', '\x3', '\x1F', '\x3', '\x1F', '\x3', '\x1F', |
| | 1 | 2787 | | '\x3', '\x1F', '\x3', '\x1F', '\a', '\x1F', '\x1D0', '\n', '\x1F', '\f', |
| | 1 | 2788 | | '\x1F', '\xE', '\x1F', '\x1D3', '\v', '\x1F', '\x5', '\x1F', '\x1D5', |
| | 1 | 2789 | | '\n', '\x1F', '\x3', '\x1F', '\x3', '\x1F', '\x6', '\x1F', '\x1D9', '\n', |
| | 1 | 2790 | | '\x1F', '\r', '\x1F', '\xE', '\x1F', '\x1DA', '\x3', '\x1F', '\x3', '\x1F', |
| | 1 | 2791 | | '\x3', '\x1F', '\x3', '\x1F', '\x3', '\x1F', '\x3', '\x1F', '\x3', '\x1F', |
| | 1 | 2792 | | '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', |
| | 1 | 2793 | | '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', |
| | 1 | 2794 | | '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', '\x3', ' ', |
| | 1 | 2795 | | '\x3', ' ', '\x3', ' ', '\x5', ' ', '\x1F8', '\n', ' ', '\x3', '!', '\x3', |
| | 1 | 2796 | | '!', '\x3', '!', '\x3', '!', '\x3', '!', '\x2', '\x3', '\n', '\"', '\x2', |
| | 1 | 2797 | | '\x4', '\x6', '\b', '\n', '\f', '\xE', '\x10', '\x12', '\x14', '\x16', |
| | 1 | 2798 | | '\x18', '\x1A', '\x1C', '\x1E', ' ', '\"', '$', '&', '(', '*', ',', '.', |
| | 1 | 2799 | | '\x30', '\x32', '\x34', '\x36', '\x38', ':', '<', '>', '@', '\x2', '\x5', |
| | 1 | 2800 | | '\x3', '\x2', '\x19', '\x1A', '\x4', '\x2', '\x1D', '\x1E', '!', '\"', |
| | 1 | 2801 | | '\x3', '\x2', '\x1B', '\x1C', '\x2', '\x212', '\x2', 'G', '\x3', '\x2', |
| | 1 | 2802 | | '\x2', '\x2', '\x4', 'I', '\x3', '\x2', '\x2', '\x2', '\x6', 'U', '\x3', |
| | 1 | 2803 | | '\x2', '\x2', '\x2', '\b', 'W', '\x3', '\x2', '\x2', '\x2', '\n', '\x80', |
| | 1 | 2804 | | '\x3', '\x2', '\x2', '\x2', '\f', '\xA0', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2805 | | '\xE', '\xB8', '\x3', '\x2', '\x2', '\x2', '\x10', '\xBA', '\x3', '\x2', |
| | 1 | 2806 | | '\x2', '\x2', '\x12', '\xCA', '\x3', '\x2', '\x2', '\x2', '\x14', '\xCC', |
| | 1 | 2807 | | '\x3', '\x2', '\x2', '\x2', '\x16', '\xD0', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2808 | | '\x18', '\x13B', '\x3', '\x2', '\x2', '\x2', '\x1A', '\x13D', '\x3', '\x2', |
| | 1 | 2809 | | '\x2', '\x2', '\x1C', '\x141', '\x3', '\x2', '\x2', '\x2', '\x1E', '\x14E', |
| | 1 | 2810 | | '\x3', '\x2', '\x2', '\x2', ' ', '\x152', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2811 | | '\"', '\x156', '\x3', '\x2', '\x2', '\x2', '$', '\x161', '\x3', '\x2', |
| | 1 | 2812 | | '\x2', '\x2', '&', '\x16F', '\x3', '\x2', '\x2', '\x2', '(', '\x171', |
| | 1 | 2813 | | '\x3', '\x2', '\x2', '\x2', '*', '\x175', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2814 | | ',', '\x182', '\x3', '\x2', '\x2', '\x2', '.', '\x18D', '\x3', '\x2', |
| | 1 | 2815 | | '\x2', '\x2', '\x30', '\x197', '\x3', '\x2', '\x2', '\x2', '\x32', '\x19B', |
| | 1 | 2816 | | '\x3', '\x2', '\x2', '\x2', '\x34', '\x1A6', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2817 | | '\x36', '\x1AA', '\x3', '\x2', '\x2', '\x2', '\x38', '\x1BE', '\x3', '\x2', |
| | 1 | 2818 | | '\x2', '\x2', ':', '\x1C2', '\x3', '\x2', '\x2', '\x2', '<', '\x1C7', |
| | 1 | 2819 | | '\x3', '\x2', '\x2', '\x2', '>', '\x1F7', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2820 | | '@', '\x1F9', '\x3', '\x2', '\x2', '\x2', '\x42', '\x43', '\a', '\x33', |
| | 1 | 2821 | | '\x2', '\x2', '\x43', 'H', '\b', '\x2', '\x1', '\x2', '\x44', '\x45', |
| | 1 | 2822 | | '\a', '-', '\x2', '\x2', '\x45', '\x46', '\a', '\x33', '\x2', '\x2', '\x46', |
| | 1 | 2823 | | 'H', '\b', '\x2', '\x1', '\x2', 'G', '\x42', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2824 | | 'G', '\x44', '\x3', '\x2', '\x2', '\x2', 'H', '\x3', '\x3', '\x2', '\x2', |
| | 1 | 2825 | | '\x2', 'I', 'J', '\x5', '\x2', '\x2', '\x2', 'J', 'K', '\a', '\x2', '\x2', |
| | 1 | 2826 | | '\x3', 'K', 'L', '\b', '\x3', '\x1', '\x2', 'L', '\x5', '\x3', '\x2', |
| | 1 | 2827 | | '\x2', '\x2', 'M', 'N', '\a', '\x34', '\x2', '\x2', 'N', 'V', '\b', '\x4', |
| | 1 | 2828 | | '\x1', '\x2', 'O', 'P', '\a', '\x34', '\x2', '\x2', 'P', 'Q', '\a', '\x19', |
| | 1 | 2829 | | '\x2', '\x2', 'Q', 'R', '\a', '\x34', '\x2', '\x2', 'R', 'V', '\b', '\x4', |
| | 1 | 2830 | | '\x1', '\x2', 'S', 'T', '\a', '\xE', '\x2', '\x2', 'T', 'V', '\b', '\x4', |
| | 1 | 2831 | | '\x1', '\x2', 'U', 'M', '\x3', '\x2', '\x2', '\x2', 'U', 'O', '\x3', '\x2', |
| | 1 | 2832 | | '\x2', '\x2', 'U', 'S', '\x3', '\x2', '\x2', '\x2', 'V', '\a', '\x3', |
| | 1 | 2833 | | '\x2', '\x2', '\x2', 'W', 'X', '\x5', '\x6', '\x4', '\x2', 'X', 'Y', '\a', |
| | 1 | 2834 | | '\x2', '\x2', '\x3', 'Y', 'Z', '\b', '\x5', '\x1', '\x2', 'Z', '\t', '\x3', |
| | 1 | 2835 | | '\x2', '\x2', '\x2', '[', '\\', '\b', '\x6', '\x1', '\x2', '\\', ']', |
| | 1 | 2836 | | '\a', '\x14', '\x2', '\x2', ']', '\x81', '\b', '\x6', '\x1', '\x2', '^', |
| | 1 | 2837 | | '_', '\a', '$', '\x2', '\x2', '_', '`', '\x5', '\n', '\x6', '\x2', '`', |
| | 1 | 2838 | | '\x61', '\a', '%', '\x2', '\x2', '\x61', '\x62', '\b', '\x6', '\x1', '\x2', |
| | 1 | 2839 | | '\x62', '\x81', '\x3', '\x2', '\x2', '\x2', '\x63', '\x64', '\a', '\xF', |
| | 1 | 2840 | | '\x2', '\x2', '\x64', '\x65', '\a', '$', '\x2', '\x2', '\x65', '\x66', |
| | 1 | 2841 | | '\x5', '\n', '\x6', '\x2', '\x66', 'g', '\a', '%', '\x2', '\x2', 'g', |
| | 1 | 2842 | | 'h', '\b', '\x6', '\x1', '\x2', 'h', '\x81', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2843 | | 'i', 'j', '\a', '\x18', '\x2', '\x2', 'j', 'k', '\a', '\x34', '\x2', '\x2', |
| | 1 | 2844 | | 'k', '\x81', '\b', '\x6', '\x1', '\x2', 'l', 'm', '\a', '\x33', '\x2', |
| | 1 | 2845 | | '\x2', 'm', 'v', '\a', '$', '\x2', '\x2', 'n', 's', '\x5', '\n', '\x6', |
| | 1 | 2846 | | '\x2', 'o', 'p', '\a', '+', '\x2', '\x2', 'p', 'r', '\x5', '\n', '\x6', |
| | 1 | 2847 | | '\x2', 'q', 'o', '\x3', '\x2', '\x2', '\x2', 'r', 'u', '\x3', '\x2', '\x2', |
| | 1 | 2848 | | '\x2', 's', 'q', '\x3', '\x2', '\x2', '\x2', 's', 't', '\x3', '\x2', '\x2', |
| | 1 | 2849 | | '\x2', 't', 'w', '\x3', '\x2', '\x2', '\x2', 'u', 's', '\x3', '\x2', '\x2', |
| | 1 | 2850 | | '\x2', 'v', 'n', '\x3', '\x2', '\x2', '\x2', 'v', 'w', '\x3', '\x2', '\x2', |
| | 1 | 2851 | | '\x2', 'w', 'x', '\x3', '\x2', '\x2', '\x2', 'x', 'y', '\a', '%', '\x2', |
| | 1 | 2852 | | '\x2', 'y', '\x81', '\b', '\x6', '\x1', '\x2', 'z', '{', '\a', '\x34', |
| | 1 | 2853 | | '\x2', '\x2', '{', '|', '\a', '.', '\x2', '\x2', '|', '}', '\a', '\x34', |
| | 1 | 2854 | | '\x2', '\x2', '}', '\x81', '\b', '\x6', '\x1', '\x2', '~', '\x7F', '\a', |
| | 1 | 2855 | | '\x33', '\x2', '\x2', '\x7F', '\x81', '\b', '\x6', '\x1', '\x2', '\x80', |
| | 1 | 2856 | | '[', '\x3', '\x2', '\x2', '\x2', '\x80', '^', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2857 | | '\x80', '\x63', '\x3', '\x2', '\x2', '\x2', '\x80', 'i', '\x3', '\x2', |
| | 1 | 2858 | | '\x2', '\x2', '\x80', 'l', '\x3', '\x2', '\x2', '\x2', '\x80', 'z', '\x3', |
| | 1 | 2859 | | '\x2', '\x2', '\x2', '\x80', '~', '\x3', '\x2', '\x2', '\x2', '\x81', |
| | 1 | 2860 | | '\x9D', '\x3', '\x2', '\x2', '\x2', '\x82', '\x83', '\f', '\xE', '\x2', |
| | 1 | 2861 | | '\x2', '\x83', '\x84', '\t', '\x2', '\x2', '\x2', '\x84', '\x85', '\x5', |
| | 1 | 2862 | | '\n', '\x6', '\xF', '\x85', '\x86', '\b', '\x6', '\x1', '\x2', '\x86', |
| | 1 | 2863 | | '\x9C', '\x3', '\x2', '\x2', '\x2', '\x87', '\x88', '\f', '\f', '\x2', |
| | 1 | 2864 | | '\x2', '\x88', '\x89', '\t', '\x3', '\x2', '\x2', '\x89', '\x8A', '\x5', |
| | 1 | 2865 | | '\n', '\x6', '\r', '\x8A', '\x8B', '\b', '\x6', '\x1', '\x2', '\x8B', |
| | 1 | 2866 | | '\x9C', '\x3', '\x2', '\x2', '\x2', '\x8C', '\x8D', '\f', '\v', '\x2', |
| | 1 | 2867 | | '\x2', '\x8D', '\x8E', '\t', '\x4', '\x2', '\x2', '\x8E', '\x8F', '\x5', |
| | 1 | 2868 | | '\n', '\x6', '\f', '\x8F', '\x90', '\b', '\x6', '\x1', '\x2', '\x90', |
| | 1 | 2869 | | '\x9C', '\x3', '\x2', '\x2', '\x2', '\x91', '\x92', '\f', '\n', '\x2', |
| | 1 | 2870 | | '\x2', '\x92', '\x93', '\a', '\x1F', '\x2', '\x2', '\x93', '\x94', '\x5', |
| | 1 | 2871 | | '\n', '\x6', '\v', '\x94', '\x95', '\b', '\x6', '\x1', '\x2', '\x95', |
| | 1 | 2872 | | '\x9C', '\x3', '\x2', '\x2', '\x2', '\x96', '\x97', '\f', '\t', '\x2', |
| | 1 | 2873 | | '\x2', '\x97', '\x98', '\a', ' ', '\x2', '\x2', '\x98', '\x99', '\x5', |
| | 1 | 2874 | | '\n', '\x6', '\n', '\x99', '\x9A', '\b', '\x6', '\x1', '\x2', '\x9A', |
| | 1 | 2875 | | '\x9C', '\x3', '\x2', '\x2', '\x2', '\x9B', '\x82', '\x3', '\x2', '\x2', |
| | 1 | 2876 | | '\x2', '\x9B', '\x87', '\x3', '\x2', '\x2', '\x2', '\x9B', '\x8C', '\x3', |
| | 1 | 2877 | | '\x2', '\x2', '\x2', '\x9B', '\x91', '\x3', '\x2', '\x2', '\x2', '\x9B', |
| | 1 | 2878 | | '\x96', '\x3', '\x2', '\x2', '\x2', '\x9C', '\x9F', '\x3', '\x2', '\x2', |
| | 1 | 2879 | | '\x2', '\x9D', '\x9B', '\x3', '\x2', '\x2', '\x2', '\x9D', '\x9E', '\x3', |
| | 1 | 2880 | | '\x2', '\x2', '\x2', '\x9E', '\v', '\x3', '\x2', '\x2', '\x2', '\x9F', |
| | 1 | 2881 | | '\x9D', '\x3', '\x2', '\x2', '\x2', '\xA0', '\xA1', '\x5', '\n', '\x6', |
| | 1 | 2882 | | '\x2', '\xA1', '\xA2', '\a', '\x2', '\x2', '\x3', '\xA2', '\xA3', '\b', |
| | 1 | 2883 | | '\a', '\x1', '\x2', '\xA3', '\r', '\x3', '\x2', '\x2', '\x2', '\xA4', |
| | 1 | 2884 | | '\xA5', '\a', '\x34', '\x2', '\x2', '\xA5', '\xA6', '\a', '(', '\x2', |
| | 1 | 2885 | | '\x2', '\xA6', '\xA7', '\x5', '\x6', '\x4', '\x2', '\xA7', '\xA8', '\a', |
| | 1 | 2886 | | ')', '\x2', '\x2', '\xA8', '\xA9', '\b', '\b', '\x1', '\x2', '\xA9', '\xB9', |
| | 1 | 2887 | | '\x3', '\x2', '\x2', '\x2', '\xAA', '\xAB', '\a', '\x17', '\x2', '\x2', |
| | 1 | 2888 | | '\xAB', '\xAC', '\a', '$', '\x2', '\x2', '\xAC', '\xAD', '\x5', '\x2', |
| | 1 | 2889 | | '\x2', '\x2', '\xAD', '\xAE', '\a', '+', '\x2', '\x2', '\xAE', '\xAF', |
| | 1 | 2890 | | '\x5', '\x6', '\x4', '\x2', '\xAF', '\xB0', '\a', '%', '\x2', '\x2', '\xB0', |
| | 1 | 2891 | | '\xB1', '\b', '\b', '\x1', '\x2', '\xB1', '\xB9', '\x3', '\x2', '\x2', |
| | 1 | 2892 | | '\x2', '\xB2', '\xB3', '\a', '\x11', '\x2', '\x2', '\xB3', '\xB9', '\b', |
| | 1 | 2893 | | '\b', '\x1', '\x2', '\xB4', '\xB5', '\a', '\x12', '\x2', '\x2', '\xB5', |
| | 1 | 2894 | | '\xB9', '\b', '\b', '\x1', '\x2', '\xB6', '\xB7', '\a', '\x13', '\x2', |
| | 1 | 2895 | | '\x2', '\xB7', '\xB9', '\b', '\b', '\x1', '\x2', '\xB8', '\xA4', '\x3', |
| | 1 | 2896 | | '\x2', '\x2', '\x2', '\xB8', '\xAA', '\x3', '\x2', '\x2', '\x2', '\xB8', |
| | 1 | 2897 | | '\xB2', '\x3', '\x2', '\x2', '\x2', '\xB8', '\xB4', '\x3', '\x2', '\x2', |
| | 1 | 2898 | | '\x2', '\xB8', '\xB6', '\x3', '\x2', '\x2', '\x2', '\xB9', '\xF', '\x3', |
| | 1 | 2899 | | '\x2', '\x2', '\x2', '\xBA', '\xBB', '\x5', '\xE', '\b', '\x2', '\xBB', |
| | 1 | 2900 | | '\xBC', '\a', '\x2', '\x2', '\x3', '\xBC', '\xBD', '\b', '\t', '\x1', |
| | 1 | 2901 | | '\x2', '\xBD', '\x11', '\x3', '\x2', '\x2', '\x2', '\xBE', '\xBF', '\a', |
| | 1 | 2902 | | '&', '\x2', '\x2', '\xBF', '\xC0', '\a', '\x33', '\x2', '\x2', '\xC0', |
| | 1 | 2903 | | '\xC1', '\a', '/', '\x2', '\x2', '\xC1', '\xC2', '\x5', '\xE', '\b', '\x2', |
| | 1 | 2904 | | '\xC2', '\xC3', '\a', '\x31', '\x2', '\x2', '\xC3', '\xC4', '\x5', '\n', |
| | 1 | 2905 | | '\x6', '\x2', '\xC4', '\xC5', '\a', '\'', '\x2', '\x2', '\xC5', '\xC6', |
| | 1 | 2906 | | '\b', '\n', '\x1', '\x2', '\xC6', '\xCB', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2907 | | '\xC7', '\xC8', '\x5', '\xE', '\b', '\x2', '\xC8', '\xC9', '\b', '\n', |
| | 1 | 2908 | | '\x1', '\x2', '\xC9', '\xCB', '\x3', '\x2', '\x2', '\x2', '\xCA', '\xBE', |
| | 1 | 2909 | | '\x3', '\x2', '\x2', '\x2', '\xCA', '\xC7', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2910 | | '\xCB', '\x13', '\x3', '\x2', '\x2', '\x2', '\xCC', '\xCD', '\x5', '\x12', |
| | 1 | 2911 | | '\n', '\x2', '\xCD', '\xCE', '\a', '\x2', '\x2', '\x3', '\xCE', '\xCF', |
| | 1 | 2912 | | '\b', '\v', '\x1', '\x2', '\xCF', '\x15', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2913 | | '\xD0', '\xD1', '\a', '(', '\x2', '\x2', '\xD1', '\xD2', '\x5', '\x30', |
| | 1 | 2914 | | '\x19', '\x2', '\xD2', '\xD3', '\a', ')', '\x2', '\x2', '\xD3', '\xD4', |
| | 1 | 2915 | | '\a', '\x33', '\x2', '\x2', '\xD4', '\xDD', '\a', '$', '\x2', '\x2', '\xD5', |
| | 1 | 2916 | | '\xDA', '\x5', '\n', '\x6', '\x2', '\xD6', '\xD7', '\a', '+', '\x2', '\x2', |
| | 1 | 2917 | | '\xD7', '\xD9', '\x5', '\n', '\x6', '\x2', '\xD8', '\xD6', '\x3', '\x2', |
| | 1 | 2918 | | '\x2', '\x2', '\xD9', '\xDC', '\x3', '\x2', '\x2', '\x2', '\xDA', '\xD8', |
| | 1 | 2919 | | '\x3', '\x2', '\x2', '\x2', '\xDA', '\xDB', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2920 | | '\xDB', '\xDE', '\x3', '\x2', '\x2', '\x2', '\xDC', '\xDA', '\x3', '\x2', |
| | 1 | 2921 | | '\x2', '\x2', '\xDD', '\xD5', '\x3', '\x2', '\x2', '\x2', '\xDD', '\xDE', |
| | 1 | 2922 | | '\x3', '\x2', '\x2', '\x2', '\xDE', '\xDF', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2923 | | '\xDF', '\xE0', '\a', '%', '\x2', '\x2', '\xE0', '\xE1', '\b', '\f', '\x1', |
| | 1 | 2924 | | '\x2', '\xE1', '\x17', '\x3', '\x2', '\x2', '\x2', '\xE2', '\xE3', '\a', |
| | 1 | 2925 | | '\v', '\x2', '\x2', '\xE3', '\xE4', '\x5', '\n', '\x6', '\x2', '\xE4', |
| | 1 | 2926 | | '\xE5', '\a', '\f', '\x2', '\x2', '\xE5', '\xE6', '\x5', '\x18', '\r', |
| | 1 | 2927 | | '\x2', '\xE6', '\xE7', '\a', '\r', '\x2', '\x2', '\xE7', '\xE8', '\x5', |
| | 1 | 2928 | | '\x18', '\r', '\x2', '\xE8', '\xE9', '\b', '\r', '\x1', '\x2', '\xE9', |
| | 1 | 2929 | | '\x13C', '\x3', '\x2', '\x2', '\x2', '\xEA', '\xEB', '\a', '\x3', '\x2', |
| | 1 | 2930 | | '\x2', '\xEB', '\xEC', '\a', '\x33', '\x2', '\x2', '\xEC', '\xED', '\a', |
| | 1 | 2931 | | '#', '\x2', '\x2', '\xED', '\xEE', '\x5', '\x18', '\r', '\x2', '\xEE', |
| | 1 | 2932 | | '\xEF', '\a', '\x16', '\x2', '\x2', '\xEF', '\xF0', '\x5', '\x18', '\r', |
| | 1 | 2933 | | '\x2', '\xF0', '\xF1', '\b', '\r', '\x1', '\x2', '\xF1', '\x13C', '\x3', |
| | 1 | 2934 | | '\x2', '\x2', '\x2', '\xF2', '\xF3', '\a', '\x3', '\x2', '\x2', '\xF3', |
| | 1 | 2935 | | '\xF4', '\x5', '\x18', '\r', '\x2', '\xF4', '\xF5', '\a', '\x16', '\x2', |
| | 1 | 2936 | | '\x2', '\xF5', '\xF6', '\x5', '\x18', '\r', '\x2', '\xF6', '\xF7', '\b', |
| | 1 | 2937 | | '\r', '\x1', '\x2', '\xF7', '\x13C', '\x3', '\x2', '\x2', '\x2', '\xF8', |
| | 1 | 2938 | | '\xF9', '\a', '\x6', '\x2', '\x2', '\xF9', '\xFA', '\a', '\x33', '\x2', |
| | 1 | 2939 | | '\x2', '\xFA', '\xFB', '\a', '#', '\x2', '\x2', '\xFB', '\xFC', '\a', |
| | 1 | 2940 | | '(', '\x2', '\x2', '\xFC', '\xFD', '\a', '\b', '\x2', '\x2', '\xFD', '\xFE', |
| | 1 | 2941 | | '\a', '\x33', '\x2', '\x2', '\xFE', '\xFF', '\a', ')', '\x2', '\x2', '\xFF', |
| | 1 | 2942 | | '\x100', '\x5', '\n', '\x6', '\x2', '\x100', '\x101', '\a', '\x16', '\x2', |
| | 1 | 2943 | | '\x2', '\x101', '\x102', '\x5', '\x18', '\r', '\x2', '\x102', '\x103', |
| | 1 | 2944 | | '\b', '\r', '\x1', '\x2', '\x103', '\x13C', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2945 | | '\x104', '\x105', '\a', '(', '\x2', '\x2', '\x105', '\x106', '\a', '\a', |
| | 1 | 2946 | | '\x2', '\x2', '\x106', '\x107', '\a', '\x33', '\x2', '\x2', '\x107', '\x108', |
| | 1 | 2947 | | '\a', ')', '\x2', '\x2', '\x108', '\x13C', '\b', '\r', '\x1', '\x2', '\x109', |
| | 1 | 2948 | | '\x10A', '\a', '*', '\x2', '\x2', '\x10A', '\x10B', '\x5', '\n', '\x6', |
| | 1 | 2949 | | '\x2', '\x10B', '\x10C', '\a', '#', '\x2', '\x2', '\x10C', '\x10D', '\x5', |
| | 1 | 2950 | | '\n', '\x6', '\x2', '\x10D', '\x10E', '\b', '\r', '\x1', '\x2', '\x10E', |
| | 1 | 2951 | | '\x13C', '\x3', '\x2', '\x2', '\x2', '\x10F', '\x110', '\a', '*', '\x2', |
| | 1 | 2952 | | '\x2', '\x110', '\x111', '\x5', '\n', '\x6', '\x2', '\x111', '\x112', |
| | 1 | 2953 | | '\b', '\r', '\x1', '\x2', '\x112', '\x13C', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2954 | | '\x113', '\x114', '\x5', '\n', '\x6', '\x2', '\x114', '\x115', '\a', '\x32', |
| | 1 | 2955 | | '\x2', '\x2', '\x115', '\x116', '\a', '\x33', '\x2', '\x2', '\x116', '\x117', |
| | 1 | 2956 | | '\a', '#', '\x2', '\x2', '\x117', '\x118', '\x5', '\n', '\x6', '\x2', |
| | 1 | 2957 | | '\x118', '\x119', '\b', '\r', '\x1', '\x2', '\x119', '\x13C', '\x3', '\x2', |
| | 1 | 2958 | | '\x2', '\x2', '\x11A', '\x11B', '\x5', '\n', '\x6', '\x2', '\x11B', '\x11C', |
| | 1 | 2959 | | '\a', '\x32', '\x2', '\x2', '\x11C', '\x11D', '\a', '\x33', '\x2', '\x2', |
| | 1 | 2960 | | '\x11D', '\x11E', '\b', '\r', '\x1', '\x2', '\x11E', '\x13C', '\x3', '\x2', |
| | 1 | 2961 | | '\x2', '\x2', '\x11F', '\x120', '\x5', '\n', '\x6', '\x2', '\x120', '\x121', |
| | 1 | 2962 | | '\a', '(', '\x2', '\x2', '\x121', '\x122', '\x5', '\n', '\x6', '\x2', |
| | 1 | 2963 | | '\x122', '\x123', '\a', ')', '\x2', '\x2', '\x123', '\x124', '\a', '#', |
| | 1 | 2964 | | '\x2', '\x2', '\x124', '\x125', '\x5', '\n', '\x6', '\x2', '\x125', '\x126', |
| | 1 | 2965 | | '\b', '\r', '\x1', '\x2', '\x126', '\x13C', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2966 | | '\x127', '\x128', '\x5', '\n', '\x6', '\x2', '\x128', '\x129', '\a', '(', |
| | 1 | 2967 | | '\x2', '\x2', '\x129', '\x12A', '\x5', '\n', '\x6', '\x2', '\x12A', '\x12B', |
| | 1 | 2968 | | '\a', ')', '\x2', '\x2', '\x12B', '\x12C', '\b', '\r', '\x1', '\x2', '\x12C', |
| | 1 | 2969 | | '\x13C', '\x3', '\x2', '\x2', '\x2', '\x12D', '\x12E', '\a', '\x10', '\x2', |
| | 1 | 2970 | | '\x2', '\x12E', '\x12F', '\a', '$', '\x2', '\x2', '\x12F', '\x130', '\a', |
| | 1 | 2971 | | '\x33', '\x2', '\x2', '\x130', '\x131', '\a', '+', '\x2', '\x2', '\x131', |
| | 1 | 2972 | | '\x132', '\x5', '\n', '\x6', '\x2', '\x132', '\x133', '\a', '%', '\x2', |
| | 1 | 2973 | | '\x2', '\x133', '\x134', '\b', '\r', '\x1', '\x2', '\x134', '\x13C', '\x3', |
| | 1 | 2974 | | '\x2', '\x2', '\x2', '\x135', '\x136', '\x5', '\x16', '\f', '\x2', '\x136', |
| | 1 | 2975 | | '\x137', '\b', '\r', '\x1', '\x2', '\x137', '\x13C', '\x3', '\x2', '\x2', |
| | 1 | 2976 | | '\x2', '\x138', '\x139', '\x5', '\n', '\x6', '\x2', '\x139', '\x13A', |
| | 1 | 2977 | | '\b', '\r', '\x1', '\x2', '\x13A', '\x13C', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2978 | | '\x13B', '\xE2', '\x3', '\x2', '\x2', '\x2', '\x13B', '\xEA', '\x3', '\x2', |
| | 1 | 2979 | | '\x2', '\x2', '\x13B', '\xF2', '\x3', '\x2', '\x2', '\x2', '\x13B', '\xF8', |
| | 1 | 2980 | | '\x3', '\x2', '\x2', '\x2', '\x13B', '\x104', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2981 | | '\x13B', '\x109', '\x3', '\x2', '\x2', '\x2', '\x13B', '\x10F', '\x3', |
| | 1 | 2982 | | '\x2', '\x2', '\x2', '\x13B', '\x113', '\x3', '\x2', '\x2', '\x2', '\x13B', |
| | 1 | 2983 | | '\x11A', '\x3', '\x2', '\x2', '\x2', '\x13B', '\x11F', '\x3', '\x2', '\x2', |
| | 1 | 2984 | | '\x2', '\x13B', '\x127', '\x3', '\x2', '\x2', '\x2', '\x13B', '\x12D', |
| | 1 | 2985 | | '\x3', '\x2', '\x2', '\x2', '\x13B', '\x135', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2986 | | '\x13B', '\x138', '\x3', '\x2', '\x2', '\x2', '\x13C', '\x19', '\x3', |
| | 1 | 2987 | | '\x2', '\x2', '\x2', '\x13D', '\x13E', '\x5', '\x18', '\r', '\x2', '\x13E', |
| | 1 | 2988 | | '\x13F', '\a', '\x2', '\x2', '\x3', '\x13F', '\x140', '\b', '\xE', '\x1', |
| | 1 | 2989 | | '\x2', '\x140', '\x1B', '\x3', '\x2', '\x2', '\x2', '\x141', '\x142', |
| | 1 | 2990 | | '\x5', '\x6', '\x4', '\x2', '\x142', '\x143', '\a', '/', '\x2', '\x2', |
| | 1 | 2991 | | '\x143', '\x144', '\x5', '\x12', '\n', '\x2', '\x144', '\x145', '\b', |
| | 1 | 2992 | | '\xF', '\x1', '\x2', '\x145', '\x1D', '\x3', '\x2', '\x2', '\x2', '\x146', |
| | 1 | 2993 | | '\x14B', '\x5', '\x1C', '\xF', '\x2', '\x147', '\x148', '\a', '+', '\x2', |
| | 1 | 2994 | | '\x2', '\x148', '\x14A', '\x5', '\x1C', '\xF', '\x2', '\x149', '\x147', |
| | 1 | 2995 | | '\x3', '\x2', '\x2', '\x2', '\x14A', '\x14D', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 2996 | | '\x14B', '\x149', '\x3', '\x2', '\x2', '\x2', '\x14B', '\x14C', '\x3', |
| | 1 | 2997 | | '\x2', '\x2', '\x2', '\x14C', '\x14F', '\x3', '\x2', '\x2', '\x2', '\x14D', |
| | 1 | 2998 | | '\x14B', '\x3', '\x2', '\x2', '\x2', '\x14E', '\x146', '\x3', '\x2', '\x2', |
| | 1 | 2999 | | '\x2', '\x14E', '\x14F', '\x3', '\x2', '\x2', '\x2', '\x14F', '\x150', |
| | 1 | 3000 | | '\x3', '\x2', '\x2', '\x2', '\x150', '\x151', '\b', '\x10', '\x1', '\x2', |
| | 1 | 3001 | | '\x151', '\x1F', '\x3', '\x2', '\x2', '\x2', '\x152', '\x153', '\x5', |
| | 1 | 3002 | | '\x1E', '\x10', '\x2', '\x153', '\x154', '\a', '\x2', '\x2', '\x3', '\x154', |
| | 1 | 3003 | | '\x155', '\b', '\x11', '\x1', '\x2', '\x155', '!', '\x3', '\x2', '\x2', |
| | 1 | 3004 | | '\x2', '\x156', '\x157', '\x5', '\x2', '\x2', '\x2', '\x157', '\x158', |
| | 1 | 3005 | | '\a', ',', '\x2', '\x2', '\x158', '\x159', '\x5', '\x1E', '\x10', '\x2', |
| | 1 | 3006 | | '\x159', '\x15A', '\b', '\x12', '\x1', '\x2', '\x15A', '#', '\x3', '\x2', |
| | 1 | 3007 | | '\x2', '\x2', '\x15B', '\x15C', '\x5', '\"', '\x12', '\x2', '\x15C', '\x15D', |
| | 1 | 3008 | | '\b', '\x13', '\x1', '\x2', '\x15D', '\x162', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3009 | | '\x15E', '\x15F', '\x5', '\x16', '\f', '\x2', '\x15F', '\x160', '\b', |
| | 1 | 3010 | | '\x13', '\x1', '\x2', '\x160', '\x162', '\x3', '\x2', '\x2', '\x2', '\x161', |
| | 1 | 3011 | | '\x15B', '\x3', '\x2', '\x2', '\x2', '\x161', '\x15E', '\x3', '\x2', '\x2', |
| | 1 | 3012 | | '\x2', '\x162', '%', '\x3', '\x2', '\x2', '\x2', '\x163', '\x164', '\a', |
| | 1 | 3013 | | '\x15', '\x2', '\x2', '\x164', '\x170', '\b', '\x14', '\x1', '\x2', '\x165', |
| | 1 | 3014 | | '\x16A', '\x5', '$', '\x13', '\x2', '\x166', '\x167', '\a', '*', '\x2', |
| | 1 | 3015 | | '\x2', '\x167', '\x169', '\x5', '$', '\x13', '\x2', '\x168', '\x166', |
| | 1 | 3016 | | '\x3', '\x2', '\x2', '\x2', '\x169', '\x16C', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3017 | | '\x16A', '\x168', '\x3', '\x2', '\x2', '\x2', '\x16A', '\x16B', '\x3', |
| | 1 | 3018 | | '\x2', '\x2', '\x2', '\x16B', '\x16D', '\x3', '\x2', '\x2', '\x2', '\x16C', |
| | 1 | 3019 | | '\x16A', '\x3', '\x2', '\x2', '\x2', '\x16D', '\x16E', '\b', '\x14', '\x1', |
| | 1 | 3020 | | '\x2', '\x16E', '\x170', '\x3', '\x2', '\x2', '\x2', '\x16F', '\x163', |
| | 1 | 3021 | | '\x3', '\x2', '\x2', '\x2', '\x16F', '\x165', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3022 | | '\x170', '\'', '\x3', '\x2', '\x2', '\x2', '\x171', '\x172', '\x5', '&', |
| | 1 | 3023 | | '\x14', '\x2', '\x172', '\x173', '\a', '\x2', '\x2', '\x3', '\x173', '\x174', |
| | 1 | 3024 | | '\b', '\x15', '\x1', '\x2', '\x174', ')', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3025 | | '\x175', '\x176', '\a', '\x33', '\x2', '\x2', '\x176', '\x177', '\a', |
| | 1 | 3026 | | '/', '\x2', '\x2', '\x177', '\x178', '\x5', '\x12', '\n', '\x2', '\x178', |
| | 1 | 3027 | | '\x179', '\b', '\x16', '\x1', '\x2', '\x179', '+', '\x3', '\x2', '\x2', |
| | 1 | 3028 | | '\x2', '\x17A', '\x17F', '\x5', '*', '\x16', '\x2', '\x17B', '\x17C', |
| | 1 | 3029 | | '\a', '+', '\x2', '\x2', '\x17C', '\x17E', '\x5', '*', '\x16', '\x2', |
| | 1 | 3030 | | '\x17D', '\x17B', '\x3', '\x2', '\x2', '\x2', '\x17E', '\x181', '\x3', |
| | 1 | 3031 | | '\x2', '\x2', '\x2', '\x17F', '\x17D', '\x3', '\x2', '\x2', '\x2', '\x17F', |
| | 1 | 3032 | | '\x180', '\x3', '\x2', '\x2', '\x2', '\x180', '\x183', '\x3', '\x2', '\x2', |
| | 1 | 3033 | | '\x2', '\x181', '\x17F', '\x3', '\x2', '\x2', '\x2', '\x182', '\x17A', |
| | 1 | 3034 | | '\x3', '\x2', '\x2', '\x2', '\x182', '\x183', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3035 | | '\x183', '\x184', '\x3', '\x2', '\x2', '\x2', '\x184', '\x185', '\b', |
| | 1 | 3036 | | '\x17', '\x1', '\x2', '\x185', '-', '\x3', '\x2', '\x2', '\x2', '\x186', |
| | 1 | 3037 | | '\x187', '\a', '\x32', '\x2', '\x2', '\x187', '\x188', '\x5', '\x12', |
| | 1 | 3038 | | '\n', '\x2', '\x188', '\x189', '\a', '\x30', '\x2', '\x2', '\x189', '\x18A', |
| | 1 | 3039 | | '\x5', '&', '\x14', '\x2', '\x18A', '\x18B', '\b', '\x18', '\x1', '\x2', |
| | 1 | 3040 | | '\x18B', '\x18E', '\x3', '\x2', '\x2', '\x2', '\x18C', '\x18E', '\b', |
| | 1 | 3041 | | '\x18', '\x1', '\x2', '\x18D', '\x186', '\x3', '\x2', '\x2', '\x2', '\x18D', |
| | 1 | 3042 | | '\x18C', '\x3', '\x2', '\x2', '\x2', '\x18E', '/', '\x3', '\x2', '\x2', |
| | 1 | 3043 | | '\x2', '\x18F', '\x194', '\a', '\x33', '\x2', '\x2', '\x190', '\x191', |
| | 1 | 3044 | | '\a', '+', '\x2', '\x2', '\x191', '\x193', '\a', '\x33', '\x2', '\x2', |
| | 1 | 3045 | | '\x192', '\x190', '\x3', '\x2', '\x2', '\x2', '\x193', '\x196', '\x3', |
| | 1 | 3046 | | '\x2', '\x2', '\x2', '\x194', '\x192', '\x3', '\x2', '\x2', '\x2', '\x194', |
| | 1 | 3047 | | '\x195', '\x3', '\x2', '\x2', '\x2', '\x195', '\x198', '\x3', '\x2', '\x2', |
| | 1 | 3048 | | '\x2', '\x196', '\x194', '\x3', '\x2', '\x2', '\x2', '\x197', '\x18F', |
| | 1 | 3049 | | '\x3', '\x2', '\x2', '\x2', '\x197', '\x198', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3050 | | '\x198', '\x199', '\x3', '\x2', '\x2', '\x2', '\x199', '\x19A', '\b', |
| | 1 | 3051 | | '\x19', '\x1', '\x2', '\x19A', '\x31', '\x3', '\x2', '\x2', '\x2', '\x19B', |
| | 1 | 3052 | | '\x19C', '\a', '(', '\x2', '\x2', '\x19C', '\x19D', '\x5', '\x30', '\x19', |
| | 1 | 3053 | | '\x2', '\x19D', '\x19E', '\a', ')', '\x2', '\x2', '\x19E', '\x19F', '\a', |
| | 1 | 3054 | | '$', '\x2', '\x2', '\x19F', '\x1A0', '\x5', ',', '\x17', '\x2', '\x1A0', |
| | 1 | 3055 | | '\x1A1', '\a', '%', '\x2', '\x2', '\x1A1', '\x1A2', '\a', '\x30', '\x2', |
| | 1 | 3056 | | '\x2', '\x1A2', '\x1A3', '\x5', '&', '\x14', '\x2', '\x1A3', '\x1A4', |
| | 1 | 3057 | | '\x5', '.', '\x18', '\x2', '\x1A4', '\x1A5', '\b', '\x1A', '\x1', '\x2', |
| | 1 | 3058 | | '\x1A5', '\x33', '\x3', '\x2', '\x2', '\x2', '\x1A6', '\x1A7', '\x5', |
| | 1 | 3059 | | '\x32', '\x1A', '\x2', '\x1A7', '\x1A8', '\a', '\x2', '\x2', '\x3', '\x1A8', |
| | 1 | 3060 | | '\x1A9', '\b', '\x1B', '\x1', '\x2', '\x1A9', '\x35', '\x3', '\x2', '\x2', |
| | 1 | 3061 | | '\x2', '\x1AA', '\x1AB', '\a', '\t', '\x2', '\x2', '\x1AB', '\x1B4', '\a', |
| | 1 | 3062 | | '$', '\x2', '\x2', '\x1AC', '\x1B1', '\a', '\x33', '\x2', '\x2', '\x1AD', |
| | 1 | 3063 | | '\x1AE', '\a', '+', '\x2', '\x2', '\x1AE', '\x1B0', '\a', '\x33', '\x2', |
| | 1 | 3064 | | '\x2', '\x1AF', '\x1AD', '\x3', '\x2', '\x2', '\x2', '\x1B0', '\x1B3', |
| | 1 | 3065 | | '\x3', '\x2', '\x2', '\x2', '\x1B1', '\x1AF', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3066 | | '\x1B1', '\x1B2', '\x3', '\x2', '\x2', '\x2', '\x1B2', '\x1B5', '\x3', |
| | 1 | 3067 | | '\x2', '\x2', '\x2', '\x1B3', '\x1B1', '\x3', '\x2', '\x2', '\x2', '\x1B4', |
| | 1 | 3068 | | '\x1AC', '\x3', '\x2', '\x2', '\x2', '\x1B4', '\x1B5', '\x3', '\x2', '\x2', |
| | 1 | 3069 | | '\x2', '\x1B5', '\x1B6', '\x3', '\x2', '\x2', '\x2', '\x1B6', '\x1B7', |
| | 1 | 3070 | | '\a', '%', '\x2', '\x2', '\x1B7', '\x1B8', '\a', '&', '\x2', '\x2', '\x1B8', |
| | 1 | 3071 | | '\x1B9', '\x5', '\x18', '\r', '\x2', '\x1B9', '\x1BA', '\a', '\'', '\x2', |
| | 1 | 3072 | | '\x2', '\x1BA', '\x1BB', '\a', '/', '\x2', '\x2', '\x1BB', '\x1BC', '\x5', |
| | 1 | 3073 | | '\x32', '\x1A', '\x2', '\x1BC', '\x1BD', '\b', '\x1C', '\x1', '\x2', '\x1BD', |
| | 1 | 3074 | | '\x37', '\x3', '\x2', '\x2', '\x2', '\x1BE', '\x1BF', '\x5', '\x36', '\x1C', |
| | 1 | 3075 | | '\x2', '\x1BF', '\x1C0', '\a', '\x2', '\x2', '\x3', '\x1C0', '\x1C1', |
| | 1 | 3076 | | '\b', '\x1D', '\x1', '\x2', '\x1C1', '\x39', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3077 | | '\x1C2', '\x1C3', '\a', '\x33', '\x2', '\x2', '\x1C3', '\x1C4', '\a', |
| | 1 | 3078 | | '#', '\x2', '\x2', '\x1C4', '\x1C5', '\x5', '\x1C', '\xF', '\x2', '\x1C5', |
| | 1 | 3079 | | '\x1C6', '\b', '\x1E', '\x1', '\x2', '\x1C6', ';', '\x3', '\x2', '\x2', |
| | 1 | 3080 | | '\x2', '\x1C7', '\x1C8', '\a', '\n', '\x2', '\x2', '\x1C8', '\x1C9', '\a', |
| | 1 | 3081 | | '$', '\x2', '\x2', '\x1C9', '\x1CA', '\x5', ',', '\x17', '\x2', '\x1CA', |
| | 1 | 3082 | | '\x1D4', '\a', '%', '\x2', '\x2', '\x1CB', '\x1CC', '\a', '/', '\x2', |
| | 1 | 3083 | | '\x2', '\x1CC', '\x1D1', '\x5', '\x16', '\f', '\x2', '\x1CD', '\x1CE', |
| | 1 | 3084 | | '\a', '+', '\x2', '\x2', '\x1CE', '\x1D0', '\x5', '\x16', '\f', '\x2', |
| | 1 | 3085 | | '\x1CF', '\x1CD', '\x3', '\x2', '\x2', '\x2', '\x1D0', '\x1D3', '\x3', |
| | 1 | 3086 | | '\x2', '\x2', '\x2', '\x1D1', '\x1CF', '\x3', '\x2', '\x2', '\x2', '\x1D1', |
| | 1 | 3087 | | '\x1D2', '\x3', '\x2', '\x2', '\x2', '\x1D2', '\x1D5', '\x3', '\x2', '\x2', |
| | 1 | 3088 | | '\x2', '\x1D3', '\x1D1', '\x3', '\x2', '\x2', '\x2', '\x1D4', '\x1CB', |
| | 1 | 3089 | | '\x3', '\x2', '\x2', '\x2', '\x1D4', '\x1D5', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3090 | | '\x1D5', '\x1D6', '\x3', '\x2', '\x2', '\x2', '\x1D6', '\x1D8', '\a', |
| | 1 | 3091 | | '&', '\x2', '\x2', '\x1D7', '\x1D9', '\x5', ':', '\x1E', '\x2', '\x1D8', |
| | 1 | 3092 | | '\x1D7', '\x3', '\x2', '\x2', '\x2', '\x1D9', '\x1DA', '\x3', '\x2', '\x2', |
| | 1 | 3093 | | '\x2', '\x1DA', '\x1D8', '\x3', '\x2', '\x2', '\x2', '\x1DA', '\x1DB', |
| | 1 | 3094 | | '\x3', '\x2', '\x2', '\x2', '\x1DB', '\x1DC', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3095 | | '\x1DC', '\x1DD', '\a', '\'', '\x2', '\x2', '\x1DD', '\x1DE', '\a', '/', |
| | 1 | 3096 | | '\x2', '\x2', '\x1DE', '\x1DF', '\a', '(', '\x2', '\x2', '\x1DF', '\x1E0', |
| | 1 | 3097 | | '\x5', '\x30', '\x19', '\x2', '\x1E0', '\x1E1', '\a', ')', '\x2', '\x2', |
| | 1 | 3098 | | '\x1E1', '\x1E2', '\b', '\x1F', '\x1', '\x2', '\x1E2', '=', '\x3', '\x2', |
| | 1 | 3099 | | '\x2', '\x2', '\x1E3', '\x1E4', '\a', '\x4', '\x2', '\x2', '\x1E4', '\x1E5', |
| | 1 | 3100 | | '\a', '\x33', '\x2', '\x2', '\x1E5', '\x1E6', '\a', '#', '\x2', '\x2', |
| | 1 | 3101 | | '\x1E6', '\x1E7', '\x5', '\x36', '\x1C', '\x2', '\x1E7', '\x1E8', '\a', |
| | 1 | 3102 | | '\x16', '\x2', '\x2', '\x1E8', '\x1E9', '\x5', '>', ' ', '\x2', '\x1E9', |
| | 1 | 3103 | | '\x1EA', '\b', ' ', '\x1', '\x2', '\x1EA', '\x1F8', '\x3', '\x2', '\x2', |
| | 1 | 3104 | | '\x2', '\x1EB', '\x1EC', '\a', '\x5', '\x2', '\x2', '\x1EC', '\x1ED', |
| | 1 | 3105 | | '\a', '\x33', '\x2', '\x2', '\x1ED', '\x1EE', '\a', '#', '\x2', '\x2', |
| | 1 | 3106 | | '\x1EE', '\x1EF', '\x5', '<', '\x1F', '\x2', '\x1EF', '\x1F0', '\a', '\x16', |
| | 1 | 3107 | | '\x2', '\x2', '\x1F0', '\x1F1', '\x5', '>', ' ', '\x2', '\x1F1', '\x1F2', |
| | 1 | 3108 | | '\b', ' ', '\x1', '\x2', '\x1F2', '\x1F8', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3109 | | '\x1F3', '\x1F4', '\a', '\x33', '\x2', '\x2', '\x1F4', '\x1F5', '\a', |
| | 1 | 3110 | | '$', '\x2', '\x2', '\x1F5', '\x1F6', '\a', '%', '\x2', '\x2', '\x1F6', |
| | 1 | 3111 | | '\x1F8', '\b', ' ', '\x1', '\x2', '\x1F7', '\x1E3', '\x3', '\x2', '\x2', |
| | 1 | 3112 | | '\x2', '\x1F7', '\x1EB', '\x3', '\x2', '\x2', '\x2', '\x1F7', '\x1F3', |
| | 1 | 3113 | | '\x3', '\x2', '\x2', '\x2', '\x1F8', '?', '\x3', '\x2', '\x2', '\x2', |
| | 1 | 3114 | | '\x1F9', '\x1FA', '\x5', '>', ' ', '\x2', '\x1FA', '\x1FB', '\a', '\x2', |
| | 1 | 3115 | | '\x2', '\x3', '\x1FB', '\x1FC', '\b', '!', '\x1', '\x2', '\x1FC', '\x41', |
| | 1 | 3116 | | '\x3', '\x2', '\x2', '\x2', '\x1E', 'G', 'U', 's', 'v', '\x80', '\x9B', |
| | 1 | 3117 | | '\x9D', '\xB8', '\xCA', '\xDA', '\xDD', '\x13B', '\x14B', '\x14E', '\x161', |
| | 1 | 3118 | | '\x16A', '\x16F', '\x17F', '\x182', '\x18D', '\x194', '\x197', '\x1B1', |
| | 1 | 3119 | | '\x1B4', '\x1D1', '\x1D4', '\x1DA', '\x1F7', |
| | 1 | 3120 | | }; |
| | | 3121 | | |
| | 1 | 3122 | | public static readonly ATN _ATN = |
| | 1 | 3123 | | new ATNDeserializer().Deserialize(_serializedATN); |
| | | 3124 | | |
| | | 3125 | | |
| | | 3126 | | } |
| | | 3127 | | } // namespace NanoCLang |