← Back to branch summary

~ubuntu-branches/ubuntu/precise/libxml-libxml-perl/precise-security

« back to all changes in this revision

Viewing changes to lib/XML/LibXML/SAX/Parser.pm

  • Committer: Bazaar Package Importer
  • Author(s): Ardo van Rangelrooij
  • Date: 2002-02-16 22:33:54 UTC
  • Revision ID: james.westby@ubuntu.com-20020216223354-8zq3wlngmkrdexns
Tags: upstream-1.31
Import upstream version 1.31

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/XML/LibXML/SAX/Parser.pm
 
1
# $Id: Parser.pm,v 1.1 2001/11/14 10:59:58 matt Exp $
 
2
 
 
3
package XML::LibXML::SAX::Parser;
 
4
 
 
5
use strict;
 
6
use vars qw($VERSION @ISA);
 
7
 
 
8
use XML::LibXML;
 
9
use XML::SAX::Base;
 
10
 
 
11
$VERSION = '1.00';
 
12
@ISA = ('XML::SAX::Base');
 
13
 
 
14
sub _parse_characterstream {
 
15
    my ($self, $fh, $options) = @_;
 
16
    die "parsing a characterstream is not supported at this time";
 
17
}
 
18
 
 
19
sub _parse_bytestream {
 
20
    my ($self, $fh, $options) = @_;
 
21
    my $parser = XML::LibXML->new();
 
22
    my $doc = $parser->parse_fh($fh);
 
23
    $self->generate($doc);
 
24
}
 
25
 
 
26
sub _parse_string {
 
27
    my ($self, $str, $options) = @_;
 
28
    my $parser = XML::LibXML->new();
 
29
    my $doc = $parser->parse_string($str);
 
30
    $self->generate($doc);
 
31
}
 
32
 
 
33
sub _parse_systemid {
 
34
    my ($self, $sysid, $options) = @_;
 
35
    my $parser = XML::LibXML->new();
 
36
    my $doc = $parser->parse_file($sysid);
 
37
    $self->generate($doc);
 
38
}
 
39
 
 
40
sub generate {
 
41
    my $self = shift;
 
42
    my ($node) = @_;
 
43
    
 
44
    $self->start_document({});
 
45
    
 
46
    $self->process_node($node);
 
47
    
 
48
    $self->end_document({});
 
49
}
 
50
 
 
51
sub process_node {
 
52
    my ($self, $node) = @_;
 
53
    
 
54
    my $node_type = $node->getType();
 
55
    if ($node_type == XML_COMMENT_NODE) {
 
56
        $self->comment( { Data => $node->getData } );
 
57
    }
 
58
    elsif ($node_type == XML_TEXT_NODE || $node_type == XML_CDATA_SECTION_NODE) {
 
59
        # warn($node->getData . "\n");
 
60
        $self->characters( { Data => $node->getData } );
 
61
    }
 
62
    elsif ($node_type == XML_ELEMENT_NODE) {
 
63
        # warn("<" . $node->getName . ">\n");
 
64
        $self->process_element($node);
 
65
        # warn("</" . $node->getName . ">\n");
 
66
    }
 
67
    elsif ($node_type == XML_ENTITY_REF_NODE) {
 
68
        foreach my $kid ($node->getChildnodes) {
 
69
            # warn("child of entity ref: " . $kid->getType() . " called: " . $kid->getName . "\n");
 
70
            $self->process_node($kid);
 
71
        }
 
72
    }
 
73
    elsif ($node_type == XML_DOCUMENT_NODE) {
 
74
        # just get root element. Ignore other cruft.
 
75
        foreach my $kid ($node->getChildnodes) {
 
76
            if ($kid->getType() == XML_ELEMENT_NODE) {
 
77
                $self->process_element($kid);
 
78
                last;
 
79
            }
 
80
        }
 
81
    }
 
82
    else {
 
83
        warn("unsupported node type: $node_type");
 
84
    }
 
85
}
 
86
 
 
87
sub process_element {
 
88
    my ($self, $element) = @_;
 
89
    
 
90
    my $attribs;
 
91
    
 
92
    foreach my $attr ($element->getAttributes) {
 
93
        my $key;
 
94
        if (my $ns = $attr->getNamespaceURI) {
 
95
            $key = "{$ns}".$attr->getLocalName;
 
96
        }
 
97
        else {
 
98
            $key = $attr->getLocalName;
 
99
        }
 
100
        $attribs->{$key} =
 
101
                {
 
102
                    Name => $attr->getName,
 
103
                    Value => $attr->getData,
 
104
                    NamespaceURI => $attr->getNamespaceURI,
 
105
                    Prefix => $attr->getPrefix,
 
106
                    LocalName => $attr->getLocalName,
 
107
                };
 
108
    }
 
109
    
 
110
    my $node = {
 
111
        Name => $element->getName,
 
112
        Attributes => $attribs,
 
113
        NamespaceURI => $element->getNamespaceURI,
 
114
        Prefix => $element->getPrefix,
 
115
        LocalName => $element->getLocalName,
 
116
    };
 
117
    
 
118
    $self->start_element($node);
 
119
    
 
120
    foreach my $child ($element->getChildnodes) {
 
121
        $self->process_node($child);
 
122
    }
 
123
    
 
124
    $self->end_element($node);
 
125
}
 
126
 
 
127
1;
 
128
 
 
129
__END__
 
130
 
 
131
=head1 NAME
 
132
 
 
133
XML::LibXML::SAX::Parser - LibXML DOM based SAX Parser
 
134
 
 
135
=head1 SYNOPSIS
 
136
 
 
137
  my $handler = MySAXHandler->new();
 
138
  my $parser = XML::LibXML::SAX::Parser->new(Handler => $handler);
 
139
  $parser->parse_uri("foo.xml");
 
140
 
 
141
=head1 DESCRIPTION
 
142
 
 
143
This class allows you to generate SAX2 events using LibXML. Note
 
144
that this is B<not> a stream based parser, instead it parses
 
145
documents into a DOM and traverses the DOM tree. The reason being
 
146
that libxml2's stream based parsing is extremely primitive,
 
147
and would require an extreme amount of work to allow SAX2
 
148
parsing in a stream manner.
 
149
 
 
150
=head1 API
 
151
 
 
152
The API is exactly the same as any other Perl SAX2 parser. See
 
153
L<XML::SAX::Intro> for details.
 
154
 
 
155
Aside from the regular parsing methods, you can access the
 
156
DOM tree traverser directly, using the generate() method:
 
157
 
 
158
  my $parser = XML::LibXML::SAX::Parser->new(...);
 
159
  $parser->generate($dom_tree);
 
160
 
 
161
This is useful for serializing DOM trees, for example that
 
162
you might have done prior processing on, or that you have
 
163
as a result of XSLT processing.
 
164
 
 
165
=cut