zunscript 0.1.1

data/ext/zunscript/parser.rb

@@ -0,0 +1,2225 @@
+#!/usr/bin/env ruby
+#
+# ZunScript.g
+# --
+# Generated using ANTLR version: 3.5
+# Ruby runtime library version: 1.10.0
+# Input grammar file: ZunScript.g
+# Generated at: 2015-04-29 05:09:24
+#
+
+# ~~~> start load path setup
+this_directory = File.expand_path( File.dirname( __FILE__ ) )
+$LOAD_PATH.unshift( this_directory ) unless $LOAD_PATH.include?( this_directory )
+
+antlr_load_failed = proc do
+  load_path = $LOAD_PATH.map { |dir| '  - ' << dir }.join( $/ )
+  raise LoadError, <<-END.strip!
+
+Failed to load the ANTLR3 runtime library (version 1.10.0):
+
+Ensure the library has been installed on your system and is available
+on the load path. If rubygems is available on your system, this can
+be done with the command:
+
+  gem install antlr3
+
+Current load path:
+#{ load_path }
+
+  END
+end
+
+defined?( ANTLR3 ) or begin
+
+  # 1: try to load the ruby antlr3 runtime library from the system path
+  require 'antlr3'
+
+rescue LoadError
+
+  # 2: try to load rubygems if it isn't already loaded
+  defined?( Gem ) or begin
+    require 'rubygems'
+  rescue LoadError
+    antlr_load_failed.call
+  end
+
+  # 3: try to activate the antlr3 gem
+  begin
+    defined?( gem ) and gem( 'antlr3', '~> 1.10.0' )
+  rescue Gem::LoadError
+    antlr_load_failed.call
+  end
+
+  require 'antlr3'
+
+end
+# <~~~ end load path setup
+
+module ZunScript
+  # TokenData defines all of the token type integer values
+  # as constants, which will be included in all
+  # ANTLR-generated recognizers.
+  const_defined?( :TokenData ) or TokenData = ANTLR3::TokenScheme.new
+
+  module TokenData
+
+    # define the token constants
+    define_tokens( :EOF => -1, :T__38 => 38, :ARITH_SIGN => 4, :ASSIGN => 5, 
+                   :BANG => 6, :BIND => 7, :BLK => 8, :BLOCK_END => 9, :BLOCK_LEFT => 10, 
+                   :BLOCK_RIGHT => 11, :BODY => 12, :COMMA => 13, :COMMENT => 14, 
+                   :DIGIT => 15, :FLOAT => 16, :INDEX => 17, :INTEGER => 18, 
+                   :INVOKE => 19, :LEFTBLOCK => 20, :LETTER => 21, :LOWER => 22, 
+                   :LPAREN => 23, :NAME => 24, :NEWLINE => 25, :NONCONTROL_CHAR => 26, 
+                   :NUM => 27, :NUMBER => 28, :PARAM => 29, :RPAREN => 30, 
+                   :SPACE => 31, :STR => 32, :STRING => 33, :SYMBOL => 34, 
+                   :UPPER => 35, :VARIABLE => 36, :WHITESPACE => 37 )
+
+
+    # register the proper human-readable name or literal value
+    # for each token type
+    #
+    # this is necessary because anonymous tokens, which are
+    # created from literal values in the grammar, do not
+    # have descriptive names
+    register_names( "ARITH_SIGN", "ASSIGN", "BANG", "BIND", "BLK", "BLOCK_END", 
+                    "BLOCK_LEFT", "BLOCK_RIGHT", "BODY", "COMMA", "COMMENT", 
+                    "DIGIT", "FLOAT", "INDEX", "INTEGER", "INVOKE", "LEFTBLOCK", 
+                    "LETTER", "LOWER", "LPAREN", "NAME", "NEWLINE", "NONCONTROL_CHAR", 
+                    "NUM", "NUMBER", "PARAM", "RPAREN", "SPACE", "STR", 
+                    "STRING", "SYMBOL", "UPPER", "VARIABLE", "WHITESPACE", 
+                    "'.'" )
+
+
+  end
+
+
+  class Parser < ANTLR3::Parser
+    @grammar_home = ZunScript
+    include ANTLR3::ASTBuilder
+
+    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
+
+    include TokenData
+
+    begin
+      generated_using( "ZunScript.g", "3.5", "1.10.0" )
+    rescue NoMethodError => error
+      # ignore
+    end
+
+    def initialize( input, options = {} )
+      super( input, options )
+    end
+    # - - - - - - - - - - - - Rules - - - - - - - - - - - - -
+    ScriptReturnValue = define_return_scope
+
+    #
+    # parser rule script
+    #
+    # (in ZunScript.g)
+    # 50:1: script : ( line )* EOF !;
+    #
+    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
+
+    LineReturnValue = define_return_scope
+
+    #
+    # parser rule line
+    #
+    # (in ZunScript.g)
+    # 51:1: line : ( open_expression )? ( comment !)? NEWLINE !;
+    #
+    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
+
+    CommentReturnValue = define_return_scope
+
+    #
+    # parser rule comment
+    #
+    # (in ZunScript.g)
+    # 53:1: comment : COMMENT (~ NEWLINE )* ;
+    #
+    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
+
+    OpenExpressionReturnValue = define_return_scope
+
+    #
+    # parser rule open_expression
+    #
+    # (in ZunScript.g)
+    # 55:1: open_expression : ( assign | invoke | bind | closed_expression );
+    #
+    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
+
+    ClosedExpressionReturnValue = define_return_scope
+
+    #
+    # parser rule closed_expression
+    #
+    # (in ZunScript.g)
+    # 57:1: closed_expression : ( value | variable | closed_invoke | closed_bind | LPAREN ! open_expression RPAREN !);
+    #
+    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
+
+    VariableReturnValue = define_return_scope
+
+    #
+    # parser rule variable
+    #
+    # (in ZunScript.g)
+    # 61:1: variable : ( NAME '.' )* NAME -> ^( VARIABLE ( NAME )* ) ;
+    #
+    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
+
+    ValueReturnValue = define_return_scope
+
+    #
+    # parser rule value
+    #
+    # (in ZunScript.g)
+    # 63:1: value : (v= NUMBER -> ^( NUM $v) |v= STRING -> ^( STR $v) | block );
+    #
+    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
+
+    BlockReturnValue = define_return_scope
+
+    #
+    # parser rule block
+    #
+    # (in ZunScript.g)
+    # 68:1: block : BLOCK_RIGHT arguments NEWLINE block_body BLOCK_END -> ^( BLK ( arguments )* block_body ) ;
+    #
+    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
+
+    BlockBodyReturnValue = define_return_scope
+
+    #
+    # parser rule block_body
+    #
+    # (in ZunScript.g)
+    # 69:1: block_body : ( line )* -> ^( BODY ( line )* ) ;
+    #
+    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
+
+    ArgumentsReturnValue = define_return_scope
+
+    #
+    # parser rule arguments
+    #
+    # (in ZunScript.g)
+    # 71:1: arguments : (| NAME ( COMMA ! NAME )* );
+    #
+    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
+
+    AssignReturnValue = define_return_scope
+
+    #
+    # parser rule assign
+    #
+    # (in ZunScript.g)
+    # 73:1: assign : variable ASSIGN open_expression -> ^( ASSIGN variable open_expression ) ;
+    #
+    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
+
+    InvokeReturnValue = define_return_scope
+
+    #
+    # parser rule invoke
+    #
+    # (in ZunScript.g)
+    # 76:1: invoke : variable BANG params -> ^( INVOKE variable ( params )* ) ;
+    #
+    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
+
+    BindReturnValue = define_return_scope
+
+    #
+    # parser rule bind
+    #
+    # (in ZunScript.g)
+    # 78:1: bind : variable params -> ^( BIND variable ( params )* ) ;
+    #
+    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
+
+    ClosedInvokeReturnValue = define_return_scope
+
+    #
+    # parser rule closed_invoke
+    #
+    # (in ZunScript.g)
+    # 80:1: closed_invoke : variable BANG ( param )? -> ^( INVOKE variable ( param )* ) ;
+    #
+    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
+
+    ClosedBindReturnValue = define_return_scope
+
+    #
+    # parser rule closed_bind
+    #
+    # (in ZunScript.g)
+    # 82:1: closed_bind : variable param -> ^( BIND variable param ) ;
+    #
+    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
+
+    ParamsReturnValue = define_return_scope
+
+    #
+    # parser rule params
+    #
+    # (in ZunScript.g)
+    # 85:1: params : param ( COMMA ! param )* ;
+    #
+    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
+
+    ParamReturnValue = define_return_scope
+
+    #
+    # parser rule param
+    #
+    # (in ZunScript.g)
+    # 87:1: param : closed_expression ;
+    #
+    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
+
+    #
+    # 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
+    #
+    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
+    #
+    # 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
+    #
+    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
+    #
+    # 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
+    #
+    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
+
+
+    # - - - - - - - - - - DFA definitions - - - - - - - - - - -
+    class DFA6 < ANTLR3::DFA
+      EOT = unpack( 8, -1 )
+      EOF = unpack( 2, -1, 1, 5, 5, -1 )
+      MIN = unpack( 1, 11, 1, -1, 1, 6, 1, -1, 1, 24, 3, -1 )
+      MAX = unpack( 1, 33, 1, -1, 1, 38, 1, -1, 1, 24, 3, -1 )
+      ACCEPT = unpack( 1, -1, 1, 1, 1, -1, 1, 5, 1, -1, 1, 2, 1, 3, 1, 4 )
+      SPECIAL = unpack( 8, -1 )
+      TRANSITION = [
+        unpack( 1, 1, 11, -1, 1, 3, 1, 2, 3, -1, 1, 1, 4, -1, 1, 1 ),
+        unpack(  ),
+        unpack( 1, 6, 4, -1, 1, 7, 1, -1, 2, 5, 8, -1, 2, 7, 1, 5, 2, -1, 
+                 1, 7, 1, -1, 1, 5, 2, -1, 1, 7, 4, -1, 1, 4 ),
+        unpack(  ),
+        unpack( 1, 2 ),
+        unpack(  ),
+        unpack(  ),
+        unpack(  )
+      ].freeze
+
+      ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
+        if a > 0 and z < 0
+          MAX[ i ] %= 0x10000
+        end
+      end
+
+      @decision = 6
+
+
+      def description
+        <<-'__dfa_description__'.strip!
+          57:1: closed_expression : ( value | variable | closed_invoke | closed_bind | LPAREN ! open_expression RPAREN !);
+        __dfa_description__
+      end
+
+    end
+
+
+    private
+
+    def initialize_dfas
+      super rescue nil
+      @dfa6 = DFA6.new( self, 6 )
+
+
+    end
+
+    TOKENS_FOLLOWING_line_IN_script_385 = Set[ 11, 14, 23, 24, 25, 28, 33 ]
+    TOKENS_FOLLOWING_EOF_IN_script_388 = Set[ 1 ]
+    TOKENS_FOLLOWING_open_expression_IN_line_395 = Set[ 14, 25 ]
+    TOKENS_FOLLOWING_comment_IN_line_398 = Set[ 25 ]
+    TOKENS_FOLLOWING_NEWLINE_IN_line_402 = Set[ 1 ]
+    TOKENS_FOLLOWING_COMMENT_IN_comment_410 = Set[ 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38 ]
+    TOKENS_FOLLOWING_assign_IN_open_expression_427 = Set[ 1 ]
+    TOKENS_FOLLOWING_invoke_IN_open_expression_431 = Set[ 1 ]
+    TOKENS_FOLLOWING_bind_IN_open_expression_435 = Set[ 1 ]
+    TOKENS_FOLLOWING_closed_expression_IN_open_expression_439 = Set[ 1 ]
+    TOKENS_FOLLOWING_value_IN_closed_expression_449 = Set[ 1 ]
+    TOKENS_FOLLOWING_variable_IN_closed_expression_453 = Set[ 1 ]
+    TOKENS_FOLLOWING_closed_invoke_IN_closed_expression_457 = Set[ 1 ]
+    TOKENS_FOLLOWING_closed_bind_IN_closed_expression_461 = Set[ 1 ]
+    TOKENS_FOLLOWING_LPAREN_IN_closed_expression_467 = Set[ 11, 23, 24, 28, 33 ]
+    TOKENS_FOLLOWING_open_expression_IN_closed_expression_470 = Set[ 30 ]
+    TOKENS_FOLLOWING_RPAREN_IN_closed_expression_472 = Set[ 1 ]
+    TOKENS_FOLLOWING_NAME_IN_variable_481 = Set[ 38 ]
+    TOKENS_FOLLOWING_T__38_IN_variable_483 = Set[ 24 ]
+    TOKENS_FOLLOWING_NAME_IN_variable_487 = Set[ 1 ]
+    TOKENS_FOLLOWING_NUMBER_IN_value_509 = Set[ 1 ]
+    TOKENS_FOLLOWING_STRING_IN_value_526 = Set[ 1 ]
+    TOKENS_FOLLOWING_block_IN_value_541 = Set[ 1 ]
+    TOKENS_FOLLOWING_BLOCK_RIGHT_IN_block_548 = Set[ 24, 25 ]
+    TOKENS_FOLLOWING_arguments_IN_block_550 = Set[ 25 ]
+    TOKENS_FOLLOWING_NEWLINE_IN_block_552 = Set[ 9, 11, 14, 23, 24, 25, 28, 33 ]
+    TOKENS_FOLLOWING_block_body_IN_block_554 = Set[ 9 ]
+    TOKENS_FOLLOWING_BLOCK_END_IN_block_556 = Set[ 1 ]
+    TOKENS_FOLLOWING_line_IN_block_body_573 = Set[ 1, 11, 14, 23, 24, 25, 28, 33 ]
+    TOKENS_FOLLOWING_NAME_IN_arguments_591 = Set[ 1, 13 ]
+    TOKENS_FOLLOWING_COMMA_IN_arguments_594 = Set[ 24 ]
+    TOKENS_FOLLOWING_NAME_IN_arguments_597 = Set[ 1, 13 ]
+    TOKENS_FOLLOWING_variable_IN_assign_610 = Set[ 5 ]
+    TOKENS_FOLLOWING_ASSIGN_IN_assign_612 = Set[ 11, 23, 24, 28, 33 ]
+    TOKENS_FOLLOWING_open_expression_IN_assign_614 = Set[ 1 ]
+    TOKENS_FOLLOWING_variable_IN_invoke_635 = Set[ 6 ]
+    TOKENS_FOLLOWING_BANG_IN_invoke_637 = Set[ 11, 23, 24, 28, 33 ]
+    TOKENS_FOLLOWING_params_IN_invoke_639 = Set[ 1 ]
+    TOKENS_FOLLOWING_variable_IN_bind_660 = Set[ 11, 23, 24, 28, 33 ]
+    TOKENS_FOLLOWING_params_IN_bind_662 = Set[ 1 ]
+    TOKENS_FOLLOWING_variable_IN_closed_invoke_684 = Set[ 6 ]
+    TOKENS_FOLLOWING_BANG_IN_closed_invoke_686 = Set[ 1, 11, 23, 24, 28, 33 ]
+    TOKENS_FOLLOWING_param_IN_closed_invoke_688 = Set[ 1 ]
+    TOKENS_FOLLOWING_variable_IN_closed_bind_710 = Set[ 11, 23, 24, 28, 33 ]
+    TOKENS_FOLLOWING_param_IN_closed_bind_712 = Set[ 1 ]
+    TOKENS_FOLLOWING_param_IN_params_733 = Set[ 1, 13 ]
+    TOKENS_FOLLOWING_COMMA_IN_params_736 = Set[ 11, 23, 24, 28, 33 ]
+    TOKENS_FOLLOWING_param_IN_params_739 = Set[ 1, 13 ]
+    TOKENS_FOLLOWING_closed_expression_IN_param_747 = Set[ 1 ]
+    TOKENS_FOLLOWING_assign_IN_synpred5_ZunScript_427 = Set[ 1 ]
+    TOKENS_FOLLOWING_invoke_IN_synpred6_ZunScript_431 = Set[ 1 ]
+    TOKENS_FOLLOWING_bind_IN_synpred7_ZunScript_435 = Set[ 1 ]
+
+  end # class Parser < ANTLR3::Parser
+
+  at_exit { Parser.main( ARGV ) } if __FILE__ == $0
+
+end