package XML::SAX::Base;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#-----------------------------------------------------#

# STOP!!!!!

#

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

# that ships with the XML::SAX distribution.

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

# this one.

#-----------------------------------------------------#

use strict;

use vars qw($VERSION);

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

$VERSION = '1.04';

sub notation_decl {

    my $self = shift;

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

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

    }

    else {

        my $method;

        my $callbacks;

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

            $callbacks = $self->{ParseOptions};

        }

        else {

            $callbacks = $self;

        }

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

        }

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

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

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

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

        }

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

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

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

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

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

        else {

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

        }

    }

}

sub resolve_entity {

    my $self = shift;

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

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

    }

    else {

        my $method;

        my $callbacks;

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

            $callbacks = $self->{ParseOptions};

        }

        else {

            $callbacks = $self;

        }

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

        }

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

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

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

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

        }

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

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

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

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

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

        else {

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

        }

    }

}

sub start_cdata {

    my $self = shift;

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

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

    }

    else {

        my $method;

        my $callbacks;

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

            $callbacks = $self->{ParseOptions};

        }

        else {

            $callbacks = $self;

        }

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

        }

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

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

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

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

        }

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

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

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

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

        }

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

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

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

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

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

        else {

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

        }

    }

}

sub set_document_locator {

    my $self = shift;

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

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

    }

    else {

        my $method;

        my $callbacks;

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

            $callbacks = $self->{ParseOptions};

        }

        else {

            $callbacks = $self;

        }

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

        }

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

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

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

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

        }

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

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

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

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

        }

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

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

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

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

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

        else {

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

        }

    }

}

sub xml_decl {

    my $self = shift;

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

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

    }

    else {

        my $method;

        my $callbacks;

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

            $callbacks = $self->{ParseOptions};

        }

        else {

            $callbacks = $self;

        }

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

        }

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

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

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

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

        }

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

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

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

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

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

        else {

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

        }

    }

}

sub processing_instruction {

    my $self = shift;

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

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

    }

    else {

        my $method;

        my $callbacks;

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

            $callbacks = $self->{ParseOptions};

        }

        else {

            $callbacks = $self;

        }

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

        }

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

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

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

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

        }

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

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

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

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

        }

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

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

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

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

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

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

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

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

        	)

        {

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

            if ($@) {

                die $@;

            }

            else {

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

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

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

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

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

            }

            return $res;

        }

        else {

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

        }

    }

}

sub start_prefix_mapping {

    my $self = shift;

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

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

    }

    else {

        my $method;

        my $callbacks;

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

            $callbacks = $self->{ParseOptions};

        }

        else {

            $callbacks = $self;