Silence several -Wunused-parameter warnings about my_perl
authorBrian Fraser <fraserbn@gmail.com>
Sat, 31 May 2014 14:54:22 +0000 (16:54 +0200)
committerBrian Fraser <fraserbn@gmail.com>
Thu, 12 Jun 2014 22:00:33 +0000 (00:00 +0200)
This meant sprinkling some PERL_UNUSED_CONTEXT invocations,
as well as stopping some functions from getting my_perl in
the first place; all of the functions in the latter category
are internal (S_ prefix and s or i in embed.fnc), so
this should be both safe and economical.

15 files changed:
dquote_static.c
embed.fnc
embed.h
hv.c
inline_invlist.c
mg.c
mro.c
op.c
perly.c
pp.c
proto.h
regcomp.c
regexec.c
sv.c
util.c

index 1f74ca5..15d168f 100644 (file)
@@ -21,6 +21,7 @@ S_regcurly(pTHX_ const char *s,
                                                 is an abnormal case */
     )
 {
+    PERL_UNUSED_CONTEXT;
     PERL_ARGS_ASSERT_REGCURLY;
 
     if (*s++ != '{')
index 659c432..7181ca7 100644 (file)
--- a/embed.fnc
+++ b/embed.fnc
@@ -1499,22 +1499,22 @@ Ap      |UV     |swash_fetch    |NN SV *swash|NN const U8 *ptr|bool do_utf8
 #ifdef PERL_IN_REGCOMP_C
 EiMR   |SV*    |add_cp_to_invlist      |NULLOK SV* invlist|const UV cp
 EsM    |void   |_append_range_to_invlist   |NN SV* const invlist|const UV start|const UV end
-EiMR   |UV*    |_invlist_array_init    |NN SV* const invlist|const bool will_have_0
-EiMR   |UV*    |invlist_array  |NN SV* const invlist
+EiMRn  |UV*    |_invlist_array_init    |NN SV* const invlist|const bool will_have_0
+EiMRn  |UV*    |invlist_array  |NN SV* const invlist
 EsM    |void   |invlist_extend    |NN SV* const invlist|const UV len
-EiMR   |UV     |invlist_max    |NN SV* const invlist
+EiMRn  |UV     |invlist_max    |NN SV* const invlist
 EiM    |void   |invlist_set_len|NN SV* const invlist|const UV len|const bool offset
-EiMR   |IV*    |get_invlist_previous_index_addr|NN SV* invlist
-EiMR   |IV     |invlist_previous_index|NN SV* const invlist
-EiM    |void   |invlist_set_previous_index|NN SV* const invlist|const IV index
-EiM    |void   |invlist_trim   |NN SV* const invlist
+EiMRn  |IV*    |get_invlist_previous_index_addr|NN SV* invlist
+EiMRn  |IV     |invlist_previous_index|NN SV* const invlist
+EiMn   |void   |invlist_set_previous_index|NN SV* const invlist|const IV index
+EiMn   |void   |invlist_trim   |NN SV* const invlist
 EiMR   |SV*    |invlist_clone  |NN SV* const invlist
-EiMR   |bool   |invlist_is_iterating|NN SV* const invlist
-EiMR   |STRLEN*|get_invlist_iter_addr  |NN SV* invlist
-EiM    |void   |invlist_iterinit|NN SV* invlist
-EsMR   |bool   |invlist_iternext|NN SV* invlist|NN UV* start|NN UV* end
-EiM    |void   |invlist_iterfinish|NN SV* invlist
-EiMR   |UV     |invlist_highest|NN SV* const invlist
+EiMRn  |bool   |invlist_is_iterating|NN SV* const invlist
+EiMRn  |STRLEN*|get_invlist_iter_addr  |NN SV* invlist
+EiMn   |void   |invlist_iterinit|NN SV* invlist
+EsMRn  |bool   |invlist_iternext|NN SV* invlist|NN UV* start|NN UV* end
+EiMn   |void   |invlist_iterfinish|NN SV* invlist
+EiMRn  |UV     |invlist_highest|NN SV* const invlist
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
 EXmM   |void   |_invlist_intersection  |NN SV* const a|NN SV* const b|NN SV** i
@@ -1531,7 +1531,7 @@ EXMpR     |SV*    |_new_invlist   |IV initial_size
 EXMpR  |SV*    |_swash_to_invlist      |NN SV* const swash
 EXMpR  |SV*    |_add_range_to_invlist  |NULLOK SV* invlist|const UV start|const UV end
 EXMpR  |SV*    |_setup_canned_invlist|const STRLEN size|const UV element0|NN UV** other_elements_ptr
-EXMp   |void   |_invlist_populate_swatch   |NN SV* const invlist|const UV start|const UV end|NN U8* swatch
+EXMpn  |void   |_invlist_populate_swatch   |NN SV* const invlist|const UV start|const UV end|NN U8* swatch
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C)
 EXp    |SV*    |_core_swash_init|NN const char* pkg|NN const char* name \
@@ -1540,10 +1540,10 @@ EXp     |SV*    |_core_swash_init|NN const char* pkg|NN const char* name \
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
 EXMpR  |SV*    |_invlist_contents|NN SV* const invlist
-EiMR   |bool*  |get_invlist_offset_addr|NN SV* invlist
-EiMR   |UV     |_invlist_len   |NN SV* const invlist
-EMiR   |bool   |_invlist_contains_cp|NN SV* const invlist|const UV cp
-EXpMR  |IV     |_invlist_search        |NN SV* const invlist|const UV cp
+EiMRn  |bool*  |get_invlist_offset_addr|NN SV* invlist
+EiMRn  |UV     |_invlist_len   |NN SV* const invlist
+EMiRn  |bool   |_invlist_contains_cp|NN SV* const invlist|const UV cp
+EXpMRn |IV     |_invlist_search        |NN SV* const invlist|const UV cp
 EXMpR  |SV*    |_get_swash_invlist|NN SV* const swash
 EXMpR  |HV*    |_swash_inversion_hash  |NN SV* const swash
 #endif
@@ -2104,7 +2104,7 @@ Es        |regnode*|regclass      |NN RExC_state_t *pRExC_state \
                                |NULLOK SV** ret_invlist
 Es     |void|add_above_Latin1_folds|NN RExC_state_t *pRExC_state|const U8 cp \
                                |NN SV** invlist
-Es     |bool|could_it_be_a_POSIX_class|NN RExC_state_t *pRExC_state
+Esn    |bool|could_it_be_a_POSIX_class|NN RExC_state_t *pRExC_state
 Es     |regnode*|handle_regex_sets|NN RExC_state_t *pRExC_state \
                                |NULLOK SV ** return_invlist            \
                                |NN I32 *flagp|U32 depth                \
@@ -2128,24 +2128,24 @@ Es      |U32    |join_exact     |NN RExC_state_t *pRExC_state \
                                |NN regnode *scan|NN UV *min_subtract  \
                                |NN bool *unfolded_multi_char          \
                                |U32 flags|NULLOK regnode *val|U32 depth
-EsR    |char * |regpatws       |NN RExC_state_t *pRExC_state \
+EsRn   |char * |regpatws       |NN RExC_state_t *pRExC_state \
                                |NN char *p|const bool recognize_comment
 Ei     |void   |alloc_maybe_populate_EXACT|NN RExC_state_t *pRExC_state \
                                |NN regnode *node|NN I32 *flagp|STRLEN len \
                                |UV code_point|bool downgradable
-Ei     |U8   |compute_EXACTish|NN RExC_state_t *pRExC_state
+Ein    |U8   |compute_EXACTish|NN RExC_state_t *pRExC_state
 Es     |char * |nextchar       |NN RExC_state_t *pRExC_state
-Ei     |char * |reg_skipcomment|NN RExC_state_t *pRExC_state|NN char * p
+Ein    |char * |reg_skipcomment|NN RExC_state_t *pRExC_state|NN char * p
 Es     |void   |scan_commit    |NN const RExC_state_t *pRExC_state \
                                |NN struct scan_data_t *data        \
                                |NN SSize_t *minlenp                \
                                |int is_inf
 Es     |void   |populate_ANYOF_from_invlist|NN regnode *node|NN SV** invlist_ptr
 Es     |void   |ssc_anything   |NN regnode_ssc *ssc
-EsR    |int    |ssc_is_anything|NN const regnode_ssc *ssc
+EsRn   |int    |ssc_is_anything|NN const regnode_ssc *ssc
 Es     |void   |ssc_init       |NN const RExC_state_t *pRExC_state \
                                |NN regnode_ssc *ssc
-EsR    |int    |ssc_is_cp_posixl_init|NN const RExC_state_t *pRExC_state \
+EsRn   |int    |ssc_is_cp_posixl_init|NN const RExC_state_t *pRExC_state \
                                |NN const regnode_ssc *ssc
 Es     |void   |ssc_and        |NN const RExC_state_t *pRExC_state \
                                |NN regnode_ssc *ssc                \
@@ -2164,7 +2164,7 @@ Ei        |void   |ssc_add_range  |NN regnode_ssc *ssc \
                                |UV const start|UV const end
 Ei     |void   |ssc_cp_and     |NN regnode_ssc *ssc \
                                |UV const cp
-Ei     |void   |ssc_clear_locale|NN regnode_ssc *ssc
+Ein    |void   |ssc_clear_locale|NN regnode_ssc *ssc
 Es     |void   |ssc_finalize   |NN RExC_state_t *pRExC_state \
                                |NN regnode_ssc *ssc
 Es     |SSize_t|study_chunk    |NN RExC_state_t *pRExC_state \
@@ -2238,7 +2238,7 @@ ERs       |char*  |find_byclass   |NN regexp * prog|NN const regnode *c \
                                |NULLOK regmatch_info *reginfo
 Es     |void   |to_utf8_substr |NN regexp * prog
 Es     |bool   |to_byte_substr |NN regexp * prog
-ERs    |I32    |reg_check_named_buff_matched   |NN const regexp *rex \
+ERsn   |I32    |reg_check_named_buff_matched   |NN const regexp *rex \
                                                |NN const regnode *scan
 #  ifdef DEBUGGING
 Es     |void   |dump_exec_pos  |NN const char *locinput|NN const regnode *scan|NN const char *loc_regeol\
diff --git a/embed.h b/embed.h
index 6b0f834..182575f 100644 (file)
--- a/embed.h
+++ b/embed.h
 #  endif
 #  if defined(PERL_IN_REGCOMP_C)
 #define _append_range_to_invlist(a,b,c)        S__append_range_to_invlist(aTHX_ a,b,c)
-#define _invlist_array_init(a,b)       S__invlist_array_init(aTHX_ a,b)
+#define _invlist_array_init    S__invlist_array_init
 #define add_above_Latin1_folds(a,b,c)  S_add_above_Latin1_folds(aTHX_ a,b,c)
 #define add_cp_to_invlist(a,b) S_add_cp_to_invlist(aTHX_ a,b)
 #define add_data               S_add_data
 #define alloc_maybe_populate_EXACT(a,b,c,d,e,f)        S_alloc_maybe_populate_EXACT(aTHX_ a,b,c,d,e,f)
-#define compute_EXACTish(a)    S_compute_EXACTish(aTHX_ a)
+#define compute_EXACTish       S_compute_EXACTish
 #define construct_ahocorasick_from_trie(a,b,c) S_construct_ahocorasick_from_trie(aTHX_ a,b,c)
-#define could_it_be_a_POSIX_class(a)   S_could_it_be_a_POSIX_class(aTHX_ a)
+#define could_it_be_a_POSIX_class      S_could_it_be_a_POSIX_class
 #define get_ANYOF_cp_list_for_ssc(a,b) S_get_ANYOF_cp_list_for_ssc(aTHX_ a,b)
-#define get_invlist_iter_addr(a)       S_get_invlist_iter_addr(aTHX_ a)
-#define get_invlist_previous_index_addr(a)     S_get_invlist_previous_index_addr(aTHX_ a)
+#define get_invlist_iter_addr  S_get_invlist_iter_addr
+#define get_invlist_previous_index_addr        S_get_invlist_previous_index_addr
 #define grok_bslash_N(a,b,c,d,e,f,g)   S_grok_bslash_N(aTHX_ a,b,c,d,e,f,g)
 #define handle_regex_sets(a,b,c,d,e)   S_handle_regex_sets(aTHX_ a,b,c,d,e)
-#define invlist_array(a)       S_invlist_array(aTHX_ a)
+#define invlist_array          S_invlist_array
 #define invlist_clone(a)       S_invlist_clone(aTHX_ a)
 #define invlist_extend(a,b)    S_invlist_extend(aTHX_ a,b)
-#define invlist_highest(a)     S_invlist_highest(aTHX_ a)
-#define invlist_is_iterating(a)        S_invlist_is_iterating(aTHX_ a)
-#define invlist_iterfinish(a)  S_invlist_iterfinish(aTHX_ a)
-#define invlist_iterinit(a)    S_invlist_iterinit(aTHX_ a)
-#define invlist_iternext(a,b,c)        S_invlist_iternext(aTHX_ a,b,c)
-#define invlist_max(a)         S_invlist_max(aTHX_ a)
-#define invlist_previous_index(a)      S_invlist_previous_index(aTHX_ a)
+#define invlist_highest                S_invlist_highest
+#define invlist_is_iterating   S_invlist_is_iterating
+#define invlist_iterfinish     S_invlist_iterfinish
+#define invlist_iterinit       S_invlist_iterinit
+#define invlist_iternext       S_invlist_iternext
+#define invlist_max            S_invlist_max
+#define invlist_previous_index S_invlist_previous_index
 #define invlist_set_len(a,b,c) S_invlist_set_len(aTHX_ a,b,c)
-#define invlist_set_previous_index(a,b)        S_invlist_set_previous_index(aTHX_ a,b)
-#define invlist_trim(a)                S_invlist_trim(aTHX_ a)
+#define invlist_set_previous_index     S_invlist_set_previous_index
+#define invlist_trim           S_invlist_trim
 #define join_exact(a,b,c,d,e,f,g)      S_join_exact(aTHX_ a,b,c,d,e,f,g)
 #define make_trie(a,b,c,d,e,f,g,h)     S_make_trie(aTHX_ a,b,c,d,e,f,g,h)
 #define nextchar(a)            S_nextchar(aTHX_ a)
 #define reg_node(a,b)          S_reg_node(aTHX_ a,b)
 #define reg_recode(a,b)                S_reg_recode(aTHX_ a,b)
 #define reg_scan_name(a,b)     S_reg_scan_name(aTHX_ a,b)
-#define reg_skipcomment(a,b)   S_reg_skipcomment(aTHX_ a,b)
+#define reg_skipcomment                S_reg_skipcomment
 #define reganode(a,b,c)                S_reganode(aTHX_ a,b,c)
 #define regatom(a,b,c)         S_regatom(aTHX_ a,b,c)
 #define regbranch(a,b,c,d)     S_regbranch(aTHX_ a,b,c,d)
 #define regclass(a,b,c,d,e,f,g)        S_regclass(aTHX_ a,b,c,d,e,f,g)
 #define reginsert(a,b,c,d)     S_reginsert(aTHX_ a,b,c,d)
-#define regpatws(a,b,c)                S_regpatws(aTHX_ a,b,c)
+#define regpatws               S_regpatws
 #define regpiece(a,b,c)                S_regpiece(aTHX_ a,b,c)
 #define regpposixcc(a,b,c)     S_regpposixcc(aTHX_ a,b,c)
 #define regtail(a,b,c,d)       S_regtail(aTHX_ a,b,c,d)
 #define ssc_add_range(a,b,c)   S_ssc_add_range(aTHX_ a,b,c)
 #define ssc_and(a,b,c)         S_ssc_and(aTHX_ a,b,c)
 #define ssc_anything(a)                S_ssc_anything(aTHX_ a)
-#define ssc_clear_locale(a)    S_ssc_clear_locale(aTHX_ a)
+#define ssc_clear_locale       S_ssc_clear_locale
 #define ssc_cp_and(a,b)                S_ssc_cp_and(aTHX_ a,b)
 #define ssc_finalize(a,b)      S_ssc_finalize(aTHX_ a,b)
 #define ssc_init(a,b)          S_ssc_init(aTHX_ a,b)
 #define ssc_intersection(a,b,c)        S_ssc_intersection(aTHX_ a,b,c)
-#define ssc_is_anything(a)     S_ssc_is_anything(aTHX_ a)
-#define ssc_is_cp_posixl_init(a,b)     S_ssc_is_cp_posixl_init(aTHX_ a,b)
+#define ssc_is_anything                S_ssc_is_anything
+#define ssc_is_cp_posixl_init  S_ssc_is_cp_posixl_init
 #define ssc_or(a,b,c)          S_ssc_or(aTHX_ a,b,c)
 #define ssc_union(a,b,c)       S_ssc_union(aTHX_ a,b,c)
 #define study_chunk(a,b,c,d,e,f,g,h,i,j,k)     S_study_chunk(aTHX_ a,b,c,d,e,f,g,h,i,j,k)
 #  endif
 #  if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
 #define _get_swash_invlist(a)  Perl__get_swash_invlist(aTHX_ a)
-#define _invlist_contains_cp(a,b)      S__invlist_contains_cp(aTHX_ a,b)
+#define _invlist_contains_cp   S__invlist_contains_cp
 #define _invlist_contents(a)   Perl__invlist_contents(aTHX_ a)
-#define _invlist_len(a)                S__invlist_len(aTHX_ a)
-#define _invlist_search(a,b)   Perl__invlist_search(aTHX_ a,b)
+#define _invlist_len           S__invlist_len
+#define _invlist_search                Perl__invlist_search
 #define _swash_inversion_hash(a)       Perl__swash_inversion_hash(aTHX_ a)
-#define get_invlist_offset_addr(a)     S_get_invlist_offset_addr(aTHX_ a)
+#define get_invlist_offset_addr        S_get_invlist_offset_addr
 #  endif
 #  if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C)
 #define _core_swash_init(a,b,c,d,e,f,g)        Perl__core_swash_init(aTHX_ a,b,c,d,e,f,g)
 #define _add_range_to_invlist(a,b,c)   Perl__add_range_to_invlist(aTHX_ a,b,c)
 #define _invlist_intersection_maybe_complement_2nd(a,b,c,d)    Perl__invlist_intersection_maybe_complement_2nd(aTHX_ a,b,c,d)
 #define _invlist_invert(a)     Perl__invlist_invert(aTHX_ a)
-#define _invlist_populate_swatch(a,b,c,d)      Perl__invlist_populate_swatch(aTHX_ a,b,c,d)
+#define _invlist_populate_swatch       Perl__invlist_populate_swatch
 #define _invlist_union_maybe_complement_2nd(a,b,c,d)   Perl__invlist_union_maybe_complement_2nd(aTHX_ a,b,c,d)
 #define _new_invlist(a)                Perl__new_invlist(aTHX_ a)
 #define _setup_canned_invlist(a,b,c)   Perl__setup_canned_invlist(aTHX_ a,b,c)
 #define find_byclass(a,b,c,d,e)        S_find_byclass(aTHX_ a,b,c,d,e)
 #define isFOO_lc(a,b)          S_isFOO_lc(aTHX_ a,b)
 #define isFOO_utf8_lc(a,b)     S_isFOO_utf8_lc(aTHX_ a,b)
-#define reg_check_named_buff_matched(a,b)      S_reg_check_named_buff_matched(aTHX_ a,b)
+#define reg_check_named_buff_matched   S_reg_check_named_buff_matched
 #define regcppop(a,b)          S_regcppop(aTHX_ a,b)
 #define regcppush(a,b,c)       S_regcppush(aTHX_ a,b,c)
 #define reghop3                        S_reghop3
diff --git a/hv.c b/hv.c
index 6e6adcb..5a975ed 100644 (file)
--- a/hv.c
+++ b/hv.c
@@ -3500,6 +3500,7 @@ struct refcounted_he *
 Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he)
 {
     dVAR;
+    PERL_UNUSED_CONTEXT;
     if (he) {
        HINTS_REFCNT_LOCK;
        he->refcounted_he_refcnt++;
@@ -3524,6 +3525,7 @@ Perl_cop_fetch_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags) {
     struct refcounted_he *const chain = cop->cop_hints_hash;
 
     PERL_ARGS_ASSERT_COP_FETCH_LABEL;
+    PERL_UNUSED_CONTEXT;
 
     if (!chain)
        return NULL;
index 1aea9f7..1875a05 100644 (file)
 #define FROM_INTERNAL_SIZE(x) ((x)/ sizeof(UV))
 
 PERL_STATIC_INLINE bool*
-S_get_invlist_offset_addr(pTHX_ SV* invlist)
+S_get_invlist_offset_addr(SV* invlist)
 {
     /* Return the address of the field that says whether the inversion list is
      * offset (it contains 1) or not (contains 0) */
-
     PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR;
 
     assert(SvTYPE(invlist) == SVt_INVLIST);
@@ -31,7 +30,7 @@ S_get_invlist_offset_addr(pTHX_ SV* invlist)
 }
 
 PERL_STATIC_INLINE UV
-S__invlist_len(pTHX_ SV* const invlist)
+S__invlist_len(SV* const invlist)
 {
     /* Returns the current number of elements stored in the inversion list's
      * array */
@@ -46,7 +45,7 @@ S__invlist_len(pTHX_ SV* const invlist)
 }
 
 PERL_STATIC_INLINE bool
-S__invlist_contains_cp(pTHX_ SV* const invlist, const UV cp)
+S__invlist_contains_cp(SV* const invlist, const UV cp)
 {
     /* Does <invlist> contain code point <cp> as part of the set? */
 
diff --git a/mg.c b/mg.c
index cf0d323..63d0d61 100644 (file)
--- a/mg.c
+++ b/mg.c
@@ -700,6 +700,7 @@ int
 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
 {
     PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET;
+    PERL_UNUSED_CONTEXT;
     PERL_UNUSED_ARG(sv);
     PERL_UNUSED_ARG(mg);
     Perl_croak_no_modify();
@@ -1433,6 +1434,7 @@ Perl_csighandler_init(void)
 static void
 unblock_sigmask(pTHX_ void* newset)
 {
+    PERL_UNUSED_CONTEXT;
     sigprocmask(SIG_UNBLOCK, (sigset_t*)newset, NULL);
 }
 #endif
@@ -2066,6 +2068,7 @@ Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg)
 
     PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P;
     PERL_UNUSED_ARG(sv);
+    PERL_UNUSED_CONTEXT;
 
     /* Reset the iterator when the array is cleared */
 #if IVSIZE == I32SIZE
diff --git a/mro.c b/mro.c
index bd62e9d..2440397 100644 (file)
--- a/mro.c
+++ b/mro.c
@@ -142,6 +142,7 @@ Perl_mro_meta_init(pTHX_ HV* stash)
     struct mro_meta* newmeta;
 
     PERL_ARGS_ASSERT_MRO_META_INIT;
+    PERL_UNUSED_CONTEXT;
     assert(HvAUX(stash));
     assert(!(HvAUX(stash)->xhv_mro_meta));
     Newxz(newmeta, 1, struct mro_meta);
diff --git a/op.c b/op.c
index d5ec4b4..be20c21 100644 (file)
--- a/op.c
+++ b/op.c
@@ -115,7 +115,7 @@ recursive, but it's recursive on basic blocks, not on tree nodes.
  */
 
 STATIC void
-S_prune_chain_head(pTHX_ OP** op_p)
+S_prune_chain_head(OP** op_p)
 {
     while (*op_p
         && (   (*op_p)->op_type == OP_NULL
@@ -162,6 +162,10 @@ S_new_slab(pTHX_ size_t sz)
     slab->opslab_size = (U16)sz;
 #else
     OPSLAB *slab = (OPSLAB *)PerlMemShared_calloc(sz, sizeof(I32 *));
+#endif
+#ifndef WIN32
+    /* The context is unused in non-Windows */
+    PERL_UNUSED_CONTEXT;
 #endif
     slab->opslab_first = (OPSLOT *)((I32 **)slab + sz - 1);
     return slab;
@@ -3323,7 +3327,7 @@ Perl_newPROG(pTHX_ OP *o)
        ENTER;
        CALL_PEEP(PL_eval_start);
        finalize_optree(PL_eval_root);
-        S_prune_chain_head(aTHX_ &PL_eval_start);
+        S_prune_chain_head(&PL_eval_start);
        LEAVE;
        PL_savestack_ix = i;
     }
@@ -3368,7 +3372,7 @@ Perl_newPROG(pTHX_ OP *o)
        PL_main_root->op_next = 0;
        CALL_PEEP(PL_main_start);
        finalize_optree(PL_main_root);
-        S_prune_chain_head(aTHX_ &PL_main_start);
+        S_prune_chain_head(&PL_main_start);
        cv_forget_slab(PL_compcv);
        PL_compcv = 0;
 
@@ -3690,7 +3694,7 @@ S_gen_constant_list(pTHX_ OP *o)
     curop = LINKLIST(o);
     o->op_next = 0;
     CALL_PEEP(curop);
-    S_prune_chain_head(aTHX_ &curop);
+    S_prune_chain_head(&curop);
     PL_op = curop;
     Perl_pp_pushmark(aTHX);
     CALLRUNOPS(aTHX);
@@ -4918,7 +4922,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg, I32 floor)
            /* have to peep the DOs individually as we've removed it from
             * the op_next chain */
            CALL_PEEP(o);
-            S_prune_chain_head(aTHX_ &(o->op_next));
+            S_prune_chain_head(&(o->op_next));
            if (is_compiletime)
                /* runtime finalizes as part of finalizing whole tree */
                finalize_optree(o);
@@ -7681,7 +7685,7 @@ Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
     CvROOT(cv)->op_next = 0;
     CALL_PEEP(CvSTART(cv));
     finalize_optree(CvROOT(cv));
-    S_prune_chain_head(aTHX_ &CvSTART(cv));
+    S_prune_chain_head(&CvSTART(cv));
 
     /* now that optimizer has done its work, adjust pad values */
 
@@ -8043,7 +8047,7 @@ Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs,
     CvROOT(cv)->op_next = 0;
     CALL_PEEP(CvSTART(cv));
     finalize_optree(CvROOT(cv));
-    S_prune_chain_head(aTHX_ &CvSTART(cv));
+    S_prune_chain_head(&CvSTART(cv));
 
     /* now that optimizer has done its work, adjust pad values */
 
@@ -8447,7 +8451,7 @@ Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block)
     CvROOT(cv)->op_next = 0;
     CALL_PEEP(CvSTART(cv));
     finalize_optree(CvROOT(cv));
-    S_prune_chain_head(aTHX_ &CvSTART(cv));
+    S_prune_chain_head(&CvSTART(cv));
     cv_forget_slab(cv);
 
   finish:
@@ -8673,6 +8677,7 @@ S_io_hints(pTHX_ OP *o)
        }
     }
 #else
+    PERL_UNUSED_CONTEXT;
     PERL_UNUSED_ARG(o);
 #endif
 }
@@ -11240,7 +11245,7 @@ S_inplace_aassign(pTHX_ OP *o) {
     if (defer_ix == (MAX_DEFERRED-1)) { \
         OP **defer = defer_queue[defer_base]; \
         CALL_RPEEP(*defer); \
-        S_prune_chain_head(aTHX_ defer); \
+        S_prune_chain_head(defer); \
        defer_base = (defer_base + 1) % MAX_DEFERRED; \
        defer_ix--; \
     } \
@@ -11298,7 +11303,7 @@ Perl_rpeep(pTHX_ OP *o)
                 OP **defer =
                         defer_queue[(defer_base + defer_ix--) % MAX_DEFERRED];
                 CALL_RPEEP(*defer);
-                S_prune_chain_head(aTHX_ defer);
+                S_prune_chain_head(defer);
             }
            break;
        }
@@ -12647,6 +12652,7 @@ Perl_wrap_op_checker(pTHX_ Optype opcode,
 {
     dVAR;
 
+    PERL_UNUSED_CONTEXT;
     PERL_ARGS_ASSERT_WRAP_OP_CHECKER;
     if (*old_checker_p) return;
     OP_CHECK_MUTEX_LOCK;
diff --git a/perly.c b/perly.c
index a7115b3..46d25a5 100644 (file)
--- a/perly.c
+++ b/perly.c
@@ -93,6 +93,7 @@ do {                                                          \
 static void
 yysymprint(pTHX_ PerlIO * const yyoutput, int yytype, const YYSTYPE * const yyvaluep)
 {
+    PERL_UNUSED_CONTEXT;
     if (yytype < YYNTOKENS) {
        YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 #   ifdef YYPRINT
diff --git a/pp.c b/pp.c
index 2c619ee..d4002ac 100644 (file)
--- a/pp.c
+++ b/pp.c
@@ -2977,6 +2977,7 @@ Perl_translate_substr_offsets(pTHX_ STRLEN curlen, IV pos1_iv,
     int    pos2_is_uv;
 
     PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS;
+    PERL_UNUSED_CONTEXT;
 
     if (!pos1_is_uv && pos1_iv < 0 && curlen) {
        pos1_is_uv = curlen-1 > ~(UV)pos1_iv;
diff --git a/proto.h b/proto.h
index 37ba5dd..fb5d5b3 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -6674,9 +6674,9 @@ STATIC void       S__append_range_to_invlist(pTHX_ SV* const invlist, const UV start,
 #define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST      \
        assert(invlist)
 
-PERL_STATIC_INLINE UV* S__invlist_array_init(pTHX_ SV* const invlist, const bool will_have_0)
+PERL_STATIC_INLINE UV* S__invlist_array_init(SV* const invlist, const bool will_have_0)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT   \
        assert(invlist)
 
@@ -6703,8 +6703,8 @@ PERL_STATIC_INLINE void   S_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t *pRExC_s
 #define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT    \
        assert(pRExC_state); assert(node); assert(flagp)
 
-PERL_STATIC_INLINE U8  S_compute_EXACTish(pTHX_ RExC_state_t *pRExC_state)
-                       __attribute__nonnull__(pTHX_1);
+PERL_STATIC_INLINE U8  S_compute_EXACTish(RExC_state_t *pRExC_state)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_COMPUTE_EXACTISH      \
        assert(pRExC_state)
 
@@ -6714,8 +6714,8 @@ STATIC regnode *  S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_sta
 #define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE       \
        assert(pRExC_state); assert(source)
 
-STATIC bool    S_could_it_be_a_POSIX_class(pTHX_ RExC_state_t *pRExC_state)
-                       __attribute__nonnull__(pTHX_1);
+STATIC bool    S_could_it_be_a_POSIX_class(RExC_state_t *pRExC_state)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS     \
        assert(pRExC_state)
 
@@ -6725,15 +6725,15 @@ STATIC SV*      S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, co
 #define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC     \
        assert(pRExC_state); assert(node)
 
-PERL_STATIC_INLINE STRLEN*     S_get_invlist_iter_addr(pTHX_ SV* invlist)
+PERL_STATIC_INLINE STRLEN*     S_get_invlist_iter_addr(SV* invlist)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \
        assert(invlist)
 
-PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(pTHX_ SV* invlist)
+PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(SV* invlist)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR       \
        assert(invlist)
 
@@ -6750,9 +6750,9 @@ STATIC regnode*   S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** retur
 #define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS     \
        assert(pRExC_state); assert(flagp); assert(oregcomp_parse)
 
-PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ SV* const invlist)
+PERL_STATIC_INLINE UV* S_invlist_array(SV* const invlist)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_INVLIST_ARRAY \
        assert(invlist)
 
@@ -6767,45 +6767,45 @@ STATIC void     S_invlist_extend(pTHX_ SV* const invlist, const UV len)
 #define PERL_ARGS_ASSERT_INVLIST_EXTEND        \
        assert(invlist)
 
-PERL_STATIC_INLINE UV  S_invlist_highest(pTHX_ SV* const invlist)
+PERL_STATIC_INLINE UV  S_invlist_highest(SV* const invlist)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_INVLIST_HIGHEST       \
        assert(invlist)
 
-PERL_STATIC_INLINE bool        S_invlist_is_iterating(pTHX_ SV* const invlist)
+PERL_STATIC_INLINE bool        S_invlist_is_iterating(SV* const invlist)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING  \
        assert(invlist)
 
-PERL_STATIC_INLINE void        S_invlist_iterfinish(pTHX_ SV* invlist)
-                       __attribute__nonnull__(pTHX_1);
+PERL_STATIC_INLINE void        S_invlist_iterfinish(SV* invlist)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_INVLIST_ITERFINISH    \
        assert(invlist)
 
-PERL_STATIC_INLINE void        S_invlist_iterinit(pTHX_ SV* invlist)
-                       __attribute__nonnull__(pTHX_1);
+PERL_STATIC_INLINE void        S_invlist_iterinit(SV* invlist)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_INVLIST_ITERINIT      \
        assert(invlist)
 
-STATIC bool    S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end)
+STATIC bool    S_invlist_iternext(SV* invlist, UV* start, UV* end)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2)
+                       __attribute__nonnull__(3);
 #define PERL_ARGS_ASSERT_INVLIST_ITERNEXT      \
        assert(invlist); assert(start); assert(end)
 
-PERL_STATIC_INLINE UV  S_invlist_max(pTHX_ SV* const invlist)
+PERL_STATIC_INLINE UV  S_invlist_max(SV* const invlist)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_INVLIST_MAX   \
        assert(invlist)
 
-PERL_STATIC_INLINE IV  S_invlist_previous_index(pTHX_ SV* const invlist)
+PERL_STATIC_INLINE IV  S_invlist_previous_index(SV* const invlist)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX        \
        assert(invlist)
 
@@ -6814,13 +6814,13 @@ PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len,
 #define PERL_ARGS_ASSERT_INVLIST_SET_LEN       \
        assert(invlist)
 
-PERL_STATIC_INLINE void        S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index)
-                       __attribute__nonnull__(pTHX_1);
+PERL_STATIC_INLINE void        S_invlist_set_previous_index(SV* const invlist, const IV index)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX    \
        assert(invlist)
 
-PERL_STATIC_INLINE void        S_invlist_trim(pTHX_ SV* const invlist)
-                       __attribute__nonnull__(pTHX_1);
+PERL_STATIC_INLINE void        S_invlist_trim(SV* const invlist)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_INVLIST_TRIM  \
        assert(invlist)
 
@@ -6885,9 +6885,9 @@ STATIC SV *       S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags)
 #define PERL_ARGS_ASSERT_REG_SCAN_NAME \
        assert(pRExC_state)
 
-PERL_STATIC_INLINE char *      S_reg_skipcomment(pTHX_ RExC_state_t *pRExC_state, char * p)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+PERL_STATIC_INLINE char *      S_reg_skipcomment(RExC_state_t *pRExC_state, char * p)
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT       \
        assert(pRExC_state); assert(p)
 
@@ -6920,10 +6920,10 @@ STATIC void     S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd, U
 #define PERL_ARGS_ASSERT_REGINSERT     \
        assert(pRExC_state); assert(opnd)
 
-STATIC char *  S_regpatws(pTHX_ RExC_state_t *pRExC_state, char *p, const bool recognize_comment)
+STATIC char *  S_regpatws(RExC_state_t *pRExC_state, char *p, const bool recognize_comment)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_REGPATWS      \
        assert(pRExC_state); assert(p)
 
@@ -6981,8 +6981,8 @@ STATIC void       S_ssc_anything(pTHX_ regnode_ssc *ssc)
 #define PERL_ARGS_ASSERT_SSC_ANYTHING  \
        assert(ssc)
 
-PERL_STATIC_INLINE void        S_ssc_clear_locale(pTHX_ regnode_ssc *ssc)
-                       __attribute__nonnull__(pTHX_1);
+PERL_STATIC_INLINE void        S_ssc_clear_locale(regnode_ssc *ssc)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE      \
        assert(ssc)
 
@@ -7009,16 +7009,16 @@ PERL_STATIC_INLINE void S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const inv
 #define PERL_ARGS_ASSERT_SSC_INTERSECTION      \
        assert(ssc); assert(invlist)
 
-STATIC int     S_ssc_is_anything(pTHX_ const regnode_ssc *ssc)
+STATIC int     S_ssc_is_anything(const regnode_ssc *ssc)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_SSC_IS_ANYTHING       \
        assert(ssc)
 
-STATIC int     S_ssc_is_cp_posixl_init(pTHX_ const RExC_state_t *pRExC_state, const regnode_ssc *ssc)
+STATIC int     S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnode_ssc *ssc)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \
        assert(pRExC_state); assert(ssc)
 
@@ -7077,9 +7077,9 @@ PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash)
 #define PERL_ARGS_ASSERT__GET_SWASH_INVLIST    \
        assert(swash)
 
-PERL_STATIC_INLINE bool        S__invlist_contains_cp(pTHX_ SV* const invlist, const UV cp)
+PERL_STATIC_INLINE bool        S__invlist_contains_cp(SV* const invlist, const UV cp)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP  \
        assert(invlist)
 
@@ -7089,15 +7089,15 @@ PERL_CALLCONV SV*       Perl__invlist_contents(pTHX_ SV* const invlist)
 #define PERL_ARGS_ASSERT__INVLIST_CONTENTS     \
        assert(invlist)
 
-PERL_STATIC_INLINE UV  S__invlist_len(pTHX_ SV* const invlist)
+PERL_STATIC_INLINE UV  S__invlist_len(SV* const invlist)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT__INVLIST_LEN  \
        assert(invlist)
 
-PERL_CALLCONV IV       Perl__invlist_search(pTHX_ SV* const invlist, const UV cp)
+PERL_CALLCONV IV       Perl__invlist_search(SV* const invlist, const UV cp)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT__INVLIST_SEARCH       \
        assert(invlist)
 
@@ -7107,9 +7107,9 @@ PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash)
 #define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
        assert(swash)
 
-PERL_STATIC_INLINE bool*       S_get_invlist_offset_addr(pTHX_ SV* invlist)
+PERL_STATIC_INLINE bool*       S_get_invlist_offset_addr(SV* invlist)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR       \
        assert(invlist)
 
@@ -7178,9 +7178,9 @@ PERL_CALLCONV void        Perl__invlist_invert(pTHX_ SV* const invlist)
 #define PERL_ARGS_ASSERT__INVLIST_INVERT       \
        assert(invlist)
 
-PERL_CALLCONV void     Perl__invlist_populate_swatch(pTHX_ SV* const invlist, const UV start, const UV end, U8* swatch)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_4);
+PERL_CALLCONV void     Perl__invlist_populate_swatch(SV* const invlist, const UV start, const UV end, U8* swatch)
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(4);
 #define PERL_ARGS_ASSERT__INVLIST_POPULATE_SWATCH      \
        assert(invlist); assert(swatch)
 
@@ -7234,10 +7234,10 @@ STATIC bool     S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character)
 #define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \
        assert(character)
 
-STATIC I32     S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
+STATIC I32     S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED  \
        assert(rex); assert(scan)
 
index e7c6662..b2c8ed4 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -895,7 +895,7 @@ S_ssc_anything(pTHX_ regnode_ssc *ssc)
 }
 
 STATIC int
-S_ssc_is_anything(pTHX_ const regnode_ssc *ssc)
+S_ssc_is_anything(const regnode_ssc *ssc)
 {
     /* Returns TRUE if the SSC 'ssc' can match the empty string and any code
      * point; FALSE otherwise.  Thus, this is used to see if using 'ssc' buys
@@ -967,8 +967,8 @@ S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc)
 }
 
 STATIC int
-S_ssc_is_cp_posixl_init(pTHX_ const RExC_state_t *pRExC_state,
-                              const regnode_ssc *ssc)
+S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state,
+                        const regnode_ssc *ssc)
 {
     /* Returns TRUE if the SSC 'ssc' is in its initial state with regard only
      * to the list of code points matched, and locale posix classes; hence does
@@ -1412,10 +1412,9 @@ S_ssc_cp_and(pTHX_ regnode_ssc *ssc, const UV cp)
 }
 
 PERL_STATIC_INLINE void
-S_ssc_clear_locale(pTHX_ regnode_ssc *ssc)
+S_ssc_clear_locale(regnode_ssc *ssc)
 {
     /* Set the SSC 'ssc' to not match any locale things */
-
     PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE;
 
     assert(is_ANYOF_SYNTHETIC(ssc));
@@ -5926,6 +5925,8 @@ S_has_runtime_code(pTHX_ RExC_state_t * const pRExC_state,
 {
     int n = 0;
     STRLEN s;
+    
+    PERL_UNUSED_CONTEXT;
 
     for (s = 0; s < plen; s++) {
        if (n < pRExC_state->num_code_blocks
@@ -7832,7 +7833,7 @@ S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags)
 /* The header definitions are in F<inline_invlist.c> */
 
 PERL_STATIC_INLINE UV*
-S__invlist_array_init(pTHX_ SV* const invlist, const bool will_have_0)
+S__invlist_array_init(SV* const invlist, const bool will_have_0)
 {
     /* Returns a pointer to the first element in the inversion list's array.
      * This is called upon initialization of an inversion list.  Where the
@@ -7858,7 +7859,7 @@ S__invlist_array_init(pTHX_ SV* const invlist, const bool will_have_0)
 }
 
 PERL_STATIC_INLINE UV*
-S_invlist_array(pTHX_ SV* const invlist)
+S_invlist_array(SV* const invlist)
 {
     /* Returns the pointer to the inversion list's array.  Every time the
      * length changes, this needs to be called in case malloc or realloc moved
@@ -7883,7 +7884,7 @@ S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)
 {
     /* Sets the current number of elements stored in the inversion list.
      * Updates SvCUR correspondingly */
-
+    PERL_UNUSED_CONTEXT;
     PERL_ARGS_ASSERT_INVLIST_SET_LEN;
 
     assert(SvTYPE(invlist) == SVt_INVLIST);
@@ -7896,11 +7897,10 @@ S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)
 }
 
 PERL_STATIC_INLINE IV*
-S_get_invlist_previous_index_addr(pTHX_ SV* invlist)
+S_get_invlist_previous_index_addr(SV* invlist)
 {
     /* Return the address of the IV that is reserved to hold the cached index
      * */
-
     PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR;
 
     assert(SvTYPE(invlist) == SVt_INVLIST);
@@ -7909,7 +7909,7 @@ S_get_invlist_previous_index_addr(pTHX_ SV* invlist)
 }
 
 PERL_STATIC_INLINE IV
-S_invlist_previous_index(pTHX_ SV* const invlist)
+S_invlist_previous_index(SV* const invlist)
 {
     /* Returns cached index of previous search */
 
@@ -7919,7 +7919,7 @@ S_invlist_previous_index(pTHX_ SV* const invlist)
 }
 
 PERL_STATIC_INLINE void
-S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index)
+S_invlist_set_previous_index(SV* const invlist, const IV index)
 {
     /* Caches <index> for later retrieval */
 
@@ -7931,7 +7931,7 @@ S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index)
 }
 
 PERL_STATIC_INLINE UV
-S_invlist_max(pTHX_ SV* const invlist)
+S_invlist_max(SV* const invlist)
 {
     /* Returns the maximum number of elements storable in the inversion list's
      * array, without having to realloc() */
@@ -8050,7 +8050,7 @@ S_invlist_extend(pTHX_ SV* const invlist, const UV new_max)
 }
 
 PERL_STATIC_INLINE void
-S_invlist_trim(pTHX_ SV* const invlist)
+S_invlist_trim(SV* const invlist)
 {
     PERL_ARGS_ASSERT_INVLIST_TRIM;
 
@@ -8149,7 +8149,7 @@ S__append_range_to_invlist(pTHX_ SV* const invlist,
 #ifndef PERL_IN_XSUB_RE
 
 IV
-Perl__invlist_search(pTHX_ SV* const invlist, const UV cp)
+Perl__invlist_search(SV* const invlist, const UV cp)
 {
     /* Searches the inversion list for the entry that contains the input code
      * point <cp>.  If <cp> is not in the list, -1 is returned.  Otherwise, the
@@ -8237,8 +8237,8 @@ Perl__invlist_search(pTHX_ SV* const invlist, const UV cp)
 }
 
 void
-Perl__invlist_populate_swatch(pTHX_ SV* const invlist,
-                                    const UV start, const UV end, U8* swatch)
+Perl__invlist_populate_swatch(SV* const invlist,
+                              const UV start, const UV end, U8* swatch)
 {
     /* populates a swatch of a swash the same way swatch_get() does in utf8.c,
      * but is used when the swash has an inversion list.  This makes this much
@@ -8950,7 +8950,7 @@ S_invlist_clone(pTHX_ SV* const invlist)
 }
 
 PERL_STATIC_INLINE STRLEN*
-S_get_invlist_iter_addr(pTHX_ SV* invlist)
+S_get_invlist_iter_addr(SV* invlist)
 {
     /* Return the address of the UV that contains the current iteration
      * position */
@@ -8963,7 +8963,7 @@ S_get_invlist_iter_addr(pTHX_ SV* invlist)
 }
 
 PERL_STATIC_INLINE void
-S_invlist_iterinit(pTHX_ SV* invlist)  /* Initialize iterator for invlist */
+S_invlist_iterinit(SV* invlist)        /* Initialize iterator for invlist */
 {
     PERL_ARGS_ASSERT_INVLIST_ITERINIT;
 
@@ -8971,7 +8971,7 @@ S_invlist_iterinit(pTHX_ SV* invlist)     /* Initialize iterator for invlist */
 }
 
 PERL_STATIC_INLINE void
-S_invlist_iterfinish(pTHX_ SV* invlist)
+S_invlist_iterfinish(SV* invlist)
 {
     /* Terminate iterator for invlist.  This is to catch development errors.
      * Any iteration that is interrupted before completed should call this
@@ -8987,7 +8987,7 @@ S_invlist_iterfinish(pTHX_ SV* invlist)
 }
 
 STATIC bool
-S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end)
+S_invlist_iternext(SV* invlist, UV* start, UV* end)
 {
     /* An C<invlist_iterinit> call on <invlist> must be used to set this up.
      * This call sets in <*start> and <*end>, the next range in <invlist>.
@@ -9022,7 +9022,7 @@ S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end)
 }
 
 PERL_STATIC_INLINE bool
-S_invlist_is_iterating(pTHX_ SV* const invlist)
+S_invlist_is_iterating(SV* const invlist)
 {
     PERL_ARGS_ASSERT_INVLIST_IS_ITERATING;
 
@@ -9030,7 +9030,7 @@ S_invlist_is_iterating(pTHX_ SV* const invlist)
 }
 
 PERL_STATIC_INLINE UV
-S_invlist_highest(pTHX_ SV* const invlist)
+S_invlist_highest(SV* const invlist)
 {
     /* Returns the highest code point that matches an inversion list.  This API
      * has an ambiguity, as it returns 0 under either the highest is actually
@@ -10982,7 +10982,7 @@ S_reg_recode(pTHX_ const char value, SV **encp)
 }
 
 PERL_STATIC_INLINE U8
-S_compute_EXACTish(pTHX_ RExC_state_t *pRExC_state)
+S_compute_EXACTish(RExC_state_t *pRExC_state)
 {
     U8 op;
 
@@ -12403,7 +12403,7 @@ tryagain:
 }
 
 STATIC char *
-S_regpatws(pTHX_ RExC_state_t *pRExC_state, char *p , const bool recognize_comment )
+S_regpatws(RExC_state_t *pRExC_state, char *p , const bool recognize_comment )
 {
     /* Returns the next non-pattern-white space, non-comment character (the
      * latter only if 'recognize_comment is true) in the string p, which is
@@ -12647,7 +12647,7 @@ S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value, const bool strict)
 }
 
 STATIC bool
-S_could_it_be_a_POSIX_class(pTHX_ RExC_state_t *pRExC_state)
+S_could_it_be_a_POSIX_class(RExC_state_t *pRExC_state)
 {
     /* This applies some heuristics at the current parse position (which should
      * be at a '[') to see if what follows might be intended to be a [:posix:]
@@ -15026,7 +15026,7 @@ S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state,
 */
 
 PERL_STATIC_INLINE char*
-S_reg_skipcomment(pTHX_ RExC_state_t *pRExC_state, char* p)
+S_reg_skipcomment(RExC_state_t *pRExC_state, char* p)
 {
     PERL_ARGS_ASSERT_REG_SKIPCOMMENT;
 
index 7e36001..0855bad 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -3526,7 +3526,7 @@ S_dump_exec_pos(pTHX_ const char *locinput,
  * or 0 if non of the buffers matched.
  */
 STATIC I32
-S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
+S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan)
 {
     I32 n;
     RXi_GET_DECL(rex,rexi);
diff --git a/sv.c b/sv.c
index 810eba7..b6409a0 100644 (file)
--- a/sv.c
+++ b/sv.c
@@ -12334,6 +12334,7 @@ Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl)
 void
 Perl_ptr_table_clear(pTHX_ PTR_TBL_t *const tbl)
 {
+    PERL_UNUSED_CONTEXT;
     if (tbl && tbl->tbl_items) {
        struct ptr_tbl_arena *arena = tbl->tbl_arena;
 
@@ -12360,6 +12361,8 @@ Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl)
 {
     struct ptr_tbl_arena *arena;
 
+    PERL_UNUSED_CONTEXT;
+
     if (!tbl) {
         return;
     }
diff --git a/util.c b/util.c
index ea13ff3..4666233 100644 (file)
--- a/util.c
+++ b/util.c
@@ -1094,6 +1094,9 @@ Perl_savesharedpv(pTHX_ const char *pv)
 {
     char *newaddr;
     STRLEN pvlen;
+
+    PERL_UNUSED_CONTEXT;
+
     if (!pv)
        return NULL;
 
@@ -1119,6 +1122,7 @@ Perl_savesharedpvn(pTHX_ const char *const pv, const STRLEN len)
 {
     char *const newaddr = (char*)PerlMemShared_malloc(len + 1);
 
+    PERL_UNUSED_CONTEXT;
     /* PERL_ARGS_ASSERT_SAVESHAREDPVN; */
 
     if (!newaddr) {
@@ -3595,12 +3599,14 @@ Perl_init_tm(pTHX_ struct tm *ptm)      /* see mktime, strftime and asctime */
 #ifdef HAS_TM_TM_ZONE
     Time_t now;
     const struct tm* my_tm;
+    PERL_UNUSED_CONTEXT;
     PERL_ARGS_ASSERT_INIT_TM;
     (void)time(&now);
     my_tm = localtime(&now);
     if (my_tm)
         Copy(my_tm, ptm, 1, struct tm);
 #else
+    PERL_UNUSED_CONTEXT;
     PERL_ARGS_ASSERT_INIT_TM;
     PERL_UNUSED_ARG(ptm);
 #endif
@@ -5385,8 +5391,10 @@ Perl_my_dirfd(pTHX_ DIR * dir) {
     if(!dir)
         return -1;
 #ifdef HAS_DIRFD
+    PERL_UNUSED_CONTEXT;
     return dirfd(dir);
 #elif defined(HAS_DIR_DD_FD)
+    PERL_UNUSED_CONTEXT;
     return dir->dd_fd;
 #else
     Perl_die(aTHX_ PL_no_func, "dirfd");