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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1.13 by wakaba,
Sat May 19 14:29:09 2007 UTC
+revision 1.97 by wakaba,
Sun Sep 21 09:45:02 2008 UTC
 Line 1
  package Whatpm::ContentChecker;
  use strict;
+ our $VERSION=do{my @r=(q$Revision$=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
+ require Whatpm::URIChecker;
  ## ISSUE: How XML and XML Namespaces conformance can (or cannot)
  ## be applied to an in-memory representation (i.e. DOM)?
+ ## TODO: Conformance of an HTML document with non-html root element.
+ ## Stability
+ sub FEATURE_STATUS_REC () { 0b1 } ## Interoperable standard
+ sub FEATURE_STATUS_CR () { 0b10 } ## Call for implementation
+ sub FEATURE_STATUS_LC () { 0b100 } ## Last call for comments
+ sub FEATURE_STATUS_WD () { 0b1000 } ## Working or editor's draft
+ ## Deprecated
+ sub FEATURE_DEPRECATED_SHOULD () { 0b100000 } ## SHOULD-level
+ sub FEATURE_DEPRECATED_INFO () { 0b1000000 } ## Does not affect conformance
+ ## Conformance
+ sub FEATURE_ALLOWED () { 0b10000 }
+ my $HTML_NS = q<http://www.w3.org/1999/xhtml>;
  my $XML_NS = q<http://www.w3.org/XML/1998/namespace>;
  my $XMLNS_NS = q<http://www.w3.org/2000/xmlns/>;
- my $AttrChecker = {
+ my $Namespace = {
+   '' => {loaded => 1},
+   q<http://www.w3.org/2005/Atom> => {module => 'Whatpm::ContentChecker::Atom'},
+   q<http://purl.org/syndication/history/1.0>
+       => {module => 'Whatpm::ContentChecker::Atom'},
+   q<http://purl.org/syndication/threading/1.0>
+       => {module => 'Whatpm::ContentChecker::Atom'},
+   $HTML_NS => {module => 'Whatpm::ContentChecker::HTML'},
+   $XML_NS => {loaded => 1},
+   $XMLNS_NS => {loaded => 1},
+   q<http://www.w3.org/1999/02/22-rdf-syntax-ns#> => {loaded => 1},
+ };
+ sub load_ns_module ($) {
+   my $nsuri = shift; # namespace URI or ''
+   unless ($Namespace->{$nsuri}->{loaded}) {
+     if ($Namespace->{$nsuri}->{module}) {
+       eval qq{ require $Namespace->{$nsuri}->{module} } or die $@;
+     } else {
+       $Namespace->{$nsuri}->{loaded} = 1;
+     }
+   }
+ } # load_ns_module
+ our $AttrChecker = {
    $XML_NS => {
      space => sub {
        my ($self, $attr) = @_;
-Line 16 
 my $AttrChecker = {
+Line 59 
 my $AttrChecker = {
          #
        } else {
          ## NOTE: An XML "error"
-         $self->{onerror}->(node => $attr,
+         $self->{onerror}->(node => $attr, level => $self->{level}->{xml_error},
-                            type => 'XML error:invalid xml:space value');
+                            type => 'invalid attribute value');
        }
      },
      lang => sub {
+       my ($self, $attr) = @_;
+       my $value = $attr->value;
+       if ($value eq '') {
+         #
+       } else {
+         require Whatpm::LangTag;
+         Whatpm::LangTag->check_rfc3066_language_tag ($value, sub {
+           $self->{onerror}->(@_, node => $attr);
+         }, $self->{level});
+       }
        ## NOTE: "The values of the attribute are language identifiers
        ## as defined by [IETF RFC 3066], Tags for the Identification
        ## of Languages, or its successor; in addition, the empty string
        ## may be specified." ("may" in lower case)
-       ## TODO: xml:lang MUST NOT in HTML document
+       ## NOTE: Is an RFC 3066-valid (but RFC 4646-invalid) language tag
+       ## allowed today?
+       ## TODO: test data
+       my $nsuri = $attr->owner_element->namespace_uri;
+       if (defined $nsuri and $nsuri eq $HTML_NS) {
+         my $lang_attr = $attr->owner_element->get_attribute_node_ns
+             (undef, 'lang');
+         if ($lang_attr) {
+           my $lang_attr_value = $lang_attr->value;
+           $lang_attr_value =~ tr/A-Z/a-z/; ## ASCII case-insensitive
+           my $value = $value;
+           $value =~ tr/A-Z/a-z/; ## ASCII case-insensitive
+           if ($lang_attr_value ne $value) {
+             ## NOTE: HTML5 Section "The |lang| and |xml:lang| attributes"
+             $self->{onerror}->(node => $attr,
+                                type => 'xml:lang ne lang',
+                                level => $self->{level}->{must});
+           }
+         }
+       }
+       if ($attr->owner_document->manakai_is_html) { # MUST NOT
+         $self->{onerror}->(node => $attr, type => 'in HTML:xml:lang',
+                            level => $self->{level}->{must});
+ ## TODO: Test data...
+       }
      },
      base => sub {
        my ($self, $attr) = @_;
        my $value = $attr->value;
        if ($value =~ /[^\x{0000}-\x{10FFFF}]/) { ## ISSUE: Should we disallow noncharacters?
          $self->{onerror}->(node => $attr,
-                            type => 'syntax error');
+                            type => 'invalid attribute value',
+                            level => $self->{level}->{fact}, ## TODO: correct?
+                           );
        }
-       ## NOTE: Conformance to URI standard is not checked.
+       ## NOTE: Conformance to URI standard is not checked since there is
+       ## no author requirement on conformance in the XML Base specification.
      },
      id => sub {
        my ($self, $attr) = @_;
-Line 45 
 my $AttrChecker = {
+Line 129 
 my $AttrChecker = {
        ## TODO: NCName in XML 1.0 or 1.1
        ## TODO: declared type is ID?
        if ($self->{id}->{$value}) {
-         $self->{onerror}->(node => $attr, type => 'xml:id error:duplicate ID');
+         $self->{onerror}->(node => $attr,
+                            type => 'duplicate ID',
+                            level => $self->{level}->{xml_id_error});
+         push @{$self->{id}->{$value}}, $attr;
        } else {
-         $self->{id}->{$value} = 1;
+         $self->{id}->{$value} = [$attr];
        }
      },
    },
-Line 59 
 my $AttrChecker = {
+Line 146 
 my $AttrChecker = {
        if ($value eq $XML_NS and $ln ne 'xml') {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:=xml');
+              type => 'Reserved Prefixes and Namespace Names:Name',
+              text => $value,
+              level => $self->{level}->{nc});
        } elsif ($value eq $XMLNS_NS) {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:=xmlns');
+              type => 'Reserved Prefixes and Namespace Names:Name',
+              text => $value,
+              level => $self->{level}->{nc});
        }
        if ($ln eq 'xml' and $value ne $XML_NS) {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:xmlns:xml=');
+              type => 'Reserved Prefixes and Namespace Names:Prefix',
+              text => $ln,
+              level => $self->{level}->{nc});
        } elsif ($ln eq 'xmlns') {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:xmlns:xmlns=');
+              type => 'Reserved Prefixes and Namespace Names:Prefix',
+              text => $ln,
+              level => $self->{level}->{nc});
        }
        ## TODO: If XML 1.0 and empty
      },
-Line 80 
 my $AttrChecker = {
+Line 175 
 my $AttrChecker = {
        my ($self, $attr) = @_;
        ## TODO: In XML 1.0, URI reference [RFC 3986] or an empty string
        ## TODO: In XML 1.1, IRI reference [RFC 3987] or an empty string
+       ## TODO: relative references are deprecated
        my $value = $attr->value;
        if ($value eq $XML_NS) {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:=xml');
+              type => 'Reserved Prefixes and Namespace Names:Name',
+              text => $value,
+              level => $self->{level}->{nc});
        } elsif ($value eq $XMLNS_NS) {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:=xmlns');
+              type => 'Reserved Prefixes and Namespace Names:Name',
+              text => $value,
+              level => $self->{level}->{nc});
        }
      },
    },
  };
+ ## ISSUE: Should we really allow these attributes?
  $AttrChecker->{''}->{'xml:space'} = $AttrChecker->{$XML_NS}->{space};
  $AttrChecker->{''}->{'xml:lang'} = $AttrChecker->{$XML_NS}->{lang};
+     ## NOTE: Checker for (null, "xml:lang") attribute is shadowed for
+     ## HTML elements in Whatpm::ContentChecker::HTML.
  $AttrChecker->{''}->{'xml:base'} = $AttrChecker->{$XML_NS}->{base};
  $AttrChecker->{''}->{'xml:id'} = $AttrChecker->{$XML_NS}->{id};
- ## ANY
+ our $AttrStatus;
- 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 = {
+ for (qw/space lang base id/) {
-   checker => sub {
+   $AttrStatus->{$XML_NS}->{$_} = FEATURE_STATUS_REC | FEATURE_ALLOWED;
-     my ($self, $todo) = @_;
+   $AttrStatus->{''}->{"xml:$_"} = FEATURE_STATUS_REC | FEATURE_ALLOWED;
-     $self->{onerror}->(node => $todo->{node}, type => 'element not supported');
+   ## XML 1.0: FEATURE_STATUS_CR
-     return $AnyChecker->($self, $todo);
+   ## XML 1.1: FEATURE_STATUS_REC
-   },
+   ## XML Namespaces 1.0: FEATURE_STATUS_CR
-   attrs_checker => sub {
+   ## XML Namespaces 1.1: FEATURE_STATUS_REC
-     my ($self, $todo) = @_;
+   ## XML Base: FEATURE_STATUS_REC
-     for my $attr (@{$todo->{node}->attributes}) {
+   ## xml:id: FEATURE_STATUS_REC
+ }
+ $AttrStatus->{$XMLNS_NS}->{''} = FEATURE_STATUS_REC | FEATURE_ALLOWED;
+ ## TODO: xsi:schemaLocation for XHTML2 support (very, very low priority)
+ our %AnyChecker = (
+   check_start => sub { },
+   check_attrs => sub {
+     my ($self, $item, $element_state) = @_;
+     for my $attr (@{$item->{node}->attributes}) {
        my $attr_ns = $attr->namespace_uri;
-       $attr_ns = '' unless defined $attr_ns;
+       if (defined $attr_ns) {
+         load_ns_module ($attr_ns);
+       } else {
+         $attr_ns = '';
+       }
        my $attr_ln = $attr->manakai_local_name;
        my $checker = $AttrChecker->{$attr_ns}->{$attr_ln}
-         || $AttrChecker->{$attr_ns}->{''};
+           || $AttrChecker->{$attr_ns}->{''};
+       my $status = $AttrStatus->{$attr_ns}->{$attr_ln}
+           || $AttrStatus->{$attr_ns}->{''};
+       if (not defined $status) {
+         $status = FEATURE_ALLOWED;
+         ## NOTE: FEATURE_ALLOWED for all attributes, since the element
+         ## is not supported and therefore "attribute not defined" error
+         ## should not raised (too verbose) and global attributes should be
+         ## allowed anyway (if a global attribute has its specified creteria
+         ## for where it may be specified, then it should be checked in it's
+         ## checker function).
+       }
        if ($checker) {
          $checker->($self, $attr);
+       } else {
+         $self->{onerror}->(node => $attr,
+                            type => 'unknown attribute',
+                            level => $self->{level}->{uncertain});
        }
-       ## Don't check otherwise, since "element type not supported" warning
+       $self->_attr_status_info ($attr, $status);
-       ## will be reported by the element checker.
      }
    },
- };
+   check_child_element => sub {
+     my ($self, $item, $child_el, $child_nsuri, $child_ln,
- my $Element = {};
+         $child_is_transparent, $element_state) = @_;
+     if ($self->{minus_elements}->{$child_nsuri}->{$child_ln}) {
- my $HTML_NS = q<http://www.w3.org/1999/xhtml>;
+       $self->{onerror}->(node => $child_el,
+                          type => 'element not allowed:minus',
- my $HTMLMetadataElements = {
+                          level => $self->{level}->{must});
-   $HTML_NS => {
+     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
-     qw/link 1 meta 1 style 1 script 1 event-source 1 command 1 base 1 title 1/,
+       #
+     } else {
+       #
+     }
    },
- };
+   check_child_text => sub { },
+   check_end => sub {
- my $HTMLSectioningElements = {
+     my ($self, $item, $element_state) = @_;
-   $HTML_NS => {qw/body 1 section 1 nav 1 article 1 blockquote 1 aside 1/},
+     ## NOTE: There is a modified copy of the code below for |html:ruby|.
- };
+     if ($element_state->{has_significant}) {
+       $item->{real_parent_state}->{has_significant} = 1;
- my $HTMLBlockLevelElements = {
+     }
-   $HTML_NS => {
+   },
-     qw/
+ );
-       section 1 nav 1 article 1 blockquote 1 aside 1
-       h1 1 h2 1 h3 1 h4 1 h5 1 h6 1 header 1 footer 1
+ our $ElementDefault = {
-       address 1 p 1 hr 1 dialog 1 pre 1 ol 1 ul 1 dl 1
+   %AnyChecker,
-       ins 1 del 1 figure 1 map 1 table 1 script 1 noscript 1
+   status => FEATURE_ALLOWED,
-       event-source 1 details 1 datagrid 1 menu 1 div 1 font 1
+       ## NOTE: No "element not defined" error - it is not supported anyway.
-     /,
+   check_start => sub {
+     my ($self, $item, $element_state) = @_;
+     $self->{onerror}->(node => $item->{node},
+                        type => 'unknown element',
+                        level => $self->{level}->{uncertain});
    },
  };
- my $HTMLStrictlyInlineLevelElements = {
+ our $HTMLEmbeddedContent = {
+   ## NOTE: All embedded content is also phrasing content.
    $HTML_NS => {
-     qw/
+     img => 1, iframe => 1, embed => 1, object => 1, video => 1, audio => 1,
-       br 1 a 1 q 1 cite 1 em 1 strong 1 small 1 m 1 dfn 1 abbr 1
+     canvas => 1,
-       time 1 meter 1 progress 1 code 1 var 1 samp 1 kbd 1
-       sub 1 sup 1 span 1 i 1 b 1 bdo 1 ins 1 del 1 img 1
-       iframe 1 embed 1 object 1 video 1 audio 1 canvas 1 area 1
-       script 1 noscript 1 event-source 1 command 1 font 1
-     /,
    },
- };
+   q<http://www.w3.org/1998/Math/MathML> => {math => 1},
+   q<http://www.w3.org/2000/svg> => {svg => 1},
- my $HTMLStructuredInlineLevelElements = {
+   ## NOTE: Foreign elements with content (but no metadata) are
-   $HTML_NS => {qw/blockquote 1 pre 1 ol 1 ul 1 dl 1 table 1 menu 1/},
+   ## embedded content.
  };
- my $HTMLInteractiveElements = {
+ our $IsInHTMLInteractiveContent = sub {
-   $HTML_NS => {a => 1, details => 1, datagrid => 1},
+   my ($el, $nsuri, $ln) = @_;
- };
- ## NOTE: |html:a| and |html:datagrid| are not allowed as a descendant
+   ## NOTE: This CODE returns whether an element that is conditionally
- ## of interactive elements
+   ## categorizzed as an interactive content is currently in that
+   ## condition or not.  See $HTMLInteractiveContent list defined in
- my $HTMLTransparentElements = {
+   ## Whatpm::ContentChecler::HTML for the list of all (conditionally
-   $HTML_NS => {qw/ins 1 font 1 noscript 1/},
+   ## or permanently) interactive content.
-   ## NOTE: |html:noscript| is transparent if scripting is disabled.
- };
+   if ($nsuri eq $HTML_NS and ($ln eq 'video' or $ln eq 'audio')) {
+     return $el->has_attribute ('controls');
- #my $HTMLSemiTransparentElements = {
+   } elsif ($nsuri eq $HTML_NS and $ln eq 'menu') {
- #  $HTML_NS => {qw/video 1 audio 1/},
+     my $value = $el->get_attribute ('type');
- #};
+     $value =~ tr/A-Z/a-z/; # ASCII case-insensitive
+     return ($value eq 'toolbar');
- my $HTMLEmbededElements = {
+   } else {
-   $HTML_NS => {qw/img 1 iframe 1 embed 1 object 1 video 1 audio 1 canvas 1/},
+     return 1;
- };
- ## Empty
- my $HTMLEmptyChecker = 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) {
-       ## 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});
-   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
-       $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 == 5) {
-       unshift @nodes, @{$node->child_nodes};
-     }
    }
-   return ($new_todos);
+ }; # $IsInHTMLInteractiveContent
- };
- ## Zero or more |html:style| elements,
+ my $HTMLTransparentElements = {
- ## followed by zero or more block-level elements
+   $HTML_NS => {qw/ins 1 del 1 font 1 noscript 1 canvas 1 a 1/},
- my $HTMLStylableBlockChecker = sub {
+   ## NOTE: |html:noscript| is transparent if scripting is disabled
-   my ($self, $todo) = @_;
+   ## and not in |head|.
-   my $el = $todo->{node};
+ };
-   my $new_todos = [];
-   my @nodes = (@{$el->child_nodes});
+ my $HTMLSemiTransparentElements = {
+   $HTML_NS => {object => 1, video => 1, audio => 1},
-   my $has_non_style;
+ };
-   while (@nodes) {
-     my $node = shift @nodes;
+ our $Element = {};
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
+ $Element->{q<http://www.w3.org/1999/02/22-rdf-syntax-ns#>}->{RDF} = {
-     my $nt = $node->node_type;
+   %AnyChecker,
-     if ($nt == 1) {
+   status => FEATURE_STATUS_REC | FEATURE_ALLOWED,
-       my $node_ns = $node->namespace_uri;
+   is_root => 1, ## ISSUE: Not explicitly allowed for non application/rdf+xml
-       $node_ns = '' unless defined $node_ns;
+   check_start => sub {
-       my $node_ln = $node->manakai_local_name;
+     my ($self, $item, $element_state) = @_;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
+     my $triple = [];
-       if ($node_ns eq $HTML_NS and $node_ln eq 'style') {
+     push @{$self->{return}->{rdf}}, [$item->{node}, $triple];
-         $not_allowed = 1 if $has_non_style;
+     require Whatpm::RDFXML;
-       } elsif ($HTMLBlockLevelElements->{$node_ns}->{$node_ln}) {
+     my $rdf = Whatpm::RDFXML->new;
-         $has_non_style = 1;
+     ## TODO: Should we make bnodeid unique in a document?
-       } else {
+     $rdf->{onerror} = $self->{onerror};
-         $has_non_style = 1;
+     $rdf->{level} = $self->{level};
-         $not_allowed = 1;
+     $rdf->{ontriple} = sub {
-       }
+       my %opt = @_;
-       $self->{onerror}->(node => $node, type => 'element not allowed')
+       push @$triple,
-         if $not_allowed;
+           [$opt{node}, $opt{subject}, $opt{predicate}, $opt{object}];
-       my ($sib, $ch) = $self->_check_get_children ($node);
+       if (defined $opt{id}) {
-       unshift @nodes, @$sib;
+         push @$triple,
-       push @$new_todos, @$ch;
+             [$opt{node},
-     } elsif ($nt == 3 or $nt == 4) {
+              $opt{id},
-       if ($node->data =~ /[^\x09-\x0D\x20]/) {
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#subject>},
-         $self->{onerror}->(node => $node, type => 'character not allowed');
+              $opt{subject}];
-       }
+         push @$triple,
-     } elsif ($nt == 5) {
+             [$opt{node},
-       unshift @nodes, @{$node->child_nodes};
+              $opt{id},
-     }
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate>},
-   }
+              $opt{predicate}];
-   return ($new_todos);
+         push @$triple,
- }; # $HTMLStylableBlockChecker
+             [$opt{node},
+              $opt{id},
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#object>},
+              $opt{object}];
+         push @$triple,
+             [$opt{node},
+              $opt{id},
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>},
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement>}];
+       }
+     };
+     $rdf->convert_rdf_element ($item->{node});
+   },
+ };
+ my $default_error_level = {
+   must => 'm',
+   should => 's',
+   warn => 'w',
+   good => 'w',
+   undefined => 'w',
+   info => 'i',
+   uncertain => 'u',
+   html4_fact => 'm',
+   html5_no_may => 'm',
+   xml_error => 'm', ## TODO: correct?
+   xml_id_error => 'm', ## TODO: ?
+   nc => 'm', ## XML Namespace Constraints ## TODO: correct?
+   ## |Whatpm::URIChecker|
+   uri_syntax => 'm',
+   uri_fact => 'm',
+   uri_lc_must => 'm',
+   uri_lc_should => 'w',
+   ## |Whatpm::IMTChecker|
+   mime_must => 'm', # lowercase "must"
+   mime_fact => 'm',
+   mime_strongly_discouraged => 'w',
+   mime_discouraged => 'w',
+   ## |Whatpm::LangTag|
+   langtag_fact => 'm',
+   ## |Whatpm::RDFXML|
+   rdf_fact => 'm',
+   rdf_grammer => 'm',
+   rdf_lc_must => 'm',
+   ## |Message::Charset::Info| and |Whatpm::Charset::DecodeHandle|
+   charset_variant => 'm',
+     ## An error caused by use of a variant charset that is not conforming
+     ## to the original charset (e.g. use of 0x80 in an ISO-8859-1 document
+     ## which is interpreted as a Windows-1252 document instead).
+   charset_fact => 'm',
+   iso_shall => 'm',
+ };
+ sub check_document ($$$;$) {
+   my ($self, $doc, $onerror, $onsubdoc) = @_;
+   $self = bless {}, $self unless ref $self;
+   $self->{onerror} = $onerror;
+   $self->{onsubdoc} = $onsubdoc || sub {
+     warn "A subdocument is not conformance-checked";
+   };
- ## Zero or more block-level elements
+   $self->{level} ||= $default_error_level;
- 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;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       $not_allowed = 1
-         unless $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $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);
- }; # $HTMLBlockChecker
- ## Inline-level content
+   ## TODO: If application/rdf+xml, RDF/XML mode should be invoked.
- 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;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       $not_allowed = 1
-         unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-           $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $not_allowed;
-       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) {
+   my $docel = $doc->document_element;
-     $_->{inline} = 1;
+   unless (defined $docel) {
+     ## ISSUE: Should we check content of Document node?
+     $onerror->(node => $doc, type => 'no document element',
+                level => $self->{level}->{must});
+     ## ISSUE: Is this non-conforming (to what spec)?  Or just a warning?
+     return {
+             class => {},
+             id => {}, table => [], term => {},
+            };
    }
-   return ($new_todos);
- }; # $HTMLInlineChecker
- my $HTMLSignificantInlineChecker = $HTMLInlineChecker;
- ## TODO: check significant content
- ## Strictly inline-level content
+   ## ISSUE: Unexpanded entity references and HTML5 conformance
- my $HTMLStrictlyInlineChecker = sub {
-   my ($self, $todo) = @_;
-   my $el = $todo->{node};
-   my $new_todos = [];
-   my @nodes = (@{$el->child_nodes});
-   while (@nodes) {
+   my $docel_nsuri = $docel->namespace_uri;
-     my $node = shift @nodes;
+   if (defined $docel_nsuri) {
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
+     load_ns_module ($docel_nsuri);
+   } else {
-     my $nt = $node->node_type;
+     $docel_nsuri = '';
-     if ($nt == 1) {
-       my $node_ns = $node->namespace_uri;
-       $node_ns = '' unless defined $node_ns;
-       my $node_ln = $node->manakai_local_name;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       $not_allowed = 1
-         unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln};
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $not_allowed;
-       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);
+   my $docel_def = $Element->{$docel_nsuri}->{$docel->manakai_local_name} ||
- }; # $HTMLStrictlyInlineChecker
+     $Element->{$docel_nsuri}->{''} ||
+     $ElementDefault;
- my $HTMLSignificantStrictlyInlineChecker = $HTMLStrictlyInlineChecker;
+   if ($docel_def->{is_root}) {
- ## TODO: check significant content
+     #
+   } elsif ($docel_def->{is_xml_root}) {
- ## Inline-level or strictly inline-kevek content
+     unless ($doc->manakai_is_html) {
- my $HTMLInlineOrStrictlyInlineChecker = sub {
+       #
-   my ($self, $todo) = @_;
+     } else {
-   my $el = $todo->{node};
+       $onerror->(node => $docel, type => 'element not allowed:root:xml',
-   my $new_todos = [];
+                  level => $self->{level}->{must});
-   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;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       if ($todo->{strictly_inline}) {
-         $not_allowed = 1
-           unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln};
-       } else {
-         $not_allowed = 1
-           unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-             $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-       }
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $not_allowed;
-       my ($sib, $ch) = $self->_check_get_children ($node);
-       unshift @nodes, @$sib;
-       push @$new_todos, @$ch;
-     } elsif ($nt == 5) {
-       unshift @nodes, @{$node->child_nodes};
      }
+   } else {
+     $onerror->(node => $docel, type => 'element not allowed:root',
+                level => $self->{level}->{must});
    }
-   for (@$new_todos) {
+   ## TODO: Check for other items other than document element
-     $_->{inline} = 1;
+   ## (second (errorous) element, text nodes, PI nodes, doctype nodes)
-     $_->{strictly_inline} = 1;
-   }
-   return ($new_todos);
- }; # $HTMLInlineOrStrictlyInlineChecker
- my $HTMLSignificantInlineOrStrictlyInlineChecker
-     = $HTMLInlineOrStrictlyInlineChecker;
- ## TODO: check significant content
- 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;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       if ($content eq 'block') {
-         $not_allowed = 1
-           unless $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-       } elsif ($content eq 'inline') {
-         $not_allowed = 1
-           unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-             $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-       } else {
-         my $is_block = $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-         my $is_inline
-           = $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} ||
-             $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-         push @block_not_inline, $node
-           if $is_block and not $is_inline and not $not_allowed;
-         unless ($is_block) {
-           $content = 'inline';
-           for (@block_not_inline) {
-             $self->{onerror}->(node => $_, type => 'element not allowed');
-           }
-           $not_allowed = 1 unless $is_inline;
-         }
-       }
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $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};
-     }
-   }
-   if ($content eq 'inline') {
+   my $return = $self->check_element ($docel, $onerror, $onsubdoc);
-     for (@$new_todos) {
-       $_->{inline} = 1;
-     }
-   }
-   return ($new_todos);
- };
- ## Zero or more XXX element, then either block-level or inline-level
+   ## TODO: Test for these checks are necessary.
- my $GetHTMLZeroOrMoreThenBlockOrInlineChecker = sub ($$) {
+   my $charset_name = $doc->input_encoding;
-   my ($elnsuri, $ellname) = @_;
+   if (defined $charset_name) {
-   return sub {
+     require Message::Charset::Info;
-     my ($self, $todo) = @_;
+     my $charset = $Message::Charset::Info::IANACharset->{$charset_name};
-     my $el = $todo->{node};
-     my $new_todos = [];
+     if ($doc->manakai_is_html) {
-     my @nodes = (@{$el->child_nodes});
+       if (not $doc->manakai_has_bom and
+           not defined $doc->manakai_charset) {
-     my $has_non_style;
+         unless ($charset->{is_html_ascii_superset}) {
-     my $content = 'block-or-inline'; # or 'block' or 'inline'
+           $onerror->(node => $doc,
-     my @block_not_inline;
+                      level => $self->{level}->{must},
-     while (@nodes) {
+                      type => 'non ascii superset',
-       my $node = shift @nodes;
+                      text => $charset_name);
-       $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;
-         my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-         if ($node_ns eq $elnsuri and $node_ln eq $ellname) {
-           $not_allowed = 1 if $has_non_style;
-         } elsif ($content eq 'block') {
-           $has_non_style = 1;
-           $not_allowed = 1
-             unless $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-         } elsif ($content eq 'inline') {
-           $has_non_style = 1;
-           $not_allowed = 1
-             unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-         } else {
-           $has_non_style = 1;
-           my $is_block = $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-           my $is_inline
-             = $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} ||
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-           push @block_not_inline, $node
-             if $is_block and not $is_inline and not $not_allowed;
-           unless ($is_block) {
-             $content = 'inline';
-             for (@block_not_inline) {
-               $self->{onerror}->(node => $_, type => 'element not allowed');
-             }
-             $not_allowed = 1 unless $is_inline;
-           }
          }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $not_allowed;
+         if (not $self->{has_charset} and ## TODO: This does not work now.
-         my ($sib, $ch) = $self->_check_get_children ($node);
+             not $charset->{iana_names}->{'us-ascii'}) {
-         unshift @nodes, @$sib;
+           $onerror->(node => $doc,
-         push @$new_todos, @$ch;
+                      level => $self->{level}->{must},
-       } elsif ($nt == 3 or $nt == 4) {
+                      type => 'no character encoding declaration',
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
+                      text => $charset_name);
-           $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};
        }
-     }
-     if ($content eq 'inline') {
+       if ($charset->{iana_names}->{'utf-8'}) {
-       for (@$new_todos) {
+         #
-         $_->{inline} = 1;
+       } elsif ($charset->{iana_names}->{'jis_x0212-1990'} or
+                $charset->{iana_names}->{'x-jis0208'} or
+                $charset->{iana_names}->{'utf-32'} or ## ISSUE: UTF-32BE? UTF-32LE?
+                ($charset->{category} & Message::Charset::Info::CHARSET_CATEGORY_EBCDIC ())) {
+         $onerror->(node => $doc,
+                    type => 'bad character encoding',
+                    text => $charset_name,
+                    level => $self->{level}->{should},
+                    layer => 'encode');
+       } elsif ($charset->{iana_names}->{'cesu-8'} or
+                $charset->{iana_names}->{'utf-8'} or ## ISSUE: UNICODE-1-1-UTF-7?
+                $charset->{iana_names}->{'bocu-1'} or
+                $charset->{iana_names}->{'scsu'}) {
+         $onerror->(node => $doc,
+                    type => 'disallowed character encoding',
+                    text => $charset_name,
+                    level => $self->{level}->{must},
+                    layer => 'encode');
+       } else {
+         $onerror->(node => $doc,
+                    type => 'non-utf-8 character encoding',
+                    text => $charset_name,
+                    level => $self->{level}->{good},
+                    layer => 'encode');
        }
      }
-     return ($new_todos);
+   } elsif ($doc->manakai_is_html) {
-   };
+     ## NOTE: MUST and SHOULD requirements above cannot be tested,
- }; # $GetHTMLZeroOrMoreThenBlockOrInlineChecker
+     ## since the document has no input charset encoding information.
+     $onerror->(node => $doc,
- my $HTMLTransparentChecker = $HTMLBlockOrInlineChecker;
+                type => 'character encoding unchecked',
+                level => $self->{level}->{info},
- my $GetHTMLEnumeratedAttrChecker = sub {
+                layer => 'encode');
-   my $states = shift; # {value => conforming ? 1 : -1}
-   return sub {
-     my ($self, $attr) = @_;
-     my $value = lc $attr->value; ## TODO: ASCII case insensitibility?
-     if ($states->{$value} > 0) {
-       #
-     } elsif ($states->{$value}) {
-       $self->{onerror}->(node => $attr,
-                          type => 'non-conforming enumerated attribute value');
-     } else {
-       $self->{onerror}->(node => $attr,
-                          type => 'invalid enumerated attribute value');
-     }
-   };
- }; # $GetHTMLEnumeratedAttrChecker
- my $GetHTMLBooleanAttrChecker = sub {
-   my $local_name = shift;
-   return sub {
-     my ($self, $attr) = @_;
-     my $value = $attr->value;
-     unless ($value eq $local_name or $value eq '') {
-       $self->{onerror}->(node => $attr,
-                          type => 'invalid boolean attribute value');
-     }
-   };
- }; # $GetHTMLBooleanAttrChecker
- my $HTMLUnorderedSetOfSpaceSeparatedTokensAttrChecker = sub {
-   my ($self, $attr) = @_;
-   my %word;
-   for my $word (grep {length $_} split /[\x09-\x0D\x20]/, $attr->value) {
-     unless ($word{$word}) {
-       $word{$word} = 1;
-     } else {
-       $self->{onerror}->(node => $attr, type => 'duplicate token:'.$word);
-     }
    }
- }; # $HTMLUnorderedSetOfSpaceSeparatedTokensAttrChecker
- my $HTMLURIAttrChecker = sub {
+   return $return;
-   my ($self, $attr) = @_;
+ } # check_document
-   ## TODO: URI or IRI check
- }; # $HTMLURIAttrChecker
- my $HTMLIntegerAttrChecker = sub {
-   my ($self, $attr) = @_;
-   my $value = $attr->value;
-   unless ($value =~ /\A-?[0-9]+\z/) {
-     $self->{onerror}->(node => $attr, type => 'syntax error');
-   }
- }; # $HTMLIntegerAttrChecker
- my $GetHTMLNonNegativeIntegerAttrChecker = sub {
-   my $range_check = shift;
-   return sub {
-     my ($self, $attr) = @_;
-     my $value = $attr->value;
-     if ($value =~ /\A[0-9]+\z/) {
-       unless ($range_check->($value + 0)) {
-         $self->{onerror}->(node => $attr, type => 'out of range');
-       }
-     } else {
-       $self->{onerror}->(node => $attr, type => 'syntax error');
-     }
-   };
- }; # $GetHTMLNonNegativeIntegerAttrChecker
- my $GetHTMLFloatingPointNumberAttrChecker = sub {
+ ## Check an element.  The element is checked as if it is an orphan node (i.e.
-   my $range_check = shift;
+ ## an element without a parent node).
-   return sub {
+ sub check_element ($$$;$) {
-     my ($self, $attr) = @_;
+   my ($self, $el, $onerror, $onsubdoc) = @_;
-     my $value = $attr->value;
+   $self = bless {}, $self unless ref $self;
-     if ($value =~ /\A-?[0-9.]+\z/ and $value =~ /[0-9]/) {
+   $self->{onerror} = $onerror;
-       unless ($range_check->($value + 0)) {
+   $self->{onsubdoc} = $onsubdoc || sub {
-         $self->{onerror}->(node => $attr, type => 'out of range');
+     warn "A subdocument is not conformance-checked";
-       }
-     } else {
-       $self->{onerror}->(node => $attr, type => 'syntax error');
-     }
    };
- }; # $GetHTMLFloatingPointNumberAttrChecker
- my $HTMLAttrChecker = {
+   $self->{level} ||= $default_error_level;
-   id => sub {
-     my ($self, $attr) = @_;
-     my $value = $attr->value;
-     unless (length $value > 0) {
-       ## NOTE: MUST contain at least one character
-       $self->{onerror}->(node => $attr, type => 'attribute value is empty');
-     } else {
-       if ($self->{id}->{$value}) {
-         $self->{onerror}->(node => $attr, type => 'duplicate ID');
-       } else {
-         $self->{id}->{$value} = 1;
-       }
-     }
-   },
-   title => sub {}, ## NOTE: No conformance creteria
-   lang => sub {
-     ## TODO: RFC 3066 test
-     ## ISSUE: RFC 4646 (3066bis)?
-     ## TODO: HTML vs XHTML
-   },
-   dir => $GetHTMLEnumeratedAttrChecker->({ltr => 1, rtl => 1}),
-   class => $HTMLUnorderedSetOfSpaceSeparatedTokensAttrChecker,
-   irrelevant => $GetHTMLBooleanAttrChecker->('irrelevant'),
-   ## TODO: tabindex
- };
- my $GetHTMLAttrsChecker = sub {
+   $self->{plus_elements} = {};
-   my $element_specific_checker = shift;
+   $self->{minus_elements} = {};
-   return sub {
+   $self->{id} = {};
-     my ($self, $todo) = @_;
+   $self->{form} = {};
-     for my $attr (@{$todo->{node}->attributes}) {
+   $self->{term} = {};
-       my $attr_ns = $attr->namespace_uri;
+   $self->{usemap} = [];
-       $attr_ns = '' unless defined $attr_ns;
+   $self->{ref} = []; # datetemplate data references
-       my $attr_ln = $attr->manakai_local_name;
+   $self->{template} = []; # datatemplate template references
-       my $checker;
+   $self->{contextmenu} = [];
-       if ($attr_ns eq '') {
+   $self->{map} = {};
-         $checker = $element_specific_checker->{$attr_ln}
+   $self->{menu} = {};
-           || $HTMLAttrChecker->{$attr_ln};
+   $self->{has_link_type} = {};
-       }
+   $self->{flag} = {};
-       $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
+   #$self->{has_uri_attr};
-         || $AttrChecker->{$attr_ns}->{''};
+   #$self->{has_hyperlink_element};
-       if ($checker) {
+   #$self->{has_charset};
-         $checker->($self, $attr);
+   #$self->{has_base};
-       } else {
+   $self->{return} = {
-         $self->{onerror}->(node => $attr, type => 'attribute not supported');
+     class => {},
-         ## ISSUE: No comformance createria for unknown attributes in the spec
+     id => $self->{id},
-       }
+     table => [], # table objects returned by Whatpm::HTMLTable
-     }
+     term => $self->{term},
+     uri => {}, # URIs other than those in RDF triples
+                      ## TODO: xmlns="", SYSTEM "", atom:* src="", xml:base=""
+     rdf => [],
    };
- }; # $GetHTMLAttrsChecker
- $Element->{$HTML_NS}->{''} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $ElementDefault->{checker},
- };
- $Element->{$HTML_NS}->{html} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     xmlns => sub {
-       my ($self, $attr) = @_;
-       my $value = $attr->value;
-       unless ($value eq $HTML_NS) {
-         $self->{onerror}->(node => $attr, type => 'syntax error');
-         ## TODO: only in HTML documents
-       }
-     },
-   }),
-   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;
-         my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-         if ($phase eq 'before head') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'head') {
-             $phase = 'after head';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'body') {
-             $self->{onerror}->(node => $node, type => 'ps element missing:head');
-             $phase = 'after body';
-           } else {
-             $not_allowed = 1;
-             # before head
-           }
-         } elsif ($phase eq 'after head') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'body') {
-             $phase = 'after body';
-           } else {
-             $not_allowed = 1;
-             # after head
-           }
-         } else { #elsif ($phase eq 'after body') {
-           $not_allowed = 1;
-           # after body
-         }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $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};
-       }
-     }
-     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);
-   },
- };
- $Element->{$HTML_NS}->{head} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $has_title;
-     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;
-         my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-         if ($node_ns eq $HTML_NS and $node_ln eq 'title') {
-           $phase = 'after base';
-           unless ($has_title) {
-             $has_title = 1;
-           } else {
-             $not_allowed = 1;
-           }
-         } elsif ($node_ns eq $HTML_NS and $node_ln eq 'meta') {
-           if ($node->has_attribute_ns (undef, 'charset')) {
-             if ($phase eq 'initial') {
-               $phase = 'after charset';
-             } else {
-               $not_allowed = 1;
-               ## NOTE: See also |base|'s "contexts" field in the spec
-             }
-           } else {
-             $phase = 'after base';
-           }
-         } elsif ($node_ns eq $HTML_NS and $node_ln eq 'base') {
-           if ($phase eq 'initial' or $phase eq 'after charset') {
-             $phase = 'after base';
-           } else {
-             $not_allowed = 1;
-           }
-         } elsif ($HTMLMetadataElements->{$node_ns}->{$node_ln}) {
-           $phase = 'after base';
-         } else {
-           $not_allowed = 1;
-         }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $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};
-       }
-     }
-     unless ($has_title) {
-       $self->{onerror}->(node => $el, type => 'child element missing:title');
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{title} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLTextChecker,
- };
- $Element->{$HTML_NS}->{base} = {
+   my @item = ({type => 'element', node => $el, parent_state => {}});
-   attrs_checker => $GetHTMLAttrsChecker->({
+   $item[-1]->{real_parent_state} = $item[-1]->{parent_state};
-     href => $HTMLURIAttrChecker,
+   while (@item) {
-     ## TODO: target
+     my $item = shift @item;
-   }),
+     if (ref $item eq 'ARRAY') {
-   checker => $HTMLEmptyChecker,
+       my $code = shift @$item;
- };
+ next unless $code;## TODO: temp.
+       $code->(@$item);
- $Element->{$HTML_NS}->{link} = {
+     } elsif ($item->{type} eq 'element') {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
+       my $el_nsuri = $item->{node}->namespace_uri;
-   checker => $HTMLEmptyChecker,
+       if (defined $el_nsuri) {
- };
+         load_ns_module ($el_nsuri);
- $Element->{$HTML_NS}->{meta} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     my $name_attr;
-     my $http_equiv_attr;
-     my $charset_attr;
-     my $content_attr;
-     for my $attr (@{$todo->{node}->attributes}) {
-       my $attr_ns = $attr->namespace_uri;
-       $attr_ns = '' unless defined $attr_ns;
-       my $attr_ln = $attr->manakai_local_name;
-       my $checker;
-       if ($attr_ns eq '') {
-         if ($attr_ln eq 'content') {
-           $content_attr = $attr;
-           $checker = 1;
-         } elsif ($attr_ln eq 'name') {
-           $name_attr = $attr;
-           $checker = 1;
-         } elsif ($attr_ln eq 'http-equiv') {
-           $http_equiv_attr = $attr;
-           $checker = 1;
-         } elsif ($attr_ln eq 'charset') {
-           $charset_attr = $attr;
-           $checker = 1;
-         } else {
-           $checker = $HTMLAttrChecker->{$attr_ln}
-             || $AttrChecker->{$attr_ns}->{$attr_ln}
-               || $AttrChecker->{$attr_ns}->{''};
-         }
-       } else {
-         $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
-           || $AttrChecker->{$attr_ns}->{''};
-       }
-       if ($checker) {
-         $checker->($self, $attr) if ref $checker;
-       } else {
-         $self->{onerror}->(node => $attr, type => 'attribute not supported');
-         ## ISSUE: No comformance createria for unknown attributes in the spec
-       }
-     }
-     if (defined $name_attr) {
-       if (defined $http_equiv_attr) {
-         $self->{onerror}->(node => $http_equiv_attr,
-                            type => 'attribute not allowed');
-       } elsif (defined $charset_attr) {
-         $self->{onerror}->(node => $charset_attr,
-                            type => 'attribute not allowed');
-       }
-       my $metadata_name = $name_attr->value;
-       my $metadata_value;
-       if (defined $content_attr) {
-         $metadata_value = $content_attr->value;
-       } else {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:content');
-         $metadata_value = '';
-       }
-     } elsif (defined $http_equiv_attr) {
-       if (defined $charset_attr) {
-         $self->{onerror}->(node => $charset_attr,
-                            type => 'attribute not allowed');
-       }
-       unless (defined $content_attr) {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:content');
-       }
-     } elsif (defined $charset_attr) {
-       if (defined $content_attr) {
-         $self->{onerror}->(node => $content_attr,
-                            type => 'attribute not allowed');
-       }
-       ## TODO: Allowed only in HTML documents
-     } else {
-       if (defined $content_attr) {
-         $self->{onerror}->(node => $content_attr,
-                            type => 'attribute not allowed');
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:name|http-equiv');
        } else {
-         $self->{onerror}->(node => $todo->{node},
+         $el_nsuri = '';
-                            type => 'attribute missing:name|http-equiv|charset');
        }
-     }
+       my $el_ln = $item->{node}->manakai_local_name;
-     ## TODO: metadata conformance
+       my $element_state = {};
+       my $eldef = $Element->{$el_nsuri}->{$el_ln} ||
-     ## TODO: pragma conformance
+           $Element->{$el_nsuri}->{''} ||
-     if (defined $http_equiv_attr) { ## An enumerated attribute
+           $ElementDefault;
-       my $keyword = lc $http_equiv_attr->value; ## TODO: ascii case?
+       my $content_def = $item->{transparent}
-       if ({
+           ? $item->{parent_def} || $eldef : $eldef;
-            'refresh' => 1,
+       my $content_state = $item->{transparent}
-            'default-style' => 1,
+           ? $item->{parent_def}
-           }->{$keyword}) {
+               ? $item->{parent_state} || $element_state : $element_state
-         #
+           : $element_state;
-       } else {
-         $self->{onerror}->(node => $http_equiv_attr,
+       unless ($eldef->{status} & FEATURE_STATUS_REC) {
-                            type => 'invalid enumerated attribute value');
+         my $status = $eldef->{status} & FEATURE_STATUS_CR ? 'cr' :
-       }
+             $eldef->{status} & FEATURE_STATUS_LC ? 'lc' :
-     }
+             $eldef->{status} & FEATURE_STATUS_WD ? 'wd' : 'non-standard';
+         $self->{onerror}->(node => $item->{node},
-     ## TODO: charset
+                            type => 'status:'.$status.':element',
-   },
+                            level => $self->{level}->{info});
-   checker => $HTMLEmptyChecker,
+       }
- };
+       if (not ($eldef->{status} & FEATURE_ALLOWED)) {
+         $self->{onerror}->(node => $item->{node},
- ## NOTE: |html:style| has no conformance creteria on content model
+                            type => 'element not defined',
- $Element->{$HTML_NS}->{style} = {
+                            level => $self->{level}->{must});
-   attrs_checker => $GetHTMLAttrsChecker->({
+       } elsif ($eldef->{status} & FEATURE_DEPRECATED_SHOULD) {
-     ## TODO: type
+         $self->{onerror}->(node => $item->{node},
-     ## TODO: media
+                            type => 'deprecated:element',
-     scoped => $GetHTMLBooleanAttrChecker->('scoped'),
+                            level => $self->{level}->{should});
-     ## NOTE: |title| has special semantics for |style|s, but is syntactically
+       } elsif ($eldef->{status} & FEATURE_DEPRECATED_INFO) {
-     ## not different
+         $self->{onerror}->(node => $item->{node},
-   }),
+                            type => 'deprecated:element',
-   checker => $AnyChecker,
+                            level => $self->{level}->{info});
- };
+       }
- $Element->{$HTML_NS}->{body} = {
+       my @new_item;
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+       push @new_item, [$eldef->{check_start}, $self, $item, $element_state];
-   checker => $HTMLBlockChecker,
+       push @new_item, [$eldef->{check_attrs}, $self, $item, $element_state];
- };
+       my @child = @{$item->{node}->child_nodes};
- $Element->{$HTML_NS}->{section} = {
+       while (@child) {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+         my $child = shift @child;
-   checker => $HTMLStylableBlockChecker,
+         my $child_nt = $child->node_type;
- };
+         if ($child_nt == 1) { # ELEMENT_NODE
+           my $child_nsuri = $child->namespace_uri;
- $Element->{$HTML_NS}->{nav} = {
+           $child_nsuri = '' unless defined $child_nsuri;
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+           my $child_ln = $child->manakai_local_name;
-   checker => $HTMLBlockOrInlineChecker,
+           if ($HTMLTransparentElements->{$child_nsuri}->{$child_ln} and
- };
+               not (($self->{flag}->{in_head} or
+                     ($el_nsuri eq $HTML_NS and $el_ln eq 'head')) and
- $Element->{$HTML_NS}->{article} = {
+                    $child_nsuri eq $HTML_NS and $child_ln eq 'noscript')) {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+             push @new_item, [$content_def->{check_child_element},
-   checker => $HTMLStylableBlockChecker,
+                              $self, $item, $child,
- };
+                              $child_nsuri, $child_ln, 1,
+                              $content_state, $element_state];
- $Element->{$HTML_NS}->{blockquote} = {
+             push @new_item, {type => 'element', node => $child,
-   attrs_checker => $GetHTMLAttrsChecker->({
+                              parent_state => $content_state,
-     cite => $HTMLURIAttrChecker,
+                              parent_def => $content_def,
-   }),
+                              real_parent_state => $element_state,
-   checker => $HTMLBlockChecker,
+                              transparent => 1};
- };
- $Element->{$HTML_NS}->{aside} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'style'),
- };
- $Element->{$HTML_NS}->{h1} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h2} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h3} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h4} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h5} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h6} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- ## TODO: header
- $Element->{$HTML_NS}->{footer} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   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;
-         my $not_allowed;
-         if ($self->{minuses}->{$node_ns}->{$node_ln}) {
-           $not_allowed = 1;
-         } 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}) {
-           $not_allowed = 1;
-         } elsif ($HTMLSectioningElements->{$node_ns}->{$node_ln}) {
-           $not_allowed = 1;
-         }
-         if ($content eq 'block') {
-           $not_allowed = 1
-             unless $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-         } elsif ($content eq 'inline') {
-           $not_allowed = 1
-             unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-         } else {
-           my $is_block = $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-           my $is_inline
-             = $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} ||
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-           push @block_not_inline, $node
-             if $is_block and not $is_inline and not $not_allowed;
-           unless ($is_block) {
-             $content = 'inline';
-             for (@block_not_inline) {
-               $self->{onerror}->(node => $_, type => 'element not allowed');
-             }
-             $not_allowed = 1 unless $is_inline;
-           }
-         }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $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';
+             if ($item->{parent_def} and # has parent
-             for (@block_not_inline) {
+                 $el_nsuri eq $HTML_NS) { ## $HTMLSemiTransparentElements
-               $self->{onerror}->(node => $_, type => 'element not allowed');
+               if ($el_ln eq 'object') {
+                 if ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
+                   #
+                 } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'param') {
+                   #
+                 } else {
+                   $content_def = $item->{parent_def} || $content_def;
+                   $content_state = $item->{parent_state} || $content_state;
+                 }
+               } elsif ($el_ln eq 'video' or $el_ln eq 'audio') {
+                 if ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
+                   #
+                 } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'source') {
+                   $element_state->{has_source} = 1;
+                 } else {
+                   $content_def = $item->{parent_def} || $content_def;
+                   $content_state = $item->{parent_state} || $content_state;
+                 }
+               }
              }
-           }
-         }
-       } 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);
-   },
- };
- $Element->{$HTML_NS}->{address} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineChecker,
- };
- $Element->{$HTML_NS}->{p} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantInlineChecker,
- };
- $Element->{$HTML_NS}->{hr} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{br} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{dialog} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $phase = 'before dt';
-     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;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($phase eq 'before dt') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             $phase = 'before dd';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             $self->{onerror}
-               ->(node => $node, type => 'ps element missing:dt');
-             $phase = 'before dt';
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } else { # before dd
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             $phase = 'before dt';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             $self->{onerror}
-               ->(node => $node, type => 'ps element missing:dd');
-             $phase = 'before dd';
-           } 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};
-       }
-     }
-     if ($phase eq 'before dd') {
-       $self->{onerror}->(node => $el, type => 'ps element missing:dd');
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{pre} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{ol} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     start => $HTMLIntegerAttrChecker,
-   }),
-   checker => 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;
-         ## NOTE: |minuses| list is not checked since redundant
-         unless ($node_ns eq $HTML_NS and $node_ln eq 'li') {
-           $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};
-       }
-     }
-     if ($todo->{inline}) {
-       for (@$new_todos) {
-         $_->{inline} = 1;
-       }
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{ul} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $Element->{$HTML_NS}->{ol}->{checker},
- };
- $Element->{$HTML_NS}->{li} = {
+             push @new_item, [$content_def->{check_child_element},
-   attrs_checker => $GetHTMLAttrsChecker->({
+                              $self, $item, $child,
-     start => sub {
+                              $child_nsuri, $child_ln,
-       my ($self, $attr) = @_;
+                              $HTMLSemiTransparentElements
-       my $parent = $attr->owner_element->manakai_parent_element;
+                                  ->{$child_nsuri}->{$child_ln},
-       if (defined $parent) {
+                              $content_state, $element_state];
-         my $parent_ns = $parent->namespace_uri;
+             push @new_item, {type => 'element', node => $child,
-         $parent_ns = '' unless defined $parent_ns;
+                              parent_def => $content_def,
-         my $parent_ln = $parent->manakai_local_name;
+                              real_parent_state => $element_state,
-         unless ($parent_ns eq $HTML_NS and $parent_ln eq 'ol') {
+                              parent_state => $content_state};
-           $self->{onerror}->(node => $attr, type => 'attribute not supported');
+           }
-         }
-       }
+           if ($HTMLEmbeddedContent->{$child_nsuri}->{$child_ln}) {
-       $HTMLIntegerAttrChecker->($self, $attr);
+             $element_state->{has_significant} = 1;
-     },
+           }
-   }),
+         } elsif ($child_nt == 3 or # TEXT_NODE
-   checker => sub {
+                  $child_nt == 4) { # CDATA_SECTION_NODE
-     my ($self, $todo) = @_;
+           my $has_significant = ($child->data =~ /[^\x09\x0A\x0C\x0D\x20]/);
-     if ($todo->{inline}) {
+           push @new_item, [$content_def->{check_child_text},
-       return $HTMLInlineChecker->($self, $todo);
+                            $self, $item, $child, $has_significant,
+                            $content_state, $element_state];
+           $element_state->{has_significant} ||= $has_significant;
+           if ($has_significant and
+               $HTMLSemiTransparentElements->{$el_nsuri}->{$el_ln}) {
+             $content_def = $item->{parent_def} || $content_def;
+           }
+         } elsif ($child_nt == 5) { # ENTITY_REFERENCE_NODE
+           push @child, @{$child->child_nodes};
+         }
+         ## TODO: PI_NODE
+         ## TODO: Unknown node type
+       }
+       push @new_item, [$eldef->{check_end}, $self, $item, $element_state];
+       unshift @item, @new_item;
      } else {
-       return $HTMLBlockOrInlineChecker->($self, $todo);
+       die "$0: Internal error: Unsupported checking action type |$item->{type}|";
      }
-   },
+   }
- };
- $Element->{$HTML_NS}->{dl} = {
+   for (@{$self->{template}}) {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+     ## TODO: If the document is an XML document, ...
-   checker => sub {
+     ## NOTE: If the document is an HTML document:
-     my ($self, $todo) = @_;
+     ## ISSUE: We need to percent-decode?
-     my $el = $todo->{node};
+     F: {
-     my $new_todos = [];
+       if ($self->{id}->{$_->[0]}) {
-     my @nodes = (@{$el->child_nodes});
+         my $el = $self->{id}->{$_->[0]}->[0]->owner_element;
+         if ($el->node_type == 1 and # ELEMENT_NODE
-     my $phase = 'before dt';
+             $el->manakai_local_name eq 'datatemplate') {
-     while (@nodes) {
+           my $nsuri = $el->namespace_uri;
-       my $node = shift @nodes;
+           if (defined $nsuri and $nsuri eq $HTML_NS) {
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
+             if ($el eq $_->[1]->owner_element) {
+               $self->{onerror}->(node => $_->[1],
-       my $nt = $node->node_type;
+                                  type => 'fragment points itself',
-       if ($nt == 1) {
+                                  level => $self->{level}->{must});
-         my $node_ns = $node->namespace_uri;
+             }
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
+             last F;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($phase eq 'in dds') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             #$phase = 'in dds';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             $phase = 'in dts';
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'in dts') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             #$phase = 'in dts';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             $phase = 'in dds';
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } else { # before dt
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             $phase = 'in dts';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             $self->{onerror}
-               ->(node => $node, type => 'ps element missing:dt');
-             $phase = 'in dds';
-           } 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};
        }
-     }
+       ## TODO: Should we raise a "fragment points nothing" error instead
-     if ($phase eq 'in dts') {
+       ## if the fragment identifier identifies no element?
-       $self->{onerror}->(node => $el, type => 'ps element missing:dd');
-     }
-     if ($todo->{inline}) {
+       $self->{onerror}->(node => $_->[1], type => 'template:not template',
-       for (@$new_todos) {
+                          level => $self->{level}->{must});
-         $_->{inline} = 1;
+     } # F
+   }
+   for (@{$self->{ref}}) {
+     ## TOOD: If XML
+     ## NOTE: If it is an HTML document:
+     if ($_->[0] eq '') {
+       ## NOTE: It points the top of the document.
+     } elsif ($self->{id}->{$_->[0]}) {
+       if ($self->{id}->{$_->[0]}->[0]->owner_element
+               eq $_->[1]->owner_element) {
+         $self->{onerror}->(node => $_->[1], type => 'fragment points itself',
+                            level => $self->{level}->{must});
        }
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{dt} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{dd} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $Element->{$HTML_NS}->{li}->{checker},
- };
- $Element->{$HTML_NS}->{a} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $end = $self->_add_minuses ($HTMLInteractiveElements);
-     my ($sib, $ch)
-       = $HTMLSignificantInlineOrStrictlyInlineChecker->($self, $todo);
-     push @$sib, $end;
-     return ($sib, $ch);
-   },
- };
- $Element->{$HTML_NS}->{q} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     cite => $HTMLURIAttrChecker,
-   }),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{cite} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{em} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{strong} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{small} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{m} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{dfn} = { ## TODO: term duplication
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   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} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     ## NOTE: |title| has special semantics for |abbr|s, but is syntactically
-     ## not different.  The spec says that the |title| MAY be omitted
-     ## if there is a |dfn| whose defining term is the abbreviation,
-     ## but it does not prohibit |abbr| w/o |title| in other cases.
-   }),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{time} = { ## TODO: validate content
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO: datetime
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{meter} = { ## TODO: "The recommended way of giving the value is to include it as contents of the element"
-   attrs_checker => $GetHTMLAttrsChecker->({
-     value => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     min => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     low => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     high => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     max => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     optimum => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-   }),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{progress} = { ## TODO: recommended to use content
-   attrs_checker => $GetHTMLAttrsChecker->({
-     value => $GetHTMLFloatingPointNumberAttrChecker->(sub { shift >= 0 }),
-     max => $GetHTMLFloatingPointNumberAttrChecker->(sub { shift > 0 }),
-   }),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{code} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{var} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{samp} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{kbd} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{sub} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{sup} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{span} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{i} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{b} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{bdo} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     $GetHTMLAttrsChecker->({})->($self, $todo);
-     unless ($todo->{node}->has_attribute_ns (undef, 'dir')) {
-       $self->{onerror}->(node => $todo->{node}, type => 'attribute missing:dir');
-     }
-   },
-   ## ISSUE: The spec does not directly say that |dir| is a enumerated attr.
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{ins} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     cite => $HTMLURIAttrChecker,
-     ## TODO: datetime
-   }),
-   checker => $HTMLTransparentChecker,
- };
- $Element->{$HTML_NS}->{del} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     cite => $HTMLURIAttrChecker,
-     ## TODO: datetime
-   }),
-   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
- $Element->{$HTML_NS}->{img} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{iframe} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     src => $HTMLURIAttrChecker,
-   }),
-   checker => $HTMLTextChecker,
- };
- $Element->{$HTML_NS}->{embed} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{param} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     $GetHTMLAttrsChecker->({
-       name => sub { },
-       value => sub { },
-     })->($self, $todo);
-     unless ($todo->{node}->has_attribute_ns (undef, 'name')) {
-       $self->{onerror}->(node => $todo->{node},
-                          type => 'attribute missing:name');
-     }
-     unless ($todo->{node}->has_attribute_ns (undef, 'value')) {
-       $self->{onerror}->(node => $todo->{node},
-                          type => 'attribute missing:value');
-     }
-   },
-   checker => $HTMLEmptyChecker,
- };
- ## TODO: object
- $Element->{$HTML_NS}->{video} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     src => $HTMLURIAttrChecker,
-     ## TODO: start, loopstart, loopend, end
-     ## ISSUE: they MUST be "value time offset"s.  Value?
-     ## ISSUE: loopcount has no conformance creteria
-     autoplay => $GetHTMLBooleanAttrChecker->('autoplay'),
-     controls => $GetHTMLBooleanAttrChecker->('controls'),
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     if ($todo->{node}->has_attribute_ns (undef, 'src')) {
-       return $HTMLBlockOrInlineChecker->($self, $todo);
      } else {
-       return $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'source')
+       $self->{onerror}->(node => $_->[1], type => 'fragment points nothing',
-         ->($self, $todo);
+                          level => $self->{level}->{must});
      }
-   },
+   }
- };
- $Element->{$HTML_NS}->{audio} = {
-   attrs_checker => $Element->{$HTML_NS}->{video}->{attrs_checker},
-   checker => $Element->{$HTML_NS}->{video}->{checker},
- };
- $Element->{$HTML_NS}->{source} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{canvas} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
-     width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
-   }),
-   checker => $HTMLInlineChecker,
- };
- $Element->{$HTML_NS}->{map} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLBlockChecker,
- };
- $Element->{$HTML_NS}->{area} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => $HTMLEmptyChecker,
- };
- ## TODO: only in map
- $Element->{$HTML_NS}->{table} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $phase = 'before caption';
-     my $has_tfoot;
-     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;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($phase eq 'in tbodys') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'tbody') {
-             #$phase = 'in tbodys';
-           } elsif (not $has_tfoot and
-                    $node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'after tfoot';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'in trs') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'tr') {
-             #$phase = 'in trs';
-           } elsif (not $has_tfoot and
-                    $node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'after tfoot';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'after thead') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'tbody') {
-             $phase = 'in tbodys';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tr') {
-             $phase = 'in trs';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'in tbodys';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'in colgroup') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'colgroup') {
-             $phase = 'in colgroup';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'thead') {
-             $phase = 'after thead';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tbody') {
-             $phase = 'in tbodys';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tr') {
-             $phase = 'in trs';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'in tbodys';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'before caption') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'caption') {
-             $phase = 'in colgroup';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'colgroup') {
-             $phase = 'in colgroup';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'thead') {
-             $phase = 'after thead';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tbody') {
-             $phase = 'in tbodys';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tr') {
-             $phase = 'in trs';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'in tbodys';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } 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');
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{caption} = {
+   ## TODO: Maybe we should have $document->manakai_get_by_fragment or something
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{colgroup} = {
+   for (@{$self->{usemap}}) {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
+     unless ($self->{map}->{$_->[0]}) {
-   checker => sub {
+       $self->{onerror}->(node => $_->[1], type => 'no referenced map',
-     my ($self, $todo) = @_;
+                          level => $self->{level}->{must});
-     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;
-         ## NOTE: |minuses| list is not checked since redundant
-         unless ($node_ns eq $HTML_NS and $node_ln eq 'col') {
-           $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);
+   }
-   },
- };
- $Element->{$HTML_NS}->{col} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     span => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-   }),
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{tbody} = {
+   for (@{$self->{contextmenu}}) {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+     unless ($self->{menu}->{$_->[0]}) {
-   checker => sub {
+       $self->{onerror}->(node => $_->[1], type => 'no referenced menu',
-     my ($self, $todo) = @_;
+                          level => $self->{level}->{must});
-     my $el = $todo->{node};
-     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) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($node_ns eq $HTML_NS and $node_ln eq '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};
-       }
-     }
-     unless ($has_tr) {
-       $self->{onerror}->(node => $el, type => 'child element missing:tr');
      }
-     return ($new_todos);
+   }
-   },
- };
- $Element->{$HTML_NS}->{thead} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $Element->{$HTML_NS}->{tbody},
- };
- $Element->{$HTML_NS}->{tfoot} = {
+   delete $self->{plus_elements};
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+   delete $self->{minus_elements};
-   checker => $Element->{$HTML_NS}->{tbody},
+   delete $self->{onerror};
- };
+   delete $self->{id};
+   delete $self->{form};
+   delete $self->{usemap};
+   delete $self->{ref};
+   delete $self->{template};
+   delete $self->{map};
+   return $self->{return};
+ } # check_element
- $Element->{$HTML_NS}->{tr} = {
+ sub _add_minus_elements ($$@) {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+   my $self = shift;
-   checker => sub {
+   my $element_state = shift;
-     my ($self, $todo) = @_;
+   for my $elements (@_) {
-     my $el = $todo->{node};
+     for my $nsuri (keys %$elements) {
-     my $new_todos = [];
+       for my $ln (keys %{$elements->{$nsuri}}) {
-     my @nodes = (@{$el->child_nodes});
+         unless ($self->{minus_elements}->{$nsuri}->{$ln}) {
+           $element_state->{minus_elements_original}->{$nsuri}->{$ln} = 0;
-     my $has_td;
+           $self->{minus_elements}->{$nsuri}->{$ln} = 1;
-     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;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($node_ns eq $HTML_NS and ($node_ln eq 'td' or $node_ln eq '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');
          }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
        }
      }
-     unless ($has_td) {
+   }
-       $self->{onerror}->(node => $el, type => 'child element missing:td|th');
+ } # _add_minus_elements
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{td} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     colspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-     rowspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-   }),
-   checker => $HTMLBlockOrInlineChecker,
- };
- $Element->{$HTML_NS}->{th} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     colspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-     rowspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-     scope => $GetHTMLEnumeratedAttrChecker
-         ->({row => 1, col => 1, rowgroup => 1, colgroup => 1}),
-   }),
-   checker => $HTMLBlockOrInlineChecker,
- };
- ## TODO: table model error checking
- ## TODO: forms
- $Element->{$HTML_NS}->{script} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => sub {
-     my ($self, $todo) = @_;
-     if ($todo->{node}->has_attribute_ns (undef, 'src')) {
+ sub _remove_minus_elements ($$) {
-       return $HTMLEmptyChecker->($self, $todo);
+   my $self = shift;
-     } else {
+   my $element_state = shift;
-       ## NOTE: No content model conformance in HTML5 spec.
+   for my $nsuri (keys %{$element_state->{minus_elements_original}}) {
-       return $AnyChecker->($self, $todo);
+     for my $ln (keys %{$element_state->{minus_elements_original}->{$nsuri}}) {
+       delete $self->{minus_elements}->{$nsuri}->{$ln};
      }
-   },
+   }
- };
+ } # _remove_minus_elements
- ## NOTE: When script is disabled.
- $Element->{$HTML_NS}->{noscript} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   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'} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     src => $HTMLURIAttrChecker,
-   }),
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{details} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     open => $GetHTMLBooleanAttrChecker->('open'),
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $end = $self->_add_minuses ({$HTML_NS => {a => 1, datagrid => 1}});
-     my ($sib, $ch)
-       = $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'legend')
-         ->($self, $todo);
-     push @$sib, $end;
-     return ($sib, $ch);
-   },
- };
- $Element->{$HTML_NS}->{datagrid} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
-     multiple => $GetHTMLBooleanAttrChecker->('multiple'),
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $end = $self->_add_minuses ({$HTML_NS => {a => 1, datagrid => 1}});
-     my ($sib, $ch) = $HTMLBlockChecker->($self, $todo);
-     push @$sib, $end;
-     return ($sib, $ch);
-   },
- };
- $Element->{$HTML_NS}->{command} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{menu} = {
+ sub _add_plus_elements ($$@) {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
+   my $self = shift;
-   checker => sub {
+   my $element_state = shift;
-     my ($self, $todo) = @_;
+   for my $elements (@_) {
-     my $el = $todo->{node};
+     for my $nsuri (keys %$elements) {
-     my $new_todos = [];
+       for my $ln (keys %{$elements->{$nsuri}}) {
-     my @nodes = (@{$el->child_nodes});
+         unless ($self->{plus_elements}->{$nsuri}->{$ln}) {
+           $element_state->{plus_elements_original}->{$nsuri}->{$ln} = 0;
-     my $content = 'li or inline';
+           $self->{plus_elements}->{$nsuri}->{$ln} = 1;
-     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;
-         my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-         if ($node_ns eq $HTML_NS and $node_ln eq 'li') {
-           if ($content eq 'inline') {
-             $not_allowed = 1;
-           } elsif ($content eq 'li or inline') {
-             $content = 'li';
-           }
-         } else {
-           if ($HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln}) {
-             $content = 'inline';
-           } else {
-             $not_allowed = 1;
-           }
-         }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $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 'li') {
-             $self->{onerror}->(node => $node, type => 'character not allowed');
-           } elsif ($content eq 'li or inline') {
-             $content = 'inline';
-           }
          }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
        }
      }
+   }
+ } # _add_plus_elements
-     for (@$new_todos) {
+ sub _remove_plus_elements ($$) {
-       $_->{inline} = 1;
+   my $self = shift;
-     }
+   my $element_state = shift;
-     return ($new_todos);
+   for my $nsuri (keys %{$element_state->{plus_elements_original}}) {
-   },
+     for my $ln (keys %{$element_state->{plus_elements_original}->{$nsuri}}) {
- };
+       delete $self->{plus_elements}->{$nsuri}->{$ln};
- $Element->{$HTML_NS}->{legend} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   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;
-       if ($nsuri eq $HTML_NS and $ln eq 'figure') {
-         return $HTMLInlineChecker->($self, $todo);
-       } else {
-         return $HTMLSignificantStrictlyInlineChecker->($self, $todo);
-       }
-     } else {
-       return $HTMLInlineChecker->($self, $todo);
      }
+   }
+ } # _remove_plus_elements
-     ## ISSUE: Content model is defined only for fieldset/legend,
+ sub _attr_status_info ($$$) {
-     ## details/legend, and figure/legend.
+   my ($self, $attr, $status_code) = @_;
-   },
- };
- $Element->{$HTML_NS}->{div} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'style'),
- };
- $Element->{$HTML_NS}->{font} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => $HTMLTransparentChecker,
- };
- sub new ($) {
-   return bless {}, shift;
- } # new
- sub check_element ($$$) {
-   my ($self, $el, $onerror) = @_;
-   $self->{minuses} = {};
+   if (not ($status_code & FEATURE_ALLOWED)) {
-   $self->{onerror} = $onerror;
+     $self->{onerror}->(node => $attr,
-   $self->{id} = {};
+                        type => 'attribute not defined',
+                        level => $self->{level}->{must});
+   } elsif ($status_code & FEATURE_DEPRECATED_SHOULD) {
+     $self->{onerror}->(node => $attr,
+                        type => 'deprecated:attr',
+                        level => $self->{level}->{should});
+   } elsif ($status_code & FEATURE_DEPRECATED_INFO) {
+     $self->{onerror}->(node => $attr,
+                        type => 'deprecated:attr',
+                        level => $self->{level}->{info});
+   }
-   my @todo = ({type => 'element', node => $el});
+   my $status;
-   while (@todo) {
+   if ($status_code & FEATURE_STATUS_REC) {
-     my $todo = shift @todo;
+     return;
-     if ($todo->{type} eq 'element') {
+   } elsif ($status_code & FEATURE_STATUS_CR) {
-       my $prefix = $todo->{node}->prefix;
+     $status = 'cr';
-       if (defined $prefix and $prefix eq 'xmlns') {
+   } elsif ($status_code & FEATURE_STATUS_LC) {
-         $self->{onerror}
+     $status = 'lc';
-           ->(node => $todo->{node},
+   } elsif ($status_code & FEATURE_STATUS_WD) {
-              type => 'NC:Reserved Prefixes and Namespace Names:<xmlns:>');
+     $status = 'wd';
-       }
+   } else {
-       my $nsuri = $todo->{node}->namespace_uri;
+     $status = 'non-standard';
-       $nsuri = '' unless defined $nsuri;
-       my $ln = $todo->{node}->manakai_local_name;
-       my $eldef = $Element->{$nsuri}->{$ln} ||
-         $Element->{$nsuri}->{''} ||
-           $ElementDefault;
-       $eldef->{attrs_checker}->($self, $todo);
-       my ($new_todos) = $eldef->{checker}->($self, $todo);
-       push @todo, @$new_todos;
-     } elsif ($todo->{type} eq 'element-attributes') {
-       my $prefix = $todo->{node}->prefix;
-       if (defined $prefix and $prefix eq 'xmlns') {
-         $self->{onerror}
-           ->(node => $todo->{node},
-              type => 'NC:Reserved Prefixes and Namespace Names:<xmlns:>');
-       }
-       my $nsuri = $todo->{node}->namespace_uri;
-       $nsuri = '' unless defined $nsuri;
-       my $ln = $todo->{node}->manakai_local_name;
-       my $eldef = $Element->{$nsuri}->{$ln} ||
-         $Element->{$nsuri}->{''} ||
-           $ElementDefault;
-       $eldef->{attrs_checker}->($self, $todo);
-     } elsif ($todo->{type} eq 'plus') {
-       $self->_remove_minuses ($todo);
-     }
    }
- } # check_element
+   $self->{onerror}->(node => $attr,
+                      type => 'status:'.$status.':attr',
+                      level => $self->{level}->{info});
+ } # _attr_status_info
  sub _add_minuses ($@) {
    my $self = shift;
-Line 2204 
 sub _add_minuses ($@) {
+Line 896 
 sub _add_minuses ($@) {
    return {type => 'plus', list => $r};
  } # _add_minuses
+ sub _add_pluses ($@) {
+   my $self = shift;
+   my $r = {};
+   for my $list (@_) {
+     for my $ns (keys %$list) {
+       for my $ln (keys %{$list->{$ns}}) {
+         unless ($self->{pluses}->{$ns}->{$ln}) {
+           $self->{pluses}->{$ns}->{$ln} = 1;
+           $r->{$ns}->{$ln} = 1;
+         }
+       }
+     }
+   }
+   return {type => 'minus', list => $r};
+ } # _add_pluses
  sub _remove_minuses ($$) {
    my ($self, $todo) = @_;
-   for my $ns (keys %{$todo->{list}}) {
+   if ($todo->{type} eq 'minus') {
-     for my $ln (keys %{$todo->{list}->{$ns}}) {
+     for my $ns (keys %{$todo->{list}}) {
-       delete $self->{minuses}->{$ns}->{$ln} if $todo->{list}->{$ns}->{$ln};
+       for my $ln (keys %{$todo->{list}->{$ns}}) {
+         delete $self->{pluses}->{$ns}->{$ln} if $todo->{list}->{$ns}->{$ln};
+       }
      }
+   } elsif ($todo->{type} eq 'plus') {
+     for my $ns (keys %{$todo->{list}}) {
+       for my $ln (keys %{$todo->{list}->{$ns}}) {
+         delete $self->{minuses}->{$ns}->{$ln} if $todo->{list}->{$ns}->{$ln};
+       }
+     }
+   } else {
+     die "$0: Unknown +- type: $todo->{type}";
    }
 ;
  } # _remove_minuses
- sub _check_get_children ($$) {
+ ## NOTE: Priority for "minuses" and "pluses" are currently left
-   my ($self, $node) = @_;
+ ## undefined and implemented inconsistently; it is not a problem for
+ ## now, since no element belongs to both lists.
+ sub _check_get_children ($$$) {
+   my ($self, $node, $parent_todo) = @_;
    my $new_todos = [];
    my $sib = [];
    TP: {
      my $node_ns = $node->namespace_uri;
      $node_ns = '' unless defined $node_ns;
      my $node_ln = $node->manakai_local_name;
-     if ($node_ns eq $HTML_NS) {
-       if ($node_ln eq 'noscript') {
-         my $end = $self->_add_minuses ({$HTML_NS, {noscript => 1}});
-         push @$sib, $end;
-       }
-     }
      if ($HTMLTransparentElements->{$node_ns}->{$node_ln}) {
-       unshift @$sib, @{$node->child_nodes};
+       if ($node_ns eq $HTML_NS and $node_ln eq 'noscript') {
-       push @$new_todos, {type => 'element-attributes', node => $node};
+         if ($parent_todo->{flag}->{in_head}) {
-       last TP;
+           #
+         } else {
+           my $end = $self->_add_minuses ({$HTML_NS, {noscript => 1}});
+           push @$sib, $end;
+           unshift @$sib, @{$node->child_nodes};
+           push @$new_todos, {type => 'element-attributes', node => $node};
+           last TP;
+         }
+       } elsif ($node_ns eq $HTML_NS and $node_ln eq 'del') {
+         my $sig_flag = $parent_todo->{flag}->{has_descendant}->{significant};
+         unshift @$sib, @{$node->child_nodes};
+         push @$new_todos, {type => 'element-attributes', node => $node};
+         push @$new_todos,
+             {type => 'code',
+              code => sub {
+                $parent_todo->{flag}->{has_descendant}->{significant} = 0
+                    if not $sig_flag;
+              }};
+         last TP;
+       } else {
+         unshift @$sib, @{$node->child_nodes};
+         push @$new_todos, {type => 'element-attributes', node => $node};
+         last TP;
+       }
      }
      if ($node_ns eq $HTML_NS and ($node_ln eq 'video' or $node_ln eq 'audio')) {
        if ($node->has_attribute_ns (undef, 'src')) {
-Line 2252 
 sub _check_get_children ($$) {
+Line 992 
 sub _check_get_children ($$) {
                last CN;
              }
            } elsif ($cnt == 3 or $cnt == 4) {
-             if ($cn->data =~ /[^\x09-\x0D\x20]/) {
+             if ($cn->data =~ /[^\x09\x0A\x0C\x0D\x20]/) {
                last CN;
              }
            }
          } # CN
          unshift @$sib, @cn;
        }
+     } elsif ($node_ns eq $HTML_NS and $node_ln eq 'object') {
+       my @cn = @{$node->child_nodes};
+       CN: while (@cn) {
+         my $cn = shift @cn;
+         my $cnt = $cn->node_type;
+         if ($cnt == 1) {
+           my $cn_nsuri = $cn->namespace_uri;
+           $cn_nsuri = '' unless defined $cn_nsuri;
+           if ($cn_nsuri eq $HTML_NS and $cn->manakai_local_name eq 'param') {
+             #
+           } else {
+             last CN;
+           }
+         } elsif ($cnt == 3 or $cnt == 4) {
+           if ($cn->data =~ /[^\x09\x0A\x0C\x0D\x20]/) {
+             last CN;
+           }
+         }
+       } # CN
+       unshift @$sib, @cn;
      }
      push @$new_todos, {type => 'element', node => $node};
    } # TP
+   for my $new_todo (@$new_todos) {
+     $new_todo->{flag} = {%{$parent_todo->{flag} or {}}};
+   }
    return ($sib, $new_todos);
  } # _check_get_children
+ =head1 LICENSE
+ Copyright 2007-2008 Wakaba <[email protected]>
+ This library is free software; you can redistribute it
+ and/or modify it under the same terms as Perl itself.
+ =cut
 ;
  # $Date$

 Legend:



Removed from v.1.13
 


changed lines


 
Added in v.1.97
 Legend:



Removed from v.1.13
 


changed lines


 
Added in v.1.97
-Removed from v.1.13
+Added in v.1.97

[email protected]	ViewVC Help
Powered by ViewVC 1.1.24