U8 * const send = s+len;
PERL_ARGS_ASSERT_DO_TRANS_SIMPLE;
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: entering do_trans_simple:"
+ " input sv:\n",
+ __FILE__, __LINE__));
+ DEBUG_y(sv_dump(sv));
/* First, take care of non-UTF-8 input strings, because they're easy */
if (!SvUTF8(sv)) {
- while (s < send) {
- const short ch = tbl->map[*s];
- if (ch >= 0) {
- matches++;
- *s = (U8)ch;
- }
- s++;
- }
- SvSETMAGIC(sv);
+ while (s < send) {
+ const short ch = tbl->map[*s];
+ if (ch >= 0) {
+ matches++;
+ *s = (U8)ch;
+ }
+ s++;
+ }
+ SvSETMAGIC(sv);
}
else {
- const bool grows = cBOOL(PL_op->op_private & OPpTRANS_GROWS);
- U8 *d;
- U8 *dstart;
+ const bool grows = cBOOL(PL_op->op_private & OPpTRANS_GROWS);
+ U8 *d;
+ U8 *dstart;
/* Allow for worst-case expansion: Each input byte can become 2. For a
* given input character, this happens when it occupies a single byte
* under UTF-8, but is to be translated to something that occupies two:
* $_="a".chr(400); tr/a/\xFE/, FE needs encoding. */
- if (grows)
- Newx(d, len*2+1, U8);
- else
- d = s;
- dstart = d;
- while (s < send) {
- STRLEN ulen;
- short ch;
-
- /* Need to check this, otherwise 128..255 won't match */
- const UV c = utf8n_to_uvchr(s, send - s, &ulen, UTF8_ALLOW_DEFAULT);
- if (c < 0x100 && (ch = tbl->map[c]) >= 0) {
- matches++;
- d = uvchr_to_utf8(d, (UV)ch);
- s += ulen;
- }
- else { /* No match -> copy */
- Move(s, d, ulen, U8);
- d += ulen;
- s += ulen;
- }
- }
- if (grows) {
- sv_setpvn(sv, (char*)dstart, d - dstart);
- Safefree(dstart);
- }
- else {
- *d = '\0';
- SvCUR_set(sv, d - dstart);
- }
- SvUTF8_on(sv);
- SvSETMAGIC(sv);
+ if (grows)
+ Newx(d, len*2+1, U8);
+ else
+ d = s;
+ dstart = d;
+ while (s < send) {
+ STRLEN ulen;
+ short ch;
+
+ /* Need to check this, otherwise 128..255 won't match */
+ const UV c = utf8n_to_uvchr(s, send - s, &ulen, UTF8_ALLOW_DEFAULT);
+ if (c < 0x100 && (ch = tbl->map[c]) >= 0) {
+ matches++;
+ d = uvchr_to_utf8(d, (UV)ch);
+ s += ulen;
+ }
+ else { /* No match -> copy */
+ Move(s, d, ulen, U8);
+ d += ulen;
+ s += ulen;
+ }
+ }
+ if (grows) {
+ sv_setpvn(sv, (char*)dstart, d - dstart);
+ Safefree(dstart);
+ }
+ else {
+ *d = '\0';
+ SvCUR_set(sv, d - dstart);
+ }
+ SvUTF8_on(sv);
+ SvSETMAGIC(sv);
}
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: returning %zu\n",
+ __FILE__, __LINE__, matches));
+ DEBUG_y(sv_dump(sv));
return matches;
}
PERL_ARGS_ASSERT_DO_TRANS_COUNT;
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: entering do_trans_count:"
+ " input sv:\n",
+ __FILE__, __LINE__));
+ DEBUG_y(sv_dump(sv));
+
if (!SvUTF8(sv)) {
- while (s < send) {
+ while (s < send) {
if (tbl->map[*s++] >= 0)
matches++;
- }
+ }
}
else {
- const bool complement = cBOOL(PL_op->op_private & OPpTRANS_COMPLEMENT);
- while (s < send) {
- STRLEN ulen;
- const UV c = utf8n_to_uvchr(s, send - s, &ulen, UTF8_ALLOW_DEFAULT);
- if (c < 0x100) {
- if (tbl->map[c] >= 0)
- matches++;
- } else if (complement)
- matches++;
- s += ulen;
- }
+ const bool complement = cBOOL(PL_op->op_private & OPpTRANS_COMPLEMENT);
+ while (s < send) {
+ STRLEN ulen;
+ const UV c = utf8n_to_uvchr(s, send - s, &ulen, UTF8_ALLOW_DEFAULT);
+ if (c < 0x100) {
+ if (tbl->map[c] >= 0)
+ matches++;
+ } else if (complement)
+ matches++;
+ s += ulen;
+ }
}
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: count returning %zu\n",
+ __FILE__, __LINE__, matches));
return matches;
}
PERL_ARGS_ASSERT_DO_TRANS_COMPLEX;
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: entering do_trans_complex:"
+ " input sv:\n",
+ __FILE__, __LINE__));
+ DEBUG_y(sv_dump(sv));
+
if (!SvUTF8(sv)) {
- U8 *d = s;
- U8 * const dstart = d;
+ U8 *d = s;
+ U8 * const dstart = d;
- if (PL_op->op_private & OPpTRANS_SQUASH) {
+ if (PL_op->op_private & OPpTRANS_SQUASH) {
/* What the mapping of the previous character was to. If the new
* character has the same mapping, it is squashed from the output
* (but still is included in the count) */
short previous_map = (short) TR_OOB;
- while (s < send) {
- const short this_map = tbl->map[*s];
- if (this_map >= 0) {
+ while (s < send) {
+ const short this_map = tbl->map[*s];
+ if (this_map >= 0) {
matches++;
if (this_map != previous_map) {
*d++ = (U8)this_map;
previous_map = this_map;
}
- }
- else {
- if (this_map == (short) TR_UNMAPPED)
+ }
+ else {
+ if (this_map == (short) TR_UNMAPPED) {
*d++ = *s;
+ previous_map = (short) TR_OOB;
+ }
else {
assert(this_map == (short) TR_DELETE);
matches++;
}
- previous_map = (short) TR_OOB;
}
- s++;
- }
- }
- else { /* Not to squash */
- while (s < send) {
- const short this_map = tbl->map[*s];
- if (this_map >= 0) {
- matches++;
- *d++ = (U8)this_map;
- }
- else if (this_map == (short) TR_UNMAPPED)
- *d++ = *s;
- else if (this_map == (short) TR_DELETE)
- matches++;
- s++;
- }
- }
- *d = '\0';
- SvCUR_set(sv, d - dstart);
+ s++;
+ }
+ }
+ else { /* Not to squash */
+ while (s < send) {
+ const short this_map = tbl->map[*s];
+ if (this_map >= 0) {
+ matches++;
+ *d++ = (U8)this_map;
+ }
+ else if (this_map == (short) TR_UNMAPPED)
+ *d++ = *s;
+ else if (this_map == (short) TR_DELETE)
+ matches++;
+ s++;
+ }
+ }
+ *d = '\0';
+ SvCUR_set(sv, d - dstart);
}
else { /* is utf8 */
- const bool squash = cBOOL(PL_op->op_private & OPpTRANS_SQUASH);
- const bool grows = cBOOL(PL_op->op_private & OPpTRANS_GROWS);
- U8 *d;
- U8 *dstart;
- Size_t size = tbl->size;
+ const bool squash = cBOOL(PL_op->op_private & OPpTRANS_SQUASH);
+ const bool grows = cBOOL(PL_op->op_private & OPpTRANS_GROWS);
+ U8 *d;
+ U8 *dstart;
+ Size_t size = tbl->size;
/* What the mapping of the previous character was to. If the new
* character has the same mapping, it is squashed from the output (but
* still is included in the count) */
UV pch = TR_OOB;
- if (grows)
+ if (grows)
/* Allow for worst-case expansion: Each input byte can become 2.
* For a given input character, this happens when it occupies a
* single byte under UTF-8, but is to be translated to something
* that occupies two: */
- Newx(d, len*2+1, U8);
- else
- d = s;
- dstart = d;
+ Newx(d, len*2+1, U8);
+ else
+ d = s;
+ dstart = d;
while (s < send) {
STRLEN len;
else if (sch == (short) TR_UNMAPPED) {
Move(s, d, len, U8);
d += len;
+ pch = TR_OOB;
}
else if (sch == (short) TR_DELETE)
matches++;
}
s += len;
- pch = TR_OOB;
}
- if (grows) {
- sv_setpvn(sv, (char*)dstart, d - dstart);
- Safefree(dstart);
- }
- else {
- *d = '\0';
- SvCUR_set(sv, d - dstart);
- }
- SvUTF8_on(sv);
+ if (grows) {
+ sv_setpvn(sv, (char*)dstart, d - dstart);
+ Safefree(dstart);
+ }
+ else {
+ *d = '\0';
+ SvCUR_set(sv, d - dstart);
+ }
+ SvUTF8_on(sv);
}
SvSETMAGIC(sv);
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: returning %zu\n",
+ __FILE__, __LINE__, matches));
+ DEBUG_y(sv_dump(sv));
return matches;
}
PERL_ARGS_ASSERT_DO_TRANS_COUNT_INVMAP;
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d:"
+ "entering do_trans_count_invmap:"
+ " input sv:\n",
+ __FILE__, __LINE__));
+ DEBUG_y(sv_dump(sv));
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "mapping:\n"));
+ DEBUG_y(invmap_dump(from_invlist, (UV *) SvPVX(to_invmap_sv)));
+
s = (U8*)SvPV_nomg(sv, len);
send = s + len;
s += s_len;
}
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: returning %zu\n",
+ __FILE__, __LINE__, matches));
return matches;
}
-
/* Helper function for do_trans().
* Handles cases where an inversion map implementation is to be used and the
* search and replacement charlists are either not identical or flags are
const bool delete_unfound = cBOOL(PL_op->op_private & OPpTRANS_DELETE);
bool inplace = ! cBOOL(PL_op->op_private & OPpTRANS_GROWS);
const UV* from_array = invlist_array(from_invlist);
- UV final_map;
+ UV final_map = TR_OOB;
bool out_is_utf8 = cBOOL(SvUTF8(sv));
STRLEN s_len;
* assume cannot */
if (! out_is_utf8 && (PL_op->op_private & OPpTRANS_CAN_FORCE_UTF8)) {
inplace = FALSE;
- if (max_expansion < 2) {
- max_expansion = 2;
- }
}
s = (U8*)SvPV_nomg(sv, len);
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: entering do_trans_invmap:"
+ " input sv:\n",
+ __FILE__, __LINE__));
+ DEBUG_y(sv_dump(sv));
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "mapping:\n"));
+ DEBUG_y(invmap_dump(from_invlist, map));
+
send = s + len;
s0 = s;
* transliterations are longer than the input. If none can, we just edit
* in place. */
if (inplace) {
- d0 = d = s;
+ d0 = d = s;
}
else {
/* Here, we can't edit in place. We have no idea how much, if any,
* this particular input string will grow. However, the compilation
- * calculated the maximum expansion possible. Use that to allocale
- * based on the worst case scenario. */
- Newx(d, len * max_expansion + 1, U8);
- d0 = d;
+ * calculated the maximum expansion possible. Use that to allocate
+ * based on the worst case scenario. (First +1 is to round up; 2nd is
+ * for \0) */
+ Newx(d, (STRLEN) (len * max_expansion + 1 + 1), U8);
+ d0 = d;
}
restart:
if (to == (UV) TR_UNLISTED) { /* Just copy the unreplaced character */
if (UVCHR_IS_INVARIANT(from) || ! out_is_utf8) {
- *d++ = from;
+ *d++ = (U8) from;
}
else if (SvUTF8(sv)) {
Move(s, d, s_len, U8);
previous_map = to;
s += s_len;
continue;
- }
+ }
/* Everything else is counted as a match */
matches++;
if (to == (UV) TR_SPECIAL_HANDLING) {
if (delete_unfound) {
- previous_map = to;
s += s_len;
continue;
}
matches = 0;
goto restart;
}
- *d++ = to;
+ *d++ = (U8) to;
}
}
s_len = 0;
s += s_len;
if (! inplace) {
- sv_setpvn(sv, (char*)d0, d - d0);
+ sv_setpvn(sv, (char*)d0, d - d0);
+ Safefree(d0);
}
else {
- *d = '\0';
- SvCUR_set(sv, d - d0);
+ *d = '\0';
+ SvCUR_set(sv, d - d0);
}
if (! SvUTF8(sv) && out_is_utf8) {
}
SvSETMAGIC(sv);
+ DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: returning %zu\n",
+ __FILE__, __LINE__, matches));
+ DEBUG_y(sv_dump(sv));
return matches;
}
-
/* Execute a tr//. sv is the value to be translated, while PL_op
* should be an OP_TRANS or OP_TRANSR op, whose op_pv field contains a
* translation table or whose op_sv field contains an inversion map.
}
(void)SvPV_const(sv, len);
if (!len)
- return 0;
+ return 0;
if (! identical) {
- if (!SvPOKp(sv) || SvTHINKFIRST(sv))
- (void)SvPV_force_nomg(sv, len);
- (void)SvPOK_only_UTF8(sv);
+ if (!SvPOKp(sv) || SvTHINKFIRST(sv))
+ (void)SvPV_force_nomg(sv, len);
+ (void)SvPOK_only_UTF8(sv);
}
if (use_utf8_fcns) {
}
}
+/*
+=for apidoc_section $string
+=for apidoc do_join
+
+This performs a Perl L<C<join>|perlfunc/join>, placing the joined output
+into C<sv>.
+
+The elements to join are in SVs, stored in a C array of pointers to SVs, from
+C<**mark> to S<C<**sp - 1>>. Hence C<*mark> is a reference to the first SV.
+Each SV will be coerced into a PV if not one already.
+
+C<delim> contains the string (or coerced into a string) that is to separate
+each of the joined elements.
+
+If any component is in UTF-8, the result will be as well, and all non-UTF-8
+components will be converted to UTF-8 as necessary.
+
+Magic and tainting are handled.
+
+=cut
+*/
+
void
Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp)
{
len = (items > 0 ? (delimlen * (items - 1) ) : 0);
SvUPGRADE(sv, SVt_PV);
if (SvLEN(sv) < len + items) { /* current length is way too short */
- while (items-- > 0) {
- if (*mark && !SvGAMAGIC(*mark) && SvOK(*mark)) {
- STRLEN tmplen;
- SvPV_const(*mark, tmplen);
- len += tmplen;
- }
- mark++;
- }
- SvGROW(sv, len + 1); /* so try to pre-extend */
-
- mark = oldmark;
- items = sp - mark;
- ++mark;
+ while (items-- > 0) {
+ if (*mark && !SvGAMAGIC(*mark) && SvOK(*mark)) {
+ STRLEN tmplen;
+ SvPV_const(*mark, tmplen);
+ len += tmplen;
+ }
+ mark++;
+ }
+ SvGROW(sv, len + 1); /* so try to pre-extend */
+
+ mark = oldmark;
+ items = sp - mark;
+ ++mark;
}
SvPVCLEAR(sv);
SvUTF8_off(sv);
if (TAINTING_get && SvMAGICAL(sv))
- SvTAINTED_off(sv);
+ SvTAINTED_off(sv);
if (items-- > 0) {
- if (*mark)
- sv_catsv(sv, *mark);
- mark++;
+ if (*mark)
+ sv_catsv(sv, *mark);
+ mark++;
}
if (delimlen) {
- const U32 delimflag = DO_UTF8(delim) ? SV_CATUTF8 : SV_CATBYTES;
- for (; items > 0; items--,mark++) {
- STRLEN len;
- const char *s;
- sv_catpvn_flags(sv,delims,delimlen,delimflag);
- s = SvPV_const(*mark,len);
- sv_catpvn_flags(sv,s,len,
- DO_UTF8(*mark) ? SV_CATUTF8 : SV_CATBYTES);
- }
+ const U32 delimflag = DO_UTF8(delim) ? SV_CATUTF8 : SV_CATBYTES;
+ for (; items > 0; items--,mark++) {
+ STRLEN len;
+ const char *s;
+ sv_catpvn_flags(sv,delims,delimlen,delimflag);
+ s = SvPV_const(*mark,len);
+ sv_catpvn_flags(sv,s,len,
+ DO_UTF8(*mark) ? SV_CATUTF8 : SV_CATBYTES);
+ }
}
else {
- for (; items > 0; items--,mark++)
- {
- STRLEN len;
- const char *s = SvPV_const(*mark,len);
- sv_catpvn_flags(sv,s,len,
- DO_UTF8(*mark) ? SV_CATUTF8 : SV_CATBYTES);
- }
+ for (; items > 0; items--,mark++)
+ {
+ STRLEN len;
+ const char *s = SvPV_const(*mark,len);
+ sv_catpvn_flags(sv,s,len,
+ DO_UTF8(*mark) ? SV_CATUTF8 : SV_CATBYTES);
+ }
}
SvSETMAGIC(sv);
}
+/*
+=for apidoc_section $string
+=for apidoc do_sprintf
+
+This performs a Perl L<C<sprintf>|perlfunc/sprintf> placing the string output
+into C<sv>.
+
+The elements to format are in SVs, stored in a C array of pointers to SVs of
+length C<len>> and beginning at C<**sarg>. The element referenced by C<*sarg>
+is the format.
+
+Magic and tainting are handled.
+
+=cut
+*/
+
void
Perl_do_sprintf(pTHX_ SV *sv, SSize_t len, SV **sarg)
{
assert(len >= 1);
if (SvTAINTED(*sarg))
- TAINT_PROPER(
- (PL_op && PL_op->op_type < OP_max)
- ? (PL_op->op_type == OP_PRTF)
- ? "printf"
- : PL_op_name[PL_op->op_type]
- : "(unknown)"
- );
+ TAINT_PROPER(
+ (PL_op && PL_op->op_type < OP_max)
+ ? (PL_op->op_type == OP_PRTF)
+ ? "printf"
+ : PL_op_name[PL_op->op_type]
+ : "(unknown)"
+ );
SvUTF8_off(sv);
if (DO_UTF8(*sarg))
SvUTF8_on(sv);
sv_vsetpvfn(sv, pat, patlen, NULL, sarg + 1, (Size_t)(len - 1), &do_taint);
SvSETMAGIC(sv);
if (do_taint)
- SvTAINTED_on(sv);
+ SvTAINTED_on(sv);
}
-/* currently converts input to bytes if possible, but doesn't sweat failure */
UV
Perl_do_vecget(pTHX_ SV *sv, STRLEN offset, int size)
{
- STRLEN srclen, len, avail, uoffset, bitoffs = 0;
+ STRLEN srclen;
const I32 svpv_flags = ((PL_op->op_flags & OPf_MOD || LVRET)
? SV_UNDEF_RETURNS_NULL : 0);
unsigned char *s = (unsigned char *)
PERL_ARGS_ASSERT_DO_VECGET;
- if (size < 1 || (size & (size-1))) /* size < 1 or not a power of two */
- Perl_croak(aTHX_ "Illegal number of bits in vec");
+ if (size < 1 || ! isPOWER_OF_2(size))
+ Perl_croak(aTHX_ "Illegal number of bits in vec");
if (SvUTF8(sv)) {
- if (Perl_sv_utf8_downgrade_flags(aTHX_ sv, TRUE, 0)) {
+ if (Perl_sv_utf8_downgrade_flags(aTHX_ sv, TRUE, 0)) {
/* PVX may have changed */
s = (unsigned char *) SvPV_flags(sv, srclen, svpv_flags);
}
else {
- Perl_croak(aTHX_ "Use of strings with code points over 0xFF as arguments to vec is forbidden");
+ Perl_croak(aTHX_ "Use of strings with code points over 0xFF"
+ " as arguments to vec is forbidden");
}
}
- if (size < 8) {
- bitoffs = ((offset%8)*size)%8;
- uoffset = offset/(8/size);
- }
- else if (size > 8) {
- int n = size/8;
- if (offset > Size_t_MAX / n - 1) /* would overflow */
+ if (size <= 8) {
+ STRLEN bitoffs = ((offset % 8) * size) % 8;
+ STRLEN uoffset = offset / (8 / size);
+
+ if (uoffset >= srclen)
return 0;
- uoffset = offset*n;
- }
- else
- uoffset = offset;
- if (uoffset >= srclen)
- return 0;
+ retnum = (s[uoffset] >> bitoffs) & nBIT_MASK(size);
+ }
+ else {
+ int n = size / 8; /* required number of bytes */
+ SSize_t uoffset;
- len = (bitoffs + size + 7)/8; /* required number of bytes */
- avail = srclen - uoffset; /* available number of bytes */
-
- /* Does the byte range overlap the end of the string? If so,
- * handle specially. */
- if (avail < len) {
- if (size <= 8)
- retnum = 0;
- else {
- if (size == 16) {
- assert(avail == 1);
- retnum = (UV) s[uoffset] << 8;
- }
- else if (size == 32) {
- assert(avail >= 1 && avail <= 3);
- if (avail == 1)
- retnum =
- ((UV) s[uoffset ] << 24);
- else if (avail == 2)
- retnum =
- ((UV) s[uoffset ] << 24) +
- ((UV) s[uoffset + 1] << 16);
- else
- retnum =
- ((UV) s[uoffset ] << 24) +
- ((UV) s[uoffset + 1] << 16) +
- ( s[uoffset + 2] << 8);
- }
#ifdef UV_IS_QUAD
- else if (size == 64) {
- Perl_ck_warner(aTHX_ packWARN(WARN_PORTABLE),
- "Bit vector size > 32 non-portable");
- assert(avail >= 1 && avail <= 7);
- if (avail == 1)
- retnum =
- (UV) s[uoffset ] << 56;
- else if (avail == 2)
- retnum =
- ((UV) s[uoffset ] << 56) +
- ((UV) s[uoffset + 1] << 48);
- else if (avail == 3)
- retnum =
- ((UV) s[uoffset ] << 56) +
- ((UV) s[uoffset + 1] << 48) +
- ((UV) s[uoffset + 2] << 40);
- else if (avail == 4)
- retnum =
- ((UV) s[uoffset ] << 56) +
- ((UV) s[uoffset + 1] << 48) +
- ((UV) s[uoffset + 2] << 40) +
- ((UV) s[uoffset + 3] << 32);
- else if (avail == 5)
- retnum =
- ((UV) s[uoffset ] << 56) +
- ((UV) s[uoffset + 1] << 48) +
- ((UV) s[uoffset + 2] << 40) +
- ((UV) s[uoffset + 3] << 32) +
- ((UV) s[uoffset + 4] << 24);
- else if (avail == 6)
- retnum =
- ((UV) s[uoffset ] << 56) +
- ((UV) s[uoffset + 1] << 48) +
- ((UV) s[uoffset + 2] << 40) +
- ((UV) s[uoffset + 3] << 32) +
- ((UV) s[uoffset + 4] << 24) +
- ((UV) s[uoffset + 5] << 16);
- else
- retnum =
- ((UV) s[uoffset ] << 56) +
- ((UV) s[uoffset + 1] << 48) +
- ((UV) s[uoffset + 2] << 40) +
- ((UV) s[uoffset + 3] << 32) +
- ((UV) s[uoffset + 4] << 24) +
- ((UV) s[uoffset + 5] << 16) +
- ((UV) s[uoffset + 6] << 8);
- }
+
+ if (size == 64) {
+ Perl_ck_warner(aTHX_ packWARN(WARN_PORTABLE),
+ "Bit vector size > 32 non-portable");
+ }
#endif
- }
- }
- else if (size < 8)
- retnum = (s[uoffset] >> bitoffs) & ((1 << size) - 1);
- else {
- if (size == 8)
- retnum = s[uoffset];
- else if (size == 16)
- retnum =
- ((UV) s[uoffset] << 8) +
- s[uoffset + 1];
- else if (size == 32)
- retnum =
- ((UV) s[uoffset ] << 24) +
- ((UV) s[uoffset + 1] << 16) +
- ( s[uoffset + 2] << 8) +
- s[uoffset + 3];
+ if (offset > Size_t_MAX / n - 1) /* would overflow */
+ return 0;
+
+ uoffset = offset * n;
+
+ /* Switch on the number of bytes available, but no more than the number
+ * required */
+ switch (MIN(n, (SSize_t) srclen - uoffset)) {
+
#ifdef UV_IS_QUAD
- else if (size == 64) {
- Perl_ck_warner(aTHX_ packWARN(WARN_PORTABLE),
- "Bit vector size > 32 non-portable");
- retnum =
- ((UV) s[uoffset ] << 56) +
- ((UV) s[uoffset + 1] << 48) +
- ((UV) s[uoffset + 2] << 40) +
- ((UV) s[uoffset + 3] << 32) +
- ((UV) s[uoffset + 4] << 24) +
- ((UV) s[uoffset + 5] << 16) +
- ( s[uoffset + 6] << 8) +
- s[uoffset + 7];
- }
+
+ case 8:
+ retnum += ((UV) s[uoffset + 7]);
+ /* FALLTHROUGH */
+ case 7:
+ retnum += ((UV) s[uoffset + 6] << 8); /* = size - 56 */
+ /* FALLTHROUGH */
+ case 6:
+ retnum += ((UV) s[uoffset + 5] << 16); /* = size - 48 */
+ /* FALLTHROUGH */
+ case 5:
+ retnum += ((UV) s[uoffset + 4] << 24); /* = size - 40 */
#endif
+ /* FALLTHROUGH */
+ case 4:
+ retnum += ((UV) s[uoffset + 3] << (size - 32));
+ /* FALLTHROUGH */
+ case 3:
+ retnum += ((UV) s[uoffset + 2] << (size - 24));
+ /* FALLTHROUGH */
+ case 2:
+ retnum += ((UV) s[uoffset + 1] << (size - 16));
+ /* FALLTHROUGH */
+ case 1:
+ retnum += ((UV) s[uoffset ] << (size - 8));
+ break;
+
+ default:
+ return 0;
+ }
}
return retnum;
}
if (!targ)
- return;
+ return;
s = (unsigned char*)SvPV_force_flags(targ, targlen,
SV_GMAGIC | SV_UNDEF_RETURNS_NULL);
if (SvUTF8(targ)) {
- /* This is handled by the SvPOK_only below...
- if (!Perl_sv_utf8_downgrade_flags(aTHX_ targ, TRUE, 0))
- SvUTF8_off(targ);
- */
- (void) Perl_sv_utf8_downgrade_flags(aTHX_ targ, TRUE, 0);
+ /* This is handled by the SvPOK_only below...
+ if (!Perl_sv_utf8_downgrade_flags(aTHX_ targ, TRUE, 0))
+ SvUTF8_off(targ);
+ */
+ (void) Perl_sv_utf8_downgrade_flags(aTHX_ targ, TRUE, 0);
}
(void)SvPOK_only(targ);
size = LvTARGLEN(sv);
if (size < 1 || (size & (size-1))) /* size < 1 or not a power of two */
- Perl_croak(aTHX_ "Illegal number of bits in vec");
+ Perl_croak(aTHX_ "Illegal number of bits in vec");
if (size < 8) {
- bitoffs = ((offset%8)*size)%8;
- offset /= 8/size;
+ bitoffs = ((offset%8)*size)%8;
+ offset /= 8/size;
}
else if (size > 8) {
- int n = size/8;
+ int n = size/8;
if (offset > Size_t_MAX / n - 1) /* would overflow */
Perl_croak_nocontext("Out of memory!");
- offset *= n;
+ offset *= n;
}
len = (bitoffs + size + 7)/8; /* required number of bytes */
if (targlen < offset || targlen - offset < len) {
STRLEN newlen = offset > Size_t_MAX - len - 1 ? /* avoid overflow */
Size_t_MAX : offset + len + 1;
- s = (unsigned char*)SvGROW(targ, newlen);
- (void)memzero((char *)(s + targlen), newlen - targlen);
- SvCUR_set(targ, newlen - 1);
+ s = (unsigned char*)SvGROW(targ, newlen);
+ (void)memzero((char *)(s + targlen), newlen - targlen);
+ SvCUR_set(targ, newlen - 1);
}
if (size < 8) {
- mask = (1 << size) - 1;
- lval &= mask;
- s[offset] &= ~(mask << bitoffs);
- s[offset] |= lval << bitoffs;
+ mask = nBIT_MASK(size);
+ lval &= mask;
+ s[offset] &= ~(mask << bitoffs);
+ s[offset] |= lval << bitoffs;
}
- else {
- if (size == 8)
- s[offset ] = (U8)( lval & 0xff);
- else if (size == 16) {
- s[offset ] = (U8)((lval >> 8) & 0xff);
- s[offset+1] = (U8)( lval & 0xff);
- }
- else if (size == 32) {
- s[offset ] = (U8)((lval >> 24) & 0xff);
- s[offset+1] = (U8)((lval >> 16) & 0xff);
- s[offset+2] = (U8)((lval >> 8) & 0xff);
- s[offset+3] = (U8)( lval & 0xff);
- }
+ else switch (size) {
+
#ifdef UV_IS_QUAD
- else if (size == 64) {
- Perl_ck_warner(aTHX_ packWARN(WARN_PORTABLE),
- "Bit vector size > 32 non-portable");
- s[offset ] = (U8)((lval >> 56) & 0xff);
- s[offset+1] = (U8)((lval >> 48) & 0xff);
- s[offset+2] = (U8)((lval >> 40) & 0xff);
- s[offset+3] = (U8)((lval >> 32) & 0xff);
- s[offset+4] = (U8)((lval >> 24) & 0xff);
- s[offset+5] = (U8)((lval >> 16) & 0xff);
- s[offset+6] = (U8)((lval >> 8) & 0xff);
- s[offset+7] = (U8)( lval & 0xff);
- }
+
+ case 64:
+ Perl_ck_warner(aTHX_ packWARN(WARN_PORTABLE),
+ "Bit vector size > 32 non-portable");
+ s[offset+7] = (U8)( lval ); /* = size - 64 */
+ s[offset+6] = (U8)( lval >> 8); /* = size - 56 */
+ s[offset+5] = (U8)( lval >> 16); /* = size - 48 */
+ s[offset+4] = (U8)( lval >> 24); /* = size - 40 */
#endif
+ /* FALLTHROUGH */
+ case 32:
+ s[offset+3] = (U8)( lval >> (size - 32));
+ s[offset+2] = (U8)( lval >> (size - 24));
+ /* FALLTHROUGH */
+ case 16:
+ s[offset+1] = (U8)( lval >> (size - 16));
+ /* FALLTHROUGH */
+ case 8:
+ s[offset ] = (U8)( lval >> (size - 8));
}
SvSETMAGIC(targ);
}
if (sv != left || (optype != OP_BIT_AND && !SvOK(sv)))
SvPVCLEAR(sv); /* avoid undef warning on |= and ^= */
if (sv == left) {
- lc = SvPV_force_nomg(left, leftlen);
+ lc = SvPV_force_nomg(left, leftlen);
}
else {
- lc = SvPV_nomg_const(left, leftlen);
- SvPV_force_nomg_nolen(sv);
+ lc = SvPV_nomg_const(left, leftlen);
+ SvPV_force_nomg_nolen(sv);
}
rc = SvPV_nomg_const(right, rightlen);
lsave = lc;
rsave = rc;
- SvCUR_set(sv, len);
(void)SvPOK_only(sv);
if (SvOK(sv) || SvTYPE(sv) > SVt_PVMG) {
- dc = SvPV_force_nomg_nolen(sv);
- if (SvLEN(sv) < len + 1) {
- dc = SvGROW(sv, len + 1);
- (void)memzero(dc + SvCUR(sv), len - SvCUR(sv) + 1);
- }
+ dc = SvPV_force_nomg_nolen(sv);
+ if (SvLEN(sv) < len + 1) {
+ dc = SvGROW(sv, len + 1);
+ (void)memzero(dc + SvCUR(sv), len - SvCUR(sv) + 1);
+ }
}
else {
- needlen = optype == OP_BIT_AND
- ? len : (leftlen > rightlen ? leftlen : rightlen);
- Newxz(dc, needlen + 1, char);
- sv_usepvn_flags(sv, dc, needlen, SV_HAS_TRAILING_NUL);
- dc = SvPVX(sv); /* sv_usepvn() calls Renew() */
+ needlen = optype == OP_BIT_AND
+ ? len : (leftlen > rightlen ? leftlen : rightlen);
+ Newxz(dc, needlen + 1, char);
+ sv_usepvn_flags(sv, dc, needlen, SV_HAS_TRAILING_NUL);
+ dc = SvPVX(sv); /* sv_usepvn() calls Renew() */
}
+ SvCUR_set(sv, len);
if (len >= sizeof(long)*4 &&
- !(PTR2nat(dc) % sizeof(long)) &&
- !(PTR2nat(lc) % sizeof(long)) &&
- !(PTR2nat(rc) % sizeof(long))) /* It's almost always aligned... */
+ !(PTR2nat(dc) % sizeof(long)) &&
+ !(PTR2nat(lc) % sizeof(long)) &&
+ !(PTR2nat(rc) % sizeof(long))) /* It's almost always aligned... */
{
- const STRLEN remainder = len % (sizeof(long)*4);
- len /= (sizeof(long)*4);
-
- dl = (long*)dc;
- ll = (long*)lc;
- rl = (long*)rc;
-
- switch (optype) {
- case OP_BIT_AND:
- while (len--) {
- *dl++ = *ll++ & *rl++;
- *dl++ = *ll++ & *rl++;
- *dl++ = *ll++ & *rl++;
- *dl++ = *ll++ & *rl++;
- }
- break;
- case OP_BIT_XOR:
- while (len--) {
- *dl++ = *ll++ ^ *rl++;
- *dl++ = *ll++ ^ *rl++;
- *dl++ = *ll++ ^ *rl++;
- *dl++ = *ll++ ^ *rl++;
- }
- break;
- case OP_BIT_OR:
- while (len--) {
- *dl++ = *ll++ | *rl++;
- *dl++ = *ll++ | *rl++;
- *dl++ = *ll++ | *rl++;
- *dl++ = *ll++ | *rl++;
- }
- }
-
- dc = (char*)dl;
- lc = (char*)ll;
- rc = (char*)rl;
-
- len = remainder;
+ const STRLEN remainder = len % (sizeof(long)*4);
+ len /= (sizeof(long)*4);
+
+ dl = (long*)dc;
+ ll = (long*)lc;
+ rl = (long*)rc;
+
+ switch (optype) {
+ case OP_BIT_AND:
+ while (len--) {
+ *dl++ = *ll++ & *rl++;
+ *dl++ = *ll++ & *rl++;
+ *dl++ = *ll++ & *rl++;
+ *dl++ = *ll++ & *rl++;
+ }
+ break;
+ case OP_BIT_XOR:
+ while (len--) {
+ *dl++ = *ll++ ^ *rl++;
+ *dl++ = *ll++ ^ *rl++;
+ *dl++ = *ll++ ^ *rl++;
+ *dl++ = *ll++ ^ *rl++;
+ }
+ break;
+ case OP_BIT_OR:
+ while (len--) {
+ *dl++ = *ll++ | *rl++;
+ *dl++ = *ll++ | *rl++;
+ *dl++ = *ll++ | *rl++;
+ *dl++ = *ll++ | *rl++;
+ }
+ }
+
+ dc = (char*)dl;
+ lc = (char*)ll;
+ rc = (char*)rl;
+
+ len = remainder;
}
switch (optype) {
(void)hv_iterinit(keys); /* always reset iterator regardless */
if (gimme == G_VOID)
- RETURN;
+ RETURN;
if (gimme == G_SCALAR) {
- if (PL_op->op_flags & OPf_MOD || LVRET) { /* lvalue */
- SV * const ret = sv_2mortal(newSV_type(SVt_PVLV)); /* Not TARG RT#67838 */
- sv_magic(ret, NULL, PERL_MAGIC_nkeys, NULL, 0);
- LvTYPE(ret) = 'k';
- LvTARG(ret) = SvREFCNT_inc_simple(keys);
- PUSHs(ret);
- }
- else {
- IV i;
- dTARGET;
+ if (PL_op->op_flags & OPf_MOD || LVRET) { /* lvalue */
+ SV * const ret = newSV_type_mortal(SVt_PVLV); /* Not TARG RT#67838 */
+ sv_magic(ret, NULL, PERL_MAGIC_nkeys, NULL, 0);
+ LvTYPE(ret) = 'k';
+ LvTARG(ret) = SvREFCNT_inc_simple(keys);
+ PUSHs(ret);
+ }
+ else {
+ IV i;
+ dTARGET;
/* note that in 'scalar(keys %h)' the OP_KEYS is usually
* optimised away and the action is performed directly by the
* padhv or rv2hv op. We now only get here via OP_AVHVSWITCH
* and \&CORE::keys
*/
- if (! SvTIED_mg((const SV *)keys, PERL_MAGIC_tied) ) {
- i = HvUSEDKEYS(keys);
- }
- else {
- i = 0;
- while (hv_iternext(keys)) i++;
- }
- PUSHi( i );
- }
- RETURN;
+ if (! SvTIED_mg((const SV *)keys, PERL_MAGIC_tied) ) {
+ i = HvUSEDKEYS(keys);
+ }
+ else {
+ i = 0;
+ while (hv_iternext(keys)) i++;
+ }
+ PUSHi( i );
+ }
+ RETURN;
}
if (UNLIKELY(PL_op->op_private & OPpMAYBE_LVSUB)) {
- const I32 flags = is_lvalue_sub();
- if (flags && !(flags & OPpENTERSUB_INARGS))
- /* diag_listed_as: Can't modify %s in %s */
- Perl_croak(aTHX_ "Can't modify keys in list assignment");
+ const I32 flags = is_lvalue_sub();
+ if (flags && !(flags & OPpENTERSUB_INARGS))
+ /* diag_listed_as: Can't modify %s in %s */
+ Perl_croak(aTHX_ "Can't modify keys in list assignment");
}
PUTBACK;
https://perl5.git.perl.org / perl5.git / blobdiff