Remove CALL_FPTR and CPERLscope.
authorBen Morrow <ben@morrow.me.uk>
Sat, 14 Aug 2010 01:07:09 +0000 (02:07 +0100)
committerJan Dubois <jand@activestate.com>
Sat, 21 Aug 2010 01:34:09 +0000 (18:34 -0700)
These are left from PERL_OBJECT, which was an implementation of
multiplicity using C++ objects. PERL_OBJECT was removed in 5.8, but the
macros seem to have been cargo-culted all over the core (including in
places where they would have been inappropriate originally). Since they
now do exactly nothing, it's cleaner to remove them.

I have left the definitions in perl.h, under #ifndef PERL_CORE, since
some CPAN XS code uses them (also often incorrectly). I have also left
STATIC alone, since it seems potentially more useful and is much more
ingrained.

The only appearance of these macros this patch doesn't touch is in
Devel-PPPort, because that's a CPAN module.

15 files changed:
dist/threads-shared/shared.xs
dump.c
mg.c
mg.h
op.c
op.h
perl.c
perl.h
pod/perlhack.pod
pp_ctl.c
pp_hot.c
run.c
sv.c
sv.h
toke.c

index 720e3b6..549fe37 100644 (file)
@@ -1181,7 +1181,7 @@ S_shared_signal_hook(pTHX) {
     MUTEX_UNLOCK(&PL_sharedsv_lock.mutex);
     if (us)
        return; /* try again later */
-    CALL_FPTR(prev_signal_hook)(aTHX);
+    prev_signal_hook(aTHX);
 }
 #endif
 
diff --git a/dump.c b/dump.c
index 2acc7e1..06ce879 100644 (file)
--- a/dump.c
+++ b/dump.c
@@ -2109,7 +2109,7 @@ Perl_runops_debug(pTHX)
            if (DEBUG_t_TEST_) debop(PL_op);
            if (DEBUG_P_TEST_) debprof(PL_op);
        }
-    } while ((PL_op = CALL_FPTR(PL_op->op_ppaddr)(aTHX)));
+    } while ((PL_op = PL_op->op_ppaddr(aTHX)));
     DEBUG_l(Perl_deb(aTHX_ "leaving RUNOPS level\n"));
 
     TAINT_NOT;
diff --git a/mg.c b/mg.c
index 797b57e..a674e43 100644 (file)
--- a/mg.c
+++ b/mg.c
@@ -227,7 +227,7 @@ Perl_mg_get(pTHX_ SV *sv)
        MAGIC * const nextmg = mg->mg_moremagic;        /* it may delete itself */
 
        if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
-           CALL_FPTR(vtbl->svt_get)(aTHX_ sv, mg);
+           vtbl->svt_get(aTHX_ sv, mg);
 
            /* guard against magic having been deleted - eg FETCH calling
             * untie */
@@ -302,7 +302,7 @@ Perl_mg_set(pTHX_ SV *sv)
        if (PL_localizing == 2 && !S_is_container_magic(mg))
            continue;
        if (vtbl && vtbl->svt_set)
-           CALL_FPTR(vtbl->svt_set)(aTHX_ sv, mg);
+           vtbl->svt_set(aTHX_ sv, mg);
     }
 
     restore_magic(INT2PTR(void*, (IV)mgs_ix));
@@ -332,7 +332,7 @@ Perl_mg_length(pTHX_ SV *sv)
             const I32 mgs_ix = SSNEW(sizeof(MGS));
            save_magic(mgs_ix, sv);
            /* omit MGf_GSKIP -- not changed here */
-           len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
+           len = vtbl->svt_len(aTHX_ sv, mg);
            restore_magic(INT2PTR(void*, (IV)mgs_ix));
            return len;
        }
@@ -364,7 +364,7 @@ Perl_mg_size(pTHX_ SV *sv)
             I32 len;
            save_magic(mgs_ix, sv);
            /* omit MGf_GSKIP -- not changed here */
-           len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
+           len = vtbl->svt_len(aTHX_ sv, mg);
            restore_magic(INT2PTR(void*, (IV)mgs_ix));
            return len;
        }
@@ -408,7 +408,7 @@ Perl_mg_clear(pTHX_ SV *sv)
        nextmg = mg->mg_moremagic; /* it may delete itself */
 
        if (vtbl && vtbl->svt_clear)
-           CALL_FPTR(vtbl->svt_clear)(aTHX_ sv, mg);
+           vtbl->svt_clear(aTHX_ sv, mg);
     }
 
     restore_magic(INT2PTR(void*, (IV)mgs_ix));
@@ -456,7 +456,7 @@ Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
     for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
         const MGVTBL* const vtbl = mg->mg_virtual;
        if ((mg->mg_flags & MGf_COPY) && vtbl->svt_copy){
-           count += CALL_FPTR(vtbl->svt_copy)(aTHX_ sv, mg, nsv, key, klen);
+           count += vtbl->svt_copy(aTHX_ sv, mg, nsv, key, klen);
        }
        else {
            const char type = mg->mg_type;
@@ -503,7 +503,7 @@ Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic)
            continue;
                
        if ((mg->mg_flags & MGf_LOCAL) && vtbl->svt_local)
-           (void)CALL_FPTR(vtbl->svt_local)(aTHX_ nsv, mg);
+           (void)vtbl->svt_local(aTHX_ nsv, mg);
        else
            sv_magicext(nsv, mg->mg_obj, mg->mg_type, vtbl,
                            mg->mg_ptr, mg->mg_len);
@@ -542,7 +542,7 @@ Perl_mg_free(pTHX_ SV *sv)
         const MGVTBL* const vtbl = mg->mg_virtual;
        moremagic = mg->mg_moremagic;
        if (vtbl && vtbl->svt_free)
-           CALL_FPTR(vtbl->svt_free)(aTHX_ sv, mg);
+           vtbl->svt_free(aTHX_ sv, mg);
        if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
            if (mg->mg_len > 0 || mg->mg_type == PERL_MAGIC_utf8)
                Safefree(mg->mg_ptr);
diff --git a/mg.h b/mg.h
index 3362854..848f735 100644 (file)
--- a/mg.h
+++ b/mg.h
 STRUCT_MGVTBL_DEFINITION;
 #else
 struct mgvtbl {
-    int                (CPERLscope(*svt_get))  (pTHX_ SV *sv, MAGIC* mg);
-    int                (CPERLscope(*svt_set))  (pTHX_ SV *sv, MAGIC* mg);
-    U32                (CPERLscope(*svt_len))  (pTHX_ SV *sv, MAGIC* mg);
-    int                (CPERLscope(*svt_clear))(pTHX_ SV *sv, MAGIC* mg);
-    int                (CPERLscope(*svt_free)) (pTHX_ SV *sv, MAGIC* mg);
-    int                (CPERLscope(*svt_copy)) (pTHX_ SV *sv, MAGIC* mg,
+    int                (*svt_get)      (pTHX_ SV *sv, MAGIC* mg);
+    int                (*svt_set)      (pTHX_ SV *sv, MAGIC* mg);
+    U32                (*svt_len)      (pTHX_ SV *sv, MAGIC* mg);
+    int                (*svt_clear)(pTHX_ SV *sv, MAGIC* mg);
+    int                (*svt_free)     (pTHX_ SV *sv, MAGIC* mg);
+    int                (*svt_copy)     (pTHX_ SV *sv, MAGIC* mg,
                                        SV *nsv, const char *name, I32 namlen);
-    int                (CPERLscope(*svt_dup))  (pTHX_ MAGIC *mg, CLONE_PARAMS *param);
-    int                (CPERLscope(*svt_local))(pTHX_ SV *nsv, MAGIC *mg);
+    int                (*svt_dup)      (pTHX_ MAGIC *mg, CLONE_PARAMS *param);
+    int                (*svt_local)(pTHX_ SV *nsv, MAGIC *mg);
 };
 #endif
 
diff --git a/op.c b/op.c
index 48b2a36..764b329 100644 (file)
--- a/op.c
+++ b/op.c
@@ -103,8 +103,8 @@ recursive, but it's recursive on basic blocks, not on tree nodes.
 #include "perl.h"
 #include "keywords.h"
 
-#define CALL_PEEP(o) CALL_FPTR(PL_peepp)(aTHX_ o)
-#define CALL_OPFREEHOOK(o) if (PL_opfreehook) CALL_FPTR(PL_opfreehook)(aTHX_ o)
+#define CALL_PEEP(o) PL_peepp(aTHX_ o)
+#define CALL_OPFREEHOOK(o) if (PL_opfreehook) PL_opfreehook(aTHX_ o)
 
 #if defined(PL_OP_SLAB_ALLOC)
 
@@ -305,7 +305,7 @@ Perl_Slab_Free(pTHX_ void *op)
      ? ( op_free((OP*)o),                                      \
         Perl_croak(aTHX_ "'%s' trapped by operation mask", PL_op_desc[type]),  \
         (OP*)0 )                                               \
-     : CALL_FPTR(PL_check[type])(aTHX_ (OP*)o))
+     : PL_check[type](aTHX_ (OP*)o))
 
 #define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
 
diff --git a/op.h b/op.h
index 4241f02..d537170 100644 (file)
--- a/op.h
+++ b/op.h
@@ -54,7 +54,7 @@ typedef PERL_BITFIELD16 Optype;
 #define BASEOP                         \
     OP*                op_next;                \
     OP*                op_sibling;             \
-    OP*                (CPERLscope(*op_ppaddr))(pTHX);         \
+    OP*                (*op_ppaddr)(pTHX);     \
     MADPROP_IN_BASEOP                  \
     PADOFFSET  op_targ;                \
     PERL_BITFIELD16 op_type:9;         \
@@ -733,7 +733,7 @@ preprocessing token; the type of I<arg> depends on I<which>.
                    hk = INT2PTR(BHK *, SvIVX(sv)); \
                \
                if (BhkENTRY(hk, which)) \
-                   CALL_FPTR(BhkENTRY(hk, which))(aTHX_ arg); \
+                   BhkENTRY(hk, which)(aTHX_ arg); \
            } \
        } \
     } STMT_END
diff --git a/perl.c b/perl.c
index 7a1c543..57be5d2 100644 (file)
--- a/perl.c
+++ b/perl.c
@@ -574,7 +574,7 @@ perl_destruct(pTHXx)
     /* Need to flush since END blocks can produce output */
     my_fflush_all();
 
-    if (CALL_FPTR(PL_threadhook)(aTHX)) {
+    if (PL_threadhook(aTHX)) {
         /* Threads hook has vetoed further cleanup */
        PL_veto_cleanup = TRUE;
         return STATUS_EXIT;
diff --git a/perl.h b/perl.h
index 1def000..d9b2228 100644 (file)
--- a/perl.h
+++ b/perl.h
 #endif
 
 #define STATIC static
+
+#ifndef PERL_CORE
+/* Do not use these macros. They were part of PERL_OBJECT, which was an
+ * implementation of multiplicity using C++ objects. They have been left
+ * here solely for the sake of XS code which has incorrectly
+ * cargo-culted them.
+ */
 #define CPERLscope(x) x
 #define CPERLarg void
 #define CPERLarg_
 #define _PERL_OBJECT_THIS
 #define PERL_OBJECT_THIS_
 #define CALL_FPTR(fptr) (*fptr)
+#endif /* !PERL_CORE */
 
-#define CALLRUNOPS  CALL_FPTR(PL_runops)
+#define CALLRUNOPS  PL_runops
 
 #define CALLREGCOMP(sv, flags) Perl_pregcomp(aTHX_ (sv),(flags))
 
-#define CALLREGCOMP_ENG(prog, sv, flags) \
-    CALL_FPTR(((prog)->comp))(aTHX_ sv, flags)
+#define CALLREGCOMP_ENG(prog, sv, flags) (prog)->comp(aTHX_ sv, flags)
 #define CALLREGEXEC(prog,stringarg,strend,strbeg,minend,screamer,data,flags) \
-    CALL_FPTR(RX_ENGINE(prog)->exec)(aTHX_ (prog),(stringarg),(strend), \
+    RX_ENGINE(prog)->exec(aTHX_ (prog),(stringarg),(strend), \
         (strbeg),(minend),(screamer),(data),(flags))
 #define CALLREG_INTUIT_START(prog,sv,strpos,strend,flags,data) \
-    CALL_FPTR(RX_ENGINE(prog)->intuit)(aTHX_ (prog), (sv), (strpos), \
+    RX_ENGINE(prog)->intuit(aTHX_ (prog), (sv), (strpos), \
         (strend),(flags),(data))
 #define CALLREG_INTUIT_STRING(prog) \
-    CALL_FPTR(RX_ENGINE(prog)->checkstr)(aTHX_ (prog))
+    RX_ENGINE(prog)->checkstr(aTHX_ (prog))
 
 #define CALLREGFREE(prog) \
     Perl_pregfree(aTHX_ (prog))
 
 #define CALLREGFREE_PVT(prog) \
-    if(prog) CALL_FPTR(RX_ENGINE(prog)->free)(aTHX_ (prog))
+    if(prog) RX_ENGINE(prog)->free(aTHX_ (prog))
 
 #define CALLREG_NUMBUF_FETCH(rx,paren,usesv)                                \
-    CALL_FPTR(RX_ENGINE(rx)->numbered_buff_FETCH)(aTHX_ (rx),(paren),(usesv))
+    RX_ENGINE(rx)->numbered_buff_FETCH(aTHX_ (rx),(paren),(usesv))
 
 #define CALLREG_NUMBUF_STORE(rx,paren,value) \
-    CALL_FPTR(RX_ENGINE(rx)->numbered_buff_STORE)(aTHX_ (rx),(paren),(value))
+    RX_ENGINE(rx)->numbered_buff_STORE(aTHX_ (rx),(paren),(value))
 
 #define CALLREG_NUMBUF_LENGTH(rx,sv,paren)                              \
-    CALL_FPTR(RX_ENGINE(rx)->numbered_buff_LENGTH)(aTHX_ (rx),(sv),(paren))
+    RX_ENGINE(rx)->numbered_buff_LENGTH(aTHX_ (rx),(sv),(paren))
 
 #define CALLREG_NAMED_BUFF_FETCH(rx, key, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), (key), NULL, ((flags) | RXapif_FETCH))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), NULL, ((flags) | RXapif_FETCH))
 
 #define CALLREG_NAMED_BUFF_STORE(rx, key, value, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), (key), (value), ((flags) | RXapif_STORE))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), (value), ((flags) | RXapif_STORE))
 
 #define CALLREG_NAMED_BUFF_DELETE(rx, key, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx),(key), NULL, ((flags) | RXapif_DELETE))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx),(key), NULL, ((flags) | RXapif_DELETE))
 
 #define CALLREG_NAMED_BUFF_CLEAR(rx, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_CLEAR))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_CLEAR))
 
 #define CALLREG_NAMED_BUFF_EXISTS(rx, key, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), (key), NULL, ((flags) | RXapif_EXISTS))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), NULL, ((flags) | RXapif_EXISTS))
 
 #define CALLREG_NAMED_BUFF_FIRSTKEY(rx, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff_iter)(aTHX_ (rx), NULL, ((flags) | RXapif_FIRSTKEY))
+    RX_ENGINE(rx)->named_buff_iter(aTHX_ (rx), NULL, ((flags) | RXapif_FIRSTKEY))
 
 #define CALLREG_NAMED_BUFF_NEXTKEY(rx, lastkey, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff_iter)(aTHX_ (rx), (lastkey), ((flags) | RXapif_NEXTKEY))
+    RX_ENGINE(rx)->named_buff_iter(aTHX_ (rx), (lastkey), ((flags) | RXapif_NEXTKEY))
 
 #define CALLREG_NAMED_BUFF_SCALAR(rx, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_SCALAR))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_SCALAR))
 
 #define CALLREG_NAMED_BUFF_COUNT(rx) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), NULL, NULL, RXapif_REGNAMES_COUNT)
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, RXapif_REGNAMES_COUNT)
 
 #define CALLREG_NAMED_BUFF_ALL(rx, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), NULL, NULL, flags)
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, flags)
 
 #define CALLREG_PACKAGE(rx) \
-    CALL_FPTR(RX_ENGINE(rx)->qr_package)(aTHX_ (rx))
+    RX_ENGINE(rx)->qr_package(aTHX_ (rx))
 
 #if defined(USE_ITHREADS)
 #define CALLREGDUPE(prog,param) \
     Perl_re_dup(aTHX_ (prog),(param))
 
 #define CALLREGDUPE_PVT(prog,param) \
-    (prog ? CALL_FPTR(RX_ENGINE(prog)->dupe)(aTHX_ (prog),(param)) \
+    (prog ? RX_ENGINE(prog)->dupe(aTHX_ (prog),(param)) \
           : (REGEXP *)NULL)
 #endif
 
@@ -4210,12 +4217,12 @@ struct perl_memory_debug_header {
 #  endif
 #endif
 
-typedef int (CPERLscope(*runops_proc_t)) (pTHX);
-typedef void (CPERLscope(*share_proc_t)) (pTHX_ SV *sv);
-typedef int  (CPERLscope(*thrhook_proc_t)) (pTHX);
-typedef OP* (CPERLscope(*PPADDR_t)[]) (pTHX);
-typedef bool (CPERLscope(*destroyable_proc_t)) (pTHX_ SV *sv);
-typedef void (CPERLscope(*despatch_signals_proc_t)) (pTHX);
+typedef int (*runops_proc_t)(pTHX);
+typedef void (*share_proc_t) (pTHX_ SV *sv);
+typedef int  (*thrhook_proc_t) (pTHX);
+typedef OP* (*PPADDR_t[]) (pTHX);
+typedef bool (*destroyable_proc_t) (pTHX_ SV *sv);
+typedef void (*despatch_signals_proc_t) (pTHX);
 
 /* _ (for $_) must be first in the following list (DEFSV requires it) */
 #define THREADSV_NAMES "_123456789&`'+/.,\\\";^-%=|~:\001\005!@"
@@ -4841,18 +4848,18 @@ struct perl_debug_pad {
        PERL_DEBUG_PAD(i))
 
 /* Enable variables which are pointers to functions */
-typedef void (CPERLscope(*peep_t))(pTHX_ OP* o);
-typedef regexp*(CPERLscope(*regcomp_t)) (pTHX_ char* exp, char* xend, PMOP* pm);
-typedef I32 (CPERLscope(*regexec_t)) (pTHX_ regexp* prog, char* stringarg,
+typedef void (*peep_t)(pTHX_ OP* o);
+typedef regexp* (*regcomp_t) (pTHX_ char* exp, char* xend, PMOP* pm);
+typedef I32     (*regexec_t) (pTHX_ regexp* prog, char* stringarg,
                                      char* strend, char* strbeg, I32 minend,
                                      SV* screamer, void* data, U32 flags);
-typedef char* (CPERLscope(*re_intuit_start_t)) (pTHX_ regexp *prog, SV *sv,
+typedef char*   (*re_intuit_start_t) (pTHX_ regexp *prog, SV *sv,
                                                char *strpos, char *strend,
                                                U32 flags,
                                                re_scream_pos_data *d);
-typedef SV*    (CPERLscope(*re_intuit_string_t)) (pTHX_ regexp *prog);
-typedef void   (CPERLscope(*regfree_t)) (pTHX_ struct regexp* r);
-typedef regexp*(CPERLscope(*regdupe_t)) (pTHX_ const regexp* r, CLONE_PARAMS *param);
+typedef SV*    (*re_intuit_string_t) (pTHX_ regexp *prog);
+typedef void   (*regfree_t) (pTHX_ struct regexp* r);
+typedef regexp* (*regdupe_t) (pTHX_ const regexp* r, CLONE_PARAMS *param);
 
 typedef void (*DESTRUCTORFUNC_NOCONTEXT_t) (void*);
 typedef void (*DESTRUCTORFUNC_t) (pTHX_ void*);
@@ -4869,10 +4876,10 @@ typedef void (*XSUBADDR_t) (pTHX_ CV *);
 #define PERLVARIC(var,type,init) type var;
 #define PERLVARISC(var,init) const char var[sizeof(init)];
 
-typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX);
-typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);
-typedef void(CPERLscope(*Perl_ophook_t))(pTHX_ OP*);
-typedef int (CPERLscope(*Perl_keyword_plugin_t))(pTHX_ char*, STRLEN, OP**);
+typedef OP* (*Perl_ppaddr_t)(pTHX);
+typedef OP* (*Perl_check_t) (pTHX_ OP*);
+typedef void(*Perl_ophook_t)(pTHX_ OP*);
+typedef int (*Perl_keyword_plugin_t)(pTHX_ char*, STRLEN, OP**);
 
 #define KEYWORD_PLUGIN_DECLINE 0
 #define KEYWORD_PLUGIN_STMT    1
@@ -5721,7 +5728,7 @@ typedef struct am_table_short AMTS;
 
 #ifndef PERL_MICRO
 #      ifndef PERL_ASYNC_CHECK
-#              define PERL_ASYNC_CHECK() if (PL_sig_pending) CALL_FPTR(PL_signalhook)(aTHX)
+#              define PERL_ASYNC_CHECK() if (PL_sig_pending) PL_signalhook(aTHX)
 #      endif
 #endif
 
index cce574d..a0b3572 100644 (file)
@@ -557,7 +557,7 @@ that's left to do is run it. The actual execution is done by the
 C<runops_standard> function in F<run.c>; more specifically, it's done by
 these three innocent looking lines:
 
-    while ((PL_op = CALL_FPTR(PL_op->op_ppaddr)(aTHX))) {
+    while ((PL_op = PL_op->op_ppaddr(aTHX))) {
         PERL_ASYNC_CHECK();
     }
 
index 57118a4..1e90894 100644 (file)
--- a/pp_ctl.c
+++ b/pp_ctl.c
@@ -2752,7 +2752,7 @@ PP(pp_goto)
                 * for each op.  For now, we punt on the hard ones. */
                if (PL_op->op_type == OP_ENTERITER)
                    DIE(aTHX_ "Can't \"goto\" into the middle of a foreach loop");
-               CALL_FPTR(PL_op->op_ppaddr)(aTHX);
+               PL_op->op_ppaddr(aTHX);
            }
            PL_op = oldop;
        }
index e1f0fc9..02f425a 100644 (file)
--- a/pp_hot.c
+++ b/pp_hot.c
@@ -2925,7 +2925,7 @@ try_autoload:
 
        /* CvXSUB(cv) must not be NULL because newXS() refuses NULL xsub address */
        assert(CvXSUB(cv));
-       CALL_FPTR(CvXSUB(cv))(aTHX_ cv);
+       CvXSUB(cv)(aTHX_ cv);
 
        /* Enforce some sanity in scalar context. */
        if (gimme == G_SCALAR && ++markix != PL_stack_sp - PL_stack_base ) {
diff --git a/run.c b/run.c
index eb465da..368ef03 100644 (file)
--- a/run.c
+++ b/run.c
@@ -38,7 +38,7 @@ Perl_runops_standard(pTHX)
 {
     dVAR;
     register OP *op = PL_op;
-    while ((PL_op = op = CALL_FPTR(op->op_ppaddr)(aTHX))) {
+    while ((PL_op = op = op->op_ppaddr(aTHX))) {
     }
 
     TAINT_NOT;
diff --git a/sv.c b/sv.c
index 9f2fde4..c9ab89e 100644 (file)
--- a/sv.c
+++ b/sv.c
@@ -5184,7 +5184,7 @@ Perl_sv_unmagic(pTHX_ SV *const sv, const int type)
             const MGVTBL* const vtbl = mg->mg_virtual;
            *mgp = mg->mg_moremagic;
            if (vtbl && vtbl->svt_free)
-               CALL_FPTR(vtbl->svt_free)(aTHX_ sv, mg);
+               vtbl->svt_free(aTHX_ sv, mg);
            if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
                if (mg->mg_len > 0)
                    Safefree(mg->mg_ptr);
@@ -10867,7 +10867,7 @@ Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param)
                nmg->mg_ptr = (char*)sv_dup_inc((const SV *)nmg->mg_ptr, param);
        }
        if ((nmg->mg_flags & MGf_DUP) && nmg->mg_virtual && nmg->mg_virtual->svt_dup) {
-           CALL_FPTR(nmg->mg_virtual->svt_dup)(aTHX_ nmg, param);
+           nmg->mg_virtual->svt_dup(aTHX_ nmg, param);
        }
     }
     return mgret;
diff --git a/sv.h b/sv.h
index a49954d..5819ee4 100644 (file)
--- a/sv.h
+++ b/sv.h
@@ -1876,10 +1876,10 @@ Returns a pointer to the character buffer.
 =cut
 */
 
-#define SvSHARE(sv) CALL_FPTR(PL_sharehook)(aTHX_ sv)
-#define SvLOCK(sv) CALL_FPTR(PL_lockhook)(aTHX_ sv)
-#define SvUNLOCK(sv) CALL_FPTR(PL_unlockhook)(aTHX_ sv)
-#define SvDESTROYABLE(sv) CALL_FPTR(PL_destroyhook)(aTHX_ sv)
+#define SvSHARE(sv) PL_sharehook(aTHX_ sv)
+#define SvLOCK(sv) PL_lockhook(aTHX_ sv)
+#define SvUNLOCK(sv) PL_unlockhook(aTHX_ sv)
+#define SvDESTROYABLE(sv) PL_destroyhook(aTHX_ sv)
 
 #define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
 #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END
diff --git a/toke.c b/toke.c
index 544cd1a..b8eb11a 100644 (file)
--- a/toke.c
+++ b/toke.c
@@ -6131,7 +6131,7 @@ Perl_yylex(pTHX)
            int result;
            char *saved_bufptr = PL_bufptr;
            PL_bufptr = s;
-           result = CALL_FPTR(PL_keyword_plugin)(aTHX_ PL_tokenbuf, len, &o);
+           result = PL_keyword_plugin(aTHX_ PL_tokenbuf, len, &o);
            s = PL_bufptr;
            if (result == KEYWORD_PLUGIN_DECLINE) {
                /* not a plugged-in keyword */