kpeg 0.8.1 → 0.8.2

Sign up to get free protection for your applications and to get access to all the features.
@@ -12,7 +12,9 @@ module KPeg
12
12
 
13
13
  def self.load_grammar(file, log=false)
14
14
  parser = KPeg::FormatParser.new File.read(file)
15
- parser.parse
15
+ if !parser.parse
16
+ parser.raise_error
17
+ end
16
18
 
17
19
  return parser.grammar
18
20
  end
@@ -296,6 +296,12 @@ module KPeg
296
296
  code << indentify("if _tmp\n", indent)
297
297
  code << indentify(" text = get_text(_text_start)\n", indent)
298
298
  code << indentify("end\n", indent)
299
+ when Bounds
300
+ code << indentify("_bounds_start = self.pos\n", indent)
301
+ output_op code, op.op, indent
302
+ code << indentify("if _tmp\n", indent)
303
+ code << indentify(" bounds = [_bounds_start, self.pos]\n", indent)
304
+ code << indentify("end\n", indent)
299
305
  else
300
306
  raise "Unknown op - #{op.class}"
301
307
  end
@@ -339,37 +339,37 @@ class KPeg::FormatParser
339
339
 
340
340
  _save = self.pos
341
341
  while true # sequence
342
- _tmp = match_string("#")
343
- unless _tmp
344
- self.pos = _save
345
- break
346
- end
347
- while true
342
+ _tmp = match_string("#")
343
+ unless _tmp
344
+ self.pos = _save
345
+ break
346
+ end
347
+ while true
348
348
 
349
- _save2 = self.pos
350
- while true # sequence
351
- _save3 = self.pos
352
- _tmp = apply(:_eof)
353
- _tmp = _tmp ? nil : true
354
- self.pos = _save3
355
- unless _tmp
356
- self.pos = _save2
357
- break
358
- end
359
- _tmp = get_byte
360
- unless _tmp
361
- self.pos = _save2
362
- end
363
- break
364
- end # end sequence
349
+ _save2 = self.pos
350
+ while true # sequence
351
+ _save3 = self.pos
352
+ _tmp = apply(:_eof)
353
+ _tmp = _tmp ? nil : true
354
+ self.pos = _save3
355
+ unless _tmp
356
+ self.pos = _save2
357
+ break
358
+ end
359
+ _tmp = get_byte
360
+ unless _tmp
361
+ self.pos = _save2
362
+ end
363
+ break
364
+ end # end sequence
365
365
 
366
- break unless _tmp
367
- end
368
- _tmp = true
369
- unless _tmp
370
- self.pos = _save
371
- end
372
- break
366
+ break unless _tmp
367
+ end
368
+ _tmp = true
369
+ unless _tmp
370
+ self.pos = _save
371
+ end
372
+ break
373
373
  end # end sequence
374
374
 
375
375
  set_failed_rule :_eof_comment unless _tmp
@@ -381,42 +381,42 @@ class KPeg::FormatParser
381
381
 
382
382
  _save = self.pos
383
383
  while true # sequence
384
- _tmp = match_string("#")
385
- unless _tmp
386
- self.pos = _save
387
- break
388
- end
389
- while true
384
+ _tmp = match_string("#")
385
+ unless _tmp
386
+ self.pos = _save
387
+ break
388
+ end
389
+ while true
390
390
 
391
- _save2 = self.pos
392
- while true # sequence
393
- _save3 = self.pos
394
- _tmp = apply(:_eol)
395
- _tmp = _tmp ? nil : true
396
- self.pos = _save3
397
- unless _tmp
398
- self.pos = _save2
399
- break
400
- end
401
- _tmp = get_byte
402
- unless _tmp
403
- self.pos = _save2
404
- end
405
- break
406
- end # end sequence
391
+ _save2 = self.pos
392
+ while true # sequence
393
+ _save3 = self.pos
394
+ _tmp = apply(:_eol)
395
+ _tmp = _tmp ? nil : true
396
+ self.pos = _save3
397
+ unless _tmp
398
+ self.pos = _save2
399
+ break
400
+ end
401
+ _tmp = get_byte
402
+ unless _tmp
403
+ self.pos = _save2
404
+ end
405
+ break
406
+ end # end sequence
407
407
 
408
- break unless _tmp
409
- end
410
- _tmp = true
411
- unless _tmp
412
- self.pos = _save
408
+ break unless _tmp
409
+ end
410
+ _tmp = true
411
+ unless _tmp
412
+ self.pos = _save
413
+ break
414
+ end
415
+ _tmp = apply(:_eol)
416
+ unless _tmp
417
+ self.pos = _save
418
+ end
413
419
  break
414
- end
415
- _tmp = apply(:_eol)
416
- unless _tmp
417
- self.pos = _save
418
- end
419
- break
420
420
  end # end sequence
421
421
 
422
422
  set_failed_rule :_comment unless _tmp
@@ -428,16 +428,16 @@ class KPeg::FormatParser
428
428
 
429
429
  _save = self.pos
430
430
  while true # choice
431
- _tmp = match_string(" ")
432
- break if _tmp
433
- self.pos = _save
434
- _tmp = match_string("\t")
435
- break if _tmp
436
- self.pos = _save
437
- _tmp = apply(:_eol)
438
- break if _tmp
439
- self.pos = _save
440
- break
431
+ _tmp = match_string(" ")
432
+ break if _tmp
433
+ self.pos = _save
434
+ _tmp = match_string("\t")
435
+ break if _tmp
436
+ self.pos = _save
437
+ _tmp = apply(:_eol)
438
+ break if _tmp
439
+ self.pos = _save
440
+ break
441
441
  end # end choice
442
442
 
443
443
  set_failed_rule :_space unless _tmp
@@ -448,18 +448,18 @@ class KPeg::FormatParser
448
448
  def __hyphen_
449
449
  while true
450
450
 
451
- _save1 = self.pos
452
- while true # choice
453
- _tmp = apply(:_space)
454
- break if _tmp
455
- self.pos = _save1
456
- _tmp = apply(:_comment)
457
- break if _tmp
458
- self.pos = _save1
459
- break
460
- end # end choice
451
+ _save1 = self.pos
452
+ while true # choice
453
+ _tmp = apply(:_space)
454
+ break if _tmp
455
+ self.pos = _save1
456
+ _tmp = apply(:_comment)
457
+ break if _tmp
458
+ self.pos = _save1
459
+ break
460
+ end # end choice
461
461
 
462
- break unless _tmp
462
+ break unless _tmp
463
463
  end
464
464
  _tmp = true
465
465
  set_failed_rule :__hyphen_ unless _tmp
@@ -478,32 +478,32 @@ class KPeg::FormatParser
478
478
 
479
479
  _save = self.pos
480
480
  while true # sequence
481
- _text_start = self.pos
482
-
483
- _save1 = self.pos
484
- while true # choice
485
- _tmp = match_string("-")
486
- break if _tmp
487
- self.pos = _save1
488
- _tmp = scan(/\A(?-mix:[a-zA-Z][\-_a-zA-Z0-9]*)/)
489
- break if _tmp
490
- self.pos = _save1
491
- break
492
- end # end choice
493
-
494
- if _tmp
495
- text = get_text(_text_start)
496
- end
497
- unless _tmp
498
- self.pos = _save
481
+ _text_start = self.pos
482
+
483
+ _save1 = self.pos
484
+ while true # choice
485
+ _tmp = match_string("-")
486
+ break if _tmp
487
+ self.pos = _save1
488
+ _tmp = scan(/\A(?-mix:[a-zA-Z][\-_a-zA-Z0-9]*)/)
489
+ break if _tmp
490
+ self.pos = _save1
491
+ break
492
+ end # end choice
493
+
494
+ if _tmp
495
+ text = get_text(_text_start)
496
+ end
497
+ unless _tmp
498
+ self.pos = _save
499
+ break
500
+ end
501
+ @result = begin; text ; end
502
+ _tmp = true
503
+ unless _tmp
504
+ self.pos = _save
505
+ end
499
506
  break
500
- end
501
- @result = begin; text ; end
502
- _tmp = true
503
- unless _tmp
504
- self.pos = _save
505
- end
506
- break
507
507
  end # end sequence
508
508
 
509
509
  set_failed_rule :_var unless _tmp
@@ -515,21 +515,21 @@ class KPeg::FormatParser
515
515
 
516
516
  _save = self.pos
517
517
  while true # sequence
518
- _text_start = self.pos
519
- _tmp = scan(/\A(?-mix:[a-zA-Z_][a-zA-Z0-9_]*)/)
520
- if _tmp
521
- text = get_text(_text_start)
522
- end
523
- unless _tmp
524
- self.pos = _save
518
+ _text_start = self.pos
519
+ _tmp = scan(/\A(?-mix:[a-zA-Z_][a-zA-Z0-9_]*)/)
520
+ if _tmp
521
+ text = get_text(_text_start)
522
+ end
523
+ unless _tmp
524
+ self.pos = _save
525
+ break
526
+ end
527
+ @result = begin; text ; end
528
+ _tmp = true
529
+ unless _tmp
530
+ self.pos = _save
531
+ end
525
532
  break
526
- end
527
- @result = begin; text ; end
528
- _tmp = true
529
- unless _tmp
530
- self.pos = _save
531
- end
532
- break
533
533
  end # end sequence
534
534
 
535
535
  set_failed_rule :_method unless _tmp
@@ -542,96 +542,96 @@ class KPeg::FormatParser
542
542
  _save = self.pos
543
543
  while true # choice
544
544
 
545
- _save1 = self.pos
546
- while true # sequence
547
- _tmp = match_string("\\\"")
548
- unless _tmp
549
- self.pos = _save1
550
- break
551
- end
552
- @result = begin; '"' ; end
553
- _tmp = true
554
- unless _tmp
555
- self.pos = _save1
556
- end
557
- break
558
- end # end sequence
545
+ _save1 = self.pos
546
+ while true # sequence
547
+ _tmp = match_string("\\\"")
548
+ unless _tmp
549
+ self.pos = _save1
550
+ break
551
+ end
552
+ @result = begin; '"' ; end
553
+ _tmp = true
554
+ unless _tmp
555
+ self.pos = _save1
556
+ end
557
+ break
558
+ end # end sequence
559
559
 
560
- break if _tmp
561
- self.pos = _save
560
+ break if _tmp
561
+ self.pos = _save
562
562
 
563
- _save2 = self.pos
564
- while true # sequence
565
- _tmp = match_string("\\n")
566
- unless _tmp
567
- self.pos = _save2
568
- break
569
- end
570
- @result = begin; "\n" ; end
571
- _tmp = true
572
- unless _tmp
573
- self.pos = _save2
574
- end
575
- break
576
- end # end sequence
563
+ _save2 = self.pos
564
+ while true # sequence
565
+ _tmp = match_string("\\n")
566
+ unless _tmp
567
+ self.pos = _save2
568
+ break
569
+ end
570
+ @result = begin; "\n" ; end
571
+ _tmp = true
572
+ unless _tmp
573
+ self.pos = _save2
574
+ end
575
+ break
576
+ end # end sequence
577
577
 
578
- break if _tmp
579
- self.pos = _save
578
+ break if _tmp
579
+ self.pos = _save
580
580
 
581
- _save3 = self.pos
582
- while true # sequence
583
- _tmp = match_string("\\t")
584
- unless _tmp
585
- self.pos = _save3
586
- break
587
- end
588
- @result = begin; "\t" ; end
589
- _tmp = true
590
- unless _tmp
591
- self.pos = _save3
592
- end
593
- break
594
- end # end sequence
581
+ _save3 = self.pos
582
+ while true # sequence
583
+ _tmp = match_string("\\t")
584
+ unless _tmp
585
+ self.pos = _save3
586
+ break
587
+ end
588
+ @result = begin; "\t" ; end
589
+ _tmp = true
590
+ unless _tmp
591
+ self.pos = _save3
592
+ end
593
+ break
594
+ end # end sequence
595
595
 
596
- break if _tmp
597
- self.pos = _save
596
+ break if _tmp
597
+ self.pos = _save
598
598
 
599
- _save4 = self.pos
600
- while true # sequence
601
- _tmp = match_string("\\b")
602
- unless _tmp
603
- self.pos = _save4
604
- break
605
- end
606
- @result = begin; "\b" ; end
607
- _tmp = true
608
- unless _tmp
609
- self.pos = _save4
610
- end
611
- break
612
- end # end sequence
599
+ _save4 = self.pos
600
+ while true # sequence
601
+ _tmp = match_string("\\b")
602
+ unless _tmp
603
+ self.pos = _save4
604
+ break
605
+ end
606
+ @result = begin; "\b" ; end
607
+ _tmp = true
608
+ unless _tmp
609
+ self.pos = _save4
610
+ end
611
+ break
612
+ end # end sequence
613
613
 
614
- break if _tmp
615
- self.pos = _save
614
+ break if _tmp
615
+ self.pos = _save
616
616
 
617
- _save5 = self.pos
618
- while true # sequence
619
- _tmp = match_string("\\\\")
620
- unless _tmp
621
- self.pos = _save5
622
- break
623
- end
624
- @result = begin; "\\" ; end
625
- _tmp = true
626
- unless _tmp
627
- self.pos = _save5
628
- end
629
- break
630
- end # end sequence
617
+ _save5 = self.pos
618
+ while true # sequence
619
+ _tmp = match_string("\\\\")
620
+ unless _tmp
621
+ self.pos = _save5
622
+ break
623
+ end
624
+ @result = begin; "\\" ; end
625
+ _tmp = true
626
+ unless _tmp
627
+ self.pos = _save5
628
+ end
629
+ break
630
+ end # end sequence
631
631
 
632
- break if _tmp
633
- self.pos = _save
634
- break
632
+ break if _tmp
633
+ self.pos = _save
634
+ break
635
635
  end # end choice
636
636
 
637
637
  set_failed_rule :_dbl_escapes unless _tmp
@@ -643,21 +643,21 @@ class KPeg::FormatParser
643
643
 
644
644
  _save = self.pos
645
645
  while true # sequence
646
- _text_start = self.pos
647
- _tmp = scan(/\A(?-mix:[^\\"]+)/)
648
- if _tmp
649
- text = get_text(_text_start)
650
- end
651
- unless _tmp
652
- self.pos = _save
646
+ _text_start = self.pos
647
+ _tmp = scan(/\A(?-mix:[^\\"]+)/)
648
+ if _tmp
649
+ text = get_text(_text_start)
650
+ end
651
+ unless _tmp
652
+ self.pos = _save
653
+ break
654
+ end
655
+ @result = begin; text ; end
656
+ _tmp = true
657
+ unless _tmp
658
+ self.pos = _save
659
+ end
653
660
  break
654
- end
655
- @result = begin; text ; end
656
- _tmp = true
657
- unless _tmp
658
- self.pos = _save
659
- end
660
- break
661
661
  end # end sequence
662
662
 
663
663
  set_failed_rule :_dbl_seq unless _tmp
@@ -669,58 +669,58 @@ class KPeg::FormatParser
669
669
 
670
670
  _save = self.pos
671
671
  while true # sequence
672
- _save1 = self.pos
673
- _ary = []
674
-
675
- _save2 = self.pos
676
- while true # choice
677
- _tmp = apply(:_dbl_escapes)
678
- s = @result
679
- break if _tmp
680
- self.pos = _save2
681
- _tmp = apply(:_dbl_seq)
682
- s = @result
683
- break if _tmp
684
- self.pos = _save2
685
- break
686
- end # end choice
672
+ _save1 = self.pos
673
+ _ary = []
687
674
 
688
- if _tmp
689
- _ary << @result
690
- while true
691
-
692
- _save3 = self.pos
693
- while true # choice
694
- _tmp = apply(:_dbl_escapes)
695
- s = @result
696
- break if _tmp
697
- self.pos = _save3
698
- _tmp = apply(:_dbl_seq)
699
- s = @result
700
- break if _tmp
701
- self.pos = _save3
702
- break
703
- end # end choice
704
-
705
- _ary << @result if _tmp
706
- break unless _tmp
675
+ _save2 = self.pos
676
+ while true # choice
677
+ _tmp = apply(:_dbl_escapes)
678
+ s = @result
679
+ break if _tmp
680
+ self.pos = _save2
681
+ _tmp = apply(:_dbl_seq)
682
+ s = @result
683
+ break if _tmp
684
+ self.pos = _save2
685
+ break
686
+ end # end choice
687
+
688
+ if _tmp
689
+ _ary << @result
690
+ while true
691
+
692
+ _save3 = self.pos
693
+ while true # choice
694
+ _tmp = apply(:_dbl_escapes)
695
+ s = @result
696
+ break if _tmp
697
+ self.pos = _save3
698
+ _tmp = apply(:_dbl_seq)
699
+ s = @result
700
+ break if _tmp
701
+ self.pos = _save3
702
+ break
703
+ end # end choice
704
+
705
+ _ary << @result if _tmp
706
+ break unless _tmp
707
+ end
708
+ _tmp = true
709
+ @result = _ary
710
+ else
711
+ self.pos = _save1
707
712
  end
713
+ ary = @result
714
+ unless _tmp
715
+ self.pos = _save
716
+ break
717
+ end
718
+ @result = begin; ary ; end
708
719
  _tmp = true
709
- @result = _ary
710
- else
711
- self.pos = _save1
712
- end
713
- ary = @result
714
- unless _tmp
715
- self.pos = _save
720
+ unless _tmp
721
+ self.pos = _save
722
+ end
716
723
  break
717
- end
718
- @result = begin; ary ; end
719
- _tmp = true
720
- unless _tmp
721
- self.pos = _save
722
- end
723
- break
724
724
  end # end sequence
725
725
 
726
726
  set_failed_rule :_dbl_not_quote unless _tmp
@@ -732,28 +732,28 @@ class KPeg::FormatParser
732
732
 
733
733
  _save = self.pos
734
734
  while true # sequence
735
- _tmp = match_string("\"")
736
- unless _tmp
737
- self.pos = _save
738
- break
739
- end
740
- _tmp = apply(:_dbl_not_quote)
741
- s = @result
742
- unless _tmp
743
- self.pos = _save
744
- break
745
- end
746
- _tmp = match_string("\"")
747
- unless _tmp
748
- self.pos = _save
735
+ _tmp = match_string("\"")
736
+ unless _tmp
737
+ self.pos = _save
738
+ break
739
+ end
740
+ _tmp = apply(:_dbl_not_quote)
741
+ s = @result
742
+ unless _tmp
743
+ self.pos = _save
744
+ break
745
+ end
746
+ _tmp = match_string("\"")
747
+ unless _tmp
748
+ self.pos = _save
749
+ break
750
+ end
751
+ @result = begin; @g.str(s.join) ; end
752
+ _tmp = true
753
+ unless _tmp
754
+ self.pos = _save
755
+ end
749
756
  break
750
- end
751
- @result = begin; @g.str(s.join) ; end
752
- _tmp = true
753
- unless _tmp
754
- self.pos = _save
755
- end
756
- break
757
757
  end # end sequence
758
758
 
759
759
  set_failed_rule :_dbl_string unless _tmp
@@ -765,17 +765,17 @@ class KPeg::FormatParser
765
765
 
766
766
  _save = self.pos
767
767
  while true # sequence
768
- _tmp = match_string("\\'")
769
- unless _tmp
770
- self.pos = _save
768
+ _tmp = match_string("\\'")
769
+ unless _tmp
770
+ self.pos = _save
771
+ break
772
+ end
773
+ @result = begin; "'" ; end
774
+ _tmp = true
775
+ unless _tmp
776
+ self.pos = _save
777
+ end
771
778
  break
772
- end
773
- @result = begin; "'" ; end
774
- _tmp = true
775
- unless _tmp
776
- self.pos = _save
777
- end
778
- break
779
779
  end # end sequence
780
780
 
781
781
  set_failed_rule :_sgl_escape_quote unless _tmp
@@ -787,21 +787,21 @@ class KPeg::FormatParser
787
787
 
788
788
  _save = self.pos
789
789
  while true # sequence
790
- _text_start = self.pos
791
- _tmp = scan(/\A(?-mix:[^'])/)
792
- if _tmp
793
- text = get_text(_text_start)
794
- end
795
- unless _tmp
796
- self.pos = _save
790
+ _text_start = self.pos
791
+ _tmp = scan(/\A(?-mix:[^'])/)
792
+ if _tmp
793
+ text = get_text(_text_start)
794
+ end
795
+ unless _tmp
796
+ self.pos = _save
797
+ break
798
+ end
799
+ @result = begin; text ; end
800
+ _tmp = true
801
+ unless _tmp
802
+ self.pos = _save
803
+ end
797
804
  break
798
- end
799
- @result = begin; text ; end
800
- _tmp = true
801
- unless _tmp
802
- self.pos = _save
803
- end
804
- break
805
805
  end # end sequence
806
806
 
807
807
  set_failed_rule :_sgl_seq unless _tmp
@@ -813,54 +813,54 @@ class KPeg::FormatParser
813
813
 
814
814
  _save = self.pos
815
815
  while true # sequence
816
- _save1 = self.pos
817
- _ary = []
816
+ _save1 = self.pos
817
+ _ary = []
818
818
 
819
- _save2 = self.pos
820
- while true # choice
821
- _tmp = apply(:_sgl_escape_quote)
822
- break if _tmp
823
- self.pos = _save2
824
- _tmp = apply(:_sgl_seq)
825
- break if _tmp
826
- self.pos = _save2
827
- break
828
- end # end choice
829
-
830
- if _tmp
831
- _ary << @result
832
- while true
833
-
834
- _save3 = self.pos
835
- while true # choice
836
- _tmp = apply(:_sgl_escape_quote)
837
- break if _tmp
838
- self.pos = _save3
839
- _tmp = apply(:_sgl_seq)
840
- break if _tmp
841
- self.pos = _save3
842
- break
843
- end # end choice
844
-
845
- _ary << @result if _tmp
846
- break unless _tmp
819
+ _save2 = self.pos
820
+ while true # choice
821
+ _tmp = apply(:_sgl_escape_quote)
822
+ break if _tmp
823
+ self.pos = _save2
824
+ _tmp = apply(:_sgl_seq)
825
+ break if _tmp
826
+ self.pos = _save2
827
+ break
828
+ end # end choice
829
+
830
+ if _tmp
831
+ _ary << @result
832
+ while true
833
+
834
+ _save3 = self.pos
835
+ while true # choice
836
+ _tmp = apply(:_sgl_escape_quote)
837
+ break if _tmp
838
+ self.pos = _save3
839
+ _tmp = apply(:_sgl_seq)
840
+ break if _tmp
841
+ self.pos = _save3
842
+ break
843
+ end # end choice
844
+
845
+ _ary << @result if _tmp
846
+ break unless _tmp
847
+ end
848
+ _tmp = true
849
+ @result = _ary
850
+ else
851
+ self.pos = _save1
852
+ end
853
+ segs = @result
854
+ unless _tmp
855
+ self.pos = _save
856
+ break
847
857
  end
858
+ @result = begin; segs.join ; end
848
859
  _tmp = true
849
- @result = _ary
850
- else
851
- self.pos = _save1
852
- end
853
- segs = @result
854
- unless _tmp
855
- self.pos = _save
860
+ unless _tmp
861
+ self.pos = _save
862
+ end
856
863
  break
857
- end
858
- @result = begin; segs.join ; end
859
- _tmp = true
860
- unless _tmp
861
- self.pos = _save
862
- end
863
- break
864
864
  end # end sequence
865
865
 
866
866
  set_failed_rule :_sgl_not_quote unless _tmp
@@ -872,28 +872,28 @@ class KPeg::FormatParser
872
872
 
873
873
  _save = self.pos
874
874
  while true # sequence
875
- _tmp = match_string("'")
876
- unless _tmp
877
- self.pos = _save
878
- break
879
- end
880
- _tmp = apply(:_sgl_not_quote)
881
- s = @result
882
- unless _tmp
883
- self.pos = _save
884
- break
885
- end
886
- _tmp = match_string("'")
887
- unless _tmp
888
- self.pos = _save
875
+ _tmp = match_string("'")
876
+ unless _tmp
877
+ self.pos = _save
878
+ break
879
+ end
880
+ _tmp = apply(:_sgl_not_quote)
881
+ s = @result
882
+ unless _tmp
883
+ self.pos = _save
884
+ break
885
+ end
886
+ _tmp = match_string("'")
887
+ unless _tmp
888
+ self.pos = _save
889
+ break
890
+ end
891
+ @result = begin; @g.str(s) ; end
892
+ _tmp = true
893
+ unless _tmp
894
+ self.pos = _save
895
+ end
889
896
  break
890
- end
891
- @result = begin; @g.str(s) ; end
892
- _tmp = true
893
- unless _tmp
894
- self.pos = _save
895
- end
896
- break
897
897
  end # end sequence
898
898
 
899
899
  set_failed_rule :_sgl_string unless _tmp
@@ -905,13 +905,13 @@ class KPeg::FormatParser
905
905
 
906
906
  _save = self.pos
907
907
  while true # choice
908
- _tmp = apply(:_dbl_string)
909
- break if _tmp
910
- self.pos = _save
911
- _tmp = apply(:_sgl_string)
912
- break if _tmp
913
- self.pos = _save
914
- break
908
+ _tmp = apply(:_dbl_string)
909
+ break if _tmp
910
+ self.pos = _save
911
+ _tmp = apply(:_sgl_string)
912
+ break if _tmp
913
+ self.pos = _save
914
+ break
915
915
  end # end choice
916
916
 
917
917
  set_failed_rule :_string unless _tmp
@@ -923,53 +923,53 @@ class KPeg::FormatParser
923
923
 
924
924
  _save = self.pos
925
925
  while true # sequence
926
- _text_start = self.pos
927
- _save1 = self.pos
928
-
929
- _save2 = self.pos
930
- while true # choice
931
- _tmp = match_string("\\/")
932
- break if _tmp
933
- self.pos = _save2
934
- _tmp = scan(/\A(?-mix:[^\/])/)
935
- break if _tmp
936
- self.pos = _save2
937
- break
938
- end # end choice
926
+ _text_start = self.pos
927
+ _save1 = self.pos
939
928
 
940
- if _tmp
941
- while true
942
-
943
- _save3 = self.pos
944
- while true # choice
945
- _tmp = match_string("\\/")
946
- break if _tmp
947
- self.pos = _save3
948
- _tmp = scan(/\A(?-mix:[^\/])/)
949
- break if _tmp
950
- self.pos = _save3
951
- break
952
- end # end choice
953
-
954
- break unless _tmp
929
+ _save2 = self.pos
930
+ while true # choice
931
+ _tmp = match_string("\\/")
932
+ break if _tmp
933
+ self.pos = _save2
934
+ _tmp = scan(/\A(?-mix:[^\/])/)
935
+ break if _tmp
936
+ self.pos = _save2
937
+ break
938
+ end # end choice
939
+
940
+ if _tmp
941
+ while true
942
+
943
+ _save3 = self.pos
944
+ while true # choice
945
+ _tmp = match_string("\\/")
946
+ break if _tmp
947
+ self.pos = _save3
948
+ _tmp = scan(/\A(?-mix:[^\/])/)
949
+ break if _tmp
950
+ self.pos = _save3
951
+ break
952
+ end # end choice
953
+
954
+ break unless _tmp
955
+ end
956
+ _tmp = true
957
+ else
958
+ self.pos = _save1
959
+ end
960
+ if _tmp
961
+ text = get_text(_text_start)
962
+ end
963
+ unless _tmp
964
+ self.pos = _save
965
+ break
955
966
  end
967
+ @result = begin; text ; end
956
968
  _tmp = true
957
- else
958
- self.pos = _save1
959
- end
960
- if _tmp
961
- text = get_text(_text_start)
962
- end
963
- unless _tmp
964
- self.pos = _save
969
+ unless _tmp
970
+ self.pos = _save
971
+ end
965
972
  break
966
- end
967
- @result = begin; text ; end
968
- _tmp = true
969
- unless _tmp
970
- self.pos = _save
971
- end
972
- break
973
973
  end # end sequence
974
974
 
975
975
  set_failed_rule :_not_slash unless _tmp
@@ -981,32 +981,32 @@ class KPeg::FormatParser
981
981
 
982
982
  _save = self.pos
983
983
  while true # sequence
984
- _text_start = self.pos
985
- while true
986
- _save2 = self.pos
987
- _tmp = get_byte
988
- if _tmp
989
- unless _tmp >= 97 and _tmp <= 122
990
- self.pos = _save2
991
- _tmp = nil
984
+ _text_start = self.pos
985
+ while true
986
+ _save2 = self.pos
987
+ _tmp = get_byte
988
+ if _tmp
989
+ unless _tmp >= 97 and _tmp <= 122
990
+ self.pos = _save2
991
+ _tmp = nil
992
+ end
993
+ end
994
+ break unless _tmp
995
+ end
996
+ _tmp = true
997
+ if _tmp
998
+ text = get_text(_text_start)
999
+ end
1000
+ unless _tmp
1001
+ self.pos = _save
1002
+ break
1003
+ end
1004
+ @result = begin; text ; end
1005
+ _tmp = true
1006
+ unless _tmp
1007
+ self.pos = _save
992
1008
  end
993
- end
994
- break unless _tmp
995
- end
996
- _tmp = true
997
- if _tmp
998
- text = get_text(_text_start)
999
- end
1000
- unless _tmp
1001
- self.pos = _save
1002
1009
  break
1003
- end
1004
- @result = begin; text ; end
1005
- _tmp = true
1006
- unless _tmp
1007
- self.pos = _save
1008
- end
1009
- break
1010
1010
  end # end sequence
1011
1011
 
1012
1012
  set_failed_rule :_regexp_opts unless _tmp
@@ -1018,34 +1018,34 @@ class KPeg::FormatParser
1018
1018
 
1019
1019
  _save = self.pos
1020
1020
  while true # sequence
1021
- _tmp = match_string("/")
1022
- unless _tmp
1023
- self.pos = _save
1024
- break
1025
- end
1026
- _tmp = apply(:_not_slash)
1027
- body = @result
1028
- unless _tmp
1029
- self.pos = _save
1030
- break
1031
- end
1032
- _tmp = match_string("/")
1033
- unless _tmp
1034
- self.pos = _save
1035
- break
1036
- end
1037
- _tmp = apply(:_regexp_opts)
1038
- opts = @result
1039
- unless _tmp
1040
- self.pos = _save
1021
+ _tmp = match_string("/")
1022
+ unless _tmp
1023
+ self.pos = _save
1024
+ break
1025
+ end
1026
+ _tmp = apply(:_not_slash)
1027
+ body = @result
1028
+ unless _tmp
1029
+ self.pos = _save
1030
+ break
1031
+ end
1032
+ _tmp = match_string("/")
1033
+ unless _tmp
1034
+ self.pos = _save
1035
+ break
1036
+ end
1037
+ _tmp = apply(:_regexp_opts)
1038
+ opts = @result
1039
+ unless _tmp
1040
+ self.pos = _save
1041
+ break
1042
+ end
1043
+ @result = begin; @g.reg body, opts ; end
1044
+ _tmp = true
1045
+ unless _tmp
1046
+ self.pos = _save
1047
+ end
1041
1048
  break
1042
- end
1043
- @result = begin; @g.reg body, opts ; end
1044
- _tmp = true
1045
- unless _tmp
1046
- self.pos = _save
1047
- end
1048
- break
1049
1049
  end # end sequence
1050
1050
 
1051
1051
  set_failed_rule :_regexp unless _tmp
@@ -1057,21 +1057,21 @@ class KPeg::FormatParser
1057
1057
 
1058
1058
  _save = self.pos
1059
1059
  while true # sequence
1060
- _text_start = self.pos
1061
- _tmp = scan(/\A(?-mix:[a-zA-Z0-9])/)
1062
- if _tmp
1063
- text = get_text(_text_start)
1064
- end
1065
- unless _tmp
1066
- self.pos = _save
1060
+ _text_start = self.pos
1061
+ _tmp = scan(/\A(?-mix:[a-zA-Z0-9])/)
1062
+ if _tmp
1063
+ text = get_text(_text_start)
1064
+ end
1065
+ unless _tmp
1066
+ self.pos = _save
1067
+ break
1068
+ end
1069
+ @result = begin; text ; end
1070
+ _tmp = true
1071
+ unless _tmp
1072
+ self.pos = _save
1073
+ end
1067
1074
  break
1068
- end
1069
- @result = begin; text ; end
1070
- _tmp = true
1071
- unless _tmp
1072
- self.pos = _save
1073
- end
1074
- break
1075
1075
  end # end sequence
1076
1076
 
1077
1077
  set_failed_rule :_char unless _tmp
@@ -1083,39 +1083,39 @@ class KPeg::FormatParser
1083
1083
 
1084
1084
  _save = self.pos
1085
1085
  while true # sequence
1086
- _tmp = match_string("[")
1087
- unless _tmp
1088
- self.pos = _save
1089
- break
1090
- end
1091
- _tmp = apply(:_char)
1092
- l = @result
1093
- unless _tmp
1094
- self.pos = _save
1095
- break
1096
- end
1097
- _tmp = match_string("-")
1098
- unless _tmp
1099
- self.pos = _save
1100
- break
1101
- end
1102
- _tmp = apply(:_char)
1103
- r = @result
1104
- unless _tmp
1105
- self.pos = _save
1106
- break
1107
- end
1108
- _tmp = match_string("]")
1109
- unless _tmp
1110
- self.pos = _save
1086
+ _tmp = match_string("[")
1087
+ unless _tmp
1088
+ self.pos = _save
1089
+ break
1090
+ end
1091
+ _tmp = apply(:_char)
1092
+ l = @result
1093
+ unless _tmp
1094
+ self.pos = _save
1095
+ break
1096
+ end
1097
+ _tmp = match_string("-")
1098
+ unless _tmp
1099
+ self.pos = _save
1100
+ break
1101
+ end
1102
+ _tmp = apply(:_char)
1103
+ r = @result
1104
+ unless _tmp
1105
+ self.pos = _save
1106
+ break
1107
+ end
1108
+ _tmp = match_string("]")
1109
+ unless _tmp
1110
+ self.pos = _save
1111
+ break
1112
+ end
1113
+ @result = begin; @g.range(l,r) ; end
1114
+ _tmp = true
1115
+ unless _tmp
1116
+ self.pos = _save
1117
+ end
1111
1118
  break
1112
- end
1113
- @result = begin; @g.range(l,r) ; end
1114
- _tmp = true
1115
- unless _tmp
1116
- self.pos = _save
1117
- end
1118
- break
1119
1119
  end # end sequence
1120
1120
 
1121
1121
  set_failed_rule :_char_range unless _tmp
@@ -1127,21 +1127,21 @@ class KPeg::FormatParser
1127
1127
 
1128
1128
  _save = self.pos
1129
1129
  while true # sequence
1130
- _text_start = self.pos
1131
- _tmp = scan(/\A(?-mix:[1-9][0-9]*)/)
1132
- if _tmp
1133
- text = get_text(_text_start)
1134
- end
1135
- unless _tmp
1136
- self.pos = _save
1130
+ _text_start = self.pos
1131
+ _tmp = scan(/\A(?-mix:[1-9][0-9]*)/)
1132
+ if _tmp
1133
+ text = get_text(_text_start)
1134
+ end
1135
+ unless _tmp
1136
+ self.pos = _save
1137
+ break
1138
+ end
1139
+ @result = begin; text ; end
1140
+ _tmp = true
1141
+ unless _tmp
1142
+ self.pos = _save
1143
+ end
1137
1144
  break
1138
- end
1139
- @result = begin; text ; end
1140
- _tmp = true
1141
- unless _tmp
1142
- self.pos = _save
1143
- end
1144
- break
1145
1145
  end # end sequence
1146
1146
 
1147
1147
  set_failed_rule :_range_num unless _tmp
@@ -1153,32 +1153,32 @@ class KPeg::FormatParser
1153
1153
 
1154
1154
  _save = self.pos
1155
1155
  while true # sequence
1156
- _text_start = self.pos
1157
-
1158
- _save1 = self.pos
1159
- while true # choice
1160
- _tmp = apply(:_range_num)
1161
- break if _tmp
1162
- self.pos = _save1
1163
- _tmp = apply(:_kleene)
1164
- break if _tmp
1165
- self.pos = _save1
1166
- break
1167
- end # end choice
1168
-
1169
- if _tmp
1170
- text = get_text(_text_start)
1171
- end
1172
- unless _tmp
1173
- self.pos = _save
1156
+ _text_start = self.pos
1157
+
1158
+ _save1 = self.pos
1159
+ while true # choice
1160
+ _tmp = apply(:_range_num)
1161
+ break if _tmp
1162
+ self.pos = _save1
1163
+ _tmp = apply(:_kleene)
1164
+ break if _tmp
1165
+ self.pos = _save1
1166
+ break
1167
+ end # end choice
1168
+
1169
+ if _tmp
1170
+ text = get_text(_text_start)
1171
+ end
1172
+ unless _tmp
1173
+ self.pos = _save
1174
+ break
1175
+ end
1176
+ @result = begin; text ; end
1177
+ _tmp = true
1178
+ unless _tmp
1179
+ self.pos = _save
1180
+ end
1174
1181
  break
1175
- end
1176
- @result = begin; text ; end
1177
- _tmp = true
1178
- unless _tmp
1179
- self.pos = _save
1180
- end
1181
- break
1182
1182
  end # end sequence
1183
1183
 
1184
1184
  set_failed_rule :_range_elem unless _tmp
@@ -1191,105 +1191,105 @@ class KPeg::FormatParser
1191
1191
  _save = self.pos
1192
1192
  while true # choice
1193
1193
 
1194
- _save1 = self.pos
1195
- while true # sequence
1196
- _tmp = match_string("[")
1197
- unless _tmp
1198
- self.pos = _save1
1199
- break
1200
- end
1201
- _tmp = apply(:__hyphen_)
1202
- unless _tmp
1203
- self.pos = _save1
1204
- break
1205
- end
1206
- _tmp = apply(:_range_elem)
1207
- l = @result
1208
- unless _tmp
1209
- self.pos = _save1
1210
- break
1211
- end
1212
- _tmp = apply(:__hyphen_)
1213
- unless _tmp
1214
- self.pos = _save1
1215
- break
1216
- end
1217
- _tmp = match_string(",")
1218
- unless _tmp
1219
- self.pos = _save1
1220
- break
1221
- end
1222
- _tmp = apply(:__hyphen_)
1223
- unless _tmp
1224
- self.pos = _save1
1225
- break
1226
- end
1227
- _tmp = apply(:_range_elem)
1228
- r = @result
1229
- unless _tmp
1230
- self.pos = _save1
1231
- break
1232
- end
1233
- _tmp = apply(:__hyphen_)
1234
- unless _tmp
1235
- self.pos = _save1
1236
- break
1237
- end
1238
- _tmp = match_string("]")
1239
- unless _tmp
1240
- self.pos = _save1
1241
- break
1242
- end
1243
- @result = begin; [l == "*" ? nil : l.to_i, r == "*" ? nil : r.to_i] ; end
1244
- _tmp = true
1245
- unless _tmp
1246
- self.pos = _save1
1247
- end
1248
- break
1249
- end # end sequence
1194
+ _save1 = self.pos
1195
+ while true # sequence
1196
+ _tmp = match_string("[")
1197
+ unless _tmp
1198
+ self.pos = _save1
1199
+ break
1200
+ end
1201
+ _tmp = apply(:__hyphen_)
1202
+ unless _tmp
1203
+ self.pos = _save1
1204
+ break
1205
+ end
1206
+ _tmp = apply(:_range_elem)
1207
+ l = @result
1208
+ unless _tmp
1209
+ self.pos = _save1
1210
+ break
1211
+ end
1212
+ _tmp = apply(:__hyphen_)
1213
+ unless _tmp
1214
+ self.pos = _save1
1215
+ break
1216
+ end
1217
+ _tmp = match_string(",")
1218
+ unless _tmp
1219
+ self.pos = _save1
1220
+ break
1221
+ end
1222
+ _tmp = apply(:__hyphen_)
1223
+ unless _tmp
1224
+ self.pos = _save1
1225
+ break
1226
+ end
1227
+ _tmp = apply(:_range_elem)
1228
+ r = @result
1229
+ unless _tmp
1230
+ self.pos = _save1
1231
+ break
1232
+ end
1233
+ _tmp = apply(:__hyphen_)
1234
+ unless _tmp
1235
+ self.pos = _save1
1236
+ break
1237
+ end
1238
+ _tmp = match_string("]")
1239
+ unless _tmp
1240
+ self.pos = _save1
1241
+ break
1242
+ end
1243
+ @result = begin; [l == "*" ? nil : l.to_i, r == "*" ? nil : r.to_i] ; end
1244
+ _tmp = true
1245
+ unless _tmp
1246
+ self.pos = _save1
1247
+ end
1248
+ break
1249
+ end # end sequence
1250
1250
 
1251
- break if _tmp
1252
- self.pos = _save
1251
+ break if _tmp
1252
+ self.pos = _save
1253
1253
 
1254
- _save2 = self.pos
1255
- while true # sequence
1256
- _tmp = match_string("[")
1257
- unless _tmp
1258
- self.pos = _save2
1259
- break
1260
- end
1261
- _tmp = apply(:__hyphen_)
1262
- unless _tmp
1263
- self.pos = _save2
1264
- break
1265
- end
1266
- _tmp = apply(:_range_num)
1267
- e = @result
1268
- unless _tmp
1269
- self.pos = _save2
1270
- break
1271
- end
1272
- _tmp = apply(:__hyphen_)
1273
- unless _tmp
1274
- self.pos = _save2
1275
- break
1276
- end
1277
- _tmp = match_string("]")
1278
- unless _tmp
1279
- self.pos = _save2
1280
- break
1281
- end
1282
- @result = begin; [e.to_i, e.to_i] ; end
1283
- _tmp = true
1284
- unless _tmp
1285
- self.pos = _save2
1286
- end
1287
- break
1288
- end # end sequence
1254
+ _save2 = self.pos
1255
+ while true # sequence
1256
+ _tmp = match_string("[")
1257
+ unless _tmp
1258
+ self.pos = _save2
1259
+ break
1260
+ end
1261
+ _tmp = apply(:__hyphen_)
1262
+ unless _tmp
1263
+ self.pos = _save2
1264
+ break
1265
+ end
1266
+ _tmp = apply(:_range_num)
1267
+ e = @result
1268
+ unless _tmp
1269
+ self.pos = _save2
1270
+ break
1271
+ end
1272
+ _tmp = apply(:__hyphen_)
1273
+ unless _tmp
1274
+ self.pos = _save2
1275
+ break
1276
+ end
1277
+ _tmp = match_string("]")
1278
+ unless _tmp
1279
+ self.pos = _save2
1280
+ break
1281
+ end
1282
+ @result = begin; [e.to_i, e.to_i] ; end
1283
+ _tmp = true
1284
+ unless _tmp
1285
+ self.pos = _save2
1286
+ end
1287
+ break
1288
+ end # end sequence
1289
1289
 
1290
- break if _tmp
1291
- self.pos = _save
1292
- break
1290
+ break if _tmp
1291
+ self.pos = _save
1292
+ break
1293
1293
  end # end choice
1294
1294
 
1295
1295
  set_failed_rule :_mult_range unless _tmp
@@ -1303,613 +1303,658 @@ class KPeg::FormatParser
1303
1303
  return _tmp
1304
1304
  end
1305
1305
 
1306
- # curly = "{" < (/[^{}]+/ | curly)* > "}" { @g.action(text) }
1306
+ # curly = "{" < (/[^{}"']+/ | string | curly)* > "}" { @g.action(text) }
1307
1307
  def _curly
1308
1308
 
1309
1309
  _save = self.pos
1310
1310
  while true # sequence
1311
- _tmp = match_string("{")
1312
- unless _tmp
1313
- self.pos = _save
1314
- break
1315
- end
1316
- _text_start = self.pos
1317
- while true
1311
+ _tmp = match_string("{")
1312
+ unless _tmp
1313
+ self.pos = _save
1314
+ break
1315
+ end
1316
+ _text_start = self.pos
1317
+ while true
1318
1318
 
1319
- _save2 = self.pos
1320
- while true # choice
1321
- _tmp = scan(/\A(?-mix:[^{}]+)/)
1322
- break if _tmp
1323
- self.pos = _save2
1324
- _tmp = apply(:_curly)
1325
- break if _tmp
1326
- self.pos = _save2
1327
- break
1328
- end # end choice
1319
+ _save2 = self.pos
1320
+ while true # choice
1321
+ _tmp = scan(/\A(?-mix:[^{}"']+)/)
1322
+ break if _tmp
1323
+ self.pos = _save2
1324
+ _tmp = apply(:_string)
1325
+ break if _tmp
1326
+ self.pos = _save2
1327
+ _tmp = apply(:_curly)
1328
+ break if _tmp
1329
+ self.pos = _save2
1330
+ break
1331
+ end # end choice
1329
1332
 
1330
- break unless _tmp
1331
- end
1332
- _tmp = true
1333
- if _tmp
1334
- text = get_text(_text_start)
1335
- end
1336
- unless _tmp
1337
- self.pos = _save
1338
- break
1339
- end
1340
- _tmp = match_string("}")
1341
- unless _tmp
1342
- self.pos = _save
1333
+ break unless _tmp
1334
+ end
1335
+ _tmp = true
1336
+ if _tmp
1337
+ text = get_text(_text_start)
1338
+ end
1339
+ unless _tmp
1340
+ self.pos = _save
1341
+ break
1342
+ end
1343
+ _tmp = match_string("}")
1344
+ unless _tmp
1345
+ self.pos = _save
1346
+ break
1347
+ end
1348
+ @result = begin; @g.action(text) ; end
1349
+ _tmp = true
1350
+ unless _tmp
1351
+ self.pos = _save
1352
+ end
1343
1353
  break
1344
- end
1345
- @result = begin; @g.action(text) ; end
1346
- _tmp = true
1347
- unless _tmp
1348
- self.pos = _save
1349
- end
1350
- break
1351
1354
  end # end sequence
1352
1355
 
1353
1356
  set_failed_rule :_curly unless _tmp
1354
1357
  return _tmp
1355
1358
  end
1356
1359
 
1357
- # nested_paren = "(" (/[^()]+/ | nested_paren)* ")"
1360
+ # nested_paren = "(" (/[^()"']+/ | string | nested_paren)* ")"
1358
1361
  def _nested_paren
1359
1362
 
1360
1363
  _save = self.pos
1361
1364
  while true # sequence
1362
- _tmp = match_string("(")
1363
- unless _tmp
1364
- self.pos = _save
1365
- break
1366
- end
1367
- while true
1365
+ _tmp = match_string("(")
1366
+ unless _tmp
1367
+ self.pos = _save
1368
+ break
1369
+ end
1370
+ while true
1368
1371
 
1369
- _save2 = self.pos
1370
- while true # choice
1371
- _tmp = scan(/\A(?-mix:[^()]+)/)
1372
- break if _tmp
1373
- self.pos = _save2
1374
- _tmp = apply(:_nested_paren)
1375
- break if _tmp
1376
- self.pos = _save2
1377
- break
1378
- end # end choice
1372
+ _save2 = self.pos
1373
+ while true # choice
1374
+ _tmp = scan(/\A(?-mix:[^()"']+)/)
1375
+ break if _tmp
1376
+ self.pos = _save2
1377
+ _tmp = apply(:_string)
1378
+ break if _tmp
1379
+ self.pos = _save2
1380
+ _tmp = apply(:_nested_paren)
1381
+ break if _tmp
1382
+ self.pos = _save2
1383
+ break
1384
+ end # end choice
1379
1385
 
1380
- break unless _tmp
1381
- end
1382
- _tmp = true
1383
- unless _tmp
1384
- self.pos = _save
1386
+ break unless _tmp
1387
+ end
1388
+ _tmp = true
1389
+ unless _tmp
1390
+ self.pos = _save
1391
+ break
1392
+ end
1393
+ _tmp = match_string(")")
1394
+ unless _tmp
1395
+ self.pos = _save
1396
+ end
1385
1397
  break
1386
- end
1387
- _tmp = match_string(")")
1388
- unless _tmp
1389
- self.pos = _save
1390
- end
1391
- break
1392
1398
  end # end sequence
1393
1399
 
1394
1400
  set_failed_rule :_nested_paren unless _tmp
1395
1401
  return _tmp
1396
1402
  end
1397
1403
 
1398
- # value = (value:v ":" var:n { @g.t(v,n) } | value:v "?" { @g.maybe(v) } | value:v "+" { @g.many(v) } | value:v "*" { @g.kleene(v) } | value:v mult_range:r { @g.multiple(v, *r) } | "&" value:v { @g.andp(v) } | "!" value:v { @g.notp(v) } | "(" - expression:o - ")" { o } | "<" - expression:o - ">" { @g.collect(o) } | curly_block | "~" method:m < nested_paren? > { @g.action("#{m}#{text}") } | "." { @g.dot } | "@" var:name !(- "=") { @g.invoke(name) } | "^" var:name < nested_paren? > { @g.foreign_invoke("parent", name, text) } | "%" var:gram "." var:name < nested_paren? > { @g.foreign_invoke(gram, name, text) } | var:name < nested_paren? > !(- "=") { text.empty? ? @g.ref(name) : @g.invoke(name, text) } | char_range | regexp | string)
1404
+ # value = (value:v ":" var:n { @g.t(v,n) } | value:v "?" { @g.maybe(v) } | value:v "+" { @g.many(v) } | value:v "*" { @g.kleene(v) } | value:v mult_range:r { @g.multiple(v, *r) } | "&" value:v { @g.andp(v) } | "!" value:v { @g.notp(v) } | "(" - expression:o - ")" { o } | "@<" - expression:o - ">" { @g.bounds(o) } | "<" - expression:o - ">" { @g.collect(o) } | curly_block | "~" method:m < nested_paren? > { @g.action("#{m}#{text}") } | "." { @g.dot } | "@" var:name !(- "=") { @g.invoke(name) } | "^" var:name < nested_paren? > { @g.foreign_invoke("parent", name, text) } | "%" var:gram "." var:name < nested_paren? > { @g.foreign_invoke(gram, name, text) } | var:name < nested_paren? > !(- "=") { text.empty? ? @g.ref(name) : @g.invoke(name, text) } | char_range | regexp | string)
1399
1405
  def _value
1400
1406
 
1401
1407
  _save = self.pos
1402
1408
  while true # choice
1403
1409
 
1404
- _save1 = self.pos
1405
- while true # sequence
1406
- _tmp = apply(:_value)
1407
- v = @result
1408
- unless _tmp
1409
- self.pos = _save1
1410
- break
1411
- end
1412
- _tmp = match_string(":")
1413
- unless _tmp
1414
- self.pos = _save1
1415
- break
1416
- end
1417
- _tmp = apply(:_var)
1418
- n = @result
1419
- unless _tmp
1420
- self.pos = _save1
1421
- break
1422
- end
1423
- @result = begin; @g.t(v,n) ; end
1424
- _tmp = true
1425
- unless _tmp
1426
- self.pos = _save1
1427
- end
1428
- break
1429
- end # end sequence
1430
-
1431
- break if _tmp
1432
- self.pos = _save
1410
+ _save1 = self.pos
1411
+ while true # sequence
1412
+ _tmp = apply(:_value)
1413
+ v = @result
1414
+ unless _tmp
1415
+ self.pos = _save1
1416
+ break
1417
+ end
1418
+ _tmp = match_string(":")
1419
+ unless _tmp
1420
+ self.pos = _save1
1421
+ break
1422
+ end
1423
+ _tmp = apply(:_var)
1424
+ n = @result
1425
+ unless _tmp
1426
+ self.pos = _save1
1427
+ break
1428
+ end
1429
+ @result = begin; @g.t(v,n) ; end
1430
+ _tmp = true
1431
+ unless _tmp
1432
+ self.pos = _save1
1433
+ end
1434
+ break
1435
+ end # end sequence
1433
1436
 
1434
- _save2 = self.pos
1435
- while true # sequence
1436
- _tmp = apply(:_value)
1437
- v = @result
1438
- unless _tmp
1439
- self.pos = _save2
1440
- break
1441
- end
1442
- _tmp = match_string("?")
1443
- unless _tmp
1444
- self.pos = _save2
1445
- break
1446
- end
1447
- @result = begin; @g.maybe(v) ; end
1448
- _tmp = true
1449
- unless _tmp
1450
- self.pos = _save2
1451
- end
1452
- break
1453
- end # end sequence
1437
+ break if _tmp
1438
+ self.pos = _save
1454
1439
 
1455
- break if _tmp
1456
- self.pos = _save
1440
+ _save2 = self.pos
1441
+ while true # sequence
1442
+ _tmp = apply(:_value)
1443
+ v = @result
1444
+ unless _tmp
1445
+ self.pos = _save2
1446
+ break
1447
+ end
1448
+ _tmp = match_string("?")
1449
+ unless _tmp
1450
+ self.pos = _save2
1451
+ break
1452
+ end
1453
+ @result = begin; @g.maybe(v) ; end
1454
+ _tmp = true
1455
+ unless _tmp
1456
+ self.pos = _save2
1457
+ end
1458
+ break
1459
+ end # end sequence
1457
1460
 
1458
- _save3 = self.pos
1459
- while true # sequence
1460
- _tmp = apply(:_value)
1461
- v = @result
1462
- unless _tmp
1463
- self.pos = _save3
1464
- break
1465
- end
1466
- _tmp = match_string("+")
1467
- unless _tmp
1468
- self.pos = _save3
1469
- break
1470
- end
1471
- @result = begin; @g.many(v) ; end
1472
- _tmp = true
1473
- unless _tmp
1474
- self.pos = _save3
1475
- end
1476
- break
1477
- end # end sequence
1461
+ break if _tmp
1462
+ self.pos = _save
1478
1463
 
1479
- break if _tmp
1480
- self.pos = _save
1464
+ _save3 = self.pos
1465
+ while true # sequence
1466
+ _tmp = apply(:_value)
1467
+ v = @result
1468
+ unless _tmp
1469
+ self.pos = _save3
1470
+ break
1471
+ end
1472
+ _tmp = match_string("+")
1473
+ unless _tmp
1474
+ self.pos = _save3
1475
+ break
1476
+ end
1477
+ @result = begin; @g.many(v) ; end
1478
+ _tmp = true
1479
+ unless _tmp
1480
+ self.pos = _save3
1481
+ end
1482
+ break
1483
+ end # end sequence
1481
1484
 
1482
- _save4 = self.pos
1483
- while true # sequence
1484
- _tmp = apply(:_value)
1485
- v = @result
1486
- unless _tmp
1487
- self.pos = _save4
1488
- break
1489
- end
1490
- _tmp = match_string("*")
1491
- unless _tmp
1492
- self.pos = _save4
1493
- break
1494
- end
1495
- @result = begin; @g.kleene(v) ; end
1496
- _tmp = true
1497
- unless _tmp
1498
- self.pos = _save4
1499
- end
1500
- break
1501
- end # end sequence
1485
+ break if _tmp
1486
+ self.pos = _save
1502
1487
 
1503
- break if _tmp
1504
- self.pos = _save
1488
+ _save4 = self.pos
1489
+ while true # sequence
1490
+ _tmp = apply(:_value)
1491
+ v = @result
1492
+ unless _tmp
1493
+ self.pos = _save4
1494
+ break
1495
+ end
1496
+ _tmp = match_string("*")
1497
+ unless _tmp
1498
+ self.pos = _save4
1499
+ break
1500
+ end
1501
+ @result = begin; @g.kleene(v) ; end
1502
+ _tmp = true
1503
+ unless _tmp
1504
+ self.pos = _save4
1505
+ end
1506
+ break
1507
+ end # end sequence
1505
1508
 
1506
- _save5 = self.pos
1507
- while true # sequence
1508
- _tmp = apply(:_value)
1509
- v = @result
1510
- unless _tmp
1511
- self.pos = _save5
1512
- break
1513
- end
1514
- _tmp = apply(:_mult_range)
1515
- r = @result
1516
- unless _tmp
1517
- self.pos = _save5
1518
- break
1519
- end
1520
- @result = begin; @g.multiple(v, *r) ; end
1521
- _tmp = true
1522
- unless _tmp
1523
- self.pos = _save5
1524
- end
1525
- break
1526
- end # end sequence
1509
+ break if _tmp
1510
+ self.pos = _save
1527
1511
 
1528
- break if _tmp
1529
- self.pos = _save
1512
+ _save5 = self.pos
1513
+ while true # sequence
1514
+ _tmp = apply(:_value)
1515
+ v = @result
1516
+ unless _tmp
1517
+ self.pos = _save5
1518
+ break
1519
+ end
1520
+ _tmp = apply(:_mult_range)
1521
+ r = @result
1522
+ unless _tmp
1523
+ self.pos = _save5
1524
+ break
1525
+ end
1526
+ @result = begin; @g.multiple(v, *r) ; end
1527
+ _tmp = true
1528
+ unless _tmp
1529
+ self.pos = _save5
1530
+ end
1531
+ break
1532
+ end # end sequence
1530
1533
 
1531
- _save6 = self.pos
1532
- while true # sequence
1533
- _tmp = match_string("&")
1534
- unless _tmp
1535
- self.pos = _save6
1536
- break
1537
- end
1538
- _tmp = apply(:_value)
1539
- v = @result
1540
- unless _tmp
1541
- self.pos = _save6
1542
- break
1543
- end
1544
- @result = begin; @g.andp(v) ; end
1545
- _tmp = true
1546
- unless _tmp
1547
- self.pos = _save6
1548
- end
1549
- break
1550
- end # end sequence
1534
+ break if _tmp
1535
+ self.pos = _save
1551
1536
 
1552
- break if _tmp
1553
- self.pos = _save
1537
+ _save6 = self.pos
1538
+ while true # sequence
1539
+ _tmp = match_string("&")
1540
+ unless _tmp
1541
+ self.pos = _save6
1542
+ break
1543
+ end
1544
+ _tmp = apply(:_value)
1545
+ v = @result
1546
+ unless _tmp
1547
+ self.pos = _save6
1548
+ break
1549
+ end
1550
+ @result = begin; @g.andp(v) ; end
1551
+ _tmp = true
1552
+ unless _tmp
1553
+ self.pos = _save6
1554
+ end
1555
+ break
1556
+ end # end sequence
1554
1557
 
1555
- _save7 = self.pos
1556
- while true # sequence
1557
- _tmp = match_string("!")
1558
- unless _tmp
1559
- self.pos = _save7
1560
- break
1561
- end
1562
- _tmp = apply(:_value)
1563
- v = @result
1564
- unless _tmp
1565
- self.pos = _save7
1566
- break
1567
- end
1568
- @result = begin; @g.notp(v) ; end
1569
- _tmp = true
1570
- unless _tmp
1571
- self.pos = _save7
1572
- end
1573
- break
1574
- end # end sequence
1558
+ break if _tmp
1559
+ self.pos = _save
1575
1560
 
1576
- break if _tmp
1577
- self.pos = _save
1561
+ _save7 = self.pos
1562
+ while true # sequence
1563
+ _tmp = match_string("!")
1564
+ unless _tmp
1565
+ self.pos = _save7
1566
+ break
1567
+ end
1568
+ _tmp = apply(:_value)
1569
+ v = @result
1570
+ unless _tmp
1571
+ self.pos = _save7
1572
+ break
1573
+ end
1574
+ @result = begin; @g.notp(v) ; end
1575
+ _tmp = true
1576
+ unless _tmp
1577
+ self.pos = _save7
1578
+ end
1579
+ break
1580
+ end # end sequence
1578
1581
 
1579
- _save8 = self.pos
1580
- while true # sequence
1581
- _tmp = match_string("(")
1582
- unless _tmp
1583
- self.pos = _save8
1584
- break
1585
- end
1586
- _tmp = apply(:__hyphen_)
1587
- unless _tmp
1588
- self.pos = _save8
1589
- break
1590
- end
1591
- _tmp = apply(:_expression)
1592
- o = @result
1593
- unless _tmp
1594
- self.pos = _save8
1595
- break
1596
- end
1597
- _tmp = apply(:__hyphen_)
1598
- unless _tmp
1599
- self.pos = _save8
1600
- break
1601
- end
1602
- _tmp = match_string(")")
1603
- unless _tmp
1604
- self.pos = _save8
1605
- break
1606
- end
1607
- @result = begin; o ; end
1608
- _tmp = true
1609
- unless _tmp
1610
- self.pos = _save8
1611
- end
1612
- break
1613
- end # end sequence
1582
+ break if _tmp
1583
+ self.pos = _save
1614
1584
 
1615
- break if _tmp
1616
- self.pos = _save
1585
+ _save8 = self.pos
1586
+ while true # sequence
1587
+ _tmp = match_string("(")
1588
+ unless _tmp
1589
+ self.pos = _save8
1590
+ break
1591
+ end
1592
+ _tmp = apply(:__hyphen_)
1593
+ unless _tmp
1594
+ self.pos = _save8
1595
+ break
1596
+ end
1597
+ _tmp = apply(:_expression)
1598
+ o = @result
1599
+ unless _tmp
1600
+ self.pos = _save8
1601
+ break
1602
+ end
1603
+ _tmp = apply(:__hyphen_)
1604
+ unless _tmp
1605
+ self.pos = _save8
1606
+ break
1607
+ end
1608
+ _tmp = match_string(")")
1609
+ unless _tmp
1610
+ self.pos = _save8
1611
+ break
1612
+ end
1613
+ @result = begin; o ; end
1614
+ _tmp = true
1615
+ unless _tmp
1616
+ self.pos = _save8
1617
+ end
1618
+ break
1619
+ end # end sequence
1617
1620
 
1618
- _save9 = self.pos
1619
- while true # sequence
1620
- _tmp = match_string("<")
1621
- unless _tmp
1622
- self.pos = _save9
1623
- break
1624
- end
1625
- _tmp = apply(:__hyphen_)
1626
- unless _tmp
1627
- self.pos = _save9
1628
- break
1629
- end
1630
- _tmp = apply(:_expression)
1631
- o = @result
1632
- unless _tmp
1633
- self.pos = _save9
1634
- break
1635
- end
1636
- _tmp = apply(:__hyphen_)
1637
- unless _tmp
1638
- self.pos = _save9
1639
- break
1640
- end
1641
- _tmp = match_string(">")
1642
- unless _tmp
1643
- self.pos = _save9
1644
- break
1645
- end
1646
- @result = begin; @g.collect(o) ; end
1647
- _tmp = true
1648
- unless _tmp
1649
- self.pos = _save9
1650
- end
1651
- break
1652
- end # end sequence
1621
+ break if _tmp
1622
+ self.pos = _save
1653
1623
 
1654
- break if _tmp
1655
- self.pos = _save
1656
- _tmp = apply(:_curly_block)
1657
- break if _tmp
1658
- self.pos = _save
1624
+ _save9 = self.pos
1625
+ while true # sequence
1626
+ _tmp = match_string("@<")
1627
+ unless _tmp
1628
+ self.pos = _save9
1629
+ break
1630
+ end
1631
+ _tmp = apply(:__hyphen_)
1632
+ unless _tmp
1633
+ self.pos = _save9
1634
+ break
1635
+ end
1636
+ _tmp = apply(:_expression)
1637
+ o = @result
1638
+ unless _tmp
1639
+ self.pos = _save9
1640
+ break
1641
+ end
1642
+ _tmp = apply(:__hyphen_)
1643
+ unless _tmp
1644
+ self.pos = _save9
1645
+ break
1646
+ end
1647
+ _tmp = match_string(">")
1648
+ unless _tmp
1649
+ self.pos = _save9
1650
+ break
1651
+ end
1652
+ @result = begin; @g.bounds(o) ; end
1653
+ _tmp = true
1654
+ unless _tmp
1655
+ self.pos = _save9
1656
+ end
1657
+ break
1658
+ end # end sequence
1659
1659
 
1660
- _save10 = self.pos
1661
- while true # sequence
1662
- _tmp = match_string("~")
1663
- unless _tmp
1664
- self.pos = _save10
1665
- break
1666
- end
1667
- _tmp = apply(:_method)
1668
- m = @result
1669
- unless _tmp
1670
- self.pos = _save10
1671
- break
1672
- end
1673
- _text_start = self.pos
1674
- _save11 = self.pos
1675
- _tmp = apply(:_nested_paren)
1676
- unless _tmp
1677
- _tmp = true
1678
- self.pos = _save11
1679
- end
1680
- if _tmp
1681
- text = get_text(_text_start)
1682
- end
1683
- unless _tmp
1684
- self.pos = _save10
1685
- break
1686
- end
1687
- @result = begin; @g.action("#{m}#{text}") ; end
1688
- _tmp = true
1689
- unless _tmp
1690
- self.pos = _save10
1691
- end
1692
- break
1693
- end # end sequence
1660
+ break if _tmp
1661
+ self.pos = _save
1694
1662
 
1695
- break if _tmp
1696
- self.pos = _save
1663
+ _save10 = self.pos
1664
+ while true # sequence
1665
+ _tmp = match_string("<")
1666
+ unless _tmp
1667
+ self.pos = _save10
1668
+ break
1669
+ end
1670
+ _tmp = apply(:__hyphen_)
1671
+ unless _tmp
1672
+ self.pos = _save10
1673
+ break
1674
+ end
1675
+ _tmp = apply(:_expression)
1676
+ o = @result
1677
+ unless _tmp
1678
+ self.pos = _save10
1679
+ break
1680
+ end
1681
+ _tmp = apply(:__hyphen_)
1682
+ unless _tmp
1683
+ self.pos = _save10
1684
+ break
1685
+ end
1686
+ _tmp = match_string(">")
1687
+ unless _tmp
1688
+ self.pos = _save10
1689
+ break
1690
+ end
1691
+ @result = begin; @g.collect(o) ; end
1692
+ _tmp = true
1693
+ unless _tmp
1694
+ self.pos = _save10
1695
+ end
1696
+ break
1697
+ end # end sequence
1697
1698
 
1698
- _save12 = self.pos
1699
- while true # sequence
1700
- _tmp = match_string(".")
1701
- unless _tmp
1702
- self.pos = _save12
1703
- break
1704
- end
1705
- @result = begin; @g.dot ; end
1706
- _tmp = true
1707
- unless _tmp
1708
- self.pos = _save12
1709
- end
1710
- break
1711
- end # end sequence
1699
+ break if _tmp
1700
+ self.pos = _save
1701
+ _tmp = apply(:_curly_block)
1702
+ break if _tmp
1703
+ self.pos = _save
1712
1704
 
1713
- break if _tmp
1714
- self.pos = _save
1705
+ _save11 = self.pos
1706
+ while true # sequence
1707
+ _tmp = match_string("~")
1708
+ unless _tmp
1709
+ self.pos = _save11
1710
+ break
1711
+ end
1712
+ _tmp = apply(:_method)
1713
+ m = @result
1714
+ unless _tmp
1715
+ self.pos = _save11
1716
+ break
1717
+ end
1718
+ _text_start = self.pos
1719
+ _save12 = self.pos
1720
+ _tmp = apply(:_nested_paren)
1721
+ unless _tmp
1722
+ _tmp = true
1723
+ self.pos = _save12
1724
+ end
1725
+ if _tmp
1726
+ text = get_text(_text_start)
1727
+ end
1728
+ unless _tmp
1729
+ self.pos = _save11
1730
+ break
1731
+ end
1732
+ @result = begin; @g.action("#{m}#{text}") ; end
1733
+ _tmp = true
1734
+ unless _tmp
1735
+ self.pos = _save11
1736
+ end
1737
+ break
1738
+ end # end sequence
1715
1739
 
1716
- _save13 = self.pos
1717
- while true # sequence
1718
- _tmp = match_string("@")
1719
- unless _tmp
1720
- self.pos = _save13
1721
- break
1722
- end
1723
- _tmp = apply(:_var)
1724
- name = @result
1725
- unless _tmp
1726
- self.pos = _save13
1727
- break
1728
- end
1729
- _save14 = self.pos
1740
+ break if _tmp
1741
+ self.pos = _save
1730
1742
 
1731
- _save15 = self.pos
1732
- while true # sequence
1733
- _tmp = apply(:__hyphen_)
1734
- unless _tmp
1735
- self.pos = _save15
1736
- break
1737
- end
1738
- _tmp = match_string("=")
1739
- unless _tmp
1740
- self.pos = _save15
1741
- end
1742
- break
1743
- end # end sequence
1743
+ _save13 = self.pos
1744
+ while true # sequence
1745
+ _tmp = match_string(".")
1746
+ unless _tmp
1747
+ self.pos = _save13
1748
+ break
1749
+ end
1750
+ @result = begin; @g.dot ; end
1751
+ _tmp = true
1752
+ unless _tmp
1753
+ self.pos = _save13
1754
+ end
1755
+ break
1756
+ end # end sequence
1744
1757
 
1745
- _tmp = _tmp ? nil : true
1746
- self.pos = _save14
1747
- unless _tmp
1748
- self.pos = _save13
1749
- break
1750
- end
1751
- @result = begin; @g.invoke(name) ; end
1752
- _tmp = true
1753
- unless _tmp
1754
- self.pos = _save13
1755
- end
1756
- break
1757
- end # end sequence
1758
+ break if _tmp
1759
+ self.pos = _save
1758
1760
 
1759
- break if _tmp
1760
- self.pos = _save
1761
+ _save14 = self.pos
1762
+ while true # sequence
1763
+ _tmp = match_string("@")
1764
+ unless _tmp
1765
+ self.pos = _save14
1766
+ break
1767
+ end
1768
+ _tmp = apply(:_var)
1769
+ name = @result
1770
+ unless _tmp
1771
+ self.pos = _save14
1772
+ break
1773
+ end
1774
+ _save15 = self.pos
1775
+
1776
+ _save16 = self.pos
1777
+ while true # sequence
1778
+ _tmp = apply(:__hyphen_)
1779
+ unless _tmp
1780
+ self.pos = _save16
1781
+ break
1782
+ end
1783
+ _tmp = match_string("=")
1784
+ unless _tmp
1785
+ self.pos = _save16
1786
+ end
1787
+ break
1788
+ end # end sequence
1789
+
1790
+ _tmp = _tmp ? nil : true
1791
+ self.pos = _save15
1792
+ unless _tmp
1793
+ self.pos = _save14
1794
+ break
1795
+ end
1796
+ @result = begin; @g.invoke(name) ; end
1797
+ _tmp = true
1798
+ unless _tmp
1799
+ self.pos = _save14
1800
+ end
1801
+ break
1802
+ end # end sequence
1761
1803
 
1762
- _save16 = self.pos
1763
- while true # sequence
1764
- _tmp = match_string("^")
1765
- unless _tmp
1766
- self.pos = _save16
1767
- break
1768
- end
1769
- _tmp = apply(:_var)
1770
- name = @result
1771
- unless _tmp
1772
- self.pos = _save16
1773
- break
1774
- end
1775
- _text_start = self.pos
1776
- _save17 = self.pos
1777
- _tmp = apply(:_nested_paren)
1778
- unless _tmp
1779
- _tmp = true
1780
- self.pos = _save17
1781
- end
1782
- if _tmp
1783
- text = get_text(_text_start)
1784
- end
1785
- unless _tmp
1786
- self.pos = _save16
1787
- break
1788
- end
1789
- @result = begin; @g.foreign_invoke("parent", name, text) ; end
1790
- _tmp = true
1791
- unless _tmp
1792
- self.pos = _save16
1793
- end
1794
- break
1795
- end # end sequence
1804
+ break if _tmp
1805
+ self.pos = _save
1796
1806
 
1797
- break if _tmp
1798
- self.pos = _save
1807
+ _save17 = self.pos
1808
+ while true # sequence
1809
+ _tmp = match_string("^")
1810
+ unless _tmp
1811
+ self.pos = _save17
1812
+ break
1813
+ end
1814
+ _tmp = apply(:_var)
1815
+ name = @result
1816
+ unless _tmp
1817
+ self.pos = _save17
1818
+ break
1819
+ end
1820
+ _text_start = self.pos
1821
+ _save18 = self.pos
1822
+ _tmp = apply(:_nested_paren)
1823
+ unless _tmp
1824
+ _tmp = true
1825
+ self.pos = _save18
1826
+ end
1827
+ if _tmp
1828
+ text = get_text(_text_start)
1829
+ end
1830
+ unless _tmp
1831
+ self.pos = _save17
1832
+ break
1833
+ end
1834
+ @result = begin; @g.foreign_invoke("parent", name, text) ; end
1835
+ _tmp = true
1836
+ unless _tmp
1837
+ self.pos = _save17
1838
+ end
1839
+ break
1840
+ end # end sequence
1799
1841
 
1800
- _save18 = self.pos
1801
- while true # sequence
1802
- _tmp = match_string("%")
1803
- unless _tmp
1804
- self.pos = _save18
1805
- break
1806
- end
1807
- _tmp = apply(:_var)
1808
- gram = @result
1809
- unless _tmp
1810
- self.pos = _save18
1811
- break
1812
- end
1813
- _tmp = match_string(".")
1814
- unless _tmp
1815
- self.pos = _save18
1816
- break
1817
- end
1818
- _tmp = apply(:_var)
1819
- name = @result
1820
- unless _tmp
1821
- self.pos = _save18
1822
- break
1823
- end
1824
- _text_start = self.pos
1825
- _save19 = self.pos
1826
- _tmp = apply(:_nested_paren)
1827
- unless _tmp
1828
- _tmp = true
1829
- self.pos = _save19
1830
- end
1831
- if _tmp
1832
- text = get_text(_text_start)
1833
- end
1834
- unless _tmp
1835
- self.pos = _save18
1836
- break
1837
- end
1838
- @result = begin; @g.foreign_invoke(gram, name, text) ; end
1839
- _tmp = true
1840
- unless _tmp
1841
- self.pos = _save18
1842
- end
1843
- break
1844
- end # end sequence
1842
+ break if _tmp
1843
+ self.pos = _save
1845
1844
 
1846
- break if _tmp
1847
- self.pos = _save
1845
+ _save19 = self.pos
1846
+ while true # sequence
1847
+ _tmp = match_string("%")
1848
+ unless _tmp
1849
+ self.pos = _save19
1850
+ break
1851
+ end
1852
+ _tmp = apply(:_var)
1853
+ gram = @result
1854
+ unless _tmp
1855
+ self.pos = _save19
1856
+ break
1857
+ end
1858
+ _tmp = match_string(".")
1859
+ unless _tmp
1860
+ self.pos = _save19
1861
+ break
1862
+ end
1863
+ _tmp = apply(:_var)
1864
+ name = @result
1865
+ unless _tmp
1866
+ self.pos = _save19
1867
+ break
1868
+ end
1869
+ _text_start = self.pos
1870
+ _save20 = self.pos
1871
+ _tmp = apply(:_nested_paren)
1872
+ unless _tmp
1873
+ _tmp = true
1874
+ self.pos = _save20
1875
+ end
1876
+ if _tmp
1877
+ text = get_text(_text_start)
1878
+ end
1879
+ unless _tmp
1880
+ self.pos = _save19
1881
+ break
1882
+ end
1883
+ @result = begin; @g.foreign_invoke(gram, name, text) ; end
1884
+ _tmp = true
1885
+ unless _tmp
1886
+ self.pos = _save19
1887
+ end
1888
+ break
1889
+ end # end sequence
1848
1890
 
1849
- _save20 = self.pos
1850
- while true # sequence
1851
- _tmp = apply(:_var)
1852
- name = @result
1853
- unless _tmp
1854
- self.pos = _save20
1855
- break
1856
- end
1857
- _text_start = self.pos
1858
- _save21 = self.pos
1859
- _tmp = apply(:_nested_paren)
1860
- unless _tmp
1861
- _tmp = true
1862
- self.pos = _save21
1863
- end
1864
- if _tmp
1865
- text = get_text(_text_start)
1866
- end
1867
- unless _tmp
1868
- self.pos = _save20
1869
- break
1870
- end
1871
- _save22 = self.pos
1891
+ break if _tmp
1892
+ self.pos = _save
1872
1893
 
1873
- _save23 = self.pos
1874
- while true # sequence
1875
- _tmp = apply(:__hyphen_)
1876
- unless _tmp
1877
- self.pos = _save23
1878
- break
1879
- end
1880
- _tmp = match_string("=")
1881
- unless _tmp
1882
- self.pos = _save23
1883
- end
1884
- break
1885
- end # end sequence
1894
+ _save21 = self.pos
1895
+ while true # sequence
1896
+ _tmp = apply(:_var)
1897
+ name = @result
1898
+ unless _tmp
1899
+ self.pos = _save21
1900
+ break
1901
+ end
1902
+ _text_start = self.pos
1903
+ _save22 = self.pos
1904
+ _tmp = apply(:_nested_paren)
1905
+ unless _tmp
1906
+ _tmp = true
1907
+ self.pos = _save22
1908
+ end
1909
+ if _tmp
1910
+ text = get_text(_text_start)
1911
+ end
1912
+ unless _tmp
1913
+ self.pos = _save21
1914
+ break
1915
+ end
1916
+ _save23 = self.pos
1917
+
1918
+ _save24 = self.pos
1919
+ while true # sequence
1920
+ _tmp = apply(:__hyphen_)
1921
+ unless _tmp
1922
+ self.pos = _save24
1923
+ break
1924
+ end
1925
+ _tmp = match_string("=")
1926
+ unless _tmp
1927
+ self.pos = _save24
1928
+ end
1929
+ break
1930
+ end # end sequence
1931
+
1932
+ _tmp = _tmp ? nil : true
1933
+ self.pos = _save23
1934
+ unless _tmp
1935
+ self.pos = _save21
1936
+ break
1937
+ end
1938
+ @result = begin; text.empty? ? @g.ref(name) : @g.invoke(name, text) ; end
1939
+ _tmp = true
1940
+ unless _tmp
1941
+ self.pos = _save21
1942
+ end
1943
+ break
1944
+ end # end sequence
1886
1945
 
1887
- _tmp = _tmp ? nil : true
1888
- self.pos = _save22
1889
- unless _tmp
1890
- self.pos = _save20
1946
+ break if _tmp
1947
+ self.pos = _save
1948
+ _tmp = apply(:_char_range)
1949
+ break if _tmp
1950
+ self.pos = _save
1951
+ _tmp = apply(:_regexp)
1952
+ break if _tmp
1953
+ self.pos = _save
1954
+ _tmp = apply(:_string)
1955
+ break if _tmp
1956
+ self.pos = _save
1891
1957
  break
1892
- end
1893
- @result = begin; text.empty? ? @g.ref(name) : @g.invoke(name, text) ; end
1894
- _tmp = true
1895
- unless _tmp
1896
- self.pos = _save20
1897
- end
1898
- break
1899
- end # end sequence
1900
-
1901
- break if _tmp
1902
- self.pos = _save
1903
- _tmp = apply(:_char_range)
1904
- break if _tmp
1905
- self.pos = _save
1906
- _tmp = apply(:_regexp)
1907
- break if _tmp
1908
- self.pos = _save
1909
- _tmp = apply(:_string)
1910
- break if _tmp
1911
- self.pos = _save
1912
- break
1913
1958
  end # end choice
1914
1959
 
1915
1960
  set_failed_rule :_value unless _tmp
@@ -1922,28 +1967,28 @@ class KPeg::FormatParser
1922
1967
 
1923
1968
  _save1 = self.pos
1924
1969
  while true # choice
1925
- _tmp = apply(:_space)
1926
- break if _tmp
1927
- self.pos = _save1
1928
- _tmp = apply(:_comment)
1929
- break if _tmp
1930
- self.pos = _save1
1931
- break
1970
+ _tmp = apply(:_space)
1971
+ break if _tmp
1972
+ self.pos = _save1
1973
+ _tmp = apply(:_comment)
1974
+ break if _tmp
1975
+ self.pos = _save1
1976
+ break
1932
1977
  end # end choice
1933
1978
 
1934
1979
  if _tmp
1935
1980
  while true
1936
-
1937
- _save2 = self.pos
1938
- while true # choice
1939
- _tmp = apply(:_space)
1940
- break if _tmp
1941
- self.pos = _save2
1942
- _tmp = apply(:_comment)
1943
- break if _tmp
1944
- self.pos = _save2
1945
- break
1946
- end # end choice
1981
+
1982
+ _save2 = self.pos
1983
+ while true # choice
1984
+ _tmp = apply(:_space)
1985
+ break if _tmp
1986
+ self.pos = _save2
1987
+ _tmp = apply(:_comment)
1988
+ break if _tmp
1989
+ self.pos = _save2
1990
+ break
1991
+ end # end choice
1947
1992
 
1948
1993
  break unless _tmp
1949
1994
  end
@@ -1961,69 +2006,69 @@ class KPeg::FormatParser
1961
2006
  _save = self.pos
1962
2007
  while true # choice
1963
2008
 
1964
- _save1 = self.pos
1965
- while true # sequence
1966
- _tmp = apply(:_values)
1967
- s = @result
1968
- unless _tmp
1969
- self.pos = _save1
1970
- break
1971
- end
1972
- _tmp = apply(:_spaces)
1973
- unless _tmp
1974
- self.pos = _save1
1975
- break
1976
- end
1977
- _tmp = apply(:_value)
1978
- v = @result
1979
- unless _tmp
1980
- self.pos = _save1
1981
- break
1982
- end
1983
- @result = begin; @g.seq(s, v) ; end
1984
- _tmp = true
1985
- unless _tmp
1986
- self.pos = _save1
1987
- end
1988
- break
1989
- end # end sequence
2009
+ _save1 = self.pos
2010
+ while true # sequence
2011
+ _tmp = apply(:_values)
2012
+ s = @result
2013
+ unless _tmp
2014
+ self.pos = _save1
2015
+ break
2016
+ end
2017
+ _tmp = apply(:_spaces)
2018
+ unless _tmp
2019
+ self.pos = _save1
2020
+ break
2021
+ end
2022
+ _tmp = apply(:_value)
2023
+ v = @result
2024
+ unless _tmp
2025
+ self.pos = _save1
2026
+ break
2027
+ end
2028
+ @result = begin; @g.seq(s, v) ; end
2029
+ _tmp = true
2030
+ unless _tmp
2031
+ self.pos = _save1
2032
+ end
2033
+ break
2034
+ end # end sequence
1990
2035
 
1991
- break if _tmp
1992
- self.pos = _save
2036
+ break if _tmp
2037
+ self.pos = _save
1993
2038
 
1994
- _save2 = self.pos
1995
- while true # sequence
1996
- _tmp = apply(:_value)
1997
- l = @result
1998
- unless _tmp
1999
- self.pos = _save2
2000
- break
2001
- end
2002
- _tmp = apply(:_spaces)
2003
- unless _tmp
2004
- self.pos = _save2
2005
- break
2006
- end
2007
- _tmp = apply(:_value)
2008
- r = @result
2009
- unless _tmp
2010
- self.pos = _save2
2011
- break
2012
- end
2013
- @result = begin; @g.seq(l, r) ; end
2014
- _tmp = true
2015
- unless _tmp
2016
- self.pos = _save2
2017
- end
2018
- break
2019
- end # end sequence
2039
+ _save2 = self.pos
2040
+ while true # sequence
2041
+ _tmp = apply(:_value)
2042
+ l = @result
2043
+ unless _tmp
2044
+ self.pos = _save2
2045
+ break
2046
+ end
2047
+ _tmp = apply(:_spaces)
2048
+ unless _tmp
2049
+ self.pos = _save2
2050
+ break
2051
+ end
2052
+ _tmp = apply(:_value)
2053
+ r = @result
2054
+ unless _tmp
2055
+ self.pos = _save2
2056
+ break
2057
+ end
2058
+ @result = begin; @g.seq(l, r) ; end
2059
+ _tmp = true
2060
+ unless _tmp
2061
+ self.pos = _save2
2062
+ end
2063
+ break
2064
+ end # end sequence
2020
2065
 
2021
- break if _tmp
2022
- self.pos = _save
2023
- _tmp = apply(:_value)
2024
- break if _tmp
2025
- self.pos = _save
2026
- break
2066
+ break if _tmp
2067
+ self.pos = _save
2068
+ _tmp = apply(:_value)
2069
+ break if _tmp
2070
+ self.pos = _save
2071
+ break
2027
2072
  end # end choice
2028
2073
 
2029
2074
  set_failed_rule :_values unless _tmp
@@ -2035,33 +2080,33 @@ class KPeg::FormatParser
2035
2080
 
2036
2081
  _save = self.pos
2037
2082
  while true # sequence
2038
- _tmp = apply(:__hyphen_)
2039
- unless _tmp
2040
- self.pos = _save
2041
- break
2042
- end
2043
- _tmp = match_string("|")
2044
- unless _tmp
2045
- self.pos = _save
2046
- break
2047
- end
2048
- _tmp = apply(:__hyphen_)
2049
- unless _tmp
2050
- self.pos = _save
2051
- break
2052
- end
2053
- _tmp = apply(:_values)
2054
- v = @result
2055
- unless _tmp
2056
- self.pos = _save
2083
+ _tmp = apply(:__hyphen_)
2084
+ unless _tmp
2085
+ self.pos = _save
2086
+ break
2087
+ end
2088
+ _tmp = match_string("|")
2089
+ unless _tmp
2090
+ self.pos = _save
2091
+ break
2092
+ end
2093
+ _tmp = apply(:__hyphen_)
2094
+ unless _tmp
2095
+ self.pos = _save
2096
+ break
2097
+ end
2098
+ _tmp = apply(:_values)
2099
+ v = @result
2100
+ unless _tmp
2101
+ self.pos = _save
2102
+ break
2103
+ end
2104
+ @result = begin; v ; end
2105
+ _tmp = true
2106
+ unless _tmp
2107
+ self.pos = _save
2108
+ end
2057
2109
  break
2058
- end
2059
- @result = begin; v ; end
2060
- _tmp = true
2061
- unless _tmp
2062
- self.pos = _save
2063
- end
2064
- break
2065
2110
  end # end sequence
2066
2111
 
2067
2112
  set_failed_rule :_choose_cont unless _tmp
@@ -2074,48 +2119,48 @@ class KPeg::FormatParser
2074
2119
  _save = self.pos
2075
2120
  while true # choice
2076
2121
 
2077
- _save1 = self.pos
2078
- while true # sequence
2079
- _tmp = apply(:_values)
2080
- v = @result
2081
- unless _tmp
2082
- self.pos = _save1
2083
- break
2084
- end
2085
- _save2 = self.pos
2086
- _ary = []
2087
- _tmp = apply(:_choose_cont)
2088
- if _tmp
2089
- _ary << @result
2090
- while true
2122
+ _save1 = self.pos
2123
+ while true # sequence
2124
+ _tmp = apply(:_values)
2125
+ v = @result
2126
+ unless _tmp
2127
+ self.pos = _save1
2128
+ break
2129
+ end
2130
+ _save2 = self.pos
2131
+ _ary = []
2091
2132
  _tmp = apply(:_choose_cont)
2092
- _ary << @result if _tmp
2093
- break unless _tmp
2094
- end
2095
- _tmp = true
2096
- @result = _ary
2097
- else
2098
- self.pos = _save2
2099
- end
2100
- alts = @result
2101
- unless _tmp
2102
- self.pos = _save1
2103
- break
2104
- end
2105
- @result = begin; @g.any(v, *alts) ; end
2106
- _tmp = true
2107
- unless _tmp
2108
- self.pos = _save1
2109
- end
2110
- break
2111
- end # end sequence
2133
+ if _tmp
2134
+ _ary << @result
2135
+ while true
2136
+ _tmp = apply(:_choose_cont)
2137
+ _ary << @result if _tmp
2138
+ break unless _tmp
2139
+ end
2140
+ _tmp = true
2141
+ @result = _ary
2142
+ else
2143
+ self.pos = _save2
2144
+ end
2145
+ alts = @result
2146
+ unless _tmp
2147
+ self.pos = _save1
2148
+ break
2149
+ end
2150
+ @result = begin; @g.any(v, *alts) ; end
2151
+ _tmp = true
2152
+ unless _tmp
2153
+ self.pos = _save1
2154
+ end
2155
+ break
2156
+ end # end sequence
2112
2157
 
2113
- break if _tmp
2114
- self.pos = _save
2115
- _tmp = apply(:_values)
2116
- break if _tmp
2117
- self.pos = _save
2118
- break
2158
+ break if _tmp
2159
+ self.pos = _save
2160
+ _tmp = apply(:_values)
2161
+ break if _tmp
2162
+ self.pos = _save
2163
+ break
2119
2164
  end # end choice
2120
2165
 
2121
2166
  set_failed_rule :_expression unless _tmp
@@ -2128,75 +2173,75 @@ class KPeg::FormatParser
2128
2173
  _save = self.pos
2129
2174
  while true # choice
2130
2175
 
2131
- _save1 = self.pos
2132
- while true # sequence
2133
- _tmp = apply(:_args)
2134
- a = @result
2135
- unless _tmp
2136
- self.pos = _save1
2137
- break
2138
- end
2139
- _tmp = match_string(",")
2140
- unless _tmp
2141
- self.pos = _save1
2142
- break
2143
- end
2144
- _tmp = apply(:__hyphen_)
2145
- unless _tmp
2146
- self.pos = _save1
2147
- break
2148
- end
2149
- _tmp = apply(:_var)
2150
- n = @result
2151
- unless _tmp
2152
- self.pos = _save1
2153
- break
2154
- end
2155
- _tmp = apply(:__hyphen_)
2156
- unless _tmp
2157
- self.pos = _save1
2158
- break
2159
- end
2160
- @result = begin; a + [n] ; end
2161
- _tmp = true
2162
- unless _tmp
2163
- self.pos = _save1
2164
- end
2165
- break
2166
- end # end sequence
2176
+ _save1 = self.pos
2177
+ while true # sequence
2178
+ _tmp = apply(:_args)
2179
+ a = @result
2180
+ unless _tmp
2181
+ self.pos = _save1
2182
+ break
2183
+ end
2184
+ _tmp = match_string(",")
2185
+ unless _tmp
2186
+ self.pos = _save1
2187
+ break
2188
+ end
2189
+ _tmp = apply(:__hyphen_)
2190
+ unless _tmp
2191
+ self.pos = _save1
2192
+ break
2193
+ end
2194
+ _tmp = apply(:_var)
2195
+ n = @result
2196
+ unless _tmp
2197
+ self.pos = _save1
2198
+ break
2199
+ end
2200
+ _tmp = apply(:__hyphen_)
2201
+ unless _tmp
2202
+ self.pos = _save1
2203
+ break
2204
+ end
2205
+ @result = begin; a + [n] ; end
2206
+ _tmp = true
2207
+ unless _tmp
2208
+ self.pos = _save1
2209
+ end
2210
+ break
2211
+ end # end sequence
2167
2212
 
2168
- break if _tmp
2169
- self.pos = _save
2213
+ break if _tmp
2214
+ self.pos = _save
2170
2215
 
2171
- _save2 = self.pos
2172
- while true # sequence
2173
- _tmp = apply(:__hyphen_)
2174
- unless _tmp
2175
- self.pos = _save2
2176
- break
2177
- end
2178
- _tmp = apply(:_var)
2179
- n = @result
2180
- unless _tmp
2181
- self.pos = _save2
2182
- break
2183
- end
2184
- _tmp = apply(:__hyphen_)
2185
- unless _tmp
2186
- self.pos = _save2
2187
- break
2188
- end
2189
- @result = begin; [n] ; end
2190
- _tmp = true
2191
- unless _tmp
2192
- self.pos = _save2
2193
- end
2194
- break
2195
- end # end sequence
2216
+ _save2 = self.pos
2217
+ while true # sequence
2218
+ _tmp = apply(:__hyphen_)
2219
+ unless _tmp
2220
+ self.pos = _save2
2221
+ break
2222
+ end
2223
+ _tmp = apply(:_var)
2224
+ n = @result
2225
+ unless _tmp
2226
+ self.pos = _save2
2227
+ break
2228
+ end
2229
+ _tmp = apply(:__hyphen_)
2230
+ unless _tmp
2231
+ self.pos = _save2
2232
+ break
2233
+ end
2234
+ @result = begin; [n] ; end
2235
+ _tmp = true
2236
+ unless _tmp
2237
+ self.pos = _save2
2238
+ end
2239
+ break
2240
+ end # end sequence
2196
2241
 
2197
- break if _tmp
2198
- self.pos = _save
2199
- break
2242
+ break if _tmp
2243
+ self.pos = _save
2244
+ break
2200
2245
  end # end choice
2201
2246
 
2202
2247
  set_failed_rule :_args unless _tmp
@@ -2209,301 +2254,301 @@ class KPeg::FormatParser
2209
2254
  _save = self.pos
2210
2255
  while true # choice
2211
2256
 
2212
- _save1 = self.pos
2213
- while true # sequence
2214
- _tmp = apply(:__hyphen_)
2215
- unless _tmp
2216
- self.pos = _save1
2217
- break
2218
- end
2219
- _tmp = apply(:_var)
2220
- v = @result
2221
- unless _tmp
2222
- self.pos = _save1
2223
- break
2224
- end
2225
- _tmp = match_string("(")
2226
- unless _tmp
2227
- self.pos = _save1
2228
- break
2229
- end
2230
- _tmp = apply(:_args)
2231
- a = @result
2232
- unless _tmp
2233
- self.pos = _save1
2234
- break
2235
- end
2236
- _tmp = match_string(")")
2237
- unless _tmp
2238
- self.pos = _save1
2239
- break
2240
- end
2241
- _tmp = apply(:__hyphen_)
2242
- unless _tmp
2243
- self.pos = _save1
2244
- break
2245
- end
2246
- _tmp = match_string("=")
2247
- unless _tmp
2248
- self.pos = _save1
2249
- break
2250
- end
2251
- _tmp = apply(:__hyphen_)
2252
- unless _tmp
2253
- self.pos = _save1
2254
- break
2255
- end
2256
- _tmp = apply(:_expression)
2257
- o = @result
2258
- unless _tmp
2259
- self.pos = _save1
2260
- break
2261
- end
2262
- @result = begin; @g.set(v, o, a) ; end
2263
- _tmp = true
2264
- unless _tmp
2265
- self.pos = _save1
2266
- end
2267
- break
2268
- end # end sequence
2269
-
2270
- break if _tmp
2271
- self.pos = _save
2272
-
2273
- _save2 = self.pos
2274
- while true # sequence
2275
- _tmp = apply(:__hyphen_)
2276
- unless _tmp
2277
- self.pos = _save2
2278
- break
2279
- end
2280
- _tmp = apply(:_var)
2281
- v = @result
2282
- unless _tmp
2283
- self.pos = _save2
2284
- break
2285
- end
2286
- _tmp = apply(:__hyphen_)
2287
- unless _tmp
2288
- self.pos = _save2
2289
- break
2290
- end
2291
- _tmp = match_string("=")
2292
- unless _tmp
2293
- self.pos = _save2
2294
- break
2295
- end
2296
- _tmp = apply(:__hyphen_)
2297
- unless _tmp
2298
- self.pos = _save2
2299
- break
2300
- end
2301
- _tmp = apply(:_expression)
2302
- o = @result
2303
- unless _tmp
2304
- self.pos = _save2
2305
- break
2306
- end
2307
- @result = begin; @g.set(v, o) ; end
2308
- _tmp = true
2309
- unless _tmp
2310
- self.pos = _save2
2311
- end
2312
- break
2313
- end # end sequence
2314
-
2315
- break if _tmp
2316
- self.pos = _save
2317
-
2318
- _save3 = self.pos
2319
- while true # sequence
2320
- _tmp = apply(:__hyphen_)
2321
- unless _tmp
2322
- self.pos = _save3
2323
- break
2324
- end
2325
- _tmp = match_string("%")
2326
- unless _tmp
2327
- self.pos = _save3
2328
- break
2329
- end
2330
- _tmp = apply(:_var)
2331
- name = @result
2332
- unless _tmp
2333
- self.pos = _save3
2334
- break
2335
- end
2336
- _tmp = apply(:__hyphen_)
2337
- unless _tmp
2338
- self.pos = _save3
2339
- break
2340
- end
2341
- _tmp = match_string("=")
2342
- unless _tmp
2343
- self.pos = _save3
2344
- break
2345
- end
2346
- _tmp = apply(:__hyphen_)
2347
- unless _tmp
2348
- self.pos = _save3
2349
- break
2350
- end
2351
- _text_start = self.pos
2352
- _tmp = scan(/\A(?-mix:[::A-Za-z0-9_]+)/)
2353
- if _tmp
2354
- text = get_text(_text_start)
2355
- end
2356
- unless _tmp
2357
- self.pos = _save3
2358
- break
2359
- end
2360
- @result = begin; @g.add_foreign_grammar(name, text) ; end
2361
- _tmp = true
2362
- unless _tmp
2363
- self.pos = _save3
2364
- end
2365
- break
2366
- end # end sequence
2257
+ _save1 = self.pos
2258
+ while true # sequence
2259
+ _tmp = apply(:__hyphen_)
2260
+ unless _tmp
2261
+ self.pos = _save1
2262
+ break
2263
+ end
2264
+ _tmp = apply(:_var)
2265
+ v = @result
2266
+ unless _tmp
2267
+ self.pos = _save1
2268
+ break
2269
+ end
2270
+ _tmp = match_string("(")
2271
+ unless _tmp
2272
+ self.pos = _save1
2273
+ break
2274
+ end
2275
+ _tmp = apply(:_args)
2276
+ a = @result
2277
+ unless _tmp
2278
+ self.pos = _save1
2279
+ break
2280
+ end
2281
+ _tmp = match_string(")")
2282
+ unless _tmp
2283
+ self.pos = _save1
2284
+ break
2285
+ end
2286
+ _tmp = apply(:__hyphen_)
2287
+ unless _tmp
2288
+ self.pos = _save1
2289
+ break
2290
+ end
2291
+ _tmp = match_string("=")
2292
+ unless _tmp
2293
+ self.pos = _save1
2294
+ break
2295
+ end
2296
+ _tmp = apply(:__hyphen_)
2297
+ unless _tmp
2298
+ self.pos = _save1
2299
+ break
2300
+ end
2301
+ _tmp = apply(:_expression)
2302
+ o = @result
2303
+ unless _tmp
2304
+ self.pos = _save1
2305
+ break
2306
+ end
2307
+ @result = begin; @g.set(v, o, a) ; end
2308
+ _tmp = true
2309
+ unless _tmp
2310
+ self.pos = _save1
2311
+ end
2312
+ break
2313
+ end # end sequence
2367
2314
 
2368
- break if _tmp
2369
- self.pos = _save
2315
+ break if _tmp
2316
+ self.pos = _save
2370
2317
 
2371
- _save4 = self.pos
2372
- while true # sequence
2373
- _tmp = apply(:__hyphen_)
2374
- unless _tmp
2375
- self.pos = _save4
2376
- break
2377
- end
2378
- _tmp = match_string("%%")
2379
- unless _tmp
2380
- self.pos = _save4
2381
- break
2382
- end
2383
- _tmp = apply(:__hyphen_)
2384
- unless _tmp
2385
- self.pos = _save4
2386
- break
2387
- end
2388
- _tmp = apply(:_curly)
2389
- act = @result
2390
- unless _tmp
2391
- self.pos = _save4
2392
- break
2393
- end
2394
- @result = begin; @g.add_setup act ; end
2395
- _tmp = true
2396
- unless _tmp
2397
- self.pos = _save4
2398
- end
2399
- break
2400
- end # end sequence
2318
+ _save2 = self.pos
2319
+ while true # sequence
2320
+ _tmp = apply(:__hyphen_)
2321
+ unless _tmp
2322
+ self.pos = _save2
2323
+ break
2324
+ end
2325
+ _tmp = apply(:_var)
2326
+ v = @result
2327
+ unless _tmp
2328
+ self.pos = _save2
2329
+ break
2330
+ end
2331
+ _tmp = apply(:__hyphen_)
2332
+ unless _tmp
2333
+ self.pos = _save2
2334
+ break
2335
+ end
2336
+ _tmp = match_string("=")
2337
+ unless _tmp
2338
+ self.pos = _save2
2339
+ break
2340
+ end
2341
+ _tmp = apply(:__hyphen_)
2342
+ unless _tmp
2343
+ self.pos = _save2
2344
+ break
2345
+ end
2346
+ _tmp = apply(:_expression)
2347
+ o = @result
2348
+ unless _tmp
2349
+ self.pos = _save2
2350
+ break
2351
+ end
2352
+ @result = begin; @g.set(v, o) ; end
2353
+ _tmp = true
2354
+ unless _tmp
2355
+ self.pos = _save2
2356
+ end
2357
+ break
2358
+ end # end sequence
2401
2359
 
2402
- break if _tmp
2403
- self.pos = _save
2360
+ break if _tmp
2361
+ self.pos = _save
2404
2362
 
2405
- _save5 = self.pos
2406
- while true # sequence
2407
- _tmp = apply(:__hyphen_)
2408
- unless _tmp
2409
- self.pos = _save5
2410
- break
2411
- end
2412
- _tmp = match_string("%%")
2413
- unless _tmp
2414
- self.pos = _save5
2415
- break
2416
- end
2417
- _tmp = apply(:__hyphen_)
2418
- unless _tmp
2419
- self.pos = _save5
2420
- break
2421
- end
2422
- _tmp = apply(:_var)
2423
- name = @result
2424
- unless _tmp
2425
- self.pos = _save5
2426
- break
2427
- end
2428
- _tmp = apply(:__hyphen_)
2429
- unless _tmp
2430
- self.pos = _save5
2431
- break
2432
- end
2433
- _tmp = match_string("=")
2434
- unless _tmp
2435
- self.pos = _save5
2436
- break
2437
- end
2438
- _tmp = apply(:__hyphen_)
2439
- unless _tmp
2440
- self.pos = _save5
2441
- break
2442
- end
2443
- _text_start = self.pos
2444
- _save6 = self.pos
2363
+ _save3 = self.pos
2364
+ while true # sequence
2365
+ _tmp = apply(:__hyphen_)
2366
+ unless _tmp
2367
+ self.pos = _save3
2368
+ break
2369
+ end
2370
+ _tmp = match_string("%")
2371
+ unless _tmp
2372
+ self.pos = _save3
2373
+ break
2374
+ end
2375
+ _tmp = apply(:_var)
2376
+ name = @result
2377
+ unless _tmp
2378
+ self.pos = _save3
2379
+ break
2380
+ end
2381
+ _tmp = apply(:__hyphen_)
2382
+ unless _tmp
2383
+ self.pos = _save3
2384
+ break
2385
+ end
2386
+ _tmp = match_string("=")
2387
+ unless _tmp
2388
+ self.pos = _save3
2389
+ break
2390
+ end
2391
+ _tmp = apply(:__hyphen_)
2392
+ unless _tmp
2393
+ self.pos = _save3
2394
+ break
2395
+ end
2396
+ _text_start = self.pos
2397
+ _tmp = scan(/\A(?-mix:[::A-Za-z0-9_]+)/)
2398
+ if _tmp
2399
+ text = get_text(_text_start)
2400
+ end
2401
+ unless _tmp
2402
+ self.pos = _save3
2403
+ break
2404
+ end
2405
+ @result = begin; @g.add_foreign_grammar(name, text) ; end
2406
+ _tmp = true
2407
+ unless _tmp
2408
+ self.pos = _save3
2409
+ end
2410
+ break
2411
+ end # end sequence
2445
2412
 
2446
- _save7 = self.pos
2447
- while true # sequence
2448
- _save8 = self.pos
2449
- _tmp = match_string("\n")
2450
- _tmp = _tmp ? nil : true
2451
- self.pos = _save8
2452
- unless _tmp
2453
- self.pos = _save7
2454
- break
2455
- end
2456
- _tmp = get_byte
2457
- unless _tmp
2458
- self.pos = _save7
2459
- end
2460
- break
2461
- end # end sequence
2413
+ break if _tmp
2414
+ self.pos = _save
2462
2415
 
2463
- if _tmp
2464
- while true
2465
-
2466
- _save9 = self.pos
2467
- while true # sequence
2468
- _save10 = self.pos
2469
- _tmp = match_string("\n")
2470
- _tmp = _tmp ? nil : true
2471
- self.pos = _save10
2472
- unless _tmp
2473
- self.pos = _save9
2474
- break
2475
- end
2476
- _tmp = get_byte
2477
- unless _tmp
2478
- self.pos = _save9
2479
- end
2480
- break
2481
- end # end sequence
2416
+ _save4 = self.pos
2417
+ while true # sequence
2418
+ _tmp = apply(:__hyphen_)
2419
+ unless _tmp
2420
+ self.pos = _save4
2421
+ break
2422
+ end
2423
+ _tmp = match_string("%%")
2424
+ unless _tmp
2425
+ self.pos = _save4
2426
+ break
2427
+ end
2428
+ _tmp = apply(:__hyphen_)
2429
+ unless _tmp
2430
+ self.pos = _save4
2431
+ break
2432
+ end
2433
+ _tmp = apply(:_curly)
2434
+ act = @result
2435
+ unless _tmp
2436
+ self.pos = _save4
2437
+ break
2438
+ end
2439
+ @result = begin; @g.add_setup act ; end
2440
+ _tmp = true
2441
+ unless _tmp
2442
+ self.pos = _save4
2443
+ end
2444
+ break
2445
+ end # end sequence
2482
2446
 
2483
- break unless _tmp
2484
- end
2485
- _tmp = true
2486
- else
2487
- self.pos = _save6
2488
- end
2489
- if _tmp
2490
- text = get_text(_text_start)
2491
- end
2492
- unless _tmp
2493
- self.pos = _save5
2494
- break
2495
- end
2496
- @result = begin; @g.set_variable(name, text) ; end
2497
- _tmp = true
2498
- unless _tmp
2499
- self.pos = _save5
2500
- end
2501
- break
2502
- end # end sequence
2447
+ break if _tmp
2448
+ self.pos = _save
2503
2449
 
2504
- break if _tmp
2505
- self.pos = _save
2506
- break
2450
+ _save5 = self.pos
2451
+ while true # sequence
2452
+ _tmp = apply(:__hyphen_)
2453
+ unless _tmp
2454
+ self.pos = _save5
2455
+ break
2456
+ end
2457
+ _tmp = match_string("%%")
2458
+ unless _tmp
2459
+ self.pos = _save5
2460
+ break
2461
+ end
2462
+ _tmp = apply(:__hyphen_)
2463
+ unless _tmp
2464
+ self.pos = _save5
2465
+ break
2466
+ end
2467
+ _tmp = apply(:_var)
2468
+ name = @result
2469
+ unless _tmp
2470
+ self.pos = _save5
2471
+ break
2472
+ end
2473
+ _tmp = apply(:__hyphen_)
2474
+ unless _tmp
2475
+ self.pos = _save5
2476
+ break
2477
+ end
2478
+ _tmp = match_string("=")
2479
+ unless _tmp
2480
+ self.pos = _save5
2481
+ break
2482
+ end
2483
+ _tmp = apply(:__hyphen_)
2484
+ unless _tmp
2485
+ self.pos = _save5
2486
+ break
2487
+ end
2488
+ _text_start = self.pos
2489
+ _save6 = self.pos
2490
+
2491
+ _save7 = self.pos
2492
+ while true # sequence
2493
+ _save8 = self.pos
2494
+ _tmp = match_string("\n")
2495
+ _tmp = _tmp ? nil : true
2496
+ self.pos = _save8
2497
+ unless _tmp
2498
+ self.pos = _save7
2499
+ break
2500
+ end
2501
+ _tmp = get_byte
2502
+ unless _tmp
2503
+ self.pos = _save7
2504
+ end
2505
+ break
2506
+ end # end sequence
2507
+
2508
+ if _tmp
2509
+ while true
2510
+
2511
+ _save9 = self.pos
2512
+ while true # sequence
2513
+ _save10 = self.pos
2514
+ _tmp = match_string("\n")
2515
+ _tmp = _tmp ? nil : true
2516
+ self.pos = _save10
2517
+ unless _tmp
2518
+ self.pos = _save9
2519
+ break
2520
+ end
2521
+ _tmp = get_byte
2522
+ unless _tmp
2523
+ self.pos = _save9
2524
+ end
2525
+ break
2526
+ end # end sequence
2527
+
2528
+ break unless _tmp
2529
+ end
2530
+ _tmp = true
2531
+ else
2532
+ self.pos = _save6
2533
+ end
2534
+ if _tmp
2535
+ text = get_text(_text_start)
2536
+ end
2537
+ unless _tmp
2538
+ self.pos = _save5
2539
+ break
2540
+ end
2541
+ @result = begin; @g.set_variable(name, text) ; end
2542
+ _tmp = true
2543
+ unless _tmp
2544
+ self.pos = _save5
2545
+ end
2546
+ break
2547
+ end # end sequence
2548
+
2549
+ break if _tmp
2550
+ self.pos = _save
2551
+ break
2507
2552
  end # end choice
2508
2553
 
2509
2554
  set_failed_rule :_statement unless _tmp
@@ -2515,35 +2560,35 @@ class KPeg::FormatParser
2515
2560
 
2516
2561
  _save = self.pos
2517
2562
  while true # sequence
2518
- _tmp = apply(:_statement)
2519
- unless _tmp
2520
- self.pos = _save
2521
- break
2522
- end
2523
- _save1 = self.pos
2563
+ _tmp = apply(:_statement)
2564
+ unless _tmp
2565
+ self.pos = _save
2566
+ break
2567
+ end
2568
+ _save1 = self.pos
2569
+
2570
+ _save2 = self.pos
2571
+ while true # sequence
2572
+ _tmp = apply(:__hyphen_)
2573
+ unless _tmp
2574
+ self.pos = _save2
2575
+ break
2576
+ end
2577
+ _tmp = apply(:_statements)
2578
+ unless _tmp
2579
+ self.pos = _save2
2580
+ end
2581
+ break
2582
+ end # end sequence
2524
2583
 
2525
- _save2 = self.pos
2526
- while true # sequence
2527
- _tmp = apply(:__hyphen_)
2528
- unless _tmp
2529
- self.pos = _save2
2584
+ unless _tmp
2585
+ _tmp = true
2586
+ self.pos = _save1
2587
+ end
2588
+ unless _tmp
2589
+ self.pos = _save
2590
+ end
2530
2591
  break
2531
- end
2532
- _tmp = apply(:_statements)
2533
- unless _tmp
2534
- self.pos = _save2
2535
- end
2536
- break
2537
- end # end sequence
2538
-
2539
- unless _tmp
2540
- _tmp = true
2541
- self.pos = _save1
2542
- end
2543
- unless _tmp
2544
- self.pos = _save
2545
- end
2546
- break
2547
2592
  end # end sequence
2548
2593
 
2549
2594
  set_failed_rule :_statements unless _tmp
@@ -2565,31 +2610,31 @@ class KPeg::FormatParser
2565
2610
 
2566
2611
  _save = self.pos
2567
2612
  while true # sequence
2568
- _tmp = apply(:_statements)
2569
- unless _tmp
2570
- self.pos = _save
2571
- break
2572
- end
2573
- _tmp = apply(:__hyphen_)
2574
- unless _tmp
2575
- self.pos = _save
2576
- break
2577
- end
2578
- _save1 = self.pos
2579
- _tmp = apply(:_eof_comment)
2580
- unless _tmp
2581
- _tmp = true
2582
- self.pos = _save1
2583
- end
2584
- unless _tmp
2585
- self.pos = _save
2613
+ _tmp = apply(:_statements)
2614
+ unless _tmp
2615
+ self.pos = _save
2616
+ break
2617
+ end
2618
+ _tmp = apply(:__hyphen_)
2619
+ unless _tmp
2620
+ self.pos = _save
2621
+ break
2622
+ end
2623
+ _save1 = self.pos
2624
+ _tmp = apply(:_eof_comment)
2625
+ unless _tmp
2626
+ _tmp = true
2627
+ self.pos = _save1
2628
+ end
2629
+ unless _tmp
2630
+ self.pos = _save
2631
+ break
2632
+ end
2633
+ _tmp = apply(:_eof)
2634
+ unless _tmp
2635
+ self.pos = _save
2636
+ end
2586
2637
  break
2587
- end
2588
- _tmp = apply(:_eof)
2589
- unless _tmp
2590
- self.pos = _save
2591
- end
2592
- break
2593
2638
  end # end sequence
2594
2639
 
2595
2640
  set_failed_rule :_root unless _tmp
@@ -2601,21 +2646,21 @@ class KPeg::FormatParser
2601
2646
 
2602
2647
  _save = self.pos
2603
2648
  while true # sequence
2604
- _text_start = self.pos
2605
- _tmp = scan(/\A(?-mix:[A-Z][A-Za-z0-9_]*)/)
2606
- if _tmp
2607
- text = get_text(_text_start)
2608
- end
2609
- unless _tmp
2610
- self.pos = _save
2649
+ _text_start = self.pos
2650
+ _tmp = scan(/\A(?-mix:[A-Z][A-Za-z0-9_]*)/)
2651
+ if _tmp
2652
+ text = get_text(_text_start)
2653
+ end
2654
+ unless _tmp
2655
+ self.pos = _save
2656
+ break
2657
+ end
2658
+ @result = begin; text ; end
2659
+ _tmp = true
2660
+ unless _tmp
2661
+ self.pos = _save
2662
+ end
2611
2663
  break
2612
- end
2613
- @result = begin; text ; end
2614
- _tmp = true
2615
- unless _tmp
2616
- self.pos = _save
2617
- end
2618
- break
2619
2664
  end # end sequence
2620
2665
 
2621
2666
  set_failed_rule :_ast_constant unless _tmp
@@ -2627,21 +2672,21 @@ class KPeg::FormatParser
2627
2672
 
2628
2673
  _save = self.pos
2629
2674
  while true # sequence
2630
- _text_start = self.pos
2631
- _tmp = scan(/\A(?-mix:[A-Za-z_][A-Za-z0-9_]*)/)
2632
- if _tmp
2633
- text = get_text(_text_start)
2634
- end
2635
- unless _tmp
2636
- self.pos = _save
2675
+ _text_start = self.pos
2676
+ _tmp = scan(/\A(?-mix:[A-Za-z_][A-Za-z0-9_]*)/)
2677
+ if _tmp
2678
+ text = get_text(_text_start)
2679
+ end
2680
+ unless _tmp
2681
+ self.pos = _save
2682
+ break
2683
+ end
2684
+ @result = begin; text ; end
2685
+ _tmp = true
2686
+ unless _tmp
2687
+ self.pos = _save
2688
+ end
2637
2689
  break
2638
- end
2639
- @result = begin; text ; end
2640
- _tmp = true
2641
- unless _tmp
2642
- self.pos = _save
2643
- end
2644
- break
2645
2690
  end # end sequence
2646
2691
 
2647
2692
  set_failed_rule :_ast_word unless _tmp
@@ -2652,18 +2697,18 @@ class KPeg::FormatParser
2652
2697
  def _ast_sp
2653
2698
  while true
2654
2699
 
2655
- _save1 = self.pos
2656
- while true # choice
2657
- _tmp = match_string(" ")
2658
- break if _tmp
2659
- self.pos = _save1
2660
- _tmp = match_string("\t")
2661
- break if _tmp
2662
- self.pos = _save1
2663
- break
2664
- end # end choice
2700
+ _save1 = self.pos
2701
+ while true # choice
2702
+ _tmp = match_string(" ")
2703
+ break if _tmp
2704
+ self.pos = _save1
2705
+ _tmp = match_string("\t")
2706
+ break if _tmp
2707
+ self.pos = _save1
2708
+ break
2709
+ end # end choice
2665
2710
 
2666
- break unless _tmp
2711
+ break unless _tmp
2667
2712
  end
2668
2713
  _tmp = true
2669
2714
  set_failed_rule :_ast_sp unless _tmp
@@ -2676,65 +2721,65 @@ class KPeg::FormatParser
2676
2721
  _save = self.pos
2677
2722
  while true # choice
2678
2723
 
2679
- _save1 = self.pos
2680
- while true # sequence
2681
- _tmp = apply(:_ast_words)
2682
- r = @result
2683
- unless _tmp
2684
- self.pos = _save1
2685
- break
2686
- end
2687
- _tmp = apply(:_ast_sp)
2688
- unless _tmp
2689
- self.pos = _save1
2690
- break
2691
- end
2692
- _tmp = match_string(",")
2693
- unless _tmp
2694
- self.pos = _save1
2695
- break
2696
- end
2697
- _tmp = apply(:_ast_sp)
2698
- unless _tmp
2699
- self.pos = _save1
2700
- break
2701
- end
2702
- _tmp = apply(:_ast_word)
2703
- w = @result
2704
- unless _tmp
2705
- self.pos = _save1
2706
- break
2707
- end
2708
- @result = begin; r + [w] ; end
2709
- _tmp = true
2710
- unless _tmp
2711
- self.pos = _save1
2712
- end
2713
- break
2714
- end # end sequence
2724
+ _save1 = self.pos
2725
+ while true # sequence
2726
+ _tmp = apply(:_ast_words)
2727
+ r = @result
2728
+ unless _tmp
2729
+ self.pos = _save1
2730
+ break
2731
+ end
2732
+ _tmp = apply(:_ast_sp)
2733
+ unless _tmp
2734
+ self.pos = _save1
2735
+ break
2736
+ end
2737
+ _tmp = match_string(",")
2738
+ unless _tmp
2739
+ self.pos = _save1
2740
+ break
2741
+ end
2742
+ _tmp = apply(:_ast_sp)
2743
+ unless _tmp
2744
+ self.pos = _save1
2745
+ break
2746
+ end
2747
+ _tmp = apply(:_ast_word)
2748
+ w = @result
2749
+ unless _tmp
2750
+ self.pos = _save1
2751
+ break
2752
+ end
2753
+ @result = begin; r + [w] ; end
2754
+ _tmp = true
2755
+ unless _tmp
2756
+ self.pos = _save1
2757
+ end
2758
+ break
2759
+ end # end sequence
2715
2760
 
2716
- break if _tmp
2717
- self.pos = _save
2761
+ break if _tmp
2762
+ self.pos = _save
2718
2763
 
2719
- _save2 = self.pos
2720
- while true # sequence
2721
- _tmp = apply(:_ast_word)
2722
- w = @result
2723
- unless _tmp
2724
- self.pos = _save2
2725
- break
2726
- end
2727
- @result = begin; [w] ; end
2728
- _tmp = true
2729
- unless _tmp
2730
- self.pos = _save2
2731
- end
2732
- break
2733
- end # end sequence
2764
+ _save2 = self.pos
2765
+ while true # sequence
2766
+ _tmp = apply(:_ast_word)
2767
+ w = @result
2768
+ unless _tmp
2769
+ self.pos = _save2
2770
+ break
2771
+ end
2772
+ @result = begin; [w] ; end
2773
+ _tmp = true
2774
+ unless _tmp
2775
+ self.pos = _save2
2776
+ end
2777
+ break
2778
+ end # end sequence
2734
2779
 
2735
- break if _tmp
2736
- self.pos = _save
2737
- break
2780
+ break if _tmp
2781
+ self.pos = _save
2782
+ break
2738
2783
  end # end choice
2739
2784
 
2740
2785
  set_failed_rule :_ast_words unless _tmp
@@ -2747,70 +2792,70 @@ class KPeg::FormatParser
2747
2792
  _save = self.pos
2748
2793
  while true # choice
2749
2794
 
2750
- _save1 = self.pos
2751
- while true # sequence
2752
- _tmp = apply(:_ast_constant)
2753
- c = @result
2754
- unless _tmp
2755
- self.pos = _save1
2756
- break
2757
- end
2758
- _tmp = match_string("(")
2759
- unless _tmp
2760
- self.pos = _save1
2761
- break
2762
- end
2763
- _tmp = apply(:_ast_words)
2764
- w = @result
2765
- unless _tmp
2766
- self.pos = _save1
2767
- break
2768
- end
2769
- _tmp = match_string(")")
2770
- unless _tmp
2771
- self.pos = _save1
2772
- break
2773
- end
2774
- @result = begin; [c, w] ; end
2775
- _tmp = true
2776
- unless _tmp
2777
- self.pos = _save1
2778
- end
2779
- break
2780
- end # end sequence
2795
+ _save1 = self.pos
2796
+ while true # sequence
2797
+ _tmp = apply(:_ast_constant)
2798
+ c = @result
2799
+ unless _tmp
2800
+ self.pos = _save1
2801
+ break
2802
+ end
2803
+ _tmp = match_string("(")
2804
+ unless _tmp
2805
+ self.pos = _save1
2806
+ break
2807
+ end
2808
+ _tmp = apply(:_ast_words)
2809
+ w = @result
2810
+ unless _tmp
2811
+ self.pos = _save1
2812
+ break
2813
+ end
2814
+ _tmp = match_string(")")
2815
+ unless _tmp
2816
+ self.pos = _save1
2817
+ break
2818
+ end
2819
+ @result = begin; [c, w] ; end
2820
+ _tmp = true
2821
+ unless _tmp
2822
+ self.pos = _save1
2823
+ end
2824
+ break
2825
+ end # end sequence
2781
2826
 
2782
- break if _tmp
2783
- self.pos = _save
2827
+ break if _tmp
2828
+ self.pos = _save
2784
2829
 
2785
- _save2 = self.pos
2786
- while true # sequence
2787
- _tmp = apply(:_ast_constant)
2788
- c = @result
2789
- unless _tmp
2790
- self.pos = _save2
2791
- break
2792
- end
2793
- _save3 = self.pos
2794
- _tmp = match_string("()")
2795
- unless _tmp
2796
- _tmp = true
2797
- self.pos = _save3
2798
- end
2799
- unless _tmp
2800
- self.pos = _save2
2801
- break
2802
- end
2803
- @result = begin; [c, []] ; end
2804
- _tmp = true
2805
- unless _tmp
2806
- self.pos = _save2
2807
- end
2808
- break
2809
- end # end sequence
2830
+ _save2 = self.pos
2831
+ while true # sequence
2832
+ _tmp = apply(:_ast_constant)
2833
+ c = @result
2834
+ unless _tmp
2835
+ self.pos = _save2
2836
+ break
2837
+ end
2838
+ _save3 = self.pos
2839
+ _tmp = match_string("()")
2840
+ unless _tmp
2841
+ _tmp = true
2842
+ self.pos = _save3
2843
+ end
2844
+ unless _tmp
2845
+ self.pos = _save2
2846
+ break
2847
+ end
2848
+ @result = begin; [c, []] ; end
2849
+ _tmp = true
2850
+ unless _tmp
2851
+ self.pos = _save2
2852
+ end
2853
+ break
2854
+ end # end sequence
2810
2855
 
2811
- break if _tmp
2812
- self.pos = _save
2813
- break
2856
+ break if _tmp
2857
+ self.pos = _save
2858
+ break
2814
2859
  end # end choice
2815
2860
 
2816
2861
  set_failed_rule :_ast_root unless _tmp
@@ -2844,9 +2889,9 @@ class KPeg::FormatParser
2844
2889
  Rules[:_range_elem] = rule_info("range_elem", "< (range_num | kleene) > { text }")
2845
2890
  Rules[:_mult_range] = rule_info("mult_range", "(\"[\" - range_elem:l - \",\" - range_elem:r - \"]\" { [l == \"*\" ? nil : l.to_i, r == \"*\" ? nil : r.to_i] } | \"[\" - range_num:e - \"]\" { [e.to_i, e.to_i] })")
2846
2891
  Rules[:_curly_block] = rule_info("curly_block", "curly")
2847
- Rules[:_curly] = rule_info("curly", "\"{\" < (/[^{}]+/ | curly)* > \"}\" { @g.action(text) }")
2848
- Rules[:_nested_paren] = rule_info("nested_paren", "\"(\" (/[^()]+/ | nested_paren)* \")\"")
2849
- Rules[:_value] = rule_info("value", "(value:v \":\" var:n { @g.t(v,n) } | value:v \"?\" { @g.maybe(v) } | value:v \"+\" { @g.many(v) } | value:v \"*\" { @g.kleene(v) } | value:v mult_range:r { @g.multiple(v, *r) } | \"&\" value:v { @g.andp(v) } | \"!\" value:v { @g.notp(v) } | \"(\" - expression:o - \")\" { o } | \"<\" - expression:o - \">\" { @g.collect(o) } | curly_block | \"~\" method:m < nested_paren? > { @g.action(\"\#{m}\#{text}\") } | \".\" { @g.dot } | \"@\" var:name !(- \"=\") { @g.invoke(name) } | \"^\" var:name < nested_paren? > { @g.foreign_invoke(\"parent\", name, text) } | \"%\" var:gram \".\" var:name < nested_paren? > { @g.foreign_invoke(gram, name, text) } | var:name < nested_paren? > !(- \"=\") { text.empty? ? @g.ref(name) : @g.invoke(name, text) } | char_range | regexp | string)")
2892
+ Rules[:_curly] = rule_info("curly", "\"{\" < (/[^{}\"']+/ | string | curly)* > \"}\" { @g.action(text) }")
2893
+ Rules[:_nested_paren] = rule_info("nested_paren", "\"(\" (/[^()\"']+/ | string | nested_paren)* \")\"")
2894
+ Rules[:_value] = rule_info("value", "(value:v \":\" var:n { @g.t(v,n) } | value:v \"?\" { @g.maybe(v) } | value:v \"+\" { @g.many(v) } | value:v \"*\" { @g.kleene(v) } | value:v mult_range:r { @g.multiple(v, *r) } | \"&\" value:v { @g.andp(v) } | \"!\" value:v { @g.notp(v) } | \"(\" - expression:o - \")\" { o } | \"@<\" - expression:o - \">\" { @g.bounds(o) } | \"<\" - expression:o - \">\" { @g.collect(o) } | curly_block | \"~\" method:m < nested_paren? > { @g.action(\"\#{m}\#{text}\") } | \".\" { @g.dot } | \"@\" var:name !(- \"=\") { @g.invoke(name) } | \"^\" var:name < nested_paren? > { @g.foreign_invoke(\"parent\", name, text) } | \"%\" var:gram \".\" var:name < nested_paren? > { @g.foreign_invoke(gram, name, text) } | var:name < nested_paren? > !(- \"=\") { text.empty? ? @g.ref(name) : @g.invoke(name, text) } | char_range | regexp | string)")
2850
2895
  Rules[:_spaces] = rule_info("spaces", "(space | comment)+")
2851
2896
  Rules[:_values] = rule_info("values", "(values:s spaces value:v { @g.seq(s, v) } | value:l spaces value:r { @g.seq(l, r) } | value)")
2852
2897
  Rules[:_choose_cont] = rule_info("choose_cont", "- \"|\" - values:v { v }")