#define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \
assert(p); assert(ustrp)
+PERL_CALLCONV void Perl__warn_problematic_locale(void);
PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_ALLOCMY \
#define PERL_ARGS_ASSERT_CK_OPEN \
assert(o)
+PERL_CALLCONV OP * Perl_ck_prototype(pTHX_ OP *o)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CK_PROTOTYPE \
+ assert(o)
+
PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
PERL_CALLCONV SV* Perl_cv_const_sv_or_av(const CV *const cv)
__attribute__warn_unused_result__;
-PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CV_FORGET_SLAB \
- assert(cv)
-
+PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv);
PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
assert(sv); assert(delim); assert(mark); assert(sp)
PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
+ __attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \
- assert(file); assert(mg)
+ assert(file)
PERL_CALLCONV I32 Perl_do_ncmp(pTHX_ SV *const left, SV *const right)
__attribute__warn_unused_result__
PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv);
PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp);
-PERL_CALLCONV UV Perl_grok_atou(const char* pv, const char** endptr)
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_GROK_ATOU \
- assert(pv)
+PERL_CALLCONV bool Perl_grok_atoUV(const char* pv, UV* valptr, const char** endptr)
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(2);
+#define PERL_ARGS_ASSERT_GROK_ATOUV \
+ assert(pv); assert(valptr)
PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result)
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_GROK_HEX \
assert(start); assert(len_p); assert(flags)
-PERL_CALLCONV int Perl_grok_infnan(const char** sp, const char *send)
- __attribute__nonnull__(1)
- __attribute__nonnull__(2);
+PERL_CALLCONV int Perl_grok_infnan(pTHX_ const char** sp, const char *send)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_GROK_INFNAN \
assert(sp); assert(send)
#define PERL_ARGS_ASSERT_GV_CONST_SV \
assert(gv)
-PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GV_DUMP \
- assert(gv)
-
+PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv);
PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \
assert(smeta); assert(which); assert(data)
+PERL_CALLCONV SV* Perl_multideref_stringify(pTHX_ const OP* o, CV *cv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_MULTIDEREF_STRINGIFY \
+ assert(o)
+
PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_MY_ATOF \
__attribute__malloc__
__attribute__warn_unused_result__;
+PERL_CALLCONV PADNAMELIST * Perl_newPADNAMELIST(size_t max)
+ __attribute__malloc__
+ __attribute__warn_unused_result__;
+
+PERL_CALLCONV PADNAME * Perl_newPADNAMEouter(PADNAME *outer)
+ __attribute__malloc__
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_NEWPADNAMEOUTER \
+ assert(outer)
+
+PERL_CALLCONV PADNAME * Perl_newPADNAMEpvn(const char *s, STRLEN len)
+ __attribute__malloc__
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_NEWPADNAMEPVN \
+ assert(s)
+
PERL_CALLCONV OP* Perl_newPMOP(pTHX_ I32 type, I32 flags)
__attribute__malloc__
__attribute__warn_unused_result__;
__attribute__malloc__
__attribute__warn_unused_result__;
+PERL_CALLCONV OP* Perl_newUNOP_AUX(pTHX_ I32 type, I32 flags, OP* first, UNOP_AUX_item *aux)
+ __attribute__malloc__
+ __attribute__warn_unused_result__;
+
PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block)
__attribute__malloc__
__attribute__warn_unused_result__
#define PERL_ARGS_ASSERT_OP_NULL \
assert(o)
-PERL_CALLCONV OP* Perl_op_parent(OP *o)
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_OP_PARENT \
- assert(o)
-
PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last);
PERL_CALLCONV void Perl_op_refcnt_lock(pTHX);
PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX);
PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o);
-PERL_CALLCONV OP* Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP* insert)
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE \
- assert(parent)
-
+PERL_CALLCONV OP* Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP* insert);
PERL_CALLCONV OP* Perl_op_unscope(pTHX_ OP* o);
PERL_CALLCONV void Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \
assert(name)
+PERL_CALLCONV void Perl_pad_add_weakref(pTHX_ CV* func)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF \
+ assert(func)
+
PERL_CALLCONV PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype);
PERL_CALLCONV void Perl_pad_block_start(pTHX_ int full);
PERL_CALLCONV HV* Perl_pad_compname_type(pTHX_ const PADOFFSET po)
#define PERL_ARGS_ASSERT_PADLIST_STORE \
assert(padlist)
+PERL_CALLCONV void Perl_padname_free(pTHX_ PADNAME *pn)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAME_FREE \
+ assert(pn)
+
+PERL_CALLCONV PADNAME * Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_PADNAMELIST_FETCH \
+ assert(pnl)
+
+PERL_CALLCONV void Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAMELIST_FREE \
+ assert(pnl)
+
+PERL_CALLCONV PADNAME ** Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAMELIST_STORE \
+ assert(pnl)
+
PERL_CALLCONV OP* Perl_parse_arithexpr(pTHX_ U32 flags);
PERL_CALLCONV OP* Perl_parse_barestmt(pTHX_ U32 flags);
PERL_CALLCONV OP* Perl_parse_block(pTHX_ U32 flags);
assert(my_perl)
PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP* pm);
-PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg, I32 floor)
+PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, bool isreg, I32 floor)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_PMRUNTIME \
assert(sv)
PERL_CALLCONV void Perl_sv_free_arenas(pTHX);
+PERL_CALLCONV SV* Perl_sv_get_backrefs(SV *const sv)
+ __attribute__pure__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SV_GET_BACKREFS \
+ assert(sv)
+
PERL_CALLCONV char* Perl_sv_gets(pTHX_ SV *const sv, PerlIO *const fp, I32 append)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_NV \
assert(sv)
+PERL_STATIC_INLINE bool S_sv_only_taint_gmagic(SV *sv)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC \
+ assert(sv)
+
PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv);
PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_XS_HANDSHAKE \
assert(v_my_perl); assert(file)
-PERL_CALLCONV void Perl_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \
- assert(xs_p)
-
PERL_CALLCONV int Perl_yyerror(pTHX_ const char *const s)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_YYERROR \
# endif
#endif
+#if !defined(PERL_EXT_RE_BUILD)
+# if defined(PERL_IN_REGCOMP_C)
+PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(SV* invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \
+ assert(invlist)
+
+PERL_STATIC_INLINE bool S_invlist_is_iterating(SV* const invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \
+ assert(invlist)
+
+PERL_STATIC_INLINE IV S_invlist_previous_index(SV* const invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \
+ assert(invlist)
+
+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(SV* const invlist)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_INVLIST_TRIM \
+ assert(invlist)
+
+# endif
+#endif
#if !defined(PERL_IMPLICIT_SYS)
PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO* ptr);
PERL_CALLCONV PerlIO* Perl_my_popen(pTHX_ const char* cmd, const char* mode)
# endif
# if defined(PERL_IN_REGCOMP_C)
-STATIC const char * S_cntrl_to_mnemonic(const U8 c)
- __attribute__pure__;
-
STATIC void S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3);
#endif
#if defined(PERL_IN_DUMP_C)
-STATIC CV* S_deb_curcv(pTHX_ const I32 ix);
+STATIC CV* S_deb_curcv(pTHX_ I32 ix);
STATIC void S_debprof(pTHX_ const OP *o)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_DEBPROF \
#define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \
assert(stash); assert(name)
+PERL_STATIC_INLINE GV* S_gv_fetchmeth_internal(pTHX_ HV* stash, SV* meth, const char* name, STRLEN len, I32 level, U32 flags);
STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \
STATIC I32 S_assignment_type(pTHX_ const OP *o)
__attribute__warn_unused_result__;
-STATIC void S_bad_type_gv(pTHX_ I32 n, const char *t, GV *gv, U32 flags, const OP *kid)
+STATIC void S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
- __attribute__nonnull__(pTHX_5);
+ __attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_BAD_TYPE_GV \
- assert(t); assert(gv); assert(kid)
+ assert(gv); assert(kid); assert(t)
-STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flags, const OP *kid)
+STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
- __attribute__nonnull__(pTHX_5);
+ __attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_BAD_TYPE_PV \
- assert(t); assert(name); assert(kid)
+ assert(t); assert(o); assert(kid)
STATIC void S_clear_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv)
__attribute__nonnull__(pTHX_1)
#endif
#if defined(PERL_IN_PAD_C)
-STATIC PADOFFSET S_pad_alloc_name(pTHX_ SV *namesv, U32 flags, HV *typestash, HV *ourstash)
+STATIC PADOFFSET S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \
- assert(namesv)
+ assert(name)
-STATIC void S_pad_check_dup(pTHX_ SV *name, U32 flags, const HV *ourstash)
+STATIC void S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PAD_CHECK_DUP \
assert(name)
-STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags)
+STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, int warn, SV** out_capture, PADNAME** out_name, int *out_flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_4)
__attribute__nonnull__(pTHX_8)
__attribute__nonnull__(pTHX_9);
#define PERL_ARGS_ASSERT_PAD_FINDLEX \
- assert(namepv); assert(cv); assert(out_name_sv); assert(out_flags)
+ assert(namepv); assert(cv); assert(out_name); assert(out_flags)
STATIC void S_pad_reset(pTHX);
#endif
#endif
#if defined(PERL_IN_PP_PACK_C)
-STATIC char * S_bytes_to_uni(const U8 *start, STRLEN len, char *dest, const bool needs_swap)
- __attribute__warn_unused_result__
- __attribute__nonnull__(1)
- __attribute__nonnull__(3);
-#define PERL_ARGS_ASSERT_BYTES_TO_UNI \
- assert(start); assert(dest)
-
STATIC int S_div128(pTHX_ SV *pnum, bool *done)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_MUL128 \
assert(sv)
+STATIC char * S_my_bytes_to_utf8(const U8 *start, STRLEN len, char *dest, const bool needs_swap)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(3);
+#define PERL_ARGS_ASSERT_MY_BYTES_TO_UTF8 \
+ assert(start); assert(dest)
+
STATIC bool S_need_utf8(const char *pat, const char *patend)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \
assert(invlist)
+STATIC SV* S__make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT__MAKE_EXACTF_INVLIST \
+ assert(pRExC_state); assert(node)
+
STATIC void S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT \
assert(pRExC_state); assert(node); assert(flagp)
+STATIC const char * S_cntrl_to_mnemonic(const U8 c)
+ __attribute__pure__;
+
PERL_STATIC_INLINE U8 S_compute_EXACTish(RExC_state_t *pRExC_state)
__attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \
#define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \
assert(invlist)
-PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(SV* invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \
- assert(invlist)
-
-STATIC STRLEN S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, SV** substitute_parse)
+STATIC bool S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV *code_point_p, int* cp_count, I32 *flagp, const U32 depth)
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_4);
+ __attribute__nonnull__(pTHX_5);
#define PERL_ARGS_ASSERT_GROK_BSLASH_N \
assert(pRExC_state); assert(flagp)
#define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \
assert(pRExC_state); assert(flagp); assert(oregcomp_parse)
-PERL_STATIC_INLINE UV* S_invlist_array(SV* const invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_INVLIST_ARRAY \
- assert(invlist)
-
PERL_STATIC_INLINE SV* S_invlist_clone(pTHX_ SV* const invlist)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INVLIST_HIGHEST \
assert(invlist)
-PERL_STATIC_INLINE bool S_invlist_is_iterating(SV* const invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \
- assert(invlist)
-
PERL_STATIC_INLINE void S_invlist_iterfinish(SV* invlist)
__attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \
#define PERL_ARGS_ASSERT_INVLIST_MAX \
assert(invlist)
-PERL_STATIC_INLINE IV S_invlist_previous_index(SV* const invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \
- assert(invlist)
-
PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INVLIST_SET_LEN \
assert(invlist)
-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(SV* const invlist)
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_INVLIST_TRIM \
- assert(invlist)
-
STATIC bool S_is_ssc_worth_it(const RExC_state_t * pRExC_state, const regnode_ssc * ssc)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_REGBRANCH \
assert(pRExC_state); assert(flagp)
-STATIC regnode* S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, SV** ret_invlist)
+STATIC regnode* S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, SV** ret_invlist)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_REGCLASS \
assert(pRExC_state); assert(flagp)
+STATIC unsigned int S_regex_set_precedence(const U8 my_operator)
+ __attribute__pure__;
+
STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_REGTAIL \
assert(pRExC_state); assert(p); assert(val)
-PERL_STATIC_INLINE STRLEN S_reguni(pTHX_ const RExC_state_t *pRExC_state, UV uv, char *s)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_REGUNI \
- assert(pRExC_state); assert(s)
-
STATIC void S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \
assert(invlist)
+PERL_STATIC_INLINE UV* S_invlist_array(SV* const invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_INVLIST_ARRAY \
+ assert(invlist)
+
#endif
#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C)
PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, SV* invlist, U8* const flags_p)
#endif
#if defined(PERL_IN_REGEXEC_C)
+STATIC SB_enum S_advance_one_SB(pTHX_ U8 ** curpos, const U8 * const strend, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_ADVANCE_ONE_SB \
+ assert(curpos); assert(strend)
+
+STATIC WB_enum S_advance_one_WB(pTHX_ U8 ** curpos, const U8 * const strend, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_ADVANCE_ONE_WB \
+ assert(curpos); assert(strend)
+
+STATIC SB_enum S_backup_one_SB(pTHX_ const U8 * const strbeg, U8 ** curpos, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_BACKUP_ONE_SB \
+ assert(strbeg); assert(curpos)
+
+STATIC WB_enum S_backup_one_WB(pTHX_ WB_enum * previous, const U8 * const strbeg, U8 ** curpos, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_BACKUP_ONE_WB \
+ assert(previous); assert(strbeg); assert(curpos)
+
STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \
assert(character)
+STATIC bool S_isGCB(const GCB_enum before, const GCB_enum after)
+ __attribute__warn_unused_result__;
+
+STATIC bool S_isSB(pTHX_ SB_enum before, SB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_ISSB \
+ assert(strbeg); assert(curpos); assert(strend)
+
+STATIC bool S_isWB(pTHX_ WB_enum previous, WB_enum before, WB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5)
+ __attribute__nonnull__(pTHX_6);
+#define PERL_ARGS_ASSERT_ISWB \
+ assert(strbeg); assert(curpos); assert(strend)
+
STATIC I32 S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan)
__attribute__warn_unused_result__
__attribute__nonnull__(1)
#define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \
assert(val)
-STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool top);
+STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool match, const char **desc_p)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_FIND_UNINIT_VAR \
+ assert(desc_p)
+
STATIC bool S_glob_2number(pTHX_ GV* const gv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GLOB_2NUMBER \
#endif
#if defined(PERL_IN_UTF8_C)
-STATIC UV S_check_locale_boundary_crossing(pTHX_ const char * const func_name, const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp)
+STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_4)
- __attribute__nonnull__(pTHX_5);
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \
- assert(func_name); assert(p); assert(ustrp); assert(lenp)
+ assert(p); assert(ustrp); assert(lenp)
PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname, SV* const invlist)
__attribute__warn_unused_result__
#define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \
assert(ex)
+STATIC void S_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \
+ assert(xs_p)
+
# if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL)
STATIC void S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname)
__attribute__nonnull__(4)
# endif
#endif
+#if defined(PERL_OP_PARENT)
+PERL_CALLCONV OP* Perl_op_parent(OP *o)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_OP_PARENT \
+ assert(o)
+
+#endif
#if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
STATIC void S_pidgone(pTHX_ Pid_t pid, int status);
#endif
#define PERL_ARGS_ASSERT_PADLIST_DUP \
assert(srcpad); assert(param)
+PERL_CALLCONV PADNAME * Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PADNAME_DUP \
+ assert(src); assert(param)
+
+PERL_CALLCONV PADNAMELIST * Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PADNAMELIST_DUP \
+ assert(srcpad); assert(param)
+
PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_PARSER_DUP \
#endif
#if defined(USE_LOCALE) && (defined(PERL_IN_LOCALE_C) || defined (PERL_EXT_POSIX))
PERL_CALLCONV bool Perl__is_cur_LC_category_utf8(pTHX_ int category);
+#endif
+#if defined(USE_LOCALE) && defined(PERL_IN_LOCALE_C)
STATIC char* S_stdize_locale(pTHX_ char* locs)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_STDIZE_LOCALE \