WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/printf/printf_core.c

 /** Print count chars from buffer without adding newline
  * @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!
  * @param count
  * @param ps output method and its data
- * @return 0 on success, EOF on fail
+ * @return number or printed characters
  */
 static int printf_putnchars(const char * buf, size_t count, struct printf_spec *ps)
+{
-    if (ps->write((void *)buf, count, ps->data) == count) {
+    return ps->write((void *)buf, count, ps->data);
-        return 0;
-    }
-    return EOF;
+}
 /** Print string without added newline
  * @param str string to print
  * @param ps write function specification and support data
- * @return 0 on success or EOF on fail
+ * @return number or printed characters
  */
 static int printf_putstr(const char * str, struct printf_spec *ps)
+{
     size_t count;
         return printf_putnchars("(NULL)", 6, ps);
+    }
     count = strlen(str);
-    if (ps->write((void *) str, count, ps->data) == count) {
+    return ps->write((void *) str, count, ps->data);
-        return 0;
-    }
-    return EOF;
+}
 /** Print one character to output
  * @param c one character
  * @param ps output method
- * @return printed character or EOF
+ * @return number or printed characters
  */
 static int printf_putchar(int c, struct printf_spec *ps)
+{
     unsigned char ch = c;
-    if (ps->write((void *) &ch, 1, ps->data) == 1) {
+    return ps->write((void *) &ch, 1, ps->data);
-        return c;
-    }
-    return EOF;
+}
 /** Print one formatted character
  * @param c character to print
  * @param width
  * @param flags
- * @return number of printed characters or EOF
+ * @return number of printed characters, negative value on fail
  */
 static int print_char(char c, int width, __u64 flags, struct printf_spec *ps)
+{
     int counter = 0;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (--width > 0) {   /* one space is consumed by character itself hence predecrement */
             /* FIXME: painful slow */
-            printf_putchar(' ', ps);
+            if (printf_putchar(' ', ps) > 0)
-            ++counter;
+                ++counter;
+        }
+    }
-    if (printf_putchar(c, ps) == EOF) {
+    if (printf_putchar(c, ps) > 0)
-        return EOF;
+        counter++;
-    }
     while (--width > 0) { /* one space is consumed by character itself hence predecrement */
-        printf_putchar(' ', ps);
+        if (printf_putchar(' ', ps) > 0)
-        ++counter;
+            ++counter;
+    }
     return ++counter;
+}
 /** Print one string
  * @param s string
  * @param width
  * @param precision
  * @param flags
- * @return number of printed characters or EOF
+ * @return number of printed characters or negative value on fail
  */
 static int print_string(char *s, int width, int precision, __u64 flags, struct printf_spec *ps)
+{
     int counter = 0;
     size_t size;
+    int retval;
     if (s == NULL) {
         return printf_putstr("(NULL)", ps);
+    }
     width -= precision;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (width-- > 0) {
-            printf_putchar(' ', ps);
+            if (printf_putchar(' ', ps) == 1)
-            counter++;
+                counter++;
+        }
+    }
     while (precision > size) {
         precision--;
-        printf_putchar(' ', ps);
+        if (printf_putchar(' ', ps) == 1)
-        ++counter;
+            ++counter;
+    }
-    if (printf_putnchars(s, precision, ps) == EOF) {
+    if ((retval = printf_putnchars(s, precision, ps)) < 0) {
-        return EOF;
+        return -counter;
+    }
-    counter += precision;
+    counter += retval;
     while (width-- > 0) {
-        printf_putchar(' ', ps);
+        if (printf_putchar(' ', ps) == 1)
-        ++counter;
+            ++counter;
+    }
-    return ++counter;
+    return counter;
+}
 /** Print number in given base
+ *
     char *digits = digits_small;
     char d[PRINT_NUMBER_BUFFER_SIZE];   /* this is good enough even for base == 2, prefix and sign */
     char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];
     int size = 0; /* size of number with all prefixes and signs */
     int number_size; /* size of plain number */
-    int written = 0;
     char sgn;
+    int retval;
+    int counter = 0;
     if (flags & __PRINTF_FLAG_BIGCHARS)
         digits = digits_big;
     *ptr-- = 0; /* Put zero at end of string */
     width -= precision + size - number_size;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (width-- > 0) {
-            printf_putchar(' ', ps);
+            if (printf_putchar(' ', ps) == 1)
-            written++;
+                counter++;
+        }
+    }
     /* print sign */
     if (sgn) {
-        printf_putchar(sgn, ps);
+        if (printf_putchar(sgn, ps) == 1)
-        written++;
+            counter++;
+    }
     /* print prefix */
     if (flags & __PRINTF_FLAG_PREFIX) {
         switch(base) {
             case 2: /* Binary formating is not standard, but usefull */
-                printf_putchar('0', ps);
+                if (printf_putchar('0', ps) == 1)
+                    counter++;
                 if (flags & __PRINTF_FLAG_BIGCHARS) {
-                    printf_putchar('B', ps);
+                    if (printf_putchar('B', ps) == 1)
+                        counter++;
                 } else {
-                    printf_putchar('b', ps);
+                    if (printf_putchar('b', ps) == 1)
+                        counter++;
+                }
-                written += 2;
                 break;
             case 8:
-                printf_putchar('o', ps);
+                if (printf_putchar('o', ps) == 1)
-                written++;
+                    counter++;
                 break;
             case 16:
-                printf_putchar('0', ps);
+                if (printf_putchar('0', ps) == 1)
+                    counter++;
                 if (flags & __PRINTF_FLAG_BIGCHARS) {
-                    printf_putchar('X', ps);
+                    if (printf_putchar('X', ps) == 1)
+                        counter++;
                 } else {
-                    printf_putchar('x', ps);
+                    if (printf_putchar('x', ps) == 1)
+                        counter++;
+                }
-                written += 2;
                 break;
+        }
+    }
     /* print leading zeroes */
     precision -= number_size;
     while (precision-- > 0) {
-        printf_putchar('0', ps);
+        if (printf_putchar('0', ps) == 1)
-        written++;
+            counter++;
+    }
     /* print number itself */
-    written += printf_putstr(++ptr, ps);
+    if ((retval = printf_putstr(++ptr, ps)) > 0) {
+        counter += retval;
+    }
     /* print ending spaces */
     while (width-- > 0) {
-        printf_putchar(' ', ps);
+        if (printf_putchar(' ', ps) == 1)
-        written++;
+            counter++;
+    }
-    return written;
+    return counter;
+}
 /** Print formatted string.
+ *
     while ((c = fmt[i])) {
         /* control character */
         if (c == '%' ) {
             /* print common characters if any processed */
             if (i > j) {
-                if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) == EOF) { /* error */
+                if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) < 0) { /* error */
                     counter = -counter;
                     goto out;
+                }
                 counter += retval;
+            }
                 /*
                 * String and character conversions.
                 */
                 case 's':
-                    if ((retval = print_string(va_arg(ap, char*), width, precision, flags, ps)) == EOF) {
+                    if ((retval = print_string(va_arg(ap, char*), width, precision, flags, ps)) < 0) {
                         counter = -counter;
                         goto out;
                     };
                     counter += retval;
                     j = i + 1;
                     goto next_char;
                 case 'c':
                     c = va_arg(ap, unsigned int);
-                    if ((retval = print_char(c, width, flags, ps)) == EOF) {
+                    if ((retval = print_char(c, width, flags, ps)) < 0) {
                         counter = -counter;
                         goto out;
                     };
                     counter += retval;
                         number++;
+                    }
+                }
+            }
-            if ((retval = print_number(number, width, precision, base, flags, ps)) == EOF ) {
+            if ((retval = print_number(number, width, precision, base, flags, ps)) < 0) {
                 counter = -counter;
                 goto out;
             };
             counter += retval;
         ++i;
+    }
     if (i > j) {
-        if ((retval = printf_putnchars(&fmt[j], (__native)(i - j), ps)) == EOF) { /* error */
+        if ((retval = printf_putnchars(&fmt[j], (__native)(i - j), ps)) < 0) { /* error */
             counter = -counter;
             goto out;
+        }
         counter += retval;

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/printf/printf_core.c – Rev 1273 → 1604