mathoms.c

   1 /*    mathoms.c
   2  *
   3  *    Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010,
   4  *    2011, 2012 by Larry Wall and others
   5  *
   6  *    You may distribute under the terms of either the GNU General Public
   7  *    License or the Artistic License, as specified in the README file.
   8  *
   9  */
  10
  11 /*
  12  *  Anything that Hobbits had no immediate use for, but were unwilling to
  13  *  throw away, they called a mathom.  Their dwellings were apt to become
  14  *  rather crowded with mathoms, and many of the presents that passed from
  15  *  hand to hand were of that sort.
  16  *
  17  *     [p.5 of _The Lord of the Rings_: "Prologue"]
  18  */
  19
  20
  21
  22 /*
  23  * This file contains mathoms, various binary artifacts from previous
  24  * versions of Perl.  For binary or source compatibility reasons, though,
  25  * we cannot completely remove them from the core code.
  26  *
  27  * SMP - Oct. 24, 2005
  28  *
  29  */
  30
  31 #include "EXTERN.h"
  32 #define PERL_IN_MATHOMS_C
  33 #include "perl.h"
  34
  35 #ifdef NO_MATHOMS
  36 /* ..." warning: ISO C forbids an empty source file"
  37    So make sure we have something in here by processing the headers anyway.
  38  */
  39 #else
  40
  41 /* Not all of these have prototypes elsewhere, so do this to get
  42  * non-mangled names.
  43  */
  44 START_EXTERN_C
  45
  46 PERL_CALLCONV OP * Perl_ref(pTHX_ OP *o, I32 type);
  47 PERL_CALLCONV void Perl_sv_unref(pTHX_ SV *sv);
  48 PERL_CALLCONV void Perl_sv_taint(pTHX_ SV *sv);
  49 PERL_CALLCONV IV Perl_sv_2iv(pTHX_ register SV *sv);
  50 PERL_CALLCONV UV Perl_sv_2uv(pTHX_ register SV *sv);
  51 PERL_CALLCONV NV Perl_sv_2nv(pTHX_ register SV *sv);
  52 PERL_CALLCONV char * Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp);
  53 PERL_CALLCONV char * Perl_sv_2pv_nolen(pTHX_ register SV *sv);
  54 PERL_CALLCONV char * Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv);
  55 PERL_CALLCONV char * Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv);
  56 PERL_CALLCONV void Perl_sv_force_normal(pTHX_ register SV *sv);
  57 PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr);
  58 PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen);
  59 PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len);
  60 PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr);
  61 PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, register SV *ssv);
  62 PERL_CALLCONV char * Perl_sv_pv(pTHX_ SV *sv);
  63 PERL_CALLCONV char * Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp);
  64 PERL_CALLCONV char * Perl_sv_pvbyte(pTHX_ SV *sv);
  65 PERL_CALLCONV char * Perl_sv_pvutf8(pTHX_ SV *sv);
  66 PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ register SV *sv);
  67 PERL_CALLCONV NV Perl_huge(void);
  68 PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
  69 PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
  70 PERL_CALLCONV GV * Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name);
  71 PERL_CALLCONV HE * Perl_hv_iternext(pTHX_ HV *hv);
  72 PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how);
  73 PERL_CALLCONV bool Perl_do_open(pTHX_ GV *gv, register const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp);
  74 PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV *really, register SV **mark, register SV **sp);
  75 PERL_CALLCONV U8 * Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv);
  76 PERL_CALLCONV bool Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep);
  77 PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv);
  78 PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len);
  79 PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len);
  80 PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...);
  81 PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...);
  82 PERL_CALLCONV int Perl_magic_setglob(pTHX_ SV* sv, MAGIC* mg);
  83 PERL_CALLCONV AV * Perl_newAV(pTHX);
  84 PERL_CALLCONV HV * Perl_newHV(pTHX);
  85 PERL_CALLCONV IO * Perl_newIO(pTHX);
  86 PERL_CALLCONV I32 Perl_my_stat(pTHX);
  87 PERL_CALLCONV I32 Perl_my_lstat(pTHX);
  88 PERL_CALLCONV I32 Perl_sv_eq(pTHX_ register SV *sv1, register SV *sv2);
  89 PERL_CALLCONV char * Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp);
  90 PERL_CALLCONV bool Perl_sv_2bool(pTHX_ register SV *const sv);
  91 PERL_CALLCONV CV * Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block);
  92 PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
  93 PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
  94 PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
  95 PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
  96
  97 /* ref() is now a macro using Perl_doref;
  98  * this version provided for binary compatibility only.
  99  */
 100 OP *
 101 Perl_ref(pTHX_ OP *o, I32 type)
 102 {
 103     return doref(o, type, TRUE);
 104 }
 105
 106 /*
 107 =for apidoc sv_unref
 108
 109 Unsets the RV status of the SV, and decrements the reference count of
 110 whatever was being referenced by the RV.  This can almost be thought of
 111 as a reversal of C<newSVrv>.  This is C<sv_unref_flags> with the C<flag>
 112 being zero.  See C<SvROK_off>.
 113
 114 =cut
 115 */
 116
 117 void
 118 Perl_sv_unref(pTHX_ SV *sv)
 119 {
 120     PERL_ARGS_ASSERT_SV_UNREF;
 121
 122     sv_unref_flags(sv, 0);
 123 }
 124
 125 /*
 126 =for apidoc sv_taint
 127
 128 Taint an SV. Use C<SvTAINTED_on> instead.
 129
 130 =cut
 131 */
 132
 133 void
 134 Perl_sv_taint(pTHX_ SV *sv)
 135 {
 136     PERL_ARGS_ASSERT_SV_TAINT;
 137
 138     sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0);
 139 }
 140
 141 /* sv_2iv() is now a macro using Perl_sv_2iv_flags();
 142  * this function provided for binary compatibility only
 143  */
 144
 145 IV
 146 Perl_sv_2iv(pTHX_ register SV *sv)
 147 {
 148     return sv_2iv_flags(sv, SV_GMAGIC);
 149 }
 150
 151 /* sv_2uv() is now a macro using Perl_sv_2uv_flags();
 152  * this function provided for binary compatibility only
 153  */
 154
 155 UV
 156 Perl_sv_2uv(pTHX_ register SV *sv)
 157 {
 158     return sv_2uv_flags(sv, SV_GMAGIC);
 159 }
 160
 161 /* sv_2nv() is now a macro using Perl_sv_2nv_flags();
 162  * this function provided for binary compatibility only
 163  */
 164
 165 NV
 166 Perl_sv_2nv(pTHX_ register SV *sv)
 167 {
 168     return sv_2nv_flags(sv, SV_GMAGIC);
 169 }
 170
 171
 172 /* sv_2pv() is now a macro using Perl_sv_2pv_flags();
 173  * this function provided for binary compatibility only
 174  */
 175
 176 char *
 177 Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp)
 178 {
 179     return sv_2pv_flags(sv, lp, SV_GMAGIC);
 180 }
 181
 182 /*
 183 =for apidoc sv_2pv_nolen
 184
 185 Like C<sv_2pv()>, but doesn't return the length too. You should usually
 186 use the macro wrapper C<SvPV_nolen(sv)> instead.
 187
 188 =cut
 189 */
 190
 191 char *
 192 Perl_sv_2pv_nolen(pTHX_ register SV *sv)
 193 {
 194     PERL_ARGS_ASSERT_SV_2PV_NOLEN;
 195     return sv_2pv(sv, NULL);
 196 }
 197
 198 /*
 199 =for apidoc sv_2pvbyte_nolen
 200
 201 Return a pointer to the byte-encoded representation of the SV.
 202 May cause the SV to be downgraded from UTF-8 as a side-effect.
 203
 204 Usually accessed via the C<SvPVbyte_nolen> macro.
 205
 206 =cut
 207 */
 208
 209 char *
 210 Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv)
 211 {
 212     PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN;
 213
 214     return sv_2pvbyte(sv, NULL);
 215 }
 216
 217 /*
 218 =for apidoc sv_2pvutf8_nolen
 219
 220 Return a pointer to the UTF-8-encoded representation of the SV.
 221 May cause the SV to be upgraded to UTF-8 as a side-effect.
 222
 223 Usually accessed via the C<SvPVutf8_nolen> macro.
 224
 225 =cut
 226 */
 227
 228 char *
 229 Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv)
 230 {
 231     PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN;
 232
 233     return sv_2pvutf8(sv, NULL);
 234 }
 235
 236 /*
 237 =for apidoc sv_force_normal
 238
 239 Undo various types of fakery on an SV: if the PV is a shared string, make
 240 a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
 241 an xpvmg. See also C<sv_force_normal_flags>.
 242
 243 =cut
 244 */
 245
 246 void
 247 Perl_sv_force_normal(pTHX_ register SV *sv)
 248 {
 249     PERL_ARGS_ASSERT_SV_FORCE_NORMAL;
 250
 251     sv_force_normal_flags(sv, 0);
 252 }
 253
 254 /* sv_setsv() is now a macro using Perl_sv_setsv_flags();
 255  * this function provided for binary compatibility only
 256  */
 257
 258 void
 259 Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr)
 260 {
 261     PERL_ARGS_ASSERT_SV_SETSV;
 262
 263     sv_setsv_flags(dstr, sstr, SV_GMAGIC);
 264 }
 265
 266 /* sv_catpvn() is now a macro using Perl_sv_catpvn_flags();
 267  * this function provided for binary compatibility only
 268  */
 269
 270 void
 271 Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen)
 272 {
 273     PERL_ARGS_ASSERT_SV_CATPVN;
 274
 275     sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC);
 276 }
 277
 278 /*
 279 =for apidoc sv_catpvn_mg
 280
 281 Like C<sv_catpvn>, but also handles 'set' magic.
 282
 283 =cut
 284 */
 285
 286 void
 287 Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
 288 {
 289     PERL_ARGS_ASSERT_SV_CATPVN_MG;
 290
 291     sv_catpvn_flags(sv,ptr,len,SV_GMAGIC|SV_SMAGIC);
 292 }
 293
 294 /* sv_catsv() is now a macro using Perl_sv_catsv_flags();
 295  * this function provided for binary compatibility only
 296  */
 297
 298 void
 299 Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr)
 300 {
 301     PERL_ARGS_ASSERT_SV_CATSV;
 302
 303     sv_catsv_flags(dstr, sstr, SV_GMAGIC);
 304 }
 305
 306 /*
 307 =for apidoc sv_catsv_mg
 308
 309 Like C<sv_catsv>, but also handles 'set' magic.
 310
 311 =cut
 312 */
 313
 314 void
 315 Perl_sv_catsv_mg(pTHX_ SV *dsv, register SV *ssv)
 316 {
 317     PERL_ARGS_ASSERT_SV_CATSV_MG;
 318
 319     sv_catsv_flags(dsv,ssv,SV_GMAGIC|SV_SMAGIC);
 320 }
 321
 322 /*
 323 =for apidoc sv_iv
 324
 325 A private implementation of the C<SvIVx> macro for compilers which can't
 326 cope with complex macro expressions. Always use the macro instead.
 327
 328 =cut
 329 */
 330
 331 IV
 332 Perl_sv_iv(pTHX_ register SV *sv)
 333 {
 334     PERL_ARGS_ASSERT_SV_IV;
 335
 336     if (SvIOK(sv)) {
 337         if (SvIsUV(sv))
 338             return (IV)SvUVX(sv);
 339         return SvIVX(sv);
 340     }
 341     return sv_2iv(sv);
 342 }
 343
 344 /*
 345 =for apidoc sv_uv
 346
 347 A private implementation of the C<SvUVx> macro for compilers which can't
 348 cope with complex macro expressions. Always use the macro instead.
 349
 350 =cut
 351 */
 352
 353 UV
 354 Perl_sv_uv(pTHX_ register SV *sv)
 355 {
 356     PERL_ARGS_ASSERT_SV_UV;
 357
 358     if (SvIOK(sv)) {
 359         if (SvIsUV(sv))
 360             return SvUVX(sv);
 361         return (UV)SvIVX(sv);
 362     }
 363     return sv_2uv(sv);
 364 }
 365
 366 /*
 367 =for apidoc sv_nv
 368
 369 A private implementation of the C<SvNVx> macro for compilers which can't
 370 cope with complex macro expressions. Always use the macro instead.
 371
 372 =cut
 373 */
 374
 375 NV
 376 Perl_sv_nv(pTHX_ register SV *sv)
 377 {
 378     PERL_ARGS_ASSERT_SV_NV;
 379
 380     if (SvNOK(sv))
 381         return SvNVX(sv);
 382     return sv_2nv(sv);
 383 }
 384
 385 /*
 386 =for apidoc sv_pv
 387
 388 Use the C<SvPV_nolen> macro instead
 389
 390 =for apidoc sv_pvn
 391
 392 A private implementation of the C<SvPV> macro for compilers which can't
 393 cope with complex macro expressions. Always use the macro instead.
 394
 395 =cut
 396 */
 397
 398 char *
 399 Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp)
 400 {
 401     PERL_ARGS_ASSERT_SV_PVN;
 402
 403     if (SvPOK(sv)) {
 404         *lp = SvCUR(sv);
 405         return SvPVX(sv);
 406     }
 407     return sv_2pv(sv, lp);
 408 }
 409
 410
 411 char *
 412 Perl_sv_pvn_nomg(pTHX_ register SV *sv, STRLEN *lp)
 413 {
 414     PERL_ARGS_ASSERT_SV_PVN_NOMG;
 415
 416     if (SvPOK(sv)) {
 417         *lp = SvCUR(sv);
 418         return SvPVX(sv);
 419     }
 420     return sv_2pv_flags(sv, lp, 0);
 421 }
 422
 423 /* sv_pv() is now a macro using SvPV_nolen();
 424  * this function provided for binary compatibility only
 425  */
 426
 427 char *
 428 Perl_sv_pv(pTHX_ SV *sv)
 429 {
 430     PERL_ARGS_ASSERT_SV_PV;
 431
 432     if (SvPOK(sv))
 433         return SvPVX(sv);
 434
 435     return sv_2pv(sv, NULL);
 436 }
 437
 438 /* sv_pvn_force() is now a macro using Perl_sv_pvn_force_flags();
 439  * this function provided for binary compatibility only
 440  */
 441
 442 char *
 443 Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp)
 444 {
 445     PERL_ARGS_ASSERT_SV_PVN_FORCE;
 446
 447     return sv_pvn_force_flags(sv, lp, SV_GMAGIC);
 448 }
 449
 450 /* sv_pvbyte () is now a macro using Perl_sv_2pv_flags();
 451  * this function provided for binary compatibility only
 452  */
 453
 454 char *
 455 Perl_sv_pvbyte(pTHX_ SV *sv)
 456 {
 457     PERL_ARGS_ASSERT_SV_PVBYTE;
 458
 459     sv_utf8_downgrade(sv, FALSE);
 460     return sv_pv(sv);
 461 }
 462
 463 /*
 464 =for apidoc sv_pvbyte
 465
 466 Use C<SvPVbyte_nolen> instead.
 467
 468 =for apidoc sv_pvbyten
 469
 470 A private implementation of the C<SvPVbyte> macro for compilers
 471 which can't cope with complex macro expressions. Always use the macro
 472 instead.
 473
 474 =cut
 475 */
 476
 477 char *
 478 Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp)
 479 {
 480     PERL_ARGS_ASSERT_SV_PVBYTEN;
 481
 482     sv_utf8_downgrade(sv, FALSE);
 483     return sv_pvn(sv,lp);
 484 }
 485
 486 /* sv_pvutf8 () is now a macro using Perl_sv_2pv_flags();
 487  * this function provided for binary compatibility only
 488  */
 489
 490 char *
 491 Perl_sv_pvutf8(pTHX_ SV *sv)
 492 {
 493     PERL_ARGS_ASSERT_SV_PVUTF8;
 494
 495     sv_utf8_upgrade(sv);
 496     return sv_pv(sv);
 497 }
 498
 499 /*
 500 =for apidoc sv_pvutf8
 501
 502 Use the C<SvPVutf8_nolen> macro instead
 503
 504 =for apidoc sv_pvutf8n
 505
 506 A private implementation of the C<SvPVutf8> macro for compilers
 507 which can't cope with complex macro expressions. Always use the macro
 508 instead.
 509
 510 =cut
 511 */
 512
 513 char *
 514 Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp)
 515 {
 516     PERL_ARGS_ASSERT_SV_PVUTF8N;
 517
 518     sv_utf8_upgrade(sv);
 519     return sv_pvn(sv,lp);
 520 }
 521
 522 /* sv_utf8_upgrade() is now a macro using sv_utf8_upgrade_flags();
 523  * this function provided for binary compatibility only
 524  */
 525
 526 STRLEN
 527 Perl_sv_utf8_upgrade(pTHX_ register SV *sv)
 528 {
 529     PERL_ARGS_ASSERT_SV_UTF8_UPGRADE;
 530
 531     return sv_utf8_upgrade_flags(sv, SV_GMAGIC);
 532 }
 533
 534 int
 535 Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...)
 536 {
 537     dTHXs;
 538     va_list(arglist);
 539
 540     /* Easier to special case this here than in embed.pl. (Look at what it
 541        generates for proto.h) */
 542 #ifdef PERL_IMPLICIT_CONTEXT
 543     PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT;
 544 #endif
 545
 546     va_start(arglist, format);
 547     return PerlIO_vprintf(stream, format, arglist);
 548 }
 549
 550 int
 551 Perl_printf_nocontext(const char *format, ...)
 552 {
 553     dTHX;
 554     va_list(arglist);
 555
 556 #ifdef PERL_IMPLICIT_CONTEXT
 557     PERL_ARGS_ASSERT_PRINTF_NOCONTEXT;
 558 #endif
 559
 560     va_start(arglist, format);
 561     return PerlIO_vprintf(PerlIO_stdout(), format, arglist);
 562 }
 563
 564 #if defined(HUGE_VAL) || (defined(USE_LONG_DOUBLE) && defined(HUGE_VALL))
 565 /*
 566  * This hack is to force load of "huge" support from libm.a
 567  * So it is in perl for (say) POSIX to use.
 568  * Needed for SunOS with Sun's 'acc' for example.
 569  */
 570 NV
 571 Perl_huge(void)
 572 {
 573 #  if defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)
 574     return HUGE_VALL;
 575 #  else
 576     return HUGE_VAL;
 577 #  endif
 578 }
 579 #endif
 580
 581 /* compatibility with versions <= 5.003. */
 582 void
 583 Perl_gv_fullname(pTHX_ SV *sv, const GV *gv)
 584 {
 585     PERL_ARGS_ASSERT_GV_FULLNAME;
 586
 587     gv_fullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
 588 }
 589
 590 /* compatibility with versions <= 5.003. */
 591 void
 592 Perl_gv_efullname(pTHX_ SV *sv, const GV *gv)
 593 {
 594     PERL_ARGS_ASSERT_GV_EFULLNAME;
 595
 596     gv_efullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
 597 }
 598
 599 void
 600 Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
 601 {
 602     PERL_ARGS_ASSERT_GV_FULLNAME3;
 603
 604     gv_fullname4(sv, gv, prefix, TRUE);
 605 }
 606
 607 void
 608 Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
 609 {
 610     PERL_ARGS_ASSERT_GV_EFULLNAME3;
 611
 612     gv_efullname4(sv, gv, prefix, TRUE);
 613 }
 614
 615 /*
 616 =for apidoc gv_fetchmethod
 617
 618 See L</gv_fetchmethod_autoload>.
 619
 620 =cut
 621 */
 622
 623 GV *
 624 Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
 625 {
 626     PERL_ARGS_ASSERT_GV_FETCHMETHOD;
 627
 628     return gv_fetchmethod_autoload(stash, name, TRUE);
 629 }
 630
 631 HE *
 632 Perl_hv_iternext(pTHX_ HV *hv)
 633 {
 634     PERL_ARGS_ASSERT_HV_ITERNEXT;
 635
 636     return hv_iternext_flags(hv, 0);
 637 }
 638
 639 void
 640 Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how)
 641 {
 642     PERL_ARGS_ASSERT_HV_MAGIC;
 643
 644     sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0);
 645 }
 646
 647 bool
 648 Perl_do_open(pTHX_ GV *gv, register const char *name, I32 len, int as_raw,
 649              int rawmode, int rawperm, PerlIO *supplied_fp)
 650 {
 651     PERL_ARGS_ASSERT_DO_OPEN;
 652
 653     return do_openn(gv, name, len, as_raw, rawmode, rawperm,
 654                     supplied_fp, (SV **) NULL, 0);
 655 }
 656
 657 bool
 658 Perl_do_open9(pTHX_ GV *gv, register const char *name, I32 len, int
 659 as_raw,
 660               int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs,
 661               I32 num_svs)
 662 {
 663     PERL_ARGS_ASSERT_DO_OPEN9;
 664
 665     PERL_UNUSED_ARG(num_svs);
 666     return do_openn(gv, name, len, as_raw, rawmode, rawperm,
 667                     supplied_fp, &svs, 1);
 668 }
 669
 670 int
 671 Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
 672 {
 673  /* The old body of this is now in non-LAYER part of perlio.c
 674   * This is a stub for any XS code which might have been calling it.
 675   */
 676  const char *name = ":raw";
 677
 678  PERL_ARGS_ASSERT_DO_BINMODE;
 679
 680 #ifdef PERLIO_USING_CRLF
 681  if (!(mode & O_BINARY))
 682      name = ":crlf";
 683 #endif
 684  return PerlIO_binmode(aTHX_ fp, iotype, mode, name);
 685 }
 686
 687 #ifndef OS2
 688 bool
 689 Perl_do_aexec(pTHX_ SV *really, register SV **mark, register SV **sp)
 690 {
 691     PERL_ARGS_ASSERT_DO_AEXEC;
 692
 693     return do_aexec5(really, mark, sp, 0, 0);
 694 }
 695 #endif
 696
 697 /* Backwards compatibility. */
 698 int
 699 Perl_init_i18nl14n(pTHX_ int printwarn)
 700 {
 701     return init_i18nl10n(printwarn);
 702 }
 703
 704 U8 *
 705 Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
 706 {
 707     PERL_ARGS_ASSERT_UVUNI_TO_UTF8;
 708
 709     return Perl_uvuni_to_utf8_flags(aTHX_ d, uv, 0);
 710 }
 711
 712 bool
 713 Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep)
 714 {
 715     PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC;
 716
 717     return is_utf8_string_loclen(s, len, ep, 0);
 718 }
 719
 720 /*
 721 =for apidoc sv_nolocking
 722
 723 Dummy routine which "locks" an SV when there is no locking module present.
 724 Exists to avoid test for a NULL function pointer and because it could
 725 potentially warn under some level of strict-ness.
 726
 727 "Superseded" by sv_nosharing().
 728
 729 =cut
 730 */
 731
 732 void
 733 Perl_sv_nolocking(pTHX_ SV *sv)
 734 {
 735     PERL_UNUSED_CONTEXT;
 736     PERL_UNUSED_ARG(sv);
 737 }
 738
 739
 740 /*
 741 =for apidoc sv_nounlocking
 742
 743 Dummy routine which "unlocks" an SV when there is no locking module present.
 744 Exists to avoid test for a NULL function pointer and because it could
 745 potentially warn under some level of strict-ness.
 746
 747 "Superseded" by sv_nosharing().
 748
 749 =cut
 750 */
 751
 752 void
 753 Perl_sv_nounlocking(pTHX_ SV *sv)
 754 {
 755     PERL_UNUSED_CONTEXT;
 756     PERL_UNUSED_ARG(sv);
 757 }
 758
 759 void
 760 Perl_save_long(pTHX_ long int *longp)
 761 {
 762     dVAR;
 763
 764     PERL_ARGS_ASSERT_SAVE_LONG;
 765
 766     SSCHECK(3);
 767     SSPUSHLONG(*longp);
 768     SSPUSHPTR(longp);
 769     SSPUSHUV(SAVEt_LONG);
 770 }
 771
 772 void
 773 Perl_save_iv(pTHX_ IV *ivp)
 774 {
 775     dVAR;
 776
 777     PERL_ARGS_ASSERT_SAVE_IV;
 778
 779     SSCHECK(3);
 780     SSPUSHIV(*ivp);
 781     SSPUSHPTR(ivp);
 782     SSPUSHUV(SAVEt_IV);
 783 }
 784
 785 void
 786 Perl_save_nogv(pTHX_ GV *gv)
 787 {
 788     dVAR;
 789
 790     PERL_ARGS_ASSERT_SAVE_NOGV;
 791
 792     SSCHECK(2);
 793     SSPUSHPTR(gv);
 794     SSPUSHUV(SAVEt_NSTAB);
 795 }
 796
 797 void
 798 Perl_save_list(pTHX_ register SV **sarg, I32 maxsarg)
 799 {
 800     dVAR;
 801     register I32 i;
 802
 803     PERL_ARGS_ASSERT_SAVE_LIST;
 804
 805     for (i = 1; i <= maxsarg; i++) {
 806         register SV * const sv = newSV(0);
 807         sv_setsv(sv,sarg[i]);
 808         SSCHECK(3);
 809         SSPUSHPTR(sarg[i]);             /* remember the pointer */
 810         SSPUSHPTR(sv);                  /* remember the value */
 811         SSPUSHUV(SAVEt_ITEM);
 812     }
 813 }
 814
 815 /*
 816 =for apidoc sv_usepvn_mg
 817
 818 Like C<sv_usepvn>, but also handles 'set' magic.
 819
 820 =cut
 821 */
 822
 823 void
 824 Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len)
 825 {
 826     PERL_ARGS_ASSERT_SV_USEPVN_MG;
 827
 828     sv_usepvn_flags(sv,ptr,len, SV_SMAGIC);
 829 }
 830
 831 /*
 832 =for apidoc sv_usepvn
 833
 834 Tells an SV to use C<ptr> to find its string value. Implemented by
 835 calling C<sv_usepvn_flags> with C<flags> of 0, hence does not handle 'set'
 836 magic. See C<sv_usepvn_flags>.
 837
 838 =cut
 839 */
 840
 841 void
 842 Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len)
 843 {
 844     PERL_ARGS_ASSERT_SV_USEPVN;
 845
 846     sv_usepvn_flags(sv,ptr,len, 0);
 847 }
 848
 849 /*
 850 =for apidoc unpack_str
 851
 852 The engine implementing unpack() Perl function. Note: parameters strbeg, new_s
 853 and ocnt are not used. This call should not be used, use unpackstring instead.
 854
 855 =cut */
 856
 857 I32
 858 Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s,
 859                 const char *strbeg, const char *strend, char **new_s, I32 ocnt,
 860                 U32 flags)
 861 {
 862     PERL_ARGS_ASSERT_UNPACK_STR;
 863
 864     PERL_UNUSED_ARG(strbeg);
 865     PERL_UNUSED_ARG(new_s);
 866     PERL_UNUSED_ARG(ocnt);
 867
 868     return unpackstring(pat, patend, s, strend, flags);
 869 }
 870
 871 /*
 872 =for apidoc pack_cat
 873
 874 The engine implementing pack() Perl function. Note: parameters next_in_list and
 875 flags are not used. This call should not be used; use packlist instead.
 876
 877 =cut
 878 */
 879
 880 void
 881 Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, register SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
 882 {
 883     PERL_ARGS_ASSERT_PACK_CAT;
 884
 885     PERL_UNUSED_ARG(next_in_list);
 886     PERL_UNUSED_ARG(flags);
 887
 888     packlist(cat, pat, patend, beglist, endlist);
 889 }
 890
 891 HE *
 892 Perl_hv_store_ent(pTHX_ HV *hv, SV *keysv, SV *val, U32 hash)
 893 {
 894   return (HE *)hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISSTORE, val, hash);
 895 }
 896
 897 bool
 898 Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
 899 {
 900     PERL_ARGS_ASSERT_HV_EXISTS_ENT;
 901
 902     return hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISEXISTS, 0, hash)
 903         ? TRUE : FALSE;
 904 }
 905
 906 HE *
 907 Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash)
 908 {
 909     PERL_ARGS_ASSERT_HV_FETCH_ENT;
 910
 911     return (HE *)hv_common(hv, keysv, NULL, 0, 0,
 912                      (lval ? HV_FETCH_LVALUE : 0), NULL, hash);
 913 }
 914
 915 SV *
 916 Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash)
 917 {
 918     PERL_ARGS_ASSERT_HV_DELETE_ENT;
 919
 920     return MUTABLE_SV(hv_common(hv, keysv, NULL, 0, 0, flags | HV_DELETE, NULL,
 921                                 hash));
 922 }
 923
 924 SV**
 925 Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash,
 926                     int flags)
 927 {
 928     return (SV**) hv_common(hv, NULL, key, klen, flags,
 929                             (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
 930 }
 931
 932 SV**
 933 Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen_i32, SV *val, U32 hash)
 934 {
 935     STRLEN klen;
 936     int flags;
 937
 938     if (klen_i32 < 0) {
 939         klen = -klen_i32;
 940         flags = HVhek_UTF8;
 941     } else {
 942         klen = klen_i32;
 943         flags = 0;
 944     }
 945     return (SV **) hv_common(hv, NULL, key, klen, flags,
 946                              (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
 947 }
 948
 949 bool
 950 Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen_i32)
 951 {
 952     STRLEN klen;
 953     int flags;
 954
 955     PERL_ARGS_ASSERT_HV_EXISTS;
 956
 957     if (klen_i32 < 0) {
 958         klen = -klen_i32;
 959         flags = HVhek_UTF8;
 960     } else {
 961         klen = klen_i32;
 962         flags = 0;
 963     }
 964     return hv_common(hv, NULL, key, klen, flags, HV_FETCH_ISEXISTS, 0, 0)
 965         ? TRUE : FALSE;
 966 }
 967
 968 SV**
 969 Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 lval)
 970 {
 971     STRLEN klen;
 972     int flags;
 973
 974     PERL_ARGS_ASSERT_HV_FETCH;
 975
 976     if (klen_i32 < 0) {
 977         klen = -klen_i32;
 978         flags = HVhek_UTF8;
 979     } else {
 980         klen = klen_i32;
 981         flags = 0;
 982     }
 983     return (SV **) hv_common(hv, NULL, key, klen, flags,
 984                              lval ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE)
 985                              : HV_FETCH_JUST_SV, NULL, 0);
 986 }
 987
 988 SV *
 989 Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 flags)
 990 {
 991     STRLEN klen;
 992     int k_flags;
 993
 994     PERL_ARGS_ASSERT_HV_DELETE;
 995
 996     if (klen_i32 < 0) {
 997         klen = -klen_i32;
 998         k_flags = HVhek_UTF8;
 999     } else {
1000         klen = klen_i32;
1001         k_flags = 0;
1002     }
1003     return MUTABLE_SV(hv_common(hv, NULL, key, klen, k_flags, flags | HV_DELETE,
1004                                 NULL, 0));
1005 }
1006
1007 /* Functions after here were made mathoms post 5.10.0 but pre 5.8.9 */
1008
1009 AV *
1010 Perl_newAV(pTHX)
1011 {
1012     return MUTABLE_AV(newSV_type(SVt_PVAV));
1013     /* sv_upgrade does AvREAL_only():
1014     AvALLOC(av) = 0;
1015     AvARRAY(av) = NULL;
1016     AvMAX(av) = AvFILLp(av) = -1; */
1017 }
1018
1019 HV *
1020 Perl_newHV(pTHX)
1021 {
1022     HV * const hv = MUTABLE_HV(newSV_type(SVt_PVHV));
1023     assert(!SvOK(hv));
1024
1025     return hv;
1026 }
1027
1028 void
1029 Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len,
1030               const char *const little, const STRLEN littlelen)
1031 {
1032     PERL_ARGS_ASSERT_SV_INSERT;
1033     sv_insert_flags(bigstr, offset, len, little, littlelen, SV_GMAGIC);
1034 }
1035
1036 void
1037 Perl_save_freesv(pTHX_ SV *sv)
1038 {
1039     dVAR;
1040     save_freesv(sv);
1041 }
1042
1043 void
1044 Perl_save_mortalizesv(pTHX_ SV *sv)
1045 {
1046     dVAR;
1047
1048     PERL_ARGS_ASSERT_SAVE_MORTALIZESV;
1049
1050     save_mortalizesv(sv);
1051 }
1052
1053 void
1054 Perl_save_freeop(pTHX_ OP *o)
1055 {
1056     dVAR;
1057     save_freeop(o);
1058 }
1059
1060 void
1061 Perl_save_freepv(pTHX_ char *pv)
1062 {
1063     dVAR;
1064     save_freepv(pv);
1065 }
1066
1067 void
1068 Perl_save_op(pTHX)
1069 {
1070     dVAR;
1071     save_op();
1072 }
1073
1074 #ifdef PERL_DONT_CREATE_GVSV
1075 GV *
1076 Perl_gv_SVadd(pTHX_ GV *gv)
1077 {
1078     return gv_SVadd(gv);
1079 }
1080 #endif
1081
1082 GV *
1083 Perl_gv_AVadd(pTHX_ GV *gv)
1084 {
1085     return gv_AVadd(gv);
1086 }
1087
1088 GV *
1089 Perl_gv_HVadd(pTHX_ register GV *gv)
1090 {
1091     return gv_HVadd(gv);
1092 }
1093
1094 GV *
1095 Perl_gv_IOadd(pTHX_ register GV *gv)
1096 {
1097     return gv_IOadd(gv);
1098 }
1099
1100 IO *
1101 Perl_newIO(pTHX)
1102 {
1103     return MUTABLE_IO(newSV_type(SVt_PVIO));
1104 }
1105
1106 I32
1107 Perl_my_stat(pTHX)
1108 {
1109     return my_stat_flags(SV_GMAGIC);
1110 }
1111
1112 I32
1113 Perl_my_lstat(pTHX)
1114 {
1115     return my_lstat_flags(SV_GMAGIC);
1116 }
1117
1118 I32
1119 Perl_sv_eq(pTHX_ register SV *sv1, register SV *sv2)
1120 {
1121     return sv_eq_flags(sv1, sv2, SV_GMAGIC);
1122 }
1123
1124 #ifdef USE_LOCALE_COLLATE
1125 char *
1126 Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp)
1127 {
1128     return sv_collxfrm_flags(sv, nxp, SV_GMAGIC);
1129 }
1130 #endif
1131
1132 bool
1133 Perl_sv_2bool(pTHX_ register SV *const sv)
1134 {
1135     return sv_2bool_flags(sv, SV_GMAGIC);
1136 }
1137
1138
1139 /*
1140 =for apidoc custom_op_name
1141 Return the name for a given custom op. This was once used by the OP_NAME
1142 macro, but is no longer: it has only been kept for compatibility, and
1143 should not be used.
1144
1145 =for apidoc custom_op_desc
1146 Return the description of a given custom op. This was once used by the
1147 OP_DESC macro, but is no longer: it has only been kept for
1148 compatibility, and should not be used.
1149
1150 =cut
1151 */
1152
1153 const char*
1154 Perl_custom_op_name(pTHX_ const OP* o)
1155 {
1156     PERL_ARGS_ASSERT_CUSTOM_OP_NAME;
1157     return XopENTRY(Perl_custom_op_xop(aTHX_ o), xop_name);
1158 }
1159
1160 const char*
1161 Perl_custom_op_desc(pTHX_ const OP* o)
1162 {
1163     PERL_ARGS_ASSERT_CUSTOM_OP_DESC;
1164     return XopENTRY(Perl_custom_op_xop(aTHX_ o), xop_desc);
1165 }
1166
1167 CV *
1168 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
1169 {
1170     return Perl_newATTRSUB(aTHX_ floor, o, proto, NULL, block);
1171 }
1172
1173 UV
1174 Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1175 {
1176     PERL_ARGS_ASSERT_TO_UTF8_FOLD;
1177
1178     return _to_utf8_fold_flags(p, ustrp, lenp, FOLD_FLAGS_FULL, NULL);
1179 }
1180
1181 UV
1182 Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1183 {
1184     PERL_ARGS_ASSERT_TO_UTF8_LOWER;
1185
1186     return _to_utf8_lower_flags(p, ustrp, lenp, FALSE, NULL);
1187 }
1188
1189 UV
1190 Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1191 {
1192     PERL_ARGS_ASSERT_TO_UTF8_TITLE;
1193
1194     return _to_utf8_title_flags(p, ustrp, lenp, FALSE, NULL);
1195 }
1196
1197 UV
1198 Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1199 {
1200     PERL_ARGS_ASSERT_TO_UTF8_UPPER;
1201
1202     return _to_utf8_upper_flags(p, ustrp, lenp, FALSE, NULL);
1203 }
1204
1205 END_EXTERN_C
1206
1207 #endif /* NO_MATHOMS */
1208
1209 /*
1210  * Local variables:
1211  * c-indentation-style: bsd
1212  * c-basic-offset: 4
1213  * indent-tabs-mode: nil
1214  * End:
1215  *
1216  * ex: set ts=8 sts=4 sw=4 et:
1217  */