av.c

   1 /*    av.c
   2  *
   3  *    Copyright (c) 1991-1994, Larry Wall
   4  *
   5  *    You may distribute under the terms of either the GNU General Public
   6  *    License or the Artistic License, as specified in the README file.
   7  *
   8  */
   9
  10 /*
  11  * "...for the Entwives desired order, and plenty, and peace (by which they
  12  * meant that things should remain where they had set them)." --Treebeard
  13  */
  14
  15 #include "EXTERN.h"
  16 #include "perl.h"
  17
  18 static void     av_reify _((AV* av));
  19
  20 static void
  21 av_reify(av)
  22 AV* av;
  23 {
  24     I32 key;
  25     SV* sv;
  26
  27     key = AvMAX(av) + 1;
  28     while (key > AvFILL(av) + 1)
  29         AvARRAY(av)[--key] = &sv_undef;
  30     while (key) {
  31         sv = AvARRAY(av)[--key];
  32         assert(sv);
  33         if (sv != &sv_undef)
  34             (void)SvREFCNT_inc(sv);
  35     }
  36     AvREAL_on(av);
  37 }
  38
  39 void
  40 av_extend(av,key)
  41 AV *av;
  42 I32 key;
  43 {
  44     if (key > AvMAX(av)) {
  45         SV** ary;
  46         I32 tmp;
  47         I32 newmax;
  48
  49         if (AvALLOC(av) != AvARRAY(av)) {
  50             ary = AvALLOC(av) + AvFILL(av) + 1;
  51             tmp = AvARRAY(av) - AvALLOC(av);
  52             Move(AvARRAY(av), AvALLOC(av), AvFILL(av)+1, SV*);
  53             AvMAX(av) += tmp;
  54             SvPVX(av) = (char*)AvALLOC(av);
  55             if (AvREAL(av)) {
  56                 while (tmp)
  57                     ary[--tmp] = &sv_undef;
  58             }
  59
  60             if (key > AvMAX(av) - 10) {
  61                 newmax = key + AvMAX(av);
  62                 goto resize;
  63             }
  64         }
  65         else {
  66             if (AvALLOC(av)) {
  67                 U32 bytes;
  68
  69                 newmax = key + AvMAX(av) / 5;
  70               resize:
  71 #ifdef STRANGE_MALLOC
  72                 Renew(AvALLOC(av),newmax+1, SV*);
  73 #else
  74                 bytes = (newmax + 1) * sizeof(SV*);
  75 #define MALLOC_OVERHEAD 16
  76                 tmp = MALLOC_OVERHEAD;
  77                 while (tmp - MALLOC_OVERHEAD < bytes)
  78                     tmp += tmp;
  79                 tmp -= MALLOC_OVERHEAD;
  80                 tmp /= sizeof(SV*);
  81                 assert(tmp > newmax);
  82                 newmax = tmp - 1;
  83                 New(2,ary, newmax+1, SV*);
  84                 Copy(AvALLOC(av), ary, AvMAX(av)+1, SV*);
  85                 if (AvMAX(av) > 64 && !AvREUSED(av))
  86                     sv_add_arena((char*)AvALLOC(av), AvMAX(av) * sizeof(SV*),0);
  87                 else
  88                     Safefree(AvALLOC(av));
  89                 AvALLOC(av) = ary;
  90 #endif
  91                 ary = AvALLOC(av) + AvMAX(av) + 1;
  92                 tmp = newmax - AvMAX(av);
  93                 if (av == stack) {      /* Oops, grew stack (via av_store()?) */
  94                     stack_sp = AvALLOC(av) + (stack_sp - stack_base);
  95                     stack_base = AvALLOC(av);
  96                     stack_max = stack_base + newmax;
  97                 }
  98             }
  99             else {
 100                 newmax = key < 4 ? 4 : key;
 101                 New(2,AvALLOC(av), newmax+1, SV*);
 102                 ary = AvALLOC(av) + 1;
 103                 tmp = newmax;
 104                 AvALLOC(av)[0] = &sv_undef;     /* For the stacks */
 105             }
 106             if (AvREAL(av)) {
 107                 while (tmp)
 108                     ary[--tmp] = &sv_undef;
 109             }
 110
 111             SvPVX(av) = (char*)AvALLOC(av);
 112             AvMAX(av) = newmax;
 113         }
 114     }
 115 }
 116
 117 SV**
 118 av_fetch(av,key,lval)
 119 register AV *av;
 120 I32 key;
 121 I32 lval;
 122 {
 123     SV *sv;
 124
 125     if (!av)
 126         return 0;
 127
 128     if (SvRMAGICAL(av)) {
 129         if (mg_find((SV*)av,'P')) {
 130             sv = sv_newmortal();
 131             mg_copy((SV*)av, sv, 0, key);
 132             Sv = sv;
 133             return &Sv;
 134         }
 135     }
 136
 137     if (key < 0) {
 138         key += AvFILL(av) + 1;
 139         if (key < 0)
 140             return 0;
 141     }
 142     else if (key > AvFILL(av)) {
 143         if (!lval)
 144             return 0;
 145         if (AvREALISH(av))
 146             sv = NEWSV(5,0);
 147         else
 148             sv = sv_newmortal();
 149         return av_store(av,key,sv);
 150     }
 151     if (AvARRAY(av)[key] == &sv_undef) {
 152         if (lval) {
 153             sv = NEWSV(6,0);
 154             return av_store(av,key,sv);
 155         }
 156         return 0;
 157     }
 158     return &AvARRAY(av)[key];
 159 }
 160
 161 SV**
 162 av_store(av,key,val)
 163 register AV *av;
 164 I32 key;
 165 SV *val;
 166 {
 167     SV** ary;
 168
 169     if (!av)
 170         return 0;
 171
 172     if (SvRMAGICAL(av)) {
 173         if (mg_find((SV*)av,'P')) {
 174             mg_copy((SV*)av, val, 0, key);
 175             return 0;
 176         }
 177     }
 178
 179     if (key < 0) {
 180         key += AvFILL(av) + 1;
 181         if (key < 0)
 182             return 0;
 183     }
 184     if (!val)
 185         val = &sv_undef;
 186
 187     if (key > AvMAX(av))
 188         av_extend(av,key);
 189     if (AvREIFY(av))
 190         av_reify(av);
 191
 192     ary = AvARRAY(av);
 193     if (AvFILL(av) < key) {
 194         if (!AvREAL(av)) {
 195             if (av == stack && key > stack_sp - stack_base)
 196                 stack_sp = stack_base + key;    /* XPUSH in disguise */
 197             do
 198                 ary[++AvFILL(av)] = &sv_undef;
 199             while (AvFILL(av) < key);
 200         }
 201         AvFILL(av) = key;
 202     }
 203     else if (AvREAL(av))
 204         SvREFCNT_dec(ary[key]);
 205     ary[key] = val;
 206     if (SvSMAGICAL(av)) {
 207         if (val != &sv_undef) {
 208             MAGIC* mg = SvMAGIC(av);
 209             sv_magic(val, (SV*)av, toLOWER(mg->mg_type), 0, key);
 210         }
 211         mg_set((SV*)av);
 212     }
 213     return &ary[key];
 214 }
 215
 216 AV *
 217 newAV()
 218 {
 219     register AV *av;
 220
 221     av = (AV*)NEWSV(3,0);
 222     sv_upgrade((SV *)av, SVt_PVAV);
 223     AvREAL_on(av);
 224     AvALLOC(av) = 0;
 225     SvPVX(av) = 0;
 226     AvMAX(av) = AvFILL(av) = -1;
 227     return av;
 228 }
 229
 230 AV *
 231 av_make(size,strp)
 232 register I32 size;
 233 register SV **strp;
 234 {
 235     register AV *av;
 236     register I32 i;
 237     register SV** ary;
 238
 239     av = (AV*)NEWSV(8,0);
 240     sv_upgrade((SV *) av,SVt_PVAV);
 241     New(4,ary,size+1,SV*);
 242     AvALLOC(av) = ary;
 243     AvFLAGS(av) = AVf_REAL;
 244     SvPVX(av) = (char*)ary;
 245     AvFILL(av) = size - 1;
 246     AvMAX(av) = size - 1;
 247     for (i = 0; i < size; i++) {
 248         assert (*strp);
 249         ary[i] = NEWSV(7,0);
 250         sv_setsv(ary[i], *strp);
 251         strp++;
 252     }
 253     return av;
 254 }
 255
 256 AV *
 257 av_fake(size,strp)
 258 register I32 size;
 259 register SV **strp;
 260 {
 261     register AV *av;
 262     register SV** ary;
 263
 264     av = (AV*)NEWSV(9,0);
 265     sv_upgrade((SV *)av, SVt_PVAV);
 266     New(4,ary,size+1,SV*);
 267     AvALLOC(av) = ary;
 268     Copy(strp,ary,size,SV*);
 269     AvFLAGS(av) = AVf_REIFY;
 270     SvPVX(av) = (char*)ary;
 271     AvFILL(av) = size - 1;
 272     AvMAX(av) = size - 1;
 273     while (size--) {
 274         assert (*strp);
 275         SvTEMP_off(*strp);
 276         strp++;
 277     }
 278     return av;
 279 }
 280
 281 void
 282 av_clear(av)
 283 register AV *av;
 284 {
 285     register I32 key;
 286     SV** ary;
 287
 288     if (!av || AvMAX(av) < 0)
 289         return;
 290     /*SUPPRESS 560*/
 291
 292     if (AvREAL(av)) {
 293         ary = AvARRAY(av);
 294         key = AvFILL(av) + 1;
 295         while (key) {
 296             SvREFCNT_dec(ary[--key]);
 297             ary[key] = &sv_undef;
 298         }
 299     }
 300     if (key = AvARRAY(av) - AvALLOC(av)) {
 301         AvMAX(av) += key;
 302         SvPVX(av) = (char*)AvALLOC(av);
 303     }
 304     AvFILL(av) = -1;
 305 }
 306
 307 void
 308 av_undef(av)
 309 register AV *av;
 310 {
 311     register I32 key;
 312
 313     if (!av)
 314         return;
 315     /*SUPPRESS 560*/
 316     if (AvREAL(av)) {
 317         key = AvFILL(av) + 1;
 318         while (key)
 319             SvREFCNT_dec(AvARRAY(av)[--key]);
 320     }
 321     if (key = AvARRAY(av) - AvALLOC(av)) {
 322         AvMAX(av) += key;
 323         SvPVX(av) = (char*)AvALLOC(av);
 324     }
 325     Safefree(AvALLOC(av));
 326     AvALLOC(av) = 0;
 327     SvPVX(av) = 0;
 328     AvMAX(av) = AvFILL(av) = -1;
 329     AvREUSED_on(av);    /* Avoid leak of making SVs out of old memory again. */
 330     if (AvARYLEN(av)) {
 331         SvREFCNT_dec(AvARYLEN(av));
 332         AvARYLEN(av) = 0;
 333     }
 334 }
 335
 336 void
 337 av_push(av,val)
 338 register AV *av;
 339 SV *val;
 340 {
 341     if (!av)
 342         return;
 343     av_store(av,AvFILL(av)+1,val);
 344 }
 345
 346 SV *
 347 av_pop(av)
 348 register AV *av;
 349 {
 350     SV *retval;
 351
 352     if (!av || AvFILL(av) < 0)
 353         return &sv_undef;
 354     retval = AvARRAY(av)[AvFILL(av)];
 355     AvARRAY(av)[AvFILL(av)--] = &sv_undef;
 356     if (SvSMAGICAL(av))
 357         mg_set((SV*)av);
 358     return retval;
 359 }
 360
 361 void
 362 av_unshift(av,num)
 363 register AV *av;
 364 register I32 num;
 365 {
 366     register I32 i;
 367     register SV **sstr,**dstr;
 368
 369     if (!av || num <= 0)
 370         return;
 371     if (!AvREAL(av)) {
 372         if (AvREIFY(av))
 373             av_reify(av);
 374         else
 375             croak("Can't unshift");
 376     }
 377     i = AvARRAY(av) - AvALLOC(av);
 378     if (i) {
 379         if (i > num)
 380             i = num;
 381         num -= i;
 382
 383         AvMAX(av) += i;
 384         AvFILL(av) += i;
 385         SvPVX(av) = (char*)(AvARRAY(av) - i);
 386     }
 387     if (num) {
 388         av_extend(av,AvFILL(av)+num);
 389         AvFILL(av) += num;
 390         dstr = AvARRAY(av) + AvFILL(av);
 391         sstr = dstr - num;
 392 #ifdef BUGGY_MSC5
 393  # pragma loop_opt(off) /* don't loop-optimize the following code */
 394 #endif /* BUGGY_MSC5 */
 395         for (i = AvFILL(av) - num; i >= 0; --i) {
 396             *dstr-- = *sstr--;
 397 #ifdef BUGGY_MSC5
 398  # pragma loop_opt()    /* loop-optimization back to command-line setting */
 399 #endif /* BUGGY_MSC5 */
 400         }
 401         while (num)
 402             AvARRAY(av)[--num] = &sv_undef;
 403     }
 404 }
 405
 406 SV *
 407 av_shift(av)
 408 register AV *av;
 409 {
 410     SV *retval;
 411
 412     if (!av || AvFILL(av) < 0)
 413         return &sv_undef;
 414     retval = *AvARRAY(av);
 415     if (AvREAL(av))
 416         *AvARRAY(av) = &sv_undef;
 417     SvPVX(av) = (char*)(AvARRAY(av) + 1);
 418     AvMAX(av)--;
 419     AvFILL(av)--;
 420     if (SvSMAGICAL(av))
 421         mg_set((SV*)av);
 422     return retval;
 423 }
 424
 425 I32
 426 av_len(av)
 427 register AV *av;
 428 {
 429     return AvFILL(av);
 430 }
 431
 432 void
 433 av_fill(av, fill)
 434 register AV *av;
 435 I32 fill;
 436 {
 437     if (!av)
 438         croak("panic: null array");
 439     if (fill < 0)
 440         fill = -1;
 441     if (fill <= AvMAX(av)) {
 442         I32 key = AvFILL(av);
 443         SV** ary = AvARRAY(av);
 444
 445         if (AvREAL(av)) {
 446             while (key > fill) {
 447                 SvREFCNT_dec(ary[key]);
 448                 ary[key--] = &sv_undef;
 449             }
 450         }
 451         else {
 452             while (key < fill)
 453                 ary[++key] = &sv_undef;
 454         }
 455
 456         AvFILL(av) = fill;
 457         if (SvSMAGICAL(av))
 458             mg_set((SV*)av);
 459     }
 460     else
 461         (void)av_store(av,fill,&sv_undef);
 462 }