modl 0.3.2 → 0.3.3

Sign up to get free protection for your applications and to get access to all the features.
Files changed (31) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +28 -4
  3. data/README.md +10 -7
  4. data/grammar_tests/base_tests.json +1 -1
  5. data/lib/modl/parser/MODLLexer.rb +217 -217
  6. data/lib/modl/parser/MODLParser.interp +1 -1
  7. data/lib/modl/parser/MODLParser.rb +389 -400
  8. data/lib/modl/parser/MODLParserBaseListener.rb +1 -1
  9. data/lib/modl/parser/MODLParserBaseVisitor.rb +1 -1
  10. data/lib/modl/parser/MODLParserListener.rb +1 -1
  11. data/lib/modl/parser/MODLParserVisitor.rb +1 -1
  12. data/lib/modl/parser/class_processor.rb +2 -2
  13. data/lib/modl/parser/evaluator.rb +5 -5
  14. data/lib/modl/parser/file_importer.rb +11 -7
  15. data/lib/modl/parser/global_parse_context.rb +7 -3
  16. data/lib/modl/parser/instruction_processor.rb +3 -1
  17. data/lib/modl/parser/interpreter.rb +20 -5
  18. data/lib/modl/parser/modl_class.rb +1 -1
  19. data/lib/modl/parser/modl_index.rb +1 -1
  20. data/lib/modl/parser/modl_keylist.rb +1 -1
  21. data/lib/modl/parser/modl_method.rb +1 -1
  22. data/lib/modl/parser/object_cache.rb +1 -1
  23. data/lib/modl/parser/parsed.rb +31 -29
  24. data/lib/modl/parser/parser.rb +3 -3
  25. data/lib/modl/parser/ref_processor.rb +3 -3
  26. data/lib/modl/parser/substitutions.rb +1 -1
  27. data/lib/modl/parser/throwing_error_listener.rb +1 -1
  28. data/lib/modl/parser/version.rb +2 -2
  29. data/modl.gemspec +15 -16
  30. metadata +18 -18
  31. /data/lib/{modl/interpreter.rb → modl.rb} +0 -0
data/lib/modl/parser/MODLParser.rb CHANGED
@@ -2,7 +2,7 @@
2
2
 
3
3
  require 'antlr4/runtime'
4
4
 
5
- module Modl::Parser
5
+ module MODL::Parser
6
6
 
7
7
  @@theMODLParserListener = MODLParserListener.new
8
8
  @@theMODLParserVisitor = MODLParserVisitor.new
@@ -19,10 +19,10 @@ class MODLParser < Antlr4::Runtime::Parser
19
19
  NULL=2
20
20
  TRUE=3
21
21
  FALSE=4
22
- COLON = 5
23
- EQUALS = 6
24
- STRUCT_SEP = 7
25
- ARR_SEP = 8
22
+ COLON=5
23
+ EQUALS=6
24
+ STRUCT_SEP=7
25
+ ARR_SEP=8
26
26
  LBRAC=9
27
27
  RBRAC=10
28
28
  LSBRAC=11
@@ -81,17 +81,17 @@ class MODLParser < Antlr4::Runtime::Parser
81
81
  ]
82
82
 
83
83
  @@_LITERAL_NAMES = [
84
- nil, nil, nil, nil, nil, nil, nil, nil, "','", nil, nil, nil, nil, nil,
85
- nil, nil, nil, nil, nil, "'{'", nil, "'?'", "'/'", "'>'", "'<'", "'*'",
86
- "'&'", "'|'", "'!'", nil, "'}'"
84
+ nil, nil, nil, nil, nil, nil, nil, nil, "','", nil, nil, nil, nil, nil,
85
+ nil, nil, nil, nil, nil, "'{'", nil, "'?'", "'/'", "'>'", "'<'", "'*'",
86
+ "'&'", "'|'", "'!'", nil, "'}'"
87
87
  ]
88
88
 
89
89
  @@_SYMBOLIC_NAMES = [
90
- nil, "WS", "NULL", "TRUE", "FALSE", "COLON", "EQUALS", "STRUCT_SEP",
91
- "ARR_SEP", "LBRAC", "RBRAC", "LSBRAC", "RSBRAC", "NUMBER", "COMMENT",
92
- "STRING", "HASH_PREFIX", "QUOTED", "GRAVED", "LCBRAC", "CWS", "QMARK",
93
- "FSLASH", "GTHAN", "LTHAN", "ASTERISK", "AMP", "PIPE", "EXCLAM", "CCOMMENT",
94
- "RCBRAC"
90
+ nil, "WS", "NULL", "TRUE", "FALSE", "COLON", "EQUALS", "STRUCT_SEP",
91
+ "ARR_SEP", "LBRAC", "RBRAC", "LSBRAC", "RSBRAC", "NUMBER", "COMMENT",
92
+ "STRING", "HASH_PREFIX", "QUOTED", "GRAVED", "LCBRAC", "CWS", "QMARK",
93
+ "FSLASH", "GTHAN", "LTHAN", "ASTERISK", "AMP", "PIPE", "EXCLAM", "CCOMMENT",
94
+ "RCBRAC"
95
95
  ]
96
96
 
97
97
  @@VOCABULARY = Antlr4::Runtime::VocabularyImpl.new(@@_LITERAL_NAMES, @@_SYMBOLIC_NAMES)
@@ -128,24 +128,21 @@ class MODLParser < Antlr4::Runtime::Parser
128
128
  end
129
129
 
130
130
  class ModlContext < Antlr4::Runtime::ParserRuleContext
131
+ def EOF()
132
+ return token(MODLParser::EOF, 0)
133
+ end
131
134
  def modl_structure()
132
135
  return rule_contexts("Modl_structureContext")
133
136
  end
134
137
  def modl_structure_i( i)
135
138
  return rule_context("Modl_structureContext",i)
136
139
  end
137
-
138
- def EOF()
139
- return token(MODLParser::EOF, 0)
140
- end
141
-
142
- def STRUCT_SEP()
143
- return tokens(MODLParser::STRUCT_SEP)
144
- end
145
-
146
- def STRUCT_SEP_i(i)
147
- return token(MODLParser::STRUCT_SEP, i)
148
- end
140
+ def STRUCT_SEP()
141
+ return tokens(MODLParser::STRUCT_SEP)
142
+ end
143
+ def STRUCT_SEP_i( i)
144
+ return token(MODLParser::STRUCT_SEP, i)
145
+ end
149
146
  def initialize( parent, invokingState)
150
147
  super(parent, invokingState)
151
148
  end
@@ -177,59 +174,59 @@ class MODLParser < Antlr4::Runtime::Parser
177
174
  enter_rule(_localctx, 0, RULE_modl)
178
175
  _la = 0
179
176
  begin
180
- _alt = 0
181
- @_state_number = 64
182
- @_err_handler.sync(self)
183
- case (@_interp.adaptive_predict(@_input, 3, @_ctx))
184
- when 1
185
- enter_outer_alt(_localctx, 1)
177
+ _alt = 0
178
+ enter_outer_alt(_localctx, 1)
186
179
 
180
+ @_state_number = 62
181
+ @_err_handler.sync(self)
182
+ case ( @_interp.adaptive_predict(@_input,3,@_ctx) )
183
+ when 1
187
184
 
188
- @_state_number = 49
189
- @_err_handler.sync(self)
190
- _la = @_input.la(1)
191
- if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0))
192
185
 
193
- @_state_number = 48
194
- modl_structure()
195
- end
186
+ @_state_number = 49
187
+ @_err_handler.sync(self)
188
+ _la = @_input.la(1)
189
+ if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0))
196
190
 
191
+ @_state_number = 48
192
+ modl_structure()
193
+ end
197
194
 
198
- when 2
199
- enter_outer_alt(_localctx, 2)
200
195
 
196
+ when 2
201
197
 
202
- @_state_number = 51
203
- modl_structure()
204
- @_state_number = 56
205
- @_err_handler.sync(self);
206
- _alt = @_interp.adaptive_predict(@_input, 1, @_ctx)
207
- while (_alt != 2 && _alt != Antlr4::Runtime::ATN::INVALID_ALT_NUMBER)
208
- if (_alt == 1)
209
198
 
199
+ @_state_number = 51
200
+ modl_structure()
201
+ @_state_number = 56
202
+ @_err_handler.sync(self);
203
+ _alt = @_interp.adaptive_predict(@_input,1,@_ctx)
204
+ while ( _alt!=2 && _alt!=Antlr4::Runtime::ATN::INVALID_ALT_NUMBER )
205
+ if ( _alt==1 )
210
206
 
211
- @_state_number = 52
212
- match(STRUCT_SEP)
213
- @_state_number = 53
214
- modl_structure()
215
- end
216
- @_state_number = 58
217
- @_err_handler.sync(self)
218
- _alt = @_interp.adaptive_predict(@_input, 1, @_ctx)
219
- end
220
- @_state_number = 60
221
- @_err_handler.sync(self)
222
- _la = @_input.la(1)
223
- if (_la == STRUCT_SEP)
224
207
 
225
- @_state_number = 59
226
- match(STRUCT_SEP)
227
- end
208
+ @_state_number = 52
209
+ match(STRUCT_SEP)
210
+ @_state_number = 53
211
+ modl_structure()
212
+ end
213
+ @_state_number = 58
214
+ @_err_handler.sync(self)
215
+ _alt = @_interp.adaptive_predict(@_input,1,@_ctx)
216
+ end
217
+ @_state_number = 60
218
+ @_err_handler.sync(self)
219
+ _la = @_input.la(1)
220
+ if (_la==STRUCT_SEP)
221
+
222
+ @_state_number = 59
223
+ match(STRUCT_SEP)
224
+ end
228
225
 
229
- @_state_number = 62
230
- match(EOF)
231
226
 
232
227
  end
228
+ @_state_number = 64
229
+ match(EOF)
233
230
  rescue Antlr4::Runtime::RecognitionException => re
234
231
  _localctx.exception = re
235
232
  @_err_handler.report_error(self, re)
@@ -283,35 +280,35 @@ class MODLParser < Antlr4::Runtime::Parser
283
280
  _localctx = Modl_structureContext.new(@_ctx, @_state_number)
284
281
  enter_rule(_localctx, 2, RULE_modl_structure)
285
282
  begin
286
- @_state_number = 70
283
+ @_state_number = 70
287
284
  @_err_handler.sync(self)
288
- case (@_input.la(1))
289
- when MODLParser::LBRAC
285
+ case (@_input.la(1))
286
+ when MODLParser::LBRAC
290
287
  enter_outer_alt(_localctx, 1)
291
288
 
292
- @_state_number = 66
289
+ @_state_number = 66
293
290
  modl_map()
294
291
 
295
- when MODLParser::LSBRAC
292
+ when MODLParser::LSBRAC
296
293
  enter_outer_alt(_localctx, 2)
297
294
 
298
- @_state_number = 67
295
+ @_state_number = 67
299
296
  modl_array()
300
297
 
301
- when MODLParser::LCBRAC
298
+ when MODLParser::LCBRAC
302
299
  enter_outer_alt(_localctx, 3)
303
300
 
304
- @_state_number = 68
301
+ @_state_number = 68
305
302
  modl_top_level_conditional()
306
303
 
307
- when MODLParser::NULL, MODLParser::TRUE, MODLParser::FALSE, MODLParser::NUMBER, MODLParser::STRING, MODLParser::QUOTED
304
+ when MODLParser::NULL, MODLParser::TRUE, MODLParser::FALSE, MODLParser::NUMBER, MODLParser::STRING, MODLParser::QUOTED
308
305
  enter_outer_alt(_localctx, 4)
309
306
 
310
- @_state_number = 69
307
+ @_state_number = 69
311
308
  modl_pair()
312
- else
309
+ else
313
310
  raise Antlr4::Runtime::NoViableAltException self
314
- end
311
+ end
315
312
  rescue Antlr4::Runtime::RecognitionException => re
316
313
  _localctx.exception = re
317
314
  @_err_handler.report_error(self, re)
@@ -335,13 +332,11 @@ class MODLParser < Antlr4::Runtime::Parser
335
332
  def modl_map_item_i( i)
336
333
  return rule_context("Modl_map_itemContext",i)
337
334
  end
338
-
339
- def STRUCT_SEP()
340
- return tokens(MODLParser::STRUCT_SEP)
335
+ def STRUCT_SEP()
336
+ return tokens(MODLParser::STRUCT_SEP)
341
337
  end
342
-
343
- def STRUCT_SEP_i(i)
344
- return token(MODLParser::STRUCT_SEP, i)
338
+ def STRUCT_SEP_i( i)
339
+ return token(MODLParser::STRUCT_SEP, i)
345
340
  end
346
341
  def initialize( parent, invokingState)
347
342
  super(parent, invokingState)
@@ -376,32 +371,32 @@ class MODLParser < Antlr4::Runtime::Parser
376
371
  begin
377
372
  enter_outer_alt(_localctx, 1)
378
373
 
379
- @_state_number = 72
374
+ @_state_number = 72
380
375
  match(LBRAC)
381
- @_state_number = 81
376
+ @_state_number = 81
382
377
  @_err_handler.sync(self)
383
378
  _la = @_input.la(1)
384
- if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0))
379
+ if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0))
385
380
 
386
- @_state_number = 73
381
+ @_state_number = 73
387
382
  modl_map_item()
388
- @_state_number = 78
383
+ @_state_number = 78
389
384
  @_err_handler.sync(self)
390
385
  _la = @_input.la(1)
391
- while (_la == STRUCT_SEP)
386
+ while (_la==STRUCT_SEP)
392
387
 
393
388
 
394
- @_state_number = 74
395
- match(STRUCT_SEP)
396
- @_state_number = 75
389
+ @_state_number = 74
390
+ match(STRUCT_SEP)
391
+ @_state_number = 75
397
392
  modl_map_item()
398
- @_state_number = 80
393
+ @_state_number = 80
399
394
  @_err_handler.sync(self)
400
395
  _la = @_input.la(1)
401
- end
402
- end
396
+ end
397
+ end
403
398
 
404
- @_state_number = 83
399
+ @_state_number = 83
405
400
  match(RBRAC)
406
401
  rescue Antlr4::Runtime::RecognitionException => re
407
402
  _localctx.exception = re
@@ -432,13 +427,11 @@ class MODLParser < Antlr4::Runtime::Parser
432
427
  def modl_nb_array_i( i)
433
428
  return rule_context("Modl_nb_arrayContext",i)
434
429
  end
435
-
436
- def STRUCT_SEP()
437
- return tokens(MODLParser::STRUCT_SEP)
430
+ def STRUCT_SEP()
431
+ return tokens(MODLParser::STRUCT_SEP)
438
432
  end
439
-
440
- def STRUCT_SEP_i(i)
441
- return token(MODLParser::STRUCT_SEP, i)
433
+ def STRUCT_SEP_i( i)
434
+ return token(MODLParser::STRUCT_SEP, i)
442
435
  end
443
436
  def initialize( parent, invokingState)
444
437
  super(parent, invokingState)
@@ -474,81 +467,81 @@ class MODLParser < Antlr4::Runtime::Parser
474
467
  _alt = 0
475
468
  enter_outer_alt(_localctx, 1)
476
469
 
477
- @_state_number = 85
470
+ @_state_number = 85
478
471
  match(LSBRAC)
479
- @_state_number = 110
472
+ @_state_number = 110
480
473
  @_err_handler.sync(self)
481
474
  _la = @_input.la(1)
482
475
  if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0))
483
476
 
484
- @_state_number = 88
477
+ @_state_number = 88
485
478
  @_err_handler.sync(self)
486
- case (@_interp.adaptive_predict(@_input, 7, @_ctx))
487
- when 1
479
+ case ( @_interp.adaptive_predict(@_input,7,@_ctx) )
480
+ when 1
488
481
 
489
- @_state_number = 86
482
+ @_state_number = 86
490
483
  modl_array_item()
491
484
 
492
- when 2
485
+ when 2
493
486
 
494
- @_state_number = 87
487
+ @_state_number = 87
495
488
  modl_nb_array()
496
489
 
497
- end
498
- @_state_number = 107
490
+ end
491
+ @_state_number = 107
499
492
  @_err_handler.sync(self)
500
493
  _la = @_input.la(1)
501
- while (_la == STRUCT_SEP)
494
+ while (_la==STRUCT_SEP)
502
495
 
503
496
 
504
- @_state_number = 91
505
- @_err_handler.sync(self)
497
+ @_state_number = 91
498
+ @_err_handler.sync(self)
506
499
  _la = @_input.la(1)
507
500
  loop do
508
501
 
509
502
 
510
- @_state_number = 90
511
- match(STRUCT_SEP)
512
- @_state_number = 93
513
- @_err_handler.sync(self)
503
+ @_state_number = 90
504
+ match(STRUCT_SEP)
505
+ @_state_number = 93
506
+ @_err_handler.sync(self)
514
507
  _la = @_input.la(1)
515
- break if (!(_la == STRUCT_SEP))
508
+ break if (!( _la==STRUCT_SEP) )
516
509
  end
517
- @_state_number = 97
510
+ @_state_number = 97
518
511
  @_err_handler.sync(self)
519
- case (@_interp.adaptive_predict(@_input, 9, @_ctx))
520
- when 1
512
+ case ( @_interp.adaptive_predict(@_input,9,@_ctx) )
513
+ when 1
521
514
 
522
- @_state_number = 95
515
+ @_state_number = 95
523
516
  modl_array_item()
524
517
 
525
- when 2
518
+ when 2
526
519
 
527
- @_state_number = 96
528
- modl_nb_array()
520
+ @_state_number = 96
521
+ modl_nb_array()
529
522
 
530
- end
531
- @_state_number = 102
523
+ end
524
+ @_state_number = 102
532
525
  @_err_handler.sync(self);
533
- _alt = @_interp.adaptive_predict(@_input, 10, @_ctx)
534
- while (_alt != 2 && _alt != Antlr4::Runtime::ATN::INVALID_ALT_NUMBER)
535
- if (_alt == 1)
526
+ _alt = @_interp.adaptive_predict(@_input,10,@_ctx)
527
+ while ( _alt!=2 && _alt!=Antlr4::Runtime::ATN::INVALID_ALT_NUMBER )
528
+ if ( _alt==1 )
536
529
 
537
530
 
538
- @_state_number = 99
539
- match(STRUCT_SEP)
540
- end
541
- @_state_number = 104
531
+ @_state_number = 99
532
+ match(STRUCT_SEP)
533
+ end
534
+ @_state_number = 104
542
535
  @_err_handler.sync(self)
543
- _alt = @_interp.adaptive_predict(@_input, 10, @_ctx)
536
+ _alt = @_interp.adaptive_predict(@_input,10,@_ctx)
544
537
  end
545
- @_state_number = 109
538
+ @_state_number = 109
546
539
  @_err_handler.sync(self)
547
540
  _la = @_input.la(1)
548
- end
541
+ end
549
542
  end
550
543
 
551
- @_state_number = 112
544
+ @_state_number = 112
552
545
  match(RSBRAC)
553
546
  rescue Antlr4::Runtime::RecognitionException => re
554
547
  _localctx.exception = re
@@ -606,67 +599,67 @@ class MODLParser < Antlr4::Runtime::Parser
606
599
  _alt = 0
607
600
  enter_outer_alt(_localctx, 1)
608
601
 
609
- @_state_number = 120
610
- @_err_handler.sync(self)
602
+ @_state_number = 120
603
+ @_err_handler.sync(self)
611
604
  _alt = 1
612
605
  loop do
613
606
  case (_alt)
614
607
  when 1
615
608
 
616
609
 
617
- @_state_number = 114
610
+ @_state_number = 114
618
611
  modl_array_item()
619
- @_state_number = 116
620
- @_err_handler.sync(self)
612
+ @_state_number = 116
613
+ @_err_handler.sync(self)
621
614
  _alt = 1
622
615
  loop do
623
616
  case (_alt)
624
617
  when 1
625
618
 
626
619
 
627
- @_state_number = 115
620
+ @_state_number = 115
628
621
  match(COLON)
629
622
 
630
623
  else
631
624
  raise Antlr4::Runtime::NoViableAltException self
632
625
  end
633
- @_state_number = 118
634
- @_err_handler.sync(self)
635
- _alt = @_interp.adaptive_predict(@_input, 13, @_ctx)
626
+ @_state_number = 118
627
+ @_err_handler.sync(self)
628
+ _alt = @_interp.adaptive_predict(@_input,13,@_ctx)
636
629
  break if !( _alt!=2 && _alt!=Antlr4::Runtime::ATN::INVALID_ALT_NUMBER )
637
630
  end
638
631
 
639
632
  else
640
633
  raise Antlr4::Runtime::NoViableAltException self
641
634
  end
642
- @_state_number = 122
643
- @_err_handler.sync(self)
644
- _alt = @_interp.adaptive_predict(@_input, 14, @_ctx)
635
+ @_state_number = 122
636
+ @_err_handler.sync(self)
637
+ _alt = @_interp.adaptive_predict(@_input,14,@_ctx)
645
638
  break if !( _alt!=2 && _alt!=Antlr4::Runtime::ATN::INVALID_ALT_NUMBER )
646
639
  end
647
- @_state_number = 127
640
+ @_state_number = 127
648
641
  @_err_handler.sync(self);
649
- _alt = @_interp.adaptive_predict(@_input, 15, @_ctx)
642
+ _alt = @_interp.adaptive_predict(@_input,15,@_ctx)
650
643
  while ( _alt!=2 && _alt!=Antlr4::Runtime::ATN::INVALID_ALT_NUMBER )
651
644
  if ( _alt==1 )
652
645
 
653
646
 
654
- @_state_number = 124
647
+ @_state_number = 124
655
648
  modl_array_item()
656
649
  end
657
- @_state_number = 129
650
+ @_state_number = 129
658
651
  @_err_handler.sync(self)
659
- _alt = @_interp.adaptive_predict(@_input, 15, @_ctx)
652
+ _alt = @_interp.adaptive_predict(@_input,15,@_ctx)
660
653
  end
661
- @_state_number = 131
654
+ @_state_number = 131
662
655
  @_err_handler.sync(self)
663
- case (@_interp.adaptive_predict(@_input, 16, @_ctx))
664
- when 1
656
+ case ( @_interp.adaptive_predict(@_input,16,@_ctx) )
657
+ when 1
665
658
 
666
- @_state_number = 130
659
+ @_state_number = 130
667
660
  match(COLON)
668
661
 
669
- end
662
+ end
670
663
  rescue Antlr4::Runtime::RecognitionException => re
671
664
  _localctx.exception = re
672
665
  @_err_handler.report_error(self, re)
@@ -690,22 +683,18 @@ class MODLParser < Antlr4::Runtime::Parser
690
683
  def QUOTED()
691
684
  return token(MODLParser::QUOTED, 0)
692
685
  end
693
-
694
- def NUMBER()
695
- return token(MODLParser::NUMBER, 0)
696
- end
697
-
698
- def NULL()
699
- return token(MODLParser::NULL, 0)
700
- end
701
-
702
- def TRUE()
703
- return token(MODLParser::TRUE, 0)
704
- end
705
-
706
- def FALSE()
707
- return token(MODLParser::FALSE, 0)
708
- end
686
+ def NUMBER()
687
+ return token(MODLParser::NUMBER, 0)
688
+ end
689
+ def NULL()
690
+ return token(MODLParser::NULL, 0)
691
+ end
692
+ def TRUE()
693
+ return token(MODLParser::TRUE, 0)
694
+ end
695
+ def FALSE()
696
+ return token(MODLParser::FALSE, 0)
697
+ end
709
698
  def modl_map()
710
699
  return rule_context("Modl_mapContext",0)
711
700
  end
@@ -743,46 +732,46 @@ class MODLParser < Antlr4::Runtime::Parser
743
732
  enter_rule(_localctx, 10, RULE_modl_pair)
744
733
  _la = 0
745
734
  begin
746
- @_state_number = 140
735
+ @_state_number = 140
747
736
  @_err_handler.sync(self)
748
- case (@_interp.adaptive_predict(@_input, 17, @_ctx))
749
- when 1
737
+ case ( @_interp.adaptive_predict(@_input,17,@_ctx) )
738
+ when 1
750
739
  enter_outer_alt(_localctx, 1)
751
740
 
752
- @_state_number = 133
741
+ @_state_number = 133
753
742
  _la = @_input.la(1)
754
- if (!((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED))) != 0)))
743
+ if ( !((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED))) != 0)) )
755
744
  @_err_handler.recover_in_line(self)
756
745
 
757
- else
746
+ else
758
747
  if ( @_input.la(1)==Antlr4::Runtime::Token::EOF )
759
748
  @matchedEOF = true
760
749
  end
761
750
  @_err_handler.report_match(self)
762
751
  consume()
763
- end
764
- @_state_number = 134
765
- match(EQUALS)
766
- @_state_number = 135
752
+ end
753
+ @_state_number = 134
754
+ match(EQUALS)
755
+ @_state_number = 135
767
756
  modl_value_item()
768
757
 
769
- when 2
758
+ when 2
770
759
  enter_outer_alt(_localctx, 2)
771
760
 
772
- @_state_number = 136
761
+ @_state_number = 136
773
762
  match(STRING)
774
- @_state_number = 137
763
+ @_state_number = 137
775
764
  modl_map()
776
765
 
777
- when 3
766
+ when 3
778
767
  enter_outer_alt(_localctx, 3)
779
768
 
780
- @_state_number = 138
781
- match(STRING)
782
- @_state_number = 139
769
+ @_state_number = 138
770
+ match(STRING)
771
+ @_state_number = 139
783
772
  modl_array()
784
773
 
785
- end
774
+ end
786
775
  rescue Antlr4::Runtime::RecognitionException => re
787
776
  _localctx.exception = re
788
777
  @_err_handler.report_error(self, re)
@@ -832,20 +821,20 @@ class MODLParser < Antlr4::Runtime::Parser
832
821
  begin
833
822
  enter_outer_alt(_localctx, 1)
834
823
 
835
- @_state_number = 144
824
+ @_state_number = 144
836
825
  @_err_handler.sync(self)
837
- case (@_interp.adaptive_predict(@_input, 18, @_ctx))
838
- when 1
826
+ case ( @_interp.adaptive_predict(@_input,18,@_ctx) )
827
+ when 1
839
828
 
840
- @_state_number = 142
829
+ @_state_number = 142
841
830
  modl_value()
842
831
 
843
- when 2
832
+ when 2
844
833
 
845
- @_state_number = 143
834
+ @_state_number = 143
846
835
  modl_value_conditional()
847
836
 
848
- end
837
+ end
849
838
  rescue Antlr4::Runtime::RecognitionException => re
850
839
  _localctx.exception = re
851
840
  @_err_handler.report_error(self, re)
@@ -920,40 +909,40 @@ class MODLParser < Antlr4::Runtime::Parser
920
909
  begin
921
910
  enter_outer_alt(_localctx, 1)
922
911
 
923
- @_state_number = 146
912
+ @_state_number = 146
924
913
  match(LCBRAC)
925
- @_state_number = 147
926
- modl_condition_test()
927
- @_state_number = 148
928
- match(QMARK)
929
- @_state_number = 149
914
+ @_state_number = 147
915
+ modl_condition_test()
916
+ @_state_number = 148
917
+ match(QMARK)
918
+ @_state_number = 149
930
919
  modl_top_level_conditional_return()
931
- @_state_number = 158
920
+ @_state_number = 158
932
921
  @_err_handler.sync(self)
933
922
  _la = @_input.la(1)
934
923
  while (_la==FSLASH)
935
924
 
936
925
 
937
- @_state_number = 150
926
+ @_state_number = 150
938
927
  match(FSLASH)
939
- @_state_number = 152
928
+ @_state_number = 152
940
929
  @_err_handler.sync(self)
941
930
  _la = @_input.la(1)
942
931
  if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << EQUALS) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC) | (1 << GTHAN) | (1 << LTHAN) | (1 << EXCLAM))) != 0))
943
932
 
944
- @_state_number = 151
933
+ @_state_number = 151
945
934
  modl_condition_test()
946
935
  end
947
936
 
948
- @_state_number = 154
949
- match(QMARK)
950
- @_state_number = 155
937
+ @_state_number = 154
938
+ match(QMARK)
939
+ @_state_number = 155
951
940
  modl_top_level_conditional_return()
952
- @_state_number = 160
941
+ @_state_number = 160
953
942
  @_err_handler.sync(self)
954
943
  _la = @_input.la(1)
955
944
  end
956
- @_state_number = 161
945
+ @_state_number = 161
957
946
  match(RCBRAC)
958
947
  rescue Antlr4::Runtime::RecognitionException => re
959
948
  _localctx.exception = re
@@ -1005,18 +994,18 @@ class MODLParser < Antlr4::Runtime::Parser
1005
994
  begin
1006
995
  enter_outer_alt(_localctx, 1)
1007
996
 
1008
- @_state_number = 166
997
+ @_state_number = 166
1009
998
  @_err_handler.sync(self)
1010
999
  _la = @_input.la(1)
1011
- while ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0))
1000
+ while ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0))
1012
1001
 
1013
1002
 
1014
- @_state_number = 163
1003
+ @_state_number = 163
1015
1004
  modl_structure()
1016
- @_state_number = 168
1005
+ @_state_number = 168
1017
1006
  @_err_handler.sync(self)
1018
1007
  _la = @_input.la(1)
1019
- end
1008
+ end
1020
1009
  rescue Antlr4::Runtime::RecognitionException => re
1021
1010
  _localctx.exception = re
1022
1011
  @_err_handler.report_error(self, re)
@@ -1091,40 +1080,40 @@ class MODLParser < Antlr4::Runtime::Parser
1091
1080
  begin
1092
1081
  enter_outer_alt(_localctx, 1)
1093
1082
 
1094
- @_state_number = 169
1083
+ @_state_number = 169
1095
1084
  match(LCBRAC)
1096
- @_state_number = 170
1097
- modl_condition_test()
1098
- @_state_number = 171
1085
+ @_state_number = 170
1086
+ modl_condition_test()
1087
+ @_state_number = 171
1099
1088
  match(QMARK)
1100
- @_state_number = 172
1089
+ @_state_number = 172
1101
1090
  modl_map_conditional_return()
1102
- @_state_number = 181
1091
+ @_state_number = 181
1103
1092
  @_err_handler.sync(self)
1104
1093
  _la = @_input.la(1)
1105
1094
  while (_la==FSLASH)
1106
1095
 
1107
1096
 
1108
- @_state_number = 173
1097
+ @_state_number = 173
1109
1098
  match(FSLASH)
1110
- @_state_number = 175
1099
+ @_state_number = 175
1111
1100
  @_err_handler.sync(self)
1112
1101
  _la = @_input.la(1)
1113
1102
  if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << EQUALS) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC) | (1 << GTHAN) | (1 << LTHAN) | (1 << EXCLAM))) != 0))
1114
1103
 
1115
- @_state_number = 174
1104
+ @_state_number = 174
1116
1105
  modl_condition_test()
1117
1106
  end
1118
1107
 
1119
- @_state_number = 177
1120
- match(QMARK)
1121
- @_state_number = 178
1108
+ @_state_number = 177
1109
+ match(QMARK)
1110
+ @_state_number = 178
1122
1111
  modl_map_conditional_return()
1123
- @_state_number = 183
1112
+ @_state_number = 183
1124
1113
  @_err_handler.sync(self)
1125
1114
  _la = @_input.la(1)
1126
1115
  end
1127
- @_state_number = 184
1116
+ @_state_number = 184
1128
1117
  match(RCBRAC)
1129
1118
  rescue Antlr4::Runtime::RecognitionException => re
1130
1119
  _localctx.exception = re
@@ -1176,18 +1165,18 @@ class MODLParser < Antlr4::Runtime::Parser
1176
1165
  begin
1177
1166
  enter_outer_alt(_localctx, 1)
1178
1167
 
1179
- @_state_number = 187
1180
- @_err_handler.sync(self)
1168
+ @_state_number = 187
1169
+ @_err_handler.sync(self)
1181
1170
  _la = @_input.la(1)
1182
1171
  loop do
1183
1172
 
1184
1173
 
1185
- @_state_number = 186
1174
+ @_state_number = 186
1186
1175
  modl_map_item()
1187
- @_state_number = 189
1188
- @_err_handler.sync(self)
1176
+ @_state_number = 189
1177
+ @_err_handler.sync(self)
1189
1178
  _la = @_input.la(1)
1190
- break if (!((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0)))
1179
+ break if (!( (((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0)) )
1191
1180
  end
1192
1181
  rescue Antlr4::Runtime::RecognitionException => re
1193
1182
  _localctx.exception = re
@@ -1236,23 +1225,23 @@ class MODLParser < Antlr4::Runtime::Parser
1236
1225
  _localctx = Modl_map_itemContext.new(@_ctx, @_state_number)
1237
1226
  enter_rule(_localctx, 22, RULE_modl_map_item)
1238
1227
  begin
1239
- @_state_number = 193
1228
+ @_state_number = 193
1240
1229
  @_err_handler.sync(self)
1241
- case (@_input.la(1))
1242
- when MODLParser::NULL, MODLParser::TRUE, MODLParser::FALSE, MODLParser::NUMBER, MODLParser::STRING, MODLParser::QUOTED
1230
+ case (@_input.la(1))
1231
+ when MODLParser::NULL, MODLParser::TRUE, MODLParser::FALSE, MODLParser::NUMBER, MODLParser::STRING, MODLParser::QUOTED
1243
1232
  enter_outer_alt(_localctx, 1)
1244
1233
 
1245
- @_state_number = 191
1234
+ @_state_number = 191
1246
1235
  modl_pair()
1247
1236
 
1248
- when MODLParser::LCBRAC
1237
+ when MODLParser::LCBRAC
1249
1238
  enter_outer_alt(_localctx, 2)
1250
1239
 
1251
- @_state_number = 192
1240
+ @_state_number = 192
1252
1241
  modl_map_conditional()
1253
- else
1242
+ else
1254
1243
  raise Antlr4::Runtime::NoViableAltException self
1255
- end
1244
+ end
1256
1245
  rescue Antlr4::Runtime::RecognitionException => re
1257
1246
  _localctx.exception = re
1258
1247
  @_err_handler.report_error(self, re)
@@ -1327,40 +1316,40 @@ class MODLParser < Antlr4::Runtime::Parser
1327
1316
  begin
1328
1317
  enter_outer_alt(_localctx, 1)
1329
1318
 
1330
- @_state_number = 195
1319
+ @_state_number = 195
1331
1320
  match(LCBRAC)
1332
- @_state_number = 196
1321
+ @_state_number = 196
1333
1322
  modl_condition_test()
1334
- @_state_number = 197
1323
+ @_state_number = 197
1335
1324
  match(QMARK)
1336
- @_state_number = 198
1325
+ @_state_number = 198
1337
1326
  modl_array_conditional_return()
1338
- @_state_number = 207
1327
+ @_state_number = 207
1339
1328
  @_err_handler.sync(self)
1340
1329
  _la = @_input.la(1)
1341
1330
  while (_la==FSLASH)
1342
1331
 
1343
1332
 
1344
- @_state_number = 199
1333
+ @_state_number = 199
1345
1334
  match(FSLASH)
1346
- @_state_number = 201
1335
+ @_state_number = 201
1347
1336
  @_err_handler.sync(self)
1348
1337
  _la = @_input.la(1)
1349
1338
  if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << EQUALS) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC) | (1 << GTHAN) | (1 << LTHAN) | (1 << EXCLAM))) != 0))
1350
1339
 
1351
- @_state_number = 200
1340
+ @_state_number = 200
1352
1341
  modl_condition_test()
1353
1342
  end
1354
1343
 
1355
- @_state_number = 203
1356
- match(QMARK)
1357
- @_state_number = 204
1344
+ @_state_number = 203
1345
+ match(QMARK)
1346
+ @_state_number = 204
1358
1347
  modl_array_conditional_return()
1359
- @_state_number = 209
1348
+ @_state_number = 209
1360
1349
  @_err_handler.sync(self)
1361
1350
  _la = @_input.la(1)
1362
1351
  end
1363
- @_state_number = 210
1352
+ @_state_number = 210
1364
1353
  match(RCBRAC)
1365
1354
  rescue Antlr4::Runtime::RecognitionException => re
1366
1355
  _localctx.exception = re
@@ -1412,18 +1401,18 @@ class MODLParser < Antlr4::Runtime::Parser
1412
1401
  begin
1413
1402
  enter_outer_alt(_localctx, 1)
1414
1403
 
1415
- @_state_number = 213
1416
- @_err_handler.sync(self)
1404
+ @_state_number = 213
1405
+ @_err_handler.sync(self)
1417
1406
  _la = @_input.la(1)
1418
1407
  loop do
1419
1408
 
1420
1409
 
1421
- @_state_number = 212
1410
+ @_state_number = 212
1422
1411
  modl_array_item()
1423
- @_state_number = 215
1424
- @_err_handler.sync(self)
1412
+ @_state_number = 215
1413
+ @_err_handler.sync(self)
1425
1414
  _la = @_input.la(1)
1426
- break if (!((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0)))
1415
+ break if (!( (((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0)) )
1427
1416
  end
1428
1417
  rescue Antlr4::Runtime::RecognitionException => re
1429
1418
  _localctx.exception = re
@@ -1472,19 +1461,19 @@ class MODLParser < Antlr4::Runtime::Parser
1472
1461
  _localctx = Modl_array_itemContext.new(@_ctx, @_state_number)
1473
1462
  enter_rule(_localctx, 28, RULE_modl_array_item)
1474
1463
  begin
1475
- @_state_number = 219
1464
+ @_state_number = 219
1476
1465
  @_err_handler.sync(self)
1477
1466
  case (@_input.la(1))
1478
1467
  when MODLParser::NULL, MODLParser::TRUE, MODLParser::FALSE, MODLParser::LBRAC, MODLParser::LSBRAC, MODLParser::NUMBER, MODLParser::STRING, MODLParser::QUOTED
1479
1468
  enter_outer_alt(_localctx, 1)
1480
1469
 
1481
- @_state_number = 217
1470
+ @_state_number = 217
1482
1471
  modl_array_value_item()
1483
1472
 
1484
1473
  when MODLParser::LCBRAC
1485
1474
  enter_outer_alt(_localctx, 2)
1486
1475
 
1487
- @_state_number = 218
1476
+ @_state_number = 218
1488
1477
  modl_array_conditional()
1489
1478
  else
1490
1479
  raise Antlr4::Runtime::NoViableAltException self
@@ -1564,49 +1553,49 @@ class MODLParser < Antlr4::Runtime::Parser
1564
1553
  _alt = 0
1565
1554
  enter_outer_alt(_localctx, 1)
1566
1555
 
1567
- @_state_number = 221
1556
+ @_state_number = 221
1568
1557
  match(LCBRAC)
1569
- @_state_number = 222
1558
+ @_state_number = 222
1570
1559
  modl_condition_test()
1571
- @_state_number = 223
1560
+ @_state_number = 223
1572
1561
  match(QMARK)
1573
- @_state_number = 239
1562
+ @_state_number = 239
1574
1563
  @_err_handler.sync(self)
1575
1564
  _la = @_input.la(1)
1576
1565
  if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << LBRAC) | (1 << LSBRAC) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED) | (1 << LCBRAC))) != 0))
1577
1566
 
1578
- @_state_number = 224
1567
+ @_state_number = 224
1579
1568
  modl_value_conditional_return()
1580
- @_state_number = 232
1569
+ @_state_number = 232
1581
1570
  @_err_handler.sync(self);
1582
- _alt = @_interp.adaptive_predict(@_input, 30, @_ctx)
1571
+ _alt = @_interp.adaptive_predict(@_input,30,@_ctx)
1583
1572
  while ( _alt!=2 && _alt!=Antlr4::Runtime::ATN::INVALID_ALT_NUMBER )
1584
1573
  if ( _alt==1 )
1585
1574
 
1586
1575
 
1587
- @_state_number = 225
1576
+ @_state_number = 225
1588
1577
  match(FSLASH)
1589
- @_state_number = 226
1578
+ @_state_number = 226
1590
1579
  modl_condition_test()
1591
- @_state_number = 227
1592
- match(QMARK)
1593
- @_state_number = 228
1580
+ @_state_number = 227
1581
+ match(QMARK)
1582
+ @_state_number = 228
1594
1583
  modl_value_conditional_return()
1595
1584
  end
1596
- @_state_number = 234
1585
+ @_state_number = 234
1597
1586
  @_err_handler.sync(self)
1598
- _alt = @_interp.adaptive_predict(@_input, 30, @_ctx)
1587
+ _alt = @_interp.adaptive_predict(@_input,30,@_ctx)
1599
1588
  end
1600
1589
 
1601
- @_state_number = 235
1602
- match(FSLASH)
1603
- @_state_number = 236
1604
- match(QMARK)
1605
- @_state_number = 237
1590
+ @_state_number = 235
1591
+ match(FSLASH)
1592
+ @_state_number = 236
1593
+ match(QMARK)
1594
+ @_state_number = 237
1606
1595
  modl_value_conditional_return()
1607
1596
  end
1608
1597
 
1609
- @_state_number = 241
1598
+ @_state_number = 241
1610
1599
  match(RCBRAC)
1611
1600
  rescue Antlr4::Runtime::RecognitionException => re
1612
1601
  _localctx.exception = re
@@ -1664,22 +1653,22 @@ class MODLParser < Antlr4::Runtime::Parser
1664
1653
  begin
1665
1654
  enter_outer_alt(_localctx, 1)
1666
1655
 
1667
- @_state_number = 243
1656
+ @_state_number = 243
1668
1657
  modl_value_item()
1669
- @_state_number = 248
1658
+ @_state_number = 248
1670
1659
  @_err_handler.sync(self)
1671
1660
  _la = @_input.la(1)
1672
- while (_la == COLON)
1661
+ while (_la==COLON)
1673
1662
 
1674
1663
 
1675
- @_state_number = 244
1676
- match(COLON)
1677
- @_state_number = 245
1664
+ @_state_number = 244
1665
+ match(COLON)
1666
+ @_state_number = 245
1678
1667
  modl_value_item()
1679
- @_state_number = 250
1668
+ @_state_number = 250
1680
1669
  @_err_handler.sync(self)
1681
1670
  _la = @_input.la(1)
1682
- end
1671
+ end
1683
1672
  rescue Antlr4::Runtime::RecognitionException => re
1684
1673
  _localctx.exception = re
1685
1674
  @_err_handler.report_error(self, re)
@@ -1755,37 +1744,37 @@ class MODLParser < Antlr4::Runtime::Parser
1755
1744
  _alt = 0
1756
1745
  enter_outer_alt(_localctx, 1)
1757
1746
 
1758
- @_state_number = 252
1747
+ @_state_number = 252
1759
1748
  @_err_handler.sync(self)
1760
- case (@_interp.adaptive_predict(@_input, 33, @_ctx))
1761
- when 1
1749
+ case ( @_interp.adaptive_predict(@_input,33,@_ctx) )
1750
+ when 1
1762
1751
 
1763
- @_state_number = 251
1752
+ @_state_number = 251
1764
1753
  match(EXCLAM)
1765
1754
 
1766
- end
1767
- @_state_number = 256
1755
+ end
1756
+ @_state_number = 256
1768
1757
  @_err_handler.sync(self)
1769
- case (@_interp.adaptive_predict(@_input, 34, @_ctx))
1770
- when 1
1758
+ case ( @_interp.adaptive_predict(@_input,34,@_ctx) )
1759
+ when 1
1771
1760
 
1772
- @_state_number = 254
1761
+ @_state_number = 254
1773
1762
  modl_condition()
1774
1763
 
1775
- when 2
1764
+ when 2
1776
1765
 
1777
- @_state_number = 255
1766
+ @_state_number = 255
1778
1767
  modl_condition_group()
1779
1768
 
1780
- end
1781
- @_state_number = 268
1769
+ end
1770
+ @_state_number = 268
1782
1771
  @_err_handler.sync(self);
1783
- _alt = @_interp.adaptive_predict(@_input, 37, @_ctx)
1772
+ _alt = @_interp.adaptive_predict(@_input,37,@_ctx)
1784
1773
  while ( _alt!=2 && _alt!=Antlr4::Runtime::ATN::INVALID_ALT_NUMBER )
1785
1774
  if ( _alt==1 )
1786
1775
 
1787
1776
 
1788
- @_state_number = 258
1777
+ @_state_number = 258
1789
1778
  _la = @_input.la(1)
1790
1779
  if ( !(_la==AMP || _la==PIPE) )
1791
1780
  @_err_handler.recover_in_line(self)
@@ -1797,33 +1786,33 @@ class MODLParser < Antlr4::Runtime::Parser
1797
1786
  @_err_handler.report_match(self)
1798
1787
  consume()
1799
1788
  end
1800
- @_state_number = 260
1789
+ @_state_number = 260
1801
1790
  @_err_handler.sync(self)
1802
- case (@_interp.adaptive_predict(@_input, 35, @_ctx))
1803
- when 1
1791
+ case ( @_interp.adaptive_predict(@_input,35,@_ctx) )
1792
+ when 1
1804
1793
 
1805
- @_state_number = 259
1794
+ @_state_number = 259
1806
1795
  match(EXCLAM)
1807
1796
 
1808
- end
1809
- @_state_number = 264
1797
+ end
1798
+ @_state_number = 264
1810
1799
  @_err_handler.sync(self)
1811
- case (@_interp.adaptive_predict(@_input, 36, @_ctx))
1812
- when 1
1800
+ case ( @_interp.adaptive_predict(@_input,36,@_ctx) )
1801
+ when 1
1813
1802
 
1814
- @_state_number = 262
1803
+ @_state_number = 262
1815
1804
  modl_condition()
1816
1805
 
1817
- when 2
1806
+ when 2
1818
1807
 
1819
- @_state_number = 263
1808
+ @_state_number = 263
1820
1809
  modl_condition_group()
1821
1810
 
1822
- end
1823
- end
1824
- @_state_number = 270
1811
+ end
1812
+ end
1813
+ @_state_number = 270
1825
1814
  @_err_handler.sync(self)
1826
- _alt = @_interp.adaptive_predict(@_input, 37, @_ctx)
1815
+ _alt = @_interp.adaptive_predict(@_input,37,@_ctx)
1827
1816
  end
1828
1817
  rescue Antlr4::Runtime::RecognitionException => re
1829
1818
  _localctx.exception = re
@@ -1878,52 +1867,52 @@ class MODLParser < Antlr4::Runtime::Parser
1878
1867
  _localctx = Modl_operatorContext.new(@_ctx, @_state_number)
1879
1868
  enter_rule(_localctx, 36, RULE_modl_operator)
1880
1869
  begin
1881
- @_state_number = 280
1870
+ @_state_number = 280
1882
1871
  @_err_handler.sync(self)
1883
- case (@_interp.adaptive_predict(@_input, 38, @_ctx))
1884
- when 1
1872
+ case ( @_interp.adaptive_predict(@_input,38,@_ctx) )
1873
+ when 1
1885
1874
  enter_outer_alt(_localctx, 1)
1886
1875
 
1887
- @_state_number = 271
1876
+ @_state_number = 271
1888
1877
  match(EQUALS)
1889
1878
 
1890
- when 2
1879
+ when 2
1891
1880
  enter_outer_alt(_localctx, 2)
1892
1881
 
1893
- @_state_number = 272
1882
+ @_state_number = 272
1894
1883
  match(GTHAN)
1895
1884
 
1896
- when 3
1885
+ when 3
1897
1886
  enter_outer_alt(_localctx, 3)
1898
1887
 
1899
- @_state_number = 273
1888
+ @_state_number = 273
1900
1889
  match(GTHAN)
1901
- @_state_number = 274
1890
+ @_state_number = 274
1902
1891
  match(EQUALS)
1903
1892
 
1904
- when 4
1893
+ when 4
1905
1894
  enter_outer_alt(_localctx, 4)
1906
1895
 
1907
- @_state_number = 275
1896
+ @_state_number = 275
1908
1897
  match(LTHAN)
1909
1898
 
1910
- when 5
1899
+ when 5
1911
1900
  enter_outer_alt(_localctx, 5)
1912
1901
 
1913
- @_state_number = 276
1902
+ @_state_number = 276
1914
1903
  match(LTHAN)
1915
- @_state_number = 277
1904
+ @_state_number = 277
1916
1905
  match(EQUALS)
1917
1906
 
1918
- when 6
1907
+ when 6
1919
1908
  enter_outer_alt(_localctx, 6)
1920
1909
 
1921
- @_state_number = 278
1910
+ @_state_number = 278
1922
1911
  match(EXCLAM)
1923
- @_state_number = 279
1912
+ @_state_number = 279
1924
1913
  match(EQUALS)
1925
1914
 
1926
- end
1915
+ end
1927
1916
  rescue Antlr4::Runtime::RecognitionException => re
1928
1917
  _localctx.exception = re
1929
1918
  @_err_handler.report_error(self, re)
@@ -1986,37 +1975,37 @@ class MODLParser < Antlr4::Runtime::Parser
1986
1975
  begin
1987
1976
  enter_outer_alt(_localctx, 1)
1988
1977
 
1989
- @_state_number = 283
1978
+ @_state_number = 283
1990
1979
  @_err_handler.sync(self)
1991
- case (@_interp.adaptive_predict(@_input, 39, @_ctx))
1992
- when 1
1980
+ case ( @_interp.adaptive_predict(@_input,39,@_ctx) )
1981
+ when 1
1993
1982
 
1994
- @_state_number = 282
1983
+ @_state_number = 282
1995
1984
  match(STRING)
1996
1985
 
1997
- end
1998
- @_state_number = 286
1986
+ end
1987
+ @_state_number = 286
1999
1988
  @_err_handler.sync(self)
2000
1989
  _la = @_input.la(1)
2001
1990
  if ((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << EQUALS) | (1 << GTHAN) | (1 << LTHAN) | (1 << EXCLAM))) != 0))
2002
1991
 
2003
- @_state_number = 285
1992
+ @_state_number = 285
2004
1993
  modl_operator()
2005
1994
  end
2006
1995
 
2007
- @_state_number = 288
1996
+ @_state_number = 288
2008
1997
  modl_value()
2009
- @_state_number = 293
1998
+ @_state_number = 293
2010
1999
  @_err_handler.sync(self)
2011
2000
  _la = @_input.la(1)
2012
2001
  while (_la==FSLASH)
2013
2002
 
2014
2003
 
2015
- @_state_number = 289
2016
- match(FSLASH)
2017
- @_state_number = 290
2004
+ @_state_number = 289
2005
+ match(FSLASH)
2006
+ @_state_number = 290
2018
2007
  modl_value()
2019
- @_state_number = 295
2008
+ @_state_number = 295
2020
2009
  @_err_handler.sync(self)
2021
2010
  _la = @_input.la(1)
2022
2011
  end
@@ -2088,17 +2077,17 @@ class MODLParser < Antlr4::Runtime::Parser
2088
2077
  begin
2089
2078
  enter_outer_alt(_localctx, 1)
2090
2079
 
2091
- @_state_number = 296
2080
+ @_state_number = 296
2092
2081
  match(LCBRAC)
2093
- @_state_number = 297
2082
+ @_state_number = 297
2094
2083
  modl_condition_test()
2095
- @_state_number = 302
2084
+ @_state_number = 302
2096
2085
  @_err_handler.sync(self)
2097
2086
  _la = @_input.la(1)
2098
2087
  while (_la==AMP || _la==PIPE)
2099
2088
 
2100
2089
 
2101
- @_state_number = 298
2090
+ @_state_number = 298
2102
2091
  _la = @_input.la(1)
2103
2092
  if ( !(_la==AMP || _la==PIPE) )
2104
2093
  @_err_handler.recover_in_line(self)
@@ -2110,13 +2099,13 @@ class MODLParser < Antlr4::Runtime::Parser
2110
2099
  @_err_handler.report_match(self)
2111
2100
  consume()
2112
2101
  end
2113
- @_state_number = 299
2102
+ @_state_number = 299
2114
2103
  modl_condition_test()
2115
- @_state_number = 304
2104
+ @_state_number = 304
2116
2105
  @_err_handler.sync(self)
2117
2106
  _la = @_input.la(1)
2118
2107
  end
2119
- @_state_number = 305
2108
+ @_state_number = 305
2120
2109
  match(RCBRAC)
2121
2110
  rescue Antlr4::Runtime::RecognitionException => re
2122
2111
  _localctx.exception = re
@@ -2174,40 +2163,40 @@ class MODLParser < Antlr4::Runtime::Parser
2174
2163
  _localctx = Modl_valueContext.new(@_ctx, @_state_number)
2175
2164
  enter_rule(_localctx, 42, RULE_modl_value)
2176
2165
  begin
2177
- @_state_number = 312
2166
+ @_state_number = 312
2178
2167
  @_err_handler.sync(self)
2179
- case (@_interp.adaptive_predict(@_input, 43, @_ctx))
2180
- when 1
2168
+ case ( @_interp.adaptive_predict(@_input,43,@_ctx) )
2169
+ when 1
2181
2170
  enter_outer_alt(_localctx, 1)
2182
2171
 
2183
- @_state_number = 307
2172
+ @_state_number = 307
2184
2173
  modl_map()
2185
2174
 
2186
- when 2
2175
+ when 2
2187
2176
  enter_outer_alt(_localctx, 2)
2188
2177
 
2189
- @_state_number = 308
2178
+ @_state_number = 308
2190
2179
  modl_array()
2191
2180
 
2192
- when 3
2181
+ when 3
2193
2182
  enter_outer_alt(_localctx, 3)
2194
2183
 
2195
- @_state_number = 309
2184
+ @_state_number = 309
2196
2185
  modl_nb_array()
2197
2186
 
2198
- when 4
2187
+ when 4
2199
2188
  enter_outer_alt(_localctx, 4)
2200
2189
 
2201
- @_state_number = 310
2190
+ @_state_number = 310
2202
2191
  modl_pair()
2203
2192
 
2204
- when 5
2193
+ when 5
2205
2194
  enter_outer_alt(_localctx, 5)
2206
2195
 
2207
- @_state_number = 311
2196
+ @_state_number = 311
2208
2197
  modl_primitive()
2209
2198
 
2210
- end
2199
+ end
2211
2200
  rescue Antlr4::Runtime::RecognitionException => re
2212
2201
  _localctx.exception = re
2213
2202
  @_err_handler.report_error(self, re)
@@ -2261,34 +2250,34 @@ class MODLParser < Antlr4::Runtime::Parser
2261
2250
  _localctx = Modl_array_value_itemContext.new(@_ctx, @_state_number)
2262
2251
  enter_rule(_localctx, 44, RULE_modl_array_value_item)
2263
2252
  begin
2264
- @_state_number = 318
2253
+ @_state_number = 318
2265
2254
  @_err_handler.sync(self)
2266
- case (@_interp.adaptive_predict(@_input, 44, @_ctx))
2267
- when 1
2255
+ case ( @_interp.adaptive_predict(@_input,44,@_ctx) )
2256
+ when 1
2268
2257
  enter_outer_alt(_localctx, 1)
2269
2258
 
2270
- @_state_number = 314
2259
+ @_state_number = 314
2271
2260
  modl_map()
2272
2261
 
2273
- when 2
2262
+ when 2
2274
2263
  enter_outer_alt(_localctx, 2)
2275
2264
 
2276
- @_state_number = 315
2265
+ @_state_number = 315
2277
2266
  modl_pair()
2278
2267
 
2279
- when 3
2268
+ when 3
2280
2269
  enter_outer_alt(_localctx, 3)
2281
2270
 
2282
- @_state_number = 316
2271
+ @_state_number = 316
2283
2272
  modl_array()
2284
2273
 
2285
- when 4
2274
+ when 4
2286
2275
  enter_outer_alt(_localctx, 4)
2287
2276
 
2288
- @_state_number = 317
2277
+ @_state_number = 317
2289
2278
  modl_primitive()
2290
2279
 
2291
- end
2280
+ end
2292
2281
  rescue Antlr4::Runtime::RecognitionException => re
2293
2282
  _localctx.exception = re
2294
2283
  @_err_handler.report_error(self, re)
@@ -2351,7 +2340,7 @@ class MODLParser < Antlr4::Runtime::Parser
2351
2340
  begin
2352
2341
  enter_outer_alt(_localctx, 1)
2353
2342
 
2354
- @_state_number = 320
2343
+ @_state_number = 320
2355
2344
  _la = @_input.la(1)
2356
2345
  if ( !((((_la) & ~0x3f) == 0 && ((1 << _la) & ((1 << NULL) | (1 << TRUE) | (1 << FALSE) | (1 << NUMBER) | (1 << STRING) | (1 << QUOTED))) != 0)) )
2357
2346
  @_err_handler.recover_in_line(self)
@@ -2378,7 +2367,7 @@ class MODLParser < Antlr4::Runtime::Parser
2378
2367
  "\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t",
2379
2368
  "\20\4\21\t\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27",
2380
2369
  "\t\27\4\30\t\30\4\31\t\31\3\2\5\2\64\n\2\3\2\3\2\3\2\7\29\n\2\f\2\16",
2381
- "\2<\13\2\3\2\5\2?\n\2\3\2\3\2\5\2C\n\2\3\3\3\3\3\3\3\3\5\3I\n\3\3\4",
2370
+ "\2<\13\2\3\2\5\2?\n\2\5\2A\n\2\3\2\3\2\3\3\3\3\3\3\3\3\5\3I\n\3\3\4",
2382
2371
  "\3\4\3\4\3\4\7\4O\n\4\f\4\16\4R\13\4\5\4T\n\4\3\4\3\4\3\5\3\5\3\5\5",
2383
2372
  "\5[\n\5\3\5\6\5^\n\5\r\5\16\5_\3\5\3\5\5\5d\n\5\3\5\7\5g\n\5\f\5\16",
2384
2373
  "\5j\13\5\7\5l\n\5\f\5\16\5o\13\5\5\5q\n\5\3\5\3\5\3\6\3\6\6\6w\n\6",
@@ -2402,16 +2391,16 @@ class MODLParser < Antlr4::Runtime::Parser
2402
2391
  "\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\5\27\u013b\n\27\3\30\3\30\3",
2403
2392
  "\30\3\30\5\30\u0141\n\30\3\31\3\31\3\31\2\2\32\2\4\6\b\n\f\16\20\22",
2404
2393
  "\24\26\30\32\34\36 \"$&(*,.\60\2\4\6\2\4\6\17\17\21\21\23\23\3\2\34",
2405
- "\35\2\u0165\2B\3\2\2\2\4H\3\2\2\2\6J\3\2\2\2\bW\3\2\2\2\nz\3\2\2\2",
2394
+ "\35\2\u0165\2@\3\2\2\2\4H\3\2\2\2\6J\3\2\2\2\bW\3\2\2\2\nz\3\2\2\2",
2406
2395
  "\f\u008e\3\2\2\2\16\u0092\3\2\2\2\20\u0094\3\2\2\2\22\u00a8\3\2\2\2",
2407
2396
  "\24\u00ab\3\2\2\2\26\u00bd\3\2\2\2\30\u00c3\3\2\2\2\32\u00c5\3\2\2",
2408
2397
  "\2\34\u00d7\3\2\2\2\36\u00dd\3\2\2\2 \u00df\3\2\2\2\"\u00f5\3\2\2\2",
2409
2398
  "$\u00fe\3\2\2\2&\u011a\3\2\2\2(\u011d\3\2\2\2*\u012a\3\2\2\2,\u013a",
2410
2399
  "\3\2\2\2.\u0140\3\2\2\2\60\u0142\3\2\2\2\62\64\5\4\3\2\63\62\3\2\2",
2411
- "\2\63\64\3\2\2\2\64C\3\2\2\2\65:\5\4\3\2\66\67\7\t\2\2\679\5\4\3\2",
2400
+ "\2\63\64\3\2\2\2\64A\3\2\2\2\65:\5\4\3\2\66\67\7\t\2\2\679\5\4\3\2",
2412
2401
  "8\66\3\2\2\29<\3\2\2\2:8\3\2\2\2:;\3\2\2\2;>\3\2\2\2<:\3\2\2\2=?\7",
2413
- "\t\2\2>=\3\2\2\2>?\3\2\2\2?@\3\2\2\2@A\7\2\2\3AC\3\2\2\2B\63\3\2\2",
2414
- "\2B\65\3\2\2\2C\3\3\2\2\2DI\5\6\4\2EI\5\b\5\2FI\5\20\t\2GI\5\f\7\2",
2402
+ "\t\2\2>=\3\2\2\2>?\3\2\2\2?A\3\2\2\2@\63\3\2\2\2@\65\3\2\2\2AB\3\2",
2403
+ "\2\2BC\7\2\2\3C\3\3\2\2\2DI\5\6\4\2EI\5\b\5\2FI\5\20\t\2GI\5\f\7\2",
2415
2404
  "HD\3\2\2\2HE\3\2\2\2HF\3\2\2\2HG\3\2\2\2I\5\3\2\2\2JS\7\13\2\2KP\5",
2416
2405
  "\30\r\2LM\7\t\2\2MO\5\30\r\2NL\3\2\2\2OR\3\2\2\2PN\3\2\2\2PQ\3\2\2",
2417
2406
  "\2QT\3\2\2\2RP\3\2\2\2SK\3\2\2\2ST\3\2\2\2TU\3\2\2\2UV\7\f\2\2V\7\3",
@@ -2492,7 +2481,7 @@ class MODLParser < Antlr4::Runtime::Parser
2492
2481
  "\2\u013c\u0141\5\6\4\2\u013d\u0141\5\f\7\2\u013e\u0141\5\b\5\2\u013f",
2493
2482
  "\u0141\5\60\31\2\u0140\u013c\3\2\2\2\u0140\u013d\3\2\2\2\u0140\u013e",
2494
2483
  "\3\2\2\2\u0140\u013f\3\2\2\2\u0141/\3\2\2\2\u0142\u0143\t\2\2\2\u0143",
2495
- "\61\3\2\2\2/\63:>BHPSZ_chmpx|\u0081\u0085\u008e\u0092\u009a\u00a0\u00a8",
2484
+ "\61\3\2\2\2/\63:>@HPSZ_chmpx|\u0081\u0085\u008e\u0092\u009a\u00a0\u00a8",
2496
2485
  "\u00b1\u00b7\u00bf\u00c3\u00cb\u00d1\u00d9\u00dd\u00ea\u00f1\u00fa",
2497
2486
  "\u00fe\u0102\u0106\u010a\u010e\u011a\u011d\u0120\u0127\u0130\u013a",
2498
2487
  "\u0140"].join("")