modl 0.3.2 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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("")