zunscript 0.1.1

data/ext/zunscript/ext.rb

@@ -0,0 +1,2 @@
+require "zunscript/lexer"
+require "zunscript/parser"

data/ext/zunscript/lexer.rb

@@ -0,0 +1,1240 @@
+#!/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 )
+
+  end
+
+
+  class Lexer < ANTLR3::Lexer
+    @grammar_home = ZunScript
+    include TokenData
+
+    begin
+      generated_using( "ZunScript.g", "3.5", "1.10.0" )
+    rescue NoMethodError => error
+      # ignore
+    end
+
+    RULE_NAMES   = [ "T__38", "ASSIGN", "BLOCK_LEFT", "BLOCK_RIGHT", "ARITH_SIGN", 
+                     "BANG", "COMMENT", "BLOCK_END", "COMMA", "LPAREN", 
+                     "RPAREN", "NONCONTROL_CHAR", "LETTER", "LOWER", "UPPER", 
+                     "DIGIT", "SYMBOL", "FLOAT", "INTEGER", "NAME", "STRING", 
+                     "NUMBER", "SPACE", "NEWLINE", "WHITESPACE" ].freeze
+    RULE_METHODS = [ :t__38!, :assign!, :block_left!, :block_right!, :arith_sign!, 
+                     :bang!, :comment!, :block_end!, :comma!, :lparen!, 
+                     :rparen!, :noncontrol_char!, :letter!, :lower!, :upper!, 
+                     :digit!, :symbol!, :float!, :integer!, :name!, :string!, 
+                     :number!, :space!, :newline!, :whitespace! ].freeze
+
+    def initialize( input=nil, options = {} )
+      super( input, options )
+    end
+
+
+    # - - - - - - - - - - - lexer rules - - - - - - - - - - - -
+    # lexer rule t__38! (T__38)
+    # (in ZunScript.g)
+    def t__38!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 1 )
+
+
+
+      type = T__38
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 7:9: '.'
+      match( 0x2e )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 1 )
+
+
+    end
+
+    # lexer rule assign! (ASSIGN)
+    # (in ZunScript.g)
+    def assign!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 2 )
+
+
+
+      type = ASSIGN
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 20:9: '='
+      match( 0x3d )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 2 )
+
+
+    end
+
+    # lexer rule block_left! (BLOCK_LEFT)
+    # (in ZunScript.g)
+    def block_left!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 3 )
+
+
+
+      type = BLOCK_LEFT
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 21:13: '<'
+      match( 0x3c )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 3 )
+
+
+    end
+
+    # lexer rule block_right! (BLOCK_RIGHT)
+    # (in ZunScript.g)
+    def block_right!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 4 )
+
+
+
+      type = BLOCK_RIGHT
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 22:14: '>'
+      match( 0x3e )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 4 )
+
+
+    end
+
+    # lexer rule arith_sign! (ARITH_SIGN)
+    # (in ZunScript.g)
+    def arith_sign!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 5 )
+
+
+
+      type = ARITH_SIGN
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 
+      if @input.peek( 1 ).between?( 0x2a, 0x2b ) || @input.peek(1) == 0x2d || @input.peek(1) == 0x2f || @input.peek(1) == 0x5e
+        @input.consume
+      else
+        mse = MismatchedSet( nil )
+        recover mse
+        raise mse
+
+      end
+
+
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 5 )
+
+
+    end
+
+    # lexer rule bang! (BANG)
+    # (in ZunScript.g)
+    def bang!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 6 )
+
+
+
+      type = BANG
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 24:7: '!'
+      match( 0x21 )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 6 )
+
+
+    end
+
+    # lexer rule comment! (COMMENT)
+    # (in ZunScript.g)
+    def comment!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 7 )
+
+
+
+      type = COMMENT
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 25:10: '#'
+      match( 0x23 )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 7 )
+
+
+    end
+
+    # lexer rule block_end! (BLOCK_END)
+    # (in ZunScript.g)
+    def block_end!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 8 )
+
+
+
+      type = BLOCK_END
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 26:12: 'end'
+      match( "end" )
+
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 8 )
+
+
+    end
+
+    # lexer rule comma! (COMMA)
+    # (in ZunScript.g)
+    def comma!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 9 )
+
+
+
+      type = COMMA
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 28:8: ','
+      match( 0x2c )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 9 )
+
+
+    end
+
+    # lexer rule lparen! (LPAREN)
+    # (in ZunScript.g)
+    def lparen!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 10 )
+
+
+
+      type = LPAREN
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 29:9: '('
+      match( 0x28 )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 10 )
+
+
+    end
+
+    # lexer rule rparen! (RPAREN)
+    # (in ZunScript.g)
+    def rparen!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 11 )
+
+
+
+      type = RPAREN
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 30:9: ')'
+      match( 0x29 )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 11 )
+
+
+    end
+
+    # lexer rule noncontrol_char! (NONCONTROL_CHAR)
+    # (in ZunScript.g)
+    def noncontrol_char!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 12 )
+
+
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 
+      if @input.peek(1) == 0x9 || @input.peek( 1 ).between?( 0x20, 0x21 ) || @input.peek( 1 ).between?( 0x23, 0x7e )
+        @input.consume
+      else
+        mse = MismatchedSet( nil )
+        recover mse
+        raise mse
+
+      end
+
+
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 12 )
+
+
+    end
+
+    # lexer rule letter! (LETTER)
+    # (in ZunScript.g)
+    def letter!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 13 )
+
+
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 
+      if @input.peek( 1 ).between?( 0x41, 0x5a ) || @input.peek( 1 ).between?( 0x61, 0x7a )
+        @input.consume
+      else
+        mse = MismatchedSet( nil )
+        recover mse
+        raise mse
+
+      end
+
+
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 13 )
+
+
+    end
+
+    # lexer rule lower! (LOWER)
+    # (in ZunScript.g)
+    def lower!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 14 )
+
+
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 
+      if @input.peek( 1 ).between?( 0x61, 0x7a )
+        @input.consume
+      else
+        mse = MismatchedSet( nil )
+        recover mse
+        raise mse
+
+      end
+
+
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 14 )
+
+
+    end
+
+    # lexer rule upper! (UPPER)
+    # (in ZunScript.g)
+    def upper!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 15 )
+
+
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 
+      if @input.peek( 1 ).between?( 0x41, 0x5a )
+        @input.consume
+      else
+        mse = MismatchedSet( nil )
+        recover mse
+        raise mse
+
+      end
+
+
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 15 )
+
+
+    end
+
+    # lexer rule digit! (DIGIT)
+    # (in ZunScript.g)
+    def digit!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 16 )
+
+
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 
+      if @input.peek( 1 ).between?( 0x30, 0x39 )
+        @input.consume
+      else
+        mse = MismatchedSet( nil )
+        recover mse
+        raise mse
+
+      end
+
+
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 16 )
+
+
+    end
+
+    # lexer rule symbol! (SYMBOL)
+    # (in ZunScript.g)
+    def symbol!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 17 )
+
+
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 
+      if @input.peek(1) == 0x21 || @input.peek( 1 ).between?( 0x23, 0x2f ) || @input.peek( 1 ).between?( 0x3a, 0x40 ) || @input.peek( 1 ).between?( 0x5b, 0x60 ) || @input.peek( 1 ).between?( 0x7b, 0x7e )
+        @input.consume
+      else
+        mse = MismatchedSet( nil )
+        recover mse
+        raise mse
+
+      end
+
+
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 17 )
+
+
+    end
+
+    # lexer rule float! (FLOAT)
+    # (in ZunScript.g)
+    def float!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 18 )
+
+
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 39:17: INTEGER '.' ( '0' .. '9' )+
+      integer!
+
+      match( 0x2e )
+      # at file 39:29: ( '0' .. '9' )+
+      match_count_1 = 0
+      while true
+        alt_1 = 2
+        look_1_0 = @input.peek( 1 )
+
+        if ( look_1_0.between?( 0x30, 0x39 ) )
+          alt_1 = 1
+
+        end
+        case alt_1
+        when 1
+          # at line 
+          if @input.peek( 1 ).between?( 0x30, 0x39 )
+            @input.consume
+          else
+            mse = MismatchedSet( nil )
+            recover mse
+            raise mse
+
+          end
+
+
+
+        else
+          match_count_1 > 0 and break
+          eee = EarlyExit(1)
+
+
+          raise eee
+        end
+        match_count_1 += 1
+      end
+
+
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 18 )
+
+
+    end
+
+    # lexer rule integer! (INTEGER)
+    # (in ZunScript.g)
+    def integer!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 19 )
+
+
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 40:17: ( '0' | ( '-' )? '1' .. '9' ( '0' .. '9' )* )
+      alt_4 = 2
+      look_4_0 = @input.peek( 1 )
+
+      if ( look_4_0 == 0x30 )
+        alt_4 = 1
+      elsif ( look_4_0 == 0x2d || look_4_0.between?( 0x31, 0x39 ) )
+        alt_4 = 2
+      else
+        raise NoViableAlternative( "", 4, 0 )
+
+      end
+      case alt_4
+      when 1
+        # at line 40:19: '0'
+        match( 0x30 )
+
+      when 2
+        # at line 40:25: ( '-' )? '1' .. '9' ( '0' .. '9' )*
+        # at line 40:25: ( '-' )?
+        alt_2 = 2
+        look_2_0 = @input.peek( 1 )
+
+        if ( look_2_0 == 0x2d )
+          alt_2 = 1
+        end
+        case alt_2
+        when 1
+          # at line 40:25: '-'
+          match( 0x2d )
+
+        end
+        match_range( 0x31, 0x39 )
+        # at line 40:39: ( '0' .. '9' )*
+        while true # decision 3
+          alt_3 = 2
+          look_3_0 = @input.peek( 1 )
+
+          if ( look_3_0.between?( 0x30, 0x39 ) )
+            alt_3 = 1
+
+          end
+          case alt_3
+          when 1
+            # at line 
+            if @input.peek( 1 ).between?( 0x30, 0x39 )
+              @input.consume
+            else
+              mse = MismatchedSet( nil )
+              recover mse
+              raise mse
+
+            end
+
+
+
+          else
+            break # out of loop for decision 3
+          end
+        end # loop for decision 3
+
+
+      end
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 19 )
+
+
+    end
+
+    # lexer rule name! (NAME)
+    # (in ZunScript.g)
+    def name!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 20 )
+
+
+
+      type = NAME
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 42:7: LETTER ( LETTER | DIGIT | '_' | '?' )*
+      letter!
+
+      # at line 42:14: ( LETTER | DIGIT | '_' | '?' )*
+      while true # decision 5
+        alt_5 = 2
+        look_5_0 = @input.peek( 1 )
+
+        if ( look_5_0.between?( 0x30, 0x39 ) || look_5_0 == 0x3f || look_5_0.between?( 0x41, 0x5a ) || look_5_0 == 0x5f || look_5_0.between?( 0x61, 0x7a ) )
+          alt_5 = 1
+
+        end
+        case alt_5
+        when 1
+          # at line 
+          if @input.peek( 1 ).between?( 0x30, 0x39 ) || @input.peek(1) == 0x3f || @input.peek( 1 ).between?( 0x41, 0x5a ) || @input.peek(1) == 0x5f || @input.peek( 1 ).between?( 0x61, 0x7a )
+            @input.consume
+          else
+            mse = MismatchedSet( nil )
+            recover mse
+            raise mse
+
+          end
+
+
+
+        else
+          break # out of loop for decision 5
+        end
+      end # loop for decision 5
+
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 20 )
+
+
+    end
+
+    # lexer rule string! (STRING)
+    # (in ZunScript.g)
+    def string!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 21 )
+
+
+
+      type = STRING
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 43:9: '\"' ( NONCONTROL_CHAR )* '\"'
+      match( 0x22 )
+      # at line 43:13: ( NONCONTROL_CHAR )*
+      while true # decision 6
+        alt_6 = 2
+        look_6_0 = @input.peek( 1 )
+
+        if ( look_6_0 == 0x9 || look_6_0.between?( 0x20, 0x21 ) || look_6_0.between?( 0x23, 0x7e ) )
+          alt_6 = 1
+
+        end
+        case alt_6
+        when 1
+          # at line 
+          if @input.peek(1) == 0x9 || @input.peek( 1 ).between?( 0x20, 0x21 ) || @input.peek( 1 ).between?( 0x23, 0x7e )
+            @input.consume
+          else
+            mse = MismatchedSet( nil )
+            recover mse
+            raise mse
+
+          end
+
+
+
+        else
+          break # out of loop for decision 6
+        end
+      end # loop for decision 6
+
+      match( 0x22 )
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 21 )
+
+
+    end
+
+    # lexer rule number! (NUMBER)
+    # (in ZunScript.g)
+    def number!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 22 )
+
+
+
+      type = NUMBER
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 44:7: ( INTEGER | FLOAT )
+      alt_7 = 2
+      alt_7 = @dfa7.predict( @input )
+      case alt_7
+      when 1
+        # at line 44:9: INTEGER
+        integer!
+
+
+      when 2
+        # at line 44:19: FLOAT
+        float!
+
+
+      end
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 22 )
+
+
+    end
+
+    # lexer rule space! (SPACE)
+    # (in ZunScript.g)
+    def space!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 23 )
+
+
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 
+      if @input.peek(1) == 0x9 || @input.peek(1) == 0x20
+        @input.consume
+      else
+        mse = MismatchedSet( nil )
+        recover mse
+        raise mse
+
+      end
+
+
+
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 23 )
+
+
+    end
+
+    # lexer rule newline! (NEWLINE)
+    # (in ZunScript.g)
+    def newline!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 24 )
+
+
+
+      type = NEWLINE
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 47:10: ( ( '\\r' )? '\\n' )+
+      # at file 47:10: ( ( '\\r' )? '\\n' )+
+      match_count_9 = 0
+      while true
+        alt_9 = 2
+        look_9_0 = @input.peek( 1 )
+
+        if ( look_9_0 == 0xa || look_9_0 == 0xd )
+          alt_9 = 1
+
+        end
+        case alt_9
+        when 1
+          # at line 47:11: ( '\\r' )? '\\n'
+          # at line 47:11: ( '\\r' )?
+          alt_8 = 2
+          look_8_0 = @input.peek( 1 )
+
+          if ( look_8_0 == 0xd )
+            alt_8 = 1
+          end
+          case alt_8
+          when 1
+            # at line 47:11: '\\r'
+            match( 0xd )
+
+          end
+          match( 0xa )
+
+        else
+          match_count_9 > 0 and break
+          eee = EarlyExit(9)
+
+
+          raise eee
+        end
+        match_count_9 += 1
+      end
+
+
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 24 )
+
+
+    end
+
+    # lexer rule whitespace! (WHITESPACE)
+    # (in ZunScript.g)
+    def whitespace!
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 25 )
+
+
+
+      type = WHITESPACE
+      channel = ANTLR3::DEFAULT_CHANNEL
+    # - - - - label initialization - - - -
+
+
+      # - - - - main rule block - - - -
+      # at line 48:13: ( SPACE )+
+      # at file 48:13: ( SPACE )+
+      match_count_10 = 0
+      while true
+        alt_10 = 2
+        look_10_0 = @input.peek( 1 )
+
+        if ( look_10_0 == 0x9 || look_10_0 == 0x20 )
+          alt_10 = 1
+
+        end
+        case alt_10
+        when 1
+          # at line 
+          if @input.peek(1) == 0x9 || @input.peek(1) == 0x20
+            @input.consume
+          else
+            mse = MismatchedSet( nil )
+            recover mse
+            raise mse
+
+          end
+
+
+
+        else
+          match_count_10 > 0 and break
+          eee = EarlyExit(10)
+
+
+          raise eee
+        end
+        match_count_10 += 1
+      end
+
+
+
+      # --> action
+       channel = HIDDEN; 
+      # <-- action
+
+
+
+      @state.type = type
+      @state.channel = channel
+    ensure
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_out( __method__, 25 )
+
+
+    end
+
+    # main rule used to study the input at the current position,
+    # and choose the proper lexer rule to call in order to
+    # fetch the next token
+    #
+    # usually, you don't make direct calls to this method,
+    # but instead use the next_token method, which will
+    # build and emit the actual next token
+    def token!
+      # at line 1:8: ( T__38 | ASSIGN | BLOCK_LEFT | BLOCK_RIGHT | ARITH_SIGN | BANG | COMMENT | BLOCK_END | COMMA | LPAREN | RPAREN | NAME | STRING | NUMBER | NEWLINE | WHITESPACE )
+      alt_11 = 16
+      case look_11 = @input.peek( 1 )
+      when 0x2e then alt_11 = 1
+      when 0x3d then alt_11 = 2
+      when 0x3c then alt_11 = 3
+      when 0x3e then alt_11 = 4
+      when 0x2d then look_11_5 = @input.peek( 2 )
+
+      if ( look_11_5.between?( 0x31, 0x39 ) )
+        alt_11 = 14
+      else
+        alt_11 = 5
+
+      end
+      when 0x21 then alt_11 = 6
+      when 0x23 then alt_11 = 7
+      when 0x65 then look_11_8 = @input.peek( 2 )
+
+      if ( look_11_8 == 0x6e )
+        look_11_18 = @input.peek( 3 )
+
+        if ( look_11_18 == 0x64 )
+          look_11_19 = @input.peek( 4 )
+
+          if ( look_11_19.between?( 0x30, 0x39 ) || look_11_19 == 0x3f || look_11_19.between?( 0x41, 0x5a ) || look_11_19 == 0x5f || look_11_19.between?( 0x61, 0x7a ) )
+            alt_11 = 12
+          else
+            alt_11 = 8
+
+          end
+        else
+          alt_11 = 12
+
+        end
+      else
+        alt_11 = 12
+
+      end
+      when 0x2c then alt_11 = 9
+      when 0x28 then alt_11 = 10
+      when 0x29 then alt_11 = 11
+      when 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a then alt_11 = 12
+      when 0x22 then alt_11 = 13
+      when 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 then alt_11 = 14
+      when 0x2a, 0x2b, 0x2f, 0x5e then alt_11 = 5
+      when 0xa, 0xd then alt_11 = 15
+      when 0x9, 0x20 then alt_11 = 16
+      else
+        raise NoViableAlternative( "", 11, 0 )
+
+      end
+      case alt_11
+      when 1
+        # at line 1:10: T__38
+        t__38!
+
+
+      when 2
+        # at line 1:16: ASSIGN
+        assign!
+
+
+      when 3
+        # at line 1:23: BLOCK_LEFT
+        block_left!
+
+
+      when 4
+        # at line 1:34: BLOCK_RIGHT
+        block_right!
+
+
+      when 5
+        # at line 1:46: ARITH_SIGN
+        arith_sign!
+
+
+      when 6
+        # at line 1:57: BANG
+        bang!
+
+
+      when 7
+        # at line 1:62: COMMENT
+        comment!
+
+
+      when 8
+        # at line 1:70: BLOCK_END
+        block_end!
+
+
+      when 9
+        # at line 1:80: COMMA
+        comma!
+
+
+      when 10
+        # at line 1:86: LPAREN
+        lparen!
+
+
+      when 11
+        # at line 1:93: RPAREN
+        rparen!
+
+
+      when 12
+        # at line 1:100: NAME
+        name!
+
+
+      when 13
+        # at line 1:105: STRING
+        string!
+
+
+      when 14
+        # at line 1:112: NUMBER
+        number!
+
+
+      when 15
+        # at line 1:119: NEWLINE
+        newline!
+
+
+      when 16
+        # at line 1:127: WHITESPACE
+        whitespace!
+
+
+      end
+    end
+
+
+    # - - - - - - - - - - DFA definitions - - - - - - - - - - -
+    class DFA7 < ANTLR3::DFA
+      EOT = unpack( 1, -1, 1, 4, 1, -1, 1, 4, 2, -1, 1, 4 )
+      EOF = unpack( 7, -1 )
+      MIN = unpack( 1, 45, 1, 46, 1, 49, 1, 46, 2, -1, 1, 46 )
+      MAX = unpack( 1, 57, 1, 46, 2, 57, 2, -1, 1, 57 )
+      ACCEPT = unpack( 4, -1, 1, 1, 1, 2, 1, -1 )
+      SPECIAL = unpack( 7, -1 )
+      TRANSITION = [
+        unpack( 1, 2, 2, -1, 1, 1, 9, 3 ),
+        unpack( 1, 5 ),
+        unpack( 9, 3 ),
+        unpack( 1, 5, 1, -1, 10, 6 ),
+        unpack(  ),
+        unpack(  ),
+        unpack( 1, 5, 1, -1, 10, 6 )
+      ].freeze
+
+      ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
+        if a > 0 and z < 0
+          MAX[ i ] %= 0x10000
+        end
+      end
+
+      @decision = 7
+
+
+      def description
+        <<-'__dfa_description__'.strip!
+          44:1: NUMBER : ( INTEGER | FLOAT );
+        __dfa_description__
+      end
+
+    end
+
+
+    private
+
+    def initialize_dfas
+      super rescue nil
+      @dfa7 = DFA7.new( self, 7 )
+
+
+    end
+
+  end # class Lexer < ANTLR3::Lexer
+
+  at_exit { Lexer.main( ARGV ) } if __FILE__ == $0
+
+end