WebHACC/Language/CSSInline.pm

package WebHACC::Language::CSSInline;
use strict;
require WebHACC::Language::CSS;
push our @ISA, 'WebHACC::Language::CSS';

sub generate_syntax_error_section ($) {
  my $self = shift;
  
  my $out = $self->output;
  
  $self->result->layer_uncertain ('charset');

  $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 $p = $self->get_css_parser ();
  $p->init;
  $p->{onerror} = sub {
    my (%opt) = @_;
    if (not defined $opt{value} and defined $opt{token}) {
      $opt{value} = Whatpm::CSS::Tokenizer->serialize_token ($opt{token});
    }
    $result->add_error (%opt, layer => 'syntax');
  };
  $p->{href} = $input->url;
  $p->{base_uri} = $input->{base_uri};

#  if ($parse_mode eq 'q') {
#    $p->{unitless_px} = 1;
#    $p->{hashless_color} = 1;
#  }

## TODO: Make $input->{s} a ref.

  my $s = \$input->{s};
  unless ($input->{is_char_string}) {
    my $charset;
    $self->result->layer_uncertain ('encode');
    require Encode;
    if (defined $input->{charset}) {## TODO: IANA->Perl
      $charset = $input->{charset};
      $s = \(Encode::decode ($input->{charset}, $$s));
    } else {
      ## TODO: charset detection
      $s = \(Encode::decode ($charset = 'utf-8', $$s));
    }
    $self->{source_charset} = $charset;
  }
  
  $self->{structure} = $p->parse_char_string_as_inline ($$s);

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

sub source_charset ($) {
  return shift->{source_charset};
} # source_charset

1;
1	wakaba	1.1	package WebHACC::Language::CSSInline;
2			use strict;
3			require WebHACC::Language::CSS;
4			push our @ISA, 'WebHACC::Language::CSS';
5
6			sub generate_syntax_error_section ($) {
7			my $self = shift;
8
9			my $out = $self->output;
10
11			$self->result->layer_uncertain ('charset');
12
13			$out->start_section (role => 'parse-errors');
14			$out->start_error_list (role => 'parse-errors');
15			$self->result->layer_applicable ('syntax');
16
17			my $input = $self->input;
18			my $result = $self->result;
19
20			my $p = $self->get_css_parser ();
21			$p->init;
22			$p->{onerror} = sub {
23			my (%opt) = @_;
24			if (not defined $opt{value} and defined $opt{token}) {
25			$opt{value} = Whatpm::CSS::Tokenizer->serialize_token ($opt{token});
26			}
27			$result->add_error (%opt, layer => 'syntax');
28			};
29			$p->{href} = $input->url;
30			$p->{base_uri} = $input->{base_uri};
31
32			# if ($parse_mode eq 'q') {
33			# $p->{unitless_px} = 1;
34			# $p->{hashless_color} = 1;
35			# }
36
37			## TODO: Make $input->{s} a ref.
38
39			my $s = \$input->{s};
40			unless ($input->{is_char_string}) {
41			my $charset;
42			$self->result->layer_uncertain ('encode');
43			require Encode;
44			if (defined $input->{charset}) {## TODO: IANA->Perl
45			$charset = $input->{charset};
46			$s = \(Encode::decode ($input->{charset}, $$s));
47			} else {
48			## TODO: charset detection
49			$s = \(Encode::decode ($charset = 'utf-8', $$s));
50			}
51			$self->{source_charset} = $charset;
52			}
53
54			$self->{structure} = $p->parse_char_string_as_inline ($$s);
55
56			$out->end_error_list (role => 'parse-errors');
57			$out->end_section;
58			} # generate_syntax_error_section
59
60			sub source_charset ($) {
61			return shift->{source_charset};
62			} # source_charset
63
64			1;