Perl_av_reify(pTHX_ AV *av)
{
dVAR;
- I32 key;
+ SSize_t key;
PERL_ARGS_ASSERT_AV_REIFY;
assert(SvTYPE(av) == SVt_PVAV);
*/
static bool
-S_adjust_index(pTHX_ AV *av, const MAGIC *mg, I32 *keyp)
+S_adjust_index(pTHX_ AV *av, const MAGIC *mg, SSize_t *keyp)
{
bool adjust_index = 1;
if (mg) {
}
SV**
-Perl_av_fetch(pTHX_ AV *av, I32 key, I32 lval)
+Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)
{
dVAR;
*/
SV**
-Perl_av_store(pTHX_ AV *av, I32 key, SV *val)
+Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val)
{
dVAR;
SV** ary;
*/
AV *
-Perl_av_make(pTHX_ I32 size, SV **strp)
+Perl_av_make(pTHX_ SSize_t size, SV **strp)
{
AV * const av = MUTABLE_AV(newSV_type(SVt_PVAV));
/* sv_upgrade does AvREAL_only() */
if (size) { /* "defined" was returning undef for size==0 anyway. */
SV** ary;
- I32 i;
+ SSize_t i;
Newx(ary,size,SV*);
AvALLOC(av) = ary;
AvARRAY(av) = ary;
Perl_av_clear(pTHX_ AV *av)
{
dVAR;
- I32 extra;
+ SSize_t extra;
bool real;
PERL_ARGS_ASSERT_AV_CLEAR;
if ((real = !!AvREAL(av))) {
SV** const ary = AvARRAY(av);
- I32 index = AvFILLp(av) + 1;
+ SSize_t index = AvFILLp(av) + 1;
ENTER;
SAVEFREESV(SvREFCNT_inc_simple_NN(av));
while (index) {
av_fill(av, -1);
if ((real = !!AvREAL(av))) {
- I32 key = AvFILLp(av) + 1;
+ SSize_t key = AvFILLp(av) + 1;
ENTER;
SAVEFREESV(SvREFCNT_inc_simple_NN(av));
while (key)
*/
void
-Perl_av_unshift(pTHX_ AV *av, I32 num)
+Perl_av_unshift(pTHX_ AV *av, SSize_t num)
{
dVAR;
- I32 i;
+ SSize_t i;
MAGIC* mg;
PERL_ARGS_ASSERT_AV_UNSHIFT;
}
if (num) {
SV **ary;
- const I32 i = AvFILLp(av);
+ const SSize_t i = AvFILLp(av);
/* Create extra elements */
- const I32 slide = i > 0 ? i : 0;
+ const SSize_t slide = i > 0 ? i : 0;
num += slide;
av_extend(av, i + num);
AvFILLp(av) += num;
=cut
*/
-I32
+SSize_t
Perl_av_len(pTHX_ AV *av)
{
PERL_ARGS_ASSERT_AV_LEN;
=cut
*/
void
-Perl_av_fill(pTHX_ AV *av, I32 fill)
+Perl_av_fill(pTHX_ AV *av, SSize_t fill)
{
dVAR;
MAGIC *mg;
return;
}
if (fill <= AvMAX(av)) {
- I32 key = AvFILLp(av);
+ SSize_t key = AvFILLp(av);
SV** const ary = AvARRAY(av);
if (AvREAL(av)) {
=cut
*/
SV *
-Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags)
+Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags)
{
dVAR;
SV *sv;
=cut
*/
bool
-Perl_av_exists(pTHX_ AV *av, I32 key)
+Perl_av_exists(pTHX_ AV *av, SSize_t key)
{
dVAR;
PERL_ARGS_ASSERT_AV_EXISTS;
int use_sparse_seen_hash, I32 useqq)
{
char tmpbuf[128];
- U32 i;
+ Size_t i;
char *c, *r, *realpack;
#ifdef DD_USE_OLD_ID_FORMAT
char id[128];
}
else if (realtype == SVt_PVAV) {
SV *totpad;
- I32 ix = 0;
- const I32 ixmax = av_len((AV *)ival);
+ SSize_t ix = 0;
+ const SSize_t ixmax = av_len((AV *)ival);
SV * const ixsv = newSViv(0);
/* allowing for a 24 char wide array index */
bool do_utf8 = FALSE;
if (sortkeys) {
- if (!(keys && (I32)i <= av_len(keys))) break;
+ if (!(keys && (SSize_t)i <= av_len(keys))) break;
} else {
if (!(entry = hv_iternext((HV *)ival))) break;
}
HV *seenhv = NULL;
AV *postav, *todumpav, *namesav;
I32 level = 0;
- I32 indent, terse, useqq, i, imax, postlen;
+ I32 indent, terse, useqq;
+ SSize_t i, imax, postlen;
SV **svp;
SV *val, *name, *pad, *xpad, *apad, *sep, *pair, *varname;
SV *freezer, *toaster, *bless, *sortkeys;
sv_catsv(retval, valstr);
sv_catsv(retval, sep);
if (postlen >= 0) {
- I32 i;
+ SSize_t i;
sv_catsv(retval, pad);
for (i = 0; i <= postlen; ++i) {
SV *elem;
SV * paths
INIT:
AV * results;
- I32 numpaths = 0;
- int i, n;
+ SSize_t numpaths = 0, n;
+ int i;
struct statfs buf;
SvGETMAGIC(paths);
INIT:
AV* a;
AV* a2;
- I32 elems;
+ SSize_t elems;
CODE:
a = (AV*)SvRV(x); /* ref to aray, don't check ref */
INIT:
AV* a;
SV* temp;
- I32 elems;
- I32 index;
+ SSize_t elems;
+ SSize_t index;
CODE:
a = (AV*)SvRV(x); /* ref to aray, don't check ref */
INIT:
AV* a;
SV* temp;
- I32 elems;
- I32 index;
+ SSize_t elems;
+ SSize_t index;
NV MAX;
CODE:
INIT:
AV* a;
SV* temp;
- I32 elems;
- I32 index;
+ SSize_t elems;
+ SSize_t index;
NV BASE;
CODE:
INIT:
AV* array_x;
AV* array_y;
- I32 elemsx, elemsy, diff;
+ SSize_t elemsx, elemsy, diff;
SV* tempx;
SV* tempy;
STRLEN lenx;
STRLEN leny;
NV diff_nv;
- I32 diff_str;
+ SSize_t diff_str;
CODE:
array_x = (AV*)SvRV(cx); /* ref to aray, don't check ref */
tempy = *av_fetch(array_y, elemsx, 0); /* fetch last element */
SvPV(tempx, lenx); /* convert to string & store length */
SvPV(tempy, leny); /* convert to string & store length */
- diff_str = (I32)lenx - (I32)leny;
+ diff_str = (SSize_t)lenx - (SSize_t)leny;
if (diff_str > 0)
{
RETURN_MORTAL_INT(1); /* same len, but first elems differs in len */
Perl_dump_indent(aTHX_ level, file, " FLAGS = (%s)\n",
SvCUR(d) ? SvPVX_const(d) + 1 : "");
if (nest < maxnest && av_len(MUTABLE_AV(sv)) >= 0) {
- int count;
+ SSize_t count;
for (count = 0; count <= av_len(MUTABLE_AV(sv)) && count < maxnest; count++) {
SV** const elt = av_fetch(MUTABLE_AV(sv),count,0);
p |I32 |apply |I32 type|NN SV** mark|NN SV** sp
ApM |void |apply_attrs_string|NN const char *stashpv|NN CV *cv|NN const char *attrstr|STRLEN len
Apd |void |av_clear |NN AV *av
-Apd |SV* |av_delete |NN AV *av|I32 key|I32 flags
-ApdR |bool |av_exists |NN AV *av|I32 key
+Apd |SV* |av_delete |NN AV *av|SSize_t key|I32 flags
+ApdR |bool |av_exists |NN AV *av|SSize_t key
Apd |void |av_extend |NN AV *av|SSize_t key
p |void |av_extend_guts |NULLOK AV *av|SSize_t key \
|NN SSize_t *maxp \
|NN SV ***allocp|NN SV ***arrayp
-ApdR |SV** |av_fetch |NN AV *av|I32 key|I32 lval
-Apd |void |av_fill |NN AV *av|I32 fill
-ApdR |I32 |av_len |NN AV *av
-ApdR |AV* |av_make |I32 size|NN SV **strp
+ApdR |SV** |av_fetch |NN AV *av|SSize_t key|I32 lval
+Apd |void |av_fill |NN AV *av|SSize_t fill
+ApdR |SSize_t|av_len |NN AV *av
+ApdR |AV* |av_make |SSize_t size|NN SV **strp
Apd |SV* |av_pop |NN AV *av
ApdoxM |void |av_create_and_push|NN AV **const avp|NN SV *const val
Apd |void |av_push |NN AV *av|NN SV *val
: Used in scope.c, and by Data::Alias
EXp |void |av_reify |NN AV *av
ApdR |SV* |av_shift |NN AV *av
-Apd |SV** |av_store |NN AV *av|I32 key|NULLOK SV *val
-AidR |I32 |av_top_index |NN AV *av
-AmpdR |I32 |av_tindex |NN AV *av
+Apd |SV** |av_store |NN AV *av|SSize_t key|NULLOK SV *val
+AidR |SSize_t|av_top_index |NN AV *av
+AmpdR |SSize_t|av_tindex |NN AV *av
Apd |void |av_undef |NN AV *av
ApdoxM |SV** |av_create_and_unshift_one|NN AV **const avp|NN SV *const val
-Apd |void |av_unshift |NN AV *av|I32 num
+Apd |void |av_unshift |NN AV *av|SSize_t num
Apo |SV** |av_arylen_p |NN AV *av
Apo |IV* |av_iter_p |NN AV *av
#if defined(PERL_IN_AV_C)
Apda |char* |savesvpv |NN SV* sv
Ap |void |savestack_grow
Ap |void |savestack_grow_cnt |I32 need
-Amp |void |save_aelem |NN AV* av|I32 idx|NN SV **sptr
-Ap |void |save_aelem_flags|NN AV* av|I32 idx|NN SV **sptr|const U32 flags
+Amp |void |save_aelem |NN AV* av|SSize_t idx|NN SV **sptr
+Ap |void |save_aelem_flags|NN AV* av|SSize_t idx|NN SV **sptr \
+ |const U32 flags
Ap |I32 |save_alloc |I32 size|I32 pad
Ap |void |save_aptr |NN AV** aptr
Ap |AV* |save_ary |NN GV* gv
Ap |void |save_clearsv |NN SV** svp
Ap |void |save_delete |NN HV *hv|NN char *key|I32 klen
Ap |void |save_hdelete |NN HV *hv|NN SV *keysv
-Ap |void |save_adelete |NN AV *av|I32 key
+Ap |void |save_adelete |NN AV *av|SSize_t key
Ap |void |save_destructor|DESTRUCTORFUNC_NOCONTEXT_t f|NN void* p
Ap |void |save_destructor_x|DESTRUCTORFUNC_t f|NULLOK void* p
Apmb |void |save_freesv |NULLOK SV* sv
The members of @seqs are the MROs of
the members of @ISA, followed by @ISA itself.
*/
- I32 items = AvFILLp(isa) + 1;
+ SSize_t items = AvFILLp(isa) + 1;
SV** isa_ptr = AvARRAY(isa);
while(items--) {
SV* const isa_item = *isa_ptr++;
/* ------------------------------- av.h ------------------------------- */
-PERL_STATIC_INLINE I32
+PERL_STATIC_INLINE SSize_t
S_av_top_index(pTHX_ AV *av)
{
PERL_ARGS_ASSERT_AV_TOP_INDEX;
/* this line can have a breakpoint - store the cop in IV */
AV *av = CopFILEAVx(PL_curcop);
if (av) {
- SV * const * const svp = av_fetch(av, (I32)CopLINE(cop), FALSE);
+ SV * const * const svp = av_fetch(av, CopLINE(cop), FALSE);
if (svp && *svp != &PL_sv_undef ) {
(void)SvIOK_on(*svp);
SvIV_set(*svp, PTR2IV(cop));
#define CALL_BLOCK_HOOKS(which, arg) \
STMT_START { \
if (PL_blockhooks) { \
- I32 i; \
+ SSize_t i; \
for (i = av_len(PL_blockhooks); i >= 0; i--) { \
SV *sv = AvARRAY(PL_blockhooks)[i]; \
BHK *hk; \
/* finally add this lib directory at the end of @INC */
if (unshift) {
#ifdef PERL_IS_MINIPERL
- const U32 extra = 0;
+ const Size_t extra = 0;
#else
- U32 extra = av_len(av) + 1;
+ Size_t extra = av_len(av) + 1;
#endif
av_unshift(inc, extra + push_basedir);
if (push_basedir)
within the C<SV> as according to the operation, returning the number of substitutions
made.
- int matches(SV *string, char *pattern, AV **matches);
+ SSize_t matches(SV *string, char *pattern, AV **matches);
Given an C<SV>, a pattern, and a pointer to an empty C<AV>,
matches() evaluates C<$string =~ $pattern> in a list context, and
** and fills in **matches with the matching substrings
**/
- I32 matches(SV *string, char *pattern, AV **match_list)
+ SSize_t matches(SV *string, char *pattern, AV **match_list)
{
SV *command = newSV(0);
- I32 num_matches;
+ SSize_t num_matches;
sv_setpvf(command, "my $string = '%s'; @array = ($string =~ %s)",
SvPV_nolen(string), pattern);
/** Remove all vowels from text **/
num_matches = substitute(&text, "s/[aeiou]//gi");
if (num_matches) {
- printf("substitute: s/[aeiou]//gi...%d substitutions made.\n",
- num_matches);
+ printf("substitute: s/[aeiou]//gi...%lu substitutions made.\n",
+ (unsigned long)num_matches);
printf("Now text is: %s\n\n", SvPV_nolen(text));
}
The second method both creates the AV and initially populates it with SVs:
- AV* av_make(I32 num, SV **ptr);
+ AV* av_make(SSize_t num, SV **ptr);
The second argument points to an array containing C<num> C<SV*>'s. Once the
AV has been created, the SVs can be destroyed, if so desired.
void av_push(AV*, SV*);
SV* av_pop(AV*);
SV* av_shift(AV*);
- void av_unshift(AV*, I32 num);
+ void av_unshift(AV*, SSize_t num);
These should be familiar operations, with the exception of C<av_unshift>.
This routine adds C<num> elements at the front of the array with the C<undef>
Here are some other functions:
- I32 av_top_index(AV*);
- SV** av_fetch(AV*, I32 key, I32 lval);
- SV** av_store(AV*, I32 key, SV* val);
+ SSize_t av_top_index(AV*);
+ SV** av_fetch(AV*, SSize_t key, I32 lval);
+ SV** av_store(AV*, SSize_t key, SV* val);
The C<av_top_index> function returns the highest index value in an array (just
like $#array in Perl). If the array is empty, -1 is returned. The
void av_clear(AV*);
void av_undef(AV*);
- void av_extend(AV*, I32 key);
+ void av_extend(AV*, SSize_t key);
The C<av_clear> function deletes all the elements in the AV* array, but
does not actually delete the array itself. The C<av_undef> function will
gimme = GIMME_V;
if (gimme == G_ARRAY) {
/* XXX see also S_pushav in pp_hot.c */
- const I32 maxarg = AvFILL(MUTABLE_AV(TARG)) + 1;
+ const Size_t maxarg = AvFILL(MUTABLE_AV(TARG)) + 1;
EXTEND(SP, maxarg);
if (SvMAGICAL(TARG)) {
- U32 i;
- for (i=0; i < (U32)maxarg; i++) {
+ Size_t i;
+ for (i=0; i < maxarg; i++) {
SV * const * const svp = av_fetch(MUTABLE_AV(TARG), i, FALSE);
SP[i+1] = (svp) ? *svp : &PL_sv_undef;
}
}
else if (gimme == G_SCALAR) {
SV* const sv = sv_newmortal();
- const I32 maxarg = AvFILL(MUTABLE_AV(TARG)) + 1;
+ const SSize_t maxarg = AvFILL(MUTABLE_AV(TARG)) + 1;
sv_setiv(sv, maxarg);
PUSHs(sv);
}
if (lval && localizing) {
SV **svp;
- I32 max = -1;
+ SSize_t max = -1;
for (svp = MARK + 1; svp <= SP; svp++) {
- const I32 elem = SvIV(*svp);
+ const SSize_t elem = SvIV(*svp);
if (elem > max)
max = elem;
}
while (++MARK <= SP) {
SV **svp;
- I32 elem = SvIV(*MARK);
+ SSize_t elem = SvIV(*MARK);
bool preeminent = TRUE;
if (localizing && can_preserve) {
if (PL_op->op_flags & OPf_SPECIAL) {
AV * const av = MUTABLE_AV(osv);
while (++MARK <= end) {
- I32 idx = SvIV(*MARK);
+ SSize_t idx = SvIV(*MARK);
SV *sv = NULL;
bool preeminent = TRUE;
if (can_preserve)
AV *ary = DEREF_PLAIN_ARRAY(MUTABLE_AV(*++MARK));
SV **src;
SV **dst;
- I32 i;
- I32 offset;
- I32 length;
- I32 newlen;
- I32 after;
- I32 diff;
+ SSize_t i;
+ SSize_t offset;
+ SSize_t length;
+ SSize_t newlen;
+ SSize_t after;
+ SSize_t diff;
const MAGIC * const mg = SvTIED_mg((const SV *)ary, PERL_MAGIC_tied);
if (mg) {
SPAGAIN;
}
else {
- I32 i = 0;
+ SSize_t i = 0;
av_unshift(ary, SP - MARK);
while (MARK < SP) {
SV * const sv = newSVsv(*++MARK);
SP = MARK;
if (SvMAGICAL(av)) {
- I32 i, j;
+ SSize_t i, j;
SV *tmp = sv_newmortal();
/* For SvCANEXISTDELETE */
HV *stash;
REGEXP *rx;
SV *dstr;
const char *m;
- I32 iters = 0;
+ SSize_t iters = 0;
const STRLEN slen = do_utf8
? utf8_length((U8*)s, (U8*)strend)
: (STRLEN)(strend - s);
- I32 maxiters = slen + 10;
+ SSize_t maxiters = slen + 10;
I32 trailing_empty = 0;
const char *orig;
const I32 origlimit = limit;
LEAVE_with_name("call_PUSH");
SPAGAIN;
if (gimme == G_ARRAY) {
- I32 i;
+ SSize_t i;
/* EXTEND should not be needed - we just popped them */
EXTEND(SP, iters);
for (i=0; i < iters; i++) {
(void)POPs; /* XXX ??? */ \
} \
else if (gimme == G_ARRAY) { \
- int i; \
- I32 len; \
+ SSize_t i; \
+ SSize_t len; \
assert(SvTYPE(tmpsv) == SVt_PVAV); \
len = av_len((AV *)tmpsv) + 1; \
(void)POPs; /* get rid of the arg */ \
&& CopSTASH_eq(PL_curcop, PL_debstash))
{
AV * const ary = cx->blk_sub.argarray;
- const int off = AvARRAY(ary) - AvALLOC(ary);
+ const SSize_t off = AvARRAY(ary) - AvALLOC(ary);
Perl_init_dbargs(aTHX);
}
if (!tryrsfp && !(errno == EACCES && !path_searchable)) {
AV * const ar = GvAVn(PL_incgv);
- I32 i;
+ SSize_t i;
#ifdef VMS
if (vms_unixname)
#endif
} else {
if (namesv) { /* did we lookup @INC? */
AV * const ar = GvAVn(PL_incgv);
- I32 i;
+ SSize_t i;
SV *const msg = newSVpvs_flags("", SVs_TEMP);
SV *const inc = newSVpvs_flags("", SVs_TEMP);
for (i = 0; i <= AvFILL(ar); i++) {
}
else if (SvROK(d) && SvTYPE(SvRV(d)) == SVt_PVAV) {
/* Test sub truth for each element */
- I32 i;
+ SSize_t i;
bool andedresults = TRUE;
AV *av = (AV*) SvRV(d);
const I32 len = av_len(av);
}
else if (SvROK(d) && SvTYPE(SvRV(d)) == SVt_PVAV) {
AV * const other_av = MUTABLE_AV(SvRV(d));
- const I32 other_len = av_len(other_av) + 1;
- I32 i;
+ const SSize_t other_len = av_len(other_av) + 1;
+ SSize_t i;
HV *hv = MUTABLE_HV(SvRV(e));
DEBUG_M(Perl_deb(aTHX_ " applying rule Array-Hash\n"));
}
else if (SvROK(d) && SvTYPE(SvRV(d)) == SVt_PVHV) {
AV * const other_av = MUTABLE_AV(SvRV(e));
- const I32 other_len = av_len(other_av) + 1;
- I32 i;
+ const SSize_t other_len = av_len(other_av) + 1;
+ SSize_t i;
DEBUG_M(Perl_deb(aTHX_ " applying rule Hash-Array\n"));
for (i = 0; i < other_len; ++i) {
if (av_len(MUTABLE_AV(SvRV(e))) != av_len(other_av))
RETPUSHNO;
else {
- I32 i;
- const I32 other_len = av_len(other_av);
+ SSize_t i;
+ const SSize_t other_len = av_len(other_av);
if (NULL == seen_this) {
seen_this = newHV();
sm_regex_array:
{
PMOP * const matcher = make_matcher((REGEXP*) SvRV(d));
- const I32 this_len = av_len(MUTABLE_AV(SvRV(e)));
- I32 i;
+ const SSize_t this_len = av_len(MUTABLE_AV(SvRV(e)));
+ SSize_t i;
for(i = 0; i <= this_len; ++i) {
SV * const * const svp = av_fetch(MUTABLE_AV(SvRV(e)), i, FALSE);
}
else if (!SvOK(d)) {
/* undef ~~ array */
- const I32 this_len = av_len(MUTABLE_AV(SvRV(e)));
- I32 i;
+ const SSize_t this_len = av_len(MUTABLE_AV(SvRV(e)));
+ SSize_t i;
DEBUG_M(Perl_deb(aTHX_ " applying rule Undef-Array\n"));
for (i = 0; i <= this_len; ++i) {
else {
sm_any_array:
{
- I32 i;
- const I32 this_len = av_len(MUTABLE_AV(SvRV(e)));
+ SSize_t i;
+ const SSize_t this_len = av_len(MUTABLE_AV(SvRV(e)));
DEBUG_M(Perl_deb(aTHX_ " applying rule Any-Array\n"));
for (i = 0; i <= this_len; ++i) {
S_pushav(pTHX_ AV* const av)
{
dSP;
- const I32 maxarg = AvFILL(av) + 1;
+ const SSize_t maxarg = AvFILL(av) + 1;
EXTEND(SP, maxarg);
if (SvRMAGICAL(av)) {
- U32 i;
- for (i=0; i < (U32)maxarg; i++) {
+ PADOFFSET i;
+ for (i=0; i < (PADOFFSET)maxarg; i++) {
SV ** const svp = av_fetch(av, i, FALSE);
/* See note in pp_helem, and bug id #27839 */
SP[i+1] = svp
}
}
else {
- U32 i;
- for (i=0; i < (U32)maxarg; i++) {
+ PADOFFSET i;
+ for (i=0; i < (PADOFFSET)maxarg; i++) {
SV * const sv = AvARRAY(av)[i];
SP[i+1] = sv ? sv : &PL_sv_undef;
}
}
else if (gimme == G_SCALAR) {
dTARGET;
- const I32 maxarg = AvFILL(av) + 1;
+ const SSize_t maxarg = AvFILL(av) + 1;
SETi(maxarg);
}
} else {
I32 gimme;
HV *hash;
- I32 i;
+ SSize_t i;
int magic;
U32 lval = 0;
{
dVAR; dSP; dMARK; dORIGMARK;
SV **p1 = ORIGMARK+1, **p2;
- I32 max, i;
+ SSize_t max, i;
AV* av = NULL;
HV *stash;
GV *gv;
#define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \
assert(avp); assert(val)
-PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags)
+PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_DELETE \
assert(av)
-PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, I32 key)
+PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, SSize_t key)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_EXISTS \
#define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \
assert(maxp); assert(allocp); assert(arrayp)
-PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, I32 key, I32 lval)
+PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_FETCH \
assert(av)
-PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, I32 fill)
+PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, SSize_t fill)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_FILL \
assert(av)
#define PERL_ARGS_ASSERT_AV_ITER_P \
assert(av)
-PERL_CALLCONV I32 Perl_av_len(pTHX_ AV *av)
+PERL_CALLCONV SSize_t Perl_av_len(pTHX_ AV *av)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_LEN \
assert(av)
-PERL_CALLCONV AV* Perl_av_make(pTHX_ I32 size, SV **strp)
+PERL_CALLCONV AV* Perl_av_make(pTHX_ SSize_t size, SV **strp)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_AV_MAKE \
#define PERL_ARGS_ASSERT_AV_SHIFT \
assert(av)
-PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, I32 key, SV *val)
+PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_STORE \
assert(av)
-/* PERL_CALLCONV I32 Perl_av_tindex(pTHX_ AV *av)
+/* PERL_CALLCONV SSize_t Perl_av_tindex(pTHX_ AV *av)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1); */
-PERL_STATIC_INLINE I32 S_av_top_index(pTHX_ AV *av)
+PERL_STATIC_INLINE SSize_t S_av_top_index(pTHX_ AV *av)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_TOP_INDEX \
#define PERL_ARGS_ASSERT_AV_UNDEF \
assert(av)
-PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, I32 num)
+PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, SSize_t num)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_UNSHIFT \
assert(av)
#define PERL_ARGS_ASSERT_SAVE_I8 \
assert(bytep)
-PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, I32 key)
+PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, SSize_t key)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SAVE_ADELETE \
assert(av)
-/* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV* av, I32 idx, SV **sptr)
+/* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3); */
-PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, I32 idx, SV **sptr, const U32 flags)
+PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, SSize_t idx, SV **sptr, const U32 flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \
}
void
-Perl_save_adelete(pTHX_ AV *av, I32 key)
+Perl_save_adelete(pTHX_ AV *av, SSize_t key)
{
dVAR;
+ dSS_ADD;
PERL_ARGS_ASSERT_SAVE_ADELETE;
SvREFCNT_inc_void(av);
- save_pushi32ptr(key, av, SAVEt_ADELETE);
+ SS_ADD_UV(key);
+ SS_ADD_PTR(av);
+ SS_ADD_IV(SAVEt_ADELETE);
+ SS_ADD_END(3);
}
void
}
void
-Perl_save_aelem_flags(pTHX_ AV *av, I32 idx, SV **sptr, const U32 flags)
+Perl_save_aelem_flags(pTHX_ AV *av, SSize_t idx, SV **sptr,
+ const U32 flags)
{
- dVAR;
+ dVAR; dSS_ADD;
SV *sv;
PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS;
SvGETMAGIC(*sptr);
- save_pushptri32ptr(SvREFCNT_inc_simple(av), idx, SvREFCNT_inc(*sptr),
- SAVEt_AELEM);
+ SS_ADD_PTR(SvREFCNT_inc_simple(av));
+ SS_ADD_IV(idx);
+ SS_ADD_PTR(SvREFCNT_inc(*sptr));
+ SS_ADD_UV(SAVEt_AELEM);
+ SS_ADD_END(4);
/* The array needs to hold a reference count on its new element, so it
must be AvREAL. */
if (!AvREAL(av) && AvREIFY(av))
Safefree(arg2.any_ptr);
break;
case SAVEt_ADELETE:
- (void)av_delete(ARG0_AV, ARG1_I32, G_DISCARD);
+ (void)av_delete(ARG0_AV, arg1.any_iv, G_DISCARD);
SvREFCNT_dec(ARG0_AV);
break;
case SAVEt_DESTRUCTOR_X:
PL_stack_sp = PL_stack_base + arg0.any_i32;
break;
case SAVEt_AELEM: /* array element */
- svp = av_fetch(ARG2_AV, ARG1_I32, 1);
+ svp = av_fetch(ARG2_AV, arg1.any_iv, 1);
if (!AvREAL(ARG2_AV) && AvREIFY(ARG2_AV)) /* undo reify guard */
SvREFCNT_dec(ARG0_SV);
if (svp) {
#define dSS_ADD \
I32 ix = PL_savestack_ix; \
- ANY *ssp = &PL_savestack[ix];
+ ANY *ssp = &PL_savestack[ix]
#define SS_ADD_END(need) \
assert((need) <= SS_MAXPUSH); \
#define SAVEHDELETE(h,s) \
save_hdelete(MUTABLE_HV(h), (s))
#define SAVEADELETE(a,k) \
- save_adelete(MUTABLE_AV(a), (I32)(k))
+ save_adelete(MUTABLE_AV(a), (SSize_t)(k))
#define SAVEDESTRUCTOR(f,p) \
save_destructor((DESTRUCTORFUNC_NOCONTEXT_t)(f), (void*)(p))
sv_setpvn(sv, buf, len);
(void)SvIOK_on(sv);
SvIV_set(sv, 0);
- av_store(av, (I32)CopLINE(PL_curcop), sv);
+ av_store(av, CopLINE(PL_curcop), sv);
}
}
if (gv && (io = GvIO(gv))) {
AV* const av = PerlIO_get_layers(aTHX_ input ?
IoIFP(io) : IoOFP(io));
- I32 i;
- const I32 last = av_len(av);
- I32 nitem = 0;
+ SSize_t i;
+ const SSize_t last = av_len(av);
+ SSize_t nitem = 0;
for (i = last; i >= 0; i -= 3) {
SV * const * const namsvp = av_fetch(av, i - 2, FALSE);
U32 flags;
SV *ret;
AV *av;
- I32 length;
- I32 i;
+ SSize_t length;
+ SSize_t i;
SV **entry;
if (items > 1)
&char_to, &to_len)))
{
if (av_len(from_list) > 0) {
- int i;
+ SSize_t i;
/* We iterate over all combinations of i,j to place each code
* point on each list */
for (i = 0; i <= av_len(from_list); i++) {
- int j;
+ SSize_t j;
AV* i_list = newAV();
SV** entryp = av_fetch(from_list, i, FALSE);
if (entryp == NULL) {
}
}
if ( qv ) { /* quoted versions always get at least three terms*/
- I32 len = av_len(av);
+ SSize_t len = av_len(av);
/* This for loop appears to trigger a compiler bug on OS X, as it
loops infinitely. Yes, len is negative. No, it makes no sense.
Compiler in question is:
if ( sv_isobject(ver) && sv_derived_from(ver, "version") )
/* can just copy directly */
{
- I32 key;
+ SSize_t key;
AV * const av = newAV();
AV *sav;
/* This will get reblessed later if a derived class*/
SV *
Perl_vnumify(pTHX_ SV *vs)
{
- I32 i, len, digit;
+ SSize_t i, len;
+ I32 digit;
int width;
bool alpha = FALSE;
SV *sv;
int
Perl_vcmp(pTHX_ SV *lhv, SV *rhv)
{
- I32 i,l,m,r,retval;
+ I32 i,l,m,r;
+ I32 retval;
bool lalpha = FALSE;
bool ralpha = FALSE;
I32 left = 0;
dXSARGS;
char ultimate_name[NAM$C_MAXRSS+1], work_name[NAM$C_MAXRSS*8 + 1],
workbuff[NAM$C_MAXRSS*1 + 1];
- int counter, num_entries;
+ SSize_t counter, num_entries;
/* ODS-5 ups this, but we want to be consistent, so... */
int max_name_len = 39;
AV *in_array = (AV *)SvRV(ST(0));