The R Project SVN – R – Diff – /trunk/src/main/errors.c

+}
 #ifndef min
 #define min(a, b) (a<b?a:b)
 #endif
+#ifndef max
+#define max(a, b) (a>b?a:b)
+#endif
 /* Total line length, in chars, before splitting in warnings/errors */
 #define LONGWARN 75
 /*
 Different values of inError are used to indicate different places
-in the error handling.
+in the error handling:
+inError = 1: In internal error handling, e.g. `verrorcall_dflt`, others.
+inError = 2: Writing traceback
+inError = 3: In user error handler (i.e. options(error=handler))
 */
 static int inError = 0;
 static int inWarning = 0;
 static int inPrintWarnings = 0;
 static int immediateWarning = 0;
+{
     R_Warnings = allocVector(VECSXP, R_nwarnings);
     setAttrib(R_Warnings, R_NamesSymbol, allocVector(STRSXP, R_nwarnings));
+}
-/* Rvsnprintf: like vsnprintf, but guaranteed to null-terminate and not to
+/* Rvsnprintf: like vsnprintf, but guaranteed to null-terminate and not to split
+   multi-byte characters, except if size is zero in which case the buffer is
-   split multi-byte characters */
+   untouched and thus may not be null-terminated.
+   Dangerous pattern: `Rvsnprintf(buf, size - n, )` with maybe n >= size*/
 #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);
+    if (size) {
+	if (val < 0) buf[0] = '\0'; /* not all uses check val < 0 */
-    buf[size-1] = '\0';
+	else buf[size-1] = '\0';
-    if (val >= size)
+	if (val >= size)
-	mbcsTruncateToValid(buf);
+	    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);
+    if (size) {
+	if (val < 0) buf[0] = '\0'; /* not all uses check val < 0 */
-    buf[size-1] = '\0';
+	else buf[size-1] = '\0';
-    if (val >= size)
+	if (val >= size)
-	mbcsTruncateToValid(buf);
+	    mbcsTruncateToValid(buf);
+    }
     return val;
+}
 #endif
-/* Rsnprintf: like snprintf, but guaranteed to null-terminate and not to
+/* Rsnprintf: like snprintf, but guaranteed to null-terminate and not to split
+   multi-byte characters, except if size is zero in which case the buffer is
-   split multi-byte characters */
+   untouched and thus may not be null-terminated.
+   Dangerous pattern: `Rsnprintf(buf, size - n, )` with maybe n >= size*/
 static int Rsnprintf(char *str, size_t size, const char *format, ...)
+{
     int val;
     va_list ap;
    overhead due to the checks would be too high, and the program is doing
    something strange anyway (i.e. running no-segfault tests). The constant
    checks in GC and session exit (or .Call) do not have such limit. */
 static int allowedConstsChecks = 1000;
+/* Construct newline terminated error message, write it to global errbuf, and
+   possibly display with REprintf. */
 static void NORET
 verrorcall_dflt(SEXP call, const char *format, va_list ap)
+{
     if (allowedConstsChecks > 0) {
 	allowedConstsChecks--;
     cntxt.cend = &restore_inError;
     cntxt.cenddata = &oldInError;
     oldInError = inError;
     inError = 1;
+    // For use with Rv?snprintf, which truncates at size - 1, hence the + 1
+    size_t msg_len = min(BUFSIZE, R_WarnLength) + 1;
     if(call != R_NilValue) {
 	char tmp[BUFSIZE], tmp2[BUFSIZE];
 	char *head = _("Error in "), *tail = "\n  ";
 	SEXP srcloc = R_NilValue; // -Wall
 	size_t len = 0;	// indicates if srcloc has been set
 	    if (len)
 		Rsnprintf(tmp2, BUFSIZE,  _("Error in %s (from %s) : "),
 			 dcall, CHAR(STRING_ELT(srcloc, 0)));
+	}
-	Rvsnprintf(tmp, min(BUFSIZE, R_WarnLength) - strlen(head), format, ap);
+	Rvsnprintf(tmp, max(msg_len - strlen(head), 0), format, ap);
 	if (strlen(tmp2) + strlen(tail) + strlen(tmp) < BUFSIZE) {
 	    if(len) Rsnprintf(errbuf, BUFSIZE,
 			     _("Error in %s (from %s) : "),
 			     dcall, CHAR(STRING_ELT(srcloc, 0)));
 	    else Rsnprintf(errbuf, BUFSIZE,  _("Error in %s : "), dcall);
 		    ERRBUFCAT(tail);
+	    }
 	    ERRBUFCAT(tmp);
 	} else {
 	    Rsnprintf(errbuf, BUFSIZE, _("Error: "));
-	    ERRBUFCAT(tmp); // FIXME
+	    ERRBUFCAT(tmp);
+	}
 	UNPROTECT(protected);
+    }
     else {
 	Rsnprintf(errbuf, BUFSIZE, _("Error: "));
 	p = errbuf + strlen(errbuf);
-	Rvsnprintf(p, min(BUFSIZE, R_WarnLength) - strlen(errbuf), format, ap);
+	Rvsnprintf(p, max(msg_len - strlen(errbuf), 0), format, ap);
+    }
+    /* Approximate truncation detection, may produce false positives.  Assumes
+       MB_CUR_MAX > 0. Note: approximation is fine, as the string may include
+       dots, anyway */
-    size_t nc = strlen(errbuf);
+    size_t nc = strlen(errbuf); // > 0, ignoring possibility of failure
-    if (nc == BUFSIZE - 1) {
+    if (nc > BUFSIZE - 1 - (MB_CUR_MAX - 1)) {
-	errbuf[BUFSIZE - 4] = '.';
+	size_t end = min(nc + 1, (BUFSIZE + 1) - 4); // room for "...\n\0"
-	errbuf[BUFSIZE - 3] = '.';
+	for(size_t i = end; i <= BUFSIZE + 1; ++i) errbuf[i - 1] = '\0';
-	errbuf[BUFSIZE - 2] = '.';
+	mbcsTruncateToValid(errbuf);
-	errbuf[BUFSIZE - 1] = '\n';
+	ERRBUFCAT("...\n");
-    }
-    else {
+    } else {
 	p = errbuf + nc - 1;
-	if(*p != '\n') ERRBUFCAT("\n");
+	if(*p != '\n') {
+	    ERRBUFCAT("\n");  // guaranteed to have room for this
-    }
+	    ++nc;
+	}
-    if(R_ShowErrorCalls && call != R_NilValue) {  /* assume we want to avoid deparse */
+	if(R_ShowErrorCalls && call != R_NilValue) {  /* assume we want to avoid deparse */
-	tr = R_ConciseTraceback(call, 0);
+	    tr = R_ConciseTraceback(call, 0);
-	size_t nc = strlen(tr);
+	    size_t nc_tr = strlen(tr);
+	    if (nc_tr) {
+		char * call_trans = _("Calls:");
-	if (nc && nc + strlen(errbuf) + 8 < BUFSIZE) {
+		if (nc_tr + nc + strlen(call_trans) + 2 < BUFSIZE + 1) {
-	    ERRBUFCAT(_("Calls:"));
+		    ERRBUFCAT(call_trans);
-	    ERRBUFCAT(" ");
+		    ERRBUFCAT(" ");
-	    ERRBUFCAT(tr);
+		    ERRBUFCAT(tr);
-	    ERRBUFCAT("\n");
+		    ERRBUFCAT("\n");
+		}
+	    }
+	}
+    }
     if (R_ShowErrorMessages) REprintf("%s", errbuf);
     if( R_ShowErrorMessages && R_CollectWarnings ) {
 SEXP R_withCallingErrorHandler(SEXP (*body)(void *), void *bdata,
 			       SEXP (*handler)(SEXP, void *), void *hdata)
+{
     /* This defines the lambda expression for th handler. The `addr`
-       variable wil be defined in the closure environment and contain
+       variable will be defined in the closure environment and contain
        an external pointer to the callback data. */
     static const char* wceh_callback_source =
 	"function(cond) .Internal(C_tryCatchHelper(addr, 1L, cond))";
     static SEXP wceh_callback = NULL;

The R Project SVN R

(root)/trunk/src/main/errors.c @ 77458 – Rev 78125 → 79123