Add Ken Hirsch to AUTHORS.
[perl.git] / mathoms.c
1 /*    mathoms.c
2  *
3  *    Copyright (C) 2005, 2006, by Larry Wall and others
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  * "Anything that Hobbits had no immediate use for, but were unwilling to 
12  * throw away, they called a mathom. Their dwellings were apt to become
13  * rather crowded with mathoms, and many of the presents that passed from
14  * hand to hand were of that sort." 
15  */
16
17 #ifndef NO_MATHOMS
18
19 /* 
20  * This file contains mathoms, various binary artifacts from previous
21  * versions of Perl.  For binary or source compatibility reasons, though,
22  * we cannot completely remove them from the core code.  
23  *
24  * SMP - Oct. 24, 2005
25  *
26  */
27
28 #include "EXTERN.h"
29 #define PERL_IN_MATHOMS_C
30 #include "perl.h"
31
32 void Perl_mathoms(void) {}
33
34 /* ref() is now a macro using Perl_doref;
35  * this version provided for binary compatibility only.
36  */
37 OP *
38 Perl_ref(pTHX_ OP *o, I32 type)
39 {
40     return doref(o, type, TRUE);
41 }
42
43 /*
44 =for apidoc sv_unref
45
46 Unsets the RV status of the SV, and decrements the reference count of
47 whatever was being referenced by the RV.  This can almost be thought of
48 as a reversal of C<newSVrv>.  This is C<sv_unref_flags> with the C<flag>
49 being zero.  See C<SvROK_off>.
50
51 =cut
52 */
53
54 void
55 Perl_sv_unref(pTHX_ SV *sv)
56 {
57     sv_unref_flags(sv, 0);
58 }
59
60 /*
61 =for apidoc sv_taint
62
63 Taint an SV. Use C<SvTAINTED_on> instead.
64 =cut
65 */
66
67 void
68 Perl_sv_taint(pTHX_ SV *sv)
69 {
70     sv_magic((sv), Nullsv, PERL_MAGIC_taint, Nullch, 0);
71 }
72
73 /* sv_2iv() is now a macro using Perl_sv_2iv_flags();
74  * this function provided for binary compatibility only
75  */
76
77 IV
78 Perl_sv_2iv(pTHX_ register SV *sv)
79 {
80     return sv_2iv_flags(sv, SV_GMAGIC);
81 }
82
83 /* sv_2uv() is now a macro using Perl_sv_2uv_flags();
84  * this function provided for binary compatibility only
85  */
86
87 UV
88 Perl_sv_2uv(pTHX_ register SV *sv)
89 {
90     return sv_2uv_flags(sv, SV_GMAGIC);
91 }
92
93 /* sv_2pv() is now a macro using Perl_sv_2pv_flags();
94  * this function provided for binary compatibility only
95  */
96
97 char *
98 Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp)
99 {
100     return sv_2pv_flags(sv, lp, SV_GMAGIC);
101 }
102
103 /*
104 =for apidoc sv_2pv_nolen
105
106 Like C<sv_2pv()>, but doesn't return the length too. You should usually
107 use the macro wrapper C<SvPV_nolen(sv)> instead.
108 =cut
109 */
110
111 char *
112 Perl_sv_2pv_nolen(pTHX_ register SV *sv)
113 {
114     return sv_2pv(sv, 0);
115 }
116
117 /*
118 =for apidoc sv_2pvbyte_nolen
119
120 Return a pointer to the byte-encoded representation of the SV.
121 May cause the SV to be downgraded from UTF-8 as a side-effect.
122
123 Usually accessed via the C<SvPVbyte_nolen> macro.
124
125 =cut
126 */
127
128 char *
129 Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv)
130 {
131     return sv_2pvbyte(sv, 0);
132 }
133
134 /*
135 =for apidoc sv_2pvutf8_nolen
136
137 Return a pointer to the UTF-8-encoded representation of the SV.
138 May cause the SV to be upgraded to UTF-8 as a side-effect.
139
140 Usually accessed via the C<SvPVutf8_nolen> macro.
141
142 =cut
143 */
144
145 char *
146 Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv)
147 {
148     return sv_2pvutf8(sv, 0);
149 }
150
151 /*
152 =for apidoc sv_force_normal
153
154 Undo various types of fakery on an SV: if the PV is a shared string, make
155 a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
156 an xpvmg. See also C<sv_force_normal_flags>.
157
158 =cut
159 */
160
161 void
162 Perl_sv_force_normal(pTHX_ register SV *sv)
163 {
164     sv_force_normal_flags(sv, 0);
165 }
166
167 /* sv_setsv() is now a macro using Perl_sv_setsv_flags();
168  * this function provided for binary compatibility only
169  */
170
171 void
172 Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr)
173 {
174     sv_setsv_flags(dstr, sstr, SV_GMAGIC);
175 }
176
177 /* sv_catpvn() is now a macro using Perl_sv_catpvn_flags();
178  * this function provided for binary compatibility only
179  */
180
181 void
182 Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen)
183 {
184     sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC);
185 }
186
187 /*
188 =for apidoc sv_catpvn_mg
189
190 Like C<sv_catpvn>, but also handles 'set' magic.
191
192 =cut
193 */
194
195 void
196 Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
197 {
198     sv_catpvn_flags(sv,ptr,len,SV_GMAGIC|SV_SMAGIC);
199 }
200
201 /* sv_catsv() is now a macro using Perl_sv_catsv_flags();
202  * this function provided for binary compatibility only
203  */
204
205 void
206 Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr)
207 {
208     sv_catsv_flags(dstr, sstr, SV_GMAGIC);
209 }
210
211 /*
212 =for apidoc sv_catsv_mg
213
214 Like C<sv_catsv>, but also handles 'set' magic.
215
216 =cut
217 */
218
219 void
220 Perl_sv_catsv_mg(pTHX_ SV *dsv, register SV *ssv)
221 {
222     sv_catsv_flags(dsv,ssv,SV_GMAGIC|SV_SMAGIC);
223 }
224
225 /*
226 =for apidoc sv_iv
227
228 A private implementation of the C<SvIVx> macro for compilers which can't
229 cope with complex macro expressions. Always use the macro instead.
230
231 =cut
232 */
233
234 IV
235 Perl_sv_iv(pTHX_ register SV *sv)
236 {
237     if (SvIOK(sv)) {
238         if (SvIsUV(sv))
239             return (IV)SvUVX(sv);
240         return SvIVX(sv);
241     }
242     return sv_2iv(sv);
243 }
244
245 /*
246 =for apidoc sv_uv
247
248 A private implementation of the C<SvUVx> macro for compilers which can't
249 cope with complex macro expressions. Always use the macro instead.
250
251 =cut
252 */
253
254 UV
255 Perl_sv_uv(pTHX_ register SV *sv)
256 {
257     if (SvIOK(sv)) {
258         if (SvIsUV(sv))
259             return SvUVX(sv);
260         return (UV)SvIVX(sv);
261     }
262     return sv_2uv(sv);
263 }
264
265 /*
266 =for apidoc sv_nv
267
268 A private implementation of the C<SvNVx> macro for compilers which can't
269 cope with complex macro expressions. Always use the macro instead.
270
271 =cut
272 */
273
274 NV
275 Perl_sv_nv(pTHX_ register SV *sv)
276 {
277     if (SvNOK(sv))
278         return SvNVX(sv);
279     return sv_2nv(sv);
280 }
281
282 /*
283 =for apidoc sv_pv
284
285 Use the C<SvPV_nolen> macro instead
286
287 =for apidoc sv_pvn
288
289 A private implementation of the C<SvPV> macro for compilers which can't
290 cope with complex macro expressions. Always use the macro instead.
291
292 =cut
293 */
294
295 char *
296 Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp)
297 {
298     if (SvPOK(sv)) {
299         *lp = SvCUR(sv);
300         return SvPVX(sv);
301     }
302     return sv_2pv(sv, lp);
303 }
304
305
306 char *
307 Perl_sv_pvn_nomg(pTHX_ register SV *sv, STRLEN *lp)
308 {
309     if (SvPOK(sv)) {
310         *lp = SvCUR(sv);
311         return SvPVX(sv);
312     }
313     return sv_2pv_flags(sv, lp, 0);
314 }
315
316 /* sv_pv() is now a macro using SvPV_nolen();
317  * this function provided for binary compatibility only
318  */
319
320 char *
321 Perl_sv_pv(pTHX_ SV *sv)
322 {
323     if (SvPOK(sv))
324         return SvPVX(sv);
325
326     return sv_2pv(sv, 0);
327 }
328
329 /* sv_pvn_force() is now a macro using Perl_sv_pvn_force_flags();
330  * this function provided for binary compatibility only
331  */
332
333 char *
334 Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp)
335 {
336     return sv_pvn_force_flags(sv, lp, SV_GMAGIC);
337 }
338
339 /* sv_pvbyte () is now a macro using Perl_sv_2pv_flags();
340  * this function provided for binary compatibility only
341  */
342
343 char *
344 Perl_sv_pvbyte(pTHX_ SV *sv)
345 {
346     sv_utf8_downgrade(sv,0);
347     return sv_pv(sv);
348 }
349
350 /*
351 =for apidoc sv_pvbyte
352
353 Use C<SvPVbyte_nolen> instead.
354
355 =for apidoc sv_pvbyten
356
357 A private implementation of the C<SvPVbyte> macro for compilers
358 which can't cope with complex macro expressions. Always use the macro
359 instead.
360
361 =cut
362 */
363
364 char *
365 Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp)
366 {
367     sv_utf8_downgrade(sv,0);
368     return sv_pvn(sv,lp);
369 }
370
371 /* sv_pvutf8 () is now a macro using Perl_sv_2pv_flags();
372  * this function provided for binary compatibility only
373  */
374
375 char *
376 Perl_sv_pvutf8(pTHX_ SV *sv)
377 {
378     sv_utf8_upgrade(sv);
379     return sv_pv(sv);
380 }
381
382 /*
383 =for apidoc sv_pvutf8
384
385 Use the C<SvPVutf8_nolen> macro instead
386
387 =for apidoc sv_pvutf8n
388
389 A private implementation of the C<SvPVutf8> macro for compilers
390 which can't cope with complex macro expressions. Always use the macro
391 instead.
392
393 =cut
394 */
395
396 char *
397 Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp)
398 {
399     sv_utf8_upgrade(sv);
400     return sv_pvn(sv,lp);
401 }
402
403 /* sv_utf8_upgrade() is now a macro using sv_utf8_upgrade_flags();
404  * this function provided for binary compatibility only
405  */
406
407 STRLEN
408 Perl_sv_utf8_upgrade(pTHX_ register SV *sv)
409 {
410     return sv_utf8_upgrade_flags(sv, SV_GMAGIC);
411 }
412
413 int
414 Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...)
415 {
416     dTHXs;
417     va_list(arglist);
418     va_start(arglist, format);
419     return PerlIO_vprintf(stream, format, arglist);
420 }
421
422 int
423 Perl_printf_nocontext(const char *format, ...)
424 {
425     dTHX;
426     va_list(arglist);
427     va_start(arglist, format);
428     return PerlIO_vprintf(PerlIO_stdout(), format, arglist);
429 }
430
431 #if defined(HUGE_VAL) || (defined(USE_LONG_DOUBLE) && defined(HUGE_VALL))
432 /*
433  * This hack is to force load of "huge" support from libm.a
434  * So it is in perl for (say) POSIX to use.
435  * Needed for SunOS with Sun's 'acc' for example.
436  */
437 NV
438 Perl_huge(void)
439 {
440 #   if defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)
441     return HUGE_VALL;
442 #   endif
443     return HUGE_VAL;
444 }
445 #endif
446
447 /* compatibility with versions <= 5.003. */
448 void
449 Perl_gv_fullname(pTHX_ SV *sv, const GV *gv)
450 {
451     gv_fullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
452 }
453
454 /* compatibility with versions <= 5.003. */
455 void
456 Perl_gv_efullname(pTHX_ SV *sv, const GV *gv)
457 {
458     gv_efullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
459 }
460
461 void
462 Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
463 {
464     gv_fullname4(sv, gv, prefix, TRUE);
465 }
466
467 void
468 Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
469 {
470     gv_efullname4(sv, gv, prefix, TRUE);
471 }
472
473 /*
474 =for apidoc gv_fetchmethod
475
476 See L<gv_fetchmethod_autoload>.
477
478 =cut
479 */
480
481 GV *
482 Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
483 {
484     return gv_fetchmethod_autoload(stash, name, TRUE);
485 }
486
487 HE *
488 Perl_hv_iternext(pTHX_ HV *hv)
489 {
490     return hv_iternext_flags(hv, 0);
491 }
492
493 void
494 Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how)
495 {
496     sv_magic((SV*)hv, (SV*)gv, how, Nullch, 0);
497 }
498
499 #if 0 /* use the macro from hv.h instead */
500
501 char*   
502 Perl_sharepvn(pTHX_ const char *sv, I32 len, U32 hash)
503 {
504     return HEK_KEY(share_hek(sv, len, hash));
505 }
506
507 #endif
508
509 AV *
510 Perl_av_fake(pTHX_ register I32 size, register SV **strp)
511 {
512     register SV** ary;
513     register AV * const av = (AV*)NEWSV(9,0);
514
515     sv_upgrade((SV *)av, SVt_PVAV);
516     Newx(ary,size+1,SV*);
517     AvALLOC(av) = ary;
518     Copy(strp,ary,size,SV*);
519     AvREIFY_only(av);
520     SvPV_set(av, (char*)ary);
521     AvFILLp(av) = size - 1;
522     AvMAX(av) = size - 1;
523     while (size--) {
524         assert (*strp);
525         SvTEMP_off(*strp);
526         strp++;
527     }
528     return av;
529 }
530
531 bool
532 Perl_do_open(pTHX_ GV *gv, register const char *name, I32 len, int as_raw,
533              int rawmode, int rawperm, PerlIO *supplied_fp)
534 {
535     return do_openn(gv, name, len, as_raw, rawmode, rawperm,
536                     supplied_fp, (SV **) NULL, 0);
537 }
538
539 bool
540 Perl_do_open9(pTHX_ GV *gv, register const char *name, I32 len, int 
541 as_raw,
542               int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs,
543               I32 num_svs)
544 {
545     PERL_UNUSED_ARG(num_svs);
546     return do_openn(gv, name, len, as_raw, rawmode, rawperm,
547                     supplied_fp, &svs, 1);
548 }
549
550 int
551 Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
552 {
553  /* The old body of this is now in non-LAYER part of perlio.c
554   * This is a stub for any XS code which might have been calling it.
555   */
556  const char *name = ":raw";
557 #ifdef PERLIO_USING_CRLF
558  if (!(mode & O_BINARY))
559      name = ":crlf";
560 #endif
561  return PerlIO_binmode(aTHX_ fp, iotype, mode, name);
562 }
563
564 #ifndef OS2
565 bool
566 Perl_do_aexec(pTHX_ SV *really, register SV **mark, register SV **sp)
567 {
568     return do_aexec5(really, mark, sp, 0, 0);
569 }
570 #endif
571
572 #ifdef PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION
573 bool
574 Perl_do_exec(pTHX_ const char *cmd)
575 {
576     return do_exec3(cmd,0,0);
577 }
578 #endif
579
580 #ifdef HAS_PIPE
581 void
582 Perl_do_pipe(pTHX_ SV *sv, GV *rgv, GV *wgv)
583 {
584     dVAR;
585     register IO *rstio;
586     register IO *wstio;
587     int fd[2];
588
589     if (!rgv)
590         goto badexit;
591     if (!wgv)
592         goto badexit;
593
594     rstio = GvIOn(rgv);
595     wstio = GvIOn(wgv);
596
597     if (IoIFP(rstio))
598         do_close(rgv,FALSE);
599     if (IoIFP(wstio))
600         do_close(wgv,FALSE);
601
602     if (PerlProc_pipe(fd) < 0)
603         goto badexit;
604     IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPE_OPEN_MODE);
605     IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPE_OPEN_MODE);
606     IoOFP(rstio) = IoIFP(rstio);
607     IoIFP(wstio) = IoOFP(wstio);
608     IoTYPE(rstio) = IoTYPE_RDONLY;
609     IoTYPE(wstio) = IoTYPE_WRONLY;
610     if (!IoIFP(rstio) || !IoOFP(wstio)) {
611         if (IoIFP(rstio)) PerlIO_close(IoIFP(rstio));
612         else PerlLIO_close(fd[0]);
613         if (IoOFP(wstio)) PerlIO_close(IoOFP(wstio));
614         else PerlLIO_close(fd[1]);
615         goto badexit;
616     }
617
618     sv_setsv(sv,&PL_sv_yes);
619     return;
620
621 badexit:
622     sv_setsv(sv,&PL_sv_undef);
623     return;
624 }
625 #endif
626
627 /* Backwards compatibility. */
628 int
629 Perl_init_i18nl14n(pTHX_ int printwarn)
630 {
631     return init_i18nl10n(printwarn);
632 }
633
634 /* XXX kept for BINCOMPAT only */
635 void
636 Perl_save_hints(pTHX)
637 {
638     Perl_croak(aTHX_ "internal error: obsolete function save_hints() called");
639 }
640
641 #if 0
642 OP *
643 Perl_ck_retarget(pTHX_ OP *o)
644 {
645     Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
646     /* STUB */
647     return o;
648 }
649 #endif
650
651 OP *
652 Perl_oopsCV(pTHX_ OP *o)
653 {
654     Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
655     /* STUB */
656     PERL_UNUSED_ARG(o);
657     NORETURN_FUNCTION_END;
658 }
659
660 PP(pp_padany)
661 {
662     DIE(aTHX_ "NOT IMPL LINE %d",__LINE__);
663 }
664
665 PP(pp_threadsv)
666 {
667     DIE(aTHX_ "tried to access per-thread data in non-threaded perl");
668 }
669
670 PP(pp_mapstart)
671 {
672     DIE(aTHX_ "panic: mapstart");       /* uses grepstart */
673 }
674
675 /* These ops all have the same body as pp_null.  */
676 PP(pp_scalar)
677 {
678     dVAR;
679     return NORMAL;
680 }
681
682 PP(pp_regcmaybe)
683 {
684     dVAR;
685     return NORMAL;
686 }
687
688 PP(pp_lineseq)
689 {
690     dVAR;
691     return NORMAL;
692 }
693
694 PP(pp_scope)
695 {
696     dVAR;
697     return NORMAL;
698 }
699
700 /* Ops that are calls to do_kv.  */
701 PP(pp_values)
702 {
703     return do_kv();
704 }
705
706 PP(pp_keys)
707 {
708     return do_kv();
709 }
710
711 /* Ops that are simply calls to other ops.  */
712 PP(pp_dump)
713 {
714     return pp_goto();
715     /*NOTREACHED*/
716 }
717
718 PP(pp_dofile)
719 {
720     return pp_require();
721 }
722
723 PP(pp_dbmclose)
724 {
725     return pp_untie();
726 }
727
728 PP(pp_read)
729 {
730     return pp_sysread();
731 }
732
733 PP(pp_recv)
734 {
735     return pp_sysread();
736 }
737
738 PP(pp_seek)
739 {
740     return pp_sysseek();
741 }
742
743 PP(pp_fcntl)
744 {
745     return pp_ioctl();
746 }
747
748 PP(pp_gsockopt)
749 {
750     return pp_ssockopt();
751 }
752
753 PP(pp_getsockname)
754 {
755     return pp_getpeername();
756 }
757
758 PP(pp_lstat)
759 {
760     return pp_stat();
761 }
762
763 PP(pp_fteowned)
764 {
765     return pp_ftrowned();
766 }
767
768 PP(pp_ftbinary)
769 {
770     return pp_fttext();
771 }
772
773 PP(pp_localtime)
774 {
775     return pp_gmtime();
776 }
777
778 PP(pp_shmget)
779 {
780     return pp_semget();
781 }
782
783 PP(pp_shmctl)
784 {
785     return pp_semctl();
786 }
787
788 PP(pp_shmread)
789 {
790     return pp_shmwrite();
791 }
792
793 PP(pp_msgget)
794 {
795     return pp_semget();
796 }
797
798 PP(pp_msgctl)
799 {
800     return pp_semctl();
801 }
802
803 PP(pp_ghbyname)
804 {
805     return pp_ghostent();
806 }
807
808 PP(pp_ghbyaddr)
809 {
810     return pp_ghostent();
811 }
812
813 PP(pp_gnbyname)
814 {
815     return pp_gnetent();
816 }
817
818 PP(pp_gnbyaddr)
819 {
820     return pp_gnetent();
821 }
822
823 PP(pp_gpbyname)
824 {
825     return pp_gprotoent();
826 }
827
828 PP(pp_gpbynumber)
829 {
830     return pp_gprotoent();
831 }
832
833 PP(pp_gsbyname)
834 {
835     return pp_gservent();
836 }
837
838 PP(pp_gsbyport)
839 {
840     return pp_gservent();
841 }
842
843 PP(pp_gpwnam)
844 {
845     return pp_gpwent();
846 }
847
848 PP(pp_gpwuid)
849 {
850     return pp_gpwent();
851 }
852
853 PP(pp_ggrnam)
854 {
855     return pp_ggrent();
856 }
857
858 PP(pp_ggrgid)
859 {
860     return pp_ggrent();
861 }
862
863 PP(pp_ftsize)
864 {
865     return pp_ftis();
866 }
867
868 PP(pp_ftmtime)
869 {
870     return pp_ftis();
871 }
872
873 PP(pp_ftatime)
874 {
875     return pp_ftis();
876 }
877
878 PP(pp_ftctime)
879 {
880     return pp_ftis();
881 }
882
883 PP(pp_ftzero)
884 {
885     return pp_ftrowned();
886 }
887
888 PP(pp_ftsock)
889 {
890     return pp_ftrowned();
891 }
892
893 PP(pp_ftchr)
894 {
895     return pp_ftrowned();
896 }
897
898 PP(pp_ftblk)
899 {
900     return pp_ftrowned();
901 }
902
903 PP(pp_ftfile)
904 {
905     return pp_ftrowned();
906 }
907
908 PP(pp_ftdir)
909 {
910     return pp_ftrowned();
911 }
912
913 PP(pp_ftpipe)
914 {
915     return pp_ftrowned();
916 }
917
918 PP(pp_ftsuid)
919 {
920     return pp_ftrowned();
921 }
922
923 PP(pp_ftsgid)
924 {
925     return pp_ftrowned();
926 }
927
928 PP(pp_ftsvtx)
929 {
930     return pp_ftrowned();
931 }
932
933 PP(pp_unlink)
934 {
935     return pp_chown();
936 }
937
938 PP(pp_chmod)
939 {
940     return pp_chown();
941 }
942
943 PP(pp_utime)
944 {
945     return pp_chown();
946 }
947
948 PP(pp_kill)
949 {
950     return pp_chown();
951 }
952
953 PP(pp_symlink)
954 {
955     return pp_link();
956 }
957
958 PP(pp_ftrwrite)
959 {
960     return pp_ftrread();
961 }
962
963 PP(pp_ftrexec)
964 {
965     return pp_ftrread();
966 }
967
968 PP(pp_fteread)
969 {
970     return pp_ftrread();
971 }
972
973 PP(pp_ftewrite)
974 {
975     return pp_ftrread();
976 }
977
978 PP(pp_fteexec)
979 {
980     return pp_ftrread();
981 }
982
983 PP(pp_msgsnd)
984 {
985     return pp_shmwrite();
986 }
987
988 PP(pp_msgrcv)
989 {
990     return pp_shmwrite();
991 }
992
993 PP(pp_syswrite)
994 {
995     return pp_send();
996 }
997
998 PP(pp_semop)
999 {
1000     return pp_shmwrite();
1001 }
1002
1003 PP(pp_dor)
1004 {
1005     return pp_defined();
1006 }
1007
1008 PP(pp_andassign)
1009 {
1010     return pp_and();
1011 }
1012
1013 PP(pp_orassign)
1014 {
1015     return pp_or();
1016 }
1017
1018 PP(pp_dorassign)
1019 {
1020     return pp_defined();
1021
1022
1023 PP(pp_lcfirst)
1024 {
1025     return pp_ucfirst();
1026 }
1027
1028 PP(pp_slt)
1029 {
1030     return pp_sle();
1031 }
1032
1033 PP(pp_sgt)
1034 {
1035     return pp_sle();
1036 }
1037
1038 PP(pp_sge)
1039 {
1040     return pp_sle();
1041 }
1042
1043 U8 *
1044 Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
1045 {
1046     return Perl_uvuni_to_utf8_flags(aTHX_ d, uv, 0);
1047 }
1048
1049 bool
1050 Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep)
1051 {
1052     return is_utf8_string_loclen(s, len, ep, 0);
1053 }
1054
1055 /*
1056 =for apidoc sv_nolocking
1057
1058 Dummy routine which "locks" an SV when there is no locking module present.
1059 Exists to avoid test for a NULL function pointer and because it could
1060 potentially warn under some level of strict-ness.
1061
1062 "Superseded" by sv_nosharing().
1063
1064 =cut
1065 */
1066
1067 void
1068 Perl_sv_nolocking(pTHX_ SV *sv)
1069 {
1070     PERL_UNUSED_ARG(sv);
1071 }
1072
1073
1074 /*
1075 =for apidoc sv_nounlocking
1076
1077 Dummy routine which "unlocks" an SV when there is no locking module present.
1078 Exists to avoid test for a NULL function pointer and because it could
1079 potentially warn under some level of strict-ness.
1080
1081 "Superseded" by sv_nosharing().
1082
1083 =cut
1084 */
1085
1086 void
1087 Perl_sv_nounlocking(pTHX_ SV *sv)
1088 {
1089     PERL_UNUSED_ARG(sv);
1090 }
1091
1092 #endif /* NO_MATHOMS */
1093
1094 /*
1095  * Local variables:
1096  * c-indentation-style: bsd
1097  * c-basic-offset: 4
1098  * indent-tabs-mode: t
1099  * End:
1100  *
1101  * ex: set ts=8 sts=4 sw=4 noet:
1102  */