From 7d39b50bff3325167beaea1283e83431b5be4c55 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 1 Jul 2021 13:21:01 -0600 Subject: [PATCH] APItest.xs: White space only Remove tabs, trailing white space --- ext/XS-APItest/APItest.xs | 3056 ++++++++++++++++++------------------- 1 file changed, 1528 insertions(+), 1528 deletions(-) diff --git a/ext/XS-APItest/APItest.xs b/ext/XS-APItest/APItest.xs index c6561f8b44de..1940a9077c2c 100644 --- a/ext/XS-APItest/APItest.xs +++ b/ext/XS-APItest/APItest.xs @@ -78,7 +78,7 @@ cat_utf8a2n(SV* sv, const char * const ascii_utf8, STRLEN len) } char_end = uvchr_to_utf8(native_utf8, code_point); - sv_catpvn(sv, (char *) native_utf8, char_end - native_utf8); + sv_catpvn(sv, (char *) native_utf8, char_end - native_utf8); } } @@ -187,7 +187,7 @@ test_freeent(freeent_function *f) { /* 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 */ if (!PL_body_roots[HE_SVSLOT]) - croak("PL_he_root is 0"); + croak("PL_he_root is 0"); victim = (HE*) PL_body_roots[HE_SVSLOT]; PL_body_roots[HE_SVSLOT] = HeNEXT(victim); #endif @@ -209,7 +209,7 @@ test_freeent(freeent_function *f) { i = 0; do { - mXPUSHu(results[i]); + mXPUSHu(results[i]); } while (++i < (int)(sizeof(results)/sizeof(results[0]))); /* Goodbye to our extra reference. */ @@ -226,41 +226,41 @@ bitflip_key(pTHX_ IV action, SV *field) { SV *keysv; PERL_UNUSED_ARG(action); if (mg && (keysv = mg->mg_obj)) { - STRLEN len; - const char *p = SvPV(keysv, len); + STRLEN len; + const char *p = SvPV(keysv, len); - if (len) { + if (len) { /* Allow for the flipped val to be longer than the original. This * is just for testing, so can afford to have some slop */ const STRLEN newlen = len * 2; - SV *newkey = newSV(newlen); - const char * const new_p_orig = SvPVX(newkey); - char *new_p = (char *) new_p_orig; + SV *newkey = newSV(newlen); + const char * const new_p_orig = SvPVX(newkey); + char *new_p = (char *) new_p_orig; - if (SvUTF8(keysv)) { - const char *const end = p + len; - while (p < end) { - STRLEN curlen; - UV chr = utf8_to_uvchr_buf((U8 *)p, (U8 *) end, &curlen); + if (SvUTF8(keysv)) { + const char *const end = p + len; + while (p < end) { + STRLEN curlen; + UV chr = utf8_to_uvchr_buf((U8 *)p, (U8 *) end, &curlen); /* Make sure don't exceed bounds */ assert(new_p - new_p_orig + curlen < newlen); - new_p = (char *)uvchr_to_utf8((U8 *)new_p, chr ^ FLIP_BIT); - p += curlen; - } - SvUTF8_on(newkey); - } else { - while (len--) - *new_p++ = *p++ ^ FLIP_BIT; - } - *new_p = '\0'; - SvCUR_set(newkey, new_p - new_p_orig); - SvPOK_on(newkey); - - mg->mg_obj = newkey; - } + new_p = (char *)uvchr_to_utf8((U8 *)new_p, chr ^ FLIP_BIT); + p += curlen; + } + SvUTF8_on(newkey); + } else { + while (len--) + *new_p++ = *p++ ^ FLIP_BIT; + } + *new_p = '\0'; + SvCUR_set(newkey, new_p - new_p_orig); + SvPOK_on(newkey); + + mg->mg_obj = newkey; + } } return 0; } @@ -271,81 +271,81 @@ rot13_key(pTHX_ IV action, SV *field) { SV *keysv; PERL_UNUSED_ARG(action); if (mg && (keysv = mg->mg_obj)) { - STRLEN len; - const char *p = SvPV(keysv, len); - - if (len) { - SV *newkey = newSV(len); - char *new_p = SvPVX(newkey); - - /* There's a deliberate fencepost error here to loop len + 1 times - to copy the trailing \0 */ - do { - char new_c = *p++; - /* Try doing this cleanly and clearly in EBCDIC another way: */ - switch (new_c) { - case 'A': new_c = 'N'; break; - case 'B': new_c = 'O'; break; - case 'C': new_c = 'P'; break; - case 'D': new_c = 'Q'; break; - case 'E': new_c = 'R'; break; - case 'F': new_c = 'S'; break; - case 'G': new_c = 'T'; break; - case 'H': new_c = 'U'; break; - case 'I': new_c = 'V'; break; - case 'J': new_c = 'W'; break; - case 'K': new_c = 'X'; break; - case 'L': new_c = 'Y'; break; - case 'M': new_c = 'Z'; break; - case 'N': new_c = 'A'; break; - case 'O': new_c = 'B'; break; - case 'P': new_c = 'C'; break; - case 'Q': new_c = 'D'; break; - case 'R': new_c = 'E'; break; - case 'S': new_c = 'F'; break; - case 'T': new_c = 'G'; break; - case 'U': new_c = 'H'; break; - case 'V': new_c = 'I'; break; - case 'W': new_c = 'J'; break; - case 'X': new_c = 'K'; break; - case 'Y': new_c = 'L'; break; - case 'Z': new_c = 'M'; break; - case 'a': new_c = 'n'; break; - case 'b': new_c = 'o'; break; - case 'c': new_c = 'p'; break; - case 'd': new_c = 'q'; break; - case 'e': new_c = 'r'; break; - case 'f': new_c = 's'; break; - case 'g': new_c = 't'; break; - case 'h': new_c = 'u'; break; - case 'i': new_c = 'v'; break; - case 'j': new_c = 'w'; break; - case 'k': new_c = 'x'; break; - case 'l': new_c = 'y'; break; - case 'm': new_c = 'z'; break; - case 'n': new_c = 'a'; break; - case 'o': new_c = 'b'; break; - case 'p': new_c = 'c'; break; - case 'q': new_c = 'd'; break; - case 'r': new_c = 'e'; break; - case 's': new_c = 'f'; break; - case 't': new_c = 'g'; break; - case 'u': new_c = 'h'; break; - case 'v': new_c = 'i'; break; - case 'w': new_c = 'j'; break; - case 'x': new_c = 'k'; break; - case 'y': new_c = 'l'; break; - case 'z': new_c = 'm'; break; - } - *new_p++ = new_c; - } while (len--); - SvCUR_set(newkey, SvCUR(keysv)); - SvPOK_on(newkey); - if (SvUTF8(keysv)) - SvUTF8_on(newkey); - - mg->mg_obj = newkey; - } + STRLEN len; + const char *p = SvPV(keysv, len); + + if (len) { + SV *newkey = newSV(len); + char *new_p = SvPVX(newkey); + + /* There's a deliberate fencepost error here to loop len + 1 times + to copy the trailing \0 */ + do { + char new_c = *p++; + /* Try doing this cleanly and clearly in EBCDIC another way: */ + switch (new_c) { + case 'A': new_c = 'N'; break; + case 'B': new_c = 'O'; break; + case 'C': new_c = 'P'; break; + case 'D': new_c = 'Q'; break; + case 'E': new_c = 'R'; break; + case 'F': new_c = 'S'; break; + case 'G': new_c = 'T'; break; + case 'H': new_c = 'U'; break; + case 'I': new_c = 'V'; break; + case 'J': new_c = 'W'; break; + case 'K': new_c = 'X'; break; + case 'L': new_c = 'Y'; break; + case 'M': new_c = 'Z'; break; + case 'N': new_c = 'A'; break; + case 'O': new_c = 'B'; break; + case 'P': new_c = 'C'; break; + case 'Q': new_c = 'D'; break; + case 'R': new_c = 'E'; break; + case 'S': new_c = 'F'; break; + case 'T': new_c = 'G'; break; + case 'U': new_c = 'H'; break; + case 'V': new_c = 'I'; break; + case 'W': new_c = 'J'; break; + case 'X': new_c = 'K'; break; + case 'Y': new_c = 'L'; break; + case 'Z': new_c = 'M'; break; + case 'a': new_c = 'n'; break; + case 'b': new_c = 'o'; break; + case 'c': new_c = 'p'; break; + case 'd': new_c = 'q'; break; + case 'e': new_c = 'r'; break; + case 'f': new_c = 's'; break; + case 'g': new_c = 't'; break; + case 'h': new_c = 'u'; break; + case 'i': new_c = 'v'; break; + case 'j': new_c = 'w'; break; + case 'k': new_c = 'x'; break; + case 'l': new_c = 'y'; break; + case 'm': new_c = 'z'; break; + case 'n': new_c = 'a'; break; + case 'o': new_c = 'b'; break; + case 'p': new_c = 'c'; break; + case 'q': new_c = 'd'; break; + case 'r': new_c = 'e'; break; + case 's': new_c = 'f'; break; + case 't': new_c = 'g'; break; + case 'u': new_c = 'h'; break; + case 'v': new_c = 'i'; break; + case 'w': new_c = 'j'; break; + case 'x': new_c = 'k'; break; + case 'y': new_c = 'l'; break; + case 'z': new_c = 'm'; break; + } + *new_p++ = new_c; + } while (len--); + SvCUR_set(newkey, SvCUR(keysv)); + SvPOK_on(newkey); + if (SvUTF8(keysv)) + SvUTF8_on(newkey); + + mg->mg_obj = newkey; + } } return 0; } @@ -404,7 +404,7 @@ blockhook_test_start(pTHX_ int full) { dMY_CXT; AV *av; - + if (MY_CXT.bhk_record) { av = newAV(); av_push(av, newSVpvs("start")); @@ -455,17 +455,17 @@ my_peep (pTHX_ OP *o) dMY_CXT; if (!o) - return; + return; MY_CXT.orig_peep(aTHX_ o); if (!MY_CXT.peep_recording) - return; + return; for (; o; o = o->op_next) { - if (o->op_type == OP_CONST && cSVOPx_sv(o) && SvPOK(cSVOPx_sv(o))) { - av_push(MY_CXT.peep_recorder, newSVsv(cSVOPx_sv(o))); - } + if (o->op_type == OP_CONST && cSVOPx_sv(o) && SvPOK(cSVOPx_sv(o))) { + av_push(MY_CXT.peep_recorder, newSVsv(cSVOPx_sv(o))); + } } } @@ -476,22 +476,22 @@ my_rpeep (pTHX_ OP *first) OP *o, *t; if (!first) - return; + return; MY_CXT.orig_rpeep(aTHX_ first); if (!MY_CXT.peep_recording) - return; + return; for (o = first, t = first; o; o = o->op_next, t = t->op_next) { - if (o->op_type == OP_CONST && cSVOPx_sv(o) && SvPOK(cSVOPx_sv(o))) { - av_push(MY_CXT.rpeep_recorder, newSVsv(cSVOPx_sv(o))); - } - o = o->op_next; - if (!o || o == t) break; - if (o->op_type == OP_CONST && cSVOPx_sv(o) && SvPOK(cSVOPx_sv(o))) { - av_push(MY_CXT.rpeep_recorder, newSVsv(cSVOPx_sv(o))); - } + if (o->op_type == OP_CONST && cSVOPx_sv(o) && SvPOK(cSVOPx_sv(o))) { + av_push(MY_CXT.rpeep_recorder, newSVsv(cSVOPx_sv(o))); + } + o = o->op_next; + if (!o || o == t) break; + if (o->op_type == OP_CONST && cSVOPx_sv(o) && SvPOK(cSVOPx_sv(o))) { + av_push(MY_CXT.rpeep_recorder, newSVsv(cSVOPx_sv(o))); + } } } @@ -510,9 +510,9 @@ THX_ck_entersub_args_scalars(pTHX_ OP *entersubop, GV *namegv, SV *ckobj) PERL_UNUSED_ARG(namegv); PERL_UNUSED_ARG(ckobj); if (!OpHAS_SIBLING(aop)) - aop = cUNOPx(aop)->op_first; + aop = cUNOPx(aop)->op_first; for (aop = OpSIBLING(aop); OpHAS_SIBLING(aop); aop = OpSIBLING(aop)) { - op_contextualize(aop, G_SCALAR); + op_contextualize(aop, G_SCALAR); } return entersubop; } @@ -527,23 +527,23 @@ THX_ck_entersub_multi_sum(pTHX_ OP *entersubop, GV *namegv, SV *ckobj) PERL_UNUSED_ARG(ckobj); if (!OpHAS_SIBLING(pushop)) { parent = pushop; - pushop = cUNOPx(pushop)->op_first; + pushop = cUNOPx(pushop)->op_first; } while (1) { - OP *aop = OpSIBLING(pushop); - if (!OpHAS_SIBLING(aop)) - break; + OP *aop = OpSIBLING(pushop); + if (!OpHAS_SIBLING(aop)) + break; /* cut out first arg */ op_sibling_splice(parent, pushop, 1, NULL); - op_contextualize(aop, G_SCALAR); - if (sumop) { - sumop = newBINOP(OP_ADD, 0, sumop, aop); - } else { - sumop = aop; - } + op_contextualize(aop, G_SCALAR); + if (sumop) { + sumop = newBINOP(OP_ADD, 0, sumop, aop); + } else { + sumop = aop; + } } if (!sumop) - sumop = newSVOP(OP_CONST, 0, newSViv(0)); + sumop = newSVOP(OP_CONST, 0, newSViv(0)); op_free(entersubop); return sumop; } @@ -554,18 +554,18 @@ test_op_list_describe_part(SV *res, OP *o) { sv_catpv(res, PL_op_name[o->op_type]); switch (o->op_type) { - case OP_CONST: { - sv_catpvf(res, "(%d)", (int)SvIV(cSVOPx(o)->op_sv)); - } break; + case OP_CONST: { + sv_catpvf(res, "(%d)", (int)SvIV(cSVOPx(o)->op_sv)); + } break; } if (o->op_flags & OPf_KIDS) { - OP *k; - sv_catpvs(res, "["); - for (k = cUNOPx(o)->op_first; k; k = OpSIBLING(k)) - test_op_list_describe_part(res, k); - sv_catpvs(res, "]"); + OP *k; + sv_catpvs(res, "["); + for (k = cUNOPx(o)->op_first; k; k = OpSIBLING(k)) + test_op_list_describe_part(res, k); + sv_catpvs(res, "]"); } else { - sv_catpvs(res, "."); + sv_catpvs(res, "."); } } @@ -574,7 +574,7 @@ test_op_list_describe(OP *o) { SV *res = sv_2mortal(newSVpvs("")); if (o) - test_op_list_describe_part(res, o); + test_op_list_describe_part(res, o); return SvPVX(res); } @@ -698,7 +698,7 @@ THX_ck_entersub_postinc(pTHX_ OP *entersubop, GV *namegv, SV *ckobj) op_sibling_splice(parent, pushop, 1, NULL); op_free(entersubop); return newUNOP(OP_POSTINC, 0, - op_lvalue(op_contextualize(argop, G_SCALAR), OP_POSTINC)); + op_lvalue(op_contextualize(argop, G_SCALAR), OP_POSTINC)); } STATIC OP * @@ -713,44 +713,44 @@ THX_ck_entersub_pad_scalar(pTHX_ OP *entersubop, GV *namegv, SV *ckobj) pushop = cUNOPx(pushop)->op_first; argop = OpSIBLING(pushop); if(argop->op_type != OP_CONST || OpSIBLING(argop)->op_type != OP_CONST) - croak("bad argument expression type for pad_scalar()"); + croak("bad argument expression type for pad_scalar()"); a0 = cSVOPx_sv(argop); a1 = cSVOPx_sv(OpSIBLING(argop)); switch(SvIV(a0)) { - case 1: { - SV *namesv = sv_2mortal(newSVpvs("$")); - sv_catsv(namesv, a1); - padoff = pad_findmy_sv(namesv, 0); - } break; - case 2: { - char *namepv; - STRLEN namelen; - SV *namesv = sv_2mortal(newSVpvs("$")); - sv_catsv(namesv, a1); - namepv = SvPV(namesv, namelen); - padoff = pad_findmy_pvn(namepv, namelen, SvUTF8(namesv)); - } break; - case 3: { - char *namepv; - SV *namesv = sv_2mortal(newSVpvs("$")); - sv_catsv(namesv, a1); - namepv = SvPV_nolen(namesv); - padoff = pad_findmy_pv(namepv, SvUTF8(namesv)); - } break; - case 4: { - padoff = pad_findmy_pvs("$foo", 0); - } break; - default: croak("bad type value for pad_scalar()"); + case 1: { + SV *namesv = sv_2mortal(newSVpvs("$")); + sv_catsv(namesv, a1); + padoff = pad_findmy_sv(namesv, 0); + } break; + case 2: { + char *namepv; + STRLEN namelen; + SV *namesv = sv_2mortal(newSVpvs("$")); + sv_catsv(namesv, a1); + namepv = SvPV(namesv, namelen); + padoff = pad_findmy_pvn(namepv, namelen, SvUTF8(namesv)); + } break; + case 3: { + char *namepv; + SV *namesv = sv_2mortal(newSVpvs("$")); + sv_catsv(namesv, a1); + namepv = SvPV_nolen(namesv); + padoff = pad_findmy_pv(namepv, SvUTF8(namesv)); + } break; + case 4: { + padoff = pad_findmy_pvs("$foo", 0); + } break; + default: croak("bad type value for pad_scalar()"); } op_free(entersubop); if(padoff == NOT_IN_PAD) { - return newSVOP(OP_CONST, 0, newSVpvs("NOT_IN_PAD")); + return newSVOP(OP_CONST, 0, newSVpvs("NOT_IN_PAD")); } else if(PAD_COMPNAME_FLAGS_isOUR(padoff)) { - return newSVOP(OP_CONST, 0, newSVpvs("NOT_MY")); + return newSVOP(OP_CONST, 0, newSVpvs("NOT_MY")); } else { - OP *padop = newOP(OP_PADSV, 0); - padop->op_targ = padoff; - return padop; + OP *padop = newOP(OP_PADSV, 0); + padop->op_targ = padoff; + return padop; } } @@ -793,14 +793,14 @@ static OP *THX_parse_var(pTHX) OP *padop; if(*s != '$') croak("RPN syntax error"); while(1) { - char c = *++s; - if(!isALNUM(c)) break; + char c = *++s; + if(!isALNUM(c)) break; } if(s-start < 2) croak("RPN syntax error"); lex_read_to(s); varpos = pad_findmy_pvn(start, s-start, 0); if(varpos == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(varpos)) - croak("RPN only supports \"my\" variables"); + croak("RPN only supports \"my\" variables"); padop = newOP(OP_PADSV, 0); padop->op_targ = varpos; return padop; @@ -820,64 +820,64 @@ static OP *THX_parse_rpn_expr(pTHX) OP *parent = mkBINOP(OP_NULL, NULL, NULL); while(1) { - I32 c; - lex_read_space(0); - c = lex_peek_unichar(0); - switch(c) { - case /*(*/')': case /*{*/'}': { - OP *result = pop_rpn_item(); - if(cLISTOPx(parent)->op_first) + I32 c; + lex_read_space(0); + c = lex_peek_unichar(0); + switch(c) { + case /*(*/')': case /*{*/'}': { + OP *result = pop_rpn_item(); + if(cLISTOPx(parent)->op_first) croak("RPN expression must return a single value"); op_free(parent); - return result; - } break; - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': { - UV val = 0; - do { - lex_read_unichar(0); - val = 10*val + (c - '0'); - c = lex_peek_unichar(0); - } while(c >= '0' && c <= '9'); - push_rpn_item(newSVOP(OP_CONST, 0, newSVuv(val))); - } break; - case '$': { - push_rpn_item(parse_var()); - } break; - case '+': { - OP *b = pop_rpn_item(); - OP *a = pop_rpn_item(); - lex_read_unichar(0); - push_rpn_item(newBINOP(OP_I_ADD, 0, a, b)); - } break; - case '-': { - OP *b = pop_rpn_item(); - OP *a = pop_rpn_item(); - lex_read_unichar(0); - push_rpn_item(newBINOP(OP_I_SUBTRACT, 0, a, b)); - } break; - case '*': { - OP *b = pop_rpn_item(); - OP *a = pop_rpn_item(); - lex_read_unichar(0); - push_rpn_item(newBINOP(OP_I_MULTIPLY, 0, a, b)); - } break; - case '/': { - OP *b = pop_rpn_item(); - OP *a = pop_rpn_item(); - lex_read_unichar(0); - push_rpn_item(newBINOP(OP_I_DIVIDE, 0, a, b)); - } break; - case '%': { - OP *b = pop_rpn_item(); - OP *a = pop_rpn_item(); - lex_read_unichar(0); - push_rpn_item(newBINOP(OP_I_MODULO, 0, a, b)); - } break; - default: { - croak("RPN syntax error"); - } break; - } + return result; + } break; + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': { + UV val = 0; + do { + lex_read_unichar(0); + val = 10*val + (c - '0'); + c = lex_peek_unichar(0); + } while(c >= '0' && c <= '9'); + push_rpn_item(newSVOP(OP_CONST, 0, newSVuv(val))); + } break; + case '$': { + push_rpn_item(parse_var()); + } break; + case '+': { + OP *b = pop_rpn_item(); + OP *a = pop_rpn_item(); + lex_read_unichar(0); + push_rpn_item(newBINOP(OP_I_ADD, 0, a, b)); + } break; + case '-': { + OP *b = pop_rpn_item(); + OP *a = pop_rpn_item(); + lex_read_unichar(0); + push_rpn_item(newBINOP(OP_I_SUBTRACT, 0, a, b)); + } break; + case '*': { + OP *b = pop_rpn_item(); + OP *a = pop_rpn_item(); + lex_read_unichar(0); + push_rpn_item(newBINOP(OP_I_MULTIPLY, 0, a, b)); + } break; + case '/': { + OP *b = pop_rpn_item(); + OP *a = pop_rpn_item(); + lex_read_unichar(0); + push_rpn_item(newBINOP(OP_I_DIVIDE, 0, a, b)); + } break; + case '%': { + OP *b = pop_rpn_item(); + OP *a = pop_rpn_item(); + lex_read_unichar(0); + push_rpn_item(newBINOP(OP_I_MODULO, 0, a, b)); + } break; + default: { + croak("RPN syntax error"); + } break; + } } } @@ -887,11 +887,11 @@ static OP *THX_parse_keyword_rpn(pTHX) OP *op; lex_read_space(0); if(lex_peek_unichar(0) != '('/*)*/) - croak("RPN expression must be parenthesised"); + croak("RPN expression must be parenthesised"); lex_read_unichar(0); op = parse_rpn_expr(); if(lex_peek_unichar(0) != /*(*/')') - croak("RPN expression must be parenthesised"); + croak("RPN expression must be parenthesised"); lex_read_unichar(0); return op; } @@ -904,11 +904,11 @@ static OP *THX_parse_keyword_calcrpn(pTHX) varop = parse_var(); lex_read_space(0); if(lex_peek_unichar(0) != '{'/*}*/) - croak("RPN expression must be braced"); + croak("RPN expression must be braced"); lex_read_unichar(0); exprop = parse_rpn_expr(); if(lex_peek_unichar(0) != /*{*/'}') - croak("RPN expression must be braced"); + croak("RPN expression must be braced"); lex_read_unichar(0); return newASSIGNOP(OPf_STACKED, varop, 0, exprop); } @@ -921,14 +921,14 @@ static OP *THX_parse_keyword_stufftest(pTHX) lex_read_space(0); do_stuff = lex_peek_unichar(0) == '+'; if(do_stuff) { - lex_read_unichar(0); - lex_read_space(0); + lex_read_unichar(0); + lex_read_space(0); } c = lex_peek_unichar(0); if(c == ';') { - lex_read_unichar(0); + lex_read_unichar(0); } else if(c != /*{*/'}') { - croak("syntax error"); + croak("syntax error"); } if(do_stuff) lex_stuff_pvs(" ", 0); return newOP(OP_NULL, 0); @@ -941,7 +941,7 @@ static OP *THX_parse_keyword_swaptwostmts(pTHX) a = parse_fullstmt(0); b = parse_fullstmt(0); if(a && b) - PL_hints |= HINT_BLOCK_SCOPE; + PL_hints |= HINT_BLOCK_SCOPE; return op_append_list(OP_LINESEQ, b, a); } @@ -949,7 +949,7 @@ static OP *THX_parse_keyword_swaptwostmts(pTHX) static OP *THX_parse_keyword_looprest(pTHX) { return newWHILEOP(0, 1, NULL, newSVOP(OP_CONST, 0, &PL_sv_yes), - parse_stmtseq(0), NULL, 1); + parse_stmtseq(0), NULL, 1); } #define parse_keyword_scopelessblock() THX_parse_keyword_scopelessblock(aTHX) @@ -996,7 +996,7 @@ static OP *THX_parse_keyword_stmtsasexpr(pTHX) static OP *THX_parse_keyword_loopblock(pTHX) { return newWHILEOP(0, 1, NULL, newSVOP(OP_CONST, 0, &PL_sv_yes), - parse_block(0), NULL, 1); + parse_block(0), NULL, 1); } #define parse_keyword_blockasexpr() THX_parse_keyword_blockasexpr(aTHX) @@ -1078,47 +1078,47 @@ static OP *THX_parse_keyword_subsignature(pTHX) * OP_NEXTSTATE-separated OP_ARGCHECK and OP_ARGELEMs */ if(sigop->op_type != OP_NULL) - croak("Expected parse_subsignature() to yield an OP_NULL"); - + croak("Expected parse_subsignature() to yield an OP_NULL"); + if(!(sigop->op_flags & OPf_KIDS)) - croak("Expected parse_subsignature() to yield an OP_NULL with kids"); + croak("Expected parse_subsignature() to yield an OP_NULL with kids"); listop = cUNOPx(sigop)->op_first; if(listop->op_type != OP_LINESEQ) - croak("Expected parse_subsignature() to yield an OP_LINESEQ"); + croak("Expected parse_subsignature() to yield an OP_LINESEQ"); for(kid = cLISTOPx(listop)->op_first; kid; kid = OpSIBLING(kid)) { - switch(kid->op_type) { - case OP_NEXTSTATE: - /* Only emit the first one otherwise they get boring */ - if(seen_nextstate) - break; - seen_nextstate++; - retop = op_append_list(OP_LIST, retop, newSVOP(OP_CONST, 0, - /* newSVpvf("nextstate:%s:%d", CopFILE(cCOPx(kid)), cCOPx(kid)->cop_line))); */ - newSVpvf("nextstate:%u", (unsigned int)cCOPx(kid)->cop_line))); - break; - case OP_ARGCHECK: { + switch(kid->op_type) { + case OP_NEXTSTATE: + /* Only emit the first one otherwise they get boring */ + if(seen_nextstate) + break; + seen_nextstate++; + retop = op_append_list(OP_LIST, retop, newSVOP(OP_CONST, 0, + /* newSVpvf("nextstate:%s:%d", CopFILE(cCOPx(kid)), cCOPx(kid)->cop_line))); */ + newSVpvf("nextstate:%u", (unsigned int)cCOPx(kid)->cop_line))); + break; + case OP_ARGCHECK: { struct op_argcheck_aux *p = (struct op_argcheck_aux*)(cUNOP_AUXx(kid)->op_aux); - retop = op_append_list(OP_LIST, retop, newSVOP(OP_CONST, 0, - newSVpvf("argcheck:%" UVuf ":%" UVuf ":%c", + retop = op_append_list(OP_LIST, retop, newSVOP(OP_CONST, 0, + newSVpvf("argcheck:%" UVuf ":%" UVuf ":%c", p->params, p->opt_params, p->slurpy ? p->slurpy : '-'))); - break; - } - case OP_ARGELEM: { - PADOFFSET padix = kid->op_targ; - PADNAMELIST *names = PadlistNAMES(CvPADLIST(find_runcv(0))); - char *namepv = PadnamePV(padnamelist_fetch(names, padix)); - retop = op_append_list(OP_LIST, retop, newSVOP(OP_CONST, 0, - newSVpvf(kid->op_flags & OPf_KIDS ? "argelem:%s:d" : "argelem:%s", namepv))); - break; - } - default: - fprintf(stderr, "TODO: examine kid %p (optype=%s)\n", kid, PL_op_name[kid->op_type]); - break; - } + break; + } + case OP_ARGELEM: { + PADOFFSET padix = kid->op_targ; + PADNAMELIST *names = PadlistNAMES(CvPADLIST(find_runcv(0))); + char *namepv = PadnamePV(padnamelist_fetch(names, padix)); + retop = op_append_list(OP_LIST, retop, newSVOP(OP_CONST, 0, + newSVpvf(kid->op_flags & OPf_KIDS ? "argelem:%s:d" : "argelem:%s", namepv))); + break; + } + default: + fprintf(stderr, "TODO: examine kid %p (optype=%s)\n", kid, PL_op_name[kid->op_type]); + break; + } } op_free(sigop); @@ -1233,7 +1233,7 @@ static int THX_keyword_active(pTHX_ SV *hintkey_sv) HE *he; if(!GvHV(PL_hintgv)) return 0; he = hv_fetch_ent(GvHV(PL_hintgv), hintkey_sv, 0, - SvSHARED_HASH(hintkey_sv)); + SvSHARED_HASH(hintkey_sv)); return he && SvTRUE(HeVAL(he)); } @@ -1241,92 +1241,92 @@ static int my_keyword_plugin(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr) { if (memEQs(keyword_ptr, keyword_len, "rpn") && - keyword_active(hintkey_rpn_sv)) { - *op_ptr = parse_keyword_rpn(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_rpn_sv)) { + *op_ptr = parse_keyword_rpn(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "calcrpn") && - keyword_active(hintkey_calcrpn_sv)) { - *op_ptr = parse_keyword_calcrpn(); - return KEYWORD_PLUGIN_STMT; + keyword_active(hintkey_calcrpn_sv)) { + *op_ptr = parse_keyword_calcrpn(); + return KEYWORD_PLUGIN_STMT; } else if (memEQs(keyword_ptr, keyword_len, "stufftest") && - keyword_active(hintkey_stufftest_sv)) { - *op_ptr = parse_keyword_stufftest(); - return KEYWORD_PLUGIN_STMT; + keyword_active(hintkey_stufftest_sv)) { + *op_ptr = parse_keyword_stufftest(); + return KEYWORD_PLUGIN_STMT; } else if (memEQs(keyword_ptr, keyword_len, "swaptwostmts") && - keyword_active(hintkey_swaptwostmts_sv)) { - *op_ptr = parse_keyword_swaptwostmts(); - return KEYWORD_PLUGIN_STMT; + keyword_active(hintkey_swaptwostmts_sv)) { + *op_ptr = parse_keyword_swaptwostmts(); + return KEYWORD_PLUGIN_STMT; } else if (memEQs(keyword_ptr, keyword_len, "looprest") && - keyword_active(hintkey_looprest_sv)) { - *op_ptr = parse_keyword_looprest(); - return KEYWORD_PLUGIN_STMT; + keyword_active(hintkey_looprest_sv)) { + *op_ptr = parse_keyword_looprest(); + return KEYWORD_PLUGIN_STMT; } else if (memEQs(keyword_ptr, keyword_len, "scopelessblock") && - keyword_active(hintkey_scopelessblock_sv)) { - *op_ptr = parse_keyword_scopelessblock(); - return KEYWORD_PLUGIN_STMT; + keyword_active(hintkey_scopelessblock_sv)) { + *op_ptr = parse_keyword_scopelessblock(); + return KEYWORD_PLUGIN_STMT; } else if (memEQs(keyword_ptr, keyword_len, "stmtasexpr") && - keyword_active(hintkey_stmtasexpr_sv)) { - *op_ptr = parse_keyword_stmtasexpr(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_stmtasexpr_sv)) { + *op_ptr = parse_keyword_stmtasexpr(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "stmtsasexpr") && - keyword_active(hintkey_stmtsasexpr_sv)) { - *op_ptr = parse_keyword_stmtsasexpr(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_stmtsasexpr_sv)) { + *op_ptr = parse_keyword_stmtsasexpr(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "loopblock") && - keyword_active(hintkey_loopblock_sv)) { - *op_ptr = parse_keyword_loopblock(); - return KEYWORD_PLUGIN_STMT; + keyword_active(hintkey_loopblock_sv)) { + *op_ptr = parse_keyword_loopblock(); + return KEYWORD_PLUGIN_STMT; } else if (memEQs(keyword_ptr, keyword_len, "blockasexpr") && - keyword_active(hintkey_blockasexpr_sv)) { - *op_ptr = parse_keyword_blockasexpr(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_blockasexpr_sv)) { + *op_ptr = parse_keyword_blockasexpr(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "swaplabel") && - keyword_active(hintkey_swaplabel_sv)) { - *op_ptr = parse_keyword_swaplabel(); - return KEYWORD_PLUGIN_STMT; + keyword_active(hintkey_swaplabel_sv)) { + *op_ptr = parse_keyword_swaplabel(); + return KEYWORD_PLUGIN_STMT; } else if (memEQs(keyword_ptr, keyword_len, "labelconst") && - keyword_active(hintkey_labelconst_sv)) { - *op_ptr = parse_keyword_labelconst(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_labelconst_sv)) { + *op_ptr = parse_keyword_labelconst(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "arrayfullexpr") && - keyword_active(hintkey_arrayfullexpr_sv)) { - *op_ptr = parse_keyword_arrayfullexpr(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_arrayfullexpr_sv)) { + *op_ptr = parse_keyword_arrayfullexpr(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "arraylistexpr") && - keyword_active(hintkey_arraylistexpr_sv)) { - *op_ptr = parse_keyword_arraylistexpr(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_arraylistexpr_sv)) { + *op_ptr = parse_keyword_arraylistexpr(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "arraytermexpr") && - keyword_active(hintkey_arraytermexpr_sv)) { - *op_ptr = parse_keyword_arraytermexpr(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_arraytermexpr_sv)) { + *op_ptr = parse_keyword_arraytermexpr(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "arrayarithexpr") && - keyword_active(hintkey_arrayarithexpr_sv)) { - *op_ptr = parse_keyword_arrayarithexpr(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_arrayarithexpr_sv)) { + *op_ptr = parse_keyword_arrayarithexpr(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "arrayexprflags") && - keyword_active(hintkey_arrayexprflags_sv)) { - *op_ptr = parse_keyword_arrayexprflags(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_arrayexprflags_sv)) { + *op_ptr = parse_keyword_arrayexprflags(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "DEFSV") && - keyword_active(hintkey_DEFSV_sv)) { - *op_ptr = parse_keyword_DEFSV(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_DEFSV_sv)) { + *op_ptr = parse_keyword_DEFSV(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "with_vars") && - keyword_active(hintkey_with_vars_sv)) { - *op_ptr = parse_keyword_with_vars(); - return KEYWORD_PLUGIN_STMT; + keyword_active(hintkey_with_vars_sv)) { + *op_ptr = parse_keyword_with_vars(); + return KEYWORD_PLUGIN_STMT; } else if (memEQs(keyword_ptr, keyword_len, "join_with_space") && - keyword_active(hintkey_join_with_space_sv)) { - *op_ptr = parse_join_with_space(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_join_with_space_sv)) { + *op_ptr = parse_join_with_space(); + return KEYWORD_PLUGIN_EXPR; } else if (memEQs(keyword_ptr, keyword_len, "subsignature") && - keyword_active(hintkey_subsignature_sv)) { - *op_ptr = parse_keyword_subsignature(); - return KEYWORD_PLUGIN_EXPR; + keyword_active(hintkey_subsignature_sv)) { + *op_ptr = parse_keyword_subsignature(); + return KEYWORD_PLUGIN_EXPR; } else { assert(next_keyword_plugin != my_keyword_plugin); - return next_keyword_plugin(aTHX_ keyword_ptr, keyword_len, op_ptr); + return next_keyword_plugin(aTHX_ keyword_ptr, keyword_len, op_ptr); } } @@ -1358,8 +1358,8 @@ filter_call(pTHX_ int idx, SV *buf_sv, int maxlen) p = SvPV_force_nolen(buf_sv); end = p + SvCUR(buf_sv); while (p < end) { - if (*p == 'o') *p = 'e'; - p++; + if (*p == 'o') *p = 'e'; + p++; } return SvCUR(buf_sv); } @@ -1369,8 +1369,8 @@ myget_linear_isa(pTHX_ HV *stash, U32 level) { GV **gvp = (GV **)hv_fetchs(stash, "ISA", 0); PERL_UNUSED_ARG(level); return gvp && *gvp && GvAV(*gvp) - ? GvAV(*gvp) - : (AV *)sv_2mortal((SV *)newAV()); + ? GvAV(*gvp) + : (AV *)sv_2mortal((SV *)newAV()); } @@ -1389,9 +1389,9 @@ addissub_myck_add(pTHX_ OP *op) OP *aop, *bop; U8 flags; if (!(flag_svp && SvTRUE(*flag_svp) && (op->op_flags & OPf_KIDS) && - (aop = cBINOPx(op)->op_first) && (bop = OpSIBLING(aop)) && - !OpHAS_SIBLING(bop))) - return addissub_nxck_add(aTHX_ op); + (aop = cBINOPx(op)->op_first) && (bop = OpSIBLING(aop)) && + !OpHAS_SIBLING(bop))) + return addissub_nxck_add(aTHX_ op); flags = op->op_flags; op_sibling_splice(op, NULL, 1, NULL); /* excise aop */ op_sibling_splice(op, NULL, 1, NULL); /* excise bop */ @@ -1415,17 +1415,17 @@ my_ck_rv2cv(pTHX_ OP *o) && (ref = cSVOPx(aop)->op_sv) && SvPOK(ref) && SvCUR(ref) && *(SvEND(ref)-1) == 'o') { - SvGROW(ref, SvCUR(ref)+2); - *SvEND(ref) = '_'; - SvCUR(ref)++; /* Not _set, so we don't accidentally break non-PERL_CORE */ - *SvEND(ref) = '\0'; + SvGROW(ref, SvCUR(ref)+2); + *SvEND(ref) = '_'; + SvCUR(ref)++; /* Not _set, so we don't accidentally break non-PERL_CORE */ + *SvEND(ref) = '\0'; } return old_ck_rv2cv(aTHX_ o); } #include "const-c.inc" -MODULE = XS::APItest PACKAGE = XS::APItest +MODULE = XS::APItest PACKAGE = XS::APItest INCLUDE: const-xs.inc @@ -1436,26 +1436,26 @@ assertx(int x) CODE: /* this only needs to compile and checks that assert() can be used this way syntactically */ - (void)(assert(x), 1); - (void)(x); + (void)(assert(x), 1); + (void)(x); -MODULE = XS::APItest::utf8 PACKAGE = XS::APItest::utf8 +MODULE = XS::APItest::utf8 PACKAGE = XS::APItest::utf8 int bytes_cmp_utf8(bytes, utf8) - SV *bytes - SV *utf8 + SV *bytes + SV *utf8 PREINIT: - const U8 *b; - STRLEN blen; - const U8 *u; - STRLEN ulen; + const U8 *b; + STRLEN blen; + const U8 *u; + STRLEN ulen; CODE: - b = (const U8 *)SvPVbyte(bytes, blen); - u = (const U8 *)SvPVbyte(utf8, ulen); - RETVAL = bytes_cmp_utf8(b, blen, u, ulen); + b = (const U8 *)SvPVbyte(bytes, blen); + u = (const U8 *)SvPVbyte(utf8, ulen); + RETVAL = bytes_cmp_utf8(b, blen, u, ulen); OUTPUT: - RETVAL + RETVAL AV * test_utf8_to_bytes(bytes, len) @@ -1635,50 +1635,50 @@ test_uvchr_to_utf8_flags_msgs(uv, flags) OUTPUT: RETVAL -MODULE = XS::APItest:Overload PACKAGE = XS::APItest::Overload +MODULE = XS::APItest:Overload PACKAGE = XS::APItest::Overload void amagic_deref_call(sv, what) - SV *sv - int what + SV *sv + int what PPCODE: - /* The reference is owned by something else. */ - PUSHs(amagic_deref_call(sv, what)); + /* The reference is owned by something else. */ + PUSHs(amagic_deref_call(sv, what)); # I'd certainly like to discourage the use of this macro, given that we now # have amagic_deref_call void tryAMAGICunDEREF_var(sv, what) - SV *sv - int what + SV *sv + int what PPCODE: - { - SV **sp = &sv; - switch(what) { - case to_av_amg: - tryAMAGICunDEREF(to_av); - break; - case to_cv_amg: - tryAMAGICunDEREF(to_cv); - break; - case to_gv_amg: - tryAMAGICunDEREF(to_gv); - break; - case to_hv_amg: - tryAMAGICunDEREF(to_hv); - break; - case to_sv_amg: - tryAMAGICunDEREF(to_sv); - break; - default: - croak("Invalid value %d passed to tryAMAGICunDEREF_var", what); - } - } - /* The reference is owned by something else. */ - PUSHs(sv); - -MODULE = XS::APItest PACKAGE = XS::APItest::XSUB + { + SV **sp = &sv; + switch(what) { + case to_av_amg: + tryAMAGICunDEREF(to_av); + break; + case to_cv_amg: + tryAMAGICunDEREF(to_cv); + break; + case to_gv_amg: + tryAMAGICunDEREF(to_gv); + break; + case to_hv_amg: + tryAMAGICunDEREF(to_hv); + break; + case to_sv_amg: + tryAMAGICunDEREF(to_sv); + break; + default: + croak("Invalid value %d passed to tryAMAGICunDEREF_var", what); + } + } + /* The reference is owned by something else. */ + PUSHs(sv); + +MODULE = XS::APItest PACKAGE = XS::APItest::XSUB BOOT: newXS("XS::APItest::XSUB::XS_VERSION_undef", XS_XS__APItest__XSUB_XS_VERSION_undef, __FILE__); @@ -1752,173 +1752,173 @@ xsreturn_empty() PPCODE: XSRETURN_EMPTY; -MODULE = XS::APItest:Hash PACKAGE = XS::APItest::Hash +MODULE = XS::APItest:Hash PACKAGE = XS::APItest::Hash void rot13_hash(hash) - HV *hash - CODE: - { - struct ufuncs uf; - uf.uf_val = rot13_key; - uf.uf_set = 0; - uf.uf_index = 0; + HV *hash + CODE: + { + struct ufuncs uf; + uf.uf_val = rot13_key; + uf.uf_set = 0; + uf.uf_index = 0; - sv_magic((SV*)hash, NULL, PERL_MAGIC_uvar, (char*)&uf, sizeof(uf)); - } + sv_magic((SV*)hash, NULL, PERL_MAGIC_uvar, (char*)&uf, sizeof(uf)); + } void bitflip_hash(hash) - HV *hash - CODE: - { - struct ufuncs uf; - uf.uf_val = bitflip_key; - uf.uf_set = 0; - uf.uf_index = 0; + HV *hash + CODE: + { + struct ufuncs uf; + uf.uf_val = bitflip_key; + uf.uf_set = 0; + uf.uf_index = 0; - sv_magic((SV*)hash, NULL, PERL_MAGIC_uvar, (char*)&uf, sizeof(uf)); - } + sv_magic((SV*)hash, NULL, PERL_MAGIC_uvar, (char*)&uf, sizeof(uf)); + } #define UTF8KLEN(sv, len) (SvUTF8(sv) ? -(I32)len : (I32)len) bool exists(hash, key_sv) - PREINIT: - STRLEN len; - const char *key; - INPUT: - HV *hash - SV *key_sv - CODE: - key = SvPV(key_sv, len); - RETVAL = hv_exists(hash, key, UTF8KLEN(key_sv, len)); + PREINIT: + STRLEN len; + const char *key; + INPUT: + HV *hash + SV *key_sv + CODE: + key = SvPV(key_sv, len); + RETVAL = hv_exists(hash, key, UTF8KLEN(key_sv, len)); OUTPUT: RETVAL bool exists_ent(hash, key_sv) - PREINIT: - INPUT: - HV *hash - SV *key_sv - CODE: - RETVAL = hv_exists_ent(hash, key_sv, 0); + PREINIT: + INPUT: + HV *hash + SV *key_sv + CODE: + RETVAL = hv_exists_ent(hash, key_sv, 0); OUTPUT: RETVAL SV * delete(hash, key_sv, flags = 0) - PREINIT: - STRLEN len; - const char *key; - INPUT: - HV *hash - SV *key_sv - I32 flags; - CODE: - key = SvPV(key_sv, len); - /* It's already mortal, so need to increase reference count. */ - RETVAL - = SvREFCNT_inc(hv_delete(hash, key, UTF8KLEN(key_sv, len), flags)); + PREINIT: + STRLEN len; + const char *key; + INPUT: + HV *hash + SV *key_sv + I32 flags; + CODE: + key = SvPV(key_sv, len); + /* It's already mortal, so need to increase reference count. */ + RETVAL + = SvREFCNT_inc(hv_delete(hash, key, UTF8KLEN(key_sv, len), flags)); OUTPUT: RETVAL SV * delete_ent(hash, key_sv, flags = 0) - INPUT: - HV *hash - SV *key_sv - I32 flags; - CODE: - /* It's already mortal, so need to increase reference count. */ - RETVAL = SvREFCNT_inc(hv_delete_ent(hash, key_sv, flags, 0)); + INPUT: + HV *hash + SV *key_sv + I32 flags; + CODE: + /* It's already mortal, so need to increase reference count. */ + RETVAL = SvREFCNT_inc(hv_delete_ent(hash, key_sv, flags, 0)); OUTPUT: RETVAL SV * store_ent(hash, key, value) - PREINIT: - SV *copy; - HE *result; - INPUT: - HV *hash - SV *key - SV *value - CODE: - copy = newSV(0); - result = hv_store_ent(hash, key, copy, 0); - SvSetMagicSV(copy, value); - if (!result) { - SvREFCNT_dec(copy); - XSRETURN_EMPTY; - } - /* It's about to become mortal, so need to increase reference count. - */ - RETVAL = SvREFCNT_inc(HeVAL(result)); + PREINIT: + SV *copy; + HE *result; + INPUT: + HV *hash + SV *key + SV *value + CODE: + copy = newSV(0); + result = hv_store_ent(hash, key, copy, 0); + SvSetMagicSV(copy, value); + if (!result) { + SvREFCNT_dec(copy); + XSRETURN_EMPTY; + } + /* It's about to become mortal, so need to increase reference count. + */ + RETVAL = SvREFCNT_inc(HeVAL(result)); OUTPUT: RETVAL SV * store(hash, key_sv, value) - PREINIT: - STRLEN len; - const char *key; - SV *copy; - SV **result; - INPUT: - HV *hash - SV *key_sv - SV *value - CODE: - key = SvPV(key_sv, len); - copy = newSV(0); - result = hv_store(hash, key, UTF8KLEN(key_sv, len), copy, 0); - SvSetMagicSV(copy, value); - if (!result) { - SvREFCNT_dec(copy); - XSRETURN_EMPTY; - } - /* It's about to become mortal, so need to increase reference count. - */ - RETVAL = SvREFCNT_inc(*result); + PREINIT: + STRLEN len; + const char *key; + SV *copy; + SV **result; + INPUT: + HV *hash + SV *key_sv + SV *value + CODE: + key = SvPV(key_sv, len); + copy = newSV(0); + result = hv_store(hash, key, UTF8KLEN(key_sv, len), copy, 0); + SvSetMagicSV(copy, value); + if (!result) { + SvREFCNT_dec(copy); + XSRETURN_EMPTY; + } + /* It's about to become mortal, so need to increase reference count. + */ + RETVAL = SvREFCNT_inc(*result); OUTPUT: RETVAL SV * fetch_ent(hash, key_sv) - PREINIT: - HE *result; - INPUT: - HV *hash - SV *key_sv - CODE: - result = hv_fetch_ent(hash, key_sv, 0, 0); - if (!result) { - XSRETURN_EMPTY; - } - /* Force mg_get */ - RETVAL = newSVsv(HeVAL(result)); + PREINIT: + HE *result; + INPUT: + HV *hash + SV *key_sv + CODE: + result = hv_fetch_ent(hash, key_sv, 0, 0); + if (!result) { + XSRETURN_EMPTY; + } + /* Force mg_get */ + RETVAL = newSVsv(HeVAL(result)); OUTPUT: RETVAL SV * fetch(hash, key_sv) - PREINIT: - STRLEN len; - const char *key; - SV **result; - INPUT: - HV *hash - SV *key_sv - CODE: - key = SvPV(key_sv, len); - result = hv_fetch(hash, key, UTF8KLEN(key_sv, len), 0); - if (!result) { - XSRETURN_EMPTY; - } - /* Force mg_get */ - RETVAL = newSVsv(*result); + PREINIT: + STRLEN len; + const char *key; + SV **result; + INPUT: + HV *hash + SV *key_sv + CODE: + key = SvPV(key_sv, len); + result = hv_fetch(hash, key, UTF8KLEN(key_sv, len), 0); + if (!result) { + XSRETURN_EMPTY; + } + /* Force mg_get */ + RETVAL = newSVsv(*result); OUTPUT: RETVAL @@ -1926,59 +1926,59 @@ fetch(hash, key_sv) SV * common(params) - INPUT: - HV *params - PREINIT: - HE *result; - HV *hv = NULL; - SV *keysv = NULL; - const char *key = NULL; - STRLEN klen = 0; - int flags = 0; - int action = 0; - SV *val = NULL; - U32 hash = 0; - SV **svp; - CODE: - if ((svp = hv_fetchs(params, "hv", 0))) { - SV *const rv = *svp; - if (!SvROK(rv)) - croak("common passed a non-reference for parameter hv"); - hv = (HV *)SvRV(rv); - } - if ((svp = hv_fetchs(params, "keysv", 0))) - keysv = *svp; - if ((svp = hv_fetchs(params, "keypv", 0))) { - key = SvPV_const(*svp, klen); - if (SvUTF8(*svp)) - flags = HVhek_UTF8; - } - if ((svp = hv_fetchs(params, "action", 0))) - action = SvIV(*svp); - if ((svp = hv_fetchs(params, "val", 0))) - val = newSVsv(*svp); - if ((svp = hv_fetchs(params, "hash", 0))) - hash = SvUV(*svp); - - if (hv_fetchs(params, "hash_pv", 0)) { + INPUT: + HV *params + PREINIT: + HE *result; + HV *hv = NULL; + SV *keysv = NULL; + const char *key = NULL; + STRLEN klen = 0; + int flags = 0; + int action = 0; + SV *val = NULL; + U32 hash = 0; + SV **svp; + CODE: + if ((svp = hv_fetchs(params, "hv", 0))) { + SV *const rv = *svp; + if (!SvROK(rv)) + croak("common passed a non-reference for parameter hv"); + hv = (HV *)SvRV(rv); + } + if ((svp = hv_fetchs(params, "keysv", 0))) + keysv = *svp; + if ((svp = hv_fetchs(params, "keypv", 0))) { + key = SvPV_const(*svp, klen); + if (SvUTF8(*svp)) + flags = HVhek_UTF8; + } + if ((svp = hv_fetchs(params, "action", 0))) + action = SvIV(*svp); + if ((svp = hv_fetchs(params, "val", 0))) + val = newSVsv(*svp); + if ((svp = hv_fetchs(params, "hash", 0))) + hash = SvUV(*svp); + + if (hv_fetchs(params, "hash_pv", 0)) { assert(key); - PERL_HASH(hash, key, klen); - } - if (hv_fetchs(params, "hash_sv", 0)) { + PERL_HASH(hash, key, klen); + } + if (hv_fetchs(params, "hash_sv", 0)) { assert(keysv); { STRLEN len; const char *const p = SvPV(keysv, len); PERL_HASH(hash, p, len); } - } - - result = (HE *)hv_common(hv, keysv, key, klen, flags, action, val, hash); - if (!result) { - XSRETURN_EMPTY; - } - /* Force mg_get */ - RETVAL = newSVsv(HeVAL(result)); + } + + result = (HE *)hv_common(hv, keysv, key, klen, flags, action, val, hash); + if (!result) { + XSRETURN_EMPTY; + } + /* Force mg_get */ + RETVAL = newSVsv(HeVAL(result)); OUTPUT: RETVAL @@ -1986,60 +1986,60 @@ common(params) void test_hv_free_ent() - PPCODE: - test_freeent(&Perl_hv_free_ent); - XSRETURN(4); + PPCODE: + test_freeent(&Perl_hv_free_ent); + XSRETURN(4); void test_hv_delayfree_ent() - PPCODE: - test_freeent(&Perl_hv_delayfree_ent); - XSRETURN(4); + PPCODE: + test_freeent(&Perl_hv_delayfree_ent); + XSRETURN(4); SV * test_share_unshare_pvn(input) - PREINIT: - STRLEN len; - U32 hash; - char *pvx; - char *p; - INPUT: - SV *input - CODE: - pvx = SvPV(input, len); - PERL_HASH(hash, pvx, len); - p = sharepvn(pvx, len, hash); - RETVAL = newSVpvn(p, len); - unsharepvn(p, len, hash); - OUTPUT: - RETVAL + PREINIT: + STRLEN len; + U32 hash; + char *pvx; + char *p; + INPUT: + SV *input + CODE: + pvx = SvPV(input, len); + PERL_HASH(hash, pvx, len); + p = sharepvn(pvx, len, hash); + RETVAL = newSVpvn(p, len); + unsharepvn(p, len, hash); + OUTPUT: + RETVAL #if PERL_VERSION_GE(5,9,0) bool refcounted_he_exists(key, level=0) - SV *key - IV level - CODE: - if (level) { - croak("level must be zero, not %" IVdf, level); - } - RETVAL = (cop_hints_fetch_sv(PL_curcop, key, 0, 0) != &PL_sv_placeholder); - OUTPUT: - RETVAL + SV *key + IV level + CODE: + if (level) { + croak("level must be zero, not %" IVdf, level); + } + RETVAL = (cop_hints_fetch_sv(PL_curcop, key, 0, 0) != &PL_sv_placeholder); + OUTPUT: + RETVAL SV * refcounted_he_fetch(key, level=0) - SV *key - IV level - CODE: - if (level) { - croak("level must be zero, not %" IVdf, level); - } - RETVAL = cop_hints_fetch_sv(PL_curcop, key, 0, 0); - SvREFCNT_inc(RETVAL); - OUTPUT: - RETVAL + SV *key + IV level + CODE: + if (level) { + croak("level must be zero, not %" IVdf, level); + } + RETVAL = cop_hints_fetch_sv(PL_curcop, key, 0, 0); + SvREFCNT_inc(RETVAL); + OUTPUT: + RETVAL #endif @@ -2047,15 +2047,15 @@ void test_force_keys(HV *hv) PREINIT: HE *he; - SSize_t count = 0; + SSize_t count = 0; PPCODE: hv_iterinit(hv); he = hv_iternext(hv); while (he) { - SV *sv = HeSVKEY_force(he); - ++count; - EXTEND(SP, count); - PUSHs(sv_mortalcopy(sv)); + SV *sv = HeSVKEY_force(he); + ++count; + EXTEND(SP, count); + PUSHs(sv_mortalcopy(sv)); he = hv_iternext(hv); } @@ -2072,29 +2072,29 @@ sub CLEAR { %{$_[0]} = () } =cut -MODULE = XS::APItest:TempLv PACKAGE = XS::APItest::TempLv +MODULE = XS::APItest:TempLv PACKAGE = XS::APItest::TempLv void make_temp_mg_lv(sv) SV* sv PREINIT: - SV * const lv = newSV_type(SVt_PVLV); - STRLEN len; + SV * const lv = newSV_type(SVt_PVLV); + STRLEN len; PPCODE: SvPV(sv, len); - sv_magic(lv, NULL, PERL_MAGIC_substr, NULL, 0); - LvTYPE(lv) = 'x'; - LvTARG(lv) = SvREFCNT_inc_simple(sv); - LvTARGOFF(lv) = len == 0 ? 0 : 1; - LvTARGLEN(lv) = len < 2 ? 0 : len-2; + sv_magic(lv, NULL, PERL_MAGIC_substr, NULL, 0); + LvTYPE(lv) = 'x'; + LvTARG(lv) = SvREFCNT_inc_simple(sv); + LvTARGOFF(lv) = len == 0 ? 0 : 1; + LvTARGLEN(lv) = len < 2 ? 0 : len-2; - EXTEND(SP, 1); - ST(0) = sv_2mortal(lv); - XSRETURN(1); + EXTEND(SP, 1); + ST(0) = sv_2mortal(lv); + XSRETURN(1); -MODULE = XS::APItest::PtrTable PACKAGE = XS::APItest::PtrTable PREFIX = ptr_table_ +MODULE = XS::APItest::PtrTable PACKAGE = XS::APItest::PtrTable PREFIX = ptr_table_ void ptr_table_new(classname) @@ -2133,26 +2133,26 @@ void ptr_table_clear(table) XS::APItest::PtrTable table -MODULE = XS::APItest::AutoLoader PACKAGE = XS::APItest::AutoLoader +MODULE = XS::APItest::AutoLoader PACKAGE = XS::APItest::AutoLoader SV * AUTOLOAD() CODE: - RETVAL = newSVpvn_flags(SvPVX(cv), SvCUR(cv), SvUTF8(cv)); + RETVAL = newSVpvn_flags(SvPVX(cv), SvCUR(cv), SvUTF8(cv)); OUTPUT: - RETVAL + RETVAL SV * AUTOLOADp(...) PROTOTYPE: *$ CODE: PERL_UNUSED_ARG(items); - RETVAL = newSVpvn_flags(SvPVX(cv), SvCUR(cv), SvUTF8(cv)); + RETVAL = newSVpvn_flags(SvPVX(cv), SvCUR(cv), SvUTF8(cv)); OUTPUT: - RETVAL + RETVAL -MODULE = XS::APItest PACKAGE = XS::APItest +MODULE = XS::APItest PACKAGE = XS::APItest PROTOTYPES: DISABLE @@ -2235,7 +2235,7 @@ xop_build_optree () MY_CXT.xop_record = newAV(); kid = newSVOP(OP_CONST, 0, newSViv(42)); - + unop = (UNOP*)mkUNOP(OP_CUSTOM, kid); unop->op_ppaddr = pp_xop; unop->op_private = 0; @@ -2384,79 +2384,79 @@ print_float(val) float val CODE: printf("%5.3f\n",val); - + void print_flush() - CODE: - fflush(stdout); + CODE: + fflush(stdout); void mpushp() - PPCODE: - EXTEND(SP, 3); - mPUSHp("one", 3); - mPUSHp("two", 3); - mPUSHp("three", 5); - XSRETURN(3); + PPCODE: + EXTEND(SP, 3); + mPUSHp("one", 3); + mPUSHp("two", 3); + mPUSHp("three", 5); + XSRETURN(3); void mpushn() - PPCODE: - EXTEND(SP, 3); - mPUSHn(0.5); - mPUSHn(-0.25); - mPUSHn(0.125); - XSRETURN(3); + PPCODE: + EXTEND(SP, 3); + mPUSHn(0.5); + mPUSHn(-0.25); + mPUSHn(0.125); + XSRETURN(3); void mpushi() - PPCODE: - EXTEND(SP, 3); - mPUSHi(-1); - mPUSHi(2); - mPUSHi(-3); - XSRETURN(3); + PPCODE: + EXTEND(SP, 3); + mPUSHi(-1); + mPUSHi(2); + mPUSHi(-3); + XSRETURN(3); void mpushu() - PPCODE: - EXTEND(SP, 3); - mPUSHu(1); - mPUSHu(2); - mPUSHu(3); - XSRETURN(3); + PPCODE: + EXTEND(SP, 3); + mPUSHu(1); + mPUSHu(2); + mPUSHu(3); + XSRETURN(3); void mxpushp() - PPCODE: - mXPUSHp("one", 3); - mXPUSHp("two", 3); - mXPUSHp("three", 5); - XSRETURN(3); + PPCODE: + mXPUSHp("one", 3); + mXPUSHp("two", 3); + mXPUSHp("three", 5); + XSRETURN(3); void mxpushn() - PPCODE: - mXPUSHn(0.5); - mXPUSHn(-0.25); - mXPUSHn(0.125); - XSRETURN(3); + PPCODE: + mXPUSHn(0.5); + mXPUSHn(-0.25); + mXPUSHn(0.125); + XSRETURN(3); void mxpushi() - PPCODE: - mXPUSHi(-1); - mXPUSHi(2); - mXPUSHi(-3); - XSRETURN(3); + PPCODE: + mXPUSHi(-1); + mXPUSHi(2); + mXPUSHi(-3); + XSRETURN(3); void mxpushu() - PPCODE: - mXPUSHu(1); - mXPUSHu(2); - mXPUSHu(3); - XSRETURN(3); + PPCODE: + mXPUSHu(1); + mXPUSHu(2); + mXPUSHu(3); + XSRETURN(3); # test_EXTEND(): excerise the EXTEND() macro. @@ -2578,68 +2578,68 @@ call_sv(sv, flags, ...) SV* sv I32 flags PREINIT: - I32 i; + I32 i; PPCODE: - for (i=0; iblk_oldcop, "foo", 0); ST(5) = cop_hints_fetch_pvn(cx->blk_oldcop, "foo", 3, 0, 0); - ST(6) = cop_hints_fetch_sv(cx->blk_oldcop, + ST(6) = cop_hints_fetch_sv(cx->blk_oldcop, sv_2mortal(newSVpvs("foo")), 0, 0); hv = cop_hints_2hv(cx->blk_oldcop, 0); @@ -3040,57 +3040,57 @@ DPeek (sv) void BEGIN() CODE: - sv_inc(get_sv("XS::APItest::BEGIN_called", GV_ADD|GV_ADDMULTI)); + sv_inc(get_sv("XS::APItest::BEGIN_called", GV_ADD|GV_ADDMULTI)); void CHECK() CODE: - sv_inc(get_sv("XS::APItest::CHECK_called", GV_ADD|GV_ADDMULTI)); + sv_inc(get_sv("XS::APItest::CHECK_called", GV_ADD|GV_ADDMULTI)); void UNITCHECK() CODE: - sv_inc(get_sv("XS::APItest::UNITCHECK_called", GV_ADD|GV_ADDMULTI)); + sv_inc(get_sv("XS::APItest::UNITCHECK_called", GV_ADD|GV_ADDMULTI)); void INIT() CODE: - sv_inc(get_sv("XS::APItest::INIT_called", GV_ADD|GV_ADDMULTI)); + sv_inc(get_sv("XS::APItest::INIT_called", GV_ADD|GV_ADDMULTI)); void END() CODE: - sv_inc(get_sv("XS::APItest::END_called", GV_ADD|GV_ADDMULTI)); + sv_inc(get_sv("XS::APItest::END_called", GV_ADD|GV_ADDMULTI)); void utf16_to_utf8 (sv, ...) SV* sv - ALIAS: - utf16_to_utf8_reversed = 1 + ALIAS: + utf16_to_utf8_reversed = 1 PREINIT: STRLEN len; - U8 *source; - SV *dest; - Size_t got; - CODE: - if (ix) (void)SvPV_force_nolen(sv); - source = (U8 *)SvPVbyte(sv, len); - /* Optionally only convert part of the buffer. */ - if (items > 1) { - len = SvUV(ST(1)); - } - /* Mortalise this right now, as we'll be testing croak()s */ - dest = sv_2mortal(newSV(len * 2 + 1)); - if (ix) { - utf16_to_utf8_reversed(source, (U8 *)SvPVX(dest), len, &got); - } else { - utf16_to_utf8(source, (U8 *)SvPVX(dest), len, &got); - } - SvCUR_set(dest, got); - SvPVX(dest)[got] = '\0'; - SvPOK_on(dest); - ST(0) = dest; - XSRETURN(1); + U8 *source; + SV *dest; + Size_t got; + CODE: + if (ix) (void)SvPV_force_nolen(sv); + source = (U8 *)SvPVbyte(sv, len); + /* Optionally only convert part of the buffer. */ + if (items > 1) { + len = SvUV(ST(1)); + } + /* Mortalise this right now, as we'll be testing croak()s */ + dest = sv_2mortal(newSV(len * 2 + 1)); + if (ix) { + utf16_to_utf8_reversed(source, (U8 *)SvPVX(dest), len, &got); + } else { + utf16_to_utf8(source, (U8 *)SvPVX(dest), len, &got); + } + SvCUR_set(dest, got); + SvPVX(dest)[got] = '\0'; + SvPOK_on(dest); + ST(0) = dest; + XSRETURN(1); void my_exit(int exitcode) @@ -3099,21 +3099,21 @@ my_exit(int exitcode) U8 first_byte(sv) - SV *sv + SV *sv CODE: char *s; STRLEN len; - s = SvPVbyte(sv, len); - RETVAL = s[0]; + s = SvPVbyte(sv, len); + RETVAL = s[0]; OUTPUT: RETVAL I32 sv_count() CODE: - RETVAL = PL_sv_count; - OUTPUT: - RETVAL + RETVAL = PL_sv_count; + OUTPUT: + RETVAL void bhk_record(bool on) @@ -3126,248 +3126,248 @@ bhk_record(bool on) void test_magic_chain() PREINIT: - SV *sv; - MAGIC *callmg, *uvarmg; - CODE: - sv = sv_2mortal(newSV(0)); - if (SvTYPE(sv) >= SVt_PVMG) croak_fail(); - if (SvMAGICAL(sv)) croak_fail(); - sv_magic(sv, &PL_sv_yes, PERL_MAGIC_checkcall, (char*)&callmg, 0); - if (SvTYPE(sv) < SVt_PVMG) croak_fail(); - if (!SvMAGICAL(sv)) croak_fail(); - if (mg_find(sv, PERL_MAGIC_uvar)) croak_fail(); - callmg = mg_find(sv, PERL_MAGIC_checkcall); - if (!callmg) croak_fail(); - if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) - croak_fail(); - sv_magic(sv, &PL_sv_no, PERL_MAGIC_uvar, (char*)&uvarmg, 0); - if (SvTYPE(sv) < SVt_PVMG) croak_fail(); - if (!SvMAGICAL(sv)) croak_fail(); - if (mg_find(sv, PERL_MAGIC_checkcall) != callmg) croak_fail(); - uvarmg = mg_find(sv, PERL_MAGIC_uvar); - if (!uvarmg) croak_fail(); - if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) - croak_fail(); - if (uvarmg->mg_obj != &PL_sv_no || uvarmg->mg_ptr != (char*)&uvarmg) - croak_fail(); - mg_free_type(sv, PERL_MAGIC_vec); - if (SvTYPE(sv) < SVt_PVMG) croak_fail(); - if (!SvMAGICAL(sv)) croak_fail(); - if (mg_find(sv, PERL_MAGIC_checkcall) != callmg) croak_fail(); - if (mg_find(sv, PERL_MAGIC_uvar) != uvarmg) croak_fail(); - if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) - croak_fail(); - if (uvarmg->mg_obj != &PL_sv_no || uvarmg->mg_ptr != (char*)&uvarmg) - croak_fail(); - mg_free_type(sv, PERL_MAGIC_uvar); - if (SvTYPE(sv) < SVt_PVMG) croak_fail(); - if (!SvMAGICAL(sv)) croak_fail(); - if (mg_find(sv, PERL_MAGIC_checkcall) != callmg) croak_fail(); - if (mg_find(sv, PERL_MAGIC_uvar)) croak_fail(); - if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) - croak_fail(); - sv_magic(sv, &PL_sv_no, PERL_MAGIC_uvar, (char*)&uvarmg, 0); - if (SvTYPE(sv) < SVt_PVMG) croak_fail(); - if (!SvMAGICAL(sv)) croak_fail(); - if (mg_find(sv, PERL_MAGIC_checkcall) != callmg) croak_fail(); - uvarmg = mg_find(sv, PERL_MAGIC_uvar); - if (!uvarmg) croak_fail(); - if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) - croak_fail(); - if (uvarmg->mg_obj != &PL_sv_no || uvarmg->mg_ptr != (char*)&uvarmg) - croak_fail(); - mg_free_type(sv, PERL_MAGIC_checkcall); - if (SvTYPE(sv) < SVt_PVMG) croak_fail(); - if (!SvMAGICAL(sv)) croak_fail(); - if (mg_find(sv, PERL_MAGIC_uvar) != uvarmg) croak_fail(); - if (mg_find(sv, PERL_MAGIC_checkcall)) croak_fail(); - if (uvarmg->mg_obj != &PL_sv_no || uvarmg->mg_ptr != (char*)&uvarmg) - croak_fail(); - mg_free_type(sv, PERL_MAGIC_uvar); - if (SvMAGICAL(sv)) croak_fail(); - if (mg_find(sv, PERL_MAGIC_checkcall)) croak_fail(); - if (mg_find(sv, PERL_MAGIC_uvar)) croak_fail(); + SV *sv; + MAGIC *callmg, *uvarmg; + CODE: + sv = sv_2mortal(newSV(0)); + if (SvTYPE(sv) >= SVt_PVMG) croak_fail(); + if (SvMAGICAL(sv)) croak_fail(); + sv_magic(sv, &PL_sv_yes, PERL_MAGIC_checkcall, (char*)&callmg, 0); + if (SvTYPE(sv) < SVt_PVMG) croak_fail(); + if (!SvMAGICAL(sv)) croak_fail(); + if (mg_find(sv, PERL_MAGIC_uvar)) croak_fail(); + callmg = mg_find(sv, PERL_MAGIC_checkcall); + if (!callmg) croak_fail(); + if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) + croak_fail(); + sv_magic(sv, &PL_sv_no, PERL_MAGIC_uvar, (char*)&uvarmg, 0); + if (SvTYPE(sv) < SVt_PVMG) croak_fail(); + if (!SvMAGICAL(sv)) croak_fail(); + if (mg_find(sv, PERL_MAGIC_checkcall) != callmg) croak_fail(); + uvarmg = mg_find(sv, PERL_MAGIC_uvar); + if (!uvarmg) croak_fail(); + if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) + croak_fail(); + if (uvarmg->mg_obj != &PL_sv_no || uvarmg->mg_ptr != (char*)&uvarmg) + croak_fail(); + mg_free_type(sv, PERL_MAGIC_vec); + if (SvTYPE(sv) < SVt_PVMG) croak_fail(); + if (!SvMAGICAL(sv)) croak_fail(); + if (mg_find(sv, PERL_MAGIC_checkcall) != callmg) croak_fail(); + if (mg_find(sv, PERL_MAGIC_uvar) != uvarmg) croak_fail(); + if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) + croak_fail(); + if (uvarmg->mg_obj != &PL_sv_no || uvarmg->mg_ptr != (char*)&uvarmg) + croak_fail(); + mg_free_type(sv, PERL_MAGIC_uvar); + if (SvTYPE(sv) < SVt_PVMG) croak_fail(); + if (!SvMAGICAL(sv)) croak_fail(); + if (mg_find(sv, PERL_MAGIC_checkcall) != callmg) croak_fail(); + if (mg_find(sv, PERL_MAGIC_uvar)) croak_fail(); + if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) + croak_fail(); + sv_magic(sv, &PL_sv_no, PERL_MAGIC_uvar, (char*)&uvarmg, 0); + if (SvTYPE(sv) < SVt_PVMG) croak_fail(); + if (!SvMAGICAL(sv)) croak_fail(); + if (mg_find(sv, PERL_MAGIC_checkcall) != callmg) croak_fail(); + uvarmg = mg_find(sv, PERL_MAGIC_uvar); + if (!uvarmg) croak_fail(); + if (callmg->mg_obj != &PL_sv_yes || callmg->mg_ptr != (char*)&callmg) + croak_fail(); + if (uvarmg->mg_obj != &PL_sv_no || uvarmg->mg_ptr != (char*)&uvarmg) + croak_fail(); + mg_free_type(sv, PERL_MAGIC_checkcall); + if (SvTYPE(sv) < SVt_PVMG) croak_fail(); + if (!SvMAGICAL(sv)) croak_fail(); + if (mg_find(sv, PERL_MAGIC_uvar) != uvarmg) croak_fail(); + if (mg_find(sv, PERL_MAGIC_checkcall)) croak_fail(); + if (uvarmg->mg_obj != &PL_sv_no || uvarmg->mg_ptr != (char*)&uvarmg) + croak_fail(); + mg_free_type(sv, PERL_MAGIC_uvar); + if (SvMAGICAL(sv)) croak_fail(); + if (mg_find(sv, PERL_MAGIC_checkcall)) croak_fail(); + if (mg_find(sv, PERL_MAGIC_uvar)) croak_fail(); void test_op_contextualize() PREINIT: - OP *o; - CODE: - o = newSVOP(OP_CONST, 0, newSViv(0)); - o->op_flags &= ~OPf_WANT; - o = op_contextualize(o, G_SCALAR); - if (o->op_type != OP_CONST || - (o->op_flags & OPf_WANT) != OPf_WANT_SCALAR) - croak_fail(); - op_free(o); - o = newSVOP(OP_CONST, 0, newSViv(0)); - o->op_flags &= ~OPf_WANT; - o = op_contextualize(o, G_LIST); - if (o->op_type != OP_CONST || - (o->op_flags & OPf_WANT) != OPf_WANT_LIST) - croak_fail(); - op_free(o); - o = newSVOP(OP_CONST, 0, newSViv(0)); - o->op_flags &= ~OPf_WANT; - o = op_contextualize(o, G_VOID); - if (o->op_type != OP_NULL) croak_fail(); - op_free(o); + OP *o; + CODE: + o = newSVOP(OP_CONST, 0, newSViv(0)); + o->op_flags &= ~OPf_WANT; + o = op_contextualize(o, G_SCALAR); + if (o->op_type != OP_CONST || + (o->op_flags & OPf_WANT) != OPf_WANT_SCALAR) + croak_fail(); + op_free(o); + o = newSVOP(OP_CONST, 0, newSViv(0)); + o->op_flags &= ~OPf_WANT; + o = op_contextualize(o, G_LIST); + if (o->op_type != OP_CONST || + (o->op_flags & OPf_WANT) != OPf_WANT_LIST) + croak_fail(); + op_free(o); + o = newSVOP(OP_CONST, 0, newSViv(0)); + o->op_flags &= ~OPf_WANT; + o = op_contextualize(o, G_VOID); + if (o->op_type != OP_NULL) croak_fail(); + op_free(o); void test_rv2cv_op_cv() PROTOTYPE: PREINIT: - GV *troc_gv; - CV *troc_cv; - OP *o; - CODE: - troc_gv = gv_fetchpv("XS::APItest::test_rv2cv_op_cv", 0, SVt_PVGV); - troc_cv = get_cv("XS::APItest::test_rv2cv_op_cv", 0); - o = newCVREF(0, newGVOP(OP_GV, 0, troc_gv)); - if (rv2cv_op_cv(o, 0) != troc_cv) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV) != (CV*)troc_gv) - croak_fail(); - o->op_private |= OPpENTERSUB_AMPER; - if (rv2cv_op_cv(o, 0)) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); - o->op_private &= ~OPpENTERSUB_AMPER; - if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_MARK_EARLY) != troc_cv) croak_fail(); - if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); - op_free(o); - o = newSVOP(OP_CONST, 0, newSVpv("XS::APItest::test_rv2cv_op_cv", 0)); - o->op_private = OPpCONST_BARE; - o = newCVREF(0, o); - if (rv2cv_op_cv(o, 0) != troc_cv) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV) != (CV*)troc_gv) - croak_fail(); - o->op_private |= OPpENTERSUB_AMPER; - if (rv2cv_op_cv(o, 0)) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); - op_free(o); - o = newCVREF(0, newSVOP(OP_CONST, 0, newRV_inc((SV*)troc_cv))); - if (rv2cv_op_cv(o, 0) != troc_cv) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV) != (CV*)troc_gv) - croak_fail(); - o->op_private |= OPpENTERSUB_AMPER; - if (rv2cv_op_cv(o, 0)) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); - o->op_private &= ~OPpENTERSUB_AMPER; - if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_MARK_EARLY) != troc_cv) croak_fail(); - if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); - op_free(o); - o = newCVREF(0, newUNOP(OP_RAND, 0, newSVOP(OP_CONST, 0, newSViv(0)))); - if (rv2cv_op_cv(o, 0)) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); - o->op_private |= OPpENTERSUB_AMPER; - if (rv2cv_op_cv(o, 0)) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); - o->op_private &= ~OPpENTERSUB_AMPER; - if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_MARK_EARLY)) croak_fail(); - if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); - op_free(o); - o = newUNOP(OP_RAND, 0, newSVOP(OP_CONST, 0, newSViv(0))); - if (rv2cv_op_cv(o, 0)) croak_fail(); - if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); - op_free(o); + GV *troc_gv; + CV *troc_cv; + OP *o; + CODE: + troc_gv = gv_fetchpv("XS::APItest::test_rv2cv_op_cv", 0, SVt_PVGV); + troc_cv = get_cv("XS::APItest::test_rv2cv_op_cv", 0); + o = newCVREF(0, newGVOP(OP_GV, 0, troc_gv)); + if (rv2cv_op_cv(o, 0) != troc_cv) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV) != (CV*)troc_gv) + croak_fail(); + o->op_private |= OPpENTERSUB_AMPER; + if (rv2cv_op_cv(o, 0)) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); + o->op_private &= ~OPpENTERSUB_AMPER; + if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_MARK_EARLY) != troc_cv) croak_fail(); + if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); + op_free(o); + o = newSVOP(OP_CONST, 0, newSVpv("XS::APItest::test_rv2cv_op_cv", 0)); + o->op_private = OPpCONST_BARE; + o = newCVREF(0, o); + if (rv2cv_op_cv(o, 0) != troc_cv) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV) != (CV*)troc_gv) + croak_fail(); + o->op_private |= OPpENTERSUB_AMPER; + if (rv2cv_op_cv(o, 0)) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); + op_free(o); + o = newCVREF(0, newSVOP(OP_CONST, 0, newRV_inc((SV*)troc_cv))); + if (rv2cv_op_cv(o, 0) != troc_cv) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV) != (CV*)troc_gv) + croak_fail(); + o->op_private |= OPpENTERSUB_AMPER; + if (rv2cv_op_cv(o, 0)) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); + o->op_private &= ~OPpENTERSUB_AMPER; + if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_MARK_EARLY) != troc_cv) croak_fail(); + if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); + op_free(o); + o = newCVREF(0, newUNOP(OP_RAND, 0, newSVOP(OP_CONST, 0, newSViv(0)))); + if (rv2cv_op_cv(o, 0)) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); + o->op_private |= OPpENTERSUB_AMPER; + if (rv2cv_op_cv(o, 0)) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); + o->op_private &= ~OPpENTERSUB_AMPER; + if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_MARK_EARLY)) croak_fail(); + if (cUNOPx(o)->op_first->op_private & OPpEARLY_CV) croak_fail(); + op_free(o); + o = newUNOP(OP_RAND, 0, newSVOP(OP_CONST, 0, newSViv(0))); + if (rv2cv_op_cv(o, 0)) croak_fail(); + if (rv2cv_op_cv(o, RV2CVOPCV_RETURN_NAME_GV)) croak_fail(); + op_free(o); void test_cv_getset_call_checker() PREINIT: - CV *troc_cv, *tsh_cv; - Perl_call_checker ckfun; - SV *ckobj; - U32 ckflags; + CV *troc_cv, *tsh_cv; + Perl_call_checker ckfun; + SV *ckobj; + U32 ckflags; CODE: #define check_cc(cv, xckfun, xckobj, xckflags) \ do { \ - cv_get_call_checker((cv), &ckfun, &ckobj); \ - if (ckfun != (xckfun)) croak_fail_nep(FPTR2DPTR(void *, ckfun), xckfun); \ - if (ckobj != (xckobj)) croak_fail_nep(FPTR2DPTR(void *, ckobj), xckobj); \ - cv_get_call_checker_flags((cv), CALL_CHECKER_REQUIRE_GV, &ckfun, &ckobj, &ckflags); \ - if (ckfun != (xckfun)) croak_fail_nep(FPTR2DPTR(void *, ckfun), xckfun); \ - if (ckobj != (xckobj)) croak_fail_nep(FPTR2DPTR(void *, ckobj), xckobj); \ - if (ckflags != CALL_CHECKER_REQUIRE_GV) croak_fail_nei(ckflags, CALL_CHECKER_REQUIRE_GV); \ - cv_get_call_checker_flags((cv), 0, &ckfun, &ckobj, &ckflags); \ - if (ckfun != (xckfun)) croak_fail_nep(FPTR2DPTR(void *, ckfun), xckfun); \ - if (ckobj != (xckobj)) croak_fail_nep(FPTR2DPTR(void *, ckobj), xckobj); \ - if (ckflags != (xckflags)) croak_fail_nei(ckflags, (xckflags)); \ + cv_get_call_checker((cv), &ckfun, &ckobj); \ + if (ckfun != (xckfun)) croak_fail_nep(FPTR2DPTR(void *, ckfun), xckfun); \ + if (ckobj != (xckobj)) croak_fail_nep(FPTR2DPTR(void *, ckobj), xckobj); \ + cv_get_call_checker_flags((cv), CALL_CHECKER_REQUIRE_GV, &ckfun, &ckobj, &ckflags); \ + if (ckfun != (xckfun)) croak_fail_nep(FPTR2DPTR(void *, ckfun), xckfun); \ + if (ckobj != (xckobj)) croak_fail_nep(FPTR2DPTR(void *, ckobj), xckobj); \ + if (ckflags != CALL_CHECKER_REQUIRE_GV) croak_fail_nei(ckflags, CALL_CHECKER_REQUIRE_GV); \ + cv_get_call_checker_flags((cv), 0, &ckfun, &ckobj, &ckflags); \ + if (ckfun != (xckfun)) croak_fail_nep(FPTR2DPTR(void *, ckfun), xckfun); \ + if (ckobj != (xckobj)) croak_fail_nep(FPTR2DPTR(void *, ckobj), xckobj); \ + if (ckflags != (xckflags)) croak_fail_nei(ckflags, (xckflags)); \ } while(0) - troc_cv = get_cv("XS::APItest::test_rv2cv_op_cv", 0); - tsh_cv = get_cv("XS::APItest::test_savehints", 0); - check_cc(troc_cv, Perl_ck_entersub_args_proto_or_list, (SV*)troc_cv, 0); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); - cv_set_call_checker(tsh_cv, Perl_ck_entersub_args_proto_or_list, - &PL_sv_yes); - check_cc(troc_cv, Perl_ck_entersub_args_proto_or_list, (SV*)troc_cv, 0); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); - cv_set_call_checker(troc_cv, THX_ck_entersub_args_scalars, &PL_sv_no); - check_cc(troc_cv, THX_ck_entersub_args_scalars, &PL_sv_no, CALL_CHECKER_REQUIRE_GV); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); - cv_set_call_checker(tsh_cv, Perl_ck_entersub_args_proto_or_list, - (SV*)tsh_cv); - check_cc(troc_cv, THX_ck_entersub_args_scalars, &PL_sv_no, CALL_CHECKER_REQUIRE_GV); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); - cv_set_call_checker(troc_cv, Perl_ck_entersub_args_proto_or_list, - (SV*)troc_cv); - check_cc(troc_cv, Perl_ck_entersub_args_proto_or_list, (SV*)troc_cv, 0); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); - if (SvMAGICAL((SV*)troc_cv) || SvMAGIC((SV*)troc_cv)) croak_fail(); - if (SvMAGICAL((SV*)tsh_cv) || SvMAGIC((SV*)tsh_cv)) croak_fail(); - cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, - &PL_sv_yes, 0); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, 0); - cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, - &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); - cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, - (SV*)tsh_cv, 0); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); - if (SvMAGICAL((SV*)tsh_cv) || SvMAGIC((SV*)tsh_cv)) croak_fail(); - cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, - &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); - cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, - (SV*)tsh_cv, CALL_CHECKER_REQUIRE_GV); - check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); - if (SvMAGICAL((SV*)tsh_cv) || SvMAGIC((SV*)tsh_cv)) croak_fail(); + troc_cv = get_cv("XS::APItest::test_rv2cv_op_cv", 0); + tsh_cv = get_cv("XS::APItest::test_savehints", 0); + check_cc(troc_cv, Perl_ck_entersub_args_proto_or_list, (SV*)troc_cv, 0); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); + cv_set_call_checker(tsh_cv, Perl_ck_entersub_args_proto_or_list, + &PL_sv_yes); + check_cc(troc_cv, Perl_ck_entersub_args_proto_or_list, (SV*)troc_cv, 0); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); + cv_set_call_checker(troc_cv, THX_ck_entersub_args_scalars, &PL_sv_no); + check_cc(troc_cv, THX_ck_entersub_args_scalars, &PL_sv_no, CALL_CHECKER_REQUIRE_GV); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); + cv_set_call_checker(tsh_cv, Perl_ck_entersub_args_proto_or_list, + (SV*)tsh_cv); + check_cc(troc_cv, THX_ck_entersub_args_scalars, &PL_sv_no, CALL_CHECKER_REQUIRE_GV); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); + cv_set_call_checker(troc_cv, Perl_ck_entersub_args_proto_or_list, + (SV*)troc_cv); + check_cc(troc_cv, Perl_ck_entersub_args_proto_or_list, (SV*)troc_cv, 0); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); + if (SvMAGICAL((SV*)troc_cv) || SvMAGIC((SV*)troc_cv)) croak_fail(); + if (SvMAGICAL((SV*)tsh_cv) || SvMAGIC((SV*)tsh_cv)) croak_fail(); + cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, + &PL_sv_yes, 0); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, 0); + cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, + &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); + cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, + (SV*)tsh_cv, 0); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); + if (SvMAGICAL((SV*)tsh_cv) || SvMAGIC((SV*)tsh_cv)) croak_fail(); + cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, + &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, &PL_sv_yes, CALL_CHECKER_REQUIRE_GV); + cv_set_call_checker_flags(tsh_cv, Perl_ck_entersub_args_proto_or_list, + (SV*)tsh_cv, CALL_CHECKER_REQUIRE_GV); + check_cc(tsh_cv, Perl_ck_entersub_args_proto_or_list, (SV*)tsh_cv, 0); + if (SvMAGICAL((SV*)tsh_cv) || SvMAGIC((SV*)tsh_cv)) croak_fail(); #undef check_cc void cv_set_call_checker_lists(CV *cv) CODE: - cv_set_call_checker(cv, THX_ck_entersub_args_lists, &PL_sv_undef); + cv_set_call_checker(cv, THX_ck_entersub_args_lists, &PL_sv_undef); void cv_set_call_checker_scalars(CV *cv) CODE: - cv_set_call_checker(cv, THX_ck_entersub_args_scalars, &PL_sv_undef); + cv_set_call_checker(cv, THX_ck_entersub_args_scalars, &PL_sv_undef); void cv_set_call_checker_proto(CV *cv, SV *proto) CODE: - if (SvROK(proto)) - proto = SvRV(proto); - cv_set_call_checker(cv, Perl_ck_entersub_args_proto, proto); + if (SvROK(proto)) + proto = SvRV(proto); + cv_set_call_checker(cv, Perl_ck_entersub_args_proto, proto); void cv_set_call_checker_proto_or_list(CV *cv, SV *proto) CODE: - if (SvROK(proto)) - proto = SvRV(proto); - cv_set_call_checker(cv, Perl_ck_entersub_args_proto_or_list, proto); + if (SvROK(proto)) + proto = SvRV(proto); + cv_set_call_checker(cv, Perl_ck_entersub_args_proto_or_list, proto); void cv_set_call_checker_multi_sum(CV *cv) CODE: - cv_set_call_checker(cv, THX_ck_entersub_multi_sum, &PL_sv_undef); + cv_set_call_checker(cv, THX_ck_entersub_multi_sum, &PL_sv_undef); void test_cophh() PREINIT: - COPHH *a, *b; + COPHH *a, *b; #ifdef EBCDIC SV* key_sv; char * key_name; @@ -3375,71 +3375,71 @@ test_cophh() #endif CODE: #define check_ph(EXPR) \ - do { if((EXPR) != &PL_sv_placeholder) croak("fail"); } while(0) + do { if((EXPR) != &PL_sv_placeholder) croak("fail"); } while(0) #define check_iv(EXPR, EXPECT) \ - do { if(SvIV(EXPR) != (EXPECT)) croak("fail"); } while(0) + do { if(SvIV(EXPR) != (EXPECT)) croak("fail"); } while(0) #define msvpvs(STR) sv_2mortal(newSVpvs(STR)) #define msviv(VALUE) sv_2mortal(newSViv(VALUE)) - a = cophh_new_empty(); - check_ph(cophh_fetch_pvn(a, "foo_1", 5, 0, 0)); - check_ph(cophh_fetch_pvs(a, "foo_1", 0)); - check_ph(cophh_fetch_pv(a, "foo_1", 0, 0)); - check_ph(cophh_fetch_sv(a, msvpvs("foo_1"), 0, 0)); - a = cophh_store_pvn(a, "foo_1abc", 5, 0, msviv(111), 0); - a = cophh_store_pvs(a, "foo_2", msviv(222), 0); - a = cophh_store_pv(a, "foo_3", 0, msviv(333), 0); - a = cophh_store_sv(a, msvpvs("foo_4"), 0, msviv(444), 0); - check_iv(cophh_fetch_pvn(a, "foo_1xyz", 5, 0, 0), 111); - check_iv(cophh_fetch_pvs(a, "foo_1", 0), 111); - check_iv(cophh_fetch_pv(a, "foo_1", 0, 0), 111); - check_iv(cophh_fetch_sv(a, msvpvs("foo_1"), 0, 0), 111); - check_iv(cophh_fetch_pvs(a, "foo_2", 0), 222); - check_iv(cophh_fetch_pvs(a, "foo_3", 0), 333); - check_iv(cophh_fetch_pvs(a, "foo_4", 0), 444); - check_ph(cophh_fetch_pvs(a, "foo_5", 0)); - b = cophh_copy(a); - b = cophh_store_pvs(b, "foo_1", msviv(1111), 0); - check_iv(cophh_fetch_pvs(a, "foo_1", 0), 111); - check_iv(cophh_fetch_pvs(a, "foo_2", 0), 222); - check_iv(cophh_fetch_pvs(a, "foo_3", 0), 333); - check_iv(cophh_fetch_pvs(a, "foo_4", 0), 444); - check_ph(cophh_fetch_pvs(a, "foo_5", 0)); - check_iv(cophh_fetch_pvs(b, "foo_1", 0), 1111); - check_iv(cophh_fetch_pvs(b, "foo_2", 0), 222); - check_iv(cophh_fetch_pvs(b, "foo_3", 0), 333); - check_iv(cophh_fetch_pvs(b, "foo_4", 0), 444); - check_ph(cophh_fetch_pvs(b, "foo_5", 0)); - a = cophh_delete_pvn(a, "foo_1abc", 5, 0, 0); - a = cophh_delete_pvs(a, "foo_2", 0); - b = cophh_delete_pv(b, "foo_3", 0, 0); - b = cophh_delete_sv(b, msvpvs("foo_4"), 0, 0); - check_ph(cophh_fetch_pvs(a, "foo_1", 0)); - check_ph(cophh_fetch_pvs(a, "foo_2", 0)); - check_iv(cophh_fetch_pvs(a, "foo_3", 0), 333); - check_iv(cophh_fetch_pvs(a, "foo_4", 0), 444); - check_ph(cophh_fetch_pvs(a, "foo_5", 0)); - check_iv(cophh_fetch_pvs(b, "foo_1", 0), 1111); - check_iv(cophh_fetch_pvs(b, "foo_2", 0), 222); - check_ph(cophh_fetch_pvs(b, "foo_3", 0)); - check_ph(cophh_fetch_pvs(b, "foo_4", 0)); - check_ph(cophh_fetch_pvs(b, "foo_5", 0)); - b = cophh_delete_pvs(b, "foo_3", 0); - b = cophh_delete_pvs(b, "foo_5", 0); - check_iv(cophh_fetch_pvs(b, "foo_1", 0), 1111); - check_iv(cophh_fetch_pvs(b, "foo_2", 0), 222); - check_ph(cophh_fetch_pvs(b, "foo_3", 0)); - check_ph(cophh_fetch_pvs(b, "foo_4", 0)); - check_ph(cophh_fetch_pvs(b, "foo_5", 0)); - cophh_free(b); - check_ph(cophh_fetch_pvs(a, "foo_1", 0)); - check_ph(cophh_fetch_pvs(a, "foo_2", 0)); - check_iv(cophh_fetch_pvs(a, "foo_3", 0), 333); - check_iv(cophh_fetch_pvs(a, "foo_4", 0), 444); - check_ph(cophh_fetch_pvs(a, "foo_5", 0)); + a = cophh_new_empty(); + check_ph(cophh_fetch_pvn(a, "foo_1", 5, 0, 0)); + check_ph(cophh_fetch_pvs(a, "foo_1", 0)); + check_ph(cophh_fetch_pv(a, "foo_1", 0, 0)); + check_ph(cophh_fetch_sv(a, msvpvs("foo_1"), 0, 0)); + a = cophh_store_pvn(a, "foo_1abc", 5, 0, msviv(111), 0); + a = cophh_store_pvs(a, "foo_2", msviv(222), 0); + a = cophh_store_pv(a, "foo_3", 0, msviv(333), 0); + a = cophh_store_sv(a, msvpvs("foo_4"), 0, msviv(444), 0); + check_iv(cophh_fetch_pvn(a, "foo_1xyz", 5, 0, 0), 111); + check_iv(cophh_fetch_pvs(a, "foo_1", 0), 111); + check_iv(cophh_fetch_pv(a, "foo_1", 0, 0), 111); + check_iv(cophh_fetch_sv(a, msvpvs("foo_1"), 0, 0), 111); + check_iv(cophh_fetch_pvs(a, "foo_2", 0), 222); + check_iv(cophh_fetch_pvs(a, "foo_3", 0), 333); + check_iv(cophh_fetch_pvs(a, "foo_4", 0), 444); + check_ph(cophh_fetch_pvs(a, "foo_5", 0)); + b = cophh_copy(a); + b = cophh_store_pvs(b, "foo_1", msviv(1111), 0); + check_iv(cophh_fetch_pvs(a, "foo_1", 0), 111); + check_iv(cophh_fetch_pvs(a, "foo_2", 0), 222); + check_iv(cophh_fetch_pvs(a, "foo_3", 0), 333); + check_iv(cophh_fetch_pvs(a, "foo_4", 0), 444); + check_ph(cophh_fetch_pvs(a, "foo_5", 0)); + check_iv(cophh_fetch_pvs(b, "foo_1", 0), 1111); + check_iv(cophh_fetch_pvs(b, "foo_2", 0), 222); + check_iv(cophh_fetch_pvs(b, "foo_3", 0), 333); + check_iv(cophh_fetch_pvs(b, "foo_4", 0), 444); + check_ph(cophh_fetch_pvs(b, "foo_5", 0)); + a = cophh_delete_pvn(a, "foo_1abc", 5, 0, 0); + a = cophh_delete_pvs(a, "foo_2", 0); + b = cophh_delete_pv(b, "foo_3", 0, 0); + b = cophh_delete_sv(b, msvpvs("foo_4"), 0, 0); + check_ph(cophh_fetch_pvs(a, "foo_1", 0)); + check_ph(cophh_fetch_pvs(a, "foo_2", 0)); + check_iv(cophh_fetch_pvs(a, "foo_3", 0), 333); + check_iv(cophh_fetch_pvs(a, "foo_4", 0), 444); + check_ph(cophh_fetch_pvs(a, "foo_5", 0)); + check_iv(cophh_fetch_pvs(b, "foo_1", 0), 1111); + check_iv(cophh_fetch_pvs(b, "foo_2", 0), 222); + check_ph(cophh_fetch_pvs(b, "foo_3", 0)); + check_ph(cophh_fetch_pvs(b, "foo_4", 0)); + check_ph(cophh_fetch_pvs(b, "foo_5", 0)); + b = cophh_delete_pvs(b, "foo_3", 0); + b = cophh_delete_pvs(b, "foo_5", 0); + check_iv(cophh_fetch_pvs(b, "foo_1", 0), 1111); + check_iv(cophh_fetch_pvs(b, "foo_2", 0), 222); + check_ph(cophh_fetch_pvs(b, "foo_3", 0)); + check_ph(cophh_fetch_pvs(b, "foo_4", 0)); + check_ph(cophh_fetch_pvs(b, "foo_5", 0)); + cophh_free(b); + check_ph(cophh_fetch_pvs(a, "foo_1", 0)); + check_ph(cophh_fetch_pvs(a, "foo_2", 0)); + check_iv(cophh_fetch_pvs(a, "foo_3", 0), 333); + check_iv(cophh_fetch_pvs(a, "foo_4", 0), 444); + check_ph(cophh_fetch_pvs(a, "foo_5", 0)); a = cophh_store_pvs(a, "foo_1", msviv(11111), COPHH_KEY_UTF8); - a = cophh_store_pvs(a, "foo_\xaa", msviv(123), 0); + a = cophh_store_pvs(a, "foo_\xaa", msviv(123), 0); #ifndef EBCDIC - a = cophh_store_pvs(a, "foo_\xc2\xbb", msviv(456), COPHH_KEY_UTF8); + a = cophh_store_pvs(a, "foo_\xc2\xbb", msviv(456), COPHH_KEY_UTF8); #else /* On EBCDIC, we need to translate the UTF-8 in the ASCII test to the * equivalent UTF-EBCDIC for the code page. This is done at runtime @@ -3447,73 +3447,73 @@ test_cophh() * cophhh_store_pvs(), as we don't have literal string */ key_sv = sv_2mortal(newSVpvs("foo_")); cat_utf8a2n(key_sv, STR_WITH_LEN("\xc2\xbb")); - key_name = SvPV(key_sv, key_len); - a = cophh_store_pvn(a, key_name, key_len, 0, msviv(456), COPHH_KEY_UTF8); + key_name = SvPV(key_sv, key_len); + a = cophh_store_pvn(a, key_name, key_len, 0, msviv(456), COPHH_KEY_UTF8); #endif #ifndef EBCDIC - a = cophh_store_pvs(a, "foo_\xc3\x8c", msviv(789), COPHH_KEY_UTF8); + a = cophh_store_pvs(a, "foo_\xc3\x8c", msviv(789), COPHH_KEY_UTF8); #else sv_setpvs(key_sv, "foo_"); cat_utf8a2n(key_sv, STR_WITH_LEN("\xc3\x8c")); - key_name = SvPV(key_sv, key_len); - a = cophh_store_pvn(a, key_name, key_len, 0, msviv(789), COPHH_KEY_UTF8); + key_name = SvPV(key_sv, key_len); + a = cophh_store_pvn(a, key_name, key_len, 0, msviv(789), COPHH_KEY_UTF8); #endif #ifndef EBCDIC - a = cophh_store_pvs(a, "foo_\xd9\xa6", msviv(666), COPHH_KEY_UTF8); + a = cophh_store_pvs(a, "foo_\xd9\xa6", msviv(666), COPHH_KEY_UTF8); #else sv_setpvs(key_sv, "foo_"); cat_utf8a2n(key_sv, STR_WITH_LEN("\xd9\xa6")); - key_name = SvPV(key_sv, key_len); - a = cophh_store_pvn(a, key_name, key_len, 0, msviv(666), COPHH_KEY_UTF8); + key_name = SvPV(key_sv, key_len); + a = cophh_store_pvn(a, key_name, key_len, 0, msviv(666), COPHH_KEY_UTF8); #endif - check_iv(cophh_fetch_pvs(a, "foo_1", 0), 11111); - check_iv(cophh_fetch_pvs(a, "foo_1", COPHH_KEY_UTF8), 11111); - check_iv(cophh_fetch_pvs(a, "foo_\xaa", 0), 123); + check_iv(cophh_fetch_pvs(a, "foo_1", 0), 11111); + check_iv(cophh_fetch_pvs(a, "foo_1", COPHH_KEY_UTF8), 11111); + check_iv(cophh_fetch_pvs(a, "foo_\xaa", 0), 123); #ifndef EBCDIC - check_iv(cophh_fetch_pvs(a, "foo_\xc2\xaa", COPHH_KEY_UTF8), 123); - check_ph(cophh_fetch_pvs(a, "foo_\xc2\xaa", 0)); + check_iv(cophh_fetch_pvs(a, "foo_\xc2\xaa", COPHH_KEY_UTF8), 123); + check_ph(cophh_fetch_pvs(a, "foo_\xc2\xaa", 0)); #else sv_setpvs(key_sv, "foo_"); cat_utf8a2n(key_sv, STR_WITH_LEN("\xc2\xaa")); - key_name = SvPV(key_sv, key_len); - check_iv(cophh_fetch_pvn(a, key_name, key_len, 0, COPHH_KEY_UTF8), 123); - check_ph(cophh_fetch_pvn(a, key_name, key_len, 0, 0)); + key_name = SvPV(key_sv, key_len); + check_iv(cophh_fetch_pvn(a, key_name, key_len, 0, COPHH_KEY_UTF8), 123); + check_ph(cophh_fetch_pvn(a, key_name, key_len, 0, 0)); #endif - check_iv(cophh_fetch_pvs(a, "foo_\xbb", 0), 456); + check_iv(cophh_fetch_pvs(a, "foo_\xbb", 0), 456); #ifndef EBCDIC - check_iv(cophh_fetch_pvs(a, "foo_\xc2\xbb", COPHH_KEY_UTF8), 456); - check_ph(cophh_fetch_pvs(a, "foo_\xc2\xbb", 0)); + check_iv(cophh_fetch_pvs(a, "foo_\xc2\xbb", COPHH_KEY_UTF8), 456); + check_ph(cophh_fetch_pvs(a, "foo_\xc2\xbb", 0)); #else sv_setpvs(key_sv, "foo_"); cat_utf8a2n(key_sv, STR_WITH_LEN("\xc2\xbb")); - key_name = SvPV(key_sv, key_len); - check_iv(cophh_fetch_pvn(a, key_name, key_len, 0, COPHH_KEY_UTF8), 456); - check_ph(cophh_fetch_pvn(a, key_name, key_len, 0, 0)); + key_name = SvPV(key_sv, key_len); + check_iv(cophh_fetch_pvn(a, key_name, key_len, 0, COPHH_KEY_UTF8), 456); + check_ph(cophh_fetch_pvn(a, key_name, key_len, 0, 0)); #endif - check_iv(cophh_fetch_pvs(a, "foo_\xcc", 0), 789); + check_iv(cophh_fetch_pvs(a, "foo_\xcc", 0), 789); #ifndef EBCDIC - check_iv(cophh_fetch_pvs(a, "foo_\xc3\x8c", COPHH_KEY_UTF8), 789); - check_ph(cophh_fetch_pvs(a, "foo_\xc2\x8c", 0)); + check_iv(cophh_fetch_pvs(a, "foo_\xc3\x8c", COPHH_KEY_UTF8), 789); + check_ph(cophh_fetch_pvs(a, "foo_\xc2\x8c", 0)); #else sv_setpvs(key_sv, "foo_"); cat_utf8a2n(key_sv, STR_WITH_LEN("\xc3\x8c")); - key_name = SvPV(key_sv, key_len); - check_iv(cophh_fetch_pvn(a, key_name, key_len, 0, COPHH_KEY_UTF8), 789); - check_ph(cophh_fetch_pvn(a, key_name, key_len, 0, 0)); + key_name = SvPV(key_sv, key_len); + check_iv(cophh_fetch_pvn(a, key_name, key_len, 0, COPHH_KEY_UTF8), 789); + check_ph(cophh_fetch_pvn(a, key_name, key_len, 0, 0)); #endif #ifndef EBCDIC - check_iv(cophh_fetch_pvs(a, "foo_\xd9\xa6", COPHH_KEY_UTF8), 666); - check_ph(cophh_fetch_pvs(a, "foo_\xd9\xa6", 0)); + check_iv(cophh_fetch_pvs(a, "foo_\xd9\xa6", COPHH_KEY_UTF8), 666); + check_ph(cophh_fetch_pvs(a, "foo_\xd9\xa6", 0)); #else sv_setpvs(key_sv, "foo_"); cat_utf8a2n(key_sv, STR_WITH_LEN("\xd9\xa6")); - key_name = SvPV(key_sv, key_len); - check_iv(cophh_fetch_pvn(a, key_name, key_len, 0, COPHH_KEY_UTF8), 666); - check_ph(cophh_fetch_pvn(a, key_name, key_len, 0, 0)); + key_name = SvPV(key_sv, key_len); + check_iv(cophh_fetch_pvn(a, key_name, key_len, 0, COPHH_KEY_UTF8), 666); + check_ph(cophh_fetch_pvn(a, key_name, key_len, 0, 0)); #endif - ENTER; - SAVEFREECOPHH(a); - LEAVE; + ENTER; + SAVEFREECOPHH(a); + LEAVE; #undef check_ph #undef check_iv #undef msvpvs @@ -3544,7 +3544,7 @@ test_coplabel() HV * example_cophh_2hv() PREINIT: - COPHH *a; + COPHH *a; #ifdef EBCDIC SV* key_sv; char * key_name; @@ -3552,86 +3552,86 @@ example_cophh_2hv() #endif CODE: #define msviv(VALUE) sv_2mortal(newSViv(VALUE)) - a = cophh_new_empty(); - a = cophh_store_pvs(a, "foo_0", msviv(999), 0); - a = cophh_store_pvs(a, "foo_1", msviv(111), 0); - a = cophh_store_pvs(a, "foo_\xaa", msviv(123), 0); + a = cophh_new_empty(); + a = cophh_store_pvs(a, "foo_0", msviv(999), 0); + a = cophh_store_pvs(a, "foo_1", msviv(111), 0); + a = cophh_store_pvs(a, "foo_\xaa", msviv(123), 0); #ifndef EBCDIC - a = cophh_store_pvs(a, "foo_\xc2\xbb", msviv(456), COPHH_KEY_UTF8); + a = cophh_store_pvs(a, "foo_\xc2\xbb", msviv(456), COPHH_KEY_UTF8); #else key_sv = sv_2mortal(newSVpvs("foo_")); cat_utf8a2n(key_sv, STR_WITH_LEN("\xc2\xbb")); - key_name = SvPV(key_sv, key_len); - a = cophh_store_pvn(a, key_name, key_len, 0, msviv(456), COPHH_KEY_UTF8); + key_name = SvPV(key_sv, key_len); + a = cophh_store_pvn(a, key_name, key_len, 0, msviv(456), COPHH_KEY_UTF8); #endif #ifndef EBCDIC - a = cophh_store_pvs(a, "foo_\xc3\x8c", msviv(789), COPHH_KEY_UTF8); + a = cophh_store_pvs(a, "foo_\xc3\x8c", msviv(789), COPHH_KEY_UTF8); #else sv_setpvs(key_sv, "foo_"); cat_utf8a2n(key_sv, STR_WITH_LEN("\xc3\x8c")); - key_name = SvPV(key_sv, key_len); - a = cophh_store_pvn(a, key_name, key_len, 0, msviv(789), COPHH_KEY_UTF8); + key_name = SvPV(key_sv, key_len); + a = cophh_store_pvn(a, key_name, key_len, 0, msviv(789), COPHH_KEY_UTF8); #endif #ifndef EBCDIC - a = cophh_store_pvs(a, "foo_\xd9\xa6", msviv(666), COPHH_KEY_UTF8); + a = cophh_store_pvs(a, "foo_\xd9\xa6", msviv(666), COPHH_KEY_UTF8); #else sv_setpvs(key_sv, "foo_"); cat_utf8a2n(key_sv, STR_WITH_LEN("\xd9\xa6")); - key_name = SvPV(key_sv, key_len); - a = cophh_store_pvn(a, key_name, key_len, 0, msviv(666), COPHH_KEY_UTF8); + key_name = SvPV(key_sv, key_len); + a = cophh_store_pvn(a, key_name, key_len, 0, msviv(666), COPHH_KEY_UTF8); #endif - a = cophh_delete_pvs(a, "foo_0", 0); - a = cophh_delete_pvs(a, "foo_2", 0); - RETVAL = cophh_2hv(a, 0); - cophh_free(a); + a = cophh_delete_pvs(a, "foo_0", 0); + a = cophh_delete_pvs(a, "foo_2", 0); + RETVAL = cophh_2hv(a, 0); + cophh_free(a); #undef msviv OUTPUT: - RETVAL + RETVAL void test_savehints() PREINIT: - SV **svp, *sv; + SV **svp, *sv; CODE: #define store_hint(KEY, VALUE) \ - sv_setiv_mg(*hv_fetchs(GvHV(PL_hintgv), KEY, 1), (VALUE)) + sv_setiv_mg(*hv_fetchs(GvHV(PL_hintgv), KEY, 1), (VALUE)) #define hint_ok(KEY, EXPECT) \ - ((svp = hv_fetchs(GvHV(PL_hintgv), KEY, 0)) && \ - (sv = *svp) && SvIV(sv) == (EXPECT) && \ - (sv = cop_hints_fetch_pvs(&PL_compiling, KEY, 0)) && \ - SvIV(sv) == (EXPECT)) + ((svp = hv_fetchs(GvHV(PL_hintgv), KEY, 0)) && \ + (sv = *svp) && SvIV(sv) == (EXPECT) && \ + (sv = cop_hints_fetch_pvs(&PL_compiling, KEY, 0)) && \ + SvIV(sv) == (EXPECT)) #define check_hint(KEY, EXPECT) \ - do { if (!hint_ok(KEY, EXPECT)) croak_fail(); } while(0) - PL_hints |= HINT_LOCALIZE_HH; - ENTER; - SAVEHINTS(); - PL_hints &= HINT_INTEGER; - store_hint("t0", 123); - store_hint("t1", 456); - if (PL_hints & HINT_INTEGER) croak_fail(); - check_hint("t0", 123); check_hint("t1", 456); - ENTER; - SAVEHINTS(); - if (PL_hints & HINT_INTEGER) croak_fail(); - check_hint("t0", 123); check_hint("t1", 456); - PL_hints |= HINT_INTEGER; - store_hint("t0", 321); - if (!(PL_hints & HINT_INTEGER)) croak_fail(); - check_hint("t0", 321); check_hint("t1", 456); - LEAVE; - if (PL_hints & HINT_INTEGER) croak_fail(); - check_hint("t0", 123); check_hint("t1", 456); - ENTER; - SAVEHINTS(); - if (PL_hints & HINT_INTEGER) croak_fail(); - check_hint("t0", 123); check_hint("t1", 456); - store_hint("t1", 654); - if (PL_hints & HINT_INTEGER) croak_fail(); - check_hint("t0", 123); check_hint("t1", 654); - LEAVE; - if (PL_hints & HINT_INTEGER) croak_fail(); - check_hint("t0", 123); check_hint("t1", 456); - LEAVE; + do { if (!hint_ok(KEY, EXPECT)) croak_fail(); } while(0) + PL_hints |= HINT_LOCALIZE_HH; + ENTER; + SAVEHINTS(); + PL_hints &= HINT_INTEGER; + store_hint("t0", 123); + store_hint("t1", 456); + if (PL_hints & HINT_INTEGER) croak_fail(); + check_hint("t0", 123); check_hint("t1", 456); + ENTER; + SAVEHINTS(); + if (PL_hints & HINT_INTEGER) croak_fail(); + check_hint("t0", 123); check_hint("t1", 456); + PL_hints |= HINT_INTEGER; + store_hint("t0", 321); + if (!(PL_hints & HINT_INTEGER)) croak_fail(); + check_hint("t0", 321); check_hint("t1", 456); + LEAVE; + if (PL_hints & HINT_INTEGER) croak_fail(); + check_hint("t0", 123); check_hint("t1", 456); + ENTER; + SAVEHINTS(); + if (PL_hints & HINT_INTEGER) croak_fail(); + check_hint("t0", 123); check_hint("t1", 456); + store_hint("t1", 654); + if (PL_hints & HINT_INTEGER) croak_fail(); + check_hint("t0", 123); check_hint("t1", 654); + LEAVE; + if (PL_hints & HINT_INTEGER) croak_fail(); + check_hint("t0", 123); check_hint("t1", 456); + LEAVE; #undef store_hint #undef hint_ok #undef check_hint @@ -3639,140 +3639,140 @@ test_savehints() void test_copyhints() PREINIT: - HV *a, *b; - CODE: - PL_hints |= HINT_LOCALIZE_HH; - ENTER; - SAVEHINTS(); - sv_setiv_mg(*hv_fetchs(GvHV(PL_hintgv), "t0", 1), 123); - if (SvIV(cop_hints_fetch_pvs(&PL_compiling, "t0", 0)) != 123) - croak_fail(); - a = newHVhv(GvHV(PL_hintgv)); - sv_2mortal((SV*)a); - sv_setiv_mg(*hv_fetchs(a, "t0", 1), 456); - if (SvIV(cop_hints_fetch_pvs(&PL_compiling, "t0", 0)) != 123) - croak_fail(); - b = hv_copy_hints_hv(a); - sv_2mortal((SV*)b); - sv_setiv_mg(*hv_fetchs(b, "t0", 1), 789); - if (SvIV(cop_hints_fetch_pvs(&PL_compiling, "t0", 0)) != 789) - croak_fail(); - LEAVE; + HV *a, *b; + CODE: + PL_hints |= HINT_LOCALIZE_HH; + ENTER; + SAVEHINTS(); + sv_setiv_mg(*hv_fetchs(GvHV(PL_hintgv), "t0", 1), 123); + if (SvIV(cop_hints_fetch_pvs(&PL_compiling, "t0", 0)) != 123) + croak_fail(); + a = newHVhv(GvHV(PL_hintgv)); + sv_2mortal((SV*)a); + sv_setiv_mg(*hv_fetchs(a, "t0", 1), 456); + if (SvIV(cop_hints_fetch_pvs(&PL_compiling, "t0", 0)) != 123) + croak_fail(); + b = hv_copy_hints_hv(a); + sv_2mortal((SV*)b); + sv_setiv_mg(*hv_fetchs(b, "t0", 1), 789); + if (SvIV(cop_hints_fetch_pvs(&PL_compiling, "t0", 0)) != 789) + croak_fail(); + LEAVE; void test_op_list() PREINIT: - OP *a; + OP *a; CODE: #define iv_op(iv) newSVOP(OP_CONST, 0, newSViv(iv)) #define check_op(o, expect) \ do { \ - if (strNE(test_op_list_describe(o), (expect))) \ - croak("fail %s %s", test_op_list_describe(o), (expect)); \ + if (strNE(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, ""); - a = op_append_elem(OP_LIST, iv_op(1), a); - check_op(a, "const(1)."); - a = op_append_elem(OP_LIST, NULL, a); - check_op(a, "const(1)."); - a = op_append_elem(OP_LIST, a, iv_op(2)); - check_op(a, "list[pushmark.const(1).const(2).]"); - a = op_append_elem(OP_LIST, a, iv_op(3)); - check_op(a, "list[pushmark.const(1).const(2).const(3).]"); - a = op_append_elem(OP_LIST, a, NULL); - check_op(a, "list[pushmark.const(1).const(2).const(3).]"); - a = op_append_elem(OP_LIST, NULL, a); - check_op(a, "list[pushmark.const(1).const(2).const(3).]"); - a = op_append_elem(OP_LIST, iv_op(4), a); - check_op(a, "list[pushmark.const(4)." - "list[pushmark.const(1).const(2).const(3).]]"); - a = op_append_elem(OP_LIST, a, iv_op(5)); - check_op(a, "list[pushmark.const(4)." - "list[pushmark.const(1).const(2).const(3).]const(5).]"); - a = op_append_elem(OP_LIST, a, - op_append_elem(OP_LIST, iv_op(7), iv_op(6))); - check_op(a, "list[pushmark.const(4)." - "list[pushmark.const(1).const(2).const(3).]const(5)." - "list[pushmark.const(7).const(6).]]"); - op_free(a); - a = op_append_elem(OP_LINESEQ, iv_op(1), iv_op(2)); - check_op(a, "lineseq[const(1).const(2).]"); - a = op_append_elem(OP_LINESEQ, a, iv_op(3)); - check_op(a, "lineseq[const(1).const(2).const(3).]"); - op_free(a); - a = op_append_elem(OP_LINESEQ, - op_append_elem(OP_LIST, iv_op(1), iv_op(2)), - iv_op(3)); - check_op(a, "lineseq[list[pushmark.const(1).const(2).]const(3).]"); - op_free(a); - a = op_prepend_elem(OP_LIST, NULL, NULL); - check_op(a, ""); - a = op_prepend_elem(OP_LIST, a, iv_op(1)); - check_op(a, "const(1)."); - a = op_prepend_elem(OP_LIST, a, NULL); - check_op(a, "const(1)."); - a = op_prepend_elem(OP_LIST, iv_op(2), a); - check_op(a, "list[pushmark.const(2).const(1).]"); - a = op_prepend_elem(OP_LIST, iv_op(3), a); - check_op(a, "list[pushmark.const(3).const(2).const(1).]"); - a = op_prepend_elem(OP_LIST, NULL, a); - check_op(a, "list[pushmark.const(3).const(2).const(1).]"); - a = op_prepend_elem(OP_LIST, a, NULL); - check_op(a, "list[pushmark.const(3).const(2).const(1).]"); - a = op_prepend_elem(OP_LIST, a, iv_op(4)); - check_op(a, "list[pushmark." - "list[pushmark.const(3).const(2).const(1).]const(4).]"); - a = op_prepend_elem(OP_LIST, iv_op(5), a); - check_op(a, "list[pushmark.const(5)." - "list[pushmark.const(3).const(2).const(1).]const(4).]"); - a = op_prepend_elem(OP_LIST, - op_prepend_elem(OP_LIST, iv_op(6), iv_op(7)), a); - check_op(a, "list[pushmark.list[pushmark.const(6).const(7).]const(5)." - "list[pushmark.const(3).const(2).const(1).]const(4).]"); - op_free(a); - a = op_prepend_elem(OP_LINESEQ, iv_op(2), iv_op(1)); - check_op(a, "lineseq[const(2).const(1).]"); - a = op_prepend_elem(OP_LINESEQ, iv_op(3), a); - check_op(a, "lineseq[const(3).const(2).const(1).]"); - op_free(a); - a = op_prepend_elem(OP_LINESEQ, iv_op(3), - op_prepend_elem(OP_LIST, iv_op(2), iv_op(1))); - check_op(a, "lineseq[const(3).list[pushmark.const(2).const(1).]]"); - op_free(a); - a = op_append_list(OP_LINESEQ, NULL, NULL); - check_op(a, ""); - a = op_append_list(OP_LINESEQ, iv_op(1), a); - check_op(a, "const(1)."); - a = op_append_list(OP_LINESEQ, NULL, a); - check_op(a, "const(1)."); - a = op_append_list(OP_LINESEQ, a, iv_op(2)); - check_op(a, "lineseq[const(1).const(2).]"); - a = op_append_list(OP_LINESEQ, a, iv_op(3)); - check_op(a, "lineseq[const(1).const(2).const(3).]"); - a = op_append_list(OP_LINESEQ, iv_op(4), a); - check_op(a, "lineseq[const(4).const(1).const(2).const(3).]"); - a = op_append_list(OP_LINESEQ, a, NULL); - check_op(a, "lineseq[const(4).const(1).const(2).const(3).]"); - a = op_append_list(OP_LINESEQ, NULL, a); - check_op(a, "lineseq[const(4).const(1).const(2).const(3).]"); - a = op_append_list(OP_LINESEQ, a, - op_append_list(OP_LINESEQ, iv_op(5), iv_op(6))); - check_op(a, "lineseq[const(4).const(1).const(2).const(3)." - "const(5).const(6).]"); - op_free(a); - a = op_append_list(OP_LINESEQ, - op_append_list(OP_LINESEQ, iv_op(1), iv_op(2)), - op_append_list(OP_LIST, iv_op(3), iv_op(4))); - check_op(a, "lineseq[const(1).const(2)." - "list[pushmark.const(3).const(4).]]"); - op_free(a); - a = op_append_list(OP_LINESEQ, - op_append_list(OP_LIST, iv_op(1), iv_op(2)), - op_append_list(OP_LINESEQ, iv_op(3), iv_op(4))); - check_op(a, "lineseq[list[pushmark.const(1).const(2).]" - "const(3).const(4).]"); - op_free(a); + a = op_append_elem(OP_LIST, NULL, NULL); + check_op(a, ""); + a = op_append_elem(OP_LIST, iv_op(1), a); + check_op(a, "const(1)."); + a = op_append_elem(OP_LIST, NULL, a); + check_op(a, "const(1)."); + a = op_append_elem(OP_LIST, a, iv_op(2)); + check_op(a, "list[pushmark.const(1).const(2).]"); + a = op_append_elem(OP_LIST, a, iv_op(3)); + check_op(a, "list[pushmark.const(1).const(2).const(3).]"); + a = op_append_elem(OP_LIST, a, NULL); + check_op(a, "list[pushmark.const(1).const(2).const(3).]"); + a = op_append_elem(OP_LIST, NULL, a); + check_op(a, "list[pushmark.const(1).const(2).const(3).]"); + a = op_append_elem(OP_LIST, iv_op(4), a); + check_op(a, "list[pushmark.const(4)." + "list[pushmark.const(1).const(2).const(3).]]"); + a = op_append_elem(OP_LIST, a, iv_op(5)); + check_op(a, "list[pushmark.const(4)." + "list[pushmark.const(1).const(2).const(3).]const(5).]"); + a = op_append_elem(OP_LIST, a, + op_append_elem(OP_LIST, iv_op(7), iv_op(6))); + check_op(a, "list[pushmark.const(4)." + "list[pushmark.const(1).const(2).const(3).]const(5)." + "list[pushmark.const(7).const(6).]]"); + op_free(a); + a = op_append_elem(OP_LINESEQ, iv_op(1), iv_op(2)); + check_op(a, "lineseq[const(1).const(2).]"); + a = op_append_elem(OP_LINESEQ, a, iv_op(3)); + check_op(a, "lineseq[const(1).const(2).const(3).]"); + op_free(a); + a = op_append_elem(OP_LINESEQ, + op_append_elem(OP_LIST, iv_op(1), iv_op(2)), + iv_op(3)); + check_op(a, "lineseq[list[pushmark.const(1).const(2).]const(3).]"); + op_free(a); + a = op_prepend_elem(OP_LIST, NULL, NULL); + check_op(a, ""); + a = op_prepend_elem(OP_LIST, a, iv_op(1)); + check_op(a, "const(1)."); + a = op_prepend_elem(OP_LIST, a, NULL); + check_op(a, "const(1)."); + a = op_prepend_elem(OP_LIST, iv_op(2), a); + check_op(a, "list[pushmark.const(2).const(1).]"); + a = op_prepend_elem(OP_LIST, iv_op(3), a); + check_op(a, "list[pushmark.const(3).const(2).const(1).]"); + a = op_prepend_elem(OP_LIST, NULL, a); + check_op(a, "list[pushmark.const(3).const(2).const(1).]"); + a = op_prepend_elem(OP_LIST, a, NULL); + check_op(a, "list[pushmark.const(3).const(2).const(1).]"); + a = op_prepend_elem(OP_LIST, a, iv_op(4)); + check_op(a, "list[pushmark." + "list[pushmark.const(3).const(2).const(1).]const(4).]"); + a = op_prepend_elem(OP_LIST, iv_op(5), a); + check_op(a, "list[pushmark.const(5)." + "list[pushmark.const(3).const(2).const(1).]const(4).]"); + a = op_prepend_elem(OP_LIST, + op_prepend_elem(OP_LIST, iv_op(6), iv_op(7)), a); + check_op(a, "list[pushmark.list[pushmark.const(6).const(7).]const(5)." + "list[pushmark.const(3).const(2).const(1).]const(4).]"); + op_free(a); + a = op_prepend_elem(OP_LINESEQ, iv_op(2), iv_op(1)); + check_op(a, "lineseq[const(2).const(1).]"); + a = op_prepend_elem(OP_LINESEQ, iv_op(3), a); + check_op(a, "lineseq[const(3).const(2).const(1).]"); + op_free(a); + a = op_prepend_elem(OP_LINESEQ, iv_op(3), + op_prepend_elem(OP_LIST, iv_op(2), iv_op(1))); + check_op(a, "lineseq[const(3).list[pushmark.const(2).const(1).]]"); + op_free(a); + a = op_append_list(OP_LINESEQ, NULL, NULL); + check_op(a, ""); + a = op_append_list(OP_LINESEQ, iv_op(1), a); + check_op(a, "const(1)."); + a = op_append_list(OP_LINESEQ, NULL, a); + check_op(a, "const(1)."); + a = op_append_list(OP_LINESEQ, a, iv_op(2)); + check_op(a, "lineseq[const(1).const(2).]"); + a = op_append_list(OP_LINESEQ, a, iv_op(3)); + check_op(a, "lineseq[const(1).const(2).const(3).]"); + a = op_append_list(OP_LINESEQ, iv_op(4), a); + check_op(a, "lineseq[const(4).const(1).const(2).const(3).]"); + a = op_append_list(OP_LINESEQ, a, NULL); + check_op(a, "lineseq[const(4).const(1).const(2).const(3).]"); + a = op_append_list(OP_LINESEQ, NULL, a); + check_op(a, "lineseq[const(4).const(1).const(2).const(3).]"); + a = op_append_list(OP_LINESEQ, a, + op_append_list(OP_LINESEQ, iv_op(5), iv_op(6))); + check_op(a, "lineseq[const(4).const(1).const(2).const(3)." + "const(5).const(6).]"); + op_free(a); + a = op_append_list(OP_LINESEQ, + op_append_list(OP_LINESEQ, iv_op(1), iv_op(2)), + op_append_list(OP_LIST, iv_op(3), iv_op(4))); + check_op(a, "lineseq[const(1).const(2)." + "list[pushmark.const(3).const(4).]]"); + op_free(a); + a = op_append_list(OP_LINESEQ, + op_append_list(OP_LIST, iv_op(1), iv_op(2)), + op_append_list(OP_LINESEQ, iv_op(3), iv_op(4))); + check_op(a, "lineseq[list[pushmark.const(1).const(2).]" + "const(3).const(4).]"); + op_free(a); #undef check_op void @@ -3782,8 +3782,8 @@ test_op_linklist () CODE: #define check_ll(o, expect) \ STMT_START { \ - if (strNE(test_op_linklist_describe(o), (expect))) \ - croak("fail %s %s", test_op_linklist_describe(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"); @@ -3832,36 +3832,36 @@ test_op_linklist () void peep_enable () PREINIT: - dMY_CXT; + dMY_CXT; CODE: - av_clear(MY_CXT.peep_recorder); - av_clear(MY_CXT.rpeep_recorder); - MY_CXT.peep_recording = 1; + av_clear(MY_CXT.peep_recorder); + av_clear(MY_CXT.rpeep_recorder); + MY_CXT.peep_recording = 1; void peep_disable () PREINIT: - dMY_CXT; + dMY_CXT; CODE: - MY_CXT.peep_recording = 0; + MY_CXT.peep_recording = 0; SV * peep_record () PREINIT: - dMY_CXT; + dMY_CXT; CODE: - RETVAL = newRV_inc((SV *)MY_CXT.peep_recorder); + RETVAL = newRV_inc((SV *)MY_CXT.peep_recorder); OUTPUT: - RETVAL + RETVAL SV * rpeep_record () PREINIT: - dMY_CXT; + dMY_CXT; CODE: - RETVAL = newRV_inc((SV *)MY_CXT.rpeep_recorder); + RETVAL = newRV_inc((SV *)MY_CXT.rpeep_recorder); OUTPUT: - RETVAL + RETVAL =pod @@ -3884,7 +3884,7 @@ CODE: CV *cv; if(items <= 1) { - XSRETURN_UNDEF; + XSRETURN_UNDEF; } cv = sv_2cv(block, &stash, &gv, 0); if (cv == Nullcv) { @@ -3894,8 +3894,8 @@ CODE: SAVESPTR(GvSV(PL_defgv)); for(index = 1 ; index < items ; index++) { - GvSV(PL_defgv) = args[index]; - MULTICALL; + GvSV(PL_defgv) = args[index]; + MULTICALL; } POP_MULTICALL; XSRETURN_UNDEF; @@ -3996,7 +3996,7 @@ CODE: /* continue after 'clone_with_stack' */ if (interp_dup->Iop) - interp_dup->Iop = interp_dup->Iop->op_next; + interp_dup->Iop = interp_dup->Iop->op_next; /* run with new perl */ Perl_runops_standard(interp_dup); @@ -4053,18 +4053,18 @@ OUTPUT: BOOT: - { - HV* stash; - SV** meth = NULL; - CV* cv; - stash = gv_stashpv("XS::APItest::TempLv", 0); - if (stash) - meth = hv_fetchs(stash, "make_temp_mg_lv", 0); - if (!meth) - croak("lost method 'make_temp_mg_lv'"); - cv = GvCV(*meth); - CvLVALUE_on(cv); - } + { + HV* stash; + SV** meth = NULL; + CV* cv; + stash = gv_stashpv("XS::APItest::TempLv", 0); + if (stash) + meth = hv_fetchs(stash, "make_temp_mg_lv", 0); + if (!meth) + croak("lost method 'make_temp_mg_lv'"); + cv = GvCV(*meth); + CvLVALUE_on(cv); + } BOOT: { @@ -4127,10 +4127,10 @@ SV * lv_temp_object() CODE: RETVAL = - sv_bless( - newRV_noinc(newSV(0)), - gv_stashpvs("XS::APItest::TempObj",GV_ADD) - ); /* Package defined in test script */ + sv_bless( + newRV_noinc(newSV(0)), + gv_stashpvs("XS::APItest::TempObj",GV_ADD) + ); /* Package defined in test script */ OUTPUT: RETVAL @@ -4140,9 +4140,9 @@ PREINIT: UV i = 0; CODE: for(; i < 1000; ++i) { - HE *entry = hv_fetch_ent(hv, sv_2mortal(newSVuv(i)), 1, 0); - SvREFCNT_dec(HeVAL(entry)); - HeVAL(entry) = NULL; + HE *entry = hv_fetch_ent(hv, sv_2mortal(newSVuv(i)), 1, 0); + SvREFCNT_dec(HeVAL(entry)); + HeVAL(entry) = NULL; } HV * @@ -4216,11 +4216,11 @@ SV * HvENAME(HV *hv) CODE: RETVAL = hv && HvENAME(hv) - ? newSVpvn_flags( - HvENAME(hv),HvENAMELEN(hv), - (HvENAMEUTF8(hv) ? SVf_UTF8 : 0) - ) - : NULL; + ? newSVpvn_flags( + HvENAME(hv),HvENAMELEN(hv), + (HvENAMEUTF8(hv) ? SVf_UTF8 : 0) + ) + : NULL; OUTPUT: RETVAL @@ -4230,8 +4230,8 @@ CODE: /* Odd sorting (odd numbers first), to make sure we are actually being called */ RETVAL = a % 2 != b % 2 - ? a % 2 ? -1 : 1 - : a < b ? -1 : a == b ? 0 : 1; + ? a % 2 ? -1 : 1 + : a < b ? -1 : a == b ? 0 : 1; OUTPUT: RETVAL @@ -4297,24 +4297,24 @@ bool test_newFOROP_without_slab() CODE: { - const I32 floor = start_subparse(0,0); - OP *o; - /* The slab allocator does not like CvROOT being set. */ - CvROOT(PL_compcv) = (OP *)1; - o = newFOROP(0, 0, newOP(OP_PUSHMARK, 0), 0, 0); - if (cLOOPx(cUNOPo->op_first)->op_last->op_sibparent - != cUNOPo->op_first) - { - Perl_warn(aTHX_ "Op parent pointer is stale"); - RETVAL = FALSE; - } - else - /* If we do not crash before returning, the test passes. */ - RETVAL = TRUE; - op_free(o); - CvROOT(PL_compcv) = NULL; - SvREFCNT_dec(PL_compcv); - LEAVE_SCOPE(floor); + const I32 floor = start_subparse(0,0); + OP *o; + /* The slab allocator does not like CvROOT being set. */ + CvROOT(PL_compcv) = (OP *)1; + o = newFOROP(0, 0, newOP(OP_PUSHMARK, 0), 0, 0); + if (cLOOPx(cUNOPo->op_first)->op_last->op_sibparent + != cUNOPo->op_first) + { + Perl_warn(aTHX_ "Op parent pointer is stale"); + RETVAL = FALSE; + } + else + /* If we do not crash before returning, the test passes. */ + RETVAL = TRUE; + op_free(o); + CvROOT(PL_compcv) = NULL; + SvREFCNT_dec(PL_compcv); + LEAVE_SCOPE(floor); } OUTPUT: RETVAL @@ -4326,19 +4326,19 @@ I32 callregexec(SV *prog, STRLEN stringarg, STRLEN strend, I32 minend, SV *sv, U32 nosave) CODE: { - STRLEN len; - char *strbeg; - if (SvROK(prog)) - prog = SvRV(prog); - strbeg = SvPV_force(sv, len); - RETVAL = CALLREGEXEC((REGEXP *)prog, - strbeg + stringarg, - strbeg + strend, - strbeg, - minend, - sv, - NULL, /* data */ - nosave); + STRLEN len; + char *strbeg; + if (SvROK(prog)) + prog = SvRV(prog); + strbeg = SvPV_force(sv, len); + RETVAL = CALLREGEXEC((REGEXP *)prog, + strbeg + stringarg, + strbeg + strend, + strbeg, + minend, + sv, + NULL, /* data */ + nosave); } OUTPUT: RETVAL @@ -4347,30 +4347,30 @@ void lexical_import(SV *name, CV *cv) CODE: { - PADLIST *pl; - PADOFFSET off; - if (!PL_compcv) - Perl_croak(aTHX_ - "lexical_import can only be called at compile time"); - pl = CvPADLIST(PL_compcv); - ENTER; - 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)), - padadd_STATE, 0, 0); - SvREFCNT_dec(PL_curpad[off]); - PL_curpad[off] = SvREFCNT_inc(cv); - intro_my(); - LEAVE; + PADLIST *pl; + PADOFFSET off; + if (!PL_compcv) + Perl_croak(aTHX_ + "lexical_import can only be called at compile time"); + pl = CvPADLIST(PL_compcv); + ENTER; + 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)), + padadd_STATE, 0, 0); + SvREFCNT_dec(PL_curpad[off]); + PL_curpad[off] = SvREFCNT_inc(cv); + intro_my(); + LEAVE; } SV * sv_mortalcopy(SV *sv) CODE: - RETVAL = SvREFCNT_inc(sv_mortalcopy(sv)); + RETVAL = SvREFCNT_inc(sv_mortalcopy(sv)); OUTPUT: - RETVAL + RETVAL SV * newRV(SV *sv) @@ -4378,71 +4378,71 @@ newRV(SV *sv) void alias_av(AV *av, IV ix, SV *sv) CODE: - av_store(av, ix, SvREFCNT_inc(sv)); + av_store(av, ix, SvREFCNT_inc(sv)); SV * cv_name(SVREF ref, ...) CODE: - RETVAL = SvREFCNT_inc(cv_name((CV *)ref, - items>1 && ST(1) != &PL_sv_undef - ? ST(1) - : NULL, - items>2 ? SvUV(ST(2)) : 0)); + RETVAL = SvREFCNT_inc(cv_name((CV *)ref, + items>1 && ST(1) != &PL_sv_undef + ? ST(1) + : NULL, + items>2 ? SvUV(ST(2)) : 0)); OUTPUT: - RETVAL + RETVAL void sv_catpvn(SV *sv, SV *sv2) CODE: { - STRLEN len; - const char *s = SvPV(sv2,len); - sv_catpvn_flags(sv,s,len, SvUTF8(sv2) ? SV_CATUTF8 : SV_CATBYTES); + STRLEN len; + const char *s = SvPV(sv2,len); + sv_catpvn_flags(sv,s,len, SvUTF8(sv2) ? SV_CATUTF8 : SV_CATBYTES); } bool test_newOP_CUSTOM() CODE: { - OP *o = newLISTOP(OP_CUSTOM, 0, NULL, NULL); - op_free(o); - o = newOP(OP_CUSTOM, 0); - op_free(o); - o = newUNOP(OP_CUSTOM, 0, NULL); - op_free(o); - o = newUNOP_AUX(OP_CUSTOM, 0, NULL, NULL); - op_free(o); - o = newMETHOP(OP_CUSTOM, 0, newOP(OP_NULL,0)); - op_free(o); - o = newMETHOP_named(OP_CUSTOM, 0, newSV(0)); - op_free(o); - o = newBINOP(OP_CUSTOM, 0, NULL, NULL); - op_free(o); - o = newPMOP(OP_CUSTOM, 0); - op_free(o); - o = newSVOP(OP_CUSTOM, 0, newSV(0)); - op_free(o); + OP *o = newLISTOP(OP_CUSTOM, 0, NULL, NULL); + op_free(o); + o = newOP(OP_CUSTOM, 0); + op_free(o); + o = newUNOP(OP_CUSTOM, 0, NULL); + op_free(o); + o = newUNOP_AUX(OP_CUSTOM, 0, NULL, NULL); + op_free(o); + o = newMETHOP(OP_CUSTOM, 0, newOP(OP_NULL,0)); + op_free(o); + o = newMETHOP_named(OP_CUSTOM, 0, newSV(0)); + op_free(o); + o = newBINOP(OP_CUSTOM, 0, NULL, NULL); + op_free(o); + o = newPMOP(OP_CUSTOM, 0); + op_free(o); + o = newSVOP(OP_CUSTOM, 0, newSV(0)); + op_free(o); #ifdef USE_ITHREADS - ENTER; - lex_start(NULL, NULL, 0); - { - I32 ix = start_subparse(FALSE,0); - o = newPADOP(OP_CUSTOM, 0, newSV(0)); - op_free(o); - LEAVE_SCOPE(ix); - } - LEAVE; + ENTER; + lex_start(NULL, NULL, 0); + { + I32 ix = start_subparse(FALSE,0); + o = newPADOP(OP_CUSTOM, 0, newSV(0)); + op_free(o); + LEAVE_SCOPE(ix); + } + LEAVE; #endif - o = newPVOP(OP_CUSTOM, 0, NULL); - op_free(o); - o = newLOGOP(OP_CUSTOM, 0, newOP(OP_NULL,0), newOP(OP_NULL,0)); - op_free(o); - o = newLOOPEX(OP_CUSTOM, newOP(OP_NULL,0)); - op_free(o); - RETVAL = TRUE; + o = newPVOP(OP_CUSTOM, 0, NULL); + op_free(o); + o = newLOGOP(OP_CUSTOM, 0, newOP(OP_NULL,0), newOP(OP_NULL,0)); + op_free(o); + o = newLOOPEX(OP_CUSTOM, newOP(OP_NULL,0)); + op_free(o); + RETVAL = TRUE; } OUTPUT: - RETVAL + RETVAL void test_sv_catpvf(SV *fmtsv) @@ -4460,9 +4460,9 @@ load_module(flags, name, ...) SV *name CODE: if (items == 2) { - Perl_load_module(aTHX_ flags, SvREFCNT_inc(name), NULL); + Perl_load_module(aTHX_ flags, SvREFCNT_inc(name), NULL); } else if (items == 3) { - Perl_load_module(aTHX_ flags, SvREFCNT_inc(name), SvREFCNT_inc(ST(2))); + 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); @@ -4504,9 +4504,9 @@ get_cv_flags(SV *sv, UV flags) void unshift_and_set_defav(SV *sv,...) CODE: - av_unshift(GvAVn(PL_defgv), 1); - av_store(GvAV(PL_defgv), 0, newSVuv(42)); - sv_setuv(sv, 43); + av_unshift(GvAVn(PL_defgv), 1); + av_store(GvAV(PL_defgv), 0, newSVuv(42)); + sv_setuv(sv, 43); PerlIO * PerlIO_stderr() @@ -4532,7 +4532,7 @@ test_MAX_types() */ RETVAL = newSVpvf("iv %" IVdf " uv %" UVuf, IV_MAX, UV_MAX); OUTPUT: - RETVAL + RETVAL MODULE = XS::APItest PACKAGE = XS::APItest::AUTOLOADtest @@ -4558,7 +4558,7 @@ AUTOLOAD(...) OUTPUT: RETVAL -MODULE = XS::APItest PACKAGE = XS::APItest::Magic +MODULE = XS::APItest PACKAGE = XS::APItest::Magic PROTOTYPES: DISABLE @@ -4594,47 +4594,47 @@ CODE: UV test_get_vtbl() PREINIT: - MGVTBL *have; - MGVTBL *want; + MGVTBL *have; + MGVTBL *want; CODE: #define test_get_this_vtable(name) \ - want = (MGVTBL*)CAT2(&PL_vtbl_, name); \ - have = get_vtbl(CAT2(want_vtbl_, name)); \ - if (have != want) \ - croak("fail %p!=%p for get_vtbl(want_vtbl_" STRINGIFY(name) ") at " __FILE__ " line %d", have, want, __LINE__) - - test_get_this_vtable(sv); - test_get_this_vtable(env); - test_get_this_vtable(envelem); - test_get_this_vtable(sigelem); - test_get_this_vtable(pack); - test_get_this_vtable(packelem); - test_get_this_vtable(dbline); - test_get_this_vtable(isa); - test_get_this_vtable(isaelem); - test_get_this_vtable(arylen); - test_get_this_vtable(mglob); - test_get_this_vtable(nkeys); - test_get_this_vtable(taint); - test_get_this_vtable(substr); - test_get_this_vtable(vec); - test_get_this_vtable(pos); - test_get_this_vtable(bm); - test_get_this_vtable(fm); - test_get_this_vtable(uvar); - test_get_this_vtable(defelem); - test_get_this_vtable(regexp); - test_get_this_vtable(regdata); - test_get_this_vtable(regdatum); + want = (MGVTBL*)CAT2(&PL_vtbl_, name); \ + have = get_vtbl(CAT2(want_vtbl_, name)); \ + if (have != want) \ + croak("fail %p!=%p for get_vtbl(want_vtbl_" STRINGIFY(name) ") at " __FILE__ " line %d", have, want, __LINE__) + + test_get_this_vtable(sv); + test_get_this_vtable(env); + test_get_this_vtable(envelem); + test_get_this_vtable(sigelem); + test_get_this_vtable(pack); + test_get_this_vtable(packelem); + test_get_this_vtable(dbline); + test_get_this_vtable(isa); + test_get_this_vtable(isaelem); + test_get_this_vtable(arylen); + test_get_this_vtable(mglob); + test_get_this_vtable(nkeys); + test_get_this_vtable(taint); + test_get_this_vtable(substr); + test_get_this_vtable(vec); + test_get_this_vtable(pos); + test_get_this_vtable(bm); + test_get_this_vtable(fm); + test_get_this_vtable(uvar); + test_get_this_vtable(defelem); + test_get_this_vtable(regexp); + test_get_this_vtable(regdata); + test_get_this_vtable(regdatum); #ifdef USE_LOCALE_COLLATE - test_get_this_vtable(collxfrm); + test_get_this_vtable(collxfrm); #endif - test_get_this_vtable(backref); - test_get_this_vtable(utf8); + test_get_this_vtable(backref); + test_get_this_vtable(utf8); - RETVAL = PTR2UV(get_vtbl(-1)); + RETVAL = PTR2UV(get_vtbl(-1)); OUTPUT: - RETVAL + RETVAL # attach ext magic to the SV pointed to by rsv that only has set magic, @@ -4700,7 +4700,7 @@ test_isBLANK_LC(UV ord) bool test_isBLANK_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: /* In this function and those that follow, the boolean 'type' @@ -4719,7 +4719,7 @@ test_isBLANK_utf8(U8 * p, int type) bool test_isBLANK_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -4748,7 +4748,7 @@ test_isVERTWS_uvchr(UV ord) bool test_isVERTWS_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -4812,7 +4812,7 @@ test_isUPPER_LC(UV ord) bool test_isUPPER_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -4827,7 +4827,7 @@ test_isUPPER_utf8(U8 * p, int type) bool test_isUPPER_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -4891,7 +4891,7 @@ test_isLOWER_LC(UV ord) bool test_isLOWER_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -4906,7 +4906,7 @@ test_isLOWER_utf8(U8 * p, int type) bool test_isLOWER_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -4970,7 +4970,7 @@ test_isALPHA_LC(UV ord) bool test_isALPHA_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -4985,7 +4985,7 @@ test_isALPHA_utf8(U8 * p, int type) bool test_isALPHA_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5049,7 +5049,7 @@ test_isWORDCHAR_LC(UV ord) bool test_isWORDCHAR_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5064,7 +5064,7 @@ test_isWORDCHAR_utf8(U8 * p, int type) bool test_isWORDCHAR_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5128,7 +5128,7 @@ test_isALPHANUMERIC_LC(UV ord) bool test_isALPHANUMERIC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5143,7 +5143,7 @@ test_isALPHANUMERIC_utf8(U8 * p, int type) bool test_isALPHANUMERIC_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5186,7 +5186,7 @@ test_isALNUM_LC(UV ord) bool test_isALNUM_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5201,7 +5201,7 @@ test_isALNUM_utf8(U8 * p, int type) bool test_isALNUM_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5237,7 +5237,7 @@ test_isDIGIT_LC_uvchr(UV ord) bool test_isDIGIT_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5252,7 +5252,7 @@ test_isDIGIT_utf8(U8 * p, int type) bool test_isDIGIT_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5365,7 +5365,7 @@ test_isIDFIRST_LC(UV ord) bool test_isIDFIRST_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5380,7 +5380,7 @@ test_isIDFIRST_utf8(U8 * p, int type) bool test_isIDFIRST_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5444,7 +5444,7 @@ test_isIDCONT_LC(UV ord) bool test_isIDCONT_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5459,7 +5459,7 @@ test_isIDCONT_utf8(U8 * p, int type) bool test_isIDCONT_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5523,7 +5523,7 @@ test_isSPACE_LC(UV ord) bool test_isSPACE_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5538,7 +5538,7 @@ test_isSPACE_utf8(U8 * p, int type) bool test_isSPACE_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5602,7 +5602,7 @@ test_isASCII_LC(UV ord) bool test_isASCII_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: #ifndef DEBUGGING PERL_UNUSED_VAR(e); @@ -5620,7 +5620,7 @@ test_isASCII_utf8(U8 * p, int type) bool test_isASCII_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: #ifndef DEBUGGING PERL_UNUSED_VAR(e); @@ -5687,7 +5687,7 @@ test_isCNTRL_LC(UV ord) bool test_isCNTRL_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5702,7 +5702,7 @@ test_isCNTRL_utf8(U8 * p, int type) bool test_isCNTRL_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5766,7 +5766,7 @@ test_isPRINT_LC(UV ord) bool test_isPRINT_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5781,7 +5781,7 @@ test_isPRINT_utf8(U8 * p, int type) bool test_isPRINT_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5845,7 +5845,7 @@ test_isGRAPH_LC(UV ord) bool test_isGRAPH_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5860,7 +5860,7 @@ test_isGRAPH_utf8(U8 * p, int type) bool test_isGRAPH_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5924,7 +5924,7 @@ test_isPUNCT_LC(UV ord) bool test_isPUNCT_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -5939,7 +5939,7 @@ test_isPUNCT_utf8(U8 * p, int type) bool test_isPUNCT_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -6003,7 +6003,7 @@ test_isXDIGIT_LC(UV ord) bool test_isXDIGIT_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -6018,7 +6018,7 @@ test_isXDIGIT_utf8(U8 * p, int type) bool test_isXDIGIT_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -6082,7 +6082,7 @@ test_isPSXSPC_LC(UV ord) bool test_isPSXSPC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -6097,7 +6097,7 @@ test_isPSXSPC_utf8(U8 * p, int type) bool test_isPSXSPC_LC_utf8(U8 * p, int type) PREINIT: - const U8 * e; + const U8 * e; CODE: if (type >= 0) { e = p + UTF8SKIP(p) - type; @@ -6536,7 +6536,7 @@ test_toLOWER_utf8(SV * p, int type) STRLEN len; AV *av; SV *utf8; - const U8 * e; + const U8 * e; UV resultant_cp = UV_MAX; /* Initialized because of dumb compilers */ CODE: input = (U8 *) SvPV(p, len); @@ -6621,7 +6621,7 @@ test_toFOLD_utf8(SV * p, int type) STRLEN len; AV *av; SV *utf8; - const U8 * e; + const U8 * e; UV resultant_cp = UV_MAX; CODE: input = (U8 *) SvPV(p, len); @@ -6706,7 +6706,7 @@ test_toUPPER_utf8(SV * p, int type) STRLEN len; AV *av; SV *utf8; - const U8 * e; + const U8 * e; UV resultant_cp = UV_MAX; CODE: input = (U8 *) SvPV(p, len); @@ -6784,7 +6784,7 @@ test_toTITLE_utf8(SV * p, int type) STRLEN len; AV *av; SV *utf8; - const U8 * e; + const U8 * e; UV resultant_cp = UV_MAX; CODE: input = (U8 *) SvPV(p, len); @@ -6817,7 +6817,7 @@ test_delimcpy(SV * from_sv, STRLEN trunc_from, char delim, STRLEN to_len, STRLEN CODE: from = SvPV_nolen(from_sv); Newx(to, to_len, char); - PoisonWith(to, to_len, char, poison); + PoisonWith(to, to_len, char, poison); assert(trunc_from <= SvCUR(from_sv)); /* trunc_to allows us to throttle the output size available */ assert(trunc_to <= to_len); @@ -6844,7 +6844,7 @@ test_delimcpy_no_escape(SV * from_sv, STRLEN trunc_from, char delim, STRLEN to_l CODE: from = SvPV_nolen(from_sv); Newx(to, to_len, char); - PoisonWith(to, to_len, char, poison); + PoisonWith(to, to_len, char, poison); assert(trunc_from <= SvCUR(from_sv)); /* trunc_to allows us to throttle the output size available */ assert(trunc_to <= to_len); @@ -6894,7 +6894,7 @@ test_Perl_langinfo(SV * item) OUTPUT: RETVAL -MODULE = XS::APItest PACKAGE = XS::APItest::Backrefs +MODULE = XS::APItest PACKAGE = XS::APItest::Backrefs void apitest_weaken(SV *sv) @@ -6967,7 +6967,7 @@ void compile_macros() PREINIT: perl_RnW1_mutex_t m; - perl_RnW1_mutex_t *pm = &m; + perl_RnW1_mutex_t *pm = &m; CODE: PERL_RW_MUTEX_INIT(&m); PERL_WRITE_LOCK(&m); @@ -7106,7 +7106,7 @@ siphash24(SV *state_sv, SV *str_sv) U8 state_pv[32]; int i; if (state_len!=32) croak("siphash state should be exactly 32 bytes"); - for( i = 0; i < 32; i++ ) { + for( i = 0; i < 32; i++ ) { if (i < 8) state_pv[ 7 - i] = temp_pv[i]; else if(i < 16) state_pv[23 - i] = temp_pv[i]; else if(i < 24) state_pv[39 - i] = temp_pv[i];