antlr3 1.2.4 → 1.3.0

data/bin/antlr4ruby

@@ -8,17 +8,5 @@ $:.unshift( lib )
 require 'antlr3'
 
 jar = ANTLR3.antlr_jar or fail( "cannot find antlr4ruby's customized ANTLR jar" )
-escape = proc do | a |
-  if a.empty? then "''"
-  else
-    a.gsub( /([^A-Za-z0-9_\-.,:\/@\n])/n, '\\\1' ).
-      gsub( /\n/, "'\n'" )
-  end
-end
 
-command = %w(java -jar) << escape[ jar ]
-for arg in ARGV
-  command << escape[ arg ]
-end
-
-exec command.join(' ')
+exec( 'java', '-jar', jar, *ARGV )

data/java/RubyTarget.java

@@ -63,11 +63,12 @@ extends Target
 		public String toString(Object o) {
 			return o.toString();
 		}
+		
 		public String toString(Object o, String formatName) {
 			String idString = o.toString();
-
+			
 			if (idString.isEmpty()) return idString;
-
+			
 			if (formatName.equals("snakecase")) {
 				return snakecase(idString);
 			} else if (formatName.equals("camelcase")) {
@@ -393,132 +394,14 @@ extends Target
 	 */
 	public String encodeIntAsCharEscape(final int v) {
 		final int intValue;
-
+		
 		if (v == 65535) {
-			intValue = -1;
+		  intValue = -1;
 		} else {
-			intValue = v;
+		  intValue = v;
 		}
-
+		
 		return String.valueOf(intValue);
+		// return String.valueOf(v);
 	}
-//    public List postProcessAction(List chunks, antlr.Token actionToken) {
-//		List nChunks = new ArrayList();
-//		
-//		for (int i = 0; i < chunks.size(); i++) {
-//			Object chunk = chunks.get(i);
-//
-//			if ( chunk instanceof String ) {
-//				String text = (String)chunks.get(i);
-//				if ( nChunks.size() == 0 && actionToken.getColumn() > 0 ) {
-//					// first chunk and some 'virtual' WS at beginning
-//					// prepend to this chunk
-//
-//					String ws = "";
-//					for ( int j = 0 ; j < actionToken.getColumn() ; j++ ) {
-//						ws += " ";
-//					}
-//					text = ws + text;
-//				}
-//
-//				String[] parts = text.split("\r?\n");
-//				for ( String line : parts  ) {
-//					nChunks.add(line);
-//				}
-//			}
-//			else {
-//				if ( nChunks.size() == 0 && actionToken.getColumn() > 0 ) {
-//					// first chunk and some 'virtual' WS at beginning
-//					// add as a chunk of its own
-//
-//					String ws = "";
-//					for ( int j = 0 ; j < actionToken.getColumn() ; j++ ) {
-//						ws += " ";
-//					}
-//					nChunks.add(ws);
-//				}
-//
-//				nChunks.add(chunk);
-//			}
-//		}
-//
-//		int lineNo = actionToken.getLine();
-//		int col = 0;
-//
-//		// strip trailing empty lines
-//		int lastChunk = nChunks.size() - 1;
-//		while ( lastChunk > 0
-//				&& nChunks.get(lastChunk) instanceof String
-//				&& ((String)nChunks.get(lastChunk)).trim().length() == 0 )
-//			lastChunk--;
-//
-//		// string leading empty lines
-//		int firstChunk = 0;
-//		while ( firstChunk <= lastChunk
-//				&& nChunks.get(firstChunk) instanceof String
-//				&& ((String)nChunks.get(firstChunk)).trim().length() == 0
-//				&& ((String)nChunks.get(firstChunk)).endsWith("\n") ) {
-//			lineNo++;
-//			firstChunk++;
-//		}
-//
-//		int indent = -1;
-//		for ( int i = firstChunk ; i <= lastChunk ; i++ ) {
-//			Object chunk = nChunks.get(i);
-//
-//			//System.out.println(lineNo + ":" + col + " " + quote(chunk.toString()));
-//
-//			if ( chunk instanceof String ) {
-//				String text = (String)chunk;
-//
-//				if ( col == 0 ) {
-//					if ( indent == -1 ) {
-//						// first non-blank line
-//						// count number of leading whitespaces
-//
-//						indent = 0;
-//						for ( int j = 0; j < text.length(); j++ ) {
-//							if ( !Character.isWhitespace(text.charAt(j)) )
-//								break;
-//			
-//							indent++;
-//						}
-//					}
-//
-//					if ( text.length() >= indent ) {
-//						int j;
-//						for ( j = 0; j < indent ; j++ ) {
-//							if ( !Character.isWhitespace(text.charAt(j)) ) {
-//								// should do real error reporting here...
-//								System.err.println("Warning: badly indented line " + lineNo + " in action:");
-//								System.err.println(text);
-//								break;
-//							}
-//						}
-//
-//						nChunks.set(i, text.substring(j));
-//					}
-//					else if ( text.trim().length() > 0 ) {
-//						// should do real error reporting here...
-//						System.err.println("Warning: badly indented line " + lineNo + " in action:");
-//						System.err.println(text);
-//					}
-//				}
-//
-//				if ( text.endsWith("\n") ) {
-//					lineNo++;
-//					col = 0;
-//				}
-//				else {
-//					col += text.length();
-//				}
-//			}
-//			else {
-//				// not really correct, but all I need is col to increment...
-//				col += 1;
-//			}
-//		}
-//
-//		return nChunks;
-//    }
 }

data/lib/antlr3/constants.rb

@@ -82,6 +82,8 @@ module Constants
     2 => "<DOWN>".freeze, 3 => "<UP>".freeze, 
     -1 => "<EOF>".freeze
   )
+  
+  
 end
 
 include Constants

data/lib/antlr3/dfa.rb

@@ -105,14 +105,15 @@ class DFA
               :accept, :special, :transition, :special_block
   
   class << self
-    attr_reader :decision
+    attr_reader :decision, :eot, :eof, :min, :max,
+                :accept, :special, :transition
     
     def unpack(*data)
       data.empty? and return [].freeze
       
       n = data.length / 2
       size = 0
-      n.times { |i| size += data[2*i] }
+      n.times { |i| size += data[ 2*i ] }
       if size > 1024
         values = Hash.new(0)
         data.each_slice(2) do |count, value|
@@ -131,26 +132,28 @@ class DFA
       else
         unpacked = []
         data.each_slice(2) do |count, value|
-          unpacked.concat Array.new(count, value)
+          unpacked.fill( value, unpacked.length, count )
         end
       end
       
-      return unpacked.freeze
+      return unpacked
     end
+    
   end
   
-  def initialize(recognizer, decision_number = nil, eot = nil, eof = nil,
-                 min = nil, max = nil, accept = nil, special = nil,
-                 transition = nil, &special_block)
+  def initialize( recognizer, decision_number = nil,
+                 eot = nil, eof = nil, min = nil, max = nil,
+                 accept = nil, special = nil,
+                 transition = nil, &special_block )
     @recognizer = recognizer
     @decision_number = decision_number || self.class.decision
-    @eot = eot || self.class::EOT
-    @eof = eof || self.class::EOF
-    @min = min || self.class::MIN
-    @max = max || self.class::MAX
-    @accept = accept || self.class::ACCEPT
-    @special = special || self.class::SPECIAL
-    @transition = transition || self.class::TRANSITION
+    @eot = eot || self.class::EOT #.eot
+    @eof = eof || self.class::EOF #.eof
+    @min = min || self.class::MIN #.min
+    @max = max || self.class::MAX #.max
+    @accept = accept || self.class::ACCEPT #.accept
+    @special = special || self.class::SPECIAL #.special
+    @transition = transition || self.class::TRANSITION #.transition
     @special_block = special_block
   rescue NameError => e
     raise unless e.message =~ /uninitialized constant/
@@ -185,7 +188,7 @@ class DFA
       c = input.peek
       # the @min and @max arrays contain the bounds of the character (or token type)
       # ranges for the transition decisions
-      if c.between?(@min[state], @max[state])
+      if c.between?( @min[ state ], @max[ state ] )
         # c - @min[state] is the position of the character within the range
         # so for a range like ?a..?z, a match of ?a would be 0,
         # ?c would be 2, and ?z would be 25

data/lib/antlr3/error.rb

@@ -100,7 +100,7 @@ class RecognitionError < StandardError
   include ANTLR3::Constants
   attr_accessor :input, :index, :line, :column, :symbol, :token, :source_name
   
-  def initialize(input = nil)
+  def initialize( input = nil )
     @index = @line =  @column = nil
     @approximate_line_info = false
     if @input = input
@@ -116,11 +116,11 @@ class RecognitionError < StandardError
         @line   = @input.line
         @column = @input.column
       when AST::TreeNodeStream
-        @symbol = nodes.look
+        @symbol = @input.look
         if @symbol.respond_to?(:line) and @symbol.respond_to?(:column)
           @line, @column = @symbol.line, @symbol.column
         else
-          extract_from_node_stream(@input)
+          extract_from_node_stream( @input )
         end
       else
         @symbol = @input.look

data/lib/antlr3/main.rb

@@ -338,13 +338,13 @@ generated lexer file is run directly from the command line.
 
 =end
 class LexerMain < Main
-  def initialize(lexer_class, options = {})
-    super(options)
+  def initialize( lexer_class, options = {} )
+    super( options )
     @lexer_class = lexer_class
   end
   
-  def recognize(in_stream)
-    lexer = @lexer_class.new(in_stream)
+  def recognize( in_stream )
+    lexer = @lexer_class.new( in_stream )
     
     loop do
       begin
@@ -353,7 +353,7 @@ class LexerMain < Main
         else display_token(token)
         end
       rescue ANTLR3::RecognitionError => error
-        report_error(error)
+        report_error( error )
         break
       end
     end
@@ -365,11 +365,11 @@ class LexerMain < Main
       prefix = '-->'
       suffix = ''
     when ANTLR3::HIDDEN_CHANNEL
-      prefix = '// '
-      suffix = ' (hidden) '
+      prefix = '#  '
+      suffix = ' (hidden)'
     else
       prefix = '~~>'
-      suffix = ' (channel %p) ' % token.channel
+      suffix = ' (channel %p)' % token.channel
     end
     
     printf("%s %-15s %-15p @ line %-3i col %-3i%s\n",
@@ -557,5 +557,4 @@ class WalkerMain < Main
   end
 end
 end
-
 end

data/lib/antlr3/modes/ast-builder.rb

@@ -26,16 +26,36 @@ module ASTBuilder
 private
 
   def subtree_stream(desc, element = nil)
-    AST::RewriteRuleSubtreeStream.new(@adaptor, desc, element)
+    AST::RewriteRuleSubtreeStream.new( @adaptor, desc, element )
+    #if element.instance_of?( Array )
+    #  AST::RewriteRuleSubtreeStream.new( @adaptor, desc, *element )
+    #elsif element
+    #  AST::RewriteRuleSubtreeStream.new( @adaptor, desc, element )
+    #else
+    #  AST::RewriteRuleSubtreeStream.new( @adaptor, desc )
+    #end
   end
   
   def token_stream(desc, element = nil)
-    AST::RewriteRuleTokenStream.new(@adaptor, desc, element)
+    AST::RewriteRuleTokenStream.new( @adaptor, desc, element )
+    #if element.instance_of?( Array )
+    #  AST::RewriteRuleTokenStream.new( @adaptor, desc, *element )
+    #elsif element
+    #  AST::RewriteRuleTokenStream.new( @adaptor, desc, element )
+    #else
+    #  AST::RewriteRuleTokenStream.new( @adaptor, desc )
+    #end
   end
   
   def node_stream(desc, element = nil)
-    AST::RewriteRuleNodeStream.new(@adaptor, desc, element)
+    AST::RewriteRuleNodeStream.new( @adaptor, desc, element )
+    #if element.instance_of?( Array )
+    #  AST::RewriteRuleNodeStream.new( @adaptor, desc, *element )
+    #elsif element
+    #  AST::RewriteRuleNodeStream.new( @adaptor, desc, element )
+    #else
+    #  AST::RewriteRuleNodeStream.new( @adaptor, desc )
+    #end
   end
-  
 end
 end

data/lib/antlr3/recognizers.rb

@@ -119,7 +119,6 @@ class RecognizerSharedState
     self.type = nil
     self.text = nil
   end
-  
 end
 end
 
@@ -165,6 +164,7 @@ class BaseRecognizer
     attr_reader :grammar_file_name,
                 :antlr_version,
                 :antlr_version_string,
+                :library_version_string,
                 :grammar_home
     
     attr_accessor :token_scheme, :default_rule
@@ -173,9 +173,10 @@ class BaseRecognizer
     # the code with the name of the grammar file and
     # the current version of ANTLR being used to generate
     # the code
-    def generated_using(grammar_file, version_string)
+    def generated_using( grammar_file, antlr_version, library_version = nil )
       @grammar_file_name = grammar_file.freeze
-      @antlr_version_string = version_string.freeze
+      @antlr_version_string = antlr_version.freeze
+      @library_version = Util.parse_version( library_version )
       if @antlr_version_string =~ /^(\d+)\.(\d+)(?:\.(\d+)(?:b(\d+))?)?(.*)$/
         @antlr_version = [$1, $2, $3, $4].map! { |str| str.to_i }
         timestamp = $5.strip
@@ -742,9 +743,8 @@ class BaseRecognizer
   # input symbol is.
   # 
   # This is ignored for lexers.
-  
   def current_input_symbol
-    return nil
+    @input.look
   end
   
   # Consume tokens until one matches the given token or token set
@@ -811,7 +811,7 @@ class BaseRecognizer
   end
   
   def trace_in(rule_name, rule_index, input_symbol)
-    @error_output.printf("--> enter %s on %s", rule_name, input_symbol)
+    @error_output.printf( "--> enter %s on %s", rule_name, input_symbol )
     @state.backtracking > 0 and @error_output.printf(
       " (in backtracking mode: depth = %s)", @state.backtracking
     )
@@ -958,6 +958,10 @@ class Lexer < BaseRecognizer
       end
   end
   
+  def current_input_symbol
+    nil
+  end
+  
   def next_token
     loop do
       @state.token = nil
@@ -1110,7 +1114,8 @@ class Lexer < BaseRecognizer
     @input.consume
   end
   
-  private
+  
+private
   
   def trace_in(rule_name, rule_index)
     if symbol = @input.look and symbol != EOF then symbol = symbol.inspect
@@ -1200,18 +1205,14 @@ class Parser < BaseRecognizer
     end
   end
   
-  def initialize(input, options = {})
-    super(options)
+  def initialize( input, options = {} )
+    super( options )
     @input = nil
     reset
     input = cast_input( input, options ) unless TokenStream === input
     @input = input
   end
   
-  def current_input_symbol
-    @input.look
-  end
-  
   def missing_symbol(error, expected_type, follow)
     current = @input.look
     current = @input.look(-1) if current == ANTLR3::EOF_TOKEN
@@ -1239,15 +1240,15 @@ class Parser < BaseRecognizer
   def source_name
     @input.source_name
   end
-
+  
 private
   
   def trace_in(rule_name, rule_index)
-    super(rule_name, rule_index, @input.look.inspect)
+    super( rule_name, rule_index, @input.look.inspect )
   end
   
   def trace_out(rule_name, rule_index)
-    super(rule_name, rule_index, @input.look.inspect)
+    super( rule_name, rule_index, @input.look.inspect )
   end
   
   def cast_input( input, options )