rubysl-rexml 1.0.0 → 2.0.1

data/lib/rexml/namespace.rb

@@ -1,47 +1,47 @@
 require 'rexml/xmltokens'
 
 module REXML
-	# Adds named attributes to an object.
-	module Namespace
-		# The name of the object, valid if set
-		attr_reader :name, :expanded_name
-		# The expanded name of the object, valid if name is set
-		attr_accessor :prefix
-		include XMLTokens
-		NAMESPLIT = /^(?:(#{NCNAME_STR}):)?(#{NCNAME_STR})/u
+  # Adds named attributes to an object.
+  module Namespace
+    # The name of the object, valid if set
+    attr_reader :name, :expanded_name
+    # The expanded name of the object, valid if name is set
+    attr_accessor :prefix
+    include XMLTokens
+    NAMESPLIT = /^(?:(#{NCNAME_STR}):)?(#{NCNAME_STR})/u
 
-		# Sets the name and the expanded name
-		def name=( name )
-			@expanded_name = name
-			name =~ NAMESPLIT
-			if $1
-				@prefix = $1
-			else
-				@prefix = ""
-				@namespace = ""
-			end
-			@name = $2
-		end
+    # Sets the name and the expanded name
+    def name=( name )
+      @expanded_name = name
+      name =~ NAMESPLIT
+      if $1
+        @prefix = $1
+      else
+        @prefix = ""
+        @namespace = ""
+      end
+      @name = $2
+    end
 
-		# Compares names optionally WITH namespaces
-		def has_name?( other, ns=nil )
-			if ns
-				return (namespace() == ns and name() == other)
-			elsif other.include? ":"
-				return fully_expanded_name == other
-			else
-				return name == other
-			end
-		end
+    # Compares names optionally WITH namespaces
+    def has_name?( other, ns=nil )
+      if ns
+        return (namespace() == ns and name() == other)
+      elsif other.include? ":"
+        return fully_expanded_name == other
+      else
+        return name == other
+      end
+    end
 
-		alias :local_name :name
+    alias :local_name :name
 
-		# Fully expand the name, even if the prefix wasn't specified in the
-		# source file.
-		def fully_expanded_name
-			ns = prefix
-			return "#{ns}:#@name" if ns.size > 0 
-			return @name
-		end
-	end
+    # Fully expand the name, even if the prefix wasn't specified in the
+    # source file.
+    def fully_expanded_name
+      ns = prefix
+      return "#{ns}:#@name" if ns.size > 0
+      return @name
+    end
+  end
 end

data/lib/rexml/node.rb

@@ -3,27 +3,27 @@ require "rexml/formatters/pretty"
 require "rexml/formatters/default"
 
 module REXML
-	# Represents a node in the tree.  Nodes are never encountered except as
-	# superclasses of other objects.  Nodes have siblings.
-	module Node
-		# @return the next sibling (nil if unset)
-		def next_sibling_node
-			return nil if @parent.nil?
-			@parent[ @parent.index(self) + 1 ]
-		end
+  # Represents a node in the tree.  Nodes are never encountered except as
+  # superclasses of other objects.  Nodes have siblings.
+  module Node
+    # @return the next sibling (nil if unset)
+    def next_sibling_node
+      return nil if @parent.nil?
+      @parent[ @parent.index(self) + 1 ]
+    end
 
-		# @return the previous sibling (nil if unset)
-		def previous_sibling_node
-			return nil if @parent.nil?
-			ind = @parent.index(self)
-			return nil if ind == 0
-			@parent[ ind - 1 ]
-		end
+    # @return the previous sibling (nil if unset)
+    def previous_sibling_node
+      return nil if @parent.nil?
+      ind = @parent.index(self)
+      return nil if ind == 0
+      @parent[ ind - 1 ]
+    end
 
     # indent::
     #   *DEPRECATED* This parameter is now ignored.  See the formatters in the
     #   REXML::Formatters package for changing the output style.
-		def to_s indent=nil
+    def to_s indent=nil
       unless indent.nil?
         Kernel.warn( "#{self.class.name}.to_s(indent) parameter is deprecated" )
         f = REXML::Formatters::Pretty.new( indent )
@@ -33,33 +33,33 @@ module REXML
         f.write( self, rv = "" )
       end
       return rv
-		end
+    end
 
-		def indent to, ind
- 			if @parent and @parent.context and not @parent.context[:indentstyle].nil? then
- 				indentstyle = @parent.context[:indentstyle]
- 			else
- 				indentstyle = '  '
- 			end
- 			to << indentstyle*ind unless ind<1
-		end
+    def indent to, ind
+                        if @parent and @parent.context and not @parent.context[:indentstyle].nil? then
+                                indentstyle = @parent.context[:indentstyle]
+                        else
+                                indentstyle = '  '
+                        end
+                        to << indentstyle*ind unless ind<1
+    end
 
-		def parent?
-			false;
-		end
+    def parent?
+      false;
+    end
 
 
-		# Visit all subnodes of +self+ recursively
-		def each_recursive(&block) # :yields: node
-			self.elements.each {|node|
-				block.call(node)
-				node.each_recursive(&block)
-			}
-		end
+    # Visit all subnodes of +self+ recursively
+    def each_recursive(&block) # :yields: node
+      self.elements.each {|node|
+        block.call(node)
+        node.each_recursive(&block)
+      }
+    end
 
-		# Find (and return) first subnode (recursively) for which the block 
+    # Find (and return) first subnode (recursively) for which the block
     # evaluates to true. Returns +nil+ if none was found.
-		def find_first_recursive(&block) # :yields: node
+    def find_first_recursive(&block) # :yields: node
       each_recursive {|node|
         return node if block.call(node)
       }
@@ -71,5 +71,5 @@ module REXML
     def index_in_parent
       parent.index(self)+1
     end
-	end
+  end
 end

data/lib/rexml/output.rb

@@ -1,24 +1,29 @@
 require 'rexml/encoding'
 
 module REXML
-	class Output
-		include Encoding
-    
+  class Output
+    include Encoding
+
     attr_reader :encoding
 
-		def initialize real_IO, encd="iso-8859-1"
-			@output = real_IO
-			self.encoding = encd
+    def initialize real_IO, encd="iso-8859-1"
+      @output = real_IO
+      self.encoding = encd
+
+      @to_utf = encoding != 'UTF-8'
 
-			@to_utf = encd == UTF_8 ? false : true
-		end
+      if encoding == "UTF-16"
+        @output << "\ufeff".encode("UTF-16BE")
+        self.encoding = "UTF-16BE"
+      end
+    end
 
-		def <<( content )
-			@output << (@to_utf ? self.encode(content) : content)
-		end
+    def <<( content )
+      @output << (@to_utf ? self.encode(content) : content)
+    end
 
     def to_s
       "Output[#{encoding}]"
     end
-	end
+  end
 end

data/lib/rexml/parent.rb

@@ -6,14 +6,14 @@ module REXML
   # object.
   class Parent < Child
     include Enumerable
-    
+
     # Constructor
     # @param parent if supplied, will be set as the parent of this object
     def initialize parent=nil
       super(parent)
       @children = []
     end
-    
+
     def add( object )
       #puts "PARENT GOTS #{size} CHILDREN"
       object.parent = self
@@ -21,47 +21,48 @@ module REXML
       #puts "PARENT NOW GOTS #{size} CHILDREN"
       object
     end
-    
+
     alias :push :add
     alias :<< :push
-    
+
     def unshift( object )
       object.parent = self
       @children.unshift object
     end
-    
+
     def delete( object )
       found = false
       @children.delete_if {|c| c.equal?(object) and found = true }
       object.parent = nil if found
+      found ? object : nil
     end
-    
+
     def each(&block)
       @children.each(&block)
     end
-    
+
     def delete_if( &block )
       @children.delete_if(&block)
     end
-    
+
     def delete_at( index )
       @children.delete_at index
     end
-    
+
     def each_index( &block )
       @children.each_index(&block)
     end
-    
+
     # Fetches a child at a given index
     # @param index the Integer index of the child to fetch
     def []( index )
       @children[index]
     end
-    
+
     alias :each_child :each
-    
-    
-    
+
+
+
     # Set an index entry.  See Array.[]=
     # @param index the index of the element to set
     # @param opt either the object to set, or an Integer length
@@ -71,7 +72,7 @@ module REXML
       args[-1].parent = self
       @children[*args[0..-2]] = args[-1]
     end
-    
+
     # Inserts an child before another child
     # @param child1 this is either an xpath or an Element.  If an Element,
     # child2 will be inserted before child1 in the child list of the parent.
@@ -91,7 +92,7 @@ module REXML
       end
       self
     end
-    
+
     # Inserts an child after another child
     # @param child1 this is either an xpath or an Element.  If an Element,
     # child2 will be inserted after child1 in the child list of the parent.
@@ -111,11 +112,11 @@ module REXML
       end
       self
     end
-    
+
     def to_a
       @children.dup
     end
-    
+
     # Fetches the index of a given child
     # @param child the child to get the index of
     # @return the index of the child, or nil if the object is not a child
@@ -125,24 +126,24 @@ module REXML
       @children.find { |i| count += 1 ; i.hash == child.hash }
       count
     end
-    
+
     # @return the number of children of this parent
     def size
       @children.size
     end
-    
+
     alias :length :size
-    
+
     # Replaces one child with another, making sure the nodelist is correct
     # @param to_replace the child to replace (must be a Child)
-    # @param replacement the child to insert into the nodelist (must be a 
+    # @param replacement the child to insert into the nodelist (must be a
     # Child)
     def replace_child( to_replace, replacement )
       @children.map! {|c| c.equal?( to_replace ) ? replacement : c }
       to_replace.parent = nil
       replacement.parent = self
     end
-    
+
     # Deeply clones this object.  This creates a complete duplicate of this
     # Parent, including all descendants.
     def deep_clone
@@ -156,9 +157,9 @@ module REXML
       end
       cl
     end
-    
+
     alias :children :to_a
-    
+
     def parent?
       true
     end

data/lib/rexml/parseexception.rb

@@ -28,9 +28,9 @@ module REXML
         err << "\nLine: #{line}\n"
         err << "Position: #{position}\n"
         err << "Last 80 unconsumed characters:\n"
-        err << @source.buffer[0..80].gsub(/\n/, ' ')
+        err << @source.buffer[0..80].force_encoding("ASCII-8BIT").gsub(/\n/, ' ')
       end
-      
+
       err
     end
 
@@ -40,12 +40,12 @@ module REXML
     end
 
     def line
-      @source.current_line[2] if @source and defined? @source.current_line and 
+      @source.current_line[2] if @source and defined? @source.current_line and
       @source.current_line
     end
 
     def context
       @source.current_line
     end
-  end  
+  end
 end

data/lib/rexml/parsers/baseparser.rb

@@ -25,24 +25,31 @@ module REXML
     #
     # Nat Price gave me some good ideas for the API.
     class BaseParser
-      NCNAME_STR= '[\w:][\-\w\d.]*'
+      LETTER = '[:alpha:]'
+      DIGIT = '[:digit:]'
+
+      COMBININGCHAR = '' # TODO
+      EXTENDER = ''      # TODO
+
+      NCNAME_STR= "[#{LETTER}_:][-[:alnum:]._:#{COMBININGCHAR}#{EXTENDER}]*"
       NAME_STR= "(?:(#{NCNAME_STR}):)?(#{NCNAME_STR})"
       UNAME_STR= "(?:#{NCNAME_STR}:)?#{NCNAME_STR}"
 
-      NAMECHAR = '[\-\w\d\.:]'
+      NAMECHAR = '[\-\w\.:]'
       NAME = "([\\w:]#{NAMECHAR}*)"
       NMTOKEN = "(?:#{NAMECHAR})+"
       NMTOKENS = "#{NMTOKEN}(\\s+#{NMTOKEN})*"
-      REFERENCE = "(?:&#{NAME};|&#\\d+;|&#x[0-9a-fA-F]+;)"
+      REFERENCE = "&(?:#{NAME};|#\\d+;|#x[0-9a-fA-F]+;)"
       REFERENCE_RE = /#{REFERENCE}/
 
       DOCTYPE_START = /\A\s*<!DOCTYPE\s/um
+      DOCTYPE_END = /\A\s*\]\s*>/um
       DOCTYPE_PATTERN = /\s*<!DOCTYPE\s+(.*?)(\[|>)/um
       ATTRIBUTE_PATTERN = /\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\4/um
       COMMENT_START = /\A<!--/u
       COMMENT_PATTERN = /<!--(.*?)-->/um
       CDATA_START = /\A<!\[CDATA\[/u
-      CDATA_END = /^\s*\]\s*>/um
+      CDATA_END = /\A\s*\]\s*>/um
       CDATA_PATTERN = /<!\[CDATA\[(.*?)\]\]>/um
       XMLDECL_START = /\A<\?xml\s/u;
       XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>/um
@@ -53,13 +60,13 @@ module REXML
 
       VERSION = /\bversion\s*=\s*["'](.*?)['"]/um
       ENCODING = /\bencoding\s*=\s*["'](.*?)['"]/um
-      STANDALONE = /\bstandalone\s*=\s["'](.*?)['"]/um
+      STANDALONE = /\bstandalone\s*=\s*["'](.*?)['"]/um
 
-      ENTITY_START = /^\s*<!ENTITY/
+      ENTITY_START = /\A\s*<!ENTITY/
       IDENTITY = /^([!\*\w\-]+)(\s+#{NCNAME_STR})?(\s+["'](.*?)['"])?(\s+['"](.*?)["'])?/u
-      ELEMENTDECL_START = /^\s*<!ELEMENT/um
-      ELEMENTDECL_PATTERN = /^\s*(<!ELEMENT.*?)>/um
-      SYSTEMENTITY = /^\s*(%.*?;)\s*$/um
+      ELEMENTDECL_START = /\A\s*<!ELEMENT/um
+      ELEMENTDECL_PATTERN = /\A\s*(<!ELEMENT.*?)>/um
+      SYSTEMENTITY = /\A\s*(%.*?;)\s*$/um
       ENUMERATION = "\\(\\s*#{NMTOKEN}(?:\\s*\\|\\s*#{NMTOKEN})*\\s*\\)"
       NOTATIONTYPE = "NOTATION\\s+\\(\\s*#{NAME}(?:\\s*\\|\\s*#{NAME})*\\s*\\)"
       ENUMERATEDTYPE = "(?:(?:#{NOTATIONTYPE})|(?:#{ENUMERATION}))"
@@ -68,11 +75,11 @@ module REXML
       DEFAULTDECL = "(#REQUIRED|#IMPLIED|(?:(#FIXED\\s+)?#{ATTVALUE}))"
       ATTDEF = "\\s+#{NAME}\\s+#{ATTTYPE}\\s+#{DEFAULTDECL}"
       ATTDEF_RE = /#{ATTDEF}/
-      ATTLISTDECL_START = /^\s*<!ATTLIST/um
-      ATTLISTDECL_PATTERN = /^\s*<!ATTLIST\s+#{NAME}(?:#{ATTDEF})*\s*>/um
-      NOTATIONDECL_START = /^\s*<!NOTATION/um
-      PUBLIC = /^\s*<!NOTATION\s+(\w[\-\w]*)\s+(PUBLIC)\s+(["'])(.*?)\3(?:\s+(["'])(.*?)\5)?\s*>/um
-      SYSTEM = /^\s*<!NOTATION\s+(\w[\-\w]*)\s+(SYSTEM)\s+(["'])(.*?)\3\s*>/um
+      ATTLISTDECL_START = /\A\s*<!ATTLIST/um
+      ATTLISTDECL_PATTERN = /\A\s*<!ATTLIST\s+#{NAME}(?:#{ATTDEF})*\s*>/um
+      NOTATIONDECL_START = /\A\s*<!NOTATION/um
+      PUBLIC = /\A\s*<!NOTATION\s+(\w[\-\w]*)\s+(PUBLIC)\s+(["'])(.*?)\3(?:\s+(["'])(.*?)\5)?\s*>/um
+      SYSTEM = /\A\s*<!NOTATION\s+(\w[\-\w]*)\s+(SYSTEM)\s+(["'])(.*?)\3\s*>/um
 
       TEXT_PATTERN = /\A([^<]*)/um
 
@@ -92,11 +99,11 @@ module REXML
 
       EREFERENCE = /&(?!#{NAME};)/
 
-      DEFAULT_ENTITIES = { 
-        'gt' => [/&gt;/, '&gt;', '>', />/], 
-        'lt' => [/&lt;/, '&lt;', '<', /</], 
-        'quot' => [/&quot;/, '&quot;', '"', /"/], 
-        "apos" => [/&apos;/, "&apos;", "'", /'/] 
+      DEFAULT_ENTITIES = {
+        'gt' => [/&gt;/, '&gt;', '>', />/],
+        'lt' => [/&lt;/, '&lt;', '<', /</],
+        'quot' => [/&quot;/, '&quot;', '"', /"/],
+        "apos" => [/&apos;/, "&apos;", "'", /'/]
       }
 
 
@@ -108,22 +115,10 @@ module REXML
 
       def initialize( source )
         self.stream = source
+        @listeners = []
       end
 
       def add_listener( listener )
-        if !defined?(@listeners) or !@listeners
-          @listeners = []
-          instance_eval <<-EOL
-            alias :_old_pull :pull
-            def pull
-              event = _old_pull
-              @listeners.each do |listener|
-                listener.receive event
-              end
-              event
-            end
-          EOL
-        end
         @listeners << listener
       end
 
@@ -167,9 +162,9 @@ module REXML
       # Peek at the +depth+ event in the stack.  The first element on the stack
       # is at depth 0.  If +depth+ is -1, will parse to the end of the input
       # stream and return the last event, which is always :end_document.
-      # Be aware that this causes the stream to be parsed up to the +depth+ 
-      # event, so you can effectively pre-parse the entire document (pull the 
-      # entire thing into memory) using this method.  
+      # Be aware that this causes the stream to be parsed up to the +depth+
+      # event, so you can effectively pre-parse the entire document (pull the
+      # entire thing into memory) using this method.
       def peek depth=0
         raise %Q[Illegal argument "#{depth}"] if depth < -1
         temp = []
@@ -186,6 +181,14 @@ module REXML
 
       # Returns the next event.  This is a +PullEvent+ object.
       def pull
+        pull_event.tap do |event|
+          @listeners.each do |listener|
+            listener.receive event
+          end
+        end
+      end
+
+      def pull_event
         if @closed
           x, @closed = @closed, nil
           return [ :end_element, x ]
@@ -210,7 +213,12 @@ module REXML
             version = version[1] unless version.nil?
             encoding = ENCODING.match(results)
             encoding = encoding[1] unless encoding.nil?
-            @source.encoding = encoding
+            if need_source_encoding_update?(encoding)
+              @source.encoding = encoding
+            end
+            if encoding.nil? and /\AUTF-16(?:BE|LE)\z/i =~ @source.encoding
+              encoding = "UTF-16"
+            end
             standalone = STANDALONE.match(results)
             standalone = standalone[1] unless standalone.nil?
             return [ :xmldecl, version, encoding, standalone ]
@@ -242,12 +250,15 @@ module REXML
             @document_status = :after_doctype
             @source.read if @source.buffer.size<2
             md = @source.match(/\s*/um, true)
+            if @source.encoding == "UTF-8"
+              @source.buffer.force_encoding(::Encoding::UTF_8)
+            end
           end
         end
         if @document_status == :in_doctype
           md = @source.match(/\s*(.*?>)/um)
           case md[1]
-          when SYSTEMENTITY 
+          when SYSTEMENTITY
             match = @source.match( SYSTEMENTITY, true )[1]
             return [ :externalentity, match ]
 
@@ -272,7 +283,8 @@ module REXML
               # External reference
               match[3] = match[3][1..-2] # PUBID
               match[4] = match[4][1..-2] # HREF
-              # match is [ :entity, name, PUBLIC, pubid, href ]
+              match.delete_at(5) if match.size > 5 # Chop out NDATA decl
+              # match is [ :entity, name, PUBLIC, pubid, href(, ndata)? ]
             else
               match[2] = match[2][1..-2]
               match.pop if match.size == 4
@@ -312,9 +324,9 @@ module REXML
               raise REXML::ParseException.new( "error parsing notation: no matching pattern", @source )
             end
             return [ :notationdecl, *vals ]
-          when CDATA_END
+          when DOCTYPE_END
             @document_status = :after_doctype
-            @source.match( CDATA_END, true )
+            @source.match( DOCTYPE_END, true )
             return [ :end_doctype ]
           end
         end
@@ -326,7 +338,7 @@ module REXML
               #md = @source.match_to_consume( '>', CLOSE_MATCH)
               md = @source.match( CLOSE_MATCH, true )
               raise REXML::ParseException.new( "Missing end tag for "+
-                "'#{last_tag}' (got \"#{md[1]}\")", 
+                "'#{last_tag}' (got \"#{md[1]}\")",
                 @source) unless last_tag == md[1]
               return [ :end_element, last_tag ]
             elsif @source.buffer[1] == ?!
@@ -335,6 +347,12 @@ module REXML
               raise REXML::ParseException.new("Malformed node", @source) unless md
               if md[0][2] == ?-
                 md = @source.match( COMMENT_PATTERN, true )
+
+                case md[1]
+                when /--/, /-\z/
+                  raise REXML::ParseException.new("Malformed comment", @source)
+                end
+
                 return [ :comment, md[1] ] if md
               else
                 md = @source.match( CDATA_PATTERN, true )
@@ -353,7 +371,7 @@ module REXML
               unless md
                 # Check for missing attribute quotes
                 raise REXML::ParseException.new("missing attribute quote", @source) if @source.match(MISSING_ATTRIBUTE_QUOTES )
-                raise REXML::ParseException.new("malformed XML: missing tag start", @source) 
+                raise REXML::ParseException.new("malformed XML: missing tag start", @source)
               end
               attributes = {}
               prefixes = Set.new
@@ -362,27 +380,33 @@ module REXML
               if md[4].size > 0
                 attrs = md[4].scan( ATTRIBUTE_PATTERN )
                 raise REXML::ParseException.new( "error parsing attributes: [#{attrs.join ', '}], excess = \"#$'\"", @source) if $' and $'.strip.size > 0
-                attrs.each { |a,b,c,d,e| 
-                  if b == "xmlns"
-                    if c == "xml"
-                      if d != "http://www.w3.org/XML/1998/namespace"
+                attrs.each do |attr_name, prefix, local_part, quote, value|
+                  if prefix == "xmlns"
+                    if local_part == "xml"
+                      if value != "http://www.w3.org/XML/1998/namespace"
                         msg = "The 'xml' prefix must not be bound to any other namespace "+
                         "(http://www.w3.org/TR/REC-xml-names/#ns-decl)"
                         raise REXML::ParseException.new( msg, @source, self )
                       end
-                    elsif c == "xmlns"
+                    elsif local_part == "xmlns"
                       msg = "The 'xmlns' prefix must not be declared "+
                       "(http://www.w3.org/TR/REC-xml-names/#ns-decl)"
                       raise REXML::ParseException.new( msg, @source, self)
                     end
-                    curr_ns << c
-                  elsif b
-                    prefixes << b unless b == "xml"
+                    curr_ns << local_part
+                  elsif prefix
+                    prefixes << prefix unless prefix == "xml"
+                  end
+
+                  if attributes.has_key?(attr_name)
+                    msg = "Duplicate attribute #{attr_name.inspect}"
+                    raise REXML::ParseException.new(msg, @source, self)
                   end
-                  attributes[a] = e 
-                }
+
+                  attributes[attr_name] = value
+                end
               end
-        
+
               # Verify that all of the prefixes have been defined
               for prefix in prefixes
                 unless @nsstack.find{|k| k.member?(prefix)}
@@ -419,6 +443,7 @@ module REXML
         end
         return [ :dummy ]
       end
+      private :pull_event
 
       def entity( reference, entities )
         value = nil
@@ -436,7 +461,7 @@ module REXML
         # Doing it like this rather than in a loop improves the speed
         copy.gsub!( EREFERENCE, '&amp;' )
         entities.each do |key, value|
-          copy.gsub!( value, "&#{key};" ) unless entity_filter and 
+          copy.gsub!( value, "&#{key};" ) unless entity_filter and
                                       entity_filter.include?(entity)
         end if entities
         copy.gsub!( EREFERENCE, '&amp;' )
@@ -452,7 +477,7 @@ module REXML
         rv.gsub!( /\r\n?/, "\n" )
         matches = rv.scan( REFERENCE_RE )
         return rv if matches.size == 0
-        rv.gsub!( /&#0*((?:\d+)|(?:x[a-fA-F0-9]+));/ ) {|m|
+        rv.gsub!( /&#0*((?:\d+)|(?:x[a-fA-F0-9]+));/ ) {
           m=$1
           m = "0#{m}" if m[0] == ?x
           [Integer(m)].pack('U*')
@@ -465,19 +490,23 @@ module REXML
               if entity_value
                 re = /&#{entity_reference};/
                 rv.gsub!( re, entity_value )
+              else
+                er = DEFAULT_ENTITIES[entity_reference]
+                rv.gsub!( er[0], er[2] ) if er
               end
             end
           end
-          matches.each do |entity_reference|
-            unless filter and filter.include?(entity_reference)
-              er = DEFAULT_ENTITIES[entity_reference]
-              rv.gsub!( er[0], er[2] ) if er
-            end
-          end
           rv.gsub!( /&amp;/, '&' )
         end
         rv
       end
+
+      private
+      def need_source_encoding_update?(xml_declaration_encoding)
+        return false if xml_declaration_encoding.nil?
+        return false if /\AUTF-16\z/i =~ xml_declaration_encoding
+        true
+      end
     end
   end
 end