idlc 0.1.1 → 0.1.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. checksums.yaml +4 -4
  2. data/lib/idlc/ast.rb +404 -184
  3. data/lib/idlc/cli.rb +11 -2
  4. data/lib/idlc/idl.treetop +39 -62
  5. data/lib/idlc/idl_parser.rb +1810 -2452
  6. data/lib/idlc/passes/find_src_registers.rb +58 -18
  7. data/lib/idlc/passes/prune.rb +54 -18
  8. data/lib/idlc/passes/reachable_exceptions.rb +6 -6
  9. data/lib/idlc/passes/reachable_functions.rb +2 -2
  10. data/lib/idlc/symbol_table.rb +50 -9
  11. data/lib/idlc/syntax_node.rb +2 -8
  12. data/lib/idlc/type.rb +16 -11
  13. data/lib/idlc/version.rb +1 -1
  14. data/lib/idlc.rb +53 -29
  15. metadata +3 -6
data/lib/idlc/idl_parser.rb CHANGED
@@ -1539,99 +1539,60 @@ module Idl
1539
1539
 
1540
1540
  i0 = index
1541
1541
  i1, s1 = index, []
1542
- i3 = index
1543
- s4, i4 = [], index
1544
- loop do
1545
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
1546
- r5 = true
1547
- @index += 1
1548
- else
1549
- terminal_parse_failure('[0-9]')
1550
- r5 = nil
1551
- end
1552
- if r5
1553
- s4 << r5
1554
- else
1555
- break
1556
- end
1557
- end
1558
- if s4.empty?
1559
- @index = i4
1560
- r4 = nil
1561
- else
1562
- r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
1563
- end
1564
- if r4
1565
- r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
1566
- r3 = r4
1567
- else
1568
- if (match_len = has_terminal?('MXLEN', false, index))
1569
- r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
1570
- @index += match_len
1571
- else
1572
- terminal_parse_failure('\'MXLEN\'')
1573
- r6 = nil
1574
- end
1575
- if r6
1576
- r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
1577
- r3 = r6
1578
- else
1579
- @index = i3
1580
- r3 = nil
1581
- end
1582
- end
1583
- if r3
1584
- r2 = r3
1542
+ if has_terminal?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
1543
+ r2 = true
1544
+ @index += 1
1585
1545
  else
1586
- r2 = instantiate_node(SyntaxNode,input, index...index)
1546
+ terminal_parse_failure('[1-9]')
1547
+ r2 = nil
1587
1548
  end
1588
1549
  s1 << r2
1589
1550
  if r2
1590
- if (match_len = has_terminal?("'", false, index))
1591
- r7 = true
1592
- @index += match_len
1593
- else
1594
- terminal_parse_failure('"\'"')
1595
- r7 = nil
1551
+ s3, i3 = [], index
1552
+ loop do
1553
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
1554
+ r4 = true
1555
+ @index += 1
1556
+ else
1557
+ terminal_parse_failure('[0-9]')
1558
+ r4 = nil
1559
+ end
1560
+ if r4
1561
+ s3 << r4
1562
+ else
1563
+ break
1564
+ end
1596
1565
  end
1597
- s1 << r7
1598
- if r7
1599
- if (match_len = has_terminal?('b', false, index))
1600
- r8 = true
1566
+ r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
1567
+ s1 << r3
1568
+ if r3
1569
+ i5 = index
1570
+ if (match_len = has_terminal?("'", false, index))
1571
+ r6 = true
1601
1572
  @index += match_len
1602
1573
  else
1603
- terminal_parse_failure('\'b\'')
1604
- r8 = nil
1574
+ terminal_parse_failure('"\'"')
1575
+ r6 = nil
1605
1576
  end
1606
- s1 << r8
1607
- if r8
1608
- if has_terminal?(@regexps[gr = '\A[0-1xX]'] ||= Regexp.new(gr), :regexp, index)
1609
- r9 = true
1610
- @index += 1
1577
+ if r6
1578
+ @index = i5
1579
+ r5 = nil
1580
+ terminal_parse_failure('"\'"', true)
1581
+ else
1582
+ @terminal_failures.pop
1583
+ @index = i5
1584
+ r5 = instantiate_node(SyntaxNode,input, index...index)
1585
+ end
1586
+ s1 << r5
1587
+ if r5
1588
+ if (match_len = has_terminal?('s', false, index))
1589
+ r7 = true
1590
+ @index += match_len
1611
1591
  else
1612
- terminal_parse_failure('[0-1xX]')
1613
- r9 = nil
1614
- end
1615
- s1 << r9
1616
- if r9
1617
- s10, i10 = [], index
1618
- loop do
1619
- if has_terminal?(@regexps[gr = '\A[0-1_xX]'] ||= Regexp.new(gr), :regexp, index)
1620
- r11 = true
1621
- @index += 1
1622
- else
1623
- terminal_parse_failure('[0-1_xX]')
1624
- r11 = nil
1625
- end
1626
- if r11
1627
- s10 << r11
1628
- else
1629
- break
1630
- end
1631
- end
1632
- r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
1633
- s1 << r10
1592
+ terminal_parse_failure('\'s\'')
1593
+ r7 = nil
1634
1594
  end
1595
+ s1 << r7
1635
1596
  end
1636
1597
  end
1637
1598
  end
@@ -1646,1228 +1607,1327 @@ module Idl
1646
1607
  r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
1647
1608
  r0 = r1
1648
1609
  else
1649
- i12, s12 = index, []
1650
- i14 = index
1651
- s15, i15 = [], index
1652
- loop do
1653
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
1654
- r16 = true
1655
- @index += 1
1656
- else
1657
- terminal_parse_failure('[0-9]')
1658
- r16 = nil
1610
+ i8, s8 = index, []
1611
+ if has_terminal?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
1612
+ r9 = true
1613
+ @index += 1
1614
+ else
1615
+ terminal_parse_failure('[1-9]')
1616
+ r9 = nil
1617
+ end
1618
+ s8 << r9
1619
+ if r9
1620
+ s10, i10 = [], index
1621
+ loop do
1622
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
1623
+ r11 = true
1624
+ @index += 1
1625
+ else
1626
+ terminal_parse_failure('[0-9]')
1627
+ r11 = nil
1628
+ end
1629
+ if r11
1630
+ s10 << r11
1631
+ else
1632
+ break
1633
+ end
1659
1634
  end
1660
- if r16
1661
- s15 << r16
1662
- else
1663
- break
1635
+ r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
1636
+ s8 << r10
1637
+ if r10
1638
+ i12 = index
1639
+ if (match_len = has_terminal?("'", false, index))
1640
+ r13 = true
1641
+ @index += match_len
1642
+ else
1643
+ terminal_parse_failure('"\'"')
1644
+ r13 = nil
1645
+ end
1646
+ if r13
1647
+ @index = i12
1648
+ r12 = nil
1649
+ terminal_parse_failure('"\'"', true)
1650
+ else
1651
+ @terminal_failures.pop
1652
+ @index = i12
1653
+ r12 = instantiate_node(SyntaxNode,input, index...index)
1654
+ end
1655
+ s8 << r12
1664
1656
  end
1665
1657
  end
1666
- if s15.empty?
1667
- @index = i15
1668
- r15 = nil
1658
+ if s8.last
1659
+ r8 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i8...index, s8)
1660
+ r8.extend(Int1)
1669
1661
  else
1670
- r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
1662
+ @index = i8
1663
+ r8 = nil
1671
1664
  end
1672
- if r15
1673
- r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
1674
- r14 = r15
1665
+ if r8
1666
+ r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
1667
+ r0 = r8
1675
1668
  else
1676
- if (match_len = has_terminal?('MXLEN', false, index))
1677
- r17 = instantiate_node(SyntaxNode,input, index...(index + match_len))
1669
+ i14, s14 = index, []
1670
+ if (match_len = has_terminal?('0b', false, index))
1671
+ r15 = instantiate_node(SyntaxNode,input, index...(index + match_len))
1678
1672
  @index += match_len
1679
1673
  else
1680
- terminal_parse_failure('\'MXLEN\'')
1681
- r17 = nil
1674
+ terminal_parse_failure('\'0b\'')
1675
+ r15 = nil
1682
1676
  end
1683
- if r17
1684
- r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
1685
- r14 = r17
1677
+ s14 << r15
1678
+ if r15
1679
+ if has_terminal?(@regexps[gr = '\A[0-1]'] ||= Regexp.new(gr), :regexp, index)
1680
+ r16 = true
1681
+ @index += 1
1682
+ else
1683
+ terminal_parse_failure('[0-1]')
1684
+ r16 = nil
1685
+ end
1686
+ s14 << r16
1687
+ if r16
1688
+ s17, i17 = [], index
1689
+ loop do
1690
+ if has_terminal?(@regexps[gr = '\A[0-1_]'] ||= Regexp.new(gr), :regexp, index)
1691
+ r18 = true
1692
+ @index += 1
1693
+ else
1694
+ terminal_parse_failure('[0-1_]')
1695
+ r18 = nil
1696
+ end
1697
+ if r18
1698
+ s17 << r18
1699
+ else
1700
+ break
1701
+ end
1702
+ end
1703
+ r17 = instantiate_node(SyntaxNode,input, i17...index, s17)
1704
+ s14 << r17
1705
+ if r17
1706
+ if (match_len = has_terminal?('s', false, index))
1707
+ r19 = true
1708
+ @index += match_len
1709
+ else
1710
+ terminal_parse_failure('\'s\'')
1711
+ r19 = nil
1712
+ end
1713
+ s14 << r19
1714
+ end
1715
+ end
1716
+ end
1717
+ if s14.last
1718
+ r14 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i14...index, s14)
1719
+ r14.extend(Int2)
1686
1720
  else
1687
1721
  @index = i14
1688
1722
  r14 = nil
1689
1723
  end
1690
- end
1691
- if r14
1692
- r13 = r14
1693
- else
1694
- r13 = instantiate_node(SyntaxNode,input, index...index)
1695
- end
1696
- s12 << r13
1697
- if r13
1698
- if (match_len = has_terminal?("'", false, index))
1699
- r18 = true
1700
- @index += match_len
1724
+ if r14
1725
+ r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
1726
+ r0 = r14
1701
1727
  else
1702
- terminal_parse_failure('"\'"')
1703
- r18 = nil
1704
- end
1705
- s12 << r18
1706
- if r18
1707
- if (match_len = has_terminal?('o', false, index))
1708
- r19 = true
1728
+ i20, s20 = index, []
1729
+ if (match_len = has_terminal?('0', false, index))
1730
+ r21 = true
1709
1731
  @index += match_len
1710
1732
  else
1711
- terminal_parse_failure('\'o\'')
1712
- r19 = nil
1733
+ terminal_parse_failure('\'0\'')
1734
+ r21 = nil
1713
1735
  end
1714
- s12 << r19
1715
- if r19
1716
- if has_terminal?(@regexps[gr = '\A[0-7xX]'] ||= Regexp.new(gr), :regexp, index)
1717
- r20 = true
1736
+ s20 << r21
1737
+ if r21
1738
+ if has_terminal?(@regexps[gr = '\A[0-7]'] ||= Regexp.new(gr), :regexp, index)
1739
+ r22 = true
1718
1740
  @index += 1
1719
1741
  else
1720
- terminal_parse_failure('[0-7xX]')
1721
- r20 = nil
1742
+ terminal_parse_failure('[0-7]')
1743
+ r22 = nil
1722
1744
  end
1723
- s12 << r20
1724
- if r20
1725
- s21, i21 = [], index
1745
+ s20 << r22
1746
+ if r22
1747
+ s23, i23 = [], index
1726
1748
  loop do
1727
- if has_terminal?(@regexps[gr = '\A[0-7_xX]'] ||= Regexp.new(gr), :regexp, index)
1728
- r22 = true
1749
+ if has_terminal?(@regexps[gr = '\A[0-7_]'] ||= Regexp.new(gr), :regexp, index)
1750
+ r24 = true
1729
1751
  @index += 1
1730
1752
  else
1731
- terminal_parse_failure('[0-7_xX]')
1732
- r22 = nil
1753
+ terminal_parse_failure('[0-7_]')
1754
+ r24 = nil
1733
1755
  end
1734
- if r22
1735
- s21 << r22
1756
+ if r24
1757
+ s23 << r24
1736
1758
  else
1737
1759
  break
1738
1760
  end
1739
1761
  end
1740
- r21 = instantiate_node(SyntaxNode,input, i21...index, s21)
1741
- s12 << r21
1762
+ r23 = instantiate_node(SyntaxNode,input, i23...index, s23)
1763
+ s20 << r23
1764
+ if r23
1765
+ if (match_len = has_terminal?('s', false, index))
1766
+ r25 = true
1767
+ @index += match_len
1768
+ else
1769
+ terminal_parse_failure('\'s\'')
1770
+ r25 = nil
1771
+ end
1772
+ s20 << r25
1773
+ end
1742
1774
  end
1743
1775
  end
1744
- end
1745
- end
1746
- if s12.last
1747
- r12 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i12...index, s12)
1748
- r12.extend(Int1)
1749
- else
1750
- @index = i12
1751
- r12 = nil
1752
- end
1753
- if r12
1754
- r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
1755
- r0 = r12
1756
- else
1757
- i23, s23 = index, []
1758
- i25 = index
1759
- s26, i26 = [], index
1760
- loop do
1761
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
1762
- r27 = true
1763
- @index += 1
1764
- else
1765
- terminal_parse_failure('[0-9]')
1766
- r27 = nil
1767
- end
1768
- if r27
1769
- s26 << r27
1770
- else
1771
- break
1772
- end
1773
- end
1774
- if s26.empty?
1775
- @index = i26
1776
- r26 = nil
1777
- else
1778
- r26 = instantiate_node(SyntaxNode,input, i26...index, s26)
1779
- end
1780
- if r26
1781
- r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
1782
- r25 = r26
1783
- else
1784
- if (match_len = has_terminal?('MXLEN', false, index))
1785
- r28 = instantiate_node(SyntaxNode,input, index...(index + match_len))
1786
- @index += match_len
1787
- else
1788
- terminal_parse_failure('\'MXLEN\'')
1789
- r28 = nil
1790
- end
1791
- if r28
1792
- r28 = SyntaxNode.new(input, (index-1)...index) if r28 == true
1793
- r25 = r28
1776
+ if s20.last
1777
+ r20 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i20...index, s20)
1778
+ r20.extend(Int3)
1794
1779
  else
1795
- @index = i25
1796
- r25 = nil
1780
+ @index = i20
1781
+ r20 = nil
1797
1782
  end
1798
- end
1799
- if r25
1800
- r24 = r25
1801
- else
1802
- r24 = instantiate_node(SyntaxNode,input, index...index)
1803
- end
1804
- s23 << r24
1805
- if r24
1806
- if (match_len = has_terminal?("'", false, index))
1807
- r29 = true
1808
- @index += match_len
1783
+ if r20
1784
+ r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
1785
+ r0 = r20
1809
1786
  else
1810
- terminal_parse_failure('"\'"')
1811
- r29 = nil
1812
- end
1813
- s23 << r29
1814
- if r29
1815
- if (match_len = has_terminal?('d', false, index))
1816
- r31 = true
1787
+ i26, s26 = index, []
1788
+ if (match_len = has_terminal?('0x', false, index))
1789
+ r27 = instantiate_node(SyntaxNode,input, index...(index + match_len))
1817
1790
  @index += match_len
1818
1791
  else
1819
- terminal_parse_failure('\'d\'')
1820
- r31 = nil
1792
+ terminal_parse_failure('\'0x\'')
1793
+ r27 = nil
1821
1794
  end
1822
- if r31
1823
- r30 = r31
1824
- else
1825
- r30 = instantiate_node(SyntaxNode,input, index...index)
1826
- end
1827
- s23 << r30
1828
- if r30
1829
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
1830
- r32 = true
1795
+ s26 << r27
1796
+ if r27
1797
+ if has_terminal?(@regexps[gr = '\A[0-9a-fA-F]'] ||= Regexp.new(gr), :regexp, index)
1798
+ r28 = true
1831
1799
  @index += 1
1832
1800
  else
1833
- terminal_parse_failure('[0-9]')
1834
- r32 = nil
1801
+ terminal_parse_failure('[0-9a-fA-F]')
1802
+ r28 = nil
1835
1803
  end
1836
- s23 << r32
1837
- if r32
1838
- s33, i33 = [], index
1804
+ s26 << r28
1805
+ if r28
1806
+ s29, i29 = [], index
1839
1807
  loop do
1840
- if has_terminal?(@regexps[gr = '\A[0-9_]'] ||= Regexp.new(gr), :regexp, index)
1841
- r34 = true
1808
+ if has_terminal?(@regexps[gr = '\A[0-9a-fA-F_]'] ||= Regexp.new(gr), :regexp, index)
1809
+ r30 = true
1842
1810
  @index += 1
1843
1811
  else
1844
- terminal_parse_failure('[0-9_]')
1845
- r34 = nil
1812
+ terminal_parse_failure('[0-9a-fA-F_]')
1813
+ r30 = nil
1846
1814
  end
1847
- if r34
1848
- s33 << r34
1815
+ if r30
1816
+ s29 << r30
1849
1817
  else
1850
1818
  break
1851
1819
  end
1852
1820
  end
1853
- r33 = instantiate_node(SyntaxNode,input, i33...index, s33)
1854
- s23 << r33
1821
+ r29 = instantiate_node(SyntaxNode,input, i29...index, s29)
1822
+ s26 << r29
1823
+ if r29
1824
+ if (match_len = has_terminal?('s', false, index))
1825
+ r31 = true
1826
+ @index += match_len
1827
+ else
1828
+ terminal_parse_failure('\'s\'')
1829
+ r31 = nil
1830
+ end
1831
+ s26 << r31
1832
+ end
1855
1833
  end
1856
1834
  end
1857
- end
1858
- end
1859
- if s23.last
1860
- r23 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i23...index, s23)
1861
- r23.extend(Int2)
1862
- else
1863
- @index = i23
1864
- r23 = nil
1865
- end
1866
- if r23
1867
- r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
1868
- r0 = r23
1869
- else
1870
- i35, s35 = index, []
1871
- i37 = index
1872
- s38, i38 = [], index
1873
- loop do
1874
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
1875
- r39 = true
1876
- @index += 1
1877
- else
1878
- terminal_parse_failure('[0-9]')
1879
- r39 = nil
1880
- end
1881
- if r39
1882
- s38 << r39
1883
- else
1884
- break
1885
- end
1886
- end
1887
- if s38.empty?
1888
- @index = i38
1889
- r38 = nil
1890
- else
1891
- r38 = instantiate_node(SyntaxNode,input, i38...index, s38)
1892
- end
1893
- if r38
1894
- r38 = SyntaxNode.new(input, (index-1)...index) if r38 == true
1895
- r37 = r38
1896
- else
1897
- if (match_len = has_terminal?('MXLEN', false, index))
1898
- r40 = instantiate_node(SyntaxNode,input, index...(index + match_len))
1899
- @index += match_len
1900
- else
1901
- terminal_parse_failure('\'MXLEN\'')
1902
- r40 = nil
1903
- end
1904
- if r40
1905
- r40 = SyntaxNode.new(input, (index-1)...index) if r40 == true
1906
- r37 = r40
1835
+ if s26.last
1836
+ r26 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i26...index, s26)
1837
+ r26.extend(Int4)
1907
1838
  else
1908
- @index = i37
1909
- r37 = nil
1839
+ @index = i26
1840
+ r26 = nil
1910
1841
  end
1911
- end
1912
- if r37
1913
- r36 = r37
1914
- else
1915
- r36 = instantiate_node(SyntaxNode,input, index...index)
1916
- end
1917
- s35 << r36
1918
- if r36
1919
- if (match_len = has_terminal?("'", false, index))
1920
- r41 = true
1921
- @index += match_len
1842
+ if r26
1843
+ r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
1844
+ r0 = r26
1922
1845
  else
1923
- terminal_parse_failure('"\'"')
1924
- r41 = nil
1925
- end
1926
- s35 << r41
1927
- if r41
1928
- if (match_len = has_terminal?('h', false, index))
1929
- r42 = true
1846
+ i32, s32 = index, []
1847
+ if (match_len = has_terminal?('0b', false, index))
1848
+ r33 = instantiate_node(SyntaxNode,input, index...(index + match_len))
1930
1849
  @index += match_len
1931
1850
  else
1932
- terminal_parse_failure('\'h\'')
1933
- r42 = nil
1851
+ terminal_parse_failure('\'0b\'')
1852
+ r33 = nil
1934
1853
  end
1935
- s35 << r42
1936
- if r42
1937
- if has_terminal?(@regexps[gr = '\A[0-9a-fA-FxX]'] ||= Regexp.new(gr), :regexp, index)
1938
- r43 = true
1854
+ s32 << r33
1855
+ if r33
1856
+ if has_terminal?(@regexps[gr = '\A[0-1]'] ||= Regexp.new(gr), :regexp, index)
1857
+ r34 = true
1939
1858
  @index += 1
1940
1859
  else
1941
- terminal_parse_failure('[0-9a-fA-FxX]')
1942
- r43 = nil
1860
+ terminal_parse_failure('[0-1]')
1861
+ r34 = nil
1943
1862
  end
1944
- s35 << r43
1945
- if r43
1946
- s44, i44 = [], index
1863
+ s32 << r34
1864
+ if r34
1865
+ s35, i35 = [], index
1947
1866
  loop do
1948
- if has_terminal?(@regexps[gr = '\A[0-9a-fA-F_xX]'] ||= Regexp.new(gr), :regexp, index)
1949
- r45 = true
1867
+ if has_terminal?(@regexps[gr = '\A[0-1_]'] ||= Regexp.new(gr), :regexp, index)
1868
+ r36 = true
1950
1869
  @index += 1
1951
1870
  else
1952
- terminal_parse_failure('[0-9a-fA-F_xX]')
1953
- r45 = nil
1871
+ terminal_parse_failure('[0-1_]')
1872
+ r36 = nil
1954
1873
  end
1955
- if r45
1956
- s44 << r45
1874
+ if r36
1875
+ s35 << r36
1957
1876
  else
1958
1877
  break
1959
1878
  end
1960
1879
  end
1961
- r44 = instantiate_node(SyntaxNode,input, i44...index, s44)
1962
- s35 << r44
1880
+ r35 = instantiate_node(SyntaxNode,input, i35...index, s35)
1881
+ s32 << r35
1963
1882
  end
1964
1883
  end
1965
- end
1966
- end
1967
- if s35.last
1968
- r35 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i35...index, s35)
1969
- r35.extend(Int3)
1970
- else
1971
- @index = i35
1972
- r35 = nil
1973
- end
1974
- if r35
1975
- r35 = SyntaxNode.new(input, (index-1)...index) if r35 == true
1976
- r0 = r35
1977
- else
1978
- i46, s46 = index, []
1979
- i48 = index
1980
- s49, i49 = [], index
1981
- loop do
1982
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
1983
- r50 = true
1984
- @index += 1
1985
- else
1986
- terminal_parse_failure('[0-9]')
1987
- r50 = nil
1988
- end
1989
- if r50
1990
- s49 << r50
1991
- else
1992
- break
1993
- end
1994
- end
1995
- if s49.empty?
1996
- @index = i49
1997
- r49 = nil
1998
- else
1999
- r49 = instantiate_node(SyntaxNode,input, i49...index, s49)
2000
- end
2001
- if r49
2002
- r49 = SyntaxNode.new(input, (index-1)...index) if r49 == true
2003
- r48 = r49
2004
- else
2005
- if (match_len = has_terminal?('MXLEN', false, index))
2006
- r51 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2007
- @index += match_len
2008
- else
2009
- terminal_parse_failure('\'MXLEN\'')
2010
- r51 = nil
2011
- end
2012
- if r51
2013
- r51 = SyntaxNode.new(input, (index-1)...index) if r51 == true
2014
- r48 = r51
1884
+ if s32.last
1885
+ r32 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i32...index, s32)
1886
+ r32.extend(Int5)
2015
1887
  else
2016
- @index = i48
2017
- r48 = nil
1888
+ @index = i32
1889
+ r32 = nil
2018
1890
  end
2019
- end
2020
- if r48
2021
- r47 = r48
2022
- else
2023
- r47 = instantiate_node(SyntaxNode,input, index...index)
2024
- end
2025
- s46 << r47
2026
- if r47
2027
- if (match_len = has_terminal?("'", false, index))
2028
- r52 = true
2029
- @index += match_len
1891
+ if r32
1892
+ r32 = SyntaxNode.new(input, (index-1)...index) if r32 == true
1893
+ r0 = r32
2030
1894
  else
2031
- terminal_parse_failure('"\'"')
2032
- r52 = nil
2033
- end
2034
- s46 << r52
2035
- if r52
2036
- if (match_len = has_terminal?('sb', false, index))
2037
- r53 = instantiate_node(SyntaxNode,input, index...(index + match_len))
1895
+ i37, s37 = index, []
1896
+ if (match_len = has_terminal?('0', false, index))
1897
+ r38 = true
2038
1898
  @index += match_len
2039
1899
  else
2040
- terminal_parse_failure('\'sb\'')
2041
- r53 = nil
1900
+ terminal_parse_failure('\'0\'')
1901
+ r38 = nil
2042
1902
  end
2043
- s46 << r53
2044
- if r53
2045
- if has_terminal?(@regexps[gr = '\A[0-1xX]'] ||= Regexp.new(gr), :regexp, index)
2046
- r54 = true
1903
+ s37 << r38
1904
+ if r38
1905
+ if has_terminal?(@regexps[gr = '\A[0-7]'] ||= Regexp.new(gr), :regexp, index)
1906
+ r39 = true
2047
1907
  @index += 1
2048
1908
  else
2049
- terminal_parse_failure('[0-1xX]')
2050
- r54 = nil
1909
+ terminal_parse_failure('[0-7]')
1910
+ r39 = nil
2051
1911
  end
2052
- s46 << r54
2053
- if r54
2054
- s55, i55 = [], index
1912
+ s37 << r39
1913
+ if r39
1914
+ s40, i40 = [], index
2055
1915
  loop do
2056
- if has_terminal?(@regexps[gr = '\A[0-1_xX]'] ||= Regexp.new(gr), :regexp, index)
2057
- r56 = true
1916
+ if has_terminal?(@regexps[gr = '\A[0-7_]'] ||= Regexp.new(gr), :regexp, index)
1917
+ r41 = true
2058
1918
  @index += 1
2059
1919
  else
2060
- terminal_parse_failure('[0-1_xX]')
2061
- r56 = nil
1920
+ terminal_parse_failure('[0-7_]')
1921
+ r41 = nil
2062
1922
  end
2063
- if r56
2064
- s55 << r56
1923
+ if r41
1924
+ s40 << r41
2065
1925
  else
2066
1926
  break
2067
1927
  end
2068
1928
  end
2069
- r55 = instantiate_node(SyntaxNode,input, i55...index, s55)
2070
- s46 << r55
1929
+ r40 = instantiate_node(SyntaxNode,input, i40...index, s40)
1930
+ s37 << r40
2071
1931
  end
2072
1932
  end
2073
- end
2074
- end
2075
- if s46.last
2076
- r46 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i46...index, s46)
2077
- r46.extend(Int4)
2078
- else
2079
- @index = i46
2080
- r46 = nil
2081
- end
2082
- if r46
2083
- r46 = SyntaxNode.new(input, (index-1)...index) if r46 == true
2084
- r0 = r46
2085
- else
2086
- i57, s57 = index, []
2087
- i59 = index
2088
- s60, i60 = [], index
2089
- loop do
2090
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2091
- r61 = true
2092
- @index += 1
2093
- else
2094
- terminal_parse_failure('[0-9]')
2095
- r61 = nil
2096
- end
2097
- if r61
2098
- s60 << r61
2099
- else
2100
- break
2101
- end
2102
- end
2103
- if s60.empty?
2104
- @index = i60
2105
- r60 = nil
2106
- else
2107
- r60 = instantiate_node(SyntaxNode,input, i60...index, s60)
2108
- end
2109
- if r60
2110
- r60 = SyntaxNode.new(input, (index-1)...index) if r60 == true
2111
- r59 = r60
2112
- else
2113
- if (match_len = has_terminal?('MXLEN', false, index))
2114
- r62 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2115
- @index += match_len
2116
- else
2117
- terminal_parse_failure('\'MXLEN\'')
2118
- r62 = nil
2119
- end
2120
- if r62
2121
- r62 = SyntaxNode.new(input, (index-1)...index) if r62 == true
2122
- r59 = r62
1933
+ if s37.last
1934
+ r37 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i37...index, s37)
1935
+ r37.extend(Int6)
2123
1936
  else
2124
- @index = i59
2125
- r59 = nil
1937
+ @index = i37
1938
+ r37 = nil
2126
1939
  end
2127
- end
2128
- if r59
2129
- r58 = r59
2130
- else
2131
- r58 = instantiate_node(SyntaxNode,input, index...index)
2132
- end
2133
- s57 << r58
2134
- if r58
2135
- if (match_len = has_terminal?("'", false, index))
2136
- r63 = true
2137
- @index += match_len
1940
+ if r37
1941
+ r37 = SyntaxNode.new(input, (index-1)...index) if r37 == true
1942
+ r0 = r37
2138
1943
  else
2139
- terminal_parse_failure('"\'"')
2140
- r63 = nil
2141
- end
2142
- s57 << r63
2143
- if r63
2144
- if (match_len = has_terminal?('so', false, index))
2145
- r64 = instantiate_node(SyntaxNode,input, index...(index + match_len))
1944
+ i42, s42 = index, []
1945
+ if (match_len = has_terminal?('0x', false, index))
1946
+ r43 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2146
1947
  @index += match_len
2147
1948
  else
2148
- terminal_parse_failure('\'so\'')
2149
- r64 = nil
1949
+ terminal_parse_failure('\'0x\'')
1950
+ r43 = nil
2150
1951
  end
2151
- s57 << r64
2152
- if r64
2153
- if has_terminal?(@regexps[gr = '\A[0-7xX]'] ||= Regexp.new(gr), :regexp, index)
2154
- r65 = true
1952
+ s42 << r43
1953
+ if r43
1954
+ if has_terminal?(@regexps[gr = '\A[0-9a-fA-F]'] ||= Regexp.new(gr), :regexp, index)
1955
+ r44 = true
2155
1956
  @index += 1
2156
1957
  else
2157
- terminal_parse_failure('[0-7xX]')
2158
- r65 = nil
1958
+ terminal_parse_failure('[0-9a-fA-F]')
1959
+ r44 = nil
2159
1960
  end
2160
- s57 << r65
2161
- if r65
2162
- s66, i66 = [], index
1961
+ s42 << r44
1962
+ if r44
1963
+ s45, i45 = [], index
2163
1964
  loop do
2164
- if has_terminal?(@regexps[gr = '\A[0-7_xX]'] ||= Regexp.new(gr), :regexp, index)
2165
- r67 = true
1965
+ if has_terminal?(@regexps[gr = '\A[0-9a-fA-F_]'] ||= Regexp.new(gr), :regexp, index)
1966
+ r46 = true
2166
1967
  @index += 1
2167
1968
  else
2168
- terminal_parse_failure('[0-7_xX]')
2169
- r67 = nil
1969
+ terminal_parse_failure('[0-9a-fA-F_]')
1970
+ r46 = nil
2170
1971
  end
2171
- if r67
2172
- s66 << r67
1972
+ if r46
1973
+ s45 << r46
2173
1974
  else
2174
1975
  break
2175
1976
  end
2176
1977
  end
2177
- r66 = instantiate_node(SyntaxNode,input, i66...index, s66)
2178
- s57 << r66
1978
+ r45 = instantiate_node(SyntaxNode,input, i45...index, s45)
1979
+ s42 << r45
2179
1980
  end
2180
1981
  end
2181
- end
2182
- end
2183
- if s57.last
2184
- r57 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i57...index, s57)
2185
- r57.extend(Int5)
2186
- else
2187
- @index = i57
2188
- r57 = nil
2189
- end
2190
- if r57
2191
- r57 = SyntaxNode.new(input, (index-1)...index) if r57 == true
2192
- r0 = r57
2193
- else
2194
- i68, s68 = index, []
2195
- i70 = index
2196
- s71, i71 = [], index
2197
- loop do
2198
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2199
- r72 = true
2200
- @index += 1
2201
- else
2202
- terminal_parse_failure('[0-9]')
2203
- r72 = nil
2204
- end
2205
- if r72
2206
- s71 << r72
2207
- else
2208
- break
2209
- end
2210
- end
2211
- if s71.empty?
2212
- @index = i71
2213
- r71 = nil
2214
- else
2215
- r71 = instantiate_node(SyntaxNode,input, i71...index, s71)
2216
- end
2217
- if r71
2218
- r71 = SyntaxNode.new(input, (index-1)...index) if r71 == true
2219
- r70 = r71
2220
- else
2221
- if (match_len = has_terminal?('MXLEN', false, index))
2222
- r73 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2223
- @index += match_len
2224
- else
2225
- terminal_parse_failure('\'MXLEN\'')
2226
- r73 = nil
2227
- end
2228
- if r73
2229
- r73 = SyntaxNode.new(input, (index-1)...index) if r73 == true
2230
- r70 = r73
1982
+ if s42.last
1983
+ r42 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i42...index, s42)
1984
+ r42.extend(Int7)
2231
1985
  else
2232
- @index = i70
2233
- r70 = nil
1986
+ @index = i42
1987
+ r42 = nil
2234
1988
  end
2235
- end
2236
- if r70
2237
- r69 = r70
2238
- else
2239
- r69 = instantiate_node(SyntaxNode,input, index...index)
2240
- end
2241
- s68 << r69
2242
- if r69
2243
- if (match_len = has_terminal?("'", false, index))
2244
- r74 = true
2245
- @index += match_len
1989
+ if r42
1990
+ r42 = SyntaxNode.new(input, (index-1)...index) if r42 == true
1991
+ r0 = r42
2246
1992
  else
2247
- terminal_parse_failure('"\'"')
2248
- r74 = nil
2249
- end
2250
- s68 << r74
2251
- if r74
2252
- if (match_len = has_terminal?('s', false, index))
2253
- r75 = true
1993
+ i47, s47 = index, []
1994
+ if (match_len = has_terminal?('0', false, index))
1995
+ r48 = true
2254
1996
  @index += match_len
2255
1997
  else
2256
- terminal_parse_failure('\'s\'')
2257
- r75 = nil
1998
+ terminal_parse_failure('\'0\'')
1999
+ r48 = nil
2258
2000
  end
2259
- s68 << r75
2260
- if r75
2261
- if (match_len = has_terminal?('d', false, index))
2262
- r77 = true
2001
+ s47 << r48
2002
+ if r48
2003
+ i49 = index
2004
+ if (match_len = has_terminal?("'", false, index))
2005
+ r50 = true
2263
2006
  @index += match_len
2264
2007
  else
2265
- terminal_parse_failure('\'d\'')
2266
- r77 = nil
2008
+ terminal_parse_failure('"\'"')
2009
+ r50 = nil
2267
2010
  end
2268
- if r77
2269
- r76 = r77
2011
+ if r50
2012
+ @index = i49
2013
+ r49 = nil
2014
+ terminal_parse_failure('"\'"', true)
2270
2015
  else
2271
- r76 = instantiate_node(SyntaxNode,input, index...index)
2016
+ @terminal_failures.pop
2017
+ @index = i49
2018
+ r49 = instantiate_node(SyntaxNode,input, index...index)
2272
2019
  end
2273
- s68 << r76
2274
- if r76
2275
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2276
- r78 = true
2277
- @index += 1
2020
+ s47 << r49
2021
+ if r49
2022
+ if (match_len = has_terminal?('s', false, index))
2023
+ r52 = true
2024
+ @index += match_len
2278
2025
  else
2279
- terminal_parse_failure('[0-9]')
2280
- r78 = nil
2026
+ terminal_parse_failure('\'s\'')
2027
+ r52 = nil
2281
2028
  end
2282
- s68 << r78
2283
- if r78
2284
- s79, i79 = [], index
2285
- loop do
2286
- if has_terminal?(@regexps[gr = '\A[0-9_]'] ||= Regexp.new(gr), :regexp, index)
2287
- r80 = true
2288
- @index += 1
2289
- else
2290
- terminal_parse_failure('[0-9_]')
2291
- r80 = nil
2292
- end
2293
- if r80
2294
- s79 << r80
2295
- else
2296
- break
2297
- end
2298
- end
2299
- r79 = instantiate_node(SyntaxNode,input, i79...index, s79)
2300
- s68 << r79
2029
+ if r52
2030
+ r51 = r52
2031
+ else
2032
+ r51 = instantiate_node(SyntaxNode,input, index...index)
2301
2033
  end
2034
+ s47 << r51
2302
2035
  end
2303
2036
  end
2304
- end
2305
- end
2306
- if s68.last
2307
- r68 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i68...index, s68)
2308
- r68.extend(Int6)
2309
- else
2310
- @index = i68
2311
- r68 = nil
2312
- end
2313
- if r68
2314
- r68 = SyntaxNode.new(input, (index-1)...index) if r68 == true
2315
- r0 = r68
2316
- else
2317
- i81, s81 = index, []
2318
- i83 = index
2319
- s84, i84 = [], index
2320
- loop do
2321
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2322
- r85 = true
2323
- @index += 1
2324
- else
2325
- terminal_parse_failure('[0-9]')
2326
- r85 = nil
2327
- end
2328
- if r85
2329
- s84 << r85
2330
- else
2331
- break
2332
- end
2333
- end
2334
- if s84.empty?
2335
- @index = i84
2336
- r84 = nil
2337
- else
2338
- r84 = instantiate_node(SyntaxNode,input, i84...index, s84)
2339
- end
2340
- if r84
2341
- r84 = SyntaxNode.new(input, (index-1)...index) if r84 == true
2342
- r83 = r84
2343
- else
2344
- if (match_len = has_terminal?('MXLEN', false, index))
2345
- r86 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2346
- @index += match_len
2347
- else
2348
- terminal_parse_failure('\'MXLEN\'')
2349
- r86 = nil
2350
- end
2351
- if r86
2352
- r86 = SyntaxNode.new(input, (index-1)...index) if r86 == true
2353
- r83 = r86
2037
+ if s47.last
2038
+ r47 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i47...index, s47)
2039
+ r47.extend(Int8)
2354
2040
  else
2355
- @index = i83
2356
- r83 = nil
2041
+ @index = i47
2042
+ r47 = nil
2357
2043
  end
2358
- end
2359
- if r83
2360
- r82 = r83
2361
- else
2362
- r82 = instantiate_node(SyntaxNode,input, index...index)
2363
- end
2364
- s81 << r82
2365
- if r82
2366
- if (match_len = has_terminal?("'", false, index))
2367
- r87 = true
2368
- @index += match_len
2044
+ if r47
2045
+ r47 = SyntaxNode.new(input, (index-1)...index) if r47 == true
2046
+ r0 = r47
2369
2047
  else
2370
- terminal_parse_failure('"\'"')
2371
- r87 = nil
2372
- end
2373
- s81 << r87
2374
- if r87
2375
- if (match_len = has_terminal?('sh', false, index))
2376
- r88 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2377
- @index += match_len
2048
+ i53, s53 = index, []
2049
+ i55 = index
2050
+ s56, i56 = [], index
2051
+ loop do
2052
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2053
+ r57 = true
2054
+ @index += 1
2055
+ else
2056
+ terminal_parse_failure('[0-9]')
2057
+ r57 = nil
2058
+ end
2059
+ if r57
2060
+ s56 << r57
2061
+ else
2062
+ break
2063
+ end
2064
+ end
2065
+ if s56.empty?
2066
+ @index = i56
2067
+ r56 = nil
2378
2068
  else
2379
- terminal_parse_failure('\'sh\'')
2380
- r88 = nil
2069
+ r56 = instantiate_node(SyntaxNode,input, i56...index, s56)
2381
2070
  end
2382
- s81 << r88
2383
- if r88
2384
- if has_terminal?(@regexps[gr = '\A[0-9a-fA-FxX]'] ||= Regexp.new(gr), :regexp, index)
2385
- r89 = true
2386
- @index += 1
2071
+ if r56
2072
+ r56 = SyntaxNode.new(input, (index-1)...index) if r56 == true
2073
+ r55 = r56
2074
+ else
2075
+ if (match_len = has_terminal?('MXLEN', false, index))
2076
+ r58 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2077
+ @index += match_len
2387
2078
  else
2388
- terminal_parse_failure('[0-9a-fA-FxX]')
2389
- r89 = nil
2079
+ terminal_parse_failure('\'MXLEN\'')
2080
+ r58 = nil
2390
2081
  end
2391
- s81 << r89
2392
- if r89
2393
- s90, i90 = [], index
2394
- loop do
2395
- if has_terminal?(@regexps[gr = '\A[0-9a-fA-F_xX]'] ||= Regexp.new(gr), :regexp, index)
2396
- r91 = true
2082
+ if r58
2083
+ r58 = SyntaxNode.new(input, (index-1)...index) if r58 == true
2084
+ r55 = r58
2085
+ else
2086
+ @index = i55
2087
+ r55 = nil
2088
+ end
2089
+ end
2090
+ if r55
2091
+ r54 = r55
2092
+ else
2093
+ r54 = instantiate_node(SyntaxNode,input, index...index)
2094
+ end
2095
+ s53 << r54
2096
+ if r54
2097
+ if (match_len = has_terminal?("'", false, index))
2098
+ r59 = true
2099
+ @index += match_len
2100
+ else
2101
+ terminal_parse_failure('"\'"')
2102
+ r59 = nil
2103
+ end
2104
+ s53 << r59
2105
+ if r59
2106
+ if (match_len = has_terminal?('b', false, index))
2107
+ r60 = true
2108
+ @index += match_len
2109
+ else
2110
+ terminal_parse_failure('\'b\'')
2111
+ r60 = nil
2112
+ end
2113
+ s53 << r60
2114
+ if r60
2115
+ if has_terminal?(@regexps[gr = '\A[0-1xX]'] ||= Regexp.new(gr), :regexp, index)
2116
+ r61 = true
2397
2117
  @index += 1
2398
2118
  else
2399
- terminal_parse_failure('[0-9a-fA-F_xX]')
2400
- r91 = nil
2119
+ terminal_parse_failure('[0-1xX]')
2120
+ r61 = nil
2401
2121
  end
2402
- if r91
2403
- s90 << r91
2404
- else
2405
- break
2122
+ s53 << r61
2123
+ if r61
2124
+ s62, i62 = [], index
2125
+ loop do
2126
+ if has_terminal?(@regexps[gr = '\A[0-1_xX]'] ||= Regexp.new(gr), :regexp, index)
2127
+ r63 = true
2128
+ @index += 1
2129
+ else
2130
+ terminal_parse_failure('[0-1_xX]')
2131
+ r63 = nil
2132
+ end
2133
+ if r63
2134
+ s62 << r63
2135
+ else
2136
+ break
2137
+ end
2138
+ end
2139
+ r62 = instantiate_node(SyntaxNode,input, i62...index, s62)
2140
+ s53 << r62
2406
2141
  end
2407
2142
  end
2408
- r90 = instantiate_node(SyntaxNode,input, i90...index, s90)
2409
- s81 << r90
2410
2143
  end
2411
2144
  end
2412
- end
2413
- end
2414
- if s81.last
2415
- r81 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i81...index, s81)
2416
- r81.extend(Int7)
2417
- else
2418
- @index = i81
2419
- r81 = nil
2420
- end
2421
- if r81
2422
- r81 = SyntaxNode.new(input, (index-1)...index) if r81 == true
2423
- r0 = r81
2424
- else
2425
- i92, s92 = index, []
2426
- if (match_len = has_terminal?('0b', false, index))
2427
- r93 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2428
- @index += match_len
2429
- else
2430
- terminal_parse_failure('\'0b\'')
2431
- r93 = nil
2432
- end
2433
- s92 << r93
2434
- if r93
2435
- if has_terminal?(@regexps[gr = '\A[0-1]'] ||= Regexp.new(gr), :regexp, index)
2436
- r94 = true
2437
- @index += 1
2145
+ if s53.last
2146
+ r53 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i53...index, s53)
2147
+ r53.extend(Int9)
2438
2148
  else
2439
- terminal_parse_failure('[0-1]')
2440
- r94 = nil
2149
+ @index = i53
2150
+ r53 = nil
2441
2151
  end
2442
- s92 << r94
2443
- if r94
2444
- s95, i95 = [], index
2152
+ if r53
2153
+ r53 = SyntaxNode.new(input, (index-1)...index) if r53 == true
2154
+ r0 = r53
2155
+ else
2156
+ i64, s64 = index, []
2157
+ i66 = index
2158
+ s67, i67 = [], index
2445
2159
  loop do
2446
- if has_terminal?(@regexps[gr = '\A[0-1_]'] ||= Regexp.new(gr), :regexp, index)
2447
- r96 = true
2160
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2161
+ r68 = true
2448
2162
  @index += 1
2449
2163
  else
2450
- terminal_parse_failure('[0-1_]')
2451
- r96 = nil
2164
+ terminal_parse_failure('[0-9]')
2165
+ r68 = nil
2452
2166
  end
2453
- if r96
2454
- s95 << r96
2167
+ if r68
2168
+ s67 << r68
2455
2169
  else
2456
2170
  break
2457
2171
  end
2458
2172
  end
2459
- r95 = instantiate_node(SyntaxNode,input, i95...index, s95)
2460
- s92 << r95
2461
- if r95
2462
- if (match_len = has_terminal?('s', false, index))
2463
- r97 = true
2173
+ if s67.empty?
2174
+ @index = i67
2175
+ r67 = nil
2176
+ else
2177
+ r67 = instantiate_node(SyntaxNode,input, i67...index, s67)
2178
+ end
2179
+ if r67
2180
+ r67 = SyntaxNode.new(input, (index-1)...index) if r67 == true
2181
+ r66 = r67
2182
+ else
2183
+ if (match_len = has_terminal?('MXLEN', false, index))
2184
+ r69 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2464
2185
  @index += match_len
2465
2186
  else
2466
- terminal_parse_failure('\'s\'')
2467
- r97 = nil
2187
+ terminal_parse_failure('\'MXLEN\'')
2188
+ r69 = nil
2189
+ end
2190
+ if r69
2191
+ r69 = SyntaxNode.new(input, (index-1)...index) if r69 == true
2192
+ r66 = r69
2193
+ else
2194
+ @index = i66
2195
+ r66 = nil
2468
2196
  end
2469
- s92 << r97
2470
2197
  end
2471
- end
2472
- end
2473
- if s92.last
2474
- r92 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i92...index, s92)
2475
- r92.extend(Int8)
2476
- else
2477
- @index = i92
2478
- r92 = nil
2479
- end
2480
- if r92
2481
- r92 = SyntaxNode.new(input, (index-1)...index) if r92 == true
2482
- r0 = r92
2483
- else
2484
- i98, s98 = index, []
2485
- if (match_len = has_terminal?('0', false, index))
2486
- r99 = true
2487
- @index += match_len
2488
- else
2489
- terminal_parse_failure('\'0\'')
2490
- r99 = nil
2491
- end
2492
- s98 << r99
2493
- if r99
2494
- if has_terminal?(@regexps[gr = '\A[0-7]'] ||= Regexp.new(gr), :regexp, index)
2495
- r100 = true
2496
- @index += 1
2198
+ if r66
2199
+ r65 = r66
2497
2200
  else
2498
- terminal_parse_failure('[0-7]')
2499
- r100 = nil
2201
+ r65 = instantiate_node(SyntaxNode,input, index...index)
2500
2202
  end
2501
- s98 << r100
2502
- if r100
2503
- s101, i101 = [], index
2504
- loop do
2505
- if has_terminal?(@regexps[gr = '\A[0-7_]'] ||= Regexp.new(gr), :regexp, index)
2506
- r102 = true
2507
- @index += 1
2508
- else
2509
- terminal_parse_failure('[0-7_]')
2510
- r102 = nil
2511
- end
2512
- if r102
2513
- s101 << r102
2514
- else
2515
- break
2516
- end
2203
+ s64 << r65
2204
+ if r65
2205
+ if (match_len = has_terminal?("'", false, index))
2206
+ r70 = true
2207
+ @index += match_len
2208
+ else
2209
+ terminal_parse_failure('"\'"')
2210
+ r70 = nil
2517
2211
  end
2518
- r101 = instantiate_node(SyntaxNode,input, i101...index, s101)
2519
- s98 << r101
2520
- if r101
2521
- if (match_len = has_terminal?('s', false, index))
2522
- r103 = true
2212
+ s64 << r70
2213
+ if r70
2214
+ if (match_len = has_terminal?('o', false, index))
2215
+ r71 = true
2523
2216
  @index += match_len
2524
2217
  else
2525
- terminal_parse_failure('\'s\'')
2526
- r103 = nil
2218
+ terminal_parse_failure('\'o\'')
2219
+ r71 = nil
2220
+ end
2221
+ s64 << r71
2222
+ if r71
2223
+ if has_terminal?(@regexps[gr = '\A[0-7xX]'] ||= Regexp.new(gr), :regexp, index)
2224
+ r72 = true
2225
+ @index += 1
2226
+ else
2227
+ terminal_parse_failure('[0-7xX]')
2228
+ r72 = nil
2229
+ end
2230
+ s64 << r72
2231
+ if r72
2232
+ s73, i73 = [], index
2233
+ loop do
2234
+ if has_terminal?(@regexps[gr = '\A[0-7_xX]'] ||= Regexp.new(gr), :regexp, index)
2235
+ r74 = true
2236
+ @index += 1
2237
+ else
2238
+ terminal_parse_failure('[0-7_xX]')
2239
+ r74 = nil
2240
+ end
2241
+ if r74
2242
+ s73 << r74
2243
+ else
2244
+ break
2245
+ end
2246
+ end
2247
+ r73 = instantiate_node(SyntaxNode,input, i73...index, s73)
2248
+ s64 << r73
2249
+ end
2527
2250
  end
2528
- s98 << r103
2529
2251
  end
2530
2252
  end
2531
- end
2532
- if s98.last
2533
- r98 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i98...index, s98)
2534
- r98.extend(Int9)
2535
- else
2536
- @index = i98
2537
- r98 = nil
2538
- end
2539
- if r98
2540
- r98 = SyntaxNode.new(input, (index-1)...index) if r98 == true
2541
- r0 = r98
2542
- else
2543
- i104, s104 = index, []
2544
- if has_terminal?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
2545
- r105 = true
2546
- @index += 1
2253
+ if s64.last
2254
+ r64 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i64...index, s64)
2255
+ r64.extend(Int10)
2547
2256
  else
2548
- terminal_parse_failure('[1-9]')
2549
- r105 = nil
2257
+ @index = i64
2258
+ r64 = nil
2550
2259
  end
2551
- s104 << r105
2552
- if r105
2553
- s106, i106 = [], index
2260
+ if r64
2261
+ r64 = SyntaxNode.new(input, (index-1)...index) if r64 == true
2262
+ r0 = r64
2263
+ else
2264
+ i75, s75 = index, []
2265
+ i77 = index
2266
+ s78, i78 = [], index
2554
2267
  loop do
2555
2268
  if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2556
- r107 = true
2269
+ r79 = true
2557
2270
  @index += 1
2558
2271
  else
2559
2272
  terminal_parse_failure('[0-9]')
2560
- r107 = nil
2273
+ r79 = nil
2561
2274
  end
2562
- if r107
2563
- s106 << r107
2275
+ if r79
2276
+ s78 << r79
2564
2277
  else
2565
2278
  break
2566
2279
  end
2567
2280
  end
2568
- r106 = instantiate_node(SyntaxNode,input, i106...index, s106)
2569
- s104 << r106
2570
- if r106
2571
- if (match_len = has_terminal?('s', false, index))
2572
- r108 = true
2573
- @index += match_len
2574
- else
2575
- terminal_parse_failure('\'s\'')
2576
- r108 = nil
2577
- end
2578
- s104 << r108
2579
- end
2580
- end
2581
- if s104.last
2582
- r104 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i104...index, s104)
2583
- r104.extend(Int10)
2584
- else
2585
- @index = i104
2586
- r104 = nil
2587
- end
2588
- if r104
2589
- r104 = SyntaxNode.new(input, (index-1)...index) if r104 == true
2590
- r0 = r104
2591
- else
2592
- i109, s109 = index, []
2593
- if (match_len = has_terminal?('0x', false, index))
2594
- r110 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2595
- @index += match_len
2281
+ if s78.empty?
2282
+ @index = i78
2283
+ r78 = nil
2596
2284
  else
2597
- terminal_parse_failure('\'0x\'')
2598
- r110 = nil
2285
+ r78 = instantiate_node(SyntaxNode,input, i78...index, s78)
2599
2286
  end
2600
- s109 << r110
2601
- if r110
2602
- if has_terminal?(@regexps[gr = '\A[0-9a-fA-F]'] ||= Regexp.new(gr), :regexp, index)
2603
- r111 = true
2604
- @index += 1
2287
+ if r78
2288
+ r78 = SyntaxNode.new(input, (index-1)...index) if r78 == true
2289
+ r77 = r78
2290
+ else
2291
+ if (match_len = has_terminal?('MXLEN', false, index))
2292
+ r80 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2293
+ @index += match_len
2605
2294
  else
2606
- terminal_parse_failure('[0-9a-fA-F]')
2607
- r111 = nil
2295
+ terminal_parse_failure('\'MXLEN\'')
2296
+ r80 = nil
2608
2297
  end
2609
- s109 << r111
2610
- if r111
2611
- s112, i112 = [], index
2612
- loop do
2613
- if has_terminal?(@regexps[gr = '\A[0-9a-fA-F_]'] ||= Regexp.new(gr), :regexp, index)
2614
- r113 = true
2615
- @index += 1
2616
- else
2617
- terminal_parse_failure('[0-9a-fA-F_]')
2618
- r113 = nil
2619
- end
2620
- if r113
2621
- s112 << r113
2622
- else
2623
- break
2624
- end
2625
- end
2626
- r112 = instantiate_node(SyntaxNode,input, i112...index, s112)
2627
- s109 << r112
2628
- if r112
2629
- if (match_len = has_terminal?('s', false, index))
2630
- r114 = true
2631
- @index += match_len
2632
- else
2633
- terminal_parse_failure('\'s\'')
2634
- r114 = nil
2635
- end
2636
- s109 << r114
2637
- end
2298
+ if r80
2299
+ r80 = SyntaxNode.new(input, (index-1)...index) if r80 == true
2300
+ r77 = r80
2301
+ else
2302
+ @index = i77
2303
+ r77 = nil
2638
2304
  end
2639
2305
  end
2640
- if s109.last
2641
- r109 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i109...index, s109)
2642
- r109.extend(Int11)
2306
+ if r77
2307
+ r76 = r77
2643
2308
  else
2644
- @index = i109
2645
- r109 = nil
2309
+ r76 = instantiate_node(SyntaxNode,input, index...index)
2646
2310
  end
2647
- if r109
2648
- r109 = SyntaxNode.new(input, (index-1)...index) if r109 == true
2649
- r0 = r109
2650
- else
2651
- i115, s115 = index, []
2652
- if (match_len = has_terminal?('0b', false, index))
2653
- r116 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2311
+ s75 << r76
2312
+ if r76
2313
+ if (match_len = has_terminal?("'", false, index))
2314
+ r81 = true
2654
2315
  @index += match_len
2655
2316
  else
2656
- terminal_parse_failure('\'0b\'')
2657
- r116 = nil
2317
+ terminal_parse_failure('"\'"')
2318
+ r81 = nil
2658
2319
  end
2659
- s115 << r116
2660
- if r116
2661
- if has_terminal?(@regexps[gr = '\A[0-1]'] ||= Regexp.new(gr), :regexp, index)
2662
- r117 = true
2663
- @index += 1
2320
+ s75 << r81
2321
+ if r81
2322
+ if (match_len = has_terminal?('d', false, index))
2323
+ r83 = true
2324
+ @index += match_len
2664
2325
  else
2665
- terminal_parse_failure('[0-1]')
2666
- r117 = nil
2667
- end
2668
- s115 << r117
2669
- if r117
2670
- s118, i118 = [], index
2671
- loop do
2672
- if has_terminal?(@regexps[gr = '\A[0-1_]'] ||= Regexp.new(gr), :regexp, index)
2673
- r119 = true
2674
- @index += 1
2675
- else
2676
- terminal_parse_failure('[0-1_]')
2677
- r119 = nil
2678
- end
2679
- if r119
2680
- s118 << r119
2681
- else
2682
- break
2683
- end
2684
- end
2685
- r118 = instantiate_node(SyntaxNode,input, i118...index, s118)
2686
- s115 << r118
2326
+ terminal_parse_failure('\'d\'')
2327
+ r83 = nil
2687
2328
  end
2688
- end
2689
- if s115.last
2690
- r115 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i115...index, s115)
2691
- r115.extend(Int12)
2692
- else
2693
- @index = i115
2694
- r115 = nil
2695
- end
2696
- if r115
2697
- r115 = SyntaxNode.new(input, (index-1)...index) if r115 == true
2698
- r0 = r115
2699
- else
2700
- i120, s120 = index, []
2701
- if (match_len = has_terminal?('0', false, index))
2702
- r121 = true
2703
- @index += match_len
2329
+ if r83
2330
+ r82 = r83
2704
2331
  else
2705
- terminal_parse_failure('\'0\'')
2706
- r121 = nil
2332
+ r82 = instantiate_node(SyntaxNode,input, index...index)
2707
2333
  end
2708
- s120 << r121
2709
- if r121
2710
- if has_terminal?(@regexps[gr = '\A[0-7]'] ||= Regexp.new(gr), :regexp, index)
2711
- r122 = true
2334
+ s75 << r82
2335
+ if r82
2336
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2337
+ r84 = true
2712
2338
  @index += 1
2713
2339
  else
2714
- terminal_parse_failure('[0-7]')
2715
- r122 = nil
2340
+ terminal_parse_failure('[0-9]')
2341
+ r84 = nil
2716
2342
  end
2717
- s120 << r122
2718
- if r122
2719
- s123, i123 = [], index
2343
+ s75 << r84
2344
+ if r84
2345
+ s85, i85 = [], index
2720
2346
  loop do
2721
- if has_terminal?(@regexps[gr = '\A[0-7_]'] ||= Regexp.new(gr), :regexp, index)
2722
- r124 = true
2347
+ if has_terminal?(@regexps[gr = '\A[0-9_]'] ||= Regexp.new(gr), :regexp, index)
2348
+ r86 = true
2723
2349
  @index += 1
2724
2350
  else
2725
- terminal_parse_failure('[0-7_]')
2726
- r124 = nil
2351
+ terminal_parse_failure('[0-9_]')
2352
+ r86 = nil
2727
2353
  end
2728
- if r124
2729
- s123 << r124
2354
+ if r86
2355
+ s85 << r86
2730
2356
  else
2731
2357
  break
2732
2358
  end
2733
2359
  end
2734
- r123 = instantiate_node(SyntaxNode,input, i123...index, s123)
2735
- s120 << r123
2360
+ r85 = instantiate_node(SyntaxNode,input, i85...index, s85)
2361
+ s75 << r85
2736
2362
  end
2737
2363
  end
2738
- if s120.last
2739
- r120 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i120...index, s120)
2740
- r120.extend(Int13)
2364
+ end
2365
+ end
2366
+ if s75.last
2367
+ r75 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i75...index, s75)
2368
+ r75.extend(Int11)
2369
+ else
2370
+ @index = i75
2371
+ r75 = nil
2372
+ end
2373
+ if r75
2374
+ r75 = SyntaxNode.new(input, (index-1)...index) if r75 == true
2375
+ r0 = r75
2376
+ else
2377
+ i87, s87 = index, []
2378
+ i89 = index
2379
+ s90, i90 = [], index
2380
+ loop do
2381
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2382
+ r91 = true
2383
+ @index += 1
2741
2384
  else
2742
- @index = i120
2743
- r120 = nil
2385
+ terminal_parse_failure('[0-9]')
2386
+ r91 = nil
2744
2387
  end
2745
- if r120
2746
- r120 = SyntaxNode.new(input, (index-1)...index) if r120 == true
2747
- r0 = r120
2388
+ if r91
2389
+ s90 << r91
2748
2390
  else
2749
- i125, s125 = index, []
2750
- if has_terminal?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
2751
- r126 = true
2752
- @index += 1
2391
+ break
2392
+ end
2393
+ end
2394
+ if s90.empty?
2395
+ @index = i90
2396
+ r90 = nil
2397
+ else
2398
+ r90 = instantiate_node(SyntaxNode,input, i90...index, s90)
2399
+ end
2400
+ if r90
2401
+ r90 = SyntaxNode.new(input, (index-1)...index) if r90 == true
2402
+ r89 = r90
2403
+ else
2404
+ if (match_len = has_terminal?('MXLEN', false, index))
2405
+ r92 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2406
+ @index += match_len
2407
+ else
2408
+ terminal_parse_failure('\'MXLEN\'')
2409
+ r92 = nil
2410
+ end
2411
+ if r92
2412
+ r92 = SyntaxNode.new(input, (index-1)...index) if r92 == true
2413
+ r89 = r92
2414
+ else
2415
+ @index = i89
2416
+ r89 = nil
2417
+ end
2418
+ end
2419
+ if r89
2420
+ r88 = r89
2421
+ else
2422
+ r88 = instantiate_node(SyntaxNode,input, index...index)
2423
+ end
2424
+ s87 << r88
2425
+ if r88
2426
+ if (match_len = has_terminal?("'", false, index))
2427
+ r93 = true
2428
+ @index += match_len
2429
+ else
2430
+ terminal_parse_failure('"\'"')
2431
+ r93 = nil
2432
+ end
2433
+ s87 << r93
2434
+ if r93
2435
+ if (match_len = has_terminal?('h', false, index))
2436
+ r94 = true
2437
+ @index += match_len
2753
2438
  else
2754
- terminal_parse_failure('[1-9]')
2755
- r126 = nil
2439
+ terminal_parse_failure('\'h\'')
2440
+ r94 = nil
2756
2441
  end
2757
- s125 << r126
2758
- if r126
2759
- s127, i127 = [], index
2760
- loop do
2761
- if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2762
- r128 = true
2763
- @index += 1
2764
- else
2765
- terminal_parse_failure('[0-9]')
2766
- r128 = nil
2767
- end
2768
- if r128
2769
- s127 << r128
2770
- else
2771
- break
2442
+ s87 << r94
2443
+ if r94
2444
+ if has_terminal?(@regexps[gr = '\A[0-9a-fA-FxX]'] ||= Regexp.new(gr), :regexp, index)
2445
+ r95 = true
2446
+ @index += 1
2447
+ else
2448
+ terminal_parse_failure('[0-9a-fA-FxX]')
2449
+ r95 = nil
2450
+ end
2451
+ s87 << r95
2452
+ if r95
2453
+ s96, i96 = [], index
2454
+ loop do
2455
+ if has_terminal?(@regexps[gr = '\A[0-9a-fA-F_xX]'] ||= Regexp.new(gr), :regexp, index)
2456
+ r97 = true
2457
+ @index += 1
2458
+ else
2459
+ terminal_parse_failure('[0-9a-fA-F_xX]')
2460
+ r97 = nil
2461
+ end
2462
+ if r97
2463
+ s96 << r97
2464
+ else
2465
+ break
2466
+ end
2772
2467
  end
2468
+ r96 = instantiate_node(SyntaxNode,input, i96...index, s96)
2469
+ s87 << r96
2773
2470
  end
2774
- r127 = instantiate_node(SyntaxNode,input, i127...index, s127)
2775
- s125 << r127
2776
2471
  end
2777
- if s125.last
2778
- r125 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i125...index, s125)
2779
- r125.extend(Int14)
2472
+ end
2473
+ end
2474
+ if s87.last
2475
+ r87 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i87...index, s87)
2476
+ r87.extend(Int12)
2477
+ else
2478
+ @index = i87
2479
+ r87 = nil
2480
+ end
2481
+ if r87
2482
+ r87 = SyntaxNode.new(input, (index-1)...index) if r87 == true
2483
+ r0 = r87
2484
+ else
2485
+ i98, s98 = index, []
2486
+ i100 = index
2487
+ s101, i101 = [], index
2488
+ loop do
2489
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2490
+ r102 = true
2491
+ @index += 1
2492
+ else
2493
+ terminal_parse_failure('[0-9]')
2494
+ r102 = nil
2495
+ end
2496
+ if r102
2497
+ s101 << r102
2498
+ else
2499
+ break
2500
+ end
2501
+ end
2502
+ if s101.empty?
2503
+ @index = i101
2504
+ r101 = nil
2505
+ else
2506
+ r101 = instantiate_node(SyntaxNode,input, i101...index, s101)
2507
+ end
2508
+ if r101
2509
+ r101 = SyntaxNode.new(input, (index-1)...index) if r101 == true
2510
+ r100 = r101
2511
+ else
2512
+ if (match_len = has_terminal?('MXLEN', false, index))
2513
+ r103 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2514
+ @index += match_len
2515
+ else
2516
+ terminal_parse_failure('\'MXLEN\'')
2517
+ r103 = nil
2518
+ end
2519
+ if r103
2520
+ r103 = SyntaxNode.new(input, (index-1)...index) if r103 == true
2521
+ r100 = r103
2780
2522
  else
2781
- @index = i125
2782
- r125 = nil
2523
+ @index = i100
2524
+ r100 = nil
2783
2525
  end
2784
- if r125
2785
- r125 = SyntaxNode.new(input, (index-1)...index) if r125 == true
2786
- r0 = r125
2526
+ end
2527
+ if r100
2528
+ r99 = r100
2529
+ else
2530
+ r99 = instantiate_node(SyntaxNode,input, index...index)
2531
+ end
2532
+ s98 << r99
2533
+ if r99
2534
+ if (match_len = has_terminal?("'", false, index))
2535
+ r104 = true
2536
+ @index += match_len
2787
2537
  else
2788
- i129, s129 = index, []
2789
- if (match_len = has_terminal?('0x', false, index))
2790
- r130 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2538
+ terminal_parse_failure('"\'"')
2539
+ r104 = nil
2540
+ end
2541
+ s98 << r104
2542
+ if r104
2543
+ if (match_len = has_terminal?('sb', false, index))
2544
+ r105 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2791
2545
  @index += match_len
2792
2546
  else
2793
- terminal_parse_failure('\'0x\'')
2794
- r130 = nil
2547
+ terminal_parse_failure('\'sb\'')
2548
+ r105 = nil
2795
2549
  end
2796
- s129 << r130
2797
- if r130
2798
- if has_terminal?(@regexps[gr = '\A[0-9a-fA-F]'] ||= Regexp.new(gr), :regexp, index)
2799
- r131 = true
2550
+ s98 << r105
2551
+ if r105
2552
+ if has_terminal?(@regexps[gr = '\A[0-1xX]'] ||= Regexp.new(gr), :regexp, index)
2553
+ r106 = true
2800
2554
  @index += 1
2801
2555
  else
2802
- terminal_parse_failure('[0-9a-fA-F]')
2803
- r131 = nil
2556
+ terminal_parse_failure('[0-1xX]')
2557
+ r106 = nil
2804
2558
  end
2805
- s129 << r131
2806
- if r131
2807
- s132, i132 = [], index
2559
+ s98 << r106
2560
+ if r106
2561
+ s107, i107 = [], index
2808
2562
  loop do
2809
- if has_terminal?(@regexps[gr = '\A[0-9a-fA-F_]'] ||= Regexp.new(gr), :regexp, index)
2810
- r133 = true
2563
+ if has_terminal?(@regexps[gr = '\A[0-1_xX]'] ||= Regexp.new(gr), :regexp, index)
2564
+ r108 = true
2811
2565
  @index += 1
2812
2566
  else
2813
- terminal_parse_failure('[0-9a-fA-F_]')
2814
- r133 = nil
2567
+ terminal_parse_failure('[0-1_xX]')
2568
+ r108 = nil
2815
2569
  end
2816
- if r133
2817
- s132 << r133
2570
+ if r108
2571
+ s107 << r108
2818
2572
  else
2819
2573
  break
2820
2574
  end
2821
2575
  end
2822
- r132 = instantiate_node(SyntaxNode,input, i132...index, s132)
2823
- s129 << r132
2576
+ r107 = instantiate_node(SyntaxNode,input, i107...index, s107)
2577
+ s98 << r107
2824
2578
  end
2825
2579
  end
2826
- if s129.last
2827
- r129 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i129...index, s129)
2828
- r129.extend(Int15)
2580
+ end
2581
+ end
2582
+ if s98.last
2583
+ r98 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i98...index, s98)
2584
+ r98.extend(Int13)
2585
+ else
2586
+ @index = i98
2587
+ r98 = nil
2588
+ end
2589
+ if r98
2590
+ r98 = SyntaxNode.new(input, (index-1)...index) if r98 == true
2591
+ r0 = r98
2592
+ else
2593
+ i109, s109 = index, []
2594
+ i111 = index
2595
+ s112, i112 = [], index
2596
+ loop do
2597
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2598
+ r113 = true
2599
+ @index += 1
2600
+ else
2601
+ terminal_parse_failure('[0-9]')
2602
+ r113 = nil
2603
+ end
2604
+ if r113
2605
+ s112 << r113
2606
+ else
2607
+ break
2608
+ end
2609
+ end
2610
+ if s112.empty?
2611
+ @index = i112
2612
+ r112 = nil
2613
+ else
2614
+ r112 = instantiate_node(SyntaxNode,input, i112...index, s112)
2615
+ end
2616
+ if r112
2617
+ r112 = SyntaxNode.new(input, (index-1)...index) if r112 == true
2618
+ r111 = r112
2619
+ else
2620
+ if (match_len = has_terminal?('MXLEN', false, index))
2621
+ r114 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2622
+ @index += match_len
2623
+ else
2624
+ terminal_parse_failure('\'MXLEN\'')
2625
+ r114 = nil
2626
+ end
2627
+ if r114
2628
+ r114 = SyntaxNode.new(input, (index-1)...index) if r114 == true
2629
+ r111 = r114
2829
2630
  else
2830
- @index = i129
2831
- r129 = nil
2631
+ @index = i111
2632
+ r111 = nil
2832
2633
  end
2833
- if r129
2834
- r129 = SyntaxNode.new(input, (index-1)...index) if r129 == true
2835
- r0 = r129
2634
+ end
2635
+ if r111
2636
+ r110 = r111
2637
+ else
2638
+ r110 = instantiate_node(SyntaxNode,input, index...index)
2639
+ end
2640
+ s109 << r110
2641
+ if r110
2642
+ if (match_len = has_terminal?("'", false, index))
2643
+ r115 = true
2644
+ @index += match_len
2836
2645
  else
2837
- i134, s134 = index, []
2838
- if (match_len = has_terminal?('0', false, index))
2839
- r135 = true
2646
+ terminal_parse_failure('"\'"')
2647
+ r115 = nil
2648
+ end
2649
+ s109 << r115
2650
+ if r115
2651
+ if (match_len = has_terminal?('so', false, index))
2652
+ r116 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2840
2653
  @index += match_len
2841
2654
  else
2842
- terminal_parse_failure('\'0\'')
2843
- r135 = nil
2655
+ terminal_parse_failure('\'so\'')
2656
+ r116 = nil
2844
2657
  end
2845
- s134 << r135
2846
- if r135
2658
+ s109 << r116
2659
+ if r116
2660
+ if has_terminal?(@regexps[gr = '\A[0-7xX]'] ||= Regexp.new(gr), :regexp, index)
2661
+ r117 = true
2662
+ @index += 1
2663
+ else
2664
+ terminal_parse_failure('[0-7xX]')
2665
+ r117 = nil
2666
+ end
2667
+ s109 << r117
2668
+ if r117
2669
+ s118, i118 = [], index
2670
+ loop do
2671
+ if has_terminal?(@regexps[gr = '\A[0-7_xX]'] ||= Regexp.new(gr), :regexp, index)
2672
+ r119 = true
2673
+ @index += 1
2674
+ else
2675
+ terminal_parse_failure('[0-7_xX]')
2676
+ r119 = nil
2677
+ end
2678
+ if r119
2679
+ s118 << r119
2680
+ else
2681
+ break
2682
+ end
2683
+ end
2684
+ r118 = instantiate_node(SyntaxNode,input, i118...index, s118)
2685
+ s109 << r118
2686
+ end
2687
+ end
2688
+ end
2689
+ end
2690
+ if s109.last
2691
+ r109 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i109...index, s109)
2692
+ r109.extend(Int14)
2693
+ else
2694
+ @index = i109
2695
+ r109 = nil
2696
+ end
2697
+ if r109
2698
+ r109 = SyntaxNode.new(input, (index-1)...index) if r109 == true
2699
+ r0 = r109
2700
+ else
2701
+ i120, s120 = index, []
2702
+ i122 = index
2703
+ s123, i123 = [], index
2704
+ loop do
2705
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2706
+ r124 = true
2707
+ @index += 1
2708
+ else
2709
+ terminal_parse_failure('[0-9]')
2710
+ r124 = nil
2711
+ end
2712
+ if r124
2713
+ s123 << r124
2714
+ else
2715
+ break
2716
+ end
2717
+ end
2718
+ if s123.empty?
2719
+ @index = i123
2720
+ r123 = nil
2721
+ else
2722
+ r123 = instantiate_node(SyntaxNode,input, i123...index, s123)
2723
+ end
2724
+ if r123
2725
+ r123 = SyntaxNode.new(input, (index-1)...index) if r123 == true
2726
+ r122 = r123
2727
+ else
2728
+ if (match_len = has_terminal?('MXLEN', false, index))
2729
+ r125 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2730
+ @index += match_len
2731
+ else
2732
+ terminal_parse_failure('\'MXLEN\'')
2733
+ r125 = nil
2734
+ end
2735
+ if r125
2736
+ r125 = SyntaxNode.new(input, (index-1)...index) if r125 == true
2737
+ r122 = r125
2738
+ else
2739
+ @index = i122
2740
+ r122 = nil
2741
+ end
2742
+ end
2743
+ if r122
2744
+ r121 = r122
2745
+ else
2746
+ r121 = instantiate_node(SyntaxNode,input, index...index)
2747
+ end
2748
+ s120 << r121
2749
+ if r121
2750
+ if (match_len = has_terminal?("'", false, index))
2751
+ r126 = true
2752
+ @index += match_len
2753
+ else
2754
+ terminal_parse_failure('"\'"')
2755
+ r126 = nil
2756
+ end
2757
+ s120 << r126
2758
+ if r126
2847
2759
  if (match_len = has_terminal?('s', false, index))
2848
- r137 = true
2760
+ r127 = true
2849
2761
  @index += match_len
2850
2762
  else
2851
2763
  terminal_parse_failure('\'s\'')
2764
+ r127 = nil
2765
+ end
2766
+ s120 << r127
2767
+ if r127
2768
+ if (match_len = has_terminal?('d', false, index))
2769
+ r129 = true
2770
+ @index += match_len
2771
+ else
2772
+ terminal_parse_failure('\'d\'')
2773
+ r129 = nil
2774
+ end
2775
+ if r129
2776
+ r128 = r129
2777
+ else
2778
+ r128 = instantiate_node(SyntaxNode,input, index...index)
2779
+ end
2780
+ s120 << r128
2781
+ if r128
2782
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2783
+ r130 = true
2784
+ @index += 1
2785
+ else
2786
+ terminal_parse_failure('[0-9]')
2787
+ r130 = nil
2788
+ end
2789
+ s120 << r130
2790
+ if r130
2791
+ s131, i131 = [], index
2792
+ loop do
2793
+ if has_terminal?(@regexps[gr = '\A[0-9_]'] ||= Regexp.new(gr), :regexp, index)
2794
+ r132 = true
2795
+ @index += 1
2796
+ else
2797
+ terminal_parse_failure('[0-9_]')
2798
+ r132 = nil
2799
+ end
2800
+ if r132
2801
+ s131 << r132
2802
+ else
2803
+ break
2804
+ end
2805
+ end
2806
+ r131 = instantiate_node(SyntaxNode,input, i131...index, s131)
2807
+ s120 << r131
2808
+ end
2809
+ end
2810
+ end
2811
+ end
2812
+ end
2813
+ if s120.last
2814
+ r120 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i120...index, s120)
2815
+ r120.extend(Int15)
2816
+ else
2817
+ @index = i120
2818
+ r120 = nil
2819
+ end
2820
+ if r120
2821
+ r120 = SyntaxNode.new(input, (index-1)...index) if r120 == true
2822
+ r0 = r120
2823
+ else
2824
+ i133, s133 = index, []
2825
+ i135 = index
2826
+ s136, i136 = [], index
2827
+ loop do
2828
+ if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
2829
+ r137 = true
2830
+ @index += 1
2831
+ else
2832
+ terminal_parse_failure('[0-9]')
2852
2833
  r137 = nil
2853
2834
  end
2854
2835
  if r137
2855
- r136 = r137
2836
+ s136 << r137
2837
+ else
2838
+ break
2839
+ end
2840
+ end
2841
+ if s136.empty?
2842
+ @index = i136
2843
+ r136 = nil
2844
+ else
2845
+ r136 = instantiate_node(SyntaxNode,input, i136...index, s136)
2846
+ end
2847
+ if r136
2848
+ r136 = SyntaxNode.new(input, (index-1)...index) if r136 == true
2849
+ r135 = r136
2850
+ else
2851
+ if (match_len = has_terminal?('MXLEN', false, index))
2852
+ r138 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2853
+ @index += match_len
2854
+ else
2855
+ terminal_parse_failure('\'MXLEN\'')
2856
+ r138 = nil
2857
+ end
2858
+ if r138
2859
+ r138 = SyntaxNode.new(input, (index-1)...index) if r138 == true
2860
+ r135 = r138
2856
2861
  else
2857
- r136 = instantiate_node(SyntaxNode,input, index...index)
2862
+ @index = i135
2863
+ r135 = nil
2858
2864
  end
2859
- s134 << r136
2860
2865
  end
2861
- if s134.last
2862
- r134 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i134...index, s134)
2863
- r134.extend(Int16)
2866
+ if r135
2867
+ r134 = r135
2864
2868
  else
2865
- @index = i134
2866
- r134 = nil
2869
+ r134 = instantiate_node(SyntaxNode,input, index...index)
2867
2870
  end
2871
+ s133 << r134
2868
2872
  if r134
2869
- r134 = SyntaxNode.new(input, (index-1)...index) if r134 == true
2870
- r0 = r134
2873
+ if (match_len = has_terminal?("'", false, index))
2874
+ r139 = true
2875
+ @index += match_len
2876
+ else
2877
+ terminal_parse_failure('"\'"')
2878
+ r139 = nil
2879
+ end
2880
+ s133 << r139
2881
+ if r139
2882
+ if (match_len = has_terminal?('sh', false, index))
2883
+ r140 = instantiate_node(SyntaxNode,input, index...(index + match_len))
2884
+ @index += match_len
2885
+ else
2886
+ terminal_parse_failure('\'sh\'')
2887
+ r140 = nil
2888
+ end
2889
+ s133 << r140
2890
+ if r140
2891
+ if has_terminal?(@regexps[gr = '\A[0-9a-fA-FxX]'] ||= Regexp.new(gr), :regexp, index)
2892
+ r141 = true
2893
+ @index += 1
2894
+ else
2895
+ terminal_parse_failure('[0-9a-fA-FxX]')
2896
+ r141 = nil
2897
+ end
2898
+ s133 << r141
2899
+ if r141
2900
+ s142, i142 = [], index
2901
+ loop do
2902
+ if has_terminal?(@regexps[gr = '\A[0-9a-fA-F_xX]'] ||= Regexp.new(gr), :regexp, index)
2903
+ r143 = true
2904
+ @index += 1
2905
+ else
2906
+ terminal_parse_failure('[0-9a-fA-F_xX]')
2907
+ r143 = nil
2908
+ end
2909
+ if r143
2910
+ s142 << r143
2911
+ else
2912
+ break
2913
+ end
2914
+ end
2915
+ r142 = instantiate_node(SyntaxNode,input, i142...index, s142)
2916
+ s133 << r142
2917
+ end
2918
+ end
2919
+ end
2920
+ end
2921
+ if s133.last
2922
+ r133 = instantiate_node(Idl::IntLiteralSyntaxNode,input, i133...index, s133)
2923
+ r133.extend(Int16)
2924
+ else
2925
+ @index = i133
2926
+ r133 = nil
2927
+ end
2928
+ if r133
2929
+ r133 = SyntaxNode.new(input, (index-1)...index) if r133 == true
2930
+ r0 = r133
2871
2931
  else
2872
2932
  @index = i0
2873
2933
  r0 = nil
@@ -6182,7 +6242,7 @@ module Idl
6182
6242
  end
6183
6243
 
6184
6244
  i0 = index
6185
- r1 = _nt_enum_to_a
6245
+ r1 = _nt_dollar_function_call
6186
6246
  if r1
6187
6247
  r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
6188
6248
  r0 = r1
@@ -6217,7 +6277,7 @@ module Idl
6217
6277
  r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
6218
6278
  r0 = r7
6219
6279
  else
6220
- r8 = _nt_bits_cast
6280
+ r8 = _nt_csr_register_access_expression
6221
6281
  if r8
6222
6282
  r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
6223
6283
  r0 = r8
@@ -6566,110 +6626,135 @@ module Idl
6566
6626
  r0
6567
6627
  end
6568
6628
 
6569
- module BitsCast0
6570
- def expr
6571
- elements[4]
6629
+ module DollarFunctionCall0
6630
+ end
6631
+
6632
+ module DollarFunctionCall1
6633
+ def name
6634
+ elements[1]
6635
+ end
6636
+
6637
+ def args
6638
+ elements[5]
6572
6639
  end
6573
6640
 
6574
6641
  end
6575
6642
 
6576
- def _nt_bits_cast
6643
+ def _nt_dollar_function_call
6577
6644
  start_index = index
6578
- if node_cache[:bits_cast].has_key?(index)
6579
- cached = node_cache[:bits_cast][index]
6645
+ if node_cache[:dollar_function_call].has_key?(index)
6646
+ cached = node_cache[:dollar_function_call][index]
6580
6647
  if cached
6581
- node_cache[:bits_cast][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
6648
+ node_cache[:dollar_function_call][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
6582
6649
  @index = cached.interval.end
6583
6650
  end
6584
6651
  return cached
6585
6652
  end
6586
6653
 
6587
6654
  i0, s0 = index, []
6588
- if (match_len = has_terminal?('$bits', false, index))
6589
- r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
6655
+ if (match_len = has_terminal?('$', false, index))
6656
+ r1 = true
6590
6657
  @index += match_len
6591
6658
  else
6592
- terminal_parse_failure('\'$bits\'')
6659
+ terminal_parse_failure('\'$\'')
6593
6660
  r1 = nil
6594
6661
  end
6595
6662
  s0 << r1
6596
6663
  if r1
6597
- s2, i2 = [], index
6598
- loop do
6599
- r3 = _nt_space
6600
- if r3
6601
- s2 << r3
6602
- else
6603
- break
6664
+ i2, s2 = index, []
6665
+ if has_terminal?(@regexps[gr = '\A[a-zA-Z_]'] ||= Regexp.new(gr), :regexp, index)
6666
+ r3 = true
6667
+ @index += 1
6668
+ else
6669
+ terminal_parse_failure('[a-zA-Z_]')
6670
+ r3 = nil
6671
+ end
6672
+ s2 << r3
6673
+ if r3
6674
+ s4, i4 = [], index
6675
+ loop do
6676
+ if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_?]'] ||= Regexp.new(gr), :regexp, index)
6677
+ r5 = true
6678
+ @index += 1
6679
+ else
6680
+ terminal_parse_failure('[a-zA-Z0-9_?]')
6681
+ r5 = nil
6682
+ end
6683
+ if r5
6684
+ s4 << r5
6685
+ else
6686
+ break
6687
+ end
6604
6688
  end
6689
+ r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
6690
+ s2 << r4
6691
+ end
6692
+ if s2.last
6693
+ r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
6694
+ r2.extend(DollarFunctionCall0)
6695
+ else
6696
+ @index = i2
6697
+ r2 = nil
6605
6698
  end
6606
- r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
6607
6699
  s0 << r2
6608
6700
  if r2
6609
- if (match_len = has_terminal?('(', false, index))
6610
- r4 = true
6611
- @index += match_len
6612
- else
6613
- terminal_parse_failure('\'(\'')
6614
- r4 = nil
6701
+ s6, i6 = [], index
6702
+ loop do
6703
+ r7 = _nt_space
6704
+ if r7
6705
+ s6 << r7
6706
+ else
6707
+ break
6708
+ end
6615
6709
  end
6616
- s0 << r4
6617
- if r4
6618
- s5, i5 = [], index
6619
- loop do
6620
- r6 = _nt_space
6621
- if r6
6622
- s5 << r6
6623
- else
6624
- break
6625
- end
6710
+ r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
6711
+ s0 << r6
6712
+ if r6
6713
+ if (match_len = has_terminal?('(', false, index))
6714
+ r8 = true
6715
+ @index += match_len
6716
+ else
6717
+ terminal_parse_failure('\'(\'')
6718
+ r8 = nil
6626
6719
  end
6627
- r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
6628
- s0 << r5
6629
- if r5
6630
- i7 = index
6631
- r8 = _nt_csr_register_access_expression
6632
- if r8
6633
- r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
6634
- r7 = r8
6635
- else
6636
- r9 = _nt_enum_ref
6637
- if r9
6638
- r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
6639
- r7 = r9
6720
+ s0 << r8
6721
+ if r8
6722
+ s9, i9 = [], index
6723
+ loop do
6724
+ r10 = _nt_space
6725
+ if r10
6726
+ s9 << r10
6640
6727
  else
6641
- r10 = _nt_expression
6642
- if r10
6643
- r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
6644
- r7 = r10
6645
- else
6646
- @index = i7
6647
- r7 = nil
6648
- end
6728
+ break
6649
6729
  end
6650
6730
  end
6651
- s0 << r7
6652
- if r7
6653
- s11, i11 = [], index
6654
- loop do
6655
- r12 = _nt_space
6656
- if r12
6657
- s11 << r12
6658
- else
6659
- break
6660
- end
6661
- end
6662
- r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
6731
+ r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
6732
+ s0 << r9
6733
+ if r9
6734
+ r11 = _nt_dollar_arg_list
6663
6735
  s0 << r11
6664
6736
  if r11
6665
- if (match_len = has_terminal?(')', false, index))
6666
- r13 = true
6667
- @index += match_len
6668
- else
6669
- terminal_parse_failure('\')\'')
6670
- r13 = nil
6737
+ s12, i12 = [], index
6738
+ loop do
6739
+ r13 = _nt_space
6740
+ if r13
6741
+ s12 << r13
6742
+ else
6743
+ break
6744
+ end
6745
+ end
6746
+ r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
6747
+ s0 << r12
6748
+ if r12
6749
+ if (match_len = has_terminal?(')', false, index))
6750
+ r14 = true
6751
+ @index += match_len
6752
+ else
6753
+ terminal_parse_failure('\')\'')
6754
+ r14 = nil
6755
+ end
6756
+ s0 << r14
6671
6757
  end
6672
- s0 << r13
6673
6758
  end
6674
6759
  end
6675
6760
  end
@@ -6677,183 +6762,222 @@ module Idl
6677
6762
  end
6678
6763
  end
6679
6764
  if s0.last
6680
- r0 = instantiate_node(Idl::BitsCastSyntaxNode,input, i0...index, s0)
6681
- r0.extend(BitsCast0)
6765
+ r0 = instantiate_node(Idl::DollarFunctionCallSyntaxNode,input, i0...index, s0)
6766
+ r0.extend(DollarFunctionCall1)
6682
6767
  else
6683
6768
  @index = i0
6684
6769
  r0 = nil
6685
6770
  end
6686
6771
 
6687
- node_cache[:bits_cast][start_index] = r0
6772
+ node_cache[:dollar_function_call][start_index] = r0
6688
6773
 
6689
6774
  r0
6690
6775
  end
6691
6776
 
6692
- module EnumToA0
6693
- def type_name
6694
- elements[4]
6695
- end
6777
+ module DollarVariable0
6778
+ end
6696
6779
 
6780
+ module DollarVariable1
6781
+ def name
6782
+ elements[1]
6783
+ end
6697
6784
  end
6698
6785
 
6699
- def _nt_enum_to_a
6786
+ def _nt_dollar_variable
6700
6787
  start_index = index
6701
- if node_cache[:enum_to_a].has_key?(index)
6702
- cached = node_cache[:enum_to_a][index]
6788
+ if node_cache[:dollar_variable].has_key?(index)
6789
+ cached = node_cache[:dollar_variable][index]
6703
6790
  if cached
6704
- node_cache[:enum_to_a][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
6791
+ node_cache[:dollar_variable][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
6705
6792
  @index = cached.interval.end
6706
6793
  end
6707
6794
  return cached
6708
6795
  end
6709
6796
 
6710
6797
  i0, s0 = index, []
6711
- if (match_len = has_terminal?('$enum_to_a', false, index))
6712
- r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
6798
+ if (match_len = has_terminal?('$', false, index))
6799
+ r1 = true
6713
6800
  @index += match_len
6714
6801
  else
6715
- terminal_parse_failure('\'$enum_to_a\'')
6802
+ terminal_parse_failure('\'$\'')
6716
6803
  r1 = nil
6717
6804
  end
6718
6805
  s0 << r1
6719
6806
  if r1
6720
- s2, i2 = [], index
6721
- loop do
6722
- r3 = _nt_space
6723
- if r3
6724
- s2 << r3
6725
- else
6726
- break
6727
- end
6807
+ i2, s2 = index, []
6808
+ if has_terminal?(@regexps[gr = '\A[a-zA-Z_]'] ||= Regexp.new(gr), :regexp, index)
6809
+ r3 = true
6810
+ @index += 1
6811
+ else
6812
+ terminal_parse_failure('[a-zA-Z_]')
6813
+ r3 = nil
6728
6814
  end
6729
- r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
6730
- s0 << r2
6731
- if r2
6732
- if (match_len = has_terminal?('(', false, index))
6733
- r4 = true
6734
- @index += match_len
6735
- else
6736
- terminal_parse_failure('\'(\'')
6737
- r4 = nil
6738
- end
6739
- s0 << r4
6740
- if r4
6741
- s5, i5 = [], index
6742
- loop do
6743
- r6 = _nt_space
6744
- if r6
6745
- s5 << r6
6746
- else
6747
- break
6748
- end
6815
+ s2 << r3
6816
+ if r3
6817
+ s4, i4 = [], index
6818
+ loop do
6819
+ if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_]'] ||= Regexp.new(gr), :regexp, index)
6820
+ r5 = true
6821
+ @index += 1
6822
+ else
6823
+ terminal_parse_failure('[a-zA-Z0-9_]')
6824
+ r5 = nil
6749
6825
  end
6750
- r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
6751
- s0 << r5
6752
6826
  if r5
6753
- r7 = _nt_type_name
6754
- s0 << r7
6755
- if r7
6756
- if (match_len = has_terminal?(')', false, index))
6757
- r8 = true
6758
- @index += match_len
6759
- else
6760
- terminal_parse_failure('\')\'')
6761
- r8 = nil
6762
- end
6763
- s0 << r8
6764
- end
6827
+ s4 << r5
6828
+ else
6829
+ break
6765
6830
  end
6766
6831
  end
6832
+ r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
6833
+ s2 << r4
6834
+ end
6835
+ if s2.last
6836
+ r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
6837
+ r2.extend(DollarVariable0)
6838
+ else
6839
+ @index = i2
6840
+ r2 = nil
6767
6841
  end
6842
+ s0 << r2
6768
6843
  end
6769
6844
  if s0.last
6770
- r0 = instantiate_node(Idl::EnumArrayCastSyntaxNode,input, i0...index, s0)
6771
- r0.extend(EnumToA0)
6845
+ r0 = instantiate_node(Idl::DollarVariableSyntaxNode,input, i0...index, s0)
6846
+ r0.extend(DollarVariable1)
6772
6847
  else
6773
6848
  @index = i0
6774
6849
  r0 = nil
6775
6850
  end
6776
6851
 
6777
- node_cache[:enum_to_a][start_index] = r0
6852
+ node_cache[:dollar_variable][start_index] = r0
6778
6853
 
6779
6854
  r0
6780
6855
  end
6781
6856
 
6782
- module UnaryExpression0
6857
+ module DollarArgList0
6783
6858
  def expression
6784
6859
  elements[3]
6785
6860
  end
6786
6861
  end
6787
6862
 
6788
- module UnaryExpression1
6863
+ module DollarArgList1
6789
6864
  def first
6790
- elements[2]
6865
+ elements[0]
6791
6866
  end
6792
6867
 
6793
6868
  def rest
6794
- elements[3]
6795
- end
6796
-
6797
- end
6798
-
6799
- module UnaryExpression2
6800
- def expression
6801
- elements[4]
6869
+ elements[1]
6802
6870
  end
6803
-
6804
6871
  end
6805
6872
 
6806
- module UnaryExpression3
6807
- def expression
6808
- elements[4]
6873
+ def _nt_dollar_arg_list
6874
+ start_index = index
6875
+ if node_cache[:dollar_arg_list].has_key?(index)
6876
+ cached = node_cache[:dollar_arg_list][index]
6877
+ if cached
6878
+ node_cache[:dollar_arg_list][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
6879
+ @index = cached.interval.end
6880
+ end
6881
+ return cached
6809
6882
  end
6810
6883
 
6811
- end
6812
-
6813
- module UnaryExpression4
6814
- def type_name
6815
- elements[4]
6884
+ i0, s0 = index, []
6885
+ r2 = _nt_expression
6886
+ if r2
6887
+ r1 = r2
6888
+ else
6889
+ r1 = instantiate_node(SyntaxNode,input, index...index)
6816
6890
  end
6817
-
6818
- end
6819
-
6820
- module UnaryExpression5
6821
- def type_name
6822
- elements[4]
6891
+ s0 << r1
6892
+ if r1
6893
+ s3, i3 = [], index
6894
+ loop do
6895
+ i4, s4 = index, []
6896
+ s5, i5 = [], index
6897
+ loop do
6898
+ r6 = _nt_space
6899
+ if r6
6900
+ s5 << r6
6901
+ else
6902
+ break
6903
+ end
6904
+ end
6905
+ r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
6906
+ s4 << r5
6907
+ if r5
6908
+ if (match_len = has_terminal?(',', false, index))
6909
+ r7 = true
6910
+ @index += match_len
6911
+ else
6912
+ terminal_parse_failure('\',\'')
6913
+ r7 = nil
6914
+ end
6915
+ s4 << r7
6916
+ if r7
6917
+ s8, i8 = [], index
6918
+ loop do
6919
+ r9 = _nt_space
6920
+ if r9
6921
+ s8 << r9
6922
+ else
6923
+ break
6924
+ end
6925
+ end
6926
+ r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
6927
+ s4 << r8
6928
+ if r8
6929
+ r10 = _nt_expression
6930
+ s4 << r10
6931
+ end
6932
+ end
6933
+ end
6934
+ if s4.last
6935
+ r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
6936
+ r4.extend(DollarArgList0)
6937
+ else
6938
+ @index = i4
6939
+ r4 = nil
6940
+ end
6941
+ if r4
6942
+ s3 << r4
6943
+ else
6944
+ break
6945
+ end
6946
+ end
6947
+ r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
6948
+ s0 << r3
6823
6949
  end
6824
-
6825
- end
6826
-
6827
- module UnaryExpression6
6828
- def type_name
6829
- elements[4]
6950
+ if s0.last
6951
+ r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
6952
+ r0.extend(DollarArgList1)
6953
+ else
6954
+ @index = i0
6955
+ r0 = nil
6830
6956
  end
6831
6957
 
6832
- def expression
6833
- elements[8]
6834
- end
6958
+ node_cache[:dollar_arg_list][start_index] = r0
6835
6959
 
6960
+ r0
6836
6961
  end
6837
6962
 
6838
- module UnaryExpression7
6963
+ module UnaryExpression0
6839
6964
  def expression
6840
- elements[4]
6965
+ elements[3]
6841
6966
  end
6842
-
6843
6967
  end
6844
6968
 
6845
- module UnaryExpression8
6846
- def ary
6847
- elements[4]
6969
+ module UnaryExpression1
6970
+ def first
6971
+ elements[2]
6848
6972
  end
6849
6973
 
6850
- def value
6851
- elements[8]
6974
+ def rest
6975
+ elements[3]
6852
6976
  end
6853
6977
 
6854
6978
  end
6855
6979
 
6856
- module UnaryExpression9
6980
+ module UnaryExpression2
6857
6981
  def o
6858
6982
  elements[0]
6859
6983
  end
@@ -6999,749 +7123,120 @@ module Idl
6999
7123
  r18 = nil
7000
7124
  end
7001
7125
  s3 << r18
7002
- end
7003
- end
7004
- end
7005
- end
7006
- end
7007
- if s3.last
7008
- r3 = instantiate_node(Idl::ArrayLiteralSyntaxNode,input, i3...index, s3)
7009
- r3.extend(UnaryExpression1)
7010
- else
7011
- @index = i3
7012
- r3 = nil
7013
- end
7014
- if r3
7015
- r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
7016
- r0 = r3
7017
- else
7018
- r19 = _nt_ary_access
7019
- if r19
7020
- r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
7021
- r0 = r19
7022
- else
7023
- i20, s20 = index, []
7024
- if (match_len = has_terminal?('$width', false, index))
7025
- r21 = instantiate_node(SyntaxNode,input, index...(index + match_len))
7026
- @index += match_len
7027
- else
7028
- terminal_parse_failure('\'$width\'')
7029
- r21 = nil
7030
- end
7031
- s20 << r21
7032
- if r21
7033
- s22, i22 = [], index
7034
- loop do
7035
- r23 = _nt_space
7036
- if r23
7037
- s22 << r23
7038
- else
7039
- break
7040
- end
7041
- end
7042
- r22 = instantiate_node(SyntaxNode,input, i22...index, s22)
7043
- s20 << r22
7044
- if r22
7045
- if (match_len = has_terminal?('(', false, index))
7046
- r24 = true
7047
- @index += match_len
7048
- else
7049
- terminal_parse_failure('\'(\'')
7050
- r24 = nil
7051
- end
7052
- s20 << r24
7053
- if r24
7054
- s25, i25 = [], index
7055
- loop do
7056
- r26 = _nt_space
7057
- if r26
7058
- s25 << r26
7059
- else
7060
- break
7061
- end
7062
- end
7063
- r25 = instantiate_node(SyntaxNode,input, i25...index, s25)
7064
- s20 << r25
7065
- if r25
7066
- r27 = _nt_expression
7067
- s20 << r27
7068
- if r27
7069
- s28, i28 = [], index
7070
- loop do
7071
- r29 = _nt_space
7072
- if r29
7073
- s28 << r29
7074
- else
7075
- break
7076
- end
7077
- end
7078
- r28 = instantiate_node(SyntaxNode,input, i28...index, s28)
7079
- s20 << r28
7080
- if r28
7081
- if (match_len = has_terminal?(')', false, index))
7082
- r30 = true
7083
- @index += match_len
7084
- else
7085
- terminal_parse_failure('\')\'')
7086
- r30 = nil
7087
- end
7088
- s20 << r30
7089
- end
7090
- end
7091
- end
7092
- end
7093
- end
7094
- end
7095
- if s20.last
7096
- r20 = instantiate_node(Idl::WidthRevealSyntaxNode,input, i20...index, s20)
7097
- r20.extend(UnaryExpression2)
7098
- else
7099
- @index = i20
7100
- r20 = nil
7101
- end
7102
- if r20
7103
- r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
7104
- r0 = r20
7105
- else
7106
- i31, s31 = index, []
7107
- if (match_len = has_terminal?('$signed', false, index))
7108
- r32 = instantiate_node(SyntaxNode,input, index...(index + match_len))
7109
- @index += match_len
7110
- else
7111
- terminal_parse_failure('\'$signed\'')
7112
- r32 = nil
7113
- end
7114
- s31 << r32
7115
- if r32
7116
- s33, i33 = [], index
7117
- loop do
7118
- r34 = _nt_space
7119
- if r34
7120
- s33 << r34
7121
- else
7122
- break
7123
- end
7124
- end
7125
- r33 = instantiate_node(SyntaxNode,input, i33...index, s33)
7126
- s31 << r33
7127
- if r33
7128
- if (match_len = has_terminal?('(', false, index))
7129
- r35 = true
7130
- @index += match_len
7131
- else
7132
- terminal_parse_failure('\'(\'')
7133
- r35 = nil
7134
- end
7135
- s31 << r35
7136
- if r35
7137
- s36, i36 = [], index
7138
- loop do
7139
- r37 = _nt_space
7140
- if r37
7141
- s36 << r37
7142
- else
7143
- break
7144
- end
7145
- end
7146
- r36 = instantiate_node(SyntaxNode,input, i36...index, s36)
7147
- s31 << r36
7148
- if r36
7149
- r38 = _nt_expression
7150
- s31 << r38
7151
- if r38
7152
- s39, i39 = [], index
7153
- loop do
7154
- r40 = _nt_space
7155
- if r40
7156
- s39 << r40
7157
- else
7158
- break
7159
- end
7160
- end
7161
- r39 = instantiate_node(SyntaxNode,input, i39...index, s39)
7162
- s31 << r39
7163
- if r39
7164
- if (match_len = has_terminal?(')', false, index))
7165
- r41 = true
7166
- @index += match_len
7167
- else
7168
- terminal_parse_failure('\')\'')
7169
- r41 = nil
7170
- end
7171
- s31 << r41
7172
- end
7173
- end
7174
- end
7175
- end
7176
- end
7177
- end
7178
- if s31.last
7179
- r31 = instantiate_node(Idl::SignCastSyntaxNode,input, i31...index, s31)
7180
- r31.extend(UnaryExpression3)
7181
- else
7182
- @index = i31
7183
- r31 = nil
7184
- end
7185
- if r31
7186
- r31 = SyntaxNode.new(input, (index-1)...index) if r31 == true
7187
- r0 = r31
7188
- else
7189
- r42 = _nt_bits_cast
7190
- if r42
7191
- r42 = SyntaxNode.new(input, (index-1)...index) if r42 == true
7192
- r0 = r42
7193
- else
7194
- i43, s43 = index, []
7195
- if (match_len = has_terminal?('$enum_size', false, index))
7196
- r44 = instantiate_node(SyntaxNode,input, index...(index + match_len))
7197
- @index += match_len
7198
- else
7199
- terminal_parse_failure('\'$enum_size\'')
7200
- r44 = nil
7201
- end
7202
- s43 << r44
7203
- if r44
7204
- s45, i45 = [], index
7205
- loop do
7206
- r46 = _nt_space
7207
- if r46
7208
- s45 << r46
7209
- else
7210
- break
7211
- end
7212
- end
7213
- r45 = instantiate_node(SyntaxNode,input, i45...index, s45)
7214
- s43 << r45
7215
- if r45
7216
- if (match_len = has_terminal?('(', false, index))
7217
- r47 = true
7218
- @index += match_len
7219
- else
7220
- terminal_parse_failure('\'(\'')
7221
- r47 = nil
7222
- end
7223
- s43 << r47
7224
- if r47
7225
- s48, i48 = [], index
7226
- loop do
7227
- r49 = _nt_space
7228
- if r49
7229
- s48 << r49
7230
- else
7231
- break
7232
- end
7233
- end
7234
- r48 = instantiate_node(SyntaxNode,input, i48...index, s48)
7235
- s43 << r48
7236
- if r48
7237
- r50 = _nt_type_name
7238
- s43 << r50
7239
- if r50
7240
- if (match_len = has_terminal?(')', false, index))
7241
- r51 = true
7242
- @index += match_len
7243
- else
7244
- terminal_parse_failure('\')\'')
7245
- r51 = nil
7246
- end
7247
- s43 << r51
7248
- end
7249
- end
7250
- end
7251
- end
7252
- end
7253
- if s43.last
7254
- r43 = instantiate_node(Idl::EnumSizeSyntaxNode,input, i43...index, s43)
7255
- r43.extend(UnaryExpression4)
7256
- else
7257
- @index = i43
7258
- r43 = nil
7259
- end
7260
- if r43
7261
- r43 = SyntaxNode.new(input, (index-1)...index) if r43 == true
7262
- r0 = r43
7263
- else
7264
- i52, s52 = index, []
7265
- if (match_len = has_terminal?('$enum_element_size', false, index))
7266
- r53 = instantiate_node(SyntaxNode,input, index...(index + match_len))
7267
- @index += match_len
7268
- else
7269
- terminal_parse_failure('\'$enum_element_size\'')
7270
- r53 = nil
7271
- end
7272
- s52 << r53
7273
- if r53
7274
- s54, i54 = [], index
7275
- loop do
7276
- r55 = _nt_space
7277
- if r55
7278
- s54 << r55
7279
- else
7280
- break
7281
- end
7282
- end
7283
- r54 = instantiate_node(SyntaxNode,input, i54...index, s54)
7284
- s52 << r54
7285
- if r54
7286
- if (match_len = has_terminal?('(', false, index))
7287
- r56 = true
7288
- @index += match_len
7289
- else
7290
- terminal_parse_failure('\'(\'')
7291
- r56 = nil
7292
- end
7293
- s52 << r56
7294
- if r56
7295
- s57, i57 = [], index
7296
- loop do
7297
- r58 = _nt_space
7298
- if r58
7299
- s57 << r58
7300
- else
7301
- break
7302
- end
7303
- end
7304
- r57 = instantiate_node(SyntaxNode,input, i57...index, s57)
7305
- s52 << r57
7306
- if r57
7307
- r59 = _nt_type_name
7308
- s52 << r59
7309
- if r59
7310
- if (match_len = has_terminal?(')', false, index))
7311
- r60 = true
7312
- @index += match_len
7313
- else
7314
- terminal_parse_failure('\')\'')
7315
- r60 = nil
7316
- end
7317
- s52 << r60
7318
- end
7319
- end
7320
- end
7321
- end
7322
- end
7323
- if s52.last
7324
- r52 = instantiate_node(Idl::EnumElementSizeSyntaxNode,input, i52...index, s52)
7325
- r52.extend(UnaryExpression5)
7326
- else
7327
- @index = i52
7328
- r52 = nil
7329
- end
7330
- if r52
7331
- r52 = SyntaxNode.new(input, (index-1)...index) if r52 == true
7332
- r0 = r52
7333
- else
7334
- r61 = _nt_enum_to_a
7335
- if r61
7336
- r61 = SyntaxNode.new(input, (index-1)...index) if r61 == true
7337
- r0 = r61
7338
- else
7339
- i62, s62 = index, []
7340
- if (match_len = has_terminal?('$enum', false, index))
7341
- r63 = instantiate_node(SyntaxNode,input, index...(index + match_len))
7342
- @index += match_len
7343
- else
7344
- terminal_parse_failure('\'$enum\'')
7345
- r63 = nil
7346
- end
7347
- s62 << r63
7348
- if r63
7349
- s64, i64 = [], index
7350
- loop do
7351
- r65 = _nt_space
7352
- if r65
7353
- s64 << r65
7354
- else
7355
- break
7356
- end
7357
- end
7358
- r64 = instantiate_node(SyntaxNode,input, i64...index, s64)
7359
- s62 << r64
7360
- if r64
7361
- if (match_len = has_terminal?('(', false, index))
7362
- r66 = true
7363
- @index += match_len
7364
- else
7365
- terminal_parse_failure('\'(\'')
7366
- r66 = nil
7367
- end
7368
- s62 << r66
7369
- if r66
7370
- s67, i67 = [], index
7371
- loop do
7372
- r68 = _nt_space
7373
- if r68
7374
- s67 << r68
7375
- else
7376
- break
7377
- end
7378
- end
7379
- r67 = instantiate_node(SyntaxNode,input, i67...index, s67)
7380
- s62 << r67
7381
- if r67
7382
- r69 = _nt_type_name
7383
- s62 << r69
7384
- if r69
7385
- s70, i70 = [], index
7386
- loop do
7387
- r71 = _nt_space
7388
- if r71
7389
- s70 << r71
7390
- else
7391
- break
7392
- end
7393
- end
7394
- r70 = instantiate_node(SyntaxNode,input, i70...index, s70)
7395
- s62 << r70
7396
- if r70
7397
- if (match_len = has_terminal?(',', false, index))
7398
- r72 = true
7399
- @index += match_len
7400
- else
7401
- terminal_parse_failure('\',\'')
7402
- r72 = nil
7403
- end
7404
- s62 << r72
7405
- if r72
7406
- s73, i73 = [], index
7407
- loop do
7408
- r74 = _nt_space
7409
- if r74
7410
- s73 << r74
7411
- else
7412
- break
7413
- end
7414
- end
7415
- r73 = instantiate_node(SyntaxNode,input, i73...index, s73)
7416
- s62 << r73
7417
- if r73
7418
- r75 = _nt_expression
7419
- s62 << r75
7420
- if r75
7421
- s76, i76 = [], index
7422
- loop do
7423
- r77 = _nt_space
7424
- if r77
7425
- s76 << r77
7426
- else
7427
- break
7428
- end
7429
- end
7430
- r76 = instantiate_node(SyntaxNode,input, i76...index, s76)
7431
- s62 << r76
7432
- if r76
7433
- if (match_len = has_terminal?(')', false, index))
7434
- r78 = true
7435
- @index += match_len
7436
- else
7437
- terminal_parse_failure('\')\'')
7438
- r78 = nil
7439
- end
7440
- s62 << r78
7441
- end
7442
- end
7443
- end
7444
- end
7445
- end
7446
- end
7447
- end
7448
- end
7449
- end
7450
- end
7451
- if s62.last
7452
- r62 = instantiate_node(Idl::EnumCastSyntaxNode,input, i62...index, s62)
7453
- r62.extend(UnaryExpression6)
7454
- else
7455
- @index = i62
7456
- r62 = nil
7457
- end
7458
- if r62
7459
- r62 = SyntaxNode.new(input, (index-1)...index) if r62 == true
7460
- r0 = r62
7126
+ end
7127
+ end
7128
+ end
7129
+ end
7130
+ end
7131
+ if s3.last
7132
+ r3 = instantiate_node(Idl::ArrayLiteralSyntaxNode,input, i3...index, s3)
7133
+ r3.extend(UnaryExpression1)
7134
+ else
7135
+ @index = i3
7136
+ r3 = nil
7137
+ end
7138
+ if r3
7139
+ r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
7140
+ r0 = r3
7141
+ else
7142
+ r19 = _nt_ary_access
7143
+ if r19
7144
+ r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
7145
+ r0 = r19
7146
+ else
7147
+ r20 = _nt_dollar_function_call
7148
+ if r20
7149
+ r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
7150
+ r0 = r20
7151
+ else
7152
+ r21 = _nt_paren_expression
7153
+ if r21
7154
+ r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
7155
+ r0 = r21
7156
+ else
7157
+ i22, s22 = index, []
7158
+ r23 = _nt_unary_operator
7159
+ s22 << r23
7160
+ if r23
7161
+ s24, i24 = [], index
7162
+ loop do
7163
+ r25 = _nt_space
7164
+ if r25
7165
+ s24 << r25
7166
+ else
7167
+ break
7168
+ end
7169
+ end
7170
+ r24 = instantiate_node(SyntaxNode,input, i24...index, s24)
7171
+ s22 << r24
7172
+ if r24
7173
+ r26 = _nt_unary_expression
7174
+ s22 << r26
7175
+ end
7176
+ end
7177
+ if s22.last
7178
+ r22 = instantiate_node(Idl::UnaryOperatorExpressionSyntaxNode,input, i22...index, s22)
7179
+ r22.extend(UnaryExpression2)
7180
+ else
7181
+ @index = i22
7182
+ r22 = nil
7183
+ end
7184
+ if r22
7185
+ r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
7186
+ r0 = r22
7187
+ else
7188
+ r27 = _nt_post_dec
7189
+ if r27
7190
+ r27 = SyntaxNode.new(input, (index-1)...index) if r27 == true
7191
+ r0 = r27
7192
+ else
7193
+ r28 = _nt_post_inc
7194
+ if r28
7195
+ r28 = SyntaxNode.new(input, (index-1)...index) if r28 == true
7196
+ r0 = r28
7197
+ else
7198
+ r29 = _nt_replication_expression
7199
+ if r29
7200
+ r29 = SyntaxNode.new(input, (index-1)...index) if r29 == true
7201
+ r0 = r29
7202
+ else
7203
+ r30 = _nt_concatenation_expression
7204
+ if r30
7205
+ r30 = SyntaxNode.new(input, (index-1)...index) if r30 == true
7206
+ r0 = r30
7461
7207
  else
7462
- i79, s79 = index, []
7463
- if (match_len = has_terminal?('$array_size', false, index))
7464
- r80 = instantiate_node(SyntaxNode,input, index...(index + match_len))
7465
- @index += match_len
7466
- else
7467
- terminal_parse_failure('\'$array_size\'')
7468
- r80 = nil
7469
- end
7470
- s79 << r80
7471
- if r80
7472
- s81, i81 = [], index
7473
- loop do
7474
- r82 = _nt_space
7475
- if r82
7476
- s81 << r82
7477
- else
7478
- break
7479
- end
7480
- end
7481
- r81 = instantiate_node(SyntaxNode,input, i81...index, s81)
7482
- s79 << r81
7483
- if r81
7484
- if (match_len = has_terminal?('(', false, index))
7485
- r83 = true
7486
- @index += match_len
7487
- else
7488
- terminal_parse_failure('\'(\'')
7489
- r83 = nil
7490
- end
7491
- s79 << r83
7492
- if r83
7493
- s84, i84 = [], index
7494
- loop do
7495
- r85 = _nt_space
7496
- if r85
7497
- s84 << r85
7498
- else
7499
- break
7500
- end
7501
- end
7502
- r84 = instantiate_node(SyntaxNode,input, i84...index, s84)
7503
- s79 << r84
7504
- if r84
7505
- r86 = _nt_expression
7506
- s79 << r86
7507
- if r86
7508
- if (match_len = has_terminal?(')', false, index))
7509
- r87 = true
7510
- @index += match_len
7511
- else
7512
- terminal_parse_failure('\')\'')
7513
- r87 = nil
7514
- end
7515
- s79 << r87
7516
- end
7517
- end
7518
- end
7519
- end
7520
- end
7521
- if s79.last
7522
- r79 = instantiate_node(Idl::ArraySizeSyntaxNode,input, i79...index, s79)
7523
- r79.extend(UnaryExpression7)
7524
- else
7525
- @index = i79
7526
- r79 = nil
7527
- end
7528
- if r79
7529
- r79 = SyntaxNode.new(input, (index-1)...index) if r79 == true
7530
- r0 = r79
7208
+ r31 = _nt_field_access_expression
7209
+ if r31
7210
+ r31 = SyntaxNode.new(input, (index-1)...index) if r31 == true
7211
+ r0 = r31
7531
7212
  else
7532
- i88, s88 = index, []
7533
- if (match_len = has_terminal?('$array_includes?', false, index))
7534
- r89 = instantiate_node(SyntaxNode,input, index...(index + match_len))
7535
- @index += match_len
7536
- else
7537
- terminal_parse_failure('\'$array_includes?\'')
7538
- r89 = nil
7539
- end
7540
- s88 << r89
7541
- if r89
7542
- s90, i90 = [], index
7543
- loop do
7544
- r91 = _nt_space
7545
- if r91
7546
- s90 << r91
7547
- else
7548
- break
7549
- end
7550
- end
7551
- r90 = instantiate_node(SyntaxNode,input, i90...index, s90)
7552
- s88 << r90
7553
- if r90
7554
- if (match_len = has_terminal?('(', false, index))
7555
- r92 = true
7556
- @index += match_len
7557
- else
7558
- terminal_parse_failure('\'(\'')
7559
- r92 = nil
7560
- end
7561
- s88 << r92
7562
- if r92
7563
- s93, i93 = [], index
7564
- loop do
7565
- r94 = _nt_space
7566
- if r94
7567
- s93 << r94
7568
- else
7569
- break
7570
- end
7571
- end
7572
- r93 = instantiate_node(SyntaxNode,input, i93...index, s93)
7573
- s88 << r93
7574
- if r93
7575
- r95 = _nt_ary_eligible_expression
7576
- s88 << r95
7577
- if r95
7578
- s96, i96 = [], index
7579
- loop do
7580
- r97 = _nt_space
7581
- if r97
7582
- s96 << r97
7583
- else
7584
- break
7585
- end
7586
- end
7587
- r96 = instantiate_node(SyntaxNode,input, i96...index, s96)
7588
- s88 << r96
7589
- if r96
7590
- if (match_len = has_terminal?(',', false, index))
7591
- r98 = true
7592
- @index += match_len
7593
- else
7594
- terminal_parse_failure('\',\'')
7595
- r98 = nil
7596
- end
7597
- s88 << r98
7598
- if r98
7599
- s99, i99 = [], index
7600
- loop do
7601
- r100 = _nt_space
7602
- if r100
7603
- s99 << r100
7604
- else
7605
- break
7606
- end
7607
- end
7608
- r99 = instantiate_node(SyntaxNode,input, i99...index, s99)
7609
- s88 << r99
7610
- if r99
7611
- r101 = _nt_expression
7612
- s88 << r101
7613
- if r101
7614
- s102, i102 = [], index
7615
- loop do
7616
- r103 = _nt_space
7617
- if r103
7618
- s102 << r103
7619
- else
7620
- break
7621
- end
7622
- end
7623
- r102 = instantiate_node(SyntaxNode,input, i102...index, s102)
7624
- s88 << r102
7625
- if r102
7626
- if (match_len = has_terminal?(')', false, index))
7627
- r104 = true
7628
- @index += match_len
7629
- else
7630
- terminal_parse_failure('\')\'')
7631
- r104 = nil
7632
- end
7633
- s88 << r104
7634
- end
7635
- end
7636
- end
7637
- end
7638
- end
7639
- end
7640
- end
7641
- end
7642
- end
7643
- end
7644
- if s88.last
7645
- r88 = instantiate_node(Idl::ArrayIncludesSyntaxNode,input, i88...index, s88)
7646
- r88.extend(UnaryExpression8)
7213
+ r32 = _nt_function_call
7214
+ if r32
7215
+ r32 = SyntaxNode.new(input, (index-1)...index) if r32 == true
7216
+ r0 = r32
7647
7217
  else
7648
- @index = i88
7649
- r88 = nil
7650
- end
7651
- if r88
7652
- r88 = SyntaxNode.new(input, (index-1)...index) if r88 == true
7653
- r0 = r88
7654
- else
7655
- r105 = _nt_paren_expression
7656
- if r105
7657
- r105 = SyntaxNode.new(input, (index-1)...index) if r105 == true
7658
- r0 = r105
7218
+ r33 = _nt_csr_field_access_expression
7219
+ if r33
7220
+ r33 = SyntaxNode.new(input, (index-1)...index) if r33 == true
7221
+ r0 = r33
7659
7222
  else
7660
- i106, s106 = index, []
7661
- r107 = _nt_unary_operator
7662
- s106 << r107
7663
- if r107
7664
- s108, i108 = [], index
7665
- loop do
7666
- r109 = _nt_space
7667
- if r109
7668
- s108 << r109
7669
- else
7670
- break
7671
- end
7672
- end
7673
- r108 = instantiate_node(SyntaxNode,input, i108...index, s108)
7674
- s106 << r108
7675
- if r108
7676
- r110 = _nt_unary_expression
7677
- s106 << r110
7678
- end
7679
- end
7680
- if s106.last
7681
- r106 = instantiate_node(Idl::UnaryOperatorExpressionSyntaxNode,input, i106...index, s106)
7682
- r106.extend(UnaryExpression9)
7683
- else
7684
- @index = i106
7685
- r106 = nil
7686
- end
7687
- if r106
7688
- r106 = SyntaxNode.new(input, (index-1)...index) if r106 == true
7689
- r0 = r106
7223
+ r34 = _nt_csr_register_access_expression
7224
+ if r34
7225
+ r34 = SyntaxNode.new(input, (index-1)...index) if r34 == true
7226
+ r0 = r34
7690
7227
  else
7691
- r111 = _nt_post_dec
7692
- if r111
7693
- r111 = SyntaxNode.new(input, (index-1)...index) if r111 == true
7694
- r0 = r111
7228
+ r35 = _nt_enum_ref
7229
+ if r35
7230
+ r35 = SyntaxNode.new(input, (index-1)...index) if r35 == true
7231
+ r0 = r35
7695
7232
  else
7696
- r112 = _nt_post_inc
7697
- if r112
7698
- r112 = SyntaxNode.new(input, (index-1)...index) if r112 == true
7699
- r0 = r112
7233
+ r36 = _nt_rval
7234
+ if r36
7235
+ r36 = SyntaxNode.new(input, (index-1)...index) if r36 == true
7236
+ r0 = r36
7700
7237
  else
7701
- r113 = _nt_replication_expression
7702
- if r113
7703
- r113 = SyntaxNode.new(input, (index-1)...index) if r113 == true
7704
- r0 = r113
7705
- else
7706
- r114 = _nt_concatenation_expression
7707
- if r114
7708
- r114 = SyntaxNode.new(input, (index-1)...index) if r114 == true
7709
- r0 = r114
7710
- else
7711
- r115 = _nt_field_access_expression
7712
- if r115
7713
- r115 = SyntaxNode.new(input, (index-1)...index) if r115 == true
7714
- r0 = r115
7715
- else
7716
- r116 = _nt_function_call
7717
- if r116
7718
- r116 = SyntaxNode.new(input, (index-1)...index) if r116 == true
7719
- r0 = r116
7720
- else
7721
- r117 = _nt_csr_field_access_expression
7722
- if r117
7723
- r117 = SyntaxNode.new(input, (index-1)...index) if r117 == true
7724
- r0 = r117
7725
- else
7726
- r118 = _nt_enum_ref
7727
- if r118
7728
- r118 = SyntaxNode.new(input, (index-1)...index) if r118 == true
7729
- r0 = r118
7730
- else
7731
- r119 = _nt_rval
7732
- if r119
7733
- r119 = SyntaxNode.new(input, (index-1)...index) if r119 == true
7734
- r0 = r119
7735
- else
7736
- @index = i0
7737
- r0 = nil
7738
- end
7739
- end
7740
- end
7741
- end
7742
- end
7743
- end
7744
- end
7238
+ @index = i0
7239
+ r0 = nil
7745
7240
  end
7746
7241
  end
7747
7242
  end
@@ -8766,12 +8261,12 @@ module Idl
8766
8261
  end
8767
8262
 
8768
8263
  module FunctionCall0
8769
- def csr
8264
+ def function_name
8770
8265
  elements[0]
8771
8266
  end
8772
8267
 
8773
- def expression
8774
- elements[8]
8268
+ def function_arg_list
8269
+ elements[4]
8775
8270
  end
8776
8271
 
8777
8272
  end
@@ -8781,25 +8276,25 @@ module Idl
8781
8276
  elements[0]
8782
8277
  end
8783
8278
 
8784
- def function_name
8785
- elements[4]
8786
- end
8787
-
8788
- def function_arg_list
8279
+ def expression
8789
8280
  elements[8]
8790
8281
  end
8791
8282
 
8792
8283
  end
8793
8284
 
8794
8285
  module FunctionCall2
8795
- def function_name
8286
+ def csr
8796
8287
  elements[0]
8797
8288
  end
8798
8289
 
8799
- def function_arg_list
8290
+ def function_name
8800
8291
  elements[4]
8801
8292
  end
8802
8293
 
8294
+ def function_arg_list
8295
+ elements[8]
8296
+ end
8297
+
8803
8298
  end
8804
8299
 
8805
8300
  def _nt_function_call
@@ -8815,7 +8310,7 @@ module Idl
8815
8310
 
8816
8311
  i0 = index
8817
8312
  i1, s1 = index, []
8818
- r2 = _nt_csr_register_access_expression
8313
+ r2 = _nt_function_name
8819
8314
  s1 << r2
8820
8315
  if r2
8821
8316
  s3, i3 = [], index
@@ -8830,11 +8325,11 @@ module Idl
8830
8325
  r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
8831
8326
  s1 << r3
8832
8327
  if r3
8833
- if (match_len = has_terminal?('.', false, index))
8328
+ if (match_len = has_terminal?('(', false, index))
8834
8329
  r5 = true
8835
8330
  @index += match_len
8836
8331
  else
8837
- terminal_parse_failure('\'.\'')
8332
+ terminal_parse_failure('\'(\'')
8838
8333
  r5 = nil
8839
8334
  end
8840
8335
  s1 << r5
@@ -8851,13 +8346,7 @@ module Idl
8851
8346
  r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
8852
8347
  s1 << r6
8853
8348
  if r6
8854
- if (match_len = has_terminal?('sw_write', false, index))
8855
- r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
8856
- @index += match_len
8857
- else
8858
- terminal_parse_failure('\'sw_write\'')
8859
- r8 = nil
8860
- end
8349
+ r8 = _nt_function_arg_list
8861
8350
  s1 << r8
8862
8351
  if r8
8863
8352
  s9, i9 = [], index
@@ -8872,54 +8361,14 @@ module Idl
8872
8361
  r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
8873
8362
  s1 << r9
8874
8363
  if r9
8875
- if (match_len = has_terminal?('(', false, index))
8364
+ if (match_len = has_terminal?(')', false, index))
8876
8365
  r11 = true
8877
8366
  @index += match_len
8878
8367
  else
8879
- terminal_parse_failure('\'(\'')
8368
+ terminal_parse_failure('\')\'')
8880
8369
  r11 = nil
8881
8370
  end
8882
8371
  s1 << r11
8883
- if r11
8884
- s12, i12 = [], index
8885
- loop do
8886
- r13 = _nt_space
8887
- if r13
8888
- s12 << r13
8889
- else
8890
- break
8891
- end
8892
- end
8893
- r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
8894
- s1 << r12
8895
- if r12
8896
- r14 = _nt_expression
8897
- s1 << r14
8898
- if r14
8899
- s15, i15 = [], index
8900
- loop do
8901
- r16 = _nt_space
8902
- if r16
8903
- s15 << r16
8904
- else
8905
- break
8906
- end
8907
- end
8908
- r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
8909
- s1 << r15
8910
- if r15
8911
- if (match_len = has_terminal?(')', false, index))
8912
- r17 = true
8913
- @index += match_len
8914
- else
8915
- terminal_parse_failure('\')\'')
8916
- r17 = nil
8917
- end
8918
- s1 << r17
8919
- end
8920
- end
8921
- end
8922
- end
8923
8372
  end
8924
8373
  end
8925
8374
  end
@@ -8927,7 +8376,7 @@ module Idl
8927
8376
  end
8928
8377
  end
8929
8378
  if s1.last
8930
- r1 = instantiate_node(Idl::CsrSoftwareWriteSyntaxNode,input, i1...index, s1)
8379
+ r1 = instantiate_node(Idl::FunctionCallExpressionSyntaxNode,input, i1...index, s1)
8931
8380
  r1.extend(FunctionCall0)
8932
8381
  else
8933
8382
  @index = i1
@@ -8937,102 +8386,108 @@ module Idl
8937
8386
  r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
8938
8387
  r0 = r1
8939
8388
  else
8940
- i18, s18 = index, []
8941
- r19 = _nt_csr_register_access_expression
8942
- s18 << r19
8943
- if r19
8944
- s20, i20 = [], index
8389
+ i12, s12 = index, []
8390
+ r13 = _nt_csr_register_access_expression
8391
+ s12 << r13
8392
+ if r13
8393
+ s14, i14 = [], index
8945
8394
  loop do
8946
- r21 = _nt_space
8947
- if r21
8948
- s20 << r21
8395
+ r15 = _nt_space
8396
+ if r15
8397
+ s14 << r15
8949
8398
  else
8950
8399
  break
8951
8400
  end
8952
8401
  end
8953
- r20 = instantiate_node(SyntaxNode,input, i20...index, s20)
8954
- s18 << r20
8955
- if r20
8402
+ r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
8403
+ s12 << r14
8404
+ if r14
8956
8405
  if (match_len = has_terminal?('.', false, index))
8957
- r22 = true
8406
+ r16 = true
8958
8407
  @index += match_len
8959
8408
  else
8960
8409
  terminal_parse_failure('\'.\'')
8961
- r22 = nil
8410
+ r16 = nil
8962
8411
  end
8963
- s18 << r22
8964
- if r22
8965
- s23, i23 = [], index
8412
+ s12 << r16
8413
+ if r16
8414
+ s17, i17 = [], index
8966
8415
  loop do
8967
- r24 = _nt_space
8968
- if r24
8969
- s23 << r24
8416
+ r18 = _nt_space
8417
+ if r18
8418
+ s17 << r18
8970
8419
  else
8971
8420
  break
8972
8421
  end
8973
8422
  end
8974
- r23 = instantiate_node(SyntaxNode,input, i23...index, s23)
8975
- s18 << r23
8976
- if r23
8977
- r25 = _nt_function_name
8978
- s18 << r25
8979
- if r25
8980
- s26, i26 = [], index
8423
+ r17 = instantiate_node(SyntaxNode,input, i17...index, s17)
8424
+ s12 << r17
8425
+ if r17
8426
+ if (match_len = has_terminal?('sw_write', false, index))
8427
+ r19 = instantiate_node(SyntaxNode,input, index...(index + match_len))
8428
+ @index += match_len
8429
+ else
8430
+ terminal_parse_failure('\'sw_write\'')
8431
+ r19 = nil
8432
+ end
8433
+ s12 << r19
8434
+ if r19
8435
+ s20, i20 = [], index
8981
8436
  loop do
8982
- r27 = _nt_space
8983
- if r27
8984
- s26 << r27
8437
+ r21 = _nt_space
8438
+ if r21
8439
+ s20 << r21
8985
8440
  else
8986
8441
  break
8987
8442
  end
8988
8443
  end
8989
- r26 = instantiate_node(SyntaxNode,input, i26...index, s26)
8990
- s18 << r26
8991
- if r26
8444
+ r20 = instantiate_node(SyntaxNode,input, i20...index, s20)
8445
+ s12 << r20
8446
+ if r20
8992
8447
  if (match_len = has_terminal?('(', false, index))
8993
- r28 = true
8448
+ r22 = true
8994
8449
  @index += match_len
8995
8450
  else
8996
8451
  terminal_parse_failure('\'(\'')
8997
- r28 = nil
8452
+ r22 = nil
8998
8453
  end
8999
- s18 << r28
9000
- if r28
9001
- s29, i29 = [], index
8454
+ s12 << r22
8455
+ if r22
8456
+ s23, i23 = [], index
9002
8457
  loop do
9003
- r30 = _nt_space
9004
- if r30
9005
- s29 << r30
8458
+ r24 = _nt_space
8459
+ if r24
8460
+ s23 << r24
9006
8461
  else
9007
8462
  break
9008
8463
  end
9009
8464
  end
9010
- r29 = instantiate_node(SyntaxNode,input, i29...index, s29)
9011
- s18 << r29
9012
- if r29
9013
- r31 = _nt_function_arg_list
9014
- s18 << r31
9015
- if r31
9016
- s32, i32 = [], index
8465
+ r23 = instantiate_node(SyntaxNode,input, i23...index, s23)
8466
+ s12 << r23
8467
+ if r23
8468
+ r25 = _nt_expression
8469
+ s12 << r25
8470
+ if r25
8471
+ s26, i26 = [], index
9017
8472
  loop do
9018
- r33 = _nt_space
9019
- if r33
9020
- s32 << r33
8473
+ r27 = _nt_space
8474
+ if r27
8475
+ s26 << r27
9021
8476
  else
9022
8477
  break
9023
8478
  end
9024
8479
  end
9025
- r32 = instantiate_node(SyntaxNode,input, i32...index, s32)
9026
- s18 << r32
9027
- if r32
8480
+ r26 = instantiate_node(SyntaxNode,input, i26...index, s26)
8481
+ s12 << r26
8482
+ if r26
9028
8483
  if (match_len = has_terminal?(')', false, index))
9029
- r34 = true
8484
+ r28 = true
9030
8485
  @index += match_len
9031
8486
  else
9032
8487
  terminal_parse_failure('\')\'')
9033
- r34 = nil
8488
+ r28 = nil
9034
8489
  end
9035
- s18 << r34
8490
+ s12 << r28
9036
8491
  end
9037
8492
  end
9038
8493
  end
@@ -9043,93 +8498,133 @@ module Idl
9043
8498
  end
9044
8499
  end
9045
8500
  end
9046
- if s18.last
9047
- r18 = instantiate_node(Idl::CsrFunctionCallSyntaxNode,input, i18...index, s18)
9048
- r18.extend(FunctionCall1)
8501
+ if s12.last
8502
+ r12 = instantiate_node(Idl::CsrSoftwareWriteSyntaxNode,input, i12...index, s12)
8503
+ r12.extend(FunctionCall1)
9049
8504
  else
9050
- @index = i18
9051
- r18 = nil
8505
+ @index = i12
8506
+ r12 = nil
9052
8507
  end
9053
- if r18
9054
- r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
9055
- r0 = r18
8508
+ if r12
8509
+ r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
8510
+ r0 = r12
9056
8511
  else
9057
- i35, s35 = index, []
9058
- r36 = _nt_function_name
9059
- s35 << r36
9060
- if r36
9061
- s37, i37 = [], index
8512
+ i29, s29 = index, []
8513
+ r30 = _nt_csr_register_access_expression
8514
+ s29 << r30
8515
+ if r30
8516
+ s31, i31 = [], index
9062
8517
  loop do
9063
- r38 = _nt_space
9064
- if r38
9065
- s37 << r38
8518
+ r32 = _nt_space
8519
+ if r32
8520
+ s31 << r32
9066
8521
  else
9067
8522
  break
9068
8523
  end
9069
8524
  end
9070
- r37 = instantiate_node(SyntaxNode,input, i37...index, s37)
9071
- s35 << r37
9072
- if r37
9073
- if (match_len = has_terminal?('(', false, index))
9074
- r39 = true
8525
+ r31 = instantiate_node(SyntaxNode,input, i31...index, s31)
8526
+ s29 << r31
8527
+ if r31
8528
+ if (match_len = has_terminal?('.', false, index))
8529
+ r33 = true
9075
8530
  @index += match_len
9076
8531
  else
9077
- terminal_parse_failure('\'(\'')
9078
- r39 = nil
8532
+ terminal_parse_failure('\'.\'')
8533
+ r33 = nil
9079
8534
  end
9080
- s35 << r39
9081
- if r39
9082
- s40, i40 = [], index
8535
+ s29 << r33
8536
+ if r33
8537
+ s34, i34 = [], index
9083
8538
  loop do
9084
- r41 = _nt_space
9085
- if r41
9086
- s40 << r41
8539
+ r35 = _nt_space
8540
+ if r35
8541
+ s34 << r35
9087
8542
  else
9088
8543
  break
9089
8544
  end
9090
8545
  end
9091
- r40 = instantiate_node(SyntaxNode,input, i40...index, s40)
9092
- s35 << r40
9093
- if r40
9094
- r42 = _nt_function_arg_list
9095
- s35 << r42
9096
- if r42
9097
- s43, i43 = [], index
8546
+ r34 = instantiate_node(SyntaxNode,input, i34...index, s34)
8547
+ s29 << r34
8548
+ if r34
8549
+ r36 = _nt_function_name
8550
+ s29 << r36
8551
+ if r36
8552
+ s37, i37 = [], index
9098
8553
  loop do
9099
- r44 = _nt_space
9100
- if r44
9101
- s43 << r44
8554
+ r38 = _nt_space
8555
+ if r38
8556
+ s37 << r38
9102
8557
  else
9103
8558
  break
9104
8559
  end
9105
8560
  end
9106
- r43 = instantiate_node(SyntaxNode,input, i43...index, s43)
9107
- s35 << r43
9108
- if r43
9109
- if (match_len = has_terminal?(')', false, index))
9110
- r45 = true
8561
+ r37 = instantiate_node(SyntaxNode,input, i37...index, s37)
8562
+ s29 << r37
8563
+ if r37
8564
+ if (match_len = has_terminal?('(', false, index))
8565
+ r39 = true
9111
8566
  @index += match_len
9112
8567
  else
9113
- terminal_parse_failure('\')\'')
9114
- r45 = nil
8568
+ terminal_parse_failure('\'(\'')
8569
+ r39 = nil
8570
+ end
8571
+ s29 << r39
8572
+ if r39
8573
+ s40, i40 = [], index
8574
+ loop do
8575
+ r41 = _nt_space
8576
+ if r41
8577
+ s40 << r41
8578
+ else
8579
+ break
8580
+ end
8581
+ end
8582
+ r40 = instantiate_node(SyntaxNode,input, i40...index, s40)
8583
+ s29 << r40
8584
+ if r40
8585
+ r42 = _nt_function_arg_list
8586
+ s29 << r42
8587
+ if r42
8588
+ s43, i43 = [], index
8589
+ loop do
8590
+ r44 = _nt_space
8591
+ if r44
8592
+ s43 << r44
8593
+ else
8594
+ break
8595
+ end
8596
+ end
8597
+ r43 = instantiate_node(SyntaxNode,input, i43...index, s43)
8598
+ s29 << r43
8599
+ if r43
8600
+ if (match_len = has_terminal?(')', false, index))
8601
+ r45 = true
8602
+ @index += match_len
8603
+ else
8604
+ terminal_parse_failure('\')\'')
8605
+ r45 = nil
8606
+ end
8607
+ s29 << r45
8608
+ end
8609
+ end
8610
+ end
9115
8611
  end
9116
- s35 << r45
9117
8612
  end
9118
8613
  end
9119
8614
  end
9120
8615
  end
9121
8616
  end
9122
8617
  end
9123
- if s35.last
9124
- r35 = instantiate_node(Idl::FunctionCallExpressionSyntaxNode,input, i35...index, s35)
9125
- r35.extend(FunctionCall2)
8618
+ if s29.last
8619
+ r29 = instantiate_node(Idl::CsrFunctionCallSyntaxNode,input, i29...index, s29)
8620
+ r29.extend(FunctionCall2)
9126
8621
  else
9127
- @index = i35
9128
- r35 = nil
8622
+ @index = i29
8623
+ r29 = nil
9129
8624
  end
9130
- if r35
9131
- r35 = SyntaxNode.new(input, (index-1)...index) if r35 == true
9132
- r0 = r35
8625
+ if r29
8626
+ r29 = SyntaxNode.new(input, (index-1)...index) if r29 == true
8627
+ r0 = r29
9133
8628
  else
9134
8629
  @index = i0
9135
8630
  r0 = nil
@@ -10631,29 +10126,23 @@ module Idl
10631
10126
  r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
10632
10127
  r0 = r1
10633
10128
  else
10634
- r2 = _nt_builtin_read_only_var
10129
+ r2 = _nt_dollar_variable
10635
10130
  if r2
10636
10131
  r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
10637
10132
  r0 = r2
10638
10133
  else
10639
- r3 = _nt_builtin_read_write_var
10134
+ r3 = _nt_string
10640
10135
  if r3
10641
10136
  r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
10642
10137
  r0 = r3
10643
10138
  else
10644
- r4 = _nt_string
10139
+ r4 = _nt_id
10645
10140
  if r4
10646
10141
  r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
10647
10142
  r0 = r4
10648
10143
  else
10649
- r5 = _nt_id
10650
- if r5
10651
- r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
10652
- r0 = r5
10653
- else
10654
- @index = i0
10655
- r0 = nil
10656
- end
10144
+ @index = i0
10145
+ r0 = nil
10657
10146
  end
10658
10147
  end
10659
10148
  end
@@ -10686,6 +10175,10 @@ module Idl
10686
10175
  end
10687
10176
 
10688
10177
  module Assignment2
10178
+ def dollar_variable
10179
+ elements[0]
10180
+ end
10181
+
10689
10182
  def rval
10690
10183
  elements[4]
10691
10184
  end
@@ -10726,34 +10219,34 @@ module Idl
10726
10219
  end
10727
10220
 
10728
10221
  module Assignment6
10729
- def var
10222
+ def expression
10730
10223
  elements[0]
10731
10224
  end
10732
10225
 
10226
+ end
10227
+
10228
+ module Assignment7
10733
10229
  def msb
10734
- elements[4]
10230
+ elements[2]
10735
10231
  end
10736
10232
 
10737
10233
  def lsb
10738
- elements[8]
10234
+ elements[3]
10739
10235
  end
10740
10236
 
10741
- def rval
10742
- elements[14]
10743
- end
10744
10237
  end
10745
10238
 
10746
- module Assignment7
10239
+ module Assignment8
10747
10240
  def var
10748
10241
  elements[0]
10749
10242
  end
10750
10243
 
10751
- def idx
10752
- elements[4]
10244
+ def brackets
10245
+ elements[2]
10753
10246
  end
10754
10247
 
10755
10248
  def rval
10756
- elements[10]
10249
+ elements[5]
10757
10250
  end
10758
10251
  end
10759
10252
 
@@ -10953,13 +10446,7 @@ module Idl
10953
10446
  r0 = r25
10954
10447
  else
10955
10448
  i26, s26 = index, []
10956
- if (match_len = has_terminal?('$pc', false, index))
10957
- r27 = instantiate_node(SyntaxNode,input, index...(index + match_len))
10958
- @index += match_len
10959
- else
10960
- terminal_parse_failure('\'$pc\'')
10961
- r27 = nil
10962
- end
10449
+ r27 = _nt_dollar_variable
10963
10450
  s26 << r27
10964
10451
  if r27
10965
10452
  s28, i28 = [], index
@@ -11002,7 +10489,7 @@ module Idl
11002
10489
  end
11003
10490
  end
11004
10491
  if s26.last
11005
- r26 = instantiate_node(Idl::PcAssignmentSyntaxNode,input, i26...index, s26)
10492
+ r26 = instantiate_node(Idl::DollarVariableAssignmentSyntaxNode,input, i26...index, s26)
11006
10493
  r26.extend(Assignment2)
11007
10494
  else
11008
10495
  @index = i26
@@ -11230,267 +10717,186 @@ module Idl
11230
10717
  r66 = instantiate_node(SyntaxNode,input, i66...index, s66)
11231
10718
  s64 << r66
11232
10719
  if r66
11233
- if (match_len = has_terminal?('[', false, index))
11234
- r68 = true
11235
- @index += match_len
11236
- else
11237
- terminal_parse_failure('\'[\'')
11238
- r68 = nil
11239
- end
11240
- s64 << r68
11241
- if r68
11242
- s69, i69 = [], index
11243
- loop do
11244
- r70 = _nt_space
11245
- if r70
11246
- s69 << r70
11247
- else
11248
- break
11249
- end
10720
+ s68, i68 = [], index
10721
+ loop do
10722
+ i69, s69 = index, []
10723
+ if (match_len = has_terminal?('[', false, index))
10724
+ r70 = true
10725
+ @index += match_len
10726
+ else
10727
+ terminal_parse_failure('\'[\'')
10728
+ r70 = nil
11250
10729
  end
11251
- r69 = instantiate_node(SyntaxNode,input, i69...index, s69)
11252
- s64 << r69
11253
- if r69
11254
- r71 = _nt_expression
11255
- s64 << r71
10730
+ s69 << r70
10731
+ if r70
10732
+ s71, i71 = [], index
10733
+ loop do
10734
+ r72 = _nt_space
10735
+ if r72
10736
+ s71 << r72
10737
+ else
10738
+ break
10739
+ end
10740
+ end
10741
+ r71 = instantiate_node(SyntaxNode,input, i71...index, s71)
10742
+ s69 << r71
11256
10743
  if r71
11257
- s72, i72 = [], index
11258
- loop do
11259
- r73 = _nt_space
11260
- if r73
11261
- s72 << r73
11262
- else
11263
- break
10744
+ i74, s74 = index, []
10745
+ r75 = _nt_expression
10746
+ s74 << r75
10747
+ if r75
10748
+ s76, i76 = [], index
10749
+ loop do
10750
+ r77 = _nt_space
10751
+ if r77
10752
+ s76 << r77
10753
+ else
10754
+ break
10755
+ end
11264
10756
  end
11265
- end
11266
- r72 = instantiate_node(SyntaxNode,input, i72...index, s72)
11267
- s64 << r72
11268
- if r72
11269
- if (match_len = has_terminal?(':', false, index))
11270
- r74 = true
11271
- @index += match_len
11272
- else
11273
- terminal_parse_failure('\':\'')
11274
- r74 = nil
10757
+ r76 = instantiate_node(SyntaxNode,input, i76...index, s76)
10758
+ s74 << r76
10759
+ if r76
10760
+ if (match_len = has_terminal?(':', false, index))
10761
+ r78 = true
10762
+ @index += match_len
10763
+ else
10764
+ terminal_parse_failure('\':\'')
10765
+ r78 = nil
10766
+ end
10767
+ s74 << r78
10768
+ if r78
10769
+ s79, i79 = [], index
10770
+ loop do
10771
+ r80 = _nt_space
10772
+ if r80
10773
+ s79 << r80
10774
+ else
10775
+ break
10776
+ end
10777
+ end
10778
+ r79 = instantiate_node(SyntaxNode,input, i79...index, s79)
10779
+ s74 << r79
10780
+ end
11275
10781
  end
11276
- s64 << r74
11277
- if r74
11278
- s75, i75 = [], index
10782
+ end
10783
+ if s74.last
10784
+ r74 = instantiate_node(SyntaxNode,input, i74...index, s74)
10785
+ r74.extend(Assignment6)
10786
+ else
10787
+ @index = i74
10788
+ r74 = nil
10789
+ end
10790
+ if r74
10791
+ r73 = r74
10792
+ else
10793
+ r73 = instantiate_node(SyntaxNode,input, index...index)
10794
+ end
10795
+ s69 << r73
10796
+ if r73
10797
+ r81 = _nt_expression
10798
+ s69 << r81
10799
+ if r81
10800
+ s82, i82 = [], index
11279
10801
  loop do
11280
- r76 = _nt_space
11281
- if r76
11282
- s75 << r76
10802
+ r83 = _nt_space
10803
+ if r83
10804
+ s82 << r83
11283
10805
  else
11284
10806
  break
11285
10807
  end
11286
10808
  end
11287
- r75 = instantiate_node(SyntaxNode,input, i75...index, s75)
11288
- s64 << r75
11289
- if r75
11290
- r77 = _nt_expression
11291
- s64 << r77
11292
- if r77
11293
- s78, i78 = [], index
10809
+ r82 = instantiate_node(SyntaxNode,input, i82...index, s82)
10810
+ s69 << r82
10811
+ if r82
10812
+ if (match_len = has_terminal?(']', false, index))
10813
+ r84 = true
10814
+ @index += match_len
10815
+ else
10816
+ terminal_parse_failure('\']\'')
10817
+ r84 = nil
10818
+ end
10819
+ s69 << r84
10820
+ if r84
10821
+ s85, i85 = [], index
11294
10822
  loop do
11295
- r79 = _nt_space
11296
- if r79
11297
- s78 << r79
10823
+ r86 = _nt_space
10824
+ if r86
10825
+ s85 << r86
11298
10826
  else
11299
10827
  break
11300
10828
  end
11301
10829
  end
11302
- r78 = instantiate_node(SyntaxNode,input, i78...index, s78)
11303
- s64 << r78
11304
- if r78
11305
- if (match_len = has_terminal?(']', false, index))
11306
- r80 = true
11307
- @index += match_len
11308
- else
11309
- terminal_parse_failure('\']\'')
11310
- r80 = nil
11311
- end
11312
- s64 << r80
11313
- if r80
11314
- s81, i81 = [], index
11315
- loop do
11316
- r82 = _nt_space
11317
- if r82
11318
- s81 << r82
11319
- else
11320
- break
11321
- end
11322
- end
11323
- r81 = instantiate_node(SyntaxNode,input, i81...index, s81)
11324
- s64 << r81
11325
- if r81
11326
- if (match_len = has_terminal?('=', false, index))
11327
- r83 = true
11328
- @index += match_len
11329
- else
11330
- terminal_parse_failure('\'=\'')
11331
- r83 = nil
11332
- end
11333
- s64 << r83
11334
- if r83
11335
- s84, i84 = [], index
11336
- loop do
11337
- r85 = _nt_space
11338
- if r85
11339
- s84 << r85
11340
- else
11341
- break
11342
- end
11343
- end
11344
- r84 = instantiate_node(SyntaxNode,input, i84...index, s84)
11345
- s64 << r84
11346
- if r84
11347
- r86 = _nt_expression
11348
- s64 << r86
11349
- end
11350
- end
11351
- end
11352
- end
11353
- end
10830
+ r85 = instantiate_node(SyntaxNode,input, i85...index, s85)
10831
+ s69 << r85
11354
10832
  end
11355
10833
  end
11356
10834
  end
11357
10835
  end
11358
10836
  end
11359
10837
  end
11360
- end
11361
- end
11362
- end
11363
- if s64.last
11364
- r64 = instantiate_node(Idl::AryRangeAssignmentSyntaxNode,input, i64...index, s64)
11365
- r64.extend(Assignment6)
11366
- else
11367
- @index = i64
11368
- r64 = nil
11369
- end
11370
- if r64
11371
- r64 = SyntaxNode.new(input, (index-1)...index) if r64 == true
11372
- r0 = r64
11373
- else
11374
- i87, s87 = index, []
11375
- r88 = _nt_ary_eligible_expression
11376
- s87 << r88
11377
- if r88
11378
- s89, i89 = [], index
11379
- loop do
11380
- r90 = _nt_space
11381
- if r90
11382
- s89 << r90
10838
+ if s69.last
10839
+ r69 = instantiate_node(SyntaxNode,input, i69...index, s69)
10840
+ r69.extend(Assignment7)
10841
+ else
10842
+ @index = i69
10843
+ r69 = nil
10844
+ end
10845
+ if r69
10846
+ s68 << r69
11383
10847
  else
11384
10848
  break
11385
10849
  end
11386
10850
  end
11387
- r89 = instantiate_node(SyntaxNode,input, i89...index, s89)
11388
- s87 << r89
11389
- if r89
11390
- if (match_len = has_terminal?('[', false, index))
11391
- r91 = true
10851
+ if s68.empty?
10852
+ @index = i68
10853
+ r68 = nil
10854
+ else
10855
+ r68 = instantiate_node(SyntaxNode,input, i68...index, s68)
10856
+ end
10857
+ s64 << r68
10858
+ if r68
10859
+ if (match_len = has_terminal?('=', false, index))
10860
+ r87 = true
11392
10861
  @index += match_len
11393
10862
  else
11394
- terminal_parse_failure('\'[\'')
11395
- r91 = nil
10863
+ terminal_parse_failure('\'=\'')
10864
+ r87 = nil
11396
10865
  end
11397
- s87 << r91
11398
- if r91
11399
- s92, i92 = [], index
10866
+ s64 << r87
10867
+ if r87
10868
+ s88, i88 = [], index
11400
10869
  loop do
11401
- r93 = _nt_space
11402
- if r93
11403
- s92 << r93
10870
+ r89 = _nt_space
10871
+ if r89
10872
+ s88 << r89
11404
10873
  else
11405
10874
  break
11406
10875
  end
11407
10876
  end
11408
- r92 = instantiate_node(SyntaxNode,input, i92...index, s92)
11409
- s87 << r92
11410
- if r92
11411
- r94 = _nt_expression
11412
- s87 << r94
11413
- if r94
11414
- s95, i95 = [], index
11415
- loop do
11416
- r96 = _nt_space
11417
- if r96
11418
- s95 << r96
11419
- else
11420
- break
11421
- end
11422
- end
11423
- r95 = instantiate_node(SyntaxNode,input, i95...index, s95)
11424
- s87 << r95
11425
- if r95
11426
- if (match_len = has_terminal?(']', false, index))
11427
- r97 = true
11428
- @index += match_len
11429
- else
11430
- terminal_parse_failure('\']\'')
11431
- r97 = nil
11432
- end
11433
- s87 << r97
11434
- if r97
11435
- s98, i98 = [], index
11436
- loop do
11437
- r99 = _nt_space
11438
- if r99
11439
- s98 << r99
11440
- else
11441
- break
11442
- end
11443
- end
11444
- r98 = instantiate_node(SyntaxNode,input, i98...index, s98)
11445
- s87 << r98
11446
- if r98
11447
- if (match_len = has_terminal?('=', false, index))
11448
- r100 = true
11449
- @index += match_len
11450
- else
11451
- terminal_parse_failure('\'=\'')
11452
- r100 = nil
11453
- end
11454
- s87 << r100
11455
- if r100
11456
- s101, i101 = [], index
11457
- loop do
11458
- r102 = _nt_space
11459
- if r102
11460
- s101 << r102
11461
- else
11462
- break
11463
- end
11464
- end
11465
- r101 = instantiate_node(SyntaxNode,input, i101...index, s101)
11466
- s87 << r101
11467
- if r101
11468
- r103 = _nt_expression
11469
- s87 << r103
11470
- end
11471
- end
11472
- end
11473
- end
11474
- end
11475
- end
10877
+ r88 = instantiate_node(SyntaxNode,input, i88...index, s88)
10878
+ s64 << r88
10879
+ if r88
10880
+ r90 = _nt_expression
10881
+ s64 << r90
11476
10882
  end
11477
10883
  end
11478
10884
  end
11479
10885
  end
11480
- if s87.last
11481
- r87 = instantiate_node(Idl::AryElementAssignmentSyntaxNode,input, i87...index, s87)
11482
- r87.extend(Assignment7)
11483
- else
11484
- @index = i87
11485
- r87 = nil
11486
- end
11487
- if r87
11488
- r87 = SyntaxNode.new(input, (index-1)...index) if r87 == true
11489
- r0 = r87
11490
- else
11491
- @index = i0
11492
- r0 = nil
11493
- end
10886
+ end
10887
+ if s64.last
10888
+ r64 = instantiate_node(Idl::AryRangeAssignmentSyntaxNode,input, i64...index, s64)
10889
+ r64.extend(Assignment8)
10890
+ else
10891
+ @index = i64
10892
+ r64 = nil
10893
+ end
10894
+ if r64
10895
+ r64 = SyntaxNode.new(input, (index-1)...index) if r64 == true
10896
+ r0 = r64
10897
+ else
10898
+ @index = i0
10899
+ r0 = nil
11494
10900
  end
11495
10901
  end
11496
10902
  end
@@ -14961,54 +14367,6 @@ module Idl
14961
14367
  r0
14962
14368
  end
14963
14369
 
14964
- def _nt_builtin_read_only_var
14965
- start_index = index
14966
- if node_cache[:builtin_read_only_var].has_key?(index)
14967
- cached = node_cache[:builtin_read_only_var][index]
14968
- if cached
14969
- node_cache[:builtin_read_only_var][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
14970
- @index = cached.interval.end
14971
- end
14972
- return cached
14973
- end
14974
-
14975
- if (match_len = has_terminal?("$encoding", false, index))
14976
- r0 = instantiate_node(Idl::BuiltinVariableSyntaxNode,input, index...(index + match_len))
14977
- @index += match_len
14978
- else
14979
- terminal_parse_failure('"$encoding"')
14980
- r0 = nil
14981
- end
14982
-
14983
- node_cache[:builtin_read_only_var][start_index] = r0
14984
-
14985
- r0
14986
- end
14987
-
14988
- def _nt_builtin_read_write_var
14989
- start_index = index
14990
- if node_cache[:builtin_read_write_var].has_key?(index)
14991
- cached = node_cache[:builtin_read_write_var][index]
14992
- if cached
14993
- node_cache[:builtin_read_write_var][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
14994
- @index = cached.interval.end
14995
- end
14996
- return cached
14997
- end
14998
-
14999
- if (match_len = has_terminal?("$pc", false, index))
15000
- r0 = instantiate_node(Idl::BuiltinVariableSyntaxNode,input, index...(index + match_len))
15001
- @index += match_len
15002
- else
15003
- terminal_parse_failure('"$pc"')
15004
- r0 = nil
15005
- end
15006
-
15007
- node_cache[:builtin_read_write_var][start_index] = r0
15008
-
15009
- r0
15010
- end
15011
-
15012
14370
  module CsrName0
15013
14371
  end
15014
14372