This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
fixup Perl_magic_freemglob()
[perl5.git] / op.h
diff --git a/op.h b/op.h
index c660b31..cd3926d 100644 (file)
--- a/op.h
+++ b/op.h
@@ -24,7 +24,7 @@
  *                      !op_slabbed.
  *     op_savefree     on savestack via SAVEFREEOP
  *     op_folded       Result/remainder of a constant fold operation.
- *     op_lastsib      this op is is the last sibling
+ *     op_moresib      this op is not the last sibling
  *     op_spare        One spare bit
  *     op_flags        Flags common to all operations.  See OPf_* below.
  *     op_private      Flags peculiar to a particular operation (BUT,
@@ -43,7 +43,7 @@ typedef PERL_BITFIELD16 Optype;
 #else
 #define BASEOP                         \
     OP*                op_next;                \
-    OP*                op_sibling;             \
+    OP*                op_sibparent;           \
     OP*                (*op_ppaddr)(pTHX);     \
     PADOFFSET  op_targ;                \
     PERL_BITFIELD16 op_type:9;         \
@@ -52,32 +52,32 @@ typedef PERL_BITFIELD16 Optype;
     PERL_BITFIELD16 op_savefree:1;     \
     PERL_BITFIELD16 op_static:1;       \
     PERL_BITFIELD16 op_folded:1;       \
-    PERL_BITFIELD16 op_lastsib:1;       \
+    PERL_BITFIELD16 op_moresib:1;       \
     PERL_BITFIELD16 op_spare:1;                \
     U8         op_flags;               \
     U8         op_private;
 #endif
 
-/* If op_type:9 is changed to :10, also change PUSHEVAL in cop.h.
+/* If op_type:9 is changed to :10, also change cx_pusheval()
    Also, if the type of op_type is ever changed (e.g. to PERL_BITFIELD32)
    then all the other bit-fields before/after it should change their
    types too to let VC pack them into the same 4 byte integer.*/
 
 /* for efficiency, requires OPf_WANT_VOID == G_VOID etc */
 #define OP_GIMME(op,dfl) \
-       (((op)->op_flags & OPf_WANT) ? ((op)->op_flags & OPf_WANT) : dfl)
+        (((op)->op_flags & OPf_WANT) ? ((op)->op_flags & OPf_WANT) : dfl)
 
 #define OP_GIMME_REVERSE(flags)        ((flags) & G_WANT)
 
 /*
-=head1 "Gimme" Values
+=for apidoc_section $callback
 
 =for apidoc Amn|U32|GIMME_V
 The XSUB-writer's equivalent to Perl's C<wantarray>.  Returns C<G_VOID>,
 C<G_SCALAR> or C<G_ARRAY> for void, scalar or list context,
 respectively.  See L<perlcall> for a usage example.
 
-=for apidoc Amn|U32|GIMME
+=for apidoc AmnD|U32|GIMME
 A backward-compatible version of C<GIMME_V> which can only return
 C<G_SCALAR> or C<G_ARRAY>; in a void context, it returns C<G_SCALAR>.
 Deprecated.  Use C<GIMME_V> instead.
@@ -85,7 +85,7 @@ Deprecated.  Use C<GIMME_V> instead.
 =cut
 */
 
-#define GIMME_V                OP_GIMME(PL_op, block_gimme())
+#define GIMME_V                Perl_gimme_V(aTHX)
 
 /* Public flags */
 
@@ -95,68 +95,84 @@ Deprecated.  Use C<GIMME_V> instead.
 #define  OPf_WANT_LIST  3      /*   Want list of any length */
 #define OPf_KIDS       4       /* There is a firstborn child. */
 #define OPf_PARENS     8       /* This operator was parenthesized. */
-                               /*  (Or block needs explicit scope entry.) */
+                                /*  (Or block needs explicit scope entry.) */
 #define OPf_REF                16      /* Certified reference. */
-                               /*  (Return container, not containee). */
+                                /*  (Return container, not containee). */
 #define OPf_MOD                32      /* Will modify (lvalue). */
+
 #define OPf_STACKED    64      /* Some arg is arriving on the stack. */
+                                /*   Indicates mutator-variant of op for those
+                                 *     ops which support them, e.g. $x += 1
+                                 */
+
 #define OPf_SPECIAL    128     /* Do something weird for this op: */
-                               /*  On local LVAL, don't init local value. */
-                               /*  On OP_SORT, subroutine is inlined. */
-                               /*  On OP_NOT, inversion was implicit. */
-                               /*  On OP_LEAVE, don't restore curpm. */
-                               /*  On truncate, we truncate filehandle */
-                               /*  On control verbs, we saw no label */
-                               /*  On flipflop, we saw ... instead of .. */
-                               /*  On UNOPs, saw bare parens, e.g. eof(). */
-                               /*  On OP_NULL, saw a "do". */
-                               /*  On OP_EXISTS, treat av as av, not avhv.  */
-                               /*  On OP_(ENTER|LEAVE)EVAL, don't clear $@ */
-                                /*  On pushre, rx is used as part of split, e.g. split " " */
-                               /*  On regcomp, "use re 'eval'" was in scope */
-                               /*  On RV2[ACGHS]V, don't create GV--in
-                                   defined()*/
-                               /*  On OP_DBSTATE, indicates breakpoint
-                                *    (runtime property) */
-                               /*  On OP_REQUIRE, was seen as CORE::require */
-                               /*  On OP_(ENTER|LEAVE)WHEN, there's
-                                   no condition */
-                               /*  On OP_SMARTMATCH, an implicit smartmatch */
-                               /*  On OP_ANONHASH and OP_ANONLIST, create a
-                                   reference to the new anon hash or array */
-                               /*  On OP_HELEM and OP_HSLICE, localization will be followed
-                                   by assignment, so do not wipe the target if it is special
-                                   (e.g. a glob or a magic SV) */
-                               /*  On OP_MATCH, OP_SUBST & OP_TRANS, the
-                                   operand of a logical or conditional
-                                   that was optimised away, so it should
-                                   not be bound via =~ */
-                               /*  On OP_CONST, from a constant CV */
-                               /*  On OP_GLOB, two meanings:
-                                   - Before ck_glob, called as CORE::glob
-                                   - After ck_glob, use Perl glob function
-                                */
+                                /*  On local LVAL, don't init local value. */
+                                /*  On OP_SORT, subroutine is inlined. */
+                                /*  On OP_NOT, inversion was implicit. */
+                                /*  On OP_LEAVE, don't restore curpm, e.g.
+                                 *      /(...)/ while ...>;  */
+                                /*  On truncate, we truncate filehandle */
+                                /*  On control verbs, we saw no label */
+                                /*  On flipflop, we saw ... instead of .. */
+                                /*  On UNOPs, saw bare parens, e.g. eof(). */
+                                /*  On OP_CHDIR, handle (or bare parens) */
+                                /*  On OP_NULL, saw a "do". */
+                                /*  On OP_EXISTS, treat av as av, not avhv.  */
+                                /*  On OP_(ENTER|LEAVE)EVAL, don't clear $@ */
+                                /*  On regcomp, "use re 'eval'" was in scope */
+                                /*  On RV2[ACGHS]V, don't create GV--in
+                                    defined()*/
+                                /*  On OP_DBSTATE, indicates breakpoint
+                                 *    (runtime property) */
+                                /*  On OP_REQUIRE, was seen as CORE::require */
+                                /*  On OP_(ENTER|LEAVE)WHEN, there's
+                                    no condition */
+                                /*  On OP_SMARTMATCH, an implicit smartmatch */
+                                /*  On OP_ANONHASH and OP_ANONLIST, create a
+                                    reference to the new anon hash or array */
+                                /*  On OP_HELEM, OP_MULTIDEREF and OP_HSLICE,
+                                    localization will be followed by assignment,
+                                    so do not wipe the target if it is special
+                                    (e.g. a glob or a magic SV) */
+                                /*  On OP_MATCH, OP_SUBST & OP_TRANS, the
+                                    operand of a logical or conditional
+                                    that was optimised away, so it should
+                                    not be bound via =~ */
+                                /*  On OP_CONST, from a constant CV */
+                                /*  On OP_GLOB, two meanings:
+                                    - Before ck_glob, called as CORE::glob
+                                    - After ck_glob, use Perl glob function
+                                 */
                                 /*  On OP_PADRANGE, push @_ */
                                 /*  On OP_DUMP, has no label */
+                                /*  On OP_UNSTACK, in a C-style for loop */
+                                /*  On OP_READLINE, it's for <<>>, not <> */
+/* There is no room in op_flags for this one, so it has its own bit-
+   field member (op_folded) instead.  The flag is only used to tell
+   op_convert_list to set op_folded.  */
+#define OPf_FOLDED      (1<<16)
 
 /* old names; don't use in new code, but don't break them, either */
 #define OPf_LIST       OPf_WANT_LIST
 #define OPf_KNOW       OPf_WANT
 
-#define GIMME \
-         (PL_op->op_flags & OPf_WANT                                   \
-          ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST             \
-             ? G_ARRAY                                                 \
-             : G_SCALAR)                                               \
-          : dowantarray())
+#if !defined(PERL_CORE) && !defined(PERL_EXT)
+#  define GIMME \
+          (PL_op->op_flags & OPf_WANT                                  \
+           ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST            \
+              ? G_ARRAY                                                        \
+              : G_SCALAR)                                              \
+           : dowantarray())
+#endif
 
 
 /* NOTE: OPp* flags are now auto-generated and defined in opcode.h,
  *       from data in regen/op_private */
 
 
-#define OPpTRANS_ALL   (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF|OPpTRANS_IDENTICAL|OPpTRANS_SQUASH|OPpTRANS_COMPLEMENT|OPpTRANS_GROWS|OPpTRANS_DELETE)
-
+#define OPpTRANS_ALL   (OPpTRANS_USE_SVOP|OPpTRANS_CAN_FORCE_UTF8|OPpTRANS_IDENTICAL|OPpTRANS_SQUASH|OPpTRANS_COMPLEMENT|OPpTRANS_GROWS|OPpTRANS_DELETE)
+#define OPpTRANS_FROM_UTF   OPpTRANS_USE_SVOP
+#define OPpTRANS_TO_UTF     OPpTRANS_CAN_FORCE_UTF8
 
 
 /* Mask for OP_ENTERSUB flags, the absence of which must be propagated
@@ -164,6 +180,24 @@ Deprecated.  Use C<GIMME_V> instead.
 #define OPpENTERSUB_LVAL_MASK (OPpLVAL_INTRO|OPpENTERSUB_INARGS)
 
 
+/* things that can be elements of op_aux */
+typedef union {
+    PADOFFSET pad_offset;
+    SV        *sv;
+    IV        iv;
+    UV        uv;
+    char      *pv;
+    SSize_t   ssize;
+} UNOP_AUX_item;
+
+#ifdef USE_ITHREADS
+#  define UNOP_AUX_item_sv(item) PAD_SVl((item)->pad_offset);
+#else
+#  define UNOP_AUX_item_sv(item) ((item)->sv);
+#endif
+
+
+
 
 struct op {
     BASEOP
@@ -174,6 +208,12 @@ struct unop {
     OP *       op_first;
 };
 
+struct unop_aux {
+    BASEOP
+    OP           *op_first;
+    UNOP_AUX_item *op_aux;
+};
+
 struct binop {
     BASEOP
     OP *       op_first;
@@ -183,6 +223,12 @@ struct binop {
 struct logop {
     BASEOP
     OP *       op_first;
+
+    /* Note that op->op_other is the *next* op in execution order of the
+     * alternate branch, not the root of the subtree. I.e. imagine it being
+     * called ->op_otherfirst.
+     * To find the structural subtree root (what could be called
+     * ->op_otherroot), use OpSIBLING of ->op_first  */
     OP *       op_other;
 };
 
@@ -201,6 +247,11 @@ struct methop {
         OP* op_first;   /* optree for method name */
         SV* op_meth_sv; /* static method name */
     } op_u;
+#ifdef USE_ITHREADS
+    PADOFFSET op_rclass_targ; /* pad index for redirect class */
+#else
+    SV*       op_rclass_sv;   /* static redirect class $o->A::meth() */
+#endif
 };
 
 struct pmop {
@@ -214,19 +265,16 @@ struct pmop {
 #endif
     U32         op_pmflags;
     union {
-       OP *    op_pmreplroot;          /* For OP_SUBST */
-#ifdef USE_ITHREADS
-       PADOFFSET  op_pmtargetoff;      /* For OP_PUSHRE */
-#else
-       GV *    op_pmtargetgv;
-#endif
+        OP *   op_pmreplroot;          /* For OP_SUBST */
+        PADOFFSET op_pmtargetoff;      /* For OP_SPLIT lex ary or thr GV */
+        GV *   op_pmtargetgv;          /* For OP_SPLIT non-threaded GV */
     }  op_pmreplrootu;
     union {
-       OP *    op_pmreplstart; /* Only used in OP_SUBST */
+        OP *   op_pmreplstart; /* Only used in OP_SUBST */
 #ifdef USE_ITHREADS
-       PADOFFSET op_pmstashoff; /* Only used in OP_MATCH, with PMf_ONCE set */
+        PADOFFSET op_pmstashoff; /* Only used in OP_MATCH, with PMf_ONCE set */
 #else
-       HV *    op_pmstash;
+        HV *   op_pmstash;
 #endif
     }          op_pmstashstartu;
     OP *       op_code_list;   /* list of (?{}) code blocks */
@@ -234,7 +282,7 @@ struct pmop {
 
 #ifdef USE_ITHREADS
 #define PM_GETRE(o)    (SvTYPE(PL_regex_pad[(o)->op_pmoffset]) == SVt_REGEXP \
-                        ? (REGEXP*)(PL_regex_pad[(o)->op_pmoffset]) : NULL)
+                         ? (REGEXP*)(PL_regex_pad[(o)->op_pmoffset]) : NULL)
 /* The assignment is just to enforce type safety (or at least get a warning).
  */
 /* With first class regexps not via a reference one needs to assign
@@ -246,7 +294,7 @@ struct pmop {
 #define PM_SETRE(o,r)  STMT_START {                                    \
                             REGEXP *const _pm_setre = (r);             \
                             assert(_pm_setre);                         \
-                           PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(_pm_setre); \
+                            PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(_pm_setre); \
                         } STMT_END
 #else
 #define PM_GETRE(o)     ((o)->op_pmregexp)
@@ -283,48 +331,56 @@ struct pmop {
  * allocate off the low end until you get to PMf_BASE_SHIFT+0.  If that isn't
  * enough, move PMf_BASE_SHIFT down (if possible) and add the new bit at the
  * other end instead; this preserves binary compatibility. */
-#define PMf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+4)
+#define PMf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+2)
+
+/* Set by the parser if it discovers an error, so the regex shouldn't be
+ * compiled */
+#define PMf_HAS_ERROR  (1U<<(PMf_BASE_SHIFT+3))
 
 /* 'use re "taint"' in scope: taint $1 etc. if target tainted */
-#define PMf_RETAINT    (1U<<(PMf_BASE_SHIFT+5))
+#define PMf_RETAINT    (1U<<(PMf_BASE_SHIFT+4))
 
 /* match successfully only once per reset, with related flag RXf_USED in
  * re->extflags holding state.  This is used only for ?? matches, and only on
  * OP_MATCH and OP_QR */
-#define PMf_ONCE       (1U<<(PMf_BASE_SHIFT+6))
+#define PMf_ONCE       (1U<<(PMf_BASE_SHIFT+5))
 
 /* PMf_ONCE, i.e. ?pat?, has matched successfully.  Not used under threading. */
-#define PMf_USED        (1U<<(PMf_BASE_SHIFT+7))
+#define PMf_USED        (1U<<(PMf_BASE_SHIFT+6))
 
 /* subst replacement is constant */
-#define PMf_CONST      (1U<<(PMf_BASE_SHIFT+8))
+#define PMf_CONST      (1U<<(PMf_BASE_SHIFT+7))
 
 /* keep 1st runtime pattern forever */
-#define PMf_KEEP       (1U<<(PMf_BASE_SHIFT+9))
+#define PMf_KEEP       (1U<<(PMf_BASE_SHIFT+8))
 
-#define PMf_GLOBAL     (1U<<(PMf_BASE_SHIFT+10)) /* pattern had a g modifier */
+#define PMf_GLOBAL     (1U<<(PMf_BASE_SHIFT+9)) /* pattern had a g modifier */
 
 /* don't reset pos() if //g fails */
-#define PMf_CONTINUE   (1U<<(PMf_BASE_SHIFT+11))
+#define PMf_CONTINUE   (1U<<(PMf_BASE_SHIFT+10))
 
 /* evaluating replacement as expr */
-#define PMf_EVAL       (1U<<(PMf_BASE_SHIFT+12))
+#define PMf_EVAL       (1U<<(PMf_BASE_SHIFT+11))
 
 /* Return substituted string instead of modifying it. */
-#define PMf_NONDESTRUCT        (1U<<(PMf_BASE_SHIFT+13))
+#define PMf_NONDESTRUCT        (1U<<(PMf_BASE_SHIFT+12))
 
 /* the pattern has a CV attached (currently only under qr/...(?{}).../) */
-#define PMf_HAS_CV     (1U<<(PMf_BASE_SHIFT+14))
+#define PMf_HAS_CV     (1U<<(PMf_BASE_SHIFT+13))
 
 /* op_code_list is private; don't free it etc. It may well point to
  * code within another sub, with different pad etc */
-#define PMf_CODELIST_PRIVATE   (1U<<(PMf_BASE_SHIFT+15))
+#define PMf_CODELIST_PRIVATE   (1U<<(PMf_BASE_SHIFT+14))
 
 /* the PMOP is a QR (we should be able to detect that from the op type,
  * but the regex compilation API passes just the pm flags, not the op
  * itself */
-#define PMf_IS_QR      (1U<<(PMf_BASE_SHIFT+16))
-#define PMf_USE_RE_EVAL        (1U<<(PMf_BASE_SHIFT+17)) /* use re'eval' in scope */
+#define PMf_IS_QR      (1U<<(PMf_BASE_SHIFT+15))
+#define PMf_USE_RE_EVAL        (1U<<(PMf_BASE_SHIFT+16)) /* use re'eval' in scope */
+
+/* Means that this is a subpattern being compiled while processing a \p{}
+ * wildcard.  This isn't called from op.c, but it is passed as a pm flag. */
+#define PMf_WILDCARD    (1U<<(PMf_BASE_SHIFT+17))
 
 /* See comments at the beginning of these defines about adding bits.  The
  * highest bit position should be used, so that if PMf_BASE_SHIFT gets
@@ -340,16 +396,16 @@ struct pmop {
                                 ? PL_stashpad[(o)->op_pmstashstartu.op_pmstashoff]   \
                                 : NULL)
 #  define PmopSTASH_set(o,hv)  \
-       (assert_((o)->op_pmflags & PMf_ONCE)                            \
-        (o)->op_pmstashstartu.op_pmstashoff =                          \
-           (hv) ? alloccopstash(hv) : 0)
+        (assert_((o)->op_pmflags & PMf_ONCE)                           \
+         (o)->op_pmstashstartu.op_pmstashoff =                         \
+            (hv) ? alloccopstash(hv) : 0)
 #else
 #  define PmopSTASH(o)                                                 \
     (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstash : NULL)
-#  if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#  if defined (DEBUGGING) && defined(PERL_USE_GCC_BRACE_GROUPS)
 #    define PmopSTASH_set(o,hv)                ({                              \
-       assert((o)->op_pmflags & PMf_ONCE);                             \
-       ((o)->op_pmstashstartu.op_pmstash = (hv));                      \
+        assert((o)->op_pmflags & PMf_ONCE);                            \
+        ((o)->op_pmstashstartu.op_pmstash = (hv));                     \
     })
 #  else
 #    define PmopSTASH_set(o,hv)        ((o)->op_pmstashstartu.op_pmstash = (hv))
@@ -383,19 +439,21 @@ struct loop {
     OP *       op_lastop;
 };
 
-#define cUNOPx(o)      ((UNOP*)o)
-#define cBINOPx(o)     ((BINOP*)o)
-#define cLISTOPx(o)    ((LISTOP*)o)
-#define cLOGOPx(o)     ((LOGOP*)o)
-#define cPMOPx(o)      ((PMOP*)o)
-#define cSVOPx(o)      ((SVOP*)o)
-#define cPADOPx(o)     ((PADOP*)o)
-#define cPVOPx(o)      ((PVOP*)o)
-#define cCOPx(o)       ((COP*)o)
-#define cLOOPx(o)      ((LOOP*)o)
-#define cMETHOPx(o)    ((METHOP*)o)
+#define cUNOPx(o)      ((UNOP*)(o))
+#define cUNOP_AUXx(o)  ((UNOP_AUX*)(o))
+#define cBINOPx(o)     ((BINOP*)(o))
+#define cLISTOPx(o)    ((LISTOP*)(o))
+#define cLOGOPx(o)     ((LOGOP*)(o))
+#define cPMOPx(o)      ((PMOP*)(o))
+#define cSVOPx(o)      ((SVOP*)(o))
+#define cPADOPx(o)     ((PADOP*)(o))
+#define cPVOPx(o)      ((PVOP*)(o))
+#define cCOPx(o)       ((COP*)(o))
+#define cLOOPx(o)      ((LOOP*)(o))
+#define cMETHOPx(o)    ((METHOP*)(o))
 
 #define cUNOP          cUNOPx(PL_op)
+#define cUNOP_AUX      cUNOP_AUXx(PL_op)
 #define cBINOP         cBINOPx(PL_op)
 #define cLISTOP                cLISTOPx(PL_op)
 #define cLOGOP         cLOGOPx(PL_op)
@@ -407,6 +465,7 @@ struct loop {
 #define cLOOP          cLOOPx(PL_op)
 
 #define cUNOPo         cUNOPx(o)
+#define cUNOP_AUXo     cUNOP_AUXx(o)
 #define cBINOPo                cBINOPx(o)
 #define cLISTOPo       cLISTOPx(o)
 #define cLOGOPo                cLOGOPx(o)
@@ -418,6 +477,7 @@ struct loop {
 #define cLOOPo         cLOOPx(o)
 
 #define kUNOP          cUNOPx(kid)
+#define kUNOP_AUX      cUNOP_AUXx(kid)
 #define kBINOP         cBINOPx(kid)
 #define kLISTOP                cLISTOPx(kid)
 #define kLOGOP         cLOGOPx(kid)
@@ -429,17 +489,36 @@ struct loop {
 #define kLOOP          cLOOPx(kid)
 
 
+typedef enum {
+    OPclass_NULL,     /*  0 */
+    OPclass_BASEOP,   /*  1 */
+    OPclass_UNOP,     /*  2 */
+    OPclass_BINOP,    /*  3 */
+    OPclass_LOGOP,    /*  4 */
+    OPclass_LISTOP,   /*  5 */
+    OPclass_PMOP,     /*  6 */
+    OPclass_SVOP,     /*  7 */
+    OPclass_PADOP,    /*  8 */
+    OPclass_PVOP,     /*  9 */
+    OPclass_LOOP,     /* 10 */
+    OPclass_COP,      /* 11 */
+    OPclass_METHOP,   /* 12 */
+    OPclass_UNOP_AUX  /* 13 */
+} OPclass;
+
+
 #ifdef USE_ITHREADS
 #  define      cGVOPx_gv(o)    ((GV*)PAD_SVl(cPADOPx(o)->op_padix))
 #  ifndef PERL_CORE
 #    define    IS_PADGV(v)     (v && isGV(v))
 #    define    IS_PADCONST(v) \
-       (v && (SvREADONLY(v) || (SvIsCOW(v) && !SvLEN(v))))
+        (v && (SvREADONLY(v) || (SvIsCOW(v) && !SvLEN(v))))
 #  endif
 #  define      cSVOPx_sv(v)    (cSVOPx(v)->op_sv \
-                                ? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ))
+                                 ? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ))
 #  define      cSVOPx_svp(v)   (cSVOPx(v)->op_sv \
-                                ? &cSVOPx(v)->op_sv : &PAD_SVl((v)->op_targ))
+                                 ? &cSVOPx(v)->op_sv : &PAD_SVl((v)->op_targ))
+#  define      cMETHOPx_rclass(v) PAD_SVl(cMETHOPx(v)->op_rclass_targ)
 #else
 #  define      cGVOPx_gv(o)    ((GV*)cSVOPx(o)->op_sv)
 #  ifndef PERL_CORE
@@ -448,9 +527,10 @@ struct loop {
 #  endif
 #  define      cSVOPx_sv(v)    (cSVOPx(v)->op_sv)
 #  define      cSVOPx_svp(v)   (&cSVOPx(v)->op_sv)
+#  define      cMETHOPx_rclass(v) (cMETHOPx(v)->op_rclass_sv)
 #endif
 
-#  define      cMETHOPx_meth(v)        cSVOPx_sv(v)
+#define        cMETHOPx_meth(v)        cSVOPx_sv(v)
 
 #define        cGVOP_gv                cGVOPx_gv(PL_op)
 #define        cGVOPo_gv               cGVOPx_gv(o)
@@ -493,6 +573,7 @@ struct loop {
 #define OA_FILESTATOP (12 << OCSHIFT)
 #define OA_LOOPEXOP (13 << OCSHIFT)
 #define OA_METHOP (14 << OCSHIFT)
+#define OA_UNOP_AUX (15 << OCSHIFT)
 
 /* Each remaining nybble of PL_opargs (i.e. bits 12..15, 16..19 etc)
  * encode the type for each arg */
@@ -546,22 +627,31 @@ struct loop {
 #define PERL_LOADMOD_DENY              0x1     /* no Module */
 #define PERL_LOADMOD_NOIMPORT          0x2     /* use Module () */
 #define PERL_LOADMOD_IMPORT_OPS                0x4     /* import arguments
-                                                  are passed as a sin-
-                                                  gle op tree, not a
-                                                  list of SVs */
+                                                   are passed as a sin-
+                                                   gle op tree, not a
+                                                   list of SVs */
 
 #if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C)
 #define ref(o, type) doref(o, type, TRUE)
 #endif
 
+
+/* translation table attached to OP_TRANS/OP_TRANSR ops */
+
+typedef struct {
+    Size_t size; /* number of entries in map[], not including final slot */
+    short map[1]; /* Unwarranted chumminess */
+} OPtrans_map;
+
+
 /*
-=head1 Optree Manipulation Functions
+=for apidoc_section $optree_manipulation
 
 =for apidoc Am|OP*|LINKLIST|OP *o
 Given the root of an optree, link the tree in execution order using the
 C<op_next> pointers and return the first op executed.  If this has
 already been done, it will not be redone, and C<< o->op_next >> will be
-returned.  If C<< o->op_next >> is not already set, I<o> should be at
+returned.  If C<< o->op_next >> is not already set, C<o> should be at
 least an C<UNOP>.
 
 =cut
@@ -584,9 +674,9 @@ least an C<UNOP>.
 #endif
 
 #define NewOp(m,var,c,type)    \
-       (var = (type *) Perl_Slab_Alloc(aTHX_ c*sizeof(type)))
+        (var = (type *) Perl_Slab_Alloc(aTHX_ c*sizeof(type)))
 #define NewOpSz(m,var,size)    \
-       (var = (OP *) Perl_Slab_Alloc(aTHX_ size))
+        (var = (OP *) Perl_Slab_Alloc(aTHX_ size))
 #define FreeOp(p) Perl_Slab_Free(aTHX_ p)
 
 /*
@@ -611,38 +701,51 @@ least an C<UNOP>.
 
 #ifdef PERL_CORE
 struct opslot {
-    /* keep opslot_next first */
-    OPSLOT *   opslot_next;            /* next slot */
-    OPSLAB *   opslot_slab;            /* owner */
+    U16         opslot_size;        /* size of this slot (in pointers) */
+    U16         opslot_offset;      /* offset from start of slab (in ptr units) */
     OP         opslot_op;              /* the op itself */
 };
 
 struct opslab {
-    OPSLOT *   opslab_first;           /* first op in this slab */
     OPSLAB *   opslab_next;            /* next slab */
-    OP *       opslab_freed;           /* chain of freed ops */
-    size_t     opslab_refcnt;          /* number of ops */
+    OPSLAB *   opslab_head;            /* first slab in chain */
+    OP **      opslab_freed;           /* array of sized chains of freed ops (head only)*/
+    size_t     opslab_refcnt;          /* number of ops (head slab only) */
+    U16         opslab_freed_size;      /* allocated size of opslab_freed */
+    U16                opslab_size;            /* size of slab in pointers,
+                                           including header */
+    U16         opslab_free_space;     /* space available in this slab
+                                           for allocating new ops (in ptr
+                                           units) */
 # ifdef PERL_DEBUG_READONLY_OPS
-    U16                opslab_size;            /* size of slab in pointers */
     bool       opslab_readonly;
 # endif
     OPSLOT     opslab_slots;           /* slots begin here */
 };
 
 # define OPSLOT_HEADER         STRUCT_OFFSET(OPSLOT, opslot_op)
-# define OPSLOT_HEADER_P       (OPSLOT_HEADER/sizeof(I32 *))
 # define OpSLOT(o)             (assert_(o->op_slabbed) \
-                                (OPSLOT *)(((char *)o)-OPSLOT_HEADER))
-# define OpSLAB(o)             OpSLOT(o)->opslot_slab
+                                 (OPSLOT *)(((char *)o)-OPSLOT_HEADER))
+
+/* the slab that owns this op */
+# define OpMySLAB(o) \
+    ((OPSLAB*)((char *)((I32**)OpSLOT(o) - OpSLOT(o)->opslot_offset)-STRUCT_OFFSET(struct opslab, opslab_slots)))
+/* the first (head) opslab of the chain in which this op is allocated */
+# define OpSLAB(o) \
+    (OpMySLAB(o)->opslab_head)
+/* calculate the slot given the owner slab and an offset */
+#define OpSLOToff(slab, offset) \
+    ((OPSLOT*)(((I32 **)&(slab)->opslab_slots)+(offset)))
+
 # define OpslabREFCNT_dec(slab)      \
-       (((slab)->opslab_refcnt == 1) \
-        ? opslab_free_nopad(slab)     \
-        : (void)--(slab)->opslab_refcnt)
+        (((slab)->opslab_refcnt == 1) \
+         ? opslab_free_nopad(slab)     \
+         : (void)--(slab)->opslab_refcnt)
   /* Variant that does not null out the pads */
 # define OpslabREFCNT_dec_padok(slab) \
-       (((slab)->opslab_refcnt == 1)  \
-        ? opslab_free(slab)            \
-        : (void)--(slab)->opslab_refcnt)
+        (((slab)->opslab_refcnt == 1)  \
+         ? opslab_free(slab)           \
+         : (void)--(slab)->opslab_refcnt)
 #endif
 
 struct block_hooks {
@@ -654,36 +757,36 @@ struct block_hooks {
 };
 
 /*
-=head1 Compile-time scope hooks
+=for apidoc_section $scope
 
 =for apidoc mx|U32|BhkFLAGS|BHK *hk
 Return the BHK's flags.
 
-=for apidoc mx|void *|BhkENTRY|BHK *hk|which
-Return an entry from the BHK structure.  I<which> is a preprocessor token
+=for apidoc mxu|void *|BhkENTRY|BHK *hk|which
+Return an entry from the BHK structure.  C<which> is a preprocessor token
 indicating which entry to return.  If the appropriate flag is not set
-this will return NULL.  The type of the return value depends on which
+this will return C<NULL>.  The type of the return value depends on which
 entry you ask for.
 
-=for apidoc Amx|void|BhkENTRY_set|BHK *hk|which|void *ptr
+=for apidoc Amxu|void|BhkENTRY_set|BHK *hk|which|void *ptr
 Set an entry in the BHK structure, and set the flags to indicate it is
-valid.  I<which> is a preprocessing token indicating which entry to set.
-The type of I<ptr> depends on the entry.
+valid.  C<which> is a preprocessing token indicating which entry to set.
+The type of C<ptr> depends on the entry.
 
-=for apidoc Amx|void|BhkDISABLE|BHK *hk|which
+=for apidoc Amxu|void|BhkDISABLE|BHK *hk|which
 Temporarily disable an entry in this BHK structure, by clearing the
-appropriate flag.  I<which> is a preprocessor token indicating which
+appropriate flag.  C<which> is a preprocessor token indicating which
 entry to disable.
 
-=for apidoc Amx|void|BhkENABLE|BHK *hk|which
+=for apidoc Amxu|void|BhkENABLE|BHK *hk|which
 Re-enable an entry in this BHK structure, by setting the appropriate
-flag.  I<which> is a preprocessor token indicating which entry to enable.
+flag.  C<which> is a preprocessor token indicating which entry to enable.
 This will assert (under -DDEBUGGING) if the entry doesn't contain a valid
 pointer.
 
-=for apidoc mx|void|CALL_BLOCK_HOOKS|which|arg
-Call all the registered block hooks for type I<which>.  I<which> is a
-preprocessing token; the type of I<arg> depends on I<which>.
+=for apidoc mxu|void|CALL_BLOCK_HOOKS|which|arg
+Call all the registered block hooks for type C<which>.  C<which> is a
+preprocessing token; the type of C<arg> depends on C<which>.
 
 =cut
 */
@@ -700,39 +803,39 @@ preprocessing token; the type of I<arg> depends on I<which>.
 
 #define BhkENABLE(hk, which) \
     STMT_START { \
-       BhkFLAGS(hk) |= BHKf_ ## which; \
-       assert(BhkENTRY(hk, which)); \
+        BhkFLAGS(hk) |= BHKf_ ## which; \
+        assert(BhkENTRY(hk, which)); \
     } STMT_END
 
 #define BhkDISABLE(hk, which) \
     STMT_START { \
-       BhkFLAGS(hk) &= ~(BHKf_ ## which); \
+        BhkFLAGS(hk) &= ~(BHKf_ ## which); \
     } STMT_END
 
 #define BhkENTRY_set(hk, which, ptr) \
     STMT_START { \
-       (hk)->which = ptr; \
-       BhkENABLE(hk, which); \
+        (hk)->which = ptr; \
+        BhkENABLE(hk, which); \
     } STMT_END
 
 #define CALL_BLOCK_HOOKS(which, arg) \
     STMT_START { \
-       if (PL_blockhooks) { \
-           SSize_t i; \
-           for (i = av_tindex(PL_blockhooks); i >= 0; i--) { \
-               SV *sv = AvARRAY(PL_blockhooks)[i]; \
-               BHK *hk; \
-               \
-               assert(SvIOK(sv)); \
-               if (SvUOK(sv)) \
-                   hk = INT2PTR(BHK *, SvUVX(sv)); \
-               else \
-                   hk = INT2PTR(BHK *, SvIVX(sv)); \
-               \
-               if (BhkENTRY(hk, which)) \
-                   BhkENTRY(hk, which)(aTHX_ arg); \
-           } \
-       } \
+        if (PL_blockhooks) { \
+            SSize_t i; \
+            for (i = av_top_index(PL_blockhooks); i >= 0; i--) { \
+                SV *sv = AvARRAY(PL_blockhooks)[i]; \
+                BHK *hk; \
+                \
+                assert(SvIOK(sv)); \
+                if (SvUOK(sv)) \
+                    hk = INT2PTR(BHK *, SvUVX(sv)); \
+                else \
+                    hk = INT2PTR(BHK *, SvIVX(sv)); \
+                \
+                if (BhkENTRY(hk, which)) \
+                    BhkENTRY(hk, which)(aTHX_ arg); \
+            } \
+        } \
     } STMT_END
 
 /* flags for rv2cv_op_cv */
@@ -740,7 +843,7 @@ preprocessing token; the type of I<arg> depends on I<which>.
 #define RV2CVOPCV_MARK_EARLY     0x00000001
 #define RV2CVOPCV_RETURN_NAME_GV 0x00000002
 #define RV2CVOPCV_RETURN_STUB    0x00000004
-#ifdef PERL_CORE /* behaviour of this flag is subject to change: */
+#if defined(PERL_CORE) || defined(PERL_EXT) /* behaviour of this flag is subject to change: */
 # define RV2CVOPCV_MAYBE_NAME_GV  0x00000008
 #endif
 #define RV2CVOPCV_FLAG_MASK      0x0000000f /* all of the above */
@@ -752,25 +855,25 @@ preprocessing token; the type of I<arg> depends on I<which>.
 #define OP_LVALUE_NO_CROAK 1
 
 /*
-=head1 Custom Operators
+=for apidoc_section $custom
 
 =for apidoc Am|U32|XopFLAGS|XOP *xop
 Return the XOP's flags.
 
 =for apidoc Am||XopENTRY|XOP *xop|which
-Return a member of the XOP structure.  I<which> is a cpp token
+Return a member of the XOP structure.  C<which> is a cpp token
 indicating which entry to return.  If the member is not set
 this will return a default value.  The return type depends
-on I<which>.  This macro evaluates its arguments more than
-once.  If you are using C<Perl_custom_op_xop> to retreive a
+on C<which>.  This macro evaluates its arguments more than
+once.  If you are using C<Perl_custom_op_xop> to retrieve a
 C<XOP *> from a C<OP *>, use the more efficient L</XopENTRYCUSTOM> instead.
 
 =for apidoc Am||XopENTRYCUSTOM|const OP *o|which
 Exactly like C<XopENTRY(XopENTRY(Perl_custom_op_xop(aTHX_ o), which)> but more
-efficient.  The I<which> parameter is identical to L</XopENTRY>.
+efficient.  The C<which> parameter is identical to L</XopENTRY>.
 
 =for apidoc Am|void|XopENTRY_set|XOP *xop|which|value
-Set a member of the XOP structure.  I<which> is a cpp token
+Set a member of the XOP structure.  C<which> is a cpp token
 indicating which entry to set.  See L<perlguts/"Custom Operators">
 for details about the available members and how
 they are used.  This macro evaluates its argument
@@ -827,8 +930,8 @@ typedef enum {
 
 #define XopENTRY_set(xop, which, to) \
     STMT_START { \
-       (xop)->which = (to); \
-       (xop)->xop_flags |= XOPf_ ## which; \
+        (xop)->which = (to); \
+        (xop)->xop_flags |= XOPf_ ## which; \
     } STMT_END
 
 #define XopENTRY(xop, which) \
@@ -840,15 +943,15 @@ typedef enum {
 #define XopDISABLE(xop, which) ((xop)->xop_flags &= ~XOPf_ ## which)
 #define XopENABLE(xop, which) \
     STMT_START { \
-       (xop)->xop_flags |= XOPf_ ## which; \
-       assert(XopENTRY(xop, which)); \
+        (xop)->xop_flags |= XOPf_ ## which; \
+        assert(XopENTRY(xop, which)); \
     } STMT_END
 
 #define Perl_custom_op_xop(x) \
     (Perl_custom_op_get_field(x, XOPe_xop_ptr).xop_ptr)
 
 /*
-=head1 Optree Manipulation Functions
+=for apidoc_section $optree_manipulation
 
 =for apidoc Am|const char *|OP_NAME|OP *o
 Return the name of the provided OP.  For core ops this looks up the name
@@ -860,20 +963,23 @@ Return a short description of the provided OP.
 =for apidoc Am|U32|OP_CLASS|OP *o
 Return the class of the provided OP: that is, which of the *OP
 structures it uses.  For core ops this currently gets the information out
-of PL_opargs, which does not always accurately reflect the type used.
+of C<PL_opargs>, which does not always accurately reflect the type used;
+in v5.26 onwards, see also the function C<L</op_class>> which can do a better
+job of determining the used type.
+
 For custom ops the type is returned from the registration, and it is up
 to the registree to ensure it is accurate.  The value returned will be
-one of the OA_* constants from op.h.
+one of the C<OA_>* constants from F<op.h>.
 
-=for apidoc Am|bool|OP_TYPE_IS|OP *oOptype type
-Returns true if the given OP is not a NULL pointer
+=for apidoc Am|bool|OP_TYPE_IS|OP *o|Optype type
+Returns true if the given OP is not a C<NULL> pointer
 and if it is of the given type.
 
 The negation of this macro, C<OP_TYPE_ISNT> is also available
 as well as C<OP_TYPE_IS_NN> and C<OP_TYPE_ISNT_NN> which elide
 the NULL pointer check.
 
-=for apidoc Am|bool|OP_TYPE_IS_OR_WAS|OP *oOptype type
+=for apidoc Am|bool|OP_TYPE_IS_OR_WAS|OP *o|Optype type
 Returns true if the given OP is not a NULL pointer and
 if it is of the given type or used to be before being
 replaced by an OP of type OP_NULL.
@@ -881,29 +987,41 @@ replaced by an OP of type OP_NULL.
 The negation of this macro, C<OP_TYPE_ISNT_AND_WASNT>
 is also available as well as C<OP_TYPE_IS_OR_WAS_NN>
 and C<OP_TYPE_ISNT_AND_WASNT_NN> which elide
-the NULL pointer check.
+the C<NULL> pointer check.
+
+=for apidoc Am|bool|OpHAS_SIBLING|OP *o
+Returns true if C<o> has a sibling
+
+=for apidoc Am|OP*|OpSIBLING|OP *o
+Returns the sibling of C<o>, or C<NULL> if there is no sibling
 
-=for apidoc Am|bool|OP_HAS_SIBLING|OP *o
-Returns true if o has a sibling
+=for apidoc Am|void|OpMORESIB_set|OP *o|OP *sib
+Sets the sibling of C<o> to the non-zero value C<sib>. See also C<L</OpLASTSIB_set>>
+and C<L</OpMAYBESIB_set>>. For a higher-level interface, see
+C<L</op_sibling_splice>>.
 
-=for apidoc Am|bool|OP_SIBLING|OP *o
-Returns the sibling of o, or NULL if there is no sibling
+=for apidoc Am|void|OpLASTSIB_set|OP *o|OP *parent
+Marks C<o> as having no further siblings and marks
+o as having the specified parent. See also C<L</OpMORESIB_set>> and
+C<OpMAYBESIB_set>. For a higher-level interface, see
+C<L</op_sibling_splice>>.
 
-=for apidoc Am|bool|OP_SIBLING_set|OP *o|OP *sib
-Sets the sibling of o to sib
+=for apidoc Am|void|OpMAYBESIB_set|OP *o|OP *sib|OP *parent
+Conditionally does C<OpMORESIB_set> or C<OpLASTSIB_set> depending on whether
+C<sib> is non-null. For a higher-level interface, see C<L</op_sibling_splice>>.
 
 =cut
 */
 
 #define OP_NAME(o) ((o)->op_type == OP_CUSTOM \
                     ? XopENTRYCUSTOM(o, xop_name) \
-                   : PL_op_name[(o)->op_type])
+                    : PL_op_name[(o)->op_type])
 #define OP_DESC(o) ((o)->op_type == OP_CUSTOM \
                     ? XopENTRYCUSTOM(o, xop_desc) \
-                   : PL_op_desc[(o)->op_type])
+                    : PL_op_desc[(o)->op_type])
 #define OP_CLASS(o) ((o)->op_type == OP_CUSTOM \
-                    ? XopENTRYCUSTOM(o, xop_class) \
-                    : (PL_opargs[(o)->op_type] & OA_CLASS_MASK))
+                     ? XopENTRYCUSTOM(o, xop_class) \
+                     : (PL_opargs[(o)->op_type] & OA_CLASS_MASK))
 
 #define OP_TYPE_IS(o, type) ((o) && (o)->op_type == (type))
 #define OP_TYPE_IS_NN(o, type) ((o)->op_type == (type))
@@ -928,23 +1046,25 @@ Sets the sibling of o to sib
 #define OP_TYPE_ISNT_AND_WASNT(o, type) \
     ( (o) && OP_TYPE_ISNT_AND_WASNT_NN(o, type) )
 
-#ifdef PERL_OP_PARENT
-#  define OP_HAS_SIBLING(o)      (!cBOOL((o)->op_lastsib))
-#  define OP_SIBLING(o)          (0 + (o)->op_lastsib ? NULL : (o)->op_sibling)
-#  define OP_SIBLING_set(o, sib) ((o)->op_sibling = (sib))
-#else
-#  define OP_HAS_SIBLING(o)      (cBOOL((o)->op_sibling))
-#  define OP_SIBLING(o)          (0 + (o)->op_sibling)
-#  define OP_SIBLING_set(o, sib) ((o)->op_sibling = (sib))
+/* should match anything that uses ck_ftst in regen/opcodes */
+#define OP_IS_STAT(op) (OP_IS_FILETEST(op) || (op) == OP_LSTAT || (op) == OP_STAT)
+
+#define OpHAS_SIBLING(o)       (cBOOL((o)->op_moresib))
+#define OpSIBLING(o)           (0 + (o)->op_moresib ? (o)->op_sibparent : NULL)
+#define OpMORESIB_set(o, sib) ((o)->op_moresib = 1, (o)->op_sibparent = (sib))
+#define OpLASTSIB_set(o, parent) \
+    ((o)->op_moresib = 0, (o)->op_sibparent = (parent))
+#define OpMAYBESIB_set(o, sib, parent) \
+    ((o)->op_sibparent = ((o)->op_moresib = cBOOL(sib)) ? (sib) : (parent))
+
+#if !defined(PERL_CORE) && !defined(PERL_EXT)
+/* for backwards compatibility only */
+#  define OP_SIBLING(o)                OpSIBLING(o)
 #endif
 
 #define newATTRSUB(f, o, p, a, b) Perl_newATTRSUB_x(aTHX_  f, o, p, a, b, FALSE)
 #define newSUB(f, o, p, b)     newATTRSUB((f), (o), (p), NULL, (b))
 
-/*
-=head1 Hook manipulation
-*/
-
 #ifdef USE_ITHREADS
 #  define OP_CHECK_MUTEX_INIT          MUTEX_INIT(&PL_check_mutex)
 #  define OP_CHECK_MUTEX_LOCK          MUTEX_LOCK(&PL_check_mutex)
@@ -957,12 +1077,73 @@ Sets the sibling of o to sib
 #  define OP_CHECK_MUTEX_TERM          NOOP
 #endif
 
+
+/* Stuff for OP_MULTDEREF/pp_multideref. */
+
+/* actions */
+
+/* Load another word of actions/flag bits. Must be 0 */
+#define MDEREF_reload                       0
+
+#define MDEREF_AV_pop_rv2av_aelem           1
+#define MDEREF_AV_gvsv_vivify_rv2av_aelem   2
+#define MDEREF_AV_padsv_vivify_rv2av_aelem  3
+#define MDEREF_AV_vivify_rv2av_aelem        4
+#define MDEREF_AV_padav_aelem               5
+#define MDEREF_AV_gvav_aelem                6
+
+#define MDEREF_HV_pop_rv2hv_helem           8
+#define MDEREF_HV_gvsv_vivify_rv2hv_helem   9
+#define MDEREF_HV_padsv_vivify_rv2hv_helem 10
+#define MDEREF_HV_vivify_rv2hv_helem       11
+#define MDEREF_HV_padhv_helem              12
+#define MDEREF_HV_gvhv_helem               13
+
+#define MDEREF_ACTION_MASK                0xf
+
+/* key / index type */
+
+#define MDEREF_INDEX_none   0x00 /* run external ops to generate index */
+#define MDEREF_INDEX_const  0x10 /* index is const PV/UV */
+#define MDEREF_INDEX_padsv  0x20 /* index is lexical var */
+#define MDEREF_INDEX_gvsv   0x30 /* index is GV */
+
+#define MDEREF_INDEX_MASK   0x30
+
+/* bit flags */
+
+#define MDEREF_FLAG_last    0x40 /* the last [ah]elem; PL_op flags apply */
+
+#define MDEREF_MASK         0x7F
+#define MDEREF_SHIFT           7
+
+#if defined(PERL_IN_DOOP_C) || defined(PERL_IN_PP_C)
+#   define FATAL_ABOVE_FF_MSG                                       \
+      "Use of strings with code points over 0xFF as arguments to "  \
+      "%s operator is not allowed"
+#endif
+#if defined(PERL_IN_OP_C) || defined(PERL_IN_DOOP_C) || defined(PERL_IN_PERL_C)
+#  define TR_UNMAPPED           (UV)-1
+#  define TR_DELETE             (UV)-2
+#  define TR_R_EMPTY            (UV)-3  /* rhs (replacement) is empty */
+#  define TR_OOB                (UV)-4  /* Something that isn't one of the others */
+#  define TR_SPECIAL_HANDLING   TR_DELETE /* Can occupy same value */
+#  define TR_UNLISTED           TR_UNMAPPED /* A synonym whose name is clearer
+                                               at times */
+#endif
+#if defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C)
+#define RANGE_INDICATOR  ILLEGAL_UTF8_BYTE
+#endif
+
+/* stuff for OP_ARGCHECK */
+
+struct op_argcheck_aux {
+    UV   params;     /* number of positional parameters */
+    UV   opt_params; /* number of optional positional parameters */
+    char slurpy;     /* presence of slurpy: may be '\0', '@' or '%' */
+};
+
+
 /*
- * Local variables:
- * c-indentation-style: bsd
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- *
  * ex: set ts=8 sts=4 sw=4 et:
  */