[perl5.git] / dist / Devel-PPPort / parts / inc / uv

################################################################################
##
##  Version 3.x, Copyright (C) 2004-2013, Marcus Holland-Moritz.
##  Version 2.x, Copyright (C) 2001, Paul Marquess.
##  Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
##
##  This program is free software; you can redistribute it and/or
##  modify it under the same terms as Perl itself.
##
################################################################################

=provides

__UNDEFINED__
my_strnlen
SvUOK

=implementation

__UNDEFINED__  sv_setuv(sv, uv)                     \
               STMT_START {                         \
                 UV TeMpUv = uv;                    \
                 if (TeMpUv <= IV_MAX)              \
                   sv_setiv(sv, TeMpUv);            \
                 else                               \
                   sv_setnv(sv, (double)TeMpUv);    \
               } STMT_END

__UNDEFINED__  newSVuv(uv)     ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))

__UNDEFINED__  sv_2uv(sv)      ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
__UNDEFINED__  SvUVX(sv)       ((UV)SvIVX(sv))
__UNDEFINED__  SvUVXx(sv)      SvUVX(sv)
__UNDEFINED__  SvUV(sv)        (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
__UNDEFINED__  SvUVx(sv)       ((PL_Sv = (sv)), SvUV(PL_Sv))

/* Hint: sv_uv
 * Always use the SvUVx() macro instead of sv_uv().
 */
__UNDEFINED__  sv_uv(sv)       SvUVx(sv)

#if !defined(SvUOK) && defined(SvIOK_UV)
#  define SvUOK(sv) SvIOK_UV(sv)
#endif

__UNDEFINED__  XST_mUV(i,v)    (ST(i) = sv_2mortal(newSVuv(v))  )
__UNDEFINED__  XSRETURN_UV(v)  STMT_START { XST_mUV(0,v);  XSRETURN(1); } STMT_END

__UNDEFINED__  PUSHu(u)        STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG;  } STMT_END
__UNDEFINED__  XPUSHu(u)       STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END

#if defined UTF8SKIP

/* Don't use official version because it uses MIN, which may not be available */
#undef UTF8_SAFE_SKIP

__UNDEFINED__  UTF8_SAFE_SKIP(s, e)  (__ASSERT_((e) >= (s))                     \
                                      ((e) - (s)) <= 0                          \
                                      ? 0                                       \
                                      : (((e) - (s)) >= UTF8SKIP(s))            \
                                         ? ((e) - (s))                          \
                                         : UTF8SKIP(s))
#endif

#if !defined(my_strnlen)
#if { NEED my_strnlen }

STRLEN
my_strnlen(const char *str, Size_t maxlen)
{
    const char *p = str;

    while(maxlen-- && *p)
        p++;

    return p - str;
}

#endif
#endif
#if defined(utf8n_to_uvchr)

__UNDEFINED__  utf8_to_uvchr_buf(s,e,lp)  (__ASSERT_(e >= s)                \
                       utf8n_to_uvchr((s), ((e)-(s)), (lp),                 \
                                    (UTF8_ALLOW_ANYUV & ~UTF8_ALLOW_LONG)))

#elif defined(utf8_to_uv)

__UNDEFINED__  utf8_to_uvchr_buf(s,e,lp)  (__ASSERT_(e >= s)                \
                       utf8_to_uv((s), ((e)-(s)), (lp),                     \
                                    (UTF8_ALLOW_ANYUV & ~UTF8_ALLOW_LONG)))
#endif

#undef utf8_to_uvchr

/* Always redefine this unsafe function so that it refuses to read past a NUL,
 * making it much less likely to read off the end of the buffer.  A NUL
 * indicates the start of the next character anyway.  If the input isn't
 * NUL-terminated, the function remains unsafe, as it always has been.
 */

__UNDEFINED__  utf8_to_uvchr(s, lp)                                             \
    ((*(s) == '\0')                                                             \
    ? utf8_to_uvchr_buf(s,((s)+1), lp) /* Handle single NUL specially */        \
    : utf8_to_uvchr_buf(s, (s) + my_strnlen((char *) (s), UTF8SKIP(s)), (lp)))

=xsinit

#define NEED_my_strnlen

=xsubs

SV *
sv_setuv(uv)
        UV uv
        CODE:
                RETVAL = newSViv(1);
                sv_setuv(RETVAL, uv);
        OUTPUT:
                RETVAL

SV *
newSVuv(uv)
        UV uv
        CODE:
                RETVAL = newSVuv(uv);
        OUTPUT:
                RETVAL

UV
sv_2uv(sv)
        SV *sv
        CODE:
                RETVAL = sv_2uv(sv);
        OUTPUT:
                RETVAL

UV
SvUVx(sv)
        SV *sv
        CODE:
                sv--;
                RETVAL = SvUVx(++sv);
        OUTPUT:
                RETVAL

void
XSRETURN_UV()
        PPCODE:
                XSRETURN_UV(42);

void
PUSHu()
        PREINIT:
                dTARG;
        PPCODE:
                TARG = sv_newmortal();
                EXTEND(SP, 1);
                PUSHu(42);
                XSRETURN(1);

void
XPUSHu()
        PREINIT:
                dTARG;
        PPCODE:
                TARG = sv_newmortal();
                XPUSHu(43);
                XSRETURN(1);

STRLEN
UTF8_SAFE_SKIP(s, adjustment)
        unsigned char * s
        int adjustment
        CODE:
            /* Instead of passing in an 'e' ptr, use the real end, adjusted */
            RETVAL = UTF8_SAFE_SKIP(s, s + UTF8SKIP(s) + adjustment);
        OUTPUT:
            RETVAL

STRLEN
my_strnlen(s, max)
        char * s
        STRLEN max
        CODE:
            RETVAL= my_strnlen(s, max);
        OUTPUT:
            RETVAL

AV *
utf8_to_uvchr_buf(s)
        unsigned char *s
        PREINIT:
            AV *av;
            STRLEN len;
        CODE:
            av = newAV();
            av_push(av, newSVuv(utf8_to_uvchr_buf(s, s + UTF8SKIP(s), &len)));
            av_push(av, newSVuv(len));
            RETVAL = av;
        OUTPUT:
                RETVAL

AV *
utf8_to_uvchr(s)
        unsigned char *s
        PREINIT:
            AV *av;
            STRLEN len;
        CODE:
            av = newAV();
            av_push(av, newSVuv(utf8_to_uvchr(s, &len)));
            av_push(av, newSVuv(len));
            RETVAL = av;
        OUTPUT:
                RETVAL

=tests plan => 21

ok(&Devel::PPPort::sv_setuv(42), 42);
ok(&Devel::PPPort::newSVuv(123), 123);
ok(&Devel::PPPort::sv_2uv("4711"), 4711);
ok(&Devel::PPPort::sv_2uv("1735928559"), 1735928559);
ok(&Devel::PPPort::SvUVx("1735928559"), 1735928559);
ok(&Devel::PPPort::SvUVx(1735928559), 1735928559);
ok(&Devel::PPPort::SvUVx(0xdeadbeef), 0xdeadbeef);
ok(&Devel::PPPort::XSRETURN_UV(), 42);
ok(&Devel::PPPort::PUSHu(), 42);
ok(&Devel::PPPort::XPUSHu(), 43);
ok(&Devel::PPPort::UTF8_SAFE_SKIP("A", 0), 1);
ok(&Devel::PPPort::UTF8_SAFE_SKIP("A", -1), 0);
ok(&Devel::PPPort::my_strnlen("abc\0def", 7), 3);
my $ret = &Devel::PPPort::utf8_to_uvchr_buf("A");
ok($ret->[0], ord("A"));
ok($ret->[1], 1);
$ret = &Devel::PPPort::utf8_to_uvchr_buf("\0");
ok($ret->[0], 0);
ok($ret->[1], 1);
$ret = &Devel::PPPort::utf8_to_uvchr("A");
ok($ret->[0], ord("A"));
ok($ret->[1], 1);
$ret = &Devel::PPPort::utf8_to_uvchr("\0");
ok($ret->[0], 0);
ok($ret->[1], 1);
Commit	Line	Data
adfe19db MHM	1	################################################################################
adfe19db MHM	2	##
b2049988	3	## Version 3.x, Copyright (C) 2004-2013, Marcus Holland-Moritz.
adfe19db MHM	4	## Version 2.x, Copyright (C) 2001, Paul Marquess.
	5	## Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
	6	##
	7	## This program is free software; you can redistribute it and/or
	8	## modify it under the same terms as Perl itself.
	9	##
	10	################################################################################
	11
	12	=provides
	13
adfe19db	14	__UNDEFINED__
e28192fd	15	my_strnlen
679ad62d	16	SvUOK
adfe19db MHM	17
	18	=implementation
	19
0d0f8426 MHM	20	__UNDEFINED__ sv_setuv(sv, uv) \
	21	STMT_START { \
	22	UV TeMpUv = uv; \
	23	if (TeMpUv <= IV_MAX) \
	24	sv_setiv(sv, TeMpUv); \
	25	else \
	26	sv_setnv(sv, (double)TeMpUv); \
	27	} STMT_END
	28
	29	__UNDEFINED__ newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
adfe19db MHM	30
	31	__UNDEFINED__ sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
	32	__UNDEFINED__ SvUVX(sv) ((UV)SvIVX(sv))
	33	__UNDEFINED__ SvUVXx(sv) SvUVX(sv)
	34	__UNDEFINED__ SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
	35	__UNDEFINED__ SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv))
	36
	37	/* Hint: sv_uv
	38	* Always use the SvUVx() macro instead of sv_uv().
	39	*/
	40	__UNDEFINED__ sv_uv(sv) SvUVx(sv)
	41
679ad62d MHM	42	#if !defined(SvUOK) && defined(SvIOK_UV)
	43	# define SvUOK(sv) SvIOK_UV(sv)
	44	#endif
	45
adfe19db MHM	46	__UNDEFINED__ XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) )
	47	__UNDEFINED__ XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END
	48
96ad942f MHM	49	__UNDEFINED__ PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END
	50	__UNDEFINED__ XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
	51
f2e3e4ce	52	#if defined UTF8SKIP
94a2c4f7 KW	53
	54	/* Don't use official version because it uses MIN, which may not be available */
	55	#undef UTF8_SAFE_SKIP
	56
f2e3e4ce KW	57	__UNDEFINED__ UTF8_SAFE_SKIP(s, e) (__ASSERT_((e) >= (s)) \
	58	((e) - (s)) <= 0 \
	59	? 0 \
	60	: (((e) - (s)) >= UTF8SKIP(s)) \
	61	? ((e) - (s)) \
	62	: UTF8SKIP(s))
	63	#endif
	64
e28192fd KW	65	#if !defined(my_strnlen)
	66	#if { NEED my_strnlen }
	67
	68	STRLEN
	69	my_strnlen(const char *str, Size_t maxlen)
	70	{
	71	const char *p = str;
	72
	73	while(maxlen-- && *p)
	74	p++;
	75
	76	return p - str;
	77	}
	78
	79	#endif
	80	#endif
4c28bdc5 KW	81	#if defined(utf8n_to_uvchr)
	82
	83	__UNDEFINED__ utf8_to_uvchr_buf(s,e,lp) (__ASSERT_(e >= s) \
	84	utf8n_to_uvchr((s), ((e)-(s)), (lp), \
	85	(UTF8_ALLOW_ANYUV & ~UTF8_ALLOW_LONG)))
	86
	87	#elif defined(utf8_to_uv)
	88
	89	__UNDEFINED__ utf8_to_uvchr_buf(s,e,lp) (__ASSERT_(e >= s) \
	90	utf8_to_uv((s), ((e)-(s)), (lp), \
	91	(UTF8_ALLOW_ANYUV & ~UTF8_ALLOW_LONG)))
	92	#endif
e28192fd	93
39d7245c KW	94	#undef utf8_to_uvchr
	95
	96	/* Always redefine this unsafe function so that it refuses to read past a NUL,
	97	* making it much less likely to read off the end of the buffer. A NUL
	98	* indicates the start of the next character anyway. If the input isn't
	99	* NUL-terminated, the function remains unsafe, as it always has been.
	100	*/
	101
	102	__UNDEFINED__ utf8_to_uvchr(s, lp) \
	103	((*(s) == '\0') \
	104	? utf8_to_uvchr_buf(s,((s)+1), lp) /* Handle single NUL specially */ \
	105	: utf8_to_uvchr_buf(s, (s) + my_strnlen((char *) (s), UTF8SKIP(s)), (lp)))
	106
e28192fd KW	107	=xsinit
	108
	109	#define NEED_my_strnlen
	110
adfe19db MHM	111	=xsubs
	112
	113	SV *
	114	sv_setuv(uv)
b2049988 MHM	115	UV uv
	116	CODE:
	117	RETVAL = newSViv(1);
	118	sv_setuv(RETVAL, uv);
	119	OUTPUT:
	120	RETVAL
adfe19db MHM	121
	122	SV *
	123	newSVuv(uv)
b2049988 MHM	124	UV uv
	125	CODE:
	126	RETVAL = newSVuv(uv);
	127	OUTPUT:
	128	RETVAL
adfe19db MHM	129
	130	UV
	131	sv_2uv(sv)
b2049988 MHM	132	SV *sv
	133	CODE:
	134	RETVAL = sv_2uv(sv);
	135	OUTPUT:
	136	RETVAL
adfe19db MHM	137
	138	UV
	139	SvUVx(sv)
b2049988 MHM	140	SV *sv
	141	CODE:
	142	sv--;
	143	RETVAL = SvUVx(++sv);
	144	OUTPUT:
	145	RETVAL
adfe19db MHM	146
	147	void
	148	XSRETURN_UV()
b2049988 MHM	149	PPCODE:
b2049988 MHM	150	XSRETURN_UV(42);
adfe19db	151
96ad942f MHM	152	void
96ad942f MHM	153	PUSHu()
b2049988 MHM	154	PREINIT:
	155	dTARG;
	156	PPCODE:
	157	TARG = sv_newmortal();
	158	EXTEND(SP, 1);
	159	PUSHu(42);
	160	XSRETURN(1);
96ad942f MHM	161
	162	void
	163	XPUSHu()
b2049988 MHM	164	PREINIT:
	165	dTARG;
	166	PPCODE:
	167	TARG = sv_newmortal();
	168	XPUSHu(43);
	169	XSRETURN(1);
96ad942f	170
f2e3e4ce KW	171	STRLEN
	172	UTF8_SAFE_SKIP(s, adjustment)
	173	unsigned char * s
	174	int adjustment
	175	CODE:
	176	/* Instead of passing in an 'e' ptr, use the real end, adjusted */
	177	RETVAL = UTF8_SAFE_SKIP(s, s + UTF8SKIP(s) + adjustment);
	178	OUTPUT:
	179	RETVAL
	180
e28192fd KW	181	STRLEN
	182	my_strnlen(s, max)
	183	char * s
	184	STRLEN max
	185	CODE:
	186	RETVAL= my_strnlen(s, max);
	187	OUTPUT:
	188	RETVAL
	189
4c28bdc5 KW	190	AV *
	191	utf8_to_uvchr_buf(s)
	192	unsigned char *s
	193	PREINIT:
	194	AV *av;
	195	STRLEN len;
	196	CODE:
	197	av = newAV();
	198	av_push(av, newSVuv(utf8_to_uvchr_buf(s, s + UTF8SKIP(s), &len)));
	199	av_push(av, newSVuv(len));
	200	RETVAL = av;
	201	OUTPUT:
	202	RETVAL
	203
39d7245c KW	204	AV *
	205	utf8_to_uvchr(s)
	206	unsigned char *s
	207	PREINIT:
	208	AV *av;
	209	STRLEN len;
	210	CODE:
	211	av = newAV();
	212	av_push(av, newSVuv(utf8_to_uvchr(s, &len)));
	213	av_push(av, newSVuv(len));
	214	RETVAL = av;
	215	OUTPUT:
	216	RETVAL
	217
	218	=tests plan => 21
adfe19db MHM	219
	220	ok(&Devel::PPPort::sv_setuv(42), 42);
	221	ok(&Devel::PPPort::newSVuv(123), 123);
	222	ok(&Devel::PPPort::sv_2uv("4711"), 4711);
	223	ok(&Devel::PPPort::sv_2uv("1735928559"), 1735928559);
	224	ok(&Devel::PPPort::SvUVx("1735928559"), 1735928559);
	225	ok(&Devel::PPPort::SvUVx(1735928559), 1735928559);
	226	ok(&Devel::PPPort::SvUVx(0xdeadbeef), 0xdeadbeef);
	227	ok(&Devel::PPPort::XSRETURN_UV(), 42);
96ad942f MHM	228	ok(&Devel::PPPort::PUSHu(), 42);
96ad942f MHM	229	ok(&Devel::PPPort::XPUSHu(), 43);
f2e3e4ce KW	230	ok(&Devel::PPPort::UTF8_SAFE_SKIP("A", 0), 1);
f2e3e4ce KW	231	ok(&Devel::PPPort::UTF8_SAFE_SKIP("A", -1), 0);
e28192fd	232	ok(&Devel::PPPort::my_strnlen("abc\0def", 7), 3);
4c28bdc5 KW	233	my $ret = &Devel::PPPort::utf8_to_uvchr_buf("A");
	234	ok($ret->[0], ord("A"));
	235	ok($ret->[1], 1);
	236	$ret = &Devel::PPPort::utf8_to_uvchr_buf("\0");
	237	ok($ret->[0], 0);
	238	ok($ret->[1], 1);
39d7245c KW	239	$ret = &Devel::PPPort::utf8_to_uvchr("A");
	240	ok($ret->[0], ord("A"));
	241	ok($ret->[1], 1);
	242	$ret = &Devel::PPPort::utf8_to_uvchr("\0");
	243	ok($ret->[0], 0);
	244	ok($ret->[1], 1);