/* We want to be able to test things that aren't API yet. */
#define PERL_EXT
-#define PERL_NO_GET_CONTEXT /* we wants efficiency */
+/* Do *not* define PERL_NO_GET_CONTEXT. This is the one place where we get
+ to test implicit Perl_get_context(). */
+
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
START_MY_CXT
+int
+S_myset_set(pTHX_ SV* sv, MAGIC* mg)
+{
+ SV *isv = (SV*)mg->mg_ptr;
+
+ PERL_UNUSED_ARG(sv);
+ SvIVX(isv)++;
+ return 0;
+}
+
MGVTBL vtbl_foo, vtbl_bar;
+MGVTBL vtbl_myset = { 0, S_myset_set, 0, 0, 0, 0, 0, 0 };
+
/* indirect functions to test the [pa]MY_CXT macros */
SV*
my_cxt_getsv_interp(void)
{
- dTHX;
dMY_CXT;
return MY_CXT.sv;
}
typedef void (freeent_function)(pTHX_ HV *, HE *);
void
-test_freeent(pTHX_ freeent_function *f) {
+test_freeent(freeent_function *f) {
dSP;
HV *test_hash = newHV();
HE *victim;
#else
/* Storing then deleting something should ensure that a hash entry is
available. */
- (void) hv_store(test_hash, "", 0, &PL_sv_yes, 0);
- (void) hv_delete(test_hash, "", 0, 0);
+ (void) hv_stores(test_hash, "", &PL_sv_yes);
+ (void) hv_deletes(test_hash, "", 0);
/* We need to "inline" new_he here as it's static, and the functions we
test expect to be able to call del_HE on the HE */
return sumop;
}
-STATIC void test_op_list_describe_part(pTHX_ SV *res, OP *o);
+STATIC void test_op_list_describe_part(SV *res, OP *o);
STATIC void
-test_op_list_describe_part(pTHX_ SV *res, OP *o)
+test_op_list_describe_part(SV *res, OP *o)
{
sv_catpv(res, PL_op_name[o->op_type]);
switch (o->op_type) {
OP *k;
sv_catpvs(res, "[");
for (k = cUNOPx(o)->op_first; k; k = OpSIBLING(k))
- test_op_list_describe_part(aTHX_ res, k);
+ test_op_list_describe_part(res, k);
sv_catpvs(res, "]");
} else {
sv_catpvs(res, ".");
}
STATIC char *
-test_op_list_describe(pTHX_ OP *o)
+test_op_list_describe(OP *o)
{
SV *res = sv_2mortal(newSVpvs(""));
if (o)
- test_op_list_describe_part(aTHX_ res, o);
+ test_op_list_describe_part(res, o);
return SvPVX(res);
}
}
static char *
-test_op_linklist_describe(pTHX_ OP *start)
+test_op_linklist_describe(OP *start)
{
SV *rv = sv_2mortal(newSVpvs(""));
OP *o;
static int my_keyword_plugin(pTHX_
char *keyword_ptr, STRLEN keyword_len, OP **op_ptr)
{
- if(keyword_len == 3 && strnEQ(keyword_ptr, "rpn", 3) &&
+ if(keyword_len == 3 && strEQs(keyword_ptr, "rpn") &&
keyword_active(hintkey_rpn_sv)) {
*op_ptr = parse_keyword_rpn();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 7 && strnEQ(keyword_ptr, "calcrpn", 7) &&
+ } else if(keyword_len == 7 && strEQs(keyword_ptr, "calcrpn") &&
keyword_active(hintkey_calcrpn_sv)) {
*op_ptr = parse_keyword_calcrpn();
return KEYWORD_PLUGIN_STMT;
- } else if(keyword_len == 9 && strnEQ(keyword_ptr, "stufftest", 9) &&
+ } else if(keyword_len == 9 && strEQs(keyword_ptr, "stufftest") &&
keyword_active(hintkey_stufftest_sv)) {
*op_ptr = parse_keyword_stufftest();
return KEYWORD_PLUGIN_STMT;
} else if(keyword_len == 12 &&
- strnEQ(keyword_ptr, "swaptwostmts", 12) &&
+ strEQs(keyword_ptr, "swaptwostmts") &&
keyword_active(hintkey_swaptwostmts_sv)) {
*op_ptr = parse_keyword_swaptwostmts();
return KEYWORD_PLUGIN_STMT;
- } else if(keyword_len == 8 && strnEQ(keyword_ptr, "looprest", 8) &&
+ } else if(keyword_len == 8 && strEQs(keyword_ptr, "looprest") &&
keyword_active(hintkey_looprest_sv)) {
*op_ptr = parse_keyword_looprest();
return KEYWORD_PLUGIN_STMT;
- } else if(keyword_len == 14 && strnEQ(keyword_ptr, "scopelessblock", 14) &&
+ } else if(keyword_len == 14 && strEQs(keyword_ptr, "scopelessblock") &&
keyword_active(hintkey_scopelessblock_sv)) {
*op_ptr = parse_keyword_scopelessblock();
return KEYWORD_PLUGIN_STMT;
- } else if(keyword_len == 10 && strnEQ(keyword_ptr, "stmtasexpr", 10) &&
+ } else if(keyword_len == 10 && strEQs(keyword_ptr, "stmtasexpr") &&
keyword_active(hintkey_stmtasexpr_sv)) {
*op_ptr = parse_keyword_stmtasexpr();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 11 && strnEQ(keyword_ptr, "stmtsasexpr", 11) &&
+ } else if(keyword_len == 11 && strEQs(keyword_ptr, "stmtsasexpr") &&
keyword_active(hintkey_stmtsasexpr_sv)) {
*op_ptr = parse_keyword_stmtsasexpr();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 9 && strnEQ(keyword_ptr, "loopblock", 9) &&
+ } else if(keyword_len == 9 && strEQs(keyword_ptr, "loopblock") &&
keyword_active(hintkey_loopblock_sv)) {
*op_ptr = parse_keyword_loopblock();
return KEYWORD_PLUGIN_STMT;
- } else if(keyword_len == 11 && strnEQ(keyword_ptr, "blockasexpr", 11) &&
+ } else if(keyword_len == 11 && strEQs(keyword_ptr, "blockasexpr") &&
keyword_active(hintkey_blockasexpr_sv)) {
*op_ptr = parse_keyword_blockasexpr();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 9 && strnEQ(keyword_ptr, "swaplabel", 9) &&
+ } else if(keyword_len == 9 && strEQs(keyword_ptr, "swaplabel") &&
keyword_active(hintkey_swaplabel_sv)) {
*op_ptr = parse_keyword_swaplabel();
return KEYWORD_PLUGIN_STMT;
- } else if(keyword_len == 10 && strnEQ(keyword_ptr, "labelconst", 10) &&
+ } else if(keyword_len == 10 && strEQs(keyword_ptr, "labelconst") &&
keyword_active(hintkey_labelconst_sv)) {
*op_ptr = parse_keyword_labelconst();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 13 && strnEQ(keyword_ptr, "arrayfullexpr", 13) &&
+ } else if(keyword_len == 13 && strEQs(keyword_ptr, "arrayfullexpr") &&
keyword_active(hintkey_arrayfullexpr_sv)) {
*op_ptr = parse_keyword_arrayfullexpr();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 13 && strnEQ(keyword_ptr, "arraylistexpr", 13) &&
+ } else if(keyword_len == 13 && strEQs(keyword_ptr, "arraylistexpr") &&
keyword_active(hintkey_arraylistexpr_sv)) {
*op_ptr = parse_keyword_arraylistexpr();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 13 && strnEQ(keyword_ptr, "arraytermexpr", 13) &&
+ } else if(keyword_len == 13 && strEQs(keyword_ptr, "arraytermexpr") &&
keyword_active(hintkey_arraytermexpr_sv)) {
*op_ptr = parse_keyword_arraytermexpr();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 14 && strnEQ(keyword_ptr, "arrayarithexpr", 14) &&
+ } else if(keyword_len == 14 && strEQs(keyword_ptr, "arrayarithexpr") &&
keyword_active(hintkey_arrayarithexpr_sv)) {
*op_ptr = parse_keyword_arrayarithexpr();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 14 && strnEQ(keyword_ptr, "arrayexprflags", 14) &&
+ } else if(keyword_len == 14 && strEQs(keyword_ptr, "arrayexprflags") &&
keyword_active(hintkey_arrayexprflags_sv)) {
*op_ptr = parse_keyword_arrayexprflags();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 5 && strnEQ(keyword_ptr, "DEFSV", 5) &&
+ } else if(keyword_len == 5 && strEQs(keyword_ptr, "DEFSV") &&
keyword_active(hintkey_DEFSV_sv)) {
*op_ptr = parse_keyword_DEFSV();
return KEYWORD_PLUGIN_EXPR;
- } else if(keyword_len == 9 && strnEQ(keyword_ptr, "with_vars", 9) &&
+ } else if(keyword_len == 9 && strEQs(keyword_ptr, "with_vars") &&
keyword_active(hintkey_with_vars_sv)) {
*op_ptr = parse_keyword_with_vars();
return KEYWORD_PLUGIN_STMT;
- } else if(keyword_len == 15 && strnEQ(keyword_ptr, "join_with_space", 15) &&
+ } else if(keyword_len == 15 && strEQs(keyword_ptr, "join_with_space") &&
keyword_active(hintkey_join_with_space_sv)) {
*op_ptr = parse_join_with_space();
return KEYWORD_PLUGIN_EXPR;
peep_xop(pTHX_ OP *o, OP *oldop)
{
dMY_CXT;
- av_push(MY_CXT.xop_record, newSVpvf("peep:%"UVxf, PTR2UV(o)));
- av_push(MY_CXT.xop_record, newSVpvf("oldop:%"UVxf, PTR2UV(oldop)));
+ av_push(MY_CXT.xop_record, newSVpvf("peep:%" UVxf, PTR2UV(o)));
+ av_push(MY_CXT.xop_record, newSVpvf("oldop:%" UVxf, PTR2UV(oldop)));
}
static I32
RETVAL
AV *
-test_utf8n_to_uvchr(s, len, flags)
+test_utf8n_to_uvchr_error(s, len, flags)
SV *s
SV *len
STRLEN retlen;
UV ret;
STRLEN slen;
+ U32 errors;
CODE:
- /* Call utf8n_to_uvchr() with the inputs. It always asks for the
- * actual length to be returned
+ /* Now that utf8n_to_uvchr() is a trivial wrapper for
+ * utf8n_to_uvchr_error(), call the latter with the inputs. It always
+ * asks for the actual length to be returned and errors to be returned
*
* Length to assume <s> is; not checked, so could have buffer overflow
*/
RETVAL = newAV();
sv_2mortal((SV*)RETVAL);
- ret
- = utf8n_to_uvchr((U8*) SvPV(s, slen), SvUV(len), &retlen, SvUV(flags));
+ ret = utf8n_to_uvchr_error((U8*) SvPV(s, slen),
+ SvUV(len),
+ &retlen,
+ SvUV(flags),
+ &errors);
- /* Returns the return value in [0]; <retlen> in [1] */
+ /* Returns the return value in [0]; <retlen> in [1], <errors> in [2] */
av_push(RETVAL, newSVuv(ret));
if (retlen == (STRLEN) -1) {
av_push(RETVAL, newSViv(-1));
else {
av_push(RETVAL, newSVuv(retlen));
}
+ av_push(RETVAL, newSVuv(errors));
OUTPUT:
RETVAL
void
test_hv_free_ent()
PPCODE:
- test_freeent(aTHX_ &Perl_hv_free_ent);
+ test_freeent(&Perl_hv_free_ent);
XSRETURN(4);
void
test_hv_delayfree_ent()
PPCODE:
- test_freeent(aTHX_ &Perl_hv_delayfree_ent);
+ test_freeent(&Perl_hv_delayfree_ent);
XSRETURN(4);
SV *
IV level
CODE:
if (level) {
- croak("level must be zero, not %"IVdf, level);
+ croak("level must be zero, not %" IVdf, level);
}
RETVAL = (cop_hints_fetch_sv(PL_curcop, key, 0, 0) != &PL_sv_placeholder);
OUTPUT:
IV level
CODE:
if (level) {
- croak("level must be zero, not %"IVdf, level);
+ croak("level must be zero, not %" IVdf, level);
}
RETVAL = cop_hints_fetch_sv(PL_curcop, key, 0, 0);
SvREFCNT_inc(RETVAL);
unop->op_next = NULL;
kid->op_next = (OP*)unop;
- av_push(MY_CXT.xop_record, newSVpvf("unop:%"UVxf, PTR2UV(unop)));
- av_push(MY_CXT.xop_record, newSVpvf("kid:%"UVxf, PTR2UV(kid)));
+ av_push(MY_CXT.xop_record, newSVpvf("unop:%" UVxf, PTR2UV(unop)));
+ av_push(MY_CXT.xop_record, newSVpvf("kid:%" UVxf, PTR2UV(kid)));
av_push(MY_CXT.xop_record, newSVpvf("NAME:%s", OP_NAME((OP*)unop)));
av_push(MY_CXT.xop_record, newSVpvf("DESC:%s", OP_DESC((OP*)unop)));
gv = gv_fetchmethod_pvn_flags(stash, name, len, flags | SvUTF8(methname));
break;
}
+ case 4:
+ gv = gv_fetchmethod_pvn_flags(stash, SvPV_nolen(methname),
+ flags, SvUTF8(methname));
}
XPUSHs( gv ? (SV*)gv : &PL_sv_undef);
#define iv_op(iv) newSVOP(OP_CONST, 0, newSViv(iv))
#define check_op(o, expect) \
do { \
- if (strcmp(test_op_list_describe(aTHX_ o), (expect))) \
- croak("fail %s %s", test_op_list_describe(aTHX_ o),(expect)); \
+ if (strcmp(test_op_list_describe(o), (expect))) \
+ croak("fail %s %s", test_op_list_describe(o), (expect)); \
} while(0)
a = op_append_elem(OP_LIST, NULL, NULL);
check_op(a, "");
CODE:
#define check_ll(o, expect) \
STMT_START { \
- if (strNE(test_op_linklist_describe(aTHX_ o), (expect))) \
- croak("fail %s %s", test_op_linklist_describe(aTHX_ o), \
- (expect)); \
+ if (strNE(test_op_linklist_describe(o), (expect))) \
+ croak("fail %s %s", test_op_linklist_describe(o), (expect)); \
} STMT_END
o = iv_op(1);
check_ll(o, ".const1");
SAVESPTR(PL_comppad_name); PL_comppad_name = PadlistNAMES(pl);
SAVESPTR(PL_comppad); PL_comppad = PadlistARRAY(pl)[1];
SAVESPTR(PL_curpad); PL_curpad = PadARRAY(PL_comppad);
- off = pad_add_name_sv(sv_2mortal(newSVpvf("&%"SVf,name)),
+ off = pad_add_name_sv(sv_2mortal(newSVpvf("&%" SVf,name)),
padadd_STATE, 0, 0);
SvREFCNT_dec(PL_curpad[off]);
PL_curpad[off] = SvREFCNT_inc(cv);
} else if (items == 3) {
Perl_load_module(aTHX_ flags, SvREFCNT_inc(name), SvREFCNT_inc(ST(2)));
} else
- Perl_croak(aTHX_ "load_module can't yet support %"IVdf" items", (IV)items);
+ Perl_croak(aTHX_ "load_module can't yet support %" IVdf " items",
+ (IV)items);
+
+SV *
+string_without_null(SV *sv)
+ CODE:
+ {
+ STRLEN len;
+ const char *s = SvPV(sv, len);
+ RETVAL = newSVpvn_flags(s, len, SvUTF8(sv));
+ *SvEND(RETVAL) = 0xff;
+ }
+ OUTPUT:
+ RETVAL
MODULE = XS::APItest PACKAGE = XS::APItest::AUTOLOADtest
OUTPUT:
RETVAL
+
+ # attach ext magic to the SV pointed to by rsv that only has set magic,
+ # where that magic's job is to increment thingy
+
+void
+sv_magic_myset(SV *rsv, SV *thingy)
+CODE:
+ sv_magicext(SvRV(rsv), NULL, PERL_MAGIC_ext, &vtbl_myset,
+ (const char *)thingy, 0);
+
+
+
bool
test_isBLANK_uni(UV ord)
CODE:
RETVAL
bool
+test_isBLANK_uvchr(UV ord)
+ CODE:
+ RETVAL = isBLANK_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isBLANK_LC_uvchr(UV ord)
CODE:
RETVAL = isBLANK_LC_uvchr(ord);
RETVAL
bool
+test_isBLANK(UV ord)
+ CODE:
+ RETVAL = isBLANK(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isBLANK_A(UV ord)
CODE:
RETVAL = isBLANK_A(ord);
RETVAL
bool
+test_isVERTWS_uvchr(UV ord)
+ CODE:
+ RETVAL = isVERTWS_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isVERTWS_utf8(unsigned char * p)
CODE:
RETVAL = isVERTWS_utf8(p);
RETVAL
bool
+test_isUPPER_uvchr(UV ord)
+ CODE:
+ RETVAL = isUPPER_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isUPPER_LC_uvchr(UV ord)
CODE:
RETVAL = isUPPER_LC_uvchr(ord);
RETVAL
bool
+test_isUPPER(UV ord)
+ CODE:
+ RETVAL = isUPPER(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isUPPER_A(UV ord)
CODE:
RETVAL = isUPPER_A(ord);
RETVAL
bool
+test_isLOWER_uvchr(UV ord)
+ CODE:
+ RETVAL = isLOWER_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isLOWER_LC_uvchr(UV ord)
CODE:
RETVAL = isLOWER_LC_uvchr(ord);
RETVAL
bool
+test_isLOWER(UV ord)
+ CODE:
+ RETVAL = isLOWER(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isLOWER_A(UV ord)
CODE:
RETVAL = isLOWER_A(ord);
RETVAL
bool
+test_isALPHA_uvchr(UV ord)
+ CODE:
+ RETVAL = isALPHA_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isALPHA_LC_uvchr(UV ord)
CODE:
RETVAL = isALPHA_LC_uvchr(ord);
RETVAL
bool
+test_isALPHA(UV ord)
+ CODE:
+ RETVAL = isALPHA(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isALPHA_A(UV ord)
CODE:
RETVAL = isALPHA_A(ord);
RETVAL
bool
+test_isWORDCHAR_uvchr(UV ord)
+ CODE:
+ RETVAL = isWORDCHAR_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isWORDCHAR_LC_uvchr(UV ord)
CODE:
RETVAL = isWORDCHAR_LC_uvchr(ord);
RETVAL
bool
+test_isWORDCHAR(UV ord)
+ CODE:
+ RETVAL = isWORDCHAR(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isWORDCHAR_A(UV ord)
CODE:
RETVAL = isWORDCHAR_A(ord);
RETVAL
bool
+test_isALPHANUMERIC_uvchr(UV ord)
+ CODE:
+ RETVAL = isALPHANUMERIC_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isALPHANUMERIC_LC_uvchr(UV ord)
CODE:
RETVAL = isALPHANUMERIC_LC_uvchr(ord);
RETVAL
bool
+test_isALPHANUMERIC(UV ord)
+ CODE:
+ RETVAL = isALPHANUMERIC(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isALPHANUMERIC_A(UV ord)
CODE:
RETVAL = isALPHANUMERIC_A(ord);
RETVAL
bool
+test_isALNUM(UV ord)
+ CODE:
+ RETVAL = isALNUM(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isALNUM_uni(UV ord)
CODE:
RETVAL = isALNUM_uni(ord);
RETVAL
bool
+test_isDIGIT_uvchr(UV ord)
+ CODE:
+ RETVAL = isDIGIT_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isDIGIT_LC_uvchr(UV ord)
CODE:
RETVAL = isDIGIT_LC_uvchr(ord);
RETVAL
bool
+test_isDIGIT(UV ord)
+ CODE:
+ RETVAL = isDIGIT(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isDIGIT_A(UV ord)
CODE:
RETVAL = isDIGIT_A(ord);
RETVAL
bool
+test_isOCTAL(UV ord)
+ CODE:
+ RETVAL = isOCTAL(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isOCTAL_A(UV ord)
CODE:
RETVAL = isOCTAL_A(ord);
RETVAL
bool
+test_isIDFIRST_uvchr(UV ord)
+ CODE:
+ RETVAL = isIDFIRST_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isIDFIRST_LC_uvchr(UV ord)
CODE:
RETVAL = isIDFIRST_LC_uvchr(ord);
RETVAL
bool
+test_isIDFIRST(UV ord)
+ CODE:
+ RETVAL = isIDFIRST(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isIDFIRST_A(UV ord)
CODE:
RETVAL = isIDFIRST_A(ord);
RETVAL
bool
+test_isIDCONT_uvchr(UV ord)
+ CODE:
+ RETVAL = isIDCONT_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isIDCONT_LC_uvchr(UV ord)
CODE:
RETVAL = isIDCONT_LC_uvchr(ord);
RETVAL
bool
+test_isIDCONT(UV ord)
+ CODE:
+ RETVAL = isIDCONT(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isIDCONT_A(UV ord)
CODE:
RETVAL = isIDCONT_A(ord);
RETVAL
bool
+test_isSPACE_uvchr(UV ord)
+ CODE:
+ RETVAL = isSPACE_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isSPACE_LC_uvchr(UV ord)
CODE:
RETVAL = isSPACE_LC_uvchr(ord);
RETVAL
bool
+test_isSPACE(UV ord)
+ CODE:
+ RETVAL = isSPACE(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isSPACE_A(UV ord)
CODE:
RETVAL = isSPACE_A(ord);
RETVAL
bool
+test_isASCII_uvchr(UV ord)
+ CODE:
+ RETVAL = isASCII_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isASCII_LC_uvchr(UV ord)
CODE:
RETVAL = isASCII_LC_uvchr(ord);
RETVAL
bool
+test_isASCII(UV ord)
+ CODE:
+ RETVAL = isASCII(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isASCII_A(UV ord)
CODE:
RETVAL = isASCII_A(ord);
RETVAL
bool
+test_isCNTRL_uvchr(UV ord)
+ CODE:
+ RETVAL = isCNTRL_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isCNTRL_LC_uvchr(UV ord)
CODE:
RETVAL = isCNTRL_LC_uvchr(ord);
RETVAL
bool
+test_isCNTRL(UV ord)
+ CODE:
+ RETVAL = isCNTRL(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isCNTRL_A(UV ord)
CODE:
RETVAL = isCNTRL_A(ord);
RETVAL
bool
+test_isPRINT_uvchr(UV ord)
+ CODE:
+ RETVAL = isPRINT_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isPRINT_LC_uvchr(UV ord)
CODE:
RETVAL = isPRINT_LC_uvchr(ord);
RETVAL
bool
+test_isPRINT(UV ord)
+ CODE:
+ RETVAL = isPRINT(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isPRINT_A(UV ord)
CODE:
RETVAL = isPRINT_A(ord);
RETVAL
bool
+test_isGRAPH_uvchr(UV ord)
+ CODE:
+ RETVAL = isGRAPH_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isGRAPH_LC_uvchr(UV ord)
CODE:
RETVAL = isGRAPH_LC_uvchr(ord);
RETVAL
bool
+test_isGRAPH(UV ord)
+ CODE:
+ RETVAL = isGRAPH(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isGRAPH_A(UV ord)
CODE:
RETVAL = isGRAPH_A(ord);
RETVAL
bool
+test_isPUNCT_uvchr(UV ord)
+ CODE:
+ RETVAL = isPUNCT_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isPUNCT_LC_uvchr(UV ord)
CODE:
RETVAL = isPUNCT_LC_uvchr(ord);
RETVAL
bool
+test_isPUNCT(UV ord)
+ CODE:
+ RETVAL = isPUNCT(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isPUNCT_A(UV ord)
CODE:
RETVAL = isPUNCT_A(ord);
RETVAL
bool
+test_isXDIGIT_uvchr(UV ord)
+ CODE:
+ RETVAL = isXDIGIT_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isXDIGIT_LC_uvchr(UV ord)
CODE:
RETVAL = isXDIGIT_LC_uvchr(ord);
RETVAL
bool
+test_isXDIGIT(UV ord)
+ CODE:
+ RETVAL = isXDIGIT(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isXDIGIT_A(UV ord)
CODE:
RETVAL = isXDIGIT_A(ord);
RETVAL
bool
+test_isPSXSPC_uvchr(UV ord)
+ CODE:
+ RETVAL = isPSXSPC_uvchr(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isPSXSPC_LC_uvchr(UV ord)
CODE:
RETVAL = isPSXSPC_LC_uvchr(ord);
RETVAL
bool
+test_isPSXSPC(UV ord)
+ CODE:
+ RETVAL = isPSXSPC(ord);
+ OUTPUT:
+ RETVAL
+
+bool
test_isPSXSPC_A(UV ord)
CODE:
RETVAL = isPSXSPC_A(ord);
OUTPUT:
RETVAL
+STRLEN
+test_isUTF8_CHAR(char *s, STRLEN len)
+ CODE:
+ RETVAL = isUTF8_CHAR((U8 *) s, (U8 *) s + len);
+ OUTPUT:
+ RETVAL
+
+STRLEN
+test_isUTF8_CHAR_flags(char *s, STRLEN len, U32 flags)
+ CODE:
+ RETVAL = isUTF8_CHAR_flags((U8 *) s, (U8 *) s + len, flags);
+ OUTPUT:
+ RETVAL
+
+STRLEN
+test_isSTRICT_UTF8_CHAR(char *s, STRLEN len)
+ CODE:
+ RETVAL = isSTRICT_UTF8_CHAR((U8 *) s, (U8 *) s + len);
+ OUTPUT:
+ RETVAL
+
+STRLEN
+test_isC9_STRICT_UTF8_CHAR(char *s, STRLEN len)
+ CODE:
+ RETVAL = isC9_STRICT_UTF8_CHAR((U8 *) s, (U8 *) s + len);
+ OUTPUT:
+ RETVAL
+
+IV
+test_is_utf8_valid_partial_char_flags(char *s, STRLEN len, U32 flags)
+ CODE:
+ /* RETVAL should be bool (here and in tests below), but making it IV
+ * allows us to test it returning 0 or 1 */
+ RETVAL = is_utf8_valid_partial_char_flags((U8 *) s, (U8 *) s + len, flags);
+ OUTPUT:
+ RETVAL
+
+IV
+test_is_utf8_string(char *s, STRLEN len)
+ CODE:
+ RETVAL = is_utf8_string((U8 *) s, len);
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_utf8_string_loc(char *s, STRLEN len)
+ PREINIT:
+ AV *av;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_utf8_string_loc((U8 *) s, len, &ep)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_utf8_string_loclen(char *s, STRLEN len)
+ PREINIT:
+ AV *av;
+ STRLEN ret_len;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_utf8_string_loclen((U8 *) s, len, &ep, &ret_len)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ av_push(av, newSVuv(ret_len));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+IV
+test_is_utf8_string_flags(char *s, STRLEN len, U32 flags)
+ CODE:
+ RETVAL = is_utf8_string_flags((U8 *) s, len, flags);
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_utf8_string_loc_flags(char *s, STRLEN len, U32 flags)
+ PREINIT:
+ AV *av;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_utf8_string_loc_flags((U8 *) s, len, &ep, flags)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_utf8_string_loclen_flags(char *s, STRLEN len, U32 flags)
+ PREINIT:
+ AV *av;
+ STRLEN ret_len;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_utf8_string_loclen_flags((U8 *) s, len, &ep, &ret_len, flags)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ av_push(av, newSVuv(ret_len));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+IV
+test_is_strict_utf8_string(char *s, STRLEN len)
+ CODE:
+ RETVAL = is_strict_utf8_string((U8 *) s, len);
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_strict_utf8_string_loc(char *s, STRLEN len)
+ PREINIT:
+ AV *av;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_strict_utf8_string_loc((U8 *) s, len, &ep)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_strict_utf8_string_loclen(char *s, STRLEN len)
+ PREINIT:
+ AV *av;
+ STRLEN ret_len;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_strict_utf8_string_loclen((U8 *) s, len, &ep, &ret_len)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ av_push(av, newSVuv(ret_len));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+IV
+test_is_c9strict_utf8_string(char *s, STRLEN len)
+ CODE:
+ RETVAL = is_c9strict_utf8_string((U8 *) s, len);
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_c9strict_utf8_string_loc(char *s, STRLEN len)
+ PREINIT:
+ AV *av;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_c9strict_utf8_string_loc((U8 *) s, len, &ep)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_c9strict_utf8_string_loclen(char *s, STRLEN len)
+ PREINIT:
+ AV *av;
+ STRLEN ret_len;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_c9strict_utf8_string_loclen((U8 *) s, len, &ep, &ret_len)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ av_push(av, newSVuv(ret_len));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+IV
+test_is_utf8_fixed_width_buf_flags(char *s, STRLEN len, U32 flags)
+ CODE:
+ RETVAL = is_utf8_fixed_width_buf_flags((U8 *) s, len, flags);
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_utf8_fixed_width_buf_loc_flags(char *s, STRLEN len, U32 flags)
+ PREINIT:
+ AV *av;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_utf8_fixed_width_buf_loc_flags((U8 *) s, len, &ep, flags)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+AV *
+test_is_utf8_fixed_width_buf_loclen_flags(char *s, STRLEN len, U32 flags)
+ PREINIT:
+ AV *av;
+ STRLEN ret_len;
+ const U8 * ep;
+ CODE:
+ av = newAV();
+ av_push(av, newSViv(is_utf8_fixed_width_buf_loclen_flags((U8 *) s, len, &ep, &ret_len, flags)));
+ av_push(av, newSViv(ep - (U8 *) s));
+ av_push(av, newSVuv(ret_len));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+IV
+test_utf8_hop_safe(SV *s_sv, STRLEN s_off, IV off)
+ PREINIT:
+ STRLEN len;
+ U8 *p;
+ U8 *r;
+ CODE:
+ p = (U8 *)SvPV(s_sv, len);
+ r = utf8_hop_safe(p + s_off, off, p, p + len);
+ RETVAL = r - p;
+ OUTPUT:
+ RETVAL
+
UV
test_toLOWER(UV ord)
CODE:
RETVAL
AV *
+test_toLOWER_uvchr(UV ord)
+ PREINIT:
+ U8 s[UTF8_MAXBYTES_CASE + 1];
+ STRLEN len;
+ AV *av;
+ SV *utf8;
+ CODE:
+ av = newAV();
+ av_push(av, newSVuv(toLOWER_uvchr(ord, s, &len)));
+
+ utf8 = newSVpvn((char *) s, len);
+ SvUTF8_on(utf8);
+ av_push(av, utf8);
+
+ av_push(av, newSVuv(len));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+AV *
test_toLOWER_utf8(SV * p)
PREINIT:
U8 *input;
RETVAL
AV *
+test_toFOLD_uvchr(UV ord)
+ PREINIT:
+ U8 s[UTF8_MAXBYTES_CASE + 1];
+ STRLEN len;
+ AV *av;
+ SV *utf8;
+ CODE:
+ av = newAV();
+ av_push(av, newSVuv(toFOLD_uvchr(ord, s, &len)));
+
+ utf8 = newSVpvn((char *) s, len);
+ SvUTF8_on(utf8);
+ av_push(av, utf8);
+
+ av_push(av, newSVuv(len));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+AV *
test_toFOLD_utf8(SV * p)
PREINIT:
U8 *input;
RETVAL
AV *
+test_toUPPER_uvchr(UV ord)
+ PREINIT:
+ U8 s[UTF8_MAXBYTES_CASE + 1];
+ STRLEN len;
+ AV *av;
+ SV *utf8;
+ CODE:
+ av = newAV();
+ av_push(av, newSVuv(toUPPER_uvchr(ord, s, &len)));
+
+ utf8 = newSVpvn((char *) s, len);
+ SvUTF8_on(utf8);
+ av_push(av, utf8);
+
+ av_push(av, newSVuv(len));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+AV *
test_toUPPER_utf8(SV * p)
PREINIT:
U8 *input;
RETVAL
AV *
+test_toTITLE_uvchr(UV ord)
+ PREINIT:
+ U8 s[UTF8_MAXBYTES_CASE + 1];
+ STRLEN len;
+ AV *av;
+ SV *utf8;
+ CODE:
+ av = newAV();
+ av_push(av, newSVuv(toTITLE_uvchr(ord, s, &len)));
+
+ utf8 = newSVpvn((char *) s, len);
+ SvUTF8_on(utf8);
+ av_push(av, utf8);
+
+ av_push(av, newSVuv(len));
+ RETVAL = av;
+ OUTPUT:
+ RETVAL
+
+AV *
test_toTITLE_utf8(SV * p)
PREINIT:
U8 *input;
https://perl5.git.perl.org / perl5.git / blobdiff