parse (REXML::Parsers::SAX2Parser)

    # File temp/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 |ns_prefix, ns_uri|
                                                                    # notify observers of namespaces
                                                                    procs.each { |ob| ob.call( ns_prefix ) } if procs
                                                                    listeners.each { |ob| ob.end_prefix_mapping(ns_prefix) } if listeners
                                                            end
                                                    end
                                            when :text
                #normalized = @parser.normalize( event[1] )
                #handle( :characters, normalized )
                copy = event[1].clone

                esub = proc { |match|
                  if @entities.has_key?($1)
                    @entities[$1].gsub(Text::REFERENCE, &esub)
                  else
                    match
                  end
                }

                copy.gsub!( Text::REFERENCE, &esub )
                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