swiprintf.cpp

sloedgy open sip stack source code

 }
 
 /* convert str to wcs */
 static int buf_str2wcs(const char *str, wchar_t *wcs, int len)
 {
   int i;
 
   for (i = 0; i < len; i++)
     wcs[i] = (wchar_t)str[i];
 
   return len;
 }
 
 static int buf_wcs2str(const wchar_t *wcs, char *str, int len)
 {
   int i;
 
   for (i = 0; i < len; i++)
     str[i] = w2c(wcs[i]);
 
   return len;
 }
 
 
 static int format_wcs2str(const wchar_t *wformat, char *nformat)
 {
   size_t len, i;
   bool replacement = false;
 
   len = wcslen(wformat);
   for (i = 0; i <= len; i++) {
     nformat[i] = w2c(wformat[i]);
     if (nformat[i] == '%') {
       if (replacement)
 	replacement = false; // double %%
       else
 	replacement = true;
     }
     else if ((replacement == true) && (SWIchar_isalpha(nformat[i]))) {
       switch (nformat[i]) {
       case 'c':
 	// wide insert for wide format -> wide insert for narrow format
 	nformat[i] = 'C';
 	break;
       case 's':
 	// wide insert for wide format -> wide insert for narrow format
 	nformat[i] = 'S';
 	break;
       case 'C':
 	// narrow insert for wide format -> narrow insert for narrow format
 	nformat[i] = 'c';
 	break;
       case 'S':
 	// narrow insert for wide format -> narrow insert for narrow format
 	nformat[i] = 's';
 	break;
       default:
 	break;
       }
       replacement = false;
     }
   }
   nformat[i] = '\0';
 
   return len;
 }
 
 
 SWIPRINTF_API int SWIvsprintf(char* str, size_t maxlen,
 			      const char* format, va_list args)
 {
   char tmpbuf[BUFSIZE];
   char *buf;
   int rc;
 
   if (maxlen < 1)
     return -1;
   str[0] = '\0';
 
   /* allocate buffer, allow for overrun */
   buf = BUFMALLOC(tmpbuf, maxlen + 1024);
   if (!buf)
     return -1;
 
 #if 0
   try {
 #endif
     char* newFormat = ConvertFormatForNarrowPrintf(format);
     rc = vsnprintf(buf, maxlen, newFormat, args);
     delete []newFormat;
 #if 0
   } catch(...) {
     if (strlen(format) < maxlen) {
       strcpy(buf, format);
       rc = strlen(buf);
       if (rc + BAD_FORMAT_TEXT_LEN < maxlen) {
 	strcat(buf, BAD_FORMAT_TEXT);
 	rc += BAD_FORMAT_TEXT_LEN;
       }
     }
   }
 #endif
 
   /* copy buffer back */
   if (rc >= 0) {
     size_t len = strlen(buf);
     if (len < maxlen) {
       strcpy(str, buf);
     } else {
       strncpy(str, buf, maxlen - 1);
       str[maxlen - 1] = '\0';
     }
   }
 
   BUFFREE(tmpbuf, buf);
 
   return rc;
 }
 
 
 SWIPRINTF_API int SWIvswprintf(wchar_t* wcs, size_t maxlen,
 			       const wchar_t* format, va_list args)
 {
   int rc;
 
   if (maxlen < 1)
     return -1;
   wcs[0] = '\0';
 
 #if defined(__GNUC__) && (__GNUC__ <= 2)
 
   /* Some versions of the GNU C library do not provide the required
      vswprintf( ) function, so we emulate it by converting the format
      string to narrow characters, do a narrow sprintf( ), then convert
      back */
 
   /* Use a temporary buffer for output to protect against relatively
      small overruns */
   char *buf, tmpbuf[BUFSIZE];
   if (BUFSIZE < maxlen + 1024)
     buf = new char[maxlen + 1024];
   else
     buf = tmpbuf;
   if (!buf)
     return -1;
 
   /* convert format to narrow, a bit generous compared to the ANSI/ISO
      C specifications for the printf( ) family format strings but we're
      not trying to do full validation here anyway */
   char *fmt, tmpfmt[BUFSIZE];
   size_t fmtlen = wcslen(format);
   if (BUFSIZE < fmtlen + 1)
     fmt = new char[fmtlen + 1];
   else
     fmt = tmpfmt;
   if (!fmt)
     return -1;
 
   format_wcs2str(format, fmt);
 
   /* generate the final string based on the narrow format and arguments */
   rc = vsnprintf(buf, maxlen, fmt, args);
 
   /* copy back to wide characters */
   size_t finallen = strlen(buf);
   if (finallen >= maxlen)
     finallen = maxlen - 1;
   for (size_t i = 0; i < finallen; i++)
     wcs[i] = buf[i];
   wcs[finallen] = L'\0';
 
   /* clean up */
   if (buf != tmpbuf)
     delete [] buf;
   if (fmt != tmpfmt)
     delete [] fmt;
 
 #else /* ! defined(__GNUC__) || (__GNUC__ > 2) */
 
   wchar_t* newFormat = ConvertFormatForWidePrintf(format);
   rc = vswprintf(wcs, maxlen, newFormat, args);
   delete [] newFormat;
 
   if ((size_t) rc >= maxlen - 1) /* overflow */
     wcs[maxlen - 1] = L'\0';
 
 #endif /* defined(__GNUC__) && (__GNUC__ <= 2) */
 
   return rc;
 }
 
 
 SWIPRINTF_API wchar_t *SWIfgetws(wchar_t *ws, int n, FILE *stream)
 {
   char tmpbuf[BUFSIZE];
   char *buf;
   char *rs;
 
   /* allocate local buffer */
   buf = BUFMALLOC(tmpbuf, n);
   if (!buf) {
     return NULL;
   }
 
   rs = fgets(buf, n, stream);
   if (rs == NULL) {
     BUFFREE(tmpbuf, buf);
     return NULL;
   }
 
   str2wcs(buf, ws);
   BUFFREE(tmpbuf, buf);
 
   return ws;
 }
 
 /* Only for linux: Solaris has a swscanf but doesn't have vsscanf!! */
 #if defined(_linux_)
 SWIPRINTF_API int SWIswscanf(const wchar_t *s, const wchar_t *format, ... )
 {
   char tmpbuf[BUFSIZE];
   char *buf;
   char tmpfmt[BUFSIZE];
   char *fmt;
   va_list ap;
   int rc;
 
   buf = BUFMALLOC(tmpbuf, wcslen(s) + 1);
   if (!buf) {
     return 0;
   }
 
   fmt = BUFMALLOC(tmpfmt, wcslen(format) + 1);
   if (!fmt) {
     BUFFREE(tmpbuf, buf);
     return 0;
   }
 
   /* convert buffers */
   wcs2str(s, buf);
   format_wcs2str(format, fmt);
 
   va_start(ap, format);
   rc = vsscanf(buf, fmt, ap);
   va_end(ap);
 
   /* we do not need to convert anything back */
   BUFFREE(tmpbuf, buf);
   BUFFREE(tmpfmt, fmt);
 
   return rc;
 }
 #endif
 
 #elif defined(WIN32)
 
 SWIPRINTF_API int SWIvsprintf(char* str, size_t maxlen,
 			      const char* format, va_list args)
 {
   int rc;
 
   if (maxlen < 1)
     return -1;
   str[0] = '\0';
 
 #if 0
   try {
 #endif
     rc = _vsnprintf(str, maxlen, format, args);
     if ((size_t) rc >= maxlen - 1) /* overflow */
       str[maxlen - 1] = '\0';
 #if 0
   } catch(...) {
     if (strlen(format) < maxlen) {
       strcpy(str, format);
       rc = strlen(str);
       if (rc + BAD_FORMAT_TEXT_LEN < maxlen) {
 	strcat(str, BAD_FORMAT_TEXT);
 	rc += BAD_FORMAT_TEXT_LEN;
       }
     }
   }
 #endif
 
   return rc;
 }
 
 
 SWIPRINTF_API int SWIvswprintf(wchar_t* wcs, size_t maxlen,
 			       const wchar_t* format, va_list args)
 {
   int rc;
 
   if (maxlen < 1)
     return -1;
   wcs[0] = '\0';
 
 #if 0
   try {
 #endif
     rc = _vsnwprintf(wcs, maxlen, format, args);
     if ((size_t) rc >= maxlen - 1) /* overflow */
       wcs[maxlen - 1] = L'\0';
 #if 0
   } catch(...) {
     if (wcslen(format) < maxlen) {
       wcscpy(wcs, format);
       rc = wcslen(wcs);
       if (rc + BAD_FORMAT_TEXT_LEN < maxlen) {
 	wcscat(wcs, BAD_FORMAT_TEXT_W);
 	rc += BAD_FORMAT_TEXT_LEN;
       }
     }
   }
 #endif
 
   return rc;
 }
 
 
 
 SWIPRINTF_API wchar_t *SWIfgetws(wchar_t *ws, int n, FILE *stream)
 {
   return fgetws(ws, n, stream);
 }
 
 
 /* SWSCANF on Win32 is just a #define to the real version */
 
 
 
 #elif
 #error
 #endif
#endif