#endif
#define CLINE (PL_copline = (CopLINE(PL_curcop) < PL_copline ? CopLINE(PL_curcop) : PL_copline))
-/* According to some strict interpretations of ANSI C89 one cannot
- * cast void pointers to code pointers or vice versa (as filter_add(),
- * filter_del(), and filter_read() will want to do). We should still
- * be able to use a union for sneaky "casting". */
-typedef union {
- XPVIO* iop;
- filter_t filter;
-} xpvio_filter_u;
-
/*
* Convenience functions to return different tokens and prime the
* lexer for the next token. They all take an argument.
* The UNIDOR macro is for unary functions that can be followed by the //
* operator (such as C<shift // 0>).
*/
-#define UNI2(f,x) return ( \
- yylval.ival = f, \
- PL_expect = x, \
- PL_bufptr = s, \
- PL_last_uni = PL_oldbufptr, \
- PL_last_lop_op = f, \
- REPORT( \
- (*s == '(' || (s = skipspace(s), *s == '(') \
- ? (int)FUNC1 : (int)UNIOP)))
+#define UNI2(f,x) { \
+ yylval.ival = f; \
+ PL_expect = x; \
+ PL_bufptr = s; \
+ PL_last_uni = PL_oldbufptr; \
+ PL_last_lop_op = f; \
+ if (*s == '(') \
+ return REPORT( (int)FUNC1 ); \
+ s = skipspace(s); \
+ return REPORT( *s=='(' ? (int)FUNC1 : (int)UNIOP ); \
+ }
#define UNI(f) UNI2(f,XTERM)
#define UNIDOR(f) UNI2(f,XTERMORDORDOR)
-#define UNIBRACK(f) return ( \
- yylval.ival = f, \
- PL_bufptr = s, \
- PL_last_uni = PL_oldbufptr, \
- REPORT( \
- (*s == '(' || (s = skipspace(s), *s == '(') \
- ? (int)FUNC1 : (int)UNIOP)))
+#define UNIBRACK(f) { \
+ yylval.ival = f; \
+ PL_bufptr = s; \
+ PL_last_uni = PL_oldbufptr; \
+ if (*s == '(') \
+ return REPORT( (int)FUNC1 ); \
+ s = skipspace(s); \
+ return REPORT( (*s == '(') ? (int)FUNC1 : (int)UNIOP ); \
+ }
/* grandfather return to old style */
#define OLDLOP(f) return(yylval.ival=f,PL_expect = XTERM,PL_bufptr = s,(int)LSTOP)
static void
strip_return(SV *sv)
{
- register const char *s = SvPVX(sv);
+ register const char *s = SvPVX_const(sv);
register const char *e = s + SvCUR(sv);
/* outer loop optimized to do nothing if there are no CR-LFs */
while (s < e) {
NV retval = 0.0;
NV nshift = 1.0;
STRLEN len;
- const char *start = SvPVx(sv,len);
+ const char *start = SvPVx_const(sv,len);
const char *end = start + len;
- bool utf = SvUTF8(sv) ? TRUE : FALSE;
+ const bool utf = SvUTF8(sv) ? TRUE : FALSE;
while (start < end) {
STRLEN skip;
UV n;
version = yylval.opval;
ver = cSVOPx(version)->op_sv;
if (SvPOK(ver) && !SvNIOK(ver)) {
- (void)SvUPGRADE(ver, SVt_PVNV);
+ SvUPGRADE(ver, SVt_PVNV);
SvNV_set(ver, str_to_version(ver));
SvNOK_on(ver); /* hint that it is a version */
}
goto finish;
d = s;
if ( PL_hints & HINT_NEW_STRING ) {
- pv = sv_2mortal(newSVpvn(SvPVX(pv), len));
+ pv = sv_2mortal(newSVpvn(SvPVX_const(pv), len));
if (SvUTF8(sv))
SvUTF8_on(pv);
}
*d++ = *s++;
}
*d = '\0';
- SvCUR_set(sv, d - SvPVX(sv));
+ SvCUR_set(sv, d - SvPVX_const(sv));
finish:
if ( PL_hints & HINT_NEW_STRING )
return new_constant(NULL, 0, "q", sv, pv, "q");
continue;
}
- i = d - SvPVX(sv); /* remember current offset */
+ i = d - SvPVX_const(sv); /* remember current offset */
SvGROW(sv, SvLEN(sv) + 256); /* never more than 256 chars in a range */
d = SvPVX(sv) + i; /* refresh d after realloc */
d -= 2; /* eat the first char and the - */
}
}
if (hicount) {
- STRLEN offset = d - SvPVX(sv);
+ STRLEN offset = d - SvPVX_const(sv);
U8 *src, *dst;
d = SvGROW(sv, SvLEN(sv) + hicount + 1) + offset;
src = (U8 *)d - 1;
}
#endif
if (!has_utf8 && SvUTF8(res)) {
- char *ostart = SvPVX(sv);
+ const char *ostart = SvPVX_const(sv);
SvCUR_set(sv, d - ostart);
SvPOK_on(sv);
*d = '\0';
has_utf8 = TRUE;
}
if (len > (STRLEN)(e - s + 4)) { /* I _guess_ 4 is \N{} --jhi */
- char *odest = SvPVX(sv);
+ const char *odest = SvPVX_const(sv);
SvGROW(sv, (SvLEN(sv) + len - (e - s + 4)));
d = SvPVX(sv) + (d - odest);
s += len;
if (need > len) {
/* encoded value larger than old, need extra space (NOTE: SvCUR() not set here) */
- STRLEN off = d - SvPVX(sv);
+ STRLEN off = d - SvPVX_const(sv);
d = SvGROW(sv, SvLEN(sv) + (need-len)) + off;
}
d = (char*)uvchr_to_utf8((U8*)d, uv);
/* terminate the string and set up the sv */
*d = '\0';
- SvCUR_set(sv, d - SvPVX(sv));
+ SvCUR_set(sv, d - SvPVX_const(sv));
if (SvCUR(sv) >= SvLEN(sv))
Perl_croak(aTHX_ "panic: constant overflowed allocated space");
if (GvIO(gv))
return 0;
if ((cv = GvCVu(gv))) {
- const char *proto = SvPVX(cv);
+ const char *proto = SvPVX_const(cv);
if (proto) {
if (*proto == ';')
proto++;
SV *
Perl_filter_add(pTHX_ filter_t funcp, SV *datasv)
{
- xpvio_filter_u u;
-
if (!funcp)
return Nullsv;
PL_rsfp_filters = newAV();
if (!datasv)
datasv = NEWSV(255,0);
- (void)SvUPGRADE(datasv, SVt_PVIO);
- u.filter = funcp;
- IoANY(datasv) = u.iop; /* stash funcp into spare field */
+ SvUPGRADE(datasv, SVt_PVIO);
+ IoANY(datasv) = FPTR2DPTR(void *, funcp); /* stash funcp into spare field */
IoFLAGS(datasv) |= IOf_FAKE_DIRP;
DEBUG_P(PerlIO_printf(Perl_debug_log, "filter_add func %p (%s)\n",
- (void*)u.iop, SvPV_nolen(datasv)));
+ IoANY(datasv), SvPV_nolen(datasv)));
av_unshift(PL_rsfp_filters, 1);
av_store(PL_rsfp_filters, 0, datasv) ;
return(datasv);
Perl_filter_del(pTHX_ filter_t funcp)
{
SV *datasv;
- xpvio_filter_u u;
#ifdef DEBUGGING
- u.filter = funcp;
- DEBUG_P(PerlIO_printf(Perl_debug_log, "filter_del func %p", (void*)u.iop));
+ DEBUG_P(PerlIO_printf(Perl_debug_log, "filter_del func %p", FPTR2DPTR(XPVIO *, funcp)));
#endif
if (!PL_rsfp_filters || AvFILLp(PL_rsfp_filters)<0)
return;
/* if filter is on top of stack (usual case) just pop it off */
datasv = FILTER_DATA(AvFILLp(PL_rsfp_filters));
- u.iop = IoANY(datasv);
- if (u.filter == funcp) {
+ if (IoANY(datasv) == FPTR2DPTR(void *, funcp)) {
IoFLAGS(datasv) &= ~IOf_FAKE_DIRP;
IoANY(datasv) = (void *)NULL;
sv_free(av_pop(PL_rsfp_filters));
{
filter_t funcp;
SV *datasv = NULL;
- xpvio_filter_u u;
if (!PL_rsfp_filters)
return -1;
return FILTER_READ(idx+1, buf_sv, maxlen); /* recurse */
}
/* Get function pointer hidden within datasv */
- u.iop = IoANY(datasv);
- funcp = u.filter;
+ funcp = DPTR2FPTR(filter_t, IoANY(datasv));
DEBUG_P(PerlIO_printf(Perl_debug_log,
"filter_read %d: via function %p (%s)\n",
- idx, (void*)u.iop, SvPV_nolen(datasv)));
+ idx, datasv, SvPV_nolen(datasv)));
/* Call function. The function is expected to */
/* call "FILTER_READ(idx+1, buf_sv)" first. */
/* Return: <0:error, =0:eof, >0:not eof */
if ((gv = gv_fetchpv(pkgname, FALSE, SVt_PVCV))) {
SV *sv;
if (GvCV(gv) && (sv = cv_const_sv(GvCV(gv)))) {
- pkgname = SvPV_nolen(sv);
+ pkgname = SvPV_nolen_const(sv);
}
}
* eval"") we have to resolve the ambiguity. This code
* covers the case where the first term in the curlies is a
* quoted string. Most other cases need to be explicitly
- * disambiguated by prepending a `+' before the opening
+ * disambiguated by prepending a "+" before the opening
* curly in order to force resolution as an anon hash.
*
* XXX should probably propagate the outer expectation
yylval.opval->op_private = OPpCONST_BARE;
/* UTF-8 package name? */
if (UTF && !IN_BYTES &&
- is_utf8_string((U8*)SvPVX(sv), SvCUR(sv)))
+ is_utf8_string((U8*)SvPVX_const(sv), SvCUR(sv)))
SvUTF8_on(sv);
/* And if "Foo::", then that's what it certainly is. */
case KEY___PACKAGE__:
yylval.opval = (OP*)newSVOP(OP_CONST, 0,
(PL_curstash
- ? newSVpv(HvNAME(PL_curstash), 0)
+ ? newSVhek(HvNAME_HEK(PL_curstash))
: &PL_sv_undef));
TERM(THING);
if (PL_rsfp && (!PL_in_eval || PL_tokenbuf[2] == 'D')) {
const char *pname = "main";
if (PL_tokenbuf[2] == 'D')
- pname = HvNAME(PL_curstash ? PL_curstash : PL_defstash);
+ pname = HvNAME_get(PL_curstash ? PL_curstash : PL_defstash);
gv = gv_fetchpv(Perl_form(aTHX_ "%s::DATA", pname), TRUE, SVt_PVIO);
GvMULTI_on(gv);
if (!GvIO(gv))
s = scan_str(s,FALSE,FALSE);
if (!s)
missingterm((char*)0);
+ PL_expect = XOPERATOR;
force_next(')');
if (SvCUR(PL_lex_stuff)) {
OP *words = Nullop;
/* might be an "our" variable" */
if (PAD_COMPNAME_FLAGS(tmp) & SVpad_OUR) {
/* build ops for a bareword */
- SV *sym = newSVpv(HvNAME(PAD_COMPNAME_OURSTASH(tmp)), 0);
+ HV *stash = PAD_COMPNAME_OURSTASH(tmp);
+ HEK *stashname = HvNAME_HEK(stash);
+ SV *sym = newSVhek(stashname);
sv_catpvn(sym, "::", 2);
sv_catpv(sym, PL_tokenbuf+1);
yylval.opval = (OP*)newSVOP(OP_CONST, 0, sym);
msg = Perl_newSVpvf(aTHX_ "Constant(%s): %s%s%s",
(type ? type: "undef"), why1, why2, why3);
msgdone:
- yyerror(SvPVX(msg));
+ yyerror(SvPVX_const(msg));
SvREFCNT_dec(msg);
return sv;
}
/* Check the eval first */
if (!PL_in_eval && SvTRUE(ERRSV)) {
- STRLEN n_a;
sv_catpv(ERRSV, "Propagated");
- yyerror(SvPV(ERRSV, n_a)); /* Duplicates the message inside eval */
+ yyerror(SvPV_nolen_const(ERRSV)); /* Duplicates the message inside eval */
(void)POPs;
res = SvREFCNT_inc(sv);
}
#ifndef PERL_STRICT_CR
d = strchr(s, '\r');
if (d) {
- char *olds = s;
+ char * const olds = s;
s = d;
while (s < PL_bufend) {
if (*s == '\r') {
}
*d = '\0';
PL_bufend = d;
- SvCUR_set(PL_linestr, PL_bufend - SvPVX(PL_linestr));
+ SvCUR_set(PL_linestr, PL_bufend - SvPVX_const(PL_linestr));
s = olds;
}
#endif
if (PL_lex_inwhat == OP_SUBST && PL_in_eval && !PL_rsfp) {
char *bufptr = PL_sublex_info.super_bufptr;
char *bufend = PL_sublex_info.super_bufend;
- char *olds = s - SvCUR(herewas);
+ char * const olds = s - SvCUR(herewas);
s = strchr(bufptr, '\n');
if (!s)
s = bufend;
sv_setpvn(tmpstr,d+1,s-d);
s += len - 1;
sv_catpvn(herewas,s,bufend-s);
- Copy(SvPVX(herewas),bufptr,SvCUR(herewas) + 1,char);
+ Copy(SvPVX_const(herewas),bufptr,SvCUR(herewas) + 1,char);
s = olds;
goto retval;
{
PL_bufend[-2] = '\n';
PL_bufend--;
- SvCUR_set(PL_linestr, PL_bufend - SvPVX(PL_linestr));
+ SvCUR_set(PL_linestr, PL_bufend - SvPVX_const(PL_linestr));
}
else if (PL_bufend[-1] == '\r')
PL_bufend[-1] = '\n';
av_store(CopFILEAV(PL_curcop), (I32)CopLINE(PL_curcop),sv);
}
if (*s == term && memEQ(s,PL_tokenbuf,len)) {
- STRLEN off = PL_bufend - 1 - SvPVX(PL_linestr);
+ STRLEN off = PL_bufend - 1 - SvPVX_const(PL_linestr);
*(SvPVX(PL_linestr) + off ) = ' ';
sv_catsv(PL_linestr,herewas);
PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr);
}
SvREFCNT_dec(herewas);
if (!IN_BYTES) {
- if (UTF && is_utf8_string((U8*)SvPVX(tmpstr), SvCUR(tmpstr)))
+ if (UTF && is_utf8_string((U8*)SvPVX_const(tmpstr), SvCUR(tmpstr)))
SvUTF8_on(tmpstr);
else if (PL_encoding)
sv_recode_to_utf8(tmpstr, PL_encoding);
*/
if ((tmp = pad_findmy(d)) != NOT_IN_PAD) {
if (PAD_COMPNAME_FLAGS(tmp) & SVpad_OUR) {
- SV *sym = sv_2mortal(
- newSVpv(HvNAME(PAD_COMPNAME_OURSTASH(tmp)),0));
+ HV *stash = PAD_COMPNAME_OURSTASH(tmp);
+ HEK *stashname = HvNAME_HEK(stash);
+ SV *sym = sv_2mortal(newSVhek(stashname));
sv_catpvn(sym, "::", 2);
sv_catpv(sym, d+1);
d = SvPVX(sym);
bool cont = TRUE;
while (cont) {
- int offset = s - SvPVX(PL_linestr);
- bool found = sv_cat_decode(sv, PL_encoding, PL_linestr,
+ int offset = s - SvPVX_const(PL_linestr);
+ const bool found = sv_cat_decode(sv, PL_encoding, PL_linestr,
&offset, (char*)termstr, termlen);
- char *ns = SvPVX(PL_linestr) + offset;
+ const char *ns = SvPVX_const(PL_linestr) + offset;
char *svlast = SvEND(sv) - 1;
for (; s < ns; s++) {
/* handle quoted delimiters */
if (SvCUR(sv) > 1 && *(svlast-1) == '\\') {
const char *t;
- for (t = svlast-2; t >= SvPVX(sv) && *t == '\\';)
+ for (t = svlast-2; t >= SvPVX_const(sv) && *t == '\\';)
t--;
if ((svlast-1 - t) % 2) {
if (!keep_quoted) {
if (w < t) {
*w++ = term;
*w = '\0';
- SvCUR_set(sv, w - SvPVX(sv));
+ SvCUR_set(sv, w - SvPVX_const(sv));
}
last = w;
if (--brackets <= 0)
}
/* terminate the copied string and update the sv's end-of-string */
*to = '\0';
- SvCUR_set(sv, to - SvPVX(sv));
+ SvCUR_set(sv, to - SvPVX_const(sv));
/*
* this next chunk reads more into the buffer if we're not done yet
break; /* handle case where we are done yet :-) */
#ifndef PERL_STRICT_CR
- if (to - SvPVX(sv) >= 2) {
+ if (to - SvPVX_const(sv) >= 2) {
if ((to[-2] == '\r' && to[-1] == '\n') ||
(to[-2] == '\n' && to[-1] == '\r'))
{
to[-2] = '\n';
to--;
- SvCUR_set(sv, to - SvPVX(sv));
+ SvCUR_set(sv, to - SvPVX_const(sv));
}
else if (to[-1] == '\r')
to[-1] = '\n';
}
- else if (to - SvPVX(sv) == 1 && to[-1] == '\r')
+ else if (to - SvPVX_const(sv) == 1 && to[-1] == '\r')
to[-1] = '\n';
#endif
else
break;
}
- s = eol;
+ s = (char*)eol;
if (PL_rsfp) {
s = filter_gets(PL_linestr, PL_rsfp, 0);
PL_oldoldbufptr = PL_oldbufptr = PL_bufptr = PL_linestart = SvPVX(PL_linestr);
else
PL_lex_state = LEX_FORMLINE;
if (!IN_BYTES) {
- if (UTF && is_utf8_string((U8*)SvPVX(stuff), SvCUR(stuff)))
+ if (UTF && is_utf8_string((U8*)SvPVX_const(stuff), SvCUR(stuff)))
SvUTF8_on(stuff);
else if (PL_encoding)
sv_recode_to_utf8(stuff, PL_encoding);
I32
Perl_start_subparse(pTHX_ I32 is_format, U32 flags)
{
- I32 oldsavestack_ix = PL_savestack_ix;
+ const I32 oldsavestack_ix = PL_savestack_ix;
CV* outsidecv = PL_compcv;
if (PL_compcv) {
if (!yychar || (yychar == ';' && !PL_rsfp))
where = "at EOF";
- else if (PL_bufptr > PL_oldoldbufptr && PL_bufptr - PL_oldoldbufptr < 200 &&
- PL_oldoldbufptr != PL_oldbufptr && PL_oldbufptr != PL_bufptr) {
+ else if (PL_oldoldbufptr && PL_bufptr > PL_oldoldbufptr &&
+ PL_bufptr - PL_oldoldbufptr < 200 && PL_oldoldbufptr != PL_oldbufptr &&
+ PL_oldbufptr != PL_bufptr) {
/*
Only for NetWare:
The code below is removed for NetWare because it abends/crashes on NetWare
context = PL_oldoldbufptr;
contlen = PL_bufptr - PL_oldoldbufptr;
}
- else if (PL_bufptr > PL_oldbufptr && PL_bufptr - PL_oldbufptr < 200 &&
- PL_oldbufptr != PL_bufptr) {
+ else if (PL_oldbufptr && PL_bufptr > PL_oldbufptr &&
+ PL_bufptr - PL_oldbufptr < 200 && PL_oldbufptr != PL_bufptr) {
/*
Only for NetWare:
The code below is removed for NetWare because it abends/crashes on NetWare
Perl_sv_catpvf(aTHX_ where_sv, "%c", yychar);
else
Perl_sv_catpvf(aTHX_ where_sv, "\\%03o", yychar & 255);
- where = SvPVX(where_sv);
+ where = SvPVX_const(where_sv);
}
msg = sv_2mortal(newSVpv(s, 0));
Perl_sv_catpvf(aTHX_ msg, " at %s line %"IVdf", ",
U8* tmps;
I32 newlen;
New(898, tmps, SvCUR(sv) * 3 / 2 + 1, U8);
- Copy(SvPVX(sv), tmps, old, char);
- utf16_to_utf8((U8*)SvPVX(sv) + old, tmps + old,
+ Copy(SvPVX_const(sv), tmps, old, char);
+ utf16_to_utf8((U8*)SvPVX_const(sv) + old, tmps + old,
SvCUR(sv) - old, &newlen);
sv_usepvn(sv, (char*)tmps, (STRLEN)newlen + old);
}
U8* tmps;
I32 newlen;
New(898, tmps, SvCUR(sv) * 3 / 2 + 1, U8);
- Copy(SvPVX(sv), tmps, old, char);
- utf16_to_utf8((U8*)SvPVX(sv) + old, tmps + old,
+ Copy(SvPVX_const(sv), tmps, old, char);
+ utf16_to_utf8((U8*)SvPVX_const(sv) + old, tmps + old,
SvCUR(sv) - old, &newlen);
sv_usepvn(sv, (char*)tmps, (STRLEN)newlen + old);
}
https://perl5.git.perl.org / perl5.git / blobdiff