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