This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Regenerate the regnode table in perldebguts.pod automatically
authorFather Chrysostomos <sprout@cpan.org>
Sun, 23 Dec 2012 07:07:31 +0000 (23:07 -0800)
committerFather Chrysostomos <sprout@cpan.org>
Sun, 23 Dec 2012 07:23:44 +0000 (23:23 -0800)
pod/perldebguts.pod
regcomp.sym
regen/regcomp.pl
regnodes.h
t/porting/known_pod_issues.dat
t/porting/regen.t

index fdddf4a..715ef34 100644 (file)
@@ -535,236 +535,254 @@ C<   >I<id>: I<TYPE> I<OPTIONAL-INFO> (I<next-id>)
 
 Here are the possible types, with short descriptions:
 
+=for comment
+This table is generated by regen/regcomp.pl.  Any changes made here
+will be lost.
+
+=for regcomp.pl begin
+
  # TYPE arg-description [num-args] [longjump-len] DESCRIPTION
 
  # Exit points
- END   no        End of program.
- SUCCEED   no        Return from a subroutine, basically.
+
+ END                no         End of program.
+ SUCCEED            no         Return from a subroutine, basically.
 
  # Anchors:
 
- BOL        no      Match "" at beginning of line.
- MBOL       no      Same, assuming multiline.
- SBOL       no      Same, assuming singleline.
- EOS        no      Match "" at end of string.
- EOL        no      Match "" at end of line.
- MEOL       no      Same, assuming multiline.
- SEOL       no      Same, assuming singleline.
- BOUND      no      Match "" at any word boundary using native charset
-                    semantics for non-utf8
- BOUNDL     no      Match "" at any locale word boundary
- BOUNDU     no      Match "" at any word boundary using Unicode semantics
- BOUNDA     no      Match "" at any word boundary using ASCII semantics
- NBOUND     no      Match "" at any word non-boundary using native charset
-                    semantics for non-utf8
- NBOUNDL    no      Match "" at any locale word non-boundary
- NBOUNDU    no      Match "" at any word non-boundary using Unicode semantics
- NBOUNDA    no      Match "" at any word non-boundary using ASCII semantics
- GPOS       no      Matches where last m//g left off.
+ BOL                no         Match "" at beginning of line.
+ MBOL               no         Same, assuming multiline.
+ SBOL               no         Same, assuming singleline.
+ EOS                no         Match "" at end of string.
+ EOL                no         Match "" at end of line.
+ MEOL               no         Same, assuming multiline.
+ SEOL               no         Same, assuming singleline.
+ BOUND              no         Match "" at any word boundary using
+                               native charset semantics for non-utf8
+ BOUNDL             no         Match "" at any locale word boundary
+ BOUNDU             no         Match "" at any word boundary using
+                               Unicode semantics
+ BOUNDA             no         Match "" at any word boundary using ASCII
+                               semantics
+ NBOUND             no         Match "" at any word non-boundary using
+                               native charset semantics for non-utf8
+ NBOUNDL            no         Match "" at any locale word non-boundary
+ NBOUNDU            no         Match "" at any word non-boundary using
+                               Unicode semantics
+ NBOUNDA            no         Match "" at any word non-boundary using
+                               ASCII semantics
+ GPOS               no         Matches where last m//g left off.
 
  # [Special] alternatives:
 
- REG_ANY    no      Match any one character (except newline).
- SANY       no      Match any one character.
- CANY       no      Match any one byte.
- ANYOF      sv      Match character in (or not in) this class, single char
-                    match only
- ANYOFV     sv      Match character in (or not in) this class, can
-                    match-multiple chars
- ALNUM      no      Match any alphanumeric character using native charset
-                    semantics for non-utf8
- ALNUML     no      Match any alphanumeric char in locale
- ALNUMU     no      Match any alphanumeric char using Unicode semantics
- ALNUMA     no      Match [A-Za-z_0-9]
- NALNUM     no      Match any non-alphanumeric character using native charset
-                    semantics for non-utf8
- NALNUML    no      Match any non-alphanumeric char in locale
- NALNUMU    no      Match any non-alphanumeric char using Unicode semantics
- NALNUMA    no      Match [^A-Za-z_0-9]
- SPACE      no      Match any whitespace character using native charset
-                    semantics for non-utf8
- SPACEL     no      Match any whitespace char in locale
- SPACEU     no      Match any whitespace char using Unicode semantics
- SPACEA     no      Match [ \t\n\f\r]
- NSPACE     no      Match any non-whitespace character using native charset
-                    semantics for non-utf8
- NSPACEL    no      Match any non-whitespace char in locale
- NSPACEU    no      Match any non-whitespace char using Unicode semantics
- NSPACEA    no      Match [^ \t\n\f\r]
- DIGIT      no      Match any numeric character using native charset semantics
-                    for non-utf8
- DIGITL     no      Match any numeric character in locale
- DIGITA     no      Match [0-9]
- NDIGIT     no      Match any non-numeric character using native charset
- i                  semantics for non-utf8
- NDIGITL    no      Match any non-numeric character in locale
- NDIGITA    no      Match [^0-9]
- CLUMP      no      Match any extended grapheme cluster sequence
+ REG_ANY            no         Match any one character (except newline).
+ SANY               no         Match any one character.
+ CANY               no         Match any one byte.
+ ANYOF              sv         Match character in (or not in) this
+                               class, single char match only
+
+ POSIXD             none       Some [[:class:]] under /d; the FLAGS
+                               field gives which one
+ POSIXL             none       Some [[:class:]] under /l; the FLAGS
+                               field gives which one
+ POSIXU             none       Some [[:class:]] under /u; the FLAGS
+                               field gives which one
+ POSIXA             none       Some [[:class:]] under /a; the FLAGS
+                               field gives which one
+ NPOSIXD            none       complement of POSIXD, [[:^class:]]
+ NPOSIXL            none       complement of POSIXL, [[:^class:]]
+ NPOSIXU            none       complement of POSIXU, [[:^class:]]
+ NPOSIXA            none       complement of POSIXA, [[:^class:]]
+
+ CLUMP              no         Match any extended grapheme cluster
+                               sequence
 
  # Alternation
 
- # BRANCH        The set of branches constituting a single choice are hooked
- #               together with their "next" pointers, since precedence prevents
- #               anything being concatenated to any individual branch.  The
- #               "next" pointer of the last BRANCH in a choice points to the
- #               thing following the whole choice.  This is also where the
- #               final "next" pointer of each individual branch points; each
- #               branch starts with the operand node of a BRANCH node.
+ # BRANCH        The set of branches constituting a single choice are
+ #               hooked together with their "next" pointers, since
+ #               precedence prevents anything being concatenated to
+ #               any individual branch.  The "next" pointer of the last
+ #               BRANCH in a choice points to the thing following the
+ #               whole choice.  This is also where the final "next"
+ #               pointer of each individual branch points; each branch
+ #               starts with the operand node of a BRANCH node.
  #
- BRANCH        node        Match this alternative, or the next...
+ BRANCH             node       Match this alternative, or the next...
 
  # Back pointer
 
- # BACK          Normal "next" pointers all implicitly point forward; BACK
- #               exists to make loop structures possible.
+ # BACK          Normal "next" pointers all implicitly point forward;
+ #               BACK exists to make loop structures possible.
  # not used
- BACK       no      Match "", "next" ptr points backward.
+ BACK               no         Match "", "next" ptr points backward.
 
  # Literals
 
- EXACT      str     Match this string (preceded by length).
- EXACTF     str     Match this string, folded, native charset semantics for
-                    non-utf8 (prec. by length).
- EXACTFL    str     Match this string, folded in locale (w/len).
- EXACTFU    str     Match this string, folded, Unicode semantics for non-utf8
-                    (prec. by length).
- EXACTFA    str            Match this string, folded, Unicode semantics for non-utf8,
-                    but no ASCII-range character matches outside ASCII (prec.
-                    by length),.
+ EXACT              str        Match this string (preceded by length).
+ EXACTF             str        Match this non-UTF-8 string (not
+                               guaranteed to be folded) using /id rules
+                               (w/len).
+ EXACTFL            str        Match this string (not guaranteed to be
+                               folded) using /il rules (w/len).
+ EXACTFU            str        Match this string (folded iff in UTF-8,
+                               length in folding doesn't change if not
+                               in UTF-8) using /iu rules (w/len).
+ EXACTFA            str        Match this string (not guaranteed to be
+                               folded) using /iaa rules (w/len).
+ EXACTFU_SS         str        Match this string (folded iff in UTF-8,
+                               length in folding may change even if not
+                               in UTF-8) using /iu rules (w/len).
+ EXACTFU_TRICKYFOLD str        Match this folded UTF-8 string using /iu
+                               rules
 
  # Do nothing types
 
- NOTHING    no        Match empty string.
+ NOTHING            no         Match empty string.
  # A variant of above which delimits a group, thus stops optimizations
- TAIL       no        Match empty string. Can jump here from outside.
+ TAIL               no         Match empty string. Can jump here from
+                               outside.
 
  # Loops
 
- # STAR,PLUS    '?', and complex '*' and '+', are implemented as circular
- #               BRANCH structures using BACK.  Simple cases (one character
- #               per match) are implemented with STAR and PLUS for speed
- #               and to minimize recursive plunges.
+ # STAR,PLUS    '?', and complex '*' and '+', are implemented as
+ #               circular BRANCH structures using BACK.  Simple cases
+ #               (one character per match) are implemented with STAR
+ #               and PLUS for speed and to minimize recursive plunges.
  #
- STAR       node    Match this (simple) thing 0 or more times.
- PLUS       node    Match this (simple) thing 1 or more times.
+ STAR               node       Match this (simple) thing 0 or more
+                               times.
+ PLUS               node       Match this (simple) thing 1 or more
+                               times.
 
- CURLY      sv 2    Match this simple thing {n,m} times.
- CURLYN     no 2    Capture next-after-this simple thing
- CURLYM     no 2    Capture this medium-complex thing {n,m} times.
- CURLYX     sv 2    Match this complex thing {n,m} times.
+ CURLY              sv 2       Match this simple thing {n,m} times.
+ CURLYN             no 2       Capture next-after-this simple thing
+ CURLYM             no 2       Capture this medium-complex thing {n,m}
+                               times.
+ CURLYX             sv 2       Match this complex thing {n,m} times.
 
  # This terminator creates a loop structure for CURLYX
- WHILEM     no      Do curly processing and see if rest matches.
+ WHILEM             no         Do curly processing and see if rest
+                               matches.
 
  # Buffer related
 
  # OPEN,CLOSE,GROUPP     ...are numbered at compile time.
- OPEN       num 1   Mark this point in input as start of #n.
- CLOSE      num 1   Analogous to OPEN.
-
- REF        num 1   Match some already matched string
- REFF       num 1   Match already matched string, folded using native charset
-                    semantics for non-utf8
- REFFL      num 1   Match already matched string, folded in loc.
- REFFU      num 1   Match already matched string, folded using unicode
-                    semantics for non-utf8
- REFFA      num 1   Match already matched string, folded using unicode
-                    semantics for non-utf8, no mixing ASCII, non-ASCII
-
- # Named references.  Code in regcomp.c assumes that these all are after the
- # numbered references
- NREF       no-sv 1 Match some already matched string
- NREFF      no-sv 1 Match already matched string, folded using native charset
-                    semantics for non-utf8
- NREFFL     no-sv 1 Match already matched string, folded in loc.
- NREFFU     num   1 Match already matched string, folded using unicode
-                    semantics for non-utf8
- NREFFA     num   1 Match already matched string, folded using unicode
-                    semantics for non-utf8, no mixing ASCII, non-ASCII
-
- IFMATCH    off 1 2 Succeeds if the following matches.
- UNLESSM    off 1 2 Fails if the following matches.
- SUSPEND    off 1 1 "Independent" sub-RE.
- IFTHEN     off 1 1 Switch, should be preceded by switcher.
- GROUPP     num 1   Whether the group matched.
+ OPEN               num 1      Mark this point in input as start of #n.
+ CLOSE              num 1      Analogous to OPEN.
+
+ REF                num 1      Match some already matched string
+ REFF               num 1      Match already matched string, folded
+                               using native charset semantics for non-
+                               utf8
+ REFFL              num 1      Match already matched string, folded in
+                               loc.
+ REFFU              num 1      Match already matched string, folded
+                               using unicode semantics for non-utf8
+ REFFA              num 1      Match already matched string, folded
+                               using unicode semantics for non-utf8, no
+                               mixing ASCII, non-ASCII
+
+ # Named references.  Code in regcomp.c assumes that these all are after
+ # the numbered references
+ NREF               no-sv 1    Match some already matched string
+ NREFF              no-sv 1    Match already matched string, folded
+                               using native charset semantics for non-
+                               utf8
+ NREFFL             no-sv 1    Match already matched string, folded in
+                               loc.
+ NREFFU             num 1      Match already matched string, folded
+                               using unicode semantics for non-utf8
+ NREFFA             num 1      Match already matched string, folded
+                               using unicode semantics for non-utf8, no
+                               mixing ASCII, non-ASCII
+
+ IFMATCH            off 1 2    Succeeds if the following matches.
+ UNLESSM            off 1 2    Fails if the following matches.
+ SUSPEND            off 1 1    "Independent" sub-RE.
+ IFTHEN             off 1 1    Switch, should be preceded by switcher.
+ GROUPP             num 1      Whether the group matched.
 
  # Support for long RE
 
- LONGJMP    off 1 1 Jump far away.
- BRANCHJ    off 1 1 BRANCH with long offset.
+ LONGJMP            off 1 1    Jump far away.
+ BRANCHJ            off 1 1    BRANCH with long offset.
 
  # The heavy worker
 
- EVAL       evl 1   Execute some Perl code.
+ EVAL               evl 1      Execute some Perl code.
 
  # Modifiers
 
- MINMOD     no      Next operator is not greedy.
- LOGICAL    no      Next opcode should set the flag only.
+ MINMOD             no         Next operator is not greedy.
+ LOGICAL            no         Next opcode should set the flag only.
 
  # This is not used yet
- RENUM      off 1 1 Group with independently numbered parens.
+ RENUM              off 1 1    Group with independently numbered parens.
 
  # Trie Related
 
- # Behave the same as A|LIST|OF|WORDS would. The '..C' variants have
- # inline charclass data (ascii only), the 'C' store it in the structure.
- # NOTE: the relative order of the TRIE-like regops  is significant
+ # Behave the same as A|LIST|OF|WORDS would. The '..C' variants
+ # have inline charclass data (ascii only), the 'C' store it in the
+ # structure.
 
- TRIE       trie 1    Match many EXACT(F[ALU]?)? at once. flags==type
- TRIEC      charclass Same as TRIE, but with embedded charclass data
+ TRIE               trie 1     Match many EXACT(F[ALU]?)? at once.
+                               flags==type
+ TRIEC              trie       Same as TRIE, but with embedded charclass
+                    charclass  data
 
- # For start classes, contains an added fail table.
- AHOCORASICK trie 1   Aho Corasick stclass. flags==type
AHOCORASICKC charclass Same as AHOCORASICK, but with embedded charclass data
+ AHOCORASICK        trie 1     Aho Corasick stclass. flags==type
+ AHOCORASICKC       trie       Same as AHOCORASICK, but with embedded
                   charclass  charclass data
 
  # Regex Subroutines
- GOSUB      num/ofs 2L recurse to paren arg1 at (signed) ofs arg2
- GOSTART    no         recurse to start of pattern
+ GOSUB              num/ofs 2L recurse to paren arg1 at (signed) ofs
+                               arg2
+ GOSTART            no         recurse to start of pattern
 
  # Special conditionals
- NGROUPP    no-sv 1   Whether the group matched.
- INSUBP     num 1     Whether we are in a specific recurse.
- DEFINEP    none 1    Never execute directly.
+ NGROUPP            no-sv 1    Whether the group matched.
+ INSUBP             num 1      Whether we are in a specific recurse.
+ DEFINEP            none 1     Never execute directly.
 
  # Backtracking Verbs
- ENDLIKE    none      Used only for the type field of verbs
- OPFAIL     none      Same as (?!)
- ACCEPT     parno 1   Accepts the current matched string.
-
+ ENDLIKE            none       Used only for the type field of verbs
+ OPFAIL             none       Same as (?!)
+ ACCEPT             parno 1    Accepts the current matched string.
 
  # Verbs With Arguments
- VERB       no-sv 1   Used only for the type field of verbs
- PRUNE      no-sv 1   Pattern fails at this startpoint if no-backtracking through this
- MARKPOINT  no-sv 1   Push the current location for rollback by cut.
- SKIP       no-sv 1   On failure skip forward (to the mark) before retrying
- COMMIT     no-sv 1   Pattern fails outright if backtracking through this
- CUTGROUP   no-sv 1   On failure go to the next alternation in the group
+ VERB               no-sv 1    Used only for the type field of verbs
+ PRUNE              no-sv 1    Pattern fails at this startpoint if no-
+                               backtracking through this
+ MARKPOINT          no-sv 1    Push the current location for rollback by
+                               cut.
+ SKIP               no-sv 1    On failure skip forward (to the mark)
+                               before retrying
+ COMMIT             no-sv 1    Pattern fails outright if backtracking
+                               through this
+ CUTGROUP           no-sv 1    On failure go to the next alternation in
+                               the group
 
  # Control what to keep in $&.
- KEEPS      no        $& begins here.
+ KEEPS              no         $& begins here.
 
  # New charclass like patterns
- LNBREAK    none      generic newline pattern
- VERTWS     none      vertical whitespace         (Perl 6)
- NVERTWS    none      not vertical whitespace     (Perl 6)
- HORIZWS    none      horizontal whitespace       (Perl 6)
- NHORIZWS   none      not horizontal whitespace   (Perl 6)
-
- FOLDCHAR   codepoint 1 codepoint with tricky case folding properties.
+ LNBREAK            none       generic newline pattern
 
  # SPECIAL  REGOPS
 
- # This is not really a node, but an optimized away piece of a "long" node.
- # To simplify debugging output, we mark it as if it were a node
- OPTIMIZED  off       Placeholder for dump.
+ # This is not really a node, but an optimized away piece of a "long"
+ # node.  To simplify debugging output, we mark it as if it were a node
+ OPTIMIZED          off        Placeholder for dump.
 
  # Special opcode with the property that no opcode in a compiled program
  # will ever be of this type. Thus it can be used as a flag value that
  # no other opcode has been seen. END is used similarly, in that an END
- # node cant be optimized. So END implies "unoptimizable" and PSEUDO mean
- # "not seen anything to optimize yet".
- PSEUDO     off       Pseudo opcode for internal use.
+ # node cant be optimized. So END implies "unoptimizable" and PSEUDO
+ # mean "not seen anything to optimize yet".
+ PSEUDO             off        Pseudo opcode for internal use.
+
+=for regcomp.pl end
 
 =for unprinted-credits
 Next section M-J. Dominus (mjd-perl-patch+@plover.com) 20010421
index 2a49d20..e9fc84e 100644 (file)
@@ -2,7 +2,9 @@
 #
 # File has two sections, divided by a line of dashes '-'. 
 #
-# Empty rows after #-comment are removed from input are ignored
+# Lines beginning with # are ignored, except for those that start with #*
+# which are included in pod/perldebguts.pod.  # within a line may be part
+# of a description.
 #
 # First section is for regops, second section is for regmatch-states
 #
@@ -14,7 +16,6 @@
 #
 #
 # run perl regen.pl after editing this file
-# Also update perlredebguts.pod
 
 
 
@@ -70,24 +71,26 @@ CLUMP       CLUMP,      no 0 V    ; Match any extended grapheme cluster sequence
 
 #* Alternation
 
-# BRANCH        The set of branches constituting a single choice are hooked
-#               together with their "next" pointers, since precedence prevents
-#               anything being concatenated to any individual branch.  The
-#               "next" pointer of the last BRANCH in a choice points to the
-#               thing following the whole choice.  This is also where the
-#               final "next" pointer of each individual branch points; each
-#               branch starts with the operand node of a BRANCH node.
-#
+#* BRANCH        The set of branches constituting a single choice are
+#*               hooked together with their "next" pointers, since
+#*               precedence prevents anything being concatenated to
+#*               any individual branch.  The "next" pointer of the last
+#*               BRANCH in a choice points to the thing following the
+#*               whole choice.  This is also where the final "next"
+#*               pointer of each individual branch points; each branch
+#*               starts with the operand node of a BRANCH node.
+#*
 BRANCH      BRANCH,     node 0 V  ; Match this alternative, or the next...
 
 #*Back pointer
 
-# BACK          Normal "next" pointers all implicitly point forward; BACK
-#               exists to make loop structures possible.
-# not used
+#* BACK          Normal "next" pointers all implicitly point forward;
+#*               BACK exists to make loop structures possible.
+#* not used
 BACK        BACK,       no 0 V    ; Match "", "next" ptr points backward.
 
-#*Literals - NOTE the relative ordering of these types is important do not change it
+#*Literals
+# NOTE: the relative ordering of these types is important do not change it
 
 EXACT       EXACT,      str       ; Match this string (preceded by length).
 EXACTF      EXACT,      str       ; Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len).
@@ -100,16 +103,16 @@ EXACTFU_TRICKYFOLD EXACT,  str      ; Match this folded UTF-8 string using /iu rule
 #*Do nothing types
 
 NOTHING     NOTHING,    no        ; Match empty string.
-# A variant of above which delimits a group, thus stops optimizations
+#*A variant of above which delimits a group, thus stops optimizations
 TAIL        NOTHING,    no        ; Match empty string. Can jump here from outside.
 
 #*Loops
 
-# STAR,PLUS    '?', and complex '*' and '+', are implemented as circular
-#               BRANCH structures using BACK.  Simple cases (one character
-#               per match) are implemented with STAR and PLUS for speed
-#               and to minimize recursive plunges.
-#
+#* STAR,PLUS    '?', and complex '*' and '+', are implemented as
+#*               circular BRANCH structures using BACK.  Simple cases
+#*               (one character per match) are implemented with STAR
+#*               and PLUS for speed and to minimize recursive plunges.
+#*
 STAR        STAR,       node 0 V  ; Match this (simple) thing 0 or more times.
 PLUS        PLUS,       node 0 V  ; Match this (simple) thing 1 or more times.
 
@@ -118,12 +121,12 @@ CURLYN      CURLY,      no 2 V    ; Capture next-after-this simple thing
 CURLYM      CURLY,      no 2 V    ; Capture this medium-complex thing {n,m} times. 
 CURLYX      CURLY,      sv 2 V    ; Match this complex thing {n,m} times.
 
-# This terminator creates a loop structure for CURLYX
+#*This terminator creates a loop structure for CURLYX
 WHILEM      WHILEM,     no 0 V    ; Do curly processing and see if rest matches.
 
 #*Buffer related
 
-# OPEN,CLOSE,GROUPP     ...are numbered at compile time.
+#*OPEN,CLOSE,GROUPP     ...are numbered at compile time.
 OPEN        OPEN,       num 1     ; Mark this point in input as start of #n.
 CLOSE       CLOSE,      num 1     ; Analogous to OPEN.
 
@@ -136,7 +139,8 @@ REFFL       REF,        num 1 V   ; Match already matched string, folded in loc.
 REFFU       REF,        num 1 V   ; Match already matched string, folded using unicode semantics for non-utf8
 REFFA       REF,        num 1 V   ; Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII
 
-#*Named references.  Code in regcomp.c assumes that these all are after the numbered references
+#*Named references.  Code in regcomp.c assumes that these all are after
+#*the numbered references
 NREF        REF,        no-sv 1 V ; Match some already matched string
 NREFF       REF,        no-sv 1 V ; Match already matched string, folded using native charset semantics for non-utf8
 NREFFL      REF,        no-sv 1 V ; Match already matched string, folded in loc.
@@ -146,7 +150,7 @@ NREFFA      REF,        num   1 V ; Match already matched string, folded using u
 IFMATCH     BRANCHJ,    off 1 . 2 ; Succeeds if the following matches.
 UNLESSM     BRANCHJ,    off 1 . 2 ; Fails if the following matches.
 SUSPEND     BRANCHJ,    off 1 V 1 ; "Independent" sub-RE.
-IFTHEN      BRANCHJ,    off 1 V 1 ; Switch, should be preceded by switcher .
+IFTHEN      BRANCHJ,    off 1 V 1 ; Switch, should be preceded by switcher.
 GROUPP      GROUPP,     num 1     ; Whether the group matched.
 
 #*Support for long RE
@@ -163,13 +167,14 @@ EVAL        EVAL,       evl 1     ; Execute some Perl code.
 MINMOD      MINMOD,     no        ; Next operator is not greedy.
 LOGICAL     LOGICAL,    no        ; Next opcode should set the flag only.
 
-# This is not used yet
+#*This is not used yet
 RENUM       BRANCHJ,    off 1 . 1 ; Group with independently numbered parens.
 
 #*Trie Related
 
-# Behave the same as A|LIST|OF|WORDS would. The '..C' variants have  
-# inline charclass data (ascii only), the 'C' store it in the structure.
+#* Behave the same as A|LIST|OF|WORDS would. The '..C' variants
+#* have inline charclass data (ascii only), the 'C' store it in the
+#* structure.
 # NOTE: the relative order of the TRIE-like regops  is significant
 
 TRIE        TRIE,       trie 1    ; Match many EXACT(F[ALU]?)? at once. flags==type
@@ -214,20 +219,20 @@ LNBREAK     LNBREAK,    none      ; generic newline pattern
 
 #*SPECIAL  REGOPS
 
-# This is not really a node, but an optimized away piece of a "long" node.
-# To simplify debugging output, we mark it as if it were a node
+#* This is not really a node, but an optimized away piece of a "long"
+#* node.  To simplify debugging output, we mark it as if it were a node
 OPTIMIZED   NOTHING,    off       ; Placeholder for dump.
 
-# Special opcode with the property that no opcode in a compiled program
-# will ever be of this type. Thus it can be used as a flag value that
-# no other opcode has been seen. END is used similarly, in that an END
-# node cant be optimized. So END implies "unoptimizable" and PSEUDO mean
-# "not seen anything to optimize yet".
+#* Special opcode with the property that no opcode in a compiled program
+#* will ever be of this type. Thus it can be used as a flag value that
+#* no other opcode has been seen. END is used similarly, in that an END
+#* node cant be optimized. So END implies "unoptimizable" and PSEUDO
+#* mean "not seen anything to optimize yet".
 PSEUDO      PSEUDO,     off       ; Pseudo opcode for internal use.
 
 -------------------------------------------------------------------------------
 # Format for second section:
-# REGOP \t typelist [ \t typelist] [# Comment]
+# REGOP \t typelist [ \t typelist]
 # typelist= namelist
 #         = namelist:FAIL
 #         = name:count
index 16091ca..843ef1b 100644 (file)
@@ -2,6 +2,7 @@
 # 
 # Regenerate (overwriting only if changed):
 #
+#    pod/perldebguts.pod
 #    regnodes.h
 #
 # from information stored in
@@ -9,6 +10,9 @@
 #    regcomp.sym
 #    regexp.h
 #
+# pod/perldebguts.pod is not completely regenerated.  Only the table of
+# regexp nodes is replaced; other parts remain unchanged.
+#
 # Accepts the standard regen_lib -q and -v args.
 #
 # This script is normally invoked from regen.pl.
@@ -22,11 +26,15 @@ use strict;
 open DESC, 'regcomp.sym';
 
 my $ind = 0;
-my (@name,@rest,@type,@code,@args,@flags,@longj);
-my ($desc,$lastregop);
+my (@name,@rest,@type,@code,@args,@flags,@longj,@cmnt);
+my ($longest_name_length,$desc,$lastregop) = 0;
 while (<DESC>) {
-    s/#.*$//;
-    next if /^\s*$/;
+    # Special pod comments
+    if (/^#\* ?/) { $cmnt[$ind] .= "# $'"; }
+    # Truly blank lines possibly surrounding pod comments
+    elsif (/^\s*$/) { $cmnt[$ind] .= "\n" }
+
+    next if /^(?:#|\s*$)/;
     chomp; # No \z in 5.004
     s/\s*$//;
     if (/^-+\s*$/) {
@@ -37,6 +45,8 @@ while (<DESC>) {
         ($name[$ind], $desc, $rest[$ind]) = /^(\S+)\s+([^\t]+?)\s*;\s*(.*)/;
         ($type[$ind], $code[$ind], $args[$ind], $flags[$ind], $longj[$ind])
           = split /[,\s]\s*/, $desc;
+        $longest_name_length = length $name[$ind]
+          if length $name[$ind] > $longest_name_length;
         ++$ind;
     } else {
         my ($type,@lists)=split /\s+/, $_;
@@ -328,3 +338,51 @@ print $out process_flags('S', 'simple', <<'EOC');
 EOC
 
 read_only_bottom_close_and_rename($out);
+
+my $guts = open_new('pod/perldebguts.pod', '>');
+
+my $code;
+my $name_fmt = '<' x ($longest_name_length-1);
+my $descr_fmt = '<' x (58-$longest_name_length);
+eval <<EOD;
+format GuTS =
+ ^*~~
+ \$cmnt[\$_]
+ ^<<<<<<<<<<<<<<<<< ^<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<~~
+ \$name[\$_], \$code,  \$rest[\$_]
+.
+EOD
+
+select +(select($guts), do {
+    $~ = "GuTS";
+
+    open my $oldguts, "pod/perldebguts.pod"
+        or die "$0 cannot open pod/perldebguts.pod for reading: $!";
+    while(<$oldguts>) {
+        print;
+        last if /=for regcomp.pl begin/;
+    }
+
+    print <<'end';
+
+ # TYPE arg-description [num-args] [longjump-len] DESCRIPTION
+end
+    for (0..$lastregop-1) {
+        $code = "$code[$_] ".($args[$_]||"");
+        $code .= " $longj[$_]" if $longj[$_];
+        if ($cmnt[$_] ||= "") {
+            # Trim multiple blanks
+            $cmnt[$_] =~ s/^\n\n+/\n/; $cmnt[$_] =~ s/\n\n+$/\n\n/
+        }
+        write;
+    }
+    print "\n";
+
+    while(<$oldguts>) {
+        last if /=for regcomp.pl end/;
+    }
+    do { print } while <$oldguts>;
+
+})[0];
+
+close_and_rename($guts);
index e1fdad1..4754921 100644 (file)
@@ -58,7 +58,7 @@
 #define        CURLYM                  46      /* 0x2e Capture this medium-complex thing {n,m} times. */
 #define        CURLYX                  47      /* 0x2f Match this complex thing {n,m} times. */
 #define        WHILEM                  48      /* 0x30 Do curly processing and see if rest matches. */
-#define        OPEN                    49      /* 0x31 Mark this point in input as start of */
+#define        OPEN                    49      /* 0x31 Mark this point in input as start of #n. */
 #define        CLOSE                   50      /* 0x32 Analogous to OPEN. */
 #define        REF                     51      /* 0x33 Match some already matched string */
 #define        REFF                    52      /* 0x34 Match already matched string, folded using native charset semantics for non-utf8 */
@@ -73,7 +73,7 @@
 #define        IFMATCH                 61      /* 0x3d Succeeds if the following matches. */
 #define        UNLESSM                 62      /* 0x3e Fails if the following matches. */
 #define        SUSPEND                 63      /* 0x3f "Independent" sub-RE. */
-#define        IFTHEN                  64      /* 0x40 Switch, should be preceded by switcher . */
+#define        IFTHEN                  64      /* 0x40 Switch, should be preceded by switcher. */
 #define        GROUPP                  65      /* 0x41 Whether the group matched. */
 #define        LONGJMP                 66      /* 0x42 Jump far away. */
 #define        BRANCHJ                 67      /* 0x43 BRANCH with long offset. */
index 0947d15..df07c14 100644 (file)
@@ -221,7 +221,7 @@ pod/perlce.pod      Verbatim line length including indents exceeds 79 by    2
 pod/perlclib.pod       Verbatim line length including indents exceeds 79 by    3
 pod/perlcygwin.pod     Verbatim line length including indents exceeds 79 by    25
 pod/perldbmfilter.pod  Verbatim line length including indents exceeds 79 by    1
-pod/perldebguts.pod    Verbatim line length including indents exceeds 79 by    68
+pod/perldebguts.pod    Verbatim line length including indents exceeds 79 by    34
 pod/perldebtut.pod     Verbatim line length including indents exceeds 79 by    22
 pod/perldebug.pod      Verbatim line length including indents exceeds 79 by    3
 pod/perldiag.pod       =item type mismatch     1
index 8595fb0..221ff17 100644 (file)
@@ -16,7 +16,7 @@ if ( $^O eq "VMS" ) {
   skip_all( "- regen.pl needs porting." );
 }
 
-my $in_regen_pl = 22; # I can't see a clean way to calculate this automatically.
+my $in_regen_pl = 23; # I can't see a clean way to calculate this automatically.
 my @files = qw(perly.act perly.h perly.tab keywords.c keywords.h uconfig.h);
 my @progs = qw(Porting/makemeta regen/regcharclass.pl regen/mk_PL_charclass.pl);