-w interacts badly with -Dt
[perl.git] / pp.c
1 /*    pp.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  * "It's a big house this, and very peculiar.  Always a bit more to discover,
12  * and no knowing what you'll find around a corner.  And Elves, sir!" --Samwise
13  */
14
15 #include "EXTERN.h"
16 #include "perl.h"
17
18 /*
19  * Types used in bitwise operations.
20  *
21  * Normally we'd just use IV and UV.  However, some hardware and
22  * software combinations (e.g. Alpha and current OSF/1) don't have a
23  * floating-point type to use for NV that has adequate bits to fully
24  * hold an IV/UV.  (In other words, sizeof(long) == sizeof(double).)
25  *
26  * It just so happens that "int" is the right size almost everywhere.
27  */
28 typedef int IBW;
29 typedef unsigned UBW;
30
31 /*
32  * Mask used after bitwise operations.
33  *
34  * There is at least one realm (Cray word machines) that doesn't
35  * have an integral type (except char) small enough to be represented
36  * in a double without loss; that is, it has no 32-bit type.
37  */
38 #if BYTEORDER > 0xFFFF && defined(_CRAY) && !defined(_CRAYMPP)
39 #  define BW_BITS  32
40 #  define BW_MASK  ((1 << BW_BITS) - 1)
41 #  define BW_SIGN  (1 << (BW_BITS - 1))
42 #  define BWi(i)  (((i) & BW_SIGN) ? ((i) | ~BW_MASK) : ((i) & BW_MASK))
43 #  define BWu(u)  ((u) & BW_MASK)
44 #else
45 #  define BWi(i)  (i)
46 #  define BWu(u)  (u)
47 #endif
48
49 /*
50  * Offset for integer pack/unpack.
51  *
52  * On architectures where I16 and I32 aren't really 16 and 32 bits,
53  * which for now are all Crays, pack and unpack have to play games.
54  */
55
56 /*
57  * These values are required for portability of pack() output.
58  * If they're not right on your machine, then pack() and unpack()
59  * wouldn't work right anyway; you'll need to apply the Cray hack.
60  * (I'd like to check them with #if, but you can't use sizeof() in
61  * the preprocessor.)
62  */
63 #define SIZE16 2
64 #define SIZE32 4
65
66 #if BYTEORDER > 0xFFFF && defined(_CRAY) && !defined(_CRAYMPP)
67 #  if BYTEORDER == 0x12345678
68 #    define OFF16(p)    (char*)(p)
69 #    define OFF32(p)    (char*)(p)
70 #  else
71 #    if BYTEORDER == 0x87654321
72 #      define OFF16(p)  ((char*)(p) + (sizeof(U16) - SIZE16))
73 #      define OFF32(p)  ((char*)(p) + (sizeof(U32) - SIZE32))
74 #    else
75        }}}} bad cray byte order
76 #    endif
77 #  endif
78 #  define COPY16(s,p)  (*(p) = 0, Copy(s, OFF16(p), SIZE16, char))
79 #  define COPY32(s,p)  (*(p) = 0, Copy(s, OFF32(p), SIZE32, char))
80 #  define CAT16(sv,p)  sv_catpvn(sv, OFF16(p), SIZE16)
81 #  define CAT32(sv,p)  sv_catpvn(sv, OFF32(p), SIZE32)
82 #else
83 #  define COPY16(s,p)  Copy(s, p, SIZE16, char)
84 #  define COPY32(s,p)  Copy(s, p, SIZE32, char)
85 #  define CAT16(sv,p)  sv_catpvn(sv, (char*)(p), SIZE16)
86 #  define CAT32(sv,p)  sv_catpvn(sv, (char*)(p), SIZE32)
87 #endif
88
89 static void doencodes _((SV* sv, char* s, I32 len));
90 static SV* refto _((SV* sv));
91 static U32 seed _((void));
92
93 static bool srand_called = FALSE;
94
95 /* variations on pp_null */
96
97 PP(pp_stub)
98 {
99     dSP;
100     if (GIMME_V == G_SCALAR)
101         XPUSHs(&sv_undef);
102     RETURN;
103 }
104
105 PP(pp_scalar)
106 {
107     return NORMAL;
108 }
109
110 /* Pushy stuff. */
111
112 PP(pp_padav)
113 {
114     dSP; dTARGET;
115     if (op->op_private & OPpLVAL_INTRO)
116         SAVECLEARSV(curpad[op->op_targ]);
117     EXTEND(SP, 1);
118     if (op->op_flags & OPf_REF) {
119         PUSHs(TARG);
120         RETURN;
121     }
122     if (GIMME == G_ARRAY) {
123         I32 maxarg = AvFILL((AV*)TARG) + 1;
124         EXTEND(SP, maxarg);
125         Copy(AvARRAY((AV*)TARG), SP+1, maxarg, SV*);
126         SP += maxarg;
127     }
128     else {
129         SV* sv = sv_newmortal();
130         I32 maxarg = AvFILL((AV*)TARG) + 1;
131         sv_setiv(sv, maxarg);
132         PUSHs(sv);
133     }
134     RETURN;
135 }
136
137 PP(pp_padhv)
138 {
139     dSP; dTARGET;
140     I32 gimme;
141
142     XPUSHs(TARG);
143     if (op->op_private & OPpLVAL_INTRO)
144         SAVECLEARSV(curpad[op->op_targ]);
145     if (op->op_flags & OPf_REF)
146         RETURN;
147     gimme = GIMME_V;
148     if (gimme == G_ARRAY) {
149         RETURNOP(do_kv(ARGS));
150     }
151     else if (gimme == G_SCALAR) {
152         SV* sv = sv_newmortal();
153         if (HvFILL((HV*)TARG))
154             sv_setpvf(sv, "%ld/%ld",
155                       (long)HvFILL((HV*)TARG), (long)HvMAX((HV*)TARG) + 1);
156         else
157             sv_setiv(sv, 0);
158         SETs(sv);
159     }
160     RETURN;
161 }
162
163 PP(pp_padany)
164 {
165     DIE("NOT IMPL LINE %d",__LINE__);
166 }
167
168 /* Translations. */
169
170 PP(pp_rv2gv)
171 {
172     dSP; dTOPss;
173     
174     if (SvROK(sv)) {
175       wasref:
176         sv = SvRV(sv);
177         if (SvTYPE(sv) == SVt_PVIO) {
178             GV *gv = (GV*) sv_newmortal();
179             gv_init(gv, 0, "", 0, 0);
180             GvIOp(gv) = (IO *)sv;
181             SvREFCNT_inc(sv);
182             sv = (SV*) gv;
183         } else if (SvTYPE(sv) != SVt_PVGV)
184             DIE("Not a GLOB reference");
185     }
186     else {
187         if (SvTYPE(sv) != SVt_PVGV) {
188             char *sym;
189
190             if (SvGMAGICAL(sv)) {
191                 mg_get(sv);
192                 if (SvROK(sv))
193                     goto wasref;
194             }
195             if (!SvOK(sv)) {
196                 if (op->op_flags & OPf_REF ||
197                     op->op_private & HINT_STRICT_REFS)
198                     DIE(no_usym, "a symbol");
199                 if (dowarn)
200                     warn(warn_uninit);
201                 RETSETUNDEF;
202             }
203             sym = SvPV(sv, na);
204             if (op->op_private & HINT_STRICT_REFS)
205                 DIE(no_symref, sym, "a symbol");
206             sv = (SV*)gv_fetchpv(sym, TRUE, SVt_PVGV);
207         }
208     }
209     if (op->op_private & OPpLVAL_INTRO)
210         save_gp((GV*)sv, !(op->op_flags & OPf_SPECIAL));
211     SETs(sv);
212     RETURN;
213 }
214
215 PP(pp_rv2sv)
216 {
217     dSP; dTOPss;
218
219     if (SvROK(sv)) {
220       wasref:
221         sv = SvRV(sv);
222         switch (SvTYPE(sv)) {
223         case SVt_PVAV:
224         case SVt_PVHV:
225         case SVt_PVCV:
226             DIE("Not a SCALAR reference");
227         }
228     }
229     else {
230         GV *gv = (GV*)sv;
231         char *sym;
232
233         if (SvTYPE(gv) != SVt_PVGV) {
234             if (SvGMAGICAL(sv)) {
235                 mg_get(sv);
236                 if (SvROK(sv))
237                     goto wasref;
238             }
239             if (!SvOK(sv)) {
240                 if (op->op_flags & OPf_REF ||
241                     op->op_private & HINT_STRICT_REFS)
242                     DIE(no_usym, "a SCALAR");
243                 if (dowarn)
244                     warn(warn_uninit);
245                 RETSETUNDEF;
246             }
247             sym = SvPV(sv, na);
248             if (op->op_private & HINT_STRICT_REFS)
249                 DIE(no_symref, sym, "a SCALAR");
250             gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PV);
251         }
252         sv = GvSV(gv);
253     }
254     if (op->op_flags & OPf_MOD) {
255         if (op->op_private & OPpLVAL_INTRO)
256             sv = save_scalar((GV*)TOPs);
257         else if (op->op_private & OPpDEREF)
258             vivify_ref(sv, op->op_private & OPpDEREF);
259     }
260     SETs(sv);
261     RETURN;
262 }
263
264 PP(pp_av2arylen)
265 {
266     dSP;
267     AV *av = (AV*)TOPs;
268     SV *sv = AvARYLEN(av);
269     if (!sv) {
270         AvARYLEN(av) = sv = NEWSV(0,0);
271         sv_upgrade(sv, SVt_IV);
272         sv_magic(sv, (SV*)av, '#', Nullch, 0);
273     }
274     SETs(sv);
275     RETURN;
276 }
277
278 PP(pp_pos)
279 {
280     dSP; dTARGET; dPOPss;
281     
282     if (op->op_flags & OPf_MOD) {
283         if (SvTYPE(TARG) < SVt_PVLV) {
284             sv_upgrade(TARG, SVt_PVLV);
285             sv_magic(TARG, Nullsv, '.', Nullch, 0);
286         }
287
288         LvTYPE(TARG) = '.';
289         LvTARG(TARG) = sv;
290         PUSHs(TARG);    /* no SvSETMAGIC */
291         RETURN;
292     }
293     else {
294         MAGIC* mg; 
295
296         if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
297             mg = mg_find(sv, 'g');
298             if (mg && mg->mg_len >= 0) {
299                 PUSHi(mg->mg_len + curcop->cop_arybase);
300                 RETURN;
301             }
302         }
303         RETPUSHUNDEF;
304     }
305 }
306
307 PP(pp_rv2cv)
308 {
309     dSP;
310     GV *gv;
311     HV *stash;
312
313     /* We usually try to add a non-existent subroutine in case of AUTOLOAD. */
314     /* (But not in defined().) */
315     CV *cv = sv_2cv(TOPs, &stash, &gv, !(op->op_flags & OPf_SPECIAL));
316     if (cv) {
317         if (CvCLONE(cv))
318             cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
319     }
320     else
321         cv = (CV*)&sv_undef;
322     SETs((SV*)cv);
323     RETURN;
324 }
325
326 PP(pp_prototype)
327 {
328     dSP;
329     CV *cv;
330     HV *stash;
331     GV *gv;
332     SV *ret;
333
334     ret = &sv_undef;
335     cv = sv_2cv(TOPs, &stash, &gv, FALSE);
336     if (cv && SvPOK(cv))
337         ret = sv_2mortal(newSVpv(SvPVX(cv), SvCUR(cv)));
338     SETs(ret);
339     RETURN;
340 }
341
342 PP(pp_anoncode)
343 {
344     dSP;
345     CV* cv = (CV*)curpad[op->op_targ];
346     if (CvCLONE(cv))
347         cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
348     EXTEND(SP,1);
349     PUSHs((SV*)cv);
350     RETURN;
351 }
352
353 PP(pp_srefgen)
354 {
355     dSP;
356     *SP = refto(*SP);
357     RETURN;
358
359
360 PP(pp_refgen)
361 {
362     dSP; dMARK;
363     if (GIMME != G_ARRAY) {
364         MARK[1] = *SP;
365         SP = MARK + 1;
366     }
367     EXTEND_MORTAL(SP - MARK);
368     while (++MARK <= SP)
369         *MARK = refto(*MARK);
370     RETURN;
371 }
372
373 static SV*
374 refto(sv)
375 SV* sv;
376 {
377     SV* rv;
378
379     if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y') {
380         if (LvTARGLEN(sv))
381             vivify_defelem(sv);
382         if (!(sv = LvTARG(sv)))
383             sv = &sv_undef;
384     }
385     else if (SvPADTMP(sv))
386         sv = newSVsv(sv);
387     else {
388         SvTEMP_off(sv);
389         (void)SvREFCNT_inc(sv);
390     }
391     rv = sv_newmortal();
392     sv_upgrade(rv, SVt_RV);
393     SvRV(rv) = sv;
394     SvROK_on(rv);
395     return rv;
396 }
397
398 PP(pp_ref)
399 {
400     dSP; dTARGET;
401     SV *sv;
402     char *pv;
403
404     sv = POPs;
405
406     if (sv && SvGMAGICAL(sv))
407         mg_get(sv);     
408
409     if (!sv || !SvROK(sv))
410         RETPUSHNO;
411
412     sv = SvRV(sv);
413     pv = sv_reftype(sv,TRUE);
414     PUSHp(pv, strlen(pv));
415     RETURN;
416 }
417
418 PP(pp_bless)
419 {
420     dSP;
421     HV *stash;
422
423     if (MAXARG == 1)
424         stash = curcop->cop_stash;
425     else
426         stash = gv_stashsv(POPs, TRUE);
427
428     (void)sv_bless(TOPs, stash);
429     RETURN;
430 }
431
432 /* Pattern matching */
433
434 PP(pp_study)
435 {
436     dSP; dPOPss;
437     register unsigned char *s;
438     register I32 pos;
439     register I32 ch;
440     register I32 *sfirst;
441     register I32 *snext;
442     STRLEN len;
443
444     if (sv == lastscream) {
445         if (SvSCREAM(sv))
446             RETPUSHYES;
447     }
448     else {
449         if (lastscream) {
450             SvSCREAM_off(lastscream);
451             SvREFCNT_dec(lastscream);
452         }
453         lastscream = SvREFCNT_inc(sv);
454     }
455
456     s = (unsigned char*)(SvPV(sv, len));
457     pos = len;
458     if (pos <= 0)
459         RETPUSHNO;
460     if (pos > maxscream) {
461         if (maxscream < 0) {
462             maxscream = pos + 80;
463             New(301, screamfirst, 256, I32);
464             New(302, screamnext, maxscream, I32);
465         }
466         else {
467             maxscream = pos + pos / 4;
468             Renew(screamnext, maxscream, I32);
469         }
470     }
471
472     sfirst = screamfirst;
473     snext = screamnext;
474
475     if (!sfirst || !snext)
476         DIE("do_study: out of memory");
477
478     for (ch = 256; ch; --ch)
479         *sfirst++ = -1;
480     sfirst -= 256;
481
482     while (--pos >= 0) {
483         ch = s[pos];
484         if (sfirst[ch] >= 0)
485             snext[pos] = sfirst[ch] - pos;
486         else
487             snext[pos] = -pos;
488         sfirst[ch] = pos;
489     }
490
491     SvSCREAM_on(sv);
492     sv_magic(sv, Nullsv, 'g', Nullch, 0);       /* piggyback on m//g magic */
493     RETPUSHYES;
494 }
495
496 PP(pp_trans)
497 {
498     dSP; dTARG;
499     SV *sv;
500
501     if (op->op_flags & OPf_STACKED)
502         sv = POPs;
503     else {
504         sv = GvSV(defgv);
505         EXTEND(SP,1);
506     }
507     TARG = sv_newmortal();
508     PUSHi(do_trans(sv, op));
509     RETURN;
510 }
511
512 /* Lvalue operators. */
513
514 PP(pp_schop)
515 {
516     dSP; dTARGET;
517     do_chop(TARG, TOPs);
518     SETTARG;
519     RETURN;
520 }
521
522 PP(pp_chop)
523 {
524     dSP; dMARK; dTARGET;
525     while (SP > MARK)
526         do_chop(TARG, POPs);
527     PUSHTARG;
528     RETURN;
529 }
530
531 PP(pp_schomp)
532 {
533     dSP; dTARGET;
534     SETi(do_chomp(TOPs));
535     RETURN;
536 }
537
538 PP(pp_chomp)
539 {
540     dSP; dMARK; dTARGET;
541     register I32 count = 0;
542     
543     while (SP > MARK)
544         count += do_chomp(POPs);
545     PUSHi(count);
546     RETURN;
547 }
548
549 PP(pp_defined)
550 {
551     dSP;
552     register SV* sv;
553
554     sv = POPs;
555     if (!sv || !SvANY(sv))
556         RETPUSHNO;
557     switch (SvTYPE(sv)) {
558     case SVt_PVAV:
559         if (AvMAX(sv) >= 0 || SvRMAGICAL(sv))
560             RETPUSHYES;
561         break;
562     case SVt_PVHV:
563         if (HvARRAY(sv) || SvRMAGICAL(sv))
564             RETPUSHYES;
565         break;
566     case SVt_PVCV:
567         if (CvROOT(sv) || CvXSUB(sv))
568             RETPUSHYES;
569         break;
570     default:
571         if (SvGMAGICAL(sv))
572             mg_get(sv);
573         if (SvOK(sv))
574             RETPUSHYES;
575     }
576     RETPUSHNO;
577 }
578
579 PP(pp_undef)
580 {
581     dSP;
582     SV *sv;
583
584     if (!op->op_private) {
585         EXTEND(SP, 1);
586         RETPUSHUNDEF;
587     }
588
589     sv = POPs;
590     if (!sv)
591         RETPUSHUNDEF;
592
593     if (SvTHINKFIRST(sv)) {
594         if (SvREADONLY(sv))
595             RETPUSHUNDEF;
596         if (SvROK(sv))
597             sv_unref(sv);
598     }
599
600     switch (SvTYPE(sv)) {
601     case SVt_NULL:
602         break;
603     case SVt_PVAV:
604         av_undef((AV*)sv);
605         break;
606     case SVt_PVHV:
607         hv_undef((HV*)sv);
608         break;
609     case SVt_PVCV:
610         if (cv_const_sv((CV*)sv))
611             warn("Constant subroutine %s undefined",
612                  CvANON((CV*)sv) ? "(anonymous)" : GvENAME(CvGV((CV*)sv)));
613         /* FALL THROUGH */
614     case SVt_PVFM:
615         { GV* gv = (GV*)SvREFCNT_inc(CvGV((CV*)sv));
616           cv_undef((CV*)sv);
617           CvGV((CV*)sv) = gv; }   /* let user-undef'd sub keep its identity */
618         break;
619     case SVt_PVGV:
620         if (SvFAKE(sv))
621             sv_setsv(sv, &sv_undef);
622         break;
623     default:
624         if (SvTYPE(sv) >= SVt_PV && SvPVX(sv) && SvLEN(sv)) {
625             (void)SvOOK_off(sv);
626             Safefree(SvPVX(sv));
627             SvPV_set(sv, Nullch);
628             SvLEN_set(sv, 0);
629         }
630         (void)SvOK_off(sv);
631         SvSETMAGIC(sv);
632     }
633
634     RETPUSHUNDEF;
635 }
636
637 PP(pp_predec)
638 {
639     dSP;
640     if (SvREADONLY(TOPs) || SvTYPE(TOPs) > SVt_PVLV)
641         croak(no_modify);
642     if (SvIOK(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs) &&
643         SvIVX(TOPs) != IV_MIN)
644     {
645         --SvIVX(TOPs);
646         SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
647     }
648     else
649         sv_dec(TOPs);
650     SvSETMAGIC(TOPs);
651     return NORMAL;
652 }
653
654 PP(pp_postinc)
655 {
656     dSP; dTARGET;
657     if (SvREADONLY(TOPs) || SvTYPE(TOPs) > SVt_PVLV)
658         croak(no_modify);
659     sv_setsv(TARG, TOPs);
660     if (SvIOK(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs) &&
661         SvIVX(TOPs) != IV_MAX)
662     {
663         ++SvIVX(TOPs);
664         SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
665     }
666     else
667         sv_inc(TOPs);
668     SvSETMAGIC(TOPs);
669     if (!SvOK(TARG))
670         sv_setiv(TARG, 0);
671     SETs(TARG);
672     return NORMAL;
673 }
674
675 PP(pp_postdec)
676 {
677     dSP; dTARGET;
678     if(SvREADONLY(TOPs) || SvTYPE(TOPs) > SVt_PVLV)
679         croak(no_modify);
680     sv_setsv(TARG, TOPs);
681     if (SvIOK(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs) &&
682         SvIVX(TOPs) != IV_MIN)
683     {
684         --SvIVX(TOPs);
685         SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
686     }
687     else
688         sv_dec(TOPs);
689     SvSETMAGIC(TOPs);
690     SETs(TARG);
691     return NORMAL;
692 }
693
694 /* Ordinary operators. */
695
696 PP(pp_pow)
697 {
698     dSP; dATARGET; tryAMAGICbin(pow,opASSIGN); 
699     {
700       dPOPTOPnnrl;
701       SETn( pow( left, right) );
702       RETURN;
703     }
704 }
705
706 PP(pp_multiply)
707 {
708     dSP; dATARGET; tryAMAGICbin(mult,opASSIGN); 
709     {
710       dPOPTOPnnrl;
711       SETn( left * right );
712       RETURN;
713     }
714 }
715
716 PP(pp_divide)
717 {
718     dSP; dATARGET; tryAMAGICbin(div,opASSIGN); 
719     {
720       dPOPPOPnnrl;
721       double value;
722       if (right == 0.0)
723         DIE("Illegal division by zero");
724 #ifdef SLOPPYDIVIDE
725       /* insure that 20./5. == 4. */
726       {
727         IV k;
728         if ((double)I_V(left)  == left &&
729             (double)I_V(right) == right &&
730             (k = I_V(left)/I_V(right))*I_V(right) == I_V(left)) {
731             value = k;
732         } else {
733             value = left / right;
734         }
735       }
736 #else
737       value = left / right;
738 #endif
739       PUSHn( value );
740       RETURN;
741     }
742 }
743
744 PP(pp_modulo)
745 {
746     dSP; dATARGET; tryAMAGICbin(mod,opASSIGN);
747     {
748       UV left;
749       UV right;
750       bool left_neg;
751       bool right_neg;
752       UV ans;
753
754       if (SvIOK(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)) {
755         IV i = SvIVX(POPs);
756         right = (right_neg = (i < 0)) ? -i : i;
757       }
758       else {
759         double n = POPn;
760         right = U_V((right_neg = (n < 0)) ? -n : n);
761       }
762
763       if (SvIOK(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)) {
764         IV i = SvIVX(POPs);
765         left = (left_neg = (i < 0)) ? -i : i;
766       }
767       else {
768         double n = POPn;
769         left = U_V((left_neg = (n < 0)) ? -n : n);
770       }
771
772       if (!right)
773         DIE("Illegal modulus zero");
774
775       ans = left % right;
776       if ((left_neg != right_neg) && ans)
777         ans = right - ans;
778       if (right_neg) {
779         if (ans <= -(UV)IV_MAX)
780           sv_setiv(TARG, (IV) -ans);
781         else
782           sv_setnv(TARG, -(double)ans);
783       }
784       else
785         sv_setuv(TARG, ans);
786       PUSHTARG;
787       RETURN;
788     }
789 }
790
791 PP(pp_repeat)
792 {
793   dSP; dATARGET; tryAMAGICbin(repeat,opASSIGN);
794   {
795     register I32 count = POPi;
796     if (GIMME == G_ARRAY && op->op_private & OPpREPEAT_DOLIST) {
797         dMARK;
798         I32 items = SP - MARK;
799         I32 max;
800
801         max = items * count;
802         MEXTEND(MARK, max);
803         if (count > 1) {
804             while (SP > MARK) {
805                 if (*SP)
806                     SvTEMP_off((*SP));
807                 SP--;
808             }
809             MARK++;
810             repeatcpy((char*)(MARK + items), (char*)MARK,
811                 items * sizeof(SV*), count - 1);
812             SP += max;
813         }
814         else if (count <= 0)
815             SP -= items;
816     }
817     else {      /* Note: mark already snarfed by pp_list */
818         SV *tmpstr;
819         STRLEN len;
820
821         tmpstr = POPs;
822         if (TARG == tmpstr && SvTHINKFIRST(tmpstr)) {
823             if (SvREADONLY(tmpstr) && curcop != &compiling)
824                 DIE("Can't x= to readonly value");
825             if (SvROK(tmpstr))
826                 sv_unref(tmpstr);
827         }
828         SvSetSV(TARG, tmpstr);
829         SvPV_force(TARG, len);
830         if (count != 1) {
831             if (count < 1)
832                 SvCUR_set(TARG, 0);
833             else {
834                 SvGROW(TARG, (count * len) + 1);
835                 repeatcpy(SvPVX(TARG) + len, SvPVX(TARG), len, count - 1);
836                 SvCUR(TARG) *= count;
837             }
838             *SvEND(TARG) = '\0';
839         }
840         (void)SvPOK_only(TARG);
841         PUSHTARG;
842     }
843     RETURN;
844   }
845 }
846
847 PP(pp_subtract)
848 {
849     dSP; dATARGET; tryAMAGICbin(subtr,opASSIGN); 
850     {
851       dPOPTOPnnrl_ul;
852       SETn( left - right );
853       RETURN;
854     }
855 }
856
857 PP(pp_left_shift)
858 {
859     dSP; dATARGET; tryAMAGICbin(lshift,opASSIGN); 
860     {
861       IBW shift = POPi;
862       if (op->op_private & HINT_INTEGER) {
863         IBW i = TOPi;
864         i = BWi(i) << shift;
865         SETi(BWi(i));
866       }
867       else {
868         UBW u = TOPu;
869         u <<= shift;
870         SETu(BWu(u));
871       }
872       RETURN;
873     }
874 }
875
876 PP(pp_right_shift)
877 {
878     dSP; dATARGET; tryAMAGICbin(rshift,opASSIGN); 
879     {
880       IBW shift = POPi;
881       if (op->op_private & HINT_INTEGER) {
882         IBW i = TOPi;
883         i = BWi(i) >> shift;
884         SETi(BWi(i));
885       }
886       else {
887         UBW u = TOPu;
888         u >>= shift;
889         SETu(BWu(u));
890       }
891       RETURN;
892     }
893 }
894
895 PP(pp_lt)
896 {
897     dSP; tryAMAGICbinSET(lt,0); 
898     {
899       dPOPnv;
900       SETs(boolSV(TOPn < value));
901       RETURN;
902     }
903 }
904
905 PP(pp_gt)
906 {
907     dSP; tryAMAGICbinSET(gt,0); 
908     {
909       dPOPnv;
910       SETs(boolSV(TOPn > value));
911       RETURN;
912     }
913 }
914
915 PP(pp_le)
916 {
917     dSP; tryAMAGICbinSET(le,0); 
918     {
919       dPOPnv;
920       SETs(boolSV(TOPn <= value));
921       RETURN;
922     }
923 }
924
925 PP(pp_ge)
926 {
927     dSP; tryAMAGICbinSET(ge,0); 
928     {
929       dPOPnv;
930       SETs(boolSV(TOPn >= value));
931       RETURN;
932     }
933 }
934
935 PP(pp_ne)
936 {
937     dSP; tryAMAGICbinSET(ne,0); 
938     {
939       dPOPnv;
940       SETs(boolSV(TOPn != value));
941       RETURN;
942     }
943 }
944
945 PP(pp_ncmp)
946 {
947     dSP; dTARGET; tryAMAGICbin(ncmp,0); 
948     {
949       dPOPTOPnnrl;
950       I32 value;
951
952       if (left == right)
953         value = 0;
954       else if (left < right)
955         value = -1;
956       else if (left > right)
957         value = 1;
958       else {
959         SETs(&sv_undef);
960         RETURN;
961       }
962       SETi(value);
963       RETURN;
964     }
965 }
966
967 PP(pp_slt)
968 {
969     dSP; tryAMAGICbinSET(slt,0); 
970     {
971       dPOPTOPssrl;
972       int cmp = ((op->op_private & OPpLOCALE)
973                  ? sv_cmp_locale(left, right)
974                  : sv_cmp(left, right));
975       SETs(boolSV(cmp < 0));
976       RETURN;
977     }
978 }
979
980 PP(pp_sgt)
981 {
982     dSP; tryAMAGICbinSET(sgt,0); 
983     {
984       dPOPTOPssrl;
985       int cmp = ((op->op_private & OPpLOCALE)
986                  ? sv_cmp_locale(left, right)
987                  : sv_cmp(left, right));
988       SETs(boolSV(cmp > 0));
989       RETURN;
990     }
991 }
992
993 PP(pp_sle)
994 {
995     dSP; tryAMAGICbinSET(sle,0); 
996     {
997       dPOPTOPssrl;
998       int cmp = ((op->op_private & OPpLOCALE)
999                  ? sv_cmp_locale(left, right)
1000                  : sv_cmp(left, right));
1001       SETs(boolSV(cmp <= 0));
1002       RETURN;
1003     }
1004 }
1005
1006 PP(pp_sge)
1007 {
1008     dSP; tryAMAGICbinSET(sge,0); 
1009     {
1010       dPOPTOPssrl;
1011       int cmp = ((op->op_private & OPpLOCALE)
1012                  ? sv_cmp_locale(left, right)
1013                  : sv_cmp(left, right));
1014       SETs(boolSV(cmp >= 0));
1015       RETURN;
1016     }
1017 }
1018
1019 PP(pp_seq)
1020 {
1021     dSP; tryAMAGICbinSET(seq,0); 
1022     {
1023       dPOPTOPssrl;
1024       SETs(boolSV(sv_eq(left, right)));
1025       RETURN;
1026     }
1027 }
1028
1029 PP(pp_sne)
1030 {
1031     dSP; tryAMAGICbinSET(sne,0); 
1032     {
1033       dPOPTOPssrl;
1034       SETs(boolSV(!sv_eq(left, right)));
1035       RETURN;
1036     }
1037 }
1038
1039 PP(pp_scmp)
1040 {
1041     dSP; dTARGET;  tryAMAGICbin(scmp,0);
1042     {
1043       dPOPTOPssrl;
1044       int cmp = ((op->op_private & OPpLOCALE)
1045                  ? sv_cmp_locale(left, right)
1046                  : sv_cmp(left, right));
1047       SETi( cmp );
1048       RETURN;
1049     }
1050 }
1051
1052 PP(pp_bit_and)
1053 {
1054     dSP; dATARGET; tryAMAGICbin(band,opASSIGN); 
1055     {
1056       dPOPTOPssrl;
1057       if (SvNIOKp(left) || SvNIOKp(right)) {
1058         if (op->op_private & HINT_INTEGER) {
1059           IBW value = SvIV(left) & SvIV(right); 
1060           SETi(BWi(value));
1061         }
1062         else {
1063           UBW value = SvUV(left) & SvUV(right); 
1064           SETu(BWu(value));
1065         }
1066       }
1067       else {
1068         do_vop(op->op_type, TARG, left, right);
1069         SETTARG;
1070       }
1071       RETURN;
1072     }
1073 }
1074
1075 PP(pp_bit_xor)
1076 {
1077     dSP; dATARGET; tryAMAGICbin(bxor,opASSIGN); 
1078     {
1079       dPOPTOPssrl;
1080       if (SvNIOKp(left) || SvNIOKp(right)) {
1081         if (op->op_private & HINT_INTEGER) {
1082           IBW value = (USE_LEFT(left) ? SvIV(left) : 0) ^ SvIV(right); 
1083           SETi(BWi(value));
1084         }
1085         else {
1086           UBW value = (USE_LEFT(left) ? SvUV(left) : 0) ^ SvUV(right); 
1087           SETu(BWu(value));
1088         }
1089       }
1090       else {
1091         do_vop(op->op_type, TARG, left, right);
1092         SETTARG;
1093       }
1094       RETURN;
1095     }
1096 }
1097
1098 PP(pp_bit_or)
1099 {
1100     dSP; dATARGET; tryAMAGICbin(bor,opASSIGN); 
1101     {
1102       dPOPTOPssrl;
1103       if (SvNIOKp(left) || SvNIOKp(right)) {
1104         if (op->op_private & HINT_INTEGER) {
1105           IBW value = (USE_LEFT(left) ? SvIV(left) : 0) | SvIV(right); 
1106           SETi(BWi(value));
1107         }
1108         else {
1109           UBW value = (USE_LEFT(left) ? SvUV(left) : 0) | SvUV(right); 
1110           SETu(BWu(value));
1111         }
1112       }
1113       else {
1114         do_vop(op->op_type, TARG, left, right);
1115         SETTARG;
1116       }
1117       RETURN;
1118     }
1119 }
1120
1121 PP(pp_negate)
1122 {
1123     dSP; dTARGET; tryAMAGICun(neg);
1124     {
1125         dTOPss;
1126         if (SvGMAGICAL(sv))
1127             mg_get(sv);
1128         if (SvIOKp(sv) && !SvNOKp(sv) && !SvPOKp(sv) && SvIVX(sv) != IV_MIN)
1129             SETi(-SvIVX(sv));
1130         else if (SvNIOKp(sv))
1131             SETn(-SvNV(sv));
1132         else if (SvPOKp(sv)) {
1133             STRLEN len;
1134             char *s = SvPV(sv, len);
1135             if (isIDFIRST(*s)) {
1136                 sv_setpvn(TARG, "-", 1);
1137                 sv_catsv(TARG, sv);
1138             }
1139             else if (*s == '+' || *s == '-') {
1140                 sv_setsv(TARG, sv);
1141                 *SvPV_force(TARG, len) = *s == '-' ? '+' : '-';
1142             }
1143             else
1144                 sv_setnv(TARG, -SvNV(sv));
1145             SETTARG;
1146         }
1147         else
1148             SETn(-SvNV(sv));
1149     }
1150     RETURN;
1151 }
1152
1153 PP(pp_not)
1154 {
1155 #ifdef OVERLOAD
1156     dSP; tryAMAGICunSET(not);
1157 #endif /* OVERLOAD */
1158     *stack_sp = boolSV(!SvTRUE(*stack_sp));
1159     return NORMAL;
1160 }
1161
1162 PP(pp_complement)
1163 {
1164     dSP; dTARGET; tryAMAGICun(compl); 
1165     {
1166       dTOPss;
1167       if (SvNIOKp(sv)) {
1168         if (op->op_private & HINT_INTEGER) {
1169           IBW value = ~SvIV(sv);
1170           SETi(BWi(value));
1171         }
1172         else {
1173           UBW value = ~SvUV(sv);
1174           SETu(BWu(value));
1175         }
1176       }
1177       else {
1178         register char *tmps;
1179         register long *tmpl;
1180         register I32 anum;
1181         STRLEN len;
1182
1183         SvSetSV(TARG, sv);
1184         tmps = SvPV_force(TARG, len);
1185         anum = len;
1186 #ifdef LIBERAL
1187         for ( ; anum && (unsigned long)tmps % sizeof(long); anum--, tmps++)
1188             *tmps = ~*tmps;
1189         tmpl = (long*)tmps;
1190         for ( ; anum >= sizeof(long); anum -= sizeof(long), tmpl++)
1191             *tmpl = ~*tmpl;
1192         tmps = (char*)tmpl;
1193 #endif
1194         for ( ; anum > 0; anum--, tmps++)
1195             *tmps = ~*tmps;
1196
1197         SETs(TARG);
1198       }
1199       RETURN;
1200     }
1201 }
1202
1203 /* integer versions of some of the above */
1204
1205 PP(pp_i_multiply)
1206 {
1207     dSP; dATARGET; tryAMAGICbin(mult,opASSIGN); 
1208     {
1209       dPOPTOPiirl;
1210       SETi( left * right );
1211       RETURN;
1212     }
1213 }
1214
1215 PP(pp_i_divide)
1216 {
1217     dSP; dATARGET; tryAMAGICbin(div,opASSIGN); 
1218     {
1219       dPOPiv;
1220       if (value == 0)
1221         DIE("Illegal division by zero");
1222       value = POPi / value;
1223       PUSHi( value );
1224       RETURN;
1225     }
1226 }
1227
1228 PP(pp_i_modulo)
1229 {
1230     dSP; dATARGET; tryAMAGICbin(mod,opASSIGN); 
1231     {
1232       dPOPTOPiirl;
1233       if (!right)
1234         DIE("Illegal modulus zero");
1235       SETi( left % right );
1236       RETURN;
1237     }
1238 }
1239
1240 PP(pp_i_add)
1241 {
1242     dSP; dATARGET; tryAMAGICbin(add,opASSIGN); 
1243     {
1244       dPOPTOPiirl;
1245       SETi( left + right );
1246       RETURN;
1247     }
1248 }
1249
1250 PP(pp_i_subtract)
1251 {
1252     dSP; dATARGET; tryAMAGICbin(subtr,opASSIGN); 
1253     {
1254       dPOPTOPiirl;
1255       SETi( left - right );
1256       RETURN;
1257     }
1258 }
1259
1260 PP(pp_i_lt)
1261 {
1262     dSP; tryAMAGICbinSET(lt,0); 
1263     {
1264       dPOPTOPiirl;
1265       SETs(boolSV(left < right));
1266       RETURN;
1267     }
1268 }
1269
1270 PP(pp_i_gt)
1271 {
1272     dSP; tryAMAGICbinSET(gt,0); 
1273     {
1274       dPOPTOPiirl;
1275       SETs(boolSV(left > right));
1276       RETURN;
1277     }
1278 }
1279
1280 PP(pp_i_le)
1281 {
1282     dSP; tryAMAGICbinSET(le,0); 
1283     {
1284       dPOPTOPiirl;
1285       SETs(boolSV(left <= right));
1286       RETURN;
1287     }
1288 }
1289
1290 PP(pp_i_ge)
1291 {
1292     dSP; tryAMAGICbinSET(ge,0); 
1293     {
1294       dPOPTOPiirl;
1295       SETs(boolSV(left >= right));
1296       RETURN;
1297     }
1298 }
1299
1300 PP(pp_i_eq)
1301 {
1302     dSP; tryAMAGICbinSET(eq,0); 
1303     {
1304       dPOPTOPiirl;
1305       SETs(boolSV(left == right));
1306       RETURN;
1307     }
1308 }
1309
1310 PP(pp_i_ne)
1311 {
1312     dSP; tryAMAGICbinSET(ne,0); 
1313     {
1314       dPOPTOPiirl;
1315       SETs(boolSV(left != right));
1316       RETURN;
1317     }
1318 }
1319
1320 PP(pp_i_ncmp)
1321 {
1322     dSP; dTARGET; tryAMAGICbin(ncmp,0); 
1323     {
1324       dPOPTOPiirl;
1325       I32 value;
1326
1327       if (left > right)
1328         value = 1;
1329       else if (left < right)
1330         value = -1;
1331       else
1332         value = 0;
1333       SETi(value);
1334       RETURN;
1335     }
1336 }
1337
1338 PP(pp_i_negate)
1339 {
1340     dSP; dTARGET; tryAMAGICun(neg);
1341     SETi(-TOPi);
1342     RETURN;
1343 }
1344
1345 /* High falutin' math. */
1346
1347 PP(pp_atan2)
1348 {
1349     dSP; dTARGET; tryAMAGICbin(atan2,0); 
1350     {
1351       dPOPTOPnnrl;
1352       SETn(atan2(left, right));
1353       RETURN;
1354     }
1355 }
1356
1357 PP(pp_sin)
1358 {
1359     dSP; dTARGET; tryAMAGICun(sin);
1360     {
1361       double value;
1362       value = POPn;
1363       value = sin(value);
1364       XPUSHn(value);
1365       RETURN;
1366     }
1367 }
1368
1369 PP(pp_cos)
1370 {
1371     dSP; dTARGET; tryAMAGICun(cos);
1372     {
1373       double value;
1374       value = POPn;
1375       value = cos(value);
1376       XPUSHn(value);
1377       RETURN;
1378     }
1379 }
1380
1381 PP(pp_rand)
1382 {
1383     dSP; dTARGET;
1384     double value;
1385     if (MAXARG < 1)
1386         value = 1.0;
1387     else
1388         value = POPn;
1389     if (value == 0.0)
1390         value = 1.0;
1391     if (!srand_called) {
1392         (void)srand((unsigned)seed());
1393         srand_called = TRUE;
1394     }
1395 #if RANDBITS == 31
1396     value = rand() * value / 2147483648.0;
1397 #else
1398 #if RANDBITS == 16
1399     value = rand() * value / 65536.0;
1400 #else
1401 #if RANDBITS == 15
1402     value = rand() * value / 32768.0;
1403 #else
1404     value = rand() * value / (double)(((unsigned long)1) << RANDBITS);
1405 #endif
1406 #endif
1407 #endif
1408     XPUSHn(value);
1409     RETURN;
1410 }
1411
1412 PP(pp_srand)
1413 {
1414     dSP;
1415     UV anum;
1416     if (MAXARG < 1)
1417         anum = seed();
1418     else
1419         anum = POPu;
1420     (void)srand((unsigned)anum);
1421     srand_called = TRUE;
1422     EXTEND(SP, 1);
1423     RETPUSHYES;
1424 }
1425
1426 static U32
1427 seed()
1428 {
1429     /*
1430      * This is really just a quick hack which grabs various garbage
1431      * values.  It really should be a real hash algorithm which
1432      * spreads the effect of every input bit onto every output bit,
1433      * if someone who knows about such tings would bother to write it.
1434      * Might be a good idea to add that function to CORE as well.
1435      * No numbers below come from careful analysis or anyting here,
1436      * except they are primes and SEED_C1 > 1E6 to get a full-width
1437      * value from (tv_sec * SEED_C1 + tv_usec).  The multipliers should
1438      * probably be bigger too.
1439      */
1440 #if RANDBITS > 16
1441 #  define SEED_C1       1000003
1442 #define   SEED_C4       73819
1443 #else
1444 #  define SEED_C1       25747
1445 #define   SEED_C4       20639
1446 #endif
1447 #define   SEED_C2       3
1448 #define   SEED_C3       269
1449 #define   SEED_C5       26107
1450
1451     U32 u;
1452 #ifdef VMS
1453 #  include <starlet.h>
1454     /* when[] = (low 32 bits, high 32 bits) of time since epoch
1455      * in 100-ns units, typically incremented ever 10 ms.        */
1456     unsigned int when[2];
1457     _ckvmssts(sys$gettim(when));
1458     u = (U32)SEED_C1 * when[0] + (U32)SEED_C2 * when[1];
1459 #else
1460 #  ifdef HAS_GETTIMEOFDAY
1461     struct timeval when;
1462     gettimeofday(&when,(struct timezone *) 0);
1463     u = (U32)SEED_C1 * when.tv_sec + (U32)SEED_C2 * when.tv_usec;
1464 #  else
1465     Time_t when;
1466     (void)time(&when);
1467     u = (U32)SEED_C1 * when;
1468 #  endif
1469 #endif
1470     u += SEED_C3 * (U32)getpid();
1471     u += SEED_C4 * (U32)(UV)stack_sp;
1472 #ifndef PLAN9           /* XXX Plan9 assembler chokes on this; fix needed  */
1473     u += SEED_C5 * (U32)(UV)&when;
1474 #endif
1475     return u;
1476 }
1477
1478 PP(pp_exp)
1479 {
1480     dSP; dTARGET; tryAMAGICun(exp);
1481     {
1482       double value;
1483       value = POPn;
1484       value = exp(value);
1485       XPUSHn(value);
1486       RETURN;
1487     }
1488 }
1489
1490 PP(pp_log)
1491 {
1492     dSP; dTARGET; tryAMAGICun(log);
1493     {
1494       double value;
1495       value = POPn;
1496       if (value <= 0.0) {
1497         SET_NUMERIC_STANDARD();
1498         DIE("Can't take log of %g", value);
1499       }
1500       value = log(value);
1501       XPUSHn(value);
1502       RETURN;
1503     }
1504 }
1505
1506 PP(pp_sqrt)
1507 {
1508     dSP; dTARGET; tryAMAGICun(sqrt);
1509     {
1510       double value;
1511       value = POPn;
1512       if (value < 0.0) {
1513         SET_NUMERIC_STANDARD();
1514         DIE("Can't take sqrt of %g", value);
1515       }
1516       value = sqrt(value);
1517       XPUSHn(value);
1518       RETURN;
1519     }
1520 }
1521
1522 PP(pp_int)
1523 {
1524     dSP; dTARGET;
1525     {
1526       double value = TOPn;
1527       IV iv;
1528
1529       if (SvIOKp(TOPs) && !SvNOKp(TOPs) && !SvPOKp(TOPs)) {
1530         iv = SvIVX(TOPs);
1531         SETi(iv);
1532       }
1533       else {
1534         if (value >= 0.0)
1535           (void)modf(value, &value);
1536         else {
1537           (void)modf(-value, &value);
1538           value = -value;
1539         }
1540         iv = I_V(value);
1541         if (iv == value)
1542           SETi(iv);
1543         else
1544           SETn(value);
1545       }
1546     }
1547     RETURN;
1548 }
1549
1550 PP(pp_abs)
1551 {
1552     dSP; dTARGET; tryAMAGICun(abs);
1553     {
1554       double value = TOPn;
1555       IV iv;
1556
1557       if (SvIOKp(TOPs) && !SvNOKp(TOPs) && !SvPOKp(TOPs) &&
1558           (iv = SvIVX(TOPs)) != IV_MIN) {
1559         if (iv < 0)
1560           iv = -iv;
1561         SETi(iv);
1562       }
1563       else {
1564         if (value < 0.0)
1565             value = -value;
1566         SETn(value);
1567       }
1568     }
1569     RETURN;
1570 }
1571
1572 PP(pp_hex)
1573 {
1574     dSP; dTARGET;
1575     char *tmps;
1576     I32 argtype;
1577
1578     tmps = POPp;
1579     XPUSHu(scan_hex(tmps, 99, &argtype));
1580     RETURN;
1581 }
1582
1583 PP(pp_oct)
1584 {
1585     dSP; dTARGET;
1586     UV value;
1587     I32 argtype;
1588     char *tmps;
1589
1590     tmps = POPp;
1591     while (*tmps && isSPACE(*tmps))
1592         tmps++;
1593     if (*tmps == '0')
1594         tmps++;
1595     if (*tmps == 'x')
1596         value = scan_hex(++tmps, 99, &argtype);
1597     else
1598         value = scan_oct(tmps, 99, &argtype);
1599     XPUSHu(value);
1600     RETURN;
1601 }
1602
1603 /* String stuff. */
1604
1605 PP(pp_length)
1606 {
1607     dSP; dTARGET;
1608     SETi( sv_len(TOPs) );
1609     RETURN;
1610 }
1611
1612 PP(pp_substr)
1613 {
1614     dSP; dTARGET;
1615     SV *sv;
1616     I32 len;
1617     STRLEN curlen;
1618     I32 pos;
1619     I32 rem;
1620     I32 lvalue = op->op_flags & OPf_MOD;
1621     char *tmps;
1622     I32 arybase = curcop->cop_arybase;
1623
1624     if (MAXARG > 2)
1625         len = POPi;
1626     pos = POPi - arybase;
1627     sv = POPs;
1628     tmps = SvPV(sv, curlen);
1629     if (pos < 0) {
1630         pos += curlen + arybase;
1631         if (pos < 0 && MAXARG < 3)
1632             pos = 0;
1633     }
1634     if (pos < 0 || pos > curlen) {
1635         if (dowarn || lvalue)
1636             warn("substr outside of string");
1637         RETPUSHUNDEF;
1638     }
1639     else {
1640         if (MAXARG < 3)
1641             len = curlen;
1642         else if (len < 0) {
1643             len += curlen - pos;
1644             if (len < 0)
1645                 len = 0;
1646         }
1647         tmps += pos;
1648         rem = curlen - pos;     /* rem=how many bytes left*/
1649         if (rem > len)
1650             rem = len;
1651         sv_setpvn(TARG, tmps, rem);
1652         if (lvalue) {                   /* it's an lvalue! */
1653             if (!SvGMAGICAL(sv)) {
1654                 if (SvROK(sv)) {
1655                     SvPV_force(sv,na);
1656                     if (dowarn)
1657                         warn("Attempt to use reference as lvalue in substr");
1658                 }
1659                 if (SvOK(sv))           /* is it defined ? */
1660                     (void)SvPOK_only(sv);
1661                 else
1662                     sv_setpvn(sv,"",0); /* avoid lexical reincarnation */
1663             }
1664
1665             if (SvTYPE(TARG) < SVt_PVLV) {
1666                 sv_upgrade(TARG, SVt_PVLV);
1667                 sv_magic(TARG, Nullsv, 'x', Nullch, 0);
1668             }
1669
1670             LvTYPE(TARG) = 'x';
1671             LvTARG(TARG) = sv;
1672             LvTARGOFF(TARG) = pos;
1673             LvTARGLEN(TARG) = rem; 
1674         }
1675     }
1676     PUSHs(TARG);                /* avoid SvSETMAGIC here */
1677     RETURN;
1678 }
1679
1680 PP(pp_vec)
1681 {
1682     dSP; dTARGET;
1683     register I32 size = POPi;
1684     register I32 offset = POPi;
1685     register SV *src = POPs;
1686     I32 lvalue = op->op_flags & OPf_MOD;
1687     STRLEN srclen;
1688     unsigned char *s = (unsigned char*)SvPV(src, srclen);
1689     unsigned long retnum;
1690     I32 len;
1691
1692     offset *= size;             /* turn into bit offset */
1693     len = (offset + size + 7) / 8;
1694     if (offset < 0 || size < 1)
1695         retnum = 0;
1696     else {
1697         if (lvalue) {                      /* it's an lvalue! */
1698             if (SvTYPE(TARG) < SVt_PVLV) {
1699                 sv_upgrade(TARG, SVt_PVLV);
1700                 sv_magic(TARG, Nullsv, 'v', Nullch, 0);
1701             }
1702
1703             LvTYPE(TARG) = 'v';
1704             LvTARG(TARG) = src;
1705             LvTARGOFF(TARG) = offset; 
1706             LvTARGLEN(TARG) = size; 
1707         }
1708         if (len > srclen) {
1709             if (size <= 8)
1710                 retnum = 0;
1711             else {
1712                 offset >>= 3;
1713                 if (size == 16) {
1714                     if (offset >= srclen)
1715                         retnum = 0;
1716                     else
1717                         retnum = (unsigned long) s[offset] << 8;
1718                 }
1719                 else if (size == 32) {
1720                     if (offset >= srclen)
1721                         retnum = 0;
1722                     else if (offset + 1 >= srclen)
1723                         retnum = (unsigned long) s[offset] << 24;
1724                     else if (offset + 2 >= srclen)
1725                         retnum = ((unsigned long) s[offset] << 24) +
1726                             ((unsigned long) s[offset + 1] << 16);
1727                     else
1728                         retnum = ((unsigned long) s[offset] << 24) +
1729                             ((unsigned long) s[offset + 1] << 16) +
1730                             (s[offset + 2] << 8);
1731                 }
1732             }
1733         }
1734         else if (size < 8)
1735             retnum = (s[offset >> 3] >> (offset & 7)) & ((1 << size) - 1);
1736         else {
1737             offset >>= 3;
1738             if (size == 8)
1739                 retnum = s[offset];
1740             else if (size == 16)
1741                 retnum = ((unsigned long) s[offset] << 8) + s[offset+1];
1742             else if (size == 32)
1743                 retnum = ((unsigned long) s[offset] << 24) +
1744                         ((unsigned long) s[offset + 1] << 16) +
1745                         (s[offset + 2] << 8) + s[offset+3];
1746         }
1747     }
1748
1749     sv_setiv(TARG, (IV)retnum);
1750     PUSHs(TARG);
1751     RETURN;
1752 }
1753
1754 PP(pp_index)
1755 {
1756     dSP; dTARGET;
1757     SV *big;
1758     SV *little;
1759     I32 offset;
1760     I32 retval;
1761     char *tmps;
1762     char *tmps2;
1763     STRLEN biglen;
1764     I32 arybase = curcop->cop_arybase;
1765
1766     if (MAXARG < 3)
1767         offset = 0;
1768     else
1769         offset = POPi - arybase;
1770     little = POPs;
1771     big = POPs;
1772     tmps = SvPV(big, biglen);
1773     if (offset < 0)
1774         offset = 0;
1775     else if (offset > biglen)
1776         offset = biglen;
1777     if (!(tmps2 = fbm_instr((unsigned char*)tmps + offset,
1778       (unsigned char*)tmps + biglen, little)))
1779         retval = -1 + arybase;
1780     else
1781         retval = tmps2 - tmps + arybase;
1782     PUSHi(retval);
1783     RETURN;
1784 }
1785
1786 PP(pp_rindex)
1787 {
1788     dSP; dTARGET;
1789     SV *big;
1790     SV *little;
1791     STRLEN blen;
1792     STRLEN llen;
1793     SV *offstr;
1794     I32 offset;
1795     I32 retval;
1796     char *tmps;
1797     char *tmps2;
1798     I32 arybase = curcop->cop_arybase;
1799
1800     if (MAXARG >= 3)
1801         offstr = POPs;
1802     little = POPs;
1803     big = POPs;
1804     tmps2 = SvPV(little, llen);
1805     tmps = SvPV(big, blen);
1806     if (MAXARG < 3)
1807         offset = blen;
1808     else
1809         offset = SvIV(offstr) - arybase + llen;
1810     if (offset < 0)
1811         offset = 0;
1812     else if (offset > blen)
1813         offset = blen;
1814     if (!(tmps2 = rninstr(tmps,  tmps  + offset,
1815                           tmps2, tmps2 + llen)))
1816         retval = -1 + arybase;
1817     else
1818         retval = tmps2 - tmps + arybase;
1819     PUSHi(retval);
1820     RETURN;
1821 }
1822
1823 PP(pp_sprintf)
1824 {
1825     dSP; dMARK; dORIGMARK; dTARGET;
1826 #ifdef USE_LOCALE_NUMERIC
1827     if (op->op_private & OPpLOCALE)
1828         SET_NUMERIC_LOCAL();
1829     else
1830         SET_NUMERIC_STANDARD();
1831 #endif
1832     do_sprintf(TARG, SP-MARK, MARK+1);
1833     TAINT_IF(SvTAINTED(TARG));
1834     SP = ORIGMARK;
1835     PUSHTARG;
1836     RETURN;
1837 }
1838
1839 PP(pp_ord)
1840 {
1841     dSP; dTARGET;
1842     I32 value;
1843     char *tmps;
1844
1845 #ifndef I286
1846     tmps = POPp;
1847     value = (I32) (*tmps & 255);
1848 #else
1849     I32 anum;
1850     tmps = POPp;
1851     anum = (I32) *tmps;
1852     value = (I32) (anum & 255);
1853 #endif
1854     XPUSHi(value);
1855     RETURN;
1856 }
1857
1858 PP(pp_chr)
1859 {
1860     dSP; dTARGET;
1861     char *tmps;
1862
1863     (void)SvUPGRADE(TARG,SVt_PV);
1864     SvGROW(TARG,2);
1865     SvCUR_set(TARG, 1);
1866     tmps = SvPVX(TARG);
1867     *tmps++ = POPi;
1868     *tmps = '\0';
1869     (void)SvPOK_only(TARG);
1870     XPUSHs(TARG);
1871     RETURN;
1872 }
1873
1874 PP(pp_crypt)
1875 {
1876     dSP; dTARGET; dPOPTOPssrl;
1877 #ifdef HAS_CRYPT
1878     char *tmps = SvPV(left, na);
1879 #ifdef FCRYPT
1880     sv_setpv(TARG, fcrypt(tmps, SvPV(right, na)));
1881 #else
1882     sv_setpv(TARG, crypt(tmps, SvPV(right, na)));
1883 #endif
1884 #else
1885     DIE(
1886       "The crypt() function is unimplemented due to excessive paranoia.");
1887 #endif
1888     SETs(TARG);
1889     RETURN;
1890 }
1891
1892 PP(pp_ucfirst)
1893 {
1894     dSP;
1895     SV *sv = TOPs;
1896     register char *s;
1897
1898     if (!SvPADTMP(sv)) {
1899         dTARGET;
1900         sv_setsv(TARG, sv);
1901         sv = TARG;
1902         SETs(sv);
1903     }
1904     s = SvPV_force(sv, na);
1905     if (*s) {
1906         if (op->op_private & OPpLOCALE) {
1907             TAINT;
1908             SvTAINTED_on(sv);
1909             *s = toUPPER_LC(*s);
1910         }
1911         else
1912             *s = toUPPER(*s);
1913     }
1914
1915     RETURN;
1916 }
1917
1918 PP(pp_lcfirst)
1919 {
1920     dSP;
1921     SV *sv = TOPs;
1922     register char *s;
1923
1924     if (!SvPADTMP(sv)) {
1925         dTARGET;
1926         sv_setsv(TARG, sv);
1927         sv = TARG;
1928         SETs(sv);
1929     }
1930     s = SvPV_force(sv, na);
1931     if (*s) {
1932         if (op->op_private & OPpLOCALE) {
1933             TAINT;
1934             SvTAINTED_on(sv);
1935             *s = toLOWER_LC(*s);
1936         }
1937         else
1938             *s = toLOWER(*s);
1939     }
1940
1941     SETs(sv);
1942     RETURN;
1943 }
1944
1945 PP(pp_uc)
1946 {
1947     dSP;
1948     SV *sv = TOPs;
1949     register char *s;
1950     STRLEN len;
1951
1952     if (!SvPADTMP(sv)) {
1953         dTARGET;
1954         sv_setsv(TARG, sv);
1955         sv = TARG;
1956         SETs(sv);
1957     }
1958
1959     s = SvPV_force(sv, len);
1960     if (len) {
1961         register char *send = s + len;
1962
1963         if (op->op_private & OPpLOCALE) {
1964             TAINT;
1965             SvTAINTED_on(sv);
1966             for (; s < send; s++)
1967                 *s = toUPPER_LC(*s);
1968         }
1969         else {
1970             for (; s < send; s++)
1971                 *s = toUPPER(*s);
1972         }
1973     }
1974     RETURN;
1975 }
1976
1977 PP(pp_lc)
1978 {
1979     dSP;
1980     SV *sv = TOPs;
1981     register char *s;
1982     STRLEN len;
1983
1984     if (!SvPADTMP(sv)) {
1985         dTARGET;
1986         sv_setsv(TARG, sv);
1987         sv = TARG;
1988         SETs(sv);
1989     }
1990
1991     s = SvPV_force(sv, len);
1992     if (len) {
1993         register char *send = s + len;
1994
1995         if (op->op_private & OPpLOCALE) {
1996             TAINT;
1997             SvTAINTED_on(sv);
1998             for (; s < send; s++)
1999                 *s = toLOWER_LC(*s);
2000         }
2001         else {
2002             for (; s < send; s++)
2003                 *s = toLOWER(*s);
2004         }
2005     }
2006     RETURN;
2007 }
2008
2009 PP(pp_quotemeta)
2010 {
2011     dSP; dTARGET;
2012     SV *sv = TOPs;
2013     STRLEN len;
2014     register char *s = SvPV(sv,len);
2015     register char *d;
2016
2017     if (len) {
2018         (void)SvUPGRADE(TARG, SVt_PV);
2019         SvGROW(TARG, (len * 2) + 1);
2020         d = SvPVX(TARG);
2021         while (len--) {
2022             if (!isALNUM(*s))
2023                 *d++ = '\\';
2024             *d++ = *s++;
2025         }
2026         *d = '\0';
2027         SvCUR_set(TARG, d - SvPVX(TARG));
2028         (void)SvPOK_only(TARG);
2029     }
2030     else
2031         sv_setpvn(TARG, s, len);
2032     SETs(TARG);
2033     RETURN;
2034 }
2035
2036 /* Arrays. */
2037
2038 PP(pp_aslice)
2039 {
2040     dSP; dMARK; dORIGMARK;
2041     register SV** svp;
2042     register AV* av = (AV*)POPs;
2043     register I32 lval = op->op_flags & OPf_MOD;
2044     I32 arybase = curcop->cop_arybase;
2045     I32 elem;
2046
2047     if (SvTYPE(av) == SVt_PVAV) {
2048         if (lval && op->op_private & OPpLVAL_INTRO) {
2049             I32 max = -1;
2050             for (svp = mark + 1; svp <= sp; svp++) {
2051                 elem = SvIVx(*svp);
2052                 if (elem > max)
2053                     max = elem;
2054             }
2055             if (max > AvMAX(av))
2056                 av_extend(av, max);
2057         }
2058         while (++MARK <= SP) {
2059             elem = SvIVx(*MARK);
2060
2061             if (elem > 0)
2062                 elem -= arybase;
2063             svp = av_fetch(av, elem, lval);
2064             if (lval) {
2065                 if (!svp || *svp == &sv_undef)
2066                     DIE(no_aelem, elem);
2067                 if (op->op_private & OPpLVAL_INTRO)
2068                     save_svref(svp);
2069             }
2070             *MARK = svp ? *svp : &sv_undef;
2071         }
2072     }
2073     if (GIMME != G_ARRAY) {
2074         MARK = ORIGMARK;
2075         *++MARK = *SP;
2076         SP = MARK;
2077     }
2078     RETURN;
2079 }
2080
2081 /* Associative arrays. */
2082
2083 PP(pp_each)
2084 {
2085     dSP; dTARGET;
2086     HV *hash = (HV*)POPs;
2087     HE *entry;
2088     I32 gimme = GIMME_V;
2089     
2090     PUTBACK;
2091     entry = hv_iternext(hash);          /* might clobber stack_sp */
2092     SPAGAIN;
2093
2094     EXTEND(SP, 2);
2095     if (entry) {
2096         PUSHs(hv_iterkeysv(entry));     /* won't clobber stack_sp */
2097         if (gimme == G_ARRAY) {
2098             PUTBACK;
2099             sv_setsv(TARG, hv_iterval(hash, entry));  /* might hit stack_sp */
2100             SPAGAIN;
2101             PUSHs(TARG);
2102         }
2103     }
2104     else if (gimme == G_SCALAR)
2105         RETPUSHUNDEF;
2106
2107     RETURN;
2108 }
2109
2110 PP(pp_values)
2111 {
2112     return do_kv(ARGS);
2113 }
2114
2115 PP(pp_keys)
2116 {
2117     return do_kv(ARGS);
2118 }
2119
2120 PP(pp_delete)
2121 {
2122     dSP;
2123     I32 gimme = GIMME_V;
2124     I32 discard = (gimme == G_VOID) ? G_DISCARD : 0;
2125     SV *sv;
2126     HV *hv;
2127
2128     if (op->op_private & OPpSLICE) {
2129         dMARK; dORIGMARK;
2130         hv = (HV*)POPs;
2131         if (SvTYPE(hv) != SVt_PVHV)
2132             DIE("Not a HASH reference");
2133         while (++MARK <= SP) {
2134             sv = hv_delete_ent(hv, *MARK, discard, 0);
2135             *MARK = sv ? sv : &sv_undef;
2136         }
2137         if (discard)
2138             SP = ORIGMARK;
2139         else if (gimme == G_SCALAR) {
2140             MARK = ORIGMARK;
2141             *++MARK = *SP;
2142             SP = MARK;
2143         }
2144     }
2145     else {
2146         SV *keysv = POPs;
2147         hv = (HV*)POPs;
2148         if (SvTYPE(hv) != SVt_PVHV)
2149             DIE("Not a HASH reference");
2150         sv = hv_delete_ent(hv, keysv, discard, 0);
2151         if (!sv)
2152             sv = &sv_undef;
2153         if (!discard)
2154             PUSHs(sv);
2155     }
2156     RETURN;
2157 }
2158
2159 PP(pp_exists)
2160 {
2161     dSP;
2162     SV *tmpsv = POPs;
2163     HV *hv = (HV*)POPs;
2164     STRLEN len;
2165     if (SvTYPE(hv) != SVt_PVHV) {
2166         DIE("Not a HASH reference");
2167     }
2168     if (hv_exists_ent(hv, tmpsv, 0))
2169         RETPUSHYES;
2170     RETPUSHNO;
2171 }
2172
2173 PP(pp_hslice)
2174 {
2175     dSP; dMARK; dORIGMARK;
2176     register HE *he;
2177     register HV *hv = (HV*)POPs;
2178     register I32 lval = op->op_flags & OPf_MOD;
2179
2180     if (SvTYPE(hv) == SVt_PVHV) {
2181         while (++MARK <= SP) {
2182             SV *keysv = *MARK;
2183
2184             he = hv_fetch_ent(hv, keysv, lval, 0);
2185             if (lval) {
2186                 if (!he || HeVAL(he) == &sv_undef)
2187                     DIE(no_helem, SvPV(keysv, na));
2188                 if (op->op_private & OPpLVAL_INTRO)
2189                     save_svref(&HeVAL(he));
2190             }
2191             *MARK = he ? HeVAL(he) : &sv_undef;
2192         }
2193     }
2194     if (GIMME != G_ARRAY) {
2195         MARK = ORIGMARK;
2196         *++MARK = *SP;
2197         SP = MARK;
2198     }
2199     RETURN;
2200 }
2201
2202 /* List operators. */
2203
2204 PP(pp_list)
2205 {
2206     dSP; dMARK;
2207     if (GIMME != G_ARRAY) {
2208         if (++MARK <= SP)
2209             *MARK = *SP;                /* unwanted list, return last item */
2210         else
2211             *MARK = &sv_undef;
2212         SP = MARK;
2213     }
2214     RETURN;
2215 }
2216
2217 PP(pp_lslice)
2218 {
2219     dSP;
2220     SV **lastrelem = stack_sp;
2221     SV **lastlelem = stack_base + POPMARK;
2222     SV **firstlelem = stack_base + POPMARK + 1;
2223     register SV **firstrelem = lastlelem + 1;
2224     I32 arybase = curcop->cop_arybase;
2225     I32 lval = op->op_flags & OPf_MOD;
2226     I32 is_something_there = lval;
2227
2228     register I32 max = lastrelem - lastlelem;
2229     register SV **lelem;
2230     register I32 ix;
2231
2232     if (GIMME != G_ARRAY) {
2233         ix = SvIVx(*lastlelem);
2234         if (ix < 0)
2235             ix += max;
2236         else
2237             ix -= arybase;
2238         if (ix < 0 || ix >= max)
2239             *firstlelem = &sv_undef;
2240         else
2241             *firstlelem = firstrelem[ix];
2242         SP = firstlelem;
2243         RETURN;
2244     }
2245
2246     if (max == 0) {
2247         SP = firstlelem - 1;
2248         RETURN;
2249     }
2250
2251     for (lelem = firstlelem; lelem <= lastlelem; lelem++) {
2252         ix = SvIVx(*lelem);
2253         if (ix < 0) {
2254             ix += max;
2255             if (ix < 0)
2256                 *lelem = &sv_undef;
2257             else if (!(*lelem = firstrelem[ix]))
2258                 *lelem = &sv_undef;
2259         }
2260         else {
2261             ix -= arybase;
2262             if (ix >= max || !(*lelem = firstrelem[ix]))
2263                 *lelem = &sv_undef;
2264         }
2265         if (!is_something_there && (SvOK(*lelem) || SvGMAGICAL(*lelem)))
2266             is_something_there = TRUE;
2267     }
2268     if (is_something_there)
2269         SP = lastlelem;
2270     else
2271         SP = firstlelem - 1;
2272     RETURN;
2273 }
2274
2275 PP(pp_anonlist)
2276 {
2277     dSP; dMARK; dORIGMARK;
2278     I32 items = SP - MARK;
2279     SV *av = sv_2mortal((SV*)av_make(items, MARK+1));
2280     SP = ORIGMARK;              /* av_make() might realloc stack_sp */
2281     XPUSHs(av);
2282     RETURN;
2283 }
2284
2285 PP(pp_anonhash)
2286 {
2287     dSP; dMARK; dORIGMARK;
2288     HV* hv = (HV*)sv_2mortal((SV*)newHV());
2289
2290     while (MARK < SP) {
2291         SV* key = *++MARK;
2292         SV *val = NEWSV(46, 0);
2293         if (MARK < SP)
2294             sv_setsv(val, *++MARK);
2295         else
2296             warn("Odd number of elements in hash list");
2297         (void)hv_store_ent(hv,key,val,0);
2298     }
2299     SP = ORIGMARK;
2300     XPUSHs((SV*)hv);
2301     RETURN;
2302 }
2303
2304 PP(pp_splice)
2305 {
2306     dSP; dMARK; dORIGMARK;
2307     register AV *ary = (AV*)*++MARK;
2308     register SV **src;
2309     register SV **dst;
2310     register I32 i;
2311     register I32 offset;
2312     register I32 length;
2313     I32 newlen;
2314     I32 after;
2315     I32 diff;
2316     SV **tmparyval = 0;
2317
2318     SP++;
2319
2320     if (++MARK < SP) {
2321         offset = SvIVx(*MARK);
2322         if (offset < 0)
2323             offset += AvFILL(ary) + 1;
2324         else
2325             offset -= curcop->cop_arybase;
2326         if (++MARK < SP) {
2327             length = SvIVx(*MARK++);
2328             if (length < 0)
2329                 length = 0;
2330         }
2331         else
2332             length = AvMAX(ary) + 1;            /* close enough to infinity */
2333     }
2334     else {
2335         offset = 0;
2336         length = AvMAX(ary) + 1;
2337     }
2338     if (offset < 0) {
2339         length += offset;
2340         offset = 0;
2341         if (length < 0)
2342             length = 0;
2343     }
2344     if (offset > AvFILL(ary) + 1)
2345         offset = AvFILL(ary) + 1;
2346     after = AvFILL(ary) + 1 - (offset + length);
2347     if (after < 0) {                            /* not that much array */
2348         length += after;                        /* offset+length now in array */
2349         after = 0;
2350         if (!AvALLOC(ary))
2351             av_extend(ary, 0);
2352     }
2353
2354     /* At this point, MARK .. SP-1 is our new LIST */
2355
2356     newlen = SP - MARK;
2357     diff = newlen - length;
2358
2359     if (diff < 0) {                             /* shrinking the area */
2360         if (newlen) {
2361             New(451, tmparyval, newlen, SV*);   /* so remember insertion */
2362             Copy(MARK, tmparyval, newlen, SV*);
2363         }
2364
2365         MARK = ORIGMARK + 1;
2366         if (GIMME == G_ARRAY) {                 /* copy return vals to stack */
2367             MEXTEND(MARK, length);
2368             Copy(AvARRAY(ary)+offset, MARK, length, SV*);
2369             if (AvREAL(ary)) {
2370                 EXTEND_MORTAL(length);
2371                 for (i = length, dst = MARK; i; i--) {
2372                     if (!SvIMMORTAL(*dst))
2373                         sv_2mortal(*dst);       /* free them eventualy */
2374                     dst++;
2375                 }
2376             }
2377             MARK += length - 1;
2378         }
2379         else {
2380             *MARK = AvARRAY(ary)[offset+length-1];
2381             if (AvREAL(ary)) {
2382                 if (!SvIMMORTAL(*MARK))
2383                     sv_2mortal(*MARK);
2384                 for (i = length - 1, dst = &AvARRAY(ary)[offset]; i > 0; i--)
2385                     SvREFCNT_dec(*dst++);       /* free them now */
2386             }
2387         }
2388         AvFILL(ary) += diff;
2389
2390         /* pull up or down? */
2391
2392         if (offset < after) {                   /* easier to pull up */
2393             if (offset) {                       /* esp. if nothing to pull */
2394                 src = &AvARRAY(ary)[offset-1];
2395                 dst = src - diff;               /* diff is negative */
2396                 for (i = offset; i > 0; i--)    /* can't trust Copy */
2397                     *dst-- = *src--;
2398             }
2399             dst = AvARRAY(ary);
2400             SvPVX(ary) = (char*)(AvARRAY(ary) - diff); /* diff is negative */
2401             AvMAX(ary) += diff;
2402         }
2403         else {
2404             if (after) {                        /* anything to pull down? */
2405                 src = AvARRAY(ary) + offset + length;
2406                 dst = src + diff;               /* diff is negative */
2407                 Move(src, dst, after, SV*);
2408             }
2409             dst = &AvARRAY(ary)[AvFILL(ary)+1];
2410                                                 /* avoid later double free */
2411         }
2412         i = -diff;
2413         while (i)
2414             dst[--i] = &sv_undef;
2415         
2416         if (newlen) {
2417             for (src = tmparyval, dst = AvARRAY(ary) + offset;
2418               newlen; newlen--) {
2419                 *dst = NEWSV(46, 0);
2420                 sv_setsv(*dst++, *src++);
2421             }
2422             Safefree(tmparyval);
2423         }
2424     }
2425     else {                                      /* no, expanding (or same) */
2426         if (length) {
2427             New(452, tmparyval, length, SV*);   /* so remember deletion */
2428             Copy(AvARRAY(ary)+offset, tmparyval, length, SV*);
2429         }
2430
2431         if (diff > 0) {                         /* expanding */
2432
2433             /* push up or down? */
2434
2435             if (offset < after && diff <= AvARRAY(ary) - AvALLOC(ary)) {
2436                 if (offset) {
2437                     src = AvARRAY(ary);
2438                     dst = src - diff;
2439                     Move(src, dst, offset, SV*);
2440                 }
2441                 SvPVX(ary) = (char*)(AvARRAY(ary) - diff);/* diff is positive */
2442                 AvMAX(ary) += diff;
2443                 AvFILL(ary) += diff;
2444             }
2445             else {
2446                 if (AvFILL(ary) + diff >= AvMAX(ary))   /* oh, well */
2447                     av_extend(ary, AvFILL(ary) + diff);
2448                 AvFILL(ary) += diff;
2449
2450                 if (after) {
2451                     dst = AvARRAY(ary) + AvFILL(ary);
2452                     src = dst - diff;
2453                     for (i = after; i; i--) {
2454                         *dst-- = *src--;
2455                     }
2456                 }
2457             }
2458         }
2459
2460         for (src = MARK, dst = AvARRAY(ary) + offset; newlen; newlen--) {
2461             *dst = NEWSV(46, 0);
2462             sv_setsv(*dst++, *src++);
2463         }
2464         MARK = ORIGMARK + 1;
2465         if (GIMME == G_ARRAY) {                 /* copy return vals to stack */
2466             if (length) {
2467                 Copy(tmparyval, MARK, length, SV*);
2468                 if (AvREAL(ary)) {
2469                     EXTEND_MORTAL(length);
2470                     for (i = length, dst = MARK; i; i--) {
2471                         if (!SvIMMORTAL(*dst))
2472                             sv_2mortal(*dst);   /* free them eventualy */
2473                         dst++;
2474                     }
2475                 }
2476                 Safefree(tmparyval);
2477             }
2478             MARK += length - 1;
2479         }
2480         else if (length--) {
2481             *MARK = tmparyval[length];
2482             if (AvREAL(ary)) {
2483                 if (!SvIMMORTAL(*MARK))
2484                     sv_2mortal(*MARK);
2485                 while (length-- > 0)
2486                     SvREFCNT_dec(tmparyval[length]);
2487             }
2488             Safefree(tmparyval);
2489         }
2490         else
2491             *MARK = &sv_undef;
2492     }
2493     SP = MARK;
2494     RETURN;
2495 }
2496
2497 PP(pp_push)
2498 {
2499     dSP; dMARK; dORIGMARK; dTARGET;
2500     register AV *ary = (AV*)*++MARK;
2501     register SV *sv = &sv_undef;
2502
2503     for (++MARK; MARK <= SP; MARK++) {
2504         sv = NEWSV(51, 0);
2505         if (*MARK)
2506             sv_setsv(sv, *MARK);
2507         av_push(ary, sv);
2508     }
2509     SP = ORIGMARK;
2510     PUSHi( AvFILL(ary) + 1 );
2511     RETURN;
2512 }
2513
2514 PP(pp_pop)
2515 {
2516     dSP;
2517     AV *av = (AV*)POPs;
2518     SV *sv = av_pop(av);
2519     if (!SvIMMORTAL(sv) && AvREAL(av))
2520         (void)sv_2mortal(sv);
2521     PUSHs(sv);
2522     RETURN;
2523 }
2524
2525 PP(pp_shift)
2526 {
2527     dSP;
2528     AV *av = (AV*)POPs;
2529     SV *sv = av_shift(av);
2530     EXTEND(SP, 1);
2531     if (!sv)
2532         RETPUSHUNDEF;
2533     if (!SvIMMORTAL(sv) && AvREAL(av))
2534         (void)sv_2mortal(sv);
2535     PUSHs(sv);
2536     RETURN;
2537 }
2538
2539 PP(pp_unshift)
2540 {
2541     dSP; dMARK; dORIGMARK; dTARGET;
2542     register AV *ary = (AV*)*++MARK;
2543     register SV *sv;
2544     register I32 i = 0;
2545
2546     av_unshift(ary, SP - MARK);
2547     while (MARK < SP) {
2548         sv = NEWSV(27, 0);
2549         sv_setsv(sv, *++MARK);
2550         (void)av_store(ary, i++, sv);
2551     }
2552
2553     SP = ORIGMARK;
2554     PUSHi( AvFILL(ary) + 1 );
2555     RETURN;
2556 }
2557
2558 PP(pp_reverse)
2559 {
2560     dSP; dMARK;
2561     register SV *tmp;
2562     SV **oldsp = SP;
2563
2564     if (GIMME == G_ARRAY) {
2565         MARK++;
2566         while (MARK < SP) {
2567             tmp = *MARK;
2568             *MARK++ = *SP;
2569             *SP-- = tmp;
2570         }
2571         SP = oldsp;
2572     }
2573     else {
2574         register char *up;
2575         register char *down;
2576         register I32 tmp;
2577         dTARGET;
2578         STRLEN len;
2579
2580         if (SP - MARK > 1)
2581             do_join(TARG, &sv_no, MARK, SP);
2582         else
2583             sv_setsv(TARG, (SP > MARK) ? *SP : GvSV(defgv));
2584         up = SvPV_force(TARG, len);
2585         if (len > 1) {
2586             down = SvPVX(TARG) + len - 1;
2587             while (down > up) {
2588                 tmp = *up;
2589                 *up++ = *down;
2590                 *down-- = tmp;
2591             }
2592             (void)SvPOK_only(TARG);
2593         }
2594         SP = MARK + 1;
2595         SETTARG;
2596     }
2597     RETURN;
2598 }
2599
2600 static SV      *
2601 mul128(sv, m)
2602      SV             *sv;
2603      U8              m;
2604 {
2605   STRLEN          len;
2606   char           *s = SvPV(sv, len);
2607   char           *t;
2608   U32             i = 0;
2609
2610   if (!strnEQ(s, "0000", 4)) {  /* need to grow sv */
2611     SV             *new = newSVpv("0000000000", 10);
2612
2613     sv_catsv(new, sv);
2614     SvREFCNT_dec(sv);           /* free old sv */
2615     sv = new;
2616     s = SvPV(sv, len);
2617   }
2618   t = s + len - 1;
2619   while (!*t)                   /* trailing '\0'? */
2620     t--;
2621   while (t > s) {
2622     i = ((*t - '0') << 7) + m;
2623     *(t--) = '0' + (i % 10);
2624     m = i / 10;
2625   }
2626   return (sv);
2627 }
2628
2629 /* Explosives and implosives. */
2630
2631 PP(pp_unpack)
2632 {
2633     dSP;
2634     dPOPPOPssrl;
2635     SV **oldsp = sp;
2636     I32 gimme = GIMME_V;
2637     SV *sv;
2638     STRLEN llen;
2639     STRLEN rlen;
2640     register char *pat = SvPV(left, llen);
2641     register char *s = SvPV(right, rlen);
2642     char *strend = s + rlen;
2643     char *strbeg = s;
2644     register char *patend = pat + llen;
2645     I32 datumtype;
2646     register I32 len;
2647     register I32 bits;
2648
2649     /* These must not be in registers: */
2650     I16 ashort;
2651     int aint;
2652     I32 along;
2653 #ifdef HAS_QUAD
2654     Quad_t aquad;
2655 #endif
2656     U16 aushort;
2657     unsigned int auint;
2658     U32 aulong;
2659 #ifdef HAS_QUAD
2660     unsigned Quad_t auquad;
2661 #endif
2662     char *aptr;
2663     float afloat;
2664     double adouble;
2665     I32 checksum = 0;
2666     register U32 culong;
2667     double cdouble;
2668     static char* bitcount = 0;
2669
2670     if (gimme != G_ARRAY) {             /* arrange to do first one only */
2671         /*SUPPRESS 530*/
2672         for (patend = pat; !isALPHA(*patend) || *patend == 'x'; patend++) ;
2673         if (strchr("aAbBhHP", *patend) || *pat == '%') {
2674             patend++;
2675             while (isDIGIT(*patend) || *patend == '*')
2676                 patend++;
2677         }
2678         else
2679             patend++;
2680     }
2681     while (pat < patend) {
2682       reparse:
2683         datumtype = *pat++ & 0xFF;
2684         if (isSPACE(datumtype))
2685             continue;
2686         if (pat >= patend)
2687             len = 1;
2688         else if (*pat == '*') {
2689             len = strend - strbeg;      /* long enough */
2690             pat++;
2691         }
2692         else if (isDIGIT(*pat)) {
2693             len = *pat++ - '0';
2694             while (isDIGIT(*pat))
2695                 len = (len * 10) + (*pat++ - '0');
2696         }
2697         else
2698             len = (datumtype != '@');
2699         switch(datumtype) {
2700         default:
2701             croak("Invalid type in unpack: '%c'", (int)datumtype);
2702         case '%':
2703             if (len == 1 && pat[-1] != '1')
2704                 len = 16;
2705             checksum = len;
2706             culong = 0;
2707             cdouble = 0;
2708             if (pat < patend)
2709                 goto reparse;
2710             break;
2711         case '@':
2712             if (len > strend - strbeg)
2713                 DIE("@ outside of string");
2714             s = strbeg + len;
2715             break;
2716         case 'X':
2717             if (len > s - strbeg)
2718                 DIE("X outside of string");
2719             s -= len;
2720             break;
2721         case 'x':
2722             if (len > strend - s)
2723                 DIE("x outside of string");
2724             s += len;
2725             break;
2726         case 'A':
2727         case 'a':
2728             if (len > strend - s)
2729                 len = strend - s;
2730             if (checksum)
2731                 goto uchar_checksum;
2732             sv = NEWSV(35, len);
2733             sv_setpvn(sv, s, len);
2734             s += len;
2735             if (datumtype == 'A') {
2736                 aptr = s;       /* borrow register */
2737                 s = SvPVX(sv) + len - 1;
2738                 while (s >= SvPVX(sv) && (!*s || isSPACE(*s)))
2739                     s--;
2740                 *++s = '\0';
2741                 SvCUR_set(sv, s - SvPVX(sv));
2742                 s = aptr;       /* unborrow register */
2743             }
2744             XPUSHs(sv_2mortal(sv));
2745             break;
2746         case 'B':
2747         case 'b':
2748             if (pat[-1] == '*' || len > (strend - s) * 8)
2749                 len = (strend - s) * 8;
2750             if (checksum) {
2751                 if (!bitcount) {
2752                     Newz(601, bitcount, 256, char);
2753                     for (bits = 1; bits < 256; bits++) {
2754                         if (bits & 1)   bitcount[bits]++;
2755                         if (bits & 2)   bitcount[bits]++;
2756                         if (bits & 4)   bitcount[bits]++;
2757                         if (bits & 8)   bitcount[bits]++;
2758                         if (bits & 16)  bitcount[bits]++;
2759                         if (bits & 32)  bitcount[bits]++;
2760                         if (bits & 64)  bitcount[bits]++;
2761                         if (bits & 128) bitcount[bits]++;
2762                     }
2763                 }
2764                 while (len >= 8) {
2765                     culong += bitcount[*(unsigned char*)s++];
2766                     len -= 8;
2767                 }
2768                 if (len) {
2769                     bits = *s;
2770                     if (datumtype == 'b') {
2771                         while (len-- > 0) {
2772                             if (bits & 1) culong++;
2773                             bits >>= 1;
2774                         }
2775                     }
2776                     else {
2777                         while (len-- > 0) {
2778                             if (bits & 128) culong++;
2779                             bits <<= 1;
2780                         }
2781                     }
2782                 }
2783                 break;
2784             }
2785             sv = NEWSV(35, len + 1);
2786             SvCUR_set(sv, len);
2787             SvPOK_on(sv);
2788             aptr = pat;                 /* borrow register */
2789             pat = SvPVX(sv);
2790             if (datumtype == 'b') {
2791                 aint = len;
2792                 for (len = 0; len < aint; len++) {
2793                     if (len & 7)                /*SUPPRESS 595*/
2794                         bits >>= 1;
2795                     else
2796                         bits = *s++;
2797                     *pat++ = '0' + (bits & 1);
2798                 }
2799             }
2800             else {
2801                 aint = len;
2802                 for (len = 0; len < aint; len++) {
2803                     if (len & 7)
2804                         bits <<= 1;
2805                     else
2806                         bits = *s++;
2807                     *pat++ = '0' + ((bits & 128) != 0);
2808                 }
2809             }
2810             *pat = '\0';
2811             pat = aptr;                 /* unborrow register */
2812             XPUSHs(sv_2mortal(sv));
2813             break;
2814         case 'H':
2815         case 'h':
2816             if (pat[-1] == '*' || len > (strend - s) * 2)
2817                 len = (strend - s) * 2;
2818             sv = NEWSV(35, len + 1);
2819             SvCUR_set(sv, len);
2820             SvPOK_on(sv);
2821             aptr = pat;                 /* borrow register */
2822             pat = SvPVX(sv);
2823             if (datumtype == 'h') {
2824                 aint = len;
2825                 for (len = 0; len < aint; len++) {
2826                     if (len & 1)
2827                         bits >>= 4;
2828                     else
2829                         bits = *s++;
2830                     *pat++ = hexdigit[bits & 15];
2831                 }
2832             }
2833             else {
2834                 aint = len;
2835                 for (len = 0; len < aint; len++) {
2836                     if (len & 1)
2837                         bits <<= 4;
2838                     else
2839                         bits = *s++;
2840                     *pat++ = hexdigit[(bits >> 4) & 15];
2841                 }
2842             }
2843             *pat = '\0';
2844             pat = aptr;                 /* unborrow register */
2845             XPUSHs(sv_2mortal(sv));
2846             break;
2847         case 'c':
2848             if (len > strend - s)
2849                 len = strend - s;
2850             if (checksum) {
2851                 while (len-- > 0) {
2852                     aint = *s++;
2853                     if (aint >= 128)    /* fake up signed chars */
2854                         aint -= 256;
2855                     culong += aint;
2856                 }
2857             }
2858             else {
2859                 EXTEND(SP, len);
2860                 EXTEND_MORTAL(len);
2861                 while (len-- > 0) {
2862                     aint = *s++;
2863                     if (aint >= 128)    /* fake up signed chars */
2864                         aint -= 256;
2865                     sv = NEWSV(36, 0);
2866                     sv_setiv(sv, (IV)aint);
2867                     PUSHs(sv_2mortal(sv));
2868                 }
2869             }
2870             break;
2871         case 'C':
2872             if (len > strend - s)
2873                 len = strend - s;
2874             if (checksum) {
2875               uchar_checksum:
2876                 while (len-- > 0) {
2877                     auint = *s++ & 255;
2878                     culong += auint;
2879                 }
2880             }
2881             else {
2882                 EXTEND(SP, len);
2883                 EXTEND_MORTAL(len);
2884                 while (len-- > 0) {
2885                     auint = *s++ & 255;
2886                     sv = NEWSV(37, 0);
2887                     sv_setiv(sv, (IV)auint);
2888                     PUSHs(sv_2mortal(sv));
2889                 }
2890             }
2891             break;
2892         case 's':
2893             along = (strend - s) / SIZE16;
2894             if (len > along)
2895                 len = along;
2896             if (checksum) {
2897                 while (len-- > 0) {
2898                     COPY16(s, &ashort);
2899                     s += SIZE16;
2900                     culong += ashort;
2901                 }
2902             }
2903             else {
2904                 EXTEND(SP, len);
2905                 EXTEND_MORTAL(len);
2906                 while (len-- > 0) {
2907                     COPY16(s, &ashort);
2908                     s += SIZE16;
2909                     sv = NEWSV(38, 0);
2910                     sv_setiv(sv, (IV)ashort);
2911                     PUSHs(sv_2mortal(sv));
2912                 }
2913             }
2914             break;
2915         case 'v':
2916         case 'n':
2917         case 'S':
2918             along = (strend - s) / SIZE16;
2919             if (len > along)
2920                 len = along;
2921             if (checksum) {
2922                 while (len-- > 0) {
2923                     COPY16(s, &aushort);
2924                     s += SIZE16;
2925 #ifdef HAS_NTOHS
2926                     if (datumtype == 'n')
2927                         aushort = ntohs(aushort);
2928 #endif
2929 #ifdef HAS_VTOHS
2930                     if (datumtype == 'v')
2931                         aushort = vtohs(aushort);
2932 #endif
2933                     culong += aushort;
2934                 }
2935             }
2936             else {
2937                 EXTEND(SP, len);
2938                 EXTEND_MORTAL(len);
2939                 while (len-- > 0) {
2940                     COPY16(s, &aushort);
2941                     s += SIZE16;
2942                     sv = NEWSV(39, 0);
2943 #ifdef HAS_NTOHS
2944                     if (datumtype == 'n')
2945                         aushort = ntohs(aushort);
2946 #endif
2947 #ifdef HAS_VTOHS
2948                     if (datumtype == 'v')
2949                         aushort = vtohs(aushort);
2950 #endif
2951                     sv_setiv(sv, (IV)aushort);
2952                     PUSHs(sv_2mortal(sv));
2953                 }
2954             }
2955             break;
2956         case 'i':
2957             along = (strend - s) / sizeof(int);
2958             if (len > along)
2959                 len = along;
2960             if (checksum) {
2961                 while (len-- > 0) {
2962                     Copy(s, &aint, 1, int);
2963                     s += sizeof(int);
2964                     if (checksum > 32)
2965                         cdouble += (double)aint;
2966                     else
2967                         culong += aint;
2968                 }
2969             }
2970             else {
2971                 EXTEND(SP, len);
2972                 EXTEND_MORTAL(len);
2973                 while (len-- > 0) {
2974                     Copy(s, &aint, 1, int);
2975                     s += sizeof(int);
2976                     sv = NEWSV(40, 0);
2977                     sv_setiv(sv, (IV)aint);
2978                     PUSHs(sv_2mortal(sv));
2979                 }
2980             }
2981             break;
2982         case 'I':
2983             along = (strend - s) / sizeof(unsigned int);
2984             if (len > along)
2985                 len = along;
2986             if (checksum) {
2987                 while (len-- > 0) {
2988                     Copy(s, &auint, 1, unsigned int);
2989                     s += sizeof(unsigned int);
2990                     if (checksum > 32)
2991                         cdouble += (double)auint;
2992                     else
2993                         culong += auint;
2994                 }
2995             }
2996             else {
2997                 EXTEND(SP, len);
2998                 EXTEND_MORTAL(len);
2999                 while (len-- > 0) {
3000                     Copy(s, &auint, 1, unsigned int);
3001                     s += sizeof(unsigned int);
3002                     sv = NEWSV(41, 0);
3003                     sv_setuv(sv, (UV)auint);
3004                     PUSHs(sv_2mortal(sv));
3005                 }
3006             }
3007             break;
3008         case 'l':
3009             along = (strend - s) / SIZE32;
3010             if (len > along)
3011                 len = along;
3012             if (checksum) {
3013                 while (len-- > 0) {
3014                     COPY32(s, &along);
3015                     s += SIZE32;
3016                     if (checksum > 32)
3017                         cdouble += (double)along;
3018                     else
3019                         culong += along;
3020                 }
3021             }
3022             else {
3023                 EXTEND(SP, len);
3024                 EXTEND_MORTAL(len);
3025                 while (len-- > 0) {
3026                     COPY32(s, &along);
3027                     s += SIZE32;
3028                     sv = NEWSV(42, 0);
3029                     sv_setiv(sv, (IV)along);
3030                     PUSHs(sv_2mortal(sv));
3031                 }
3032             }
3033             break;
3034         case 'V':
3035         case 'N':
3036         case 'L':
3037             along = (strend - s) / SIZE32;
3038             if (len > along)
3039                 len = along;
3040             if (checksum) {
3041                 while (len-- > 0) {
3042                     COPY32(s, &aulong);
3043                     s += SIZE32;
3044 #ifdef HAS_NTOHL
3045                     if (datumtype == 'N')
3046                         aulong = ntohl(aulong);
3047 #endif
3048 #ifdef HAS_VTOHL
3049                     if (datumtype == 'V')
3050                         aulong = vtohl(aulong);
3051 #endif
3052                     if (checksum > 32)
3053                         cdouble += (double)aulong;
3054                     else
3055                         culong += aulong;
3056                 }
3057             }
3058             else {
3059                 EXTEND(SP, len);
3060                 EXTEND_MORTAL(len);
3061                 while (len-- > 0) {
3062                     COPY32(s, &aulong);
3063                     s += SIZE32;
3064 #ifdef HAS_NTOHL
3065                     if (datumtype == 'N')
3066                         aulong = ntohl(aulong);
3067 #endif
3068 #ifdef HAS_VTOHL
3069                     if (datumtype == 'V')
3070                         aulong = vtohl(aulong);
3071 #endif
3072                     sv = NEWSV(43, 0);
3073                     sv_setuv(sv, (UV)aulong);
3074                     PUSHs(sv_2mortal(sv));
3075                 }
3076             }
3077             break;
3078         case 'p':
3079             along = (strend - s) / sizeof(char*);
3080             if (len > along)
3081                 len = along;
3082             EXTEND(SP, len);
3083             EXTEND_MORTAL(len);
3084             while (len-- > 0) {
3085                 if (sizeof(char*) > strend - s)
3086                     break;
3087                 else {
3088                     Copy(s, &aptr, 1, char*);
3089                     s += sizeof(char*);
3090                 }
3091                 sv = NEWSV(44, 0);
3092                 if (aptr)
3093                     sv_setpv(sv, aptr);
3094                 PUSHs(sv_2mortal(sv));
3095             }
3096             break;
3097         case 'w':
3098             EXTEND(SP, len);
3099             EXTEND_MORTAL(len);
3100             { 
3101                 UV auv = 0;
3102                 U32 bytes = 0;
3103                 
3104                 while ((len > 0) && (s < strend)) {
3105                     auv = (auv << 7) | (*s & 0x7f);
3106                     if (!(*s++ & 0x80)) {
3107                         bytes = 0;
3108                         sv = NEWSV(40, 0);
3109                         sv_setuv(sv, auv);
3110                         PUSHs(sv_2mortal(sv));
3111                         len--;
3112                         auv = 0;
3113                     }
3114                     else if (++bytes >= sizeof(UV)) {   /* promote to string */
3115                         char *t;
3116
3117                         sv = newSVpvf("%.*Vu", (int)TYPE_DIGITS(UV), auv);
3118                         while (s < strend) {
3119                             sv = mul128(sv, *s & 0x7f);
3120                             if (!(*s++ & 0x80)) {
3121                                 bytes = 0;
3122                                 break;
3123                             }
3124                         }
3125                         t = SvPV(sv, na);
3126                         while (*t == '0')
3127                             t++;
3128                         sv_chop(sv, t);
3129                         PUSHs(sv_2mortal(sv));
3130                         len--;
3131                         auv = 0;
3132                     }
3133                 }
3134                 if ((s >= strend) && bytes)
3135                     croak("Unterminated compressed integer");
3136             }
3137             break;
3138         case 'P':
3139             EXTEND(SP, 1);
3140             if (sizeof(char*) > strend - s)
3141                 break;
3142             else {
3143                 Copy(s, &aptr, 1, char*);
3144                 s += sizeof(char*);
3145             }
3146             sv = NEWSV(44, 0);
3147             if (aptr)
3148                 sv_setpvn(sv, aptr, len);
3149             PUSHs(sv_2mortal(sv));
3150             break;
3151 #ifdef HAS_QUAD
3152         case 'q':
3153             EXTEND(SP, len);
3154             EXTEND_MORTAL(len);
3155             while (len-- > 0) {
3156                 if (s + sizeof(Quad_t) > strend)
3157                     aquad = 0;
3158                 else {
3159                     Copy(s, &aquad, 1, Quad_t);
3160                     s += sizeof(Quad_t);
3161                 }
3162                 sv = NEWSV(42, 0);
3163                 if (aquad >= IV_MIN && aquad <= IV_MAX)
3164                     sv_setiv(sv, (IV)aquad);
3165                 else
3166                     sv_setnv(sv, (double)aquad);
3167                 PUSHs(sv_2mortal(sv));
3168             }
3169             break;
3170         case 'Q':
3171             EXTEND(SP, len);
3172             EXTEND_MORTAL(len);
3173             while (len-- > 0) {
3174                 if (s + sizeof(unsigned Quad_t) > strend)
3175                     auquad = 0;
3176                 else {
3177                     Copy(s, &auquad, 1, unsigned Quad_t);
3178                     s += sizeof(unsigned Quad_t);
3179                 }
3180                 sv = NEWSV(43, 0);
3181                 if (aquad <= UV_MAX)
3182                     sv_setuv(sv, (UV)auquad);
3183                 else
3184                     sv_setnv(sv, (double)auquad);
3185                 PUSHs(sv_2mortal(sv));
3186             }
3187             break;
3188 #endif
3189         /* float and double added gnb@melba.bby.oz.au 22/11/89 */
3190         case 'f':
3191         case 'F':
3192             along = (strend - s) / sizeof(float);
3193             if (len > along)
3194                 len = along;
3195             if (checksum) {
3196                 while (len-- > 0) {
3197                     Copy(s, &afloat, 1, float);
3198                     s += sizeof(float);
3199                     cdouble += afloat;
3200                 }
3201             }
3202             else {
3203                 EXTEND(SP, len);
3204                 EXTEND_MORTAL(len);
3205                 while (len-- > 0) {
3206                     Copy(s, &afloat, 1, float);
3207                     s += sizeof(float);
3208                     sv = NEWSV(47, 0);
3209                     sv_setnv(sv, (double)afloat);
3210                     PUSHs(sv_2mortal(sv));
3211                 }
3212             }
3213             break;
3214         case 'd':
3215         case 'D':
3216             along = (strend - s) / sizeof(double);
3217             if (len > along)
3218                 len = along;
3219             if (checksum) {
3220                 while (len-- > 0) {
3221                     Copy(s, &adouble, 1, double);
3222                     s += sizeof(double);
3223                     cdouble += adouble;
3224                 }
3225             }
3226             else {
3227                 EXTEND(SP, len);
3228                 EXTEND_MORTAL(len);
3229                 while (len-- > 0) {
3230                     Copy(s, &adouble, 1, double);
3231                     s += sizeof(double);
3232                     sv = NEWSV(48, 0);
3233                     sv_setnv(sv, (double)adouble);
3234                     PUSHs(sv_2mortal(sv));
3235                 }
3236             }
3237             break;
3238         case 'u':
3239             along = (strend - s) * 3 / 4;
3240             sv = NEWSV(42, along);
3241             if (along)
3242                 SvPOK_on(sv);
3243             while (s < strend && *s > ' ' && *s < 'a') {
3244                 I32 a, b, c, d;
3245                 char hunk[4];
3246
3247                 hunk[3] = '\0';
3248                 len = (*s++ - ' ') & 077;
3249                 while (len > 0) {
3250                     if (s < strend && *s >= ' ')
3251                         a = (*s++ - ' ') & 077;
3252                     else
3253                         a = 0;
3254                     if (s < strend && *s >= ' ')
3255                         b = (*s++ - ' ') & 077;
3256                     else
3257                         b = 0;
3258                     if (s < strend && *s >= ' ')
3259                         c = (*s++ - ' ') & 077;
3260                     else
3261                         c = 0;
3262                     if (s < strend && *s >= ' ')
3263                         d = (*s++ - ' ') & 077;
3264                     else
3265                         d = 0;
3266                     hunk[0] = a << 2 | b >> 4;
3267                     hunk[1] = b << 4 | c >> 2;
3268                     hunk[2] = c << 6 | d;
3269                     sv_catpvn(sv, hunk, len > 3 ? 3 : len);
3270                     len -= 3;
3271                 }
3272                 if (*s == '\n')
3273                     s++;
3274                 else if (s[1] == '\n')          /* possible checksum byte */
3275                     s += 2;
3276             }
3277             XPUSHs(sv_2mortal(sv));
3278             break;
3279         }
3280         if (checksum) {
3281             sv = NEWSV(42, 0);
3282             if (strchr("fFdD", datumtype) ||
3283               (checksum > 32 && strchr("iIlLN", datumtype)) ) {
3284                 double trouble;
3285
3286                 adouble = 1.0;
3287                 while (checksum >= 16) {
3288                     checksum -= 16;
3289                     adouble *= 65536.0;
3290                 }
3291                 while (checksum >= 4) {
3292                     checksum -= 4;
3293                     adouble *= 16.0;
3294                 }
3295                 while (checksum--)
3296                     adouble *= 2.0;
3297                 along = (1 << checksum) - 1;
3298                 while (cdouble < 0.0)
3299                     cdouble += adouble;
3300                 cdouble = modf(cdouble / adouble, &trouble) * adouble;
3301                 sv_setnv(sv, cdouble);
3302             }
3303             else {
3304                 if (checksum < 32) {
3305                     aulong = (1 << checksum) - 1;
3306                     culong &= aulong;
3307                 }
3308                 sv_setuv(sv, (UV)culong);
3309             }
3310             XPUSHs(sv_2mortal(sv));
3311             checksum = 0;
3312         }
3313     }
3314     if (sp == oldsp && gimme == G_SCALAR)
3315         PUSHs(&sv_undef);
3316     RETURN;
3317 }
3318
3319 static void
3320 doencodes(sv, s, len)
3321 register SV *sv;
3322 register char *s;
3323 register I32 len;
3324 {
3325     char hunk[5];
3326
3327     *hunk = len + ' ';
3328     sv_catpvn(sv, hunk, 1);
3329     hunk[4] = '\0';
3330     while (len > 0) {
3331         hunk[0] = ' ' + (077 & (*s >> 2));
3332         hunk[1] = ' ' + (077 & ((*s << 4) & 060 | (s[1] >> 4) & 017));
3333         hunk[2] = ' ' + (077 & ((s[1] << 2) & 074 | (s[2] >> 6) & 03));
3334         hunk[3] = ' ' + (077 & (s[2] & 077));
3335         sv_catpvn(sv, hunk, 4);
3336         s += 3;
3337         len -= 3;
3338     }
3339     for (s = SvPVX(sv); *s; s++) {
3340         if (*s == ' ')
3341             *s = '`';
3342     }
3343     sv_catpvn(sv, "\n", 1);
3344 }
3345
3346 static SV      *
3347 is_an_int(s, l)
3348      char           *s;
3349      STRLEN          l;
3350 {
3351   SV             *result = newSVpv("", l);
3352   char           *result_c = SvPV(result, na);  /* convenience */
3353   char           *out = result_c;
3354   bool            skip = 1;
3355   bool            ignore = 0;
3356
3357   while (*s) {
3358     switch (*s) {
3359     case ' ':
3360       break;
3361     case '+':
3362       if (!skip) {
3363         SvREFCNT_dec(result);
3364         return (NULL);
3365       }
3366       break;
3367     case '0':
3368     case '1':
3369     case '2':
3370     case '3':
3371     case '4':
3372     case '5':
3373     case '6':
3374     case '7':
3375     case '8':
3376     case '9':
3377       skip = 0;
3378       if (!ignore) {
3379         *(out++) = *s;
3380       }
3381       break;
3382     case '.':
3383       ignore = 1;
3384       break;
3385     default:
3386       SvREFCNT_dec(result);
3387       return (NULL);
3388     }
3389     s++;
3390   }
3391   *(out++) = '\0';
3392   SvCUR_set(result, out - result_c);
3393   return (result);
3394 }
3395
3396 static int
3397 div128(pnum, done)
3398      SV             *pnum;                  /* must be '\0' terminated */
3399      bool           *done;
3400 {
3401   STRLEN          len;
3402   char           *s = SvPV(pnum, len);
3403   int             m = 0;
3404   int             r = 0;
3405   char           *t = s;
3406
3407   *done = 1;
3408   while (*t) {
3409     int             i;
3410
3411     i = m * 10 + (*t - '0');
3412     m = i & 0x7F;
3413     r = (i >> 7);               /* r < 10 */
3414     if (r) {
3415       *done = 0;
3416     }
3417     *(t++) = '0' + r;
3418   }
3419   *(t++) = '\0';
3420   SvCUR_set(pnum, (STRLEN) (t - s));
3421   return (m);
3422 }
3423
3424
3425 PP(pp_pack)
3426 {
3427     dSP; dMARK; dORIGMARK; dTARGET;
3428     register SV *cat = TARG;
3429     register I32 items;
3430     STRLEN fromlen;
3431     register char *pat = SvPVx(*++MARK, fromlen);
3432     register char *patend = pat + fromlen;
3433     register I32 len;
3434     I32 datumtype;
3435     SV *fromstr;
3436     /*SUPPRESS 442*/
3437     static char null10[] = {0,0,0,0,0,0,0,0,0,0};
3438     static char *space10 = "          ";
3439
3440     /* These must not be in registers: */
3441     char achar;
3442     I16 ashort;
3443     int aint;
3444     unsigned int auint;
3445     I32 along;
3446     U32 aulong;
3447 #ifdef HAS_QUAD
3448     Quad_t aquad;
3449     unsigned Quad_t auquad;
3450 #endif
3451     char *aptr;
3452     float afloat;
3453     double adouble;
3454
3455     items = SP - MARK;
3456     MARK++;
3457     sv_setpvn(cat, "", 0);
3458     while (pat < patend) {
3459 #define NEXTFROM (items-- > 0 ? *MARK++ : &sv_no)
3460         datumtype = *pat++ & 0xFF;
3461         if (isSPACE(datumtype))
3462             continue;
3463         if (*pat == '*') {
3464             len = strchr("@Xxu", datumtype) ? 0 : items;
3465             pat++;
3466         }
3467         else if (isDIGIT(*pat)) {
3468             len = *pat++ - '0';
3469             while (isDIGIT(*pat))
3470                 len = (len * 10) + (*pat++ - '0');
3471         }
3472         else
3473             len = 1;
3474         switch(datumtype) {
3475         default:
3476             croak("Invalid type in pack: '%c'", (int)datumtype);
3477         case '%':
3478             DIE("%% may only be used in unpack");
3479         case '@':
3480             len -= SvCUR(cat);
3481             if (len > 0)
3482                 goto grow;
3483             len = -len;
3484             if (len > 0)
3485                 goto shrink;
3486             break;
3487         case 'X':
3488           shrink:
3489             if (SvCUR(cat) < len)
3490                 DIE("X outside of string");
3491             SvCUR(cat) -= len;
3492             *SvEND(cat) = '\0';
3493             break;
3494         case 'x':
3495           grow:
3496             while (len >= 10) {
3497                 sv_catpvn(cat, null10, 10);
3498                 len -= 10;
3499             }
3500             sv_catpvn(cat, null10, len);
3501             break;
3502         case 'A':
3503         case 'a':
3504             fromstr = NEXTFROM;
3505             aptr = SvPV(fromstr, fromlen);
3506             if (pat[-1] == '*')
3507                 len = fromlen;
3508             if (fromlen > len)
3509                 sv_catpvn(cat, aptr, len);
3510             else {
3511                 sv_catpvn(cat, aptr, fromlen);
3512                 len -= fromlen;
3513                 if (datumtype == 'A') {
3514                     while (len >= 10) {
3515                         sv_catpvn(cat, space10, 10);
3516                         len -= 10;
3517                     }
3518                     sv_catpvn(cat, space10, len);
3519                 }
3520                 else {
3521                     while (len >= 10) {
3522                         sv_catpvn(cat, null10, 10);
3523                         len -= 10;
3524                     }
3525                     sv_catpvn(cat, null10, len);
3526                 }
3527             }
3528             break;
3529         case 'B':
3530         case 'b':
3531             {
3532                 char *savepat = pat;
3533                 I32 saveitems;
3534
3535                 fromstr = NEXTFROM;
3536                 saveitems = items;
3537                 aptr = SvPV(fromstr, fromlen);
3538                 if (pat[-1] == '*')
3539                     len = fromlen;
3540                 pat = aptr;
3541                 aint = SvCUR(cat);
3542                 SvCUR(cat) += (len+7)/8;
3543                 SvGROW(cat, SvCUR(cat) + 1);
3544                 aptr = SvPVX(cat) + aint;
3545                 if (len > fromlen)
3546                     len = fromlen;
3547                 aint = len;
3548                 items = 0;
3549                 if (datumtype == 'B') {
3550                     for (len = 0; len++ < aint;) {
3551                         items |= *pat++ & 1;
3552                         if (len & 7)
3553                             items <<= 1;
3554                         else {
3555                             *aptr++ = items & 0xff;
3556                             items = 0;
3557                         }
3558                     }
3559                 }
3560                 else {
3561                     for (len = 0; len++ < aint;) {
3562                         if (*pat++ & 1)
3563                             items |= 128;
3564                         if (len & 7)
3565                             items >>= 1;
3566                         else {
3567                             *aptr++ = items & 0xff;
3568                             items = 0;
3569                         }
3570                     }
3571                 }
3572                 if (aint & 7) {
3573                     if (datumtype == 'B')
3574                         items <<= 7 - (aint & 7);
3575                     else
3576                         items >>= 7 - (aint & 7);
3577                     *aptr++ = items & 0xff;
3578                 }
3579                 pat = SvPVX(cat) + SvCUR(cat);
3580                 while (aptr <= pat)
3581                     *aptr++ = '\0';
3582
3583                 pat = savepat;
3584                 items = saveitems;
3585             }
3586             break;
3587         case 'H':
3588         case 'h':
3589             {
3590                 char *savepat = pat;
3591                 I32 saveitems;
3592
3593                 fromstr = NEXTFROM;
3594                 saveitems = items;
3595                 aptr = SvPV(fromstr, fromlen);
3596                 if (pat[-1] == '*')
3597                     len = fromlen;
3598                 pat = aptr;
3599                 aint = SvCUR(cat);
3600                 SvCUR(cat) += (len+1)/2;
3601                 SvGROW(cat, SvCUR(cat) + 1);
3602                 aptr = SvPVX(cat) + aint;
3603                 if (len > fromlen)
3604                     len = fromlen;
3605                 aint = len;
3606                 items = 0;
3607                 if (datumtype == 'H') {
3608                     for (len = 0; len++ < aint;) {
3609                         if (isALPHA(*pat))
3610                             items |= ((*pat++ & 15) + 9) & 15;
3611                         else
3612                             items |= *pat++ & 15;
3613                         if (len & 1)
3614                             items <<= 4;
3615                         else {
3616                             *aptr++ = items & 0xff;
3617                             items = 0;
3618                         }
3619                     }
3620                 }
3621                 else {
3622                     for (len = 0; len++ < aint;) {
3623                         if (isALPHA(*pat))
3624                             items |= (((*pat++ & 15) + 9) & 15) << 4;
3625                         else
3626                             items |= (*pat++ & 15) << 4;
3627                         if (len & 1)
3628                             items >>= 4;
3629                         else {
3630                             *aptr++ = items & 0xff;
3631                             items = 0;
3632                         }
3633                     }
3634                 }
3635                 if (aint & 1)
3636                     *aptr++ = items & 0xff;
3637                 pat = SvPVX(cat) + SvCUR(cat);
3638                 while (aptr <= pat)
3639                     *aptr++ = '\0';
3640
3641                 pat = savepat;
3642                 items = saveitems;
3643             }
3644             break;
3645         case 'C':
3646         case 'c':
3647             while (len-- > 0) {
3648                 fromstr = NEXTFROM;
3649                 aint = SvIV(fromstr);
3650                 achar = aint;
3651                 sv_catpvn(cat, &achar, sizeof(char));
3652             }
3653             break;
3654         /* Float and double added by gnb@melba.bby.oz.au  22/11/89 */
3655         case 'f':
3656         case 'F':
3657             while (len-- > 0) {
3658                 fromstr = NEXTFROM;
3659                 afloat = (float)SvNV(fromstr);
3660                 sv_catpvn(cat, (char *)&afloat, sizeof (float));
3661             }
3662             break;
3663         case 'd':
3664         case 'D':
3665             while (len-- > 0) {
3666                 fromstr = NEXTFROM;
3667                 adouble = (double)SvNV(fromstr);
3668                 sv_catpvn(cat, (char *)&adouble, sizeof (double));
3669             }
3670             break;
3671         case 'n':
3672             while (len-- > 0) {
3673                 fromstr = NEXTFROM;
3674                 ashort = (I16)SvIV(fromstr);
3675 #ifdef HAS_HTONS
3676                 ashort = htons(ashort);
3677 #endif
3678                 CAT16(cat, &ashort);
3679             }
3680             break;
3681         case 'v':
3682             while (len-- > 0) {
3683                 fromstr = NEXTFROM;
3684                 ashort = (I16)SvIV(fromstr);
3685 #ifdef HAS_HTOVS
3686                 ashort = htovs(ashort);
3687 #endif
3688                 CAT16(cat, &ashort);
3689             }
3690             break;
3691         case 'S':
3692         case 's':
3693             while (len-- > 0) {
3694                 fromstr = NEXTFROM;
3695                 ashort = (I16)SvIV(fromstr);
3696                 CAT16(cat, &ashort);
3697             }
3698             break;
3699         case 'I':
3700             while (len-- > 0) {
3701                 fromstr = NEXTFROM;
3702                 auint = SvUV(fromstr);
3703                 sv_catpvn(cat, (char*)&auint, sizeof(unsigned int));
3704             }
3705             break;
3706         case 'w':
3707             while (len-- > 0) {
3708                 fromstr = NEXTFROM;
3709                 adouble = floor(SvNV(fromstr));
3710
3711                 if (adouble < 0)
3712                     croak("Cannot compress negative numbers");
3713
3714                 if (
3715 #ifdef BW_BITS
3716                     adouble <= BW_MASK
3717 #else
3718                     adouble <= UV_MAX
3719 #endif
3720                     )
3721                 {
3722                     char   buf[1 + sizeof(UV)];
3723                     char  *in = buf + sizeof(buf);
3724                     UV     auv = U_V(adouble);;
3725
3726                     do {
3727                         *--in = (auv & 0x7f) | 0x80;
3728                         auv >>= 7;
3729                     } while (auv);
3730                     buf[sizeof(buf) - 1] &= 0x7f; /* clear continue bit */
3731                     sv_catpvn(cat, in, (buf + sizeof(buf)) - in);
3732                 }
3733                 else if (SvPOKp(fromstr)) {  /* decimal string arithmetics */
3734                     char           *from, *result, *in;
3735                     SV             *norm;
3736                     STRLEN          len;
3737                     bool            done;
3738             
3739                     /* Copy string and check for compliance */
3740                     from = SvPV(fromstr, len);
3741                     if ((norm = is_an_int(from, len)) == NULL)
3742                         croak("can compress only unsigned integer");
3743
3744                     New('w', result, len, char);
3745                     in = result + len;
3746                     done = FALSE;
3747                     while (!done)
3748                         *--in = div128(norm, &done) | 0x80;
3749                     result[len - 1] &= 0x7F; /* clear continue bit */
3750                     sv_catpvn(cat, in, (result + len) - in);
3751                     Safefree(result);
3752                     SvREFCNT_dec(norm); /* free norm */
3753                 }
3754                 else if (SvNOKp(fromstr)) {
3755                     char   buf[sizeof(double) * 2];     /* 8/7 <= 2 */
3756                     char  *in = buf + sizeof(buf);
3757
3758                     do {
3759                         double next = floor(adouble / 128);
3760                         *--in = (unsigned char)(adouble - (next * 128)) | 0x80;
3761                         if (--in < buf)  /* this cannot happen ;-) */
3762                             croak ("Cannot compress integer");
3763                         adouble = next;
3764                     } while (adouble > 0);
3765                     buf[sizeof(buf) - 1] &= 0x7f; /* clear continue bit */
3766                     sv_catpvn(cat, in, (buf + sizeof(buf)) - in);
3767                 }
3768                 else
3769                     croak("Cannot compress non integer");
3770             }
3771             break;
3772         case 'i':
3773             while (len-- > 0) {
3774                 fromstr = NEXTFROM;
3775                 aint = SvIV(fromstr);
3776                 sv_catpvn(cat, (char*)&aint, sizeof(int));
3777             }
3778             break;
3779         case 'N':
3780             while (len-- > 0) {
3781                 fromstr = NEXTFROM;
3782                 aulong = SvUV(fromstr);
3783 #ifdef HAS_HTONL
3784                 aulong = htonl(aulong);
3785 #endif
3786                 CAT32(cat, &aulong);
3787             }
3788             break;
3789         case 'V':
3790             while (len-- > 0) {
3791                 fromstr = NEXTFROM;
3792                 aulong = SvUV(fromstr);
3793 #ifdef HAS_HTOVL
3794                 aulong = htovl(aulong);
3795 #endif
3796                 CAT32(cat, &aulong);
3797             }
3798             break;
3799         case 'L':
3800             while (len-- > 0) {
3801                 fromstr = NEXTFROM;
3802                 aulong = SvUV(fromstr);
3803                 CAT32(cat, &aulong);
3804             }
3805             break;
3806         case 'l':
3807             while (len-- > 0) {
3808                 fromstr = NEXTFROM;
3809                 along = SvIV(fromstr);
3810                 CAT32(cat, &along);
3811             }
3812             break;
3813 #ifdef HAS_QUAD
3814         case 'Q':
3815             while (len-- > 0) {
3816                 fromstr = NEXTFROM;
3817                 auquad = (unsigned Quad_t)SvIV(fromstr);
3818                 sv_catpvn(cat, (char*)&auquad, sizeof(unsigned Quad_t));
3819             }
3820             break;
3821         case 'q':
3822             while (len-- > 0) {
3823                 fromstr = NEXTFROM;
3824                 aquad = (Quad_t)SvIV(fromstr);
3825                 sv_catpvn(cat, (char*)&aquad, sizeof(Quad_t));
3826             }
3827             break;
3828 #endif /* HAS_QUAD */
3829         case 'P':
3830             len = 1;            /* assume SV is correct length */
3831             /* FALL THROUGH */
3832         case 'p':
3833             while (len-- > 0) {
3834                 fromstr = NEXTFROM;
3835                 aptr = SvPV_force(fromstr, na); /* XXX Error if TEMP? */
3836                 sv_catpvn(cat, (char*)&aptr, sizeof(char*));
3837             }
3838             break;
3839         case 'u':
3840             fromstr = NEXTFROM;
3841             aptr = SvPV(fromstr, fromlen);
3842             SvGROW(cat, fromlen * 4 / 3);
3843             if (len <= 1)
3844                 len = 45;
3845             else
3846                 len = len / 3 * 3;
3847             while (fromlen > 0) {
3848                 I32 todo;
3849
3850                 if (fromlen > len)
3851                     todo = len;
3852                 else
3853                     todo = fromlen;
3854                 doencodes(cat, aptr, todo);
3855                 fromlen -= todo;
3856                 aptr += todo;
3857             }
3858             break;
3859         }
3860     }
3861     SvSETMAGIC(cat);
3862     SP = ORIGMARK;
3863     PUSHs(cat);
3864     RETURN;
3865 }
3866 #undef NEXTFROM
3867
3868 PP(pp_split)
3869 {
3870     dSP; dTARG;
3871     AV *ary;
3872     register I32 limit = POPi;                  /* note, negative is forever */
3873     SV *sv = POPs;
3874     STRLEN len;
3875     register char *s = SvPV(sv, len);
3876     char *strend = s + len;
3877     register PMOP *pm;
3878     register REGEXP *rx;
3879     register SV *dstr;
3880     register char *m;
3881     I32 iters = 0;
3882     I32 maxiters = (strend - s) + 10;
3883     I32 i;
3884     char *orig;
3885     I32 origlimit = limit;
3886     I32 realarray = 0;
3887     I32 base;
3888     AV *oldstack = curstack;
3889     I32 gimme = GIMME_V;
3890     I32 oldsave = savestack_ix;
3891
3892 #ifdef DEBUGGING
3893     Copy(&LvTARGOFF(POPs), &pm, 1, PMOP*);
3894 #else
3895     pm = (PMOP*)POPs;
3896 #endif
3897     if (!pm || !s)
3898         DIE("panic: do_split");
3899     rx = pm->op_pmregexp;
3900
3901     TAINT_IF((pm->op_pmflags & PMf_LOCALE) &&
3902              (pm->op_pmflags & (PMf_WHITE | PMf_SKIPWHITE)));
3903
3904     if (pm->op_pmreplroot)
3905         ary = GvAVn((GV*)pm->op_pmreplroot);
3906     else if (gimme != G_ARRAY)
3907         ary = GvAVn(defgv);
3908     else
3909         ary = Nullav;
3910     if (ary && (gimme != G_ARRAY || (pm->op_pmflags & PMf_ONCE))) {
3911         realarray = 1;
3912         if (!AvREAL(ary)) {
3913             AvREAL_on(ary);
3914             for (i = AvFILL(ary); i >= 0; i--)
3915                 AvARRAY(ary)[i] = &sv_undef;    /* don't free mere refs */
3916         }
3917         av_extend(ary,0);
3918         av_clear(ary);
3919         /* temporarily switch stacks */
3920         SWITCHSTACK(curstack, ary);
3921     }
3922     base = SP - stack_base;
3923     orig = s;
3924     if (pm->op_pmflags & PMf_SKIPWHITE) {
3925         if (pm->op_pmflags & PMf_LOCALE) {
3926             while (isSPACE_LC(*s))
3927                 s++;
3928         }
3929         else {
3930             while (isSPACE(*s))
3931                 s++;
3932         }
3933     }
3934     if (pm->op_pmflags & (PMf_MULTILINE|PMf_SINGLELINE)) {
3935         SAVEINT(multiline);
3936         multiline = pm->op_pmflags & PMf_MULTILINE;
3937     }
3938
3939     if (!limit)
3940         limit = maxiters + 2;
3941     if (pm->op_pmflags & PMf_WHITE) {
3942         while (--limit) {
3943             m = s;
3944             while (m < strend &&
3945                    !((pm->op_pmflags & PMf_LOCALE)
3946                      ? isSPACE_LC(*m) : isSPACE(*m)))
3947                 ++m;
3948             if (m >= strend)
3949                 break;
3950
3951             dstr = NEWSV(30, m-s);
3952             sv_setpvn(dstr, s, m-s);
3953             if (!realarray)
3954                 sv_2mortal(dstr);
3955             XPUSHs(dstr);
3956
3957             s = m + 1;
3958             while (s < strend &&
3959                    ((pm->op_pmflags & PMf_LOCALE)
3960                     ? isSPACE_LC(*s) : isSPACE(*s)))
3961                 ++s;
3962         }
3963     }
3964     else if (strEQ("^", rx->precomp)) {
3965         while (--limit) {
3966             /*SUPPRESS 530*/
3967             for (m = s; m < strend && *m != '\n'; m++) ;
3968             m++;
3969             if (m >= strend)
3970                 break;
3971             dstr = NEWSV(30, m-s);
3972             sv_setpvn(dstr, s, m-s);
3973             if (!realarray)
3974                 sv_2mortal(dstr);
3975             XPUSHs(dstr);
3976             s = m;
3977         }
3978     }
3979     else if (pm->op_pmshort && !rx->nparens) {
3980         i = SvCUR(pm->op_pmshort);
3981         if (i == 1) {
3982             i = *SvPVX(pm->op_pmshort);
3983             while (--limit) {
3984                 /*SUPPRESS 530*/
3985                 for (m = s; m < strend && *m != i; m++) ;
3986                 if (m >= strend)
3987                     break;
3988                 dstr = NEWSV(30, m-s);
3989                 sv_setpvn(dstr, s, m-s);
3990                 if (!realarray)
3991                     sv_2mortal(dstr);
3992                 XPUSHs(dstr);
3993                 s = m + 1;
3994             }
3995         }
3996         else {
3997 #ifndef lint
3998             while (s < strend && --limit &&
3999               (m=fbm_instr((unsigned char*)s, (unsigned char*)strend,
4000                     pm->op_pmshort)) )
4001 #endif
4002             {
4003                 dstr = NEWSV(31, m-s);
4004                 sv_setpvn(dstr, s, m-s);
4005                 if (!realarray)
4006                     sv_2mortal(dstr);
4007                 XPUSHs(dstr);
4008                 s = m + i;
4009             }
4010         }
4011     }
4012     else {
4013         maxiters += (strend - s) * rx->nparens;
4014         while (s < strend && --limit &&
4015                pregexec(rx, s, strend, orig, 1, Nullsv, TRUE))
4016         {
4017             TAINT_IF(rx->exec_tainted);
4018             if (rx->subbase
4019               && rx->subbase != orig) {
4020                 m = s;
4021                 s = orig;
4022                 orig = rx->subbase;
4023                 s = orig + (m - s);
4024                 strend = s + (strend - m);
4025             }
4026             m = rx->startp[0];
4027             dstr = NEWSV(32, m-s);
4028             sv_setpvn(dstr, s, m-s);
4029             if (!realarray)
4030                 sv_2mortal(dstr);
4031             XPUSHs(dstr);
4032             if (rx->nparens) {
4033                 for (i = 1; i <= rx->nparens; i++) {
4034                     s = rx->startp[i];
4035                     m = rx->endp[i];
4036                     if (m && s) {
4037                         dstr = NEWSV(33, m-s);
4038                         sv_setpvn(dstr, s, m-s);
4039                     }
4040                     else
4041                         dstr = NEWSV(33, 0);
4042                     if (!realarray)
4043                         sv_2mortal(dstr);
4044                     XPUSHs(dstr);
4045                 }
4046             }
4047             s = rx->endp[0];
4048         }
4049     }
4050     LEAVE_SCOPE(oldsave);
4051     iters = (SP - stack_base) - base;
4052     if (iters > maxiters)
4053         DIE("Split loop");
4054     
4055     /* keep field after final delim? */
4056     if (s < strend || (iters && origlimit)) {
4057         dstr = NEWSV(34, strend-s);
4058         sv_setpvn(dstr, s, strend-s);
4059         if (!realarray)
4060             sv_2mortal(dstr);
4061         XPUSHs(dstr);
4062         iters++;
4063     }
4064     else if (!origlimit) {
4065         while (iters > 0 && (!TOPs || !SvANY(TOPs) || SvCUR(TOPs) == 0))
4066             iters--, SP--;
4067     }
4068     if (realarray) {
4069         SWITCHSTACK(ary, oldstack);
4070         if (gimme == G_ARRAY) {
4071             EXTEND(SP, iters);
4072             Copy(AvARRAY(ary), SP + 1, iters, SV*);
4073             SP += iters;
4074             RETURN;
4075         }
4076     }
4077     else {
4078         if (gimme == G_ARRAY)
4079             RETURN;
4080     }
4081     if (iters || !pm->op_pmreplroot) {
4082         GETTARGET;
4083         PUSHi(iters);
4084         RETURN;
4085     }
4086     RETPUSHUNDEF;
4087 }
4088