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