perlre.1

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

By default, when a quantified subpattern does not allow the rest of the
overall pattern to match, Perl will backtrack. However, this behaviour is
sometimes undesirable. Thus Perl provides the \*(L"possessive\*(R" quantifier form
as well.
.PP
.Vb 6
\&    *+     Match 0 or more times and give nothing back
\&    ++     Match 1 or more times and give nothing back
\&    ?+     Match 0 or 1 time and give nothing back
\&    {n}+   Match exactly n times and give nothing back (redundant)
\&    {n,}+  Match at least n times and give nothing back
\&    {n,m}+ Match at least n but not more than m times and give nothing back
.Ve
.PP
For instance,
.PP
.Vb 1
\&   \*(Aqaaaa\*(Aq =~ /a++a/
.Ve
.PP
will never match, as the \f(CW\*(C`a++\*(C'\fR will gobble up all the \f(CW\*(C`a\*(C'\fR's in the
string and won't leave any for the remaining part of the pattern. This
feature can be extremely useful to give perl hints about where it
shouldn't backtrack. For instance, the typical \*(L"match a double-quoted
string\*(R" problem can be most efficiently performed when written as:
.PP
.Vb 1
\&   /"(?:[^"\e\e]++|\e\e.)*+"/
.Ve
.PP
as we know that if the final quote does not match, backtracking will not
help. See the independent subexpression \f(CW\*(C`(?>...)\*(C'\fR for more details;
possessive quantifiers are just syntactic sugar for that construct. For
instance the above example could also be written as follows:
.PP
.Vb 1
\&   /"(?>(?:(?>[^"\e\e]+)|\e\e.)*)"/
.Ve
.PP
\fIEscape sequences\fR
.IX Subsection "Escape sequences"
.PP
Because patterns are processed as double quoted strings, the following
also work:
.IX Xref "\et \en \er \ef \ee \ea \el \eu \eL \eU \eE \eQ \e0 \ec \eN \ex"
.PP
.Vb 10
\&    \et          tab                   (HT, TAB)
\&    \en          newline               (LF, NL)
\&    \er          return                (CR)
\&    \ef          form feed             (FF)
\&    \ea          alarm (bell)          (BEL)
\&    \ee          escape (think troff)  (ESC)
\&    \e033        octal char            (example: ESC)
\&    \ex1B        hex char              (example: ESC)
\&    \ex{263a}    long hex char         (example: Unicode SMILEY)
\&    \ecK         control char          (example: VT)
\&    \eN{name}    named Unicode character
\&    \el          lowercase next char (think vi)
\&    \eu          uppercase next char (think vi)
\&    \eL          lowercase till \eE (think vi)
\&    \eU          uppercase till \eE (think vi)
\&    \eE          end case modification (think vi)
\&    \eQ          quote (disable) pattern metacharacters till \eE
.Ve
.PP
If \f(CW\*(C`use locale\*(C'\fR is in effect, the case map used by \f(CW\*(C`\el\*(C'\fR, \f(CW\*(C`\eL\*(C'\fR, \f(CW\*(C`\eu\*(C'\fR
and \f(CW\*(C`\eU\*(C'\fR is taken from the current locale.  See perllocale.  For
documentation of \f(CW\*(C`\eN{name}\*(C'\fR, see charnames.
.PP
You cannot include a literal \f(CW\*(C`$\*(C'\fR or \f(CW\*(C`@\*(C'\fR within a \f(CW\*(C`\eQ\*(C'\fR sequence.
An unescaped \f(CW\*(C`$\*(C'\fR or \f(CW\*(C`@\*(C'\fR interpolates the corresponding variable,
while escaping will cause the literal string \f(CW\*(C`\e$\*(C'\fR to be matched.
You'll need to write something like \f(CW\*(C`m/\eQuser\eE\e@\eQhost/\*(C'\fR.
.PP
\fICharacter Classes and other Special Escapes\fR
.IX Subsection "Character Classes and other Special Escapes"
.PP
In addition, Perl defines the following:
.IX Xref "\ew \eW \es \eS \ed \eD \eX \ep \eP \eC \eg \ek \eN \eK \ev \eV \eh \eH word whitespace character class backreference"
.PP
.Vb 10
\&    \ew       Match a "word" character (alphanumeric plus "_")
\&    \eW       Match a non\-"word" character
\&    \es       Match a whitespace character
\&    \eS       Match a non\-whitespace character
\&    \ed       Match a digit character
\&    \eD       Match a non\-digit character
\&    \epP      Match P, named property.  Use \ep{Prop} for longer names.
\&    \ePP      Match non\-P
\&    \eX       Match eXtended Unicode "combining character sequence",
\&             equivalent to (?:\ePM\epM*)
\&    \eC       Match a single C char (octet) even under Unicode.
\&             NOTE: breaks up characters into their UTF\-8 bytes,
\&             so you may end up with malformed pieces of UTF\-8.
\&             Unsupported in lookbehind.
\&    \e1       Backreference to a specific group.
\&             \*(Aq1\*(Aq may actually be any positive integer.
\&    \eg1      Backreference to a specific or previous group,
\&    \eg{\-1}   number may be negative indicating a previous buffer and may
\&             optionally be wrapped in curly brackets for safer parsing.
\&    \eg{name} Named backreference
\&    \ek<name> Named backreference
\&    \eK       Keep the stuff left of the \eK, don\*(Aqt include it in $&
\&    \ev       Vertical whitespace
\&    \eV       Not vertical whitespace
\&    \eh       Horizontal whitespace
\&    \eH       Not horizontal whitespace
\&    \eR       Linebreak
.Ve
.PP
A \f(CW\*(C`\ew\*(C'\fR matches a single alphanumeric character (an alphabetic
character, or a decimal digit) or \f(CW\*(C`_\*(C'\fR, not a whole word.  Use \f(CW\*(C`\ew+\*(C'\fR
to match a string of Perl-identifier characters (which isn't the same
as matching an English word).  If \f(CW\*(C`use locale\*(C'\fR is in effect, the list
of alphabetic characters generated by \f(CW\*(C`\ew\*(C'\fR is taken from the current
locale.  See perllocale.  You may use \f(CW\*(C`\ew\*(C'\fR, \f(CW\*(C`\eW\*(C'\fR, \f(CW\*(C`\es\*(C'\fR, \f(CW\*(C`\eS\*(C'\fR,
\&\f(CW\*(C`\ed\*(C'\fR, and \f(CW\*(C`\eD\*(C'\fR within character classes, but they aren't usable
as either end of a range. If any of them precedes or follows a \*(L"\-\*(R",
the \*(L"\-\*(R" is understood literally. If Unicode is in effect, \f(CW\*(C`\es\*(C'\fR matches
also \*(L"\ex{85}\*(R", \*(L"\ex{2028}\*(R", and \*(L"\ex{2029}\*(R". See perlunicode for more
details about \f(CW\*(C`\epP\*(C'\fR, \f(CW\*(C`\ePP\*(C'\fR, \f(CW\*(C`\eX\*(C'\fR and the possibility of defining
your own \f(CW\*(C`\ep\*(C'\fR and \f(CW\*(C`\eP\*(C'\fR properties, and perluniintro about Unicode
in general.
.IX Xref "\ew \eW word"
.PP
\&\f(CW\*(C`\eR\*(C'\fR will atomically match a linebreak, including the network line-ending
\&\*(L"\ex0D\ex0A\*(R".  Specifically,  is exactly equivalent to
.IX Xref "\eR"
.PP
.Vb 1
\&  (?>\ex0D\ex0A?|[\ex0A\-\ex0C\ex85\ex{2028}\ex{2029}])
.Ve
.PP
\&\fBNote:\fR \f(CW\*(C`\eR\*(C'\fR has no special meaning inside of a character class;
use \f(CW\*(C`\ev\*(C'\fR instead (vertical whitespace).
.IX Xref "\eR"
.PP
The \s-1POSIX\s0 character class syntax
.IX Xref "character class"
.PP
.Vb 1
\&    [:class:]
.Ve
.PP
is also available.  Note that the \f(CW\*(C`[\*(C'\fR and \f(CW\*(C`]\*(C'\fR brackets are \fIliteral\fR;
they must always be used within a character class expression.
.PP
.Vb 2
\&    # this is correct:
\&    $string =~ /[[:alpha:]]/;
\&
\&    # this is not, and will generate a warning:
\&    $string =~ /[:alpha:]/;
.Ve
.PP
The available classes and their backslash equivalents (if available) are
as follows:
.IX Xref "character class alpha alnum ascii blank cntrl digit graph lower print punct space upper word xdigit"
.PP
.Vb 10
\&    alpha
\&    alnum
\&    ascii
\&    blank               [1]
\&    cntrl
\&    digit       \ed
\&    graph
\&    lower
\&    print
\&    punct
\&    space       \es      [2]
\&    upper
\&    word        \ew      [3]
\&    xdigit
.Ve
.IP "[1]" 4
.IX Item "[1]"
A \s-1GNU\s0 extension equivalent to \f(CW\*(C`[ \et]\*(C'\fR, \*(L"all horizontal whitespace\*(R".
.IP "[2]" 4
.IX Item "[2]"
Not exactly equivalent to \f(CW\*(C`\es\*(C'\fR since the \f(CW\*(C`[[:space:]]\*(C'\fR includes
also the (very rare) \*(L"vertical tabulator\*(R", \*(L"\ecK\*(R" or chr(11) in \s-1ASCII\s0.
.IP "[3]" 4
.IX Item "[3]"
A Perl extension, see above.
.PP
For example use \f(CW\*(C`[:upper:]\*(C'\fR to match all the uppercase characters.
Note that the \f(CW\*(C`[]\*(C'\fR are part of the \f(CW\*(C`[::]\*(C'\fR construct, not part of the
whole character class.  For example:
.PP
.Vb 1
\&    [01[:alpha:]%]
.Ve
.PP
matches zero, one, any alphabetic character, and the percent sign.
.PP
The following equivalences to Unicode \ep{} constructs and equivalent
backslash character classes (if available), will hold:
.IX Xref "character class \ep \ep{}"
.PP
.Vb 1
\&    [[:...:]]   \ep{...}         backslash
\&
\&    alpha       IsAlpha
\&    alnum       IsAlnum
\&    ascii       IsASCII
\&    blank
\&    cntrl       IsCntrl
\&    digit       IsDigit        \ed
\&    graph       IsGraph
\&    lower       IsLower
\&    print       IsPrint
\&    punct       IsPunct
\&    space       IsSpace
\&                IsSpacePerl    \es
\&    upper       IsUpper
\&    word        IsWord
\&    xdigit      IsXDigit
.Ve
.PP
For example \f(CW\*(C`[[:lower:]]\*(C'\fR and \f(CW\*(C`\ep{IsLower}\*(C'\fR are equivalent.
.PP
If the \f(CW\*(C`utf8\*(C'\fR pragma is not used but the \f(CW\*(C`locale\*(C'\fR pragma is, the
classes correlate with the usual \fIisalpha\fR\|(3) interface (except for
\&\*(L"word\*(R" and \*(L"blank\*(R").
.PP
The other named classes are:
.IP "cntrl" 4
.IX Xref "cntrl"
.IX Item "cntrl"
Any control character.  Usually characters that don't produce output as
such but instead control the terminal somehow: for example newline and
backspace are control characters.  All characters with \fIord()\fR less than
32 are usually classified as control characters (assuming \s-1ASCII\s0,
the \s-1ISO\s0 Latin character sets, and Unicode), as is the character with
the \fIord()\fR value of 127 (\f(CW\*(C`DEL\*(C'\fR).
.IP "graph" 4
.IX Xref "graph"
.IX Item "graph"
Any alphanumeric or punctuation (special) character.
.IP "print" 4
.IX Xref "print"
.IX Item "print"
Any alphanumeric or punctuation (special) character or the space character.
.IP "punct" 4
.IX Xref "punct"
.IX Item "punct"
Any punctuation (special) character.
.IP "xdigit" 4
.IX Xref "xdigit"
.IX Item "xdigit"
Any hexadecimal digit.  Though this may feel silly ([0\-9A\-Fa\-f] would
work just fine) it is included for completeness.
.PP
You can negate the [::] character classes by prefixing the class name
with a '^'. This is a Perl extension.  For example:
.IX Xref "character class, negation"
.PP
.Vb 1
\&    POSIX         traditional  Unicode
\&
\&    [[:^digit:]]    \eD         \eP{IsDigit}
\&    [[:^space:]]    \eS         \eP{IsSpace}
\&    [[:^word:]]     \eW         \eP{IsWord}
.Ve
.PP
Perl respects the \s-1POSIX\s0 standard in that \s-1POSIX\s0 character classes are
only supported within a character class.  The \s-1POSIX\s0 character classes
[.cc.] and [=cc=] are recognized but \fBnot\fR supported and trying to
use them will cause an error.
.PP
\fIAssertions\fR
.IX Subsection "Assertions"
.PP
Perl defines the following zero-width assertions:
.IX Xref "zero-width assertion assertion regex, zero-width assertion regexp, zero-width assertion regular expression, zero-width assertion \eb \eB \eA \eZ \ez \eG"
.PP
.Vb 7
\&    \eb  Match a word boundary
\&    \eB  Match except at a word boundary
\&    \eA  Match only at beginning of string
\&    \eZ  Match only at end of string, or before newline at the end
\&    \ez  Match only at end of string
\&    \eG  Match only at pos() (e.g. at the end\-of\-match position
\&        of prior m//g)
.Ve
.PP
A word boundary (\f(CW\*(C`\eb\*(C'\fR) is a spot between two characters
that has a \f(CW\*(C`\ew\*(C'\fR on one side of it and a \f(CW\*(C`\eW\*(C'\fR on the other side
of it (in either order), counting the imaginary characters off the
beginning and end of the string as matching a \f(CW\*(C`\eW\*(C'\fR.  (Within
character classes \f(CW\*(C`\eb\*(C'\fR represents backspace rather than a word
boundary, just as it normally does in any double-quoted string.)
The \f(CW\*(C`\eA\*(C'\fR and \f(CW\*(C`\eZ\*(C'\fR are just like \*(L"^\*(R" and \*(L"$\*(R", except that they
won't match multiple times when the \f(CW\*(C`/m\*(C'\fR modifier is used, while
\&\*(L"^\*(R" and \*(L"$\*(R" will match at every internal line boundary.  To match
the actual end of the string and not ignore an optional trailing
newline, use \f(CW\*(C`\ez\*(C'\fR.
.IX Xref "\eb \eA \eZ \ez  m"
.PP
The \f(CW\*(C`\eG\*(C'\fR assertion can be used to chain global matches (using
\&\f(CW\*(C`m//g\*(C'\fR), as described in \*(L"Regexp Quote-Like Operators\*(R" in perlop.
It is also useful when writing \f(CW\*(C`lex\*(C'\fR\-like scanners, when you have
several patterns that you want to match against consequent substrings
of your string, see the previous reference.  The actual location
where \f(CW\*(C`\eG\*(C'\fR will match can also be influenced by using \f(CW\*(C`pos()\*(C'\fR as
an lvalue: see \*(L"pos\*(R" in perlfunc. Note that the rule for zero-length