Changeset f2b8cdc in mainline for uspace/lib/libc/generic/io/vsnprintf.c

Timestamp:

2009-04-04T22:04:28Z (15 years ago)

Author:

Jiri Svoboda <jirik.svoboda@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

b27eb71

Parents:

4527fb5

Message:

Copy printf with Unicode support to userspace.

File:

• uspace/lib/libc/generic/io/vsnprintf.c (modified) (1 diff)

uspace/lib/libc/generic/io/vsnprintf.c

@@ -37 +37 @@
 #include <string.h>
 #include <io/printf_core.h>
+#include <errno.h>
 
-struct vsnprintf_data {
-        size_t size;    /* total space for string */
-        size_t len;     /* count of currently used characters */
-        char *string;   /* destination string */
-};
+typedef struct {
+        size_t size;    /* Total size of the buffer (in bytes) */
+        size_t len;     /* Number of already used bytes */
+        char *dst;      /* Destination */
+} vsnprintf_data_t;
 
 /** Write string to given buffer.
- * Write at most data->size characters including trailing zero. According to C99
- * has snprintf to return number of characters that would have been written if
- * enough space had been available. Hence the return value is not number of
- * really printed characters but size of input string. Number of really used
- * characters is stored in data->len.
  *
- * @param str           Source string to print.
- * @param count         Size of the source string.
- * @param data          Structure with destination string, counter of used space
- *                      and total string size.
- * @return              Number of characters to print (not characters really
- *                      printed!)
+ * Write at most data->size plain characters including trailing zero.
+ * According to C99, snprintf() has to return number of characters that
+ * would have been written if enough space had been available. Hence
+ * the return value is not the number of actually printed characters
+ * but size of the input string.
+ *
+ * @param str  Source string to print.
+ * @param size Number of plain characters in str.
+ * @param data Structure describing destination string, counter
+ *             of used space and total string size.
+ *
+ * @return Number of characters to print (not characters actually
+ *         printed).
+ *
  */
-static int
-vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
+static int vsnprintf_str_write(const char *str, size_t size, vsnprintf_data_t *data)
 {
-        size_t i;
-        i = data->size - data->len;
-
-        if (i == 0) {
-                return count;
+        size_t left = data->size - data->len;
+        
+        if (left == 0)
+                return ((int) size);
+        
+        if (left == 1) {
+                /* We have only one free byte left in buffer
+                 * -> store trailing zero
+                 */
+                data->dst[data->size - 1] = 0;
+                data->len = data->size;
+                return ((int) size);
         }
         
-        if (i == 1) {
-                /*
-                 * We have only one free byte left in buffer => write there
-                 * trailing zero.
+        if (left <= size) {
+                /* We do not have enough space for the whole string
+                 * with the trailing zero => print only a part
+                 * of string
                  */
-                data->string[data->size - 1] = 0;
-                data->len = data->size;
-                return count;
+                index_t index = 0;
+                
+                while (index < size) {
+                        wchar_t uc = str_decode(str, &index, size);
+                        
+                        if (chr_encode(uc, data->dst, &data->len, data->size - 1) != EOK)
+                                break;
+                }
+                
+                /* Put trailing zero at end, but not count it
+                 * into data->len so it could be rewritten next time
+                 */
+                data->dst[data->len] = 0;
+                
+                return ((int) size);
         }
         
-        if (i <= count) {
-                /*
-                 * We have not enought space for whole string with the trailing
-                 * zero => print only a part of string.
-                 */
-                memcpy((void *)(data->string + data->len), (void *)str, i - 1);
-                data->string[data->size - 1] = 0;
-                data->len = data->size;
-                return count;
+        /* Buffer is big enought to print the whole string */
+        memcpy((void *)(data->dst + data->len), (void *) str, size);
+        data->len += size;
+        
+        /* Put trailing zero at end, but not count it
+         * into data->len so it could be rewritten next time
+         */
+        data->dst[data->len] = 0;
+        
+        return ((int) size);
+}
+
+/** Write wide string to given buffer.
+ *
+ * Write at most data->size plain characters including trailing zero.
+ * According to C99, snprintf() has to return number of characters that
+ * would have been written if enough space had been available. Hence
+ * the return value is not the number of actually printed characters
+ * but size of the input string.
+ *
+ * @param str  Source wide string to print.
+ * @param size Number of bytes in str.
+ * @param data Structure describing destination string, counter
+ *             of used space and total string size.
+ *
+ * @return Number of wide characters to print (not characters actually
+ *         printed).
+ *
+ */
+static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data)
+{
+        index_t index = 0;
+        
+        while (index < (size / sizeof(wchar_t))) {
+                size_t left = data->size - data->len;
+                
+                if (left == 0)
+                        return ((int) size);
+                
+                if (left == 1) {
+                        /* We have only one free byte left in buffer
+                         * -> store trailing zero
+                         */
+                        data->dst[data->size - 1] = 0;
+                        data->len = data->size;
+                        return ((int) size);
+                }
+                
+                if (chr_encode(str[index], data->dst, &data->len, data->size - 1) != EOK)
+                        break;
+                
+                index++;
         }
         
-        /* Buffer is big enought to print whole string */
-        memcpy((void *)(data->string + data->len), (void *)str, count);
-        data->len += count;
-        /*
-         * Put trailing zero at end, but not count it into data->len so it could
-         * be rewritten next time.
+        /* Put trailing zero at end, but not count it
+         * into data->len so it could be rewritten next time
          */
-        data->string[data->len] = 0;
-
-        return count;   
+        data->dst[data->len] = 0;
+        
+        return ((int) size);
 }
 
-/** Print formatted to the given buffer with limited size.
- * @param str           Buffer.
- * @param size          Bffer size.
- * @param fmt           Format string.
- * \see For more details about format string see printf_core.
- */
 int vsnprintf(char *str, size_t size, const char *fmt, va_list ap)
 {
-        struct vsnprintf_data data = {size, 0, str};
-        struct printf_spec ps = {
-                (int(*)(void *, size_t, void *)) vsnprintf_write,
+        vsnprintf_data_t data = {
+                size,
+                0,
+                str
+        };
+        printf_spec_t ps = {
+                (int(*) (const char *, size_t, void *)) vsnprintf_str_write,
+                (int(*) (const wchar_t *, size_t, void *)) vsnprintf_wstr_write,
                 &data
         };
-
-        /*
-         * Print 0 at end of string - fix the case that nothing will be printed.
-         */
+        
+        /* Print 0 at end of string - fix the case that nothing will be printed */
         if (size > 0)
                 str[0] = 0;