This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Spelling/grammar nits
[perl5.git] / mathoms.c
CommitLineData
7ee2227d
SP
1/* mathoms.c
2 *
1129b882 3 * Copyright (C) 2005, 2006, 2007, 2008 by Larry Wall and others
7ee2227d
SP
4 *
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Artistic License, as specified in the README file.
7 *
8 */
9
10/*
4ac71550
TC
11 * Anything that Hobbits had no immediate use for, but were unwilling to
12 * throw away, they called a mathom. Their dwellings were apt to become
13 * rather crowded with mathoms, and many of the presents that passed from
14 * hand to hand were of that sort.
15 *
16 * [p.5 of _The Lord of the Rings_: "Prologue"]
7ee2227d
SP
17 */
18
359d40ba 19
20fac488 20
7ee2227d
SP
21/*
22 * This file contains mathoms, various binary artifacts from previous
f2f0f092
NC
23 * versions of Perl. For binary or source compatibility reasons, though,
24 * we cannot completely remove them from the core code.
7ee2227d
SP
25 *
26 * SMP - Oct. 24, 2005
27 *
28 */
29
30#include "EXTERN.h"
31#define PERL_IN_MATHOMS_C
32#include "perl.h"
33
359d40ba
NC
34#ifdef NO_MATHOMS
35/* ..." warning: ISO C forbids an empty source file"
36 So make sure we have something in here by processing the headers anyway.
37 */
38#else
39
a0c21aa1
JH
40PERL_CALLCONV OP * Perl_ref(pTHX_ OP *o, I32 type);
41PERL_CALLCONV void Perl_sv_unref(pTHX_ SV *sv);
42PERL_CALLCONV void Perl_sv_taint(pTHX_ SV *sv);
43PERL_CALLCONV IV Perl_sv_2iv(pTHX_ register SV *sv);
44PERL_CALLCONV UV Perl_sv_2uv(pTHX_ register SV *sv);
39d5de13 45PERL_CALLCONV NV Perl_sv_2nv(pTHX_ register SV *sv);
a0c21aa1
JH
46PERL_CALLCONV char * Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp);
47PERL_CALLCONV char * Perl_sv_2pv_nolen(pTHX_ register SV *sv);
48PERL_CALLCONV char * Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv);
49PERL_CALLCONV char * Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv);
50PERL_CALLCONV void Perl_sv_force_normal(pTHX_ register SV *sv);
51PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr);
52PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen);
53PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len);
54PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr);
55PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, register SV *ssv);
56PERL_CALLCONV char * Perl_sv_pv(pTHX_ SV *sv);
57PERL_CALLCONV char * Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp);
58PERL_CALLCONV char * Perl_sv_pvbyte(pTHX_ SV *sv);
59PERL_CALLCONV char * Perl_sv_pvutf8(pTHX_ SV *sv);
60PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ register SV *sv);
61PERL_CALLCONV NV Perl_huge(void);
62PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
63PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
64PERL_CALLCONV GV * Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name);
65PERL_CALLCONV HE * Perl_hv_iternext(pTHX_ HV *hv);
66PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how);
67PERL_CALLCONV bool Perl_do_open(pTHX_ GV *gv, register const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp);
68PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV *really, register SV **mark, register SV **sp);
69PERL_CALLCONV bool Perl_do_exec(pTHX_ const char *cmd);
70PERL_CALLCONV U8 * Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv);
71PERL_CALLCONV bool Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep);
72PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv);
73PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len);
74PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len);
75PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...);
76PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...);
56d7a086 77PERL_CALLCONV int Perl_magic_setglob(pTHX_ SV* sv, MAGIC* mg);
ac572bf4 78PERL_CALLCONV AV * Perl_newAV(pTHX);
78ac7dd9 79PERL_CALLCONV HV * Perl_newHV(pTHX);
85dca89a 80PERL_CALLCONV IO * Perl_newIO(pTHX);
0d7d409d
DM
81PERL_CALLCONV I32 Perl_my_stat(pTHX);
82PERL_CALLCONV I32 Perl_my_lstat(pTHX);
078504b2
FC
83PERL_CALLCONV I32 Perl_sv_eq(pTHX_ register SV *sv1, register SV *sv2);
84PERL_CALLCONV char * Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp);
06c841cf 85PERL_CALLCONV bool Perl_sv_2bool(pTHX_ register SV *const sv);
b5445a23 86
7ee2227d
SP
87/* ref() is now a macro using Perl_doref;
88 * this version provided for binary compatibility only.
89 */
90OP *
91Perl_ref(pTHX_ OP *o, I32 type)
92{
93 return doref(o, type, TRUE);
94}
95
aae9cea0 96/*
174c73e3
NC
97=for apidoc sv_unref
98
99Unsets the RV status of the SV, and decrements the reference count of
100whatever was being referenced by the RV. This can almost be thought of
101as a reversal of C<newSVrv>. This is C<sv_unref_flags> with the C<flag>
102being zero. See C<SvROK_off>.
103
104=cut
105*/
106
107void
108Perl_sv_unref(pTHX_ SV *sv)
109{
7918f24d
NC
110 PERL_ARGS_ASSERT_SV_UNREF;
111
174c73e3
NC
112 sv_unref_flags(sv, 0);
113}
114
115/*
aae9cea0
NC
116=for apidoc sv_taint
117
118Taint an SV. Use C<SvTAINTED_on> instead.
119=cut
120*/
121
122void
123Perl_sv_taint(pTHX_ SV *sv)
124{
7918f24d
NC
125 PERL_ARGS_ASSERT_SV_TAINT;
126
a0714e2c 127 sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0);
aae9cea0
NC
128}
129
7ee2227d
SP
130/* sv_2iv() is now a macro using Perl_sv_2iv_flags();
131 * this function provided for binary compatibility only
132 */
133
134IV
135Perl_sv_2iv(pTHX_ register SV *sv)
136{
137 return sv_2iv_flags(sv, SV_GMAGIC);
138}
139
140/* sv_2uv() is now a macro using Perl_sv_2uv_flags();
141 * this function provided for binary compatibility only
142 */
143
144UV
145Perl_sv_2uv(pTHX_ register SV *sv)
146{
147 return sv_2uv_flags(sv, SV_GMAGIC);
148}
149
39d5de13
DM
150/* sv_2nv() is now a macro using Perl_sv_2nv_flags();
151 * this function provided for binary compatibility only
152 */
153
154NV
155Perl_sv_2nv(pTHX_ register SV *sv)
156{
157 return sv_2nv_flags(sv, SV_GMAGIC);
158}
159
160
7ee2227d
SP
161/* sv_2pv() is now a macro using Perl_sv_2pv_flags();
162 * this function provided for binary compatibility only
163 */
164
165char *
166Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp)
167{
168 return sv_2pv_flags(sv, lp, SV_GMAGIC);
169}
170
5abc721d 171/*
cb2f1b7b
NC
172=for apidoc sv_2pv_nolen
173
174Like C<sv_2pv()>, but doesn't return the length too. You should usually
175use the macro wrapper C<SvPV_nolen(sv)> instead.
176=cut
177*/
178
179char *
180Perl_sv_2pv_nolen(pTHX_ register SV *sv)
181{
c85ae797 182 PERL_ARGS_ASSERT_SV_2PV_NOLEN;
b5445a23 183 return sv_2pv(sv, NULL);
cb2f1b7b
NC
184}
185
186/*
187=for apidoc sv_2pvbyte_nolen
188
189Return a pointer to the byte-encoded representation of the SV.
190May cause the SV to be downgraded from UTF-8 as a side-effect.
191
192Usually accessed via the C<SvPVbyte_nolen> macro.
193
194=cut
195*/
196
197char *
198Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv)
199{
7918f24d
NC
200 PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN;
201
b5445a23 202 return sv_2pvbyte(sv, NULL);
cb2f1b7b
NC
203}
204
205/*
206=for apidoc sv_2pvutf8_nolen
207
208Return a pointer to the UTF-8-encoded representation of the SV.
209May cause the SV to be upgraded to UTF-8 as a side-effect.
210
211Usually accessed via the C<SvPVutf8_nolen> macro.
212
213=cut
214*/
215
216char *
217Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv)
218{
7918f24d
NC
219 PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN;
220
b5445a23 221 return sv_2pvutf8(sv, NULL);
cb2f1b7b
NC
222}
223
224/*
5abc721d
NC
225=for apidoc sv_force_normal
226
227Undo various types of fakery on an SV: if the PV is a shared string, make
228a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
229an xpvmg. See also C<sv_force_normal_flags>.
230
231=cut
232*/
233
234void
235Perl_sv_force_normal(pTHX_ register SV *sv)
236{
7918f24d
NC
237 PERL_ARGS_ASSERT_SV_FORCE_NORMAL;
238
5abc721d
NC
239 sv_force_normal_flags(sv, 0);
240}
7ee2227d
SP
241
242/* sv_setsv() is now a macro using Perl_sv_setsv_flags();
243 * this function provided for binary compatibility only
244 */
245
246void
247Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr)
248{
7918f24d
NC
249 PERL_ARGS_ASSERT_SV_SETSV;
250
7ee2227d
SP
251 sv_setsv_flags(dstr, sstr, SV_GMAGIC);
252}
253
254/* sv_catpvn() is now a macro using Perl_sv_catpvn_flags();
255 * this function provided for binary compatibility only
256 */
257
258void
259Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen)
260{
7918f24d
NC
261 PERL_ARGS_ASSERT_SV_CATPVN;
262
7ee2227d
SP
263 sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC);
264}
265
b347df82
NC
266/*
267=for apidoc sv_catpvn_mg
268
269Like C<sv_catpvn>, but also handles 'set' magic.
270
271=cut
272*/
273
274void
275Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
276{
7918f24d
NC
277 PERL_ARGS_ASSERT_SV_CATPVN_MG;
278
b347df82
NC
279 sv_catpvn_flags(sv,ptr,len,SV_GMAGIC|SV_SMAGIC);
280}
281
7ee2227d
SP
282/* sv_catsv() is now a macro using Perl_sv_catsv_flags();
283 * this function provided for binary compatibility only
284 */
285
286void
287Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr)
288{
7918f24d
NC
289 PERL_ARGS_ASSERT_SV_CATSV;
290
7ee2227d
SP
291 sv_catsv_flags(dstr, sstr, SV_GMAGIC);
292}
293
0feed65a 294/*
b347df82
NC
295=for apidoc sv_catsv_mg
296
297Like C<sv_catsv>, but also handles 'set' magic.
298
299=cut
300*/
301
302void
303Perl_sv_catsv_mg(pTHX_ SV *dsv, register SV *ssv)
304{
7918f24d
NC
305 PERL_ARGS_ASSERT_SV_CATSV_MG;
306
b347df82
NC
307 sv_catsv_flags(dsv,ssv,SV_GMAGIC|SV_SMAGIC);
308}
309
310/*
0feed65a
NC
311=for apidoc sv_iv
312
313A private implementation of the C<SvIVx> macro for compilers which can't
314cope with complex macro expressions. Always use the macro instead.
315
316=cut
317*/
318
319IV
320Perl_sv_iv(pTHX_ register SV *sv)
321{
7918f24d
NC
322 PERL_ARGS_ASSERT_SV_IV;
323
0feed65a
NC
324 if (SvIOK(sv)) {
325 if (SvIsUV(sv))
326 return (IV)SvUVX(sv);
327 return SvIVX(sv);
328 }
329 return sv_2iv(sv);
330}
331
332/*
333=for apidoc sv_uv
334
335A private implementation of the C<SvUVx> macro for compilers which can't
336cope with complex macro expressions. Always use the macro instead.
337
338=cut
339*/
340
341UV
342Perl_sv_uv(pTHX_ register SV *sv)
343{
7918f24d
NC
344 PERL_ARGS_ASSERT_SV_UV;
345
0feed65a
NC
346 if (SvIOK(sv)) {
347 if (SvIsUV(sv))
348 return SvUVX(sv);
349 return (UV)SvIVX(sv);
350 }
351 return sv_2uv(sv);
352}
353
354/*
355=for apidoc sv_nv
356
357A private implementation of the C<SvNVx> macro for compilers which can't
358cope with complex macro expressions. Always use the macro instead.
359
360=cut
361*/
362
363NV
364Perl_sv_nv(pTHX_ register SV *sv)
365{
7918f24d
NC
366 PERL_ARGS_ASSERT_SV_NV;
367
0feed65a
NC
368 if (SvNOK(sv))
369 return SvNVX(sv);
370 return sv_2nv(sv);
371}
372
373/*
374=for apidoc sv_pv
375
376Use the C<SvPV_nolen> macro instead
377
378=for apidoc sv_pvn
379
380A private implementation of the C<SvPV> macro for compilers which can't
381cope with complex macro expressions. Always use the macro instead.
382
383=cut
384*/
385
386char *
387Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp)
388{
7918f24d
NC
389 PERL_ARGS_ASSERT_SV_PVN;
390
0feed65a
NC
391 if (SvPOK(sv)) {
392 *lp = SvCUR(sv);
393 return SvPVX(sv);
394 }
395 return sv_2pv(sv, lp);
396}
397
398
399char *
400Perl_sv_pvn_nomg(pTHX_ register SV *sv, STRLEN *lp)
401{
7918f24d
NC
402 PERL_ARGS_ASSERT_SV_PVN_NOMG;
403
0feed65a
NC
404 if (SvPOK(sv)) {
405 *lp = SvCUR(sv);
406 return SvPVX(sv);
407 }
408 return sv_2pv_flags(sv, lp, 0);
409}
410
7ee2227d
SP
411/* sv_pv() is now a macro using SvPV_nolen();
412 * this function provided for binary compatibility only
413 */
414
415char *
416Perl_sv_pv(pTHX_ SV *sv)
417{
7918f24d
NC
418 PERL_ARGS_ASSERT_SV_PV;
419
7ee2227d
SP
420 if (SvPOK(sv))
421 return SvPVX(sv);
422
b5445a23 423 return sv_2pv(sv, NULL);
7ee2227d
SP
424}
425
426/* sv_pvn_force() is now a macro using Perl_sv_pvn_force_flags();
427 * this function provided for binary compatibility only
428 */
429
430char *
431Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp)
432{
7918f24d
NC
433 PERL_ARGS_ASSERT_SV_PVN_FORCE;
434
7ee2227d
SP
435 return sv_pvn_force_flags(sv, lp, SV_GMAGIC);
436}
437
438/* sv_pvbyte () is now a macro using Perl_sv_2pv_flags();
439 * this function provided for binary compatibility only
440 */
441
442char *
443Perl_sv_pvbyte(pTHX_ SV *sv)
444{
7918f24d
NC
445 PERL_ARGS_ASSERT_SV_PVBYTE;
446
b5445a23 447 sv_utf8_downgrade(sv, FALSE);
7ee2227d
SP
448 return sv_pv(sv);
449}
450
0feed65a
NC
451/*
452=for apidoc sv_pvbyte
453
454Use C<SvPVbyte_nolen> instead.
455
456=for apidoc sv_pvbyten
457
458A private implementation of the C<SvPVbyte> macro for compilers
459which can't cope with complex macro expressions. Always use the macro
460instead.
461
462=cut
463*/
464
465char *
466Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp)
467{
7918f24d
NC
468 PERL_ARGS_ASSERT_SV_PVBYTEN;
469
b5445a23 470 sv_utf8_downgrade(sv, FALSE);
0feed65a
NC
471 return sv_pvn(sv,lp);
472}
473
7ee2227d
SP
474/* sv_pvutf8 () is now a macro using Perl_sv_2pv_flags();
475 * this function provided for binary compatibility only
476 */
477
478char *
479Perl_sv_pvutf8(pTHX_ SV *sv)
480{
7918f24d
NC
481 PERL_ARGS_ASSERT_SV_PVUTF8;
482
7ee2227d
SP
483 sv_utf8_upgrade(sv);
484 return sv_pv(sv);
485}
486
0feed65a
NC
487/*
488=for apidoc sv_pvutf8
489
490Use the C<SvPVutf8_nolen> macro instead
491
492=for apidoc sv_pvutf8n
493
494A private implementation of the C<SvPVutf8> macro for compilers
495which can't cope with complex macro expressions. Always use the macro
496instead.
497
498=cut
499*/
500
501char *
502Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp)
503{
7918f24d
NC
504 PERL_ARGS_ASSERT_SV_PVUTF8N;
505
0feed65a
NC
506 sv_utf8_upgrade(sv);
507 return sv_pvn(sv,lp);
508}
509
205c02c2
NC
510/* sv_utf8_upgrade() is now a macro using sv_utf8_upgrade_flags();
511 * this function provided for binary compatibility only
512 */
513
514STRLEN
515Perl_sv_utf8_upgrade(pTHX_ register SV *sv)
516{
7918f24d
NC
517 PERL_ARGS_ASSERT_SV_UTF8_UPGRADE;
518
205c02c2
NC
519 return sv_utf8_upgrade_flags(sv, SV_GMAGIC);
520}
521
7ee2227d
SP
522int
523Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...)
524{
525 dTHXs;
526 va_list(arglist);
7918f24d
NC
527
528 /* Easier to special case this here than in embed.pl. (Look at what it
529 generates for proto.h) */
530#ifdef PERL_IMPLICIT_CONTEXT
531 PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT;
532#endif
533
7ee2227d
SP
534 va_start(arglist, format);
535 return PerlIO_vprintf(stream, format, arglist);
536}
537
538int
539Perl_printf_nocontext(const char *format, ...)
540{
541 dTHX;
542 va_list(arglist);
7918f24d
NC
543
544#ifdef PERL_IMPLICIT_CONTEXT
545 PERL_ARGS_ASSERT_PRINTF_NOCONTEXT;
546#endif
547
7ee2227d
SP
548 va_start(arglist, format);
549 return PerlIO_vprintf(PerlIO_stdout(), format, arglist);
550}
551
552#if defined(HUGE_VAL) || (defined(USE_LONG_DOUBLE) && defined(HUGE_VALL))
553/*
554 * This hack is to force load of "huge" support from libm.a
555 * So it is in perl for (say) POSIX to use.
556 * Needed for SunOS with Sun's 'acc' for example.
557 */
558NV
559Perl_huge(void)
560{
c773ee7a 561# if defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)
7ee2227d 562 return HUGE_VALL;
c773ee7a 563# else
7ee2227d 564 return HUGE_VAL;
c773ee7a 565# endif
7ee2227d
SP
566}
567#endif
568
f2f0f092
NC
569/* compatibility with versions <= 5.003. */
570void
571Perl_gv_fullname(pTHX_ SV *sv, const GV *gv)
572{
7918f24d
NC
573 PERL_ARGS_ASSERT_GV_FULLNAME;
574
666ea192 575 gv_fullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
f2f0f092
NC
576}
577
578/* compatibility with versions <= 5.003. */
579void
580Perl_gv_efullname(pTHX_ SV *sv, const GV *gv)
581{
7918f24d
NC
582 PERL_ARGS_ASSERT_GV_EFULLNAME;
583
666ea192 584 gv_efullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
f2f0f092
NC
585}
586
2674aeec
NC
587void
588Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
589{
7918f24d
NC
590 PERL_ARGS_ASSERT_GV_FULLNAME3;
591
2674aeec
NC
592 gv_fullname4(sv, gv, prefix, TRUE);
593}
594
595void
596Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
597{
7918f24d
NC
598 PERL_ARGS_ASSERT_GV_EFULLNAME3;
599
2674aeec
NC
600 gv_efullname4(sv, gv, prefix, TRUE);
601}
602
887986eb
NC
603/*
604=for apidoc gv_fetchmethod
605
606See L<gv_fetchmethod_autoload>.
607
608=cut
609*/
610
611GV *
612Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
613{
7918f24d
NC
614 PERL_ARGS_ASSERT_GV_FETCHMETHOD;
615
887986eb
NC
616 return gv_fetchmethod_autoload(stash, name, TRUE);
617}
618
7a7b9979
NC
619HE *
620Perl_hv_iternext(pTHX_ HV *hv)
621{
7918f24d
NC
622 PERL_ARGS_ASSERT_HV_ITERNEXT;
623
7a7b9979
NC
624 return hv_iternext_flags(hv, 0);
625}
626
bc5cdc23
NC
627void
628Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how)
629{
7918f24d
NC
630 PERL_ARGS_ASSERT_HV_MAGIC;
631
ad64d0ec 632 sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0);
bc5cdc23
NC
633}
634
34d367cd 635bool
e4dba786
NC
636Perl_do_open(pTHX_ GV *gv, register const char *name, I32 len, int as_raw,
637 int rawmode, int rawperm, PerlIO *supplied_fp)
638{
7918f24d
NC
639 PERL_ARGS_ASSERT_DO_OPEN;
640
e4dba786
NC
641 return do_openn(gv, name, len, as_raw, rawmode, rawperm,
642 supplied_fp, (SV **) NULL, 0);
643}
644
645bool
34d367cd
SP
646Perl_do_open9(pTHX_ GV *gv, register const char *name, I32 len, int
647as_raw,
648 int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs,
649 I32 num_svs)
650{
7918f24d
NC
651 PERL_ARGS_ASSERT_DO_OPEN9;
652
34d367cd
SP
653 PERL_UNUSED_ARG(num_svs);
654 return do_openn(gv, name, len, as_raw, rawmode, rawperm,
655 supplied_fp, &svs, 1);
656}
657
658int
659Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
660{
661 /* The old body of this is now in non-LAYER part of perlio.c
662 * This is a stub for any XS code which might have been calling it.
663 */
664 const char *name = ":raw";
7918f24d
NC
665
666 PERL_ARGS_ASSERT_DO_BINMODE;
667
34d367cd
SP
668#ifdef PERLIO_USING_CRLF
669 if (!(mode & O_BINARY))
670 name = ":crlf";
671#endif
672 return PerlIO_binmode(aTHX_ fp, iotype, mode, name);
673}
674
a9f96b3f
NC
675#ifndef OS2
676bool
677Perl_do_aexec(pTHX_ SV *really, register SV **mark, register SV **sp)
678{
7918f24d
NC
679 PERL_ARGS_ASSERT_DO_AEXEC;
680
a9f96b3f
NC
681 return do_aexec5(really, mark, sp, 0, 0);
682}
683#endif
684
9555a685
NC
685#ifdef PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION
686bool
687Perl_do_exec(pTHX_ const char *cmd)
688{
7918f24d
NC
689 PERL_ARGS_ASSERT_DO_EXEC;
690
9555a685
NC
691 return do_exec3(cmd,0,0);
692}
693#endif
694
89552e80
NC
695/* Backwards compatibility. */
696int
697Perl_init_i18nl14n(pTHX_ int printwarn)
698{
699 return init_i18nl10n(printwarn);
700}
701
c78ff979
NC
702PP(pp_padany)
703{
704 DIE(aTHX_ "NOT IMPL LINE %d",__LINE__);
c78ff979
NC
705}
706
707PP(pp_mapstart)
708{
709 DIE(aTHX_ "panic: mapstart"); /* uses grepstart */
710}
711
0b612f93
NC
712/* These ops all have the same body as pp_null. */
713PP(pp_scalar)
714{
97aff369 715 dVAR;
0b612f93
NC
716 return NORMAL;
717}
718
719PP(pp_regcmaybe)
720{
97aff369 721 dVAR;
0b612f93
NC
722 return NORMAL;
723}
724
725PP(pp_lineseq)
726{
97aff369 727 dVAR;
0b612f93
NC
728 return NORMAL;
729}
730
731PP(pp_scope)
732{
97aff369 733 dVAR;
0b612f93
NC
734 return NORMAL;
735}
736
737/* Ops that are calls to do_kv. */
738PP(pp_values)
739{
740 return do_kv();
741}
742
743PP(pp_keys)
744{
745 return do_kv();
746}
747
748/* Ops that are simply calls to other ops. */
749PP(pp_dump)
750{
751 return pp_goto();
752 /*NOTREACHED*/
753}
754
755PP(pp_dofile)
756{
757 return pp_require();
758}
759
760PP(pp_dbmclose)
761{
762 return pp_untie();
763}
764
765PP(pp_read)
766{
767 return pp_sysread();
768}
769
770PP(pp_recv)
771{
772 return pp_sysread();
773}
774
775PP(pp_seek)
776{
777 return pp_sysseek();
778}
779
780PP(pp_fcntl)
781{
782 return pp_ioctl();
783}
784
785PP(pp_gsockopt)
786{
787 return pp_ssockopt();
788}
789
790PP(pp_getsockname)
791{
792 return pp_getpeername();
793}
794
795PP(pp_lstat)
796{
797 return pp_stat();
798}
799
800PP(pp_fteowned)
801{
802 return pp_ftrowned();
803}
804
805PP(pp_ftbinary)
806{
807 return pp_fttext();
808}
809
810PP(pp_localtime)
811{
812 return pp_gmtime();
813}
814
815PP(pp_shmget)
816{
817 return pp_semget();
818}
819
820PP(pp_shmctl)
821{
822 return pp_semctl();
823}
824
825PP(pp_shmread)
826{
827 return pp_shmwrite();
828}
829
830PP(pp_msgget)
831{
832 return pp_semget();
833}
834
835PP(pp_msgctl)
836{
837 return pp_semctl();
838}
839
840PP(pp_ghbyname)
841{
842 return pp_ghostent();
843}
844
845PP(pp_ghbyaddr)
846{
847 return pp_ghostent();
848}
849
850PP(pp_gnbyname)
851{
852 return pp_gnetent();
853}
854
855PP(pp_gnbyaddr)
856{
857 return pp_gnetent();
858}
859
860PP(pp_gpbyname)
861{
862 return pp_gprotoent();
863}
864
865PP(pp_gpbynumber)
866{
867 return pp_gprotoent();
868}
869
870PP(pp_gsbyname)
871{
872 return pp_gservent();
873}
874
875PP(pp_gsbyport)
876{
877 return pp_gservent();
878}
879
880PP(pp_gpwnam)
881{
882 return pp_gpwent();
883}
884
885PP(pp_gpwuid)
886{
887 return pp_gpwent();
888}
889
890PP(pp_ggrnam)
891{
892 return pp_ggrent();
893}
894
895PP(pp_ggrgid)
896{
897 return pp_ggrent();
898}
899
957b0e1d
NC
900PP(pp_ftsize)
901{
4992681b 902 return pp_ftis();
957b0e1d
NC
903}
904
905PP(pp_ftmtime)
906{
4992681b 907 return pp_ftis();
957b0e1d
NC
908}
909
910PP(pp_ftatime)
911{
4992681b 912 return pp_ftis();
957b0e1d
NC
913}
914
915PP(pp_ftctime)
916{
4992681b 917 return pp_ftis();
957b0e1d
NC
918}
919
f1cb2d48
NC
920PP(pp_ftzero)
921{
922 return pp_ftrowned();
923}
924
925PP(pp_ftsock)
926{
927 return pp_ftrowned();
928}
929
930PP(pp_ftchr)
931{
932 return pp_ftrowned();
933}
934
935PP(pp_ftblk)
936{
937 return pp_ftrowned();
938}
939
940PP(pp_ftfile)
941{
942 return pp_ftrowned();
943}
944
945PP(pp_ftdir)
946{
947 return pp_ftrowned();
948}
949
950PP(pp_ftpipe)
951{
952 return pp_ftrowned();
953}
954
17ad201a
NC
955PP(pp_ftsuid)
956{
957 return pp_ftrowned();
958}
959
960PP(pp_ftsgid)
961{
962 return pp_ftrowned();
963}
964
965PP(pp_ftsvtx)
966{
967 return pp_ftrowned();
968}
969
605b9385
NC
970PP(pp_unlink)
971{
972 return pp_chown();
973}
974
975PP(pp_chmod)
976{
977 return pp_chown();
978}
979
980PP(pp_utime)
981{
982 return pp_chown();
983}
984
985PP(pp_kill)
986{
987 return pp_chown();
988}
989
ce6987d0
NC
990PP(pp_symlink)
991{
992 return pp_link();
993}
994
af9e49b4
NC
995PP(pp_ftrwrite)
996{
997 return pp_ftrread();
998}
999
1000PP(pp_ftrexec)
1001{
1002 return pp_ftrread();
1003}
1004
1005PP(pp_fteread)
1006{
1007 return pp_ftrread();
1008}
1009
1010PP(pp_ftewrite)
1011{
1012 return pp_ftrread();
1013}
1014
1015PP(pp_fteexec)
1016{
1017 return pp_ftrread();
1018}
1019
c9f7ac20
NC
1020PP(pp_msgsnd)
1021{
1022 return pp_shmwrite();
1023}
1024
1025PP(pp_msgrcv)
1026{
1027 return pp_shmwrite();
1028}
1029
64a1bc8e
NC
1030PP(pp_syswrite)
1031{
1032 return pp_send();
1033}
1034
ca563b4e
NC
1035PP(pp_semop)
1036{
1037 return pp_shmwrite();
1038}
1039
25a55bd7
SP
1040PP(pp_dor)
1041{
f6a64177 1042 return pp_defined();
25a55bd7
SP
1043}
1044
c960fc3b
SP
1045PP(pp_andassign)
1046{
1047 return pp_and();
1048}
1049
1050PP(pp_orassign)
1051{
1052 return pp_or();
1053}
1054
1055PP(pp_dorassign)
1056{
1057 return pp_defined();
1058}
1059
12e9c124
NC
1060PP(pp_lcfirst)
1061{
1062 return pp_ucfirst();
1063}
1064
afd9910b
NC
1065PP(pp_slt)
1066{
1067 return pp_sle();
1068}
1069
1070PP(pp_sgt)
1071{
1072 return pp_sle();
1073}
1074
1075PP(pp_sge)
1076{
1077 return pp_sle();
1078}
1079
2723d216
NC
1080PP(pp_rindex)
1081{
1082 return pp_index();
1083}
1084
daa2adfd
NC
1085PP(pp_hex)
1086{
1087 return pp_oct();
1088}
1089
789b4bc9
NC
1090PP(pp_pop)
1091{
1092 return pp_shift();
1093}
1094
71302fe3
NC
1095PP(pp_cos)
1096{
1097 return pp_sin();
1098}
1099
1100PP(pp_exp)
1101{
1102 return pp_sin();
1103}
1104
1105PP(pp_log)
1106{
1107 return pp_sin();
1108}
1109
1110PP(pp_sqrt)
1111{
1112 return pp_sin();
1113}
1114
3658c1f1
NC
1115PP(pp_bit_xor)
1116{
1117 return pp_bit_or();
1118}
1119
17ab7946
NC
1120PP(pp_rv2hv)
1121{
1122 return Perl_pp_rv2av(aTHX);
1123}
1124
038e8d3c
NC
1125U8 *
1126Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
1127{
7918f24d
NC
1128 PERL_ARGS_ASSERT_UVUNI_TO_UTF8;
1129
038e8d3c
NC
1130 return Perl_uvuni_to_utf8_flags(aTHX_ d, uv, 0);
1131}
1132
814fafa7
NC
1133bool
1134Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep)
1135{
7918f24d
NC
1136 PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC;
1137
814fafa7
NC
1138 return is_utf8_string_loclen(s, len, ep, 0);
1139}
1140
7ee2227d 1141/*
d5b2b27b
NC
1142=for apidoc sv_nolocking
1143
1144Dummy routine which "locks" an SV when there is no locking module present.
1145Exists to avoid test for a NULL function pointer and because it could
1146potentially warn under some level of strict-ness.
1147
1148"Superseded" by sv_nosharing().
1149
1150=cut
1151*/
1152
1153void
1154Perl_sv_nolocking(pTHX_ SV *sv)
1155{
96a5add6 1156 PERL_UNUSED_CONTEXT;
d5b2b27b
NC
1157 PERL_UNUSED_ARG(sv);
1158}
1159
1160
1161/*
1162=for apidoc sv_nounlocking
1163
1164Dummy routine which "unlocks" an SV when there is no locking module present.
1165Exists to avoid test for a NULL function pointer and because it could
1166potentially warn under some level of strict-ness.
1167
1168"Superseded" by sv_nosharing().
1169
1170=cut
1171*/
1172
1173void
1174Perl_sv_nounlocking(pTHX_ SV *sv)
1175{
96a5add6 1176 PERL_UNUSED_CONTEXT;
d5b2b27b
NC
1177 PERL_UNUSED_ARG(sv);
1178}
1179
2053acbf
NC
1180void
1181Perl_save_long(pTHX_ long int *longp)
1182{
1183 dVAR;
7918f24d
NC
1184
1185 PERL_ARGS_ASSERT_SAVE_LONG;
1186
2053acbf
NC
1187 SSCHECK(3);
1188 SSPUSHLONG(*longp);
1189 SSPUSHPTR(longp);
c6bf6a65 1190 SSPUSHUV(SAVEt_LONG);
2053acbf
NC
1191}
1192
1193void
2053acbf
NC
1194Perl_save_iv(pTHX_ IV *ivp)
1195{
1196 dVAR;
7918f24d
NC
1197
1198 PERL_ARGS_ASSERT_SAVE_IV;
1199
2053acbf
NC
1200 SSCHECK(3);
1201 SSPUSHIV(*ivp);
1202 SSPUSHPTR(ivp);
c6bf6a65 1203 SSPUSHUV(SAVEt_IV);
2053acbf
NC
1204}
1205
1206void
1207Perl_save_nogv(pTHX_ GV *gv)
1208{
1209 dVAR;
7918f24d
NC
1210
1211 PERL_ARGS_ASSERT_SAVE_NOGV;
1212
2053acbf
NC
1213 SSCHECK(2);
1214 SSPUSHPTR(gv);
c6bf6a65 1215 SSPUSHUV(SAVEt_NSTAB);
2053acbf
NC
1216}
1217
1218void
1219Perl_save_list(pTHX_ register SV **sarg, I32 maxsarg)
1220{
1221 dVAR;
1222 register I32 i;
1223
7918f24d
NC
1224 PERL_ARGS_ASSERT_SAVE_LIST;
1225
2053acbf
NC
1226 for (i = 1; i <= maxsarg; i++) {
1227 register SV * const sv = newSV(0);
1228 sv_setsv(sv,sarg[i]);
1229 SSCHECK(3);
1230 SSPUSHPTR(sarg[i]); /* remember the pointer */
1231 SSPUSHPTR(sv); /* remember the value */
c6bf6a65 1232 SSPUSHUV(SAVEt_ITEM);
2053acbf
NC
1233 }
1234}
1235
47518d95
NC
1236/*
1237=for apidoc sv_usepvn_mg
1238
1239Like C<sv_usepvn>, but also handles 'set' magic.
1240
1241=cut
1242*/
1243
1244void
1245Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len)
1246{
7918f24d
NC
1247 PERL_ARGS_ASSERT_SV_USEPVN_MG;
1248
47518d95
NC
1249 sv_usepvn_flags(sv,ptr,len, SV_SMAGIC);
1250}
1251
1252/*
1253=for apidoc sv_usepvn
1254
1255Tells an SV to use C<ptr> to find its string value. Implemented by
1256calling C<sv_usepvn_flags> with C<flags> of 0, hence does not handle 'set'
1257magic. See C<sv_usepvn_flags>.
1258
1259=cut
1260*/
1261
1262void
1263Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len)
1264{
7918f24d
NC
1265 PERL_ARGS_ASSERT_SV_USEPVN;
1266
47518d95
NC
1267 sv_usepvn_flags(sv,ptr,len, 0);
1268}
1269
c03e83bf
NC
1270/*
1271=for apidoc unpack_str
1272
1273The engine implementing unpack() Perl function. Note: parameters strbeg, new_s
1274and ocnt are not used. This call should not be used, use unpackstring instead.
1275
1276=cut */
1277
1278I32
1279Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s,
1280 const char *strbeg, const char *strend, char **new_s, I32 ocnt,
1281 U32 flags)
1282{
7918f24d
NC
1283 PERL_ARGS_ASSERT_UNPACK_STR;
1284
c03e83bf
NC
1285 PERL_UNUSED_ARG(strbeg);
1286 PERL_UNUSED_ARG(new_s);
1287 PERL_UNUSED_ARG(ocnt);
1288
1289 return unpackstring(pat, patend, s, strend, flags);
1290}
b47163a2
NC
1291
1292/*
1293=for apidoc pack_cat
1294
1295The engine implementing pack() Perl function. Note: parameters next_in_list and
1296flags are not used. This call should not be used; use packlist instead.
1297
1298=cut
1299*/
1300
1301void
1302Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, register SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
1303{
7918f24d
NC
1304 PERL_ARGS_ASSERT_PACK_CAT;
1305
b47163a2
NC
1306 PERL_UNUSED_ARG(next_in_list);
1307 PERL_UNUSED_ARG(flags);
1308
1309 packlist(cat, pat, patend, beglist, endlist);
1310}
4c2df08c
NC
1311
1312HE *
1313Perl_hv_store_ent(pTHX_ HV *hv, SV *keysv, SV *val, U32 hash)
1314{
59af68cc 1315 return (HE *)hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISSTORE, val, hash);
4c2df08c
NC
1316}
1317
1318bool
1319Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
1320{
7918f24d
NC
1321 PERL_ARGS_ASSERT_HV_EXISTS_ENT;
1322
4c2df08c
NC
1323 return hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISEXISTS, 0, hash)
1324 ? TRUE : FALSE;
1325}
1326
1327HE *
1328Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash)
1329{
7918f24d
NC
1330 PERL_ARGS_ASSERT_HV_FETCH_ENT;
1331
59af68cc 1332 return (HE *)hv_common(hv, keysv, NULL, 0, 0,
4c2df08c
NC
1333 (lval ? HV_FETCH_LVALUE : 0), NULL, hash);
1334}
1335
1336SV *
1337Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash)
1338{
7918f24d
NC
1339 PERL_ARGS_ASSERT_HV_DELETE_ENT;
1340
ad64d0ec
NC
1341 return MUTABLE_SV(hv_common(hv, keysv, NULL, 0, 0, flags | HV_DELETE, NULL,
1342 hash));
4c2df08c
NC
1343}
1344
a038e571
NC
1345SV**
1346Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash,
1347 int flags)
1348{
1349 return (SV**) hv_common(hv, NULL, key, klen, flags,
1350 (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
1351}
1352
1353SV**
1354Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen_i32, SV *val, U32 hash)
1355{
1356 STRLEN klen;
1357 int flags;
1358
1359 if (klen_i32 < 0) {
1360 klen = -klen_i32;
1361 flags = HVhek_UTF8;
1362 } else {
1363 klen = klen_i32;
1364 flags = 0;
1365 }
1366 return (SV **) hv_common(hv, NULL, key, klen, flags,
1367 (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
1368}
1369
1370bool
1371Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen_i32)
1372{
1373 STRLEN klen;
1374 int flags;
1375
7918f24d
NC
1376 PERL_ARGS_ASSERT_HV_EXISTS;
1377
a038e571
NC
1378 if (klen_i32 < 0) {
1379 klen = -klen_i32;
1380 flags = HVhek_UTF8;
1381 } else {
1382 klen = klen_i32;
1383 flags = 0;
1384 }
1385 return hv_common(hv, NULL, key, klen, flags, HV_FETCH_ISEXISTS, 0, 0)
1386 ? TRUE : FALSE;
1387}
1388
1389SV**
1390Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 lval)
1391{
1392 STRLEN klen;
1393 int flags;
1394
7918f24d
NC
1395 PERL_ARGS_ASSERT_HV_FETCH;
1396
a038e571
NC
1397 if (klen_i32 < 0) {
1398 klen = -klen_i32;
1399 flags = HVhek_UTF8;
1400 } else {
1401 klen = klen_i32;
1402 flags = 0;
1403 }
1404 return (SV **) hv_common(hv, NULL, key, klen, flags,
1405 lval ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE)
1406 : HV_FETCH_JUST_SV, NULL, 0);
1407}
1408
1409SV *
1410Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 flags)
1411{
1412 STRLEN klen;
1413 int k_flags;
1414
7918f24d
NC
1415 PERL_ARGS_ASSERT_HV_DELETE;
1416
a038e571
NC
1417 if (klen_i32 < 0) {
1418 klen = -klen_i32;
1419 k_flags = HVhek_UTF8;
1420 } else {
1421 klen = klen_i32;
1422 k_flags = 0;
1423 }
ad64d0ec
NC
1424 return MUTABLE_SV(hv_common(hv, NULL, key, klen, k_flags, flags | HV_DELETE,
1425 NULL, 0));
a038e571
NC
1426}
1427
56d7a086 1428/* Functions after here were made mathoms post 5.10.0 but pre 5.8.9 */
56d7a086 1429
ac572bf4
NC
1430AV *
1431Perl_newAV(pTHX)
1432{
502c6561 1433 return MUTABLE_AV(newSV_type(SVt_PVAV));
ac572bf4
NC
1434 /* sv_upgrade does AvREAL_only():
1435 AvALLOC(av) = 0;
1436 AvARRAY(av) = NULL;
1437 AvMAX(av) = AvFILLp(av) = -1; */
1438}
1439
78ac7dd9
NC
1440HV *
1441Perl_newHV(pTHX)
1442{
85fbaab2 1443 HV * const hv = MUTABLE_HV(newSV_type(SVt_PVHV));
78ac7dd9
NC
1444 assert(!SvOK(hv));
1445
1446 return hv;
1447}
1448
84335ee9
NC
1449void
1450Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len,
1451 const char *const little, const STRLEN littlelen)
1452{
1453 PERL_ARGS_ASSERT_SV_INSERT;
1454 sv_insert_flags(bigstr, offset, len, little, littlelen, SV_GMAGIC);
1455}
1456
2fd8beea
NC
1457void
1458Perl_save_freesv(pTHX_ SV *sv)
1459{
1460 dVAR;
1461 save_freesv(sv);
1462}
1463
1464void
1465Perl_save_mortalizesv(pTHX_ SV *sv)
1466{
1467 dVAR;
1468
1469 PERL_ARGS_ASSERT_SAVE_MORTALIZESV;
1470
1471 save_mortalizesv(sv);
1472}
1473
1474void
1475Perl_save_freeop(pTHX_ OP *o)
1476{
1477 dVAR;
1478 save_freeop(o);
1479}
1480
1481void
1482Perl_save_freepv(pTHX_ char *pv)
1483{
1484 dVAR;
1485 save_freepv(pv);
1486}
1487
1488void
1489Perl_save_op(pTHX)
1490{
1491 dVAR;
1492 save_op();
1493}
1494
d5713896
NC
1495#ifdef PERL_DONT_CREATE_GVSV
1496GV *
1497Perl_gv_SVadd(pTHX_ GV *gv)
1498{
d5713896
NC
1499 return gv_SVadd(gv);
1500}
1501#endif
1502
1503GV *
1504Perl_gv_AVadd(pTHX_ GV *gv)
1505{
d5713896
NC
1506 return gv_AVadd(gv);
1507}
1508
1509GV *
1510Perl_gv_HVadd(pTHX_ register GV *gv)
1511{
d5713896
NC
1512 return gv_HVadd(gv);
1513}
1514
bb85b28a
NC
1515GV *
1516Perl_gv_IOadd(pTHX_ register GV *gv)
1517{
1518 return gv_IOadd(gv);
1519}
1520
85dca89a
NC
1521IO *
1522Perl_newIO(pTHX)
1523{
1524 return MUTABLE_IO(newSV_type(SVt_PVIO));
1525}
1526
0d7d409d
DM
1527I32
1528Perl_my_stat(pTHX)
1529{
1530 return my_stat_flags(SV_GMAGIC);
1531}
1532
1533I32
1534Perl_my_lstat(pTHX)
1535{
1536 return my_lstat_flags(SV_GMAGIC);
1537}
1538
078504b2
FC
1539I32
1540Perl_sv_eq(pTHX_ register SV *sv1, register SV *sv2)
1541{
1542 return sv_eq_flags(sv1, sv2, SV_GMAGIC);
1543}
1544
1545char *
1546Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp)
1547{
1548 return sv_collxfrm_flags(sv, nxp, SV_GMAGIC);
1549}
1550
06c841cf
FC
1551bool
1552Perl_sv_2bool(pTHX_ register SV *const sv)
1553{
1554 return sv_2bool_flags(sv, SV_GMAGIC);
1555}
1556
1830b3d9 1557
9733086d
BM
1558/*
1559=for apidoc custom_op_name
1560Return the name for a given custom op. This was once used by the OP_NAME
1561macro, but is no longer: it has only been kept for compatibility, and
1562should not be used.
1563
1564=for apidoc custom_op_desc
1565Return the description of a given custom op. This was once used by the
1566OP_DESC macro, but is no longer: it has only been kept for
1567compatibility, and should not be used.
1568
1569=cut
1570*/
1571
1830b3d9
BM
1572const char*
1573Perl_custom_op_name(pTHX_ const OP* o)
1574{
1575 PERL_ARGS_ASSERT_CUSTOM_OP_NAME;
1576 return XopENTRY(Perl_custom_op_xop(aTHX_ o), xop_name);
1577}
1578
1579const char*
1580Perl_custom_op_desc(pTHX_ const OP* o)
1581{
1582 PERL_ARGS_ASSERT_CUSTOM_OP_DESC;
1583 return XopENTRY(Perl_custom_op_xop(aTHX_ o), xop_desc);
1584}
20fac488
GA
1585#endif /* NO_MATHOMS */
1586
d5b2b27b 1587/*
7ee2227d
SP
1588 * Local variables:
1589 * c-indentation-style: bsd
1590 * c-basic-offset: 4
1591 * indent-tabs-mode: t
1592 * End:
1593 *
1594 * ex: set ts=8 sts=4 sw=4 noet:
1595 */