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)
  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     New(4,ary,size+1,SV*);
 260     AvALLOC(av) = ary;
 261     AvFLAGS(av) = AVf_REAL;
 262     SvPVX(av) = (char*)ary;
 263     AvFILL(av) = size - 1;
 264     AvMAX(av) = size - 1;
 265     for (i = 0; i < size; i++) {
 266         assert (*strp);
 267         ary[i] = NEWSV(7,0);
 268         sv_setsv(ary[i], *strp);
 269         strp++;
 270     }
 271     return av;
 272 }
 273
 274 AV *
 275 av_fake(size,strp)
 276 register I32 size;
 277 register SV **strp;
 278 {
 279     register AV *av;
 280     register SV** ary;
 281
 282     av = (AV*)NEWSV(9,0);
 283     sv_upgrade((SV *)av, SVt_PVAV);
 284     New(4,ary,size+1,SV*);
 285     AvALLOC(av) = ary;
 286     Copy(strp,ary,size,SV*);
 287     AvFLAGS(av) = AVf_REIFY;
 288     SvPVX(av) = (char*)ary;
 289     AvFILL(av) = size - 1;
 290     AvMAX(av) = size - 1;
 291     while (size--) {
 292         assert (*strp);
 293         SvTEMP_off(*strp);
 294         strp++;
 295     }
 296     return av;
 297 }
 298
 299 void
 300 av_clear(av)
 301 register AV *av;
 302 {
 303     register I32 key;
 304     SV** ary;
 305
 306 #ifdef DEBUGGING
 307     if (SvREFCNT(av) <= 0) {
 308         warn("Attempt to clear deleted array");
 309     }
 310 #endif
 311     if (!av || AvMAX(av) < 0)
 312         return;
 313     /*SUPPRESS 560*/
 314
 315     if (AvREAL(av)) {
 316         ary = AvARRAY(av);
 317         key = AvFILL(av) + 1;
 318         while (key) {
 319             SvREFCNT_dec(ary[--key]);
 320             ary[key] = &sv_undef;
 321         }
 322     }
 323     if (key = AvARRAY(av) - AvALLOC(av)) {
 324         AvMAX(av) += key;
 325         SvPVX(av) = (char*)AvALLOC(av);
 326     }
 327     AvFILL(av) = -1;
 328 }
 329
 330 void
 331 av_undef(av)
 332 register AV *av;
 333 {
 334     register I32 key;
 335
 336     if (!av)
 337         return;
 338     /*SUPPRESS 560*/
 339     if (AvREAL(av)) {
 340         key = AvFILL(av) + 1;
 341         while (key)
 342             SvREFCNT_dec(AvARRAY(av)[--key]);
 343     }
 344     Safefree(AvALLOC(av));
 345     AvALLOC(av) = 0;
 346     SvPVX(av) = 0;
 347     AvMAX(av) = AvFILL(av) = -1;
 348     if (AvARYLEN(av)) {
 349         SvREFCNT_dec(AvARYLEN(av));
 350         AvARYLEN(av) = 0;
 351     }
 352 }
 353
 354 void
 355 av_push(av,val)
 356 register AV *av;
 357 SV *val;
 358 {
 359     if (!av)
 360         return;
 361     av_store(av,AvFILL(av)+1,val);
 362 }
 363
 364 SV *
 365 av_pop(av)
 366 register AV *av;
 367 {
 368     SV *retval;
 369
 370     if (!av || AvFILL(av) < 0)
 371         return &sv_undef;
 372     if (SvREADONLY(av))
 373         croak(no_modify);
 374     retval = AvARRAY(av)[AvFILL(av)];
 375     AvARRAY(av)[AvFILL(av)--] = &sv_undef;
 376     if (SvSMAGICAL(av))
 377         mg_set((SV*)av);
 378     return retval;
 379 }
 380
 381 void
 382 av_unshift(av,num)
 383 register AV *av;
 384 register I32 num;
 385 {
 386     register I32 i;
 387     register SV **sstr,**dstr;
 388
 389     if (!av || num <= 0)
 390         return;
 391     if (SvREADONLY(av))
 392         croak(no_modify);
 393     if (!AvREAL(av) && AvREIFY(av))
 394         av_reify(av);
 395     i = AvARRAY(av) - AvALLOC(av);
 396     if (i) {
 397         if (i > num)
 398             i = num;
 399         num -= i;
 400
 401         AvMAX(av) += i;
 402         AvFILL(av) += i;
 403         SvPVX(av) = (char*)(AvARRAY(av) - i);
 404     }
 405     if (num) {
 406         av_extend(av,AvFILL(av)+num);
 407         AvFILL(av) += num;
 408         dstr = AvARRAY(av) + AvFILL(av);
 409         sstr = dstr - num;
 410 #ifdef BUGGY_MSC5
 411  # pragma loop_opt(off) /* don't loop-optimize the following code */
 412 #endif /* BUGGY_MSC5 */
 413         for (i = AvFILL(av) - num; i >= 0; --i) {
 414             *dstr-- = *sstr--;
 415 #ifdef BUGGY_MSC5
 416  # pragma loop_opt()    /* loop-optimization back to command-line setting */
 417 #endif /* BUGGY_MSC5 */
 418         }
 419         while (num)
 420             AvARRAY(av)[--num] = &sv_undef;
 421     }
 422 }
 423
 424 SV *
 425 av_shift(av)
 426 register AV *av;
 427 {
 428     SV *retval;
 429
 430     if (!av || AvFILL(av) < 0)
 431         return &sv_undef;
 432     if (SvREADONLY(av))
 433         croak(no_modify);
 434     retval = *AvARRAY(av);
 435     if (AvREAL(av))
 436         *AvARRAY(av) = &sv_undef;
 437     SvPVX(av) = (char*)(AvARRAY(av) + 1);
 438     AvMAX(av)--;
 439     AvFILL(av)--;
 440     if (SvSMAGICAL(av))
 441         mg_set((SV*)av);
 442     return retval;
 443 }
 444
 445 I32
 446 av_len(av)
 447 register AV *av;
 448 {
 449     return AvFILL(av);
 450 }
 451
 452 void
 453 av_fill(av, fill)
 454 register AV *av;
 455 I32 fill;
 456 {
 457     if (!av)
 458         croak("panic: null array");
 459     if (fill < 0)
 460         fill = -1;
 461     if (fill <= AvMAX(av)) {
 462         I32 key = AvFILL(av);
 463         SV** ary = AvARRAY(av);
 464
 465         if (AvREAL(av)) {
 466             while (key > fill) {
 467                 SvREFCNT_dec(ary[key]);
 468                 ary[key--] = &sv_undef;
 469             }
 470         }
 471         else {
 472             while (key < fill)
 473                 ary[++key] = &sv_undef;
 474         }
 475
 476         AvFILL(av) = fill;
 477         if (SvSMAGICAL(av))
 478             mg_set((SV*)av);
 479     }
 480     else
 481         (void)av_store(av,fill,&sv_undef);
 482 }
 483
 484 SV**
 485 avhv_fetch(av, key, klen, lval)
 486 AV *av;
 487 char *key;
 488 U32 klen;
 489 I32 lval;
 490 {
 491     SV **keys, **indsvp;
 492     I32 ind;
 493
 494     keys = av_fetch(av, 0, FALSE);
 495     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 496         croak("Can't coerce array into hash");
 497     indsvp = hv_fetch((HV*)SvRV(*keys), key, klen, FALSE);
 498     if (indsvp) {
 499         ind = SvIV(*indsvp);
 500         if (ind < 1)
 501             croak("Bad index while coercing array into hash");
 502     } else {
 503         if (!lval)
 504             return 0;
 505
 506         ind = AvFILL(av) + 1;
 507         hv_store((HV*)SvRV(*keys), key, klen, newSViv(ind), 0);
 508     }
 509     return av_fetch(av, ind, lval);
 510 }
 511
 512 SV**
 513 avhv_fetch_ent(av, keysv, lval, hash)
 514 AV *av;
 515 SV *keysv;
 516 I32 lval;
 517 U32 hash;
 518 {
 519     SV **keys, **indsvp;
 520     HE *he;
 521     I32 ind;
 522
 523     keys = av_fetch(av, 0, FALSE);
 524     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 525         croak("Can't coerce array into hash");
 526     he = hv_fetch_ent((HV*)SvRV(*keys), keysv, FALSE, hash);
 527     if (he) {
 528         ind = SvIV(HeVAL(he));
 529         if (ind < 1)
 530             croak("Bad index while coercing array into hash");
 531     } else {
 532         if (!lval)
 533             return 0;
 534
 535         ind = AvFILL(av) + 1;
 536         hv_store_ent((HV*)SvRV(*keys), keysv, newSViv(ind), 0);
 537     }
 538     return av_fetch(av, ind, lval);
 539 }
 540
 541 SV**
 542 avhv_store(av, key, klen, val, hash)
 543 AV *av;
 544 char *key;
 545 U32 klen;
 546 SV *val;
 547 U32 hash;
 548 {
 549     SV **keys, **indsvp;
 550     I32 ind;
 551
 552     keys = av_fetch(av, 0, FALSE);
 553     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 554         croak("Can't coerce array into hash");
 555     indsvp = hv_fetch((HV*)SvRV(*keys), key, klen, FALSE);
 556     if (indsvp) {
 557         ind = SvIV(*indsvp);
 558         if (ind < 1)
 559             croak("Bad index while coercing array into hash");
 560     } else {
 561         ind = AvFILL(av) + 1;
 562         hv_store((HV*)SvRV(*keys), key, klen, newSViv(ind), hash);
 563     }
 564     return av_store(av, ind, val);
 565 }
 566
 567 SV**
 568 avhv_store_ent(av, keysv, val, hash)
 569 AV *av;
 570 SV *keysv;
 571 SV *val;
 572 U32 hash;
 573 {
 574     SV **keys;
 575     HE *he;
 576     I32 ind;
 577
 578     keys = av_fetch(av, 0, FALSE);
 579     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 580         croak("Can't coerce array into hash");
 581     he = hv_fetch_ent((HV*)SvRV(*keys), keysv, FALSE, hash);
 582     if (he) {
 583         ind = SvIV(HeVAL(he));
 584         if (ind < 1)
 585             croak("Bad index while coercing array into hash");
 586     } else {
 587         ind = AvFILL(av) + 1;
 588         hv_store_ent((HV*)SvRV(*keys), keysv, newSViv(ind), hash);
 589     }
 590     return av_store(av, ind, val);
 591 }
 592
 593 bool
 594 avhv_exists_ent(av, keysv, hash)
 595 AV *av;
 596 SV *keysv;
 597 U32 hash;
 598 {
 599     SV **keys;
 600
 601     keys = av_fetch(av, 0, FALSE);
 602     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 603         croak("Can't coerce array into hash");
 604     return hv_exists_ent((HV*)SvRV(*keys), keysv, hash);
 605 }
 606
 607 bool
 608 avhv_exists(av, key, klen)
 609 AV *av;
 610 char *key;
 611 U32 klen;
 612 {
 613     SV **keys;
 614
 615     keys = av_fetch(av, 0, FALSE);
 616     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 617         croak("Can't coerce array into hash");
 618     return hv_exists((HV*)SvRV(*keys), key, klen);
 619 }
 620
 621 /* avhv_delete leaks. Caller can re-index and compress if so desired. */
 622 SV *
 623 avhv_delete(av, key, klen, flags)
 624 AV *av;
 625 char *key;
 626 U32 klen;
 627 I32 flags;
 628 {
 629     SV **keys;
 630     SV *sv;
 631     SV **svp;
 632     I32 ind;
 633
 634     keys = av_fetch(av, 0, FALSE);
 635     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 636         croak("Can't coerce array into hash");
 637     sv = hv_delete((HV*)SvRV(*keys), key, klen, 0);
 638     if (!sv)
 639         return Nullsv;
 640     ind = SvIV(sv);
 641     if (ind < 1)
 642         croak("Bad index while coercing array into hash");
 643     svp = av_fetch(av, ind, FALSE);
 644     if (!svp)
 645         return Nullsv;
 646     if (flags & G_DISCARD) {
 647         sv = Nullsv;
 648         SvREFCNT_dec(*svp);
 649     } else {
 650         sv = sv_2mortal(*svp);
 651     }
 652     *svp = &sv_undef;
 653     return sv;
 654 }
 655
 656 /* avhv_delete_ent leaks. Caller can re-index and compress if so desired. */
 657 SV *
 658 avhv_delete_ent(av, keysv, flags, hash)
 659 AV *av;
 660 SV *keysv;
 661 I32 flags;
 662 U32 hash;
 663 {
 664     SV **keys;
 665     SV *sv;
 666     SV **svp;
 667     I32 ind;
 668
 669     keys = av_fetch(av, 0, FALSE);
 670     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 671         croak("Can't coerce array into hash");
 672     sv = hv_delete_ent((HV*)SvRV(*keys), keysv, 0, hash);
 673     if (!sv)
 674         return Nullsv;
 675     ind = SvIV(sv);
 676     if (ind < 1)
 677         croak("Bad index while coercing array into hash");
 678     svp = av_fetch(av, ind, FALSE);
 679     if (!svp)
 680         return Nullsv;
 681     if (flags & G_DISCARD) {
 682         sv = Nullsv;
 683         SvREFCNT_dec(*svp);
 684     } else {
 685         sv = sv_2mortal(*svp);
 686     }
 687     *svp = &sv_undef;
 688     return sv;
 689 }
 690
 691 I32
 692 avhv_iterinit(av)
 693 AV *av;
 694 {
 695     SV **keys;
 696
 697     keys = av_fetch(av, 0, FALSE);
 698     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 699         croak("Can't coerce array into hash");
 700     return hv_iterinit((HV*)SvRV(*keys));
 701 }
 702
 703 HE *
 704 avhv_iternext(av)
 705 AV *av;
 706 {
 707     SV **keys;
 708
 709     keys = av_fetch(av, 0, FALSE);
 710     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 711         croak("Can't coerce array into hash");
 712     return hv_iternext((HV*)SvRV(*keys));
 713 }
 714
 715 SV *
 716 avhv_iterval(av, entry)
 717 AV *av;
 718 register HE *entry;
 719 {
 720     SV **keys;
 721     SV *sv;
 722     I32 ind;
 723
 724     keys = av_fetch(av, 0, FALSE);
 725     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 726         croak("Can't coerce array into hash");
 727     sv = hv_iterval((HV*)SvRV(*keys), entry);
 728     ind = SvIV(sv);
 729     if (ind < 1)
 730         croak("Bad index while coercing array into hash");
 731     return *av_fetch(av, ind, TRUE);
 732 }
 733
 734 SV *
 735 avhv_iternextsv(av, key, retlen)
 736 AV *av;
 737 char **key;
 738 I32 *retlen;
 739 {
 740     SV **keys;
 741     HE *he;
 742     SV *sv;
 743     I32 ind;
 744
 745     keys = av_fetch(av, 0, FALSE);
 746     if (!keys || !SvROK(*keys) || SvTYPE(SvRV(*keys)) != SVt_PVHV)
 747         croak("Can't coerce array into hash");
 748     if ( (he = hv_iternext((HV*)SvRV(*keys))) == NULL)
 749         return NULL;
 750     *key = hv_iterkey(he, retlen);
 751     sv = hv_iterval((HV*)SvRV(*keys), he);
 752     ind = SvIV(sv);
 753     if (ind < 1)
 754         croak("Bad index while coercing array into hash");
 755     return *av_fetch(av, ind, TRUE);
 756 }