WebHACC/Language/H2H.pm

package WebHACC::Language::H2H;
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 Encode;
  require Whatpm::H2H;
  
  $self->result->layer_uncertain ('encode');
  $self->result->layer_uncertain ('charset');

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

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

  my $dom = Message::DOM::DOMImplementation->new;
  my $doc = $dom->create_document;

  $input->{charset} ||= 'euc-jp';
  my $t = \($input->{s});
  unless ($input->{is_char_string}) {
    $t = \(Encode::decode ($input->{charset}, $$t));
    $self->result->layer_applicable ('encode');
  }
    
  Whatpm::H2H->parse_string ($$t => $doc);

  $self->{structure} = $doc;

  $doc->manakai_charset ($input->{official_charset})
      if defined $input->{official_charset};

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

  $doc->input_encoding ($input->{charset})
      unless $input->isa ('WebHACC::Input::Text');

  $out->end_error_list (role => 'parse-errors');
  $out->end_section;
} # generate_syntax_error_section

sub source_charset ($) {
  my $self = shift;
  return $self->input->{charset} || $self->{structure}->input_encoding;
} # source_charset

1;
1	wakaba	1.1	package WebHACC::Language::H2H;
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::DOMImplementation;
14			require Encode;
15			require Whatpm::H2H;
16
17			$self->result->layer_uncertain ('encode');
18			$self->result->layer_uncertain ('charset');
19
20			my $out = $self->output;
21			$out->start_section (role => 'parse-errors');
22			$out->start_error_list (role => 'parse-errors');
23			$self->result->layer_applicable ('syntax');
24
25			my $input = $self->input;
26			my $result = $self->result;
27
28			my $dom = Message::DOM::DOMImplementation->new;
29			my $doc = $dom->create_document;
30
31			$input->{charset} \|\|= 'euc-jp';
32			my $t = \($input->{s});
33			unless ($input->{is_char_string}) {
34			$t = \(Encode::decode ($input->{charset}, $$t));
35			$self->result->layer_applicable ('encode');
36			}
37
38			Whatpm::H2H->parse_string ($$t => $doc);
39
40			$self->{structure} = $doc;
41
42			$doc->manakai_charset ($input->{official_charset})
43			if defined $input->{official_charset};
44
45			$doc->document_uri ($input->url);
46			$doc->manakai_entity_base_uri ($input->{base_uri});
47
48			$doc->input_encoding ($input->{charset})
49			unless $input->isa ('WebHACC::Input::Text');
50
51			$out->end_error_list (role => 'parse-errors');
52			$out->end_section;
53			} # generate_syntax_error_section
54
55			sub source_charset ($) {
56			my $self = shift;
57			return $self->input->{charset} \|\| $self->{structure}->input_encoding;
58			} # source_charset
59
60			1;