parse

# File lib/rexml/parsers/sax2parser.rb, line 85
                        def parse
                                @procs.each { |sym,match,block| block.call if sym == :start_document }
                                @listeners.each { |sym,match,block| 
                                        block.start_document if sym == :start_document or sym.nil?
                                }
                                root = context = []
                                while true
                                        event = @parser.pull
                                        case event[0]
                                        when :end_document
                                                handle( :end_document )
                                                break
          when :start_doctype
            handle( :doctype, *event[1..-1])
                                        when :end_doctype
                                                context = context[1]
                                        when :start_element
                                                @tag_stack.push(event[1])
                                                # find the observers for namespaces
                                                procs = get_procs( :start_prefix_mapping, event[1] )
                                                listeners = get_listeners( :start_prefix_mapping, event[1] )
                                                if procs or listeners
                                                        # break out the namespace declarations
                                                        # The attributes live in event[2]
                                                        event[2].each {|n, v| event[2][n] = @parser.normalize(v)}
                                                        nsdecl = event[2].find_all { |n, value| n =~ /^xmlns(:|$)/ }
                                                        nsdecl.collect! { |n, value| [ n[6..-1], value ] }
                                                        @namespace_stack.push({})
                                                        nsdecl.each do |n,v|
                                                                @namespace_stack[-1][n] = v
                                                                # notify observers of namespaces
                                                                procs.each { |ob| ob.call( n, v ) } if procs
                                                                listeners.each { |ob| ob.start_prefix_mapping(n, v) } if listeners
                                                        end
                                                end
                                                event[1] =~ Namespace::NAMESPLIT
                                                prefix = $1
                                                local = $2
                                                uri = get_namespace(prefix)
                                                # find the observers for start_element
                                                procs = get_procs( :start_element, event[1] )
                                                listeners = get_listeners( :start_element, event[1] )
                                                # notify observers
                                                procs.each { |ob| ob.call( uri, local, event[1], event[2] ) } if procs
                                                listeners.each { |ob| 
                                                        ob.start_element( uri, local, event[1], event[2] ) 
                                                } if listeners
                                        when :end_element
                                                @tag_stack.pop
                                                event[1] =~ Namespace::NAMESPLIT
                                                prefix = $1
                                                local = $2
                                                uri = get_namespace(prefix)
                                                # find the observers for start_element
                                                procs = get_procs( :end_element, event[1] )
                                                listeners = get_listeners( :end_element, event[1] )
                                                # notify observers
                                                procs.each { |ob| ob.call( uri, local, event[1] ) } if procs
                                                listeners.each { |ob| 
                                                        ob.end_element( uri, local, event[1] ) 
                                                } if listeners

                                                namespace_mapping = @namespace_stack.pop
                                                # find the observers for namespaces
                                                procs = get_procs( :end_prefix_mapping, event[1] )
                                                listeners = get_listeners( :end_prefix_mapping, event[1] )
                                                if procs or listeners
                                                        namespace_mapping.each do |prefix, uri|
                                                                # notify observers of namespaces
                                                                procs.each { |ob| ob.call( prefix ) } if procs
                                                                listeners.each { |ob| ob.end_prefix_mapping(prefix) } if listeners
                                                        end
                                                end
                                        when :text
            #normalized = @parser.normalize( event[1] )
            #handle( :characters, normalized )
            copy = event[1].clone
            @entities.each { |key, value| copy = copy.gsub("&#{key};", value) }
            copy.gsub!( Text::NUMERICENTITY ) {|m|
              m=$1
              m = "0#{m}" if m[0] == ?x
              [Integer(m)].pack('U*')
            }
            handle( :characters, copy )
          when :entitydecl
            @entities[ event[1] ] = event[2] if event.size == 3
                                                handle( *event )
                                        when :processing_instruction, :comment, :attlistdecl, 
                                                :elementdecl, :cdata, :notationdecl, :xmldecl
                                                handle( *event )
                                        end
          handle( :progress, @parser.position )
                                end
                        end