Module: ActiveFacts::CQL::TransformRules

Includes:: Treetop::Runtime

Included in:: CQL, TransformRulesParser

Defined in:: lib/activefacts/cql/parser/TransformRules.rb

Defined Under Namespace

Modules: AdditiveTexpr0, AdditiveTexpr1, AdditiveTexpr2, CompoundMatching0, CompoundMatching1, EqualityTexpr0, EqualityTexpr1, EqualityTexpr2, LogicalAndTexpr0, LogicalAndTexpr1, LogicalAndTexpr2, LogicalTexpr0, LogicalTexpr1, LogicalTexpr2, MultiplicativeTexpr0, MultiplicativeTexpr1, MultiplicativeTexpr2, PrimaryTexpr0, PrimaryTexpr1, PrimaryTexpr2, PrimaryTexpr3, RelationalTexpr0, RelationalTexpr1, RelationalTexpr2, SimpleMatching0, SimpleMatching1, TermList0, TermList1, TermList2, TransformExpr0, TransformExpr1, TransformExpr2, TransformExpr3, TransformExpr4, TransformExpr5, TransformMatching0, TransformMatching1, TransformMatching2, TransformMatching3, TransformMatchings0, TransformMatchings1, TransformMatchings2, TransformQuery0, TransformQuery1, TransformQuery2, TransformQuery3, TransformRule0, TransformRule1, UnaryTexpr0, UnaryTexpr1

Instance Method Summary collapse

Instance Method Details

#_nt_additive_op ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1610

def _nt_additive_op
  start_index = index
  if node_cache[:additive_op].has_key?(index)
    cached = node_cache[:additive_op][index]
    if cached
      node_cache[:additive_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('+', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('\'+\'')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('-', false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('\'-\'')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:additive_op][start_index] = r0

  r0
end

#_nt_additive_texpr ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1544

def _nt_additive_texpr
  start_index = index
  if node_cache[:additive_texpr].has_key?(index)
    cached = node_cache[:additive_texpr][index]
    if cached
      node_cache[:additive_texpr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_multiplicative_texpr
    s0 << r2
    if r2
      s3, i3 = [], index
      loop do
        i4, s4 = index, []
        r5 = _nt_s
        s4 << r5
        if r5
          r6 = _nt_additive_op
          s4 << r6
          if r6
            r7 = _nt_s
            s4 << r7
            if r7
              r8 = _nt_multiplicative_texpr
              s4 << r8
            end
          end
        end
        if s4.last
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
          r4.extend(AdditiveTexpr0)
        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(AdditiveTexpr1)
    r0.extend(AdditiveTexpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:additive_texpr][start_index] = r0

  r0
end

#_nt_aggregate_op ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 883

def _nt_aggregate_op
  start_index = index
  if node_cache[:aggregate_op].has_key?(index)
    cached = node_cache[:aggregate_op][index]
    if cached
      node_cache[:aggregate_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('sum', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('\'sum\'')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('average', false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('\'average\'')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?('max', false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('\'max\'')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?('min', false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('\'min\'')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          if (match_len = has_terminal?('count', false, index))
            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('\'count\'')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end
  end

  node_cache[:aggregate_op][start_index] = r0

  r0
end

#_nt_compound_matching ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 119

def _nt_compound_matching
  start_index = index
  if node_cache[:compound_matching].has_key?(index)
    cached = node_cache[:compound_matching][index]
    if cached
      node_cache[:compound_matching][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_term_list
    s0 << r2
    if r2
      r3 = _nt_s
      s0 << r3
      if r3
        if (match_len = has_terminal?('<==', false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('\'<==\'')
          r4 = nil
        end
        s0 << r4
        if r4
          r5 = _nt_s
          s0 << r5
          if r5
            r7 = _nt_transform_query
            if r7
              r6 = r7
            else
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
            if r6
              r8 = _nt_s
              s0 << r8
              if r8
                if (match_len = has_terminal?('{', false, index))
                  r9 = true
                  @index += match_len
                else
                  terminal_parse_failure('\'{\'')
                  r9 = nil
                end
                s0 << r9
                if r9
                  r10 = _nt_transform_matchings
                  s0 << r10
                  if r10
                    r11 = _nt_s
                    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
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CompoundMatching0)
    r0.extend(CompoundMatching1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:compound_matching][start_index] = r0

  r0
end

#_nt_equality_op ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1283

def _nt_equality_op
  start_index = index
  if node_cache[:equality_op].has_key?(index)
    cached = node_cache[:equality_op][index]
    if cached
      node_cache[:equality_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('=', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('\'=\'')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('!=', false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('\'!=\'')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:equality_op][start_index] = r0

  r0
end

#_nt_equality_texpr ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1221

def _nt_equality_texpr
  start_index = index
  if node_cache[:equality_texpr].has_key?(index)
    cached = node_cache[:equality_texpr][index]
    if cached
      node_cache[:equality_texpr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_relational_texpr
    s0 << r2
    if r2
      i4, s4 = index, []
      r5 = _nt_s
      s4 << r5
      if r5
        r6 = _nt_equality_op
        s4 << r6
        if r6
          r7 = _nt_s
          s4 << r7
          if r7
            r8 = _nt_relational_texpr
            s4 << r8
          end
        end
      end
      if s4.last
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        r4.extend(EqualityTexpr0)
      else
        @index = i4
        r4 = nil
      end
      if r4
        r3 = r4
      else
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(EqualityTexpr1)
    r0.extend(EqualityTexpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:equality_texpr][start_index] = r0

  r0
end

#_nt_logical_and_texpr ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1113

def _nt_logical_and_texpr
  start_index = index
  if node_cache[:logical_and_texpr].has_key?(index)
    cached = node_cache[:logical_and_texpr][index]
    if cached
      node_cache[:logical_and_texpr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_equality_texpr
    s0 << r2
    if r2
      s3, i3 = [], index
      loop do
        i4, s4 = index, []
        r5 = _nt_s
        s4 << r5
        if r5
          r6 = _nt_and
          s4 << r6
          if r6
            r7 = _nt_s
            s4 << r7
            if r7
              r8 = _nt_equality_texpr
              s4 << r8
            end
          end
        end
        if s4.last
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
          r4.extend(LogicalAndTexpr0)
        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(LogicalAndTexpr1)
    r0.extend(LogicalAndTexpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:logical_and_texpr][start_index] = r0

  r0
end

#_nt_logical_texpr ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1005

def _nt_logical_texpr
  start_index = index
  if node_cache[:logical_texpr].has_key?(index)
    cached = node_cache[:logical_texpr][index]
    if cached
      node_cache[:logical_texpr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_logical_and_texpr
    s0 << r2
    if r2
      s3, i3 = [], index
      loop do
        i4, s4 = index, []
        r5 = _nt_s
        s4 << r5
        if r5
          r6 = _nt_or
          s4 << r6
          if r6
            r7 = _nt_s
            s4 << r7
            if r7
              r8 = _nt_logical_and_texpr
              s4 << r8
            end
          end
        end
        if s4.last
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
          r4.extend(LogicalTexpr0)
        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(LogicalTexpr1)
    r0.extend(LogicalTexpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:logical_texpr][start_index] = r0

  r0
end

#_nt_multiplicative_op ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1765

def _nt_multiplicative_op
  start_index = index
  if node_cache[:multiplicative_op].has_key?(index)
    cached = node_cache[:multiplicative_op][index]
    if cached
      node_cache[:multiplicative_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('*', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('\'*\'')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('/', false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('\'/\'')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:multiplicative_op][start_index] = r0

  r0
end

#_nt_multiplicative_texpr ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1699

def _nt_multiplicative_texpr
  start_index = index
  if node_cache[:multiplicative_texpr].has_key?(index)
    cached = node_cache[:multiplicative_texpr][index]
    if cached
      node_cache[:multiplicative_texpr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_unary_texpr
    s0 << r2
    if r2
      s3, i3 = [], index
      loop do
        i4, s4 = index, []
        r5 = _nt_s
        s4 << r5
        if r5
          r6 = _nt_multiplicative_op
          s4 << r6
          if r6
            r7 = _nt_s
            s4 << r7
            if r7
              r8 = _nt_unary_texpr
              s4 << r8
            end
          end
        end
        if s4.last
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
          r4.extend(MultiplicativeTexpr0)
        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(MultiplicativeTexpr1)
    r0.extend(MultiplicativeTexpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:multiplicative_texpr][start_index] = r0

  r0
end

#_nt_primary_texpr ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1950

def _nt_primary_texpr
  start_index = index
  if node_cache[:primary_texpr].has_key?(index)
    cached = node_cache[:primary_texpr][index]
    if cached
      node_cache[:primary_texpr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_term_list
  s1 << r2
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(PrimaryTexpr0)
    r1.extend(PrimaryTexpr1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i3, s3 = index, []
    r4 = _nt_literal
    s3 << r4
    if s3.last
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      r3.extend(PrimaryTexpr2)
      r3.extend(PrimaryTexpr3)
    else
      @index = i3
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r0 = r3
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:primary_texpr][start_index] = r0

  r0
end

#_nt_relational_op ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1431

def _nt_relational_op
  start_index = index
  if node_cache[:relational_op].has_key?(index)
    cached = node_cache[:relational_op][index]
    if cached
      node_cache[:relational_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('<', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('\'<\'')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('>', false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('\'>\'')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?('>=', false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('\'>=\'')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?('<=', false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('\'<=\'')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          @index = i0
          r0 = nil
        end
      end
    end
  end

  node_cache[:relational_op][start_index] = r0

  r0
end

#_nt_relational_texpr ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1369

def _nt_relational_texpr
  start_index = index
  if node_cache[:relational_texpr].has_key?(index)
    cached = node_cache[:relational_texpr][index]
    if cached
      node_cache[:relational_texpr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_additive_texpr
    s0 << r2
    if r2
      i4, s4 = index, []
      r5 = _nt_s
      s4 << r5
      if r5
        r6 = _nt_relational_op
        s4 << r6
        if r6
          r7 = _nt_s
          s4 << r7
          if r7
            r8 = _nt_additive_texpr
            s4 << r8
          end
        end
      end
      if s4.last
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        r4.extend(RelationalTexpr0)
      else
        @index = i4
        r4 = nil
      end
      if r4
        r3 = r4
      else
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RelationalTexpr1)
    r0.extend(RelationalTexpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:relational_texpr][start_index] = r0

  r0
end

#_nt_simple_matching ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 238

def _nt_simple_matching
  start_index = index
  if node_cache[:simple_matching].has_key?(index)
    cached = node_cache[:simple_matching][index]
    if cached
      node_cache[:simple_matching][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_term_list
    s0 << r2
    if r2
      r3 = _nt_s
      s0 << r3
      if r3
        if (match_len = has_terminal?('<--', false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('\'<--\'')
          r4 = nil
        end
        s0 << r4
        if r4
          r5 = _nt_s
          s0 << r5
          if r5
            r7 = _nt_transform_expr
            if r7
              r6 = r7
            else
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SimpleMatching0)
    r0.extend(SimpleMatching1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:simple_matching][start_index] = r0

  r0
end

#_nt_term_list ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 585

def _nt_term_list
  start_index = index
  if node_cache[:term_list].has_key?(index)
    cached = node_cache[:term_list][index]
    if cached
      node_cache[:term_list][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_term
    s0 << r2
    if r2
      s3, i3 = [], index
      loop do
        i4, s4 = index, []
        r5 = _nt_s
        s4 << r5
        if r5
          if (match_len = has_terminal?('.', false, index))
            r6 = true
            @index += match_len
          else
            terminal_parse_failure('\'.\'')
            r6 = nil
          end
          s4 << r6
          if r6
            r7 = _nt_s
            s4 << r7
            if r7
              r8 = _nt_term_list
              s4 << r8
            end
          end
        end
        if s4.last
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
          r4.extend(TermList0)
        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(TermList1)
    r0.extend(TermList2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:term_list][start_index] = r0

  r0
end

#_nt_transform_expr ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 743

def _nt_transform_expr
  start_index = index
  if node_cache[:transform_expr].has_key?(index)
    cached = node_cache[:transform_expr][index]
    if cached
      node_cache[:transform_expr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_s
  s1 << r2
  if r2
    r3 = _nt_logical_texpr
    s1 << r3
    if r3
      r4 = _nt_s
      s1 << r4
      if r4
        if (match_len = has_terminal?('?', false, index))
          r5 = true
          @index += match_len
        else
          terminal_parse_failure('\'?\'')
          r5 = nil
        end
        s1 << r5
        if r5
          r6 = _nt_s
          s1 << r6
          if r6
            r7 = _nt_logical_texpr
            s1 << r7
            if r7
              r8 = _nt_s
              s1 << r8
              if r8
                if (match_len = has_terminal?(':', false, index))
                  r9 = true
                  @index += match_len
                else
                  terminal_parse_failure('\':\'')
                  r9 = nil
                end
                s1 << r9
                if r9
                  r10 = _nt_s
                  s1 << r10
                  if r10
                    r11 = _nt_logical_texpr
                    s1 << r11
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(TransformExpr0)
    r1.extend(TransformExpr1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i12, s12 = index, []
    r13 = _nt_s
    s12 << r13
    if r13
      r14 = _nt_aggregate_op
      s12 << r14
      if r14
        r15 = _nt_S
        s12 << r15
        if r15
          r16 = _nt_agg_of
          s12 << r16
          if r16
            r17 = _nt_s
            s12 << r17
            if r17
              r18 = _nt_logical_texpr
              s12 << r18
            end
          end
        end
      end
    end
    if s12.last
      r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
      r12.extend(TransformExpr2)
      r12.extend(TransformExpr3)
    else
      @index = i12
      r12 = nil
    end
    if r12
      r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
      r0 = r12
    else
      i19, s19 = index, []
      r20 = _nt_s
      s19 << r20
      if r20
        r21 = _nt_logical_texpr
        s19 << r21
      end
      if s19.last
        r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
        r19.extend(TransformExpr4)
        r19.extend(TransformExpr5)
      else
        @index = i19
        r19 = nil
      end
      if r19
        r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
        r0 = r19
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:transform_expr][start_index] = r0

  r0
end

#_nt_transform_matching ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 495

def _nt_transform_matching
  start_index = index
  if node_cache[:transform_matching].has_key?(index)
    cached = node_cache[:transform_matching][index]
    if cached
      node_cache[:transform_matching][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_simple_matching
  s1 << r2
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(TransformMatching0)
    r1.extend(TransformMatching1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i3, s3 = index, []
    r4 = _nt_compound_matching
    s3 << r4
    if s3.last
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      r3.extend(TransformMatching2)
      r3.extend(TransformMatching3)
    else
      @index = i3
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r0 = r3
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:transform_matching][start_index] = r0

  r0
end

#_nt_transform_matchings ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 403

def _nt_transform_matchings
  start_index = index
  if node_cache[:transform_matchings].has_key?(index)
    cached = node_cache[:transform_matchings][index]
    if cached
      node_cache[:transform_matchings][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r2 = _nt_transform_matching
    s0 << r2
    if r2
      s3, i3 = [], index
      loop do
        i4, s4 = index, []
        r5 = _nt_s
        s4 << r5
        if r5
          if (match_len = has_terminal?(',', false, index))
            r6 = true
            @index += match_len
          else
            terminal_parse_failure('\',\'')
            r6 = nil
          end
          s4 << r6
          if r6
            r7 = _nt_s
            s4 << r7
            if r7
              r8 = _nt_transform_matching
              s4 << r8
            end
          end
        end
        if s4.last
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
          r4.extend(TransformMatchings0)
        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(TransformMatchings1)
    r0.extend(TransformMatchings2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:transform_matchings][start_index] = r0

  r0
end

#_nt_transform_query ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 317

def _nt_transform_query
  start_index = index
  if node_cache[:transform_query].has_key?(index)
    cached = node_cache[:transform_query][index]
    if cached
      node_cache[:transform_query][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_clauses_list
  s1 << r2
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(TransformQuery0)
    r1.extend(TransformQuery1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i3, s3 = index, []
    r4 = _nt_term
    s3 << r4
    if s3.last
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      r3.extend(TransformQuery2)
      r3.extend(TransformQuery3)
    else
      @index = i3
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r0 = r3
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:transform_query][start_index] = r0

  r0
end

#_nt_transform_rule ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 36

def _nt_transform_rule
  start_index = index
  if node_cache[:transform_rule].has_key?(index)
    cached = node_cache[:transform_rule][index]
    if cached
      node_cache[:transform_rule][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_compound_matching
  s0 << r1
  if r1
    r2 = _nt_s
    s0 << r2
    if r2
      if (match_len = has_terminal?(';', false, index))
        r3 = true
        @index += match_len
      else
        terminal_parse_failure('\';\'')
        r3 = nil
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TransformRule0)
    r0.extend(TransformRule1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:transform_rule][start_index] = r0

  r0
end

#_nt_unary_op ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1882

def _nt_unary_op
  start_index = index
  if node_cache[:unary_op].has_key?(index)
    cached = node_cache[:unary_op][index]
    if cached
      node_cache[:unary_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('-', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('\'-\'')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('!', false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('\'!\'')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:unary_op][start_index] = r0

  r0
end

#_nt_unary_texpr ⇒ `Object`

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 1837

def _nt_unary_texpr
  start_index = index
  if node_cache[:unary_texpr].has_key?(index)
    cached = node_cache[:unary_texpr][index]
    if cached
      node_cache[:unary_texpr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_s
  s0 << r1
  if r1
    r3 = _nt_unary_op
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      r4 = _nt_s
      s0 << r4
      if r4
        r5 = _nt_primary_texpr
        s0 << r5
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(UnaryTexpr0)
    r0.extend(UnaryTexpr1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:unary_texpr][start_index] = r0

  r0
end

#root ⇒ `Object`



15
16
17

# File 'lib/activefacts/cql/parser/TransformRules.rb', line 15

def root
  @root ||= :transform_rule
end

Module: ActiveFacts::CQL::TransformRules

Defined Under Namespace

Instance Method Summary collapse

Instance Method Details

#_nt_additive_op ⇒ Object

#_nt_additive_texpr ⇒ Object

#_nt_aggregate_op ⇒ Object

#_nt_compound_matching ⇒ Object

#_nt_equality_op ⇒ Object

#_nt_equality_texpr ⇒ Object

#_nt_logical_and_texpr ⇒ Object

#_nt_logical_texpr ⇒ Object

#_nt_multiplicative_op ⇒ Object

#_nt_multiplicative_texpr ⇒ Object

#_nt_primary_texpr ⇒ Object

#_nt_relational_op ⇒ Object

#_nt_relational_texpr ⇒ Object

#_nt_simple_matching ⇒ Object

#_nt_term_list ⇒ Object

#_nt_transform_expr ⇒ Object

#_nt_transform_matching ⇒ Object

#_nt_transform_matchings ⇒ Object

#_nt_transform_query ⇒ Object

#_nt_transform_rule ⇒ Object

#_nt_unary_op ⇒ Object

#_nt_unary_texpr ⇒ Object

#root ⇒ Object

#_nt_additive_op ⇒ `Object`

#_nt_additive_texpr ⇒ `Object`

#_nt_aggregate_op ⇒ `Object`

#_nt_compound_matching ⇒ `Object`

#_nt_equality_op ⇒ `Object`

#_nt_equality_texpr ⇒ `Object`

#_nt_logical_and_texpr ⇒ `Object`

#_nt_logical_texpr ⇒ `Object`

#_nt_multiplicative_op ⇒ `Object`

#_nt_multiplicative_texpr ⇒ `Object`

#_nt_primary_texpr ⇒ `Object`

#_nt_relational_op ⇒ `Object`

#_nt_relational_texpr ⇒ `Object`

#_nt_simple_matching ⇒ `Object`

#_nt_term_list ⇒ `Object`

#_nt_transform_expr ⇒ `Object`

#_nt_transform_matching ⇒ `Object`

#_nt_transform_matchings ⇒ `Object`

#_nt_transform_query ⇒ `Object`

#_nt_transform_rule ⇒ `Object`

#_nt_unary_op ⇒ `Object`

#_nt_unary_texpr ⇒ `Object`

#root ⇒ `Object`