Commit | Line | Data |
a0d0e21e |
1 | /* doop.c |
79072805 |
2 | * |
a0d0e21e |
3 | * Copyright (c) 1991-1994, Larry Wall |
79072805 |
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 | * |
a0d0e21e |
8 | */ |
9 | |
10 | /* |
11 | * "'So that was the job I felt I had to do when I started,' thought Sam." |
79072805 |
12 | */ |
13 | |
14 | #include "EXTERN.h" |
15 | #include "perl.h" |
16 | |
17 | #if !defined(NSIG) || defined(M_UNIX) || defined(M_XENIX) |
18 | #include <signal.h> |
19 | #endif |
20 | |
79072805 |
21 | I32 |
22 | do_trans(sv,arg) |
23 | SV *sv; |
24 | OP *arg; |
25 | { |
26 | register short *tbl; |
1476d272 |
27 | register U8 *s; |
28 | register U8 *send; |
29 | register U8 *d; |
79072805 |
30 | register I32 ch; |
1476d272 |
31 | register I32 matches = 0; |
79072805 |
32 | register I32 squash = op->op_private & OPpTRANS_SQUASH; |
463ee0b2 |
33 | STRLEN len; |
79072805 |
34 | |
a0d0e21e |
35 | if (SvREADONLY(sv)) |
36 | croak(no_modify); |
1476d272 |
37 | tbl = (short*)cPVOP->op_pv; |
38 | s = (U8*)SvPV(sv, len); |
a0d0e21e |
39 | if (!len) |
40 | return 0; |
41 | if (!SvPOKp(sv)) |
1476d272 |
42 | s = (U8*)SvPV_force(sv, len); |
a0d0e21e |
43 | (void)SvPOK_only(sv); |
463ee0b2 |
44 | send = s + len; |
79072805 |
45 | if (!tbl || !s) |
463ee0b2 |
46 | croak("panic: do_trans"); |
79072805 |
47 | DEBUG_t( deb("2.TBL\n")); |
48 | if (!op->op_private) { |
49 | while (s < send) { |
1476d272 |
50 | if ((ch = tbl[*s]) >= 0) { |
79072805 |
51 | matches++; |
52 | *s = ch; |
53 | } |
54 | s++; |
55 | } |
56 | } |
57 | else { |
58 | d = s; |
59 | while (s < send) { |
1476d272 |
60 | if ((ch = tbl[*s]) >= 0) { |
79072805 |
61 | *d = ch; |
62 | if (matches++ && squash) { |
63 | if (d[-1] == *d) |
64 | matches--; |
65 | else |
66 | d++; |
67 | } |
68 | else |
69 | d++; |
70 | } |
71 | else if (ch == -1) /* -1 is unmapped character */ |
72 | *d++ = *s; /* -2 is delete character */ |
73 | s++; |
74 | } |
75 | matches += send - d; /* account for disappeared chars */ |
76 | *d = '\0'; |
1476d272 |
77 | SvCUR_set(sv, d - (U8*)SvPVX(sv)); |
79072805 |
78 | } |
79 | SvSETMAGIC(sv); |
80 | return matches; |
81 | } |
82 | |
83 | void |
84 | do_join(sv,del,mark,sp) |
85 | register SV *sv; |
86 | SV *del; |
87 | register SV **mark; |
88 | register SV **sp; |
89 | { |
90 | SV **oldmark = mark; |
91 | register I32 items = sp - mark; |
79072805 |
92 | register STRLEN len; |
463ee0b2 |
93 | STRLEN delimlen; |
94 | register char *delim = SvPV(del, delimlen); |
95 | STRLEN tmplen; |
79072805 |
96 | |
97 | mark++; |
98 | len = (items > 0 ? (delimlen * (items - 1) ) : 0); |
99 | if (SvTYPE(sv) < SVt_PV) |
100 | sv_upgrade(sv, SVt_PV); |
101 | if (SvLEN(sv) < len + items) { /* current length is way too short */ |
102 | while (items-- > 0) { |
103 | if (*mark) { |
463ee0b2 |
104 | SvPV(*mark, tmplen); |
105 | len += tmplen; |
79072805 |
106 | } |
107 | mark++; |
108 | } |
109 | SvGROW(sv, len + 1); /* so try to pre-extend */ |
110 | |
111 | mark = oldmark; |
112 | items = sp - mark;; |
113 | ++mark; |
114 | } |
115 | |
463ee0b2 |
116 | if (items-- > 0) { |
8990e307 |
117 | char *s; |
118 | |
119 | if (*mark) { |
120 | s = SvPV(*mark, tmplen); |
121 | sv_setpvn(sv, s, tmplen); |
122 | } |
123 | else |
124 | sv_setpv(sv, ""); |
463ee0b2 |
125 | mark++; |
126 | } |
79072805 |
127 | else |
128 | sv_setpv(sv,""); |
129 | len = delimlen; |
130 | if (len) { |
131 | for (; items > 0; items--,mark++) { |
132 | sv_catpvn(sv,delim,len); |
133 | sv_catsv(sv,*mark); |
134 | } |
135 | } |
136 | else { |
137 | for (; items > 0; items--,mark++) |
138 | sv_catsv(sv,*mark); |
139 | } |
140 | SvSETMAGIC(sv); |
141 | } |
142 | |
143 | void |
144 | do_sprintf(sv,len,sarg) |
145 | register SV *sv; |
146 | register I32 len; |
147 | register SV **sarg; |
148 | { |
149 | register char *s; |
150 | register char *t; |
151 | register char *f; |
046ff0ed |
152 | char dotype; |
79072805 |
153 | char ch; |
154 | register char *send; |
155 | register SV *arg; |
156 | char *xs; |
157 | I32 xlen; |
158 | I32 pre; |
159 | I32 post; |
160 | double value; |
463ee0b2 |
161 | STRLEN arglen; |
79072805 |
162 | |
163 | sv_setpv(sv,""); |
164 | len--; /* don't count pattern string */ |
a0d0e21e |
165 | t = s = SvPV(*sarg, arglen); /* XXX Don't know t is writeable */ |
463ee0b2 |
166 | send = s + arglen; |
79072805 |
167 | sarg++; |
168 | for ( ; ; len--) { |
169 | |
170 | /*SUPPRESS 560*/ |
171 | if (len <= 0 || !(arg = *sarg++)) |
172 | arg = &sv_no; |
173 | |
174 | /*SUPPRESS 530*/ |
175 | for ( ; t < send && *t != '%'; t++) ; |
176 | if (t >= send) |
177 | break; /* end of run_format string, ignore extra args */ |
178 | f = t; |
179 | *buf = '\0'; |
180 | xs = buf; |
046ff0ed |
181 | dotype = '\0'; |
79072805 |
182 | pre = post = 0; |
183 | for (t++; t < send; t++) { |
184 | switch (*t) { |
185 | default: |
186 | ch = *(++t); |
187 | *t = '\0'; |
188 | (void)sprintf(xs,f); |
189 | len++, sarg--; |
190 | xlen = strlen(xs); |
191 | break; |
748a9306 |
192 | case 'n': case '*': |
193 | croak("Use of %c in printf format not supported", *t); |
194 | |
79072805 |
195 | case '0': case '1': case '2': case '3': case '4': |
196 | case '5': case '6': case '7': case '8': case '9': |
197 | case '.': case '#': case '-': case '+': case ' ': |
198 | continue; |
463ee0b2 |
199 | case 'l': |
ecfc5424 |
200 | #ifdef HAS_QUAD |
046ff0ed |
201 | if (dotype == 'l') |
202 | dotype = 'q'; |
203 | else |
79072805 |
204 | #endif |
046ff0ed |
205 | dotype = 'l'; |
206 | continue; |
207 | case 'h': |
208 | dotype = 's'; |
79072805 |
209 | continue; |
210 | case 'c': |
211 | ch = *(++t); |
212 | *t = '\0'; |
463ee0b2 |
213 | xlen = SvIV(arg); |
79072805 |
214 | if (strEQ(f,"%c")) { /* some printfs fail on null chars */ |
215 | *xs = xlen; |
216 | xs[1] = '\0'; |
217 | xlen = 1; |
218 | } |
219 | else { |
220 | (void)sprintf(xs,f,xlen); |
221 | xlen = strlen(xs); |
222 | } |
223 | break; |
224 | case 'D': |
046ff0ed |
225 | dotype = 'l'; |
79072805 |
226 | /* FALL THROUGH */ |
227 | case 'd': |
046ff0ed |
228 | case 'i': |
79072805 |
229 | ch = *(++t); |
230 | *t = '\0'; |
046ff0ed |
231 | switch (dotype) { |
ecfc5424 |
232 | #ifdef HAS_QUAD |
046ff0ed |
233 | case 'q': |
234 | /* perl.h says that if quad is available, IV is quad */ |
235 | (void)sprintf(xs,f,(Quad_t)SvIV(arg)); |
236 | break; |
79072805 |
237 | #endif |
046ff0ed |
238 | case 'l': |
239 | (void)sprintf(xs,f,(long)SvIV(arg)); |
240 | break; |
241 | default: |
242 | (void)sprintf(xs,f,(int)SvIV(arg)); |
243 | break; |
244 | case 's': |
245 | (void)sprintf(xs,f,(short)SvIV(arg)); |
246 | break; |
247 | } |
79072805 |
248 | xlen = strlen(xs); |
249 | break; |
250 | case 'X': case 'O': |
046ff0ed |
251 | dotype = 'l'; |
79072805 |
252 | /* FALL THROUGH */ |
253 | case 'x': case 'o': case 'u': |
254 | ch = *(++t); |
255 | *t = '\0'; |
046ff0ed |
256 | switch (dotype) { |
ecfc5424 |
257 | #ifdef HAS_QUAD |
046ff0ed |
258 | case 'q': |
259 | /* perl.h says that if quad is available, UV is quad */ |
260 | (void)sprintf(xs,f,(unsigned Quad_t)SvUV(arg)); |
261 | break; |
79072805 |
262 | #endif |
046ff0ed |
263 | case 'l': |
264 | (void)sprintf(xs,f,(unsigned long)SvUV(arg)); |
265 | break; |
266 | default: |
267 | (void)sprintf(xs,f,(unsigned int)SvUV(arg)); |
268 | break; |
269 | case 's': |
270 | (void)sprintf(xs,f,(unsigned short)SvUV(arg)); |
271 | break; |
272 | } |
79072805 |
273 | xlen = strlen(xs); |
274 | break; |
275 | case 'E': case 'e': case 'f': case 'G': case 'g': |
276 | ch = *(++t); |
277 | *t = '\0'; |
463ee0b2 |
278 | (void)sprintf(xs,f,SvNV(arg)); |
79072805 |
279 | xlen = strlen(xs); |
bbce6d69 |
280 | #ifdef LC_NUMERIC |
ff68c719 |
281 | /* |
282 | * User-defined locales may include arbitrary characters. |
283 | * And, unfortunately, some system may alloc the "C" locale |
284 | * to be overridden by a malicious user. |
285 | */ |
286 | if (op->op_type == OP_SPRINTF) |
bbce6d69 |
287 | SvTAINTED_on(sv); |
ff68c719 |
288 | #endif /* LC_NUMERIC */ |
79072805 |
289 | break; |
290 | case 's': |
291 | ch = *(++t); |
292 | *t = '\0'; |
463ee0b2 |
293 | xs = SvPV(arg, arglen); |
294 | xlen = (I32)arglen; |
79072805 |
295 | if (strEQ(f,"%s")) { /* some printfs fail on >128 chars */ |
296 | break; /* so handle simple cases */ |
297 | } |
298 | else if (f[1] == '-') { |
93a17b20 |
299 | char *mp = strchr(f, '.'); |
79072805 |
300 | I32 min = atoi(f+2); |
301 | |
302 | if (mp) { |
303 | I32 max = atoi(mp+1); |
304 | |
305 | if (xlen > max) |
306 | xlen = max; |
307 | } |
308 | if (xlen < min) |
309 | post = min - xlen; |
310 | break; |
311 | } |
312 | else if (isDIGIT(f[1])) { |
93a17b20 |
313 | char *mp = strchr(f, '.'); |
79072805 |
314 | I32 min = atoi(f+1); |
315 | |
316 | if (mp) { |
317 | I32 max = atoi(mp+1); |
318 | |
319 | if (xlen > max) |
320 | xlen = max; |
321 | } |
322 | if (xlen < min) |
323 | pre = min - xlen; |
324 | break; |
325 | } |
326 | strcpy(tokenbuf+64,f); /* sprintf($s,...$s...) */ |
327 | *t = ch; |
328 | (void)sprintf(buf,tokenbuf+64,xs); |
329 | xs = buf; |
330 | xlen = strlen(xs); |
331 | break; |
332 | } |
333 | /* end of switch, copy results */ |
334 | *t = ch; |
4633a7c4 |
335 | if (xs == buf && xlen >= sizeof(buf)) { /* Ooops! */ |
760ac839 |
336 | PerlIO_puts(PerlIO_stderr(),"panic: sprintf overflow - memory corrupted!\n"); |
4633a7c4 |
337 | my_exit(1); |
338 | } |
79072805 |
339 | SvGROW(sv, SvCUR(sv) + (f - s) + xlen + 1 + pre + post); |
340 | sv_catpvn(sv, s, f - s); |
341 | if (pre) { |
463ee0b2 |
342 | repeatcpy(SvPVX(sv) + SvCUR(sv), " ", 1, pre); |
79072805 |
343 | SvCUR(sv) += pre; |
344 | } |
345 | sv_catpvn(sv, xs, xlen); |
346 | if (post) { |
463ee0b2 |
347 | repeatcpy(SvPVX(sv) + SvCUR(sv), " ", 1, post); |
79072805 |
348 | SvCUR(sv) += post; |
349 | } |
350 | s = t; |
351 | break; /* break from for loop */ |
352 | } |
353 | } |
354 | sv_catpvn(sv, s, t - s); |
355 | SvSETMAGIC(sv); |
356 | } |
357 | |
358 | void |
359 | do_vecset(sv) |
360 | SV *sv; |
361 | { |
362 | SV *targ = LvTARG(sv); |
363 | register I32 offset; |
364 | register I32 size; |
8990e307 |
365 | register unsigned char *s; |
366 | register unsigned long lval; |
79072805 |
367 | I32 mask; |
a0d0e21e |
368 | STRLEN targlen; |
369 | STRLEN len; |
79072805 |
370 | |
8990e307 |
371 | if (!targ) |
372 | return; |
a0d0e21e |
373 | s = (unsigned char*)SvPV_force(targ, targlen); |
8990e307 |
374 | lval = U_L(SvNV(sv)); |
79072805 |
375 | offset = LvTARGOFF(sv); |
376 | size = LvTARGLEN(sv); |
a0d0e21e |
377 | |
378 | len = (offset + size + 7) / 8; |
379 | if (len > targlen) { |
380 | s = (unsigned char*)SvGROW(targ, len + 1); |
381 | (void)memzero(s + targlen, len - targlen + 1); |
382 | SvCUR_set(targ, len); |
383 | } |
384 | |
79072805 |
385 | if (size < 8) { |
386 | mask = (1 << size) - 1; |
387 | size = offset & 7; |
388 | lval &= mask; |
389 | offset >>= 3; |
390 | s[offset] &= ~(mask << size); |
391 | s[offset] |= lval << size; |
392 | } |
393 | else { |
a0d0e21e |
394 | offset >>= 3; |
79072805 |
395 | if (size == 8) |
396 | s[offset] = lval & 255; |
397 | else if (size == 16) { |
398 | s[offset] = (lval >> 8) & 255; |
399 | s[offset+1] = lval & 255; |
400 | } |
401 | else if (size == 32) { |
402 | s[offset] = (lval >> 24) & 255; |
403 | s[offset+1] = (lval >> 16) & 255; |
404 | s[offset+2] = (lval >> 8) & 255; |
405 | s[offset+3] = lval & 255; |
406 | } |
407 | } |
408 | } |
409 | |
410 | void |
411 | do_chop(astr,sv) |
412 | register SV *astr; |
413 | register SV *sv; |
414 | { |
463ee0b2 |
415 | STRLEN len; |
a0d0e21e |
416 | char *s; |
417 | |
79072805 |
418 | if (SvTYPE(sv) == SVt_PVAV) { |
a0d0e21e |
419 | register I32 i; |
420 | I32 max; |
421 | AV* av = (AV*)sv; |
422 | max = AvFILL(av); |
423 | for (i = 0; i <= max; i++) { |
424 | sv = (SV*)av_fetch(av, i, FALSE); |
425 | if (sv && ((sv = *(SV**)sv), sv != &sv_undef)) |
426 | do_chop(astr, sv); |
427 | } |
428 | return; |
79072805 |
429 | } |
430 | if (SvTYPE(sv) == SVt_PVHV) { |
a0d0e21e |
431 | HV* hv = (HV*)sv; |
432 | HE* entry; |
433 | (void)hv_iterinit(hv); |
434 | /*SUPPRESS 560*/ |
435 | while (entry = hv_iternext(hv)) |
436 | do_chop(astr,hv_iterval(hv,entry)); |
437 | return; |
79072805 |
438 | } |
a0d0e21e |
439 | s = SvPV(sv, len); |
748a9306 |
440 | if (len && !SvPOK(sv)) |
a0d0e21e |
441 | s = SvPV_force(sv, len); |
442 | if (s && len) { |
443 | s += --len; |
444 | sv_setpvn(astr, s, 1); |
445 | *s = '\0'; |
446 | SvCUR_set(sv, len); |
447 | SvNIOK_off(sv); |
79072805 |
448 | } |
449 | else |
a0d0e21e |
450 | sv_setpvn(astr, "", 0); |
451 | SvSETMAGIC(sv); |
452 | } |
453 | |
454 | I32 |
455 | do_chomp(sv) |
456 | register SV *sv; |
457 | { |
c07a80fd |
458 | register I32 count; |
a0d0e21e |
459 | STRLEN len; |
460 | char *s; |
c07a80fd |
461 | |
462 | if (RsSNARF(rs)) |
463 | return 0; |
464 | count = 0; |
a0d0e21e |
465 | if (SvTYPE(sv) == SVt_PVAV) { |
466 | register I32 i; |
467 | I32 max; |
468 | AV* av = (AV*)sv; |
469 | max = AvFILL(av); |
470 | for (i = 0; i <= max; i++) { |
471 | sv = (SV*)av_fetch(av, i, FALSE); |
472 | if (sv && ((sv = *(SV**)sv), sv != &sv_undef)) |
473 | count += do_chomp(sv); |
474 | } |
475 | return count; |
476 | } |
477 | if (SvTYPE(sv) == SVt_PVHV) { |
478 | HV* hv = (HV*)sv; |
479 | HE* entry; |
480 | (void)hv_iterinit(hv); |
481 | /*SUPPRESS 560*/ |
482 | while (entry = hv_iternext(hv)) |
483 | count += do_chomp(hv_iterval(hv,entry)); |
484 | return count; |
485 | } |
486 | s = SvPV(sv, len); |
487 | if (len && !SvPOKp(sv)) |
488 | s = SvPV_force(sv, len); |
489 | if (s && len) { |
490 | s += --len; |
c07a80fd |
491 | if (RsPARA(rs)) { |
a0d0e21e |
492 | if (*s != '\n') |
493 | goto nope; |
494 | ++count; |
495 | while (len && s[-1] == '\n') { |
496 | --len; |
497 | --s; |
498 | ++count; |
499 | } |
500 | } |
a0d0e21e |
501 | else { |
c07a80fd |
502 | STRLEN rslen; |
503 | char *rsptr = SvPV(rs, rslen); |
504 | if (rslen == 1) { |
505 | if (*s != *rsptr) |
506 | goto nope; |
507 | ++count; |
508 | } |
509 | else { |
8c2cee6f |
510 | if (len < rslen - 1) |
c07a80fd |
511 | goto nope; |
512 | len -= rslen - 1; |
513 | s -= rslen - 1; |
36477c24 |
514 | if (memNE(s, rsptr, rslen)) |
c07a80fd |
515 | goto nope; |
516 | count += rslen; |
517 | } |
a0d0e21e |
518 | } |
a0d0e21e |
519 | *s = '\0'; |
520 | SvCUR_set(sv, len); |
521 | SvNIOK_off(sv); |
522 | } |
523 | nope: |
524 | SvSETMAGIC(sv); |
525 | return count; |
526 | } |
79072805 |
527 | |
528 | void |
529 | do_vop(optype,sv,left,right) |
530 | I32 optype; |
531 | SV *sv; |
532 | SV *left; |
533 | SV *right; |
534 | { |
535 | #ifdef LIBERAL |
536 | register long *dl; |
537 | register long *ll; |
538 | register long *rl; |
539 | #endif |
540 | register char *dc; |
463ee0b2 |
541 | STRLEN leftlen; |
542 | STRLEN rightlen; |
7a4c00b4 |
543 | register char *lc; |
544 | register char *rc; |
79072805 |
545 | register I32 len; |
a0d0e21e |
546 | I32 lensave; |
7a4c00b4 |
547 | char *lsave; |
548 | char *rsave; |
79072805 |
549 | |
1fbd88dc |
550 | if (sv != left || (optype != OP_BIT_AND && !SvOK(sv) && !SvGMAGICAL(sv))) |
551 | sv_setpvn(sv, "", 0); /* avoid undef warning on |= and ^= */ |
7a4c00b4 |
552 | lsave = lc = SvPV(left, leftlen); |
553 | rsave = rc = SvPV(right, rightlen); |
93a17b20 |
554 | len = leftlen < rightlen ? leftlen : rightlen; |
a0d0e21e |
555 | lensave = len; |
7a4c00b4 |
556 | if (SvOK(sv) || SvTYPE(sv) > SVt_PVMG) { |
ff68c719 |
557 | dc = SvPV_force(sv, na); |
558 | if (SvCUR(sv) < len) { |
559 | dc = SvGROW(sv, len + 1); |
560 | (void)memzero(dc + SvCUR(sv), len - SvCUR(sv) + 1); |
561 | } |
562 | } |
563 | else { |
564 | I32 needlen = ((optype == OP_BIT_AND) |
565 | ? len : (leftlen > rightlen ? leftlen : rightlen)); |
566 | Newz(801, dc, needlen + 1, char); |
567 | (void)sv_usepvn(sv, dc, needlen); |
568 | dc = SvPVX(sv); /* sv_usepvn() calls Renew() */ |
79072805 |
569 | } |
a0d0e21e |
570 | SvCUR_set(sv, len); |
571 | (void)SvPOK_only(sv); |
79072805 |
572 | #ifdef LIBERAL |
573 | if (len >= sizeof(long)*4 && |
574 | !((long)dc % sizeof(long)) && |
575 | !((long)lc % sizeof(long)) && |
576 | !((long)rc % sizeof(long))) /* It's almost always aligned... */ |
577 | { |
578 | I32 remainder = len % (sizeof(long)*4); |
579 | len /= (sizeof(long)*4); |
580 | |
581 | dl = (long*)dc; |
582 | ll = (long*)lc; |
583 | rl = (long*)rc; |
584 | |
585 | switch (optype) { |
586 | case OP_BIT_AND: |
587 | while (len--) { |
588 | *dl++ = *ll++ & *rl++; |
589 | *dl++ = *ll++ & *rl++; |
590 | *dl++ = *ll++ & *rl++; |
591 | *dl++ = *ll++ & *rl++; |
592 | } |
593 | break; |
a0d0e21e |
594 | case OP_BIT_XOR: |
79072805 |
595 | while (len--) { |
596 | *dl++ = *ll++ ^ *rl++; |
597 | *dl++ = *ll++ ^ *rl++; |
598 | *dl++ = *ll++ ^ *rl++; |
599 | *dl++ = *ll++ ^ *rl++; |
600 | } |
601 | break; |
602 | case OP_BIT_OR: |
603 | while (len--) { |
604 | *dl++ = *ll++ | *rl++; |
605 | *dl++ = *ll++ | *rl++; |
606 | *dl++ = *ll++ | *rl++; |
607 | *dl++ = *ll++ | *rl++; |
608 | } |
609 | } |
610 | |
611 | dc = (char*)dl; |
612 | lc = (char*)ll; |
613 | rc = (char*)rl; |
614 | |
615 | len = remainder; |
616 | } |
617 | #endif |
a0d0e21e |
618 | { |
a0d0e21e |
619 | switch (optype) { |
620 | case OP_BIT_AND: |
621 | while (len--) |
622 | *dc++ = *lc++ & *rc++; |
623 | break; |
624 | case OP_BIT_XOR: |
625 | while (len--) |
626 | *dc++ = *lc++ ^ *rc++; |
627 | goto mop_up; |
628 | case OP_BIT_OR: |
629 | while (len--) |
630 | *dc++ = *lc++ | *rc++; |
631 | mop_up: |
632 | len = lensave; |
633 | if (rightlen > len) |
634 | sv_catpvn(sv, rsave + len, rightlen - len); |
635 | else if (leftlen > len) |
636 | sv_catpvn(sv, lsave + len, leftlen - len); |
4633a7c4 |
637 | else |
638 | *SvEND(sv) = '\0'; |
a0d0e21e |
639 | break; |
640 | } |
79072805 |
641 | } |
642 | } |
463ee0b2 |
643 | |
644 | OP * |
645 | do_kv(ARGS) |
646 | dARGS |
647 | { |
648 | dSP; |
649 | HV *hv = (HV*)POPs; |
463ee0b2 |
650 | register HE *entry; |
463ee0b2 |
651 | SV *tmpstr; |
a0d0e21e |
652 | I32 dokeys = (op->op_type == OP_KEYS); |
653 | I32 dovalues = (op->op_type == OP_VALUES); |
654 | |
655 | if (op->op_type == OP_RV2HV || op->op_type == OP_PADHV) |
656 | dokeys = dovalues = TRUE; |
463ee0b2 |
657 | |
85581909 |
658 | if (!hv) { |
659 | if (op->op_flags & OPf_MOD) { /* lvalue */ |
660 | dTARGET; /* make sure to clear its target here */ |
661 | if (SvTYPE(TARG) == SVt_PVLV) |
662 | LvTARG(TARG) = Nullsv; |
663 | PUSHs(TARG); |
664 | } |
463ee0b2 |
665 | RETURN; |
85581909 |
666 | } |
748a9306 |
667 | |
668 | (void)hv_iterinit(hv); /* always reset iterator regardless */ |
669 | |
aa689395 |
670 | if (op->op_private & OPpLEAVE_VOID) |
671 | RETURN; |
672 | |
463ee0b2 |
673 | if (GIMME != G_ARRAY) { |
8c2cee6f |
674 | I32 i; |
463ee0b2 |
675 | dTARGET; |
676 | |
85581909 |
677 | if (op->op_flags & OPf_MOD) { /* lvalue */ |
678 | if (SvTYPE(TARG) < SVt_PVLV) { |
679 | sv_upgrade(TARG, SVt_PVLV); |
680 | sv_magic(TARG, Nullsv, 'k', Nullch, 0); |
681 | } |
682 | LvTYPE(TARG) = 'k'; |
683 | LvTARG(TARG) = (SV*)hv; |
684 | PUSHs(TARG); |
685 | RETURN; |
686 | } |
687 | |
8990e307 |
688 | if (!SvRMAGICAL(hv) || !mg_find((SV*)hv,'P')) |
463ee0b2 |
689 | i = HvKEYS(hv); |
690 | else { |
691 | i = 0; |
463ee0b2 |
692 | /*SUPPRESS 560*/ |
693 | while (entry = hv_iternext(hv)) { |
694 | i++; |
695 | } |
696 | } |
697 | PUSHi( i ); |
698 | RETURN; |
699 | } |
700 | |
701 | /* Guess how much room we need. hv_max may be a few too many. Oh well. */ |
702 | EXTEND(sp, HvMAX(hv) * (dokeys + dovalues)); |
703 | |
463ee0b2 |
704 | PUTBACK; /* hv_iternext and hv_iterval might clobber stack_sp */ |
705 | while (entry = hv_iternext(hv)) { |
706 | SPAGAIN; |
8c2cee6f |
707 | if (dokeys) |
708 | XPUSHs(hv_iterkeysv(entry)); /* won't clobber stack_sp */ |
463ee0b2 |
709 | if (dovalues) { |
710 | tmpstr = NEWSV(45,0); |
711 | PUTBACK; |
712 | sv_setsv(tmpstr,hv_iterval(hv,entry)); |
713 | SPAGAIN; |
714 | DEBUG_H( { |
8c2cee6f |
715 | sprintf(buf,"%d%%%d=%d\n", HeHASH(entry), |
716 | HvMAX(hv)+1, HeHASH(entry) & HvMAX(hv)); |
717 | sv_setpv(tmpstr,buf); |
463ee0b2 |
718 | } ) |
719 | XPUSHs(sv_2mortal(tmpstr)); |
720 | } |
721 | PUTBACK; |
722 | } |
723 | return NORMAL; |
724 | } |
725 | |