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                 newmax = key + AvMAX(av) / 5;
  68               resize:
  69                 Renew(AvALLOC(av),newmax+1, SV*);
  70                 ary = AvALLOC(av) + AvMAX(av) + 1;
  71                 tmp = newmax - AvMAX(av);
  72                 if (av == stack) {      /* Oops, grew stack (via av_store()?) */
  73                     stack_sp = AvALLOC(av) + (stack_sp - stack_base);
  74                     stack_base = AvALLOC(av);
  75                     stack_max = stack_base + newmax;
  76                 }
  77             }
  78             else {
  79                 newmax = key < 4 ? 4 : key;
  80                 New(2,AvALLOC(av), newmax+1, SV*);
  81                 ary = AvALLOC(av) + 1;
  82                 tmp = newmax;
  83                 AvALLOC(av)[0] = &sv_undef;     /* For the stacks */
  84             }
  85             if (AvREAL(av)) {
  86                 while (tmp)
  87                     ary[--tmp] = &sv_undef;
  88             }
  89
  90             SvPVX(av) = (char*)AvALLOC(av);
  91             AvMAX(av) = newmax;
  92         }
  93     }
  94 }
  95
  96 SV**
  97 av_fetch(av,key,lval)
  98 register AV *av;
  99 I32 key;
 100 I32 lval;
 101 {
 102     SV *sv;
 103
 104     if (!av)
 105         return 0;
 106
 107     if (SvRMAGICAL(av)) {
 108         if (mg_find((SV*)av,'P')) {
 109             sv = sv_newmortal();
 110             mg_copy((SV*)av, sv, 0, key);
 111             Sv = sv;
 112             return &Sv;
 113         }
 114     }
 115
 116     if (key < 0) {
 117         key += AvFILL(av) + 1;
 118         if (key < 0)
 119             return 0;
 120     }
 121     else if (key > AvFILL(av)) {
 122         if (!lval)
 123             return 0;
 124         if (AvREALISH(av))
 125             sv = NEWSV(5,0);
 126         else
 127             sv = sv_newmortal();
 128         return av_store(av,key,sv);
 129     }
 130     if (AvARRAY(av)[key] == &sv_undef) {
 131         if (lval) {
 132             sv = NEWSV(6,0);
 133             return av_store(av,key,sv);
 134         }
 135         return 0;
 136     }
 137     return &AvARRAY(av)[key];
 138 }
 139
 140 SV**
 141 av_store(av,key,val)
 142 register AV *av;
 143 I32 key;
 144 SV *val;
 145 {
 146     SV** ary;
 147
 148     if (!av)
 149         return 0;
 150
 151     if (SvRMAGICAL(av)) {
 152         if (mg_find((SV*)av,'P')) {
 153             mg_copy((SV*)av, val, 0, key);
 154             return 0;
 155         }
 156     }
 157
 158     if (key < 0) {
 159         key += AvFILL(av) + 1;
 160         if (key < 0)
 161             return 0;
 162     }
 163     if (!val)
 164         val = &sv_undef;
 165
 166     if (key > AvMAX(av))
 167         av_extend(av,key);
 168     if (AvREIFY(av))
 169         av_reify(av);
 170
 171     ary = AvARRAY(av);
 172     if (AvFILL(av) < key) {
 173         if (!AvREAL(av)) {
 174             if (av == stack && key > stack_sp - stack_base)
 175                 stack_sp = stack_base + key;    /* XPUSH in disguise */
 176             do
 177                 ary[++AvFILL(av)] = &sv_undef;
 178             while (AvFILL(av) < key);
 179         }
 180         AvFILL(av) = key;
 181     }
 182     else if (AvREAL(av))
 183         SvREFCNT_dec(ary[key]);
 184     ary[key] = val;
 185     if (SvSMAGICAL(av)) {
 186         if (val != &sv_undef) {
 187             MAGIC* mg = SvMAGIC(av);
 188             sv_magic(val, (SV*)av, toLOWER(mg->mg_type), 0, key);
 189         }
 190         mg_set((SV*)av);
 191     }
 192     return &ary[key];
 193 }
 194
 195 AV *
 196 newAV()
 197 {
 198     register AV *av;
 199
 200     av = (AV*)NEWSV(3,0);
 201     sv_upgrade((SV *)av, SVt_PVAV);
 202     AvREAL_on(av);
 203     AvALLOC(av) = 0;
 204     SvPVX(av) = 0;
 205     AvMAX(av) = AvFILL(av) = -1;
 206     return av;
 207 }
 208
 209 AV *
 210 av_make(size,strp)
 211 register I32 size;
 212 register SV **strp;
 213 {
 214     register AV *av;
 215     register I32 i;
 216     register SV** ary;
 217
 218     av = (AV*)NEWSV(8,0);
 219     sv_upgrade((SV *) av,SVt_PVAV);
 220     New(4,ary,size+1,SV*);
 221     AvALLOC(av) = ary;
 222     AvFLAGS(av) = AVf_REAL;
 223     SvPVX(av) = (char*)ary;
 224     AvFILL(av) = size - 1;
 225     AvMAX(av) = size - 1;
 226     for (i = 0; i < size; i++) {
 227         assert (*strp);
 228         ary[i] = NEWSV(7,0);
 229         sv_setsv(ary[i], *strp);
 230         strp++;
 231     }
 232     return av;
 233 }
 234
 235 AV *
 236 av_fake(size,strp)
 237 register I32 size;
 238 register SV **strp;
 239 {
 240     register AV *av;
 241     register SV** ary;
 242
 243     av = (AV*)NEWSV(9,0);
 244     sv_upgrade((SV *)av, SVt_PVAV);
 245     New(4,ary,size+1,SV*);
 246     AvALLOC(av) = ary;
 247     Copy(strp,ary,size,SV*);
 248     AvFLAGS(av) = AVf_REIFY;
 249     SvPVX(av) = (char*)ary;
 250     AvFILL(av) = size - 1;
 251     AvMAX(av) = size - 1;
 252     while (size--) {
 253         assert (*strp);
 254         SvTEMP_off(*strp);
 255         strp++;
 256     }
 257     return av;
 258 }
 259
 260 void
 261 av_clear(av)
 262 register AV *av;
 263 {
 264     register I32 key;
 265     SV** ary;
 266
 267     if (!av || AvMAX(av) < 0)
 268         return;
 269     /*SUPPRESS 560*/
 270
 271     if (AvREAL(av)) {
 272         ary = AvARRAY(av);
 273         key = AvFILL(av) + 1;
 274         while (key) {
 275             SvREFCNT_dec(ary[--key]);
 276             ary[key] = &sv_undef;
 277         }
 278     }
 279     if (key = AvARRAY(av) - AvALLOC(av)) {
 280         AvMAX(av) += key;
 281         SvPVX(av) = (char*)AvALLOC(av);
 282     }
 283     AvFILL(av) = -1;
 284 }
 285
 286 void
 287 av_undef(av)
 288 register AV *av;
 289 {
 290     register I32 key;
 291
 292     if (!av)
 293         return;
 294     /*SUPPRESS 560*/
 295     if (AvREAL(av)) {
 296         key = AvFILL(av) + 1;
 297         while (key)
 298             SvREFCNT_dec(AvARRAY(av)[--key]);
 299     }
 300     if (key = AvARRAY(av) - AvALLOC(av)) {
 301         AvMAX(av) += key;
 302         SvPVX(av) = (char*)AvALLOC(av);
 303     }
 304     Safefree(AvALLOC(av));
 305     AvALLOC(av) = 0;
 306     SvPVX(av) = 0;
 307     AvMAX(av) = AvFILL(av) = -1;
 308     if (AvARYLEN(av)) {
 309         SvREFCNT_dec(AvARYLEN(av));
 310         AvARYLEN(av) = 0;
 311     }
 312 }
 313
 314 void
 315 av_push(av,val)
 316 register AV *av;
 317 SV *val;
 318 {
 319     if (!av)
 320         return;
 321     av_store(av,AvFILL(av)+1,val);
 322 }
 323
 324 SV *
 325 av_pop(av)
 326 register AV *av;
 327 {
 328     SV *retval;
 329
 330     if (!av || AvFILL(av) < 0)
 331         return &sv_undef;
 332     retval = AvARRAY(av)[AvFILL(av)];
 333     AvARRAY(av)[AvFILL(av)--] = &sv_undef;
 334     if (SvSMAGICAL(av))
 335         mg_set((SV*)av);
 336     return retval;
 337 }
 338
 339 void
 340 av_unshift(av,num)
 341 register AV *av;
 342 register I32 num;
 343 {
 344     register I32 i;
 345     register SV **sstr,**dstr;
 346
 347     if (!av || num <= 0)
 348         return;
 349     if (!AvREAL(av)) {
 350         if (AvREIFY(av))
 351             av_reify(av);
 352         else
 353             croak("Can't unshift");
 354     }
 355     i = AvARRAY(av) - AvALLOC(av);
 356     if (i) {
 357         if (i > num)
 358             i = num;
 359         num -= i;
 360
 361         AvMAX(av) += i;
 362         AvFILL(av) += i;
 363         SvPVX(av) = (char*)(AvARRAY(av) - i);
 364     }
 365     if (num) {
 366         av_extend(av,AvFILL(av)+num);
 367         AvFILL(av) += num;
 368         dstr = AvARRAY(av) + AvFILL(av);
 369         sstr = dstr - num;
 370 #ifdef BUGGY_MSC5
 371  # pragma loop_opt(off) /* don't loop-optimize the following code */
 372 #endif /* BUGGY_MSC5 */
 373         for (i = AvFILL(av) - num; i >= 0; --i) {
 374             *dstr-- = *sstr--;
 375 #ifdef BUGGY_MSC5
 376  # pragma loop_opt()    /* loop-optimization back to command-line setting */
 377 #endif /* BUGGY_MSC5 */
 378         }
 379         while (num)
 380             AvARRAY(av)[--num] = &sv_undef;
 381     }
 382 }
 383
 384 SV *
 385 av_shift(av)
 386 register AV *av;
 387 {
 388     SV *retval;
 389
 390     if (!av || AvFILL(av) < 0)
 391         return &sv_undef;
 392     retval = *AvARRAY(av);
 393     if (AvREAL(av))
 394         *AvARRAY(av) = &sv_undef;
 395     SvPVX(av) = (char*)(AvARRAY(av) + 1);
 396     AvMAX(av)--;
 397     AvFILL(av)--;
 398     if (SvSMAGICAL(av))
 399         mg_set((SV*)av);
 400     return retval;
 401 }
 402
 403 I32
 404 av_len(av)
 405 register AV *av;
 406 {
 407     return AvFILL(av);
 408 }
 409
 410 void
 411 av_fill(av, fill)
 412 register AV *av;
 413 I32 fill;
 414 {
 415     if (!av)
 416         croak("panic: null array");
 417     if (fill < 0)
 418         fill = -1;
 419     if (fill <= AvMAX(av)) {
 420         I32 key = AvFILL(av);
 421         SV** ary = AvARRAY(av);
 422
 423         if (AvREAL(av)) {
 424             while (key > fill) {
 425                 SvREFCNT_dec(ary[key]);
 426                 ary[key--] = &sv_undef;
 427             }
 428         }
 429         else {
 430             while (key < fill)
 431                 ary[++key] = &sv_undef;
 432         }
 433
 434         AvFILL(av) = fill;
 435         if (SvSMAGICAL(av))
 436             mg_set((SV*)av);
 437     }
 438     else
 439         (void)av_store(av,fill,&sv_undef);
 440 }