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