1 package XML::SAX::Base;

     2 

     3 # version 0.10 - Kip Hampton <khampton@totalcinema.com>

     4 # version 0.13 - Robin Berjon <robin@knowscape.com>

     5 # version 0.15 - Kip Hampton <khampton@totalcinema.com>

     6 # version 0.17 - Kip Hampton <khampton@totalcinema.com>

     7 # version 0.19 - Kip Hampton <khampton@totalcinema.com>

     8 # version 0.21 - Kip Hampton <khampton@totalcinema.com>

     9 # version 0.22 - Robin Berjon <robin@knowscape.com>

    10 # version 0.23 - Matt Sergeant <matt@sergeant.org>

    11 # version 0.24 - Robin Berjon <robin@knowscape.com>

    12 # version 0.25 - Kip Hampton <khampton@totalcinema.com>

    13 # version 1.00 - Kip Hampton <khampton@totalcinema.com>

    14 # version 1.01 - Kip Hampton <khampton@totalcinema.com>

    15 # version 1.02 - Robin Berjon <robin@knowscape.com>

    16 # version 1.03 - Matt Sergeant <matt@sergeant.org>

    17 # version 1.04 - Kip Hampton <khampton@totalcinema.com>

    18 

    19 #-----------------------------------------------------#

    20 # STOP!!!!!

    21 #

    22 # This file is generated by the 'Makefile.PL' file

    23 # that ships with the XML::SAX distribution.

    24 # If you need to make changes, patch that file NOT

    25 # this one.

    26 #-----------------------------------------------------#

    27 

    28 use strict;

    29 use vars qw($VERSION);

    30 use XML::SAX::Exception qw();

    31 

    32 $VERSION = '1.04';

    33 

    34 sub notation_decl {

    35     my $self = shift;

    36     if (defined $self->{Methods}->{'notation_decl'}) {

    37         $self->{Methods}->{'notation_decl'}->(@_);

    38     }

    39     else {

    40         my $method;

    41         my $callbacks;

    42         if (exists $self->{ParseOptions}) {

    43             $callbacks = $self->{ParseOptions};

    44         }

    45         else {

    46             $callbacks = $self;

    47         }

    48         if (0) { # dummy to make elsif's below compile

    49         }

    50         elsif (defined $callbacks->{'DTDHandler'} and $method = $callbacks->{'DTDHandler'}->can('notation_decl') ) {

    51             my $handler = $callbacks->{'DTDHandler'};

    52             $self->{Methods}->{'notation_decl'} = sub { $method->($handler, @_) };

    53             return $method->($handler, @_);

    54         }

    55         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('notation_decl') ) {

    56             my $handler = $callbacks->{'Handler'};

    57             $self->{Methods}->{'notation_decl'} = sub { $method->($handler, @_) };

    58             return $method->($handler, @_);

    59         }

    60         elsif (defined $callbacks->{'DTDHandler'} 

    61         	and $callbacks->{'DTDHandler'}->can('AUTOLOAD')

    62         	and $callbacks->{'DTDHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

    63         	)

    64         {

    65             my $res = eval { $callbacks->{'DTDHandler'}->notation_decl(@_) };

    66             if ($@) {

    67                 die $@;

    68             }

    69             else {

    70                 # I think there's a buggette here...

    71                 # if the first call throws an exception, we don't set it up right.

    72                 # Not fatal, but we might want to address it.

    73                 my $handler = $callbacks->{'DTDHandler'};

    74                 $self->{Methods}->{'notation_decl'} = sub { $handler->notation_decl(@_) };

    75             }

    76             return $res;

    77         }

    78         elsif (defined $callbacks->{'Handler'} 

    79         	and $callbacks->{'Handler'}->can('AUTOLOAD')

    80         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

    81         	)

    82         {

    83             my $res = eval { $callbacks->{'Handler'}->notation_decl(@_) };

    84             if ($@) {

    85                 die $@;

    86             }

    87             else {

    88                 # I think there's a buggette here...

    89                 # if the first call throws an exception, we don't set it up right.

    90                 # Not fatal, but we might want to address it.

    91                 my $handler = $callbacks->{'Handler'};

    92                 $self->{Methods}->{'notation_decl'} = sub { $handler->notation_decl(@_) };

    93             }

    94             return $res;

    95         }

    96         else {

    97             $self->{Methods}->{'notation_decl'} = sub { };

    98         }

    99     }

   100 

   101 }

   102 

   103 sub resolve_entity {

   104     my $self = shift;

   105     if (defined $self->{Methods}->{'resolve_entity'}) {

   106         $self->{Methods}->{'resolve_entity'}->(@_);

   107     }

   108     else {

   109         my $method;

   110         my $callbacks;

   111         if (exists $self->{ParseOptions}) {

   112             $callbacks = $self->{ParseOptions};

   113         }

   114         else {

   115             $callbacks = $self;

   116         }

   117         if (0) { # dummy to make elsif's below compile

   118         }

   119         elsif (defined $callbacks->{'EntityResolver'} and $method = $callbacks->{'EntityResolver'}->can('resolve_entity') ) {

   120             my $handler = $callbacks->{'EntityResolver'};

   121             $self->{Methods}->{'resolve_entity'} = sub { $method->($handler, @_) };

   122             return $method->($handler, @_);

   123         }

   124         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('resolve_entity') ) {

   125             my $handler = $callbacks->{'Handler'};

   126             $self->{Methods}->{'resolve_entity'} = sub { $method->($handler, @_) };

   127             return $method->($handler, @_);

   128         }

   129         elsif (defined $callbacks->{'EntityResolver'} 

   130         	and $callbacks->{'EntityResolver'}->can('AUTOLOAD')

   131         	and $callbacks->{'EntityResolver'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   132         	)

   133         {

   134             my $res = eval { $callbacks->{'EntityResolver'}->resolve_entity(@_) };

   135             if ($@) {

   136                 die $@;

   137             }

   138             else {

   139                 # I think there's a buggette here...

   140                 # if the first call throws an exception, we don't set it up right.

   141                 # Not fatal, but we might want to address it.

   142                 my $handler = $callbacks->{'EntityResolver'};

   143                 $self->{Methods}->{'resolve_entity'} = sub { $handler->resolve_entity(@_) };

   144             }

   145             return $res;

   146         }

   147         elsif (defined $callbacks->{'Handler'} 

   148         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   149         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   150         	)

   151         {

   152             my $res = eval { $callbacks->{'Handler'}->resolve_entity(@_) };

   153             if ($@) {

   154                 die $@;

   155             }

   156             else {

   157                 # I think there's a buggette here...

   158                 # if the first call throws an exception, we don't set it up right.

   159                 # Not fatal, but we might want to address it.

   160                 my $handler = $callbacks->{'Handler'};

   161                 $self->{Methods}->{'resolve_entity'} = sub { $handler->resolve_entity(@_) };

   162             }

   163             return $res;

   164         }

   165         else {

   166             $self->{Methods}->{'resolve_entity'} = sub { };

   167         }

   168     }

   169 

   170 }

   171 

   172 sub start_cdata {

   173     my $self = shift;

   174     if (defined $self->{Methods}->{'start_cdata'}) {

   175         $self->{Methods}->{'start_cdata'}->(@_);

   176     }

   177     else {

   178         my $method;

   179         my $callbacks;

   180         if (exists $self->{ParseOptions}) {

   181             $callbacks = $self->{ParseOptions};

   182         }

   183         else {

   184             $callbacks = $self;

   185         }

   186         if (0) { # dummy to make elsif's below compile

   187         }

   188         elsif (defined $callbacks->{'DocumentHandler'} and $method = $callbacks->{'DocumentHandler'}->can('start_cdata') ) {

   189             my $handler = $callbacks->{'DocumentHandler'};

   190             $self->{Methods}->{'start_cdata'} = sub { $method->($handler, @_) };

   191             return $method->($handler, @_);

   192         }

   193         elsif (defined $callbacks->{'LexicalHandler'} and $method = $callbacks->{'LexicalHandler'}->can('start_cdata') ) {

   194             my $handler = $callbacks->{'LexicalHandler'};

   195             $self->{Methods}->{'start_cdata'} = sub { $method->($handler, @_) };

   196             return $method->($handler, @_);

   197         }

   198         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('start_cdata') ) {

   199             my $handler = $callbacks->{'Handler'};

   200             $self->{Methods}->{'start_cdata'} = sub { $method->($handler, @_) };

   201             return $method->($handler, @_);

   202         }

   203         elsif (defined $callbacks->{'DocumentHandler'} 

   204         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD')

   205         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   206         	)

   207         {

   208             my $res = eval { $callbacks->{'DocumentHandler'}->start_cdata(@_) };

   209             if ($@) {

   210                 die $@;

   211             }

   212             else {

   213                 # I think there's a buggette here...

   214                 # if the first call throws an exception, we don't set it up right.

   215                 # Not fatal, but we might want to address it.

   216                 my $handler = $callbacks->{'DocumentHandler'};

   217                 $self->{Methods}->{'start_cdata'} = sub { $handler->start_cdata(@_) };

   218             }

   219             return $res;

   220         }

   221         elsif (defined $callbacks->{'LexicalHandler'} 

   222         	and $callbacks->{'LexicalHandler'}->can('AUTOLOAD')

   223         	and $callbacks->{'LexicalHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   224         	)

   225         {

   226             my $res = eval { $callbacks->{'LexicalHandler'}->start_cdata(@_) };

   227             if ($@) {

   228                 die $@;

   229             }

   230             else {

   231                 # I think there's a buggette here...

   232                 # if the first call throws an exception, we don't set it up right.

   233                 # Not fatal, but we might want to address it.

   234                 my $handler = $callbacks->{'LexicalHandler'};

   235                 $self->{Methods}->{'start_cdata'} = sub { $handler->start_cdata(@_) };

   236             }

   237             return $res;

   238         }

   239         elsif (defined $callbacks->{'Handler'} 

   240         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   241         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   242         	)

   243         {

   244             my $res = eval { $callbacks->{'Handler'}->start_cdata(@_) };

   245             if ($@) {

   246                 die $@;

   247             }

   248             else {

   249                 # I think there's a buggette here...

   250                 # if the first call throws an exception, we don't set it up right.

   251                 # Not fatal, but we might want to address it.

   252                 my $handler = $callbacks->{'Handler'};

   253                 $self->{Methods}->{'start_cdata'} = sub { $handler->start_cdata(@_) };

   254             }

   255             return $res;

   256         }

   257         else {

   258             $self->{Methods}->{'start_cdata'} = sub { };

   259         }

   260     }

   261 

   262 }

   263 

   264 sub set_document_locator {

   265     my $self = shift;

   266     if (defined $self->{Methods}->{'set_document_locator'}) {

   267         $self->{Methods}->{'set_document_locator'}->(@_);

   268     }

   269     else {

   270         my $method;

   271         my $callbacks;

   272         if (exists $self->{ParseOptions}) {

   273             $callbacks = $self->{ParseOptions};

   274         }

   275         else {

   276             $callbacks = $self;

   277         }

   278         if (0) { # dummy to make elsif's below compile

   279         }

   280         elsif (defined $callbacks->{'ContentHandler'} and $method = $callbacks->{'ContentHandler'}->can('set_document_locator') ) {

   281             my $handler = $callbacks->{'ContentHandler'};

   282             $self->{Methods}->{'set_document_locator'} = sub { $method->($handler, @_) };

   283             return $method->($handler, @_);

   284         }

   285         elsif (defined $callbacks->{'DocumentHandler'} and $method = $callbacks->{'DocumentHandler'}->can('set_document_locator') ) {

   286             my $handler = $callbacks->{'DocumentHandler'};

   287             $self->{Methods}->{'set_document_locator'} = sub { $method->($handler, @_) };

   288             return $method->($handler, @_);

   289         }

   290         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('set_document_locator') ) {

   291             my $handler = $callbacks->{'Handler'};

   292             $self->{Methods}->{'set_document_locator'} = sub { $method->($handler, @_) };

   293             return $method->($handler, @_);

   294         }

   295         elsif (defined $callbacks->{'ContentHandler'} 

   296         	and $callbacks->{'ContentHandler'}->can('AUTOLOAD')

   297         	and $callbacks->{'ContentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   298         	)

   299         {

   300             my $res = eval { $callbacks->{'ContentHandler'}->set_document_locator(@_) };

   301             if ($@) {

   302                 die $@;

   303             }

   304             else {

   305                 # I think there's a buggette here...

   306                 # if the first call throws an exception, we don't set it up right.

   307                 # Not fatal, but we might want to address it.

   308                 my $handler = $callbacks->{'ContentHandler'};

   309                 $self->{Methods}->{'set_document_locator'} = sub { $handler->set_document_locator(@_) };

   310             }

   311             return $res;

   312         }

   313         elsif (defined $callbacks->{'DocumentHandler'} 

   314         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD')

   315         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   316         	)

   317         {

   318             my $res = eval { $callbacks->{'DocumentHandler'}->set_document_locator(@_) };

   319             if ($@) {

   320                 die $@;

   321             }

   322             else {

   323                 # I think there's a buggette here...

   324                 # if the first call throws an exception, we don't set it up right.

   325                 # Not fatal, but we might want to address it.

   326                 my $handler = $callbacks->{'DocumentHandler'};

   327                 $self->{Methods}->{'set_document_locator'} = sub { $handler->set_document_locator(@_) };

   328             }

   329             return $res;

   330         }

   331         elsif (defined $callbacks->{'Handler'} 

   332         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   333         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   334         	)

   335         {

   336             my $res = eval { $callbacks->{'Handler'}->set_document_locator(@_) };

   337             if ($@) {

   338                 die $@;

   339             }

   340             else {

   341                 # I think there's a buggette here...

   342                 # if the first call throws an exception, we don't set it up right.

   343                 # Not fatal, but we might want to address it.

   344                 my $handler = $callbacks->{'Handler'};

   345                 $self->{Methods}->{'set_document_locator'} = sub { $handler->set_document_locator(@_) };

   346             }

   347             return $res;

   348         }

   349         else {

   350             $self->{Methods}->{'set_document_locator'} = sub { };

   351         }

   352     }

   353 

   354 }

   355 

   356 sub xml_decl {

   357     my $self = shift;

   358     if (defined $self->{Methods}->{'xml_decl'}) {

   359         $self->{Methods}->{'xml_decl'}->(@_);

   360     }

   361     else {

   362         my $method;

   363         my $callbacks;

   364         if (exists $self->{ParseOptions}) {

   365             $callbacks = $self->{ParseOptions};

   366         }

   367         else {

   368             $callbacks = $self;

   369         }

   370         if (0) { # dummy to make elsif's below compile

   371         }

   372         elsif (defined $callbacks->{'DTDHandler'} and $method = $callbacks->{'DTDHandler'}->can('xml_decl') ) {

   373             my $handler = $callbacks->{'DTDHandler'};

   374             $self->{Methods}->{'xml_decl'} = sub { $method->($handler, @_) };

   375             return $method->($handler, @_);

   376         }

   377         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('xml_decl') ) {

   378             my $handler = $callbacks->{'Handler'};

   379             $self->{Methods}->{'xml_decl'} = sub { $method->($handler, @_) };

   380             return $method->($handler, @_);

   381         }

   382         elsif (defined $callbacks->{'DTDHandler'} 

   383         	and $callbacks->{'DTDHandler'}->can('AUTOLOAD')

   384         	and $callbacks->{'DTDHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   385         	)

   386         {

   387             my $res = eval { $callbacks->{'DTDHandler'}->xml_decl(@_) };

   388             if ($@) {

   389                 die $@;

   390             }

   391             else {

   392                 # I think there's a buggette here...

   393                 # if the first call throws an exception, we don't set it up right.

   394                 # Not fatal, but we might want to address it.

   395                 my $handler = $callbacks->{'DTDHandler'};

   396                 $self->{Methods}->{'xml_decl'} = sub { $handler->xml_decl(@_) };

   397             }

   398             return $res;

   399         }

   400         elsif (defined $callbacks->{'Handler'} 

   401         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   402         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   403         	)

   404         {

   405             my $res = eval { $callbacks->{'Handler'}->xml_decl(@_) };

   406             if ($@) {

   407                 die $@;

   408             }

   409             else {

   410                 # I think there's a buggette here...

   411                 # if the first call throws an exception, we don't set it up right.

   412                 # Not fatal, but we might want to address it.

   413                 my $handler = $callbacks->{'Handler'};

   414                 $self->{Methods}->{'xml_decl'} = sub { $handler->xml_decl(@_) };

   415             }

   416             return $res;

   417         }

   418         else {

   419             $self->{Methods}->{'xml_decl'} = sub { };

   420         }

   421     }

   422 

   423 }

   424 

   425 sub processing_instruction {

   426     my $self = shift;

   427     if (defined $self->{Methods}->{'processing_instruction'}) {

   428         $self->{Methods}->{'processing_instruction'}->(@_);

   429     }

   430     else {

   431         my $method;

   432         my $callbacks;

   433         if (exists $self->{ParseOptions}) {

   434             $callbacks = $self->{ParseOptions};

   435         }

   436         else {

   437             $callbacks = $self;

   438         }

   439         if (0) { # dummy to make elsif's below compile

   440         }

   441         elsif (defined $callbacks->{'ContentHandler'} and $method = $callbacks->{'ContentHandler'}->can('processing_instruction') ) {

   442             my $handler = $callbacks->{'ContentHandler'};

   443             $self->{Methods}->{'processing_instruction'} = sub { $method->($handler, @_) };

   444             return $method->($handler, @_);

   445         }

   446         elsif (defined $callbacks->{'DocumentHandler'} and $method = $callbacks->{'DocumentHandler'}->can('processing_instruction') ) {

   447             my $handler = $callbacks->{'DocumentHandler'};

   448             $self->{Methods}->{'processing_instruction'} = sub { $method->($handler, @_) };

   449             return $method->($handler, @_);

   450         }

   451         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('processing_instruction') ) {

   452             my $handler = $callbacks->{'Handler'};

   453             $self->{Methods}->{'processing_instruction'} = sub { $method->($handler, @_) };

   454             return $method->($handler, @_);

   455         }

   456         elsif (defined $callbacks->{'ContentHandler'} 

   457         	and $callbacks->{'ContentHandler'}->can('AUTOLOAD')

   458         	and $callbacks->{'ContentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   459         	)

   460         {

   461             my $res = eval { $callbacks->{'ContentHandler'}->processing_instruction(@_) };

   462             if ($@) {

   463                 die $@;

   464             }

   465             else {

   466                 # I think there's a buggette here...

   467                 # if the first call throws an exception, we don't set it up right.

   468                 # Not fatal, but we might want to address it.

   469                 my $handler = $callbacks->{'ContentHandler'};

   470                 $self->{Methods}->{'processing_instruction'} = sub { $handler->processing_instruction(@_) };

   471             }

   472             return $res;

   473         }

   474         elsif (defined $callbacks->{'DocumentHandler'} 

   475         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD')

   476         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   477         	)

   478         {

   479             my $res = eval { $callbacks->{'DocumentHandler'}->processing_instruction(@_) };

   480             if ($@) {

   481                 die $@;

   482             }

   483             else {

   484                 # I think there's a buggette here...

   485                 # if the first call throws an exception, we don't set it up right.

   486                 # Not fatal, but we might want to address it.

   487                 my $handler = $callbacks->{'DocumentHandler'};

   488                 $self->{Methods}->{'processing_instruction'} = sub { $handler->processing_instruction(@_) };

   489             }

   490             return $res;

   491         }

   492         elsif (defined $callbacks->{'Handler'} 

   493         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   494         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   495         	)

   496         {

   497             my $res = eval { $callbacks->{'Handler'}->processing_instruction(@_) };

   498             if ($@) {

   499                 die $@;

   500             }

   501             else {

   502                 # I think there's a buggette here...

   503                 # if the first call throws an exception, we don't set it up right.

   504                 # Not fatal, but we might want to address it.

   505                 my $handler = $callbacks->{'Handler'};

   506                 $self->{Methods}->{'processing_instruction'} = sub { $handler->processing_instruction(@_) };

   507             }

   508             return $res;

   509         }

   510         else {

   511             $self->{Methods}->{'processing_instruction'} = sub { };

   512         }

   513     }

   514 

   515 }

   516 

   517 sub start_prefix_mapping {

   518     my $self = shift;

   519     if (defined $self->{Methods}->{'start_prefix_mapping'}) {

   520         $self->{Methods}->{'start_prefix_mapping'}->(@_);

   521     }

   522     else {

   523         my $method;

   524         my $callbacks;

   525         if (exists $self->{ParseOptions}) {

   526             $callbacks = $self->{ParseOptions};

   527         }

   528         else {

   529             $callbacks = $self;

   530         }

   531         if (0) { # dummy to make elsif's below compile

   532         }

   533         elsif (defined $callbacks->{'ContentHandler'} and $method = $callbacks->{'ContentHandler'}->can('start_prefix_mapping') ) {

   534             my $handler = $callbacks->{'ContentHandler'};

   535             $self->{Methods}->{'start_prefix_mapping'} = sub { $method->($handler, @_) };

   536             return $method->($handler, @_);

   537         }

   538         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('start_prefix_mapping') ) {

   539             my $handler = $callbacks->{'Handler'};

   540             $self->{Methods}->{'start_prefix_mapping'} = sub { $method->($handler, @_) };

   541             return $method->($handler, @_);

   542         }

   543         elsif (defined $callbacks->{'ContentHandler'} 

   544         	and $callbacks->{'ContentHandler'}->can('AUTOLOAD')

   545         	and $callbacks->{'ContentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   546         	)

   547         {

   548             my $res = eval { $callbacks->{'ContentHandler'}->start_prefix_mapping(@_) };

   549             if ($@) {

   550                 die $@;

   551             }

   552             else {

   553                 # I think there's a buggette here...

   554                 # if the first call throws an exception, we don't set it up right.

   555                 # Not fatal, but we might want to address it.

   556                 my $handler = $callbacks->{'ContentHandler'};

   557                 $self->{Methods}->{'start_prefix_mapping'} = sub { $handler->start_prefix_mapping(@_) };

   558             }

   559             return $res;

   560         }

   561         elsif (defined $callbacks->{'Handler'} 

   562         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   563         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   564         	)

   565         {

   566             my $res = eval { $callbacks->{'Handler'}->start_prefix_mapping(@_) };

   567             if ($@) {

   568                 die $@;

   569             }

   570             else {

   571                 # I think there's a buggette here...

   572                 # if the first call throws an exception, we don't set it up right.

   573                 # Not fatal, but we might want to address it.

   574                 my $handler = $callbacks->{'Handler'};

   575                 $self->{Methods}->{'start_prefix_mapping'} = sub { $handler->start_prefix_mapping(@_) };

   576             }

   577             return $res;

   578         }

   579         else {

   580             $self->{Methods}->{'start_prefix_mapping'} = sub { };

   581         }

   582     }

   583 

   584 }

   585 

   586 sub entity_reference {

   587     my $self = shift;

   588     if (defined $self->{Methods}->{'entity_reference'}) {

   589         $self->{Methods}->{'entity_reference'}->(@_);

   590     }

   591     else {

   592         my $method;

   593         my $callbacks;

   594         if (exists $self->{ParseOptions}) {

   595             $callbacks = $self->{ParseOptions};

   596         }

   597         else {

   598             $callbacks = $self;

   599         }

   600         if (0) { # dummy to make elsif's below compile

   601         }

   602         elsif (defined $callbacks->{'DocumentHandler'} and $method = $callbacks->{'DocumentHandler'}->can('entity_reference') ) {

   603             my $handler = $callbacks->{'DocumentHandler'};

   604             $self->{Methods}->{'entity_reference'} = sub { $method->($handler, @_) };

   605             return $method->($handler, @_);

   606         }

   607         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('entity_reference') ) {

   608             my $handler = $callbacks->{'Handler'};

   609             $self->{Methods}->{'entity_reference'} = sub { $method->($handler, @_) };

   610             return $method->($handler, @_);

   611         }

   612         elsif (defined $callbacks->{'DocumentHandler'} 

   613         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD')

   614         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   615         	)

   616         {

   617             my $res = eval { $callbacks->{'DocumentHandler'}->entity_reference(@_) };

   618             if ($@) {

   619                 die $@;

   620             }

   621             else {

   622                 # I think there's a buggette here...

   623                 # if the first call throws an exception, we don't set it up right.

   624                 # Not fatal, but we might want to address it.

   625                 my $handler = $callbacks->{'DocumentHandler'};

   626                 $self->{Methods}->{'entity_reference'} = sub { $handler->entity_reference(@_) };

   627             }

   628             return $res;

   629         }

   630         elsif (defined $callbacks->{'Handler'} 

   631         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   632         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   633         	)

   634         {

   635             my $res = eval { $callbacks->{'Handler'}->entity_reference(@_) };

   636             if ($@) {

   637                 die $@;

   638             }

   639             else {

   640                 # I think there's a buggette here...

   641                 # if the first call throws an exception, we don't set it up right.

   642                 # Not fatal, but we might want to address it.

   643                 my $handler = $callbacks->{'Handler'};

   644                 $self->{Methods}->{'entity_reference'} = sub { $handler->entity_reference(@_) };

   645             }

   646             return $res;

   647         }

   648         else {

   649             $self->{Methods}->{'entity_reference'} = sub { };

   650         }

   651     }

   652 

   653 }

   654 

   655 sub attlist_decl {

   656     my $self = shift;

   657     if (defined $self->{Methods}->{'attlist_decl'}) {

   658         $self->{Methods}->{'attlist_decl'}->(@_);

   659     }

   660     else {

   661         my $method;

   662         my $callbacks;

   663         if (exists $self->{ParseOptions}) {

   664             $callbacks = $self->{ParseOptions};

   665         }

   666         else {

   667             $callbacks = $self;

   668         }

   669         if (0) { # dummy to make elsif's below compile

   670         }

   671         elsif (defined $callbacks->{'DTDHandler'} and $method = $callbacks->{'DTDHandler'}->can('attlist_decl') ) {

   672             my $handler = $callbacks->{'DTDHandler'};

   673             $self->{Methods}->{'attlist_decl'} = sub { $method->($handler, @_) };

   674             return $method->($handler, @_);

   675         }

   676         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('attlist_decl') ) {

   677             my $handler = $callbacks->{'Handler'};

   678             $self->{Methods}->{'attlist_decl'} = sub { $method->($handler, @_) };

   679             return $method->($handler, @_);

   680         }

   681         elsif (defined $callbacks->{'DTDHandler'} 

   682         	and $callbacks->{'DTDHandler'}->can('AUTOLOAD')

   683         	and $callbacks->{'DTDHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   684         	)

   685         {

   686             my $res = eval { $callbacks->{'DTDHandler'}->attlist_decl(@_) };

   687             if ($@) {

   688                 die $@;

   689             }

   690             else {

   691                 # I think there's a buggette here...

   692                 # if the first call throws an exception, we don't set it up right.

   693                 # Not fatal, but we might want to address it.

   694                 my $handler = $callbacks->{'DTDHandler'};

   695                 $self->{Methods}->{'attlist_decl'} = sub { $handler->attlist_decl(@_) };

   696             }

   697             return $res;

   698         }

   699         elsif (defined $callbacks->{'Handler'} 

   700         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   701         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   702         	)

   703         {

   704             my $res = eval { $callbacks->{'Handler'}->attlist_decl(@_) };

   705             if ($@) {

   706                 die $@;

   707             }

   708             else {

   709                 # I think there's a buggette here...

   710                 # if the first call throws an exception, we don't set it up right.

   711                 # Not fatal, but we might want to address it.

   712                 my $handler = $callbacks->{'Handler'};

   713                 $self->{Methods}->{'attlist_decl'} = sub { $handler->attlist_decl(@_) };

   714             }

   715             return $res;

   716         }

   717         else {

   718             $self->{Methods}->{'attlist_decl'} = sub { };

   719         }

   720     }

   721 

   722 }

   723 

   724 sub error {

   725     my $self = shift;

   726     if (defined $self->{Methods}->{'error'}) {

   727         $self->{Methods}->{'error'}->(@_);

   728     }

   729     else {

   730         my $method;

   731         my $callbacks;

   732         if (exists $self->{ParseOptions}) {

   733             $callbacks = $self->{ParseOptions};

   734         }

   735         else {

   736             $callbacks = $self;

   737         }

   738         if (0) { # dummy to make elsif's below compile

   739         }

   740         elsif (defined $callbacks->{'ErrorHandler'} and $method = $callbacks->{'ErrorHandler'}->can('error') ) {

   741             my $handler = $callbacks->{'ErrorHandler'};

   742             $self->{Methods}->{'error'} = sub { $method->($handler, @_) };

   743             return $method->($handler, @_);

   744         }

   745         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('error') ) {

   746             my $handler = $callbacks->{'Handler'};

   747             $self->{Methods}->{'error'} = sub { $method->($handler, @_) };

   748             return $method->($handler, @_);

   749         }

   750         elsif (defined $callbacks->{'ErrorHandler'} 

   751         	and $callbacks->{'ErrorHandler'}->can('AUTOLOAD')

   752         	and $callbacks->{'ErrorHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   753         	)

   754         {

   755             my $res = eval { $callbacks->{'ErrorHandler'}->error(@_) };

   756             if ($@) {

   757                 die $@;

   758             }

   759             else {

   760                 # I think there's a buggette here...

   761                 # if the first call throws an exception, we don't set it up right.

   762                 # Not fatal, but we might want to address it.

   763                 my $handler = $callbacks->{'ErrorHandler'};

   764                 $self->{Methods}->{'error'} = sub { $handler->error(@_) };

   765             }

   766             return $res;

   767         }

   768         elsif (defined $callbacks->{'Handler'} 

   769         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   770         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   771         	)

   772         {

   773             my $res = eval { $callbacks->{'Handler'}->error(@_) };

   774             if ($@) {

   775                 die $@;

   776             }

   777             else {

   778                 # I think there's a buggette here...

   779                 # if the first call throws an exception, we don't set it up right.

   780                 # Not fatal, but we might want to address it.

   781                 my $handler = $callbacks->{'Handler'};

   782                 $self->{Methods}->{'error'} = sub { $handler->error(@_) };

   783             }

   784             return $res;

   785         }

   786         else {

   787             $self->{Methods}->{'error'} = sub { };

   788         }

   789     }

   790 

   791 }

   792 

   793 sub unparsed_entity_decl {

   794     my $self = shift;

   795     if (defined $self->{Methods}->{'unparsed_entity_decl'}) {

   796         $self->{Methods}->{'unparsed_entity_decl'}->(@_);

   797     }

   798     else {

   799         my $method;

   800         my $callbacks;

   801         if (exists $self->{ParseOptions}) {

   802             $callbacks = $self->{ParseOptions};

   803         }

   804         else {

   805             $callbacks = $self;

   806         }

   807         if (0) { # dummy to make elsif's below compile

   808         }

   809         elsif (defined $callbacks->{'DTDHandler'} and $method = $callbacks->{'DTDHandler'}->can('unparsed_entity_decl') ) {

   810             my $handler = $callbacks->{'DTDHandler'};

   811             $self->{Methods}->{'unparsed_entity_decl'} = sub { $method->($handler, @_) };

   812             return $method->($handler, @_);

   813         }

   814         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('unparsed_entity_decl') ) {

   815             my $handler = $callbacks->{'Handler'};

   816             $self->{Methods}->{'unparsed_entity_decl'} = sub { $method->($handler, @_) };

   817             return $method->($handler, @_);

   818         }

   819         elsif (defined $callbacks->{'DTDHandler'} 

   820         	and $callbacks->{'DTDHandler'}->can('AUTOLOAD')

   821         	and $callbacks->{'DTDHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   822         	)

   823         {

   824             my $res = eval { $callbacks->{'DTDHandler'}->unparsed_entity_decl(@_) };

   825             if ($@) {

   826                 die $@;

   827             }

   828             else {

   829                 # I think there's a buggette here...

   830                 # if the first call throws an exception, we don't set it up right.

   831                 # Not fatal, but we might want to address it.

   832                 my $handler = $callbacks->{'DTDHandler'};

   833                 $self->{Methods}->{'unparsed_entity_decl'} = sub { $handler->unparsed_entity_decl(@_) };

   834             }

   835             return $res;

   836         }

   837         elsif (defined $callbacks->{'Handler'} 

   838         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   839         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   840         	)

   841         {

   842             my $res = eval { $callbacks->{'Handler'}->unparsed_entity_decl(@_) };

   843             if ($@) {

   844                 die $@;

   845             }

   846             else {

   847                 # I think there's a buggette here...

   848                 # if the first call throws an exception, we don't set it up right.

   849                 # Not fatal, but we might want to address it.

   850                 my $handler = $callbacks->{'Handler'};

   851                 $self->{Methods}->{'unparsed_entity_decl'} = sub { $handler->unparsed_entity_decl(@_) };

   852             }

   853             return $res;

   854         }

   855         else {

   856             $self->{Methods}->{'unparsed_entity_decl'} = sub { };

   857         }

   858     }

   859 

   860 }

   861 

   862 sub end_entity {

   863     my $self = shift;

   864     if (defined $self->{Methods}->{'end_entity'}) {

   865         $self->{Methods}->{'end_entity'}->(@_);

   866     }

   867     else {

   868         my $method;

   869         my $callbacks;

   870         if (exists $self->{ParseOptions}) {

   871             $callbacks = $self->{ParseOptions};

   872         }

   873         else {

   874             $callbacks = $self;

   875         }

   876         if (0) { # dummy to make elsif's below compile

   877         }

   878         elsif (defined $callbacks->{'LexicalHandler'} and $method = $callbacks->{'LexicalHandler'}->can('end_entity') ) {

   879             my $handler = $callbacks->{'LexicalHandler'};

   880             $self->{Methods}->{'end_entity'} = sub { $method->($handler, @_) };

   881             return $method->($handler, @_);

   882         }

   883         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('end_entity') ) {

   884             my $handler = $callbacks->{'Handler'};

   885             $self->{Methods}->{'end_entity'} = sub { $method->($handler, @_) };

   886             return $method->($handler, @_);

   887         }

   888         elsif (defined $callbacks->{'LexicalHandler'} 

   889         	and $callbacks->{'LexicalHandler'}->can('AUTOLOAD')

   890         	and $callbacks->{'LexicalHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   891         	)

   892         {

   893             my $res = eval { $callbacks->{'LexicalHandler'}->end_entity(@_) };

   894             if ($@) {

   895                 die $@;

   896             }

   897             else {

   898                 # I think there's a buggette here...

   899                 # if the first call throws an exception, we don't set it up right.

   900                 # Not fatal, but we might want to address it.

   901                 my $handler = $callbacks->{'LexicalHandler'};

   902                 $self->{Methods}->{'end_entity'} = sub { $handler->end_entity(@_) };

   903             }

   904             return $res;

   905         }

   906         elsif (defined $callbacks->{'Handler'} 

   907         	and $callbacks->{'Handler'}->can('AUTOLOAD')

   908         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   909         	)

   910         {

   911             my $res = eval { $callbacks->{'Handler'}->end_entity(@_) };

   912             if ($@) {

   913                 die $@;

   914             }

   915             else {

   916                 # I think there's a buggette here...

   917                 # if the first call throws an exception, we don't set it up right.

   918                 # Not fatal, but we might want to address it.

   919                 my $handler = $callbacks->{'Handler'};

   920                 $self->{Methods}->{'end_entity'} = sub { $handler->end_entity(@_) };

   921             }

   922             return $res;

   923         }

   924         else {

   925             $self->{Methods}->{'end_entity'} = sub { };

   926         }

   927     }

   928 

   929 }

   930 

   931 sub end_element {

   932     my $self = shift;

   933     if (defined $self->{Methods}->{'end_element'}) {

   934         $self->{Methods}->{'end_element'}->(@_);

   935     }

   936     else {

   937         my $method;

   938         my $callbacks;

   939         if (exists $self->{ParseOptions}) {

   940             $callbacks = $self->{ParseOptions};

   941         }

   942         else {

   943             $callbacks = $self;

   944         }

   945         if (0) { # dummy to make elsif's below compile

   946         }

   947         elsif (defined $callbacks->{'ContentHandler'} and $method = $callbacks->{'ContentHandler'}->can('end_element') ) {

   948             my $handler = $callbacks->{'ContentHandler'};

   949             $self->{Methods}->{'end_element'} = sub { $method->($handler, @_) };

   950             return $method->($handler, @_);

   951         }

   952         elsif (defined $callbacks->{'DocumentHandler'} and $method = $callbacks->{'DocumentHandler'}->can('end_element') ) {

   953             my $handler = $callbacks->{'DocumentHandler'};

   954             $self->{Methods}->{'end_element'} = sub { $method->($handler, @_) };

   955             return $method->($handler, @_);

   956         }

   957         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('end_element') ) {

   958             my $handler = $callbacks->{'Handler'};

   959             $self->{Methods}->{'end_element'} = sub { $method->($handler, @_) };

   960             return $method->($handler, @_);

   961         }

   962         elsif (defined $callbacks->{'ContentHandler'} 

   963         	and $callbacks->{'ContentHandler'}->can('AUTOLOAD')

   964         	and $callbacks->{'ContentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   965         	)

   966         {

   967             my $res = eval { $callbacks->{'ContentHandler'}->end_element(@_) };

   968             if ($@) {

   969                 die $@;

   970             }

   971             else {

   972                 # I think there's a buggette here...

   973                 # if the first call throws an exception, we don't set it up right.

   974                 # Not fatal, but we might want to address it.

   975                 my $handler = $callbacks->{'ContentHandler'};

   976                 $self->{Methods}->{'end_element'} = sub { $handler->end_element(@_) };

   977             }

   978             return $res;

   979         }

   980         elsif (defined $callbacks->{'DocumentHandler'} 

   981         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD')

   982         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

   983         	)

   984         {

   985             my $res = eval { $callbacks->{'DocumentHandler'}->end_element(@_) };

   986             if ($@) {

   987                 die $@;

   988             }

   989             else {

   990                 # I think there's a buggette here...

   991                 # if the first call throws an exception, we don't set it up right.

   992                 # Not fatal, but we might want to address it.

   993                 my $handler = $callbacks->{'DocumentHandler'};

   994                 $self->{Methods}->{'end_element'} = sub { $handler->end_element(@_) };

   995             }

   996             return $res;

   997         }

   998         elsif (defined $callbacks->{'Handler'} 

   999         	and $callbacks->{'Handler'}->can('AUTOLOAD')

  1000         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

  1001         	)

  1002         {

  1003             my $res = eval { $callbacks->{'Handler'}->end_element(@_) };

  1004             if ($@) {

  1005                 die $@;

  1006             }

  1007             else {

  1008                 # I think there's a buggette here...

  1009                 # if the first call throws an exception, we don't set it up right.

  1010                 # Not fatal, but we might want to address it.

  1011                 my $handler = $callbacks->{'Handler'};

  1012                 $self->{Methods}->{'end_element'} = sub { $handler->end_element(@_) };

  1013             }

  1014             return $res;

  1015         }

  1016         else {

  1017             $self->{Methods}->{'end_element'} = sub { };

  1018         }

  1019     }

  1020 

  1021 }

  1022 

  1023 sub comment {

  1024     my $self = shift;

  1025     if (defined $self->{Methods}->{'comment'}) {

  1026         $self->{Methods}->{'comment'}->(@_);

  1027     }

  1028     else {

  1029         my $method;

  1030         my $callbacks;

  1031         if (exists $self->{ParseOptions}) {

  1032             $callbacks = $self->{ParseOptions};

  1033         }

  1034         else {

  1035             $callbacks = $self;

  1036         }

  1037         if (0) { # dummy to make elsif's below compile

  1038         }

  1039         elsif (defined $callbacks->{'DocumentHandler'} and $method = $callbacks->{'DocumentHandler'}->can('comment') ) {

  1040             my $handler = $callbacks->{'DocumentHandler'};

  1041             $self->{Methods}->{'comment'} = sub { $method->($handler, @_) };

  1042             return $method->($handler, @_);

  1043         }

  1044         elsif (defined $callbacks->{'LexicalHandler'} and $method = $callbacks->{'LexicalHandler'}->can('comment') ) {

  1045             my $handler = $callbacks->{'LexicalHandler'};

  1046             $self->{Methods}->{'comment'} = sub { $method->($handler, @_) };

  1047             return $method->($handler, @_);

  1048         }

  1049         elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('comment') ) {

  1050             my $handler = $callbacks->{'Handler'};

  1051             $self->{Methods}->{'comment'} = sub { $method->($handler, @_) };

  1052             return $method->($handler, @_);

  1053         }

  1054         elsif (defined $callbacks->{'DocumentHandler'} 

  1055         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD')

  1056         	and $callbacks->{'DocumentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

  1057         	)

  1058         {

  1059             my $res = eval { $callbacks->{'DocumentHandler'}->comment(@_) };

  1060             if ($@) {

  1061                 die $@;

  1062             }

  1063             else {

  1064                 # I think there's a buggette here...

  1065                 # if the first call throws an exception, we don't set it up right.

  1066                 # Not fatal, but we might want to address it.

  1067                 my $handler = $callbacks->{'DocumentHandler'};

  1068                 $self->{Methods}->{'comment'} = sub { $handler->comment(@_) };

  1069             }

  1070             return $res;

  1071         }

  1072         elsif (defined $callbacks->{'LexicalHandler'} 

  1073         	and $callbacks->{'LexicalHandler'}->can('AUTOLOAD')

  1074         	and $callbacks->{'LexicalHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

  1075         	)

  1076         {

  1077             my $res = eval { $callbacks->{'LexicalHandler'}->comment(@_) };

  1078             if ($@) {

  1079                 die $@;

  1080             }

  1081             else {

  1082                 # I think there's a buggette here...

  1083                 # if the first call throws an exception, we don't set it up right.

  1084                 # Not fatal, but we might want to address it.

  1085                 my $handler = $callbacks->{'LexicalHandler'};

  1086                 $self->{Methods}->{'comment'} = sub { $handler->comment(@_) };

  1087             }

  1088             return $res;

  1089         }

  1090         elsif (defined $callbacks->{'Handler'} 

  1091         	and $callbacks->{'Handler'}->can('AUTOLOAD')

  1092         	and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')

  1093         	)

  1094         {

  1095             my $res = eval { $callbacks->{'Handler'}->comment(@_) };

  1096             if ($@) {

  1097                 die $@;

  1098             }

  1099             else {

  1100                 # I think there's a buggette here...

  1101                 # if the first call throws an exception, we don't set it up right.

  1102                 # Not fatal, but we might want to address it.

  1103                 my $handler = $callbacks->{'Handler'};

  1104                 $self->{Methods}->{'comment'} = sub { $handler->comment(@_) };

  1105             }

  1106             return $res;

  1107         }

  1108         else {

  1109             $self->{Methods}->{'comment'} = sub { };

  1110         }

  1111     }

  1112 

  1113 }

  1114 

  1115 sub element_decl {

  1116     my $self = shift;

  1117     if (defined $self->{Methods}->{'element_decl'}) {

  1118         $self->{Methods}->{'element_decl'}->(@_);

  1119     }

  1120     else {

  1121         my $method;

  1122         my $callbacks;

  1123         if (exists $self->{ParseOptions}) {

  1124             $callbacks = $self->{ParseOptions};

  1125         }

  1126         else {

  1127             $callbacks = $self;

  1128         }

  1129         if (0) { # dummy to make elsif's below compile

  1130         }

  1131         elsif (defined $callbacks->{'DeclHandler'} and $method = $callbacks->{'DeclHandler'}->can('element_decl') ) {

  1132             my $handler = $callbacks->{'DeclHandler'};

  1133             $self->{Methods}->{'element_decl'} = sub { $method->($handler, @_) };

  1134             return $method->($handler, @_);