[perl5.git] / inline.h

/*    inline.h
 *
 *    Copyright (C) 2012 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 * This file is a home for static inline functions that cannot go in other
 * headers files, because they depend on proto.h (included after most other
 * headers) or struct definitions.
 *
 * Each section names the header file that the functions "belong" to.
 */

/* ------------------------------- av.h ------------------------------- */

PERL_STATIC_INLINE SSize_t
S_av_top_index(pTHX_ AV *av)
{
    PERL_ARGS_ASSERT_AV_TOP_INDEX;
    assert(SvTYPE(av) == SVt_PVAV);

    return AvFILL(av);
}

/* ------------------------------- cv.h ------------------------------- */

PERL_STATIC_INLINE I32 *
S_CvDEPTHp(const CV * const sv)
{
    assert(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM);
    return &((XPVCV*)SvANY(sv))->xcv_depth;
}

/*
 CvPROTO returns the prototype as stored, which is not necessarily what
 the interpreter should be using. Specifically, the interpreter assumes
 that spaces have been stripped, which has been the case if the prototype
 was added by toke.c, but is generally not the case if it was added elsewhere.
 Since we can't enforce the spacelessness at assignment time, this routine
 provides a temporary copy at parse time with spaces removed.
 I<orig> is the start of the original buffer, I<len> is the length of the
 prototype and will be updated when this returns.
 */

#ifdef PERL_CORE
PERL_STATIC_INLINE char *
S_strip_spaces(pTHX_ const char * orig, STRLEN * const len)
{
    SV * tmpsv;
    char * tmps;
    tmpsv = newSVpvn_flags(orig, *len, SVs_TEMP);
    tmps = SvPVX(tmpsv);
    while ((*len)--) {
	if (!isSPACE(*orig))
	    *tmps++ = *orig;
	orig++;
    }
    *tmps = '\0';
    *len = tmps - SvPVX(tmpsv);
		return SvPVX(tmpsv);
}
#endif

/* ------------------------------- mg.h ------------------------------- */

#if defined(PERL_CORE) || defined(PERL_EXT)
/* assumes get-magic and stringification have already occurred */
PERL_STATIC_INLINE STRLEN
S_MgBYTEPOS(pTHX_ MAGIC *mg, SV *sv, const char *s, STRLEN len)
{
    assert(mg->mg_type == PERL_MAGIC_regex_global);
    assert(mg->mg_len != -1);
    if (mg->mg_flags & MGf_BYTES || !DO_UTF8(sv))
	return (STRLEN)mg->mg_len;
    else {
	const STRLEN pos = (STRLEN)mg->mg_len;
	/* Without this check, we may read past the end of the buffer: */
	if (pos > sv_or_pv_len_utf8(sv, s, len)) return len+1;
	return sv_or_pv_pos_u2b(sv, s, pos, NULL);
    }
}
#endif

/* ----------------------------- regexp.h ----------------------------- */

PERL_STATIC_INLINE struct regexp *
S_ReANY(const REGEXP * const re)
{
    assert(isREGEXP(re));
    return re->sv_u.svu_rx;
}

/* ------------------------------- sv.h ------------------------------- */

PERL_STATIC_INLINE SV *
S_SvREFCNT_inc(SV *sv)
{
    if (LIKELY(sv != NULL))
	SvREFCNT(sv)++;
    return sv;
}
PERL_STATIC_INLINE SV *
S_SvREFCNT_inc_NN(SV *sv)
{
    SvREFCNT(sv)++;
    return sv;
}
PERL_STATIC_INLINE void
S_SvREFCNT_inc_void(SV *sv)
{
    if (LIKELY(sv != NULL))
	SvREFCNT(sv)++;
}
PERL_STATIC_INLINE void
S_SvREFCNT_dec(pTHX_ SV *sv)
{
    if (LIKELY(sv != NULL)) {
	U32 rc = SvREFCNT(sv);
	if (LIKELY(rc > 1))
	    SvREFCNT(sv) = rc - 1;
	else
	    Perl_sv_free2(aTHX_ sv, rc);
    }
}

PERL_STATIC_INLINE void
S_SvREFCNT_dec_NN(pTHX_ SV *sv)
{
    U32 rc = SvREFCNT(sv);
    if (LIKELY(rc > 1))
	SvREFCNT(sv) = rc - 1;
    else
	Perl_sv_free2(aTHX_ sv, rc);
}

PERL_STATIC_INLINE void
SvAMAGIC_on(SV *sv)
{
    assert(SvROK(sv));
    if (SvOBJECT(SvRV(sv))) HvAMAGIC_on(SvSTASH(SvRV(sv)));
}
PERL_STATIC_INLINE void
SvAMAGIC_off(SV *sv)
{
    if (SvROK(sv) && SvOBJECT(SvRV(sv)))
	HvAMAGIC_off(SvSTASH(SvRV(sv)));
}

PERL_STATIC_INLINE U32
S_SvPADTMP_on(SV *sv)
{
    assert(!(SvFLAGS(sv) & SVs_PADMY));
    return SvFLAGS(sv) |= SVs_PADTMP;
}
PERL_STATIC_INLINE U32
S_SvPADTMP_off(SV *sv)
{
    assert(!(SvFLAGS(sv) & SVs_PADMY));
    return SvFLAGS(sv) &= ~SVs_PADTMP;
}
PERL_STATIC_INLINE U32
S_SvPADSTALE_on(SV *sv)
{
    assert(SvFLAGS(sv) & SVs_PADMY);
    return SvFLAGS(sv) |= SVs_PADSTALE;
}
PERL_STATIC_INLINE U32
S_SvPADSTALE_off(SV *sv)
{
    assert(SvFLAGS(sv) & SVs_PADMY);
    return SvFLAGS(sv) &= ~SVs_PADSTALE;
}
#if defined(PERL_CORE) || defined (PERL_EXT)
PERL_STATIC_INLINE STRLEN
S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp)
{
    PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B;
    if (SvGAMAGIC(sv)) {
	U8 *hopped = utf8_hop((U8 *)pv, pos);
	if (lenp) *lenp = (STRLEN)(utf8_hop(hopped, *lenp) - hopped);
	return (STRLEN)(hopped - (U8 *)pv);
    }
    return sv_pos_u2b_flags(sv,pos,lenp,SV_CONST_RETURN);
}
#endif

/* ------------------------------- handy.h ------------------------------- */

/* saves machine code for a common noreturn idiom typically used in Newx*() */
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
#endif
static void
S_croak_memory_wrap(void)
{
    Perl_croak_nocontext("%s",PL_memory_wrap);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif

#ifdef BOOTSTRAP_CHARSET
static bool
S_bootstrap_ctype(U8 character, UV classnum, bool full_Latin1)
{
    /* See comments in handy.h.  This is placed in this file primarily to avoid
     * having to have an entry for it in embed.fnc */

    dTHX;

    if (! full_Latin1 && ! isASCII(character)) {
        return FALSE;
    }

    switch (classnum) {
        case _CC_ALPHANUMERIC: return isALPHANUMERIC_L1(character);
        case _CC_ALPHA:     return isALPHA_L1(character);
        case _CC_ASCII:     return isASCII_L1(character);
        case _CC_BLANK:     return isBLANK_L1(character);
        case _CC_CASED:     return isLOWER_L1(character)
                                   || isUPPER_L1(character);
        case _CC_CNTRL:     return isCNTRL_L1(character);
        case _CC_DIGIT:     return isDIGIT_L1(character);
        case _CC_GRAPH:     return isGRAPH_L1(character);
        case _CC_LOWER:     return isLOWER_L1(character);
        case _CC_PRINT:     return isPRINT_L1(character);
        case _CC_PSXSPC:    return isPSXSPC_L1(character);
        case _CC_PUNCT:     return isPUNCT_L1(character);
        case _CC_SPACE:     return isSPACE_L1(character);
        case _CC_UPPER:     return isUPPER_L1(character);
        case _CC_WORDCHAR:  return isWORDCHAR_L1(character);
        case _CC_XDIGIT:    return isXDIGIT_L1(character);
        case _CC_VERTSPACE: return isSPACE_L1(character) && ! isBLANK_L1(character);
        case _CC_IDFIRST:   return isIDFIRST_L1(character);
        case _CC_QUOTEMETA: return _isQUOTEMETA(character);
        case _CC_CHARNAME_CONT: return isCHARNAME_CONT(character);
        case _CC_NONLATIN1_FOLD: return _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(character);
        case _CC_NON_FINAL_FOLD: return _IS_NON_FINAL_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(character);
        case _CC_IS_IN_SOME_FOLD: return _IS_IN_SOME_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(character);
        case _CC_BACKSLASH_FOO_LBRACE_IS_META: return 0;


        default: break;
    }
    Perl_croak(aTHX_ "panic: bootstrap_ctype() has an unexpected character class '%"UVxf"'", classnum);
}
#endif

/* ------------------------------- utf8.h ------------------------------- */

PERL_STATIC_INLINE void
S_append_utf8_from_native_byte(const U8 byte, U8** dest)
{
    /* Takes an input 'byte' (Latin1 or EBCDIC) and appends it to the UTF-8
     * encoded string at '*dest', updating '*dest' to include it */

    PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE;

    if (NATIVE_BYTE_IS_INVARIANT(byte))
        *(*dest)++ = byte;
    else {
        *(*dest)++ = UTF8_EIGHT_BIT_HI(byte);
        *(*dest)++ = UTF8_EIGHT_BIT_LO(byte);
    }
}

/* These two exist only to replace the macros they formerly were so that their
 * use can be deprecated */

PERL_STATIC_INLINE bool
S_isIDFIRST_lazy(pTHX_ const char* p)
{
    PERL_ARGS_ASSERT_ISIDFIRST_LAZY;

    return isIDFIRST_lazy_if(p,1);
}

PERL_STATIC_INLINE bool
S_isALNUM_lazy(pTHX_ const char* p)
{
    PERL_ARGS_ASSERT_ISALNUM_LAZY;

    return isALNUM_lazy_if(p,1);
}

/* ------------------------------- perl.h ----------------------------- */

/*
=for apidoc AiR|bool|is_safe_syscall|const char *pv|STRLEN len|const char *what|const char *op_name

Test that the given C<pv> doesn't contain any internal NUL characters.
If it does, set C<errno> to ENOENT, optionally warn, and return FALSE.

Return TRUE if the name is safe.

Used by the IS_SAFE_SYSCALL() macro.

=cut
*/

PERL_STATIC_INLINE bool
S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) {
    /* While the Windows CE API provides only UCS-16 (or UTF-16) APIs
     * perl itself uses xce*() functions which accept 8-bit strings.
     */

    PERL_ARGS_ASSERT_IS_SAFE_SYSCALL;

    if (pv && len > 1) {
        char *null_at;
        if (UNLIKELY((null_at = (char *)memchr(pv, 0, len-1)) != NULL)) {
                SETERRNO(ENOENT, LIB_INVARG);
                Perl_ck_warner(aTHX_ packWARN(WARN_SYSCALLS),
                                   "Invalid \\0 character in %s for %s: %s\\0%s",
                                   what, op_name, pv, null_at+1);
                return FALSE;
        }
    }

    return TRUE;
}

/*
 * Local variables:
 * c-indentation-style: bsd
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 *
 * ex: set ts=8 sts=4 sw=4 et:
 */
Commit	Line	Data
25468daa FC	1	/* inline.h
	2	*
	3	* Copyright (C) 2012 by Larry Wall and others
	4	*
	5	* You may distribute under the terms of either the GNU General Public
	6	* License or the Artistic License, as specified in the README file.
	7	*
	8	* This file is a home for static inline functions that cannot go in other
	9	* headers files, because they depend on proto.h (included after most other
	10	* headers) or struct definitions.
	11	*
	12	* Each section names the header file that the functions "belong" to.
	13	*/
27669aa4	14
be3a7a5d KW	15	/* ------------------------------- av.h ------------------------------- */
be3a7a5d KW	16
c70927a6	17	PERL_STATIC_INLINE SSize_t
be3a7a5d KW	18	S_av_top_index(pTHX_ AV *av)
	19	{
	20	PERL_ARGS_ASSERT_AV_TOP_INDEX;
	21	assert(SvTYPE(av) == SVt_PVAV);
	22
	23	return AvFILL(av);
	24	}
	25
1afe1db1 FC	26	/* ------------------------------- cv.h ------------------------------- */
	27
	28	PERL_STATIC_INLINE I32 *
	29	S_CvDEPTHp(const CV * const sv)
	30	{
	31	assert(SvTYPE(sv) == SVt_PVCV \|\| SvTYPE(sv) == SVt_PVFM);
8de47657	32	return &((XPVCV*)SvANY(sv))->xcv_depth;
1afe1db1 FC	33	}
1afe1db1 FC	34
d16269d8 PM	35	/*
	36	CvPROTO returns the prototype as stored, which is not necessarily what
	37	the interpreter should be using. Specifically, the interpreter assumes
	38	that spaces have been stripped, which has been the case if the prototype
	39	was added by toke.c, but is generally not the case if it was added elsewhere.
	40	Since we can't enforce the spacelessness at assignment time, this routine
	41	provides a temporary copy at parse time with spaces removed.
	42	I<orig> is the start of the original buffer, I<len> is the length of the
	43	prototype and will be updated when this returns.
	44	*/
	45
5b67adb8	46	#ifdef PERL_CORE
d16269d8 PM	47	PERL_STATIC_INLINE char *
	48	S_strip_spaces(pTHX_ const char * orig, STRLEN * const len)
	49	{
	50	SV * tmpsv;
	51	char * tmps;
	52	tmpsv = newSVpvn_flags(orig, *len, SVs_TEMP);
	53	tmps = SvPVX(tmpsv);
	54	while ((*len)--) {
	55	if (!isSPACE(*orig))
	56	tmps++ = orig;
	57	orig++;
	58	}
	59	*tmps = '\0';
	60	*len = tmps - SvPVX(tmpsv);
	61	return SvPVX(tmpsv);
	62	}
5b67adb8	63	#endif
d16269d8	64
25fdce4a FC	65	/* ------------------------------- mg.h ------------------------------- */
	66
	67	#if defined(PERL_CORE) \|\| defined(PERL_EXT)
	68	/* assumes get-magic and stringification have already occurred */
	69	PERL_STATIC_INLINE STRLEN
	70	S_MgBYTEPOS(pTHX_ MAGIC mg, SV sv, const char *s, STRLEN len)
	71	{
	72	assert(mg->mg_type == PERL_MAGIC_regex_global);
	73	assert(mg->mg_len != -1);
	74	if (mg->mg_flags & MGf_BYTES \|\| !DO_UTF8(sv))
	75	return (STRLEN)mg->mg_len;
	76	else {
	77	const STRLEN pos = (STRLEN)mg->mg_len;
	78	/* Without this check, we may read past the end of the buffer: */
	79	if (pos > sv_or_pv_len_utf8(sv, s, len)) return len+1;
	80	return sv_or_pv_pos_u2b(sv, s, pos, NULL);
	81	}
	82	}
	83	#endif
	84
8d919b0a FC	85	/* ----------------------------- regexp.h ----------------------------- */
	86
	87	PERL_STATIC_INLINE struct regexp *
	88	S_ReANY(const REGEXP * const re)
	89	{
	90	assert(isREGEXP(re));
	91	return re->sv_u.svu_rx;
	92	}
	93
27669aa4 FC	94	/* ------------------------------- sv.h ------------------------------- */
	95
	96	PERL_STATIC_INLINE SV *
	97	S_SvREFCNT_inc(SV *sv)
	98	{
2439e033	99	if (LIKELY(sv != NULL))
27669aa4 FC	100	SvREFCNT(sv)++;
	101	return sv;
	102	}
	103	PERL_STATIC_INLINE SV *
	104	S_SvREFCNT_inc_NN(SV *sv)
	105	{
	106	SvREFCNT(sv)++;
	107	return sv;
	108	}
	109	PERL_STATIC_INLINE void
	110	S_SvREFCNT_inc_void(SV *sv)
	111	{
2439e033	112	if (LIKELY(sv != NULL))
27669aa4 FC	113	SvREFCNT(sv)++;
27669aa4 FC	114	}
75e16a44 FC	115	PERL_STATIC_INLINE void
	116	S_SvREFCNT_dec(pTHX_ SV *sv)
	117	{
2439e033	118	if (LIKELY(sv != NULL)) {
75a9bf96	119	U32 rc = SvREFCNT(sv);
79e2a32a	120	if (LIKELY(rc > 1))
75a9bf96 DM	121	SvREFCNT(sv) = rc - 1;
	122	else
	123	Perl_sv_free2(aTHX_ sv, rc);
75e16a44 FC	124	}
75e16a44 FC	125	}
541377b1 FC	126
541377b1 FC	127	PERL_STATIC_INLINE void
4a9a56a7 DM	128	S_SvREFCNT_dec_NN(pTHX_ SV *sv)
	129	{
	130	U32 rc = SvREFCNT(sv);
79e2a32a	131	if (LIKELY(rc > 1))
4a9a56a7 DM	132	SvREFCNT(sv) = rc - 1;
	133	else
	134	Perl_sv_free2(aTHX_ sv, rc);
	135	}
	136
	137	PERL_STATIC_INLINE void
541377b1 FC	138	SvAMAGIC_on(SV *sv)
	139	{
	140	assert(SvROK(sv));
	141	if (SvOBJECT(SvRV(sv))) HvAMAGIC_on(SvSTASH(SvRV(sv)));
	142	}
	143	PERL_STATIC_INLINE void
	144	SvAMAGIC_off(SV *sv)
	145	{
	146	if (SvROK(sv) && SvOBJECT(SvRV(sv)))
	147	HvAMAGIC_off(SvSTASH(SvRV(sv)));
	148	}
	149
	150	PERL_STATIC_INLINE U32
	151	S_SvPADTMP_on(SV *sv)
	152	{
	153	assert(!(SvFLAGS(sv) & SVs_PADMY));
	154	return SvFLAGS(sv) \|= SVs_PADTMP;
	155	}
	156	PERL_STATIC_INLINE U32
	157	S_SvPADTMP_off(SV *sv)
	158	{
	159	assert(!(SvFLAGS(sv) & SVs_PADMY));
	160	return SvFLAGS(sv) &= ~SVs_PADTMP;
	161	}
	162	PERL_STATIC_INLINE U32
	163	S_SvPADSTALE_on(SV *sv)
	164	{
	165	assert(SvFLAGS(sv) & SVs_PADMY);
	166	return SvFLAGS(sv) \|= SVs_PADSTALE;
	167	}
	168	PERL_STATIC_INLINE U32
	169	S_SvPADSTALE_off(SV *sv)
	170	{
	171	assert(SvFLAGS(sv) & SVs_PADMY);
	172	return SvFLAGS(sv) &= ~SVs_PADSTALE;
	173	}
25fdce4a	174	#if defined(PERL_CORE) \|\| defined (PERL_EXT)
4ddea69a	175	PERL_STATIC_INLINE STRLEN
6964422a	176	S_sv_or_pv_pos_u2b(pTHX_ SV sv, const char pv, STRLEN pos, STRLEN *lenp)
4ddea69a	177	{
25fdce4a	178	PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B;
4ddea69a FC	179	if (SvGAMAGIC(sv)) {
	180	U8 hopped = utf8_hop((U8 )pv, pos);
	181	if (lenp) lenp = (STRLEN)(utf8_hop(hopped, lenp) - hopped);
	182	return (STRLEN)(hopped - (U8 *)pv);
	183	}
	184	return sv_pos_u2b_flags(sv,pos,lenp,SV_CONST_RETURN);
	185	}
	186	#endif
f019c49e	187
d1decf2b TC	188	/* ------------------------------- handy.h ------------------------------- */
	189
	190	/* saves machine code for a common noreturn idiom typically used in Newx() /
	191	#ifdef __clang__
	192	#pragma clang diagnostic push
	193	#pragma clang diagnostic ignored "-Wunused-function"
	194	#endif
	195	static void
	196	S_croak_memory_wrap(void)
	197	{
	198	Perl_croak_nocontext("%s",PL_memory_wrap);
	199	}
	200	#ifdef __clang__
	201	#pragma clang diagnostic pop
	202	#endif
	203
3ded5eb0 KW	204	#ifdef BOOTSTRAP_CHARSET
	205	static bool
	206	S_bootstrap_ctype(U8 character, UV classnum, bool full_Latin1)
	207	{
	208	/* See comments in handy.h. This is placed in this file primarily to avoid
	209	* having to have an entry for it in embed.fnc */
	210
	211	dTHX;
	212
	213	if (! full_Latin1 && ! isASCII(character)) {
	214	return FALSE;
	215	}
	216
	217	switch (classnum) {
	218	case _CC_ALPHANUMERIC: return isALPHANUMERIC_L1(character);
	219	case _CC_ALPHA: return isALPHA_L1(character);
	220	case _CC_ASCII: return isASCII_L1(character);
	221	case _CC_BLANK: return isBLANK_L1(character);
	222	case _CC_CASED: return isLOWER_L1(character)
	223	\|\| isUPPER_L1(character);
	224	case _CC_CNTRL: return isCNTRL_L1(character);
	225	case _CC_DIGIT: return isDIGIT_L1(character);
	226	case _CC_GRAPH: return isGRAPH_L1(character);
	227	case _CC_LOWER: return isLOWER_L1(character);
	228	case _CC_PRINT: return isPRINT_L1(character);
	229	case _CC_PSXSPC: return isPSXSPC_L1(character);
	230	case _CC_PUNCT: return isPUNCT_L1(character);
	231	case _CC_SPACE: return isSPACE_L1(character);
	232	case _CC_UPPER: return isUPPER_L1(character);
	233	case _CC_WORDCHAR: return isWORDCHAR_L1(character);
	234	case _CC_XDIGIT: return isXDIGIT_L1(character);
	235	case _CC_VERTSPACE: return isSPACE_L1(character) && ! isBLANK_L1(character);
	236	case _CC_IDFIRST: return isIDFIRST_L1(character);
	237	case _CC_QUOTEMETA: return _isQUOTEMETA(character);
	238	case _CC_CHARNAME_CONT: return isCHARNAME_CONT(character);
	239	case _CC_NONLATIN1_FOLD: return _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(character);
	240	case _CC_NON_FINAL_FOLD: return _IS_NON_FINAL_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(character);
	241	case _CC_IS_IN_SOME_FOLD: return _IS_IN_SOME_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(character);
	242	case _CC_BACKSLASH_FOO_LBRACE_IS_META: return 0;
	243
	244
	245	default: break;
	246	}
	247	Perl_croak(aTHX_ "panic: bootstrap_ctype() has an unexpected character class '%"UVxf"'", classnum);
	248	}
	249	#endif
	250
a8a2ceaa KW	251	/* ------------------------------- utf8.h ------------------------------- */
a8a2ceaa KW	252
55d09dc8 KW	253	PERL_STATIC_INLINE void
	254	S_append_utf8_from_native_byte(const U8 byte, U8** dest)
	255	{
	256	/* Takes an input 'byte' (Latin1 or EBCDIC) and appends it to the UTF-8
	257	* encoded string at 'dest', updating 'dest' to include it */
	258
55d09dc8 KW	259	PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE;
55d09dc8 KW	260
6f2d5cbc	261	if (NATIVE_BYTE_IS_INVARIANT(byte))
9ff651ce	262	(dest)++ = byte;
55d09dc8	263	else {
9ff651ce KW	264	(dest)++ = UTF8_EIGHT_BIT_HI(byte);
9ff651ce KW	265	(dest)++ = UTF8_EIGHT_BIT_LO(byte);
55d09dc8 KW	266	}
	267	}
	268
	269	/* These two exist only to replace the macros they formerly were so that their
	270	* use can be deprecated */
a8a2ceaa KW	271
	272	PERL_STATIC_INLINE bool
	273	S_isIDFIRST_lazy(pTHX_ const char* p)
	274	{
	275	PERL_ARGS_ASSERT_ISIDFIRST_LAZY;
	276
	277	return isIDFIRST_lazy_if(p,1);
	278	}
	279
	280	PERL_STATIC_INLINE bool
	281	S_isALNUM_lazy(pTHX_ const char* p)
	282	{
	283	PERL_ARGS_ASSERT_ISALNUM_LAZY;
	284
	285	return isALNUM_lazy_if(p,1);
	286	}
c8028aa6 TC	287
	288	/* ------------------------------- perl.h ----------------------------- */
	289
	290	/*
41188aa0	291	=for apidoc AiR\|bool\|is_safe_syscall\|const char pv\|STRLEN len\|const char what\|const char *op_name
c8028aa6 TC	292
	293	Test that the given C<pv> doesn't contain any internal NUL characters.
	294	If it does, set C<errno> to ENOENT, optionally warn, and return FALSE.
	295
	296	Return TRUE if the name is safe.
	297
	298	Used by the IS_SAFE_SYSCALL() macro.
	299
	300	=cut
	301	*/
	302
	303	PERL_STATIC_INLINE bool
41188aa0	304	S_is_safe_syscall(pTHX_ const char pv, STRLEN len, const char what, const char *op_name) {
c8028aa6 TC	305	/* While the Windows CE API provides only UCS-16 (or UTF-16) APIs
	306	* perl itself uses xce*() functions which accept 8-bit strings.
	307	*/
	308
	309	PERL_ARGS_ASSERT_IS_SAFE_SYSCALL;
	310
41188aa0	311	if (pv && len > 1) {
c8028aa6	312	char *null_at;
41188aa0	313	if (UNLIKELY((null_at = (char *)memchr(pv, 0, len-1)) != NULL)) {
c8028aa6	314	SETERRNO(ENOENT, LIB_INVARG);
1d505182	315	Perl_ck_warner(aTHX_ packWARN(WARN_SYSCALLS),
c8028aa6	316	"Invalid \\0 character in %s for %s: %s\\0%s",
41188aa0	317	what, op_name, pv, null_at+1);
c8028aa6 TC	318	return FALSE;
	319	}
	320	}
	321
	322	return TRUE;
	323	}
	324
	325	/*
	326	* Local variables:
	327	* c-indentation-style: bsd
	328	* c-basic-offset: 4
	329	* indent-tabs-mode: nil
	330	* End:
	331	*
	332	* ex: set ts=8 sts=4 sw=4 et:
	333	*/