Upgrade to PathTools-3.14_01
[perl.git] / mathoms.c
1 /*    mathoms.c
2  *
3  *    Copyright (C) 2005, 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     register IO *rstio;
585     register IO *wstio;
586     int fd[2];
587
588     if (!rgv)
589         goto badexit;
590     if (!wgv)
591         goto badexit;
592
593     rstio = GvIOn(rgv);
594     wstio = GvIOn(wgv);
595
596     if (IoIFP(rstio))
597         do_close(rgv,FALSE);
598     if (IoIFP(wstio))
599         do_close(wgv,FALSE);
600
601     if (PerlProc_pipe(fd) < 0)
602         goto badexit;
603     IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPE_OPEN_MODE);
604     IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPE_OPEN_MODE);
605     IoOFP(rstio) = IoIFP(rstio);
606     IoIFP(wstio) = IoOFP(wstio);
607     IoTYPE(rstio) = IoTYPE_RDONLY;
608     IoTYPE(wstio) = IoTYPE_WRONLY;
609     if (!IoIFP(rstio) || !IoOFP(wstio)) {
610         if (IoIFP(rstio)) PerlIO_close(IoIFP(rstio));
611         else PerlLIO_close(fd[0]);
612         if (IoOFP(wstio)) PerlIO_close(IoOFP(wstio));
613         else PerlLIO_close(fd[1]);
614         goto badexit;
615     }
616
617     sv_setsv(sv,&PL_sv_yes);
618     return;
619
620 badexit:
621     sv_setsv(sv,&PL_sv_undef);
622     return;
623 }
624 #endif
625
626 /* Backwards compatibility. */
627 int
628 Perl_init_i18nl14n(pTHX_ int printwarn)
629 {
630     return init_i18nl10n(printwarn);
631 }
632
633 /* XXX kept for BINCOMPAT only */
634 void
635 Perl_save_hints(pTHX)
636 {
637     Perl_croak(aTHX_ "internal error: obsolete function save_hints() called");
638 }
639
640 #if 0
641 OP *
642 Perl_ck_retarget(pTHX_ OP *o)
643 {
644     Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
645     /* STUB */
646     return o;
647 }
648 #endif
649
650 OP *
651 Perl_oopsCV(pTHX_ OP *o)
652 {
653     Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
654     /* STUB */
655     PERL_UNUSED_ARG(o);
656     NORETURN_FUNCTION_END;
657 }
658
659 PP(pp_padany)
660 {
661     DIE(aTHX_ "NOT IMPL LINE %d",__LINE__);
662 }
663
664 PP(pp_threadsv)
665 {
666     DIE(aTHX_ "tried to access per-thread data in non-threaded perl");
667 }
668
669 PP(pp_mapstart)
670 {
671     DIE(aTHX_ "panic: mapstart");       /* uses grepstart */
672 }
673
674 /* These ops all have the same body as pp_null.  */
675 PP(pp_scalar)
676 {
677     return NORMAL;
678 }
679
680 PP(pp_regcmaybe)
681 {
682     return NORMAL;
683 }
684
685 PP(pp_lineseq)
686 {
687     return NORMAL;
688 }
689
690 PP(pp_scope)
691 {
692     return NORMAL;
693 }
694
695 /* Ops that are calls to do_kv.  */
696 PP(pp_values)
697 {
698     return do_kv();
699 }
700
701 PP(pp_keys)
702 {
703     return do_kv();
704 }
705
706 /* Ops that are simply calls to other ops.  */
707 PP(pp_dump)
708 {
709     return pp_goto();
710     /*NOTREACHED*/
711 }
712
713 PP(pp_dofile)
714 {
715     return pp_require();
716 }
717
718 PP(pp_dbmclose)
719 {
720     return pp_untie();
721 }
722
723 PP(pp_read)
724 {
725     return pp_sysread();
726 }
727
728 PP(pp_recv)
729 {
730     return pp_sysread();
731 }
732
733 PP(pp_seek)
734 {
735     return pp_sysseek();
736 }
737
738 PP(pp_fcntl)
739 {
740     return pp_ioctl();
741 }
742
743 PP(pp_gsockopt)
744 {
745     return pp_ssockopt();
746 }
747
748 PP(pp_getsockname)
749 {
750     return pp_getpeername();
751 }
752
753 PP(pp_lstat)
754 {
755     return pp_stat();
756 }
757
758 PP(pp_fteowned)
759 {
760     return pp_ftrowned();
761 }
762
763 PP(pp_ftbinary)
764 {
765     return pp_fttext();
766 }
767
768 PP(pp_localtime)
769 {
770     return pp_gmtime();
771 }
772
773 PP(pp_shmget)
774 {
775     return pp_semget();
776 }
777
778 PP(pp_shmctl)
779 {
780     return pp_semctl();
781 }
782
783 PP(pp_shmread)
784 {
785     return pp_shmwrite();
786 }
787
788 PP(pp_msgget)
789 {
790     return pp_semget();
791 }
792
793 PP(pp_msgctl)
794 {
795     return pp_semctl();
796 }
797
798 PP(pp_ghbyname)
799 {
800     return pp_ghostent();
801 }
802
803 PP(pp_ghbyaddr)
804 {
805     return pp_ghostent();
806 }
807
808 PP(pp_gnbyname)
809 {
810     return pp_gnetent();
811 }
812
813 PP(pp_gnbyaddr)
814 {
815     return pp_gnetent();
816 }
817
818 PP(pp_gpbyname)
819 {
820     return pp_gprotoent();
821 }
822
823 PP(pp_gpbynumber)
824 {
825     return pp_gprotoent();
826 }
827
828 PP(pp_gsbyname)
829 {
830     return pp_gservent();
831 }
832
833 PP(pp_gsbyport)
834 {
835     return pp_gservent();
836 }
837
838 PP(pp_gpwnam)
839 {
840     return pp_gpwent();
841 }
842
843 PP(pp_gpwuid)
844 {
845     return pp_gpwent();
846 }
847
848 PP(pp_ggrnam)
849 {
850     return pp_ggrent();
851 }
852
853 PP(pp_ggrgid)
854 {
855     return pp_ggrent();
856 }
857
858 PP(pp_ftsize)
859 {
860     return pp_ftis();
861 }
862
863 PP(pp_ftmtime)
864 {
865     return pp_ftis();
866 }
867
868 PP(pp_ftatime)
869 {
870     return pp_ftis();
871 }
872
873 PP(pp_ftctime)
874 {
875     return pp_ftis();
876 }
877
878 PP(pp_ftzero)
879 {
880     return pp_ftrowned();
881 }
882
883 PP(pp_ftsock)
884 {
885     return pp_ftrowned();
886 }
887
888 PP(pp_ftchr)
889 {
890     return pp_ftrowned();
891 }
892
893 PP(pp_ftblk)
894 {
895     return pp_ftrowned();
896 }
897
898 PP(pp_ftfile)
899 {
900     return pp_ftrowned();
901 }
902
903 PP(pp_ftdir)
904 {
905     return pp_ftrowned();
906 }
907
908 PP(pp_ftpipe)
909 {
910     return pp_ftrowned();
911 }
912
913 PP(pp_ftsuid)
914 {
915     return pp_ftrowned();
916 }
917
918 PP(pp_ftsgid)
919 {
920     return pp_ftrowned();
921 }
922
923 PP(pp_ftsvtx)
924 {
925     return pp_ftrowned();
926 }
927
928 PP(pp_unlink)
929 {
930     return pp_chown();
931 }
932
933 PP(pp_chmod)
934 {
935     return pp_chown();
936 }
937
938 PP(pp_utime)
939 {
940     return pp_chown();
941 }
942
943 PP(pp_kill)
944 {
945     return pp_chown();
946 }
947
948 PP(pp_symlink)
949 {
950     return pp_link();
951 }
952
953 PP(pp_ftrwrite)
954 {
955     return pp_ftrread();
956 }
957
958 PP(pp_ftrexec)
959 {
960     return pp_ftrread();
961 }
962
963 PP(pp_fteread)
964 {
965     return pp_ftrread();
966 }
967
968 PP(pp_ftewrite)
969 {
970     return pp_ftrread();
971 }
972
973 PP(pp_fteexec)
974 {
975     return pp_ftrread();
976 }
977
978 PP(pp_msgsnd)
979 {
980     return pp_shmwrite();
981 }
982
983 PP(pp_msgrcv)
984 {
985     return pp_shmwrite();
986 }
987
988 PP(pp_syswrite)
989 {
990     return pp_send();
991 }
992
993 PP(pp_semop)
994 {
995     return pp_shmwrite();
996 }
997
998 PP(pp_dor)
999 {
1000     return pp_defined();
1001 }
1002
1003 PP(pp_andassign)
1004 {
1005     return pp_and();
1006 }
1007
1008 PP(pp_orassign)
1009 {
1010     return pp_or();
1011 }
1012
1013 PP(pp_dorassign)
1014 {
1015     return pp_defined();
1016
1017
1018 PP(pp_lcfirst)
1019 {
1020     return pp_ucfirst();
1021 }
1022
1023 PP(pp_slt)
1024 {
1025     return pp_sle();
1026 }
1027
1028 PP(pp_sgt)
1029 {
1030     return pp_sle();
1031 }
1032
1033 PP(pp_sge)
1034 {
1035     return pp_sle();
1036 }
1037
1038 U8 *
1039 Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
1040 {
1041     return Perl_uvuni_to_utf8_flags(aTHX_ d, uv, 0);
1042 }
1043
1044 bool
1045 Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep)
1046 {
1047     return is_utf8_string_loclen(s, len, ep, 0);
1048 }
1049
1050 /*
1051 =for apidoc sv_nolocking
1052
1053 Dummy routine which "locks" an SV when there is no locking module present.
1054 Exists to avoid test for a NULL function pointer and because it could
1055 potentially warn under some level of strict-ness.
1056
1057 "Superseded" by sv_nosharing().
1058
1059 =cut
1060 */
1061
1062 void
1063 Perl_sv_nolocking(pTHX_ SV *sv)
1064 {
1065     PERL_UNUSED_ARG(sv);
1066 }
1067
1068
1069 /*
1070 =for apidoc sv_nounlocking
1071
1072 Dummy routine which "unlocks" an SV when there is no locking module present.
1073 Exists to avoid test for a NULL function pointer and because it could
1074 potentially warn under some level of strict-ness.
1075
1076 "Superseded" by sv_nosharing().
1077
1078 =cut
1079 */
1080
1081 void
1082 Perl_sv_nounlocking(pTHX_ SV *sv)
1083 {
1084     PERL_UNUSED_ARG(sv);
1085 }
1086
1087 #endif /* NO_MATHOMS */
1088
1089 /*
1090  * Local variables:
1091  * c-indentation-style: bsd
1092  * c-basic-offset: 4
1093  * indent-tabs-mode: t
1094  * End:
1095  *
1096  * ex: set ts=8 sts=4 sw=4 noet:
1097  */