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