antlr3 1.8.8 → 1.8.10

data/java/RubyTarget.java

@@ -477,4 +477,135 @@ public class RubyTarget extends Target
 
         return String.valueOf( intValue );
     }
+
+    /** Convert from an ANTLR string literal found in a grammar file to
+     *  an equivalent string literal in the target language.  For Java, this
+     *  is the translation 'a\n"' -> "a\n\"".  Expect single quotes
+     *  around the incoming literal.  Just flip the quotes and replace
+     *  double quotes with \"
+       * 
+       *  Note that we have decided to allow poeple to use '\"' without
+       *  penalty, so we must build the target string in a loop as Utils.replae
+       *  cannot handle both \" and " without a lot of messing around.
+       * 
+     */
+    public String getTargetStringLiteralFromANTLRStringLiteral(
+      CodeGenerator generator,
+      String literal)
+    {
+          StringBuilder sb = new StringBuilder();
+          StringBuffer is = new StringBuffer(literal);
+          int lastIndex = is.length() - 1;
+          
+          // Opening quote
+          //
+          sb.append('"');
+          
+          for ( int i = 1; i < lastIndex; i++ ) {
+              if  (is.charAt(i) == '\\') {
+                  // Anything escaped is what it is! We assume that
+                  // people know how to escape characters correctly. However
+                  // we catch anything that does not need an escape in Java (which
+                  // is what the default implementation is dealing with and remove 
+                  // the escape. The C target does this for instance.
+                  //
+                  switch (is.charAt(i+1)) {
+                      // Pass through any escapes that Java also needs
+                      //
+                      case    '"':
+                      case    'n':
+                      case    'r':
+                      case    't':
+                      case    'b':
+                      case    'f':
+                      case    '\\':
+                      case    'u':    // Assume unnnn
+                          sb.append('\\');    // Pass the escape through
+                          break;
+                      default:
+                          // Remove the escape by virtue of not adding it here
+                          // Thus \' becomes ' and so on
+                          //
+                          break;
+                  }
+                  
+                  // Go past the \ character
+                  //
+                  i++;
+              } else {
+                  
+                  // in ruby, double quoted strings have interpolation signifiers that
+                  // will cause a syntax error in the output if they are not properly
+                  // escaped
+                  
+                  if ( is.charAt( i ) == '#' && i < lastIndex - 1 ) {
+                    switch ( is.charAt( i + 1 ) ) {
+                      case '{':
+                      case '@':
+                      case '$':
+                        sb.append('\\');
+                        break;
+                      default:
+                        break;
+                        // pass through
+                    }
+                  } else if (is.charAt(i) == '"') {
+                      sb.append('\\');
+                  }
+                  
+              }
+              // Add in the next character, which may have been escaped
+              //
+              sb.append(is.charAt(i));   
+          }
+          
+          // Append closing " and return
+          //
+          sb.append('"');
+          
+      return sb.toString();
+    }
+
+
+    public String getTargetStringLiteralFromString(String s, boolean quoted) {
+      if ( s == null ) { return null; }
+      
+      StringBuffer buf = new StringBuffer();
+      
+      if ( quoted ) { buf.append('"'); }
+      
+      for ( int i = 0; i < s.length(); i++ ) {
+        int c = s.charAt( i );
+        
+        if ( c != '\'' && // don't escape single quotes in strings for java
+           c < targetCharValueEscape.length &&
+           targetCharValueEscape[c] != null )
+        {
+          buf.append(targetCharValueEscape[c]);
+        }
+        else if ( c == '#' && i < s.length() - 1 )
+        {
+            switch ( s.charAt( i + 1 ) ) {
+              case '{':
+              case '@':
+              case '$':
+                buf.append( "\\#" );
+                break;
+              default:
+                buf.append( '#' );
+                break;
+            }
+        }
+        else
+        {
+          buf.append((char)c);
+        }
+      }
+      if ( quoted ) {
+        buf.append('"');
+      }
+      return buf.toString();
+    }
+
+
 }

data/lib/antlr3/main.rb

@@ -145,19 +145,13 @@ class Main
         ANTLR3::FileStream.new( args[ 0 ] )
       else ANTLR3::FileStream.new( @input )
       end
-    case
-    when @ruby_prof
+    if @ruby_prof
       load_ruby_prof
       profile = RubyProf.profile do
         recognize( in_stream )
       end
       printer = RubyProf::FlatPrinter.new( profile )
       printer.print( @output )
-    when @profile
-      require 'profiler'
-      Profiler__.start_profile
-      recognize( in_stream )
-      Profiler__.print_profile
     else
       recognize( in_stream )
     end
@@ -457,7 +451,7 @@ class ParserMain < Main
     # token_stream = CommonTokenStream.new( lexer )
     parser = @parser_class.new( lexer, parser_options )
     result = parser.send( @parser_rule ) and present( result )
-    @profile and puts( parser.generate_report )
+    @profile and puts( parser.profile.generate_report )
   end
   
   def present( return_value )

data/lib/antlr3/profile.rb

@@ -68,7 +68,7 @@ module ParserEvents
   end
   
   def memoize( rule, start_index, success )
-    @debug_listener.memoize( rule, rule_start_index, sucess )
+    @debug_listener.memoize( rule, start_index, success )
     super
   end
 end

data/lib/antlr3/version.rb

@@ -20,7 +20,7 @@ module ANTLR3
   # 
   MAJOR_VERSION = 1
   MINOR_VERSION = 8
-  PATCH_VERSION = 8
+  PATCH_VERSION = 10
   VERSION = [ MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION ]
   VERSION_STRING = VERSION.join( '.' ).freeze
   

data/templates/Ruby.stg

@@ -1459,4 +1459,4 @@ placeAction(scope, name) ::= <<
 <endif>
 >>
 
-runtimeLibraryVersion() ::= "1.8.8"
+runtimeLibraryVersion() ::= "1.8.10"

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: antlr3
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: 35
+  prerelease: 
   segments: 
   - 1
   - 8
-  - 8
-  version: 1.8.8
+  - 10
+  version: 1.8.10
 platform: ruby
 authors: 
 - Kyle Yetter
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-10 00:00:00 -05:00
+date: 2011-03-28 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -240,25 +241,29 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 57
       segments: 
       - 1
       - 8
       - 7
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: 
 - java
 rubyforge_project: antlr3
-rubygems_version: 1.3.6
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
 summary: Fully-featured ruby parser generation for ANTLR version 3.