#define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
-STATIC char*
+STATIC const char*
S_gv_ename(pTHX_ GV *gv)
{
- STRLEN n_a;
SV* tmpsv = sv_newmortal();
gv_efullname3(tmpsv, gv, Nullch);
- return SvPV(tmpsv,n_a);
+ return SvPV_nolen_const(tmpsv);
}
STATIC OP *
SV *rstr = ((SVOP*)repl)->op_sv;
STRLEN tlen;
STRLEN rlen;
- U8 *t = (U8*)SvPV(tstr, tlen);
- U8 *r = (U8*)SvPV(rstr, rlen);
+ const U8 *t = (U8*)SvPV_const(tstr, tlen);
+ const U8 *r = (U8*)SvPV_const(rstr, rlen);
register I32 i;
register I32 j;
I32 del;
if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
SV* listsv = newSVpvn("# comment\n",10);
SV* transv = 0;
- U8* tend = t + tlen;
- U8* rend = r + rlen;
+ const U8* tend = t + tlen;
+ const U8* rend = r + rlen;
STRLEN ulen;
UV tfirst = 1;
UV tlast = 0;
if (!from_utf) {
STRLEN len = tlen;
- tsave = t = bytes_to_utf8(t, &len);
+ t = tsave = bytes_to_utf8(t, &len);
tend = t + len;
}
if (!to_utf && rlen) {
STRLEN len = rlen;
- rsave = r = bytes_to_utf8(r, &len);
+ r = rsave = bytes_to_utf8(r, &len);
rend = r + len;
}
t = uvuni_to_utf8_flags(tmpbuf, 0x7fffffff,
UNICODE_ALLOW_SUPER);
sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
- t = (U8*)SvPVX(transv);
+ t = (const U8*)SvPVX_const(transv);
tlen = SvCUR(transv);
tend = t + tlen;
Safefree(cp);
if (expr->op_type == OP_CONST) {
STRLEN plen;
SV *pat = ((SVOP*)expr)->op_sv;
- char *p = SvPV(pat, plen);
+ const char *p = SvPV_const(pat, plen);
if ((o->op_flags & OPf_SPECIAL) && (*p == ' ' && p[1] == '\0')) {
+ U32 was_readonly = SvREADONLY(pat);
+
+ if (was_readonly) {
+ if (SvFAKE(pat)) {
+ sv_force_normal_flags(pat, 0);
+ assert(!SvREADONLY(pat));
+ was_readonly = 0;
+ } else {
+ SvREADONLY_off(pat);
+ }
+ }
+
sv_setpvn(pat, "\\s+", 3);
- p = SvPV(pat, plen);
+
+ SvFLAGS(pat) |= was_readonly;
+
+ p = SvPV_const(pat, plen);
pm->op_pmflags |= PMf_SKIPWHITE;
}
if (DO_UTF8(pat))
pm->op_pmdynflags |= PMdf_UTF8;
- PM_SETRE(pm, CALLREGCOMP(aTHX_ p, p + plen, pm));
+ /* FIXME - can we make this function take const char * args? */
+ PM_SETRE(pm, CALLREGCOMP(aTHX_ (char*)p, (char*)p + plen, pm));
if (strEQ("\\s+", PM_GETRE(pm)->precomp))
pm->op_pmflags |= PMf_WHITE;
op_free(expr);
save_hptr(&PL_curstash);
save_item(PL_curstname);
- name = SvPV(cSVOPo->op_sv, len);
+ name = SvPV_const(cSVOPo->op_sv, len);
PL_curstash = gv_stashpvn(name, len, TRUE);
sv_setpvn(PL_curstname, name, len);
op_free(o);
}
OP *
-Perl_newFOROP(pTHX_ I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *block,OP *cont)
+Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP *block, OP *cont)
{
dVAR;
LOOP *loop;
*/
UNOP* flip = (UNOP*)((UNOP*)((BINOP*)expr)->op_first)->op_first;
LOGOP* range = (LOGOP*) flip->op_first;
- OP* left = range->op_first;
- OP* right = left->op_sibling;
+ OP* const left = range->op_first;
+ OP* const right = left->op_sibling;
LISTOP* listop;
range->op_flags &= ~OPf_KIDS;
Perl_newLOOPEX(pTHX_ I32 type, OP *label)
{
OP *o;
- STRLEN n_a;
if (type != OP_GOTO || label->op_type == OP_CONST) {
/* "last()" means "last" */
o = newOP(type, OPf_SPECIAL);
else {
o = newPVOP(type, 0, savepv(label->op_type == OP_CONST
- ? SvPVx(((SVOP*)label)->op_sv, n_a)
+ ? SvPVx_nolen_const(((SVOP*)label)->op_sv)
: ""));
}
op_free(label);
Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
{
dVAR;
- STRLEN n_a;
const char *aname;
GV *gv;
- char *ps;
+ const char *ps;
STRLEN ps_len;
register CV *cv=0;
SV *const_sv;
- const char * const name = o ? SvPVx(cSVOPo->op_sv, n_a) : Nullch;
+ const char * const name = o ? SvPVx_nolen_const(cSVOPo->op_sv) : Nullch;
if (proto) {
assert(proto->op_type == OP_CONST);
- ps = SvPVx(((SVOP*)proto)->op_sv, ps_len);
+ ps = SvPVx_const(((SVOP*)proto)->op_sv, ps_len);
}
else
ps = Nullch;
if (GvCVGEN(gv)) {
/* just a cached method */
SvREFCNT_dec(cv);
- cv = 0;
+ cv = Nullcv;
}
else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
/* already defined (or promised) */
/* XXX It's possible for this HvNAME_get to return null, and get passed into strEQ */
- if (ckWARN(WARN_REDEFINE) && !(CvGV(cv) && GvSTASH(CvGV(cv))
- && strEQ(HvNAME_get(GvSTASH(CvGV(cv))), "autouse"))) {
- const line_t oldline = CopLINE(PL_curcop);
- if (PL_copline != NOLINE)
- CopLINE_set(PL_curcop, PL_copline);
- Perl_warner(aTHX_ packWARN(WARN_REDEFINE),
- CvCONST(cv) ? "Constant subroutine %s redefined"
- : "Subroutine %s redefined"
- ,name);
- CopLINE_set(PL_curcop, oldline);
+ if (ckWARN(WARN_REDEFINE)) {
+ GV * const gvcv = CvGV(cv);
+ if (gvcv) {
+ HV * const stash = GvSTASH(gvcv);
+ if (stash) {
+ const char *name = HvNAME_get(stash);
+ if ( strEQ(name,"autouse") ) {
+ const line_t oldline = CopLINE(PL_curcop);
+ if (PL_copline != NOLINE)
+ CopLINE_set(PL_curcop, PL_copline);
+ Perl_warner(aTHX_ packWARN(WARN_REDEFINE),
+ CvCONST(cv) ? "Constant subroutine %s redefined"
+ : "Subroutine %s redefined"
+ ,name);
+ CopLINE_set(PL_curcop, oldline);
+ }
+ }
+ }
}
SvREFCNT_dec(cv);
- cv = 0;
+ cv = Nullcv;
}
}
}
if (tmpstr) {
- name = SvPV(tmpstr, len);
+ name = SvPV_const(tmpstr, len);
sv_2mortal(tmpstr);
}
}
SVOP *kid = (SVOP*)cUNOPo->op_first;
if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
+ SV *sv = kid->op_sv;
+ U32 was_readonly = SvREADONLY(sv);
char *s;
- for (s = SvPVX(kid->op_sv); *s; s++) {
+
+ if (was_readonly) {
+ if (SvFAKE(sv)) {
+ sv_force_normal_flags(sv, 0);
+ assert(!SvREADONLY(sv));
+ was_readonly = 0;
+ } else {
+ SvREADONLY_off(sv);
+ }
+ }
+
+ for (s = SvPVX(sv); *s; s++) {
if (*s == ':' && s[1] == ':') {
*s = '/';
Move(s+2, s+1, strlen(s+2)+1, char);
- SvCUR_set(kid->op_sv, SvCUR(kid->op_sv) - 1);
+ SvCUR_set(sv, SvCUR(sv) - 1);
}
}
- if (SvREADONLY(kid->op_sv)) {
- SvREADONLY_off(kid->op_sv);
- sv_catpvn(kid->op_sv, ".pm", 3);
- SvREADONLY_on(kid->op_sv);
- }
- else
- sv_catpvn(kid->op_sv, ".pm", 3);
+ sv_catpvn(sv, ".pm", 3);
+ SvFLAGS(sv) |= was_readonly;
}
}
I32 arg = 0;
I32 contextclass = 0;
char *e = 0;
- STRLEN n_a;
bool delete_op = 0;
o->op_private |= OPpENTERSUB_HASTARG;
else {
if (SvPOK(cv)) {
namegv = CvANON(cv) ? gv : CvGV(cv);
- proto = SvPV((SV*)cv, n_a);
+ proto = SvPV_nolen((SV*)cv);
}
if (CvASSERTION(cv)) {
if (PL_hints & HINT_ASSERTING) {
SV *lexname;
GV **fields;
SV **svp, *sv;
- char *key = NULL;
+ const char *key = NULL;
STRLEN keylen;
o->op_opt = 1;
/* Make the CONST have a shared SV */
svp = cSVOPx_svp(((BINOP*)o)->op_last);
if ((!SvFAKE(sv = *svp) || !SvREADONLY(sv)) && !IS_PADCONST(sv)) {
- key = SvPV(sv, keylen);
+ key = SvPV_const(sv, keylen);
lexname = newSVpvn_share(key,
SvUTF8(sv) ? -(I32)keylen : keylen,
0);
fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
if (!fields || !GvHV(*fields))
break;
- key = SvPV(*svp, keylen);
+ key = SvPV_const(*svp, keylen);
if (!hv_fetch(GvHV(*fields), key,
SvUTF8(*svp) ? -(I32)keylen : keylen, FALSE))
{
Perl_croak(aTHX_ "No such class field \"%s\" "
"in variable %s of type %s",
- key, SvPV_nolen(lexname), HvNAME_get(SvSTASH(lexname)));
+ key, SvPV_nolen_const(lexname), HvNAME_get(SvSTASH(lexname)));
}
break;
SV *lexname;
GV **fields;
SV **svp;
- char *key;
+ const char *key;
STRLEN keylen;
SVOP *first_key_op, *key_op;
if (key_op->op_type != OP_CONST)
continue;
svp = cSVOPx_svp(key_op);
- key = SvPV(*svp, keylen);
+ key = SvPV_const(*svp, keylen);
if (!hv_fetch(GvHV(*fields), key,
SvUTF8(*svp) ? -(I32)keylen : keylen, FALSE))
{
projects / p5sagit/p5-mst-13.2.git / blobdiff