blib/lib/Uplug/IO/XML.pm untested

filter: Statementstmt 0.0% 0 / 493 Branchbran 0.0% 0 / 208 Conditioncond 0.0% 0 / 36 MC/DCmcdc 0.0% 0 / 24 Subroutinesub 0.0% 0 / 54 Podpod 0.0% 0 / 42 totaltotal 0.0% 0 / 857 CC 105 SCAR 39.6
CC
105
Cov
0%
printXML
210.0
init
90.0
select
90.0
CRAP 52.5
1 #-*-perl-*-
2 #####################################################################
3 # Copyright (C) 2004 Jörg Tiedemann <joerg@stp.ling.uu.se>
4 #
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 2 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 #####################################################################
19 #
20 # XML
21 #
22 #####################################################################
23 #
24 # Note: XML without encoding-specification will be treated as latin1!
25 # (look at readFromHandle)
26 #
27  
28 package Uplug::IO::XML;
29  
30 use strict;
31  
32 use vars qw(@ISA $PARSERENCODING $USESGGREP $SGGREP);
33 use vars qw(%DEFAULTOPTIONS);
34 use XML::Parser;
35 use XML::Simple;
36  
37 # use our own copy of XML::Writer
38 # (the latest version seems to break some things ...)
39 use Uplug::XML::Writer;
40  
41 use Uplug::Encoding;
42 use Uplug::IO::Text;
43 use Uplug::Data;
44  
45  
46 @ISA = qw( Uplug::IO::Text );
47 $PARSERENCODING='utf-8';
48 $USESGGREP=0;
49  
50 sub __find_sggrep{
51 if ($_=`which sggrep 2>/dev/null`){
52 chomp;$SGGREP=$_;
53 use autouse 'Data::Dumper';
54 $Data::Dumper::Indent=0;
55 $Data::Dumper::Terse=0;
56 $Data::Dumper::Purity=1;
57 }
58 }
59  
60 my $IGNOREWARNINGS=0;
61 my $DEFAULTROOTTAG='document';
62  
63 # stream options and their default values!!
64 #
65 # encoding: physical encoding in the file
66 # InternalEncoding: encoding within UPLUG
67 #
68  
69 %DEFAULTOPTIONS = (
70 'root' => '.*', # sub-tree root: any tag!
71 'encoding' => 'utf-8',
72 # 'attributes' => 1, # save attribute values
73 # 'delimiter' => ' ', # default delimiter
74 'REMOVESPACES' => 1,
75 'EXPANDBASICENT' => 1, # expand &lt; %gt; $amp;
76 # 'DocRootTag' => 'document',
77 );
78  
79 1;
80  
81 sub new{
82 my $class=shift;
83 my $self=$class->SUPER::new($class);
84 foreach (keys %DEFAULTOPTIONS){
85 $self->setOption($_,$DEFAULTOPTIONS{$_});
86 }
87 # &Uplug::IO::AddHash2Hash($self->{StreamOptions},\%DEFAULTOPTIONS);
88 return $self;
89 }
90  
91  
92 sub init{
93 my $self = shift;
94 my $options = $_[0];
95 if (ref($options) ne 'HASH'){$options={};}
96 # if (not defined $options->{DocRootTag}){
97 # $options->{DocRootTag}='.*';
98 # }
99 if ($self->SUPER::init($options)){
100 if (defined $options->{DocRootTag}){
101 if (not defined $self->{StreamOptions}->{DocRoot}){
102 $self->{StreamOptions}->{DocRoot}={};
103 }
104 }
105 if (defined $options->{DocHeaderTag}){
106 if (not defined $self->{StreamOptions}->{DocHeader}){
107 $self->{StreamOptions}->{DocHeader}={};
108 }
109 }
110 if (defined $options->{DocBodyTag}){
111 if (not defined $self->{StreamOptions}->{DocBody}){
112 $self->{StreamOptions}->{DocBody}={};
113 }
114 }
115 return 1;
116 }
117 return 0;
118 }
119  
120 #---------------------------------------------------------------------------
121  
122 sub open{
123 my $self = shift;
124 $self->{AccessMode} = shift;
125 my $HeaderHash = $_[0];
126  
127 my $ret=$self->SUPER::open($self->{AccessMode},$HeaderHash);
128  
129 if ($self->{AccessMode} eq 'read'){
130 if (defined $self->{FileHandle}){ # read data in binary mode!!!!
131 binmode($self->{FileHandle}); # XML::Parser takes care of the
132 } # internal encoding!
133 }
134 else{
135 if (not defined $self->{XmlHandle}){
136 $self->{XmlHandle}=
137 new Uplug::XML::Writer(
138 DATA_MODE => 1,
139 DATA_INDENT => 1,
140 UNSAFE => 1,
141 OUTPUT => $self->{'FileHandle'});
142 }
143 }
144  
145 return $ret;
146 }
147  
148  
149 sub close{
150 my $self=shift;
151 my $ret=$self->SUPER::close();
152 delete $self->{XmlParser};
153 delete $self->{XmlHandle};
154 return $ret;
155 }
156  
157  
158 sub read{
159 my $self=shift;
160 my $data=shift;
161 if (not ref($data)){return 0;}
162 my $root=shift;
163 if (not $root){$root=$self->option('root');}
164 $data->init();
165 # $data->setDocRootTag($self->option('DocRootTag'));
166  
167 my $fh=$self->{FileHandle};
168 $data->setHeader(undef);
169  
170 my $MakeIndex = $self->option('MAKESUBTREEINDEX');
171 my $FilePos = tell($fh);
172 my $NewSubtree = 1;
173  
174 while ($_=$self->readFromHandle($fh)){
175 my $ret = $self->parseXML($data,$_,$root);
176 if ($MakeIndex){
177 if (($self->{XmlHandle}->{SubTreeStarted} || $ret) && $NewSubtree){
178 my $id = $self->{XmlHandle}->{SubTreeAttr}->{id};
179 $self->saveSubtreePosition($id,$FilePos);
180 $NewSubtree = 0;
181 }
182 if ($self->{XmlHandle}->{SubTreeEnded}){
183 $NewSubtree = 1;
184 }
185 }
186 return 1 if ($ret);
187 $FilePos = tell($fh);
188 }
189 if ($data->header){
190 return 1;
191 }
192 return 0;
193 }
194  
195  
196 ##########################################################################
197 # saveSubtreePosition and gotoSubtreePosition
198 #
199 # cache the byte position of each subtree in a DBM file
200 # (this is quite ad hoc but helps to speed up searching
201 # for subtrees with select and IDs)
202  
203  
204 BEGIN { @AnyDBM_File::ISA=qw(DB_File GDBM_File SDBM_File NDBM_File ODBM_File) }
205 use AnyDBM_File;
206 use POSIX;
207  
208 sub saveSubtreePosition{
209 my $self = shift;
210 my ($id,$pos) = @_;
211  
212 my $file=$self->option('file');
213 if (-e $file){
214 if (not defined $self->{SUBTREEINDEX}){
215 if (not $self->{DBH}=tie %{$self->{SUBTREEINDEX}},
216 'AnyDBM_File',
217 $file.'.idx',
218 O_RDWR|O_CREAT,0644){
219 # print STDERR "problems!";
220 return 0;
221 }
222 }
223 $self->{SUBTREEINDEX}->{$id} = $pos;
224 # print STDERR "save $id .. $pos\n";
225 }
226 }
227  
228 sub gotoSubtreePosition{
229 my $self = shift;
230 my ($id,$pos) = @_;
231  
232 my $file=$self->option('file');
233 if (-e $file){
234 if (not defined $self->{SUBTREEINDEX}){
235 if (not $self->{DBH}=tie %{$self->{SUBTREEINDEX}},
236 'AnyDBM_File',
237 $file.'.idx',
238 O_RDWR,0644){
239 ## print STDERR "problems!";
240 ## try to open in read-only mode!
241 if (not $self->{DBH}=tie %{$self->{SUBTREEINDEX}},
242 'AnyDBM_File',
243 $file.'.idx',
244 O_RDONLY,0444){
245 # print STDERR "problems!";
246 delete $self->{SUBTREEINDEX};
247 return 0;
248 }
249 }
250 }
251 }
252 if (my $pos = $self->{SUBTREEINDEX}->{$id}){
253 if (my $fh=$self->{FileHandle}){
254 seek $fh,$pos,0;
255 # print STDERR "goto $id .. $pos\n";
256 return 1;
257 }
258 }
259 return 0;
260 }
261  
262  
263 ##########################################################################
264 # select .... select subtrees in the XML file
265 #
266 # * use sggrep if defined
267 # * use byte-position cache if it exists
268 # * read through the file sequentially otherwise
269 #
270  
271 sub select{
272 my $self=shift;
273 my ($data,$pattern) = @_;
274 my $file=$self->option('file');
275 if (-e $file){
276 if (ref($pattern) eq 'HASH'){
277 if (defined $pattern->{id}){
278 if ($self->gotoSubtreePosition($pattern->{id})){
279 if (scalar keys %{$pattern} == 1){
280 # print STDERR "reading only ...\n";
281 return $self->read(@_);
282 }
283 }
284 }
285 }
286  
287 if ($USESGGREP){
288 &__find_sggrep() if (not defined $SGGREP);
289 if (defined $SGGREP){
290 return $self->sggrepSelect($file,@_);
291 }
292 }
293 }
294 return $self->SUPER::select(@_);
295 }
296  
297  
298 sub sggrepSelect{
299 my $self=shift;
300 my ($file,$data,$pattern,$attr,$operator)=@_;
301 $data->init();
302 my $patternkey=Dumper($pattern);
303  
304 my $ret=$self->readSggrepResult($data,$patternkey);
305 if ($ret<0){
306 my $root=$self->option('root');
307 my $query=&MakeSggrepQuery($root,$pattern);
308 my $subquery=&MakeSggrepSubQuery($pattern);
309 my $regexp=&MakeSggrepRegExp($pattern);
310  
311 my $result;
312 if ($file=~/\.gz$/){
313 $result=`gzip -cd $file | $SGGREP -r $query $subquery $regexp 2>/dev/null`;
314 }
315 else{
316 $result=`$SGGREP -r $query $subquery $regexp <$file 2>/dev/null`;
317 }
318 if ($?){
319 print STDERR "something went wrong when executing sggrep!\n";
320 print STDERR "command: $SGGREP -r $query $subquery $regexp <$file";
321 return $self->SUPER::select($data,$pattern,$attr,$operator);
322 }
323 my @lines=split(/\n/,$result);
324 my @header=();
325 while (@lines and $lines[0]!~/^\<$root/){push(@header,shift @lines);}
326 unshift (@lines,'<sggrep>');
327 push (@lines,'</sggrep>');
328 @{$self->{SGGREPRESULT}->{$patternkey}}=@lines;
329 return $self->readSggrepResult($data,$patternkey);
330 }
331 return $ret;
332 }
333  
334 #------------
335 # read sggrep results
336 # return 1 + data if sggrep result is found and ok
337 # return 0 if sggrep result is found but empty
338 # return -1 if the query pattern is new
339  
340 sub readSggrepResult{
341 my $self=shift;
342 my $data=shift;
343 my $key=shift;
344 if (ref($self->{SGGREPRESULT}) ne 'HASH'){
345 $self->{SGGREPRESULT}={};
346 }
347 if (ref($self->{SGGREPRESULT}->{$key}) eq 'ARRAY'){
348 my $fh=$self->{FileHandle};
349 $self->{FileHandle}=$self->{SGGREPRESULT}->{$key};
350 if ($self->read($data)){
351 $self->{FileHandle}=$fh;
352 return $self->Uplug::IO::read($data);
353 }
354 $self->{FileHandle}=$fh;
355 delete $self->{SGGREPRESULT}->{$key};
356 return 0;
357 }
358 return -1;
359 }
360  
361 sub MakeSggrepQuery{
362 my $root=shift;
363 my $pattern=shift;
364 my $query=".*/$root";
365 my %attr=();
366 if (ref($pattern) eq 'HASH'){
367 foreach (keys %{$pattern}){
368 if ($pattern->{$_}!~/\//){
369 $attr{$_}=$pattern->{$_};
370 }
371 }
372 }
373 if (keys %attr){
374 $query.='[';
375 foreach (keys %attr){
376 $query.="$_\=\"$attr{$_}\" ";
377 }
378 chop $query;
379 $query.=']';
380 }
381 $query="'$query'";
382 return $query;
383 }
384  
385 sub MakeSggrepSubQuery{ # doesn't do anything yet
386 my $pattern=shift;
387 return '';
388 }
389  
390 sub MakeSggrepRegExp{ # doesn't do anything yet
391 my $pattern=shift;
392 return '';
393 }
394  
395  
396 sub readFromHandle{
397 my $self=shift;
398 my $fh=shift;
399  
400 if (ref($fh) eq 'ARRAY'){
401 return shift @{$fh};
402 }
403  
404 my $InputDel=$/; # save old input delimiter
405 $/='>'; # set delimiter to '>'
406  
407 #-------------------------------------
408 # don't change the encoding! just read the original string!
409 # (the XML-parser changes everything to UTF-8!)
410 # (don't do 'my $content=$self->SUPER::readFromHandle(@_);')
411  
412 my $content=<$fh>;
413 $/=$InputDel; # restore old input delimiter
414  
415 #------------------------------------------------
416 # fixing a bug in the PLUG corpus:
417 # set the default encoding (to 'iso-8859-1')
418 # if not specified in the xml declaration
419  
420 if ($content=~/\<\?xml\s/){
421 if ($content!~/encoding/s){
422 $content=~s/\?\>/ encoding="iso-8859-1"\?\>/s;
423 }
424 }
425 return $content;
426 }
427  
428  
429  
430 #-------------------------------------------------------------------
431 # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
432 #
433  
434 sub write{
435 my $self=shift;
436 my $data=shift;
437  
438 $self->Uplug::IO::write($data);
439  
440 my $fh=$self->{FileHandle};
441 if (not $self->{StreamOptions}->{SkipDataHeader}){
442 my $before=$data->header;
443 if (defined $before){
444 $self->writeToHandle($fh,$before);
445 }
446 }
447  
448 $self->printXML($fh,$data->root()); # print XML-node!
449 # $self->writeToHandle($fh,$data->toXML);
450  
451 if (not $self->{StreamOptions}->{SkipDataTail}){
452 my $after=$data->tail;
453 if (defined $after){
454 $self->writeToHandle($fh,$after);
455 }
456 }
457 return 1;
458 }
459  
460 sub readheader{
461 my $self=shift;
462  
463 if (defined $self->{StreamOptions}->{DocHeaderTag}){
464 $self->{StreamOptions}->{DocHeader}={};
465 my $data=Uplug::Data->new();
466 # $data->setDocRoot($self->{StreamHeader}->{DocRootTag});
467 $self->read($data,$self->{StreamOptions}->{DocHeaderTag});
468 my $attr=$data->attribute();
469 $self->addheader($attr);
470 # $self->{StreamHeader}->{DocRootTag}=$data->DocRootTag;
471 }
472 elsif (ref($self->{FileHandle})){
473 my $fh=$self->{FileHandle};
474 my $root=shift;
475 if (not $root){$root=$self->option('root');}
476 my $data=Uplug::Data->new();
477 binmode($fh);
478 while ($_=$self->readFromHandle($fh)){
479 # print STDERR "\n header: $_";
480 my $ret = $self->parseXML($data,$_,$root);
481 if ($self->{XmlHandle}->{NewDoc}){last;}
482 # if (defined $self->{XmlHandle}->{XmlProlog}){last;}
483 }
484 }
485 }
486  
487 sub writeheader{
488 my $self=shift;
489 if (not defined $self->{XmlHandle}){
490 $self->{XmlHandle}= new Uplug::XML::Writer(
491 DATA_MODE => 1,
492 DATA_INDENT => 1,
493 UNSAFE => 1,
494 # NEWLINES => 1,
495 OUTPUT => $self->{'FileHandle'});
496 }
497 $self->{XmlHandle}->xmlDecl($self->{StreamOptions}->{encoding});
498 if (defined $self->{StreamOptions}->{DTDname}){
499 # print STDERR "$self->{StreamOptions}->{DTDname}\n";
500 # print STDERR "$self->{StreamOptions}->{DTDpublicID}\n";
501 # print STDERR "$self->{StreamOptions}->{DTDsystemID}\n";
502 $self->{XmlHandle}->doctype($self->{StreamOptions}->{DTDname},
503 $self->{StreamOptions}->{DTDpublicID},
504 $self->{StreamOptions}->{DTDsystemID});
505 }
506 my $ret;
507 my $fh=$self->{'FileHandle'};
508 if (defined $self->{StreamHeader}->{BeforeDocRoot}){
509 if ($self->{StreamHeader}->{BeforeDocRoot}=~/\S/s){
510 $self->writeToHandle($fh,$self->{StreamHeader}->{BeforeDocRoot});
511 }
512 }
513 if (defined $self->{StreamOptions}->{DocRootTag}){
514 $ret*=$self->OpenTag($self->{StreamOptions}->{DocRootTag},
515 $self->{StreamOptions}->{DocRoot});
516 }
517  
518 my $string=&XMLout($self->{StreamOptions}->{DocHeader},
519 keyattr => ['id'],
520 rootname => $self->{StreamOptions}->{DocHeaderTag});
521 if ($string=~/\S/s){
522 $self->writeToHandle($fh,$string);
523 }
524  
525 if (defined $self->{StreamOptions}->{DocBodyTag}){
526 $ret*=$self->OpenTag($self->{StreamOptions}->{DocBodyTag},
527 $self->{StreamOptions}->{DocBody});
528 }
529 return $ret;
530 }
531  
532  
533 sub writetail{
534 my $self=shift;
535 $self->CloseAllTags;
536 $self->{XmlHandle}->end();
537 }
538  
539  
540  
541  
542  
543 #------------------------------------------------------------------------
544  
545 sub keepSpaces{$_[0]->setOption('REMOVESPACES',0);}
546 sub removeSpaces{$_[0]->setOption('REMOVESPACES',1);}
547  
548  
549 sub CompileTagREs{
550 my $self=shift;
551 foreach my $t ('DocRootTag','SubTreeRoot','DocBodyTag'){
552 if (defined $self->{XmlHandle}->{$t}){
553 $self->{XmlHandle}->{$t.'RE'}=qr/^($self->{XmlHandle}->{$t})$/;
554 }
555 }
556 }
557  
558 sub parseXML{
559 my $self=shift;
560 my ($data,$xml,$root)=@_;
561  
562 if ($root and ($root ne $self->{SubTreeRoot})){
563 $self->{SubTreeRoot}=$root;
564 $self->CompileTagREs;
565 }
566  
567 if (not ref($self->{XmlParser})){
568 $self->{XmlParser}=
569 new XML::Parser(Handlers => {Start => \&XmlTagStart,
570 End => \&XmlTagEnd,
571 Default => \&XmlChar,
572 XMLDecl => \&XmlDecl,
573 # Doctype => \&XmlDoctype
574 },);
575 $self->{XmlHandle}=$self->{XmlParser}->parse_start;
576 $self->{XmlHandle}->{XmlProlog}='';
577 #
578 # set some parameters for the parser:
579 #
580 $self->{XmlHandle}->{REMOVESPACES}=$self->option('REMOVESPACES');
581 $self->{XmlHandle}->{EXPANDBASICENT}=$self->option('EXPANDBASICENT');
582 $self->{XmlHandle}->{SubTreeRoot}=$self->option('root');
583 $self->{XmlHandle}->{DocRootTag}=$self->option('DocRootTag');
584 $self->{XmlHandle}->{DocBodyTag}=$self->option('DocBodyTag');
585 $self->CompileTagREs;
586 }
587  
588 $self->{XmlHandle}->{XmlData}=$data;
589  
590 if (not $self->{XmlHandle}->{LastNode}){ # --> new data!
591 delete $self->{XmlHandle}->{BeforeSubTree}; # delete header
592 delete $self->{XmlHandle}->{SubTreeEnded}; # reset subtree flag
593 $self->{XmlHandle}->{LastNode}=1;
594 }
595  
596 eval { $self->{XmlHandle}->parse_more($xml); }; # call xml-parser
597  
598 if ($@){ # and catch possible errors
599 if (not $IGNOREWARNINGS){ # print warnings
600 warn $@;
601 print STDERR $xml;
602 }
603 $data->setHeader($self->{XmlHandle}->{BeforeSubTree}.$xml);
604 $self->{XmlHandle}->{SubTreeEnded}=undef;
605 $self->{XmlHandle}=$self->{XmlParser}->parse_start; # re-start
606 my $ParseStr=$self->{XmlHandle}->{XmlProlog}; # XML parsern!
607 eval { $self->{XmlHandle}->parse_more($ParseStr); };
608 return -1; # return error!
609 }
610 if ($self->{XmlHandle}->{REMOVESPACES}){
611 $self->{XmlHandle}->{BeforeSubTree}=~s/(\S)\s*$/$1/s;
612 $self->{XmlHandle}->{BeforeSubTree}=~s/^\s*(\S)/$1/s;
613 }
614 $data->setHeader($self->{XmlHandle}->{BeforeSubTree});
615 if ($self->{XmlHandle}->{SubTreeEnded}){ # complete SubTree
616 delete $self->{XmlHandle}->{LastNode};
617 delete $self->{XmlHandle}->{SubTreeEnded};
618 delete $self->{XmlHandle}->{BeforeSubTree};
619 delete $self->{XmlHandle}->{SubTreeString};
620 return 1;
621 }
622 return 0; # incomplete!
623 }
624  
625  
626  
627 #---------------------------------------------------------------------------
628 # subroutine-handles for the XML-parser
629 #
630  
631 sub XmlTagStart{
632 my ($p,$e,%a)=@_;
633  
634 #--------------------------------------------------
635 # document root tags are parsed ... but ignored
636 #--------------------------------------------------
637 if ((defined $p->{DocRootTag}) and # if DocRootTag is specified
638 ($e=~/$p->{DocRootTagRE}/)){ # and the current tag matches
639 $p->{BeforeSubTree}=''; # --> this is the doc root tag
640 $p->{DocRootTag}=$e;
641 $p->{DocRootTagRE}=qr/^($p->{DocRootTag})$/;
642 $p->{NewDoc}=1; # --> the beginning of a new doc!
643 %{$p->{DocRoot}}=%a;
644 return;
645 }
646 if ((not defined $p->{DocRootTag}) and # DocRootTag is not specified and
647 (not $p->{NewDoc})){ # no doc-root-tag is parsed yet:
648 $p->{BeforeSubTree}.=$p->recognized_string;
649 $p->{NewDoc}=1; # --> the beginning of a new doc!
650 %{$p->{DocRoot}}=%a;
651 return;
652 }
653 #--------------------------------------------------
654 # a new subtree starts!
655 #--------------------------------------------------
656 if ($e=~/$p->{SubTreeRootRE}/){
657 $p->{SubTreeStarted}=$e;
658 $p->{SubTreeEnded}=0;
659 if ($p->{SubTreeString}){ # check previous data
660 $p->{BeforeSubTree}.=$p->{SubTreeString};
661 $p->{SubTreeString}=undef;
662 # $p->{XmlData}=Uplug::Data::Node->new($p->{XmlData}->label,\%a);
663 # $p->{LastNode}=$p->{XmlData};
664 }
665 $p->{XmlData}->init($e,\%a);
666 $p->{LastNode}=$p->{XmlData}->root;
667 $p->{SubTreeString}.=$p->recognized_string();
668 %{$p->{SubTreeAttr}}=%a;
669 }
670  
671 elsif ($p->{SubTreeStarted}){
672  
673 #--------------------------------------------------
674 # we are inside a valid subtree!
675 #--------------------------------------------------
676  
677 $p->{LastNode}=
678 $p->{XmlData}->addNode($p->{LastNode},$e,\%a);
679 $p->{SubTreeString}.=$p->recognized_string();
680 }
681  
682 #--------------------------------------------------
683 # still before a sub-tree
684 #--------------------------------------------------
685  
686 else{
687 if ((defined $p->{DocBodyTagRE}) and ($e=~/$p->{DocBodyTagRE}/)){
688 $p->{DocBodyTag}=$e;
689 $p->{DocBodyTagRE}=qr/^($p->{DocBodyTag})$/;
690 $p->{NewBody}=1;
691 %{$p->{DocBody}}=%a;
692 }
693 $p->{BeforeSubTree}.=$p->recognized_string;
694 }
695 }
696  
697 sub XmlTagEnd{
698 my ($p,$e)=@_;
699 #--------------------------------------------------
700 # document root tags are parsed ... but ignored
701 #--------------------------------------------------
702 if ((defined $p->{DocRootTagRE}) and ($e=~/$p->{DocRootTagRE}/)){
703 delete $p->{NewDoc};
704 return;
705 }
706 if ($p->{SubTreeStarted}){
707 if (ref($p->{LastNode})){
708 $p->{LastNode}=
709 $p->{XmlData}->parent($p->{LastNode});
710 }
711 }
712 else{
713 $p->{BeforeSubTree}.=$p->recognized_string;
714 }
715 #--------------------------------------------------
716 # the subtree ended!
717 #--------------------------------------------------
718 if (($e=~/$p->{SubTreeRootRE}/) and
719 ($p->{SubTreeStarted} eq $e)){
720 $p->{XmlData}->setLabel($e);
721 $p->{SubTreeEnded}=$e;
722 $p->{SubTreeStarted}=0;
723 }
724 }
725  
726  
727 sub XmlChar{
728 my ($p,$c)=@_;
729  
730  
731 #--------------------------------------------------
732 # inside a subtree -> save the string
733 #--------------------------------------------------
734 if ($p->{SubTreeStarted}){
735 if (($c!~/\S/) and $p->{REMOVESPACES}){
736 return;
737 }
738 if ($p->{EXPANDBASICENT}){
739 $c=~s/\&gt\;/\>/gis;
740 $c=~s/\&lt\;/\</gis;
741 $c=~s/\&amp\;/\&/gis;
742 $c=~s/\&apos\;/\'/gis;
743 $c=~s/\&d?quot\;/\"/gis;
744 }
745  
746 $p->{XmlData}->addContent($p->{LastNode},$c); # add new content!
747 # $p->{LastNode}->addTextNode($c);
748 # $p->{LastNode}->addContent($c);
749 }
750 #--------------------------------------------------
751 # not inside?! -> save string as header
752 #--------------------------------------------------
753 else{
754 $p->{BeforeSubTree}.=$c;
755 }
756 }
757  
758 sub XmlDecl{
759 my ($p,$v,$e,$s)=@_;
760  
761 $p->{XmlProlog}=$p->original_string;
762 $p->{XmlEncoding}=$e;
763 $p->{XmlVersion}=$v;
764 }
765  
766 #sub XmlDoctype{
767 # my ($p,$name,$sysid,$publid,$internal)=@_;
768 # my $ll;
769 #}
770  
771  
772  
773  
774  
775  
776 #------------------------------------
777 # links to the SubTree-parser
778 #------------------------------------
779 # information from the XML SubTree parser:
780 # XmlProlog: xml declaration (and more?)
781 # SubTreeHeader: everything before SubTreeRoot
782 # SubTreeRootTag: XML-tag of current sub-tree
783 # LastDocRootTag: document root tag
784 # LastDocBodyTag: document body tag
785 # DocRootAttr: document root attributes
786 # DocBodyAttr: document body attributes
787 # NewDocRoot: 1 --> new document root
788 # NewDocBody: 1 --> new document body
789  
790 sub XmlProlog{return $_[0]->{XmlHandle}->{XmlProlog};}
791 sub SubTreeHeader{return $_[0]->{XmlHandle}->{BeforeSubTree};}
792 sub SubTreeRootTag{return $_[0]->{SubTreeRootTag};}
793 sub LastDocRootTag{return $_[0]->{XmlHandle}->{DocRootTag};}
794 sub LastBodyRootTag{return $_[0]->{XmlHandle}->{DocBodyTag};}
795 sub DocRootAttr{return $_[0]->{XmlHandle}->{DocRoot};}
796 sub DocBodyAttr{return $_[0]->{XmlHandle}->{DocBody};}
797 sub NewDocRoot{
798 my $self=shift;
799 if ($self->{XmlHandle}->{NewDoc}){
800 $self->{XmlHandle}->{NewDoc}=0;
801 return 1;
802 }
803 return 0;
804 }
805 sub NewDocBody{
806 my $self=shift;
807 if ($self->{XmlHandle}->{NewBody}){
808 $self->{XmlHandle}->{NewBody}=0;
809 return 1;
810 }
811 return 0;
812 }
813  
814  
815  
816  
817  
818  
819  
820  
821 sub printXML{
822 my $self=shift;
823 my $fh=shift;
824 my $node=shift;
825 my $writer=shift;
826  
827 my $internal=$self->getInternalEncoding();
828 my $external=$self->getExternalEncoding();
829 my $rmSpaces=$self->option('REMOVESPACES');
830  
831 if (not defined $node){return undef;}
832  
833 if (not ref($fh)){$fh=*STDOUT;}
834 if (not $writer){
835 if (not $self->{XmlWriter}){
836 $self->{XmlWriter}=
837 new Uplug::XML::Writer(
838 DATA_MODE => $rmSpaces,
839 DATA_INDENT => $rmSpaces,
840 UNSAFE => $rmSpaces,
841 OUTPUT => $fh,
842 );
843 }
844 $writer=$self->{XmlWriter};
845 }
846  
847 if (not ref($node)){next;}
848 elsif ($node->isTextNode){
849 my $str=$node->text;
850 if ($rmSpaces and $node!~/\S/){next;}
851 if ($internal ne $external){
852 $str=&Uplug::Encoding::convert($str,$internal,$external);
853 # $str=&Uplug::Encoding::encode($str,$external,$internal);
854 }
855 $writer->characters($str);
856 }
857 else{
858 my $attr=$node->attributes();
859 my $name=$node->getNodeName();
860 if (not $node->hasChildNodes()){
861 if (ref($attr) eq 'HASH'){
862 if ($internal ne $external){
863 &Uplug::Encoding::encodeArray($attr,$internal,$external);
864 }
865 $writer->emptyTag($name,%{$attr});
866 }
867 else{
868 $writer->emptyTag($name);
869 }
870 }
871 else{
872 if (ref($attr) eq 'HASH'){
873 if ($internal ne $external){
874 &Uplug::Encoding::encodeArray($attr,$internal,$external);
875 }
876 $writer->startTag($name,%{$attr});
877 }
878 else{
879 $writer->startTag($name);
880 }
881  
882 foreach my $n ($node->children()){
883 $self->printXML($fh,$n,$writer);
884 }
885  
886 $writer->endTag($name);
887 }
888 }
889  
890  
891 }
892  
893  
894 sub prettyPrintXML{
895 my $self=shift;
896 return $self->printXML(@_);
897 }
898  
899  
900  
901  
902  
903  
904 sub OpenTag{
905 my ($self,$tag,$attr)=@_;
906 if (ref($attr) eq 'HASH'){
907 $self->{XmlHandle}->startTag($tag,%{$attr});
908 }
909 else{
910 $self->{XmlHandle}->startTag($tag);
911 }
912 push (@{$self->{OpenTagStack}},$tag);
913 }
914  
915 sub CloseTag{
916 my ($self,$tag)=@_;
917 if (not defined $self->{OpenTagStack}){
918 return 0;
919 }
920 if (not $tag){
921 $tag=$self->{OpenTagStack}->[-1];
922 }
923 while ((@{$self->{OpenTagStack}}) and
924 ($self->{OpenTagStack}->[-1] ne $tag)){
925 $self->CloseTag($self->{OpenTagStack}->[-1]);
926 }
927 if ($self->{OpenTagStack}->[-1] eq $tag){
928 pop @{$self->{OpenTagStack}};
929 $self->{XmlHandle}->endTag($tag);
930 return 1;
931 }
932 return 0;
933 }
934  
935 sub CloseAllTags{
936 my ($self)=@_;
937 if (defined $self->{OpenTagStack}){
938 while (@{$self->{OpenTagStack}}){
939 $self->CloseTag;
940 }
941 }
942 }
943