File Coverage

blib/lib/XML/LibXML/Error.pm

Criterion	Covered	Total	%
statement	181	194	93.3
branch	33	42	78.5
condition	11	17	64.7
subroutine	49	54	90.7
pod	3	6	50.0
total	277	313	88.5

# $Id: Error.pm,v 1.1.2.1 2004/04/20 20:09:48 pajas Exp $
#
# This is free software, you may use it and distribute it under the same terms as
# Perl itself.
#
# Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas
#
#
package XML::LibXML::Error;

use strict;
use warnings;

# To avoid a "Deep recursion on subroutine as_string" warning
no warnings 'recursion';

use Encode ();

use vars qw(@error_domains $VERSION $WARNINGS);
use overload
  '""' => \&as_string,
  'eq' => sub {
    ("$_[0]" eq "$_[1]")
  },
  'cmp' => sub {
    ("$_[0]" cmp "$_[1]")
  },
  fallback => 1;

$WARNINGS = 0; # 0: suppress, 1: report via warn, 2: report via die
$VERSION = "2.0207"; # VERSION TEMPLATE: DO NOT CHANGE

use constant XML_ERR_NONE            => 0;
use constant XML_ERR_WARNING         => 1; # A simple warning
use constant XML_ERR_ERROR           => 2; # A recoverable error
use constant XML_ERR_FATAL           => 3; # A fatal error

use constant XML_ERR_FROM_NONE       => 0;
use constant XML_ERR_FROM_PARSER     => 1; # The XML parser
use constant XML_ERR_FROM_TREE       => 2; # The tree module
use constant XML_ERR_FROM_NAMESPACE  => 3; # The XML Namespace module
use constant XML_ERR_FROM_DTD        => 4; # The XML DTD validation
use constant XML_ERR_FROM_HTML       => 5; # The HTML parser
use constant XML_ERR_FROM_MEMORY     => 6; # The memory allocator
use constant XML_ERR_FROM_OUTPUT     => 7; # The serialization code
use constant XML_ERR_FROM_IO         => 8; # The Input/Output stack
use constant XML_ERR_FROM_FTP        => 9; # The FTP module
use constant XML_ERR_FROM_HTTP       => 10; # The FTP module
use constant XML_ERR_FROM_XINCLUDE   => 11; # The XInclude processing
use constant XML_ERR_FROM_XPATH      => 12; # The XPath module
use constant XML_ERR_FROM_XPOINTER   => 13; # The XPointer module
use constant XML_ERR_FROM_REGEXP     => 14;     # The regular expressions module
use constant XML_ERR_FROM_DATATYPE   => 15; # The W3C XML Schemas Datatype module
use constant XML_ERR_FROM_SCHEMASP   => 16; # The W3C XML Schemas parser module
use constant XML_ERR_FROM_SCHEMASV   => 17; # The W3C XML Schemas validation module
use constant XML_ERR_FROM_RELAXNGP   => 18; # The Relax-NG parser module
use constant XML_ERR_FROM_RELAXNGV   => 19; # The Relax-NG validator module
use constant XML_ERR_FROM_CATALOG    => 20; # The Catalog module
use constant XML_ERR_FROM_C14N       => 21; # The Canonicalization module
use constant XML_ERR_FROM_XSLT       => 22; # The XSLT engine from libxslt
use constant XML_ERR_FROM_VALID      => 23; # The DTD validation module with valid context
use constant XML_ERR_FROM_CHECK      => 24; # The error-checking module
use constant XML_ERR_FROM_WRITER     => 25; # The xmlwriter module
use constant XML_ERR_FROM_MODULE     => 26; # The dynamically-loaded module module
use constant XML_ERR_FROM_I18N       => 27; # The module handling character conversion
use constant XML_ERR_FROM_SCHEMATRONV=> 28; # The Schematron validator module

@error_domains = ("", "parser", "tree", "namespace", "validity",
                  "HTML parser", "memory", "output", "I/O", "ftp",
                  "http", "XInclude", "XPath", "xpointer", "regexp",
                  "Schemas datatype", "Schemas parser", "Schemas validity",
                  "Relax-NG parser", "Relax-NG validity",
                  "Catalog", "C14N", "XSLT", "validity", "error-checking",
                  "xmlwriter", "dynamic loading", "i18n",
                  "Schematron validity");

my $MAX_ERROR_PREV_DEPTH = 100;

for my $field (qw
                  str1 str2 str3 num1 num2 __prev_depth>) {
    my $method = sub { $_[0]{$field} };
    no strict 'refs';
    *$field = $method;
}

{

  sub new {
    my ($class,$xE) = @_;
    my $terr;
    if (ref($xE)) {
      my ($context,$column) = $xE->context_and_column();
      $terr =bless {
        domain  => $xE->domain(),
        level   => $xE->level(),
        code    => $xE->code(),
        message => $xE->message(),
        file    => $xE->file(),
        line    => $xE->line(),
        str1    => $xE->str1(),
        str2    => $xE->str2(),
        str3    => $xE->str3(),
        num1    => $xE->num1(),
        num2    => $xE->num2(),
        __prev_depth => 0,
        (defined($context) ?
           (
             context => $context,
             column => $column,
            ) : ()),
      }, $class;
    } else {
      # !!!! problem : got a flat error
      # warn("PROBLEM: GOT A FLAT ERROR $xE\n");
      $terr =bless {
        domain  => 0,
        level   => 2,
        code    => -1,
        message => $xE,
        file    => undef,
        line    => undef,
        str1    => undef,
        str2    => undef,
        str3    => undef,
        num1    => undef,
        num2    => undef,
        __prev_depth => 0,
      }, $class;
    }
    return $terr;
  }

    sub _callback_error {
      #print "CALLBACK\n";
      my ($xE,$prev) = @_;
      my $terr;
      $terr=XML::LibXML::Error->new($xE);
      if ($terr->{level} == XML_ERR_WARNING and $WARNINGS!=2) {
        warn $terr if $WARNINGS;
        return $prev;
      }
      #unless ( defined $terr->{file} and length $terr->{file} ) {
        # this would make it easier to recognize parsed strings
        # but it breaks old implementations
        # [CG] $terr->{file} = 'string()';
      #}
      #warn "Saving the error ",$terr->dump;

      if (ref($prev))
      {
          if ($prev->__prev_depth()  >= $MAX_ERROR_PREV_DEPTH)
          {
              return $prev;
          }
          $terr->{_prev} = $prev;
          $terr->{__prev_depth} = $prev->__prev_depth() + 1;
      }
      else
      {
          $terr->{_prev} = defined($prev) && length($prev) ? XML::LibXML::Error->new($prev) : undef;
      }
      return $terr;
    }
    sub _instant_error_callback {
      my $xE = shift;
      my $terr= XML::LibXML::Error->new($xE);
      print "Reporting an instanteous error ",$terr->dump;
      die $terr;
    }
    sub _report_warning {
      my ($saved_error) = @_;
      #print "CALLBACK WARN\n";
      if ( defined $saved_error ) {
        #print "reporting a warning ",$saved_error->dump;
        warn $saved_error;
      }
    }
    sub _report_error {
      my ($saved_error) = @_;
      #print "CALLBACK ERROR: $saved_error\n";
      if ( defined $saved_error ) {
        die $saved_error;
      }
    }
}


# backward compatibility
sub int1 { $_[0]->num1 }
sub int2 { $_[0]->num2 }

sub domain {
    my ($self)=@_;
    return undef unless ref($self);
    my $domain = $self->{domain};
    # Newer versions of libxml2 might yield errors in domains that aren't
    # listed above.  Invent something reasonable in that case.
    return $domain < @error_domains ? $error_domains[$domain] : "domain_$domain";
}

sub as_string {
    my ($self)=@_;
    my $msg = "";
    my $level;

    if (defined($self->{_prev})) {
        $msg = $self->{_prev}->as_string;
    }

    if ($self->{level} == XML_ERR_NONE) {
        $level = "";
    } elsif ($self->{level} == XML_ERR_WARNING) {
        $level = "warning";
    } elsif ($self->{level} == XML_ERR_ERROR ||
             $self->{level} == XML_ERR_FATAL) {
        $level = "error";
    }
    my $where="";
    if (defined($self->{file})) {
        $where="$self->{file}:$self->{line}";
    } elsif (($self->{domain} == XML_ERR_FROM_PARSER)
             and
             $self->{line})  {
        $where="Entity: line $self->{line}";
    }
    if ($self->{nodename}) {
        $where.=": element ".$self->{nodename};
    }
    $msg.=$where.": " if $where ne "";
    $msg.=$self->domain." ".$level." :";
    my $str=$self->{message}||"";
    chomp($str);
    $msg.=" ".$str."\n";
    if (($self->{domain} == XML_ERR_FROM_XPATH) and
          defined($self->{str1})) {
      $msg.=$self->{str1}."\n";
      $msg.=(" " x $self->{num1})."^\n";
    } elsif (defined $self->{context}) {
      # If the error relates to character-encoding problems in the context,
      # then doing textual operations on it will spew warnings that
      # XML::LibXML can do nothing to fix.  So just disable all such
      # warnings.  This has the pleasing benefit of making the test suite
      # run warning-free.
      no warnings 'utf8';
      my $context = Encode::encode('UTF-8', $self->{context});
      $msg.=$context."\n";
      $context = substr($context,0,$self->{column});
      $context=~s/[^\t]/ /g;
      $msg.=$context."^\n";
    }
    return $msg;
}

sub dump {
  my ($self)=@_;
  require Data::Dumper;
  return Data::Dumper->new([$self],['error'])->Dump;
}

1;