html::parser.3

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

with a \s-1TRUE\s0 argument and disabled with a \s-1FALSE\s0 argument.  The
attribute value is left unchanged if no argument is given.  The return
value from each method is the old attribute value.
.PP
Methods that can be used to get and/or set parser options are:
.ie n .IP "$p\->attr_encoded" 4
.el .IP "\f(CW$p\fR\->attr_encoded" 4
.IX Item "$p->attr_encoded"
.PD 0
.ie n .IP "$p\fR\->attr_encoded( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->attr_encoded( \f(CW$bool\fR )" 4
.IX Item "$p->attr_encoded( $bool )"
.PD
By default, the \f(CW\*(C`attr\*(C'\fR and \f(CW@attr\fR argspecs will have general
entities for attribute values decoded.  Enabling this attribute leaves
entities alone.
.ie n .IP "$p\fR\->boolean_attribute_value( \f(CW$val )" 4
.el .IP "\f(CW$p\fR\->boolean_attribute_value( \f(CW$val\fR )" 4
.IX Item "$p->boolean_attribute_value( $val )"
This method sets the value reported for boolean attributes inside \s-1HTML\s0
start tags.  By default, the name of the attribute is also used as its
value.  This affects the values reported for \f(CW\*(C`tokens\*(C'\fR and \f(CW\*(C`attr\*(C'\fR
argspecs.
.ie n .IP "$p\->case_sensitive" 4
.el .IP "\f(CW$p\fR\->case_sensitive" 4
.IX Item "$p->case_sensitive"
.PD 0
.ie n .IP "$p\fR\->case_sensitive( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->case_sensitive( \f(CW$bool\fR )" 4
.IX Item "$p->case_sensitive( $bool )"
.PD
By default, tagnames and attribute names are down-cased.  Enabling this
attribute leaves them as found in the \s-1HTML\s0 source document.
.ie n .IP "$p\->closing_plaintext" 4
.el .IP "\f(CW$p\fR\->closing_plaintext" 4
.IX Item "$p->closing_plaintext"
.PD 0
.ie n .IP "$p\fR\->closing_plaintext( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->closing_plaintext( \f(CW$bool\fR )" 4
.IX Item "$p->closing_plaintext( $bool )"
.PD
By default, \*(L"plaintext\*(R" element can never be closed. Everything up to
the end of the document is parsed in \s-1CDATA\s0 mode.  This historical
behaviour is what at least \s-1MSIE\s0 does.  Enabling this attribute makes
closing \*(L"</plaintext>\*(R" tag effective and the parsing process will resume
after seeing this tag.  This emulates gecko-based browsers.
.ie n .IP "$p\->empty_element_tags" 4
.el .IP "\f(CW$p\fR\->empty_element_tags" 4
.IX Item "$p->empty_element_tags"
.PD 0
.ie n .IP "$p\fR\->empty_element_tags( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->empty_element_tags( \f(CW$bool\fR )" 4
.IX Item "$p->empty_element_tags( $bool )"
.PD
By default, empty element tags are not recognized as such and the \*(L"/\*(R"
before \*(L">\*(R" is just treated like a normal name character (unless
\&\f(CW\*(C`strict_names\*(C'\fR is enabled).  Enabling this attribute make
\&\f(CW\*(C`HTML::Parser\*(C'\fR recognize these tags.
.Sp
Empty element tags look like start tags, but end with the character
sequence \*(L"/>\*(R" instead of \*(L">\*(R".  When recognized by \f(CW\*(C`HTML::Parser\*(C'\fR they
cause an artificial end event in addition to the start event.  The
\&\f(CW\*(C`text\*(C'\fR for the artificial end event will be empty and the \f(CW\*(C`tokenpos\*(C'\fR
array will be undefined even though the the token array will have one
element containing the tag name.
.ie n .IP "$p\->marked_sections" 4
.el .IP "\f(CW$p\fR\->marked_sections" 4
.IX Item "$p->marked_sections"
.PD 0
.ie n .IP "$p\fR\->marked_sections( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->marked_sections( \f(CW$bool\fR )" 4
.IX Item "$p->marked_sections( $bool )"
.PD
By default, section markings like <![CDATA[...]]> are treated like
ordinary text.  When this attribute is enabled section markings are
honoured.
.Sp
There are currently no events associated with the marked section
markup, but the text can be returned as \f(CW\*(C`skipped_text\*(C'\fR.
.ie n .IP "$p\->strict_comment" 4
.el .IP "\f(CW$p\fR\->strict_comment" 4
.IX Item "$p->strict_comment"
.PD 0
.ie n .IP "$p\fR\->strict_comment( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->strict_comment( \f(CW$bool\fR )" 4
.IX Item "$p->strict_comment( $bool )"
.PD
By default, comments are terminated by the first occurrence of \*(L"\-\->\*(R".
This is the behaviour of most popular browsers (like Mozilla, Opera and
\&\s-1MSIE\s0), but it is not correct according to the official \s-1HTML\s0
standard.  Officially, you need an even number of \*(L"\-\-\*(R" tokens before
the closing \*(L">\*(R" is recognized and there may not be anything but
whitespace between an even and an odd \*(L"\-\-\*(R".
.Sp
The official behaviour is enabled by enabling this attribute.
.Sp
Enabling of 'strict_comment' also disables recognizing these forms as
comments:
.Sp
.Vb 2
\&  </ comment>
\&  <! comment>
.Ve
.ie n .IP "$p\->strict_end" 4
.el .IP "\f(CW$p\fR\->strict_end" 4
.IX Item "$p->strict_end"
.PD 0
.ie n .IP "$p\fR\->strict_end( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->strict_end( \f(CW$bool\fR )" 4
.IX Item "$p->strict_end( $bool )"
.PD
By default, attributes and other junk are allowed to be present on end tags in a
manner that emulates \s-1MSIE\s0's behaviour.
.Sp
The official behaviour is enabled with this attribute.  If enabled,
only whitespace is allowed between the tagname and the final \*(L">\*(R".
.ie n .IP "$p\->strict_names" 4
.el .IP "\f(CW$p\fR\->strict_names" 4
.IX Item "$p->strict_names"
.PD 0
.ie n .IP "$p\fR\->strict_names( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->strict_names( \f(CW$bool\fR )" 4
.IX Item "$p->strict_names( $bool )"
.PD
By default, almost anything is allowed in tag and attribute names.
This is the behaviour of most popular browsers and allows us to parse
some broken tags with invalid attribute values like:
.Sp
.Vb 1
\&   <IMG SRC=newprevlstGr.gif ALT=[PREV LIST] BORDER=0>
.Ve
.Sp
By default, \*(L"\s-1LIST\s0]\*(R" is parsed as a boolean attribute, not as
part of the \s-1ALT\s0 value as was clearly intended.  This is also what
Mozilla sees.
.Sp
The official behaviour is enabled by enabling this attribute.  If
enabled, it will cause the tag above to be reported as text
since \*(L"\s-1LIST\s0]\*(R" is not a legal attribute name.
.ie n .IP "$p\->unbroken_text" 4
.el .IP "\f(CW$p\fR\->unbroken_text" 4
.IX Item "$p->unbroken_text"
.PD 0
.ie n .IP "$p\fR\->unbroken_text( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->unbroken_text( \f(CW$bool\fR )" 4
.IX Item "$p->unbroken_text( $bool )"
.PD
By default, blocks of text are given to the text handler as soon as
possible (but the parser takes care always to break text at a
boundary between whitespace and non-whitespace so single words and
entities can always be decoded safely).  This might create breaks that
make it hard to do transformations on the text. When this attribute is
enabled, blocks of text are always reported in one piece.  This will
delay the text event until the following (non-text) event has been
recognized by the parser.
.Sp
Note that the \f(CW\*(C`offset\*(C'\fR argspec will give you the offset of the first
segment of text and \f(CW\*(C`length\*(C'\fR is the combined length of the segments.
Since there might be ignored tags in between, these numbers can't be
used to directly index in the original document file.
.ie n .IP "$p\->utf8_mode" 4
.el .IP "\f(CW$p\fR\->utf8_mode" 4
.IX Item "$p->utf8_mode"
.PD 0
.ie n .IP "$p\fR\->utf8_mode( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->utf8_mode( \f(CW$bool\fR )" 4
.IX Item "$p->utf8_mode( $bool )"
.PD
Enable this option when parsing raw undecoded \s-1UTF\-8\s0.  This tells the
parser that the entities expanded for strings reported by \f(CW\*(C`attr\*(C'\fR,
\&\f(CW@attr\fR and \f(CW\*(C`dtext\*(C'\fR should be expanded as decoded \s-1UTF\-8\s0 so they end
up compatible with the surrounding text.
.Sp
If \f(CW\*(C`utf8_mode\*(C'\fR is enabled then it is an error to pass strings
containing characters with code above 255 to the \fIparse()\fR method, and
the \fIparse()\fR method will croak if you try.
.Sp
Example: The Unicode character \*(L"\ex{2665}\*(R" is \*(L"\exE2\ex99\exA5\*(R" when \s-1UTF\-8\s0
encoded.  The character can also be represented by the entity
\&\*(L"&hearts;\*(R" or \*(L"&#x2665\*(R".  If we feed the parser:
.Sp
.Vb 1
\&  $p\->parse("\exE2\ex99\exA5&hearts;");
.Ve
.Sp
then \f(CW\*(C`dtext\*(C'\fR will be reported as \*(L"\exE2\ex99\exA5\ex{2665}\*(R" without
\&\f(CW\*(C`utf8_mode\*(C'\fR enabled, but as \*(L"\exE2\ex99\exA5\exE2\ex99\exA5\*(R" when enabled.
The later string is what you want.
.Sp
This option is only available with perl\-5.8 or better.
.ie n .IP "$p\->xml_mode" 4
.el .IP "\f(CW$p\fR\->xml_mode" 4
.IX Item "$p->xml_mode"
.PD 0
.ie n .IP "$p\fR\->xml_mode( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->xml_mode( \f(CW$bool\fR )" 4
.IX Item "$p->xml_mode( $bool )"
.PD
Enabling this attribute changes the parser to allow some \s-1XML\s0
constructs.  This enables the behaviour controlled by individually by
the \f(CW\*(C`case_sensitive\*(C'\fR, \f(CW\*(C`empty_element_tags\*(C'\fR, \f(CW\*(C`strict_names\*(C'\fR and
\&\f(CW\*(C`xml_pic\*(C'\fR attributes and also suppresses special treatment of
elements that are parsed as \s-1CDATA\s0 for \s-1HTML\s0.
.ie n .IP "$p\->xml_pic" 4
.el .IP "\f(CW$p\fR\->xml_pic" 4
.IX Item "$p->xml_pic"
.PD 0
.ie n .IP "$p\fR\->xml_pic( \f(CW$bool )" 4
.el .IP "\f(CW$p\fR\->xml_pic( \f(CW$bool\fR )" 4
.IX Item "$p->xml_pic( $bool )"
.PD
By default, \fIprocessing instructions\fR are terminated by \*(L">\*(R". When
this attribute is enabled, processing instructions are terminated by
\&\*(L"?>\*(R" instead.
.PP
As markup and text is recognized, handlers are invoked.  The following
method is used to set up handlers for different events:
.ie n .IP "$p\fR\->handler( event => \e&subroutine, \f(CW$argspec )" 4
.el .IP "\f(CW$p\fR\->handler( event => \e&subroutine, \f(CW$argspec\fR )" 4
.IX Item "$p->handler( event => &subroutine, $argspec )"
.PD 0
.ie n .IP "$p\fR\->handler( event => \f(CW$method_name\fR, \f(CW$argspec )" 4
.el .IP "\f(CW$p\fR\->handler( event => \f(CW$method_name\fR, \f(CW$argspec\fR )" 4
.IX Item "$p->handler( event => $method_name, $argspec )"
.ie n .IP "$p\fR\->handler( event => \e@accum, \f(CW$argspec )" 4
.el .IP "\f(CW$p\fR\->handler( event => \e@accum, \f(CW$argspec\fR )" 4
.IX Item "$p->handler( event => @accum, $argspec )"
.ie n .IP "$p\->handler( event => """" );" 4
.el .IP "\f(CW$p\fR\->handler( event => ``'' );" 4
.IX Item "$p->handler( event => """" );"
.ie n .IP "$p\->handler( event => undef );" 4
.el .IP "\f(CW$p\fR\->handler( event => undef );" 4
.IX Item "$p->handler( event => undef );"
.ie n .IP "$p\->handler( event );" 4
.el .IP "\f(CW$p\fR\->handler( event );" 4
.IX Item "$p->handler( event );"
.PD
This method assigns a subroutine, method, or array to handle an event.
.Sp
Event is one of \f(CW\*(C`text\*(C'\fR, \f(CW\*(C`start\*(C'\fR, \f(CW\*(C`end\*(C'\fR, \f(CW\*(C`declaration\*(C'\fR, \f(CW\*(C`comment\*(C'\fR,
\&\f(CW\*(C`process\*(C'\fR, \f(CW\*(C`start_document\*(C'\fR, \f(CW\*(C`end_document\*(C'\fR or \f(CW\*(C`default\*(C'\fR.
.Sp
The \f(CW\*(C`\e&subroutine\*(C'\fR is a reference to a subroutine which is called to handle
the event.
.Sp
The \f(CW$method_name\fR is the name of a method of \f(CW$p\fR which is called to handle
the event.
.Sp
The \f(CW@accum\fR is an array that will hold the event information as
sub-arrays.
.Sp
If the second argument is "", the event is ignored.
If it is undef, the default handler is invoked for the event.
.Sp
The \f(CW$argspec\fR is a string that describes the information to be reported
for the event.  Any requested information that does not apply to a
specific event is passed as \f(CW\*(C`undef\*(C'\fR.  If argspec is omitted, then it
is left unchanged.
.Sp
The return value from \f(CW$p\fR\->handler is the old callback routine or a
reference to the accumulator array.
.Sp
Any return values from handler callback routines/methods are always
ignored.  A handler callback can request parsing to be aborted by
invoking the \f(CW$p\fR\->eof method.  A handler callback is not allowed to
invoke the \f(CW$p\fR\->\fIparse()\fR or \f(CW$p\fR\->\fIparse_file()\fR method.  An exception will
be raised if it tries.
.Sp
Examples:
.Sp
.Vb 1
\&    $p\->handler(start =>  "start", \*(Aqself, attr, attrseq, text\*(Aq );
.Ve
.Sp
This causes the \*(L"start\*(R" method of object \f(CW$p\fR to be called for 'start' events.
The callback signature is \f(CW$p\fR\->start(\e%attr, \e@attr_seq, \f(CW$text\fR).
.Sp
.Vb 1
\&    $p\->handler(start =>  \e&start, \*(Aqattr, attrseq, text\*(Aq );
.Ve
.Sp
This causes subroutine \fIstart()\fR to be called for 'start' events.
The callback signature is start(\e%attr, \e@attr_seq, \f(CW$text\fR).
.Sp
.Vb 1
\&    $p\->handler(start =>  \e@accum, \*(Aq"S", attr, attrseq, text\*(Aq );
.Ve
.Sp
This causes 'start' event information to be saved in \f(CW@accum\fR.
The array elements will be ['S', \e%attr, \e@attr_seq, \f(CW$text\fR].
.Sp
.Vb 1
\&   $p\->handler(start => "");
.Ve
.Sp
This causes 'start' events to be ignored.  It also suppresses
invocations of any default handler for start events.  It is in most
cases equivalent to \f(CW$p\fR\->handler(start => sub {}), but is more
efficient.  It is different from the empty-sub-handler in that
\&\f(CW\*(C`skipped_text\*(C'\fR is not reset by it.
.Sp
.Vb 1
\&   $p\->handler(start => undef);
.Ve
.Sp
This causes no handler to be associated with start events.
If there is a default handler it will be invoked.
.PP
Filters based on tags can be set up to limit the number of events
reported.  The main bottleneck during parsing is often the huge number
of callbacks made from the parser.  Applying filters can improve
performance significantly.
.PP
The following methods control filters:
.ie n .IP "$p\fR\->ignore_elements( \f(CW@tags )" 4
.el .IP "\f(CW$p\fR\->ignore_elements( \f(CW@tags\fR )" 4
.IX Item "$p->ignore_elements( @tags )"
Both the \f(CW\*(C`start\*(C'\fR event and the \f(CW\*(C`end\*(C'\fR event as well as any events that