The R Project SVN – R – Diff – /branches/R-conflicts/src/main/errors.c

 #include <Rconnections.h>
 #include <Rinterface.h>
 #include <R_ext/GraphicsEngine.h> /* for GEonExit */
 #include <Rmath.h> /* for imax2 */
 #include <R_ext/Print.h>
+#include <stdarg.h>
 #ifndef min
 #define min(a, b) (a<b?a:b)
 #endif
+{
     R_Warnings = allocVector(VECSXP, R_nwarnings);
     setAttrib(R_Warnings, R_NamesSymbol, allocVector(STRSXP, R_nwarnings));
+}
-/* Rvsnprintf: like vsnprintf, but guaranteed to null-terminate. */
+/* Rvsnprintf: like vsnprintf, but guaranteed to null-terminate and not to
+   split multi-byte characters */
 #ifdef Win32
 int trio_vsnprintf(char *buffer, size_t bufferSize, const char *format,
 		   va_list args);
 static int Rvsnprintf(char *buf, size_t size, const char  *format, va_list ap)
+{
     int val;
     val = trio_vsnprintf(buf, size, format, ap);
     buf[size-1] = '\0';
+    if (val >= size)
+	mbcsTruncateToValid(buf);
     return val;
+}
 #else
 static int Rvsnprintf(char *buf, size_t size, const char  *format, va_list ap)
+{
     int val;
     val = vsnprintf(buf, size, format, ap);
     buf[size-1] = '\0';
+    if (val >= size)
+	mbcsTruncateToValid(buf);
     return val;
+}
 #endif
+/* Rsnprintf: like snprintf, but guaranteed to null-terminate and not to
+   split multi-byte characters */
+static int Rsnprintf(char *str, size_t size, const char *format, ...)
+{
+    int val;
+    va_list ap;
+    va_start(ap, format);
+    val = Rvsnprintf(str, size, format, ap);
+    va_end(ap);
+    return val;
+}
+/* Rstrncat: like strncat, but guaranteed not to split multi-byte characters */
+static char *Rstrncat(char *dest, const char *src, size_t n)
+{
+    size_t after;
+    size_t before = strlen(dest);
+    strncat(dest, src, n);
+    after = strlen(dest);
+    if (after - before == n)
+	/* the string may have been truncated, but we cannot know for sure
+	   because str may not be null terminated */
+	mbcsTruncateToValid(dest + before);
+    return dest;
+}
+/* Rstrncat: like strncpy, but guaranteed to null-terminate and not to
+   split multi-byte characters */
+static char *Rstrncpy(char *dest, const char *src, size_t n)
+{
+    strncpy(dest, src, n);
+    if (dest[n-1] != '\0') {
+	dest[n-1] = '\0';
+	mbcsTruncateToValid(dest);
+    }
+    return dest;
+}
 #define BUFSIZE 8192
-static R_INLINE void RprintTrunc(char *buf)
+static R_INLINE void RprintTrunc(char *buf, int truncated)
+{
+    if(R_WarnLength < BUFSIZE - 20 &&
-    if(R_WarnLength < BUFSIZE - 20 && strlen(buf) == R_WarnLength) {
+      (truncated || strlen(buf) == R_WarnLength)) {
 	strcat(buf, " ");
 	strcat(buf, _("[... truncated]"));
+    }
+}
+{
     char buf[BUFSIZE], *p;
     va_list(ap);
     va_start(ap, format);
+    size_t psize;
+    int pval;
-    Rvsnprintf(buf, min(BUFSIZE, R_WarnLength+1), format, ap);
+    psize = min(BUFSIZE, R_WarnLength+1);
+    pval = Rvsnprintf(buf, psize, format, ap);
     va_end(ap);
     p = buf + strlen(buf) - 1;
     if(strlen(buf) > 0 && *p == '\n') *p = '\0';
-    RprintTrunc(buf);
+    RprintTrunc(buf, pval >= psize);
     warningcall(getCurrentCall(), "%s", buf);
+}
 /* declarations for internal condition handling */
     SEXP names, s;
     const char *dcall;
     char buf[BUFSIZE];
     RCNTXT *cptr;
     RCNTXT cntxt;
+    size_t psize;
+    int pval;
     if (inWarning)
 	return;
     s = GetOption1(install("warning.expression"));
     cntxt.cend = &reset_inWarning;
     inWarning = 1;
     if(w >= 2) { /* make it an error */
-	Rvsnprintf(buf, min(BUFSIZE, R_WarnLength), format, ap);
+	psize = min(BUFSIZE, R_WarnLength+1);
+	pval = Rvsnprintf(buf, psize, format, ap);
-	RprintTrunc(buf);
+	RprintTrunc(buf, pval >= psize);
 	inWarning = 0; /* PR#1570 */
 	errorcall(call, _("(converted from warning) %s"), buf);
+    }
     else if(w == 1) {	/* print as they happen */
 	char *tr;
 	if( call != R_NilValue ) {
 	    dcall = CHAR(STRING_ELT(deparse1s(call), 0));
 	} else dcall = "";
-	Rvsnprintf(buf, min(BUFSIZE, R_WarnLength+1), format, ap);
+	psize = min(BUFSIZE, R_WarnLength+1);
+	pval = Rvsnprintf(buf, psize, format, ap);
-	RprintTrunc(buf);
+	RprintTrunc(buf, pval >= psize);
 	if(dcall[0] == '\0') REprintf(_("Warning:"));
 	else {
 	    REprintf(_("Warning in %s :"), dcall);
 	    if(!(noBreakWarning ||
+    }
     else if(w == 0) {	/* collect them */
 	if(!R_CollectWarnings) setupwarnings();
 	if(R_CollectWarnings < R_nwarnings) {
 	    SET_VECTOR_ELT(R_Warnings, R_CollectWarnings, call);
-	    Rvsnprintf(buf, min(BUFSIZE, R_WarnLength+1), format, ap);
+	    psize = min(BUFSIZE, R_WarnLength+1);
+	    pval = Rvsnprintf(buf, psize, format, ap);
-	    RprintTrunc(buf);
+	    RprintTrunc(buf, pval >= psize);
 	    if(R_ShowWarnCalls && call != R_NilValue) {
 		char *tr =  R_ConciseTraceback(call, 0);
 		size_t nc = strlen(tr);
 		if (nc && nc + (int)strlen(buf) + 8 < BUFSIZE) {
 		    strcat(buf, "\n");
     return result;
+}
 static char errbuf[BUFSIZE];
-#define ERRBUFCAT(txt) strncat(errbuf, txt, BUFSIZE - strlen(errbuf))
+#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
 const char *R_curErrorBuf() {
     return (const char *)errbuf;
+}
 	    else
 		skip = asInteger(opt);
+	}
 	const char *dcall = CHAR(STRING_ELT(deparse1s(call), 0));
-	snprintf(tmp2, BUFSIZE,  "%s", head);
+	Rsnprintf(tmp2, BUFSIZE,  "%s", head);
 	if (skip != NA_INTEGER) {
 	    PROTECT(srcloc = GetSrcLoc(R_GetCurrentSrcref(skip)));
 	    protected++;
 	    len = strlen(CHAR(STRING_ELT(srcloc, 0)));
 	    if (len)
-		snprintf(tmp2, BUFSIZE,  _("Error in %s (from %s) : "),
+		Rsnprintf(tmp2, BUFSIZE,  _("Error in %s (from %s) : "),
 			 dcall, CHAR(STRING_ELT(srcloc, 0)));
+	}
 	Rvsnprintf(tmp, min(BUFSIZE, R_WarnLength) - strlen(head), format, ap);
 	if (strlen(tmp2) + strlen(tail) + strlen(tmp) < BUFSIZE) {
-	    if(len) snprintf(errbuf, BUFSIZE,
+	    if(len) Rsnprintf(errbuf, BUFSIZE,
 			     _("Error in %s (from %s) : "),
 			     dcall, CHAR(STRING_ELT(srcloc, 0)));
-	    else snprintf(errbuf, BUFSIZE,  _("Error in %s : "), dcall);
+	    else Rsnprintf(errbuf, BUFSIZE,  _("Error in %s : "), dcall);
 	    if (mbcslocale) {
 		int msgline1;
 		char *p = strchr(tmp, '\n');
 		if (p) {
 		    *p = '\0';
 		if (14 + strlen(dcall) + msgline1 > LONGWARN)
 		    ERRBUFCAT(tail);
+	    }
 	    ERRBUFCAT(tmp);
 	} else {
-	    snprintf(errbuf, BUFSIZE, _("Error: "));
+	    Rsnprintf(errbuf, BUFSIZE, _("Error: "));
 	    ERRBUFCAT(tmp); // FIXME
+	}
 	UNPROTECT(protected);
+    }
     else {
-	snprintf(errbuf, BUFSIZE, _("Error: "));
+	Rsnprintf(errbuf, BUFSIZE, _("Error: "));
 	p = errbuf + strlen(errbuf);
 	Rvsnprintf(p, min(BUFSIZE, R_WarnLength) - strlen(errbuf), format, ap);
+    }
     size_t nc = strlen(errbuf);
+	}
 	if(strlen(domain)) {
 	    size_t len = strlen(domain)+3;
 	    R_CheckStack2(len);
 	    buf = (char *) alloca(len);
-	    snprintf(buf, len, "R-%s", domain);
+	    Rsnprintf(buf, len, "R-%s", domain);
 	    domain = buf;
+	}
     } else if(isString(CAR(args)))
 	domain = translateChar(STRING_ELT(CAR(args),0));
     else if(isLogical(CAR(args)) && LENGTH(CAR(args)) == 1 && LOGICAL(CAR(args))[0] == NA_LOGICAL) ;
 		*p && (*p == ' ' || *p == '\t' || *p == '\n');
 		p++, ihead++) ;
 	    if(ihead > 0) {
 		R_CheckStack2(ihead + 1);
 		head = (char *) alloca(ihead + 1);
-		strncpy(head, tmp, ihead);
+		Rstrncpy(head, tmp, ihead + 1);
-		head[ihead] = '\0';
 		tmp += ihead;
+		}
 	    if(strlen(tmp))
 		for(p = tmp+strlen(tmp)-1;
 		    p >= tmp && (*p == ' ' || *p == '\t' || *p == '\n');
+	}
 	if(strlen(domain)) {
 	    size_t len = strlen(domain)+3;
 	    R_CheckStack2(len);
 	    buf = (char *) alloca(len);
-	    snprintf(buf, len, "R-%s", domain);
+	    Rsnprintf(buf, len, "R-%s", domain);
 	    domain = buf;
+	}
     } else if(isString(sdom))
 	domain = CHAR(STRING_ELT(sdom,0));
     else if(isLogical(sdom) && LENGTH(sdom) == 1 && LOGICAL(sdom)[0] == NA_LOGICAL) ;
+}
 #endif
 static void R_SetErrmessage(const char *s)
+{
-    strncpy(errbuf, s, sizeof(errbuf));
+    Rstrncpy(errbuf, s, sizeof(errbuf));
-    errbuf[sizeof(errbuf) - 1] = 0;
+}
 static void R_PrintDeferredWarnings(void)
+{
     if( R_ShowErrorMessages && R_CollectWarnings ) {
     Rvsnprintf(localbuf, BUFSIZE - 1, format, ap);
     while ((list = findSimpleErrorHandler()) != R_NilValue) {
 	char *buf = errbuf;
 	SEXP entry = CAR(list);
 	R_HandlerStack = CDR(list);
-	strncpy(buf, localbuf, BUFSIZE);
+	Rstrncpy(buf, localbuf, BUFSIZE);
 	/*	Rvsnprintf(buf, BUFSIZE - 1, format, ap);*/
-	buf[BUFSIZE - 1] = 0;
 	if (IS_CALLING_ENTRY(entry)) {
 	    if (ENTRY_HANDLER(entry) == R_RestartToken)
 		return; /* go to default error handling; do not reset stack */
 	    else {
 		/* if we are in the process of handling a C stack
                   const char *errmsg, const char *warnmsg,
                   const char *varname, Rboolean warnByDefault)
+{
     /* disable GC so that use of this temporary checking code does not
        introduce new PROTECT errors e.g. in asLogical() use */
+    R_CHECK_THREAD;
     int enabled = R_GCEnabled;
     R_GCEnabled = FALSE;
     int nprotect = 0;
     char *check = getenv(varname);
     const void *vmax = vmaxget();

The R Project SVN R

(root)/branches/R-conflicts/src/main/errors.c – Rev 75597 → 75629