/* mathoms.c
*
- * Copyright (C) 2005, by Larry Wall and others
+ * Copyright (C) 2005, 2006, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
* hand to hand were of that sort."
*/
+#ifndef NO_MATHOMS
+
/*
* This file contains mathoms, various binary artifacts from previous
* versions of Perl. For binary or source compatibility reasons, though,
return doref(o, type, TRUE);
}
+/*
+=for apidoc sv_unref
+
+Unsets the RV status of the SV, and decrements the reference count of
+whatever was being referenced by the RV. This can almost be thought of
+as a reversal of C<newSVrv>. This is C<sv_unref_flags> with the C<flag>
+being zero. See C<SvROK_off>.
+
+=cut
+*/
+
+void
+Perl_sv_unref(pTHX_ SV *sv)
+{
+ sv_unref_flags(sv, 0);
+}
+
+/*
+=for apidoc sv_taint
+
+Taint an SV. Use C<SvTAINTED_on> instead.
+=cut
+*/
+
+void
+Perl_sv_taint(pTHX_ SV *sv)
+{
+ sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0);
+}
+
/* sv_2iv() is now a macro using Perl_sv_2iv_flags();
* this function provided for binary compatibility only
*/
return sv_2pv_flags(sv, lp, SV_GMAGIC);
}
+/*
+=for apidoc sv_2pv_nolen
+
+Like C<sv_2pv()>, but doesn't return the length too. You should usually
+use the macro wrapper C<SvPV_nolen(sv)> instead.
+=cut
+*/
+
+char *
+Perl_sv_2pv_nolen(pTHX_ register SV *sv)
+{
+ return sv_2pv(sv, 0);
+}
+
+/*
+=for apidoc sv_2pvbyte_nolen
+
+Return a pointer to the byte-encoded representation of the SV.
+May cause the SV to be downgraded from UTF-8 as a side-effect.
+
+Usually accessed via the C<SvPVbyte_nolen> macro.
+
+=cut
+*/
+
+char *
+Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv)
+{
+ return sv_2pvbyte(sv, 0);
+}
+
+/*
+=for apidoc sv_2pvutf8_nolen
+
+Return a pointer to the UTF-8-encoded representation of the SV.
+May cause the SV to be upgraded to UTF-8 as a side-effect.
+
+Usually accessed via the C<SvPVutf8_nolen> macro.
+
+=cut
+*/
+
+char *
+Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv)
+{
+ return sv_2pvutf8(sv, 0);
+}
+
+/*
+=for apidoc sv_force_normal
+
+Undo various types of fakery on an SV: if the PV is a shared string, make
+a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
+an xpvmg. See also C<sv_force_normal_flags>.
+
+=cut
+*/
+
+void
+Perl_sv_force_normal(pTHX_ register SV *sv)
+{
+ sv_force_normal_flags(sv, 0);
+}
/* sv_setsv() is now a macro using Perl_sv_setsv_flags();
* this function provided for binary compatibility only
sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC);
}
+/*
+=for apidoc sv_catpvn_mg
+
+Like C<sv_catpvn>, but also handles 'set' magic.
+
+=cut
+*/
+
+void
+Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
+{
+ sv_catpvn_flags(sv,ptr,len,SV_GMAGIC|SV_SMAGIC);
+}
+
/* sv_catsv() is now a macro using Perl_sv_catsv_flags();
* this function provided for binary compatibility only
*/
sv_catsv_flags(dstr, sstr, SV_GMAGIC);
}
+/*
+=for apidoc sv_catsv_mg
+
+Like C<sv_catsv>, but also handles 'set' magic.
+
+=cut
+*/
+
+void
+Perl_sv_catsv_mg(pTHX_ SV *dsv, register SV *ssv)
+{
+ sv_catsv_flags(dsv,ssv,SV_GMAGIC|SV_SMAGIC);
+}
+
+/*
+=for apidoc sv_iv
+
+A private implementation of the C<SvIVx> macro for compilers which can't
+cope with complex macro expressions. Always use the macro instead.
+
+=cut
+*/
+
+IV
+Perl_sv_iv(pTHX_ register SV *sv)
+{
+ if (SvIOK(sv)) {
+ if (SvIsUV(sv))
+ return (IV)SvUVX(sv);
+ return SvIVX(sv);
+ }
+ return sv_2iv(sv);
+}
+
+/*
+=for apidoc sv_uv
+
+A private implementation of the C<SvUVx> macro for compilers which can't
+cope with complex macro expressions. Always use the macro instead.
+
+=cut
+*/
+
+UV
+Perl_sv_uv(pTHX_ register SV *sv)
+{
+ if (SvIOK(sv)) {
+ if (SvIsUV(sv))
+ return SvUVX(sv);
+ return (UV)SvIVX(sv);
+ }
+ return sv_2uv(sv);
+}
+
+/*
+=for apidoc sv_nv
+
+A private implementation of the C<SvNVx> macro for compilers which can't
+cope with complex macro expressions. Always use the macro instead.
+
+=cut
+*/
+
+NV
+Perl_sv_nv(pTHX_ register SV *sv)
+{
+ if (SvNOK(sv))
+ return SvNVX(sv);
+ return sv_2nv(sv);
+}
+
+/*
+=for apidoc sv_pv
+
+Use the C<SvPV_nolen> macro instead
+
+=for apidoc sv_pvn
+
+A private implementation of the C<SvPV> macro for compilers which can't
+cope with complex macro expressions. Always use the macro instead.
+
+=cut
+*/
+
+char *
+Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp)
+{
+ if (SvPOK(sv)) {
+ *lp = SvCUR(sv);
+ return SvPVX(sv);
+ }
+ return sv_2pv(sv, lp);
+}
+
+
+char *
+Perl_sv_pvn_nomg(pTHX_ register SV *sv, STRLEN *lp)
+{
+ if (SvPOK(sv)) {
+ *lp = SvCUR(sv);
+ return SvPVX(sv);
+ }
+ return sv_2pv_flags(sv, lp, 0);
+}
+
/* sv_pv() is now a macro using SvPV_nolen();
* this function provided for binary compatibility only
*/
return sv_pv(sv);
}
+/*
+=for apidoc sv_pvbyte
+
+Use C<SvPVbyte_nolen> instead.
+
+=for apidoc sv_pvbyten
+
+A private implementation of the C<SvPVbyte> macro for compilers
+which can't cope with complex macro expressions. Always use the macro
+instead.
+
+=cut
+*/
+
+char *
+Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp)
+{
+ sv_utf8_downgrade(sv,0);
+ return sv_pvn(sv,lp);
+}
+
/* sv_pvutf8 () is now a macro using Perl_sv_2pv_flags();
* this function provided for binary compatibility only
*/
}
/*
-=for apidoc A|U8 *|uvchr_to_utf8|U8 *d|UV uv
-
-Adds the UTF-8 representation of the Native codepoint C<uv> to the end
-of the string C<d>; C<d> should be have at least C<UTF8_MAXBYTES+1> free
-bytes available. The return value is the pointer to the byte after the
-end of the new character. In other words,
+=for apidoc sv_pvutf8
- d = uvchr_to_utf8(d, uv);
+Use the C<SvPVutf8_nolen> macro instead
-is the recommended wide native character-aware way of saying
+=for apidoc sv_pvutf8n
- *(d++) = uv;
+A private implementation of the C<SvPVutf8> macro for compilers
+which can't cope with complex macro expressions. Always use the macro
+instead.
=cut
*/
-/* On ASCII machines this is normally a macro but we want a
- real function in case XS code wants it
-*/
-#undef Perl_uvchr_to_utf8
-U8 *
-Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv)
+char *
+Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp)
{
- return Perl_uvuni_to_utf8_flags(aTHX_ d, NATIVE_TO_UNI(uv), 0);
+ sv_utf8_upgrade(sv);
+ return sv_pvn(sv,lp);
}
+/* sv_utf8_upgrade() is now a macro using sv_utf8_upgrade_flags();
+ * this function provided for binary compatibility only
+ */
-/*
-=for apidoc A|UV|utf8n_to_uvchr|U8 *s|STRLEN curlen|STRLEN *retlen|U32
-flags
-
-Returns the native character value of the first character in the string
-C<s>
-which is assumed to be in UTF-8 encoding; C<retlen> will be set to the
-length, in bytes, of that character.
-
-Allows length and flags to be passed to low level routine.
-
-=cut
-*/
-/* On ASCII machines this is normally a macro but we want
- a real function in case XS code wants it
-*/
-#undef Perl_utf8n_to_uvchr
-UV
-Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen,
-U32 flags)
+STRLEN
+Perl_sv_utf8_upgrade(pTHX_ register SV *sv)
{
- const UV uv = Perl_utf8n_to_uvuni(aTHX_ s, curlen, retlen, flags);
- return UNI_TO_NATIVE(uv);
+ return sv_utf8_upgrade_flags(sv, SV_GMAGIC);
}
+
int
Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...)
{
NV
Perl_huge(void)
{
-# if defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)
+# if defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)
return HUGE_VALL;
-# endif
- return HUGE_VAL;
-}
-#endif
-
-#ifndef USE_SFIO
-int
-perlsio_binmode(FILE *fp, int iotype, int mode)
-{
- /*
- * This used to be contents of do_binmode in doio.c
- */
-#ifdef DOSISH
-# if defined(atarist) || defined(__MINT__)
- if (!fflush(fp)) {
- if (mode & O_BINARY)
- ((FILE *) fp)->_flag |= _IOBIN;
- else
- ((FILE *) fp)->_flag &= ~_IOBIN;
- return 1;
- }
- return 0;
-# else
- dTHX;
-#ifdef NETWARE
- if (PerlLIO_setmode(fp, mode) != -1) {
-#else
- if (PerlLIO_setmode(fileno(fp), mode) != -1) {
-#endif
-# if defined(WIN32) && defined(__BORLANDC__)
- /*
- * The translation mode of the stream is maintained independent
-of
- * the translation mode of the fd in the Borland RTL (heavy
- * digging through their runtime sources reveal). User has to
-set
- * the mode explicitly for the stream (though they don't
-document
- * this anywhere). GSAR 97-5-24
- */
- fseek(fp, 0L, 0);
- if (mode & O_BINARY)
- fp->flags |= _F_BIN;
- else
- fp->flags &= ~_F_BIN;
-# endif
- return 1;
- }
- else
- return 0;
-# endif
-#else
-# if defined(USEMYBINMODE)
- dTHX;
- if (my_binmode(fp, iotype, mode) != FALSE)
- return 1;
- else
- return 0;
# else
- PERL_UNUSED_ARG(fp);
- PERL_UNUSED_ARG(iotype);
- PERL_UNUSED_ARG(mode);
- return 1;
+ return HUGE_VAL;
# endif
-#endif
}
-#endif /* sfio */
+#endif
/* compatibility with versions <= 5.003. */
void
}
/*
+=for apidoc gv_fetchmethod
+
+See L<gv_fetchmethod_autoload>.
+
+=cut
+*/
+
+GV *
+Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
+{
+ return gv_fetchmethod_autoload(stash, name, TRUE);
+}
+
+HE *
+Perl_hv_iternext(pTHX_ HV *hv)
+{
+ return hv_iternext_flags(hv, 0);
+}
+
+void
+Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how)
+{
+ sv_magic((SV*)hv, (SV*)gv, how, NULL, 0);
+}
+
+#if 0 /* use the macro from hv.h instead */
+
+char*
+Perl_sharepvn(pTHX_ const char *sv, I32 len, U32 hash)
+{
+ return HEK_KEY(share_hek(sv, len, hash));
+}
+
+#endif
+
+AV *
+Perl_av_fake(pTHX_ register I32 size, register SV **strp)
+{
+ register SV** ary;
+ register AV * const av = (AV*)newSV(0);
+
+ sv_upgrade((SV *)av, SVt_PVAV);
+ Newx(ary,size+1,SV*);
+ AvALLOC(av) = ary;
+ Copy(strp,ary,size,SV*);
+ AvREIFY_only(av);
+ SvPV_set(av, (char*)ary);
+ AvFILLp(av) = size - 1;
+ AvMAX(av) = size - 1;
+ while (size--) {
+ assert (*strp);
+ SvTEMP_off(*strp);
+ strp++;
+ }
+ return av;
+}
+
+bool
+Perl_do_open(pTHX_ GV *gv, register const char *name, I32 len, int as_raw,
+ int rawmode, int rawperm, PerlIO *supplied_fp)
+{
+ return do_openn(gv, name, len, as_raw, rawmode, rawperm,
+ supplied_fp, (SV **) NULL, 0);
+}
+
+bool
+Perl_do_open9(pTHX_ GV *gv, register const char *name, I32 len, int
+as_raw,
+ int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs,
+ I32 num_svs)
+{
+ PERL_UNUSED_ARG(num_svs);
+ return do_openn(gv, name, len, as_raw, rawmode, rawperm,
+ supplied_fp, &svs, 1);
+}
+
+int
+Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
+{
+ /* The old body of this is now in non-LAYER part of perlio.c
+ * This is a stub for any XS code which might have been calling it.
+ */
+ const char *name = ":raw";
+#ifdef PERLIO_USING_CRLF
+ if (!(mode & O_BINARY))
+ name = ":crlf";
+#endif
+ return PerlIO_binmode(aTHX_ fp, iotype, mode, name);
+}
+
+#ifndef OS2
+bool
+Perl_do_aexec(pTHX_ SV *really, register SV **mark, register SV **sp)
+{
+ return do_aexec5(really, mark, sp, 0, 0);
+}
+#endif
+
+#ifdef PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION
+bool
+Perl_do_exec(pTHX_ const char *cmd)
+{
+ return do_exec3(cmd,0,0);
+}
+#endif
+
+#ifdef HAS_PIPE
+void
+Perl_do_pipe(pTHX_ SV *sv, GV *rgv, GV *wgv)
+{
+ dVAR;
+ register IO *rstio;
+ register IO *wstio;
+ int fd[2];
+
+ if (!rgv)
+ goto badexit;
+ if (!wgv)
+ goto badexit;
+
+ rstio = GvIOn(rgv);
+ wstio = GvIOn(wgv);
+
+ if (IoIFP(rstio))
+ do_close(rgv,FALSE);
+ if (IoIFP(wstio))
+ do_close(wgv,FALSE);
+
+ if (PerlProc_pipe(fd) < 0)
+ goto badexit;
+ IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPE_OPEN_MODE);
+ IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPE_OPEN_MODE);
+ IoOFP(rstio) = IoIFP(rstio);
+ IoIFP(wstio) = IoOFP(wstio);
+ IoTYPE(rstio) = IoTYPE_RDONLY;
+ IoTYPE(wstio) = IoTYPE_WRONLY;
+ if (!IoIFP(rstio) || !IoOFP(wstio)) {
+ if (IoIFP(rstio)) PerlIO_close(IoIFP(rstio));
+ else PerlLIO_close(fd[0]);
+ if (IoOFP(wstio)) PerlIO_close(IoOFP(wstio));
+ else PerlLIO_close(fd[1]);
+ goto badexit;
+ }
+
+ sv_setsv(sv,&PL_sv_yes);
+ return;
+
+badexit:
+ sv_setsv(sv,&PL_sv_undef);
+ return;
+}
+#endif
+
+/* Backwards compatibility. */
+int
+Perl_init_i18nl14n(pTHX_ int printwarn)
+{
+ return init_i18nl10n(printwarn);
+}
+
+/* XXX kept for BINCOMPAT only */
+void
+Perl_save_hints(pTHX)
+{
+ Perl_croak(aTHX_ "internal error: obsolete function save_hints() called");
+}
+
+#if 0
+OP *
+Perl_ck_retarget(pTHX_ OP *o)
+{
+ Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
+ /* STUB */
+ return o;
+}
+#endif
+
+OP *
+Perl_oopsCV(pTHX_ OP *o)
+{
+ Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
+ /* STUB */
+ PERL_UNUSED_ARG(o);
+ NORETURN_FUNCTION_END;
+}
+
+PP(pp_padany)
+{
+ DIE(aTHX_ "NOT IMPL LINE %d",__LINE__);
+}
+
+PP(pp_threadsv)
+{
+ DIE(aTHX_ "tried to access per-thread data in non-threaded perl");
+}
+
+PP(pp_mapstart)
+{
+ DIE(aTHX_ "panic: mapstart"); /* uses grepstart */
+}
+
+/* These ops all have the same body as pp_null. */
+PP(pp_scalar)
+{
+ dVAR;
+ return NORMAL;
+}
+
+PP(pp_regcmaybe)
+{
+ dVAR;
+ return NORMAL;
+}
+
+PP(pp_lineseq)
+{
+ dVAR;
+ return NORMAL;
+}
+
+PP(pp_scope)
+{
+ dVAR;
+ return NORMAL;
+}
+
+/* Ops that are calls to do_kv. */
+PP(pp_values)
+{
+ return do_kv();
+}
+
+PP(pp_keys)
+{
+ return do_kv();
+}
+
+/* Ops that are simply calls to other ops. */
+PP(pp_dump)
+{
+ return pp_goto();
+ /*NOTREACHED*/
+}
+
+PP(pp_dofile)
+{
+ return pp_require();
+}
+
+PP(pp_dbmclose)
+{
+ return pp_untie();
+}
+
+PP(pp_read)
+{
+ return pp_sysread();
+}
+
+PP(pp_recv)
+{
+ return pp_sysread();
+}
+
+PP(pp_seek)
+{
+ return pp_sysseek();
+}
+
+PP(pp_fcntl)
+{
+ return pp_ioctl();
+}
+
+PP(pp_gsockopt)
+{
+ return pp_ssockopt();
+}
+
+PP(pp_getsockname)
+{
+ return pp_getpeername();
+}
+
+PP(pp_lstat)
+{
+ return pp_stat();
+}
+
+PP(pp_fteowned)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftbinary)
+{
+ return pp_fttext();
+}
+
+PP(pp_localtime)
+{
+ return pp_gmtime();
+}
+
+PP(pp_shmget)
+{
+ return pp_semget();
+}
+
+PP(pp_shmctl)
+{
+ return pp_semctl();
+}
+
+PP(pp_shmread)
+{
+ return pp_shmwrite();
+}
+
+PP(pp_msgget)
+{
+ return pp_semget();
+}
+
+PP(pp_msgctl)
+{
+ return pp_semctl();
+}
+
+PP(pp_ghbyname)
+{
+ return pp_ghostent();
+}
+
+PP(pp_ghbyaddr)
+{
+ return pp_ghostent();
+}
+
+PP(pp_gnbyname)
+{
+ return pp_gnetent();
+}
+
+PP(pp_gnbyaddr)
+{
+ return pp_gnetent();
+}
+
+PP(pp_gpbyname)
+{
+ return pp_gprotoent();
+}
+
+PP(pp_gpbynumber)
+{
+ return pp_gprotoent();
+}
+
+PP(pp_gsbyname)
+{
+ return pp_gservent();
+}
+
+PP(pp_gsbyport)
+{
+ return pp_gservent();
+}
+
+PP(pp_gpwnam)
+{
+ return pp_gpwent();
+}
+
+PP(pp_gpwuid)
+{
+ return pp_gpwent();
+}
+
+PP(pp_ggrnam)
+{
+ return pp_ggrent();
+}
+
+PP(pp_ggrgid)
+{
+ return pp_ggrent();
+}
+
+PP(pp_ftsize)
+{
+ return pp_ftis();
+}
+
+PP(pp_ftmtime)
+{
+ return pp_ftis();
+}
+
+PP(pp_ftatime)
+{
+ return pp_ftis();
+}
+
+PP(pp_ftctime)
+{
+ return pp_ftis();
+}
+
+PP(pp_ftzero)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftsock)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftchr)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftblk)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftfile)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftdir)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftpipe)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftsuid)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftsgid)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_ftsvtx)
+{
+ return pp_ftrowned();
+}
+
+PP(pp_unlink)
+{
+ return pp_chown();
+}
+
+PP(pp_chmod)
+{
+ return pp_chown();
+}
+
+PP(pp_utime)
+{
+ return pp_chown();
+}
+
+PP(pp_kill)
+{
+ return pp_chown();
+}
+
+PP(pp_symlink)
+{
+ return pp_link();
+}
+
+PP(pp_ftrwrite)
+{
+ return pp_ftrread();
+}
+
+PP(pp_ftrexec)
+{
+ return pp_ftrread();
+}
+
+PP(pp_fteread)
+{
+ return pp_ftrread();
+}
+
+PP(pp_ftewrite)
+{
+ return pp_ftrread();
+}
+
+PP(pp_fteexec)
+{
+ return pp_ftrread();
+}
+
+PP(pp_msgsnd)
+{
+ return pp_shmwrite();
+}
+
+PP(pp_msgrcv)
+{
+ return pp_shmwrite();
+}
+
+PP(pp_syswrite)
+{
+ return pp_send();
+}
+
+PP(pp_semop)
+{
+ return pp_shmwrite();
+}
+
+PP(pp_dor)
+{
+ return pp_defined();
+}
+
+PP(pp_andassign)
+{
+ return pp_and();
+}
+
+PP(pp_orassign)
+{
+ return pp_or();
+}
+
+PP(pp_dorassign)
+{
+ return pp_defined();
+}
+
+PP(pp_lcfirst)
+{
+ return pp_ucfirst();
+}
+
+PP(pp_slt)
+{
+ return pp_sle();
+}
+
+PP(pp_sgt)
+{
+ return pp_sle();
+}
+
+PP(pp_sge)
+{
+ return pp_sle();
+}
+
+PP(pp_rindex)
+{
+ return pp_index();
+}
+
+PP(pp_hex)
+{
+ return pp_oct();
+}
+
+PP(pp_pop)
+{
+ return pp_shift();
+}
+
+PP(pp_cos)
+{
+ return pp_sin();
+}
+
+PP(pp_exp)
+{
+ return pp_sin();
+}
+
+PP(pp_log)
+{
+ return pp_sin();
+}
+
+PP(pp_sqrt)
+{
+ return pp_sin();
+}
+
+PP(pp_bit_xor)
+{
+ return pp_bit_or();
+}
+
+U8 *
+Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
+{
+ return Perl_uvuni_to_utf8_flags(aTHX_ d, uv, 0);
+}
+
+bool
+Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep)
+{
+ return is_utf8_string_loclen(s, len, ep, 0);
+}
+
+/*
+=for apidoc sv_nolocking
+
+Dummy routine which "locks" an SV when there is no locking module present.
+Exists to avoid test for a NULL function pointer and because it could
+potentially warn under some level of strict-ness.
+
+"Superseded" by sv_nosharing().
+
+=cut
+*/
+
+void
+Perl_sv_nolocking(pTHX_ SV *sv)
+{
+ PERL_UNUSED_CONTEXT;
+ PERL_UNUSED_ARG(sv);
+}
+
+
+/*
+=for apidoc sv_nounlocking
+
+Dummy routine which "unlocks" an SV when there is no locking module present.
+Exists to avoid test for a NULL function pointer and because it could
+potentially warn under some level of strict-ness.
+
+"Superseded" by sv_nosharing().
+
+=cut
+*/
+
+void
+Perl_sv_nounlocking(pTHX_ SV *sv)
+{
+ PERL_UNUSED_CONTEXT;
+ PERL_UNUSED_ARG(sv);
+}
+
+void
+Perl_save_long(pTHX_ long int *longp)
+{
+ dVAR;
+ SSCHECK(3);
+ SSPUSHLONG(*longp);
+ SSPUSHPTR(longp);
+ SSPUSHINT(SAVEt_LONG);
+}
+
+void
+Perl_save_I16(pTHX_ I16 *intp)
+{
+ dVAR;
+ SSCHECK(3);
+ SSPUSHINT(*intp);
+ SSPUSHPTR(intp);
+ SSPUSHINT(SAVEt_I16);
+}
+
+void
+Perl_save_I8(pTHX_ I8 *bytep)
+{
+ dVAR;
+ SSCHECK(3);
+ SSPUSHINT(*bytep);
+ SSPUSHPTR(bytep);
+ SSPUSHINT(SAVEt_I8);
+}
+
+void
+Perl_save_iv(pTHX_ IV *ivp)
+{
+ dVAR;
+ SSCHECK(3);
+ SSPUSHIV(*ivp);
+ SSPUSHPTR(ivp);
+ SSPUSHINT(SAVEt_IV);
+}
+
+void
+Perl_save_nogv(pTHX_ GV *gv)
+{
+ dVAR;
+ SSCHECK(2);
+ SSPUSHPTR(gv);
+ SSPUSHINT(SAVEt_NSTAB);
+}
+
+void
+Perl_save_list(pTHX_ register SV **sarg, I32 maxsarg)
+{
+ dVAR;
+ register I32 i;
+
+ for (i = 1; i <= maxsarg; i++) {
+ register SV * const sv = newSV(0);
+ sv_setsv(sv,sarg[i]);
+ SSCHECK(3);
+ SSPUSHPTR(sarg[i]); /* remember the pointer */
+ SSPUSHPTR(sv); /* remember the value */
+ SSPUSHINT(SAVEt_ITEM);
+ }
+}
+
+void
+Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p)
+{
+ dVAR;
+ SSCHECK(3);
+ SSPUSHDPTR(f);
+ SSPUSHPTR(p);
+ SSPUSHINT(SAVEt_DESTRUCTOR);
+}
+
+#endif /* NO_MATHOMS */
+
+/*
* Local variables:
* c-indentation-style: bsd
* c-basic-offset: 4