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  */