antlr3 1.6.0 → 1.6.3

data/lib/antlr3/dfa.rb

@@ -4,7 +4,7 @@
 =begin LICENSE
 
 [The "BSD licence"]
-Copyright (c) 2009 Kyle Yetter
+Copyright (c) 2009-2010 Kyle Yetter
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -108,30 +108,30 @@ class DFA
     attr_reader :decision, :eot, :eof, :min, :max,
                 :accept, :special, :transition
     
-    def unpack(*data)
+    def unpack( *data )
       data.empty? and return [].freeze
       
       n = data.length / 2
       size = 0
       n.times { |i| size += data[ 2*i ] }
       if size > 1024
-        values = Hash.new(0)
-        data.each_slice(2) do |count, value|
-          values[value] += count
+        values = Hash.new( 0 )
+        data.each_slice( 2 ) do |count, value|
+          values[ value ] += count
         end
-        default = values.keys.max_by { |v| values[v] }
+        default = values.keys.max_by { |v| values[ v ] }
         
-        unpacked = Hash.new(default)
+        unpacked = Hash.new( default )
         position = 0
-        data.each_slice(2) do |count, value|
+        data.each_slice( 2 ) do |count, value|
           unless value == default
-            count.times { |i| unpacked[position + i] = value }
+            count.times { |i| unpacked[ position + i ] = value }
           end
           position += count
         end
       else
         unpacked = []
-        data.each_slice(2) do |count, value|
+        data.each_slice( 2 ) do |count, value|
           unpacked.fill( value, unpacked.length, count )
         end
       end
@@ -159,87 +159,157 @@ class DFA
     raise unless e.message =~ /uninitialized constant/
     constant = e.name
     message = Util.tidy( <<-END )
-    | No #{constant} information provided.
+    | No #{ constant } information provided.
     | DFA cannot be instantiated without providing state array information.
     | When DFAs are generated by ANTLR, this information should already be
     | provided in the DFA subclass constants.
     END
   end
   
-  def predict(input)
-    mark = input.mark
-    state = 0
+  if RUBY_VERSION =~ /^1\.9/
     
-    50000.times do
-      special_state = @special[state]
-      if special_state >= 0
-        state = @special_block.call(special_state)
-        if state == -1
-          no_viable_alternative(state, input)
-          return 0
+    def predict( input )
+      mark = input.mark
+      state = 0
+      
+      50000.times do
+        special_state = @special[ state ]
+        if special_state >= 0
+          state = @special_block.call( special_state )
+          if state == -1
+            no_viable_alternative( state, input )
+            return 0
+          end
+          input.consume
+          next
+        end
+        @accept[ state ] >= 1 and return @accept[ state ]
+        
+        # look for a normal char transition
+        
+        c = input.peek.ord
+        # 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 ] )
+          # 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
+          next_state = @transition[ state ][ c - @min[ state ] ]
+          if next_state < 0
+            if @eot[ state ] >= 0
+              state = @eot[ state ]
+              input.consume
+              next
+            end
+            no_viable_alternative( state, input )
+            return 0
+          end
+          
+          state = next_state
+          input.consume
+          next
         end
-        input.consume
-        next
+        
+        if @eot[ state ] >= 0
+          state = @eot[ state ]
+          input.consume()
+          next
+        end
+        
+        ( c == EOF && @eof[ state ] >= 0 ) and return @accept[ @eof[ state ] ]
+        no_viable_alternative( state, input )
+        return 0
       end
-      @accept[state] >= 1 and return @accept[state]
       
-      # look for a normal char transition
+      ANTLR3.bug!( Util.tidy( <<-END ) )
+      | DFA BANG!
+      |   The prediction loop has exceeded a maximum limit of 50000 iterations
+      | ----
+      | decision: #@decision_number
+      | description: #{ description }
+      END
+    ensure
+      input.rewind( mark )
+    end
+    
+  else
+    
+    def predict( input )
+      mark = input.mark
+      state = 0
       
-      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 ] )
-        # 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
-        next_state = @transition[state][c - @min[state]]
-        if next_state < 0
-          if @eot[state] >= 0
-            state = @eot[state]
-            input.consume
-            next
+      50000.times do
+        special_state = @special[ state ]
+        if special_state >= 0
+          state = @special_block.call( special_state )
+          if state == -1
+            no_viable_alternative( state, input )
+            return 0
           end
-          no_viable_alternative(state, input)
-          return 0
+          input.consume
+          next
         end
+        @accept[ state ] >= 1 and return @accept[ state ]
         
-        state = next_state
-        input.consume()
-        next
-      end
-      if @eot[state] >= 0
-        state = @eot[state]
-        input.consume()
-        next
+        # look for a normal char transition
+        
+        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 ] )
+          # 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
+          next_state = @transition[ state ][ c - @min[ state ] ]
+          if next_state < 0
+            if @eot[ state ] >= 0
+              state = @eot[ state ]
+              input.consume
+              next
+            end
+            no_viable_alternative( state, input )
+            return 0
+          end
+          
+          state = next_state
+          input.consume()
+          next
+        end
+        if @eot[ state ] >= 0
+          state = @eot[ state ]
+          input.consume()
+          next
+        end
+        ( c == EOF && @eof[ state ] >= 0 ) and return @accept[ @eof[ state ] ]
+        no_viable_alternative( state, input )
+        return 0
       end
-      (c == EOF && @eof[state] >= 0) and return @accept[@eof[state]]
-      no_viable_alternative(state, input)
-      return 0
+      
+      ANTLR3.bug!( Util.tidy( <<-END ) )
+      | DFA BANG!
+      |   The prediction loop has exceeded a maximum limit of 50000 iterations
+      | ----
+      | decision: #@decision_number
+      | description: #{ description }
+      END
+    ensure
+      input.rewind( mark )
     end
     
-    ANTLR3.bug!( Util.tidy(<<-END) )
-    | DFA BANG!
-    |   The prediction loop has exceeded a maximum limit of 50000 iterations
-    | ----
-    | decision: #@decision_number
-    | description: #{description}
-    END
-  ensure
-    input.rewind(mark)
   end
-
-  def no_viable_alternative(state, input)
-    raise(BacktrackingFailed) if @recognizer.state.backtracking > 0
-    except = NoViableAlternative.new(description, @decision_number, state, input)
-    error(except)
-    raise(except)
+  
+  def no_viable_alternative( state, input )
+    raise( BacktrackingFailed ) if @recognizer.state.backtracking > 0
+    except = NoViableAlternative.new( description, @decision_number, state, input )
+    error( except )
+    raise( except )
   end
   
-  def error(except)
+  def error( except )
     # overridable debugging hook
   end
   
-  def special_state_transition(state, input)
+  def special_state_transition( state, input )
     return -1
   end
   

data/lib/antlr3/dot.rb

@@ -4,7 +4,7 @@
 =begin LICENSE
 
 [The "BSD licence"]
-Copyright (c) 2009 Kyle Yetter
+Copyright (c) 2009-2010 Kyle Yetter
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -49,26 +49,26 @@ library.
 
 module DOT
   class Context
-    def []=(var, value)
-      instance_variable_set(:"@#{var}", value)
+    def []=( var, value )
+      instance_variable_set( :"@#{ var }", value )
     end
-    def [](var)
-      instance_variable_get(:"@#{var}")
+    def []( var )
+      instance_variable_get( :"@#{ var }" )
     end
     
-    def initialize(template, vars = {})
+    def initialize( template, vars = {} )
       @__template__ = template
       vars.each do |var, value|
-        self[var] = value
+        self[ var ] = value
       end
     end
     
     def to_s
-      @__template__.result(binding)
+      @__template__.result( binding )
     end
   end
   class TreeGenerator
-    TREE_TEMPLATE = ERB.new( Util.tidy(<<-END) )
+    TREE_TEMPLATE = ERB.new( Util.tidy( <<-END ) )
     | digraph {
     |   ordering=out;
     |   ranksep=.4;
@@ -80,33 +80,33 @@ module DOT
     | }
     END
     
-    NODE_TEMPLATE = ERB.new( Util.tidy(<<-END) )
+    NODE_TEMPLATE = ERB.new( Util.tidy( <<-END ) )
     | <%= @name %> [label="<%= @text %>"];
     END
     
-    EDGE_TEMPLATE = ERB.new( Util.tidy(<<-END) )
+    EDGE_TEMPLATE = ERB.new( Util.tidy( <<-END ) )
     | <%= @parent %> -> <%= @child %>; // "<%= @parent_text %>" -> "<%= @child_text %>"
     END
     
-    def self.generate(tree, adaptor = nil, tree_template = TREE_TEMPLATE,
-                      edge_template = EDGE_TEMPLATE)
-      new.to_dot(tree, adaptor, tree_template, edge_template)
+    def self.generate( tree, adaptor = nil, tree_template = TREE_TEMPLATE,
+                      edge_template = EDGE_TEMPLATE )
+      new.to_dot( tree, adaptor, tree_template, edge_template )
     end
     
     def initialize
       @node_number = 0
       @node_to_number_map = Hash.new do |map, node|
-        map[node] = @node_number
+        map[ node ] = @node_number
         @node_number += 1
         @node_number - 1
       end
     end
     
-    def to_dot(tree, adaptor = nil, tree_template = TREE_TEMPLATE,
-               edge_template = EDGE_TEMPLATE)
+    def to_dot( tree, adaptor = nil, tree_template = TREE_TEMPLATE,
+               edge_template = EDGE_TEMPLATE )
       adaptor ||= AST::CommonTreeAdaptor.new
       @node_number = 0
-      tree_template = Context.new(tree_template, :nodes => [], :edges => [])
+      tree_template = Context.new( tree_template, :nodes => [], :edges => [] )
       define_nodes( tree, adaptor, tree_template )
       
       @node_number = 0
@@ -114,28 +114,28 @@ module DOT
       return tree_template.to_s
     end
     
-    def define_nodes( tree, adaptor, tree_template, known_nodes = nil)
+    def define_nodes( tree, adaptor, tree_template, known_nodes = nil )
       known_nodes ||= Set.new
       tree.nil? and return
       n = adaptor.child_count( tree )
       n == 0 and return
       number = node_number( tree )
       unless known_nodes.include?( number )
-        parent_node_template = node_template_for(adaptor, child)
-        tree_template[:nodes] << parent_node_template
+        parent_node_template = node_template_for( adaptor, child )
+        tree_template[ :nodes ] << parent_node_template
         known_nodes.add( number )
       end
       
       n.times do |index|
         child = adaptor.child_of( tree, index )
         number = @node_to_number_map[ child ]
-        unless known_nodes.include?(number)
+        unless known_nodes.include?( number )
           node_template = node_template_for( adaptor, child )
-          tree_template[:nodes] << node_template
+          tree_template[ :nodes ] << node_template
           known_nodes.add( number )
         end
         
-        define_nodes(child, adaptor, tree_template, edge_template)
+        define_nodes( child, adaptor, tree_template, edge_template )
       end
     end
     
@@ -151,24 +151,24 @@ module DOT
         child = adaptor.child_of( tree, index )
         child_text = adaptor.text_of( child )
         child_name = 'n%i' % @node_to_number_map[ tree ]
-        edge_template = Context.new(edge_template,
+        edge_template = Context.new( edge_template,
           :parent => parent_name, :child => child_name,
           :parent_text => parent_text, :child_text => child_text
         )
-        tree_template[:edges] << edge_template
+        tree_template[ :edges ] << edge_template
         define_edges( child, adaptor, tree_template, edge_template )
       end
     end
     
-    def node_template_for(adaptor, tree)
+    def node_template_for( adaptor, tree )
       text = adaptor.text_of( tree )
-      node_template = Context.new(NODE_TEMPLATE)
+      node_template = Context.new( NODE_TEMPLATE )
       unique_name = 'n%i' % @node_to_number_map[ tree ]
-      node_template[:name] = unique_name
-      text and text = text.gsub(/"/, '\\"')
-      node_template[:text] = text
+      node_template[ :name ] = unique_name
+      text and text = text.gsub( /"/, '\\"' )
+      node_template[ :text ] = text
       return node_template
     end
   end
 end
-end
+end

data/lib/antlr3/error.rb

@@ -4,7 +4,7 @@
 =begin LICENSE
 
 [The "BSD licence"]
-Copyright (c) 2009 Kyle Yetter
+Copyright (c) 2009-2010 Kyle Yetter
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -117,21 +117,21 @@ class RecognitionError < StandardError
         @column = @input.column
       when AST::TreeNodeStream
         @symbol = @input.look
-        if @symbol.respond_to?(:line) and @symbol.respond_to?(:column)
+        if @symbol.respond_to?( :line ) and @symbol.respond_to?( :column )
           @line, @column = @symbol.line, @symbol.column
         else
           extract_from_node_stream( @input )
         end
       else
         @symbol = @input.look
-        if @symbol.respond_to?(:line) and @symbol.respond_to?(:column)
+        if @symbol.respond_to?( :line ) and @symbol.respond_to?( :column )
           @line, @column = @symbol.line, @symbol.column
-        elsif @input.respond_to?(:line) and @input.respond_to?(:column)
+        elsif @input.respond_to?( :line ) and @input.respond_to?( :column )
           @line, @column = @input.line, @input.column
         end
       end
     end
-    super(message)
+    super( message )
   end
   
   def approximate_line_info?
@@ -144,7 +144,7 @@ class RecognitionError < StandardError
       @symbol.type
     when AST::TreeNodeStream
       adaptor = @input.adaptor
-      return adaptor.type(@symbol)
+      return adaptor.type( @symbol )
     else
       return @symbol
     end
@@ -160,16 +160,16 @@ class RecognitionError < StandardError
   
 private
   
-  def extract_from_node_stream(nodes)
+  def extract_from_node_stream( nodes )
     adaptor = nodes.adaptor
-    payload = adaptor.token(@symbol)
+    payload = adaptor.token( @symbol )
     
     if payload
       @token = payload
       if payload.line <= 0
         i = -1
-        while prior_node = nodes.look(i)
-          prior_payload = adaptor.token(prior_node)
+        while prior_node = nodes.look( i )
+          prior_payload = adaptor.token( prior_node )
           if prior_payload and prior_payload.line > 0
             @line = prior_payload.line
             @column = prior_payload.column
@@ -182,10 +182,10 @@ private
         @line = payload.line
         @column = payload.column
       end
-    elsif @symbol.is_a?(AST::Tree)
+    elsif @symbol.is_a?( AST::Tree )
       @line = @symbol.line
       @column = @symbol.column
-      @symbol.is_a?(AST::CommonTree) and @token = @symbol.token
+      @symbol.is_a?( AST::CommonTree ) and @token = @symbol.token
     else
       type = adaptor.type( @symbol )
       text = adaptor.text( @symbol )
@@ -210,13 +210,14 @@ occurs when::
 
 class MismatchedToken < RecognitionError
   attr_reader :expecting
-  def initialize(expecting, input)
+  
+  def initialize( expecting, input )
     @expecting = expecting
-    super(input)
+    super( input )
   end
   
   def message
-    "%s: %p %p" % [self.class, unexpected_type, @expecting.inspect]
+    "%s: %p %p" % [ self.class, unexpected_type, @expecting.inspect ]
   end
 end
 
@@ -234,7 +235,7 @@ class UnwantedToken < MismatchedToken
   def message
     exp = @expecting == INVALID_TOKEN_TYPE ? '' : ", expected %p" % @expecting
     text = @symbol.text rescue nil
-    "%s: found=%p%s" % [self.class, text, exp]
+    "%s: found=%p%s" % [ self.class, text, exp ]
   end
 end
 
@@ -282,8 +283,8 @@ in ruby:
 
 class MissingToken < MismatchedToken
   attr_accessor :inserted
-  def initialize(expecting, input, inserted)
-    super(expecting, input)
+  def initialize( expecting, input, inserted )
+    super( expecting, input )
     @inserted = inserted
   end
   
@@ -294,7 +295,7 @@ class MissingToken < MismatchedToken
   def message
     if @inserted and @symbol
       "%s: inserted %p at %p" %
-        [self.class, @inserted, @symbol.text]
+        [ self.class, @inserted, @symbol.text ]
     else
       msg = self.class.to_s
       msg << ': at %p' % token.text unless @token.nil?
@@ -316,15 +317,15 @@ occurs when::
 
 class MismatchedRange < RecognitionError
   attr_accessor :min, :max
-  def initialize(min, max, input)
+  def initialize( min, max, input )
     @min = min
     @max = max
-    super(input)
+    super( input )
   end
   
   def message
     "%s: %p not in %p..%p" %
-      [self.class, unexpected_type, @min, @max]
+      [ self.class, unexpected_type, @min, @max ]
   end
 end
 
@@ -340,14 +341,14 @@ occurs when::
 
 class MismatchedSet < RecognitionError
   attr_accessor :expecting
-  def initialize(expecting, input)
-    super(input)
+  def initialize( expecting, input )
+    super( input )
     @expecting = expecting
   end
   
   def message
     "%s: %p not in %p" %
-      [self.class, unexpected_type, @expecting]
+      [ self.class, unexpected_type, @expecting ]
   end
 end
 
@@ -364,7 +365,7 @@ occurs when::
 class MismatchedNotSet < MismatchedSet
   def message
     '%s: %p != %p' %
-      [self.class, unexpected_type, @expecting]
+      [ self.class, unexpected_type, @expecting ]
   end
 end
 
@@ -394,16 +395,16 @@ current input does not appear to be part of any token specification.
 
 class NoViableAlternative < RecognitionError
   attr_accessor :grammar_decision_description, :decision_number, :state_number
-  def initialize(grammar_decision_description, decision_number, state_number, input)
+  def initialize( grammar_decision_description, decision_number, state_number, input )
     @grammar_decision_description = grammar_decision_description
     @decision_number = decision_number
     @state_number = state_number
-    super(input)
+    super( input )
   end
   
   def message
     '%s: %p != [%p]' %
-      [self.class, unexpected_type, @grammar_decision_description]
+      [ self.class, unexpected_type, @grammar_decision_description ]
   end
 end
 
@@ -438,13 +439,16 @@ now in ruby
 
 class EarlyExit < RecognitionError
   attr_accessor :decision_number
-  def initialize(decision_number, input)
+  
+  def initialize( decision_number, input )
     @decision_number = decision_number
-    super(input)
+    super( input )
   end
+  
   def message
     "The recognizer did not match anything for a (..)+ loop."
   end
+  
 end
 
 =begin rdoc ANTLR3::Error::FailedPredicate
@@ -459,14 +463,18 @@ occurs when::
 
 class FailedPredicate < RecognitionError
   attr_accessor :input, :rule_name, :predicate_text
-  def initialize(input, rule_name, predicate_text)
+  def initialize( input, rule_name, predicate_text )
     @rule_name = rule_name
     @predicate_text = predicate_text
-    super(input)
+    super( input )
+  end
+  
+  def inspect
+    '%s(%s, { %s }?)' % [ self.class.name, @rule_name, @predicate_text ]
   end
   
   def message
-    '%s(%s, { %s }?)' % [self.class.name, @rule_name, @predicate_text]
+    "rule #@rule_name failed predicate: { #@predicate_text }?"
   end
 end
 
@@ -483,14 +491,14 @@ occurs when::
 
 class MismatchedTreeNode < RecognitionError
   attr_accessor :expecting, :input
-  def initialize(expecting, input)
+  def initialize( expecting, input )
     @expecting = expecting
-    super(input)
+    super( input )
   end
   
   def message
     '%s: %p != %p' %
-      [self.class, unexpected_type, @expecting]
+      [ self.class, unexpected_type, @expecting ]
   end
 end
 
@@ -507,13 +515,13 @@ occurs when::
 
 class RewriteCardinalityError < StandardError
   attr_accessor :element_description
-  def initialize(element_description)
+  def initialize( element_description )
     @element_description = element_description
-    super(message)
+    super( message )
   end
   
   def message
-    "%s: %s" % [self.class, @element_description]
+    "%s: %s" % [ self.class, @element_description ]
   end
 end
 
@@ -529,8 +537,8 @@ occurs when::
 
 class RewriteEarlyExit < RewriteCardinalityError
   attr_accessor :element_description
-  def initialize(element_description = nil)
-    super(element_description)
+  def initialize( element_description = nil )
+    super( element_description )
   end
 end
 
@@ -562,17 +570,17 @@ situations that result in tree inconsistencies:
 =end
 
 class TreeInconsistency < StandardError
-  def self.failed_index_check!(expected, real)
-    new(
+  def self.failed_index_check!( expected, real )
+    new( 
       "%s: child indexes don't match -> expected %d found %d" %
-      [self, expected, real]
+      [ self, expected, real ]
     )
   end
   
-  def self.failed_parent_check!(expected, real)
-    new(
+  def self.failed_parent_check!( expected, real )
+    new( 
       "%s: parents don't match; expected %p found %p" %
-      [self, expected, real]
+      [ self, expected, real ]
     )
   end
   
@@ -583,56 +591,56 @@ end
 
 module_function
 
-def MismatchedToken(expecting, input = @input)
-  MismatchedToken.new(expecting, input)
+def MismatchedToken( expecting, input = @input )
+  MismatchedToken.new( expecting, input )
 end
 
-def UnwantedToken(expecting, input = @input)
-  UnwantedToken.new(expecting, input)
+def UnwantedToken( expecting, input = @input )
+  UnwantedToken.new( expecting, input )
 end
 
-def MissingToken(expecting, inserted, input = @input)
-  MissingToken.new(expecting, input, inserted)
+def MissingToken( expecting, inserted, input = @input )
+  MissingToken.new( expecting, input, inserted )
 end
 
-def MismatchedRange(min, max, input = @input)
-  MismatchedRange.new(min, max, input)
+def MismatchedRange( min, max, input = @input )
+  MismatchedRange.new( min, max, input )
 end
 
-def MismatchedSet(expecting, input = @input)
-  MismatchedSet.new(expecting, input)
+def MismatchedSet( expecting, input = @input )
+  MismatchedSet.new( expecting, input )
 end
 
-def MismatchedNotSet(expecting, input = @input)
-  MismatchedNotSet.new(expecting, input)
+def MismatchedNotSet( expecting, input = @input )
+  MismatchedNotSet.new( expecting, input )
 end
 
-def NoViableAlternative(description, decision_number, state_number, input = @input)
-  NoViableAlternative.new(description, decision_number, state_number, input)
+def NoViableAlternative( description, decision, state, input = @input )
+  NoViableAlternative.new( description, decision, state, input )
 end
 
-def EarlyExit(decision_number, input = @input)
-  EarlyExit.new(decision_number, input)
+def EarlyExit( decision, input = @input )
+  EarlyExit.new( decision, input )
 end
 
-def FailedPredicate(rule_name, predicate_text, input = @input)
-  FailedPredicate.new(input, rule_name, predicate_text)
+def FailedPredicate( rule, predicate, input = @input )
+  FailedPredicate.new( input, rule_name, predicate )
 end
 
-def MismatchedTreeNode(expecting, input = @input)
-  MismatchedTreeNode.new(expecting, input)
+def MismatchedTreeNode( expecting, input = @input )
+  MismatchedTreeNode.new( expecting, input )
 end
 
-def RewriteCardinalityError(element_description)
-  RewriteCardinalityError.new(element_description)
+def RewriteCardinalityError( element_description )
+  RewriteCardinalityError.new( element_description )
 end
 
-def RewriteEarlyExit(element_description = nil)
-  RewriteEarlyExit.new(element_description)
+def RewriteEarlyExit( element_description = nil )
+  RewriteEarlyExit.new( element_description )
 end
 
-def RewriteEmptyStream(element_description)
-  RewriteEmptyStream.new(element_description)
+def RewriteEmptyStream( element_description )
+  RewriteEmptyStream.new( element_description )
 end
 
 end
@@ -646,12 +654,11 @@ include Error
 =end
 
 class Bug < StandardError
-  def initialize(message = nil, *args)
+  def initialize( message = nil, *args )
     message = "something occurred that should not occur within unmodified, " <<
-              "ANTLR-generated source code: #{message}"
-    super(message, *args)
+              "ANTLR-generated source code: #{ message }"
+    super( message, *args )
   end
 end
 
 end
-