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 c0e6386..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_moresib      this op is is not 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,
 
 typedef PERL_BITFIELD16 Optype;
 
-/* this field now either points to the next sibling or to the parent,
- * depending on op_moresib. So rename it from op_sibling to op_sibparent.
- */
-#ifdef PERL_OP_PARENT
-#  define _OP_SIBPARENT_FIELDNAME op_sibparent
-#else
-#  define _OP_SIBPARENT_FIELDNAME op_sibling
-#endif
-
 #ifdef BASEOP_DEFINITION
 #define BASEOP BASEOP_DEFINITION
 #else
 #define BASEOP                         \
     OP*                op_next;                \
-    OP*                _OP_SIBPARENT_FIELDNAME;\
+    OP*                op_sibparent;           \
     OP*                (*op_ppaddr)(pTHX);     \
     PADOFFSET  op_targ;                \
     PERL_BITFIELD16 op_type:9;         \
@@ -74,19 +65,19 @@ typedef PERL_BITFIELD16 Optype;
 
 /* 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.
@@ -94,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 */
 
@@ -104,52 +95,58 @@ 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, e.g.
+                                /*  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,
+                                /*  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_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.  */
@@ -161,11 +158,11 @@ Deprecated.  Use C<GIMME_V> instead.
 
 #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())
+          (PL_op->op_flags & OPf_WANT                                  \
+           ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST            \
+              ? G_ARRAY                                                        \
+              : G_SCALAR)                                              \
+           : dowantarray())
 #endif
 
 
@@ -173,8 +170,9 @@ Deprecated.  Use C<GIMME_V> instead.
  *       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
@@ -183,11 +181,13 @@ Deprecated.  Use C<GIMME_V> instead.
 
 
 /* things that can be elements of op_aux */
-typedef union  {
+typedef union {
     PADOFFSET pad_offset;
     SV        *sv;
     IV        iv;
     UV        uv;
+    char      *pv;
+    SSize_t   ssize;
 } UNOP_AUX_item;
 
 #ifdef USE_ITHREADS
@@ -223,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;
 };
 
@@ -259,16 +265,16 @@ struct pmop {
 #endif
     U32         op_pmflags;
     union {
-       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 *   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 */
@@ -276,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
@@ -288,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)
@@ -327,46 +333,54 @@ struct pmop {
  * other end instead; this preserves binary compatibility. */
 #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
@@ -382,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))
@@ -475,17 +489,35 @@ 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)
@@ -498,7 +530,7 @@ struct loop {
 #  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)
@@ -595,16 +627,25 @@ 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
@@ -633,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)
 
 /*
@@ -660,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 {
@@ -703,34 +757,34 @@ 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
+=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 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.  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.  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.  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
+=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>.
 
@@ -749,39 +803,39 @@ preprocessing token; the type of C<arg> depends on C<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 */
@@ -789,7 +843,7 @@ preprocessing token; the type of C<arg> depends on C<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 */
@@ -801,7 +855,7 @@ preprocessing token; the type of C<arg> depends on C<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.
@@ -811,7 +865,7 @@ 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 C<which>.  This macro evaluates its arguments more than
-once.  If you are using C<Perl_custom_op_xop> to retreive a
+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
@@ -876,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) \
@@ -889,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
@@ -909,7 +963,10 @@ 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 C<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 C<OA_>* constants from F<op.h>.
@@ -944,7 +1001,7 @@ and C<L</OpMAYBESIB_set>>. For a higher-level interface, see
 C<L</op_sibling_splice>>.
 
 =for apidoc Am|void|OpLASTSIB_set|OP *o|OP *parent
-Marks C<o> as having no further siblings. On C<PERL_OP_PARENT> builds, marks
+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>>.
@@ -958,13 +1015,13 @@ C<sib> is non-null. For a higher-level interface, see C<L</op_sibling_splice>>.
 
 #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))
@@ -989,24 +1046,16 @@ C<sib> is non-null. For a higher-level interface, see C<L</op_sibling_splice>>.
 #define OP_TYPE_ISNT_AND_WASNT(o, type) \
     ( (o) && OP_TYPE_ISNT_AND_WASNT_NN(o, type) )
 
+/* 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)
 
-#ifdef PERL_OP_PARENT
-#  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))
-#else
-#  define OpHAS_SIBLING(o)     (cBOOL((o)->op_sibling))
-#  define OpSIBLING(o)         (0 + (o)->op_sibling)
-#  define OpMORESIB_set(o, sib) ((o)->op_moresib = 1, (o)->op_sibling = (sib))
-#  define OpLASTSIB_set(o, parent) \
-       ((o)->op_moresib = 0, (o)->op_sibling = NULL)
-#  define OpMAYBESIB_set(o, sib, parent) \
-       ((o)->op_moresib = cBOOL(sib), (o)->op_sibling = (sib))
-#endif
+#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 */
@@ -1016,10 +1065,6 @@ C<sib> is non-null. For a higher-level interface, see C<L</op_sibling_splice>>.
 #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)
@@ -1073,11 +1118,31 @@ C<sib> is non-null. For a higher-level interface, see C<L</op_sibling_splice>>.
 #define MDEREF_SHIFT           7
 
 #if defined(PERL_IN_DOOP_C) || defined(PERL_IN_PP_C)
-static const char * const deprecated_above_ff_msg
-    = "Use of strings with code points over 0xFF as arguments to "
-      "%s operator is deprecated";
+#   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 '%' */
+};
+
 
 /*
  * ex: set ts=8 sts=4 sw=4 et: