*/
Malloc_t
-Perl_safesysmalloc(pTHX_ MEM_SIZE size)
+Perl_safesysmalloc(MEM_SIZE size)
{
Malloc_t ptr;
#ifdef HAS_64K_LIMIT
if (size > 0xffff) {
PerlIO_printf(PerlIO_stderr(), "Allocation too large: %lx\n", size) FLUSH;
- my_exit(1);
+ WITH_THX(my_exit(1));
}
#endif /* HAS_64K_LIMIT */
#ifdef DEBUGGING
if ((long)size < 0)
- croak("panic: malloc");
+ Perl_croak_nocontext("panic: malloc");
#endif
ptr = PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
#if !(defined(I286) || defined(atarist))
return Nullch;
else {
PerlIO_puts(PerlIO_stderr(),PL_no_mem) FLUSH;
- my_exit(1);
+ WITH_THX(my_exit(1));
return Nullch;
}
/*NOTREACHED*/
/* paranoid version of system's realloc() */
Malloc_t
-Perl_safesysrealloc(pTHX_ Malloc_t where,MEM_SIZE size)
+Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
{
Malloc_t ptr;
#if !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE)
if (size > 0xffff) {
PerlIO_printf(PerlIO_stderr(),
"Reallocation too large: %lx\n", size) FLUSH;
- my_exit(1);
+ WITH_THX(my_exit(1));
}
#endif /* HAS_64K_LIMIT */
if (!size) {
return safesysmalloc(size);
#ifdef DEBUGGING
if ((long)size < 0)
- croak("panic: realloc");
+ Perl_croak_nocontext("panic: realloc");
#endif
ptr = PerlMem_realloc(where,size);
return Nullch;
else {
PerlIO_puts(PerlIO_stderr(),PL_no_mem) FLUSH;
- my_exit(1);
+ WITH_THX(my_exit(1));
return Nullch;
}
/*NOTREACHED*/
/* safe version of system's free() */
Free_t
-Perl_safesysfree(pTHX_ Malloc_t where)
+Perl_safesysfree(Malloc_t where)
{
#if !(defined(I286) || defined(atarist))
DEBUG_m( PerlIO_printf(Perl_debug_log, "0x%x: (%05d) free\n",(char *) where,PL_an++));
/* safe version of system's calloc() */
Malloc_t
-Perl_safesyscalloc(pTHX_ MEM_SIZE count, MEM_SIZE size)
+Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
{
Malloc_t ptr;
if (size * count > 0xffff) {
PerlIO_printf(PerlIO_stderr(),
"Allocation too large: %lx\n", size * count) FLUSH;
- my_exit(1);
+ WITH_THX(my_exit(1));
}
#endif /* HAS_64K_LIMIT */
#ifdef DEBUGGING
if ((long)size < 0 || (long)count < 0)
- croak("panic: calloc");
+ Perl_croak_nocontext("panic: calloc");
#endif
size *= count;
ptr = PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
return Nullch;
else {
PerlIO_puts(PerlIO_stderr(),PL_no_mem) FLUSH;
- my_exit(1);
+ WITH_THX(my_exit(1));
return Nullch;
}
/*NOTREACHED*/
: ((size) - 1)/4))
Malloc_t
-Perl_safexmalloc(pTHX_ I32 x, MEM_SIZE size)
+Perl_safexmalloc(I32 x, MEM_SIZE size)
{
register char* where = (char*)safemalloc(size + ALIGN);
}
Malloc_t
-Perl_safexrealloc(pTHX_ Malloc_t wh, MEM_SIZE size)
+Perl_safexrealloc(Malloc_t wh, MEM_SIZE size)
{
char *where = (char*)wh;
}
void
-Perl_safexfree(pTHX_ Malloc_t wh)
+Perl_safexfree(Malloc_t wh)
{
I32 x;
char *where = (char*)wh;
}
Malloc_t
-Perl_safexcalloc(pTHX_ I32 x,MEM_SIZE count, MEM_SIZE size)
+Perl_safexcalloc(I32 x,MEM_SIZE count, MEM_SIZE size)
{
register char * where = (char*)safexmalloc(x, size * count + ALIGN);
xcount[x] += size;
}
STATIC void
-xstat(pTHX_ int flag)
+S_xstat(pTHX_ int flag)
{
register I32 i, j, total = 0;
I32 subtot[MAXYCOUNT];
Size_t fb = strxfrm(xbuf, "ab", XFRMBUFSIZE);
SSize_t mult = fb - fa;
if (mult < 1)
- croak("strxfrm() gets absurd");
+ Perl_croak(aTHX_ "strxfrm() gets absurd");
PL_collxfrm_base = (fa > mult) ? (fa - mult) : 0;
PL_collxfrm_mult = mult;
}
return newaddr;
}
-/* the SV for form() and mess() is not kept in an arena */
+/* the SV for Perl_form() and mess() is not kept in an arena */
STATIC SV *
-mess_alloc(pTHX)
+S_mess_alloc(pTHX)
{
dTHR;
SV *sv;
return sv;
}
+#ifdef PERL_IMPLICIT_CONTEXT
+char *
+Perl_form_nocontext(const char* pat, ...)
+{
+ dTHX;
+ SV *sv = mess_alloc();
+ va_list args;
+ va_start(args, pat);
+ sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+ va_end(args);
+ return SvPVX(sv);
+}
+#endif
+
char *
Perl_form(pTHX_ const char* pat, ...)
{
if (!SvCUR(sv) || *(SvEND(sv) - 1) != '\n') {
dTHR;
if (PL_curcop->cop_line)
- sv_catpvf(sv, " at %_ line %ld",
+ Perl_sv_catpvf(aTHX_ sv, " at %_ line %ld",
GvSV(PL_curcop->cop_filegv), (long)PL_curcop->cop_line);
if (GvIO(PL_last_in_gv) && IoLINES(GvIOp(PL_last_in_gv))) {
bool line_mode = (RsSIMPLE(PL_rs) &&
SvCUR(PL_rs) == 1 && *SvPVX(PL_rs) == '\n');
- sv_catpvf(sv, ", <%s> %s %ld",
+ Perl_sv_catpvf(aTHX_ sv, ", <%s> %s %ld",
PL_last_in_gv == PL_argvgv ? "" : GvNAME(PL_last_in_gv),
line_mode ? "line" : "chunk",
(long)IoLINES(GvIOp(PL_last_in_gv)));
return sv;
}
-OP *
-Perl_die(pTHX_ const char* pat, ...)
+static OP *
+do_die(pTHX_ const char* pat, va_list *args)
{
dTHR;
- va_list args;
char *message;
int was_in_eval = PL_in_eval;
HV *stash;
"%p: die: curstack = %p, mainstack = %p\n",
thr, PL_curstack, PL_mainstack));
- va_start(args, pat);
if (pat) {
- msv = mess(pat, &args);
+ msv = mess(pat, args);
message = SvPV(msv,msglen);
}
else {
message = Nullch;
}
- va_end(args);
DEBUG_S(PerlIO_printf(PerlIO_stderr(),
"%p: die: message = %s\ndiehook = %p\n",
thr, message, PL_diehook));
if (PL_diehook) {
- /* sv_2cv might call croak() */
+ /* sv_2cv might call Perl_croak() */
SV *olddiehook = PL_diehook;
ENTER;
SAVESPTR(PL_diehook);
return PL_restartop;
}
-void
-Perl_croak(pTHX_ const char* pat, ...)
+#ifdef PERL_IMPLICIT_CONTEXT
+OP *
+Perl_die_nocontext(const char* pat, ...)
{
- dTHR;
+ dTHX;
+ OP *o;
va_list args;
+ va_start(args, pat);
+ o = do_die(aTHX_ pat, &args);
+ va_end(args);
+ return o;
+}
+#endif
+
+OP *
+Perl_die(pTHX_ const char* pat, ...)
+{
+ OP *o;
+ va_list args;
+ va_start(args, pat);
+ o = do_die(aTHX_ pat, &args);
+ va_end(args);
+ return o;
+}
+
+STATIC void
+S_do_croak(pTHX_ const char* pat, va_list *args)
+{
+ dTHR;
char *message;
HV *stash;
GV *gv;
SV *msv;
STRLEN msglen;
- va_start(args, pat);
- msv = mess(pat, &args);
+ msv = mess(pat, args);
message = SvPV(msv,msglen);
- va_end(args);
DEBUG_S(PerlIO_printf(PerlIO_stderr(), "croak: 0x%lx %s", (unsigned long) thr, message));
if (PL_diehook) {
- /* sv_2cv might call croak() */
+ /* sv_2cv might call Perl_croak() */
SV *olddiehook = PL_diehook;
ENTER;
SAVESPTR(PL_diehook);
my_failure_exit();
}
+#ifdef PERL_IMPLICIT_CONTEXT
void
-Perl_warn(pTHX_ const char* pat,...)
+Perl_croak_nocontext(const char *pat, ...)
{
+ dTHX;
va_list args;
+ va_start(args, pat);
+ do_croak(pat, &args);
+ /* NOTREACHED */
+ va_end(args);
+}
+#endif /* PERL_IMPLICIT_CONTEXT */
+
+void
+Perl_croak(pTHX_ const char *pat, ...)
+{
+ va_list args;
+ va_start(args, pat);
+ do_croak(pat, &args);
+ /* NOTREACHED */
+ va_end(args);
+}
+
+STATIC void
+S_do_warn(pTHX_ const char* pat, va_list *args)
+{
char *message;
HV *stash;
GV *gv;
SV *msv;
STRLEN msglen;
- va_start(args, pat);
- msv = mess(pat, &args);
+ msv = mess(pat, args);
message = SvPV(msv, msglen);
- va_end(args);
if (PL_warnhook) {
- /* sv_2cv might call warn() */
+ /* sv_2cv might call Perl_warn() */
dTHR;
SV *oldwarnhook = PL_warnhook;
ENTER;
(void)PerlIO_flush(PerlIO_stderr());
}
+#ifdef PERL_IMPLICIT_CONTEXT
+void
+Perl_warn_nocontext(const char *pat, ...)
+{
+ dTHX;
+ va_list args;
+ va_start(args, pat);
+ do_warn(pat, &args);
+ va_end(args);
+}
+#endif /* PERL_IMPLICIT_CONTEXT */
+
+void
+Perl_warn(pTHX_ const char *pat, ...)
+{
+ va_list args;
+ va_start(args, pat);
+ do_warn(pat, &args);
+ va_end(args);
+}
+
void
Perl_warner(pTHX_ U32 err, const char* pat,...)
{
DEBUG_S(PerlIO_printf(PerlIO_stderr(), "croak: 0x%lx %s", (unsigned long) thr, message));
#endif /* USE_THREADS */
if (PL_diehook) {
- /* sv_2cv might call croak() */
+ /* sv_2cv might call Perl_croak() */
SV *olddiehook = PL_diehook;
ENTER;
SAVESPTR(PL_diehook);
}
else {
if (PL_warnhook) {
- /* sv_2cv might call warn() */
+ /* sv_2cv might call Perl_warn() */
dTHR;
SV *oldwarnhook = PL_warnhook;
ENTER;
return u.result;
#else
#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
- croak("Unknown BYTEORDER\n");
+ Perl_croak(aTHX_ "Unknown BYTEORDER\n");
#else
register I32 o;
register I32 s;
return u.l;
#else
#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
- croak("Unknown BYTEORDER\n");
+ Perl_croak(aTHX_ "Unknown BYTEORDER\n");
#else
register I32 o;
register I32 s;
PerlLIO_close(pp[1]);
}
if (!doexec)
- croak("Can't fork");
+ Perl_croak(aTHX_ "Can't fork");
return Nullfp;
}
sleep(5);
}
if (n) { /* Error */
if (n != sizeof(int))
- croak("panic: kid popen errno read");
+ Perl_croak(aTHX_ "panic: kid popen errno read");
PerlLIO_close(pp[0]);
errno = errkid; /* Propagate errno from kid */
return Nullfp;
{
I32 result;
if (flags)
- croak("Can't do waitpid with flags");
+ Perl_croak(aTHX_ "Can't do waitpid with flags");
else {
while ((result = PerlProc_wait(statusp)) != pid && pid > 0 && result >= 0)
pidgone(result,*statusp);
while (len && *s >= '0' && *s <= '1') {
register UV n = retval << 1;
if (!overflowed && (n >> 1) != retval) {
- warn("Integer overflow in binary number");
+ Perl_warn(aTHX_ "Integer overflow in binary number");
overflowed = TRUE;
}
retval = n | (*s++ - '0');
if (len && (*s >= '2' && *s <= '9')) {
dTHR;
if (ckWARN(WARN_UNSAFE))
- warner(WARN_UNSAFE, "Illegal binary digit '%c' ignored", *s);
+ Perl_warner(aTHX_ WARN_UNSAFE, "Illegal binary digit '%c' ignored", *s);
}
*retlen = s - start;
return retval;
while (len && *s >= '0' && *s <= '7') {
register UV n = retval << 3;
if (!overflowed && (n >> 3) != retval) {
- warn("Integer overflow in octal number");
+ Perl_warn(aTHX_ "Integer overflow in octal number");
overflowed = TRUE;
}
retval = n | (*s++ - '0');
if (len && (*s == '8' || *s == '9')) {
dTHR;
if (ckWARN(WARN_OCTAL))
- warner(WARN_OCTAL, "Illegal octal digit '%c' ignored", *s);
+ Perl_warner(aTHX_ WARN_OCTAL, "Illegal octal digit '%c' ignored", *s);
}
*retlen = s - start;
return retval;
dTHR;
--s;
if (ckWARN(WARN_UNSAFE))
- warner(WARN_UNSAFE,"Illegal hex digit '%c' ignored", *s);
+ Perl_warner(aTHX_ WARN_UNSAFE,"Illegal hex digit '%c' ignored", *s);
break;
}
}
n = retval << 4;
if (!overflowed && (n >> 4) != retval) {
- warn("Integer overflow in hex number");
+ Perl_warn(aTHX_ "Integer overflow in hex number");
overflowed = TRUE;
}
retval = n | ((tmp - PL_hexdigit) & 15);
seen_dot = 1; /* Disable message. */
if (!xfound) {
if (flags & 1) { /* do or die? */
- croak("Can't %s %s%s%s",
+ Perl_croak(aTHX_ "Can't %s %s%s%s",
(xfailed ? "execute" : "find"),
(xfailed ? xfailed : scriptname),
(xfailed ? "" : " on PATH"),
perl_cond cond;
if (thr->i.next_run == thr)
- croak("panic: perl_cond_wait called by last runnable thread");
+ Perl_croak(aTHX_ "panic: perl_cond_wait called by last runnable thread");
New(666, cond, 1, struct perl_wait_queue);
cond->thread = thr;
pthread_addr_t t;
if (pthread_getspecific(PL_thr_key, &t))
- croak("panic: pthread_getspecific");
+ Perl_croak(aTHX_ "panic: pthread_getspecific");
return (struct perl_thread *) t;
}
#endif
struct perl_thread *
Perl_new_struct_thread(pTHX_ struct perl_thread *t)
{
+#ifndef PERL_IMPLICIT_CONTEXT
struct perl_thread *thr;
+#endif
SV *sv;
SV **svp;
I32 i;
Zero(thr, 1, struct perl_thread);
#endif
- PL_protect = FUNC_NAME_TO_PTR(default_protect);
+ PL_protect = FUNC_NAME_TO_PTR(Perl_default_protect);
thr->oursv = sv;
- init_stacks(ARGS);
+ init_stacks();
PL_curcop = &PL_compiling;
thr->cvcache = newHV();
PL_statname = NEWSV(66,0);
PL_maxscream = -1;
- PL_regcompp = FUNC_NAME_TO_PTR(pregcomp);
- PL_regexecp = FUNC_NAME_TO_PTR(regexec_flags);
+ PL_regcompp = FUNC_NAME_TO_PTR(Perl_pregcomp);
+ PL_regexecp = FUNC_NAME_TO_PTR(Perl_regexec_flags);
PL_regindent = 0;
PL_reginterp_cnt = 0;
PL_lastscream = Nullsv;
MUTEX_UNLOCK(&t->mutex);
#ifdef HAVE_THREAD_INTERN
- init_thread_intern(thr);
+ Perl_init_thread_intern(thr);
#endif /* HAVE_THREAD_INTERN */
return thr;
}
projects / p5sagit/p5-mst-13.2.git / blobdiff