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