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  * REMEMBER to update makedef.pl when adding a function to mathoms.c!!!
  28  *
  29  * SMP - Oct. 24, 2005
  30  *
  31  * The compilation of this file can be suppressed; see INSTALL
  32  *
  33 =head1 Obsolete backwards compatibility functions
  34 Some of these are also deprecated.  You can exclude these from
  35 your compiled Perl by adding this option to Configure:
  36 C<-Accflags='-DNO_MATHOMS'>
  37
  38 =cut
  39
  40  */
  41
  42
  43 #include "EXTERN.h"
  44 #define PERL_IN_MATHOMS_C
  45 #include "perl.h"
  46
  47 #ifdef NO_MATHOMS
  48 /* ..." warning: ISO C forbids an empty source file"
  49    So make sure we have something in here by processing the headers anyway.
  50  */
  51 #else
  52
  53 /* Not all of these have prototypes elsewhere, so do this to get
  54  * non-mangled names.
  55  */
  56 START_EXTERN_C
  57
  58 PERL_CALLCONV OP * Perl_ref(pTHX_ OP *o, I32 type);
  59 PERL_CALLCONV void Perl_sv_unref(pTHX_ SV *sv);
  60 PERL_CALLCONV void Perl_sv_taint(pTHX_ SV *sv);
  61 PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv);
  62 PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv);
  63 PERL_CALLCONV NV Perl_sv_2nv(pTHX_ SV *sv);
  64 PERL_CALLCONV char * Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp);
  65 PERL_CALLCONV char * Perl_sv_2pv_nolen(pTHX_ SV *sv);
  66 PERL_CALLCONV char * Perl_sv_2pvbyte_nolen(pTHX_ SV *sv);
  67 PERL_CALLCONV char * Perl_sv_2pvutf8_nolen(pTHX_ SV *sv);
  68 PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv);
  69 PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr);
  70 PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen);
  71 PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len);
  72 PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr);
  73 PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv);
  74 PERL_CALLCONV char * Perl_sv_pv(pTHX_ SV *sv);
  75 PERL_CALLCONV char * Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp);
  76 PERL_CALLCONV char * Perl_sv_pvbyte(pTHX_ SV *sv);
  77 PERL_CALLCONV char * Perl_sv_pvutf8(pTHX_ SV *sv);
  78 PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv);
  79 PERL_CALLCONV NV Perl_huge(void);
  80 PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
  81 PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
  82 PERL_CALLCONV GV * Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name);
  83 PERL_CALLCONV HE * Perl_hv_iternext(pTHX_ HV *hv);
  84 PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how);
  85 PERL_CALLCONV bool Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp);
  86 PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp);
  87 PERL_CALLCONV U8 * Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv);
  88 PERL_CALLCONV bool Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep);
  89 PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv);
  90 PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len);
  91 PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len);
  92 PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...);
  93 PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...);
  94 PERL_CALLCONV int Perl_magic_setglob(pTHX_ SV* sv, MAGIC* mg);
  95 PERL_CALLCONV AV * Perl_newAV(pTHX);
  96 PERL_CALLCONV HV * Perl_newHV(pTHX);
  97 PERL_CALLCONV IO * Perl_newIO(pTHX);
  98 PERL_CALLCONV I32 Perl_my_stat(pTHX);
  99 PERL_CALLCONV I32 Perl_my_lstat(pTHX);
 100 PERL_CALLCONV I32 Perl_sv_eq(pTHX_ SV *sv1, SV *sv2);
 101 PERL_CALLCONV char * Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp);
 102 PERL_CALLCONV bool Perl_sv_2bool(pTHX_ SV *const sv);
 103 PERL_CALLCONV CV * Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block);
 104 PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
 105 PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
 106 PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
 107 PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
 108 PERL_CALLCONV SV *Perl_sv_mortalcopy(pTHX_ SV *const oldstr);
 109
 110 /* ref() is now a macro using Perl_doref;
 111  * this version provided for binary compatibility only.
 112  */
 113 OP *
 114 Perl_ref(pTHX_ OP *o, I32 type)
 115 {
 116     return doref(o, type, TRUE);
 117 }
 118
 119 /*
 120 =for apidoc sv_unref
 121
 122 Unsets the RV status of the SV, and decrements the reference count of
 123 whatever was being referenced by the RV.  This can almost be thought of
 124 as a reversal of C<newSVrv>.  This is C<sv_unref_flags> with the C<flag>
 125 being zero.  See C<SvROK_off>.
 126
 127 =cut
 128 */
 129
 130 void
 131 Perl_sv_unref(pTHX_ SV *sv)
 132 {
 133     PERL_ARGS_ASSERT_SV_UNREF;
 134
 135     sv_unref_flags(sv, 0);
 136 }
 137
 138 /*
 139 =for apidoc sv_taint
 140
 141 Taint an SV.  Use C<SvTAINTED_on> instead.
 142
 143 =cut
 144 */
 145
 146 void
 147 Perl_sv_taint(pTHX_ SV *sv)
 148 {
 149     PERL_ARGS_ASSERT_SV_TAINT;
 150
 151     sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0);
 152 }
 153
 154 /* sv_2iv() is now a macro using Perl_sv_2iv_flags();
 155  * this function provided for binary compatibility only
 156  */
 157
 158 IV
 159 Perl_sv_2iv(pTHX_ SV *sv)
 160 {
 161     PERL_ARGS_ASSERT_SV_2IV;
 162
 163     return sv_2iv_flags(sv, SV_GMAGIC);
 164 }
 165
 166 /* sv_2uv() is now a macro using Perl_sv_2uv_flags();
 167  * this function provided for binary compatibility only
 168  */
 169
 170 UV
 171 Perl_sv_2uv(pTHX_ SV *sv)
 172 {
 173     PERL_ARGS_ASSERT_SV_2UV;
 174
 175     return sv_2uv_flags(sv, SV_GMAGIC);
 176 }
 177
 178 /* sv_2nv() is now a macro using Perl_sv_2nv_flags();
 179  * this function provided for binary compatibility only
 180  */
 181
 182 NV
 183 Perl_sv_2nv(pTHX_ SV *sv)
 184 {
 185     return sv_2nv_flags(sv, SV_GMAGIC);
 186 }
 187
 188
 189 /* sv_2pv() is now a macro using Perl_sv_2pv_flags();
 190  * this function provided for binary compatibility only
 191  */
 192
 193 char *
 194 Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp)
 195 {
 196     PERL_ARGS_ASSERT_SV_2PV;
 197
 198     return sv_2pv_flags(sv, lp, SV_GMAGIC);
 199 }
 200
 201 /*
 202 =for apidoc sv_2pv_nolen
 203
 204 Like C<sv_2pv()>, but doesn't return the length too.  You should usually
 205 use the macro wrapper C<SvPV_nolen(sv)> instead.
 206
 207 =cut
 208 */
 209
 210 char *
 211 Perl_sv_2pv_nolen(pTHX_ SV *sv)
 212 {
 213     PERL_ARGS_ASSERT_SV_2PV_NOLEN;
 214     return sv_2pv(sv, NULL);
 215 }
 216
 217 /*
 218 =for apidoc sv_2pvbyte_nolen
 219
 220 Return a pointer to the byte-encoded representation of the SV.
 221 May cause the SV to be downgraded from UTF-8 as a side-effect.
 222
 223 Usually accessed via the C<SvPVbyte_nolen> macro.
 224
 225 =cut
 226 */
 227
 228 char *
 229 Perl_sv_2pvbyte_nolen(pTHX_ SV *sv)
 230 {
 231     PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN;
 232
 233     return sv_2pvbyte(sv, NULL);
 234 }
 235
 236 /*
 237 =for apidoc sv_2pvutf8_nolen
 238
 239 Return a pointer to the UTF-8-encoded representation of the SV.
 240 May cause the SV to be upgraded to UTF-8 as a side-effect.
 241
 242 Usually accessed via the C<SvPVutf8_nolen> macro.
 243
 244 =cut
 245 */
 246
 247 char *
 248 Perl_sv_2pvutf8_nolen(pTHX_ SV *sv)
 249 {
 250     PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN;
 251
 252     return sv_2pvutf8(sv, NULL);
 253 }
 254
 255 /*
 256 =for apidoc sv_force_normal
 257
 258 Undo various types of fakery on an SV: if the PV is a shared string, make
 259 a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
 260 an xpvmg.  See also C<sv_force_normal_flags>.
 261
 262 =cut
 263 */
 264
 265 void
 266 Perl_sv_force_normal(pTHX_ SV *sv)
 267 {
 268     PERL_ARGS_ASSERT_SV_FORCE_NORMAL;
 269
 270     sv_force_normal_flags(sv, 0);
 271 }
 272
 273 /* sv_setsv() is now a macro using Perl_sv_setsv_flags();
 274  * this function provided for binary compatibility only
 275  */
 276
 277 void
 278 Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr)
 279 {
 280     PERL_ARGS_ASSERT_SV_SETSV;
 281
 282     sv_setsv_flags(dstr, sstr, SV_GMAGIC);
 283 }
 284
 285 /* sv_catpvn() is now a macro using Perl_sv_catpvn_flags();
 286  * this function provided for binary compatibility only
 287  */
 288
 289 void
 290 Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen)
 291 {
 292     PERL_ARGS_ASSERT_SV_CATPVN;
 293
 294     sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC);
 295 }
 296
 297 /*
 298 =for apidoc sv_catpvn_mg
 299
 300 Like C<sv_catpvn>, but also handles 'set' magic.
 301
 302 =cut
 303 */
 304
 305 void
 306 Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len)
 307 {
 308     PERL_ARGS_ASSERT_SV_CATPVN_MG;
 309
 310     sv_catpvn_flags(sv,ptr,len,SV_GMAGIC|SV_SMAGIC);
 311 }
 312
 313 /* sv_catsv() is now a macro using Perl_sv_catsv_flags();
 314  * this function provided for binary compatibility only
 315  */
 316
 317 void
 318 Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr)
 319 {
 320     PERL_ARGS_ASSERT_SV_CATSV;
 321
 322     sv_catsv_flags(dstr, sstr, SV_GMAGIC);
 323 }
 324
 325 /*
 326 =for apidoc sv_catsv_mg
 327
 328 Like C<sv_catsv>, but also handles 'set' magic.
 329
 330 =cut
 331 */
 332
 333 void
 334 Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv)
 335 {
 336     PERL_ARGS_ASSERT_SV_CATSV_MG;
 337
 338     sv_catsv_flags(dsv,ssv,SV_GMAGIC|SV_SMAGIC);
 339 }
 340
 341 /*
 342 =for apidoc sv_iv
 343
 344 A private implementation of the C<SvIVx> macro for compilers which can't
 345 cope with complex macro expressions.  Always use the macro instead.
 346
 347 =cut
 348 */
 349
 350 IV
 351 Perl_sv_iv(pTHX_ SV *sv)
 352 {
 353     PERL_ARGS_ASSERT_SV_IV;
 354
 355     if (SvIOK(sv)) {
 356         if (SvIsUV(sv))
 357             return (IV)SvUVX(sv);
 358         return SvIVX(sv);
 359     }
 360     return sv_2iv(sv);
 361 }
 362
 363 /*
 364 =for apidoc sv_uv
 365
 366 A private implementation of the C<SvUVx> macro for compilers which can't
 367 cope with complex macro expressions.  Always use the macro instead.
 368
 369 =cut
 370 */
 371
 372 UV
 373 Perl_sv_uv(pTHX_ SV *sv)
 374 {
 375     PERL_ARGS_ASSERT_SV_UV;
 376
 377     if (SvIOK(sv)) {
 378         if (SvIsUV(sv))
 379             return SvUVX(sv);
 380         return (UV)SvIVX(sv);
 381     }
 382     return sv_2uv(sv);
 383 }
 384
 385 /*
 386 =for apidoc sv_nv
 387
 388 A private implementation of the C<SvNVx> macro for compilers which can't
 389 cope with complex macro expressions.  Always use the macro instead.
 390
 391 =cut
 392 */
 393
 394 NV
 395 Perl_sv_nv(pTHX_ SV *sv)
 396 {
 397     PERL_ARGS_ASSERT_SV_NV;
 398
 399     if (SvNOK(sv))
 400         return SvNVX(sv);
 401     return sv_2nv(sv);
 402 }
 403
 404 /*
 405 =for apidoc sv_pv
 406
 407 Use the C<SvPV_nolen> macro instead
 408
 409 =for apidoc sv_pvn
 410
 411 A private implementation of the C<SvPV> macro for compilers which can't
 412 cope with complex macro expressions.  Always use the macro instead.
 413
 414 =cut
 415 */
 416
 417 char *
 418 Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp)
 419 {
 420     PERL_ARGS_ASSERT_SV_PVN;
 421
 422     if (SvPOK(sv)) {
 423         *lp = SvCUR(sv);
 424         return SvPVX(sv);
 425     }
 426     return sv_2pv(sv, lp);
 427 }
 428
 429
 430 char *
 431 Perl_sv_pvn_nomg(pTHX_ SV *sv, STRLEN *lp)
 432 {
 433     PERL_ARGS_ASSERT_SV_PVN_NOMG;
 434
 435     if (SvPOK(sv)) {
 436         *lp = SvCUR(sv);
 437         return SvPVX(sv);
 438     }
 439     return sv_2pv_flags(sv, lp, 0);
 440 }
 441
 442 /* sv_pv() is now a macro using SvPV_nolen();
 443  * this function provided for binary compatibility only
 444  */
 445
 446 char *
 447 Perl_sv_pv(pTHX_ SV *sv)
 448 {
 449     PERL_ARGS_ASSERT_SV_PV;
 450
 451     if (SvPOK(sv))
 452         return SvPVX(sv);
 453
 454     return sv_2pv(sv, NULL);
 455 }
 456
 457 /* sv_pvn_force() is now a macro using Perl_sv_pvn_force_flags();
 458  * this function provided for binary compatibility only
 459  */
 460
 461 char *
 462 Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp)
 463 {
 464     PERL_ARGS_ASSERT_SV_PVN_FORCE;
 465
 466     return sv_pvn_force_flags(sv, lp, SV_GMAGIC);
 467 }
 468
 469 /* sv_pvbyte () is now a macro using Perl_sv_2pv_flags();
 470  * this function provided for binary compatibility only
 471  */
 472
 473 char *
 474 Perl_sv_pvbyte(pTHX_ SV *sv)
 475 {
 476     PERL_ARGS_ASSERT_SV_PVBYTE;
 477
 478     sv_utf8_downgrade(sv, FALSE);
 479     return sv_pv(sv);
 480 }
 481
 482 /*
 483 =for apidoc sv_pvbyte
 484
 485 Use C<SvPVbyte_nolen> instead.
 486
 487 =for apidoc sv_pvbyten
 488
 489 A private implementation of the C<SvPVbyte> macro for compilers
 490 which can't cope with complex macro expressions.  Always use the macro
 491 instead.
 492
 493 =cut
 494 */
 495
 496 char *
 497 Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp)
 498 {
 499     PERL_ARGS_ASSERT_SV_PVBYTEN;
 500
 501     sv_utf8_downgrade(sv, FALSE);
 502     return sv_pvn(sv,lp);
 503 }
 504
 505 /* sv_pvutf8 () is now a macro using Perl_sv_2pv_flags();
 506  * this function provided for binary compatibility only
 507  */
 508
 509 char *
 510 Perl_sv_pvutf8(pTHX_ SV *sv)
 511 {
 512     PERL_ARGS_ASSERT_SV_PVUTF8;
 513
 514     sv_utf8_upgrade(sv);
 515     return sv_pv(sv);
 516 }
 517
 518 /*
 519 =for apidoc sv_pvutf8
 520
 521 Use the C<SvPVutf8_nolen> macro instead
 522
 523 =for apidoc sv_pvutf8n
 524
 525 A private implementation of the C<SvPVutf8> macro for compilers
 526 which can't cope with complex macro expressions.  Always use the macro
 527 instead.
 528
 529 =cut
 530 */
 531
 532 char *
 533 Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp)
 534 {
 535     PERL_ARGS_ASSERT_SV_PVUTF8N;
 536
 537     sv_utf8_upgrade(sv);
 538     return sv_pvn(sv,lp);
 539 }
 540
 541 /* sv_utf8_upgrade() is now a macro using sv_utf8_upgrade_flags();
 542  * this function provided for binary compatibility only
 543  */
 544
 545 STRLEN
 546 Perl_sv_utf8_upgrade(pTHX_ SV *sv)
 547 {
 548     PERL_ARGS_ASSERT_SV_UTF8_UPGRADE;
 549
 550     return sv_utf8_upgrade_flags(sv, SV_GMAGIC);
 551 }
 552
 553 int
 554 Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...)
 555 {
 556     int ret = 0;
 557     va_list(arglist);
 558
 559     /* Easier to special case this here than in embed.pl. (Look at what it
 560        generates for proto.h) */
 561 #ifdef PERL_IMPLICIT_CONTEXT
 562     PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT;
 563 #endif
 564
 565     va_start(arglist, format);
 566     ret = PerlIO_vprintf(stream, format, arglist);
 567     va_end(arglist);
 568     return ret;
 569 }
 570
 571 int
 572 Perl_printf_nocontext(const char *format, ...)
 573 {
 574     dTHX;
 575     va_list(arglist);
 576     int ret = 0;
 577
 578 #ifdef PERL_IMPLICIT_CONTEXT
 579     PERL_ARGS_ASSERT_PRINTF_NOCONTEXT;
 580 #endif
 581
 582     va_start(arglist, format);
 583     ret = PerlIO_vprintf(PerlIO_stdout(), format, arglist);
 584     va_end(arglist);
 585     return ret;
 586 }
 587
 588 #if defined(HUGE_VAL) || (defined(USE_LONG_DOUBLE) && defined(HUGE_VALL))
 589 /*
 590  * This hack is to force load of "huge" support from libm.a
 591  * So it is in perl for (say) POSIX to use.
 592  * Needed for SunOS with Sun's 'acc' for example.
 593  */
 594 NV
 595 Perl_huge(void)
 596 {
 597 #  if defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)
 598     return HUGE_VALL;
 599 #  else
 600     return HUGE_VAL;
 601 #  endif
 602 }
 603 #endif
 604
 605 /* compatibility with versions <= 5.003. */
 606 void
 607 Perl_gv_fullname(pTHX_ SV *sv, const GV *gv)
 608 {
 609     PERL_ARGS_ASSERT_GV_FULLNAME;
 610
 611     gv_fullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
 612 }
 613
 614 /* compatibility with versions <= 5.003. */
 615 void
 616 Perl_gv_efullname(pTHX_ SV *sv, const GV *gv)
 617 {
 618     PERL_ARGS_ASSERT_GV_EFULLNAME;
 619
 620     gv_efullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
 621 }
 622
 623 void
 624 Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
 625 {
 626     PERL_ARGS_ASSERT_GV_FULLNAME3;
 627
 628     gv_fullname4(sv, gv, prefix, TRUE);
 629 }
 630
 631 void
 632 Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
 633 {
 634     PERL_ARGS_ASSERT_GV_EFULLNAME3;
 635
 636     gv_efullname4(sv, gv, prefix, TRUE);
 637 }
 638
 639 /*
 640 =for apidoc gv_fetchmethod
 641
 642 See L</gv_fetchmethod_autoload>.
 643
 644 =cut
 645 */
 646
 647 GV *
 648 Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
 649 {
 650     PERL_ARGS_ASSERT_GV_FETCHMETHOD;
 651
 652     return gv_fetchmethod_autoload(stash, name, TRUE);
 653 }
 654
 655 HE *
 656 Perl_hv_iternext(pTHX_ HV *hv)
 657 {
 658     PERL_ARGS_ASSERT_HV_ITERNEXT;
 659
 660     return hv_iternext_flags(hv, 0);
 661 }
 662
 663 void
 664 Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how)
 665 {
 666     PERL_ARGS_ASSERT_HV_MAGIC;
 667
 668     sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0);
 669 }
 670
 671 bool
 672 Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw,
 673              int rawmode, int rawperm, PerlIO *supplied_fp)
 674 {
 675     PERL_ARGS_ASSERT_DO_OPEN;
 676
 677     return do_openn(gv, name, len, as_raw, rawmode, rawperm,
 678                     supplied_fp, (SV **) NULL, 0);
 679 }
 680
 681 bool
 682 Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int
 683 as_raw,
 684               int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs,
 685               I32 num_svs)
 686 {
 687     PERL_ARGS_ASSERT_DO_OPEN9;
 688
 689     PERL_UNUSED_ARG(num_svs);
 690     return do_openn(gv, name, len, as_raw, rawmode, rawperm,
 691                     supplied_fp, &svs, 1);
 692 }
 693
 694 int
 695 Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
 696 {
 697  /* The old body of this is now in non-LAYER part of perlio.c
 698   * This is a stub for any XS code which might have been calling it.
 699   */
 700  const char *name = ":raw";
 701
 702  PERL_ARGS_ASSERT_DO_BINMODE;
 703
 704 #ifdef PERLIO_USING_CRLF
 705  if (!(mode & O_BINARY))
 706      name = ":crlf";
 707 #endif
 708  return PerlIO_binmode(aTHX_ fp, iotype, mode, name);
 709 }
 710
 711 #ifndef OS2
 712 bool
 713 Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp)
 714 {
 715     PERL_ARGS_ASSERT_DO_AEXEC;
 716
 717     return do_aexec5(really, mark, sp, 0, 0);
 718 }
 719 #endif
 720
 721 /* Backwards compatibility. */
 722 int
 723 Perl_init_i18nl14n(pTHX_ int printwarn)
 724 {
 725     return init_i18nl10n(printwarn);
 726 }
 727
 728 bool
 729 Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep)
 730 {
 731     PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC;
 732     PERL_UNUSED_CONTEXT;
 733
 734     return is_utf8_string_loclen(s, len, ep, 0);
 735 }
 736
 737 /*
 738 =for apidoc sv_nolocking
 739
 740 Dummy routine which "locks" an SV when there is no locking module present.
 741 Exists to avoid test for a NULL function pointer and because it could
 742 potentially warn under some level of strict-ness.
 743
 744 "Superseded" by sv_nosharing().
 745
 746 =cut
 747 */
 748
 749 void
 750 Perl_sv_nolocking(pTHX_ SV *sv)
 751 {
 752     PERL_UNUSED_CONTEXT;
 753     PERL_UNUSED_ARG(sv);
 754 }
 755
 756
 757 /*
 758 =for apidoc sv_nounlocking
 759
 760 Dummy routine which "unlocks" an SV when there is no locking module present.
 761 Exists to avoid test for a NULL function pointer and because it could
 762 potentially warn under some level of strict-ness.
 763
 764 "Superseded" by sv_nosharing().
 765
 766 =cut
 767 */
 768
 769 void
 770 Perl_sv_nounlocking(pTHX_ SV *sv)
 771 {
 772     PERL_UNUSED_CONTEXT;
 773     PERL_UNUSED_ARG(sv);
 774 }
 775
 776 void
 777 Perl_save_long(pTHX_ long int *longp)
 778 {
 779     PERL_ARGS_ASSERT_SAVE_LONG;
 780
 781     SSCHECK(3);
 782     SSPUSHLONG(*longp);
 783     SSPUSHPTR(longp);
 784     SSPUSHUV(SAVEt_LONG);
 785 }
 786
 787 void
 788 Perl_save_iv(pTHX_ IV *ivp)
 789 {
 790     PERL_ARGS_ASSERT_SAVE_IV;
 791
 792     SSCHECK(3);
 793     SSPUSHIV(*ivp);
 794     SSPUSHPTR(ivp);
 795     SSPUSHUV(SAVEt_IV);
 796 }
 797
 798 void
 799 Perl_save_nogv(pTHX_ GV *gv)
 800 {
 801     PERL_ARGS_ASSERT_SAVE_NOGV;
 802
 803     SSCHECK(2);
 804     SSPUSHPTR(gv);
 805     SSPUSHUV(SAVEt_NSTAB);
 806 }
 807
 808 void
 809 Perl_save_list(pTHX_ SV **sarg, I32 maxsarg)
 810 {
 811     I32 i;
 812
 813     PERL_ARGS_ASSERT_SAVE_LIST;
 814
 815     for (i = 1; i <= maxsarg; i++) {
 816         SV *sv;
 817         SvGETMAGIC(sarg[i]);
 818         sv = newSV(0);
 819         sv_setsv_nomg(sv,sarg[i]);
 820         SSCHECK(3);
 821         SSPUSHPTR(sarg[i]);             /* remember the pointer */
 822         SSPUSHPTR(sv);                  /* remember the value */
 823         SSPUSHUV(SAVEt_ITEM);
 824     }
 825 }
 826
 827 /*
 828 =for apidoc sv_usepvn_mg
 829
 830 Like C<sv_usepvn>, but also handles 'set' magic.
 831
 832 =cut
 833 */
 834
 835 void
 836 Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len)
 837 {
 838     PERL_ARGS_ASSERT_SV_USEPVN_MG;
 839
 840     sv_usepvn_flags(sv,ptr,len, SV_SMAGIC);
 841 }
 842
 843 /*
 844 =for apidoc sv_usepvn
 845
 846 Tells an SV to use C<ptr> to find its string value.  Implemented by
 847 calling C<sv_usepvn_flags> with C<flags> of 0, hence does not handle 'set'
 848 magic.  See C<sv_usepvn_flags>.
 849
 850 =cut
 851 */
 852
 853 void
 854 Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len)
 855 {
 856     PERL_ARGS_ASSERT_SV_USEPVN;
 857
 858     sv_usepvn_flags(sv,ptr,len, 0);
 859 }
 860
 861 /*
 862 =for apidoc unpack_str
 863
 864 The engine implementing unpack() Perl function.  Note: parameters strbeg,
 865 new_s and ocnt are not used.  This call should not be used, use
 866 unpackstring instead.
 867
 868 =cut */
 869
 870 I32
 871 Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s,
 872                 const char *strbeg, const char *strend, char **new_s, I32 ocnt,
 873                 U32 flags)
 874 {
 875     PERL_ARGS_ASSERT_UNPACK_STR;
 876
 877     PERL_UNUSED_ARG(strbeg);
 878     PERL_UNUSED_ARG(new_s);
 879     PERL_UNUSED_ARG(ocnt);
 880
 881     return unpackstring(pat, patend, s, strend, flags);
 882 }
 883
 884 /*
 885 =for apidoc pack_cat
 886
 887 The engine implementing pack() Perl function.  Note: parameters
 888 next_in_list and flags are not used.  This call should not be used; use
 889 packlist instead.
 890
 891 =cut
 892 */
 893
 894 void
 895 Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
 896 {
 897     PERL_ARGS_ASSERT_PACK_CAT;
 898
 899     PERL_UNUSED_ARG(next_in_list);
 900     PERL_UNUSED_ARG(flags);
 901
 902     packlist(cat, pat, patend, beglist, endlist);
 903 }
 904
 905 HE *
 906 Perl_hv_store_ent(pTHX_ HV *hv, SV *keysv, SV *val, U32 hash)
 907 {
 908   return (HE *)hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISSTORE, val, hash);
 909 }
 910
 911 bool
 912 Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
 913 {
 914     PERL_ARGS_ASSERT_HV_EXISTS_ENT;
 915
 916     return hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISEXISTS, 0, hash)
 917         ? TRUE : FALSE;
 918 }
 919
 920 HE *
 921 Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash)
 922 {
 923     PERL_ARGS_ASSERT_HV_FETCH_ENT;
 924
 925     return (HE *)hv_common(hv, keysv, NULL, 0, 0,
 926                      (lval ? HV_FETCH_LVALUE : 0), NULL, hash);
 927 }
 928
 929 SV *
 930 Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash)
 931 {
 932     PERL_ARGS_ASSERT_HV_DELETE_ENT;
 933
 934     return MUTABLE_SV(hv_common(hv, keysv, NULL, 0, 0, flags | HV_DELETE, NULL,
 935                                 hash));
 936 }
 937
 938 SV**
 939 Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash,
 940                     int flags)
 941 {
 942     return (SV**) hv_common(hv, NULL, key, klen, flags,
 943                             (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
 944 }
 945
 946 SV**
 947 Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen_i32, SV *val, U32 hash)
 948 {
 949     STRLEN klen;
 950     int flags;
 951
 952     if (klen_i32 < 0) {
 953         klen = -klen_i32;
 954         flags = HVhek_UTF8;
 955     } else {
 956         klen = klen_i32;
 957         flags = 0;
 958     }
 959     return (SV **) hv_common(hv, NULL, key, klen, flags,
 960                              (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
 961 }
 962
 963 bool
 964 Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen_i32)
 965 {
 966     STRLEN klen;
 967     int flags;
 968
 969     PERL_ARGS_ASSERT_HV_EXISTS;
 970
 971     if (klen_i32 < 0) {
 972         klen = -klen_i32;
 973         flags = HVhek_UTF8;
 974     } else {
 975         klen = klen_i32;
 976         flags = 0;
 977     }
 978     return hv_common(hv, NULL, key, klen, flags, HV_FETCH_ISEXISTS, 0, 0)
 979         ? TRUE : FALSE;
 980 }
 981
 982 SV**
 983 Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 lval)
 984 {
 985     STRLEN klen;
 986     int flags;
 987
 988     PERL_ARGS_ASSERT_HV_FETCH;
 989
 990     if (klen_i32 < 0) {
 991         klen = -klen_i32;
 992         flags = HVhek_UTF8;
 993     } else {
 994         klen = klen_i32;
 995         flags = 0;
 996     }
 997     return (SV **) hv_common(hv, NULL, key, klen, flags,
 998                              lval ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE)
 999                              : HV_FETCH_JUST_SV, NULL, 0);
1000 }
1001
1002 SV *
1003 Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 flags)
1004 {
1005     STRLEN klen;
1006     int k_flags;
1007
1008     PERL_ARGS_ASSERT_HV_DELETE;
1009
1010     if (klen_i32 < 0) {
1011         klen = -klen_i32;
1012         k_flags = HVhek_UTF8;
1013     } else {
1014         klen = klen_i32;
1015         k_flags = 0;
1016     }
1017     return MUTABLE_SV(hv_common(hv, NULL, key, klen, k_flags, flags | HV_DELETE,
1018                                 NULL, 0));
1019 }
1020
1021 /* Functions after here were made mathoms post 5.10.0 but pre 5.8.9 */
1022
1023 AV *
1024 Perl_newAV(pTHX)
1025 {
1026     return MUTABLE_AV(newSV_type(SVt_PVAV));
1027     /* sv_upgrade does AvREAL_only():
1028     AvALLOC(av) = 0;
1029     AvARRAY(av) = NULL;
1030     AvMAX(av) = AvFILLp(av) = -1; */
1031 }
1032
1033 HV *
1034 Perl_newHV(pTHX)
1035 {
1036     HV * const hv = MUTABLE_HV(newSV_type(SVt_PVHV));
1037     assert(!SvOK(hv));
1038
1039     return hv;
1040 }
1041
1042 void
1043 Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len,
1044               const char *const little, const STRLEN littlelen)
1045 {
1046     PERL_ARGS_ASSERT_SV_INSERT;
1047     sv_insert_flags(bigstr, offset, len, little, littlelen, SV_GMAGIC);
1048 }
1049
1050 void
1051 Perl_save_freesv(pTHX_ SV *sv)
1052 {
1053     save_freesv(sv);
1054 }
1055
1056 void
1057 Perl_save_mortalizesv(pTHX_ SV *sv)
1058 {
1059     PERL_ARGS_ASSERT_SAVE_MORTALIZESV;
1060
1061     save_mortalizesv(sv);
1062 }
1063
1064 void
1065 Perl_save_freeop(pTHX_ OP *o)
1066 {
1067     save_freeop(o);
1068 }
1069
1070 void
1071 Perl_save_freepv(pTHX_ char *pv)
1072 {
1073     save_freepv(pv);
1074 }
1075
1076 void
1077 Perl_save_op(pTHX)
1078 {
1079     save_op();
1080 }
1081
1082 #ifdef PERL_DONT_CREATE_GVSV
1083 GV *
1084 Perl_gv_SVadd(pTHX_ GV *gv)
1085 {
1086     return gv_SVadd(gv);
1087 }
1088 #endif
1089
1090 GV *
1091 Perl_gv_AVadd(pTHX_ GV *gv)
1092 {
1093     return gv_AVadd(gv);
1094 }
1095
1096 GV *
1097 Perl_gv_HVadd(pTHX_ GV *gv)
1098 {
1099     return gv_HVadd(gv);
1100 }
1101
1102 GV *
1103 Perl_gv_IOadd(pTHX_ GV *gv)
1104 {
1105     return gv_IOadd(gv);
1106 }
1107
1108 IO *
1109 Perl_newIO(pTHX)
1110 {
1111     return MUTABLE_IO(newSV_type(SVt_PVIO));
1112 }
1113
1114 I32
1115 Perl_my_stat(pTHX)
1116 {
1117     return my_stat_flags(SV_GMAGIC);
1118 }
1119
1120 I32
1121 Perl_my_lstat(pTHX)
1122 {
1123     return my_lstat_flags(SV_GMAGIC);
1124 }
1125
1126 I32
1127 Perl_sv_eq(pTHX_ SV *sv1, SV *sv2)
1128 {
1129     return sv_eq_flags(sv1, sv2, SV_GMAGIC);
1130 }
1131
1132 #ifdef USE_LOCALE_COLLATE
1133 char *
1134 Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp)
1135 {
1136     return sv_collxfrm_flags(sv, nxp, SV_GMAGIC);
1137 }
1138 #endif
1139
1140 bool
1141 Perl_sv_2bool(pTHX_ SV *const sv)
1142 {
1143     return sv_2bool_flags(sv, SV_GMAGIC);
1144 }
1145
1146
1147 /*
1148 =for apidoc custom_op_name
1149 Return the name for a given custom op.  This was once used by the OP_NAME
1150 macro, but is no longer: it has only been kept for compatibility, and
1151 should not be used.
1152
1153 =for apidoc custom_op_desc
1154 Return the description of a given custom op.  This was once used by the
1155 OP_DESC macro, but is no longer: it has only been kept for
1156 compatibility, and should not be used.
1157
1158 =cut
1159 */
1160
1161 const char*
1162 Perl_custom_op_name(pTHX_ const OP* o)
1163 {
1164     PERL_ARGS_ASSERT_CUSTOM_OP_NAME;
1165     return XopENTRYCUSTOM(o, xop_name);
1166 }
1167
1168 const char*
1169 Perl_custom_op_desc(pTHX_ const OP* o)
1170 {
1171     PERL_ARGS_ASSERT_CUSTOM_OP_DESC;
1172     return XopENTRYCUSTOM(o, xop_desc);
1173 }
1174
1175 CV *
1176 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
1177 {
1178     return newATTRSUB(floor, o, proto, NULL, block);
1179 }
1180
1181 UV
1182 Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1183 {
1184     PERL_ARGS_ASSERT_TO_UTF8_FOLD;
1185
1186     return _to_utf8_fold_flags(p, ustrp, lenp, FOLD_FLAGS_FULL);
1187 }
1188
1189 UV
1190 Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1191 {
1192     PERL_ARGS_ASSERT_TO_UTF8_LOWER;
1193
1194     return _to_utf8_lower_flags(p, ustrp, lenp, FALSE);
1195 }
1196
1197 UV
1198 Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1199 {
1200     PERL_ARGS_ASSERT_TO_UTF8_TITLE;
1201
1202     return _to_utf8_title_flags(p, ustrp, lenp, FALSE);
1203 }
1204
1205 UV
1206 Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1207 {
1208     PERL_ARGS_ASSERT_TO_UTF8_UPPER;
1209
1210     return _to_utf8_upper_flags(p, ustrp, lenp, FALSE);
1211 }
1212
1213 SV *
1214 Perl_sv_mortalcopy(pTHX_ SV *const oldstr)
1215 {
1216     return Perl_sv_mortalcopy_flags(aTHX_ oldstr, SV_GMAGIC);
1217 }
1218
1219 UV      /* Made into a function, so can be deprecated */
1220 NATIVE_TO_NEED(const UV enc, const UV ch)
1221 {
1222     PERL_UNUSED_ARG(enc);
1223     return ch;
1224 }
1225
1226 UV      /* Made into a function, so can be deprecated */
1227 ASCII_TO_NEED(const UV enc, const UV ch)
1228 {
1229     PERL_UNUSED_ARG(enc);
1230     return ch;
1231 }
1232
1233 bool      /* Made into a function, so can be deprecated */
1234 Perl_isIDFIRST_lazy(pTHX_ const char* p)
1235 {
1236     PERL_ARGS_ASSERT_ISIDFIRST_LAZY;
1237
1238     return isIDFIRST_lazy_if(p,1);
1239 }
1240
1241 bool      /* Made into a function, so can be deprecated */
1242 Perl_isALNUM_lazy(pTHX_ const char* p)
1243 {
1244     PERL_ARGS_ASSERT_ISALNUM_LAZY;
1245
1246     return isALNUM_lazy_if(p,1);
1247 }
1248
1249 bool
1250 Perl_is_uni_alnum(pTHX_ UV c)
1251 {
1252     return isWORDCHAR_uni(c);
1253 }
1254
1255 bool
1256 Perl_is_uni_alnumc(pTHX_ UV c)
1257 {
1258     return isALNUM_uni(c);
1259 }
1260
1261 bool
1262 Perl_is_uni_alpha(pTHX_ UV c)
1263 {
1264     return isALPHA_uni(c);
1265 }
1266
1267 bool
1268 Perl_is_uni_ascii(pTHX_ UV c)
1269 {
1270     PERL_UNUSED_CONTEXT;
1271     return isASCII_uni(c);
1272 }
1273
1274 bool
1275 Perl_is_uni_blank(pTHX_ UV c)
1276 {
1277     PERL_UNUSED_CONTEXT;
1278     return isBLANK_uni(c);
1279 }
1280
1281 bool
1282 Perl_is_uni_space(pTHX_ UV c)
1283 {
1284     PERL_UNUSED_CONTEXT;
1285     return isSPACE_uni(c);
1286 }
1287
1288 bool
1289 Perl_is_uni_digit(pTHX_ UV c)
1290 {
1291     PERL_UNUSED_CONTEXT;
1292     return isDIGIT_uni(c);
1293 }
1294
1295 bool
1296 Perl_is_uni_upper(pTHX_ UV c)
1297 {
1298     PERL_UNUSED_CONTEXT;
1299     return isUPPER_uni(c);
1300 }
1301
1302 bool
1303 Perl_is_uni_lower(pTHX_ UV c)
1304 {
1305     PERL_UNUSED_CONTEXT;
1306     return isLOWER_uni(c);
1307 }
1308
1309 bool
1310 Perl_is_uni_cntrl(pTHX_ UV c)
1311 {
1312     PERL_UNUSED_CONTEXT;
1313     return isCNTRL_L1(c);
1314 }
1315
1316 bool
1317 Perl_is_uni_graph(pTHX_ UV c)
1318 {
1319     PERL_UNUSED_CONTEXT;
1320     return isGRAPH_uni(c);
1321 }
1322
1323 bool
1324 Perl_is_uni_print(pTHX_ UV c)
1325 {
1326     PERL_UNUSED_CONTEXT;
1327     return isPRINT_uni(c);
1328 }
1329
1330 bool
1331 Perl_is_uni_punct(pTHX_ UV c)
1332 {
1333     PERL_UNUSED_CONTEXT;
1334     return isPUNCT_uni(c);
1335 }
1336
1337 bool
1338 Perl_is_uni_xdigit(pTHX_ UV c)
1339 {
1340     PERL_UNUSED_CONTEXT;
1341     return isXDIGIT_uni(c);
1342 }
1343
1344 bool
1345 Perl_is_uni_alnum_lc(pTHX_ UV c)
1346 {
1347     PERL_UNUSED_CONTEXT;
1348     return isWORDCHAR_LC_uvchr(c);
1349 }
1350
1351 bool
1352 Perl_is_uni_alnumc_lc(pTHX_ UV c)
1353 {
1354     PERL_UNUSED_CONTEXT;
1355     return isALPHANUMERIC_LC_uvchr(c);
1356 }
1357
1358 bool
1359 Perl_is_uni_idfirst_lc(pTHX_ UV c)
1360 {
1361     PERL_UNUSED_CONTEXT;
1362     /* XXX Should probably be something that resolves to the old IDFIRST, but
1363      * this function is deprecated, so not bothering */
1364     return isIDFIRST_LC_uvchr(c);
1365 }
1366
1367 bool
1368 Perl_is_uni_alpha_lc(pTHX_ UV c)
1369 {
1370     PERL_UNUSED_CONTEXT;
1371     return isALPHA_LC_uvchr(c);
1372 }
1373
1374 bool
1375 Perl_is_uni_ascii_lc(pTHX_ UV c)
1376 {
1377     PERL_UNUSED_CONTEXT;
1378     return isASCII_LC_uvchr(c);
1379 }
1380
1381 bool
1382 Perl_is_uni_blank_lc(pTHX_ UV c)
1383 {
1384     PERL_UNUSED_CONTEXT;
1385     return isBLANK_LC_uvchr(c);
1386 }
1387
1388 bool
1389 Perl_is_uni_space_lc(pTHX_ UV c)
1390 {
1391     PERL_UNUSED_CONTEXT;
1392     return isSPACE_LC_uvchr(c);
1393 }
1394
1395 bool
1396 Perl_is_uni_digit_lc(pTHX_ UV c)
1397 {
1398     return isDIGIT_LC_uvchr(c);
1399 }
1400
1401 bool
1402 Perl_is_uni_idfirst(pTHX_ UV c)
1403 {
1404     U8 tmpbuf[UTF8_MAXBYTES+1];
1405     uvchr_to_utf8(tmpbuf, c);
1406     return _is_utf8_idstart(tmpbuf);
1407 }
1408
1409 bool
1410 Perl_is_utf8_idfirst(pTHX_ const U8 *p) /* The naming is historical. */
1411 {
1412     PERL_ARGS_ASSERT_IS_UTF8_IDFIRST;
1413
1414     return _is_utf8_idstart(p);
1415 }
1416
1417 bool
1418 Perl_is_utf8_xidfirst(pTHX_ const U8 *p) /* The naming is historical. */
1419 {
1420     PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST;
1421
1422     return _is_utf8_xidstart(p);
1423 }
1424
1425 bool
1426 Perl_is_utf8_idcont(pTHX_ const U8 *p)
1427 {
1428     PERL_ARGS_ASSERT_IS_UTF8_IDCONT;
1429
1430     return _is_utf8_idcont(p);
1431 }
1432
1433 bool
1434 Perl_is_utf8_xidcont(pTHX_ const U8 *p)
1435 {
1436     PERL_ARGS_ASSERT_IS_UTF8_XIDCONT;
1437
1438     return _is_utf8_xidcont(p);
1439 }
1440
1441 bool
1442 Perl_is_uni_upper_lc(pTHX_ UV c)
1443 {
1444     return isUPPER_LC_uvchr(c);
1445 }
1446
1447 bool
1448 Perl_is_uni_lower_lc(pTHX_ UV c)
1449 {
1450     return isLOWER_LC_uvchr(c);
1451 }
1452
1453 bool
1454 Perl_is_uni_cntrl_lc(pTHX_ UV c)
1455 {
1456     return isCNTRL_LC_uvchr(c);
1457 }
1458
1459 bool
1460 Perl_is_uni_graph_lc(pTHX_ UV c)
1461 {
1462     return isGRAPH_LC_uvchr(c);
1463 }
1464
1465 bool
1466 Perl_is_uni_print_lc(pTHX_ UV c)
1467 {
1468     return isPRINT_LC_uvchr(c);
1469 }
1470
1471 bool
1472 Perl_is_uni_punct_lc(pTHX_ UV c)
1473 {
1474     return isPUNCT_LC_uvchr(c);
1475 }
1476
1477 bool
1478 Perl_is_uni_xdigit_lc(pTHX_ UV c)
1479 {
1480     return isXDIGIT_LC_uvchr(c);
1481 }
1482
1483 U32
1484 Perl_to_uni_upper_lc(pTHX_ U32 c)
1485 {
1486     /* XXX returns only the first character -- do not use XXX */
1487     /* XXX no locale support yet */
1488     STRLEN len;
1489     U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1490     return (U32)to_uni_upper(c, tmpbuf, &len);
1491 }
1492
1493 U32
1494 Perl_to_uni_title_lc(pTHX_ U32 c)
1495 {
1496     /* XXX returns only the first character XXX -- do not use XXX */
1497     /* XXX no locale support yet */
1498     STRLEN len;
1499     U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1500     return (U32)to_uni_title(c, tmpbuf, &len);
1501 }
1502
1503 U32
1504 Perl_to_uni_lower_lc(pTHX_ U32 c)
1505 {
1506     /* XXX returns only the first character -- do not use XXX */
1507     /* XXX no locale support yet */
1508     STRLEN len;
1509     U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1510     return (U32)to_uni_lower(c, tmpbuf, &len);
1511 }
1512
1513 bool
1514 Perl_is_utf8_alnum(pTHX_ const U8 *p)
1515 {
1516     PERL_ARGS_ASSERT_IS_UTF8_ALNUM;
1517
1518     /* NOTE: "IsWord", not "IsAlnum", since Alnum is a true
1519      * descendant of isalnum(3), in other words, it doesn't
1520      * contain the '_'. --jhi */
1521     return isWORDCHAR_utf8(p);
1522 }
1523
1524 bool
1525 Perl_is_utf8_alnumc(pTHX_ const U8 *p)
1526 {
1527     PERL_ARGS_ASSERT_IS_UTF8_ALNUMC;
1528
1529     return isALPHANUMERIC_utf8(p);
1530 }
1531
1532 bool
1533 Perl_is_utf8_alpha(pTHX_ const U8 *p)
1534 {
1535     PERL_ARGS_ASSERT_IS_UTF8_ALPHA;
1536
1537     return isALPHA_utf8(p);
1538 }
1539
1540 bool
1541 Perl_is_utf8_ascii(pTHX_ const U8 *p)
1542 {
1543     PERL_ARGS_ASSERT_IS_UTF8_ASCII;
1544     PERL_UNUSED_CONTEXT;
1545
1546     return isASCII_utf8(p);
1547 }
1548
1549 bool
1550 Perl_is_utf8_blank(pTHX_ const U8 *p)
1551 {
1552     PERL_ARGS_ASSERT_IS_UTF8_BLANK;
1553     PERL_UNUSED_CONTEXT;
1554
1555     return isBLANK_utf8(p);
1556 }
1557
1558 bool
1559 Perl_is_utf8_space(pTHX_ const U8 *p)
1560 {
1561     PERL_ARGS_ASSERT_IS_UTF8_SPACE;
1562     PERL_UNUSED_CONTEXT;
1563
1564     return isSPACE_utf8(p);
1565 }
1566
1567 bool
1568 Perl_is_utf8_perl_space(pTHX_ const U8 *p)
1569 {
1570     PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE;
1571     PERL_UNUSED_CONTEXT;
1572
1573     /* Only true if is an ASCII space-like character, and ASCII is invariant
1574      * under utf8, so can just use the macro */
1575     return isSPACE_A(*p);
1576 }
1577
1578 bool
1579 Perl_is_utf8_perl_word(pTHX_ const U8 *p)
1580 {
1581     PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD;
1582     PERL_UNUSED_CONTEXT;
1583
1584     /* Only true if is an ASCII word character, and ASCII is invariant
1585      * under utf8, so can just use the macro */
1586     return isWORDCHAR_A(*p);
1587 }
1588
1589 bool
1590 Perl_is_utf8_digit(pTHX_ const U8 *p)
1591 {
1592     PERL_ARGS_ASSERT_IS_UTF8_DIGIT;
1593
1594     return isDIGIT_utf8(p);
1595 }
1596
1597 bool
1598 Perl_is_utf8_posix_digit(pTHX_ const U8 *p)
1599 {
1600     PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT;
1601     PERL_UNUSED_CONTEXT;
1602
1603     /* Only true if is an ASCII digit character, and ASCII is invariant
1604      * under utf8, so can just use the macro */
1605     return isDIGIT_A(*p);
1606 }
1607
1608 bool
1609 Perl_is_utf8_upper(pTHX_ const U8 *p)
1610 {
1611     PERL_ARGS_ASSERT_IS_UTF8_UPPER;
1612
1613     return isUPPER_utf8(p);
1614 }
1615
1616 bool
1617 Perl_is_utf8_lower(pTHX_ const U8 *p)
1618 {
1619     PERL_ARGS_ASSERT_IS_UTF8_LOWER;
1620
1621     return isLOWER_utf8(p);
1622 }
1623
1624 bool
1625 Perl_is_utf8_cntrl(pTHX_ const U8 *p)
1626 {
1627     PERL_ARGS_ASSERT_IS_UTF8_CNTRL;
1628     PERL_UNUSED_CONTEXT;
1629
1630     return isCNTRL_utf8(p);
1631 }
1632
1633 bool
1634 Perl_is_utf8_graph(pTHX_ const U8 *p)
1635 {
1636     PERL_ARGS_ASSERT_IS_UTF8_GRAPH;
1637
1638     return isGRAPH_utf8(p);
1639 }
1640
1641 bool
1642 Perl_is_utf8_print(pTHX_ const U8 *p)
1643 {
1644     PERL_ARGS_ASSERT_IS_UTF8_PRINT;
1645
1646     return isPRINT_utf8(p);
1647 }
1648
1649 bool
1650 Perl_is_utf8_punct(pTHX_ const U8 *p)
1651 {
1652     PERL_ARGS_ASSERT_IS_UTF8_PUNCT;
1653
1654     return isPUNCT_utf8(p);
1655 }
1656
1657 bool
1658 Perl_is_utf8_xdigit(pTHX_ const U8 *p)
1659 {
1660     PERL_ARGS_ASSERT_IS_UTF8_XDIGIT;
1661     PERL_UNUSED_CONTEXT;
1662
1663     return isXDIGIT_utf8(p);
1664 }
1665
1666 bool
1667 Perl_is_utf8_mark(pTHX_ const U8 *p)
1668 {
1669     PERL_ARGS_ASSERT_IS_UTF8_MARK;
1670
1671     return _is_utf8_mark(p);
1672 }
1673
1674 /*
1675 =for apidoc is_utf8_char
1676
1677 Tests if some arbitrary number of bytes begins in a valid UTF-8
1678 character.  Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines)
1679 character is a valid UTF-8 character.  The actual number of bytes in the UTF-8
1680 character will be returned if it is valid, otherwise 0.
1681
1682 This function is deprecated due to the possibility that malformed input could
1683 cause reading beyond the end of the input buffer.  Use L</isUTF8_CHAR>
1684 instead.
1685
1686 =cut */
1687
1688 STRLEN
1689 Perl_is_utf8_char(const U8 *s)
1690 {
1691     PERL_ARGS_ASSERT_IS_UTF8_CHAR;
1692
1693     /* Assumes we have enough space, which is why this is deprecated */
1694     return isUTF8_CHAR(s, s + UTF8SKIP(s));
1695 }
1696
1697 /* DEPRECATED!
1698  * Like L</utf8_to_uvuni_buf>(), but should only be called when it is known that
1699  * there are no malformations in the input UTF-8 string C<s>.  Surrogates,
1700  * non-character code points, and non-Unicode code points are allowed */
1701
1702 UV
1703 Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
1704 {
1705     PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI;
1706
1707     return NATIVE_TO_UNI(valid_utf8_to_uvchr(s, retlen));
1708 }
1709
1710 /*
1711 =for apidoc utf8_to_uvchr
1712
1713 Returns the native code point of the first character in the string C<s>
1714 which is assumed to be in UTF-8 encoding; C<retlen> will be set to the
1715 length, in bytes, of that character.
1716
1717 Some, but not all, UTF-8 malformations are detected, and in fact, some
1718 malformed input could cause reading beyond the end of the input buffer, which
1719 is why this function is deprecated.  Use L</utf8_to_uvchr_buf> instead.
1720
1721 If C<s> points to one of the detected malformations, and UTF8 warnings are
1722 enabled, zero is returned and C<*retlen> is set (if C<retlen> isn't
1723 NULL) to -1.  If those warnings are off, the computed value if well-defined (or
1724 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
1725 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
1726 next possible position in C<s> that could begin a non-malformed character.
1727 See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
1728
1729 =cut
1730 */
1731
1732 UV
1733 Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
1734 {
1735     PERL_ARGS_ASSERT_UTF8_TO_UVCHR;
1736
1737     return utf8_to_uvchr_buf(s, s + UTF8_MAXBYTES, retlen);
1738 }
1739
1740 /*
1741 =for apidoc utf8_to_uvuni
1742
1743 Returns the Unicode code point of the first character in the string C<s>
1744 which is assumed to be in UTF-8 encoding; C<retlen> will be set to the
1745 length, in bytes, of that character.
1746
1747 Some, but not all, UTF-8 malformations are detected, and in fact, some
1748 malformed input could cause reading beyond the end of the input buffer, which
1749 is one reason why this function is deprecated.  The other is that only in
1750 extremely limited circumstances should the Unicode versus native code point be
1751 of any interest to you.  See L</utf8_to_uvuni_buf> for alternatives.
1752
1753 If C<s> points to one of the detected malformations, and UTF8 warnings are
1754 enabled, zero is returned and C<*retlen> is set (if C<retlen> doesn't point to
1755 NULL) to -1.  If those warnings are off, the computed value if well-defined (or
1756 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
1757 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
1758 next possible position in C<s> that could begin a non-malformed character.
1759 See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
1760
1761 =cut
1762 */
1763
1764 UV
1765 Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
1766 {
1767     PERL_ARGS_ASSERT_UTF8_TO_UVUNI;
1768
1769     return NATIVE_TO_UNI(valid_utf8_to_uvchr(s, retlen));
1770 }
1771
1772 void
1773 Perl_save_re_context(pTHX)
1774 {
1775     PERL_UNUSED_CONTEXT;
1776 }
1777
1778 /*
1779 =for apidoc Am|HV *|pad_compname_type|PADOFFSET po
1780
1781 Looks up the type of the lexical variable at position I<po> in the
1782 currently-compiling pad.  If the variable is typed, the stash of the
1783 class to which it is typed is returned.  If not, C<NULL> is returned.
1784
1785 =cut
1786 */
1787
1788 HV *
1789 Perl_pad_compname_type(pTHX_ const PADOFFSET po)
1790 {
1791     return PAD_COMPNAME_TYPE(po);
1792 }
1793
1794
1795 END_EXTERN_C
1796
1797 #endif /* NO_MATHOMS */
1798
1799 /*
1800  * Local variables:
1801  * c-indentation-style: bsd
1802  * c-basic-offset: 4
1803  * indent-tabs-mode: nil
1804  * End:
1805  *
1806  * ex: set ts=8 sts=4 sw=4 et:
1807  */