Class: ZunScript::Parser

Inherits:

ANTLR3::Parser

Object
ANTLR3::Parser
ZunScript::Parser

show all

Includes:: ANTLR3::ASTBuilder, TokenData

Defined in:: ext/zunscript/parser.rb

Defined Under Namespace

Classes: DFA6

Constant Summary collapse

RULE_METHODS =

[ :script, :line, :comment, :open_expression, :closed_expression, 
:variable, :value, :block, :block_body, :arguments, 
:assign, :invoke, :bind, :closed_invoke, :closed_bind, 
:params, :param, :synpred5_ZunScript, :synpred6_ZunScript, 
:synpred7_ZunScript ].freeze

ScriptReturnValue = Rules - - - - - - - - - - - - -

define_return_scope

LineReturnValue =

define_return_scope

CommentReturnValue =

define_return_scope

OpenExpressionReturnValue =

define_return_scope

ClosedExpressionReturnValue =

define_return_scope

VariableReturnValue =

define_return_scope

ValueReturnValue =

define_return_scope

BlockReturnValue =

define_return_scope

BlockBodyReturnValue =

define_return_scope

ArgumentsReturnValue =

define_return_scope

AssignReturnValue =

define_return_scope

InvokeReturnValue =

define_return_scope

BindReturnValue =

define_return_scope

ClosedInvokeReturnValue =

define_return_scope

ClosedBindReturnValue =

define_return_scope

ParamsReturnValue =

define_return_scope

ParamReturnValue =

define_return_scope

Instance Method Summary collapse

#arguments ⇒ Object

parser rule arguments.
#assign ⇒ Object

parser rule assign.
#bind ⇒ Object

parser rule bind.
#block ⇒ Object

parser rule block.
#block_body ⇒ Object

parser rule block_body.
#closed_bind ⇒ Object

parser rule closed_bind.
#closed_expression ⇒ Object

parser rule closed_expression.
#closed_invoke ⇒ Object

parser rule closed_invoke.
#comment ⇒ Object

parser rule comment.
#initialize(input, options = {}) ⇒ Parser constructor

A new instance of Parser.
#invoke ⇒ Object

parser rule invoke.
#line ⇒ Object

parser rule line.
#open_expression ⇒ Object

parser rule open_expression.
#param ⇒ Object

parser rule param.
#params ⇒ Object

parser rule params.
#script ⇒ Object

parser rule script.
#synpred5_ZunScript ⇒ Object

syntactic predicate synpred5_ZunScript.
#synpred6_ZunScript ⇒ Object

syntactic predicate synpred6_ZunScript.
#synpred7_ZunScript ⇒ Object

syntactic predicate synpred7_ZunScript.
#value ⇒ Object

parser rule value.
#variable ⇒ Object

parser rule variable.

Constructor Details

#initialize(input, options = {}) ⇒ `Parser`

Returns a new instance of Parser.



115
116
117

# File 'ext/zunscript/parser.rb', line 115

def initialize( input, options = {} )
  super( input, options )
end

Instance Method Details

#arguments ⇒ `Object`

parser rule arguments

(in ZunScript.g) 71:1: arguments : (| NAME ( COMMA ! NAME )* );

# File 'ext/zunscript/parser.rb', line 1221

def arguments
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 10 )


  return_value = ArgumentsReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __NAME29__ = nil
  __COMMA30__ = nil
  __NAME31__ = nil


  tree_for_NAME29 = nil
  tree_for_COMMA30 = nil
  tree_for_NAME31 = nil

  begin
  # at line 71:10: (| NAME ( COMMA ! NAME )* )
  alt_11 = 2
  look_11_0 = @input.peek( 1 )

  if ( look_11_0 == NEWLINE )
    alt_11 = 1
  elsif ( look_11_0 == NAME )
    alt_11 = 2
  else
    @state.backtracking > 0 and raise( ANTLR3::Error::BacktrackingFailed )



    raise NoViableAlternative( "", 11, 0 )

  end
  case alt_11
  when 1
    root_0 = @adaptor.create_flat_list


    # at line 71:12: 

  when 2
    root_0 = @adaptor.create_flat_list


    # at line 71:13: NAME ( COMMA ! NAME )*
    __NAME29__ = match( NAME, TOKENS_FOLLOWING_NAME_IN_arguments_591 )
    if @state.backtracking == 0
      tree_for_NAME29 = @adaptor.create_with_payload( __NAME29__ )
      @adaptor.add_child( root_0, tree_for_NAME29 )

    end

    # at line 71:18: ( COMMA ! NAME )*
    while true # decision 10
      alt_10 = 2
      look_10_0 = @input.peek( 1 )

      if ( look_10_0 == COMMA )
        alt_10 = 1

      end
      case alt_10
      when 1
        # at line 71:19: COMMA ! NAME
        __COMMA30__ = match( COMMA, TOKENS_FOLLOWING_COMMA_IN_arguments_594 )
        __NAME31__ = match( NAME, TOKENS_FOLLOWING_NAME_IN_arguments_597 )
        if @state.backtracking == 0
          tree_for_NAME31 = @adaptor.create_with_payload( __NAME31__ )
          @adaptor.add_child( root_0, tree_for_NAME31 )

        end


      else
        break # out of loop for decision 10
      end
    end # loop for decision 10


  end
  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 10 )


  end

  return return_value
end

#assign ⇒ `Object`

parser rule assign

(in ZunScript.g) 73:1: assign : variable ASSIGN open_expression -> ^( ASSIGN variable open_expression ) ;

# File 'ext/zunscript/parser.rb', line 1341

def assign
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 11 )


  return_value = AssignReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __ASSIGN33__ = nil
  variable32 = nil
  open_expression34 = nil


  tree_for_ASSIGN33 = nil
  stream_ASSIGN = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token ASSIGN" )
  stream_open_expression = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule open_expression" )
  stream_variable = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule variable" )
  begin
  # at line 74:5: variable ASSIGN open_expression
  @state.following.push( TOKENS_FOLLOWING_variable_IN_assign_610 )
  variable32 = variable
  @state.following.pop
  if @state.backtracking == 0
    stream_variable.add( variable32.tree )
  end

  __ASSIGN33__ = match( ASSIGN, TOKENS_FOLLOWING_ASSIGN_IN_assign_612 )
  if @state.backtracking == 0
    stream_ASSIGN.add( __ASSIGN33__ )
  end

  @state.following.push( TOKENS_FOLLOWING_open_expression_IN_assign_614 )
  open_expression34 = open_expression
  @state.following.pop
  if @state.backtracking == 0
    stream_open_expression.add( open_expression34.tree )
  end

  # AST Rewrite
  # elements: variable, open_expression, ASSIGN
  # token labels: 
  # rule labels: return_value
  # token list labels: 
  # rule list labels: 
  # wildcard labels: 
  if @state.backtracking == 0
    return_value.tree = root_0
    stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

    root_0 = @adaptor.create_flat_list
    # 74:37: -> ^( ASSIGN variable open_expression )
    # at line 74:40: ^( ASSIGN variable open_expression )
    root_1 = @adaptor.create_flat_list
    root_1 = @adaptor.become_root( stream_ASSIGN.next_node, root_1 )

    @adaptor.add_child( root_1, stream_variable.next_tree )

    @adaptor.add_child( root_1, stream_open_expression.next_tree )

    @adaptor.add_child( root_0, root_1 )




    return_value.tree = root_0


  end

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 11 )


  end

  return return_value
end

#bind ⇒ `Object`

parser rule bind

(in ZunScript.g) 78:1: bind : variable params -> ^( BIND variable ( params )* ) ;

# File 'ext/zunscript/parser.rb', line 1563

def bind
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 13 )


  return_value = BindReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  variable38 = nil
  params39 = nil


  stream_params = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule params" )
  stream_variable = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule variable" )
  begin
  # at line 79:5: variable params
  @state.following.push( TOKENS_FOLLOWING_variable_IN_bind_660 )
  variable38 = variable
  @state.following.pop
  if @state.backtracking == 0
    stream_variable.add( variable38.tree )
  end

  @state.following.push( TOKENS_FOLLOWING_params_IN_bind_662 )
  params39 = params
  @state.following.pop
  if @state.backtracking == 0
    stream_params.add( params39.tree )
  end

  # AST Rewrite
  # elements: variable, params
  # token labels: 
  # rule labels: return_value
  # token list labels: 
  # rule list labels: 
  # wildcard labels: 
  if @state.backtracking == 0
    return_value.tree = root_0
    stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

    root_0 = @adaptor.create_flat_list
    # 79:21: -> ^( BIND variable ( params )* )
    # at line 79:24: ^( BIND variable ( params )* )
    root_1 = @adaptor.create_flat_list
    root_1 = @adaptor.become_root( @adaptor.create_from_type( BIND, "BIND" ), root_1 )

    @adaptor.add_child( root_1, stream_variable.next_tree )

    # at line 79:40: ( params )*
    while stream_params.has_next?
      @adaptor.add_child( root_1, stream_params.next_tree )

    end

    stream_params.reset();

    @adaptor.add_child( root_0, root_1 )




    return_value.tree = root_0


  end

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 13 )


  end

  return return_value
end

#block ⇒ `Object`

parser rule block

(in ZunScript.g) 68:1: block : BLOCK_RIGHT arguments NEWLINE block_body BLOCK_END -> ^( BLK ( arguments )* block_body ) ;

# File 'ext/zunscript/parser.rb', line 978

def block
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 8 )


  return_value = BlockReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __BLOCK_RIGHT23__ = nil
  __NEWLINE25__ = nil
  __BLOCK_END27__ = nil
  arguments24 = nil
  block_body26 = nil


  tree_for_BLOCK_RIGHT23 = nil
  tree_for_NEWLINE25 = nil
  tree_for_BLOCK_END27 = nil
  stream_BLOCK_RIGHT = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token BLOCK_RIGHT" )
  stream_NEWLINE = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token NEWLINE" )
  stream_BLOCK_END = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token BLOCK_END" )
  stream_arguments = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule arguments" )
  stream_block_body = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule block_body" )
  begin
  # at line 68:8: BLOCK_RIGHT arguments NEWLINE block_body BLOCK_END
  __BLOCK_RIGHT23__ = match( BLOCK_RIGHT, TOKENS_FOLLOWING_BLOCK_RIGHT_IN_block_548 )
  if @state.backtracking == 0
    stream_BLOCK_RIGHT.add( __BLOCK_RIGHT23__ )
  end

  @state.following.push( TOKENS_FOLLOWING_arguments_IN_block_550 )
  arguments24 = arguments
  @state.following.pop
  if @state.backtracking == 0
    stream_arguments.add( arguments24.tree )
  end

  __NEWLINE25__ = match( NEWLINE, TOKENS_FOLLOWING_NEWLINE_IN_block_552 )
  if @state.backtracking == 0
    stream_NEWLINE.add( __NEWLINE25__ )
  end

  @state.following.push( TOKENS_FOLLOWING_block_body_IN_block_554 )
  block_body26 = block_body
  @state.following.pop
  if @state.backtracking == 0
    stream_block_body.add( block_body26.tree )
  end

  __BLOCK_END27__ = match( BLOCK_END, TOKENS_FOLLOWING_BLOCK_END_IN_block_556 )
  if @state.backtracking == 0
    stream_BLOCK_END.add( __BLOCK_END27__ )
  end

  # AST Rewrite
  # elements: block_body, arguments
  # token labels: 
  # rule labels: return_value
  # token list labels: 
  # rule list labels: 
  # wildcard labels: 
  if @state.backtracking == 0
    return_value.tree = root_0
    stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

    root_0 = @adaptor.create_flat_list
    # 68:59: -> ^( BLK ( arguments )* block_body )
    # at line 68:62: ^( BLK ( arguments )* block_body )
    root_1 = @adaptor.create_flat_list
    root_1 = @adaptor.become_root( @adaptor.create_from_type( BLK, "BLK" ), root_1 )

    # at line 68:68: ( arguments )*
    while stream_arguments.has_next?
      @adaptor.add_child( root_1, stream_arguments.next_tree )

    end

    stream_arguments.reset();

    @adaptor.add_child( root_1, stream_block_body.next_tree )

    @adaptor.add_child( root_0, root_1 )




    return_value.tree = root_0


  end

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 8 )


  end

  return return_value
end

#block_body ⇒ `Object`

parser rule block_body

(in ZunScript.g) 69:1: block_body : ( line )* -> ^( BODY ( line )* ) ;

# File 'ext/zunscript/parser.rb', line 1108

def block_body
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 9 )


  return_value = BlockBodyReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  line28 = nil


  stream_line = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule line" )
  begin
  # at line 69:13: ( line )*
  # at line 69:13: ( line )*
  while true # decision 9
    alt_9 = 2
    look_9_0 = @input.peek( 1 )

    if ( look_9_0 == BLOCK_RIGHT || look_9_0 == COMMENT || look_9_0.between?( LPAREN, NEWLINE ) || look_9_0 == NUMBER || look_9_0 == STRING )
      alt_9 = 1

    end
    case alt_9
    when 1
      # at line 69:13: line
      @state.following.push( TOKENS_FOLLOWING_line_IN_block_body_573 )
      line28 = line
      @state.following.pop
      if @state.backtracking == 0
        stream_line.add( line28.tree )
      end


    else
      break # out of loop for decision 9
    end
  end # loop for decision 9

  # AST Rewrite
  # elements: line
  # token labels: 
  # rule labels: return_value
  # token list labels: 
  # rule list labels: 
  # wildcard labels: 
  if @state.backtracking == 0
    return_value.tree = root_0
    stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

    root_0 = @adaptor.create_flat_list
    # 69:19: -> ^( BODY ( line )* )
    # at line 69:22: ^( BODY ( line )* )
    root_1 = @adaptor.create_flat_list
    root_1 = @adaptor.become_root( @adaptor.create_from_type( BODY, "BODY" ), root_1 )

    # at line 69:29: ( line )*
    while stream_line.has_next?
      @adaptor.add_child( root_1, stream_line.next_tree )

    end

    stream_line.reset();

    @adaptor.add_child( root_0, root_1 )




    return_value.tree = root_0


  end

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 9 )


  end

  return return_value
end

#closed_bind ⇒ `Object`

parser rule closed_bind

(in ZunScript.g) 82:1: closed_bind : variable param -> ^( BIND variable param ) ;

# File 'ext/zunscript/parser.rb', line 1795

def closed_bind
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 15 )


  return_value = ClosedBindReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  variable43 = nil
  param44 = nil


  stream_param = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule param" )
  stream_variable = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule variable" )
  begin
  # at line 83:5: variable param
  @state.following.push( TOKENS_FOLLOWING_variable_IN_closed_bind_710 )
  variable43 = variable
  @state.following.pop
  if @state.backtracking == 0
    stream_variable.add( variable43.tree )
  end

  @state.following.push( TOKENS_FOLLOWING_param_IN_closed_bind_712 )
  param44 = param
  @state.following.pop
  if @state.backtracking == 0
    stream_param.add( param44.tree )
  end

  # AST Rewrite
  # elements: variable, param
  # token labels: 
  # rule labels: return_value
  # token list labels: 
  # rule list labels: 
  # wildcard labels: 
  if @state.backtracking == 0
    return_value.tree = root_0
    stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

    root_0 = @adaptor.create_flat_list
    # 83:20: -> ^( BIND variable param )
    # at line 83:23: ^( BIND variable param )
    root_1 = @adaptor.create_flat_list
    root_1 = @adaptor.become_root( @adaptor.create_from_type( BIND, "BIND" ), root_1 )

    @adaptor.add_child( root_1, stream_variable.next_tree )

    @adaptor.add_child( root_1, stream_param.next_tree )

    @adaptor.add_child( root_0, root_1 )




    return_value.tree = root_0


  end

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 15 )


  end

  return return_value
end

#closed_expression ⇒ `Object`

parser rule closed_expression

(in ZunScript.g) 57:1: closed_expression : ( value | variable | closed_invoke | closed_bind | LPAREN ! open_expression RPAREN !);

# File 'ext/zunscript/parser.rb', line 554

def closed_expression
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 5 )


  return_value = ClosedExpressionReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __LPAREN16__ = nil
  __RPAREN18__ = nil
  value12 = nil
  variable13 = nil
  closed_invoke14 = nil
  closed_bind15 = nil
  open_expression17 = nil


  tree_for_LPAREN16 = nil
  tree_for_RPAREN18 = nil

  begin
  # at line 57:18: ( value | variable | closed_invoke | closed_bind | LPAREN ! open_expression RPAREN !)
  alt_6 = 5
  alt_6 = @dfa6.predict( @input )
  case alt_6
  when 1
    root_0 = @adaptor.create_flat_list


    # at line 58:5: value
    @state.following.push( TOKENS_FOLLOWING_value_IN_closed_expression_449 )
    value12 = value
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, value12.tree )
    end


  when 2
    root_0 = @adaptor.create_flat_list


    # at line 58:13: variable
    @state.following.push( TOKENS_FOLLOWING_variable_IN_closed_expression_453 )
    variable13 = variable
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, variable13.tree )
    end


  when 3
    root_0 = @adaptor.create_flat_list


    # at line 58:24: closed_invoke
    @state.following.push( TOKENS_FOLLOWING_closed_invoke_IN_closed_expression_457 )
    closed_invoke14 = closed_invoke
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, closed_invoke14.tree )
    end


  when 4
    root_0 = @adaptor.create_flat_list


    # at line 58:40: closed_bind
    @state.following.push( TOKENS_FOLLOWING_closed_bind_IN_closed_expression_461 )
    closed_bind15 = closed_bind
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, closed_bind15.tree )
    end


  when 5
    root_0 = @adaptor.create_flat_list


    # at line 59:5: LPAREN ! open_expression RPAREN !
    __LPAREN16__ = match( LPAREN, TOKENS_FOLLOWING_LPAREN_IN_closed_expression_467 )
    @state.following.push( TOKENS_FOLLOWING_open_expression_IN_closed_expression_470 )
    open_expression17 = open_expression
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, open_expression17.tree )
    end

    __RPAREN18__ = match( RPAREN, TOKENS_FOLLOWING_RPAREN_IN_closed_expression_472 )

  end
  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 5 )


  end

  return return_value
end

#closed_invoke ⇒ `Object`

parser rule closed_invoke

(in ZunScript.g) 80:1: closed_invoke : variable BANG ( param )? -> ^( INVOKE variable ( param )* ) ;

# File 'ext/zunscript/parser.rb', line 1669

def closed_invoke
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 14 )


  return_value = ClosedInvokeReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __BANG41__ = nil
  variable40 = nil
  param42 = nil


  tree_for_BANG41 = nil
  stream_BANG = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token BANG" )
  stream_param = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule param" )
  stream_variable = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule variable" )
  begin
  # at line 81:5: variable BANG ( param )?
  @state.following.push( TOKENS_FOLLOWING_variable_IN_closed_invoke_684 )
  variable40 = variable
  @state.following.pop
  if @state.backtracking == 0
    stream_variable.add( variable40.tree )
  end

  __BANG41__ = match( BANG, TOKENS_FOLLOWING_BANG_IN_closed_invoke_686 )
  if @state.backtracking == 0
    stream_BANG.add( __BANG41__ )
  end

  # at line 81:19: ( param )?
  alt_12 = 2
  look_12_0 = @input.peek( 1 )

  if ( look_12_0 == BLOCK_RIGHT || look_12_0.between?( LPAREN, NAME ) || look_12_0 == NUMBER || look_12_0 == STRING )
    alt_12 = 1
  end
  case alt_12
  when 1
    # at line 81:19: param
    @state.following.push( TOKENS_FOLLOWING_param_IN_closed_invoke_688 )
    param42 = param
    @state.following.pop
    if @state.backtracking == 0
      stream_param.add( param42.tree )
    end


  end
  # AST Rewrite
  # elements: param, variable
  # token labels: 
  # rule labels: return_value
  # token list labels: 
  # rule list labels: 
  # wildcard labels: 
  if @state.backtracking == 0
    return_value.tree = root_0
    stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

    root_0 = @adaptor.create_flat_list
    # 81:26: -> ^( INVOKE variable ( param )* )
    # at line 81:29: ^( INVOKE variable ( param )* )
    root_1 = @adaptor.create_flat_list
    root_1 = @adaptor.become_root( @adaptor.create_from_type( INVOKE, "INVOKE" ), root_1 )

    @adaptor.add_child( root_1, stream_variable.next_tree )

    # at line 81:47: ( param )*
    while stream_param.has_next?
      @adaptor.add_child( root_1, stream_param.next_tree )

    end

    stream_param.reset();

    @adaptor.add_child( root_0, root_1 )




    return_value.tree = root_0


  end

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 14 )


  end

  return return_value
end

#comment ⇒ `Object`

parser rule comment

(in ZunScript.g) 53:1: comment : COMMENT (~ NEWLINE )* ;

# File 'ext/zunscript/parser.rb', line 307

def comment
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 3 )


  return_value = CommentReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __COMMENT6__ = nil
  set7 = nil


  tree_for_COMMENT6 = nil
  tree_for_set7 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 53:10: COMMENT (~ NEWLINE )*
  __COMMENT6__ = match( COMMENT, TOKENS_FOLLOWING_COMMENT_IN_comment_410 )
  if @state.backtracking == 0
    tree_for_COMMENT6 = @adaptor.create_with_payload( __COMMENT6__ )
    @adaptor.add_child( root_0, tree_for_COMMENT6 )

  end

  # at line 53:18: (~ NEWLINE )*
  while true # decision 4
    alt_4 = 2
    look_4_0 = @input.peek( 1 )

    if ( look_4_0.between?( ARITH_SIGN, NAME ) || look_4_0.between?( NONCONTROL_CHAR, T__38 ) )
      alt_4 = 1

    end
    case alt_4
    when 1
      # at line 
      set7 = @input.look

      if @input.peek( 1 ).between?( ARITH_SIGN, NAME ) || @input.peek( 1 ).between?( NONCONTROL_CHAR, T__38 )
        @input.consume
        if @state.backtracking == 0
          @adaptor.add_child( root_0, @adaptor.create_with_payload( set7 ) )
        end

        @state.error_recovery = false

      else
        @state.backtracking > 0 and raise( ANTLR3::Error::BacktrackingFailed )


        mse = MismatchedSet( nil )
        raise mse

      end



    else
      break # out of loop for decision 4
    end
  end # loop for decision 4


  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 3 )


  end

  return return_value
end

#invoke ⇒ `Object`

parser rule invoke

(in ZunScript.g) 76:1: invoke : variable BANG params -> ^( INVOKE variable ( params )* ) ;

# File 'ext/zunscript/parser.rb', line 1449

def invoke
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 12 )


  return_value = InvokeReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __BANG36__ = nil
  variable35 = nil
  params37 = nil


  tree_for_BANG36 = nil
  stream_BANG = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token BANG" )
  stream_params = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule params" )
  stream_variable = ANTLR3::AST::RewriteRuleSubtreeStream.new( @adaptor, "rule variable" )
  begin
  # at line 77:5: variable BANG params
  @state.following.push( TOKENS_FOLLOWING_variable_IN_invoke_635 )
  variable35 = variable
  @state.following.pop
  if @state.backtracking == 0
    stream_variable.add( variable35.tree )
  end

  __BANG36__ = match( BANG, TOKENS_FOLLOWING_BANG_IN_invoke_637 )
  if @state.backtracking == 0
    stream_BANG.add( __BANG36__ )
  end

  @state.following.push( TOKENS_FOLLOWING_params_IN_invoke_639 )
  params37 = params
  @state.following.pop
  if @state.backtracking == 0
    stream_params.add( params37.tree )
  end

  # AST Rewrite
  # elements: variable, params
  # token labels: 
  # rule labels: return_value
  # token list labels: 
  # rule list labels: 
  # wildcard labels: 
  if @state.backtracking == 0
    return_value.tree = root_0
    stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

    root_0 = @adaptor.create_flat_list
    # 77:26: -> ^( INVOKE variable ( params )* )
    # at line 77:29: ^( INVOKE variable ( params )* )
    root_1 = @adaptor.create_flat_list
    root_1 = @adaptor.become_root( @adaptor.create_from_type( INVOKE, "INVOKE" ), root_1 )

    @adaptor.add_child( root_1, stream_variable.next_tree )

    # at line 77:47: ( params )*
    while stream_params.has_next?
      @adaptor.add_child( root_1, stream_params.next_tree )

    end

    stream_params.reset();

    @adaptor.add_child( root_0, root_1 )




    return_value.tree = root_0


  end

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 12 )


  end

  return return_value
end

#line ⇒ `Object`

parser rule line

(in ZunScript.g) 51:1: line : ( open_expression )? ( comment !)? NEWLINE !;

# File 'ext/zunscript/parser.rb', line 212

def line
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 2 )


  return_value = LineReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __NEWLINE5__ = nil
  open_expression3 = nil
  comment4 = nil


  tree_for_NEWLINE5 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 51:7: ( open_expression )? ( comment !)? NEWLINE !
  # at line 51:7: ( open_expression )?
  alt_2 = 2
  look_2_0 = @input.peek( 1 )

  if ( look_2_0 == BLOCK_RIGHT || look_2_0.between?( LPAREN, NAME ) || look_2_0 == NUMBER || look_2_0 == STRING )
    alt_2 = 1
  end
  case alt_2
  when 1
    # at line 51:7: open_expression
    @state.following.push( TOKENS_FOLLOWING_open_expression_IN_line_395 )
    open_expression3 = open_expression
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, open_expression3.tree )
    end


  end
  # at line 51:31: ( comment !)?
  alt_3 = 2
  look_3_0 = @input.peek( 1 )

  if ( look_3_0 == COMMENT )
    alt_3 = 1
  end
  case alt_3
  when 1
    # at line 51:31: comment !
    @state.following.push( TOKENS_FOLLOWING_comment_IN_line_398 )
    comment4 = comment
    @state.following.pop

  end
  __NEWLINE5__ = match( NEWLINE, TOKENS_FOLLOWING_NEWLINE_IN_line_402 )

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 2 )


  end

  return return_value
end

#open_expression ⇒ `Object`

parser rule open_expression

(in ZunScript.g) 55:1: open_expression : ( assign | invoke | bind | closed_expression );

# File 'ext/zunscript/parser.rb', line 412

def open_expression
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 4 )


  return_value = OpenExpressionReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  assign8 = nil
  invoke9 = nil
  bind10 = nil
  closed_expression11 = nil



  begin
  # at line 55:16: ( assign | invoke | bind | closed_expression )
  alt_5 = 4
  look_5_0 = @input.peek( 1 )

  if ( look_5_0 == NAME )
    look_5_1 = @input.peek( 2 )

    if ( syntactic_predicate?( :synpred5_ZunScript ) )
      alt_5 = 1
    elsif ( syntactic_predicate?( :synpred6_ZunScript ) )
      alt_5 = 2
    elsif ( syntactic_predicate?( :synpred7_ZunScript ) )
      alt_5 = 3
    elsif ( true )
      alt_5 = 4
    else
      @state.backtracking > 0 and raise( ANTLR3::Error::BacktrackingFailed )



      raise NoViableAlternative( "", 5, 1 )

    end
  elsif ( look_5_0 == BLOCK_RIGHT || look_5_0 == LPAREN || look_5_0 == NUMBER || look_5_0 == STRING )
    alt_5 = 4
  else
    @state.backtracking > 0 and raise( ANTLR3::Error::BacktrackingFailed )



    raise NoViableAlternative( "", 5, 0 )

  end
  case alt_5
  when 1
    root_0 = @adaptor.create_flat_list


    # at line 56:5: assign
    @state.following.push( TOKENS_FOLLOWING_assign_IN_open_expression_427 )
    assign8 = assign
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, assign8.tree )
    end


  when 2
    root_0 = @adaptor.create_flat_list


    # at line 56:14: invoke
    @state.following.push( TOKENS_FOLLOWING_invoke_IN_open_expression_431 )
    invoke9 = invoke
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, invoke9.tree )
    end


  when 3
    root_0 = @adaptor.create_flat_list


    # at line 56:23: bind
    @state.following.push( TOKENS_FOLLOWING_bind_IN_open_expression_435 )
    bind10 = bind
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, bind10.tree )
    end


  when 4
    root_0 = @adaptor.create_flat_list


    # at line 56:30: closed_expression
    @state.following.push( TOKENS_FOLLOWING_closed_expression_IN_open_expression_439 )
    closed_expression11 = closed_expression
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, closed_expression11.tree )
    end


  end
  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 4 )


  end

  return return_value
end

#param ⇒ `Object`

parser rule param

(in ZunScript.g) 87:1: param : closed_expression ;

# File 'ext/zunscript/parser.rb', line 1988

def param
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 17 )


  return_value = ParamReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  closed_expression48 = nil



  begin
  root_0 = @adaptor.create_flat_list


  # at line 87:8: closed_expression
  @state.following.push( TOKENS_FOLLOWING_closed_expression_IN_param_747 )
  closed_expression48 = closed_expression
  @state.following.pop
  if @state.backtracking == 0
    @adaptor.add_child( root_0, closed_expression48.tree )
  end


  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 17 )


  end

  return return_value
end

#params ⇒ `Object`

parser rule params

(in ZunScript.g) 85:1: params : param ( COMMA ! param )* ;

# File 'ext/zunscript/parser.rb', line 1895

def params
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 16 )


  return_value = ParamsReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __COMMA46__ = nil
  param45 = nil
  param47 = nil


  tree_for_COMMA46 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 86:5: param ( COMMA ! param )*
  @state.following.push( TOKENS_FOLLOWING_param_IN_params_733 )
  param45 = param
  @state.following.pop
  if @state.backtracking == 0
    @adaptor.add_child( root_0, param45.tree )
  end

  # at line 86:11: ( COMMA ! param )*
  while true # decision 13
    alt_13 = 2
    look_13_0 = @input.peek( 1 )

    if ( look_13_0 == COMMA )
      alt_13 = 1

    end
    case alt_13
    when 1
      # at line 86:12: COMMA ! param
      __COMMA46__ = match( COMMA, TOKENS_FOLLOWING_COMMA_IN_params_736 )
      @state.following.push( TOKENS_FOLLOWING_param_IN_params_739 )
      param47 = param
      @state.following.pop
      if @state.backtracking == 0
        @adaptor.add_child( root_0, param47.tree )
      end


    else
      break # out of loop for decision 13
    end
  end # loop for decision 13


  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 16 )


  end

  return return_value
end

#script ⇒ `Object`

parser rule script

(in ZunScript.g) 50:1: script : ( line )* EOF !;

# File 'ext/zunscript/parser.rb', line 127

def script
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 1 )


  return_value = ScriptReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __EOF2__ = nil
  line1 = nil


  tree_for_EOF2 = nil

  begin
  root_0 = @adaptor.create_flat_list


  # at line 50:9: ( line )* EOF !
  # at line 50:9: ( line )*
  while true # decision 1
    alt_1 = 2
    look_1_0 = @input.peek( 1 )

    if ( look_1_0 == BLOCK_RIGHT || look_1_0 == COMMENT || look_1_0.between?( LPAREN, NEWLINE ) || look_1_0 == NUMBER || look_1_0 == STRING )
      alt_1 = 1

    end
    case alt_1
    when 1
      # at line 50:9: line
      @state.following.push( TOKENS_FOLLOWING_line_IN_script_385 )
      line1 = line
      @state.following.pop
      if @state.backtracking == 0
        @adaptor.add_child( root_0, line1.tree )
      end


    else
      break # out of loop for decision 1
    end
  end # loop for decision 1

  __EOF2__ = match( EOF, TOKENS_FOLLOWING_EOF_IN_script_388 )

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 1 )


  end

  return return_value
end

#synpred5_ZunScript ⇒ `Object`

syntactic predicate synpred5_ZunScript

(in ZunScript.g) 56:5: synpred5_ZunScript : assign ;

This is an imaginary rule inserted by ANTLR to implement a syntactic predicate decision

# File 'ext/zunscript/parser.rb', line 2053

def synpred5_ZunScript
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 22 )


  # at line 56:5: assign
  @state.following.push( TOKENS_FOLLOWING_assign_IN_synpred5_ZunScript_427 )
  assign
  @state.following.pop

ensure
  # -> uncomment the next line to manually enable rule tracing
  # trace_out( __method__, 22 )


end

#synpred6_ZunScript ⇒ `Object`

syntactic predicate synpred6_ZunScript

(in ZunScript.g) 56:14: synpred6_ZunScript : invoke ;

This is an imaginary rule inserted by ANTLR to implement a syntactic predicate decision

# File 'ext/zunscript/parser.rb', line 2078

def synpred6_ZunScript
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 23 )


  # at line 56:14: invoke
  @state.following.push( TOKENS_FOLLOWING_invoke_IN_synpred6_ZunScript_431 )
  invoke
  @state.following.pop

ensure
  # -> uncomment the next line to manually enable rule tracing
  # trace_out( __method__, 23 )


end

#synpred7_ZunScript ⇒ `Object`

syntactic predicate synpred7_ZunScript

(in ZunScript.g) 56:23: synpred7_ZunScript : bind ;

This is an imaginary rule inserted by ANTLR to implement a syntactic predicate decision

# File 'ext/zunscript/parser.rb', line 2103

def synpred7_ZunScript
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 24 )


  # at line 56:23: bind
  @state.following.push( TOKENS_FOLLOWING_bind_IN_synpred7_ZunScript_435 )
  bind
  @state.following.pop

ensure
  # -> uncomment the next line to manually enable rule tracing
  # trace_out( __method__, 24 )


end

#value ⇒ `Object`

parser rule value

(in ZunScript.g) 63:1: value : (v= NUMBER -> ^( NUM $v) |v= STRING -> ^( STR $v) | block );

# File 'ext/zunscript/parser.rb', line 819

def value
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 7 )


  return_value = ValueReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  v = nil
  block22 = nil


  tree_for_v = nil
  stream_STRING = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token STRING" )
  stream_NUMBER = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token NUMBER" )

  begin
  # at line 63:6: (v= NUMBER -> ^( NUM $v) |v= STRING -> ^( STR $v) | block )
  alt_8 = 3
  case look_8 = @input.peek( 1 )
  when NUMBER then alt_8 = 1
  when STRING then alt_8 = 2
  when BLOCK_RIGHT then alt_8 = 3
  else
    @state.backtracking > 0 and raise( ANTLR3::Error::BacktrackingFailed )



    raise NoViableAlternative( "", 8, 0 )

  end
  case alt_8
  when 1
    # at line 64:5: v= NUMBER
    v = match( NUMBER, TOKENS_FOLLOWING_NUMBER_IN_value_509 )
    if @state.backtracking == 0
      stream_NUMBER.add( v )
    end

    # AST Rewrite
    # elements: v
    # token labels: v
    # rule labels: return_value
    # token list labels: 
    # rule list labels: 
    # wildcard labels: 
    if @state.backtracking == 0
      return_value.tree = root_0
      stream_v = token_stream( "token v", v )
      stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

      root_0 = @adaptor.create_flat_list
      # 64:14: -> ^( NUM $v)
      # at line 64:17: ^( NUM $v)
      root_1 = @adaptor.create_flat_list
      root_1 = @adaptor.become_root( @adaptor.create_from_type( NUM, "NUM" ), root_1 )

      @adaptor.add_child( root_1, stream_v.next_node )

      @adaptor.add_child( root_0, root_1 )




      return_value.tree = root_0


    end

  when 2
    # at line 65:5: v= STRING
    v = match( STRING, TOKENS_FOLLOWING_STRING_IN_value_526 )
    if @state.backtracking == 0
      stream_STRING.add( v )
    end

    # AST Rewrite
    # elements: v
    # token labels: v
    # rule labels: return_value
    # token list labels: 
    # rule list labels: 
    # wildcard labels: 
    if @state.backtracking == 0
      return_value.tree = root_0
      stream_v = token_stream( "token v", v )
      stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

      root_0 = @adaptor.create_flat_list
      # 65:14: -> ^( STR $v)
      # at line 65:17: ^( STR $v)
      root_1 = @adaptor.create_flat_list
      root_1 = @adaptor.become_root( @adaptor.create_from_type( STR, "STR" ), root_1 )

      @adaptor.add_child( root_1, stream_v.next_node )

      @adaptor.add_child( root_0, root_1 )




      return_value.tree = root_0


    end

  when 3
    root_0 = @adaptor.create_flat_list


    # at line 66:5: block
    @state.following.push( TOKENS_FOLLOWING_block_IN_value_541 )
    block22 = block
    @state.following.pop
    if @state.backtracking == 0
      @adaptor.add_child( root_0, block22.tree )
    end


  end
  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 7 )


  end

  return return_value
end

#variable ⇒ `Object`

parser rule variable

(in ZunScript.g) 61:1: variable : ( NAME ‘.’ )* NAME -> ^( VARIABLE ( NAME )* ) ;

# File 'ext/zunscript/parser.rb', line 686

def variable
  # -> uncomment the next line to manually enable rule tracing
  # trace_in( __method__, 6 )


  return_value = VariableReturnValue.new

  # $rule.start = the first token seen before matching
  return_value.start = @input.look


  root_0 = nil

  __NAME19__ = nil
  char_literal20 = nil
  __NAME21__ = nil


  tree_for_NAME19 = nil
  tree_for_char_literal20 = nil
  tree_for_NAME21 = nil
  stream_NAME = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token NAME" )
  stream_T__38 = ANTLR3::AST::RewriteRuleTokenStream.new( @adaptor, "token T__38" )

  begin
  # at line 61:11: ( NAME '.' )* NAME
  # at line 61:11: ( NAME '.' )*
  while true # decision 7
    alt_7 = 2
    look_7_0 = @input.peek( 1 )

    if ( look_7_0 == NAME )
      look_7_1 = @input.peek( 2 )

      if ( look_7_1 == T__38 )
        alt_7 = 1

      end

    end
    case alt_7
    when 1
      # at line 61:12: NAME '.'
      __NAME19__ = match( NAME, TOKENS_FOLLOWING_NAME_IN_variable_481 )
      if @state.backtracking == 0
        stream_NAME.add( __NAME19__ )
      end

      char_literal20 = match( T__38, TOKENS_FOLLOWING_T__38_IN_variable_483 )
      if @state.backtracking == 0
        stream_T__38.add( char_literal20 )
      end


    else
      break # out of loop for decision 7
    end
  end # loop for decision 7

  __NAME21__ = match( NAME, TOKENS_FOLLOWING_NAME_IN_variable_487 )
  if @state.backtracking == 0
    stream_NAME.add( __NAME21__ )
  end

  # AST Rewrite
  # elements: NAME
  # token labels: 
  # rule labels: return_value
  # token list labels: 
  # rule list labels: 
  # wildcard labels: 
  if @state.backtracking == 0
    return_value.tree = root_0
    stream_return_value = return_value ? subtree_stream( "rule return_value", return_value.tree ) : subtree_stream( "token return_value" )

    root_0 = @adaptor.create_flat_list
    # 61:28: -> ^( VARIABLE ( NAME )* )
    # at line 61:31: ^( VARIABLE ( NAME )* )
    root_1 = @adaptor.create_flat_list
    root_1 = @adaptor.become_root( @adaptor.create_from_type( VARIABLE, "VARIABLE" ), root_1 )

    # at line 61:42: ( NAME )*
    while stream_NAME.has_next?
      @adaptor.add_child( root_1, stream_NAME.next_node )

    end

    stream_NAME.reset();

    @adaptor.add_child( root_0, root_1 )




    return_value.tree = root_0


  end

  # - - - - - - - rule clean up - - - - - - - -
  return_value.stop = @input.look( -1 )


  if @state.backtracking == 0
    return_value.tree = @adaptor.rule_post_processing( root_0 )
    @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )

  end

  rescue ANTLR3::Error::RecognitionError => re
    report_error(re)
    recover(re)
    return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )


  ensure
    # -> uncomment the next line to manually enable rule tracing
    # trace_out( __method__, 6 )


  end

  return return_value
end

Class: ZunScript::Parser

Defined Under Namespace

Constant Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(input, options = {}) ⇒ Parser

Instance Method Details

#arguments ⇒ Object

#assign ⇒ Object

#bind ⇒ Object

#block ⇒ Object

#block_body ⇒ Object

#closed_bind ⇒ Object

#closed_expression ⇒ Object

#closed_invoke ⇒ Object

#comment ⇒ Object

#invoke ⇒ Object

#line ⇒ Object

#open_expression ⇒ Object

#param ⇒ Object

#params ⇒ Object

#script ⇒ Object

#synpred5_ZunScript ⇒ Object

#synpred6_ZunScript ⇒ Object

#synpred7_ZunScript ⇒ Object

#value ⇒ Object

#variable ⇒ Object

#initialize(input, options = {}) ⇒ `Parser`

#arguments ⇒ `Object`

#assign ⇒ `Object`

#bind ⇒ `Object`

#block ⇒ `Object`

#block_body ⇒ `Object`

#closed_bind ⇒ `Object`

#closed_expression ⇒ `Object`

#closed_invoke ⇒ `Object`

#comment ⇒ `Object`

#invoke ⇒ `Object`

#line ⇒ `Object`

#open_expression ⇒ `Object`

#param ⇒ `Object`

#params ⇒ `Object`

#script ⇒ `Object`

#synpred5_ZunScript ⇒ `Object`

#synpred6_ZunScript ⇒ `Object`

#synpred7_ZunScript ⇒ `Object`

#value ⇒ `Object`

#variable ⇒ `Object`