/* viengoos.c - Main file for viengoos. Copyright (C) 2007, 2008 Free Software Foundation, Inc. Written by Neal H. Walfield . This file is part of the GNU Hurd. The GNU Hurd is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. The GNU Hurd is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #if HAVE_CONFIG_H #include #endif //#include "mutex.h" #ifndef NDEBUG //struct ss_lock_trace ss_lock_trace[SS_LOCK_TRACE_COUNT]; int ss_lock_trace_count; #endif #include #include #include #include #include //#include #include #include //#include //#include #include "arch.h" #include "viengoos.h" //#include "sigma0.h" #include "memory.h" #include "boot-modules.h" //#include "cap.h" //#include "object.h" //#include "activity.h" //#include "thread.h" //#include "server.h" #include "shutdown.h" #include "output.h" #include "zalloc.h" #include "ager.h" #define BUG_ADDRESS "" /* The program name. */ char *program_name = "viengoos"; /* The following must be defined and are used to calculate the extents of the laden binary itself. _END is one more than the address of the last byte. */ extern char _start; extern char _end; static struct output_driver output_device; static void parse_args (int argc, char *argv[]) { int i = 1; while (i < argc) { if (!strcmp (argv[i], "--usage")) { i++; printf ("Usage %s [OPTION...]\n", argv[0]); printf ("Try `%s --help' for more information\n", program_name); shutdown_machine (); } else if (!strcmp (argv[i], "--help")) { struct output_driver **drv = output_drivers; i++; printf ("Usage: %s [OPTION...]\n" "\n" "Boot the Hurd system and wrap the L4 privileged system " "calls.\n" "\n" " -o, --output DRV use output driver DRV\n" " -D, --debug LEVEL enable debug output (1-5)" #ifdef DEBUG_ELIDE " (disabled)" #endif "\n" " -h, --halt halt the system at error (default)\n" " -r, --reboot reboot the system at error\n" "\n" " --usage print out some usage information and " "exit\n" " --help display this help and exit\n" " --version output version information and exit\n" "\n", argv[0]); printf ("Valid output drivers are: "); while (*drv) { printf ("%s", (*drv)->name); if (drv == output_drivers) printf (" (default)"); drv++; if (*drv && (*drv)->name) printf (", "); else printf (".\n\n"); } printf ("Report bugs to " BUG_ADDRESS ".\n"); shutdown_machine (); } else if (!strcmp (argv[i], "--version")) { i++; printf ("%s " PACKAGE_VERSION "\n", program_name); shutdown_machine (); } else if (!strcmp (argv[i], "-o") || !strcmp (argv[i], "--output")) { i++; if (!output_init (&output_device, argv[i], true)) panic ("Unknown output driver %s", argv[i]); i++; } else if (!strcmp (argv[i], "-h") || !strcmp (argv[i], "--halt")) { i++; shutdown_reset = 0; } else if (!strcmp (argv[i], "-r") || !strcmp (argv[i], "--reset")) { i++; shutdown_reset = 1; } else if (!strcmp (argv[i], "-D") || !strcmp (argv[i], "--debug")) { i++; if (! ('0' <= argv[i][0] && argv[i][0] <= '9')) panic ("Option -D expects an integer argument"); #ifndef DEBUG_ELIDE output_debug = strtol (argv[i], (char **) NULL, 10); #endif i++; } else if (argv[i][0] == '-') panic ("Unsupported option %s", argv[i]); else panic ("Invalid non-option argument %s", argv[i]); } } struct thread * system_task_load (void) { #if 0 const char *const argv[] = { boot_modules[0].command_line, NULL }; struct thread *thread; thread = process_spawn (VG_ADDR_VOID, (void *) boot_modules[0].start, (void *) boot_modules[0].end, argv, NULL, true); /* Free the associated memory. */ memory_reservation_clear (memory_reservation_system_executable); return thread; #endif return 0; } void ager_start (void) { #if 0 const int stack_size = PAGESIZE * 32; void *stack = (void *) zalloc (stack_size); /* XXX: We assume the stack grows down. */ void *sp = stack + stack_size; /* Push the return address onto the stack. */ /* XXX: We assume the stack grows down and we assume that the stack has the normal x86 layout. */ sp -= sizeof (uintptr_t); * (uintptr_t *) sp = 0; l4_thread_id_t tid = l4_global_id (l4_thread_no (l4_myself ()) + 1, l4_version (l4_myself ())); int ret = l4_thread_control (tid, l4_myself (), l4_myself (), l4_myself (), (void *) _L4_utcb_base () + l4_utcb_size ()); if (! ret) panic ("Could not create ager thread (id=%x.%x): %s", l4_thread_no (tid), l4_version (tid), l4_strerror (l4_error_code ())); debug (1, "Created ager: %x", tid); ager_tid = tid; l4_thread_id_t targ = tid; uintptr_t control = _L4_XCHG_REGS_CANCEL_IPC | _L4_XCHG_REGS_SET_SP | _L4_XCHG_REGS_SET_IP; uintptr_t dummy = 0; uintptr_t sp_arg = (uintptr_t) sp; uintptr_t ip = (uintptr_t) ager_loop; _L4_exchange_registers (&targ, &control, &sp_arg, &ip, &dummy, &dummy, &dummy); if (targ == l4_nilthread) panic ("Failed to start ager thread (id=%x.%x): %s", l4_thread_no (tid), l4_version (tid), l4_strerror (l4_error_code ())); #endif } static void bootstrap (void) __attribute__ ((noinline)); static void bootstrap (void) { #if 0 object_init (); ager_start (); /* Load the system task. */ struct thread *thread = system_task_load (); #if 0 /* Discard every second page to try and catch out of bounds errors. After this point, there will be no unallocated frames that are consecutive in memory. */ int discarded = 0; void discard (void *f) { l4_flush (l4_fpage ((l4_word_t) f, PAGESIZE)); discarded ++; } uintptr_t size; for (size = 1 << (sizeof (uintptr_t) * 8 - 1); size > PAGESIZE; size >>= 1) { void *chunk; while ((chunk = zalloc (size))) { void *f = chunk; void *end = chunk + size; /* Discard the first page. */ discard (f); f += PAGESIZE; while (end - f >= 2 * PAGESIZE) { /* Release the second. */ zfree (f, PAGESIZE); f += PAGESIZE; discard (f); f += PAGESIZE; } if (f < end) { assert (f + PAGESIZE == end); discard (f); } } } debug (0, DEBUG_BOLD ("Discarded %d pages"), discarded); #endif /* MEMORY_TOTAL is the total number of frames in the system. We need to know the number of frames that are available to user tasks. This is the sum of the free memory plus that which is already allocated to activities. So far, there is only the root activity. */ memory_total = zalloc_memory + root_activity->frames_total; #endif } int main (int argc, char *argv[]) { parse_args (argc, argv); debug (1, "%s " PACKAGE_VERSION, program_name); /* print hello message */ arch_bootstrap (); /* Bootstrap the system. */ bootstrap (); // TODO #if 0 /* And, start serving requests. */ server_loop (); #endif } /* XXX I adapted the printf routines!!! */ /* XXX temporary */ int backtrace (void **a, int b) { panic ("unimplemented: backrace\n"); } void backtrace_print (void) { panic ("unimplemented: backtrace_print\n"); } void _exit (int a) { panic ("unimplemented: _exit\n"); } #include int __stack_chk_guard = 0xcab00d1e; void __stack_chk_fail (void) { backtrace_print (); panic ("stack check failed!"); } /* temporary errno location */ int errno; /* temporary string routines */ size_t strlen (const char* s) { size_t r = 0; for (;*s;++s,++r); return r; } char* strcpy (char* d, const char* s) { char* r = d; for (;*s;++s,++d) *d = *s; *d = 0; return r; } int strcmp (const char* s1, const char* s2) { while (*s1 && *s2) { if (*s1 > *s2) return 1; else if (*s1 < *s2) return -1; ++s1; ++s2; } if (*s1 == 0 && *s2 == 0) return 0; if (*s1) return 1; return -1; } int strncmp (const char *s1, const char *s2, size_t n) { unsigned char uc1, uc2; /* Nothing to compare? Return zero. */ if (n == 0) return 0; /* Loop, comparing bytes. */ while (n-- > 0 && *s1 == *s2) { /* If we've run out of bytes or hit a null, return zero since we already know *s1 == *s2. */ if (n == 0 || *s1 == '\0') return 0; s1++; s2++; } uc1 = (*(unsigned char *) s1); uc2 = (*(unsigned char *) s2); return ((uc1 < uc2) ? -1 : (uc1 > uc2)); } char* strchr (const char* s, int c) { /* Scan s for the character. When this loop is finished, s will either point to the end of the string or the character we were looking for. */ while (*s != '\0' && *s != (char)c) s++; return ((*s == c) ? (char *) s : NULL); } size_t strcspn (const char* s1, const char* s2) { const char *sc1; for (sc1 = s1; *sc1 != '\0'; sc1++) if (strchr(s2, *sc1) != NULL) return (sc1 - s1); return sc1 - s1; /* terminating nulls match */ } char* strpbrk (const char* s1, const char* s2) { const char *sc1; for (sc1 = s1; *sc1 != '\0'; sc1++) if (strchr(s2, *sc1) != NULL) return (char *)sc1; return NULL; /* terminating nulls match */ } size_t strspn (const char* s1, const char* s2) { const char *sc1; for (sc1 = s1; *sc1 != '\0'; sc1++) if (strchr(s2, *sc1) == NULL) return (sc1 - s1); return sc1 - s1; /* terminating nulls don't match */ } static char* strtok_r (char* s, const char* delimiters, char** lasts) { char *sbegin, *send; sbegin = s ? s : *lasts; sbegin += strspn (sbegin, delimiters); if (*sbegin == '\0') { *lasts = ""; return NULL; } send = sbegin + strcspn (sbegin, delimiters); if (*send != '\0') *send++ = '\0'; *lasts = send; return sbegin; } char* strtok (char* s1, const char* delimiters) { static char* ssave = ""; return strtok_r(s1, delimiters, &ssave); } void* memset (void* s, int c, size_t n) { unsigned char* d = (unsigned char*) s; unsigned char v = (unsigned char) c; for (unsigned i = 0;i < n;++i) d[i] = v; return s; } void* memcpy (void* dst, const void* src, size_t n) { char* cdst = dst; char* csrc = src; for (;n;--n) cdst[n - 1] = csrc[n - 1]; return dst; } unsigned long strtoul (const char *nptr, char **endptr, int base) { return (unsigned long)strtol (nptr, endptr, base); } /* Convert string representation of a number into an integer value. Copyright (C) 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2003 Free Software Foundation, Inc. NOTE: The canonical source of this file is maintained with the GNU C Library. Bugs can be reported to bug-glibc@gnu.org. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #if HAVE_CONFIG_H # include #endif #ifdef _LIBC # define USE_NUMBER_GROUPING #endif #include #include #ifndef errno extern int errno; #endif #ifndef __set_errno # define __set_errno(Val) errno = (Val) #endif #include #include #include #include #ifdef USE_NUMBER_GROUPING # include "../locale/localeinfo.h" #endif /* Nonzero if we are defining `strtoul' or `strtoull', operating on unsigned integers. */ #ifndef UNSIGNED # define UNSIGNED 0 # define INT LONG int #else # define INT unsigned LONG int #endif /* Determine the name. */ #ifdef USE_IN_EXTENDED_LOCALE_MODEL # if UNSIGNED # ifdef USE_WIDE_CHAR # ifdef QUAD # define strtol __wcstoull_l # else # define strtol __wcstoul_l # endif # else # ifdef QUAD # define strtol __strtoull_l # else # define strtol __strtoul_l # endif # endif # else # ifdef USE_WIDE_CHAR # ifdef QUAD # define strtol __wcstoll_l # else # define strtol __wcstol_l # endif # else # ifdef QUAD # define strtol __strtoll_l # else # define strtol __strtol_l # endif # endif # endif #else # if UNSIGNED # ifdef USE_WIDE_CHAR # ifdef QUAD # define strtol wcstoull # else # define strtol wcstoul # endif # else # ifdef QUAD # define strtol strtoull # else # define strtol strtoul # endif # endif # else # ifdef USE_WIDE_CHAR # ifdef QUAD # define strtol wcstoll # else # define strtol wcstol # endif # else # ifdef QUAD # define strtol strtoll # endif # endif # endif #endif /* If QUAD is defined, we are defining `strtoll' or `strtoull', operating on `long long int's. */ #ifdef QUAD # define LONG long long # define STRTOL_LONG_MIN LONG_LONG_MIN # define STRTOL_LONG_MAX LONG_LONG_MAX # define STRTOL_ULONG_MAX ULONG_LONG_MAX /* The extra casts work around common compiler bugs, e.g. Cray C 5.0.3.0 when t == time_t. */ # ifndef TYPE_SIGNED # define TYPE_SIGNED(t) (! ((t) 0 < (t) -1)) # endif # ifndef TYPE_MINIMUM # define TYPE_MINIMUM(t) ((t) (TYPE_SIGNED (t) \ ? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) \ : (t) 0)) # endif # ifndef TYPE_MAXIMUM # define TYPE_MAXIMUM(t) ((t) (~ (t) 0 - TYPE_MINIMUM (t))) # endif # ifndef ULONG_LONG_MAX # define ULONG_LONG_MAX TYPE_MAXIMUM (unsigned long long) # endif # ifndef LONG_LONG_MAX # define LONG_LONG_MAX TYPE_MAXIMUM (long long int) # endif # ifndef LONG_LONG_MIN # define LONG_LONG_MIN TYPE_MINIMUM (long long int) # endif # if __GNUC__ == 2 && __GNUC_MINOR__ < 7 /* Work around gcc bug with using this constant. */ static const unsigned long long int maxquad = ULONG_LONG_MAX; # undef STRTOL_ULONG_MAX # define STRTOL_ULONG_MAX maxquad # endif #else # define LONG long # define STRTOL_LONG_MIN LONG_MIN # define STRTOL_LONG_MAX LONG_MAX # define STRTOL_ULONG_MAX ULONG_MAX #endif /* We use this code also for the extended locale handling where the function gets as an additional argument the locale which has to be used. To access the values we have to redefine the _NL_CURRENT macro. */ #ifdef USE_IN_EXTENDED_LOCALE_MODEL # undef _NL_CURRENT # define _NL_CURRENT(category, item) \ (current->values[_NL_ITEM_INDEX (item)].string) # define LOCALE_PARAM , loc # define LOCALE_PARAM_PROTO , __locale_t loc #else # define LOCALE_PARAM # define LOCALE_PARAM_PROTO #endif #if defined _LIBC || defined HAVE_WCHAR_H # include #endif #ifdef USE_WIDE_CHAR # include # define L_(Ch) L##Ch # define UCHAR_TYPE wint_t # define STRING_TYPE wchar_t # ifdef USE_IN_EXTENDED_LOCALE_MODEL # define ISSPACE(Ch) __iswspace_l ((Ch), loc) # define ISALPHA(Ch) __iswalpha_l ((Ch), loc) # define TOUPPER(Ch) __towupper_l ((Ch), loc) # else # define ISSPACE(Ch) iswspace (Ch) # define ISALPHA(Ch) iswalpha (Ch) # define TOUPPER(Ch) towupper (Ch) # endif #else # if defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII) # define IN_CTYPE_DOMAIN(c) 1 # else # define IN_CTYPE_DOMAIN(c) isascii(c) # endif # define L_(Ch) Ch # define UCHAR_TYPE unsigned char # define STRING_TYPE char # ifdef USE_IN_EXTENDED_LOCALE_MODEL # define ISSPACE(Ch) __isspace_l ((Ch), loc) # define ISALPHA(Ch) __isalpha_l ((Ch), loc) # define TOUPPER(Ch) __toupper_l ((Ch), loc) # else # define ISSPACE(Ch) (IN_CTYPE_DOMAIN (Ch) && isspace (Ch)) # define ISALPHA(Ch) (IN_CTYPE_DOMAIN (Ch) && isalpha (Ch)) # define TOUPPER(Ch) (IN_CTYPE_DOMAIN (Ch) ? toupper (Ch) : (Ch)) # endif #endif #define INTERNAL(X) INTERNAL1(X) #define INTERNAL1(X) __##X##_internal #define WEAKNAME(X) WEAKNAME1(X) #ifdef USE_NUMBER_GROUPING /* This file defines a function to check for correct grouping. */ # include "grouping.h" #endif /* Convert NPTR to an `unsigned long int' or `long int' in base BASE. If BASE is 0 the base is determined by the presence of a leading zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal. If BASE is < 2 or > 36, it is reset to 10. If ENDPTR is not NULL, a pointer to the character after the last one converted is stored in *ENDPTR. */ INT INTERNAL (strtol) (const STRING_TYPE *nptr, STRING_TYPE **endptr, int base, int group LOCALE_PARAM_PROTO) { int negative; register unsigned LONG int cutoff; register unsigned int cutlim; register unsigned LONG int i; register const STRING_TYPE *s; register UCHAR_TYPE c; const STRING_TYPE *save, *end; int overflow; #ifdef USE_NUMBER_GROUPING # ifdef USE_IN_EXTENDED_LOCALE_MODEL struct locale_data *current = loc->__locales[LC_NUMERIC]; # endif /* The thousands character of the current locale. */ wchar_t thousands = L'\0'; /* The numeric grouping specification of the current locale, in the format described in . */ const char *grouping; if (group) { grouping = _NL_CURRENT (LC_NUMERIC, GROUPING); if (*grouping <= 0 || *grouping == CHAR_MAX) grouping = NULL; else { /* Figure out the thousands separator character. */ # if defined _LIBC || defined _HAVE_BTOWC thousands = __btowc (*_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP)); if (thousands == WEOF) thousands = L'\0'; # endif if (thousands == L'\0') grouping = NULL; } } else grouping = NULL; #endif if (base < 0 || base == 1 || base > 36) { __set_errno (EINVAL); return 0; } save = s = nptr; /* Skip white space. */ while (ISSPACE (*s)) ++s; if (*s == L_('\0')) goto noconv; /* Check for a sign. */ if (*s == L_('-')) { negative = 1; ++s; } else if (*s == L_('+')) { negative = 0; ++s; } else negative = 0; /* Recognize number prefix and if BASE is zero, figure it out ourselves. */ if (*s == L_('0')) { if ((base == 0 || base == 16) && TOUPPER (s[1]) == L_('X')) { s += 2; base = 16; } else if (base == 0) base = 8; } else if (base == 0) base = 10; /* Save the pointer so we can check later if anything happened. */ save = s; #ifdef USE_NUMBER_GROUPING if (group) { /* Find the end of the digit string and check its grouping. */ end = s; for (c = *end; c != L_('\0'); c = *++end) if ((wchar_t) c != thousands && ((wchar_t) c < L_('0') || (wchar_t) c > L_('9')) && (!ISALPHA (c) || (int) (TOUPPER (c) - L_('A') + 10) >= base)) break; if (*s == thousands) end = s; else end = correctly_grouped_prefix (s, end, thousands, grouping); } else #endif end = NULL; cutoff = STRTOL_ULONG_MAX / (unsigned LONG int) base; cutlim = STRTOL_ULONG_MAX % (unsigned LONG int) base; overflow = 0; i = 0; for (c = *s; c != L_('\0'); c = *++s) { if (s == end) break; if (c >= L_('0') && c <= L_('9')) c -= L_('0'); else if (ISALPHA (c)) c = TOUPPER (c) - L_('A') + 10; else break; if ((int) c >= base) break; /* Check for overflow. */ if (i > cutoff || (i == cutoff && c > cutlim)) overflow = 1; else { i *= (unsigned LONG int) base; i += c; } } /* Check if anything actually happened. */ if (s == save) goto noconv; /* Store in ENDPTR the address of one character past the last character we converted. */ if (endptr != NULL) *endptr = (STRING_TYPE *) s; #if !UNSIGNED /* Check for a value that is within the range of `unsigned LONG int', but outside the range of `LONG int'. */ if (overflow == 0 && i > (negative ? -((unsigned LONG int) (STRTOL_LONG_MIN + 1)) + 1 : (unsigned LONG int) STRTOL_LONG_MAX)) overflow = 1; #endif if (overflow) { __set_errno (ERANGE); #if UNSIGNED return STRTOL_ULONG_MAX; #else return negative ? STRTOL_LONG_MIN : STRTOL_LONG_MAX; #endif } /* Return the result of the appropriate sign. */ return negative ? -i : i; noconv: /* We must handle a special case here: the base is 0 or 16 and the first two characters are '0' and 'x', but the rest are no hexadecimal digits. This is no error case. We return 0 and ENDPTR points to the `x`. */ if (endptr != NULL) { if (save - nptr >= 2 && TOUPPER (save[-1]) == L_('X') && save[-2] == L_('0')) *endptr = (STRING_TYPE *) &save[-1]; else /* There was no number to convert. */ *endptr = (STRING_TYPE *) nptr; } return 0L; } /* External user entry point. */ INT #ifdef weak_function weak_function #endif strtol (const STRING_TYPE *nptr, STRING_TYPE **endptr, int base LOCALE_PARAM_PROTO) { return INTERNAL (strtol) (nptr, endptr, base, 0 LOCALE_PARAM); } #if HAVE_CONFIG_H #include #endif #ifndef RM_INTERN static void io_buffer_flush (struct io_buffer *buffer) { if (buffer->len == 0) return; rm_write (*buffer); buffer->len = 0; } static void io_buffer_append (struct io_buffer *buffer, int chr) { if (buffer->len == sizeof (buffer->data)) io_buffer_flush (buffer); buffer->data[buffer->len ++] = chr; } #endif /* Print the single character CHR on the output device. */ int s_putchar (int chr) { #if defined(RM_INTERN) || defined(_L4_TEST_ENVIRONMENT) /* For Viengoos, use driver putchar routine. For the test environment, just use the stdio putchar. */ extern int putchar (int chr); return putchar (chr); #else struct io_buffer buffer; buffer.len = 1; buffer.data[0] = chr; rm_write (buffer); return 0; #endif } int s_cputs (int (*putchar) (int), const char *str) { while (*str != '\0') putchar (*(str++)); putchar ('\n'); return 0; } int s_puts (const char *str) { #ifndef RM_INTERN struct io_buffer buffer; buffer.len = 0; int putchar (int chr) { io_buffer_append (&buffer, chr); return 0; } #endif int ret = s_cputs (putchar, str); #ifndef RM_INTERN io_buffer_flush (&buffer); #endif return ret; } /* Output format flags. */ #define FLAG_LONGLONG (1 << 0) #define FLAG_PAD_ZERO (1 << 1) #define FLAG_BASE (1 << 2) #define FLAG_UPPERCASE (1 << 3) #define FLAG_LONG (1 << 4) static void print_nr (unsigned long long nr, int base, int precision, unsigned int flags) { static char *digits; char str[30]; int i = 0; digits = (flags & FLAG_UPPERCASE) ? "0123456789ABCDEF" : "0123456789abcdef"; if (flags & FLAG_BASE) { if (base == 16) { putchar ('0'); putchar ((flags & FLAG_UPPERCASE) ? 'X' : 'x'); } else if (base == 8) putchar ('0'); } do { str[i++] = digits[nr % base]; nr = nr / base; } while (nr); if (precision >= sizeof (str)) precision = sizeof (str); while (i < precision) str[i++] = (flags & FLAG_PAD_ZERO) ? '0' : ' '; i--; while (i >= 0) putchar (str[i--]); } static void print_signed_nr (long long nr, int base, int precision, unsigned int flags) { unsigned long long unr; if (nr < 0) { putchar ('-'); unr = -nr; } else unr = nr; print_nr (unr, base, precision, flags); } int s_cvprintf (int (*putchar) (int), const char *fmt, va_list ap) { int precision = 0; unsigned int flags = 0; bool done; const char *p = fmt; while (*p != '\0') { const char *startp; if (*p != '%') { putchar (*(p++)); continue; } p++; startp = p; flags = 0; precision = 0; done = false; while (*p && !done) { switch (*p) { case '%': putchar ('%'); p++; done = true; break; case '#': flags |= FLAG_BASE; p++; break; case '0': flags |= FLAG_PAD_ZERO; p++; break; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': while (*p >= '0' && *p <= '9') { precision = precision * 10; precision += *(p++) - '0'; } break; case 'l': p++; if (*p == 'l') { p++; flags |= FLAG_LONGLONG; } else flags |= FLAG_LONG; break; case 'o': if (flags & FLAG_LONGLONG) print_nr (va_arg (ap, unsigned long long), 8, precision, flags); else if (flags & FLAG_LONG) print_nr (va_arg (ap, unsigned long), 8, precision, flags); else print_nr (va_arg (ap, unsigned int), 8, precision, flags); p++; done = true; break; case 'd': case 'i': if (flags & FLAG_LONGLONG) print_signed_nr (va_arg (ap, long long), 10, precision, flags); else if (flags & FLAG_LONG) print_signed_nr (va_arg (ap, long), 10, precision, flags); else print_signed_nr (va_arg (ap, int), 10, precision, flags); p++; done = true; break; case 'X': flags |= FLAG_UPPERCASE; /* Fall-through. */ case 'x': if (flags & FLAG_LONGLONG) print_nr (va_arg (ap, unsigned long long), 16, precision, flags); else if (flags & FLAG_LONG) print_nr (va_arg (ap, unsigned long), 16, precision, flags); else print_nr (va_arg (ap, unsigned int), 16, precision, flags); p++; done = true; break; case 'u': if (flags & FLAG_LONGLONG) print_nr (va_arg (ap, unsigned long long), 10, precision, flags); else if (flags & FLAG_LONG) print_nr (va_arg (ap, unsigned long), 10, precision, flags); else print_nr (va_arg (ap, unsigned int), 10, precision, flags); p++; done = true; break; case 'c': putchar (va_arg (ap, int)); p++; done = true; break; case 's': { char *str = va_arg (ap, char *); while (*str) putchar (*(str++)); } p++; done = true; break; case 'P': flags |= FLAG_UPPERCASE; /* Fall-through. */ case 'p': flags |= FLAG_BASE; print_nr ((uintptr_t) va_arg (ap, void *), 16, precision, flags); p++; done = true; break; default: putchar ('%'); p++; while (startp < p) putchar (*(startp++)); done = true; break; } } } return 0; #if 0 const char *p = fmt; while (*p != '\0') { if (*p != '%') { putchar (*(p++)); continue; } p++; switch (*p) { case '%': putchar ('%'); p++; break; case 'l': p++; if (*p != 'l') { putchar ('%'); putchar ('l'); putchar (*(p++)); continue; } p++; switch (*p) { case 'o': print_nr (putchar, va_arg (ap, unsigned long long), 8); p++; break; case 'd': case 'i': print_signed_nr (putchar, va_arg (ap, long long), 10); p++; break; case 'x': case 'X': print_nr (putchar, va_arg (ap, unsigned long long), 16); p++; break; case 'u': print_nr (putchar, va_arg (ap, unsigned long long), 10); p++; break; default: putchar ('%'); putchar ('l'); putchar ('l'); putchar (*(p++)); break; } break; case 'o': print_nr (putchar, va_arg (ap, unsigned int), 8); p++; break; case 'd': case 'i': print_signed_nr (putchar, va_arg (ap, int), 10); p++; break; case 'x': case 'X': print_nr (putchar, va_arg (ap, unsigned int), 16); p++; break; case 'u': print_nr (putchar, va_arg (ap, unsigned int), 10); p++; break; case 'c': putchar (va_arg (ap, int)); p++; break; case 's': { char *str = va_arg (ap, char *); if (str) while (*str) putchar (*(str++)); else { putchar ('N'); putchar ('U'); putchar ('L'); putchar ('L'); } } p++; break; case 'p': print_nr (putchar, (unsigned int) va_arg (ap, void *), 16); p++; break; default: putchar ('%'); putchar (*p); p++; break; } } return 0; #endif } int s_vprintf (const char *fmt, va_list ap) { #ifndef RM_INTERN struct io_buffer buffer; buffer.len = 0; int putchar (int chr) { io_buffer_append (&buffer, chr); return 0; } #endif int ret = s_cvprintf (putchar, fmt, ap); #ifndef RM_INTERN io_buffer_flush (&buffer); #endif return ret; } int s_cprintf (int (*putchar) (int), const char *fmt, ...) { va_list ap; va_start (ap, fmt); int r = s_cvprintf (putchar, fmt, ap); va_end (ap); return r; } int s_printf (const char *fmt, ...) { #ifndef RM_INTERN struct io_buffer buffer; buffer.len = 0; int putchar (int chr) { io_buffer_append (&buffer, chr); return 0; } #endif va_list ap; va_start (ap, fmt); int r = s_cvprintf (putchar, fmt, ap); va_end (ap); #ifndef RM_INTERN io_buffer_flush (&buffer); #endif return r; }