av.c

   1 /*    av.c
   2  *
   3  *    Copyright (c) 1991-1997, 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 void
  19 av_reify(av)
  20 AV* av;
  21 {
  22     I32 key;
  23     SV* sv;
  24
  25     if (AvREAL(av))
  26         return;
  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             dTHR;
  35             (void)SvREFCNT_inc(sv);
  36         }
  37     }
  38     key = AvARRAY(av) - AvALLOC(av);
  39     while (key)
  40         AvALLOC(av)[--key] = &sv_undef;
  41     AvREAL_on(av);
  42 }
  43
  44 void
  45 av_extend(av,key)
  46 AV *av;
  47 I32 key;
  48 {
  49     dTHR;                       /* only necessary if we have to extend stack */
  50     if (key > AvMAX(av)) {
  51         SV** ary;
  52         I32 tmp;
  53         I32 newmax;
  54
  55         if (AvALLOC(av) != AvARRAY(av)) {
  56             ary = AvALLOC(av) + AvFILL(av) + 1;
  57             tmp = AvARRAY(av) - AvALLOC(av);
  58             Move(AvARRAY(av), AvALLOC(av), AvFILL(av)+1, SV*);
  59             AvMAX(av) += tmp;
  60             SvPVX(av) = (char*)AvALLOC(av);
  61             if (AvREAL(av)) {
  62                 while (tmp)
  63                     ary[--tmp] = &sv_undef;
  64             }
  65
  66             if (key > AvMAX(av) - 10) {
  67                 newmax = key + AvMAX(av);
  68                 goto resize;
  69             }
  70         }
  71         else {
  72             if (AvALLOC(av)) {
  73 #ifndef STRANGE_MALLOC
  74                 U32 bytes;
  75 #endif
  76
  77                 newmax = key + AvMAX(av) / 5;
  78               resize:
  79 #ifdef STRANGE_MALLOC
  80                 Renew(AvALLOC(av),newmax+1, SV*);
  81 #else
  82                 bytes = (newmax + 1) * sizeof(SV*);
  83 #define MALLOC_OVERHEAD 16
  84                 tmp = MALLOC_OVERHEAD;
  85                 while (tmp - MALLOC_OVERHEAD < bytes)
  86                     tmp += tmp;
  87                 tmp -= MALLOC_OVERHEAD;
  88                 tmp /= sizeof(SV*);
  89                 assert(tmp > newmax);
  90                 newmax = tmp - 1;
  91                 New(2,ary, newmax+1, SV*);
  92                 Copy(AvALLOC(av), ary, AvMAX(av)+1, SV*);
  93                 if (AvMAX(av) > 64)
  94                     offer_nice_chunk(AvALLOC(av), (AvMAX(av)+1) * sizeof(SV*));
  95                 else
  96                     Safefree(AvALLOC(av));
  97                 AvALLOC(av) = ary;
  98 #endif
  99                 ary = AvALLOC(av) + AvMAX(av) + 1;
 100                 tmp = newmax - AvMAX(av);
 101                 if (av == curstack) {   /* Oops, grew stack (via av_store()?) */
 102                     stack_sp = AvALLOC(av) + (stack_sp - stack_base);
 103                     stack_base = AvALLOC(av);
 104                     stack_max = stack_base + newmax;
 105                 }
 106             }
 107             else {
 108                 newmax = key < 4 ? 4 : key;
 109                 New(2,AvALLOC(av), newmax+1, SV*);
 110                 ary = AvALLOC(av) + 1;
 111                 tmp = newmax;
 112                 AvALLOC(av)[0] = &sv_undef;     /* For the stacks */
 113             }
 114             if (AvREAL(av)) {
 115                 while (tmp)
 116                     ary[--tmp] = &sv_undef;
 117             }
 118
 119             SvPVX(av) = (char*)AvALLOC(av);
 120             AvMAX(av) = newmax;
 121         }
 122     }
 123 }
 124
 125 SV**
 126 av_fetch(av,key,lval)
 127 register AV *av;
 128 I32 key;
 129 I32 lval;
 130 {
 131     SV *sv;
 132
 133     if (!av)
 134         return 0;
 135
 136     if (SvRMAGICAL(av)) {
 137         if (mg_find((SV*)av,'P')) {
 138             dTHR;
 139             sv = sv_newmortal();
 140             mg_copy((SV*)av, sv, 0, key);
 141             Sv = sv;
 142             return &Sv;
 143         }
 144     }
 145
 146     if (key < 0) {
 147         key += AvFILL(av) + 1;
 148         if (key < 0)
 149             return 0;
 150     }
 151     else if (key > AvFILL(av)) {
 152         if (!lval)
 153             return 0;
 154         if (AvREALISH(av))
 155             sv = NEWSV(5,0);
 156         else
 157             sv = sv_newmortal();
 158         return av_store(av,key,sv);
 159     }
 160     if (AvARRAY(av)[key] == &sv_undef) {
 161     emptyness:
 162         if (lval) {
 163             sv = NEWSV(6,0);
 164             return av_store(av,key,sv);
 165         }
 166         return 0;
 167     }
 168     else if (AvREIFY(av)
 169              && (!AvARRAY(av)[key]      /* eg. @_ could have freed elts */
 170                  || SvTYPE(AvARRAY(av)[key]) == SVTYPEMASK)) {
 171         AvARRAY(av)[key] = &sv_undef;   /* 1/2 reify */
 172         goto emptyness;
 173     }
 174     return &AvARRAY(av)[key];
 175 }
 176
 177 SV**
 178 av_store(av,key,val)
 179 register AV *av;
 180 I32 key;
 181 SV *val;
 182 {
 183     SV** ary;
 184
 185     if (!av)
 186         return 0;
 187     if (!val)
 188         val = &sv_undef;
 189
 190     if (SvRMAGICAL(av)) {
 191         if (mg_find((SV*)av,'P')) {
 192             if (val != &sv_undef)
 193                 mg_copy((SV*)av, val, 0, key);
 194             return 0;
 195         }
 196     }
 197
 198     if (key < 0) {
 199         key += AvFILL(av) + 1;
 200         if (key < 0)
 201             return 0;
 202     }
 203     if (SvREADONLY(av) && key >= AvFILL(av))
 204         croak(no_modify);
 205     if (!AvREAL(av) && AvREIFY(av))
 206         av_reify(av);
 207     if (key > AvMAX(av))
 208         av_extend(av,key);
 209     ary = AvARRAY(av);
 210     if (AvFILL(av) < key) {
 211         if (!AvREAL(av)) {
 212             dTHR;
 213             if (av == curstack && key > stack_sp - stack_base)
 214                 stack_sp = stack_base + key;    /* XPUSH in disguise */
 215             do
 216                 ary[++AvFILL(av)] = &sv_undef;
 217             while (AvFILL(av) < key);
 218         }
 219         AvFILL(av) = key;
 220     }
 221     else if (AvREAL(av))
 222         SvREFCNT_dec(ary[key]);
 223     ary[key] = val;
 224     if (SvSMAGICAL(av)) {
 225         if (val != &sv_undef) {
 226             MAGIC* mg = SvMAGIC(av);
 227             sv_magic(val, (SV*)av, toLOWER(mg->mg_type), 0, key);
 228         }
 229         mg_set((SV*)av);
 230     }
 231     return &ary[key];
 232 }
 233
 234 AV *
 235 newAV()
 236 {
 237     register AV *av;
 238
 239     av = (AV*)NEWSV(3,0);
 240     sv_upgrade((SV *)av, SVt_PVAV);
 241     AvREAL_on(av);
 242     AvALLOC(av) = 0;
 243     SvPVX(av) = 0;
 244     AvMAX(av) = AvFILL(av) = -1;
 245     return av;
 246 }
 247
 248 AV *
 249 av_make(size,strp)
 250 register I32 size;
 251 register SV **strp;
 252 {
 253     register AV *av;
 254     register I32 i;
 255     register SV** ary;
 256
 257     av = (AV*)NEWSV(8,0);
 258     sv_upgrade((SV *) av,SVt_PVAV);
 259     AvFLAGS(av) = AVf_REAL;
 260     if (size) {         /* `defined' was returning undef for size==0 anyway. */
 261         New(4,ary,size,SV*);
 262         AvALLOC(av) = ary;
 263         SvPVX(av) = (char*)ary;
 264         AvFILL(av) = size - 1;
 265         AvMAX(av) = size - 1;
 266         for (i = 0; i < size; i++) {
 267             assert (*strp);
 268             ary[i] = NEWSV(7,0);
 269             sv_setsv(ary[i], *strp);
 270             strp++;
 271         }
 272     }
 273     return av;
 274 }
 275
 276 AV *
 277 av_fake(size,strp)
 278 register I32 size;
 279 register SV **strp;
 280 {
 281     register AV *av;
 282     register SV** ary;
 283
 284     av = (AV*)NEWSV(9,0);
 285     sv_upgrade((SV *)av, SVt_PVAV);
 286     New(4,ary,size+1,SV*);
 287     AvALLOC(av) = ary;
 288     Copy(strp,ary,size,SV*);
 289     AvFLAGS(av) = AVf_REIFY;
 290     SvPVX(av) = (char*)ary;
 291     AvFILL(av) = size - 1;
 292     AvMAX(av) = size - 1;
 293     while (size--) {
 294         assert (*strp);
 295         SvTEMP_off(*strp);
 296         strp++;
 297     }
 298     return av;
 299 }
 300
 301 void
 302 av_clear(av)
 303 register AV *av;
 304 {
 305     register I32 key;
 306     SV** ary;
 307
 308 #ifdef DEBUGGING
 309     if (SvREFCNT(av) <= 0) {
 310         warn("Attempt to clear deleted array");
 311     }
 312 #endif
 313     if (!av || AvMAX(av) < 0)
 314         return;
 315     /*SUPPRESS 560*/
 316
 317     if (AvREAL(av)) {
 318         ary = AvARRAY(av);
 319         key = AvFILL(av) + 1;
 320         while (key) {
 321             SvREFCNT_dec(ary[--key]);
 322             ary[key] = &sv_undef;
 323         }
 324     }
 325     if (key = AvARRAY(av) - AvALLOC(av)) {
 326         AvMAX(av) += key;
 327         SvPVX(av) = (char*)AvALLOC(av);
 328     }
 329     AvFILL(av) = -1;
 330
 331     if (SvRMAGICAL(av))
 332         mg_clear((SV*)av);
 333 }
 334
 335 void
 336 av_undef(av)
 337 register AV *av;
 338 {
 339     register I32 key;
 340
 341     if (!av)
 342         return;
 343     /*SUPPRESS 560*/
 344     if (AvREAL(av)) {
 345         key = AvFILL(av) + 1;
 346         while (key)
 347             SvREFCNT_dec(AvARRAY(av)[--key]);
 348     }
 349     Safefree(AvALLOC(av));
 350     AvALLOC(av) = 0;
 351     SvPVX(av) = 0;
 352     AvMAX(av) = AvFILL(av) = -1;
 353     if (AvARYLEN(av)) {
 354         SvREFCNT_dec(AvARYLEN(av));
 355         AvARYLEN(av) = 0;
 356     }
 357 }
 358
 359 void
 360 av_push(av,val)
 361 register AV *av;
 362 SV *val;
 363 {
 364     if (!av)
 365         return;
 366     av_store(av,AvFILL(av)+1,val);
 367 }
 368
 369 SV *
 370 av_pop(av)
 371 register AV *av;
 372 {
 373     SV *retval;
 374
 375     if (!av || AvFILL(av) < 0)
 376         return &sv_undef;
 377     if (SvREADONLY(av))
 378         croak(no_modify);
 379     retval = AvARRAY(av)[AvFILL(av)];
 380     AvARRAY(av)[AvFILL(av)--] = &sv_undef;
 381     if (SvSMAGICAL(av))
 382         mg_set((SV*)av);
 383     return retval;
 384 }
 385
 386 void
 387 av_unshift(av,num)
 388 register AV *av;
 389 register I32 num;
 390 {
 391     register I32 i;
 392     register SV **sstr,**dstr;
 393
 394     if (!av || num <= 0)
 395         return;
 396     if (SvREADONLY(av))
 397         croak(no_modify);
 398     if (!AvREAL(av) && AvREIFY(av))
 399         av_reify(av);
 400     i = AvARRAY(av) - AvALLOC(av);
 401     if (i) {
 402         if (i > num)
 403             i = num;
 404         num -= i;
 405
 406         AvMAX(av) += i;
 407         AvFILL(av) += i;
 408         SvPVX(av) = (char*)(AvARRAY(av) - i);
 409     }
 410     if (num) {
 411         av_extend(av,AvFILL(av)+num);
 412         AvFILL(av) += num;
 413         dstr = AvARRAY(av) + AvFILL(av);
 414         sstr = dstr - num;
 415 #ifdef BUGGY_MSC5
 416  # pragma loop_opt(off) /* don't loop-optimize the following code */
 417 #endif /* BUGGY_MSC5 */
 418         for (i = AvFILL(av) - num; i >= 0; --i) {
 419             *dstr-- = *sstr--;
 420 #ifdef BUGGY_MSC5
 421  # pragma loop_opt()    /* loop-optimization back to command-line setting */
 422 #endif /* BUGGY_MSC5 */
 423         }
 424         while (num)
 425             AvARRAY(av)[--num] = &sv_undef;
 426     }
 427 }
 428
 429 SV *
 430 av_shift(av)
 431 register AV *av;
 432 {
 433     SV *retval;
 434
 435     if (!av || AvFILL(av) < 0)
 436         return &sv_undef;
 437     if (SvREADONLY(av))
 438         croak(no_modify);
 439     retval = *AvARRAY(av);
 440     if (AvREAL(av))
 441         *AvARRAY(av) = &sv_undef;
 442     SvPVX(av) = (char*)(AvARRAY(av) + 1);
 443     AvMAX(av)--;
 444     AvFILL(av)--;
 445     if (SvSMAGICAL(av))
 446         mg_set((SV*)av);
 447     return retval;
 448 }
 449
 450 I32
 451 av_len(av)
 452 register AV *av;
 453 {
 454     return AvFILL(av);
 455 }
 456
 457 void
 458 av_fill(av, fill)
 459 register AV *av;
 460 I32 fill;
 461 {
 462     if (!av)
 463         croak("panic: null array");
 464     if (fill < 0)
 465         fill = -1;
 466     if (fill <= AvMAX(av)) {
 467         I32 key = AvFILL(av);
 468         SV** ary = AvARRAY(av);
 469
 470         if (AvREAL(av)) {
 471             while (key > fill) {
 472                 SvREFCNT_dec(ary[key]);
 473                 ary[key--] = &sv_undef;
 474             }
 475         }
 476         else {
 477             while (key < fill)
 478                 ary[++key] = &sv_undef;
 479         }
 480
 481         AvFILL(av) = fill;
 482         if (SvSMAGICAL(av))
 483             mg_set((SV*)av);
 484     }
 485     else
 486         (void)av_store(av,fill,&sv_undef);
 487 }
 488
 489 SV**
 490 avhv_fetch(av, key, klen, lval)
 491 AV *av;
 492 char *key;
 493 U32 klen;
 494 I32 lval;
 495 {
 496     SV **keys, **indsvp;
 497     I32 ind;
 498
 499     keys = av_fetch(av, 0, FALSE);
 500     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 501         croak("Can't coerce array into hash");
 502     indsvp = hv_fetch((HV*)SvRV(*keys), key, klen, FALSE);
 503     if (indsvp) {
 504         ind = SvIV(*indsvp);
 505         if (ind < 1)
 506             croak("Bad index while coercing array into hash");
 507     } else {
 508         if (!lval)
 509             return 0;
 510
 511         ind = AvFILL(av) + 1;
 512         hv_store((HV*)SvRV(*keys), key, klen, newSViv(ind), 0);
 513     }
 514     return av_fetch(av, ind, lval);
 515 }
 516
 517 SV**
 518 avhv_fetch_ent(av, keysv, lval, hash)
 519 AV *av;
 520 SV *keysv;
 521 I32 lval;
 522 U32 hash;
 523 {
 524     SV **keys, **indsvp;
 525     HE *he;
 526     I32 ind;
 527
 528     keys = av_fetch(av, 0, FALSE);
 529     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 530         croak("Can't coerce array into hash");
 531     he = hv_fetch_ent((HV*)SvRV(*keys), keysv, FALSE, hash);
 532     if (he) {
 533         ind = SvIV(HeVAL(he));
 534         if (ind < 1)
 535             croak("Bad index while coercing array into hash");
 536     } else {
 537         if (!lval)
 538             return 0;
 539
 540         ind = AvFILL(av) + 1;
 541         hv_store_ent((HV*)SvRV(*keys), keysv, newSViv(ind), 0);
 542     }
 543     return av_fetch(av, ind, lval);
 544 }
 545
 546 SV**
 547 avhv_store(av, key, klen, val, hash)
 548 AV *av;
 549 char *key;
 550 U32 klen;
 551 SV *val;
 552 U32 hash;
 553 {
 554     SV **keys, **indsvp;
 555     I32 ind;
 556
 557     keys = av_fetch(av, 0, FALSE);
 558     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 559         croak("Can't coerce array into hash");
 560     indsvp = hv_fetch((HV*)SvRV(*keys), key, klen, FALSE);
 561     if (indsvp) {
 562         ind = SvIV(*indsvp);
 563         if (ind < 1)
 564             croak("Bad index while coercing array into hash");
 565     } else {
 566         ind = AvFILL(av) + 1;
 567         hv_store((HV*)SvRV(*keys), key, klen, newSViv(ind), hash);
 568     }
 569     return av_store(av, ind, val);
 570 }
 571
 572 SV**
 573 avhv_store_ent(av, keysv, val, hash)
 574 AV *av;
 575 SV *keysv;
 576 SV *val;
 577 U32 hash;
 578 {
 579     SV **keys;
 580     HE *he;
 581     I32 ind;
 582
 583     keys = av_fetch(av, 0, FALSE);
 584     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 585         croak("Can't coerce array into hash");
 586     he = hv_fetch_ent((HV*)SvRV(*keys), keysv, FALSE, hash);
 587     if (he) {
 588         ind = SvIV(HeVAL(he));
 589         if (ind < 1)
 590             croak("Bad index while coercing array into hash");
 591     } else {
 592         ind = AvFILL(av) + 1;
 593         hv_store_ent((HV*)SvRV(*keys), keysv, newSViv(ind), hash);
 594     }
 595     return av_store(av, ind, val);
 596 }
 597
 598 bool
 599 avhv_exists_ent(av, keysv, hash)
 600 AV *av;
 601 SV *keysv;
 602 U32 hash;
 603 {
 604     SV **keys;
 605
 606     keys = av_fetch(av, 0, FALSE);
 607     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 608         croak("Can't coerce array into hash");
 609     return hv_exists_ent((HV*)SvRV(*keys), keysv, hash);
 610 }
 611
 612 bool
 613 avhv_exists(av, key, klen)
 614 AV *av;
 615 char *key;
 616 U32 klen;
 617 {
 618     SV **keys;
 619
 620     keys = av_fetch(av, 0, FALSE);
 621     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 622         croak("Can't coerce array into hash");
 623     return hv_exists((HV*)SvRV(*keys), key, klen);
 624 }
 625
 626 /* avhv_delete leaks. Caller can re-index and compress if so desired. */
 627 SV *
 628 avhv_delete(av, key, klen, flags)
 629 AV *av;
 630 char *key;
 631 U32 klen;
 632 I32 flags;
 633 {
 634     SV **keys;
 635     SV *sv;
 636     SV **svp;
 637     I32 ind;
 638
 639     keys = av_fetch(av, 0, FALSE);
 640     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 641         croak("Can't coerce array into hash");
 642     sv = hv_delete((HV*)SvRV(*keys), key, klen, 0);
 643     if (!sv)
 644         return Nullsv;
 645     ind = SvIV(sv);
 646     if (ind < 1)
 647         croak("Bad index while coercing array into hash");
 648     svp = av_fetch(av, ind, FALSE);
 649     if (!svp)
 650         return Nullsv;
 651     if (flags & G_DISCARD) {
 652         sv = Nullsv;
 653         SvREFCNT_dec(*svp);
 654     } else {
 655         sv = sv_2mortal(*svp);
 656     }
 657     *svp = &sv_undef;
 658     return sv;
 659 }
 660
 661 /* avhv_delete_ent leaks. Caller can re-index and compress if so desired. */
 662 SV *
 663 avhv_delete_ent(av, keysv, flags, hash)
 664 AV *av;
 665 SV *keysv;
 666 I32 flags;
 667 U32 hash;
 668 {
 669     SV **keys;
 670     SV *sv;
 671     SV **svp;
 672     I32 ind;
 673
 674     keys = av_fetch(av, 0, FALSE);
 675     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 676         croak("Can't coerce array into hash");
 677     sv = hv_delete_ent((HV*)SvRV(*keys), keysv, 0, hash);
 678     if (!sv)
 679         return Nullsv;
 680     ind = SvIV(sv);
 681     if (ind < 1)
 682         croak("Bad index while coercing array into hash");
 683     svp = av_fetch(av, ind, FALSE);
 684     if (!svp)
 685         return Nullsv;
 686     if (flags & G_DISCARD) {
 687         sv = Nullsv;
 688         SvREFCNT_dec(*svp);
 689     } else {
 690         sv = sv_2mortal(*svp);
 691     }
 692     *svp = &sv_undef;
 693     return sv;
 694 }
 695
 696 I32
 697 avhv_iterinit(av)
 698 AV *av;
 699 {
 700     SV **keys;
 701
 702     keys = av_fetch(av, 0, FALSE);
 703     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 704         croak("Can't coerce array into hash");
 705     return hv_iterinit((HV*)SvRV(*keys));
 706 }
 707
 708 HE *
 709 avhv_iternext(av)
 710 AV *av;
 711 {
 712     SV **keys;
 713
 714     keys = av_fetch(av, 0, FALSE);
 715     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 716         croak("Can't coerce array into hash");
 717     return hv_iternext((HV*)SvRV(*keys));
 718 }
 719
 720 SV *
 721 avhv_iterval(av, entry)
 722 AV *av;
 723 register HE *entry;
 724 {
 725     SV **keys;
 726     SV *sv;
 727     I32 ind;
 728
 729     keys = av_fetch(av, 0, FALSE);
 730     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 731         croak("Can't coerce array into hash");
 732     sv = hv_iterval((HV*)SvRV(*keys), entry);
 733     ind = SvIV(sv);
 734     if (ind < 1)
 735         croak("Bad index while coercing array into hash");
 736     return *av_fetch(av, ind, TRUE);
 737 }
 738
 739 SV *
 740 avhv_iternextsv(av, key, retlen)
 741 AV *av;
 742 char **key;
 743 I32 *retlen;
 744 {
 745     SV **keys;
 746     HE *he;
 747     SV *sv;
 748     I32 ind;
 749
 750     keys = av_fetch(av, 0, FALSE);
 751     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 752         croak("Can't coerce array into hash");
 753     if ( (he = hv_iternext((HV*)SvRV(*keys))) == NULL)
 754         return NULL;
 755     *key = hv_iterkey(he, retlen);
 756     sv = hv_iterval((HV*)SvRV(*keys), he);
 757     ind = SvIV(sv);
 758     if (ind < 1)
 759         croak("Bad index while coercing array into hash");
 760     return *av_fetch(av, ind, TRUE);
 761 }