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