Fixups for thrperl integration.

p4raw-id: //depot/perl@25

diff --git a/embed.h b/embed.h
index dcaca38..18368fa 100644 (file)
--- a/embed.h
+++ b/embed.h
@@ -126,6 +126,7 @@
 #define comppad_name_fill      Perl_comppad_name_fill
 #define concat_amg             Perl_concat_amg
 #define concat_ass_amg         Perl_concat_ass_amg
+#define condpair_magic         Perl_condpair_magic
 #define convert                        Perl_convert
 #define cop_seqmax             Perl_cop_seqmax
 #define cos_amg                        Perl_cos_amg
@@ -279,6 +280,7 @@
 #define in_my_stash            Perl_in_my_stash
 #define inc_amg                        Perl_inc_amg
 #define ingroup                        Perl_ingroup
+#define init_stacks            Perl_init_stacks
 #define instr                  Perl_instr
 #define intro_my               Perl_intro_my
 #define intuit_more            Perl_intuit_more
@@ -335,6 +337,7 @@
 #define magic_gettaint         Perl_magic_gettaint
 #define magic_getuvar          Perl_magic_getuvar
 #define magic_len              Perl_magic_len
+#define magic_mutexfree                Perl_magic_mutexfree
 #define magic_nextpack         Perl_magic_nextpack
 #define magic_set              Perl_magic_set
 #define magic_setamagic                Perl_magic_setamagic
@@ -1106,6 +1109,7 @@
 #define vtbl_isa               Perl_vtbl_isa
 #define vtbl_isaelem           Perl_vtbl_isaelem
 #define vtbl_mglob             Perl_vtbl_mglob
+#define vtbl_mutex             Perl_vtbl_mutex
 #define vtbl_nkeys             Perl_vtbl_nkeys
 #define vtbl_pack              Perl_vtbl_pack
 #define vtbl_packelem          Perl_vtbl_packelem

diff --git a/op.c b/op.c
index 08a2e7a..45b7400 100644 (file)
--- a/op.c
+++ b/op.c
@@ -55,7 +55,7 @@ no_fh_allowed(o)
 OP *o;
 {
     yyerror(form("Missing comma after first argument to %s function",
-                op_desc[op->op_type]));
+                op_desc[o->op_type]));
     return o;
 }
 
@@ -77,7 +77,7 @@ char* name;
     return o;
 }
 
-static void
+static OP *
 bad_type(n, t, name, kid)
 I32 n;
 char *t;
@@ -537,7 +537,7 @@ OP *o;
        o->op_targ = 0; /* Was holding hints. */
        break;
     default:
-       if (!(op->op_flags & OPf_REF) || (check[op->op_type] != ck_ftst))
+       if (!(o->op_flags & OPf_REF) || (check[o->op_type] != ck_ftst))
            break;
        /* FALL THROUGH */
     case OP_GVSV:
@@ -547,7 +547,7 @@ OP *o;
        break;
     case OP_NEXTSTATE:
     case OP_DBSTATE:
-       Safefree(cCOP->cop_label);
+       Safefree(cCOPo->cop_label);
        SvREFCNT_dec(cCOPo->cop_filegv);
        break;
     case OP_CONST:
@@ -880,12 +880,12 @@ OP *o;
            scalarvoid(kid);
        break;
     case OP_ENTEREVAL:
-       scalarkids(op);
+       scalarkids(o);
        break;
     case OP_REQUIRE:
        /* all requires must return a boolean value */
-       op->op_flags &= ~OPf_WANT;
-       return scalar(op);
+       o->op_flags &= ~OPf_WANT;
+       return scalar(o);
     case OP_SPLIT:
        if ((kid = cLISTOPo->op_first) && kid->op_type == OP_PUSHRE) {
            if (!kPMOP->op_pmreplroot)
@@ -971,8 +971,8 @@ OP *o;
        break;
     case OP_REQUIRE:
        /* all requires must return a boolean value */
-       op->op_flags &= ~OPf_WANT;
-       return scalar(op);
+       o->op_flags &= ~OPf_WANT;
+       return scalar(o);
     }
     return o;
 }
@@ -1052,7 +1052,7 @@ I32 type;
            croak("That use of $[ is unsupported");
        break;
     case OP_STUB:
-       if (op->op_flags & OPf_PARENS)
+       if (o->op_flags & OPf_PARENS)
            break;
        goto nomod;
     case OP_ENTERSUB:
@@ -1141,9 +1141,9 @@ I32 type;
     case OP_PADAV:
     case OP_PADHV:
        modcount = 10000;
-       if (type == OP_REFGEN && op->op_flags & OPf_PARENS)
-           return op;          /* Treat \(@foo) like ordinary list. */
-       if (scalar_mod_type(op, type))
+       if (type == OP_REFGEN && o->op_flags & OPf_PARENS)
+           return o;           /* Treat \(@foo) like ordinary list. */
+       if (scalar_mod_type(o, type))
            goto nomod;
        /* FALL THROUGH */
     case OP_PADSV:
@@ -1213,13 +1213,13 @@ I32 type;
 }
 
 static bool
-scalar_mod_type(op, type)
-OP *op;
+scalar_mod_type(o, type)
+OP *o;
 I32 type;
 {
     switch (type) {
     case OP_SASSIGN:
-       if (op->op_type == OP_RV2GV)
+       if (o->op_type == OP_RV2GV)
            return FALSE;
        /* FALL THROUGH */
     case OP_PREINC:
@@ -3572,7 +3572,7 @@ char *filename;
            sub_generation++;
        }
     }
-    CvGV(cv) = SvREFCNT_inc(gv);
+    CvGV(cv) = (GV*)SvREFCNT_inc(gv);
 #ifdef USE_THREADS
     New(666, CvMUTEXP(cv), 1, pthread_mutex_t);
     MUTEX_INIT(CvMUTEXP(cv));
@@ -3958,17 +3958,17 @@ OP *o;
 }
 
 OP *
-ck_exists(op)
-OP *op;
+ck_exists(o)
+OP *o;
 {
-    op = ck_fun(op);
-    if (op->op_flags & OPf_KIDS) {
-       OP *kid = cUNOP->op_first;
+    o = ck_fun(o);
+    if (o->op_flags & OPf_KIDS) {
+       OP *kid = cUNOPo->op_first;
        if (kid->op_type != OP_HELEM)
-           croak("%s argument is not a HASH element", op_desc[op->op_type]);
+           croak("%s argument is not a HASH element", op_desc[o->op_type]);
        null(kid);
     }
-    return op;
+    return o;
 }
 
 OP *
@@ -4014,7 +4014,7 @@ register OP *o;
                      name, badthing);
        }
        kid->op_type = OP_GV;
-       iscv = (op->op_type == OP_RV2CV) * 2;
+       iscv = (o->op_type == OP_RV2CV) * 2;
        for (gv = 0; !gv; iscv++) {
            /*
             * This is a little tricky.  We only want to add the symbol if we
@@ -4221,20 +4221,20 @@ OP *o;
     if (gv && GvIMPORTED_CV(gv)) {
        static int glob_index;
 
-       append_elem(OP_GLOB, op,
+       append_elem(OP_GLOB, o,
                    newSVOP(OP_CONST, 0, newSViv(glob_index++)));
-       op->op_type = OP_LIST;
-       op->op_ppaddr = ppaddr[OP_LIST];
-       ((LISTOP*)op)->op_first->op_type = OP_PUSHMARK;
-       ((LISTOP*)op)->op_first->op_ppaddr = ppaddr[OP_PUSHMARK];
-       op = newUNOP(OP_ENTERSUB, OPf_STACKED,
-                    append_elem(OP_LIST, op, 
-                                scalar(newUNOP(OP_RV2CV, 0,
-                                               newGVOP(OP_GV, 0, gv)))));
-       return ck_subr(op);
-    }
-    if ((op->op_flags & OPf_KIDS) && !cLISTOP->op_first->op_sibling)
-       append_elem(OP_GLOB, op, newSVREF(newGVOP(OP_GV, 0, defgv)));
+       o->op_type = OP_LIST;
+       o->op_ppaddr = ppaddr[OP_LIST];
+       cLISTOPo->op_first->op_type = OP_PUSHMARK;
+       cLISTOPo->op_first->op_ppaddr = ppaddr[OP_PUSHMARK];
+       o = newUNOP(OP_ENTERSUB, OPf_STACKED,
+                   append_elem(OP_LIST, o, 
+                               scalar(newUNOP(OP_RV2CV, 0,
+                                              newGVOP(OP_GV, 0, gv)))));
+       return ck_subr(o);
+    }
+    if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
+       append_elem(OP_GLOB, o, newSVREF(newGVOP(OP_GV, 0, defgv)));
     gv = newGVgen("main");
     gv_IOadd(gv);
     append_elem(OP_GLOB, o, newGVOP(OP_GV, 0, gv));
@@ -4824,7 +4824,7 @@ register OP* o;
                OP* pop = o->op_next->op_next;
                IV i;
                if (pop->op_type == OP_CONST &&
-                   (op = pop->op_next) &&
+                   (o = pop->op_next) &&
                    pop->op_next->op_type == OP_AELEM &&
                    !(pop->op_next->op_private &
                      (OPpLVAL_INTRO|OPpLVAL_DEFER|OPpDEREF)) &&
@@ -4907,7 +4907,7 @@ register OP* o;
            lexname = *av_fetch(comppad_name, rop->op_first->op_targ, TRUE);
            if (!SvOBJECT(lexname))
                break;
-           fields = hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
+           fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
            if (!fields || !GvHV(*fields))
                break;
            svp = &((SVOP*)((BINOP*)o)->op_last)->op_sv;

diff --git a/opcode.h b/opcode.h
index bdcf5f6..c4a6563 100644 (file)
--- a/opcode.h
+++ b/opcode.h
@@ -1055,383 +1055,383 @@ EXT char *op_desc[] = {
 };
 #endif
 
-OP *   ck_anoncode     _((OP* op));
-OP *   ck_bitop        _((OP* op));
-OP *   ck_concat       _((OP* op));
-OP *   ck_delete       _((OP* op));
-OP *   ck_eof          _((OP* op));
-OP *   ck_eval         _((OP* op));
-OP *   ck_exec         _((OP* op));
-OP *   ck_exists       _((OP* op));
-OP *   ck_ftst         _((OP* op));
-OP *   ck_fun          _((OP* op));
-OP *   ck_fun_locale   _((OP* op));
-OP *   ck_glob         _((OP* op));
-OP *   ck_grep         _((OP* op));
-OP *   ck_index        _((OP* op));
-OP *   ck_lengthconst  _((OP* op));
-OP *   ck_lfun         _((OP* op));
-OP *   ck_listiob      _((OP* op));
-OP *   ck_match        _((OP* op));
-OP *   ck_null         _((OP* op));
-OP *   ck_repeat       _((OP* op));
-OP *   ck_require      _((OP* op));
-OP *   ck_rfun         _((OP* op));
-OP *   ck_rvconst      _((OP* op));
-OP *   ck_scmp         _((OP* op));
-OP *   ck_select       _((OP* op));
-OP *   ck_shift        _((OP* op));
-OP *   ck_sort         _((OP* op));
-OP *   ck_spair        _((OP* op));
-OP *   ck_split        _((OP* op));
-OP *   ck_subr         _((OP* op));
-OP *   ck_svconst      _((OP* op));
-OP *   ck_trunc        _((OP* op));
+OP *   ck_anoncode     _((OP* o));
+OP *   ck_bitop        _((OP* o));
+OP *   ck_concat       _((OP* o));
+OP *   ck_delete       _((OP* o));
+OP *   ck_eof          _((OP* o));
+OP *   ck_eval         _((OP* o));
+OP *   ck_exec         _((OP* o));
+OP *   ck_exists       _((OP* o));
+OP *   ck_ftst         _((OP* o));
+OP *   ck_fun          _((OP* o));
+OP *   ck_fun_locale   _((OP* o));
+OP *   ck_glob         _((OP* o));
+OP *   ck_grep         _((OP* o));
+OP *   ck_index        _((OP* o));
+OP *   ck_lengthconst  _((OP* o));
+OP *   ck_lfun         _((OP* o));
+OP *   ck_listiob      _((OP* o));
+OP *   ck_match        _((OP* o));
+OP *   ck_null         _((OP* o));
+OP *   ck_repeat       _((OP* o));
+OP *   ck_require      _((OP* o));
+OP *   ck_rfun         _((OP* o));
+OP *   ck_rvconst      _((OP* o));
+OP *   ck_scmp         _((OP* o));
+OP *   ck_select       _((OP* o));
+OP *   ck_shift        _((OP* o));
+OP *   ck_sort         _((OP* o));
+OP *   ck_spair        _((OP* o));
+OP *   ck_split        _((OP* o));
+OP *   ck_subr         _((OP* o));
+OP *   ck_svconst      _((OP* o));
+OP *   ck_trunc        _((OP* o));
 
-OP *   pp_null         _((void));
-OP *   pp_stub         _((void));
-OP *   pp_scalar       _((void));
-OP *   pp_pushmark     _((void));
-OP *   pp_wantarray    _((void));
-OP *   pp_const        _((void));
-OP *   pp_gvsv         _((void));
-OP *   pp_gv           _((void));
-OP *   pp_gelem        _((void));
-OP *   pp_padsv        _((void));
-OP *   pp_padav        _((void));
-OP *   pp_padhv        _((void));
-OP *   pp_padany       _((void));
-OP *   pp_pushre       _((void));
-OP *   pp_rv2gv        _((void));
-OP *   pp_rv2sv        _((void));
-OP *   pp_av2arylen    _((void));
-OP *   pp_rv2cv        _((void));
-OP *   pp_anoncode     _((void));
-OP *   pp_prototype    _((void));
-OP *   pp_refgen       _((void));
-OP *   pp_srefgen      _((void));
-OP *   pp_ref          _((void));
-OP *   pp_bless        _((void));
-OP *   pp_backtick     _((void));
-OP *   pp_glob         _((void));
-OP *   pp_readline     _((void));
-OP *   pp_rcatline     _((void));
-OP *   pp_regcmaybe    _((void));
-OP *   pp_regcomp      _((void));
-OP *   pp_match        _((void));
-OP *   pp_subst        _((void));
-OP *   pp_substcont    _((void));
-OP *   pp_trans        _((void));
-OP *   pp_sassign      _((void));
-OP *   pp_aassign      _((void));
-OP *   pp_chop         _((void));
-OP *   pp_schop        _((void));
-OP *   pp_chomp        _((void));
-OP *   pp_schomp       _((void));
-OP *   pp_defined      _((void));
-OP *   pp_undef        _((void));
-OP *   pp_study        _((void));
-OP *   pp_pos          _((void));
-OP *   pp_preinc       _((void));
-OP *   pp_i_preinc     _((void));
-OP *   pp_predec       _((void));
-OP *   pp_i_predec     _((void));
-OP *   pp_postinc      _((void));
-OP *   pp_i_postinc    _((void));
-OP *   pp_postdec      _((void));
-OP *   pp_i_postdec    _((void));
-OP *   pp_pow          _((void));
-OP *   pp_multiply     _((void));
-OP *   pp_i_multiply   _((void));
-OP *   pp_divide       _((void));
-OP *   pp_i_divide     _((void));
-OP *   pp_modulo       _((void));
-OP *   pp_i_modulo     _((void));
-OP *   pp_repeat       _((void));
-OP *   pp_add          _((void));
-OP *   pp_i_add        _((void));
-OP *   pp_subtract     _((void));
-OP *   pp_i_subtract   _((void));
-OP *   pp_concat       _((void));
-OP *   pp_stringify    _((void));
-OP *   pp_left_shift   _((void));
-OP *   pp_right_shift  _((void));
-OP *   pp_lt           _((void));
-OP *   pp_i_lt         _((void));
-OP *   pp_gt           _((void));
-OP *   pp_i_gt         _((void));
-OP *   pp_le           _((void));
-OP *   pp_i_le         _((void));
-OP *   pp_ge           _((void));
-OP *   pp_i_ge         _((void));
-OP *   pp_eq           _((void));
-OP *   pp_i_eq         _((void));
-OP *   pp_ne           _((void));
-OP *   pp_i_ne         _((void));
-OP *   pp_ncmp         _((void));
-OP *   pp_i_ncmp       _((void));
-OP *   pp_slt          _((void));
-OP *   pp_sgt          _((void));
-OP *   pp_sle          _((void));
-OP *   pp_sge          _((void));
-OP *   pp_seq          _((void));
-OP *   pp_sne          _((void));
-OP *   pp_scmp         _((void));
-OP *   pp_bit_and      _((void));
-OP *   pp_bit_xor      _((void));
-OP *   pp_bit_or       _((void));
-OP *   pp_negate       _((void));
-OP *   pp_i_negate     _((void));
-OP *   pp_not          _((void));
-OP *   pp_complement   _((void));
-OP *   pp_atan2        _((void));
-OP *   pp_sin          _((void));
-OP *   pp_cos          _((void));
-OP *   pp_rand         _((void));
-OP *   pp_srand        _((void));
-OP *   pp_exp          _((void));
-OP *   pp_log          _((void));
-OP *   pp_sqrt         _((void));
-OP *   pp_int          _((void));
-OP *   pp_hex          _((void));
-OP *   pp_oct          _((void));
-OP *   pp_abs          _((void));
-OP *   pp_length       _((void));
-OP *   pp_substr       _((void));
-OP *   pp_vec          _((void));
-OP *   pp_index        _((void));
-OP *   pp_rindex       _((void));
-OP *   pp_sprintf      _((void));
-OP *   pp_formline     _((void));
-OP *   pp_ord          _((void));
-OP *   pp_chr          _((void));
-OP *   pp_crypt        _((void));
-OP *   pp_ucfirst      _((void));
-OP *   pp_lcfirst      _((void));
-OP *   pp_uc           _((void));
-OP *   pp_lc           _((void));
-OP *   pp_quotemeta    _((void));
-OP *   pp_rv2av        _((void));
-OP *   pp_aelemfast    _((void));
-OP *   pp_aelem        _((void));
-OP *   pp_aslice       _((void));
-OP *   pp_each         _((void));
-OP *   pp_values       _((void));
-OP *   pp_keys         _((void));
-OP *   pp_delete       _((void));
-OP *   pp_exists       _((void));
-OP *   pp_rv2hv        _((void));
-OP *   pp_helem        _((void));
-OP *   pp_hslice       _((void));
-OP *   pp_unpack       _((void));
-OP *   pp_pack         _((void));
-OP *   pp_split        _((void));
-OP *   pp_join         _((void));
-OP *   pp_list         _((void));
-OP *   pp_lslice       _((void));
-OP *   pp_anonlist     _((void));
-OP *   pp_anonhash     _((void));
-OP *   pp_splice       _((void));
-OP *   pp_push         _((void));
-OP *   pp_pop          _((void));
-OP *   pp_shift        _((void));
-OP *   pp_unshift      _((void));
-OP *   pp_sort         _((void));
-OP *   pp_reverse      _((void));
-OP *   pp_grepstart    _((void));
-OP *   pp_grepwhile    _((void));
-OP *   pp_mapstart     _((void));
-OP *   pp_mapwhile     _((void));
-OP *   pp_range        _((void));
-OP *   pp_flip         _((void));
-OP *   pp_flop         _((void));
-OP *   pp_and          _((void));
-OP *   pp_or           _((void));
-OP *   pp_xor          _((void));
-OP *   pp_cond_expr    _((void));
-OP *   pp_andassign    _((void));
-OP *   pp_orassign     _((void));
-OP *   pp_method       _((void));
-OP *   pp_entersub     _((void));
-OP *   pp_leavesub     _((void));
-OP *   pp_caller       _((void));
-OP *   pp_warn         _((void));
-OP *   pp_die          _((void));
-OP *   pp_reset        _((void));
-OP *   pp_lineseq      _((void));
-OP *   pp_nextstate    _((void));
-OP *   pp_dbstate      _((void));
-OP *   pp_unstack      _((void));
-OP *   pp_enter        _((void));
-OP *   pp_leave        _((void));
-OP *   pp_scope        _((void));
-OP *   pp_enteriter    _((void));
-OP *   pp_iter         _((void));
-OP *   pp_enterloop    _((void));
-OP *   pp_leaveloop    _((void));
-OP *   pp_return       _((void));
-OP *   pp_last         _((void));
-OP *   pp_next         _((void));
-OP *   pp_redo         _((void));
-OP *   pp_dump         _((void));
-OP *   pp_goto         _((void));
-OP *   pp_exit         _((void));
-OP *   pp_open         _((void));
-OP *   pp_close        _((void));
-OP *   pp_pipe_op      _((void));
-OP *   pp_fileno       _((void));
-OP *   pp_umask        _((void));
-OP *   pp_binmode      _((void));
-OP *   pp_tie          _((void));
-OP *   pp_untie        _((void));
-OP *   pp_tied         _((void));
-OP *   pp_dbmopen      _((void));
-OP *   pp_dbmclose     _((void));
-OP *   pp_sselect      _((void));
-OP *   pp_select       _((void));
-OP *   pp_getc         _((void));
-OP *   pp_read         _((void));
-OP *   pp_enterwrite   _((void));
-OP *   pp_leavewrite   _((void));
-OP *   pp_prtf         _((void));
-OP *   pp_print        _((void));
-OP *   pp_sysopen      _((void));
-OP *   pp_sysseek      _((void));
-OP *   pp_sysread      _((void));
-OP *   pp_syswrite     _((void));
-OP *   pp_send         _((void));
-OP *   pp_recv         _((void));
-OP *   pp_eof          _((void));
-OP *   pp_tell         _((void));
-OP *   pp_seek         _((void));
-OP *   pp_truncate     _((void));
-OP *   pp_fcntl        _((void));
-OP *   pp_ioctl        _((void));
-OP *   pp_flock        _((void));
-OP *   pp_socket       _((void));
-OP *   pp_sockpair     _((void));
-OP *   pp_bind         _((void));
-OP *   pp_connect      _((void));
-OP *   pp_listen       _((void));
-OP *   pp_accept       _((void));
-OP *   pp_shutdown     _((void));
-OP *   pp_gsockopt     _((void));
-OP *   pp_ssockopt     _((void));
-OP *   pp_getsockname  _((void));
-OP *   pp_getpeername  _((void));
-OP *   pp_lstat        _((void));
-OP *   pp_stat         _((void));
-OP *   pp_ftrread      _((void));
-OP *   pp_ftrwrite     _((void));
-OP *   pp_ftrexec      _((void));
-OP *   pp_fteread      _((void));
-OP *   pp_ftewrite     _((void));
-OP *   pp_fteexec      _((void));
-OP *   pp_ftis         _((void));
-OP *   pp_fteowned     _((void));
-OP *   pp_ftrowned     _((void));
-OP *   pp_ftzero       _((void));
-OP *   pp_ftsize       _((void));
-OP *   pp_ftmtime      _((void));
-OP *   pp_ftatime      _((void));
-OP *   pp_ftctime      _((void));
-OP *   pp_ftsock       _((void));
-OP *   pp_ftchr        _((void));
-OP *   pp_ftblk        _((void));
-OP *   pp_ftfile       _((void));
-OP *   pp_ftdir        _((void));
-OP *   pp_ftpipe       _((void));
-OP *   pp_ftlink       _((void));
-OP *   pp_ftsuid       _((void));
-OP *   pp_ftsgid       _((void));
-OP *   pp_ftsvtx       _((void));
-OP *   pp_fttty        _((void));
-OP *   pp_fttext       _((void));
-OP *   pp_ftbinary     _((void));
-OP *   pp_chdir        _((void));
-OP *   pp_chown        _((void));
-OP *   pp_chroot       _((void));
-OP *   pp_unlink       _((void));
-OP *   pp_chmod        _((void));
-OP *   pp_utime        _((void));
-OP *   pp_rename       _((void));
-OP *   pp_link         _((void));
-OP *   pp_symlink      _((void));
-OP *   pp_readlink     _((void));
-OP *   pp_mkdir        _((void));
-OP *   pp_rmdir        _((void));
-OP *   pp_open_dir     _((void));
-OP *   pp_readdir      _((void));
-OP *   pp_telldir      _((void));
-OP *   pp_seekdir      _((void));
-OP *   pp_rewinddir    _((void));
-OP *   pp_closedir     _((void));
-OP *   pp_fork         _((void));
-OP *   pp_wait         _((void));
-OP *   pp_waitpid      _((void));
-OP *   pp_system       _((void));
-OP *   pp_exec         _((void));
-OP *   pp_kill         _((void));
-OP *   pp_getppid      _((void));
-OP *   pp_getpgrp      _((void));
-OP *   pp_setpgrp      _((void));
-OP *   pp_getpriority  _((void));
-OP *   pp_setpriority  _((void));
-OP *   pp_time         _((void));
-OP *   pp_tms          _((void));
-OP *   pp_localtime    _((void));
-OP *   pp_gmtime       _((void));
-OP *   pp_alarm        _((void));
-OP *   pp_sleep        _((void));
-OP *   pp_shmget       _((void));
-OP *   pp_shmctl       _((void));
-OP *   pp_shmread      _((void));
-OP *   pp_shmwrite     _((void));
-OP *   pp_msgget       _((void));
-OP *   pp_msgctl       _((void));
-OP *   pp_msgsnd       _((void));
-OP *   pp_msgrcv       _((void));
-OP *   pp_semget       _((void));
-OP *   pp_semctl       _((void));
-OP *   pp_semop        _((void));
-OP *   pp_require      _((void));
-OP *   pp_dofile       _((void));
-OP *   pp_entereval    _((void));
-OP *   pp_leaveeval    _((void));
-OP *   pp_entertry     _((void));
-OP *   pp_leavetry     _((void));
-OP *   pp_ghbyname     _((void));
-OP *   pp_ghbyaddr     _((void));
-OP *   pp_ghostent     _((void));
-OP *   pp_gnbyname     _((void));
-OP *   pp_gnbyaddr     _((void));
-OP *   pp_gnetent      _((void));
-OP *   pp_gpbyname     _((void));
-OP *   pp_gpbynumber   _((void));
-OP *   pp_gprotoent    _((void));
-OP *   pp_gsbyname     _((void));
-OP *   pp_gsbyport     _((void));
-OP *   pp_gservent     _((void));
-OP *   pp_shostent     _((void));
-OP *   pp_snetent      _((void));
-OP *   pp_sprotoent    _((void));
-OP *   pp_sservent     _((void));
-OP *   pp_ehostent     _((void));
-OP *   pp_enetent      _((void));
-OP *   pp_eprotoent    _((void));
-OP *   pp_eservent     _((void));
-OP *   pp_gpwnam       _((void));
-OP *   pp_gpwuid       _((void));
-OP *   pp_gpwent       _((void));
-OP *   pp_spwent       _((void));
-OP *   pp_epwent       _((void));
-OP *   pp_ggrnam       _((void));
-OP *   pp_ggrgid       _((void));
-OP *   pp_ggrent       _((void));
-OP *   pp_sgrent       _((void));
-OP *   pp_egrent       _((void));
-OP *   pp_getlogin     _((void));
-OP *   pp_syscall      _((void));
+OP *   pp_null         _((ARGSproto));
+OP *   pp_stub         _((ARGSproto));
+OP *   pp_scalar       _((ARGSproto));
+OP *   pp_pushmark     _((ARGSproto));
+OP *   pp_wantarray    _((ARGSproto));
+OP *   pp_const        _((ARGSproto));
+OP *   pp_gvsv         _((ARGSproto));
+OP *   pp_gv           _((ARGSproto));
+OP *   pp_gelem        _((ARGSproto));
+OP *   pp_padsv        _((ARGSproto));
+OP *   pp_padav        _((ARGSproto));
+OP *   pp_padhv        _((ARGSproto));
+OP *   pp_padany       _((ARGSproto));
+OP *   pp_pushre       _((ARGSproto));
+OP *   pp_rv2gv        _((ARGSproto));
+OP *   pp_rv2sv        _((ARGSproto));
+OP *   pp_av2arylen    _((ARGSproto));
+OP *   pp_rv2cv        _((ARGSproto));
+OP *   pp_anoncode     _((ARGSproto));
+OP *   pp_prototype    _((ARGSproto));
+OP *   pp_refgen       _((ARGSproto));
+OP *   pp_srefgen      _((ARGSproto));
+OP *   pp_ref          _((ARGSproto));
+OP *   pp_bless        _((ARGSproto));
+OP *   pp_backtick     _((ARGSproto));
+OP *   pp_glob         _((ARGSproto));
+OP *   pp_readline     _((ARGSproto));
+OP *   pp_rcatline     _((ARGSproto));
+OP *   pp_regcmaybe    _((ARGSproto));
+OP *   pp_regcomp      _((ARGSproto));
+OP *   pp_match        _((ARGSproto));
+OP *   pp_subst        _((ARGSproto));
+OP *   pp_substcont    _((ARGSproto));
+OP *   pp_trans        _((ARGSproto));
+OP *   pp_sassign      _((ARGSproto));
+OP *   pp_aassign      _((ARGSproto));
+OP *   pp_chop         _((ARGSproto));
+OP *   pp_schop        _((ARGSproto));
+OP *   pp_chomp        _((ARGSproto));
+OP *   pp_schomp       _((ARGSproto));
+OP *   pp_defined      _((ARGSproto));
+OP *   pp_undef        _((ARGSproto));
+OP *   pp_study        _((ARGSproto));
+OP *   pp_pos          _((ARGSproto));
+OP *   pp_preinc       _((ARGSproto));
+OP *   pp_i_preinc     _((ARGSproto));
+OP *   pp_predec       _((ARGSproto));
+OP *   pp_i_predec     _((ARGSproto));
+OP *   pp_postinc      _((ARGSproto));
+OP *   pp_i_postinc    _((ARGSproto));
+OP *   pp_postdec      _((ARGSproto));
+OP *   pp_i_postdec    _((ARGSproto));
+OP *   pp_pow          _((ARGSproto));
+OP *   pp_multiply     _((ARGSproto));
+OP *   pp_i_multiply   _((ARGSproto));
+OP *   pp_divide       _((ARGSproto));
+OP *   pp_i_divide     _((ARGSproto));
+OP *   pp_modulo       _((ARGSproto));
+OP *   pp_i_modulo     _((ARGSproto));
+OP *   pp_repeat       _((ARGSproto));
+OP *   pp_add          _((ARGSproto));
+OP *   pp_i_add        _((ARGSproto));
+OP *   pp_subtract     _((ARGSproto));
+OP *   pp_i_subtract   _((ARGSproto));
+OP *   pp_concat       _((ARGSproto));
+OP *   pp_stringify    _((ARGSproto));
+OP *   pp_left_shift   _((ARGSproto));
+OP *   pp_right_shift  _((ARGSproto));
+OP *   pp_lt           _((ARGSproto));
+OP *   pp_i_lt         _((ARGSproto));
+OP *   pp_gt           _((ARGSproto));
+OP *   pp_i_gt         _((ARGSproto));
+OP *   pp_le           _((ARGSproto));
+OP *   pp_i_le         _((ARGSproto));
+OP *   pp_ge           _((ARGSproto));
+OP *   pp_i_ge         _((ARGSproto));
+OP *   pp_eq           _((ARGSproto));
+OP *   pp_i_eq         _((ARGSproto));
+OP *   pp_ne           _((ARGSproto));
+OP *   pp_i_ne         _((ARGSproto));
+OP *   pp_ncmp         _((ARGSproto));
+OP *   pp_i_ncmp       _((ARGSproto));
+OP *   pp_slt          _((ARGSproto));
+OP *   pp_sgt          _((ARGSproto));
+OP *   pp_sle          _((ARGSproto));
+OP *   pp_sge          _((ARGSproto));
+OP *   pp_seq          _((ARGSproto));
+OP *   pp_sne          _((ARGSproto));
+OP *   pp_scmp         _((ARGSproto));
+OP *   pp_bit_and      _((ARGSproto));
+OP *   pp_bit_xor      _((ARGSproto));
+OP *   pp_bit_or       _((ARGSproto));
+OP *   pp_negate       _((ARGSproto));
+OP *   pp_i_negate     _((ARGSproto));
+OP *   pp_not          _((ARGSproto));
+OP *   pp_complement   _((ARGSproto));
+OP *   pp_atan2        _((ARGSproto));
+OP *   pp_sin          _((ARGSproto));
+OP *   pp_cos          _((ARGSproto));
+OP *   pp_rand         _((ARGSproto));
+OP *   pp_srand        _((ARGSproto));
+OP *   pp_exp          _((ARGSproto));
+OP *   pp_log          _((ARGSproto));
+OP *   pp_sqrt         _((ARGSproto));
+OP *   pp_int          _((ARGSproto));
+OP *   pp_hex          _((ARGSproto));
+OP *   pp_oct          _((ARGSproto));
+OP *   pp_abs          _((ARGSproto));
+OP *   pp_length       _((ARGSproto));
+OP *   pp_substr       _((ARGSproto));
+OP *   pp_vec          _((ARGSproto));
+OP *   pp_index        _((ARGSproto));
+OP *   pp_rindex       _((ARGSproto));
+OP *   pp_sprintf      _((ARGSproto));
+OP *   pp_formline     _((ARGSproto));
+OP *   pp_ord          _((ARGSproto));
+OP *   pp_chr          _((ARGSproto));
+OP *   pp_crypt        _((ARGSproto));
+OP *   pp_ucfirst      _((ARGSproto));
+OP *   pp_lcfirst      _((ARGSproto));
+OP *   pp_uc           _((ARGSproto));
+OP *   pp_lc           _((ARGSproto));
+OP *   pp_quotemeta    _((ARGSproto));
+OP *   pp_rv2av        _((ARGSproto));
+OP *   pp_aelemfast    _((ARGSproto));
+OP *   pp_aelem        _((ARGSproto));
+OP *   pp_aslice       _((ARGSproto));
+OP *   pp_each         _((ARGSproto));
+OP *   pp_values       _((ARGSproto));
+OP *   pp_keys         _((ARGSproto));
+OP *   pp_delete       _((ARGSproto));
+OP *   pp_exists       _((ARGSproto));
+OP *   pp_rv2hv        _((ARGSproto));
+OP *   pp_helem        _((ARGSproto));
+OP *   pp_hslice       _((ARGSproto));
+OP *   pp_unpack       _((ARGSproto));
+OP *   pp_pack         _((ARGSproto));
+OP *   pp_split        _((ARGSproto));
+OP *   pp_join         _((ARGSproto));
+OP *   pp_list         _((ARGSproto));
+OP *   pp_lslice       _((ARGSproto));
+OP *   pp_anonlist     _((ARGSproto));
+OP *   pp_anonhash     _((ARGSproto));
+OP *   pp_splice       _((ARGSproto));
+OP *   pp_push         _((ARGSproto));
+OP *   pp_pop          _((ARGSproto));
+OP *   pp_shift        _((ARGSproto));
+OP *   pp_unshift      _((ARGSproto));
+OP *   pp_sort         _((ARGSproto));
+OP *   pp_reverse      _((ARGSproto));
+OP *   pp_grepstart    _((ARGSproto));
+OP *   pp_grepwhile    _((ARGSproto));
+OP *   pp_mapstart     _((ARGSproto));
+OP *   pp_mapwhile     _((ARGSproto));
+OP *   pp_range        _((ARGSproto));
+OP *   pp_flip         _((ARGSproto));
+OP *   pp_flop         _((ARGSproto));
+OP *   pp_and          _((ARGSproto));
+OP *   pp_or           _((ARGSproto));
+OP *   pp_xor          _((ARGSproto));
+OP *   pp_cond_expr    _((ARGSproto));
+OP *   pp_andassign    _((ARGSproto));
+OP *   pp_orassign     _((ARGSproto));
+OP *   pp_method       _((ARGSproto));
+OP *   pp_entersub     _((ARGSproto));
+OP *   pp_leavesub     _((ARGSproto));
+OP *   pp_caller       _((ARGSproto));
+OP *   pp_warn         _((ARGSproto));
+OP *   pp_die          _((ARGSproto));
+OP *   pp_reset        _((ARGSproto));
+OP *   pp_lineseq      _((ARGSproto));
+OP *   pp_nextstate    _((ARGSproto));
+OP *   pp_dbstate      _((ARGSproto));
+OP *   pp_unstack      _((ARGSproto));
+OP *   pp_enter        _((ARGSproto));
+OP *   pp_leave        _((ARGSproto));
+OP *   pp_scope        _((ARGSproto));
+OP *   pp_enteriter    _((ARGSproto));
+OP *   pp_iter         _((ARGSproto));
+OP *   pp_enterloop    _((ARGSproto));
+OP *   pp_leaveloop    _((ARGSproto));
+OP *   pp_return       _((ARGSproto));
+OP *   pp_last         _((ARGSproto));
+OP *   pp_next         _((ARGSproto));
+OP *   pp_redo         _((ARGSproto));
+OP *   pp_dump         _((ARGSproto));
+OP *   pp_goto         _((ARGSproto));
+OP *   pp_exit         _((ARGSproto));
+OP *   pp_open         _((ARGSproto));
+OP *   pp_close        _((ARGSproto));
+OP *   pp_pipe_op      _((ARGSproto));
+OP *   pp_fileno       _((ARGSproto));
+OP *   pp_umask        _((ARGSproto));
+OP *   pp_binmode      _((ARGSproto));
+OP *   pp_tie          _((ARGSproto));
+OP *   pp_untie        _((ARGSproto));
+OP *   pp_tied         _((ARGSproto));
+OP *   pp_dbmopen      _((ARGSproto));
+OP *   pp_dbmclose     _((ARGSproto));
+OP *   pp_sselect      _((ARGSproto));
+OP *   pp_select       _((ARGSproto));
+OP *   pp_getc         _((ARGSproto));
+OP *   pp_read         _((ARGSproto));
+OP *   pp_enterwrite   _((ARGSproto));
+OP *   pp_leavewrite   _((ARGSproto));
+OP *   pp_prtf         _((ARGSproto));
+OP *   pp_print        _((ARGSproto));
+OP *   pp_sysopen      _((ARGSproto));
+OP *   pp_sysseek      _((ARGSproto));
+OP *   pp_sysread      _((ARGSproto));
+OP *   pp_syswrite     _((ARGSproto));
+OP *   pp_send         _((ARGSproto));
+OP *   pp_recv         _((ARGSproto));
+OP *   pp_eof          _((ARGSproto));
+OP *   pp_tell         _((ARGSproto));
+OP *   pp_seek         _((ARGSproto));
+OP *   pp_truncate     _((ARGSproto));
+OP *   pp_fcntl        _((ARGSproto));
+OP *   pp_ioctl        _((ARGSproto));
+OP *   pp_flock        _((ARGSproto));
+OP *   pp_socket       _((ARGSproto));
+OP *   pp_sockpair     _((ARGSproto));
+OP *   pp_bind         _((ARGSproto));
+OP *   pp_connect      _((ARGSproto));
+OP *   pp_listen       _((ARGSproto));
+OP *   pp_accept       _((ARGSproto));
+OP *   pp_shutdown     _((ARGSproto));
+OP *   pp_gsockopt     _((ARGSproto));
+OP *   pp_ssockopt     _((ARGSproto));
+OP *   pp_getsockname  _((ARGSproto));
+OP *   pp_getpeername  _((ARGSproto));
+OP *   pp_lstat        _((ARGSproto));
+OP *   pp_stat         _((ARGSproto));
+OP *   pp_ftrread      _((ARGSproto));
+OP *   pp_ftrwrite     _((ARGSproto));
+OP *   pp_ftrexec      _((ARGSproto));
+OP *   pp_fteread      _((ARGSproto));
+OP *   pp_ftewrite     _((ARGSproto));
+OP *   pp_fteexec      _((ARGSproto));
+OP *   pp_ftis         _((ARGSproto));
+OP *   pp_fteowned     _((ARGSproto));
+OP *   pp_ftrowned     _((ARGSproto));
+OP *   pp_ftzero       _((ARGSproto));
+OP *   pp_ftsize       _((ARGSproto));
+OP *   pp_ftmtime      _((ARGSproto));
+OP *   pp_ftatime      _((ARGSproto));
+OP *   pp_ftctime      _((ARGSproto));
+OP *   pp_ftsock       _((ARGSproto));
+OP *   pp_ftchr        _((ARGSproto));
+OP *   pp_ftblk        _((ARGSproto));
+OP *   pp_ftfile       _((ARGSproto));
+OP *   pp_ftdir        _((ARGSproto));
+OP *   pp_ftpipe       _((ARGSproto));
+OP *   pp_ftlink       _((ARGSproto));
+OP *   pp_ftsuid       _((ARGSproto));
+OP *   pp_ftsgid       _((ARGSproto));
+OP *   pp_ftsvtx       _((ARGSproto));
+OP *   pp_fttty        _((ARGSproto));
+OP *   pp_fttext       _((ARGSproto));
+OP *   pp_ftbinary     _((ARGSproto));
+OP *   pp_chdir        _((ARGSproto));
+OP *   pp_chown        _((ARGSproto));
+OP *   pp_chroot       _((ARGSproto));
+OP *   pp_unlink       _((ARGSproto));
+OP *   pp_chmod        _((ARGSproto));
+OP *   pp_utime        _((ARGSproto));
+OP *   pp_rename       _((ARGSproto));
+OP *   pp_link         _((ARGSproto));
+OP *   pp_symlink      _((ARGSproto));
+OP *   pp_readlink     _((ARGSproto));
+OP *   pp_mkdir        _((ARGSproto));
+OP *   pp_rmdir        _((ARGSproto));
+OP *   pp_open_dir     _((ARGSproto));
+OP *   pp_readdir      _((ARGSproto));
+OP *   pp_telldir      _((ARGSproto));
+OP *   pp_seekdir      _((ARGSproto));
+OP *   pp_rewinddir    _((ARGSproto));
+OP *   pp_closedir     _((ARGSproto));
+OP *   pp_fork         _((ARGSproto));
+OP *   pp_wait         _((ARGSproto));
+OP *   pp_waitpid      _((ARGSproto));
+OP *   pp_system       _((ARGSproto));
+OP *   pp_exec         _((ARGSproto));
+OP *   pp_kill         _((ARGSproto));
+OP *   pp_getppid      _((ARGSproto));
+OP *   pp_getpgrp      _((ARGSproto));
+OP *   pp_setpgrp      _((ARGSproto));
+OP *   pp_getpriority  _((ARGSproto));
+OP *   pp_setpriority  _((ARGSproto));
+OP *   pp_time         _((ARGSproto));
+OP *   pp_tms          _((ARGSproto));
+OP *   pp_localtime    _((ARGSproto));
+OP *   pp_gmtime       _((ARGSproto));
+OP *   pp_alarm        _((ARGSproto));
+OP *   pp_sleep        _((ARGSproto));
+OP *   pp_shmget       _((ARGSproto));
+OP *   pp_shmctl       _((ARGSproto));
+OP *   pp_shmread      _((ARGSproto));
+OP *   pp_shmwrite     _((ARGSproto));
+OP *   pp_msgget       _((ARGSproto));
+OP *   pp_msgctl       _((ARGSproto));
+OP *   pp_msgsnd       _((ARGSproto));
+OP *   pp_msgrcv       _((ARGSproto));
+OP *   pp_semget       _((ARGSproto));
+OP *   pp_semctl       _((ARGSproto));
+OP *   pp_semop        _((ARGSproto));
+OP *   pp_require      _((ARGSproto));
+OP *   pp_dofile       _((ARGSproto));
+OP *   pp_entereval    _((ARGSproto));
+OP *   pp_leaveeval    _((ARGSproto));
+OP *   pp_entertry     _((ARGSproto));
+OP *   pp_leavetry     _((ARGSproto));
+OP *   pp_ghbyname     _((ARGSproto));
+OP *   pp_ghbyaddr     _((ARGSproto));
+OP *   pp_ghostent     _((ARGSproto));
+OP *   pp_gnbyname     _((ARGSproto));
+OP *   pp_gnbyaddr     _((ARGSproto));
+OP *   pp_gnetent      _((ARGSproto));
+OP *   pp_gpbyname     _((ARGSproto));
+OP *   pp_gpbynumber   _((ARGSproto));
+OP *   pp_gprotoent    _((ARGSproto));
+OP *   pp_gsbyname     _((ARGSproto));
+OP *   pp_gsbyport     _((ARGSproto));
+OP *   pp_gservent     _((ARGSproto));
+OP *   pp_shostent     _((ARGSproto));
+OP *   pp_snetent      _((ARGSproto));
+OP *   pp_sprotoent    _((ARGSproto));
+OP *   pp_sservent     _((ARGSproto));
+OP *   pp_ehostent     _((ARGSproto));
+OP *   pp_enetent      _((ARGSproto));
+OP *   pp_eprotoent    _((ARGSproto));
+OP *   pp_eservent     _((ARGSproto));
+OP *   pp_gpwnam       _((ARGSproto));
+OP *   pp_gpwuid       _((ARGSproto));
+OP *   pp_gpwent       _((ARGSproto));
+OP *   pp_spwent       _((ARGSproto));
+OP *   pp_epwent       _((ARGSproto));
+OP *   pp_ggrnam       _((ARGSproto));
+OP *   pp_ggrgid       _((ARGSproto));
+OP *   pp_ggrent       _((ARGSproto));
+OP *   pp_sgrent       _((ARGSproto));
+OP *   pp_egrent       _((ARGSproto));
+OP *   pp_getlogin     _((ARGSproto));
+OP *   pp_syscall      _((ARGSproto));
 
 #ifndef DOINIT
 EXT OP * (*ppaddr[])();

diff --git a/perl.c b/perl.c
index e7600df..4f96f28 100644 (file)
--- a/perl.c
+++ b/perl.c
@@ -2329,7 +2329,6 @@ nuke_stacks()
        Safefree(debname);
        Safefree(debdelim);
     } )
-<<<<
 }
 
 static PerlIO *tmpfp;  /* moved outside init_lexer() because of UNICOS bug */

diff --git a/util.c b/util.c
index 0387332..5759e5a 100644 (file)
--- a/util.c
+++ b/util.c
@@ -1268,7 +1268,6 @@ croak(pat, va_alist)
            XPUSHs(msg);
            PUTBACK;
            perl_call_sv((SV*)cv, G_DISCARD);
-<<<<
 
            LEAVE;
        }