bayesnet 0.0.1 → 0.1.0

data/lib/bayesnet/parsers/bif.rb

@@ -0,0 +1,2484 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+require "treetop"
+
+module Bayesnet
+  module Parsers
+    module Bif
+      include Treetop::Runtime
+
+      def root
+        @root ||= :CompilationUnit
+      end
+
+      include Bayesnet::Parsers::Builder
+
+      module CompilationUnit0
+        def SEP1
+          elements[0]
+        end
+
+        def NetworkDeclaration
+          elements[1]
+        end
+
+        def list
+          elements[2]
+        end
+
+        def SEP2
+          elements[3]
+        end
+      end
+
+      module CompilationUnit1
+        def nodes
+          list.elements.select { |e| e.respond_to?(:node) }.map(&:node)
+        end
+
+        def cpts
+          list.elements.select { |e| e.respond_to?(:cpt) }.map(&:cpt)
+        end
+      end
+
+      def _nt_CompilationUnit
+        start_index = index
+        if node_cache[:CompilationUnit].has_key?(index)
+          cached = node_cache[:CompilationUnit][index]
+          if cached
+            node_cache[:CompilationUnit][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_NetworkDeclaration
+          s0 << r2
+          if r2
+            s3, i3 = [], index
+            loop do
+              i4 = index
+              r5 = _nt_VariableDeclaration
+              if r5
+                r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+                r4 = r5
+              else
+                r6 = _nt_ProbabilityDeclaration
+                if r6
+                  r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                  r4 = r6
+                else
+                  @index = i4
+                  r4 = nil
+                end
+              end
+              if r4
+                s3 << r4
+              else
+                break
+              end
+            end
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            s0 << r3
+            if r3
+              r7 = _nt_SEP
+              s0 << r7
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(CompilationUnit0)
+          r0.extend(CompilationUnit1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:CompilationUnit][start_index] = r0
+
+        r0
+      end
+
+      module NetworkDeclaration0
+        def SEP1
+          elements[0]
+        end
+
+        def NETWORK
+          elements[1]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def WORD
+          elements[3]
+        end
+
+        def SEP3
+          elements[4]
+        end
+
+        def NetworkContent
+          elements[5]
+        end
+
+        def SEP4
+          elements[6]
+        end
+      end
+
+      def _nt_NetworkDeclaration
+        start_index = index
+        if node_cache[:NetworkDeclaration].has_key?(index)
+          cached = node_cache[:NetworkDeclaration][index]
+          if cached
+            node_cache[:NetworkDeclaration][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_NETWORK
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              r4 = _nt_WORD
+              s0 << r4
+              if r4
+                r5 = _nt_SEP
+                s0 << r5
+                if r5
+                  r6 = _nt_NetworkContent
+                  s0 << r6
+                  if r6
+                    r7 = _nt_SEP
+                    s0 << r7
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(NetworkDeclaration0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:NetworkDeclaration][start_index] = r0
+
+        r0
+      end
+
+      module NetworkContent0
+        def SEP
+          elements[0]
+        end
+
+        def Property
+          elements[1]
+        end
+      end
+
+      module NetworkContent1
+        def SEP1
+          elements[0]
+        end
+
+        def SEP2
+          elements[3]
+        end
+
+        def SEP3
+          elements[5]
+        end
+      end
+
+      def _nt_NetworkContent
+        start_index = index
+        if node_cache[:NetworkContent].has_key?(index)
+          cached = node_cache[:NetworkContent][index]
+          if cached
+            node_cache[:NetworkContent][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          if (match_len = has_terminal?("{", false, index))
+            r2 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"{"')
+            r2 = nil
+          end
+          s0 << r2
+          if r2
+            s3, i3 = [], index
+            loop do
+              i4, s4 = index, []
+              r5 = _nt_SEP
+              s4 << r5
+              if r5
+                r6 = _nt_Property
+                s4 << r6
+              end
+              if s4.last
+                r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+                r4.extend(NetworkContent0)
+              else
+                @index = i4
+                r4 = nil
+              end
+              if r4
+                s3 << r4
+              else
+                break
+              end
+            end
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            s0 << r3
+            if r3
+              r7 = _nt_SEP
+              s0 << r7
+              if r7
+                if (match_len = has_terminal?("}", false, index))
+                  r8 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('"}"')
+                  r8 = nil
+                end
+                s0 << r8
+                if r8
+                  r9 = _nt_SEP
+                  s0 << r9
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(NetworkContent1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:NetworkContent][start_index] = r0
+
+        r0
+      end
+
+      module VariableDeclaration0
+        def SEP1
+          elements[0]
+        end
+
+        def VARIABLE
+          elements[1]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def probabilityVariableName
+          elements[3]
+        end
+
+        def SEP3
+          elements[4]
+        end
+
+        def variableContent
+          elements[5]
+        end
+
+        def SEP4
+          elements[6]
+        end
+      end
+
+      module VariableDeclaration1
+        def node
+          values = variableContent.values
+          [probabilityVariableName.text_value.to_sym, values]
+        end
+      end
+
+      def _nt_VariableDeclaration
+        start_index = index
+        if node_cache[:VariableDeclaration].has_key?(index)
+          cached = node_cache[:VariableDeclaration][index]
+          if cached
+            node_cache[:VariableDeclaration][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_VARIABLE
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              r4 = _nt_probabilityVariableName
+              s0 << r4
+              if r4
+                r5 = _nt_SEP
+                s0 << r5
+                if r5
+                  r6 = _nt_variableContent
+                  s0 << r6
+                  if r6
+                    r7 = _nt_SEP
+                    s0 << r7
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(VariableDeclaration0)
+          r0.extend(VariableDeclaration1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:VariableDeclaration][start_index] = r0
+
+        r0
+      end
+
+      module VariableContent0
+        def SEP
+          elements[0]
+        end
+
+        def Property
+          elements[1]
+        end
+      end
+
+      module VariableContent1
+        def SEP1
+          elements[0]
+        end
+
+        def list
+          elements[2]
+        end
+
+        def SEP2
+          elements[3]
+        end
+
+        def SEP3
+          elements[5]
+        end
+      end
+
+      module VariableContent2
+        def values
+          list.elements.select { |e| e.respond_to?(:values) }.map(&:values).flatten
+        end
+      end
+
+      def _nt_variableContent
+        start_index = index
+        if node_cache[:variableContent].has_key?(index)
+          cached = node_cache[:variableContent][index]
+          if cached
+            node_cache[:variableContent][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          if (match_len = has_terminal?("{", false, index))
+            r2 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"{"')
+            r2 = nil
+          end
+          s0 << r2
+          if r2
+            s3, i3 = [], index
+            loop do
+              i4 = index
+              i5, s5 = index, []
+              r6 = _nt_SEP
+              s5 << r6
+              if r6
+                r7 = _nt_Property
+                s5 << r7
+              end
+              if s5.last
+                r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+                r5.extend(VariableContent0)
+              else
+                @index = i5
+                r5 = nil
+              end
+              if r5
+                r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+                r4 = r5
+              else
+                r8 = _nt_variableDiscrete
+                if r8
+                  r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+                  r4 = r8
+                else
+                  @index = i4
+                  r4 = nil
+                end
+              end
+              if r4
+                s3 << r4
+              else
+                break
+              end
+            end
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            s0 << r3
+            if r3
+              r9 = _nt_SEP
+              s0 << r9
+              if r9
+                if (match_len = has_terminal?("}", false, index))
+                  r10 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('"}"')
+                  r10 = nil
+                end
+                s0 << r10
+                if r10
+                  r11 = _nt_SEP
+                  s0 << r11
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(VariableContent1)
+          r0.extend(VariableContent2)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:variableContent][start_index] = r0
+
+        r0
+      end
+
+      module VariableDiscrete0
+        def SEP1
+          elements[0]
+        end
+
+        def VARIABLETYPE
+          elements[1]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def DISCRETE
+          elements[3]
+        end
+
+        def SEP3
+          elements[4]
+        end
+
+        def SEP4
+          elements[6]
+        end
+
+        def DECIMAL_LITERAL
+          elements[7]
+        end
+
+        def SEP5
+          elements[8]
+        end
+
+        def SEP6
+          elements[10]
+        end
+
+        def SEP7
+          elements[12]
+        end
+
+        def variableValuesList
+          elements[13]
+        end
+
+        def SEP8
+          elements[14]
+        end
+
+        def SEP9
+          elements[16]
+        end
+
+        def SEP10
+          elements[18]
+        end
+      end
+
+      module VariableDiscrete1
+        def values
+          variableValuesList.values
+        end
+      end
+
+      def _nt_variableDiscrete
+        start_index = index
+        if node_cache[:variableDiscrete].has_key?(index)
+          cached = node_cache[:variableDiscrete][index]
+          if cached
+            node_cache[:variableDiscrete][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_VARIABLETYPE
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              r4 = _nt_DISCRETE
+              s0 << r4
+              if r4
+                r5 = _nt_SEP
+                s0 << r5
+                if r5
+                  if (match_len = has_terminal?("[", false, index))
+                    r6 = true
+                    @index += match_len
+                  else
+                    terminal_parse_failure('"["')
+                    r6 = nil
+                  end
+                  s0 << r6
+                  if r6
+                    r7 = _nt_SEP
+                    s0 << r7
+                    if r7
+                      r8 = _nt_DECIMAL_LITERAL
+                      s0 << r8
+                      if r8
+                        r9 = _nt_SEP
+                        s0 << r9
+                        if r9
+                          if (match_len = has_terminal?("]", false, index))
+                            r10 = true
+                            @index += match_len
+                          else
+                            terminal_parse_failure('"]"')
+                            r10 = nil
+                          end
+                          s0 << r10
+                          if r10
+                            r11 = _nt_SEP
+                            s0 << r11
+                            if r11
+                              if (match_len = has_terminal?("{", false, index))
+                                r12 = true
+                                @index += match_len
+                              else
+                                terminal_parse_failure('"{"')
+                                r12 = nil
+                              end
+                              s0 << r12
+                              if r12
+                                r13 = _nt_SEP
+                                s0 << r13
+                                if r13
+                                  r14 = _nt_variableValuesList
+                                  s0 << r14
+                                  if r14
+                                    r15 = _nt_SEP
+                                    s0 << r15
+                                    if r15
+                                      if (match_len = has_terminal?("}", false, index))
+                                        r16 = true
+                                        @index += match_len
+                                      else
+                                        terminal_parse_failure('"}"')
+                                        r16 = nil
+                                      end
+                                      s0 << r16
+                                      if r16
+                                        r17 = _nt_SEP
+                                        s0 << r17
+                                        if r17
+                                          if (match_len = has_terminal?(";", false, index))
+                                            r18 = true
+                                            @index += match_len
+                                          else
+                                            terminal_parse_failure('";"')
+                                            r18 = nil
+                                          end
+                                          s0 << r18
+                                          if r18
+                                            r19 = _nt_SEP
+                                            s0 << r19
+                                          end
+                                        end
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(VariableDiscrete0)
+          r0.extend(VariableDiscrete1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:variableDiscrete][start_index] = r0
+
+        r0
+      end
+
+      module VariableValuesList0
+        def SEP
+          elements[0]
+        end
+
+        def probabilityVariableValue
+          elements[1]
+        end
+      end
+
+      module VariableValuesList1
+        def SEP
+          elements[0]
+        end
+
+        def probabilityVariableValue
+          elements[1]
+        end
+
+        def list
+          elements[2]
+        end
+      end
+
+      module VariableValuesList2
+        def values
+          [probabilityVariableValue.value] + list.elements.map { |e| e.elements[1].value }.flatten
+        end
+      end
+
+      def _nt_variableValuesList
+        start_index = index
+        if node_cache[:variableValuesList].has_key?(index)
+          cached = node_cache[:variableValuesList][index]
+          if cached
+            node_cache[:variableValuesList][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_probabilityVariableValue
+          s0 << r2
+          if r2
+            s3, i3 = [], index
+            loop do
+              i4, s4 = index, []
+              r5 = _nt_SEP
+              s4 << r5
+              if r5
+                r6 = _nt_probabilityVariableValue
+                s4 << r6
+              end
+              if s4.last
+                r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+                r4.extend(VariableValuesList0)
+              else
+                @index = i4
+                r4 = nil
+              end
+              if r4
+                s3 << r4
+              else
+                break
+              end
+            end
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            s0 << r3
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(VariableValuesList1)
+          r0.extend(VariableValuesList2)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:variableValuesList][start_index] = r0
+
+        r0
+      end
+
+      module ProbabilityVariableValue0
+        def value
+          self.text_value.to_sym
+        end
+      end
+
+      def _nt_probabilityVariableValue
+        start_index = index
+        if node_cache[:probabilityVariableValue].has_key?(index)
+          cached = node_cache[:probabilityVariableValue][index]
+          if cached
+            node_cache[:probabilityVariableValue][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        r0 = _nt_VALUE
+        r0.extend(ProbabilityVariableValue0)
+        r0.extend(ProbabilityVariableValue0)
+
+        node_cache[:probabilityVariableValue][start_index] = r0
+
+        r0
+      end
+
+      module ProbabilityDeclaration0
+        def SEP1
+          elements[0]
+        end
+
+        def PROBABILITY
+          elements[1]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def probabilityVariablesList
+          elements[3]
+        end
+
+        def SEP3
+          elements[4]
+        end
+
+        def probabilityContent
+          elements[5]
+        end
+
+        def SEP4
+          elements[6]
+        end
+      end
+
+      module ProbabilityDeclaration1
+        def cpt
+          { variable: probabilityVariablesList.value,
+            parents: probabilityVariablesList.parents,
+            cpt: probabilityContent.cpt}
+        end
+      end
+
+      def _nt_ProbabilityDeclaration
+        start_index = index
+        if node_cache[:ProbabilityDeclaration].has_key?(index)
+          cached = node_cache[:ProbabilityDeclaration][index]
+          if cached
+            node_cache[:ProbabilityDeclaration][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_PROBABILITY
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              r4 = _nt_probabilityVariablesList
+              s0 << r4
+              if r4
+                r5 = _nt_SEP
+                s0 << r5
+                if r5
+                  r6 = _nt_probabilityContent
+                  s0 << r6
+                  if r6
+                    r7 = _nt_SEP
+                    s0 << r7
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(ProbabilityDeclaration0)
+          r0.extend(ProbabilityDeclaration1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:ProbabilityDeclaration][start_index] = r0
+
+        r0
+      end
+
+      module ProbabilityVariablesList0
+        def SEP
+          elements[0]
+        end
+
+        def probabilityVariableName
+          elements[1]
+        end
+      end
+
+      module ProbabilityVariablesList1
+        def SEP1
+          elements[0]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def probabilityVariableName
+          elements[3]
+        end
+
+        def list
+          elements[4]
+        end
+
+        def SEP3
+          elements[5]
+        end
+
+        def SEP4
+          elements[7]
+        end
+      end
+
+      module ProbabilityVariablesList2
+        def value
+          probabilityVariableName.value
+        end
+
+        def parents
+           list.elements.map { |e| e.elements[1].value }.flatten
+        end
+      end
+
+      def _nt_probabilityVariablesList
+        start_index = index
+        if node_cache[:probabilityVariablesList].has_key?(index)
+          cached = node_cache[:probabilityVariablesList][index]
+          if cached
+            node_cache[:probabilityVariablesList][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          if (match_len = has_terminal?("(", false, index))
+            r2 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"("')
+            r2 = nil
+          end
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              r4 = _nt_probabilityVariableName
+              s0 << r4
+              if r4
+                s5, i5 = [], index
+                loop do
+                  i6, s6 = index, []
+                  r7 = _nt_SEP
+                  s6 << r7
+                  if r7
+                    r8 = _nt_probabilityVariableName
+                    s6 << r8
+                  end
+                  if s6.last
+                    r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+                    r6.extend(ProbabilityVariablesList0)
+                  else
+                    @index = i6
+                    r6 = nil
+                  end
+                  if r6
+                    s5 << r6
+                  else
+                    break
+                  end
+                end
+                r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+                s0 << r5
+                if r5
+                  r9 = _nt_SEP
+                  s0 << r9
+                  if r9
+                    if (match_len = has_terminal?(")", false, index))
+                      r10 = true
+                      @index += match_len
+                    else
+                      terminal_parse_failure('")"')
+                      r10 = nil
+                    end
+                    s0 << r10
+                    if r10
+                      r11 = _nt_SEP
+                      s0 << r11
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(ProbabilityVariablesList1)
+          r0.extend(ProbabilityVariablesList2)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:probabilityVariablesList][start_index] = r0
+
+        r0
+      end
+
+      module ProbabilityVariableName0
+        def value
+          self.text_value.to_sym
+        end
+      end
+
+      def _nt_probabilityVariableName
+        start_index = index
+        if node_cache[:probabilityVariableName].has_key?(index)
+          cached = node_cache[:probabilityVariableName][index]
+          if cached
+            node_cache[:probabilityVariableName][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        r0 = _nt_WORD
+        r0.extend(ProbabilityVariableName0)
+        r0.extend(ProbabilityVariableName0)
+
+        node_cache[:probabilityVariableName][start_index] = r0
+
+        r0
+      end
+
+      module ProbabilityContent0
+        def SEP
+          elements[0]
+        end
+
+        def Property
+          elements[1]
+        end
+      end
+
+      module ProbabilityContent1
+        def SEP1
+          elements[0]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def list
+          elements[3]
+        end
+
+        def SEP3
+          elements[4]
+        end
+
+        def SEP4
+          elements[6]
+        end
+      end
+
+      module ProbabilityContent2
+        def cpt
+           distributions = list.elements.select { |e| e.respond_to?(:given) }.map do |e|
+             {given: e.given,
+              distribution: e.distribution}
+           end
+           table = list.elements.select { |e| e.respond_to?(:table) }.map do |e|
+            {table: e.table}
+           end
+           if distributions.empty? && !table.empty?
+             return table.first
+           elsif !distributions.empty? && table.empty?
+             return distributions
+           elsif distributions.empty? && table.empty?
+             raise "Either distributions or table must be provided"
+           else
+             raise "Both - distributions or table cannot be provided at the same time"
+           end
+        end
+      end
+
+      def _nt_probabilityContent
+        start_index = index
+        if node_cache[:probabilityContent].has_key?(index)
+          cached = node_cache[:probabilityContent][index]
+          if cached
+            node_cache[:probabilityContent][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          if (match_len = has_terminal?("{", false, index))
+            r2 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"{"')
+            r2 = nil
+          end
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              s4, i4 = [], index
+              loop do
+                i5 = index
+                i6, s6 = index, []
+                r7 = _nt_SEP
+                s6 << r7
+                if r7
+                  r8 = _nt_Property
+                  s6 << r8
+                end
+                if s6.last
+                  r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+                  r6.extend(ProbabilityContent0)
+                else
+                  @index = i6
+                  r6 = nil
+                end
+                if r6
+                  r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                  r5 = r6
+                else
+                  r9 = _nt_ProbabilityDefaultEntry
+                  if r9
+                    r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+                    r5 = r9
+                  else
+                    r10 = _nt_ProbabilityEntry
+                    if r10
+                      r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
+                      r5 = r10
+                    else
+                      r11 = _nt_ProbabilityTable
+                      if r11
+                        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
+                        r5 = r11
+                      else
+                        @index = i5
+                        r5 = nil
+                      end
+                    end
+                  end
+                end
+                if r5
+                  s4 << r5
+                else
+                  break
+                end
+              end
+              r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+              s0 << r4
+              if r4
+                r12 = _nt_SEP
+                s0 << r12
+                if r12
+                  if (match_len = has_terminal?("}", false, index))
+                    r13 = true
+                    @index += match_len
+                  else
+                    terminal_parse_failure('"}"')
+                    r13 = nil
+                  end
+                  s0 << r13
+                  if r13
+                    r14 = _nt_SEP
+                    s0 << r14
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(ProbabilityContent1)
+          r0.extend(ProbabilityContent2)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:probabilityContent][start_index] = r0
+
+        r0
+      end
+
+      module ProbabilityEntry0
+        def SEP1
+          elements[0]
+        end
+
+        def probabilityValuesList
+          elements[1]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def floatingPointList
+          elements[3]
+        end
+
+        def SEP3
+          elements[4]
+        end
+
+        def SEP4
+          elements[6]
+        end
+      end
+
+      module ProbabilityEntry1
+        def given
+          probabilityValuesList.values
+        end
+        def distribution
+          floatingPointList.values
+        end
+      end
+
+      def _nt_ProbabilityEntry
+        start_index = index
+        if node_cache[:ProbabilityEntry].has_key?(index)
+          cached = node_cache[:ProbabilityEntry][index]
+          if cached
+            node_cache[:ProbabilityEntry][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_probabilityValuesList
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              r4 = _nt_floatingPointList
+              s0 << r4
+              if r4
+                r5 = _nt_SEP
+                s0 << r5
+                if r5
+                  if (match_len = has_terminal?(";", false, index))
+                    r6 = true
+                    @index += match_len
+                  else
+                    terminal_parse_failure('";"')
+                    r6 = nil
+                  end
+                  s0 << r6
+                  if r6
+                    r7 = _nt_SEP
+                    s0 << r7
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(ProbabilityEntry0)
+          r0.extend(ProbabilityEntry1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:ProbabilityEntry][start_index] = r0
+
+        r0
+      end
+
+      module ProbabilityValuesList0
+        def SEP
+          elements[0]
+        end
+
+        def probabilityVariableValue
+          elements[1]
+        end
+      end
+
+      module ProbabilityValuesList1
+        def SEP1
+          elements[0]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def probabilityVariableValue
+          elements[3]
+        end
+
+        def list
+          elements[4]
+        end
+
+        def SEP3
+          elements[5]
+        end
+
+      end
+
+      module ProbabilityValuesList2
+        def values
+          [probabilityVariableValue.value] + list.elements.map { |e| e.elements[1].value }
+        end
+      end
+
+      def _nt_probabilityValuesList
+        start_index = index
+        if node_cache[:probabilityValuesList].has_key?(index)
+          cached = node_cache[:probabilityValuesList][index]
+          if cached
+            node_cache[:probabilityValuesList][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          if (match_len = has_terminal?("(", false, index))
+            r2 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"("')
+            r2 = nil
+          end
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              r4 = _nt_probabilityVariableValue
+              s0 << r4
+              if r4
+                s5, i5 = [], index
+                loop do
+                  i6, s6 = index, []
+                  r7 = _nt_SEP
+                  s6 << r7
+                  if r7
+                    r8 = _nt_probabilityVariableValue
+                    s6 << r8
+                  end
+                  if s6.last
+                    r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+                    r6.extend(ProbabilityValuesList0)
+                  else
+                    @index = i6
+                    r6 = nil
+                  end
+                  if r6
+                    s5 << r6
+                  else
+                    break
+                  end
+                end
+                r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+                s0 << r5
+                if r5
+                  r9 = _nt_SEP
+                  s0 << r9
+                  if r9
+                    if (match_len = has_terminal?(")", false, index))
+                      r10 = true
+                      @index += match_len
+                    else
+                      terminal_parse_failure('")"')
+                      r10 = nil
+                    end
+                    s0 << r10
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(ProbabilityValuesList1)
+          r0.extend(ProbabilityValuesList2)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:probabilityValuesList][start_index] = r0
+
+        r0
+      end
+
+      module ProbabilityDefaultEntry0
+        def SEP1
+          elements[0]
+        end
+
+        def floatingPointList
+          elements[1]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def SEP3
+          elements[4]
+        end
+      end
+
+      module ProbabilityDefaultEntry1
+        def values
+          floatingPointList.values
+        end
+      end
+
+      def _nt_ProbabilityDefaultEntry
+        start_index = index
+        if node_cache[:ProbabilityDefaultEntry].has_key?(index)
+          cached = node_cache[:ProbabilityDefaultEntry][index]
+          if cached
+            node_cache[:ProbabilityDefaultEntry][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_floatingPointList
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              if (match_len = has_terminal?(";", false, index))
+                r4 = true
+                @index += match_len
+              else
+                terminal_parse_failure('";"')
+                r4 = nil
+              end
+              s0 << r4
+              if r4
+                r5 = _nt_SEP
+                s0 << r5
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(ProbabilityDefaultEntry0)
+          r0.extend(ProbabilityDefaultEntry1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:ProbabilityDefaultEntry][start_index] = r0
+
+        r0
+      end
+
+      module ProbabilityTable0
+        def SEP1
+          elements[0]
+        end
+
+        def TABLEVALUE
+          elements[1]
+        end
+
+        def SEP2
+          elements[2]
+        end
+
+        def floatingPointList
+          elements[3]
+        end
+
+        def SEP3
+          elements[4]
+        end
+
+        def SEP4
+          elements[6]
+        end
+      end
+
+      module ProbabilityTable1
+        def table
+          floatingPointList.values
+        end
+      end
+
+      def _nt_ProbabilityTable
+        start_index = index
+        if node_cache[:ProbabilityTable].has_key?(index)
+          cached = node_cache[:ProbabilityTable][index]
+          if cached
+            node_cache[:ProbabilityTable][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_TABLEVALUE
+          s0 << r2
+          if r2
+            r3 = _nt_SEP
+            s0 << r3
+            if r3
+              r4 = _nt_floatingPointList
+              s0 << r4
+              if r4
+                r5 = _nt_SEP
+                s0 << r5
+                if r5
+                  if (match_len = has_terminal?(";", false, index))
+                    r6 = true
+                    @index += match_len
+                  else
+                    terminal_parse_failure('";"')
+                    r6 = nil
+                  end
+                  s0 << r6
+                  if r6
+                    r7 = _nt_SEP
+                    s0 << r7
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(ProbabilityTable0)
+          r0.extend(ProbabilityTable1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:ProbabilityTable][start_index] = r0
+
+        r0
+      end
+
+      module FloatingPointList0
+        def SEP
+          elements[0]
+        end
+
+        def floatingPointToken
+          elements[1]
+        end
+      end
+
+      module FloatingPointList1
+        def SEP
+          elements[0]
+        end
+
+        def floatingPointToken
+          elements[1]
+        end
+
+        def list
+          elements[2]
+        end
+      end
+
+      module FloatingPointList2
+        def values
+          [floatingPointToken.value] + list.elements.map {|e| e.elements[1]}.select { |e| e.respond_to?(:value) }.map(&:value)
+        end
+      end
+
+      def _nt_floatingPointList
+        start_index = index
+        if node_cache[:floatingPointList].has_key?(index)
+          cached = node_cache[:floatingPointList][index]
+          if cached
+            node_cache[:floatingPointList][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_SEP
+        s0 << r1
+        if r1
+          r2 = _nt_floatingPointToken
+          s0 << r2
+          if r2
+            s3, i3 = [], index
+            loop do
+              i4, s4 = index, []
+              r5 = _nt_SEP
+              s4 << r5
+              if r5
+                r6 = _nt_floatingPointToken
+                s4 << r6
+              end
+              if s4.last
+                r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+                r4.extend(FloatingPointList0)
+              else
+                @index = i4
+                r4 = nil
+              end
+              if r4
+                s3 << r4
+              else
+                break
+              end
+            end
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            s0 << r3
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(FloatingPointList1)
+          r0.extend(FloatingPointList2)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:floatingPointList][start_index] = r0
+
+        r0
+      end
+
+      module FloatingPointToken0
+        def value
+          self.text_value.to_f
+        end
+      end
+
+      def _nt_floatingPointToken
+        start_index = index
+        if node_cache[:floatingPointToken].has_key?(index)
+          cached = node_cache[:floatingPointToken][index]
+          if cached
+            node_cache[:floatingPointToken][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        r0 = _nt_FLOATING_POINT_LITERAL
+        r0.extend(FloatingPointToken0)
+        r0.extend(FloatingPointToken0)
+
+        node_cache[:floatingPointToken][start_index] = r0
+
+        r0
+      end
+
+      def _nt_Property
+        start_index = index
+        if node_cache[:Property].has_key?(index)
+          cached = node_cache[:Property][index]
+          if cached
+            node_cache[:Property][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        r0 = _nt_PROPERTYSTRING
+
+        node_cache[:Property][start_index] = r0
+
+        r0
+      end
+
+      def _nt_NETWORK
+        start_index = index
+        if node_cache[:NETWORK].has_key?(index)
+          cached = node_cache[:NETWORK][index]
+          if cached
+            node_cache[:NETWORK][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if (match_len = has_terminal?('network', false, index))
+          r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('\'network\'')
+          r0 = nil
+        end
+
+        node_cache[:NETWORK][start_index] = r0
+
+        r0
+      end
+
+      def _nt_VARIABLE
+        start_index = index
+        if node_cache[:VARIABLE].has_key?(index)
+          cached = node_cache[:VARIABLE][index]
+          if cached
+            node_cache[:VARIABLE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if (match_len = has_terminal?('variable', false, index))
+          r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('\'variable\'')
+          r0 = nil
+        end
+
+        node_cache[:VARIABLE][start_index] = r0
+
+        r0
+      end
+
+      def _nt_PROBABILITY
+        start_index = index
+        if node_cache[:PROBABILITY].has_key?(index)
+          cached = node_cache[:PROBABILITY][index]
+          if cached
+            node_cache[:PROBABILITY][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if (match_len = has_terminal?('probability', false, index))
+          r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('\'probability\'')
+          r0 = nil
+        end
+
+        node_cache[:PROBABILITY][start_index] = r0
+
+        r0
+      end
+
+      def _nt_PROPERTY
+        start_index = index
+        if node_cache[:PROPERTY].has_key?(index)
+          cached = node_cache[:PROPERTY][index]
+          if cached
+            node_cache[:PROPERTY][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if (match_len = has_terminal?('property', false, index))
+          r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('\'property\'')
+          r0 = nil
+        end
+
+        node_cache[:PROPERTY][start_index] = r0
+
+        r0
+      end
+
+      def _nt_VARIABLETYPE
+        start_index = index
+        if node_cache[:VARIABLETYPE].has_key?(index)
+          cached = node_cache[:VARIABLETYPE][index]
+          if cached
+            node_cache[:VARIABLETYPE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if (match_len = has_terminal?('type', false, index))
+          r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('\'type\'')
+          r0 = nil
+        end
+
+        node_cache[:VARIABLETYPE][start_index] = r0
+
+        r0
+      end
+
+      def _nt_DISCRETE
+        start_index = index
+        if node_cache[:DISCRETE].has_key?(index)
+          cached = node_cache[:DISCRETE][index]
+          if cached
+            node_cache[:DISCRETE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if (match_len = has_terminal?('discrete', false, index))
+          r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('\'discrete\'')
+          r0 = nil
+        end
+
+        node_cache[:DISCRETE][start_index] = r0
+
+        r0
+      end
+
+      def _nt_DEFAULTVALUE
+        start_index = index
+        if node_cache[:DEFAULTVALUE].has_key?(index)
+          cached = node_cache[:DEFAULTVALUE][index]
+          if cached
+            node_cache[:DEFAULTVALUE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if (match_len = has_terminal?('default', false, index))
+          r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('\'default\'')
+          r0 = nil
+        end
+
+        node_cache[:DEFAULTVALUE][start_index] = r0
+
+        r0
+      end
+
+      def _nt_TABLEVALUE
+        start_index = index
+        if node_cache[:TABLEVALUE].has_key?(index)
+          cached = node_cache[:TABLEVALUE][index]
+          if cached
+            node_cache[:TABLEVALUE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if (match_len = has_terminal?('table', false, index))
+          r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('\'table\'')
+          r0 = nil
+        end
+
+        node_cache[:TABLEVALUE][start_index] = r0
+
+        r0
+      end
+
+      module WORD0
+        def LETTER
+          elements[0]
+        end
+
+      end
+
+      def _nt_WORD
+        start_index = index
+        if node_cache[:WORD].has_key?(index)
+          cached = node_cache[:WORD][index]
+          if cached
+            node_cache[:WORD][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_LETTER
+        s0 << r1
+        if r1
+          s2, i2 = [], index
+          loop do
+            i3 = index
+            r4 = _nt_LETTER
+            if r4
+              r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+              r3 = r4
+            else
+              r5 = _nt_DIGIT
+              if r5
+                r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+                r3 = r5
+              else
+                @index = i3
+                r3 = nil
+              end
+            end
+            if r3
+              s2 << r3
+            else
+              break
+            end
+          end
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          s0 << r2
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(WORD0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:WORD][start_index] = r0
+
+        r0
+      end
+
+      def _nt_LETTER
+        start_index = index
+        if node_cache[:LETTER].has_key?(index)
+          cached = node_cache[:LETTER][index]
+          if cached
+            node_cache[:LETTER][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if has_terminal?(@regexps[gr = '\A[a-zA-Z_-]'] ||= Regexp.new(gr), :regexp, index)
+          r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('[a-zA-Z_-]')
+          r0 = nil
+        end
+
+        node_cache[:LETTER][start_index] = r0
+
+        r0
+      end
+
+      def _nt_VALUE
+        start_index = index
+        if node_cache[:VALUE].has_key?(index)
+          cached = node_cache[:VALUE][index]
+          if cached
+            node_cache[:VALUE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        s0, i0 = [], index
+        loop do
+          if has_terminal?(@regexps[gr = '\A[/<>=.+a-zA-Z_0-9-]'] ||= Regexp.new(gr), :regexp, index)
+            r1 = true
+            @index += 1
+          else
+            terminal_parse_failure('[/<>=.+a-zA-Z_0-9-]')
+            r1 = nil
+          end
+          if r1
+            s0 << r1
+          else
+            break
+          end
+        end
+        if s0.empty?
+          @index = i0
+          r0 = nil
+        else
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        end
+
+        node_cache[:VALUE][start_index] = r0
+
+        r0
+      end
+
+      def _nt_DIGIT
+        start_index = index
+        if node_cache[:DIGIT].has_key?(index)
+          cached = node_cache[:DIGIT][index]
+          if cached
+            node_cache[:DIGIT][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
+          r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('[0-9]')
+          r0 = nil
+        end
+
+        node_cache[:DIGIT][start_index] = r0
+
+        r0
+      end
+
+      module DECIMALLITERAL0
+        def DIGIT
+          elements[0]
+        end
+
+      end
+
+      def _nt_DECIMAL_LITERAL
+        start_index = index
+        if node_cache[:DECIMAL_LITERAL].has_key?(index)
+          cached = node_cache[:DECIMAL_LITERAL][index]
+          if cached
+            node_cache[:DECIMAL_LITERAL][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_DIGIT
+        s0 << r1
+        if r1
+          s2, i2 = [], index
+          loop do
+            r3 = _nt_DIGIT
+            if r3
+              s2 << r3
+            else
+              break
+            end
+          end
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          s0 << r2
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(DECIMALLITERAL0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:DECIMAL_LITERAL][start_index] = r0
+
+        r0
+      end
+
+      module FLOATINGPOINTLITERAL0
+      end
+
+      module FLOATINGPOINTLITERAL1
+      end
+
+      module FLOATINGPOINTLITERAL2
+        def EXPONENT
+          elements[1]
+        end
+      end
+
+      def _nt_FLOATING_POINT_LITERAL
+        start_index = index
+        if node_cache[:FLOATING_POINT_LITERAL].has_key?(index)
+          cached = node_cache[:FLOATING_POINT_LITERAL][index]
+          if cached
+            node_cache[:FLOATING_POINT_LITERAL][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        i1, s1 = index, []
+        s2, i2 = [], index
+        loop do
+          r3 = _nt_DIGIT
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        if s2.empty?
+          @index = i2
+          r2 = nil
+        else
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        end
+        s1 << r2
+        if r2
+          if (match_len = has_terminal?('.', false, index))
+            r4 = true
+            @index += match_len
+          else
+            terminal_parse_failure('\'.\'')
+            r4 = nil
+          end
+          s1 << r4
+          if r4
+            s5, i5 = [], index
+            loop do
+              r6 = _nt_DIGIT
+              if r6
+                s5 << r6
+              else
+                break
+              end
+            end
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            s1 << r5
+            if r5
+              r8 = _nt_EXPONENT
+              if r8
+                r7 = r8
+              else
+                r7 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s1 << r7
+            end
+          end
+        end
+        if s1.last
+          r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+          r1.extend(FLOATINGPOINTLITERAL0)
+        else
+          @index = i1
+          r1 = nil
+        end
+        if r1
+          r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+          r0 = r1
+        else
+          i9, s9 = index, []
+          if (match_len = has_terminal?('.', false, index))
+            r10 = true
+            @index += match_len
+          else
+            terminal_parse_failure('\'.\'')
+            r10 = nil
+          end
+          s9 << r10
+          if r10
+            s11, i11 = [], index
+            loop do
+              r12 = _nt_DIGIT
+              if r12
+                s11 << r12
+              else
+                break
+              end
+            end
+            if s11.empty?
+              @index = i11
+              r11 = nil
+            else
+              r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+            end
+            s9 << r11
+            if r11
+              r14 = _nt_EXPONENT
+              if r14
+                r13 = r14
+              else
+                r13 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s9 << r13
+            end
+          end
+          if s9.last
+            r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+            r9.extend(FLOATINGPOINTLITERAL1)
+          else
+            @index = i9
+            r9 = nil
+          end
+          if r9
+            r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+            r0 = r9
+          else
+            i15, s15 = index, []
+            s16, i16 = [], index
+            loop do
+              r17 = _nt_DIGIT
+              if r17
+                s16 << r17
+              else
+                break
+              end
+            end
+            if s16.empty?
+              @index = i16
+              r16 = nil
+            else
+              r16 = instantiate_node(SyntaxNode,input, i16...index, s16)
+            end
+            s15 << r16
+            if r16
+              r18 = _nt_EXPONENT
+              s15 << r18
+            end
+            if s15.last
+              r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+              r15.extend(FLOATINGPOINTLITERAL2)
+            else
+              @index = i15
+              r15 = nil
+            end
+            if r15
+              r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
+              r0 = r15
+            else
+              @index = i0
+              r0 = nil
+            end
+          end
+        end
+
+        node_cache[:FLOATING_POINT_LITERAL][start_index] = r0
+
+        r0
+      end
+
+      module EXPONENT0
+      end
+
+      def _nt_EXPONENT
+        start_index = index
+        if node_cache[:EXPONENT].has_key?(index)
+          cached = node_cache[:EXPONENT][index]
+          if cached
+            node_cache[:EXPONENT][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
+          r1 = true
+          @index += 1
+        else
+          terminal_parse_failure('[eE]')
+          r1 = nil
+        end
+        s0 << r1
+        if r1
+          if has_terminal?(@regexps[gr = '\A[+-]'] ||= Regexp.new(gr), :regexp, index)
+            r3 = true
+            @index += 1
+          else
+            terminal_parse_failure('[+-]')
+            r3 = nil
+          end
+          if r3
+            r2 = r3
+          else
+            r2 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s0 << r2
+          if r2
+            s4, i4 = [], index
+            loop do
+              r5 = _nt_DIGIT
+              if r5
+                s4 << r5
+              else
+                break
+              end
+            end
+            if s4.empty?
+              @index = i4
+              r4 = nil
+            else
+              r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            end
+            s0 << r4
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(EXPONENT0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:EXPONENT][start_index] = r0
+
+        r0
+      end
+
+      module PROPERTYSTRING0
+        def PROPERTY
+          elements[0]
+        end
+
+      end
+
+      def _nt_PROPERTYSTRING
+        start_index = index
+        if node_cache[:PROPERTYSTRING].has_key?(index)
+          cached = node_cache[:PROPERTYSTRING][index]
+          if cached
+            node_cache[:PROPERTYSTRING][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_PROPERTY
+        s0 << r1
+        if r1
+          s2, i2 = [], index
+          loop do
+            if index < input_length
+              r3 = true
+              @index += 1
+            else
+              terminal_parse_failure("any character")
+              r3 = nil
+            end
+            if r3
+              s2 << r3
+            else
+              break
+            end
+          end
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          s0 << r2
+          if r2
+            if (match_len = has_terminal?(';', false, index))
+              r4 = true
+              @index += match_len
+            else
+              terminal_parse_failure('\';\'')
+              r4 = nil
+            end
+            s0 << r4
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(PROPERTYSTRING0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:PROPERTYSTRING][start_index] = r0
+
+        r0
+      end
+
+      def _nt_SEP
+        start_index = index
+        if node_cache[:SEP].has_key?(index)
+          cached = node_cache[:SEP][index]
+          if cached
+            node_cache[:SEP][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        s0, i0 = [], index
+        loop do
+          if has_terminal?(@regexps[gr = '\A[\\r\\n\\t ,|]'] ||= Regexp.new(gr), :regexp, index)
+            r1 = true
+            @index += 1
+          else
+            terminal_parse_failure('[\\r\\n\\t ,|]')
+            r1 = nil
+          end
+          if r1
+            s0 << r1
+          else
+            break
+          end
+        end
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+        node_cache[:SEP][start_index] = r0
+
+        r0
+      end
+
+    end
+
+    class BifParser < Treetop::Runtime::CompiledParser
+      include Bif
+    end
+
+  end
+end