/* util.c
*
- * Copyright (c) 1991-1997, Larry Wall
+ * Copyright (c) 1991-1999, Larry Wall
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
/* This routine was donated by Corey Satten. */
char *
-instr(register char *big, register char *little)
+instr(register const char *big, register const char *little)
{
- register char *s, *x;
+ register const char *s, *x;
register I32 first;
if (!little)
- return big;
+ return (char*)big;
first = *little++;
if (!first)
- return big;
+ return (char*)big;
while (*big) {
if (*big++ != first)
continue;
}
}
if (!*s)
- return big-1;
+ return (char*)(big-1);
}
return Nullch;
}
/* same as instr but allow embedded nulls */
char *
-ninstr(register char *big, register char *bigend, char *little, char *lend)
+ninstr(register const char *big, register const char *bigend, const char *little, const char *lend)
{
- register char *s, *x;
+ register const char *s, *x;
register I32 first = *little;
- register char *littleend = lend;
+ register const char *littleend = lend;
if (!first && little >= littleend)
- return big;
+ return (char*)big;
if (bigend - big < littleend - little)
return Nullch;
bigend -= littleend - little++;
}
}
if (s >= littleend)
- return big-1;
+ return (char*)(big-1);
}
return Nullch;
}
/* reverse of the above--find last substring */
char *
-rninstr(register char *big, char *bigend, char *little, char *lend)
+rninstr(register const char *big, const char *bigend, const char *little, const char *lend)
{
- register char *bigbeg;
- register char *s, *x;
+ register const char *bigbeg;
+ register const char *s, *x;
register I32 first = *little;
- register char *littleend = lend;
+ register const char *littleend = lend;
if (!first && little >= littleend)
- return bigend;
+ return (char*)bigend;
bigbeg = big;
big = bigend - (littleend - little++);
while (big >= bigbeg) {
}
}
if (s >= littleend)
- return big+1;
+ return (char*)(big+1);
}
return Nullch;
}
* Set up for a new ctype locale.
*/
void
-perl_new_ctype(char *newctype)
+perl_new_ctype(const char *newctype)
{
#ifdef USE_LOCALE_CTYPE
* Set up for a new collation locale.
*/
void
-perl_new_collate(char *newcoll)
+perl_new_collate(const char *newcoll)
{
#ifdef USE_LOCALE_COLLATE
* Set up for a new numeric locale.
*/
void
-perl_new_numeric(char *newnum)
+perl_new_numeric(const char *newnum)
{
#ifdef USE_LOCALE_NUMERIC
}
I32
-ibcmp(char *s1, char *s2, register I32 len)
+ibcmp(const char *s1, const char *s2, register I32 len)
{
register U8 *a = (U8 *)s1;
register U8 *b = (U8 *)s2;
}
I32
-ibcmp_locale(char *s1, char *s2, register I32 len)
+ibcmp_locale(const char *s1, const char *s2, register I32 len)
{
register U8 *a = (U8 *)s1;
register U8 *b = (U8 *)s2;
/* copy a string to a safe spot */
char *
-savepv(char *sv)
+savepv(const char *sv)
{
register char *newaddr;
/* same thing but with a known length */
char *
-savepvn(char *sv, register I32 len)
+savepvn(const char *sv, register I32 len)
{
register char *newaddr;
return SvPVX(sv);
}
-char *
+SV *
mess(const char *pat, va_list *args)
{
SV *sv = mess_alloc();
sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
if (!SvCUR(sv) || *(SvEND(sv) - 1) != '\n') {
dTHR;
- if (PL_dirty)
- sv_catpv(sv, dgd);
- else {
- if (PL_curcop->cop_line)
- sv_catpvf(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) &&
- SvLEN(PL_rs) == 1 && *SvPVX(PL_rs) == '\n');
- sv_catpvf(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)));
- }
- sv_catpv(sv, ".\n");
+ if (PL_curcop->cop_line)
+ sv_catpvf(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",
+ PL_last_in_gv == PL_argvgv ? "" : GvNAME(PL_last_in_gv),
+ line_mode ? "line" : "chunk",
+ (long)IoLINES(GvIOp(PL_last_in_gv)));
}
+ sv_catpv(sv, PL_dirty ? dgd : ".\n");
}
- return SvPVX(sv);
+ return sv;
}
OP *
HV *stash;
GV *gv;
CV *cv;
+ SV *msv;
+ STRLEN msglen;
DEBUG_S(PerlIO_printf(PerlIO_stderr(),
"%p: die: curstack = %p, mainstack = %p\n",
thr, PL_curstack, PL_mainstack));
va_start(args, pat);
- message = pat ? mess(pat, &args) : Nullch;
+ if (pat) {
+ msv = mess(pat, &args);
+ message = SvPV(msv,msglen);
+ }
+ else {
+ message = Nullch;
+ }
va_end(args);
DEBUG_S(PerlIO_printf(PerlIO_stderr(),
SV *msg;
ENTER;
- if(message) {
- msg = newSVpv(message, 0);
+ if (message) {
+ msg = newSVpvn(message, msglen);
SvREADONLY_on(msg);
SAVEFREESV(msg);
}
}
}
- PL_restartop = die_where(message);
+ PL_restartop = die_where(message, msglen);
DEBUG_S(PerlIO_printf(PerlIO_stderr(),
"%p: die: restartop = %p, was_in_eval = %d, top_env = %p\n",
thr, PL_restartop, was_in_eval, PL_top_env));
HV *stash;
GV *gv;
CV *cv;
+ SV *msv;
+ STRLEN msglen;
va_start(args, pat);
- message = 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 *msg;
ENTER;
- msg = newSVpv(message, 0);
+ msg = newSVpvn(message, msglen);
SvREADONLY_on(msg);
SAVEFREESV(msg);
}
}
if (PL_in_eval) {
- PL_restartop = die_where(message);
+ PL_restartop = die_where(message, msglen);
JMPENV_JUMP(3);
}
- PerlIO_puts(PerlIO_stderr(),message);
- (void)PerlIO_flush(PerlIO_stderr());
+ {
+#ifdef USE_SFIO
+ /* SFIO can really mess with your errno */
+ int e = errno;
+#endif
+ PerlIO_write(PerlIO_stderr(), message, msglen);
+ (void)PerlIO_flush(PerlIO_stderr());
+#ifdef USE_SFIO
+ errno = e;
+#endif
+ }
my_failure_exit();
}
HV *stash;
GV *gv;
CV *cv;
+ SV *msv;
+ STRLEN msglen;
va_start(args, pat);
- message = mess(pat, &args);
+ msv = mess(pat, &args);
+ message = SvPV(msv, msglen);
va_end(args);
if (PL_warnhook) {
SV *msg;
ENTER;
- msg = newSVpv(message, 0);
+ msg = newSVpvn(message, msglen);
SvREADONLY_on(msg);
SAVEFREESV(msg);
return;
}
}
- PerlIO_puts(PerlIO_stderr(),message);
+ PerlIO_write(PerlIO_stderr(), message, msglen);
#ifdef LEAKTEST
DEBUG_L(*message == '!'
? (xstat(message[1]=='!'
HV *stash;
GV *gv;
CV *cv;
+ SV *msv;
+ STRLEN msglen;
va_start(args, pat);
- message = mess(pat, &args);
+ msv = mess(pat, &args);
+ message = SvPV(msv, msglen);
va_end(args);
if (ckDEAD(err)) {
SV *msg;
ENTER;
- msg = newSVpv(message, 0);
+ msg = newSVpvn(message, msglen);
SvREADONLY_on(msg);
SAVEFREESV(msg);
}
}
if (PL_in_eval) {
- PL_restartop = die_where(message);
+ PL_restartop = die_where(message, msglen);
JMPENV_JUMP(3);
}
- PerlIO_puts(PerlIO_stderr(),message);
+ PerlIO_write(PerlIO_stderr(), message, msglen);
(void)PerlIO_flush(PerlIO_stderr());
my_failure_exit();
SV *msg;
ENTER;
- msg = newSVpv(message, 0);
+ msg = newSVpvn(message, msglen);
SvREADONLY_on(msg);
SAVEFREESV(msg);
return;
}
}
- PerlIO_puts(PerlIO_stderr(),message);
+ PerlIO_write(PerlIO_stderr(), message, msglen);
#ifdef LEAKTEST
DEBUG_L(xstat());
#endif
#else /* !USE_WIN32_RTL_ENV */
- /* The sane way to deal with the environment.
- * Has these advantages over putenv() & co.:
- * * enables us to store a truly empty value in the
- * environment (like in UNIX).
- * * we don't have to deal with RTL globals, bugs and leaks.
- * * Much faster.
- * Why you may want to enable USE_WIN32_RTL_ENV:
- * * environ[] and RTL functions will not reflect changes,
- * which might be an issue if extensions want to access
- * the env. via RTL. This cuts both ways, since RTL will
- * not see changes made by extensions that call the Win32
- * functions directly, either.
- * GSAR 97-06-07
- */
- SetEnvironmentVariable(nam,val);
+ register char *envstr;
+ STRLEN len = strlen(nam) + 3;
+ if (!val) {
+ val = "";
+ }
+ len += strlen(val);
+ New(904, envstr, len, char);
+ (void)sprintf(envstr,"%s=%s",nam,val);
+ (void)PerlEnv_putenv(envstr);
+ Safefree(envstr);
#endif
}
#if !defined(HAS_BCOPY) || !defined(HAS_SAFE_BCOPY)
char *
-my_bcopy(register char *from,register char *to,register I32 len)
+my_bcopy(register const char *from,register char *to,register I32 len)
{
char *retval = to;
#ifndef HAS_MEMSET
void *
-my_memset(loc,ch,len)
-register char *loc;
-register I32 ch;
-register I32 len;
+my_memset(register char *loc, register I32 ch, register I32 len)
{
char *retval = loc;
#if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
char *
-my_bzero(loc,len)
-register char *loc;
-register I32 len;
+my_bzero(register char *loc, register I32 len)
{
char *retval = loc;
#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
I32
-my_memcmp(s1,s2,len)
-char *s1;
-char *s2;
-register I32 len;
+my_memcmp(const char *s1, const char *s2, register I32 len)
{
register U8 *a = (U8 *)s1;
register U8 *b = (U8 *)s2;
#else
int
#endif
-vsprintf(dest, pat, args)
-char *dest;
-const char *pat;
-char *args;
+vsprintf(char *dest, const char *pat, char *args)
{
FILE fakebuf;
SV *sv;
I32 doexec = strNE(cmd,"-");
+ PERL_FLUSHALL_FOR_CHILD;
#ifdef OS2
if (doexec) {
return my_syspopen(cmd,mode);
#if defined(atarist) || defined(DJGPP)
FILE *popen();
PerlIO *
-my_popen(cmd,mode)
-char *cmd;
-char *mode;
+my_popen(char *cmd, char *mode)
{
/* Needs work for PerlIO ! */
/* used 0 for 2nd parameter to PerlIO-exportFILE; apparently not used */
+ PERL_FLUSHALL_FOR_CHILD;
return popen(PerlIO_exportFILE(cmd, 0), mode);
}
#endif
}
#endif /* !DOSISH */
-#if !defined(DOSISH) || defined(OS2) || defined(WIN32)
+#if !defined(DOSISH) || defined(OS2) || defined(WIN32) || defined(CYGWIN32)
I32
wait4pid(int pid, int *statusp, int flags)
{
#endif
void
-repeatcpy(register char *to, register char *from, I32 len, register I32 count)
+repeatcpy(register char *to, register const char *from, I32 len, register I32 count)
{
register I32 todo;
- register char *frombase = from;
+ register const char *frombase = from;
if (len == 1) {
- register char c = *from;
+ register const char c = *from;
while (count-- > 0)
*to++ = c;
return;
retval = n | (*s++ - '0');
len--;
}
- if (len && (*s >= '2' || *s <= '9')) {
+ if (len && (*s >= '2' && *s <= '9')) {
dTHR;
if (ckWARN(WARN_UNSAFE))
- warner(WARN_UNSAFE, "Illegal binary digit ignored");
+ warner(WARN_UNSAFE, "Illegal binary digit '%c' ignored", *s);
}
*retlen = s - start;
return retval;
if (len && (*s == '8' || *s == '9')) {
dTHR;
if (ckWARN(WARN_OCTAL))
- warner(WARN_OCTAL, "Illegal octal digit ignored");
+ warner(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 ignored");
+ warner(WARN_UNSAFE,"Illegal hex digit '%c' ignored", *s);
break;
}
}
COND_INIT(&cp->owner_cond);
COND_INIT(&cp->cond);
cp->owner = 0;
- LOCK_SV_MUTEX;
+ MUTEX_LOCK(&PL_cred_mutex); /* XXX need separate mutex? */
mg = mg_find(sv, 'm');
if (mg) {
/* someone else beat us to initialising it */
- UNLOCK_SV_MUTEX;
+ MUTEX_UNLOCK(&PL_cred_mutex); /* XXX need separate mutex? */
MUTEX_DESTROY(&cp->mutex);
COND_DESTROY(&cp->owner_cond);
COND_DESTROY(&cp->cond);
mg = SvMAGIC(sv);
mg->mg_ptr = (char *)cp;
mg->mg_len = sizeof(cp);
- UNLOCK_SV_MUTEX;
+ MUTEX_UNLOCK(&PL_cred_mutex); /* XXX need separate mutex? */
DEBUG_S(WITH_THR(PerlIO_printf(PerlIO_stderr(),
"%p: condpair_magic %p\n", thr, sv));)
}
SV **svp;
I32 i;
- sv = newSVpv("", 0);
+ sv = newSVpvn("", 0);
SvGROW(sv, sizeof(struct perl_thread) + 1);
SvCUR_set(sv, sizeof(struct perl_thread));
thr = (Thread) SvPVX(sv);
thr->cvcache = newHV();
thr->threadsv = newAV();
thr->specific = newAV();
- thr->errsv = newSVpv("", 0);
+ thr->errsv = newSVpvn("", 0);
thr->errhv = newHV();
thr->flags = THRf_R_JOINABLE;
MUTEX_INIT(&thr->mutex);
return PL_specialsv_list;
}
+#ifndef HAS_GETENV_SV
+SV *
+getenv_sv(char *env_elem)
+{
+ char *env_trans;
+ SV *temp_sv;
+ if ((env_trans = PerlEnv_getenv(env_elem)) != Nullch) {
+ temp_sv = newSVpv(env_trans, strlen(env_trans));
+ return temp_sv;
+ } else {
+ return &PL_sv_undef;
+ }
+}
+#endif
+
MGVTBL*
get_vtbl(int vtbl_id)
projects / p5sagit/p5-mst-13.2.git / blobdiff