/[suikacvs]/markup/html/whatpm/Whatpm/ContentChecker.pm
Suika

Diff of /markup/html/whatpm/Whatpm/ContentChecker.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.5 by wakaba, Sun May 13 08:45:47 2007 UTC revision 1.97 by wakaba, Sun Sep 21 09:45:02 2008 UTC
# Line 1  Line 1 
1  package Whatpm::ContentChecker;  package Whatpm::ContentChecker;
2  use strict;  use strict;
3    our $VERSION=do{my @r=(q$Revision$=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
4    
5  ## ANY  require Whatpm::URIChecker;
 my $AnyChecker = sub {  
   my ($self, $todo) = @_;  
   my $el = $todo->{node};  
   my $new_todos = [];  
   my @nodes = (@{$el->child_nodes});  
   while (@nodes) {  
     my $node = shift @nodes;  
     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
     my $nt = $node->node_type;  
     if ($nt == 1) {  
       my $node_ns = $node->namespace_uri;  
       $node_ns = '' unless defined $node_ns;  
       my $node_ln = $node->manakai_local_name;  
       if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       }  
       push @$new_todos, {type => 'element', node => $node};  
     } elsif ($nt == 5) {  
       unshift @nodes, @{$node->child_nodes};  
     }  
   }  
   return ($new_todos);  
 }; # $AnyChecker  
   
 my $ElementDefault = {  
   checker => sub {  
     my ($self, $todo) = @_;  
     $self->{onerror}->(node => $todo->{node}, type => 'element not supported');  
     return $AnyChecker->($self, $todo);  
   },  
 };  
   
 my $Element = {};  
6    
7  my $HTML_NS = q<http://www.w3.org/1999/xhtml>;  ## ISSUE: How XML and XML Namespaces conformance can (or cannot)
8    ## be applied to an in-memory representation (i.e. DOM)?
9    
10  my $HTMLMetadataElements = [  ## TODO: Conformance of an HTML document with non-html root element.
   [$HTML_NS, 'link'],  
   [$HTML_NS, 'meta'],  
   [$HTML_NS, 'style'],  
   [$HTML_NS, 'script'],  
   [$HTML_NS, 'event-source'],  
   [$HTML_NS, 'command'],  
   [$HTML_NS, 'base'],  
   [$HTML_NS, 'title'],  
 ];  
11    
12  my $HTMLSectioningElements = {  ## Stability
13    $HTML_NS => {qw/body 1 section 1 nav 1 article 1 blockquote 1 aside 1/},  sub FEATURE_STATUS_REC () { 0b1 } ## Interoperable standard
14  };  sub FEATURE_STATUS_CR () { 0b10 } ## Call for implementation
15    sub FEATURE_STATUS_LC () { 0b100 } ## Last call for comments
16    sub FEATURE_STATUS_WD () { 0b1000 } ## Working or editor's draft
17    
18  my $HTMLBlockLevelElements = [  ## Deprecated
19    [$HTML_NS, 'section'],  sub FEATURE_DEPRECATED_SHOULD () { 0b100000 } ## SHOULD-level
20    [$HTML_NS, 'nav'],  sub FEATURE_DEPRECATED_INFO () { 0b1000000 } ## Does not affect conformance
   [$HTML_NS, 'article'],  
   [$HTML_NS, 'blockquote'],  
   [$HTML_NS, 'aside'],  
   [$HTML_NS, 'h1'],  
   [$HTML_NS, 'h2'],  
   [$HTML_NS, 'h3'],  
   [$HTML_NS, 'h4'],  
   [$HTML_NS, 'h5'],  
   [$HTML_NS, 'h6'],  
   [$HTML_NS, 'header'],  
   [$HTML_NS, 'footer'],  
   [$HTML_NS, 'address'],  
   [$HTML_NS, 'p'],  
   [$HTML_NS, 'hr'],  
   [$HTML_NS, 'dialog'],  
   [$HTML_NS, 'pre'],  
   [$HTML_NS, 'ol'],  
   [$HTML_NS, 'ul'],  
   [$HTML_NS, 'dl'],  
   [$HTML_NS, 'ins'],  
   [$HTML_NS, 'del'],  
   [$HTML_NS, 'figure'],  
   [$HTML_NS, 'map'],  
   [$HTML_NS, 'table'],  
   [$HTML_NS, 'script'],  
   [$HTML_NS, 'noscript'],  
   [$HTML_NS, 'event-source'],  
   [$HTML_NS, 'details'],  
   [$HTML_NS, 'datagrid'],  
   [$HTML_NS, 'menu'],  
   [$HTML_NS, 'div'],  
   [$HTML_NS, 'font'],  
 ];  
   
 my $HTMLStrictlyInlineLevelElements = [  
   [$HTML_NS, 'br'],  
   [$HTML_NS, 'a'],  
   [$HTML_NS, 'q'],  
   [$HTML_NS, 'cite'],  
   [$HTML_NS, 'em'],  
   [$HTML_NS, 'strong'],  
   [$HTML_NS, 'small'],  
   [$HTML_NS, 'm'],  
   [$HTML_NS, 'dfn'],  
   [$HTML_NS, 'abbr'],  
   [$HTML_NS, 'time'],  
   [$HTML_NS, 'meter'],  
   [$HTML_NS, 'progress'],  
   [$HTML_NS, 'code'],  
   [$HTML_NS, 'var'],  
   [$HTML_NS, 'samp'],  
   [$HTML_NS, 'kbd'],  
   [$HTML_NS, 'sub'],  
   [$HTML_NS, 'sup'],  
   [$HTML_NS, 'span'],  
   [$HTML_NS, 'i'],  
   [$HTML_NS, 'b'],  
   [$HTML_NS, 'bdo'],  
   [$HTML_NS, 'ins'],  
   [$HTML_NS, 'del'],  
   [$HTML_NS, 'img'],  
   [$HTML_NS, 'iframe'],  
   [$HTML_NS, 'embed'],  
   [$HTML_NS, 'object'],  
   [$HTML_NS, 'video'],  
   [$HTML_NS, 'audio'],  
   [$HTML_NS, 'canvas'],  
   [$HTML_NS, 'area'],  
   [$HTML_NS, 'script'],  
   [$HTML_NS, 'noscript'],  
   [$HTML_NS, 'event-source'],  
   [$HTML_NS, 'command'],  
   [$HTML_NS, 'font'],  
 ];  
   
 my $HTMLStructuredInlineLevelElements = [  
   [$HTML_NS, 'blockquote'],  
   [$HTML_NS, 'pre'],  
   [$HTML_NS, 'ol'],  
   [$HTML_NS, 'ul'],  
   [$HTML_NS, 'dl'],  
   [$HTML_NS, 'table'],  
   [$HTML_NS, 'menu'],  
 ];  
   
 my $HTMLInteractiveElements = [  
   [$HTML_NS, 'a'],  
   [$HTML_NS, 'details'],  
   [$HTML_NS, 'datagrid'],  
 ];  
   
 my $HTMLTransparentElements = [  
   [$HTML_NS, 'ins'],  
   [$HTML_NS, 'font'],  
   [$HTML_NS, 'noscript'], ## NOTE: If scripting is disabled.  
 ];  
   
 #my $HTMLSemiTransparentElements = [  
 #  [$HTML_NS, 'video'],  
 #  [$HTML_NS, 'audio'],  
 #];  
   
 my $HTMLEmbededElements = [  
   [$HTML_NS, 'img'],  
   [$HTML_NS, 'iframe'],  
   [$HTML_NS, 'embed'],  
   [$HTML_NS, 'object'],  
   [$HTML_NS, 'video'],  
   [$HTML_NS, 'audio'],  
   [$HTML_NS, 'canvas'],  
 ];  
21    
22  ## Empty  ## Conformance
23  my $HTMLEmptyChecker = sub {  sub FEATURE_ALLOWED () { 0b10000 }
   my ($self, $todo) = @_;  
   my $el = $todo->{node};  
   my $new_todos = [];  
   my @nodes = (@{$el->child_nodes});  
24    
25    while (@nodes) {  my $HTML_NS = q<http://www.w3.org/1999/xhtml>;
26      my $node = shift @nodes;  my $XML_NS = q<http://www.w3.org/XML/1998/namespace>;
27      $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  my $XMLNS_NS = q<http://www.w3.org/2000/xmlns/>;
   
     my $nt = $node->node_type;  
     if ($nt == 1) {  
       ## NOTE: |minuses| list is not checked since redundant  
       $self->{onerror}->(node => $node, type => 'element not allowed');  
       my ($sib, $ch) = $self->_check_get_children ($node);  
       unshift @nodes, @$sib;  
       push @$new_todos, @$ch;  
     } elsif ($nt == 3 or $nt == 4) {  
       if ($node->data =~ /[^\x09-\x0D\x20]/) {  
         $self->{onerror}->(node => $node, type => 'character not allowed');  
       }  
     } elsif ($nt == 5) {  
       unshift @nodes, @{$node->child_nodes};  
     }  
   }  
   return ($new_todos);  
 };  
   
 ## Text  
 my $HTMLTextChecker = sub {  
   my ($self, $todo) = @_;  
   my $el = $todo->{node};  
   my $new_todos = [];  
   my @nodes = (@{$el->child_nodes});  
28    
29    while (@nodes) {  my $Namespace = {
30      my $node = shift @nodes;    '' => {loaded => 1},
31      $self->_remove_minuses ($node) and next if ref $node eq 'HASH';    q<http://www.w3.org/2005/Atom> => {module => 'Whatpm::ContentChecker::Atom'},
32      q<http://purl.org/syndication/history/1.0>
33      my $nt = $node->node_type;        => {module => 'Whatpm::ContentChecker::Atom'},
34      if ($nt == 1) {    q<http://purl.org/syndication/threading/1.0>
35        ## NOTE: |minuses| list is not checked since redundant        => {module => 'Whatpm::ContentChecker::Atom'},
36        $self->{onerror}->(node => $node, type => 'element not allowed');    $HTML_NS => {module => 'Whatpm::ContentChecker::HTML'},
37        my ($sib, $ch) = $self->_check_get_children ($node);    $XML_NS => {loaded => 1},
38        unshift @nodes, @$sib;    $XMLNS_NS => {loaded => 1},
39        push @$new_todos, @$ch;    q<http://www.w3.org/1999/02/22-rdf-syntax-ns#> => {loaded => 1},
40      } elsif ($nt == 5) {  };
41        unshift @nodes, @{$node->child_nodes};  
42    sub load_ns_module ($) {
43      my $nsuri = shift; # namespace URI or ''
44      unless ($Namespace->{$nsuri}->{loaded}) {
45        if ($Namespace->{$nsuri}->{module}) {
46          eval qq{ require $Namespace->{$nsuri}->{module} } or die $@;
47        } else {
48          $Namespace->{$nsuri}->{loaded} = 1;
49      }      }
50    }    }
51    return ($new_todos);  } # load_ns_module
 };  
52    
53  ## Zero or more |html:style| elements,  our $AttrChecker = {
54  ## followed by zero or more block-level elements    $XML_NS => {
55  my $HTMLStylableBlockChecker = sub {      space => sub {
56    my ($self, $todo) = @_;        my ($self, $attr) = @_;
57    my $el = $todo->{node};        my $value = $attr->value;
58    my $new_todos = [];        if ($value eq 'default' or $value eq 'preserve') {
59    my @nodes = (@{$el->child_nodes});          #
     
   my $has_non_style;  
   while (@nodes) {  
     my $node = shift @nodes;  
     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
     my $nt = $node->node_type;  
     if ($nt == 1) {  
       my $node_ns = $node->namespace_uri;  
       $node_ns = '' unless defined $node_ns;  
       my $node_ln = $node->manakai_local_name;  
       if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       }  
       if ($node->manakai_element_type_match ($HTML_NS, 'style')) {  
         if ($has_non_style) {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         }  
60        } else {        } else {
61          $has_non_style = 1;          ## NOTE: An XML "error"
62          CHK: {          $self->{onerror}->(node => $attr, level => $self->{level}->{xml_error},
63            for (@{$HTMLBlockLevelElements}) {                             type => 'invalid attribute value');
64              if ($node->manakai_element_type_match ($_->[0], $_->[1])) {        }
65                last CHK;      },
66              }      lang => sub {
67            }        my ($self, $attr) = @_;
68            $self->{onerror}->(node => $node, type => 'element not allowed');        my $value = $attr->value;
69          } # CHK        if ($value eq '') {
70        }          #
       my ($sib, $ch) = $self->_check_get_children ($node);  
       unshift @nodes, @$sib;  
       push @$new_todos, @$ch;  
     } elsif ($nt == 3 or $nt == 4) {  
       if ($node->data =~ /[^\x09-\x0D\x20]/) {  
         $self->{onerror}->(node => $node, type => 'character not allowed');  
       }  
     } elsif ($nt == 5) {  
       unshift @nodes, @{$node->child_nodes};  
     }  
   }  
   return ($new_todos);  
 }; # $HTMLStylableBlockChecker  
   
 ## Zero or more block-level elements  
 my $HTMLBlockChecker = sub {  
   my ($self, $todo) = @_;  
   my $el = $todo->{node};  
   my $new_todos = [];  
   my @nodes = (@{$el->child_nodes});  
     
   while (@nodes) {  
     my $node = shift @nodes;  
     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
     my $nt = $node->node_type;  
     if ($nt == 1) {  
       my $node_ns = $node->namespace_uri;  
       $node_ns = '' unless defined $node_ns;  
       my $node_ln = $node->manakai_local_name;  
       if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       }  
       CHK: {  
         for (@{$HTMLBlockLevelElements}) {  
           if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
             last CHK;  
           }  
         }  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       } # CHK  
       my ($sib, $ch) = $self->_check_get_children ($node);  
       unshift @nodes, @$sib;  
       push @$new_todos, @$ch;  
     } elsif ($nt == 3 or $nt == 4) {  
       if ($node->data =~ /[^\x09-\x0D\x20]/) {  
         $self->{onerror}->(node => $node, type => 'character not allowed');  
       }  
     } elsif ($nt == 5) {  
       unshift @nodes, @{$node->child_nodes};  
     }  
   }  
   return ($new_todos);  
 }; # $HTMLBlockChecker  
   
 ## Inline-level content  
 my $HTMLInlineChecker = sub {  
   my ($self, $todo) = @_;  
   my $el = $todo->{node};  
   my $new_todos = [];  
   my @nodes = (@{$el->child_nodes});  
     
   while (@nodes) {  
     my $node = shift @nodes;  
     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
     my $nt = $node->node_type;  
     if ($nt == 1) {  
       my $node_ns = $node->namespace_uri;  
       $node_ns = '' unless defined $node_ns;  
       my $node_ln = $node->manakai_local_name;  
       if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       }  
       CHK: {  
         for (@{$HTMLStrictlyInlineLevelElements},  
              @{$HTMLStructuredInlineLevelElements}) {  
           if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
             last CHK;  
           }  
         }  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       } # CHK  
       my ($sib, $ch) = $self->_check_get_children ($node);  
       unshift @nodes, @$sib;  
       push @$new_todos, @$ch;  
     } elsif ($nt == 5) {  
       unshift @nodes, @{$node->child_nodes};  
     }  
   }  
   
   for (@$new_todos) {  
     $_->{inline} = 1;  
   }  
   return ($new_todos);  
 }; # $HTMLInlineChecker  
   
 my $HTMLSignificantInlineChecker = $HTMLInlineChecker;  
 ## TODO: check significant content  
   
 ## Strictly inline-level content  
 my $HTMLStrictlyInlineChecker = sub {  
   my ($self, $todo) = @_;  
   my $el = $todo->{node};  
   my $new_todos = [];  
   my @nodes = (@{$el->child_nodes});  
     
   while (@nodes) {  
     my $node = shift @nodes;  
     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
     my $nt = $node->node_type;  
     if ($nt == 1) {  
       my $node_ns = $node->namespace_uri;  
       $node_ns = '' unless defined $node_ns;  
       my $node_ln = $node->manakai_local_name;  
       if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       }  
       CHK: {  
         for (@{$HTMLStrictlyInlineLevelElements}) {  
           if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
             last CHK;  
           }  
         }  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       } # CHK  
       my ($sib, $ch) = $self->_check_get_children ($node);  
       unshift @nodes, @$sib;  
       push @$new_todos, @$ch;  
     } elsif ($nt == 5) {  
       unshift @nodes, @{$node->child_nodes};  
     }  
   }  
   
   for (@$new_todos) {  
     $_->{inline} = 1;  
     $_->{strictly_inline} = 1;  
   }  
   return ($new_todos);  
 }; # $HTMLStrictlyInlineChecker  
   
 my $HTMLSignificantStrictlyInlineChecker = $HTMLStrictlyInlineChecker;  
 ## TODO: check significant content  
   
 ## Inline-level or strictly inline-kevek content  
 my $HTMLInlineOrStrictlyInlineChecker = sub {  
   my ($self, $todo) = @_;  
   my $el = $todo->{node};  
   my $new_todos = [];  
   my @nodes = (@{$el->child_nodes});  
     
   while (@nodes) {  
     my $node = shift @nodes;  
     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
     my $nt = $node->node_type;  
     if ($nt == 1) {  
       my $node_ns = $node->namespace_uri;  
       $node_ns = '' unless defined $node_ns;  
       my $node_ln = $node->manakai_local_name;  
       if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       }  
       CHK: {  
         for (@{$HTMLStrictlyInlineLevelElements},  
              $todo->{strictly_inline} ? () : @{$HTMLStructuredInlineLevelElements}) {  
           if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
             last CHK;  
           }  
         }  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       } # CHK  
       my ($sib, $ch) = $self->_check_get_children ($node);  
       unshift @nodes, @$sib;  
       push @$new_todos, @$ch;  
     } elsif ($nt == 5) {  
       unshift @nodes, @{$node->child_nodes};  
     }  
   }  
   
   for (@$new_todos) {  
     $_->{inline} = 1;  
     $_->{strictly_inline} = 1;  
   }  
   return ($new_todos);  
 }; # $HTMLInlineOrStrictlyInlineChecker  
   
 my $HTMLBlockOrInlineChecker = sub {  
   my ($self, $todo) = @_;  
   my $el = $todo->{node};  
   my $new_todos = [];  
   my @nodes = (@{$el->child_nodes});  
     
   my $content = 'block-or-inline'; # or 'block' or 'inline'  
   my @block_not_inline;  
   while (@nodes) {  
     my $node = shift @nodes;  
     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
     my $nt = $node->node_type;  
     if ($nt == 1) {  
       my $node_ns = $node->namespace_uri;  
       $node_ns = '' unless defined $node_ns;  
       my $node_ln = $node->manakai_local_name;  
       if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
         $self->{onerror}->(node => $node, type => 'element not allowed');  
       }  
       if ($content eq 'block') {  
         CHK: {  
           for (@{$HTMLBlockLevelElements}) {  
             if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
               last CHK;  
             }  
           }  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         } # CHK  
       } elsif ($content eq 'inline') {  
         CHK: {  
           for (@{$HTMLStrictlyInlineLevelElements},  
                @{$HTMLStructuredInlineLevelElements}) {  
             if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
               last CHK;  
             }  
           }  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         } # CHK  
71        } else {        } else {
72          my $is_block;          require Whatpm::LangTag;
73          my $is_inline;          Whatpm::LangTag->check_rfc3066_language_tag ($value, sub {
74          for (@{$HTMLBlockLevelElements}) {            $self->{onerror}->(@_, node => $attr);
75            if ($node->manakai_element_type_match ($_->[0], $_->[1])) {          }, $self->{level});
76              $is_block = 1;        }
77              last;  
78            }        ## NOTE: "The values of the attribute are language identifiers
79          }        ## as defined by [IETF RFC 3066], Tags for the Identification
80                  ## of Languages, or its successor; in addition, the empty string
81          for (@{$HTMLStrictlyInlineLevelElements},        ## may be specified." ("may" in lower case)
82               @{$HTMLStructuredInlineLevelElements}) {        ## NOTE: Is an RFC 3066-valid (but RFC 4646-invalid) language tag
83            if ($node->manakai_element_type_match ($_->[0], $_->[1])) {        ## allowed today?
84              $is_inline = 1;  
85              last;        ## TODO: test data
86            }  
87          }        my $nsuri = $attr->owner_element->namespace_uri;
88                  if (defined $nsuri and $nsuri eq $HTML_NS) {
89          push @block_not_inline, $node if $is_block and not $is_inline;          my $lang_attr = $attr->owner_element->get_attribute_node_ns
90          unless ($is_block) {              (undef, 'lang');
91            $content = 'inline';          if ($lang_attr) {
92            for (@block_not_inline) {            my $lang_attr_value = $lang_attr->value;
93              $self->{onerror}->(node => $_, type => 'element not allowed');            $lang_attr_value =~ tr/A-Z/a-z/; ## ASCII case-insensitive
94            }            my $value = $value;
95            unless ($is_inline) {            $value =~ tr/A-Z/a-z/; ## ASCII case-insensitive
96              $self->{onerror}->(node => $node, type => 'element not allowed');            if ($lang_attr_value ne $value) {
97            }              ## NOTE: HTML5 Section "The |lang| and |xml:lang| attributes"
98          }              $self->{onerror}->(node => $attr,
99                                   type => 'xml:lang ne lang',
100                                   level => $self->{level}->{must});
101              }
102            }
103          }
104    
105          if ($attr->owner_document->manakai_is_html) { # MUST NOT
106            $self->{onerror}->(node => $attr, type => 'in HTML:xml:lang',
107                               level => $self->{level}->{must});
108    ## TODO: Test data...
109          }
110        },
111        base => sub {
112          my ($self, $attr) = @_;
113          my $value = $attr->value;
114          if ($value =~ /[^\x{0000}-\x{10FFFF}]/) { ## ISSUE: Should we disallow noncharacters?
115            $self->{onerror}->(node => $attr,
116                               type => 'invalid attribute value',
117                               level => $self->{level}->{fact}, ## TODO: correct?
118                              );
119          }
120          ## NOTE: Conformance to URI standard is not checked since there is
121          ## no author requirement on conformance in the XML Base specification.
122        },
123        id => sub {
124          my ($self, $attr) = @_;
125          my $value = $attr->value;
126          $value =~ s/[\x09\x0A\x0D\x20]+/ /g;
127          $value =~ s/^\x20//;
128          $value =~ s/\x20$//;
129          ## TODO: NCName in XML 1.0 or 1.1
130          ## TODO: declared type is ID?
131          if ($self->{id}->{$value}) {
132            $self->{onerror}->(node => $attr,
133                               type => 'duplicate ID',
134                               level => $self->{level}->{xml_id_error});
135            push @{$self->{id}->{$value}}, $attr;
136          } else {
137            $self->{id}->{$value} = [$attr];
138        }        }
139        my ($sib, $ch) = $self->_check_get_children ($node);      },
140        unshift @nodes, @$sib;    },
141        push @$new_todos, @$ch;    $XMLNS_NS => {
142      } elsif ($nt == 3 or $nt == 4) {      '' => sub {
143        if ($node->data =~ /[^\x09-\x0D\x20]/) {        my ($self, $attr) = @_;
144          if ($content eq 'block') {        my $ln = $attr->manakai_local_name;
145            $self->{onerror}->(node => $node, type => 'character not allowed');        my $value = $attr->value;
146          } else {        if ($value eq $XML_NS and $ln ne 'xml') {
147            $content = 'inline';          $self->{onerror}
148            for (@block_not_inline) {            ->(node => $attr,
149              $self->{onerror}->(node => $_, type => 'element not allowed');               type => 'Reserved Prefixes and Namespace Names:Name',
150            }               text => $value,
151          }               level => $self->{level}->{nc});
152          } elsif ($value eq $XMLNS_NS) {
153            $self->{onerror}
154              ->(node => $attr,
155                 type => 'Reserved Prefixes and Namespace Names:Name',
156                 text => $value,
157                 level => $self->{level}->{nc});
158          }
159          if ($ln eq 'xml' and $value ne $XML_NS) {
160            $self->{onerror}
161              ->(node => $attr,
162                 type => 'Reserved Prefixes and Namespace Names:Prefix',
163                 text => $ln,
164                 level => $self->{level}->{nc});
165          } elsif ($ln eq 'xmlns') {
166            $self->{onerror}
167              ->(node => $attr,
168                 type => 'Reserved Prefixes and Namespace Names:Prefix',
169                 text => $ln,
170                 level => $self->{level}->{nc});
171          }
172          ## TODO: If XML 1.0 and empty
173        },
174        xmlns => sub {
175          my ($self, $attr) = @_;
176          ## TODO: In XML 1.0, URI reference [RFC 3986] or an empty string
177          ## TODO: In XML 1.1, IRI reference [RFC 3987] or an empty string
178          ## TODO: relative references are deprecated
179          my $value = $attr->value;
180          if ($value eq $XML_NS) {
181            $self->{onerror}
182              ->(node => $attr,
183                 type => 'Reserved Prefixes and Namespace Names:Name',
184                 text => $value,
185                 level => $self->{level}->{nc});
186          } elsif ($value eq $XMLNS_NS) {
187            $self->{onerror}
188              ->(node => $attr,
189                 type => 'Reserved Prefixes and Namespace Names:Name',
190                 text => $value,
191                 level => $self->{level}->{nc});
192        }        }
193      } elsif ($nt == 5) {      },
194        unshift @nodes, @{$node->child_nodes};    },
     }  
   }  
   
   if ($content eq 'inline') {  
     for (@$new_todos) {  
       $_->{inline} = 1;  
     }  
   }  
   return ($new_todos);  
195  };  };
196    
197  ## Zero or more XXX element, then either block-level or inline-level  ## ISSUE: Should we really allow these attributes?
198  my $GetHTMLZeroOrMoreThenBlockOrInlineChecker = sub ($$) {  $AttrChecker->{''}->{'xml:space'} = $AttrChecker->{$XML_NS}->{space};
199    my ($elnsuri, $ellname) = @_;  $AttrChecker->{''}->{'xml:lang'} = $AttrChecker->{$XML_NS}->{lang};
200    return sub {      ## NOTE: Checker for (null, "xml:lang") attribute is shadowed for
201      my ($self, $todo) = @_;      ## HTML elements in Whatpm::ContentChecker::HTML.
202      my $el = $todo->{node};  $AttrChecker->{''}->{'xml:base'} = $AttrChecker->{$XML_NS}->{base};
203      my $new_todos = [];  $AttrChecker->{''}->{'xml:id'} = $AttrChecker->{$XML_NS}->{id};
204      my @nodes = (@{$el->child_nodes});  
205        our $AttrStatus;
206      my $has_non_style;  
207      my $content = 'block-or-inline'; # or 'block' or 'inline'  for (qw/space lang base id/) {
208      my @block_not_inline;    $AttrStatus->{$XML_NS}->{$_} = FEATURE_STATUS_REC | FEATURE_ALLOWED;
209      while (@nodes) {    $AttrStatus->{''}->{"xml:$_"} = FEATURE_STATUS_REC | FEATURE_ALLOWED;
210        my $node = shift @nodes;    ## XML 1.0: FEATURE_STATUS_CR
211        $self->_remove_minuses ($node) and next if ref $node eq 'HASH';    ## XML 1.1: FEATURE_STATUS_REC
212      ## XML Namespaces 1.0: FEATURE_STATUS_CR
213        my $nt = $node->node_type;    ## XML Namespaces 1.1: FEATURE_STATUS_REC
214        if ($nt == 1) {    ## XML Base: FEATURE_STATUS_REC
215          my $node_ns = $node->namespace_uri;    ## xml:id: FEATURE_STATUS_REC
216          $node_ns = '' unless defined $node_ns;  }
217          my $node_ln = $node->manakai_local_name;  
218          if ($self->{minuses}->{$node_ns}->{$node_ln}) {  $AttrStatus->{$XMLNS_NS}->{''} = FEATURE_STATUS_REC | FEATURE_ALLOWED;
219            $self->{onerror}->(node => $node, type => 'element not allowed');  
220          }  ## TODO: xsi:schemaLocation for XHTML2 support (very, very low priority)
221          if ($node->manakai_element_type_match ($elnsuri, $ellname)) {  
222            if ($has_non_style) {  our %AnyChecker = (
223              $self->{onerror}->(node => $node, type => 'element not allowed');    check_start => sub { },
224            }    check_attrs => sub {
225          } elsif ($content eq 'block') {      my ($self, $item, $element_state) = @_;
226            $has_non_style = 1;      for my $attr (@{$item->{node}->attributes}) {
227            CHK: {        my $attr_ns = $attr->namespace_uri;
228              for (@{$HTMLBlockLevelElements}) {        if (defined $attr_ns) {
229                if ($node->manakai_element_type_match ($_->[0], $_->[1])) {          load_ns_module ($attr_ns);
230                  last CHK;        } else {
231                }          $attr_ns = '';
             }  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           } # CHK  
         } elsif ($content eq 'inline') {  
           $has_non_style = 1;  
           CHK: {  
             for (@{$HTMLStrictlyInlineLevelElements},  
                  @{$HTMLStructuredInlineLevelElements}) {  
               if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
                 last CHK;  
               }  
             }  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           } # CHK  
         } else {  
           $has_non_style = 1;  
           my $is_block;  
           my $is_inline;  
           for (@{$HTMLBlockLevelElements}) {  
             if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
               $is_block = 1;  
               last;  
             }  
           }  
             
           for (@{$HTMLStrictlyInlineLevelElements},  
                @{$HTMLStructuredInlineLevelElements}) {  
             if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
               $is_inline = 1;  
               last;  
             }  
           }  
               
           push @block_not_inline, $node if $is_block and not $is_inline;  
           unless ($is_block) {  
             $content = 'inline';  
             for (@block_not_inline) {  
               $self->{onerror}->(node => $_, type => 'element not allowed');  
             }  
             unless ($is_inline) {  
               $self->{onerror}->(node => $node, type => 'element not allowed');  
             }  
           }  
         }  
         my ($sib, $ch) = $self->_check_get_children ($node);  
         unshift @nodes, @$sib;  
         push @$new_todos, @$ch;  
       } elsif ($nt == 3 or $nt == 4) {  
         if ($node->data =~ /[^\x09-\x0D\x20]/) {  
           $has_non_style = 1;  
           if ($content eq 'block') {  
             $self->{onerror}->(node => $node, type => 'character not allowed');  
           } else {  
             $content = 'inline';  
             for (@block_not_inline) {  
               $self->{onerror}->(node => $_, type => 'element not allowed');  
             }  
           }  
         }  
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
232        }        }
233      }        my $attr_ln = $attr->manakai_local_name;
234          
235      if ($content eq 'inline') {        my $checker = $AttrChecker->{$attr_ns}->{$attr_ln}
236        for (@$new_todos) {            || $AttrChecker->{$attr_ns}->{''};
237          $_->{inline} = 1;        my $status = $AttrStatus->{$attr_ns}->{$attr_ln}
238              || $AttrStatus->{$attr_ns}->{''};
239          if (not defined $status) {
240            $status = FEATURE_ALLOWED;
241            ## NOTE: FEATURE_ALLOWED for all attributes, since the element
242            ## is not supported and therefore "attribute not defined" error
243            ## should not raised (too verbose) and global attributes should be
244            ## allowed anyway (if a global attribute has its specified creteria
245            ## for where it may be specified, then it should be checked in it's
246            ## checker function).
247        }        }
248      }        if ($checker) {
249      return ($new_todos);          $checker->($self, $attr);
250    };        } else {
251  }; # $GetHTMLZeroOrMoreThenBlockOrInlineChecker          $self->{onerror}->(node => $attr,
252                               type => 'unknown attribute',
253  my $HTMLTransparentChecker = $HTMLBlockOrInlineChecker;                             level => $self->{level}->{uncertain});
   
 $Element->{$HTML_NS}->{html} = {  
   checker => sub {  
     my ($self, $todo) = @_;  
     my $el = $todo->{node};  
     my $new_todos = [];  
     my @nodes = (@{$el->child_nodes});  
   
     my $phase = 'before head';  
     while (@nodes) {  
       my $node = shift @nodes;  
       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
       my $nt = $node->node_type;  
       if ($nt == 1) {  
         my $node_ns = $node->namespace_uri;  
         $node_ns = '' unless defined $node_ns;  
         my $node_ln = $node->manakai_local_name;  
         if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         }  
         if ($phase eq 'before head') {  
           if ($node->manakai_element_type_match ($HTML_NS, 'head')) {  
             $phase = 'after head';              
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'body')) {  
             $self->{onerror}  
               ->(node => $node, type => 'ps element missing:head');  
             $phase = 'after body';  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
             # before head  
           }  
         } elsif ($phase eq 'after head') {  
           if ($node->manakai_element_type_match ($HTML_NS, 'body')) {  
             $phase = 'after body';  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
             # after head  
           }  
         } else { #elsif ($phase eq 'after body') {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
           # after body  
         }  
         my ($sib, $ch) = $self->_check_get_children ($node);  
         unshift @nodes, @$sib;  
         push @$new_todos, @$ch;  
       } elsif ($nt == 3 or $nt == 4) {  
         if ($node->data =~ /[^\x09-\x0D\x20]/) {  
           $self->{onerror}->(node => $node, type => 'character not allowed');  
         }  
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
254        }        }
255          $self->_attr_status_info ($attr, $status);
256      }      }
   
     if ($phase eq 'before head') {  
       $self->{onerror}->(node => $el, type => 'child element missing:head');  
       $self->{onerror}->(node => $el, type => 'child element missing:body');  
     } elsif ($phase eq 'after head') {  
       $self->{onerror}->(node => $el, type => 'child element missing:body');  
     }  
   
     return ($new_todos);  
257    },    },
258  };    check_child_element => sub {
259        my ($self, $item, $child_el, $child_nsuri, $child_ln,
260  $Element->{$HTML_NS}->{head} = {          $child_is_transparent, $element_state) = @_;
261    checker => sub {      if ($self->{minus_elements}->{$child_nsuri}->{$child_ln}) {
262      my ($self, $todo) = @_;        $self->{onerror}->(node => $child_el,
263      my $el = $todo->{node};                           type => 'element not allowed:minus',
264      my $new_todos = [];                           level => $self->{level}->{must});
265      my @nodes = (@{$el->child_nodes});      } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
266          #
267      my $has_title;      } else {
268      my $phase = 'initial'; # 'after charset', 'after base'        #
     while (@nodes) {  
       my $node = shift @nodes;  
       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
       my $nt = $node->node_type;  
       if ($nt == 1) {  
         my $node_ns = $node->namespace_uri;  
         $node_ns = '' unless defined $node_ns;  
         my $node_ln = $node->manakai_local_name;  
         if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         }  
         if ($node->manakai_element_type_match ($HTML_NS, 'title')) {  
           $phase = 'after base';  
           unless ($has_title) {  
             $has_title = 1;  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           }  
         } elsif ($node->manakai_element_type_match ($HTML_NS, 'meta')) {  
           if ($node->has_attribute_ns (undef, 'charset')) {  
             if ($phase eq 'initial') {  
               $phase = 'after charset';  
             } else {  
               $self->{onerror}->(node => $node, type => 'element not allowed');  
               ## NOTE: See also |base|'s "contexts" field in the spec  
             }  
           } else {  
             $phase = 'after base';  
           }  
         } elsif ($node->manakai_element_type_match ($HTML_NS, 'base')) {  
           if ($phase eq 'initial' or $phase eq 'after charset') {  
             $phase = 'after base';  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           }  
         } else {  
           $phase = 'after base';  
           CHK: {  
             for (@{$HTMLMetadataElements}) {  
               if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
                 last CHK;  
               }  
             }  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           } # CHK  
         }  
         my ($sib, $ch) = $self->_check_get_children ($node);  
         unshift @nodes, @$sib;  
         push @$new_todos, @$ch;  
       } elsif ($nt == 3 or $nt == 4) {  
         if ($node->data =~ /[^\x09-\x0D\x20]/) {  
           $self->{onerror}->(node => $node, type => 'character not allowed');  
         }  
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
       }  
     }  
     unless ($has_title) {  
       $self->{onerror}->(node => $el, type => 'child element missing:title');  
269      }      }
     return ($new_todos);  
270    },    },
271  };    check_child_text => sub { },
272      check_end => sub {
273  $Element->{$HTML_NS}->{title} = {      my ($self, $item, $element_state) = @_;
274    checker => $HTMLTextChecker,      ## NOTE: There is a modified copy of the code below for |html:ruby|.
275  };      if ($element_state->{has_significant}) {
276          $item->{real_parent_state}->{has_significant} = 1;
277  $Element->{$HTML_NS}->{base} = {      }    
   checker => $HTMLEmptyChecker,  
 };  
   
 $Element->{$HTML_NS}->{link} = {  
   checker => $HTMLEmptyChecker,  
 };  
   
 $Element->{$HTML_NS}->{meta} = {  
   checker => $HTMLEmptyChecker,  
 };  
   
 ## NOTE: |html:style| has no conformance creteria on content model  
 $Element->{$HTML_NS}->{style} = {  
   checker => $AnyChecker,  
 };  
   
 $Element->{$HTML_NS}->{body} = {  
   checker => $HTMLBlockChecker,  
 };  
   
 $Element->{$HTML_NS}->{section} = {  
   checker => $HTMLStylableBlockChecker,  
 };  
   
 $Element->{$HTML_NS}->{nav} = {  
   checker => $HTMLBlockOrInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{article} = {  
   checker => $HTMLStylableBlockChecker,  
 };  
   
 $Element->{$HTML_NS}->{blockquote} = {  
   checker => $HTMLBlockChecker,  
 };  
   
 $Element->{$HTML_NS}->{aside} = {  
   checker => $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'style'),  
 };  
   
 $Element->{$HTML_NS}->{h1} = {  
   checker => $HTMLSignificantStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{h2} = {  
   checker => $HTMLSignificantStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{h3} = {  
   checker => $HTMLSignificantStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{h4} = {  
   checker => $HTMLSignificantStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{h5} = {  
   checker => $HTMLSignificantStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{h6} = {  
   checker => $HTMLSignificantStrictlyInlineChecker,  
 };  
   
 ## TODO: header  
   
 $Element->{$HTML_NS}->{footer} = {  
   checker => sub { ## block -hn -header -footer -sectioning or inline  
     my ($self, $todo) = @_;  
     my $el = $todo->{node};  
     my $new_todos = [];  
     my @nodes = (@{$el->child_nodes});  
     
     my $content = 'block-or-inline'; # or 'block' or 'inline'  
     my @block_not_inline;  
     while (@nodes) {  
       my $node = shift @nodes;  
       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
       my $nt = $node->node_type;  
       if ($nt == 1) {  
         my $node_ns = $node->namespace_uri;  
         $node_ns = '' unless defined $node_ns;    
         my $node_ln = $node->manakai_local_name;  
         if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         } elsif ($node_ns eq $HTML_NS and  
                  {  
                    qw/h1 1 h2 1 h3 1 h4 1 h5 1 h6 1 header 1 footer 1/  
                  }->{$node_ln}) {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         } elsif ($HTMLSectioningElements->{$node_ns}->{$node_ln}) {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         }  
         if ($content eq 'block') {  
           CHK: {  
             for (@{$HTMLBlockLevelElements}) {  
               if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
                 last CHK;  
               }  
             }  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           } # CHK  
         } elsif ($content eq 'inline') {  
           CHK: {  
             for (@{$HTMLStrictlyInlineLevelElements},  
                  @{$HTMLStructuredInlineLevelElements}) {  
               if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
                 last CHK;  
               }  
             }  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           } # CHK  
         } else {  
           my $is_block;  
           my $is_inline;  
           for (@{$HTMLBlockLevelElements}) {  
             if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
               $is_block = 1;  
               last;  
             }  
           }  
             
           for (@{$HTMLStrictlyInlineLevelElements},  
                @{$HTMLStructuredInlineLevelElements}) {  
             if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
               $is_inline = 1;  
               last;  
             }  
           }  
             
           push @block_not_inline, $node if $is_block and not $is_inline;  
           unless ($is_block) {  
             $content = 'inline';  
             for (@block_not_inline) {  
               $self->{onerror}->(node => $_, type => 'element not allowed');  
             }  
             unless ($is_inline) {  
               $self->{onerror}->(node => $node, type => 'element not allowed');  
             }  
           }  
         }  
         my ($sib, $ch) = $self->_check_get_children ($node);  
         unshift @nodes, @$sib;  
         push @$new_todos, @$ch;  
       } elsif ($nt == 3 or $nt == 4) {  
         if ($node->data =~ /[^\x09-\x0D\x20]/) {  
           if ($content eq 'block') {  
             $self->{onerror}->(node => $node, type => 'character not allowed');  
           } else {  
             $content = 'inline';  
             for (@block_not_inline) {  
               $self->{onerror}->(node => $_, type => 'element not allowed');  
             }  
           }  
         }  
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
       }  
     }  
   
     my $end = $self->_add_minuses  
       ({$HTML_NS => {qw/h1 1 h2 1 h3 1 h4 1 h5 1 h6 1/}},  
        $HTMLSectioningElements);  
     push @$new_todos, $end;  
   
     if ($content eq 'inline') {  
       for (@$new_todos) {  
         $_->{inline} = 1;  
       }  
     }  
   
     return ($new_todos);  
278    },    },
279  };  );
   
 $Element->{$HTML_NS}->{address} = {  
   checker => $HTMLInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{p} = {  
   checker => $HTMLSignificantInlineChecker,  
 };  
280    
281  $Element->{$HTML_NS}->{hr} = {  our $ElementDefault = {
282    checker => $HTMLEmptyChecker,    %AnyChecker,
283      status => FEATURE_ALLOWED,
284          ## NOTE: No "element not defined" error - it is not supported anyway.
285      check_start => sub {
286        my ($self, $item, $element_state) = @_;
287        $self->{onerror}->(node => $item->{node},
288                           type => 'unknown element',
289                           level => $self->{level}->{uncertain});
290      },
291  };  };
292    
293  $Element->{$HTML_NS}->{br} = {  our $HTMLEmbeddedContent = {
294    checker => $HTMLEmptyChecker,    ## NOTE: All embedded content is also phrasing content.
295  };    $HTML_NS => {
296        img => 1, iframe => 1, embed => 1, object => 1, video => 1, audio => 1,
297        canvas => 1,
298      },
299      q<http://www.w3.org/1998/Math/MathML> => {math => 1},
300      q<http://www.w3.org/2000/svg> => {svg => 1},
301      ## NOTE: Foreign elements with content (but no metadata) are
302      ## embedded content.
303    };  
304    
305    our $IsInHTMLInteractiveContent = sub {
306      my ($el, $nsuri, $ln) = @_;
307    
308      ## NOTE: This CODE returns whether an element that is conditionally
309      ## categorizzed as an interactive content is currently in that
310      ## condition or not.  See $HTMLInteractiveContent list defined in
311      ## Whatpm::ContentChecler::HTML for the list of all (conditionally
312      ## or permanently) interactive content.
313    
314      if ($nsuri eq $HTML_NS and ($ln eq 'video' or $ln eq 'audio')) {
315        return $el->has_attribute ('controls');
316      } elsif ($nsuri eq $HTML_NS and $ln eq 'menu') {
317        my $value = $el->get_attribute ('type');
318        $value =~ tr/A-Z/a-z/; # ASCII case-insensitive
319        return ($value eq 'toolbar');
320      } else {
321        return 1;
322      }
323    }; # $IsInHTMLInteractiveContent
324    
325  $Element->{$HTML_NS}->{dialog} = {  my $HTMLTransparentElements = {
326    checker => sub {    $HTML_NS => {qw/ins 1 del 1 font 1 noscript 1 canvas 1 a 1/},
327      my ($self, $todo) = @_;    ## NOTE: |html:noscript| is transparent if scripting is disabled
328      my $el = $todo->{node};    ## and not in |head|.
329      my $new_todos = [];  };
330      my @nodes = (@{$el->child_nodes});  
331    my $HTMLSemiTransparentElements = {
332      my $phase = 'before dt';    $HTML_NS => {object => 1, video => 1, audio => 1},
333      while (@nodes) {  };
334        my $node = shift @nodes;  
335        $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  our $Element = {};
336    
337        my $nt = $node->node_type;  $Element->{q<http://www.w3.org/1999/02/22-rdf-syntax-ns#>}->{RDF} = {
338        if ($nt == 1) {    %AnyChecker,
339          ## NOTE: |minuses| list is not checked since redundant    status => FEATURE_STATUS_REC | FEATURE_ALLOWED,
340          if ($phase eq 'before dt') {    is_root => 1, ## ISSUE: Not explicitly allowed for non application/rdf+xml
341            if ($node->manakai_element_type_match ($HTML_NS, 'dt')) {    check_start => sub {
342              $phase = 'before dd';      my ($self, $item, $element_state) = @_;
343            } elsif ($node->manakai_element_type_match ($HTML_NS, 'dd')) {      my $triple = [];
344              $self->{onerror}      push @{$self->{return}->{rdf}}, [$item->{node}, $triple];
345                ->(node => $node, type => 'ps element missing:dt');      require Whatpm::RDFXML;
346              $phase = 'before dt';      my $rdf = Whatpm::RDFXML->new;
347            } else {      ## TODO: Should we make bnodeid unique in a document?
348              $self->{onerror}->(node => $node, type => 'element not allowed');      $rdf->{onerror} = $self->{onerror};
349            }      $rdf->{level} = $self->{level};
350          } else { # before dd      $rdf->{ontriple} = sub {
351            if ($node->manakai_element_type_match ($HTML_NS, 'dd')) {        my %opt = @_;
352              $phase = 'before dt';        push @$triple,
353            } elsif ($node->manakai_element_type_match ($HTML_NS, 'dt')) {            [$opt{node}, $opt{subject}, $opt{predicate}, $opt{object}];
354              $self->{onerror}        if (defined $opt{id}) {
355                ->(node => $node, type => 'ps element missing:dd');          push @$triple,
356              $phase = 'before dd';              [$opt{node},
357            } else {               $opt{id},
358              $self->{onerror}->(node => $node, type => 'element not allowed');               {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#subject>},
359            }               $opt{subject}];
360          }          push @$triple,
361          my ($sib, $ch) = $self->_check_get_children ($node);              [$opt{node},
362          unshift @nodes, @$sib;               $opt{id},
363          push @$new_todos, @$ch;               {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate>},
364        } elsif ($nt == 3 or $nt == 4) {               $opt{predicate}];
365          if ($node->data =~ /[^\x09-\x0D\x20]/) {          push @$triple,
366            $self->{onerror}->(node => $node, type => 'character not allowed');              [$opt{node},
367          }               $opt{id},
368        } elsif ($nt == 5) {               {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#object>},
369          unshift @nodes, @{$node->child_nodes};               $opt{object}];
370            push @$triple,
371                [$opt{node},
372                 $opt{id},
373                 {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>},
374                 {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement>}];
375        }        }
376      }      };
377      if ($phase eq 'before dd') {      $rdf->convert_rdf_element ($item->{node});
       $self->{onerror}->(node => $el, type => 'ps element missing:dd');  
     }  
     return ($new_todos);  
378    },    },
379  };  };
380    
381  $Element->{$HTML_NS}->{pre} = {  my $default_error_level = {
382    checker => $HTMLStrictlyInlineChecker,    must => 'm',
383  };    should => 's',
384      warn => 'w',
385  $Element->{$HTML_NS}->{ol} = {    good => 'w',
386    checker => sub {    undefined => 'w',
387      my ($self, $todo) = @_;    info => 'i',
388      my $el = $todo->{node};  
389      my $new_todos = [];    uncertain => 'u',
390      my @nodes = (@{$el->child_nodes});  
391      html4_fact => 'm',
392      while (@nodes) {    html5_no_may => 'm',
393        my $node = shift @nodes;  
394        $self->_remove_minuses ($node) and next if ref $node eq 'HASH';    xml_error => 'm', ## TODO: correct?
395      xml_id_error => 'm', ## TODO: ?
396        my $nt = $node->node_type;    nc => 'm', ## XML Namespace Constraints ## TODO: correct?
397        if ($nt == 1) {  
398          ## NOTE: |minuses| list is not checked since redundant    ## |Whatpm::URIChecker|
399          unless ($node->manakai_element_type_match ($HTML_NS, 'li')) {    uri_syntax => 'm',
400            $self->{onerror}->(node => $node, type => 'element not allowed');    uri_fact => 'm',
401          }    uri_lc_must => 'm',
402          my ($sib, $ch) = $self->_check_get_children ($node);    uri_lc_should => 'w',
403          unshift @nodes, @$sib;  
404          push @$new_todos, @$ch;    ## |Whatpm::IMTChecker|
405        } elsif ($nt == 3 or $nt == 4) {    mime_must => 'm', # lowercase "must"
406          if ($node->data =~ /[^\x09-\x0D\x20]/) {    mime_fact => 'm',
407            $self->{onerror}->(node => $node, type => 'character not allowed');    mime_strongly_discouraged => 'w',
408          }    mime_discouraged => 'w',
409        } elsif ($nt == 5) {  
410          unshift @nodes, @{$node->child_nodes};    ## |Whatpm::LangTag|
411        }    langtag_fact => 'm',
412      }  
413      ## |Whatpm::RDFXML|
414      rdf_fact => 'm',
415      rdf_grammer => 'm',
416      rdf_lc_must => 'm',
417    
418      ## |Message::Charset::Info| and |Whatpm::Charset::DecodeHandle|
419      charset_variant => 'm',
420        ## An error caused by use of a variant charset that is not conforming
421        ## to the original charset (e.g. use of 0x80 in an ISO-8859-1 document
422        ## which is interpreted as a Windows-1252 document instead).
423      charset_fact => 'm',
424      iso_shall => 'm',
425    };
426    
427    sub check_document ($$$;$) {
428      my ($self, $doc, $onerror, $onsubdoc) = @_;
429      $self = bless {}, $self unless ref $self;
430      $self->{onerror} = $onerror;
431      $self->{onsubdoc} = $onsubdoc || sub {
432        warn "A subdocument is not conformance-checked";
433      };
434    
435      if ($todo->{inline}) {    $self->{level} ||= $default_error_level;
       for (@$new_todos) {  
         $_->{inline} = 1;  
       }  
     }  
     return ($new_todos);  
   },  
 };  
436    
437  $Element->{$HTML_NS}->{ul} = {    ## TODO: If application/rdf+xml, RDF/XML mode should be invoked.
   checker => $Element->{$HTML_NS}->{ol}->{checker},  
 };  
438    
439      my $docel = $doc->document_element;
440      unless (defined $docel) {
441        ## ISSUE: Should we check content of Document node?
442        $onerror->(node => $doc, type => 'no document element',
443                   level => $self->{level}->{must});
444        ## ISSUE: Is this non-conforming (to what spec)?  Or just a warning?
445        return {
446                class => {},
447                id => {}, table => [], term => {},
448               };
449      }
450    
451  $Element->{$HTML_NS}->{li} = {    ## ISSUE: Unexpanded entity references and HTML5 conformance
452    checker => sub {    
453      my ($self, $todo) = @_;    my $docel_nsuri = $docel->namespace_uri;
454      if ($todo->{inline}) {    if (defined $docel_nsuri) {
455        return $HTMLInlineChecker->($self, $todo);      load_ns_module ($docel_nsuri);
456      } else {
457        $docel_nsuri = '';
458      }
459      my $docel_def = $Element->{$docel_nsuri}->{$docel->manakai_local_name} ||
460        $Element->{$docel_nsuri}->{''} ||
461        $ElementDefault;
462      if ($docel_def->{is_root}) {
463        #
464      } elsif ($docel_def->{is_xml_root}) {
465        unless ($doc->manakai_is_html) {
466          #
467      } else {      } else {
468        return $HTMLBlockOrInlineChecker->($self, $todo);        $onerror->(node => $docel, type => 'element not allowed:root:xml',
469                     level => $self->{level}->{must});
470      }      }
471    },    } else {
472  };      $onerror->(node => $docel, type => 'element not allowed:root',
473                   level => $self->{level}->{must});
474      }
475    
476  $Element->{$HTML_NS}->{dl} = {    ## TODO: Check for other items other than document element
477    checker => sub {    ## (second (errorous) element, text nodes, PI nodes, doctype nodes)
478      my ($self, $todo) = @_;  
479      my $el = $todo->{node};    my $return = $self->check_element ($docel, $onerror, $onsubdoc);
480      my $new_todos = [];  
481      my @nodes = (@{$el->child_nodes});    ## TODO: Test for these checks are necessary.
482      my $charset_name = $doc->input_encoding;
483      my $phase = 'before dt';    if (defined $charset_name) {
484      while (@nodes) {      require Message::Charset::Info;
485        my $node = shift @nodes;      my $charset = $Message::Charset::Info::IANACharset->{$charset_name};
486        $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
487        if ($doc->manakai_is_html) {
488        my $nt = $node->node_type;        if (not $doc->manakai_has_bom and
489        if ($nt == 1) {            not defined $doc->manakai_charset) {
490          ## NOTE: |minuses| list is not checked since redundant          unless ($charset->{is_html_ascii_superset}) {
491          if ($phase eq 'in dds') {            $onerror->(node => $doc,
492            if ($node->manakai_element_type_match ($HTML_NS, 'dd')) {                       level => $self->{level}->{must},
493              #$phase = 'in dds';                       type => 'non ascii superset',
494            } elsif ($node->manakai_element_type_match ($HTML_NS, 'dt')) {                       text => $charset_name);
             $phase = 'in dts';  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           }  
         } elsif ($phase eq 'in dts') {  
           if ($node->manakai_element_type_match ($HTML_NS, 'dt')) {  
             #$phase = 'in dts';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'dd')) {  
             $phase = 'in dds';  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           }  
         } else { # before dt  
           if ($node->manakai_element_type_match ($HTML_NS, 'dt')) {  
             $phase = 'in dts';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'dd')) {  
             $self->{onerror}  
               ->(node => $node, type => 'ps element missing:dt');  
             $phase = 'in dds';  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           }  
495          }          }
496          my ($sib, $ch) = $self->_check_get_children ($node);          
497          unshift @nodes, @$sib;          if (not $self->{has_charset} and ## TODO: This does not work now.
498          push @$new_todos, @$ch;              not $charset->{iana_names}->{'us-ascii'}) {
499        } elsif ($nt == 3 or $nt == 4) {            $onerror->(node => $doc,
500          if ($node->data =~ /[^\x09-\x0D\x20]/) {                       level => $self->{level}->{must},
501            $self->{onerror}->(node => $node, type => 'character not allowed');                       type => 'no character encoding declaration',
502                         text => $charset_name);
503          }          }
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
504        }        }
     }  
     if ($phase eq 'in dts') {  
       $self->{onerror}->(node => $el, type => 'ps element missing:dd');  
     }  
505    
506      if ($todo->{inline}) {        if ($charset->{iana_names}->{'utf-8'}) {
507        for (@$new_todos) {          #
508          $_->{inline} = 1;        } elsif ($charset->{iana_names}->{'jis_x0212-1990'} or
509                   $charset->{iana_names}->{'x-jis0208'} or
510                   $charset->{iana_names}->{'utf-32'} or ## ISSUE: UTF-32BE? UTF-32LE?
511                   ($charset->{category} & Message::Charset::Info::CHARSET_CATEGORY_EBCDIC ())) {
512            $onerror->(node => $doc,
513                       type => 'bad character encoding',
514                       text => $charset_name,
515                       level => $self->{level}->{should},
516                       layer => 'encode');
517          } elsif ($charset->{iana_names}->{'cesu-8'} or
518                   $charset->{iana_names}->{'utf-8'} or ## ISSUE: UNICODE-1-1-UTF-7?
519                   $charset->{iana_names}->{'bocu-1'} or
520                   $charset->{iana_names}->{'scsu'}) {
521            $onerror->(node => $doc,
522                       type => 'disallowed character encoding',
523                       text => $charset_name,
524                       level => $self->{level}->{must},
525                       layer => 'encode');
526          } else {
527            $onerror->(node => $doc,
528                       type => 'non-utf-8 character encoding',
529                       text => $charset_name,
530                       level => $self->{level}->{good},
531                       layer => 'encode');
532        }        }
533      }      }
534      return ($new_todos);    } elsif ($doc->manakai_is_html) {
535    },      ## NOTE: MUST and SHOULD requirements above cannot be tested,
536  };      ## since the document has no input charset encoding information.
537        $onerror->(node => $doc,
538  $Element->{$HTML_NS}->{dt} = {                 type => 'character encoding unchecked',
539    checker => $HTMLStrictlyInlineChecker,                 level => $self->{level}->{info},
540  };                 layer => 'encode');
541      }
 $Element->{$HTML_NS}->{dd} = {  
   checker => $Element->{$HTML_NS}->{li}->{checker},  
 };  
   
 ## TODO: a  
   
 $Element->{$HTML_NS}->{q} = {  
   checker => $HTMLInlineOrStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{cite} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{em} = {  
   checker => $HTMLInlineOrStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{strong} = {  
   checker => $HTMLInlineOrStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{small} = {  
   checker => $HTMLInlineOrStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{m} = {  
   checker => $HTMLInlineOrStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{dfn} = {  
   checker => sub {  
     my ($self, $todo) = @_;  
   
     my $end = $self->_add_minuses ({$HTML_NS => {dfn => 1}});  
     my ($sib, $ch) = $HTMLStrictlyInlineChecker->($self, $todo);  
     push @$sib, $end;  
     return ($sib, $ch);  
   },  
 };  
   
 $Element->{$HTML_NS}->{abbr} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{time} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{meter} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{progress} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{code} = {  
   checker => $HTMLInlineOrStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{var} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{samp} = {  
   checker => $HTMLInlineOrStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{kbd} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{sub} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{sup} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{span} = {  
   checker => $HTMLInlineOrStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{i} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{b} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{bdo} = {  
   checker => $HTMLStrictlyInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{ins} = {  
   checker => $HTMLTransparentChecker,  
 };  
   
 $Element->{$HTML_NS}->{del} = {  
   checker => sub {  
     my ($self, $todo) = @_;  
   
     my $parent = $todo->{node}->manakai_parent_element;  
     if (defined $parent) {  
       my $nsuri = $parent->namespace_uri;  
       $nsuri = '' unless defined $nsuri;  
       my $ln = $parent->manakai_local_name;  
       my $eldef = $Element->{$nsuri}->{$ln} ||  
         $Element->{$nsuri}->{''} ||  
         $ElementDefault;  
       return $eldef->{checker}->($self, $todo);  
     } else {  
       return $HTMLBlockOrInlineChecker->($self, $todo);  
     }  
   },  
 };  
   
 ## TODO: figure  
542    
543  $Element->{$HTML_NS}->{img} = {    return $return;
544    checker => $HTMLEmptyChecker,  } # check_document
 };  
545    
546  $Element->{$HTML_NS}->{iframe} = {  ## Check an element.  The element is checked as if it is an orphan node (i.e.
547    checker => $HTMLTextChecker,  ## an element without a parent node).
548  };  sub check_element ($$$;$) {
549      my ($self, $el, $onerror, $onsubdoc) = @_;
550  $Element->{$HTML_NS}->{embed} = {    $self = bless {}, $self unless ref $self;
551    checker => $HTMLEmptyChecker,    $self->{onerror} = $onerror;
552  };    $self->{onsubdoc} = $onsubdoc || sub {
553        warn "A subdocument is not conformance-checked";
554      };
555    
556  $Element->{$HTML_NS}->{param} = {    $self->{level} ||= $default_error_level;
   checker => $HTMLEmptyChecker,  
 };  
557    
558  ## TODO: object    $self->{plus_elements} = {};
559      $self->{minus_elements} = {};
560      $self->{id} = {};
561      $self->{form} = {};
562      $self->{term} = {};
563      $self->{usemap} = [];
564      $self->{ref} = []; # datetemplate data references
565      $self->{template} = []; # datatemplate template references
566      $self->{contextmenu} = [];
567      $self->{map} = {};
568      $self->{menu} = {};
569      $self->{has_link_type} = {};
570      $self->{flag} = {};
571      #$self->{has_uri_attr};
572      #$self->{has_hyperlink_element};
573      #$self->{has_charset};
574      #$self->{has_base};
575      $self->{return} = {
576        class => {},
577        id => $self->{id},
578        table => [], # table objects returned by Whatpm::HTMLTable
579        term => $self->{term},
580        uri => {}, # URIs other than those in RDF triples
581                         ## TODO: xmlns="", SYSTEM "", atom:* src="", xml:base=""
582        rdf => [],
583      };
584    
585  $Element->{$HTML_NS}->{video} = {    my @item = ({type => 'element', node => $el, parent_state => {}});
586    checker => sub {    $item[-1]->{real_parent_state} = $item[-1]->{parent_state};
587      my ($self, $todo) = @_;    while (@item) {
588        my $item = shift @item;
589        if (ref $item eq 'ARRAY') {
590          my $code = shift @$item;
591    next unless $code;## TODO: temp.
592          $code->(@$item);
593        } elsif ($item->{type} eq 'element') {
594          my $el_nsuri = $item->{node}->namespace_uri;
595          if (defined $el_nsuri) {
596            load_ns_module ($el_nsuri);
597          } else {
598            $el_nsuri = '';
599          }
600          my $el_ln = $item->{node}->manakai_local_name;
601          
602          my $element_state = {};
603          my $eldef = $Element->{$el_nsuri}->{$el_ln} ||
604              $Element->{$el_nsuri}->{''} ||
605              $ElementDefault;
606          my $content_def = $item->{transparent}
607              ? $item->{parent_def} || $eldef : $eldef;
608          my $content_state = $item->{transparent}
609              ? $item->{parent_def}
610                  ? $item->{parent_state} || $element_state : $element_state
611              : $element_state;
612    
613          unless ($eldef->{status} & FEATURE_STATUS_REC) {
614            my $status = $eldef->{status} & FEATURE_STATUS_CR ? 'cr' :
615                $eldef->{status} & FEATURE_STATUS_LC ? 'lc' :
616                $eldef->{status} & FEATURE_STATUS_WD ? 'wd' : 'non-standard';
617            $self->{onerror}->(node => $item->{node},
618                               type => 'status:'.$status.':element',
619                               level => $self->{level}->{info});
620          }
621          if (not ($eldef->{status} & FEATURE_ALLOWED)) {
622            $self->{onerror}->(node => $item->{node},
623                               type => 'element not defined',
624                               level => $self->{level}->{must});
625          } elsif ($eldef->{status} & FEATURE_DEPRECATED_SHOULD) {
626            $self->{onerror}->(node => $item->{node},
627                               type => 'deprecated:element',
628                               level => $self->{level}->{should});
629          } elsif ($eldef->{status} & FEATURE_DEPRECATED_INFO) {
630            $self->{onerror}->(node => $item->{node},
631                               type => 'deprecated:element',
632                               level => $self->{level}->{info});
633          }
634    
635          my @new_item;
636          push @new_item, [$eldef->{check_start}, $self, $item, $element_state];
637          push @new_item, [$eldef->{check_attrs}, $self, $item, $element_state];
638          
639          my @child = @{$item->{node}->child_nodes};
640          while (@child) {
641            my $child = shift @child;
642            my $child_nt = $child->node_type;
643            if ($child_nt == 1) { # ELEMENT_NODE
644              my $child_nsuri = $child->namespace_uri;
645              $child_nsuri = '' unless defined $child_nsuri;
646              my $child_ln = $child->manakai_local_name;
647              if ($HTMLTransparentElements->{$child_nsuri}->{$child_ln} and
648                  not (($self->{flag}->{in_head} or
649                        ($el_nsuri eq $HTML_NS and $el_ln eq 'head')) and
650                       $child_nsuri eq $HTML_NS and $child_ln eq 'noscript')) {
651                push @new_item, [$content_def->{check_child_element},
652                                 $self, $item, $child,
653                                 $child_nsuri, $child_ln, 1,
654                                 $content_state, $element_state];
655                push @new_item, {type => 'element', node => $child,
656                                 parent_state => $content_state,
657                                 parent_def => $content_def,
658                                 real_parent_state => $element_state,
659                                 transparent => 1};
660              } else {
661                if ($item->{parent_def} and # has parent
662                    $el_nsuri eq $HTML_NS) { ## $HTMLSemiTransparentElements
663                  if ($el_ln eq 'object') {
664                    if ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
665                      #
666                    } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'param') {
667                      #
668                    } else {
669                      $content_def = $item->{parent_def} || $content_def;
670                      $content_state = $item->{parent_state} || $content_state;
671                    }
672                  } elsif ($el_ln eq 'video' or $el_ln eq 'audio') {
673                    if ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
674                      #
675                    } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'source') {
676                      $element_state->{has_source} = 1;
677                    } else {
678                      $content_def = $item->{parent_def} || $content_def;
679                      $content_state = $item->{parent_state} || $content_state;
680                    }
681                  }
682                }
683    
684      if ($todo->{node}->has_attribute_ns (undef, 'src')) {              push @new_item, [$content_def->{check_child_element},
685        return $HTMLBlockOrInlineChecker->($self, $todo);                               $self, $item, $child,
686                                 $child_nsuri, $child_ln,
687                                 $HTMLSemiTransparentElements
688                                     ->{$child_nsuri}->{$child_ln},
689                                 $content_state, $element_state];
690                push @new_item, {type => 'element', node => $child,
691                                 parent_def => $content_def,
692                                 real_parent_state => $element_state,
693                                 parent_state => $content_state};
694              }
695    
696              if ($HTMLEmbeddedContent->{$child_nsuri}->{$child_ln}) {
697                $element_state->{has_significant} = 1;
698              }
699            } elsif ($child_nt == 3 or # TEXT_NODE
700                     $child_nt == 4) { # CDATA_SECTION_NODE
701              my $has_significant = ($child->data =~ /[^\x09\x0A\x0C\x0D\x20]/);
702              push @new_item, [$content_def->{check_child_text},
703                               $self, $item, $child, $has_significant,
704                               $content_state, $element_state];
705              $element_state->{has_significant} ||= $has_significant;
706              if ($has_significant and
707                  $HTMLSemiTransparentElements->{$el_nsuri}->{$el_ln}) {
708                $content_def = $item->{parent_def} || $content_def;
709              }
710            } elsif ($child_nt == 5) { # ENTITY_REFERENCE_NODE
711              push @child, @{$child->child_nodes};
712            }
713            ## TODO: PI_NODE
714            ## TODO: Unknown node type
715          }
716          
717          push @new_item, [$eldef->{check_end}, $self, $item, $element_state];
718          
719          unshift @item, @new_item;
720      } else {      } else {
721        return $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'source')        die "$0: Internal error: Unsupported checking action type |$item->{type}|";
         ->($self, $todo);  
722      }      }
723    },    }
 };  
   
 $Element->{$HTML_NS}->{audio} = {  
   checker => $Element->{$HTML_NS}->{audio}->{checker},  
 };  
   
 $Element->{$HTML_NS}->{source} = {  
   checker => $HTMLEmptyChecker,  
 };  
   
 $Element->{$HTML_NS}->{canvas} = {  
   checker => $HTMLInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{map} = {  
   checker => $HTMLBlockChecker,  
 };  
   
 $Element->{$HTML_NS}->{area} = {  
   checker => $HTMLEmptyChecker,  
 };  
 ## TODO: only in map  
724    
725  $Element->{$HTML_NS}->{table} = {    for (@{$self->{template}}) {
726    checker => sub {      ## TODO: If the document is an XML document, ...
727      my ($self, $todo) = @_;      ## NOTE: If the document is an HTML document:
728      my $el = $todo->{node};      ## ISSUE: We need to percent-decode?
729      my $new_todos = [];      F: {
730      my @nodes = (@{$el->child_nodes});        if ($self->{id}->{$_->[0]}) {
731            my $el = $self->{id}->{$_->[0]}->[0]->owner_element;
732      my $phase = 'before caption';          if ($el->node_type == 1 and # ELEMENT_NODE
733      my $has_tfoot;              $el->manakai_local_name eq 'datatemplate') {
734      while (@nodes) {            my $nsuri = $el->namespace_uri;
735        my $node = shift @nodes;            if (defined $nsuri and $nsuri eq $HTML_NS) {
736        $self->_remove_minuses ($node) and next if ref $node eq 'HASH';              if ($el eq $_->[1]->owner_element) {
737                  $self->{onerror}->(node => $_->[1],
738        my $nt = $node->node_type;                                   type => 'fragment points itself',
739        if ($nt == 1) {                                   level => $self->{level}->{must});
740          ## NOTE: |minuses| list is not checked since redundant              }
741          if ($phase eq 'in tbodys') {              
742            if ($node->manakai_element_type_match ($HTML_NS, 'tbody')) {              last F;
             #$phase = 'in tbodys';  
           } elsif (not $has_tfoot and  
                    $node->manakai_element_type_match ($HTML_NS, 'tfoot')) {  
             $phase = 'after tfoot';  
             $has_tfoot = 1;  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           }  
         } elsif ($phase eq 'in trs') {  
           if ($node->manakai_element_type_match ($HTML_NS, 'tr')) {  
             #$phase = 'in trs';  
           } elsif (not $has_tfoot and  
                    $node->manakai_element_type_match ($HTML_NS, 'tfoot')) {  
             $phase = 'after tfoot';  
             $has_tfoot = 1;  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           }  
         } elsif ($phase eq 'after thead') {  
           if ($node->manakai_element_type_match ($HTML_NS, 'tbody')) {  
             $phase = 'in tbodys';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'tr')) {  
             $phase = 'in trs';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'tfoot')) {  
             $phase = 'in tbodys';  
             $has_tfoot = 1;  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           }  
         } elsif ($phase eq 'in colgroup') {  
           if ($node->manakai_element_type_match ($HTML_NS, 'colgroup')) {  
             $phase = 'in colgroup';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'thead')) {  
             $phase = 'after thead';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'tbody')) {  
             $phase = 'in tbodys';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'tr')) {  
             $phase = 'in trs';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'tfoot')) {  
             $phase = 'in tbodys';  
             $has_tfoot = 1;  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           }  
         } elsif ($phase eq 'before caption') {  
           if ($node->manakai_element_type_match ($HTML_NS, 'caption')) {  
             $phase = 'in colgroup';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'colgroup')) {  
             $phase = 'in colgroup';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'thead')) {  
             $phase = 'after thead';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'tbody')) {  
             $phase = 'in tbodys';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'tr')) {  
             $phase = 'in trs';  
           } elsif ($node->manakai_element_type_match ($HTML_NS, 'tfoot')) {  
             $phase = 'in tbodys';  
             $has_tfoot = 1;  
           } else {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
743            }            }
         } else { # after tfoot  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         }  
         my ($sib, $ch) = $self->_check_get_children ($node);  
         unshift @nodes, @$sib;  
         push @$new_todos, @$ch;  
       } elsif ($nt == 3 or $nt == 4) {  
         if ($node->data =~ /[^\x09-\x0D\x20]/) {  
           $self->{onerror}->(node => $node, type => 'character not allowed');  
744          }          }
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
745        }        }
746      }        ## TODO: Should we raise a "fragment points nothing" error instead
747      return ($new_todos);        ## if the fragment identifier identifies no element?
   },  
 };  
   
 $Element->{$HTML_NS}->{caption} = {  
   checker => $HTMLSignificantStrictlyInlineChecker,  
 };  
748    
749  $Element->{$HTML_NS}->{colgroup} = {        $self->{onerror}->(node => $_->[1], type => 'template:not template',
750    checker => sub {                           level => $self->{level}->{must});
751      my ($self, $todo) = @_;      } # F
752      my $el = $todo->{node};    }
753      my $new_todos = [];    
754      my @nodes = (@{$el->child_nodes});    for (@{$self->{ref}}) {
755        ## TOOD: If XML
756      while (@nodes) {      ## NOTE: If it is an HTML document:
757        my $node = shift @nodes;      if ($_->[0] eq '') {
758        $self->_remove_minuses ($node) and next if ref $node eq 'HASH';        ## NOTE: It points the top of the document.
759        } elsif ($self->{id}->{$_->[0]}) {
760        my $nt = $node->node_type;        if ($self->{id}->{$_->[0]}->[0]->owner_element
761        if ($nt == 1) {                eq $_->[1]->owner_element) {
762          ## NOTE: |minuses| list is not checked since redundant          $self->{onerror}->(node => $_->[1], type => 'fragment points itself',
763          unless ($node->manakai_element_type_match ($HTML_NS, 'col')) {                             level => $self->{level}->{must});
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         }  
         my ($sib, $ch) = $self->_check_get_children ($node);  
         unshift @nodes, @$sib;  
         push @$new_todos, @$ch;  
       } elsif ($nt == 3 or $nt == 4) {  
         if ($node->data =~ /[^\x09-\x0D\x20]/) {  
           $self->{onerror}->(node => $node, type => 'character not allowed');  
         }  
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
764        }        }
765        } else {
766          $self->{onerror}->(node => $_->[1], type => 'fragment points nothing',
767                             level => $self->{level}->{must});
768      }      }
769      return ($new_todos);    }
   },  
 };  
770    
771  $Element->{$HTML_NS}->{col} = {    ## TODO: Maybe we should have $document->manakai_get_by_fragment or something
   checker => $HTMLEmptyChecker,  
 };  
772    
773  $Element->{$HTML_NS}->{tbody} = {    for (@{$self->{usemap}}) {
774    checker => sub {      unless ($self->{map}->{$_->[0]}) {
775      my ($self, $todo) = @_;        $self->{onerror}->(node => $_->[1], type => 'no referenced map',
776      my $el = $todo->{node};                           level => $self->{level}->{must});
     my $new_todos = [];  
     my @nodes = (@{$el->child_nodes});  
   
     my $has_tr;  
     while (@nodes) {  
       my $node = shift @nodes;  
       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
       my $nt = $node->node_type;  
       if ($nt == 1) {  
         ## NOTE: |minuses| list is not checked since redundant  
         if ($node->manakai_element_type_match ($HTML_NS, 'tr')) {  
           $has_tr = 1;  
         } else {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         }  
         my ($sib, $ch) = $self->_check_get_children ($node);  
         unshift @nodes, @$sib;  
         push @$new_todos, @$ch;  
       } elsif ($nt == 3 or $nt == 4) {  
         if ($node->data =~ /[^\x09-\x0D\x20]/) {  
           $self->{onerror}->(node => $node, type => 'character not allowed');  
         }  
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
       }  
777      }      }
778      unless ($has_tr) {    }
       $self->{onerror}->(node => $el, type => 'child element missing:tr');  
     }  
     return ($new_todos);  
   },  
 };  
779    
780  $Element->{$HTML_NS}->{thead} = {    for (@{$self->{contextmenu}}) {
781    checker => $Element->{$HTML_NS}->{tbody},      unless ($self->{menu}->{$_->[0]}) {
782  };        $self->{onerror}->(node => $_->[1], type => 'no referenced menu',
783                             level => $self->{level}->{must});
784        }
785      }
786    
787  $Element->{$HTML_NS}->{tfoot} = {    delete $self->{plus_elements};
788    checker => $Element->{$HTML_NS}->{tbody},    delete $self->{minus_elements};
789  };    delete $self->{onerror};
790      delete $self->{id};
791      delete $self->{form};
792      delete $self->{usemap};
793      delete $self->{ref};
794      delete $self->{template};
795      delete $self->{map};
796      return $self->{return};
797    } # check_element
798    
799  $Element->{$HTML_NS}->{tr} = {  sub _add_minus_elements ($$@) {
800    checker => sub {    my $self = shift;
801      my ($self, $todo) = @_;    my $element_state = shift;
802      my $el = $todo->{node};    for my $elements (@_) {
803      my $new_todos = [];      for my $nsuri (keys %$elements) {
804      my @nodes = (@{$el->child_nodes});        for my $ln (keys %{$elements->{$nsuri}}) {
805            unless ($self->{minus_elements}->{$nsuri}->{$ln}) {
806      my $has_td;            $element_state->{minus_elements_original}->{$nsuri}->{$ln} = 0;
807      while (@nodes) {            $self->{minus_elements}->{$nsuri}->{$ln} = 1;
       my $node = shift @nodes;  
       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
       my $nt = $node->node_type;  
       if ($nt == 1) {  
         ## NOTE: |minuses| list is not checked since redundant  
         if ($node->manakai_element_type_match ($HTML_NS, 'td') or  
             $node->manakai_element_type_match ($HTML_NS, 'th')) {  
           $has_td = 1;  
         } else {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         }  
         my ($sib, $ch) = $self->_check_get_children ($node);  
         unshift @nodes, @$sib;  
         push @$new_todos, @$ch;  
       } elsif ($nt == 3 or $nt == 4) {  
         if ($node->data =~ /[^\x09-\x0D\x20]/) {  
           $self->{onerror}->(node => $node, type => 'character not allowed');  
808          }          }
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
809        }        }
810      }      }
811      unless ($has_td) {    }
812        $self->{onerror}->(node => $el, type => 'child element missing:td|th');  } # _add_minus_elements
     }  
     return ($new_todos);  
   },  
 };  
   
 $Element->{$HTML_NS}->{td} = {  
   checker => $HTMLBlockOrInlineChecker,  
 };  
   
 $Element->{$HTML_NS}->{th} = {  
   checker => $HTMLBlockOrInlineChecker,  
 };  
   
 ## TODO: forms  
   
 $Element->{$HTML_NS}->{script} = {  
   checker => sub {  
     my ($self, $todo) = @_;  
813    
814      if ($todo->{node}->has_attribute_ns (undef, 'src')) {  sub _remove_minus_elements ($$) {
815        return $HTMLEmptyChecker->($self, $todo);    my $self = shift;
816      } else {    my $element_state = shift;
817        ## NOTE: No content model conformance in HTML5 spec.    for my $nsuri (keys %{$element_state->{minus_elements_original}}) {
818        return $AnyChecker->($self, $todo);      for my $ln (keys %{$element_state->{minus_elements_original}->{$nsuri}}) {
819          delete $self->{minus_elements}->{$nsuri}->{$ln};
820      }      }
821    },    }
822  };  } # _remove_minus_elements
   
 ## NOTE: When script is disabled.  
 $Element->{$HTML_NS}->{noscript} = {  
   checker => sub {  
     my ($self, $todo) = @_;  
   
     my $end = $self->_add_minuses ({$HTML_NS => {noscript => 1}});  
     my ($sib, $ch) = $HTMLBlockOrInlineChecker->($self, $todo);  
     push @$sib, $end;  
     return ($sib, $ch);  
   },  
 };  
   
 $Element->{$HTML_NS}->{'event-source'} = {  
   checker => $HTMLEmptyChecker,  
 };  
   
 $Element->{$HTML_NS}->{details} = {  
   checker => $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'legend'),  
 };  
   
 $Element->{$HTML_NS}->{datagrid} = {  
   checker => $HTMLBlockChecker,  
 };  
   
 $Element->{$HTML_NS}->{command} = {  
   checker => $HTMLEmptyChecker,  
 };  
823    
824  $Element->{$HTML_NS}->{menu} = {  sub _add_plus_elements ($$@) {
825    checker => sub {    my $self = shift;
826      my ($self, $todo) = @_;    my $element_state = shift;
827      my $el = $todo->{node};    for my $elements (@_) {
828      my $new_todos = [];      for my $nsuri (keys %$elements) {
829      my @nodes = (@{$el->child_nodes});        for my $ln (keys %{$elements->{$nsuri}}) {
830                unless ($self->{plus_elements}->{$nsuri}->{$ln}) {
831      my $content = 'li or inline';            $element_state->{plus_elements_original}->{$nsuri}->{$ln} = 0;
832      while (@nodes) {            $self->{plus_elements}->{$nsuri}->{$ln} = 1;
       my $node = shift @nodes;  
       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';  
   
       my $nt = $node->node_type;  
       if ($nt == 1) {  
         my $node_ns = $node->namespace_uri;  
         $node_ns = '' unless defined $node_ns;  
         my $node_ln = $node->manakai_local_name;  
         if ($self->{minuses}->{$node_ns}->{$node_ln}) {  
           $self->{onerror}->(node => $node, type => 'element not allowed');  
         }  
         if ($node->manakai_element_type_match ($HTML_NS, 'li')) {  
           if ($content eq 'inline') {  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           } elsif ($content eq 'li or inline') {  
             $content = 'li';  
           }  
         } else {  
           CHK: {  
             for (@{$HTMLStrictlyInlineLevelElements},  
                  @{$HTMLStructuredInlineLevelElements}) {  
               if ($node->manakai_element_type_match ($_->[0], $_->[1])) {  
                 $content = 'inline';  
                 last CHK;  
               }  
             }  
             $self->{onerror}->(node => $node, type => 'element not allowed');  
           } # CHK  
         }  
         my ($sib, $ch) = $self->_check_get_children ($node);  
         unshift @nodes, @$sib;  
         push @$new_todos, @$ch;  
       } elsif ($nt == 3 or $nt == 4) {  
         if ($node->data =~ /[^\x09-\x0D\x20]/) {  
           if ($content eq 'li') {  
             $self->{onerror}->(node => $node, type => 'character not allowed');  
           } elsif ($content eq 'li or inline') {  
             $content = 'inline';  
           }  
833          }          }
       } elsif ($nt == 5) {  
         unshift @nodes, @{$node->child_nodes};  
834        }        }
835      }      }
836      }
837    } # _add_plus_elements
838    
839      for (@$new_todos) {  sub _remove_plus_elements ($$) {
840        $_->{inline} = 1;    my $self = shift;
841      my $element_state = shift;
842      for my $nsuri (keys %{$element_state->{plus_elements_original}}) {
843        for my $ln (keys %{$element_state->{plus_elements_original}->{$nsuri}}) {
844          delete $self->{plus_elements}->{$nsuri}->{$ln};
845      }      }
846      return ($new_todos);    }
847    },  } # _remove_plus_elements
 };  
   
 ## TODO: legend  
   
 $Element->{$HTML_NS}->{div} = {  
   checker => $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'style'),  
 };  
   
 $Element->{$HTML_NS}->{font} = {  
   checker => $HTMLTransparentChecker,  
 };  
   
 my $Attr = {  
   
 };  
   
 sub new ($) {  
   return bless {}, shift;  
 } # new  
848    
849  sub check_element ($$$) {  sub _attr_status_info ($$$) {
850    my ($self, $el, $onerror) = @_;    my ($self, $attr, $status_code) = @_;
851    
852    $self->{minuses} = {};    if (not ($status_code & FEATURE_ALLOWED)) {
853    $self->{onerror} = $onerror;      $self->{onerror}->(node => $attr,
854                           type => 'attribute not defined',
855                           level => $self->{level}->{must});
856      } elsif ($status_code & FEATURE_DEPRECATED_SHOULD) {
857        $self->{onerror}->(node => $attr,
858                           type => 'deprecated:attr',
859                           level => $self->{level}->{should});
860      } elsif ($status_code & FEATURE_DEPRECATED_INFO) {
861        $self->{onerror}->(node => $attr,
862                           type => 'deprecated:attr',
863                           level => $self->{level}->{info});
864      }
865    
866    my @todo = ({type => 'element', node => $el});    my $status;
867    while (@todo) {    if ($status_code & FEATURE_STATUS_REC) {
868      my $todo = shift @todo;      return;
869      if ($todo->{type} eq 'element') {    } elsif ($status_code & FEATURE_STATUS_CR) {
870        my $nsuri = $todo->{node}->namespace_uri;      $status = 'cr';
871        $nsuri = '' unless defined $nsuri;    } elsif ($status_code & FEATURE_STATUS_LC) {
872        my $ln = $todo->{node}->manakai_local_name;      $status = 'lc';
873        my $eldef = $Element->{$nsuri}->{$ln} ||    } elsif ($status_code & FEATURE_STATUS_WD) {
874          $Element->{$nsuri}->{''} ||      $status = 'wd';
875            $ElementDefault;    } else {
876        my ($new_todos) = $eldef->{checker}->($self, $todo);      $status = 'non-standard';
       push @todo, @$new_todos;  
     } elsif ($todo->{type} eq 'plus') {  
       $self->_remove_minuses ($todo);  
     }  
877    }    }
878  } # check_element    $self->{onerror}->(node => $attr,
879                         type => 'status:'.$status.':attr',
880                         level => $self->{level}->{info});
881    } # _attr_status_info
882    
883  sub _add_minuses ($@) {  sub _add_minuses ($@) {
884    my $self = shift;    my $self = shift;
# Line 1736  sub _add_minuses ($@) { Line 896  sub _add_minuses ($@) {
896    return {type => 'plus', list => $r};    return {type => 'plus', list => $r};
897  } # _add_minuses  } # _add_minuses
898    
899    sub _add_pluses ($@) {
900      my $self = shift;
901      my $r = {};
902      for my $list (@_) {
903        for my $ns (keys %$list) {
904          for my $ln (keys %{$list->{$ns}}) {
905            unless ($self->{pluses}->{$ns}->{$ln}) {
906              $self->{pluses}->{$ns}->{$ln} = 1;
907              $r->{$ns}->{$ln} = 1;
908            }
909          }
910        }
911      }
912      return {type => 'minus', list => $r};
913    } # _add_pluses
914    
915  sub _remove_minuses ($$) {  sub _remove_minuses ($$) {
916    my ($self, $todo) = @_;    my ($self, $todo) = @_;
917    for my $ns (keys %{$todo->{list}}) {    if ($todo->{type} eq 'minus') {
918      for my $ln (keys %{$todo->{list}->{$ns}}) {      for my $ns (keys %{$todo->{list}}) {
919        delete $self->{minuses}->{$ns}->{$ln} if $todo->{list}->{$ns}->{$ln};        for my $ln (keys %{$todo->{list}->{$ns}}) {
920            delete $self->{pluses}->{$ns}->{$ln} if $todo->{list}->{$ns}->{$ln};
921          }
922      }      }
923      } elsif ($todo->{type} eq 'plus') {
924        for my $ns (keys %{$todo->{list}}) {
925          for my $ln (keys %{$todo->{list}->{$ns}}) {
926            delete $self->{minuses}->{$ns}->{$ln} if $todo->{list}->{$ns}->{$ln};
927          }
928        }
929      } else {
930        die "$0: Unknown +- type: $todo->{type}";
931    }    }
932    1;    1;
933  } # _remove_minuses  } # _remove_minuses
934    
935  sub _check_get_children ($$) {  ## NOTE: Priority for "minuses" and "pluses" are currently left
936    my ($self, $node) = @_;  ## undefined and implemented inconsistently; it is not a problem for
937    ## now, since no element belongs to both lists.
938    
939    sub _check_get_children ($$$) {
940      my ($self, $node, $parent_todo) = @_;
941    my $new_todos = [];    my $new_todos = [];
942    my $sib = [];    my $sib = [];
943    TP: {    TP: {
944      my $node_ns = $node->namespace_uri;      my $node_ns = $node->namespace_uri;
945      $node_ns = '' unless defined $node_ns;      $node_ns = '' unless defined $node_ns;
946      my $node_ln = $node->manakai_local_name;      my $node_ln = $node->manakai_local_name;
947      if ($node_ns eq $HTML_NS) {      if ($HTMLTransparentElements->{$node_ns}->{$node_ln}) {
948        if ($node_ln eq 'noscript') {        if ($node_ns eq $HTML_NS and $node_ln eq 'noscript') {
949          my $end = $self->_add_minuses ({$HTML_NS, {noscript => 1}});          if ($parent_todo->{flag}->{in_head}) {
950          push @$sib, $end;            #
951        }          } else {
952      }            my $end = $self->_add_minuses ({$HTML_NS, {noscript => 1}});
953      for (@{$HTMLTransparentElements}) {            push @$sib, $end;
954        if ($node->manakai_element_type_match ($_->[0], $_->[1])) {            
955              unshift @$sib, @{$node->child_nodes};
956              push @$new_todos, {type => 'element-attributes', node => $node};
957              last TP;
958            }
959          } elsif ($node_ns eq $HTML_NS and $node_ln eq 'del') {
960            my $sig_flag = $parent_todo->{flag}->{has_descendant}->{significant};
961            unshift @$sib, @{$node->child_nodes};
962            push @$new_todos, {type => 'element-attributes', node => $node};
963            push @$new_todos,
964                {type => 'code',
965                 code => sub {
966                   $parent_todo->{flag}->{has_descendant}->{significant} = 0
967                       if not $sig_flag;
968                 }};
969            last TP;
970          } else {
971          unshift @$sib, @{$node->child_nodes};          unshift @$sib, @{$node->child_nodes};
972            push @$new_todos, {type => 'element-attributes', node => $node};
973          last TP;          last TP;
974        }        }
975      }      }
976      if ($node->manakai_element_type_match ($HTML_NS, 'video') or      if ($node_ns eq $HTML_NS and ($node_ln eq 'video' or $node_ln eq 'audio')) {
         $node->manakai_element_type_match ($HTML_NS, 'audio')) {  
977        if ($node->has_attribute_ns (undef, 'src')) {        if ($node->has_attribute_ns (undef, 'src')) {
978          unshift @$sib, @{$node->child_nodes};          unshift @$sib, @{$node->child_nodes};
979            push @$new_todos, {type => 'element-attributes', node => $node};
980          last TP;          last TP;
981        } else {        } else {
982          my @cn = @{$node->child_nodes};          my @cn = @{$node->child_nodes};
# Line 1777  sub _check_get_children ($$) { Line 984  sub _check_get_children ($$) {
984            my $cn = shift @cn;            my $cn = shift @cn;
985            my $cnt = $cn->node_type;            my $cnt = $cn->node_type;
986            if ($cnt == 1) {            if ($cnt == 1) {
987              if ($cn->manakai_element_type_match ($HTML_NS, 'source')) {              my $cn_nsuri = $cn->namespace_uri;
988                $cn_nsuri = '' unless defined $cn_nsuri;
989                if ($cn_nsuri eq $HTML_NS and $cn->manakai_local_name eq 'source') {
990                #                #
991              } else {              } else {
992                last CN;                last CN;
993              }              }
994            } elsif ($cnt == 3 or $cnt == 4) {            } elsif ($cnt == 3 or $cnt == 4) {
995              if ($cn->data =~ /[^\x09-\x0D\x20]/) {              if ($cn->data =~ /[^\x09\x0A\x0C\x0D\x20]/) {
996                last CN;                last CN;
997              }              }
998            }            }
999          } # CN          } # CN
1000          unshift @$sib, @cn;          unshift @$sib, @cn;
1001        }        }
1002        } elsif ($node_ns eq $HTML_NS and $node_ln eq 'object') {
1003          my @cn = @{$node->child_nodes};
1004          CN: while (@cn) {
1005            my $cn = shift @cn;
1006            my $cnt = $cn->node_type;
1007            if ($cnt == 1) {
1008              my $cn_nsuri = $cn->namespace_uri;
1009              $cn_nsuri = '' unless defined $cn_nsuri;
1010              if ($cn_nsuri eq $HTML_NS and $cn->manakai_local_name eq 'param') {
1011                #
1012              } else {
1013                last CN;
1014              }
1015            } elsif ($cnt == 3 or $cnt == 4) {
1016              if ($cn->data =~ /[^\x09\x0A\x0C\x0D\x20]/) {
1017                last CN;
1018              }
1019            }
1020          } # CN
1021          unshift @$sib, @cn;
1022      }      }
1023      push @$new_todos, {type => 'element', node => $node};      push @$new_todos, {type => 'element', node => $node};
1024    } # TP    } # TP
1025      
1026      for my $new_todo (@$new_todos) {
1027        $new_todo->{flag} = {%{$parent_todo->{flag} or {}}};
1028      }
1029      
1030    return ($sib, $new_todos);    return ($sib, $new_todos);
1031  } # _check_get_children  } # _check_get_children
1032    
1033    =head1 LICENSE
1034    
1035    Copyright 2007-2008 Wakaba <[email protected]>
1036    
1037    This library is free software; you can redistribute it
1038    and/or modify it under the same terms as Perl itself.
1039    
1040    =cut
1041    
1042  1;  1;
1043  # $Date$  # $Date$
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.97
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.24