#define PERL_ARGS_ASSERT_SLAB_FREE \
assert(op)
+PERL_CALLCONV bool Perl__is_in_locale_category(pTHX_ const bool compiling, const int category);
PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c)
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT__IS_UTF8_FOO \
assert(p)
+PERL_STATIC_INLINE STRLEN S__is_utf8_char_slow(const U8 *s, const U8 *e)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(2);
+#define PERL_ARGS_ASSERT__IS_UTF8_CHAR_SLOW \
+ assert(s); assert(e)
+
+PERL_CALLCONV bool Perl__is_utf8_idcont(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_IDCONT \
+ assert(p)
+
+PERL_CALLCONV bool Perl__is_utf8_idstart(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_IDSTART \
+ assert(p)
+
PERL_CALLCONV bool Perl__is_utf8_mark(pTHX_ const U8 *p)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \
assert(p)
+PERL_CALLCONV bool Perl__is_utf8_xidcont(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_XIDCONT \
+ assert(p)
+
+PERL_CALLCONV bool Perl__is_utf8_xidstart(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_XIDSTART \
+ assert(p)
+
PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_CANDO \
assert(statbufp)
-PERL_CALLCONV I32 Perl_cast_i32(pTHX_ NV f)
+PERL_CALLCONV I32 Perl_cast_i32(NV f)
__attribute__warn_unused_result__;
-PERL_CALLCONV IV Perl_cast_iv(pTHX_ NV f)
+PERL_CALLCONV IV Perl_cast_iv(NV f)
__attribute__warn_unused_result__;
-PERL_CALLCONV U32 Perl_cast_ulong(pTHX_ NV f)
+PERL_CALLCONV U32 Perl_cast_ulong(NV f)
__attribute__warn_unused_result__;
-PERL_CALLCONV UV Perl_cast_uv(pTHX_ NV f)
+PERL_CALLCONV UV Perl_cast_uv(NV f)
__attribute__warn_unused_result__;
PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len)
#define PERL_ARGS_ASSERT_CV_CLONE_INTO \
assert(proto); assert(target)
-PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv)
+PERL_CALLCONV SV* Perl_cv_const_sv(const CV *const cv)
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_cv_const_sv_or_av(pTHX_ const CV *const cv)
+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)
#define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \
assert(cv); assert(ckfun_p); assert(ckobj_p)
+PERL_CALLCONV SV * Perl_cv_name(pTHX_ CV *cv, SV *sv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CV_NAME \
+ assert(cv)
+
PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_CV_UNDEF \
assert(cv)
+PERL_CALLCONV GV * Perl_cvgv_from_hek(pTHX_ CV* cv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CVGV_FROM_HEK \
+ assert(cv)
+
PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV* cv, GV* gv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CVGV_SET \
assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
PERL_CALLCONV void Perl_despatch_signals(pTHX);
-PERL_CALLCONV OP* Perl_die(pTHX_ const char* pat, ...)
- __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
-
-PERL_CALLCONV OP* Perl_die_sv(pTHX_ SV *baseex)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_DIE_SV \
- assert(baseex)
-
PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV* msv)
__attribute__noreturn__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_DO_OPEN \
assert(gv); assert(name)
+PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_DO_OPEN6 \
+ assert(gv); assert(oname)
+
PERL_CALLCONV bool Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs, I32 num)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_DO_OPEN9 \
assert(gv); assert(name); assert(svs)
+PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_DO_OPEN_RAW \
+ assert(gv); assert(oname)
+
PERL_CALLCONV bool Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
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 UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#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);
+#define PERL_ARGS_ASSERT_GROK_INFNAN \
+ assert(sp); assert(send)
+
PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GROK_NUMBER \
assert(pv)
+PERL_CALLCONV int Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS \
+ assert(pv)
+
PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_IO_CLOSE \
assert(io)
-PERL_STATIC_INLINE bool S_isALNUM_lazy(pTHX_ const char* p)
+PERL_CALLCONV bool Perl_isALNUM_lazy(pTHX_ const char* p)
__attribute__deprecated__
__attribute__warn_unused_result__
__attribute__pure__
#define PERL_ARGS_ASSERT_ISALNUM_LAZY \
assert(p)
-PERL_STATIC_INLINE bool S_isIDFIRST_lazy(pTHX_ const char* p)
+PERL_CALLCONV bool Perl_isIDFIRST_lazy(pTHX_ const char* p)
__attribute__deprecated__
__attribute__warn_unused_result__
__attribute__pure__
#define PERL_ARGS_ASSERT_IS_UTF8_CHAR \
assert(s)
-PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end)
+/* PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end)
__attribute__nonnull__(1)
- __attribute__nonnull__(2);
+ __attribute__nonnull__(2); */
#define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \
assert(buf); assert(buf_end)
#define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST \
assert(p)
+PERL_CALLCONV bool Perl_isinfnan(NV nv);
PERL_CALLCONV OP* Perl_jmaybe(pTHX_ OP *o)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_JMAYBE \
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV void Perl_markstack_grow(pTHX);
+PERL_CALLCONV I32 * Perl_markstack_grow(pTHX);
PERL_CALLCONV SV* Perl_mess(pTHX_ const char* pat, ...)
__attribute__format__(__printf__,pTHX_1,pTHX_2)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_MG_COPY \
assert(sv); assert(nsv)
-PERL_CALLCONV MAGIC* Perl_mg_find(pTHX_ const SV* sv, int type)
+PERL_CALLCONV MAGIC* Perl_mg_find(const SV* sv, int type)
__attribute__warn_unused_result__;
PERL_CALLCONV MAGIC* Perl_mg_find_mglob(pTHX_ SV* sv)
#define PERL_ARGS_ASSERT_MG_FIND_MGLOB \
assert(sv)
-PERL_CALLCONV MAGIC* Perl_mg_findext(pTHX_ const SV* sv, int type, const MGVTBL *vtbl)
+PERL_CALLCONV MAGIC* Perl_mg_findext(const SV* sv, int type, const MGVTBL *vtbl)
__attribute__warn_unused_result__;
PERL_CALLCONV int Perl_mg_free(pTHX_ SV* sv)
#define PERL_ARGS_ASSERT_MG_LOCALIZE \
assert(sv); assert(nsv)
-PERL_CALLCONV void Perl_mg_magical(pTHX_ SV* sv)
- __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV void Perl_mg_magical(SV* sv)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_MG_MAGICAL \
assert(sv)
#define PERL_ARGS_ASSERT_MG_SIZE \
assert(sv)
-PERL_CALLCONV void Perl_mini_mktime(pTHX_ struct tm *ptm)
- __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV void Perl_mini_mktime(struct tm *ptm)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_MINI_MKTIME \
assert(ptm)
assert(o)
PERL_CALLCONV void Perl_my_clearenv(pTHX);
-PERL_CALLCONV int Perl_my_dirfd(pTHX_ DIR* dir);
+PERL_CALLCONV int Perl_my_dirfd(DIR* dir);
PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status)
__attribute__noreturn__;
PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]);
/* PERL_CALLCONV I32 Perl_my_stat(pTHX); */
PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags);
+PERL_CALLCONV char* Perl_my_strerror(pTHX_ const int errnum);
PERL_CALLCONV char * Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst)
__attribute__format__(__strftime__,pTHX_1,0)
__attribute__nonnull__(pTHX_1);
__attribute__malloc__
__attribute__warn_unused_result__;
+PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
PERL_CALLCONV OP* Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont)
__attribute__malloc__
__attribute__warn_unused_result__
#define PERL_ARGS_ASSERT_OP_CLEAR \
assert(o)
-PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o)
+PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o, CV* cv)
__attribute__warn_unused_result__;
PERL_CALLCONV OP* Perl_op_contextualize(pTHX_ OP* o, I32 context)
#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_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_PACK_CAT \
assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list)
+PERL_CALLCONV void Perl_package(pTHX_ OP* o)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PACKAGE \
+ assert(o)
+
PERL_CALLCONV void Perl_package_version(pTHX_ OP* v)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PACKAGE_VERSION \
#define PERL_ARGS_ASSERT_SCAN_VSTRING \
assert(s); assert(e); assert(sv)
-PERL_CALLCONV char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_SCREAMINSTR \
- assert(bigstr); assert(littlestr); assert(old_posp)
-
PERL_CALLCONV U32 Perl_seed(pTHX);
PERL_CALLCONV void Perl_set_caret_X(pTHX);
PERL_CALLCONV void Perl_set_context(void *t)
#define PERL_ARGS_ASSERT_SV_2UV_FLAGS \
assert(sv)
-PERL_CALLCONV int Perl_sv_backoff(pTHX_ SV *const sv)
- __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV int Perl_sv_backoff(SV *const sv)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_SV_BACKOFF \
assert(sv)
#define PERL_ARGS_ASSERT_SWASH_INIT \
assert(pkg); assert(name); assert(listsv)
+PERL_CALLCONV void Perl_sync_locale(pTHX);
PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_UTF8_DISTANCE \
assert(a); assert(b)
-PERL_CALLCONV U8* Perl_utf8_hop(pTHX_ const U8 *s, I32 off)
+PERL_CALLCONV U8* Perl_utf8_hop(const U8 *s, I32 off)
__attribute__warn_unused_result__
__attribute__pure__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_UTF8_HOP \
assert(s)
#define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \
assert(s)
+PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_UTILIZE \
+ assert(idop)
+
/* PERL_CALLCONV U8* uvchr_to_utf8(pTHX_ U8 *d, UV uv)
__attribute__nonnull__(pTHX_1); */
# endif
#endif
-#if !(defined(PERL_MAD))
-PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
-PERL_CALLCONV void Perl_package(pTHX_ OP* o)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PACKAGE \
- assert(o)
-
-PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg)
- __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_UTILIZE \
- assert(idop)
-
-#endif
#if !(defined(WIN32))
/* PERL_CALLCONV char* my_setlocale(pTHX_ int category, const char* locale)
__attribute__pure__; */
#endif
#if !(defined(_MSC_VER))
+PERL_CALLCONV_NO_RET OP* Perl_die(pTHX_ const char* pat, ...)
+ __attribute__noreturn__
+ __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
+
+PERL_CALLCONV_NO_RET OP* Perl_die_sv(pTHX_ SV *baseex)
+ __attribute__noreturn__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_DIE_SV \
+ assert(baseex)
+
PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
__attribute__noreturn__
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \
assert(sv); assert(mg)
+PERL_CALLCONV_NO_RET char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
+ __attribute__noreturn__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_SCREAMINSTR \
+ assert(bigstr); assert(littlestr); assert(old_posp)
+
+# if defined(PERL_IMPLICIT_CONTEXT)
+PERL_CALLCONV_NO_RET OP* Perl_die_nocontext(const char* pat, ...)
+ __attribute__noreturn__
+ __attribute__format__null_ok__(__printf__,1,2);
+
+# endif
#endif
#if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
PERL_CALLCONV char* Perl_my_bzero(char* loc, I32 len)
# 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);
#define PERL_ARGS_ASSERT_DUMPUNTIL \
assert(r); assert(start); assert(node); assert(sv)
-STATIC void S_put_byte(pTHX_ SV* sv, int c)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PUT_BYTE \
- assert(sv)
-
-STATIC bool S_put_latin1_charclass_innards(pTHX_ SV* sv, char* bitmap)
+STATIC bool S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV** bitmap_invlist)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_PUT_LATIN1_CHARCLASS_INNARDS \
+#define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS \
assert(sv); assert(bitmap)
-STATIC void S_put_range(pTHX_ SV* sv, UV start, UV end)
+STATIC void S_put_code_point(pTHX_ SV* sv, UV c)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PUT_CODE_POINT \
+ assert(sv)
+
+STATIC void S_put_range(pTHX_ SV* sv, UV start, const UV end, const bool allow_literals)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PUT_RANGE \
assert(sv)
#define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \
assert(parser); assert(slab)
+PERL_STATIC_INLINE bool S_should_warn_nl(const char *pv)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SHOULD_WARN_NL \
+ assert(pv)
+
# if defined(PERL_DEBUG_READONLY_OPS)
PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_DEB_NOCONTEXT \
assert(pat)
-PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...)
- __attribute__format__null_ok__(__printf__,1,2);
-
PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...)
__attribute__format__(__printf__,1,2)
__attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \
assert(pat)
+# if defined(_MSC_VER)
+PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...)
+ __attribute__format__null_ok__(__printf__,1,2);
+
+# endif
#endif
#if defined(PERL_IMPLICIT_SYS)
PERL_CALLCONV PerlInterpreter* perl_alloc_using(struct IPerlMem *ipM, struct IPerlMem *ipMS, struct IPerlMem *ipMP, struct IPerlEnv *ipE, struct IPerlStdIO *ipStd, struct IPerlLIO *ipLIO, struct IPerlDir *ipD, struct IPerlSock *ipS, struct IPerlProc *ipP)
STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective)
__attribute__warn_unused_result__;
+STATIC bool S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype, int writing, bool was_fdopen, const char *type)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_OPENN_CLEANUP \
+ assert(gv); assert(io); assert(mode); assert(oname)
+
+STATIC IO * S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5)
+ __attribute__nonnull__(pTHX_6);
+#define PERL_ARGS_ASSERT_OPENN_SETUP \
+ assert(gv); assert(mode); assert(saveifp); assert(saveofp); assert(savefd); assert(savetype)
+
#endif
#if defined(PERL_IN_DOOP_C)
STATIC I32 S_do_trans_complex(pTHX_ SV * const sv)
assert(pm)
STATIC UV S_sequence_num(pTHX_ const OP *o);
-# if defined(PERL_MAD)
-STATIC void S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
- __attribute__format__(__printf__,pTHX_3,pTHX_4)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_XMLDUMP_ATTR \
- assert(file); assert(pat)
-
-# endif
#endif
#if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_SCOPE_C)
PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv)
#define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \
assert(gv)
+PERL_STATIC_INLINE HV* S_gv_stashpvn_internal(pTHX_ const char* name, U32 namelen, I32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \
+ assert(name)
+
+PERL_STATIC_INLINE HV* S_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char* name, U32 namelen, I32 flags);
STATIC void S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_HV_AUXINIT \
assert(hv)
+STATIC struct xpvhv_aux* S_hv_auxinit_internal(struct xpvhv_aux *iter)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_HV_AUXINIT_INTERNAL \
+ assert(iter)
+
STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash);
STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry)
__attribute__nonnull__(pTHX_1)
assert(hv); assert(indexp)
#endif
-#if defined(PERL_IN_LOCALE_C) && defined(USE_LOCALE)
-STATIC bool S_is_cur_LC_category_utf8(pTHX_ int category);
-STATIC char* S_stdize_locale(pTHX_ char* locs)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_STDIZE_LOCALE \
- assert(locs)
-
-#endif
#if defined(PERL_IN_MALLOC_C)
STATIC int S_adjust_size_and_find_bucket(size_t *nbytes_p)
__attribute__nonnull__(1);
STATIC void S_unwind_handler_stack(pTHX_ const void *p);
#endif
#if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C)
-PERL_CALLCONV bool Perl_translate_substr_offsets(pTHX_ STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp)
- __attribute__nonnull__(pTHX_6)
- __attribute__nonnull__(pTHX_7);
+PERL_CALLCONV bool Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp)
+ __attribute__nonnull__(6)
+ __attribute__nonnull__(7);
#define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \
assert(posp); assert(lenp)
#define PERL_ARGS_ASSERT_BAD_TYPE_PV \
assert(t); assert(name); assert(kid)
+STATIC void S_clear_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS \
+ assert(fullname); assert(gv); assert(cv)
+
STATIC void S_cop_free(pTHX_ COP *cop)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_COP_FREE \
#define PERL_ARGS_ASSERT_FOLD_CONSTANTS \
assert(o)
-STATIC OP* S_force_list(pTHX_ OP* arg);
+STATIC OP* S_force_list(pTHX_ OP* arg, bool nullit);
STATIC void S_forget_pmop(pTHX_ PMOP *const o)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_FORGET_PMOP \
#define PERL_ARGS_ASSERT_PMTRANS \
assert(o); assert(expr); assert(repl)
-STATIC void S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv)
+STATIC bool S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
__attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_AMAGIC_CMP \
assert(str1); assert(str2)
-STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \
- assert(str1); assert(str2)
-
STATIC I32 S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_NCMP \
assert(a); assert(b)
+# if defined(USE_LOCALE_COLLATE)
+STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \
+ assert(str1); assert(str2)
+
+# endif
#endif
#if defined(PERL_IN_PP_SYS_C)
STATIC OP* S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
+ __attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_DOFORM \
- assert(cv); assert(gv); assert(retop)
+ assert(cv); assert(gv)
STATIC SV * S_space_join_names_mortal(pTHX_ char *const *array)
__attribute__nonnull__(pTHX_1);
#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)
+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_ADD_ABOVE_LATIN1_FOLDS \
+ assert(pRExC_state); assert(invlist)
+
PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT_ADD_DATA \
assert(pRExC_state); assert(s)
+STATIC AV* S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, const STRLEN cp_count)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_ADD_MULTI_MATCH \
+ assert(multi_string)
+
PERL_STATIC_INLINE void S_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t *pRExC_state, regnode *node, I32 *flagp, STRLEN len, UV code_point, bool downgradable)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#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)
-STATIC bool S_could_it_be_a_POSIX_class(pTHX_ RExC_state_t *pRExC_state)
- __attribute__nonnull__(pTHX_1);
+STATIC regnode * S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE \
+ assert(pRExC_state); assert(source)
+
+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)
-STATIC SV* S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass_posixl* const node)
+STATIC SV* S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass* const node)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#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)
-STATIC bool S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, bool in_char_class, const bool strict)
+STATIC STRLEN S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, SV** substitute_parse)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_GROK_BSLASH_N \
#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)
#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)
#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)
#define PERL_ARGS_ASSERT_MAKE_TRIE \
assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail)
-STATIC void S_make_trie_failtable(pTHX_ RExC_state_t *pRExC_state, regnode *source, regnode *stclass, U32 depth)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE \
- assert(pRExC_state); assert(source); assert(stclass)
-
STATIC char * S_nextchar(pTHX_ RExC_state_t *pRExC_state)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_NEXTCHAR \
#define PERL_ARGS_ASSERT_REG_SCAN_NAME \
assert(pRExC_state)
-STATIC bool S_reg_skipcomment(pTHX_ RExC_state_t *pRExC_state)
- __attribute__nonnull__(pTHX_1);
+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(pRExC_state); assert(p)
STATIC regnode* S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REGUNI \
assert(pRExC_state); assert(s)
-STATIC char * S_regwhite(RExC_state_t *pRExC_state, char *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(1)
- __attribute__nonnull__(2);
-#define PERL_ARGS_ASSERT_REGWHITE \
- assert(pRExC_state); assert(p)
-
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_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)
#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)
#endif
#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
-PERL_CALLCONV SV* Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale)
+PERL_CALLCONV SV* Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV *exclude_list)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA \
assert(node)
+PERL_CALLCONV void Perl__load_PL_utf8_foldclosures(pTHX);
#endif
#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
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)
#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)
#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)
#define PERL_ARGS_ASSERT_GROK_BSLASH_X \
assert(s); assert(uv); assert(error_msg)
-PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s, const bool rbrace_must_be_escaped)
+PERL_STATIC_INLINE I32 S_regcurly(const char *s)
__attribute__warn_unused_result__
__attribute__pure__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_REGCURLY \
assert(s)
#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)
#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)
#define PERL_ARGS_ASSERT_INCLINE \
assert(s)
-STATIC int S_intuit_method(pTHX_ char *s, GV *gv, CV *cv)
+STATIC int S_intuit_method(pTHX_ char *s, SV *ioname, CV *cv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INTUIT_METHOD \
assert(s)
#define PERL_ARGS_ASSERT_SCAN_PAT \
assert(start)
-STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching, char **delimp)
+STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, char **delimp)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SCAN_STR \
#define PERL_ARGS_ASSERT_YYWARN \
assert(s)
-# if defined(PERL_MAD)
-STATIC void S_curmad(pTHX_ char slot, SV *sv);
-STATIC char* S_skipspace0(pTHX_ char *s)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SKIPSPACE0 \
- assert(s)
-
-STATIC char* S_skipspace1(pTHX_ char *s)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SKIPSPACE1 \
- assert(s)
-
-STATIC char* S_skipspace2(pTHX_ char *s, SV **sv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SKIPSPACE2 \
- assert(s)
-
-STATIC void S_start_force(pTHX_ int where);
-# endif
#endif
#if defined(PERL_IN_UNIVERSAL_C)
STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name, STRLEN len, U32 flags)
#define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \
assert(p); assert(ustrp); assert(lenp)
-PERL_STATIC_INLINE STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len)
- __attribute__warn_unused_result__
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW \
- assert(s)
-
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__
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_IS_UTF8_COMMON \
assert(p); assert(swash); assert(swashname)
+STATIC U8* S_swash_scan_list_line(pTHX_ U8* l, U8* const lend, UV* min, UV* max, UV* val, const bool wants_value, const U8* const typestr)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5)
+ __attribute__nonnull__(pTHX_7);
+#define PERL_ARGS_ASSERT_SWASH_SCAN_LIST_LINE \
+ assert(l); assert(lend); assert(min); assert(max); assert(val); assert(typestr)
+
STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SWATCH_GET \
assert(swash)
-STATIC U8 S_to_lower_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp)
+STATIC U8 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp)
__attribute__warn_unused_result__;
#endif
# endif
#endif
-#if defined(PERL_MAD)
-PERL_CALLCONV void Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot);
-PERL_CALLCONV void Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot);
-PERL_CALLCONV void Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_DO_OP_XMLDUMP \
- assert(file)
-
-PERL_CALLCONV void Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP \
- assert(file)
-
-PERL_CALLCONV void Perl_mad_free(pTHX_ MADPROP* mp);
-PERL_CALLCONV int Perl_madlex(pTHX);
-PERL_CALLCONV int Perl_madparse(pTHX_ int gramtype);
-PERL_CALLCONV OP* Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
-PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen);
-PERL_CALLCONV MADPROP* Perl_newMADsv(pTHX_ char key, SV* sv)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_NEWMADSV \
- assert(sv)
-
-PERL_CALLCONV TOKEN* Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop);
-PERL_CALLCONV void Perl_op_getmad(pTHX_ OP* from, OP* o, char slot);
-PERL_CALLCONV void Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot);
-PERL_CALLCONV void Perl_op_xmldump(pTHX_ const OP *o)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_OP_XMLDUMP \
- assert(o)
-
-PERL_CALLCONV OP* Perl_package(pTHX_ OP* o)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PACKAGE \
- assert(o)
-
-PERL_CALLCONV void Perl_pad_peg(const char* s)
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_PAD_PEG \
- assert(s)
-
-PERL_CALLCONV void Perl_pmop_xmldump(pTHX_ const PMOP* pm);
-PERL_CALLCONV void Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot);
-PERL_CALLCONV char* Perl_sv_catxmlpv(pTHX_ SV *dsv, const char *pv, int utf8)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_CATXMLPV \
- assert(dsv); assert(pv)
-
-PERL_CALLCONV char* Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_CATXMLPVN \
- assert(dsv); assert(pv)
-
-PERL_CALLCONV char* Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_CATXMLSV \
- assert(dsv); assert(ssv)
-
-PERL_CALLCONV char* Perl_sv_xmlpeek(pTHX_ SV* sv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SV_XMLPEEK \
- assert(sv)
-
-PERL_CALLCONV void Perl_token_free(pTHX_ TOKEN *tk)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_TOKEN_FREE \
- assert(tk)
-
-PERL_CALLCONV void Perl_token_getmad(pTHX_ TOKEN *tk, OP *o, char slot)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_TOKEN_GETMAD \
- assert(tk)
-
-PERL_CALLCONV OP * Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg)
- __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_UTILIZE \
- assert(idop)
-
-PERL_CALLCONV void Perl_xmldump_all(pTHX);
-PERL_CALLCONV void Perl_xmldump_all_perl(pTHX_ bool justperl);
-PERL_CALLCONV void Perl_xmldump_eval(pTHX);
-PERL_CALLCONV void Perl_xmldump_form(pTHX_ const GV* gv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_FORM \
- assert(gv)
-
-PERL_CALLCONV void Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
- __attribute__format__(__printf__,pTHX_3,pTHX_4)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_XMLDUMP_INDENT \
- assert(file); assert(pat)
-
-PERL_CALLCONV void Perl_xmldump_packsubs(pTHX_ const HV* stash)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS \
- assert(stash)
-
-PERL_CALLCONV void Perl_xmldump_packsubs_perl(pTHX_ const HV* stash, bool justperl)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL \
- assert(stash)
-
-PERL_CALLCONV void Perl_xmldump_sub(pTHX_ const GV* gv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_SUB \
- assert(gv)
-
-PERL_CALLCONV void Perl_xmldump_sub_perl(pTHX_ const GV* gv, bool justperl)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL \
- assert(gv)
-
-PERL_CALLCONV void Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_XMLDUMP_VINDENT \
- assert(file); assert(pat)
-
-#endif
#if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
STATIC void S_pidgone(pTHX_ Pid_t pid, int status);
#endif
assert(f)
#endif
+#if defined(USE_C_BACKTRACE)
+PERL_CALLCONV bool Perl_dump_c_backtrace(pTHX_ PerlIO* fp, int max_depth, int skip)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \
+ assert(fp)
+
+/* PERL_CALLCONV void free_c_backtrace(pTHX_ Perl_c_backtrace* bt)
+ __attribute__nonnull__(pTHX_1); */
+
+PERL_CALLCONV Perl_c_backtrace* Perl_get_c_backtrace(pTHX_ int max_depth, int skip);
+PERL_CALLCONV SV* Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip);
+#endif
#if defined(USE_ITHREADS)
PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv)
__attribute__nonnull__(pTHX_1);
assert(param)
#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);
+STATIC char* S_stdize_locale(pTHX_ char* locs)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_STDIZE_LOCALE \
+ assert(locs)
+
+#endif
#if defined(USE_LOCALE_COLLATE)
PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg)
__attribute__nonnull__(pTHX_1)
#endif
#if defined(_MSC_VER)
+PERL_CALLCONV OP* Perl_die(pTHX_ const char* pat, ...)
+ __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
+
+PERL_CALLCONV OP* Perl_die_sv(pTHX_ SV *baseex)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_DIE_SV \
+ assert(baseex)
+
PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \
assert(sv); assert(mg)
+PERL_CALLCONV char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_SCREAMINSTR \
+ assert(bigstr); assert(littlestr); assert(old_posp)
+
#endif
#ifdef PERL_CORE
# include "pp_proto.h"
https://perl5.git.perl.org / perl5.git / blobdiff