This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
APIify op list constructors
authorZefram <zefram@fysh.org>
Mon, 4 Oct 2010 21:19:08 +0000 (22:19 +0100)
committerFather Chrysostomos <sprout@cpan.org>
Tue, 12 Oct 2010 19:52:12 +0000 (12:52 -0700)
Put into the API op_append_elem, op_prepend_elem, and op_append_list.  All
renamed from op_-less internal names.  Parameter types for op_append_list
changed to match the rest of the op API and avoid some casting.

12 files changed:
MANIFEST
embed.fnc
embed.h
ext/XS-APItest/APItest.xs
ext/XS-APItest/t/op_list.t [new file with mode: 0644]
global.sym
op.c
perly.act
perly.tab
perly.y
proto.h
toke.c

index 064993d..deea667 100644 (file)
--- a/MANIFEST
+++ b/MANIFEST
@@ -3390,6 +3390,7 @@ ext/XS-APItest/t/my_cxt.t XS::APItest: test MY_CXT interface
 ext/XS-APItest/t/my_exit.t     XS::APItest: test my_exit
 ext/XS-APItest/t/Null.pm       Helper for ./blockhooks.t
 ext/XS-APItest/t/op_contextualize.t    test op_contextualize() API
+ext/XS-APItest/t/op_list.t     test OP list construction API
 ext/XS-APItest/t/op.t          XS::APItest: tests for OP related APIs
 ext/XS-APItest/t/peep.t                test PL_peepp/PL_rpeepp
 ext/XS-APItest/t/pmflag.t      Test removal of Perl_pmflag()
index cc4e738..4ef49ba 100644 (file)
--- a/embed.fnc
+++ b/embed.fnc
@@ -173,10 +173,9 @@ XEop       |bool   |try_amagic_un  |int method|int flags
 Ap     |SV*    |amagic_call    |NN SV* left|NN SV* right|int method|int dir
 Ap     |int    |Gv_AMupdate    |NN HV* stash|bool destructing
 ApR    |CV*    |gv_handler     |NULLOK HV* stash|I32 id
-: Used in perly.y
-p      |OP*    |append_elem    |I32 optype|NULLOK OP* first|NULLOK OP* last
-: Used in perly.y
-p      |OP*    |append_list    |I32 optype|NULLOK LISTOP* first|NULLOK LISTOP* last
+Apd    |OP*    |op_append_elem |I32 optype|NULLOK OP* first|NULLOK OP* last
+Apd    |OP*    |op_append_list |I32 optype|NULLOK OP* first|NULLOK OP* last
+Apd    |OP*    |op_prepend_elem|I32 optype|NULLOK OP* first|NULLOK OP* last
 : FIXME - this is only called by pp_chown. They should be merged.
 p      |I32    |apply          |I32 type|NN SV** mark|NN SV** sp
 ApM    |void   |apply_attrs_string|NN const char *stashpv|NN CV *cv|NN const char *attrstr|STRLEN len
@@ -952,8 +951,6 @@ p   |OP*    |pmruntime      |NN OP *o|NN OP *expr|bool isreg
 s      |OP*    |pmtrans        |NN OP* o|NN OP* expr|NN OP* repl
 #endif
 Ap     |void   |pop_scope
-: Used in perly.y
-p      |OP*    |prepend_elem   |I32 optype|NULLOK OP* head|NULLOK OP* tail
 Ap     |void   |push_scope
 Amb    |OP*    |ref            |NULLOK OP* o|I32 type
 #if defined(PERL_IN_OP_C)
diff --git a/embed.h b/embed.h
index 7e187bd..72c16a4 100644 (file)
--- a/embed.h
+++ b/embed.h
 #define new_version(a)         Perl_new_version(aTHX_ a)
 #define ninstr                 Perl_ninstr
 #define nothreadhook()         Perl_nothreadhook(aTHX)
+#define op_append_elem(a,b,c)  Perl_op_append_elem(aTHX_ a,b,c)
+#define op_append_list(a,b,c)  Perl_op_append_list(aTHX_ a,b,c)
 #define op_contextualize(a,b)  Perl_op_contextualize(aTHX_ a,b)
 #define op_dump(a)             Perl_op_dump(aTHX_ a)
 #define op_free(a)             Perl_op_free(aTHX_ a)
 #define op_null(a)             Perl_op_null(aTHX_ a)
+#define op_prepend_elem(a,b,c) Perl_op_prepend_elem(aTHX_ a,b,c)
 #define op_refcnt_lock()       Perl_op_refcnt_lock(aTHX)
 #define op_refcnt_unlock()     Perl_op_refcnt_unlock(aTHX)
 #define pack_cat(a,b,c,d,e,f,g)        Perl_pack_cat(aTHX_ a,b,c,d,e,f,g)
 #endif
 #ifdef PERL_CORE
 #define allocmy(a,b,c)         Perl_allocmy(aTHX_ a,b,c)
-#define append_elem(a,b,c)     Perl_append_elem(aTHX_ a,b,c)
-#define append_list(a,b,c)     Perl_append_list(aTHX_ a,b,c)
 #define apply(a,b,c)           Perl_apply(aTHX_ a,b,c)
 #define bind_match(a,b,c)      Perl_bind_match(aTHX_ a,b,c)
 #define block_end(a,b)         Perl_block_end(aTHX_ a,b)
 #define pp_wantarray()         Perl_pp_wantarray(aTHX)
 #define pp_warn()              Perl_pp_warn(aTHX)
 #define pp_xor()               Perl_pp_xor(aTHX)
-#define prepend_elem(a,b,c)    Perl_prepend_elem(aTHX_ a,b,c)
 #define report_evil_fh(a,b,c)  Perl_report_evil_fh(aTHX_ a,b,c)
 #define rpeep(a)               Perl_rpeep(aTHX_ a)
 #define rsignal_restore(a,b)   Perl_rsignal_restore(aTHX_ a,b)
index 9f0304e..cadfaa4 100644 (file)
@@ -418,6 +418,36 @@ THX_ck_entersub_multi_sum(pTHX_ OP *entersubop, GV *namegv, SV *ckobj)
     return sumop;
 }
 
+STATIC void test_op_list_describe_part(SV *res, OP *o);
+STATIC void
+test_op_list_describe_part(SV *res, OP *o)
+{
+    sv_catpv(res, PL_op_name[o->op_type]);
+    switch (o->op_type) {
+       case OP_CONST: {
+           sv_catpvf(res, "(%d)", (int)SvIV(cSVOPx(o)->op_sv));
+       } break;
+    }
+    if (o->op_flags & OPf_KIDS) {
+       OP *k;
+       sv_catpvs(res, "[");
+       for (k = cUNOPx(o)->op_first; k; k = k->op_sibling)
+           test_op_list_describe_part(res, k);
+       sv_catpvs(res, "]");
+    } else {
+       sv_catpvs(res, ".");
+    }
+}
+
+STATIC char *
+test_op_list_describe(OP *o)
+{
+    SV *res = sv_2mortal(newSVpvs(""));
+    if (o)
+       test_op_list_describe_part(res, o);
+    return SvPVX(res);
+}
+
 /** RPN keyword parser **/
 
 #define sv_is_glob(sv) (SvTYPE(sv) == SVt_PVGV)
@@ -595,8 +625,7 @@ static OP *THX_parse_keyword_swaptwostmts(pTHX)
     b = parse_fullstmt(0);
     if(a && b)
        PL_hints |= HINT_BLOCK_SCOPE;
-    /* should use append_list(), but that's not part of the public API */
-    return !a ? b : !b ? a : newLISTOP(OP_LINESEQ, 0, b, a);
+    return op_append_list(OP_LINESEQ, b, a);
 }
 
 #define parse_keyword_looprest() THX_parse_keyword_looprest(aTHX)
@@ -1790,6 +1819,123 @@ test_copyhints()
        LEAVE;
 
 void
+test_op_list()
+    PREINIT:
+       OP *a;
+    CODE:
+#define iv_op(iv) newSVOP(OP_CONST, 0, newSViv(iv))
+#define check_op(o, expect) \
+    do { \
+       if (strcmp(test_op_list_describe(o), (expect))) \
+           croak("fail %s %s", test_op_list_describe(o), (expect)); \
+    } while(0)
+       a = op_append_elem(OP_LIST, NULL, NULL);
+       check_op(a, "");
+       a = op_append_elem(OP_LIST, iv_op(1), a);
+       check_op(a, "const(1).");
+       a = op_append_elem(OP_LIST, NULL, a);
+       check_op(a, "const(1).");
+       a = op_append_elem(OP_LIST, a, iv_op(2));
+       check_op(a, "list[pushmark.const(1).const(2).]");
+       a = op_append_elem(OP_LIST, a, iv_op(3));
+       check_op(a, "list[pushmark.const(1).const(2).const(3).]");
+       a = op_append_elem(OP_LIST, a, NULL);
+       check_op(a, "list[pushmark.const(1).const(2).const(3).]");
+       a = op_append_elem(OP_LIST, NULL, a);
+       check_op(a, "list[pushmark.const(1).const(2).const(3).]");
+       a = op_append_elem(OP_LIST, iv_op(4), a);
+       check_op(a, "list[pushmark.const(4)."
+               "list[pushmark.const(1).const(2).const(3).]]");
+       a = op_append_elem(OP_LIST, a, iv_op(5));
+       check_op(a, "list[pushmark.const(4)."
+               "list[pushmark.const(1).const(2).const(3).]const(5).]");
+       a = op_append_elem(OP_LIST, a, 
+               op_append_elem(OP_LIST, iv_op(7), iv_op(6)));
+       check_op(a, "list[pushmark.const(4)."
+               "list[pushmark.const(1).const(2).const(3).]const(5)."
+               "list[pushmark.const(7).const(6).]]");
+       op_free(a);
+       a = op_append_elem(OP_LINESEQ, iv_op(1), iv_op(2));
+       check_op(a, "lineseq[const(1).const(2).]");
+       a = op_append_elem(OP_LINESEQ, a, iv_op(3));
+       check_op(a, "lineseq[const(1).const(2).const(3).]");
+       op_free(a);
+       a = op_append_elem(OP_LINESEQ,
+               op_append_elem(OP_LIST, iv_op(1), iv_op(2)),
+               iv_op(3));
+       check_op(a, "lineseq[list[pushmark.const(1).const(2).]const(3).]");
+       op_free(a);
+       a = op_prepend_elem(OP_LIST, NULL, NULL);
+       check_op(a, "");
+       a = op_prepend_elem(OP_LIST, a, iv_op(1));
+       check_op(a, "const(1).");
+       a = op_prepend_elem(OP_LIST, a, NULL);
+       check_op(a, "const(1).");
+       a = op_prepend_elem(OP_LIST, iv_op(2), a);
+       check_op(a, "list[pushmark.const(2).const(1).]");
+       a = op_prepend_elem(OP_LIST, iv_op(3), a);
+       check_op(a, "list[pushmark.const(3).const(2).const(1).]");
+       a = op_prepend_elem(OP_LIST, NULL, a);
+       check_op(a, "list[pushmark.const(3).const(2).const(1).]");
+       a = op_prepend_elem(OP_LIST, a, NULL);
+       check_op(a, "list[pushmark.const(3).const(2).const(1).]");
+       a = op_prepend_elem(OP_LIST, a, iv_op(4));
+       check_op(a, "list[pushmark."
+               "list[pushmark.const(3).const(2).const(1).]const(4).]");
+       a = op_prepend_elem(OP_LIST, iv_op(5), a);
+       check_op(a, "list[pushmark.const(5)."
+               "list[pushmark.const(3).const(2).const(1).]const(4).]");
+       a = op_prepend_elem(OP_LIST,
+               op_prepend_elem(OP_LIST, iv_op(6), iv_op(7)), a);
+       check_op(a, "list[pushmark.list[pushmark.const(6).const(7).]const(5)."
+               "list[pushmark.const(3).const(2).const(1).]const(4).]");
+       op_free(a);
+       a = op_prepend_elem(OP_LINESEQ, iv_op(2), iv_op(1));
+       check_op(a, "lineseq[const(2).const(1).]");
+       a = op_prepend_elem(OP_LINESEQ, iv_op(3), a);
+       check_op(a, "lineseq[const(3).const(2).const(1).]");
+       op_free(a);
+       a = op_prepend_elem(OP_LINESEQ, iv_op(3),
+               op_prepend_elem(OP_LIST, iv_op(2), iv_op(1)));
+       check_op(a, "lineseq[const(3).list[pushmark.const(2).const(1).]]");
+       op_free(a);
+       a = op_append_list(OP_LINESEQ, NULL, NULL);
+       check_op(a, "");
+       a = op_append_list(OP_LINESEQ, iv_op(1), a);
+       check_op(a, "const(1).");
+       a = op_append_list(OP_LINESEQ, NULL, a);
+       check_op(a, "const(1).");
+       a = op_append_list(OP_LINESEQ, a, iv_op(2));
+       check_op(a, "lineseq[const(1).const(2).]");
+       a = op_append_list(OP_LINESEQ, a, iv_op(3));
+       check_op(a, "lineseq[const(1).const(2).const(3).]");
+       a = op_append_list(OP_LINESEQ, iv_op(4), a);
+       check_op(a, "lineseq[const(4).const(1).const(2).const(3).]");
+       a = op_append_list(OP_LINESEQ, a, NULL);
+       check_op(a, "lineseq[const(4).const(1).const(2).const(3).]");
+       a = op_append_list(OP_LINESEQ, NULL, a);
+       check_op(a, "lineseq[const(4).const(1).const(2).const(3).]");
+       a = op_append_list(OP_LINESEQ, a,
+               op_append_list(OP_LINESEQ, iv_op(5), iv_op(6)));
+       check_op(a, "lineseq[const(4).const(1).const(2).const(3)."
+               "const(5).const(6).]");
+       op_free(a);
+       a = op_append_list(OP_LINESEQ,
+               op_append_list(OP_LINESEQ, iv_op(1), iv_op(2)),
+               op_append_list(OP_LIST, iv_op(3), iv_op(4)));
+       check_op(a, "lineseq[const(1).const(2)."
+               "list[pushmark.const(3).const(4).]]");
+       op_free(a);
+       a = op_append_list(OP_LINESEQ,
+               op_append_list(OP_LIST, iv_op(1), iv_op(2)),
+               op_append_list(OP_LINESEQ, iv_op(3), iv_op(4)));
+       check_op(a, "lineseq[list[pushmark.const(1).const(2).]"
+               "const(3).const(4).]");
+       op_free(a);
+#undef iv_op
+#undef check_op
+
+void
 peep_enable ()
     PREINIT:
        dMY_CXT;
diff --git a/ext/XS-APItest/t/op_list.t b/ext/XS-APItest/t/op_list.t
new file mode 100644 (file)
index 0000000..e5b55a9
--- /dev/null
@@ -0,0 +1,10 @@
+use warnings;
+use strict;
+use Test::More tests => 1;
+
+use XS::APItest;
+
+XS::APItest::test_op_list();
+ok 1;
+
+1;
index d7b4796..11a2961 100644 (file)
@@ -408,11 +408,14 @@ Perl_new_version
 Perl_new_warnings_bitfield
 Perl_ninstr
 Perl_nothreadhook
+Perl_op_append_elem
+Perl_op_append_list
 Perl_op_clear
 Perl_op_contextualize
 Perl_op_dump
 Perl_op_free
 Perl_op_null
+Perl_op_prepend_elem
 Perl_op_refcnt_lock
 Perl_op_refcnt_unlock
 Perl_pack_cat
diff --git a/op.c b/op.c
index e4ddfbc..ee2c9f3 100644 (file)
--- a/op.c
+++ b/op.c
@@ -1959,7 +1959,7 @@ S_dup_attrlist(pTHX_ OP *o)
        rop = NULL;
        for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
            if (o->op_type == OP_CONST)
-               rop = append_elem(OP_LIST, rop,
+               rop = op_append_elem(OP_LIST, rop,
                                  newSVOP(OP_CONST, o->op_flags,
                                          SvREFCNT_inc_NN(cSVOPo->op_sv)));
        }
@@ -1995,9 +1995,9 @@ S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
        Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
                         newSVpvs(ATTRSMODULE),
                         NULL,
-                        prepend_elem(OP_LIST,
+                        op_prepend_elem(OP_LIST,
                                      newSVOP(OP_CONST, 0, stashsv),
-                                     prepend_elem(OP_LIST,
+                                     op_prepend_elem(OP_LIST,
                                                   newSVOP(OP_CONST, 0,
                                                           newRV(target)),
                                                   dup_attrlist(attrs))));
@@ -2032,9 +2032,9 @@ S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
 
     arg = newOP(OP_PADSV, 0);
     arg->op_targ = target->op_targ;
-    arg = prepend_elem(OP_LIST,
+    arg = op_prepend_elem(OP_LIST,
                       newSVOP(OP_CONST, 0, stashsv),
-                      prepend_elem(OP_LIST,
+                      op_prepend_elem(OP_LIST,
                                    newUNOP(OP_REFGEN, 0,
                                            mod(arg, OP_REFGEN)),
                                    dup_attrlist(attrs)));
@@ -2042,13 +2042,13 @@ S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
     /* Fake up a method call to import */
     meth = newSVpvs_share("import");
     imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL|OPf_WANT_VOID,
-                  append_elem(OP_LIST,
-                              prepend_elem(OP_LIST, pack, list(arg)),
+                  op_append_elem(OP_LIST,
+                              op_prepend_elem(OP_LIST, pack, list(arg)),
                               newSVOP(OP_METHOD_NAMED, 0, meth)));
     imop->op_private |= OPpENTERSUB_NOMOD;
 
     /* Combine the ops. */
-    *imopsp = append_elem(OP_LIST, *imopsp, imop);
+    *imopsp = op_append_elem(OP_LIST, *imopsp, imop);
 }
 
 /*
@@ -2085,7 +2085,7 @@ Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
         if (len) {
             const char * const sstr = attrstr;
             for (; !isSPACE(*attrstr) && len; --len, ++attrstr) ;
-            attrs = append_elem(OP_LIST, attrs,
+            attrs = op_append_elem(OP_LIST, attrs,
                                 newSVOP(OP_CONST, 0,
                                         newSVpvn(sstr, attrstr-sstr)));
         }
@@ -2093,9 +2093,9 @@ Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
 
     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
                     newSVpvs(ATTRSMODULE),
-                     NULL, prepend_elem(OP_LIST,
+                     NULL, op_prepend_elem(OP_LIST,
                                  newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
-                                 prepend_elem(OP_LIST,
+                                 op_prepend_elem(OP_LIST,
                                               newSVOP(OP_CONST, 0,
                                                       newRV(MUTABLE_SV(cv))),
                                                attrs)));
@@ -2206,11 +2206,11 @@ Perl_my_attrs(pTHX_ OP *o, OP *attrs)
     o = my_kid(o, attrs, &rops);
     if (rops) {
        if (maybe_scalar && o->op_type == OP_PADSV) {
-           o = scalar(append_list(OP_LIST, (LISTOP*)rops, (LISTOP*)o));
+           o = scalar(op_append_list(OP_LIST, rops, o));
            o->op_private |= OPpLVAL_INTRO;
        }
        else
-           o = append_list(OP_LIST, (LISTOP*)o, (LISTOP*)rops);
+           o = op_append_list(OP_LIST, o, rops);
     }
     PL_parser->in_my = FALSE;
     PL_parser->in_my_stash = NULL;
@@ -2284,7 +2284,7 @@ Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
        if (right->op_type == OP_TRANS)
            o = newBINOP(OP_NULL, OPf_STACKED, scalar(newleft), right);
        else
-           o = prepend_elem(rtype, scalar(newleft), right);
+           o = op_prepend_elem(rtype, scalar(newleft), right);
        if (type == OP_NOT)
            return newUNOP(OP_NOT, 0, scalar(o));
        return o;
@@ -2308,7 +2308,7 @@ Perl_scope(pTHX_ OP *o)
     dVAR;
     if (o) {
        if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || PL_tainting) {
-           o = prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
+           o = op_prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
            o->op_type = OP_LEAVE;
            o->op_ppaddr = PL_ppaddr[OP_LEAVE];
        }
@@ -2523,7 +2523,7 @@ Perl_jmaybe(pTHX_ OP *o)
     if (o->op_type == OP_LIST) {
        OP * const o2
            = newSVREF(newGVOP(OP_GV, 0, gv_fetchpvs(";", GV_ADD|GV_NOTQUAL, SVt_PV)));
-       o = convert(OP_JOIN, 0, prepend_elem(OP_LIST, o2, o));
+       o = convert(OP_JOIN, 0, op_prepend_elem(OP_LIST, o2, o));
     }
     return o;
 }
@@ -2730,10 +2730,27 @@ Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
     return fold_constants(o);
 }
 
+/*
+=head1 Optree Manipulation Functions
+*/
+
 /* List constructors */
 
+/*
+=for apidoc Am|OP *|op_append_elem|I32 optype|OP *first|OP *last
+
+Append an item to the list of ops contained directly within a list-type
+op, returning the lengthened list.  I<first> is the list-type op,
+and I<last> is the op to append to the list.  I<optype> specifies the
+intended opcode for the list.  If I<first> is not already a list of the
+right type, it will be upgraded into one.  If either I<first> or I<last>
+is null, the other is returned unchanged.
+
+=cut
+*/
+
 OP *
-Perl_append_elem(pTHX_ I32 type, OP *first, OP *last)
+Perl_op_append_elem(pTHX_ I32 type, OP *first, OP *last)
 {
     if (!first)
        return last;
@@ -2757,48 +2774,74 @@ Perl_append_elem(pTHX_ I32 type, OP *first, OP *last)
     return first;
 }
 
+/*
+=for apidoc Am|OP *|op_append_list|I32 optype|OP *first|OP *last
+
+Concatenate the lists of ops contained directly within two list-type ops,
+returning the combined list.  I<first> and I<last> are the list-type ops
+to concatenate.  I<optype> specifies the intended opcode for the list.
+If either I<first> or I<last> is not already a list of the right type,
+it will be upgraded into one.  If either I<first> or I<last> is null,
+the other is returned unchanged.
+
+=cut
+*/
+
 OP *
-Perl_append_list(pTHX_ I32 type, LISTOP *first, LISTOP *last)
+Perl_op_append_list(pTHX_ I32 type, OP *first, OP *last)
 {
     if (!first)
-       return (OP*)last;
+       return last;
 
     if (!last)
-       return (OP*)first;
+       return first;
 
     if (first->op_type != (unsigned)type)
-       return prepend_elem(type, (OP*)first, (OP*)last);
+       return op_prepend_elem(type, first, last);
 
     if (last->op_type != (unsigned)type)
-       return append_elem(type, (OP*)first, (OP*)last);
+       return op_append_elem(type, first, last);
 
-    first->op_last->op_sibling = last->op_first;
-    first->op_last = last->op_last;
+    ((LISTOP*)first)->op_last->op_sibling = ((LISTOP*)last)->op_first;
+    ((LISTOP*)first)->op_last = ((LISTOP*)last)->op_last;
     first->op_flags |= (last->op_flags & OPf_KIDS);
 
 #ifdef PERL_MAD
-    if (last->op_first && first->op_madprop) {
-       MADPROP *mp = last->op_first->op_madprop;
+    if (((LISTOP*)last)->op_first && first->op_madprop) {
+       MADPROP *mp = ((LISTOP*)last)->op_first->op_madprop;
        if (mp) {
            while (mp->mad_next)
                mp = mp->mad_next;
            mp->mad_next = first->op_madprop;
        }
        else {
-           last->op_first->op_madprop = first->op_madprop;
+           ((LISTOP*)last)->op_first->op_madprop = first->op_madprop;
        }
     }
     first->op_madprop = last->op_madprop;
     last->op_madprop = 0;
 #endif
 
-    S_op_destroy(aTHX_ (OP*)last);
+    S_op_destroy(aTHX_ last);
 
-    return (OP*)first;
+    return first;
 }
 
+/*
+=for apidoc Am|OP *|op_prepend_elem|I32 optype|OP *first|OP *last
+
+Prepend an item to the list of ops contained directly within a list-type
+op, returning the lengthened list.  I<first> is the op to prepend to the
+list, and I<last> is the list-type op.  I<optype> specifies the intended
+opcode for the list.  If I<last> is not already a list of the right type,
+it will be upgraded into one.  If either I<first> or I<last> is null,
+the other is returned unchanged.
+
+=cut
+*/
+
 OP *
-Perl_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
+Perl_op_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
 {
     if (!first)
        return last;
@@ -3824,7 +3867,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
            expr->op_next = (OP*)rcop;
        }
 
-       prepend_elem(o->op_type, scalar((OP*)rcop), o);
+       op_prepend_elem(o->op_type, scalar((OP*)rcop), o);
     }
 
     if (repl) {
@@ -3878,7 +3921,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
                     || RX_EXTFLAGS(PM_GETRE(pm)) & RXf_EVAL_SEEN)))
        {
            pm->op_pmflags |= PMf_CONST;        /* const for long enough */
-           prepend_elem(o->op_type, scalar(repl), o);
+           op_prepend_elem(o->op_type, scalar(repl), o);
        }
        else {
            if (curop == repl && !PM_GETRE(pm)) { /* Has variables. */
@@ -4148,8 +4191,8 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
            /* Fake up a method call to VERSION */
            meth = newSVpvs_share("VERSION");
            veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
-                           append_elem(OP_LIST,
-                                       prepend_elem(OP_LIST, pack, list(version)),
+                           op_append_elem(OP_LIST,
+                                       op_prepend_elem(OP_LIST, pack, list(version)),
                                        newSVOP(OP_METHOD_NAMED, 0, meth)));
        }
     }
@@ -4178,8 +4221,8 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
        meth = aver
            ? newSVpvs_share("import") : newSVpvs_share("unimport");
        imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
-                      append_elem(OP_LIST,
-                                  prepend_elem(OP_LIST, pack, list(arg)),
+                      op_append_elem(OP_LIST,
+                                  op_prepend_elem(OP_LIST, pack, list(arg)),
                                   newSVOP(OP_METHOD_NAMED, 0, meth)));
     }
 
@@ -4188,8 +4231,8 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
        newSVOP(OP_CONST, 0, newSVpvs_share("BEGIN")),
        NULL,
        NULL,
-       append_elem(OP_LINESEQ,
-           append_elem(OP_LINESEQ,
+       op_append_elem(OP_LINESEQ,
+           op_append_elem(OP_LINESEQ,
                newSTATEOP(0, NULL, newUNOP(OP_REQUIRE, 0, idop)),
                newSTATEOP(0, NULL, veop)),
            newSTATEOP(0, NULL, imop) ));
@@ -4297,7 +4340,7 @@ Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
        imop = NULL;
        sv = va_arg(*args, SV*);
        while (sv) {
-           imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
+           imop = op_append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
            sv = va_arg(*args, SV*);
        }
     }
@@ -4335,7 +4378,7 @@ Perl_dofile(pTHX_ OP *term, I32 force_builtin)
 
     if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) {
        doop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
-                              append_elem(OP_LIST, term,
+                              op_append_elem(OP_LIST, term,
                                           scalar(newUNOP(OP_RV2CV, 0,
                                                          newGVOP(OP_GV, 0, gv))))));
     }
@@ -4775,7 +4818,7 @@ Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o)
 
     if (flags & OPf_SPECIAL)
        op_null((OP*)cop);
-    return prepend_elem(OP_LINESEQ, (OP*)cop, o);
+    return op_prepend_elem(OP_LINESEQ, (OP*)cop, o);
 }
 
 /*
@@ -5216,11 +5259,11 @@ Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
        }
     }
 
-    /* if block is null, the next append_elem() would put UNSTACK, a scalar
+    /* if block is null, the next op_append_elem() would put UNSTACK, a scalar
      * op, in listop. This is wrong. [perl #27024] */
     if (!block)
        block = newOP(OP_NULL, 0);
-    listop = append_elem(OP_LINESEQ, block, newOP(OP_UNSTACK, 0));
+    listop = op_append_elem(OP_LINESEQ, block, newOP(OP_UNSTACK, 0));
     o = new_logop(OP_AND, 0, &expr, &listop);
 
     if (listop)
@@ -5318,11 +5361,11 @@ whileline, OP *expr, OP *block, OP *cont, I32 has_my)
        OP * const unstack = newOP(OP_UNSTACK, 0);
        if (!next)
            next = unstack;
-       cont = append_elem(OP_LINESEQ, cont, unstack);
+       cont = op_append_elem(OP_LINESEQ, cont, unstack);
     }
 
     assert(block);
-    listop = append_list(OP_LINESEQ, (LISTOP*)block, (LISTOP*)cont);
+    listop = op_append_list(OP_LINESEQ, block, cont);
     assert(listop);
     redo = LINKLIST(listop);
 
@@ -5495,7 +5538,7 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
     }
 
     loop = (LOOP*)list(convert(OP_ENTERITER, iterflags,
-                              append_elem(OP_LIST, expr, scalar(sv))));
+                              op_append_elem(OP_LIST, expr, scalar(sv))));
     assert(!loop->op_next);
     /* for my  $x () sets OPpLVAL_INTRO;
      * for our $x () sets OPpOUR_INTRO */
@@ -5788,7 +5831,7 @@ Perl_newWHENOP(pTHX_ OP *cond, OP *block)
     
     return newGIVWHENOP(
        cond_op,
-       append_elem(block->op_type, block, newOP(OP_BREAK, OPf_SPECIAL)),
+       op_append_elem(block->op_type, block, newOP(OP_BREAK, OPf_SPECIAL)),
        OP_ENTERWHEN, OP_LEAVEWHEN, 0);
 }
 
@@ -7032,7 +7075,7 @@ Perl_ck_eval(pTHX_ OP *o)
            /* establish postfix order */
            enter->op_next = (OP*)enter;
 
-           o = prepend_elem(OP_LINESEQ, (OP*)enter, (OP*)kid);
+           o = op_prepend_elem(OP_LINESEQ, (OP*)enter, (OP*)kid);
            o->op_type = OP_LEAVETRY;
            o->op_ppaddr = PL_ppaddr[OP_LEAVETRY];
            enter->op_other = o;
@@ -7565,7 +7608,7 @@ Perl_ck_glob(pTHX_ OP *o)
 
     o = ck_fun(o);
     if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
-       append_elem(OP_GLOB, o, newDEFSVOP());
+       op_append_elem(OP_GLOB, o, newDEFSVOP());
 
     if (!((gv = gv_fetchpvs("glob", GV_NOTQUAL, SVt_PVCV))
          && GvCVu(gv) && GvIMPORTED_CV(gv)))
@@ -7591,7 +7634,7 @@ Perl_ck_glob(pTHX_ OP *o)
 #endif /* PERL_EXTERNAL_GLOB */
 
     if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) {
-       append_elem(OP_GLOB, o,
+       op_append_elem(OP_GLOB, o,
                    newSVOP(OP_CONST, 0, newSViv(PL_glob_index++)));
        o->op_type = OP_LIST;
        o->op_ppaddr = PL_ppaddr[OP_LIST];
@@ -7599,7 +7642,7 @@ Perl_ck_glob(pTHX_ OP *o)
        cLISTOPo->op_first->op_ppaddr = PL_ppaddr[OP_PUSHMARK];
        cLISTOPo->op_first->op_targ = 0;
        o = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                   append_elem(OP_LIST, o,
+                   op_append_elem(OP_LIST, o,
                                scalar(newUNOP(OP_RV2CV, 0,
                                               newGVOP(OP_GV, 0, gv)))));
        o = newUNOP(OP_NULL, 0, ck_subr(o));
@@ -7608,7 +7651,7 @@ Perl_ck_glob(pTHX_ OP *o)
     }
     gv = newGVgen("main");
     gv_IOadd(gv);
-    append_elem(OP_GLOB, o, newGVOP(OP_GV, 0, gv));
+    op_append_elem(OP_GLOB, o, newGVOP(OP_GV, 0, gv));
     scalarkids(o);
     return o;
 }
@@ -7795,7 +7838,7 @@ Perl_ck_listiob(pTHX_ OP *o)
     }
 
     if (!kid)
-       append_elem(o->op_type, o, newDEFSVOP());
+       op_append_elem(o->op_type, o, newDEFSVOP());
 
     return listkids(o);
 }
@@ -8093,7 +8136,7 @@ Perl_ck_require(pTHX_ OP *o)
        op_free(o);
 #endif
        newop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST, kid,
+                               op_append_elem(OP_LIST, kid,
                                            scalar(newUNOP(OP_RV2CV, 0,
                                                           newGVOP(OP_GV, 0,
                                                                   gv))))));
@@ -8388,13 +8431,13 @@ Perl_ck_split(pTHX_ OP *o)
     }
 
     if (!kid->op_sibling)
-       append_elem(OP_SPLIT, o, newDEFSVOP());
+       op_append_elem(OP_SPLIT, o, newDEFSVOP());
 
     kid = kid->op_sibling;
     scalar(kid);
 
     if (!kid->op_sibling)
-       append_elem(OP_SPLIT, o, newSVOP(OP_CONST, 0, newSViv(0)));
+       op_append_elem(OP_SPLIT, o, newSVOP(OP_CONST, 0, newSViv(0)));
     assert(kid->op_sibling);
 
     kid = kid->op_sibling;
index 7da32fb..3401882 100644 (file)
--- a/perly.act
+++ b/perly.act
@@ -103,17 +103,13 @@ case 2:
   case 16:
 #line 228 "perly.y"
     {
-                       (yyval.opval) = IF_MAD(
-                               append_list(OP_LINESEQ,
-                                   (LISTOP*)(ps[(1) - (2)].val.opval), (LISTOP*)(ps[(2) - (2)].val.opval)),
-                               (ps[(1) - (2)].val.opval));
+                         (yyval.opval) = IF_MAD(op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval)), (ps[(1) - (2)].val.opval));
                        ;}
     break;
 
   case 17:
-#line 235 "perly.y"
-    {   (yyval.opval) = append_list(OP_LINESEQ,
-                               (LISTOP*)(ps[(1) - (2)].val.opval), (LISTOP*)(ps[(2) - (2)].val.opval));
+#line 232 "perly.y"
+    {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
                            PL_pad_reset_pending = TRUE;
                            if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
                                PL_hints |= HINT_BLOCK_SCOPE;
@@ -121,12 +117,12 @@ case 2:
     break;
 
   case 18:
-#line 245 "perly.y"
+#line 241 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 19:
-#line 247 "perly.y"
+#line 243 "perly.y"
     {
                          PL_pad_reset_pending = TRUE;
                          (yyval.opval) = (ps[(1) - (1)].val.opval);
@@ -134,23 +130,23 @@ case 2:
     break;
 
   case 20:
-#line 255 "perly.y"
+#line 251 "perly.y"
     { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.p_tkval),((LISTOP*)(yyval.opval))->op_first,'L'); ;}
     break;
 
   case 22:
-#line 259 "perly.y"
+#line 255 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 23:
-#line 261 "perly.y"
+#line 257 "perly.y"
     { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 24:
-#line 263 "perly.y"
+#line 259 "perly.y"
     {
                          if (PVAL((ps[(1) - (2)].val.p_tkval))) {
                              (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), newOP(OP_NULL, 0));
@@ -170,7 +166,7 @@ case 2:
     break;
 
   case 25:
-#line 280 "perly.y"
+#line 276 "perly.y"
     {
                          (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (3)].val.p_tkval)), (ps[(2) - (3)].val.opval));
                          PL_parser->expect = XSTATE;
@@ -189,7 +185,7 @@ case 2:
     break;
 
   case 26:
-#line 296 "perly.y"
+#line 292 "perly.y"
     { (yyval.opval) = newSTATEOP(0, NULL,
                                 newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
                                            NOLINE, (OP*)NULL, (ps[(1) - (1)].val.opval),
@@ -197,50 +193,50 @@ case 2:
     break;
 
   case 27:
-#line 301 "perly.y"
+#line 297 "perly.y"
     { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (2)].val.p_tkval)), (ps[(2) - (2)].val.opval)); ;}
     break;
 
   case 28:
-#line 306 "perly.y"
+#line 302 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 29:
-#line 308 "perly.y"
+#line 304 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 30:
-#line 310 "perly.y"
+#line 306 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
                        ;}
     break;
 
   case 31:
-#line 314 "perly.y"
+#line 310 "perly.y"
     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
                        ;}
     break;
 
   case 32:
-#line 318 "perly.y"
+#line 314 "perly.y"
     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
                        ;}
     break;
 
   case 33:
-#line 322 "perly.y"
+#line 318 "perly.y"
     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
                        ;}
     break;
 
   case 34:
-#line 326 "perly.y"
+#line 322 "perly.y"
     { (yyval.opval) = newFOROP(0, NULL, (line_t)IVAL((ps[(2) - (3)].val.i_tkval)),
                                        (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),((LISTOP*)(yyval.opval))->op_first->op_sibling,'w');
@@ -248,24 +244,24 @@ case 2:
     break;
 
   case 35:
-#line 331 "perly.y"
+#line 327 "perly.y"
     { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), scope((ps[(1) - (3)].val.opval))); ;}
     break;
 
   case 36:
-#line 336 "perly.y"
+#line 332 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 37:
-#line 338 "perly.y"
+#line 334 "perly.y"
     { ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS; (yyval.opval) = scope((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 38:
-#line 342 "perly.y"
+#line 338 "perly.y"
     { PL_parser->copline = (line_t)IVAL((ps[(1) - (6)].val.i_tkval));
                            (yyval.opval) = newCONDOP(0, newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)), scope((ps[(5) - (6)].val.opval)), (ps[(6) - (6)].val.opval));
                            PL_hints |= HINT_BLOCK_SCOPE;
@@ -276,7 +272,7 @@ case 2:
     break;
 
   case 39:
-#line 353 "perly.y"
+#line 349 "perly.y"
     { PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
                            (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
                                   newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
@@ -287,7 +283,7 @@ case 2:
     break;
 
   case 40:
-#line 361 "perly.y"
+#line 357 "perly.y"
     { PL_parser->copline = (line_t)IVAL((ps[(1) - (7)].val.i_tkval));
                            (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
                                   newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
@@ -298,30 +294,30 @@ case 2:
     break;
 
   case 41:
-#line 372 "perly.y"
+#line 368 "perly.y"
     { (yyval.opval) = block_end((ps[(3) - (6)].val.ival),
                newWHENOP((ps[(4) - (6)].val.opval), scope((ps[(6) - (6)].val.opval)))); ;}
     break;
 
   case 42:
-#line 375 "perly.y"
+#line 371 "perly.y"
     { (yyval.opval) = newWHENOP(0, scope((ps[(2) - (2)].val.opval))); ;}
     break;
 
   case 43:
-#line 380 "perly.y"
+#line 376 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 44:
-#line 382 "perly.y"
+#line 378 "perly.y"
     { (yyval.opval) = scope((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 45:
-#line 389 "perly.y"
+#line 385 "perly.y"
     { OP *innerop;
                          PL_parser->copline = (line_t)IVAL((ps[(2) - (9)].val.i_tkval));
                            (yyval.opval) = block_end((ps[(4) - (9)].val.ival),
@@ -336,7 +332,7 @@ case 2:
     break;
 
   case 46:
-#line 402 "perly.y"
+#line 398 "perly.y"
     { OP *innerop;
                          PL_parser->copline = (line_t)IVAL((ps[(2) - (9)].val.i_tkval));
                            (yyval.opval) = block_end((ps[(4) - (9)].val.ival),
@@ -351,7 +347,7 @@ case 2:
     break;
 
   case 47:
-#line 414 "perly.y"
+#line 410 "perly.y"
     { OP *innerop;
                          (yyval.opval) = block_end((ps[(4) - (10)].val.ival),
                             innerop = newFOROP(0, PVAL((ps[(1) - (10)].val.p_tkval)), (line_t)IVAL((ps[(2) - (10)].val.i_tkval)),
@@ -365,7 +361,7 @@ case 2:
     break;
 
   case 48:
-#line 425 "perly.y"
+#line 421 "perly.y"
     { OP *innerop;
                          (yyval.opval) = block_end((ps[(5) - (9)].val.ival),
                             innerop = newFOROP(0, PVAL((ps[(1) - (9)].val.p_tkval)), (line_t)IVAL((ps[(2) - (9)].val.i_tkval)),
@@ -378,7 +374,7 @@ case 2:
     break;
 
   case 49:
-#line 435 "perly.y"
+#line 431 "perly.y"
     { OP *innerop;
                          (yyval.opval) = block_end((ps[(4) - (8)].val.ival),
                             innerop = newFOROP(0, PVAL((ps[(1) - (8)].val.p_tkval)), (line_t)IVAL((ps[(2) - (8)].val.i_tkval)),
@@ -391,7 +387,7 @@ case 2:
     break;
 
   case 50:
-#line 447 "perly.y"
+#line 443 "perly.y"
     { OP *forop;
                          PL_parser->copline = (line_t)IVAL((ps[(2) - (12)].val.i_tkval));
                          forop = newSTATEOP(0, PVAL((ps[(1) - (12)].val.p_tkval)),
@@ -399,7 +395,7 @@ case 2:
                                                IVAL((ps[(2) - (12)].val.i_tkval)), scalar((ps[(7) - (12)].val.opval)),
                                                (ps[(12) - (12)].val.opval), (ps[(10) - (12)].val.opval), (ps[(9) - (12)].val.ival)));
 #ifdef MAD
-                         forop = newUNOP(OP_NULL, 0, append_elem(OP_LINESEQ,
+                         forop = newUNOP(OP_NULL, 0, op_append_elem(OP_LINESEQ,
                                newSTATEOP(0,
                                           CopLABEL_alloc(((ps[(1) - (12)].val.p_tkval))->tk_lval.pval),
                                           ((ps[(5) - (12)].val.opval) ? (ps[(5) - (12)].val.opval) : newOP(OP_NULL, 0)) ),
@@ -413,7 +409,7 @@ case 2:
                          token_getmad((ps[(1) - (12)].val.p_tkval),forop,'L');
 #else
                          if ((ps[(5) - (12)].val.opval)) {
-                               forop = append_elem(OP_LINESEQ,
+                               forop = op_append_elem(OP_LINESEQ,
                                         newSTATEOP(0, CopLABEL_alloc((ps[(1) - (12)].val.p_tkval)), (ps[(5) - (12)].val.opval)),
                                        forop);
                          }
@@ -424,7 +420,7 @@ case 2:
     break;
 
   case 51:
-#line 477 "perly.y"
+#line 473 "perly.y"
     { (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (3)].val.p_tkval)),
                                 newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
                                            NOLINE, (OP*)NULL, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval), 0));
@@ -432,7 +428,7 @@ case 2:
     break;
 
   case 52:
-#line 485 "perly.y"
+#line 481 "perly.y"
     { PL_parser->copline = (line_t) IVAL((ps[(2) - (8)].val.i_tkval));
                            (yyval.opval) = block_end((ps[(4) - (8)].val.ival),
                                newSTATEOP(0, PVAL((ps[(1) - (8)].val.p_tkval)),
@@ -441,46 +437,46 @@ case 2:
     break;
 
   case 53:
-#line 494 "perly.y"
+#line 490 "perly.y"
     { (yyval.ival) = (PL_min_intro_pending &&
                            PL_max_intro_pending >=  PL_min_intro_pending);
                          intro_my(); ;}
     break;
 
   case 54:
-#line 500 "perly.y"
+#line 496 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 56:
-#line 506 "perly.y"
+#line 502 "perly.y"
     { YYSTYPE tmplval;
                          (void)scan_num("1", &tmplval);
                          (yyval.opval) = tmplval.opval; ;}
     break;
 
   case 58:
-#line 514 "perly.y"
+#line 510 "perly.y"
     { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 59:
-#line 519 "perly.y"
+#line 515 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 60:
-#line 523 "perly.y"
+#line 519 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 61:
-#line 527 "perly.y"
+#line 523 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 62:
-#line 532 "perly.y"
+#line 528 "perly.y"
     {
 #ifdef MAD
                          YYSTYPE tmplval;
@@ -493,44 +489,44 @@ case 2:
     break;
 
   case 64:
-#line 546 "perly.y"
+#line 542 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 65:
-#line 548 "perly.y"
+#line 544 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 66:
-#line 550 "perly.y"
+#line 546 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 67:
-#line 552 "perly.y"
+#line 548 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 68:
-#line 554 "perly.y"
+#line 550 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 69:
-#line 559 "perly.y"
+#line 555 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 70:
-#line 563 "perly.y"
+#line 559 "perly.y"
     { (yyval.opval) = newOP(OP_NULL,0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'p');
                        ;}
     break;
 
   case 71:
-#line 569 "perly.y"
+#line 565 "perly.y"
     {
                          CV *fmtcv = PL_compcv;
                          SvREFCNT_inc_simple_void(PL_compcv);
@@ -551,17 +547,17 @@ case 2:
     break;
 
   case 72:
-#line 588 "perly.y"
+#line 584 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 73:
-#line 589 "perly.y"
+#line 585 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 74:
-#line 594 "perly.y"
+#line 590 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
 #ifdef MAD
                          (yyval.opval) = newMYSUB((ps[(2) - (6)].val.ival), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval), (ps[(6) - (6)].val.opval));
@@ -574,7 +570,7 @@ case 2:
     break;
 
   case 75:
-#line 607 "perly.y"
+#line 603 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
 #ifdef MAD
                          {
@@ -597,25 +593,25 @@ case 2:
     break;
 
   case 76:
-#line 629 "perly.y"
+#line 625 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 77:
-#line 635 "perly.y"
+#line 631 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 78:
-#line 640 "perly.y"
+#line 636 "perly.y"
     { (yyval.ival) = start_subparse(TRUE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 79:
-#line 645 "perly.y"
+#line 641 "perly.y"
     { const char *const name = SvPV_nolen_const(((SVOP*)(ps[(1) - (1)].val.opval))->op_sv);
                          if (strEQ(name, "BEGIN") || strEQ(name, "END")
                              || strEQ(name, "INIT") || strEQ(name, "CHECK")
@@ -625,24 +621,24 @@ case 2:
     break;
 
   case 80:
-#line 655 "perly.y"
+#line 651 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 82:
-#line 661 "perly.y"
+#line 657 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 83:
-#line 663 "perly.y"
+#line 659 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
                        ;}
     break;
 
   case 84:
-#line 667 "perly.y"
+#line 663 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL, 0),
                                    (OP*)NULL
@@ -652,14 +648,14 @@ case 2:
     break;
 
   case 85:
-#line 677 "perly.y"
+#line 673 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
                        ;}
     break;
 
   case 86:
-#line 681 "perly.y"
+#line 677 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL, 0),
                                    (OP*)NULL
@@ -669,12 +665,12 @@ case 2:
     break;
 
   case 87:
-#line 690 "perly.y"
+#line 686 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 88:
-#line 691 "perly.y"
+#line 687 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL,0),
                                    (OP*)NULL
@@ -685,7 +681,7 @@ case 2:
     break;
 
   case 89:
-#line 701 "perly.y"
+#line 697 "perly.y"
     {
 #ifdef MAD
                          (yyval.opval) = package((ps[(3) - (4)].val.opval));
@@ -703,7 +699,7 @@ case 2:
     break;
 
   case 90:
-#line 718 "perly.y"
+#line 714 "perly.y"
     {
                          int save_3_latefree = (ps[(3) - (5)].val.opval)->op_latefree;
                          (ps[(3) - (5)].val.opval)->op_latefree = 1;
@@ -719,7 +715,7 @@ case 2:
     break;
 
   case 91:
-#line 731 "perly.y"
+#line 727 "perly.y"
     { if (PL_parser->copline > (line_t)IVAL((ps[(4) - (8)].val.i_tkval)))
                              PL_parser->copline = (line_t)IVAL((ps[(4) - (8)].val.i_tkval));
                          (yyval.opval) = block_end((ps[(5) - (8)].val.ival), (ps[(7) - (8)].val.opval));
@@ -732,12 +728,12 @@ case 2:
     break;
 
   case 92:
-#line 743 "perly.y"
+#line 739 "perly.y"
     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
     break;
 
   case 93:
-#line 745 "perly.y"
+#line 741 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
 #ifdef MAD
                          (yyval.opval) = utilize(IVAL((ps[(1) - (7)].val.i_tkval)), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
@@ -754,33 +750,33 @@ case 2:
     break;
 
   case 94:
-#line 762 "perly.y"
+#line 758 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 95:
-#line 766 "perly.y"
+#line 762 "perly.y"
     { (yyval.opval) = newLOGOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 96:
-#line 770 "perly.y"
+#line 766 "perly.y"
     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 98:
-#line 778 "perly.y"
+#line 774 "perly.y"
     {
 #ifdef MAD
                          OP* op = newNULLLIST();
                          token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
-                         (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
+                         (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
 #else
                          (yyval.opval) = (ps[(1) - (2)].val.opval);
 #endif
@@ -788,29 +784,29 @@ case 2:
     break;
 
   case 99:
-#line 788 "perly.y"
+#line 784 "perly.y"
     { 
                          OP* term = (ps[(3) - (3)].val.opval);
                          DO_MAD(
                              term = newUNOP(OP_NULL, 0, term);
                              token_getmad((ps[(2) - (3)].val.i_tkval),term,',');
                          )
-                         (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
+                         (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
                        ;}
     break;
 
   case 101:
-#line 801 "perly.y"
+#line 797 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_STACKED,
-                               prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (3)].val.i_tkval)),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
+                               op_prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (3)].val.i_tkval)),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 102:
-#line 806 "perly.y"
+#line 802 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (5)].val.i_tkval)), OPf_STACKED,
-                               prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (5)].val.i_tkval)),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
+                               op_prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (5)].val.i_tkval)),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
@@ -818,10 +814,10 @@ case 2:
     break;
 
   case 103:
-#line 813 "perly.y"
+#line 809 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST,
-                                   prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
+                               op_append_elem(OP_LIST,
+                                   op_prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
                                    newUNOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
                          TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'A');
                          TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'(');
@@ -830,28 +826,28 @@ case 2:
     break;
 
   case 104:
-#line 822 "perly.y"
+#line 818 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
+                               op_append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
                                    newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'A');
                        ;}
     break;
 
   case 105:
-#line 828 "perly.y"
+#line 824 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST,
-                                   prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
+                               op_append_elem(OP_LIST,
+                                   op_prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
                                    newUNOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
                        ;}
     break;
 
   case 106:
-#line 834 "perly.y"
+#line 830 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST,
-                                   prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
+                               op_append_elem(OP_LIST,
+                                   op_prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
                                    newUNOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
                          TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
@@ -859,14 +855,14 @@ case 2:
     break;
 
   case 107:
-#line 842 "perly.y"
+#line 838 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 108:
-#line 846 "perly.y"
+#line 842 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
@@ -875,21 +871,21 @@ case 2:
     break;
 
   case 109:
-#line 852 "perly.y"
+#line 848 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
                          (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 110:
-#line 855 "perly.y"
+#line 851 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                                append_elem(OP_LIST,
-                                  prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
+                                op_append_elem(OP_LIST,
+                                  op_prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
                        ;}
     break;
 
   case 113:
-#line 870 "perly.y"
+#line 866 "perly.y"
     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)));
                            PL_parser->expect = XOPERATOR;
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
@@ -899,7 +895,7 @@ case 2:
     break;
 
   case 114:
-#line 877 "perly.y"
+#line 873 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
@@ -907,7 +903,7 @@ case 2:
     break;
 
   case 115:
-#line 882 "perly.y"
+#line 878 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
                                        scalar((ps[(4) - (5)].val.opval)));
@@ -918,7 +914,7 @@ case 2:
     break;
 
   case 116:
-#line 890 "perly.y"
+#line 886 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
                                        scalar((ps[(3) - (4)].val.opval)));
@@ -928,7 +924,7 @@ case 2:
     break;
 
   case 117:
-#line 897 "perly.y"
+#line 893 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
                            PL_parser->expect = XOPERATOR;
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
@@ -938,7 +934,7 @@ case 2:
     break;
 
   case 118:
-#line 904 "perly.y"
+#line 900 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(4) - (6)].val.opval)));
@@ -951,7 +947,7 @@ case 2:
     break;
 
   case 119:
-#line 914 "perly.y"
+#line 910 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(3) - (5)].val.opval)));
@@ -963,7 +959,7 @@ case 2:
     break;
 
   case 120:
-#line 923 "perly.y"
+#line 919 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   newCVREF(0, scalar((ps[(1) - (4)].val.opval))));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'a');
@@ -973,9 +969,9 @@ case 2:
     break;
 
   case 121:
-#line 930 "perly.y"
+#line 926 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                                  append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
+                                  op_append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
                                       newCVREF(0, scalar((ps[(1) - (5)].val.opval)))));
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
                          TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
@@ -984,9 +980,9 @@ case 2:
     break;
 
   case 122:
-#line 939 "perly.y"
+#line 935 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                                  append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
+                                  op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
                                               newCVREF(0, scalar((ps[(1) - (4)].val.opval)))));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
@@ -994,7 +990,7 @@ case 2:
     break;
 
   case 123:
-#line 946 "perly.y"
+#line 942 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   newCVREF(0, scalar((ps[(1) - (3)].val.opval))));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
@@ -1003,7 +999,7 @@ case 2:
     break;
 
   case 124:
-#line 952 "perly.y"
+#line 948 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),')');
@@ -1013,7 +1009,7 @@ case 2:
     break;
 
   case 125:
-#line 959 "perly.y"
+#line 955 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
@@ -1021,7 +1017,7 @@ case 2:
     break;
 
   case 126:
-#line 964 "perly.y"
+#line 960 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL);
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),')');
@@ -1031,21 +1027,21 @@ case 2:
     break;
 
   case 127:
-#line 974 "perly.y"
+#line 970 "perly.y"
     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 128:
-#line 978 "perly.y"
+#line 974 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 129:
-#line 982 "perly.y"
+#line 978 "perly.y"
     {   if (IVAL((ps[(2) - (3)].val.i_tkval)) != OP_REPEAT)
                                scalar((ps[(1) - (3)].val.opval));
                            (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
@@ -1054,49 +1050,49 @@ case 2:
     break;
 
   case 130:
-#line 988 "perly.y"
+#line 984 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 131:
-#line 992 "perly.y"
+#line 988 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 132:
-#line 996 "perly.y"
+#line 992 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 133:
-#line 1000 "perly.y"
+#line 996 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 134:
-#line 1004 "perly.y"
+#line 1000 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 135:
-#line 1008 "perly.y"
+#line 1004 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 136:
-#line 1012 "perly.y"
+#line 1008 "perly.y"
     {
                          (yyval.opval) = newRANGE(IVAL((ps[(2) - (3)].val.i_tkval)), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          DO_MAD({
@@ -1111,28 +1107,28 @@ case 2:
     break;
 
   case 137:
-#line 1024 "perly.y"
+#line 1020 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 138:
-#line 1028 "perly.y"
+#line 1024 "perly.y"
     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 139:
-#line 1032 "perly.y"
+#line 1028 "perly.y"
     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 140:
-#line 1036 "perly.y"
+#line 1032 "perly.y"
     { (yyval.opval) = bind_match(IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),
                                ((yyval.opval)->op_type == OP_NOT
@@ -1142,14 +1138,14 @@ case 2:
     break;
 
   case 141:
-#line 1046 "perly.y"
+#line 1042 "perly.y"
     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 142:
-#line 1050 "perly.y"
+#line 1046 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newUNOP(OP_NULL, 0, (ps[(2) - (2)].val.opval)),
                                    (ps[(2) - (2)].val.opval)
@@ -1159,21 +1155,21 @@ case 2:
     break;
 
   case 143:
-#line 1057 "perly.y"
+#line 1053 "perly.y"
     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 144:
-#line 1061 "perly.y"
+#line 1057 "perly.y"
     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 145:
-#line 1065 "perly.y"
+#line 1061 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
                                        mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC));
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1181,7 +1177,7 @@ case 2:
     break;
 
   case 146:
-#line 1070 "perly.y"
+#line 1066 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
                                        mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1189,7 +1185,7 @@ case 2:
     break;
 
   case 147:
-#line 1075 "perly.y"
+#line 1071 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREINC, 0,
                                        mod(scalar((ps[(2) - (2)].val.opval)), OP_PREINC));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1197,7 +1193,7 @@ case 2:
     break;
 
   case 148:
-#line 1080 "perly.y"
+#line 1076 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
                                        mod(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1205,7 +1201,7 @@ case 2:
     break;
 
   case 149:
-#line 1089 "perly.y"
+#line 1085 "perly.y"
     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');
@@ -1213,7 +1209,7 @@ case 2:
     break;
 
   case 150:
-#line 1094 "perly.y"
+#line 1090 "perly.y"
     { (yyval.opval) = newANONLIST((OP*)NULL);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),']');
@@ -1221,7 +1217,7 @@ case 2:
     break;
 
   case 151:
-#line 1099 "perly.y"
+#line 1095 "perly.y"
     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
                          TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),';');
@@ -1230,7 +1226,7 @@ case 2:
     break;
 
   case 152:
-#line 1105 "perly.y"
+#line 1101 "perly.y"
     { (yyval.opval) = newANONHASH((OP*)NULL);
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'{');
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),';');
@@ -1239,7 +1235,7 @@ case 2:
     break;
 
   case 153:
-#line 1111 "perly.y"
+#line 1107 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
                          (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
@@ -1249,24 +1245,24 @@ case 2:
     break;
 
   case 154:
-#line 1122 "perly.y"
+#line 1118 "perly.y"
     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), IVAL((ps[(1) - (2)].val.i_tkval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 155:
-#line 1126 "perly.y"
+#line 1122 "perly.y"
     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, scope((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'D');
                        ;}
     break;
 
   case 156:
-#line 1130 "perly.y"
+#line 1126 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
-                           prepend_elem(OP_LIST,
+                           op_prepend_elem(OP_LIST,
                                scalar(newCVREF(
                                    (OPpENTERSUB_AMPER<<8),
                                    scalar((ps[(2) - (4)].val.opval))
@@ -1278,10 +1274,10 @@ case 2:
     break;
 
   case 157:
-#line 1142 "perly.y"
+#line 1138 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
-                           append_elem(OP_LIST,
+                           op_append_elem(OP_LIST,
                                (ps[(4) - (5)].val.opval),
                                scalar(newCVREF(
                                    (OPpENTERSUB_AMPER<<8),
@@ -1294,9 +1290,9 @@ case 2:
     break;
 
   case 158:
-#line 1155 "perly.y"
+#line 1151 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
-                           prepend_elem(OP_LIST,
+                           op_prepend_elem(OP_LIST,
                                scalar(newCVREF(0,scalar((ps[(2) - (4)].val.opval)))), (OP*)NULL)); dep();
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
@@ -1305,9 +1301,9 @@ case 2:
     break;
 
   case 159:
-#line 1163 "perly.y"
+#line 1159 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
-                           prepend_elem(OP_LIST,
+                           op_prepend_elem(OP_LIST,
                                (ps[(4) - (5)].val.opval),
                                scalar(newCVREF(0,scalar((ps[(2) - (5)].val.opval)))))); dep();
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
@@ -1317,7 +1313,7 @@ case 2:
     break;
 
   case 164:
-#line 1179 "perly.y"
+#line 1175 "perly.y"
     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'?');
                          TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),':');
@@ -1325,26 +1321,26 @@ case 2:
     break;
 
   case 165:
-#line 1184 "perly.y"
+#line 1180 "perly.y"
     { (yyval.opval) = newUNOP(OP_REFGEN, 0, mod((ps[(2) - (2)].val.opval),OP_REFGEN));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 166:
-#line 1188 "perly.y"
+#line 1184 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 167:
-#line 1190 "perly.y"
+#line 1186 "perly.y"
     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'k');
                        ;}
     break;
 
   case 168:
-#line 1194 "perly.y"
+#line 1190 "perly.y"
     { (yyval.opval) = sawparens(IF_MAD(newUNOP(OP_NULL,0,(ps[(2) - (3)].val.opval)), (ps[(2) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1352,12 +1348,12 @@ case 2:
     break;
 
   case 169:
-#line 1199 "perly.y"
+#line 1195 "perly.y"
     { (yyval.opval) = IF_MAD(newUNOP(OP_NULL,0,(ps[(1) - (1)].val.opval)), (ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 170:
-#line 1201 "perly.y"
+#line 1197 "perly.y"
     { (yyval.opval) = sawparens(newNULLLIST());
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
@@ -1365,38 +1361,38 @@ case 2:
     break;
 
   case 171:
-#line 1206 "perly.y"
+#line 1202 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 172:
-#line 1208 "perly.y"
+#line 1204 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 173:
-#line 1210 "perly.y"
+#line 1206 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 174:
-#line 1212 "perly.y"
+#line 1208 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 175:
-#line 1214 "perly.y"
+#line 1210 "perly.y"
     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
     break;
 
   case 176:
-#line 1216 "perly.y"
+#line 1212 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 177:
-#line 1218 "perly.y"
-    { (yyval.opval) = prepend_elem(OP_ASLICE,
+#line 1214 "perly.y"
+    { (yyval.opval) = op_prepend_elem(OP_ASLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_ASLICE, 0,
                                        list((ps[(3) - (4)].val.opval)),
@@ -1407,8 +1403,8 @@ case 2:
     break;
 
   case 178:
-#line 1227 "perly.y"
-    { (yyval.opval) = prepend_elem(OP_HSLICE,
+#line 1223 "perly.y"
+    { (yyval.opval) = op_prepend_elem(OP_HSLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_HSLICE, 0,
                                        list((ps[(3) - (5)].val.opval)),
@@ -1421,17 +1417,17 @@ case 2:
     break;
 
   case 179:
-#line 1238 "perly.y"
+#line 1234 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 180:
-#line 1240 "perly.y"
+#line 1236 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 181:
-#line 1242 "perly.y"
+#line 1238 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1439,10 +1435,10 @@ case 2:
     break;
 
   case 182:
-#line 1247 "perly.y"
+#line 1243 "perly.y"
     {
                          (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
+                               op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
                          DO_MAD({
                              OP* op = (yyval.opval);
                              if (op->op_type == OP_CONST) { /* defeat const fold */
@@ -1455,15 +1451,15 @@ case 2:
     break;
 
   case 183:
-#line 1260 "perly.y"
+#line 1256 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                           append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
+                           op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 184:
-#line 1265 "perly.y"
+#line 1261 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), OPf_SPECIAL);
                            PL_hints |= HINT_BLOCK_SCOPE;
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
@@ -1471,74 +1467,74 @@ case 2:
     break;
 
   case 185:
-#line 1270 "perly.y"
+#line 1266 "perly.y"
     { (yyval.opval) = newLOOPEX(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 186:
-#line 1274 "perly.y"
+#line 1270 "perly.y"
     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 187:
-#line 1278 "perly.y"
+#line 1274 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 188:
-#line 1282 "perly.y"
+#line 1278 "perly.y"
     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 189:
-#line 1286 "perly.y"
+#line 1282 "perly.y"
     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 190:
-#line 1290 "perly.y"
+#line 1286 "perly.y"
     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.i_tkval) ? OPf_SPECIAL : 0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 191:
-#line 1294 "perly.y"
+#line 1290 "perly.y"
     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.i_tkval) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 192:
-#line 1298 "perly.y"
+#line 1294 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 193:
-#line 1300 "perly.y"
+#line 1296 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                           append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
+                           op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
     break;
 
   case 194:
-#line 1303 "perly.y"
+#line 1299 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 195:
-#line 1307 "perly.y"
+#line 1303 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0);
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
@@ -1547,13 +1543,13 @@ case 2:
     break;
 
   case 196:
-#line 1313 "perly.y"
+#line 1309 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 197:
-#line 1316 "perly.y"
+#line 1312 "perly.y"
     { (yyval.opval) = (IVAL((ps[(1) - (3)].val.i_tkval)) == OP_NOT)
                            ? newUNOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, newSVOP(OP_CONST, 0, newSViv(0)))
                            : newOP(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_SPECIAL);
@@ -1565,7 +1561,7 @@ case 2:
     break;
 
   case 198:
-#line 1325 "perly.y"
+#line 1321 "perly.y"
     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
@@ -1574,7 +1570,7 @@ case 2:
     break;
 
   case 199:
-#line 1331 "perly.y"
+#line 1327 "perly.y"
     { (yyval.opval) = pmruntime((ps[(1) - (4)].val.opval), (ps[(3) - (4)].val.opval), 1);
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
@@ -1582,7 +1578,7 @@ case 2:
     break;
 
   case 202:
-#line 1338 "perly.y"
+#line 1334 "perly.y"
     {
                          (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
                                newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
@@ -1591,7 +1587,7 @@ case 2:
     break;
 
   case 204:
-#line 1348 "perly.y"
+#line 1344 "perly.y"
     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval));
                          DO_MAD(
                              token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'d');
@@ -1602,14 +1598,14 @@ case 2:
     break;
 
   case 205:
-#line 1356 "perly.y"
+#line 1352 "perly.y"
     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
                        ;}
     break;
 
   case 206:
-#line 1363 "perly.y"
+#line 1359 "perly.y"
     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1617,7 +1613,7 @@ case 2:
     break;
 
   case 207:
-#line 1368 "perly.y"
+#line 1364 "perly.y"
     { (yyval.opval) = sawparens(newNULLLIST());
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
@@ -1625,119 +1621,119 @@ case 2:
     break;
 
   case 208:
-#line 1373 "perly.y"
+#line 1369 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 209:
-#line 1375 "perly.y"
+#line 1371 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 210:
-#line 1377 "perly.y"
+#line 1373 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 211:
-#line 1382 "perly.y"
+#line 1378 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 212:
-#line 1384 "perly.y"
+#line 1380 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 213:
-#line 1388 "perly.y"
+#line 1384 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 214:
-#line 1390 "perly.y"
+#line 1386 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 215:
-#line 1394 "perly.y"
+#line 1390 "perly.y"
     { (yyval.i_tkval) = (ps[(1) - (1)].val.i_tkval); ;}
     break;
 
   case 216:
-#line 1396 "perly.y"
+#line 1392 "perly.y"
     { munge_qwlist_to_paren_list((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 217:
-#line 1398 "perly.y"
+#line 1394 "perly.y"
     { (yyval.i_tkval) = (ps[(3) - (3)].val.i_tkval); ;}
     break;
 
   case 218:
-#line 1404 "perly.y"
+#line 1400 "perly.y"
     { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 219:
-#line 1408 "perly.y"
+#line 1404 "perly.y"
     { (yyval.opval) = newCVREF(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'&');
                        ;}
     break;
 
   case 220:
-#line 1414 "perly.y"
+#line 1410 "perly.y"
     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
                        ;}
     break;
 
   case 221:
-#line 1420 "perly.y"
+#line 1416 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
                        ;}
     break;
 
   case 222:
-#line 1426 "perly.y"
+#line 1422 "perly.y"
     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
                        ;}
     break;
 
   case 223:
-#line 1432 "perly.y"
+#line 1428 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'l');
                        ;}
     break;
 
   case 224:
-#line 1438 "perly.y"
+#line 1434 "perly.y"
     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
                        ;}
     break;
 
   case 225:
-#line 1445 "perly.y"
+#line 1441 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 226:
-#line 1447 "perly.y"
+#line 1443 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 227:
-#line 1449 "perly.y"
+#line 1445 "perly.y"
     { (yyval.opval) = scope((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 228:
-#line 1452 "perly.y"
+#line 1448 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
index 92f4695..a29d2cc 100644 (file)
--- a/perly.tab
+++ b/perly.tab
@@ -175,28 +175,28 @@ static const yytype_int16 yyrhs[] =
 static const yytype_uint16 yyrline[] =
 {
        0,   144,   144,   146,   154,   153,   164,   177,   181,   187,
-     197,   201,   205,   211,   221,   226,   227,   234,   244,   246,
-     254,   257,   258,   260,   262,   279,   295,   300,   305,   307,
-     309,   313,   317,   321,   325,   330,   336,   337,   341,   352,
-     360,   371,   374,   380,   381,   388,   401,   413,   424,   434,
-     444,   476,   484,   494,   500,   501,   506,   509,   513,   518,
-     522,   526,   532,   541,   545,   547,   549,   551,   553,   558,
-     562,   568,   588,   589,   593,   606,   629,   635,   640,   645,
-     655,   656,   661,   662,   666,   676,   680,   690,   691,   700,
-     718,   717,   743,   742,   761,   765,   769,   773,   777,   787,
-     796,   800,   805,   812,   821,   827,   833,   841,   845,   852,
-     851,   862,   863,   867,   876,   881,   889,   896,   903,   913,
-     922,   929,   938,   945,   951,   958,   963,   973,   977,   981,
-     987,   991,   995,   999,  1003,  1007,  1011,  1023,  1027,  1031,
-    1035,  1045,  1049,  1056,  1060,  1064,  1069,  1074,  1079,  1088,
-    1093,  1098,  1104,  1110,  1121,  1125,  1129,  1141,  1154,  1162,
-    1174,  1175,  1176,  1177,  1178,  1183,  1187,  1189,  1193,  1198,
-    1200,  1205,  1207,  1209,  1211,  1213,  1215,  1217,  1226,  1237,
-    1239,  1241,  1246,  1259,  1264,  1269,  1273,  1277,  1281,  1285,
-    1289,  1293,  1297,  1299,  1302,  1306,  1312,  1315,  1324,  1330,
-    1335,  1336,  1337,  1343,  1347,  1355,  1362,  1367,  1372,  1374,
-    1376,  1381,  1383,  1388,  1389,  1393,  1396,  1395,  1403,  1407,
-    1413,  1419,  1425,  1431,  1437,  1444,  1446,  1448,  1451
+     197,   201,   205,   211,   221,   226,   227,   231,   240,   242,
+     250,   253,   254,   256,   258,   275,   291,   296,   301,   303,
+     305,   309,   313,   317,   321,   326,   332,   333,   337,   348,
+     356,   367,   370,   376,   377,   384,   397,   409,   420,   430,
+     440,   472,   480,   490,   496,   497,   502,   505,   509,   514,
+     518,   522,   528,   537,   541,   543,   545,   547,   549,   554,
+     558,   564,   584,   585,   589,   602,   625,   631,   636,   641,
+     651,   652,   657,   658,   662,   672,   676,   686,   687,   696,
+     714,   713,   739,   738,   757,   761,   765,   769,   773,   783,
+     792,   796,   801,   808,   817,   823,   829,   837,   841,   848,
+     847,   858,   859,   863,   872,   877,   885,   892,   899,   909,
+     918,   925,   934,   941,   947,   954,   959,   969,   973,   977,
+     983,   987,   991,   995,   999,  1003,  1007,  1019,  1023,  1027,
+    1031,  1041,  1045,  1052,  1056,  1060,  1065,  1070,  1075,  1084,
+    1089,  1094,  1100,  1106,  1117,  1121,  1125,  1137,  1150,  1158,
+    1170,  1171,  1172,  1173,  1174,  1179,  1183,  1185,  1189,  1194,
+    1196,  1201,  1203,  1205,  1207,  1209,  1211,  1213,  1222,  1233,
+    1235,  1237,  1242,  1255,  1260,  1265,  1269,  1273,  1277,  1281,
+    1285,  1289,  1293,  1295,  1298,  1302,  1308,  1311,  1320,  1326,
+    1331,  1332,  1333,  1339,  1343,  1351,  1358,  1363,  1368,  1370,
+    1372,  1377,  1379,  1384,  1385,  1389,  1392,  1391,  1399,  1403,
+    1409,  1415,  1421,  1427,  1433,  1440,  1442,  1444,  1447
 };
 #endif
 
diff --git a/perly.y b/perly.y
index 0b7c068..da7bcb0 100644 (file)
--- a/perly.y
+++ b/perly.y
@@ -226,14 +226,10 @@ lineseq   :       /* NULL */
                        { $$ = (OP*)NULL; }
        |       lineseq decl
                        {
-                       $$ = IF_MAD(
-                               append_list(OP_LINESEQ,
-                                   (LISTOP*)$1, (LISTOP*)$2),
-                               $1);
+                         $$ = IF_MAD(op_append_list(OP_LINESEQ, $1, $2), $1);
                        }
        |       lineseq line
-                       {   $$ = append_list(OP_LINESEQ,
-                               (LISTOP*)$1, (LISTOP*)$2);
+                       {   $$ = op_append_list(OP_LINESEQ, $1, $2);
                            PL_pad_reset_pending = TRUE;
                            if ($1 && $2)
                                PL_hints |= HINT_BLOCK_SCOPE;
@@ -451,7 +447,7 @@ loop        :       label WHILE lpar_or_qw remember texpr ')' mintro mblock cont
                                                IVAL($2), scalar($7),
                                                $12, $10, $9));
 #ifdef MAD
-                         forop = newUNOP(OP_NULL, 0, append_elem(OP_LINESEQ,
+                         forop = newUNOP(OP_NULL, 0, op_append_elem(OP_LINESEQ,
                                newSTATEOP(0,
                                           CopLABEL_alloc(($1)->tk_lval.pval),
                                           ($5 ? $5 : newOP(OP_NULL, 0)) ),
@@ -465,7 +461,7 @@ loop        :       label WHILE lpar_or_qw remember texpr ')' mintro mblock cont
                          token_getmad($1,forop,'L');
 #else
                          if ($5) {
-                               forop = append_elem(OP_LINESEQ,
+                               forop = op_append_elem(OP_LINESEQ,
                                         newSTATEOP(0, CopLABEL_alloc($1), $5),
                                        forop);
                          }
@@ -779,7 +775,7 @@ argexpr     :       argexpr ','
 #ifdef MAD
                          OP* op = newNULLLIST();
                          token_getmad($2,op,',');
-                         $$ = append_elem(OP_LIST, $1, op);
+                         $$ = op_append_elem(OP_LIST, $1, op);
 #else
                          $$ = $1;
 #endif
@@ -791,7 +787,7 @@ argexpr     :       argexpr ','
                              term = newUNOP(OP_NULL, 0, term);
                              token_getmad($2,term,',');
                          )
-                         $$ = append_elem(OP_LIST, $1, term);
+                         $$ = op_append_elem(OP_LIST, $1, term);
                        }
        |       term %prec PREC_LOW
        ;
@@ -799,20 +795,20 @@ argexpr   :       argexpr ','
 /* List operators */
 listop :       LSTOP indirob argexpr /* map {...} @args or print $fh @args */
                        { $$ = convert(IVAL($1), OPf_STACKED,
-                               prepend_elem(OP_LIST, newGVREF(IVAL($1),$2), $3) );
+                               op_prepend_elem(OP_LIST, newGVREF(IVAL($1),$2), $3) );
                          TOKEN_GETMAD($1,$$,'o');
                        }
        |       FUNC '(' indirob expr ')'      /* print ($fh @args */
                        { $$ = convert(IVAL($1), OPf_STACKED,
-                               prepend_elem(OP_LIST, newGVREF(IVAL($1),$3), $4) );
+                               op_prepend_elem(OP_LIST, newGVREF(IVAL($1),$3), $4) );
                          TOKEN_GETMAD($1,$$,'o');
                          TOKEN_GETMAD($2,$$,'(');
                          TOKEN_GETMAD($5,$$,')');
                        }
        |       term ARROW method lpar_or_qw listexprcom ')' /* $foo->bar(list) */
                        { $$ = convert(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST,
-                                   prepend_elem(OP_LIST, scalar($1), $5),
+                               op_append_elem(OP_LIST,
+                                   op_prepend_elem(OP_LIST, scalar($1), $5),
                                    newUNOP(OP_METHOD, 0, $3)));
                          TOKEN_GETMAD($2,$$,'A');
                          TOKEN_GETMAD($4,$$,'(');
@@ -820,20 +816,20 @@ listop    :       LSTOP indirob argexpr /* map {...} @args or print $fh @args */
                        }
        |       term ARROW method                     /* $foo->bar */
                        { $$ = convert(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST, scalar($1),
+                               op_append_elem(OP_LIST, scalar($1),
                                    newUNOP(OP_METHOD, 0, $3)));
                          TOKEN_GETMAD($2,$$,'A');
                        }
        |       METHOD indirob listexpr              /* new Class @args */
                        { $$ = convert(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST,
-                                   prepend_elem(OP_LIST, $2, $3),
+                               op_append_elem(OP_LIST,
+                                   op_prepend_elem(OP_LIST, $2, $3),
                                    newUNOP(OP_METHOD, 0, $1)));
                        }
        |       FUNCMETH indirob '(' listexprcom ')' /* method $object (@args) */
                        { $$ = convert(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST,
-                                   prepend_elem(OP_LIST, $2, $4),
+                               op_append_elem(OP_LIST,
+                                   op_prepend_elem(OP_LIST, $2, $4),
                                    newUNOP(OP_METHOD, 0, $1)));
                          TOKEN_GETMAD($3,$$,'(');
                          TOKEN_GETMAD($5,$$,')');
@@ -853,8 +849,8 @@ listop      :       LSTOP indirob argexpr /* map {...} @args or print $fh @args */
                          $<opval>$ = newANONATTRSUB($2, 0, (OP*)NULL, $3); }
                    listexpr            %prec LSTOP  /* ... @bar */
                        { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                                append_elem(OP_LIST,
-                                  prepend_elem(OP_LIST, $<opval>4, $5), $1));
+                                op_append_elem(OP_LIST,
+                                  op_prepend_elem(OP_LIST, $<opval>4, $5), $1));
                        }
        ;
 
@@ -928,7 +924,7 @@ subscripted:    star '{' expr ';' '}'        /* *main::{something} */
                        }
        |       term ARROW '(' expr ')'     /* $subref->(@args) */
                        { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                                  append_elem(OP_LIST, $4,
+                                  op_append_elem(OP_LIST, $4,
                                       newCVREF(0, scalar($1))));
                          TOKEN_GETMAD($2,$$,'a');
                          TOKEN_GETMAD($3,$$,'(');
@@ -937,7 +933,7 @@ subscripted:    star '{' expr ';' '}'        /* *main::{something} */
 
        |       subscripted lpar_or_qw expr ')'   /* $foo->{bar}->(@args) */
                        { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                                  append_elem(OP_LIST, $3,
+                                  op_append_elem(OP_LIST, $3,
                                               newCVREF(0, scalar($1))));
                          TOKEN_GETMAD($2,$$,'(');
                          TOKEN_GETMAD($4,$$,')');
@@ -1129,7 +1125,7 @@ termdo    :       DO term %prec UNIOP                     /* do $filename */
        |       DO WORD lpar_or_qw ')'                  /* do somesub() */
                        { $$ = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
-                           prepend_elem(OP_LIST,
+                           op_prepend_elem(OP_LIST,
                                scalar(newCVREF(
                                    (OPpENTERSUB_AMPER<<8),
                                    scalar($2)
@@ -1141,7 +1137,7 @@ termdo    :       DO term %prec UNIOP                     /* do $filename */
        |       DO WORD lpar_or_qw expr ')'             /* do somesub(@args) */
                        { $$ = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
-                           append_elem(OP_LIST,
+                           op_append_elem(OP_LIST,
                                $4,
                                scalar(newCVREF(
                                    (OPpENTERSUB_AMPER<<8),
@@ -1153,7 +1149,7 @@ termdo    :       DO term %prec UNIOP                     /* do $filename */
                        }
        |       DO scalar lpar_or_qw ')'                /* do $subref () */
                        { $$ = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
-                           prepend_elem(OP_LIST,
+                           op_prepend_elem(OP_LIST,
                                scalar(newCVREF(0,scalar($2))), (OP*)NULL)); dep();
                          TOKEN_GETMAD($1,$$,'o');
                          TOKEN_GETMAD($3,$$,'(');
@@ -1161,7 +1157,7 @@ termdo    :       DO term %prec UNIOP                     /* do $filename */
                        }
        |       DO scalar lpar_or_qw expr ')'           /* do $subref (@args) */
                        { $$ = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
-                           prepend_elem(OP_LIST,
+                           op_prepend_elem(OP_LIST,
                                $4,
                                scalar(newCVREF(0,scalar($2))))); dep();
                          TOKEN_GETMAD($1,$$,'o');
@@ -1215,7 +1211,7 @@ term      :       termbinop
        |       subscripted
                        { $$ = $1; }
        |       ary '[' expr ']'                     /* array slice */
-                       { $$ = prepend_elem(OP_ASLICE,
+                       { $$ = op_prepend_elem(OP_ASLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_ASLICE, 0,
                                        list($3),
@@ -1224,7 +1220,7 @@ term      :       termbinop
                          TOKEN_GETMAD($4,$$,']');
                        }
        |       ary '{' expr ';' '}'                 /* @hash{@keys} */
-                       { $$ = prepend_elem(OP_HSLICE,
+                       { $$ = op_prepend_elem(OP_HSLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_HSLICE, 0,
                                        list($3),
@@ -1246,7 +1242,7 @@ term      :       termbinop
        |       amper lpar_or_qw expr ')'            /* &foo(@args) */
                        {
                          $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST, $3, scalar($1)));
+                               op_append_elem(OP_LIST, $3, scalar($1)));
                          DO_MAD({
                              OP* op = $$;
                              if (op->op_type == OP_CONST) { /* defeat const fold */
@@ -1258,7 +1254,7 @@ term      :       termbinop
                        }
        |       NOAMP WORD listexpr                  /* foo(@args) */
                        { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                           append_elem(OP_LIST, $3, scalar($2)));
+                           op_append_elem(OP_LIST, $3, scalar($2)));
                          TOKEN_GETMAD($1,$$,'o');
                        }
        |       LOOPEX  /* loop exiting command (goto, last, dump, etc) */
@@ -1298,7 +1294,7 @@ term      :       termbinop
                        { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar($1)); }
        |       UNIOPSUB term                        /* Sub treated as unop */
                        { $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                           append_elem(OP_LIST, $2, scalar($1))); }
+                           op_append_elem(OP_LIST, $2, scalar($1))); }
        |       FUNC0                                /* Nullary operator */
                        { $$ = newOP(IVAL($1), 0);
                          TOKEN_GETMAD($1,$$,'o');
diff --git a/proto.h b/proto.h
index 10ed4d3..45483e9 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -34,8 +34,6 @@ PERL_CALLCONV SV*     Perl_amagic_call(pTHX_ SV* left, SV* right, int method, int di
 #define PERL_ARGS_ASSERT_AMAGIC_CALL   \
        assert(left); assert(right)
 
-PERL_CALLCONV OP*      Perl_append_elem(pTHX_ I32 optype, OP* first, OP* last);
-PERL_CALLCONV OP*      Perl_append_list(pTHX_ I32 optype, LISTOP* first, LISTOP* last);
 PERL_CALLCONV I32      Perl_apply(pTHX_ I32 type, SV** mark, SV** sp)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
@@ -2675,6 +2673,8 @@ PERL_CALLCONV OP* Perl_oopsHV(pTHX_ OP* o)
 #define PERL_ARGS_ASSERT_OOPSHV        \
        assert(o)
 
+PERL_CALLCONV OP*      Perl_op_append_elem(pTHX_ I32 optype, OP* first, OP* last);
+PERL_CALLCONV OP*      Perl_op_append_list(pTHX_ I32 optype, OP* first, OP* last);
 PERL_CALLCONV void     Perl_op_clear(pTHX_ OP* o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_OP_CLEAR      \
@@ -2699,6 +2699,7 @@ PERL_CALLCONV void        Perl_op_null(pTHX_ OP* o)
 #define PERL_ARGS_ASSERT_OP_NULL       \
        assert(o)
 
+PERL_CALLCONV OP*      Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last);
 PERL_CALLCONV void     Perl_op_refcnt_lock(pTHX);
 PERL_CALLCONV void     Perl_op_refcnt_unlock(pTHX);
 PERL_CALLCONV void     Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
@@ -3204,7 +3205,6 @@ PERL_CALLCONV void        Perl_pregfree2(pTHX_ REGEXP *rx)
 #define PERL_ARGS_ASSERT_PREGFREE2     \
        assert(rx)
 
-PERL_CALLCONV OP*      Perl_prepend_elem(pTHX_ I32 optype, OP* head, OP* tail);
 PERL_CALLCONV const char*      Perl_prescan_version(pTHX_ const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PRESCAN_VERSION       \
diff --git a/toke.c b/toke.c
index b223ea4..36d1f24 100644 (file)
--- a/toke.c
+++ b/toke.c
@@ -3952,7 +3952,7 @@ S_readpipe_override(pTHX)
             && GvCVu(gv_readpipe) && GvIMPORTED_CV(gv_readpipe)))
     {
        PL_lex_op = (OP*)newUNOP(OP_ENTERSUB, OPf_STACKED,
-           append_elem(OP_LIST,
+           op_append_elem(OP_LIST,
                newSVOP(OP_CONST, 0, &PL_sv_undef), /* value will be read later */
                newCVREF(0, newGVOP(OP_GV, 0, gv_readpipe))));
     }
@@ -5247,7 +5247,7 @@ Perl_yylex(pTHX)
                }
                if (PL_lex_stuff) {
                    sv_catsv(sv, PL_lex_stuff);
-                   attrs = append_elem(OP_LIST, attrs,
+                   attrs = op_append_elem(OP_LIST, attrs,
                                        newSVOP(OP_CONST, 0, sv));
                    SvREFCNT_dec(PL_lex_stuff);
                    PL_lex_stuff = NULL;
@@ -5287,7 +5287,7 @@ Perl_yylex(pTHX)
                       justified by the performance win for the common case
                       of applying only built-in attributes.) */
                    else
-                       attrs = append_elem(OP_LIST, attrs,
+                       attrs = op_append_elem(OP_LIST, attrs,
                                            newSVOP(OP_CONST, 0,
                                                    sv));
                }
@@ -7363,7 +7363,7 @@ Perl_yylex(pTHX)
                                /**/;
                        }
                        sv = newSVpvn_utf8(b, d-b, DO_UTF8(PL_lex_stuff));
-                       words = append_elem(OP_LIST, words,
+                       words = op_append_elem(OP_LIST, words,
                                            newSVOP(OP_CONST, 0, tokeq(sv)));
                    }
                }
@@ -12530,7 +12530,7 @@ S_scan_inputsymbol(pTHX_ char *start)
                    o->op_targ = tmp;
                    PL_lex_op = readline_overriden
                        ? (OP*)newUNOP(OP_ENTERSUB, OPf_STACKED,
-                               append_elem(OP_LIST, o,
+                               op_append_elem(OP_LIST, o,
                                    newCVREF(0, newGVOP(OP_GV,0,gv_readline))))
                        : (OP*)newUNOP(OP_READLINE, 0, o);
                }
@@ -12546,7 +12546,7 @@ intro_sym:
                                SVt_PV);
                PL_lex_op = readline_overriden
                    ? (OP*)newUNOP(OP_ENTERSUB, OPf_STACKED,
-                           append_elem(OP_LIST,
+                           op_append_elem(OP_LIST,
                                newUNOP(OP_RV2SV, 0, newGVOP(OP_GV, 0, gv)),
                                newCVREF(0, newGVOP(OP_GV, 0, gv_readline))))
                    : (OP*)newUNOP(OP_READLINE, 0,
@@ -12565,7 +12565,7 @@ intro_sym:
            GV * const gv = gv_fetchpv(d, GV_ADD, SVt_PVIO);
            PL_lex_op = readline_overriden
                ? (OP*)newUNOP(OP_ENTERSUB, OPf_STACKED,
-                       append_elem(OP_LIST,
+                       op_append_elem(OP_LIST,
                            newGVOP(OP_GV, 0, gv),
                            newCVREF(0, newGVOP(OP_GV, 0, gv_readline))))
                : (OP*)newUNOP(OP_READLINE, 0, newGVOP(OP_GV, 0, gv));