WebHACC/Language/XML.pm

package WebHACC::Language::XML;
use strict;
require WebHACC::Language::DOM;
push our @ISA, 'WebHACC::Language::DOM';

sub new ($) {
  return bless {}, shift;
} # new

sub generate_syntax_error_section ($) {
  my $self = shift;
  
  require Message::DOM::DOMImplementation;
  require Message::DOM::XMLParserTemp;

  $self->result->layer_uncertain ('charset');

  my $out = $self->output;
  $out->start_section (role => 'parse-errors');
  $out->start_error_list (role => 'parse-errors');

  my $input = $self->input;
  my $result = $self->result;
  $self->result->layer_applicable ('syntax');

  my $onerror = sub {
    my $err = shift;
    $result->add_error (line => $err->location->line_number,
                        column => $err->location->column_number,
                        type => 'xml parse error',
                        value => $err->text,
                        level => [
                          $err->SEVERITY_FATAL_ERROR => 'm',
                          $err->SEVERITY_ERROR => 'm',
                          $err->SEVERITY_WARNING => 's',
                        ]->[$err->severity],
                        layer => 'syntax');
    return 1;
  };

  my $t = \($input->{s});
  if ($input->{is_char_string}) {
    require Encode;
    $t = \(Encode::encode ('utf8', $$t));
    $input->{charset} = 'utf-8';
  } else {
    $self->result->layer_uncertain ('encode');
  }

  open my $fh, '<', $t;
  my $dom = Message::DOM::DOMImplementation->new;
  $self->{structure} = Message::DOM::XMLParserTemp->parse_byte_stream
      ($fh => $dom, $onerror, charset => $input->{charset});
  $self->{structure}->manakai_charset ($input->{official_charset})
      if defined $input->{official_charset};

  $self->{structure}->document_uri ($input->{uri});
  $self->{structure}->manakai_entity_base_uri ($input->{base_uri});

  $out->end_error_list;
  $out->end_section;
} # generate_syntax_error_section

sub source_charset ($) {
  my $self = shift;
  return $self->input->{charset} || ($self->{structure}->owner_document || $self->{structure})->input_encoding;
  ## TODO: Can we always use input_encoding?
} # source_charset

1;
1	wakaba	1.1	package WebHACC::Language::XML;
2			use strict;
3			require WebHACC::Language::DOM;
4			push our @ISA, 'WebHACC::Language::DOM';
5
6			sub new ($) {
7			return bless {}, shift;
8			} # new
9
10			sub generate_syntax_error_section ($) {
11			my $self = shift;
12
13	wakaba	1.4	require Message::DOM::DOMImplementation;
14	wakaba	1.1	require Message::DOM::XMLParserTemp;
15
16	wakaba	1.5	$self->result->layer_uncertain ('charset');
17
18	wakaba	1.1	my $out = $self->output;
19	wakaba	1.3	$out->start_section (role => 'parse-errors');
20			$out->start_error_list (role => 'parse-errors');
21	wakaba	1.1
22			my $input = $self->input;
23			my $result = $self->result;
24	wakaba	1.5	$self->result->layer_applicable ('syntax');
25	wakaba	1.1
26			my $onerror = sub {
27			my $err = shift;
28	wakaba	1.2	$result->add_error (line => $err->location->line_number,
29			column => $err->location->column_number,
30			type => 'xml parse error',
31			value => $err->text,
32			level => [
33	wakaba	1.1	$err->SEVERITY_FATAL_ERROR => 'm',
34			$err->SEVERITY_ERROR => 'm',
35			$err->SEVERITY_WARNING => 's',
36	wakaba	1.2	]->[$err->severity],
37			layer => 'syntax');
38	wakaba	1.1	return 1;
39			};
40
41			my $t = \($input->{s});
42			if ($input->{is_char_string}) {
43			require Encode;
44			$t = \(Encode::encode ('utf8', $$t));
45			$input->{charset} = 'utf-8';
46	wakaba	1.6	} else {
47			$self->result->layer_uncertain ('encode');
48	wakaba	1.1	}
49
50			open my $fh, '<', $t;
51	wakaba	1.4	my $dom = Message::DOM::DOMImplementation->new;
52			$self->{structure} = Message::DOM::XMLParserTemp->parse_byte_stream
53	wakaba	1.1	($fh => $dom, $onerror, charset => $input->{charset});
54	wakaba	1.4	$self->{structure}->manakai_charset ($input->{official_charset})
55	wakaba	1.1	if defined $input->{official_charset};
56
57	wakaba	1.4	$self->{structure}->document_uri ($input->{uri});
58			$self->{structure}->manakai_entity_base_uri ($input->{base_uri});
59	wakaba	1.1
60	wakaba	1.3	$out->end_error_list;
61	wakaba	1.1	$out->end_section;
62			} # generate_syntax_error_section
63
64			sub source_charset ($) {
65			my $self = shift;
66			return $self->input->{charset} \|\| ($self->{structure}->owner_document \|\| $self->{structure})->input_encoding;
67			## TODO: Can we always use input_encoding?
68			} # source_charset
69
70			1;