doop.c

   1 /*    doop.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  * "'So that was the job I felt I had to do when I started,' thought Sam."
  12  */
  13
  14 #include "EXTERN.h"
  15 #include "perl.h"
  16
  17 #if !defined(NSIG) || defined(M_UNIX) || defined(M_XENIX)
  18 #include <signal.h>
  19 #endif
  20
  21 I32
  22 do_trans(SV *sv, OP *arg)
  23 {
  24     dTHR;
  25     register U8 *s;
  26     register U8 *send;
  27     register U8 *d;
  28     register I32 matches = 0;
  29     register I32 squash = PL_op->op_private & OPpTRANS_SQUASH;
  30     STRLEN len;
  31
  32     if (SvREADONLY(sv) && !(PL_op->op_private & OPpTRANS_COUNTONLY))
  33         croak(no_modify);
  34
  35     if (PL_op->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
  36         SV* rv = (SV*)cSVOP->op_sv;
  37         HV* hv = (HV*)SvRV(rv);
  38         SV** svp = hv_fetch(hv, "NONE", 4, FALSE);
  39         UV none = svp ? SvUV(*svp) : 0x7fffffff;
  40         UV extra = none + 1;
  41         I32 del = PL_op->op_private & OPpTRANS_DELETE;
  42         UV final;
  43         register UV uv;
  44         UV puv;
  45         char *dst;
  46         register I32 from_utf = PL_op->op_private & OPpTRANS_FROM_UTF;
  47         register I32 to_utf = PL_op->op_private & OPpTRANS_TO_UTF;
  48
  49         s = (U8*)SvPV(sv, len);
  50         if (!len)
  51             return 0;
  52         if (!SvPOKp(sv))
  53             s = (U8*)SvPV_force(sv, len);
  54         (void)SvPOK_only(sv);
  55         send = s + len;
  56         DEBUG_t( deb("2.TBL\n"));
  57         if (PL_op->op_private == (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) { /* no other flags */
  58             svp = hv_fetch(hv, "FINAL", 5, FALSE);
  59             if (svp)
  60                 final = SvUV(*svp);
  61
  62             d = s;
  63             while (s < send) {
  64                 if ((uv = swash_fetch(rv, s)) < none) {
  65                     s += UTF8SKIP(s);
  66                     matches++;
  67                     d = uv_to_utf8(d, uv);
  68                 }
  69                 else if (uv == none) {
  70                     int i;
  71                     for (i = UTF8SKIP(s); i; i--)
  72                         *d++ = *s++;
  73                 }
  74                 else if (uv == extra) {
  75                     s += UTF8SKIP(s);
  76                     matches++;
  77                     d = uv_to_utf8(d, final);
  78                 }
  79                 else
  80                     s += UTF8SKIP(s);
  81             }
  82             *d = '\0';
  83             SvCUR_set(sv, d - (U8*)SvPVX(sv));
  84             SvSETMAGIC(sv);
  85         }
  86         else if (PL_op->op_private == OPpTRANS_FROM_UTF) {      /* no other flags */
  87             svp = hv_fetch(hv, "FINAL", 5, FALSE);
  88             if (svp)
  89                 final = SvUV(*svp);
  90
  91             d = s;
  92             while (s < send) {
  93                 if ((uv = swash_fetch(rv, s)) < none) {
  94                     s += UTF8SKIP(s);
  95                     matches++;
  96                     *d++ = (U8)uv;
  97                 }
  98                 else if (uv == none) {
  99                     I32 ulen;
 100                     uv = utf8_to_uv(s, &ulen);
 101                     s += ulen;
 102                     *d++ = (U8)uv;
 103                 }
 104                 else if (uv == extra) {
 105                     s += UTF8SKIP(s);
 106                     matches++;
 107                     *d++ = (U8)final;
 108                 }
 109                 else
 110                     s += UTF8SKIP(s);
 111             }
 112             *d = '\0';
 113             SvCUR_set(sv, d - (U8*)SvPVX(sv));
 114             SvSETMAGIC(sv);
 115         }
 116         else if (PL_op->op_private == OPpTRANS_TO_UTF) {        /* no other flags */
 117             svp = hv_fetch(hv, "FINAL", 5, FALSE);
 118             if (svp)
 119                 final = SvUV(*svp);
 120
 121             d = s;
 122             while (s < send) {
 123                 U8 tmpbuf[10];
 124                 uv_to_utf8(tmpbuf, *s);         /* XXX suboptimal */
 125                 if ((uv = swash_fetch(rv, tmpbuf)) < none) {
 126                     s += UTF8SKIP(s);
 127                     matches++;
 128                     d = uv_to_utf8(d, uv);
 129                 }
 130                 else if (uv == none) {
 131                     I32 ulen;
 132                     uv = utf8_to_uv(s, &ulen);
 133                     s += ulen;
 134                     d = uv_to_utf8(d, uv);
 135                 }
 136                 else if (uv == extra) {
 137                     s += UTF8SKIP(s);
 138                     matches++;
 139                     d = uv_to_utf8(d, final);
 140                 }
 141                 else
 142                     s += UTF8SKIP(s);
 143             }
 144             *d = '\0';
 145             SvCUR_set(sv, d - (U8*)SvPVX(sv));
 146             SvSETMAGIC(sv);
 147         }
 148         else if (PL_op->op_private & OPpTRANS_COUNTONLY) {
 149             if (from_utf) {
 150                 while (s < send) {
 151                     if (swash_fetch(rv, s) < none)
 152                         matches++;
 153                     s += UTF8SKIP(s);
 154                 }
 155             }
 156             else {
 157                 while (s < send) {
 158                     char tmpbuf[10];
 159                     uv_to_utf8(tmpbuf, *s);     /* XXX suboptimal */
 160                     if (swash_fetch(rv, tmpbuf) < none)
 161                         matches++;
 162                     s += UTF8SKIP(s);
 163                 }
 164             }
 165         }
 166         else {
 167             I32 bits = 16;
 168             U8 *dst;
 169
 170             svp = hv_fetch(hv, "BITS", 4, FALSE);
 171             if (svp)
 172                 bits = (I32)SvIV(*svp);
 173
 174             svp = hv_fetch(hv, "FINAL", 5, FALSE);
 175             if (svp)
 176                 final = SvUV(*svp);
 177
 178             Newz(801, d, len * (bits >> 3) + 1, char);
 179             dst = d;
 180
 181             puv = 0xfeedface;
 182             if (squash) {
 183                 while (s < send) {
 184                     if (from_utf)
 185                         uv = swash_fetch(rv, s);
 186                     else {
 187                         char tmpbuf[10];
 188                         uv_to_utf8(tmpbuf, *s); /* XXX suboptimal */
 189                         uv = swash_fetch(rv, tmpbuf);
 190                     }
 191                     if (uv < none) {
 192                         matches++;
 193                         if (uv != puv) {
 194                             if (to_utf)
 195                                 d = uv_to_utf8(d, uv);
 196                             else
 197                                 *d++ = (U8)uv;
 198                         }
 199                         puv = uv;
 200                         s += UTF8SKIP(s);
 201                         continue;
 202                     }
 203                     else if (uv == none) {      /* "none" is unmapped character */
 204                         int i;
 205                         if (to_utf) {
 206                             for (i = UTF8SKIP(s); i; --i)
 207                                 *d++ = *s++;
 208                         }
 209                         else {
 210                             I32 ulen;
 211                             *d++ = (U8)utf8_to_uv(s, &ulen);
 212                             s += ulen;
 213                         }
 214                         puv = 0xfeedface;
 215                         continue;
 216                     }
 217                     else if (uv == extra && !del) {
 218                         matches++;
 219                         if (to_utf)
 220                             d = uv_to_utf8(d, final);
 221                         else
 222                             *d++ = (U8)final;
 223                         s += UTF8SKIP(s);
 224                         puv = 0xfeedface;
 225                         continue;
 226                     }
 227                     matches++;          /* "none+1" is delete character */
 228                     s += UTF8SKIP(s);
 229                 }
 230             }
 231             else {
 232                 while (s < send) {
 233                     if (from_utf)
 234                         uv = swash_fetch(rv, s);
 235                     else {
 236                         char tmpbuf[10];
 237                         uv_to_utf8(tmpbuf, *s); /* XXX suboptimal */
 238                         uv = swash_fetch(rv, tmpbuf);
 239                     }
 240                     if (uv < none) {
 241                         if (to_utf)
 242                             d = uv_to_utf8(d, uv);
 243                         else
 244                             *d++ = (U8)uv;
 245                         matches++;
 246                         s += UTF8SKIP(s);
 247                         continue;
 248                     }
 249                     else if (uv == none) {      /* "none" is unmapped character */
 250                         int i;
 251                         if (to_utf) {
 252                             for (i = UTF8SKIP(s); i; --i)
 253                                 *d++ = *s++;
 254                         }
 255                         else {
 256                             I32 ulen;
 257                             *d++ = (U8)utf8_to_uv(s, &ulen);
 258                             s += ulen;
 259                         }
 260                         continue;
 261                     }
 262                     else if (uv == extra && !del) {
 263                         matches++;
 264                         if (to_utf)
 265                             d = uv_to_utf8(d, final);
 266                         else
 267                             *d++ = (U8)final;
 268                         s += UTF8SKIP(s);
 269                         continue;
 270                     }
 271                     matches++;          /* "none+1" is delete character */
 272                     s += UTF8SKIP(s);
 273                 }
 274             }
 275             sv_usepvn_mg(sv, dst, d - dst);
 276         }
 277         return matches;
 278     }
 279     else {
 280         register short *tbl;
 281         register I32 ch;
 282         register U8 *p;
 283
 284         tbl = (short*)cPVOP->op_pv;
 285         s = (U8*)SvPV(sv, len);
 286         if (!len)
 287             return 0;
 288         if (!SvPOKp(sv))
 289             s = (U8*)SvPV_force(sv, len);
 290         (void)SvPOK_only(sv);
 291         send = s + len;
 292         if (!tbl || !s)
 293             croak("panic: do_trans");
 294         DEBUG_t( deb("2.TBL\n"));
 295         if (!PL_op->op_private) {
 296             while (s < send) {
 297                 if ((ch = tbl[*s]) >= 0) {
 298                     matches++;
 299                     *s = ch;
 300                 }
 301                 s++;
 302             }
 303             SvSETMAGIC(sv);
 304         }
 305         else if (PL_op->op_private & OPpTRANS_COUNTONLY) {
 306             while (s < send) {
 307                 if (tbl[*s] >= 0)
 308                     matches++;
 309                 s++;
 310             }
 311         }
 312         else {
 313             d = s;
 314             p = send;
 315             while (s < send) {
 316                 if ((ch = tbl[*s]) >= 0) {
 317                     *d = ch;
 318                     matches++;
 319                     if (squash) {
 320                         if (p == d - 1 && *p == *d)
 321                             matches--;
 322                         else
 323                             p = d++;
 324                     }
 325                     else
 326                         d++;
 327                 }
 328                 else if (ch == -1)              /* -1 is unmapped character */
 329                     *d++ = *s;          /* -2 is delete character */
 330                 s++;
 331             }
 332             matches += send - d;        /* account for disappeared chars */
 333             *d = '\0';
 334             SvCUR_set(sv, d - (U8*)SvPVX(sv));
 335             SvSETMAGIC(sv);
 336         }
 337         return matches;
 338     }
 339 }
 340
 341 void
 342 do_join(register SV *sv, SV *del, register SV **mark, register SV **sp)
 343 {
 344     SV **oldmark = mark;
 345     register I32 items = sp - mark;
 346     register STRLEN len;
 347     STRLEN delimlen;
 348     register char *delim = SvPV(del, delimlen);
 349     STRLEN tmplen;
 350
 351     mark++;
 352     len = (items > 0 ? (delimlen * (items - 1) ) : 0);
 353     if (SvTYPE(sv) < SVt_PV)
 354         sv_upgrade(sv, SVt_PV);
 355     if (SvLEN(sv) < len + items) {      /* current length is way too short */
 356         while (items-- > 0) {
 357             if (*mark && !SvGMAGICAL(*mark) && SvOK(*mark)) {
 358                 SvPV(*mark, tmplen);
 359                 len += tmplen;
 360             }
 361             mark++;
 362         }
 363         SvGROW(sv, len + 1);            /* so try to pre-extend */
 364
 365         mark = oldmark;
 366         items = sp - mark;;
 367         ++mark;
 368     }
 369
 370     if (items-- > 0) {
 371         char *s;
 372
 373         if (*mark) {
 374             s = SvPV(*mark, tmplen);
 375             sv_setpvn(sv, s, tmplen);
 376         }
 377         else
 378             sv_setpv(sv, "");
 379         mark++;
 380     }
 381     else
 382         sv_setpv(sv,"");
 383     len = delimlen;
 384     if (len) {
 385         for (; items > 0; items--,mark++) {
 386             sv_catpvn(sv,delim,len);
 387             sv_catsv(sv,*mark);
 388         }
 389     }
 390     else {
 391         for (; items > 0; items--,mark++)
 392             sv_catsv(sv,*mark);
 393     }
 394     SvSETMAGIC(sv);
 395 }
 396
 397 void
 398 do_sprintf(SV *sv, I32 len, SV **sarg)
 399 {
 400     STRLEN patlen;
 401     char *pat = SvPV(*sarg, patlen);
 402     bool do_taint = FALSE;
 403
 404     sv_vsetpvfn(sv, pat, patlen, Null(va_list*), sarg + 1, len - 1, &do_taint);
 405     SvSETMAGIC(sv);
 406     if (do_taint)
 407         SvTAINTED_on(sv);
 408 }
 409
 410 void
 411 do_vecset(SV *sv)
 412 {
 413     SV *targ = LvTARG(sv);
 414     register I32 offset;
 415     register I32 size;
 416     register unsigned char *s;
 417     register unsigned long lval;
 418     I32 mask;
 419     STRLEN targlen;
 420     STRLEN len;
 421
 422     if (!targ)
 423         return;
 424     s = (unsigned char*)SvPV_force(targ, targlen);
 425     lval = U_L(SvNV(sv));
 426     offset = LvTARGOFF(sv);
 427     size = LvTARGLEN(sv);
 428
 429     len = (offset + size + 7) / 8;
 430     if (len > targlen) {
 431         s = (unsigned char*)SvGROW(targ, len + 1);
 432         (void)memzero(s + targlen, len - targlen + 1);
 433         SvCUR_set(targ, len);
 434     }
 435
 436     if (size < 8) {
 437         mask = (1 << size) - 1;
 438         size = offset & 7;
 439         lval &= mask;
 440         offset >>= 3;
 441         s[offset] &= ~(mask << size);
 442         s[offset] |= lval << size;
 443     }
 444     else {
 445         offset >>= 3;
 446         if (size == 8)
 447             s[offset] = lval & 255;
 448         else if (size == 16) {
 449             s[offset] = (lval >> 8) & 255;
 450             s[offset+1] = lval & 255;
 451         }
 452         else if (size == 32) {
 453             s[offset] = (lval >> 24) & 255;
 454             s[offset+1] = (lval >> 16) & 255;
 455             s[offset+2] = (lval >> 8) & 255;
 456             s[offset+3] = lval & 255;
 457         }
 458     }
 459 }
 460
 461 void
 462 do_chop(register SV *astr, register SV *sv)
 463 {
 464     STRLEN len;
 465     char *s;
 466     dTHR;
 467
 468     if (SvTYPE(sv) == SVt_PVAV) {
 469         register I32 i;
 470         I32 max;
 471         AV* av = (AV*)sv;
 472         max = AvFILL(av);
 473         for (i = 0; i <= max; i++) {
 474             sv = (SV*)av_fetch(av, i, FALSE);
 475             if (sv && ((sv = *(SV**)sv), sv != &PL_sv_undef))
 476                 do_chop(astr, sv);
 477         }
 478         return;
 479     }
 480     if (SvTYPE(sv) == SVt_PVHV) {
 481         HV* hv = (HV*)sv;
 482         HE* entry;
 483         (void)hv_iterinit(hv);
 484         /*SUPPRESS 560*/
 485         while (entry = hv_iternext(hv))
 486             do_chop(astr,hv_iterval(hv,entry));
 487         return;
 488     }
 489     s = SvPV(sv, len);
 490     if (len && !SvPOK(sv))
 491         s = SvPV_force(sv, len);
 492     if (IN_UTF8) {
 493         if (s && len) {
 494             char *send = s + len;
 495             char *start = s;
 496             s = send - 1;
 497             while ((*s & 0xc0) == 0x80)
 498                 --s;
 499             if (UTF8SKIP(s) != send - s)
 500                 warn("Malformed UTF-8 character");
 501             sv_setpvn(astr, s, send - s);
 502             *s = '\0';
 503             SvCUR_set(sv, s - start);
 504             SvNIOK_off(sv);
 505         }
 506         else
 507             sv_setpvn(astr, "", 0);
 508     }
 509     else
 510     if (s && len) {
 511         s += --len;
 512         sv_setpvn(astr, s, 1);
 513         *s = '\0';
 514         SvCUR_set(sv, len);
 515         SvNIOK_off(sv);
 516     }
 517     else
 518         sv_setpvn(astr, "", 0);
 519     SvSETMAGIC(sv);
 520 }
 521
 522 I32
 523 do_chomp(register SV *sv)
 524 {
 525     dTHR;
 526     register I32 count;
 527     STRLEN len;
 528     char *s;
 529
 530     if (RsSNARF(PL_rs))
 531         return 0;
 532     count = 0;
 533     if (SvTYPE(sv) == SVt_PVAV) {
 534         register I32 i;
 535         I32 max;
 536         AV* av = (AV*)sv;
 537         max = AvFILL(av);
 538         for (i = 0; i <= max; i++) {
 539             sv = (SV*)av_fetch(av, i, FALSE);
 540             if (sv && ((sv = *(SV**)sv), sv != &PL_sv_undef))
 541                 count += do_chomp(sv);
 542         }
 543         return count;
 544     }
 545     if (SvTYPE(sv) == SVt_PVHV) {
 546         HV* hv = (HV*)sv;
 547         HE* entry;
 548         (void)hv_iterinit(hv);
 549         /*SUPPRESS 560*/
 550         while (entry = hv_iternext(hv))
 551             count += do_chomp(hv_iterval(hv,entry));
 552         return count;
 553     }
 554     s = SvPV(sv, len);
 555     if (len && !SvPOKp(sv))
 556         s = SvPV_force(sv, len);
 557     if (s && len) {
 558         s += --len;
 559         if (RsPARA(PL_rs)) {
 560             if (*s != '\n')
 561                 goto nope;
 562             ++count;
 563             while (len && s[-1] == '\n') {
 564                 --len;
 565                 --s;
 566                 ++count;
 567             }
 568         }
 569         else {
 570             STRLEN rslen;
 571             char *rsptr = SvPV(PL_rs, rslen);
 572             if (rslen == 1) {
 573                 if (*s != *rsptr)
 574                     goto nope;
 575                 ++count;
 576             }
 577             else {
 578                 if (len < rslen - 1)
 579                     goto nope;
 580                 len -= rslen - 1;
 581                 s -= rslen - 1;
 582                 if (memNE(s, rsptr, rslen))
 583                     goto nope;
 584                 count += rslen;
 585             }
 586         }
 587         *s = '\0';
 588         SvCUR_set(sv, len);
 589         SvNIOK_off(sv);
 590     }
 591   nope:
 592     SvSETMAGIC(sv);
 593     return count;
 594 }
 595
 596 void
 597 do_vop(I32 optype, SV *sv, SV *left, SV *right)
 598 {
 599     dTHR;       /* just for taint */
 600 #ifdef LIBERAL
 601     register long *dl;
 602     register long *ll;
 603     register long *rl;
 604 #endif
 605     register char *dc;
 606     STRLEN leftlen;
 607     STRLEN rightlen;
 608     register char *lc;
 609     register char *rc;
 610     register I32 len;
 611     I32 lensave;
 612     char *lsave;
 613     char *rsave;
 614
 615     if (sv != left || (optype != OP_BIT_AND && !SvOK(sv) && !SvGMAGICAL(sv)))
 616         sv_setpvn(sv, "", 0);   /* avoid undef warning on |= and ^= */
 617     lsave = lc = SvPV(left, leftlen);
 618     rsave = rc = SvPV(right, rightlen);
 619     len = leftlen < rightlen ? leftlen : rightlen;
 620     lensave = len;
 621     if (SvOK(sv) || SvTYPE(sv) > SVt_PVMG) {
 622         dc = SvPV_force(sv, PL_na);
 623         if (SvCUR(sv) < len) {
 624             dc = SvGROW(sv, len + 1);
 625             (void)memzero(dc + SvCUR(sv), len - SvCUR(sv) + 1);
 626         }
 627     }
 628     else {
 629         I32 needlen = ((optype == OP_BIT_AND)
 630                         ? len : (leftlen > rightlen ? leftlen : rightlen));
 631         Newz(801, dc, needlen + 1, char);
 632         (void)sv_usepvn(sv, dc, needlen);
 633         dc = SvPVX(sv);         /* sv_usepvn() calls Renew() */
 634     }
 635     SvCUR_set(sv, len);
 636     (void)SvPOK_only(sv);
 637 #ifdef LIBERAL
 638     if (len >= sizeof(long)*4 &&
 639         !((long)dc % sizeof(long)) &&
 640         !((long)lc % sizeof(long)) &&
 641         !((long)rc % sizeof(long)))     /* It's almost always aligned... */
 642     {
 643         I32 remainder = len % (sizeof(long)*4);
 644         len /= (sizeof(long)*4);
 645
 646         dl = (long*)dc;
 647         ll = (long*)lc;
 648         rl = (long*)rc;
 649
 650         switch (optype) {
 651         case OP_BIT_AND:
 652             while (len--) {
 653                 *dl++ = *ll++ & *rl++;
 654                 *dl++ = *ll++ & *rl++;
 655                 *dl++ = *ll++ & *rl++;
 656                 *dl++ = *ll++ & *rl++;
 657             }
 658             break;
 659         case OP_BIT_XOR:
 660             while (len--) {
 661                 *dl++ = *ll++ ^ *rl++;
 662                 *dl++ = *ll++ ^ *rl++;
 663                 *dl++ = *ll++ ^ *rl++;
 664                 *dl++ = *ll++ ^ *rl++;
 665             }
 666             break;
 667         case OP_BIT_OR:
 668             while (len--) {
 669                 *dl++ = *ll++ | *rl++;
 670                 *dl++ = *ll++ | *rl++;
 671                 *dl++ = *ll++ | *rl++;
 672                 *dl++ = *ll++ | *rl++;
 673             }
 674         }
 675
 676         dc = (char*)dl;
 677         lc = (char*)ll;
 678         rc = (char*)rl;
 679
 680         len = remainder;
 681     }
 682 #endif
 683     {
 684         switch (optype) {
 685         case OP_BIT_AND:
 686             while (len--)
 687                 *dc++ = *lc++ & *rc++;
 688             break;
 689         case OP_BIT_XOR:
 690             while (len--)
 691                 *dc++ = *lc++ ^ *rc++;
 692             goto mop_up;
 693         case OP_BIT_OR:
 694             while (len--)
 695                 *dc++ = *lc++ | *rc++;
 696           mop_up:
 697             len = lensave;
 698             if (rightlen > len)
 699                 sv_catpvn(sv, rsave + len, rightlen - len);
 700             else if (leftlen > len)
 701                 sv_catpvn(sv, lsave + len, leftlen - len);
 702             else
 703                 *SvEND(sv) = '\0';
 704             break;
 705         }
 706     }
 707     SvTAINT(sv);
 708 }
 709
 710 OP *
 711 do_kv(ARGSproto)
 712 {
 713     djSP;
 714     HV *hv = (HV*)POPs;
 715     HV *keys;
 716     register HE *entry;
 717     SV *tmpstr;
 718     I32 gimme = GIMME_V;
 719     I32 dokeys =   (PL_op->op_type == OP_KEYS);
 720     I32 dovalues = (PL_op->op_type == OP_VALUES);
 721     I32 realhv = (SvTYPE(hv) == SVt_PVHV);
 722
 723     if (PL_op->op_type == OP_RV2HV || PL_op->op_type == OP_PADHV)
 724         dokeys = dovalues = TRUE;
 725
 726     if (!hv) {
 727         if (PL_op->op_flags & OPf_MOD) {        /* lvalue */
 728             dTARGET;            /* make sure to clear its target here */
 729             if (SvTYPE(TARG) == SVt_PVLV)
 730                 LvTARG(TARG) = Nullsv;
 731             PUSHs(TARG);
 732         }
 733         RETURN;
 734     }
 735
 736     keys = realhv ? hv : avhv_keys((AV*)hv);
 737     (void)hv_iterinit(keys);    /* always reset iterator regardless */
 738
 739     if (gimme == G_VOID)
 740         RETURN;
 741
 742     if (gimme == G_SCALAR) {
 743         IV i;
 744         dTARGET;
 745
 746         if (PL_op->op_flags & OPf_MOD) {        /* lvalue */
 747             if (SvTYPE(TARG) < SVt_PVLV) {
 748                 sv_upgrade(TARG, SVt_PVLV);
 749                 sv_magic(TARG, Nullsv, 'k', Nullch, 0);
 750             }
 751             LvTYPE(TARG) = 'k';
 752             if (LvTARG(TARG) != (SV*)keys) {
 753                 if (LvTARG(TARG))
 754                     SvREFCNT_dec(LvTARG(TARG));
 755                 LvTARG(TARG) = SvREFCNT_inc(keys);
 756             }
 757             PUSHs(TARG);
 758             RETURN;
 759         }
 760
 761         if (!SvRMAGICAL(keys) || !mg_find((SV*)keys,'P'))
 762             i = HvKEYS(keys);
 763         else {
 764             i = 0;
 765             /*SUPPRESS 560*/
 766             while (hv_iternext(keys)) i++;
 767         }
 768         PUSHi( i );
 769         RETURN;
 770     }
 771
 772     EXTEND(SP, HvKEYS(keys) * (dokeys + dovalues));
 773
 774     PUTBACK;    /* hv_iternext and hv_iterval might clobber stack_sp */
 775     while (entry = hv_iternext(keys)) {
 776         SPAGAIN;
 777         if (dokeys)
 778             XPUSHs(hv_iterkeysv(entry));        /* won't clobber stack_sp */
 779         if (dovalues) {
 780             tmpstr = sv_newmortal();
 781             PUTBACK;
 782             sv_setsv(tmpstr,realhv ?
 783                      hv_iterval(hv,entry) : avhv_iterval((AV*)hv,entry));
 784             DEBUG_H(sv_setpvf(tmpstr, "%lu%%%d=%lu",
 785                             (unsigned long)HeHASH(entry),
 786                             HvMAX(keys)+1,
 787                             (unsigned long)(HeHASH(entry) & HvMAX(keys))));
 788             SPAGAIN;
 789             XPUSHs(tmpstr);
 790         }
 791         PUTBACK;
 792     }
 793     return NORMAL;
 794 }
 795