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::XMLParserTemp;

  my $out = $self->output;
  $out->start_section (id => 'parse-errors', title => 'Parse Errors');
  $out->start_tag ('dl', class => 'parse-errors-list');

  my $input = $self->input;
  my $result = $self->result;

  my $onerror = sub {
    my $err = shift;
    my $line = $err->location->line_number;
    $out->start_tag ('dt');
    $out->xref (qq[Line $line], target => 'line-' . $line);
    $out->html (' column ' . $err->location->column_number . '<dd>');
    $out->text ($err->text);

    add_error ('syntax', {type => $err->text,
                level => [
                          $err->SEVERITY_FATAL_ERROR => 'm',
                          $err->SEVERITY_ERROR => 'm',
                          $err->SEVERITY_WARNING => 's',
                         ]->[$err->severity]} => $result);

    return 1;
  };

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

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

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

  $out->end_tag ('dl');
  $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			require Message::DOM::XMLParserTemp;
14
15			my $out = $self->output;
16			$out->start_section (id => 'parse-errors', title => 'Parse Errors');
17			$out->start_tag ('dl', class => 'parse-errors-list');
18
19			my $input = $self->input;
20			my $result = $self->result;
21
22			my $onerror = sub {
23			my $err = shift;
24			my $line = $err->location->line_number;
25			$out->start_tag ('dt');
26			$out->xref (qq[Line $line], target => 'line-' . $line);
27			$out->html (' column ' . $err->location->column_number . '<dd>');
28			$out->text ($err->text);
29
30			add_error ('syntax', {type => $err->text,
31			level => [
32			$err->SEVERITY_FATAL_ERROR => 'm',
33			$err->SEVERITY_ERROR => 'm',
34			$err->SEVERITY_WARNING => 's',
35			]->[$err->severity]} => $result);
36
37			return 1;
38			};
39
40			my $t = \($input->{s});
41			if ($input->{is_char_string}) {
42			require Encode;
43			$t = \(Encode::encode ('utf8', $$t));
44			$input->{charset} = 'utf-8';
45			}
46
47			open my $fh, '<', $t;
48			my $doc = Message::DOM::XMLParserTemp->parse_byte_stream
49			($fh => $dom, $onerror, charset => $input->{charset});
50			$doc->manakai_charset ($input->{official_charset})
51			if defined $input->{official_charset};
52
53			$doc->document_uri ($input->{uri});
54			$doc->manakai_entity_base_uri ($input->{base_uri});
55
56			$out->end_tag ('dl');
57			$out->end_section;
58			} # generate_syntax_error_section
59
60			sub source_charset ($) {
61			my $self = shift;
62			return $self->input->{charset} \|\| ($self->{structure}->owner_document \|\| $self->{structure})->input_encoding;
63			## TODO: Can we always use input_encoding?
64			} # source_charset
65
66			1;