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