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     int ret = 0;
 555     va_list(arglist);
 556
 557     /* Easier to special case this here than in embed.pl. (Look at what it
 558        generates for proto.h) */
 559 #ifdef PERL_IMPLICIT_CONTEXT
 560     PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT;
 561 #endif
 562
 563     va_start(arglist, format);
 564     ret = PerlIO_vprintf(stream, format, arglist);
 565     va_end(arglist);
 566     return ret;
 567 }
 568
 569 int
 570 Perl_printf_nocontext(const char *format, ...)
 571 {
 572     dTHX;
 573     va_list(arglist);
 574     int ret = 0;
 575
 576 #ifdef PERL_IMPLICIT_CONTEXT
 577     PERL_ARGS_ASSERT_PRINTF_NOCONTEXT;
 578 #endif
 579
 580     va_start(arglist, format);
 581     ret = PerlIO_vprintf(PerlIO_stdout(), format, arglist);
 582     va_end(arglist);
 583     return ret;
 584 }
 585
 586 #if defined(HUGE_VAL) || (defined(USE_LONG_DOUBLE) && defined(HUGE_VALL))
 587 /*
 588  * This hack is to force load of "huge" support from libm.a
 589  * So it is in perl for (say) POSIX to use.
 590  * Needed for SunOS with Sun's 'acc' for example.
 591  */
 592 NV
 593 Perl_huge(void)
 594 {
 595 #  if defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)
 596     return HUGE_VALL;
 597 #  else
 598     return HUGE_VAL;
 599 #  endif
 600 }
 601 #endif
 602
 603 /* compatibility with versions <= 5.003. */
 604 void
 605 Perl_gv_fullname(pTHX_ SV *sv, const GV *gv)
 606 {
 607     PERL_ARGS_ASSERT_GV_FULLNAME;
 608
 609     gv_fullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
 610 }
 611
 612 /* compatibility with versions <= 5.003. */
 613 void
 614 Perl_gv_efullname(pTHX_ SV *sv, const GV *gv)
 615 {
 616     PERL_ARGS_ASSERT_GV_EFULLNAME;
 617
 618     gv_efullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
 619 }
 620
 621 void
 622 Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
 623 {
 624     PERL_ARGS_ASSERT_GV_FULLNAME3;
 625
 626     gv_fullname4(sv, gv, prefix, TRUE);
 627 }
 628
 629 void
 630 Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
 631 {
 632     PERL_ARGS_ASSERT_GV_EFULLNAME3;
 633
 634     gv_efullname4(sv, gv, prefix, TRUE);
 635 }
 636
 637 /*
 638 =for apidoc gv_fetchmethod
 639
 640 See L</gv_fetchmethod_autoload>.
 641
 642 =cut
 643 */
 644
 645 GV *
 646 Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
 647 {
 648     PERL_ARGS_ASSERT_GV_FETCHMETHOD;
 649
 650     return gv_fetchmethod_autoload(stash, name, TRUE);
 651 }
 652
 653 HE *
 654 Perl_hv_iternext(pTHX_ HV *hv)
 655 {
 656     PERL_ARGS_ASSERT_HV_ITERNEXT;
 657
 658     return hv_iternext_flags(hv, 0);
 659 }
 660
 661 void
 662 Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how)
 663 {
 664     PERL_ARGS_ASSERT_HV_MAGIC;
 665
 666     sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0);
 667 }
 668
 669 bool
 670 Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw,
 671              int rawmode, int rawperm, PerlIO *supplied_fp)
 672 {
 673     PERL_ARGS_ASSERT_DO_OPEN;
 674
 675     return do_openn(gv, name, len, as_raw, rawmode, rawperm,
 676                     supplied_fp, (SV **) NULL, 0);
 677 }
 678
 679 bool
 680 Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int
 681 as_raw,
 682               int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs,
 683               I32 num_svs)
 684 {
 685     PERL_ARGS_ASSERT_DO_OPEN9;
 686
 687     PERL_UNUSED_ARG(num_svs);
 688     return do_openn(gv, name, len, as_raw, rawmode, rawperm,
 689                     supplied_fp, &svs, 1);
 690 }
 691
 692 int
 693 Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
 694 {
 695  /* The old body of this is now in non-LAYER part of perlio.c
 696   * This is a stub for any XS code which might have been calling it.
 697   */
 698  const char *name = ":raw";
 699
 700  PERL_ARGS_ASSERT_DO_BINMODE;
 701
 702 #ifdef PERLIO_USING_CRLF
 703  if (!(mode & O_BINARY))
 704      name = ":crlf";
 705 #endif
 706  return PerlIO_binmode(aTHX_ fp, iotype, mode, name);
 707 }
 708
 709 #ifndef OS2
 710 bool
 711 Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp)
 712 {
 713     PERL_ARGS_ASSERT_DO_AEXEC;
 714
 715     return do_aexec5(really, mark, sp, 0, 0);
 716 }
 717 #endif
 718
 719 /* Backwards compatibility. */
 720 int
 721 Perl_init_i18nl14n(pTHX_ int printwarn)
 722 {
 723     return init_i18nl10n(printwarn);
 724 }
 725
 726 bool
 727 Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep)
 728 {
 729     PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC;
 730     PERL_UNUSED_CONTEXT;
 731
 732     return is_utf8_string_loclen(s, len, ep, 0);
 733 }
 734
 735 /*
 736 =for apidoc sv_nolocking
 737
 738 Dummy routine which "locks" an SV when there is no locking module present.
 739 Exists to avoid test for a NULL function pointer and because it could
 740 potentially warn under some level of strict-ness.
 741
 742 "Superseded" by sv_nosharing().
 743
 744 =cut
 745 */
 746
 747 void
 748 Perl_sv_nolocking(pTHX_ SV *sv)
 749 {
 750     PERL_UNUSED_CONTEXT;
 751     PERL_UNUSED_ARG(sv);
 752 }
 753
 754
 755 /*
 756 =for apidoc sv_nounlocking
 757
 758 Dummy routine which "unlocks" an SV when there is no locking module present.
 759 Exists to avoid test for a NULL function pointer and because it could
 760 potentially warn under some level of strict-ness.
 761
 762 "Superseded" by sv_nosharing().
 763
 764 =cut
 765 */
 766
 767 void
 768 Perl_sv_nounlocking(pTHX_ SV *sv)
 769 {
 770     PERL_UNUSED_CONTEXT;
 771     PERL_UNUSED_ARG(sv);
 772 }
 773
 774 void
 775 Perl_save_long(pTHX_ long int *longp)
 776 {
 777     PERL_ARGS_ASSERT_SAVE_LONG;
 778
 779     SSCHECK(3);
 780     SSPUSHLONG(*longp);
 781     SSPUSHPTR(longp);
 782     SSPUSHUV(SAVEt_LONG);
 783 }
 784
 785 void
 786 Perl_save_iv(pTHX_ IV *ivp)
 787 {
 788     PERL_ARGS_ASSERT_SAVE_IV;
 789
 790     SSCHECK(3);
 791     SSPUSHIV(*ivp);
 792     SSPUSHPTR(ivp);
 793     SSPUSHUV(SAVEt_IV);
 794 }
 795
 796 void
 797 Perl_save_nogv(pTHX_ GV *gv)
 798 {
 799     PERL_ARGS_ASSERT_SAVE_NOGV;
 800
 801     SSCHECK(2);
 802     SSPUSHPTR(gv);
 803     SSPUSHUV(SAVEt_NSTAB);
 804 }
 805
 806 void
 807 Perl_save_list(pTHX_ SV **sarg, I32 maxsarg)
 808 {
 809     I32 i;
 810
 811     PERL_ARGS_ASSERT_SAVE_LIST;
 812
 813     for (i = 1; i <= maxsarg; i++) {
 814         SV *sv;
 815         SvGETMAGIC(sarg[i]);
 816         sv = newSV(0);
 817         sv_setsv_nomg(sv,sarg[i]);
 818         SSCHECK(3);
 819         SSPUSHPTR(sarg[i]);             /* remember the pointer */
 820         SSPUSHPTR(sv);                  /* remember the value */
 821         SSPUSHUV(SAVEt_ITEM);
 822     }
 823 }
 824
 825 /*
 826 =for apidoc sv_usepvn_mg
 827
 828 Like C<sv_usepvn>, but also handles 'set' magic.
 829
 830 =cut
 831 */
 832
 833 void
 834 Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len)
 835 {
 836     PERL_ARGS_ASSERT_SV_USEPVN_MG;
 837
 838     sv_usepvn_flags(sv,ptr,len, SV_SMAGIC);
 839 }
 840
 841 /*
 842 =for apidoc sv_usepvn
 843
 844 Tells an SV to use C<ptr> to find its string value.  Implemented by
 845 calling C<sv_usepvn_flags> with C<flags> of 0, hence does not handle 'set'
 846 magic.  See C<sv_usepvn_flags>.
 847
 848 =cut
 849 */
 850
 851 void
 852 Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len)
 853 {
 854     PERL_ARGS_ASSERT_SV_USEPVN;
 855
 856     sv_usepvn_flags(sv,ptr,len, 0);
 857 }
 858
 859 /*
 860 =for apidoc unpack_str
 861
 862 The engine implementing unpack() Perl function.  Note: parameters strbeg,
 863 new_s and ocnt are not used.  This call should not be used, use
 864 unpackstring instead.
 865
 866 =cut */
 867
 868 I32
 869 Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s,
 870                 const char *strbeg, const char *strend, char **new_s, I32 ocnt,
 871                 U32 flags)
 872 {
 873     PERL_ARGS_ASSERT_UNPACK_STR;
 874
 875     PERL_UNUSED_ARG(strbeg);
 876     PERL_UNUSED_ARG(new_s);
 877     PERL_UNUSED_ARG(ocnt);
 878
 879     return unpackstring(pat, patend, s, strend, flags);
 880 }
 881
 882 /*
 883 =for apidoc pack_cat
 884
 885 The engine implementing pack() Perl function.  Note: parameters
 886 next_in_list and flags are not used.  This call should not be used; use
 887 packlist instead.
 888
 889 =cut
 890 */
 891
 892 void
 893 Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
 894 {
 895     PERL_ARGS_ASSERT_PACK_CAT;
 896
 897     PERL_UNUSED_ARG(next_in_list);
 898     PERL_UNUSED_ARG(flags);
 899
 900     packlist(cat, pat, patend, beglist, endlist);
 901 }
 902
 903 HE *
 904 Perl_hv_store_ent(pTHX_ HV *hv, SV *keysv, SV *val, U32 hash)
 905 {
 906   return (HE *)hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISSTORE, val, hash);
 907 }
 908
 909 bool
 910 Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
 911 {
 912     PERL_ARGS_ASSERT_HV_EXISTS_ENT;
 913
 914     return hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISEXISTS, 0, hash)
 915         ? TRUE : FALSE;
 916 }
 917
 918 HE *
 919 Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash)
 920 {
 921     PERL_ARGS_ASSERT_HV_FETCH_ENT;
 922
 923     return (HE *)hv_common(hv, keysv, NULL, 0, 0,
 924                      (lval ? HV_FETCH_LVALUE : 0), NULL, hash);
 925 }
 926
 927 SV *
 928 Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash)
 929 {
 930     PERL_ARGS_ASSERT_HV_DELETE_ENT;
 931
 932     return MUTABLE_SV(hv_common(hv, keysv, NULL, 0, 0, flags | HV_DELETE, NULL,
 933                                 hash));
 934 }
 935
 936 SV**
 937 Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash,
 938                     int flags)
 939 {
 940     return (SV**) hv_common(hv, NULL, key, klen, flags,
 941                             (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
 942 }
 943
 944 SV**
 945 Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen_i32, SV *val, U32 hash)
 946 {
 947     STRLEN klen;
 948     int flags;
 949
 950     if (klen_i32 < 0) {
 951         klen = -klen_i32;
 952         flags = HVhek_UTF8;
 953     } else {
 954         klen = klen_i32;
 955         flags = 0;
 956     }
 957     return (SV **) hv_common(hv, NULL, key, klen, flags,
 958                              (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
 959 }
 960
 961 bool
 962 Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen_i32)
 963 {
 964     STRLEN klen;
 965     int flags;
 966
 967     PERL_ARGS_ASSERT_HV_EXISTS;
 968
 969     if (klen_i32 < 0) {
 970         klen = -klen_i32;
 971         flags = HVhek_UTF8;
 972     } else {
 973         klen = klen_i32;
 974         flags = 0;
 975     }
 976     return hv_common(hv, NULL, key, klen, flags, HV_FETCH_ISEXISTS, 0, 0)
 977         ? TRUE : FALSE;
 978 }
 979
 980 SV**
 981 Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 lval)
 982 {
 983     STRLEN klen;
 984     int flags;
 985
 986     PERL_ARGS_ASSERT_HV_FETCH;
 987
 988     if (klen_i32 < 0) {
 989         klen = -klen_i32;
 990         flags = HVhek_UTF8;
 991     } else {
 992         klen = klen_i32;
 993         flags = 0;
 994     }
 995     return (SV **) hv_common(hv, NULL, key, klen, flags,
 996                              lval ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE)
 997                              : HV_FETCH_JUST_SV, NULL, 0);
 998 }
 999
1000 SV *
1001 Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 flags)
1002 {
1003     STRLEN klen;
1004     int k_flags;
1005
1006     PERL_ARGS_ASSERT_HV_DELETE;
1007
1008     if (klen_i32 < 0) {
1009         klen = -klen_i32;
1010         k_flags = HVhek_UTF8;
1011     } else {
1012         klen = klen_i32;
1013         k_flags = 0;
1014     }
1015     return MUTABLE_SV(hv_common(hv, NULL, key, klen, k_flags, flags | HV_DELETE,
1016                                 NULL, 0));
1017 }
1018
1019 /* Functions after here were made mathoms post 5.10.0 but pre 5.8.9 */
1020
1021 AV *
1022 Perl_newAV(pTHX)
1023 {
1024     return MUTABLE_AV(newSV_type(SVt_PVAV));
1025     /* sv_upgrade does AvREAL_only():
1026     AvALLOC(av) = 0;
1027     AvARRAY(av) = NULL;
1028     AvMAX(av) = AvFILLp(av) = -1; */
1029 }
1030
1031 HV *
1032 Perl_newHV(pTHX)
1033 {
1034     HV * const hv = MUTABLE_HV(newSV_type(SVt_PVHV));
1035     assert(!SvOK(hv));
1036
1037     return hv;
1038 }
1039
1040 void
1041 Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len,
1042               const char *const little, const STRLEN littlelen)
1043 {
1044     PERL_ARGS_ASSERT_SV_INSERT;
1045     sv_insert_flags(bigstr, offset, len, little, littlelen, SV_GMAGIC);
1046 }
1047
1048 void
1049 Perl_save_freesv(pTHX_ SV *sv)
1050 {
1051     save_freesv(sv);
1052 }
1053
1054 void
1055 Perl_save_mortalizesv(pTHX_ SV *sv)
1056 {
1057     PERL_ARGS_ASSERT_SAVE_MORTALIZESV;
1058
1059     save_mortalizesv(sv);
1060 }
1061
1062 void
1063 Perl_save_freeop(pTHX_ OP *o)
1064 {
1065     save_freeop(o);
1066 }
1067
1068 void
1069 Perl_save_freepv(pTHX_ char *pv)
1070 {
1071     save_freepv(pv);
1072 }
1073
1074 void
1075 Perl_save_op(pTHX)
1076 {
1077     save_op();
1078 }
1079
1080 #ifdef PERL_DONT_CREATE_GVSV
1081 GV *
1082 Perl_gv_SVadd(pTHX_ GV *gv)
1083 {
1084     return gv_SVadd(gv);
1085 }
1086 #endif
1087
1088 GV *
1089 Perl_gv_AVadd(pTHX_ GV *gv)
1090 {
1091     return gv_AVadd(gv);
1092 }
1093
1094 GV *
1095 Perl_gv_HVadd(pTHX_ GV *gv)
1096 {
1097     return gv_HVadd(gv);
1098 }
1099
1100 GV *
1101 Perl_gv_IOadd(pTHX_ GV *gv)
1102 {
1103     return gv_IOadd(gv);
1104 }
1105
1106 IO *
1107 Perl_newIO(pTHX)
1108 {
1109     return MUTABLE_IO(newSV_type(SVt_PVIO));
1110 }
1111
1112 I32
1113 Perl_my_stat(pTHX)
1114 {
1115     return my_stat_flags(SV_GMAGIC);
1116 }
1117
1118 I32
1119 Perl_my_lstat(pTHX)
1120 {
1121     return my_lstat_flags(SV_GMAGIC);
1122 }
1123
1124 I32
1125 Perl_sv_eq(pTHX_ SV *sv1, SV *sv2)
1126 {
1127     return sv_eq_flags(sv1, sv2, SV_GMAGIC);
1128 }
1129
1130 #ifdef USE_LOCALE_COLLATE
1131 char *
1132 Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp)
1133 {
1134     return sv_collxfrm_flags(sv, nxp, SV_GMAGIC);
1135 }
1136 #endif
1137
1138 bool
1139 Perl_sv_2bool(pTHX_ SV *const sv)
1140 {
1141     return sv_2bool_flags(sv, SV_GMAGIC);
1142 }
1143
1144
1145 /*
1146 =for apidoc custom_op_name
1147 Return the name for a given custom op.  This was once used by the OP_NAME
1148 macro, but is no longer: it has only been kept for compatibility, and
1149 should not be used.
1150
1151 =for apidoc custom_op_desc
1152 Return the description of a given custom op.  This was once used by the
1153 OP_DESC macro, but is no longer: it has only been kept for
1154 compatibility, and should not be used.
1155
1156 =cut
1157 */
1158
1159 const char*
1160 Perl_custom_op_name(pTHX_ const OP* o)
1161 {
1162     PERL_ARGS_ASSERT_CUSTOM_OP_NAME;
1163     return XopENTRYCUSTOM(o, xop_name);
1164 }
1165
1166 const char*
1167 Perl_custom_op_desc(pTHX_ const OP* o)
1168 {
1169     PERL_ARGS_ASSERT_CUSTOM_OP_DESC;
1170     return XopENTRYCUSTOM(o, xop_desc);
1171 }
1172
1173 CV *
1174 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
1175 {
1176     return newATTRSUB(floor, o, proto, NULL, block);
1177 }
1178
1179 UV
1180 Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1181 {
1182     PERL_ARGS_ASSERT_TO_UTF8_FOLD;
1183
1184     return _to_utf8_fold_flags(p, ustrp, lenp, FOLD_FLAGS_FULL);
1185 }
1186
1187 UV
1188 Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1189 {
1190     PERL_ARGS_ASSERT_TO_UTF8_LOWER;
1191
1192     return _to_utf8_lower_flags(p, ustrp, lenp, FALSE);
1193 }
1194
1195 UV
1196 Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1197 {
1198     PERL_ARGS_ASSERT_TO_UTF8_TITLE;
1199
1200     return _to_utf8_title_flags(p, ustrp, lenp, FALSE);
1201 }
1202
1203 UV
1204 Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1205 {
1206     PERL_ARGS_ASSERT_TO_UTF8_UPPER;
1207
1208     return _to_utf8_upper_flags(p, ustrp, lenp, FALSE);
1209 }
1210
1211 SV *
1212 Perl_sv_mortalcopy(pTHX_ SV *const oldstr)
1213 {
1214     return Perl_sv_mortalcopy_flags(aTHX_ oldstr, SV_GMAGIC);
1215 }
1216
1217 UV      /* Made into a function, so can be deprecated */
1218 NATIVE_TO_NEED(const UV enc, const UV ch)
1219 {
1220     PERL_UNUSED_ARG(enc);
1221     return ch;
1222 }
1223
1224 UV      /* Made into a function, so can be deprecated */
1225 ASCII_TO_NEED(const UV enc, const UV ch)
1226 {
1227     PERL_UNUSED_ARG(enc);
1228     return ch;
1229 }
1230
1231 bool      /* Made into a function, so can be deprecated */
1232 Perl_isIDFIRST_lazy(pTHX_ const char* p)
1233 {
1234     PERL_ARGS_ASSERT_ISIDFIRST_LAZY;
1235
1236     return isIDFIRST_lazy_if(p,1);
1237 }
1238
1239 bool      /* Made into a function, so can be deprecated */
1240 Perl_isALNUM_lazy(pTHX_ const char* p)
1241 {
1242     PERL_ARGS_ASSERT_ISALNUM_LAZY;
1243
1244     return isALNUM_lazy_if(p,1);
1245 }
1246
1247 bool
1248 Perl_is_uni_alnum(pTHX_ UV c)
1249 {
1250     return isWORDCHAR_uni(c);
1251 }
1252
1253 bool
1254 Perl_is_uni_alnumc(pTHX_ UV c)
1255 {
1256     return isALNUM_uni(c);
1257 }
1258
1259 bool
1260 Perl_is_uni_alpha(pTHX_ UV c)
1261 {
1262     return isALPHA_uni(c);
1263 }
1264
1265 bool
1266 Perl_is_uni_ascii(pTHX_ UV c)
1267 {
1268     PERL_UNUSED_CONTEXT;
1269     return isASCII_uni(c);
1270 }
1271
1272 bool
1273 Perl_is_uni_blank(pTHX_ UV c)
1274 {
1275     PERL_UNUSED_CONTEXT;
1276     return isBLANK_uni(c);
1277 }
1278
1279 bool
1280 Perl_is_uni_space(pTHX_ UV c)
1281 {
1282     PERL_UNUSED_CONTEXT;
1283     return isSPACE_uni(c);
1284 }
1285
1286 bool
1287 Perl_is_uni_digit(pTHX_ UV c)
1288 {
1289     PERL_UNUSED_CONTEXT;
1290     return isDIGIT_uni(c);
1291 }
1292
1293 bool
1294 Perl_is_uni_upper(pTHX_ UV c)
1295 {
1296     PERL_UNUSED_CONTEXT;
1297     return isUPPER_uni(c);
1298 }
1299
1300 bool
1301 Perl_is_uni_lower(pTHX_ UV c)
1302 {
1303     PERL_UNUSED_CONTEXT;
1304     return isLOWER_uni(c);
1305 }
1306
1307 bool
1308 Perl_is_uni_cntrl(pTHX_ UV c)
1309 {
1310     PERL_UNUSED_CONTEXT;
1311     return isCNTRL_L1(c);
1312 }
1313
1314 bool
1315 Perl_is_uni_graph(pTHX_ UV c)
1316 {
1317     PERL_UNUSED_CONTEXT;
1318     return isGRAPH_uni(c);
1319 }
1320
1321 bool
1322 Perl_is_uni_print(pTHX_ UV c)
1323 {
1324     PERL_UNUSED_CONTEXT;
1325     return isPRINT_uni(c);
1326 }
1327
1328 bool
1329 Perl_is_uni_punct(pTHX_ UV c)
1330 {
1331     PERL_UNUSED_CONTEXT;
1332     return isPUNCT_uni(c);
1333 }
1334
1335 bool
1336 Perl_is_uni_xdigit(pTHX_ UV c)
1337 {
1338     PERL_UNUSED_CONTEXT;
1339     return isXDIGIT_uni(c);
1340 }
1341
1342 bool
1343 Perl_is_uni_alnum_lc(pTHX_ UV c)
1344 {
1345     PERL_UNUSED_CONTEXT;
1346     return isWORDCHAR_LC_uvchr(c);
1347 }
1348
1349 bool
1350 Perl_is_uni_alnumc_lc(pTHX_ UV c)
1351 {
1352     PERL_UNUSED_CONTEXT;
1353     return isALPHANUMERIC_LC_uvchr(c);
1354 }
1355
1356 bool
1357 Perl_is_uni_idfirst_lc(pTHX_ UV c)
1358 {
1359     PERL_UNUSED_CONTEXT;
1360     /* XXX Should probably be something that resolves to the old IDFIRST, but
1361      * this function is deprecated, so not bothering */
1362     return isIDFIRST_LC_uvchr(c);
1363 }
1364
1365 bool
1366 Perl_is_uni_alpha_lc(pTHX_ UV c)
1367 {
1368     PERL_UNUSED_CONTEXT;
1369     return isALPHA_LC_uvchr(c);
1370 }
1371
1372 bool
1373 Perl_is_uni_ascii_lc(pTHX_ UV c)
1374 {
1375     PERL_UNUSED_CONTEXT;
1376     return isASCII_LC_uvchr(c);
1377 }
1378
1379 bool
1380 Perl_is_uni_blank_lc(pTHX_ UV c)
1381 {
1382     PERL_UNUSED_CONTEXT;
1383     return isBLANK_LC_uvchr(c);
1384 }
1385
1386 bool
1387 Perl_is_uni_space_lc(pTHX_ UV c)
1388 {
1389     PERL_UNUSED_CONTEXT;
1390     return isSPACE_LC_uvchr(c);
1391 }
1392
1393 bool
1394 Perl_is_uni_digit_lc(pTHX_ UV c)
1395 {
1396     return isDIGIT_LC_uvchr(c);
1397 }
1398
1399 bool
1400 Perl_is_uni_idfirst(pTHX_ UV c)
1401 {
1402     U8 tmpbuf[UTF8_MAXBYTES+1];
1403     uvchr_to_utf8(tmpbuf, c);
1404     return _is_utf8_idstart(tmpbuf);
1405 }
1406
1407 bool
1408 Perl_is_utf8_idfirst(pTHX_ const U8 *p) /* The naming is historical. */
1409 {
1410     PERL_ARGS_ASSERT_IS_UTF8_IDFIRST;
1411
1412     return _is_utf8_idstart(p);
1413 }
1414
1415 bool
1416 Perl_is_utf8_xidfirst(pTHX_ const U8 *p) /* The naming is historical. */
1417 {
1418     PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST;
1419
1420     return _is_utf8_xidstart(p);
1421 }
1422
1423 bool
1424 Perl_is_utf8_idcont(pTHX_ const U8 *p)
1425 {
1426     PERL_ARGS_ASSERT_IS_UTF8_IDCONT;
1427
1428     return _is_utf8_idcont(p);
1429 }
1430
1431 bool
1432 Perl_is_utf8_xidcont(pTHX_ const U8 *p)
1433 {
1434     PERL_ARGS_ASSERT_IS_UTF8_XIDCONT;
1435
1436     return _is_utf8_xidcont(p);
1437 }
1438
1439 bool
1440 Perl_is_uni_upper_lc(pTHX_ UV c)
1441 {
1442     return isUPPER_LC_uvchr(c);
1443 }
1444
1445 bool
1446 Perl_is_uni_lower_lc(pTHX_ UV c)
1447 {
1448     return isLOWER_LC_uvchr(c);
1449 }
1450
1451 bool
1452 Perl_is_uni_cntrl_lc(pTHX_ UV c)
1453 {
1454     return isCNTRL_LC_uvchr(c);
1455 }
1456
1457 bool
1458 Perl_is_uni_graph_lc(pTHX_ UV c)
1459 {
1460     return isGRAPH_LC_uvchr(c);
1461 }
1462
1463 bool
1464 Perl_is_uni_print_lc(pTHX_ UV c)
1465 {
1466     return isPRINT_LC_uvchr(c);
1467 }
1468
1469 bool
1470 Perl_is_uni_punct_lc(pTHX_ UV c)
1471 {
1472     return isPUNCT_LC_uvchr(c);
1473 }
1474
1475 bool
1476 Perl_is_uni_xdigit_lc(pTHX_ UV c)
1477 {
1478     return isXDIGIT_LC_uvchr(c);
1479 }
1480
1481 U32
1482 Perl_to_uni_upper_lc(pTHX_ U32 c)
1483 {
1484     /* XXX returns only the first character -- do not use XXX */
1485     /* XXX no locale support yet */
1486     STRLEN len;
1487     U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1488     return (U32)to_uni_upper(c, tmpbuf, &len);
1489 }
1490
1491 U32
1492 Perl_to_uni_title_lc(pTHX_ U32 c)
1493 {
1494     /* XXX returns only the first character XXX -- do not use XXX */
1495     /* XXX no locale support yet */
1496     STRLEN len;
1497     U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1498     return (U32)to_uni_title(c, tmpbuf, &len);
1499 }
1500
1501 U32
1502 Perl_to_uni_lower_lc(pTHX_ U32 c)
1503 {
1504     /* XXX returns only the first character -- do not use XXX */
1505     /* XXX no locale support yet */
1506     STRLEN len;
1507     U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1508     return (U32)to_uni_lower(c, tmpbuf, &len);
1509 }
1510
1511 bool
1512 Perl_is_utf8_alnum(pTHX_ const U8 *p)
1513 {
1514     PERL_ARGS_ASSERT_IS_UTF8_ALNUM;
1515
1516     /* NOTE: "IsWord", not "IsAlnum", since Alnum is a true
1517      * descendant of isalnum(3), in other words, it doesn't
1518      * contain the '_'. --jhi */
1519     return isWORDCHAR_utf8(p);
1520 }
1521
1522 bool
1523 Perl_is_utf8_alnumc(pTHX_ const U8 *p)
1524 {
1525     PERL_ARGS_ASSERT_IS_UTF8_ALNUMC;
1526
1527     return isALPHANUMERIC_utf8(p);
1528 }
1529
1530 bool
1531 Perl_is_utf8_alpha(pTHX_ const U8 *p)
1532 {
1533     PERL_ARGS_ASSERT_IS_UTF8_ALPHA;
1534
1535     return isALPHA_utf8(p);
1536 }
1537
1538 bool
1539 Perl_is_utf8_ascii(pTHX_ const U8 *p)
1540 {
1541     PERL_ARGS_ASSERT_IS_UTF8_ASCII;
1542     PERL_UNUSED_CONTEXT;
1543
1544     return isASCII_utf8(p);
1545 }
1546
1547 bool
1548 Perl_is_utf8_blank(pTHX_ const U8 *p)
1549 {
1550     PERL_ARGS_ASSERT_IS_UTF8_BLANK;
1551     PERL_UNUSED_CONTEXT;
1552
1553     return isBLANK_utf8(p);
1554 }
1555
1556 bool
1557 Perl_is_utf8_space(pTHX_ const U8 *p)
1558 {
1559     PERL_ARGS_ASSERT_IS_UTF8_SPACE;
1560     PERL_UNUSED_CONTEXT;
1561
1562     return isSPACE_utf8(p);
1563 }
1564
1565 bool
1566 Perl_is_utf8_perl_space(pTHX_ const U8 *p)
1567 {
1568     PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE;
1569     PERL_UNUSED_CONTEXT;
1570
1571     /* Only true if is an ASCII space-like character, and ASCII is invariant
1572      * under utf8, so can just use the macro */
1573     return isSPACE_A(*p);
1574 }
1575
1576 bool
1577 Perl_is_utf8_perl_word(pTHX_ const U8 *p)
1578 {
1579     PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD;
1580     PERL_UNUSED_CONTEXT;
1581
1582     /* Only true if is an ASCII word character, and ASCII is invariant
1583      * under utf8, so can just use the macro */
1584     return isWORDCHAR_A(*p);
1585 }
1586
1587 bool
1588 Perl_is_utf8_digit(pTHX_ const U8 *p)
1589 {
1590     PERL_ARGS_ASSERT_IS_UTF8_DIGIT;
1591
1592     return isDIGIT_utf8(p);
1593 }
1594
1595 bool
1596 Perl_is_utf8_posix_digit(pTHX_ const U8 *p)
1597 {
1598     PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT;
1599     PERL_UNUSED_CONTEXT;
1600
1601     /* Only true if is an ASCII digit character, and ASCII is invariant
1602      * under utf8, so can just use the macro */
1603     return isDIGIT_A(*p);
1604 }
1605
1606 bool
1607 Perl_is_utf8_upper(pTHX_ const U8 *p)
1608 {
1609     PERL_ARGS_ASSERT_IS_UTF8_UPPER;
1610
1611     return isUPPER_utf8(p);
1612 }
1613
1614 bool
1615 Perl_is_utf8_lower(pTHX_ const U8 *p)
1616 {
1617     PERL_ARGS_ASSERT_IS_UTF8_LOWER;
1618
1619     return isLOWER_utf8(p);
1620 }
1621
1622 bool
1623 Perl_is_utf8_cntrl(pTHX_ const U8 *p)
1624 {
1625     PERL_ARGS_ASSERT_IS_UTF8_CNTRL;
1626     PERL_UNUSED_CONTEXT;
1627
1628     return isCNTRL_utf8(p);
1629 }
1630
1631 bool
1632 Perl_is_utf8_graph(pTHX_ const U8 *p)
1633 {
1634     PERL_ARGS_ASSERT_IS_UTF8_GRAPH;
1635
1636     return isGRAPH_utf8(p);
1637 }
1638
1639 bool
1640 Perl_is_utf8_print(pTHX_ const U8 *p)
1641 {
1642     PERL_ARGS_ASSERT_IS_UTF8_PRINT;
1643
1644     return isPRINT_utf8(p);
1645 }
1646
1647 bool
1648 Perl_is_utf8_punct(pTHX_ const U8 *p)
1649 {
1650     PERL_ARGS_ASSERT_IS_UTF8_PUNCT;
1651
1652     return isPUNCT_utf8(p);
1653 }
1654
1655 bool
1656 Perl_is_utf8_xdigit(pTHX_ const U8 *p)
1657 {
1658     PERL_ARGS_ASSERT_IS_UTF8_XDIGIT;
1659     PERL_UNUSED_CONTEXT;
1660
1661     return isXDIGIT_utf8(p);
1662 }
1663
1664 bool
1665 Perl_is_utf8_mark(pTHX_ const U8 *p)
1666 {
1667     PERL_ARGS_ASSERT_IS_UTF8_MARK;
1668
1669     return _is_utf8_mark(p);
1670 }
1671
1672 /*
1673 =for apidoc is_utf8_char
1674
1675 Tests if some arbitrary number of bytes begins in a valid UTF-8
1676 character.  Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines)
1677 character is a valid UTF-8 character.  The actual number of bytes in the UTF-8
1678 character will be returned if it is valid, otherwise 0.
1679
1680 This function is deprecated due to the possibility that malformed input could
1681 cause reading beyond the end of the input buffer.  Use L</isUTF8_CHAR>
1682 instead.
1683
1684 =cut */
1685
1686 STRLEN
1687 Perl_is_utf8_char(const U8 *s)
1688 {
1689     PERL_ARGS_ASSERT_IS_UTF8_CHAR;
1690
1691     /* Assumes we have enough space, which is why this is deprecated */
1692     return isUTF8_CHAR(s, s + UTF8SKIP(s));
1693 }
1694
1695 /* DEPRECATED!
1696  * Like L</utf8_to_uvuni_buf>(), but should only be called when it is known that
1697  * there are no malformations in the input UTF-8 string C<s>.  Surrogates,
1698  * non-character code points, and non-Unicode code points are allowed */
1699
1700 UV
1701 Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
1702 {
1703     PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI;
1704
1705     return NATIVE_TO_UNI(valid_utf8_to_uvchr(s, retlen));
1706 }
1707
1708 /*
1709 =for apidoc utf8_to_uvchr
1710
1711 Returns the native code point of the first character in the string C<s>
1712 which is assumed to be in UTF-8 encoding; C<retlen> will be set to the
1713 length, in bytes, of that character.
1714
1715 Some, but not all, UTF-8 malformations are detected, and in fact, some
1716 malformed input could cause reading beyond the end of the input buffer, which
1717 is why this function is deprecated.  Use L</utf8_to_uvchr_buf> instead.
1718
1719 If C<s> points to one of the detected malformations, and UTF8 warnings are
1720 enabled, zero is returned and C<*retlen> is set (if C<retlen> isn't
1721 NULL) to -1.  If those warnings are off, the computed value if well-defined (or
1722 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
1723 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
1724 next possible position in C<s> that could begin a non-malformed character.
1725 See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
1726
1727 =cut
1728 */
1729
1730 UV
1731 Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
1732 {
1733     PERL_ARGS_ASSERT_UTF8_TO_UVCHR;
1734
1735     return utf8_to_uvchr_buf(s, s + UTF8_MAXBYTES, retlen);
1736 }
1737
1738 /*
1739 =for apidoc utf8_to_uvuni
1740
1741 Returns the Unicode code point of the first character in the string C<s>
1742 which is assumed to be in UTF-8 encoding; C<retlen> will be set to the
1743 length, in bytes, of that character.
1744
1745 Some, but not all, UTF-8 malformations are detected, and in fact, some
1746 malformed input could cause reading beyond the end of the input buffer, which
1747 is one reason why this function is deprecated.  The other is that only in
1748 extremely limited circumstances should the Unicode versus native code point be
1749 of any interest to you.  See L</utf8_to_uvuni_buf> for alternatives.
1750
1751 If C<s> points to one of the detected malformations, and UTF8 warnings are
1752 enabled, zero is returned and C<*retlen> is set (if C<retlen> doesn't point to
1753 NULL) to -1.  If those warnings are off, the computed value if well-defined (or
1754 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
1755 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
1756 next possible position in C<s> that could begin a non-malformed character.
1757 See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
1758
1759 =cut
1760 */
1761
1762 UV
1763 Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
1764 {
1765     PERL_ARGS_ASSERT_UTF8_TO_UVUNI;
1766
1767     return NATIVE_TO_UNI(valid_utf8_to_uvchr(s, retlen));
1768 }
1769
1770 END_EXTERN_C
1771
1772 #endif /* NO_MATHOMS */
1773
1774 /*
1775  * Local variables:
1776  * c-indentation-style: bsd
1777  * c-basic-offset: 4
1778  * indent-tabs-mode: nil
1779  * End:
1780  *
1781  * ex: set ts=8 sts=4 sw=4 et:
1782  */