forked from luck/tmp_suning_uos_patched
7840e5e95c
if num has a value of -1, accessing the digits[] array will fail and the format string will be printed in funny way, or not at all. This happens if one prints negative numbers. Just change the code to match lib/vsprintf.c asm/div64.h cant be used because u64 maps to u32 for this build. Signed-off-by: Olaf Hering <olh@suse.de> Signed-off-by: Paul Mackerras <paulus@samba.org>
654 lines
12 KiB
C
654 lines
12 KiB
C
/*
|
|
* Copyright (C) Paul Mackerras 1997.
|
|
*
|
|
* 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
|
|
* 2 of the License, or (at your option) any later version.
|
|
*/
|
|
#include <stdarg.h>
|
|
#include <linux/types.h>
|
|
#include <linux/string.h>
|
|
#include <linux/ctype.h>
|
|
|
|
extern __u32 __div64_32(unsigned long long *dividend, __u32 divisor);
|
|
|
|
/* The unnecessary pointer compare is there
|
|
* to check for type safety (n must be 64bit)
|
|
*/
|
|
# define do_div(n,base) ({ \
|
|
__u32 __base = (base); \
|
|
__u32 __rem; \
|
|
(void)(((typeof((n)) *)0) == ((unsigned long long *)0)); \
|
|
if (((n) >> 32) == 0) { \
|
|
__rem = (__u32)(n) % __base; \
|
|
(n) = (__u32)(n) / __base; \
|
|
} else \
|
|
__rem = __div64_32(&(n), __base); \
|
|
__rem; \
|
|
})
|
|
|
|
int (*prom)(void *);
|
|
|
|
void *chosen_handle;
|
|
void *stdin;
|
|
void *stdout;
|
|
void *stderr;
|
|
|
|
void exit(void);
|
|
void *finddevice(const char *name);
|
|
int getprop(void *phandle, const char *name, void *buf, int buflen);
|
|
void chrpboot(int a1, int a2, void *prom); /* in main.c */
|
|
|
|
void printk(char *fmt, ...);
|
|
|
|
/* there is no convenient header to get this from... -- paulus */
|
|
extern unsigned long strlen(const char *);
|
|
|
|
int
|
|
write(void *handle, void *ptr, int nb)
|
|
{
|
|
struct prom_args {
|
|
char *service;
|
|
int nargs;
|
|
int nret;
|
|
void *ihandle;
|
|
void *addr;
|
|
int len;
|
|
int actual;
|
|
} args;
|
|
|
|
args.service = "write";
|
|
args.nargs = 3;
|
|
args.nret = 1;
|
|
args.ihandle = handle;
|
|
args.addr = ptr;
|
|
args.len = nb;
|
|
args.actual = -1;
|
|
(*prom)(&args);
|
|
return args.actual;
|
|
}
|
|
|
|
int
|
|
read(void *handle, void *ptr, int nb)
|
|
{
|
|
struct prom_args {
|
|
char *service;
|
|
int nargs;
|
|
int nret;
|
|
void *ihandle;
|
|
void *addr;
|
|
int len;
|
|
int actual;
|
|
} args;
|
|
|
|
args.service = "read";
|
|
args.nargs = 3;
|
|
args.nret = 1;
|
|
args.ihandle = handle;
|
|
args.addr = ptr;
|
|
args.len = nb;
|
|
args.actual = -1;
|
|
(*prom)(&args);
|
|
return args.actual;
|
|
}
|
|
|
|
void
|
|
exit()
|
|
{
|
|
struct prom_args {
|
|
char *service;
|
|
} args;
|
|
|
|
for (;;) {
|
|
args.service = "exit";
|
|
(*prom)(&args);
|
|
}
|
|
}
|
|
|
|
void
|
|
pause(void)
|
|
{
|
|
struct prom_args {
|
|
char *service;
|
|
} args;
|
|
|
|
args.service = "enter";
|
|
(*prom)(&args);
|
|
}
|
|
|
|
void *
|
|
finddevice(const char *name)
|
|
{
|
|
struct prom_args {
|
|
char *service;
|
|
int nargs;
|
|
int nret;
|
|
const char *devspec;
|
|
void *phandle;
|
|
} args;
|
|
|
|
args.service = "finddevice";
|
|
args.nargs = 1;
|
|
args.nret = 1;
|
|
args.devspec = name;
|
|
args.phandle = (void *) -1;
|
|
(*prom)(&args);
|
|
return args.phandle;
|
|
}
|
|
|
|
void *
|
|
claim(unsigned long virt, unsigned long size, unsigned long align)
|
|
{
|
|
struct prom_args {
|
|
char *service;
|
|
int nargs;
|
|
int nret;
|
|
unsigned int virt;
|
|
unsigned int size;
|
|
unsigned int align;
|
|
void *ret;
|
|
} args;
|
|
|
|
args.service = "claim";
|
|
args.nargs = 3;
|
|
args.nret = 1;
|
|
args.virt = virt;
|
|
args.size = size;
|
|
args.align = align;
|
|
(*prom)(&args);
|
|
return args.ret;
|
|
}
|
|
|
|
int
|
|
getprop(void *phandle, const char *name, void *buf, int buflen)
|
|
{
|
|
struct prom_args {
|
|
char *service;
|
|
int nargs;
|
|
int nret;
|
|
void *phandle;
|
|
const char *name;
|
|
void *buf;
|
|
int buflen;
|
|
int size;
|
|
} args;
|
|
|
|
args.service = "getprop";
|
|
args.nargs = 4;
|
|
args.nret = 1;
|
|
args.phandle = phandle;
|
|
args.name = name;
|
|
args.buf = buf;
|
|
args.buflen = buflen;
|
|
args.size = -1;
|
|
(*prom)(&args);
|
|
return args.size;
|
|
}
|
|
|
|
int
|
|
putc(int c, void *f)
|
|
{
|
|
char ch = c;
|
|
|
|
if (c == '\n')
|
|
putc('\r', f);
|
|
return write(f, &ch, 1) == 1? c: -1;
|
|
}
|
|
|
|
int
|
|
putchar(int c)
|
|
{
|
|
return putc(c, stdout);
|
|
}
|
|
|
|
int
|
|
fputs(char *str, void *f)
|
|
{
|
|
int n = strlen(str);
|
|
|
|
return write(f, str, n) == n? 0: -1;
|
|
}
|
|
|
|
int
|
|
readchar(void)
|
|
{
|
|
char ch;
|
|
|
|
for (;;) {
|
|
switch (read(stdin, &ch, 1)) {
|
|
case 1:
|
|
return ch;
|
|
case -1:
|
|
printk("read(stdin) returned -1\r\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
static char line[256];
|
|
static char *lineptr;
|
|
static int lineleft;
|
|
|
|
int
|
|
getchar(void)
|
|
{
|
|
int c;
|
|
|
|
if (lineleft == 0) {
|
|
lineptr = line;
|
|
for (;;) {
|
|
c = readchar();
|
|
if (c == -1 || c == 4)
|
|
break;
|
|
if (c == '\r' || c == '\n') {
|
|
*lineptr++ = '\n';
|
|
putchar('\n');
|
|
break;
|
|
}
|
|
switch (c) {
|
|
case 0177:
|
|
case '\b':
|
|
if (lineptr > line) {
|
|
putchar('\b');
|
|
putchar(' ');
|
|
putchar('\b');
|
|
--lineptr;
|
|
}
|
|
break;
|
|
case 'U' & 0x1F:
|
|
while (lineptr > line) {
|
|
putchar('\b');
|
|
putchar(' ');
|
|
putchar('\b');
|
|
--lineptr;
|
|
}
|
|
break;
|
|
default:
|
|
if (lineptr >= &line[sizeof(line) - 1])
|
|
putchar('\a');
|
|
else {
|
|
putchar(c);
|
|
*lineptr++ = c;
|
|
}
|
|
}
|
|
}
|
|
lineleft = lineptr - line;
|
|
lineptr = line;
|
|
}
|
|
if (lineleft == 0)
|
|
return -1;
|
|
--lineleft;
|
|
return *lineptr++;
|
|
}
|
|
|
|
|
|
|
|
/* String functions lifted from lib/vsprintf.c and lib/ctype.c */
|
|
unsigned char _ctype[] = {
|
|
_C,_C,_C,_C,_C,_C,_C,_C, /* 0-7 */
|
|
_C,_C|_S,_C|_S,_C|_S,_C|_S,_C|_S,_C,_C, /* 8-15 */
|
|
_C,_C,_C,_C,_C,_C,_C,_C, /* 16-23 */
|
|
_C,_C,_C,_C,_C,_C,_C,_C, /* 24-31 */
|
|
_S|_SP,_P,_P,_P,_P,_P,_P,_P, /* 32-39 */
|
|
_P,_P,_P,_P,_P,_P,_P,_P, /* 40-47 */
|
|
_D,_D,_D,_D,_D,_D,_D,_D, /* 48-55 */
|
|
_D,_D,_P,_P,_P,_P,_P,_P, /* 56-63 */
|
|
_P,_U|_X,_U|_X,_U|_X,_U|_X,_U|_X,_U|_X,_U, /* 64-71 */
|
|
_U,_U,_U,_U,_U,_U,_U,_U, /* 72-79 */
|
|
_U,_U,_U,_U,_U,_U,_U,_U, /* 80-87 */
|
|
_U,_U,_U,_P,_P,_P,_P,_P, /* 88-95 */
|
|
_P,_L|_X,_L|_X,_L|_X,_L|_X,_L|_X,_L|_X,_L, /* 96-103 */
|
|
_L,_L,_L,_L,_L,_L,_L,_L, /* 104-111 */
|
|
_L,_L,_L,_L,_L,_L,_L,_L, /* 112-119 */
|
|
_L,_L,_L,_P,_P,_P,_P,_C, /* 120-127 */
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 128-143 */
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 144-159 */
|
|
_S|_SP,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P, /* 160-175 */
|
|
_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P, /* 176-191 */
|
|
_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U, /* 192-207 */
|
|
_U,_U,_U,_U,_U,_U,_U,_P,_U,_U,_U,_U,_U,_U,_U,_L, /* 208-223 */
|
|
_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L, /* 224-239 */
|
|
_L,_L,_L,_L,_L,_L,_L,_P,_L,_L,_L,_L,_L,_L,_L,_L}; /* 240-255 */
|
|
|
|
size_t strnlen(const char * s, size_t count)
|
|
{
|
|
const char *sc;
|
|
|
|
for (sc = s; count-- && *sc != '\0'; ++sc)
|
|
/* nothing */;
|
|
return sc - s;
|
|
}
|
|
|
|
unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base)
|
|
{
|
|
unsigned long result = 0,value;
|
|
|
|
if (!base) {
|
|
base = 10;
|
|
if (*cp == '0') {
|
|
base = 8;
|
|
cp++;
|
|
if ((*cp == 'x') && isxdigit(cp[1])) {
|
|
cp++;
|
|
base = 16;
|
|
}
|
|
}
|
|
}
|
|
while (isxdigit(*cp) &&
|
|
(value = isdigit(*cp) ? *cp-'0' : toupper(*cp)-'A'+10) < base) {
|
|
result = result*base + value;
|
|
cp++;
|
|
}
|
|
if (endp)
|
|
*endp = (char *)cp;
|
|
return result;
|
|
}
|
|
|
|
long simple_strtol(const char *cp,char **endp,unsigned int base)
|
|
{
|
|
if(*cp=='-')
|
|
return -simple_strtoul(cp+1,endp,base);
|
|
return simple_strtoul(cp,endp,base);
|
|
}
|
|
|
|
static int skip_atoi(const char **s)
|
|
{
|
|
int i=0;
|
|
|
|
while (isdigit(**s))
|
|
i = i*10 + *((*s)++) - '0';
|
|
return i;
|
|
}
|
|
|
|
#define ZEROPAD 1 /* pad with zero */
|
|
#define SIGN 2 /* unsigned/signed long */
|
|
#define PLUS 4 /* show plus */
|
|
#define SPACE 8 /* space if plus */
|
|
#define LEFT 16 /* left justified */
|
|
#define SPECIAL 32 /* 0x */
|
|
#define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
|
|
|
|
static char * number(char * str, unsigned long long num, int base, int size, int precision, int type)
|
|
{
|
|
char c,sign,tmp[66];
|
|
const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
|
|
int i;
|
|
|
|
if (type & LARGE)
|
|
digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
if (type & LEFT)
|
|
type &= ~ZEROPAD;
|
|
if (base < 2 || base > 36)
|
|
return 0;
|
|
c = (type & ZEROPAD) ? '0' : ' ';
|
|
sign = 0;
|
|
if (type & SIGN) {
|
|
if ((signed long long)num < 0) {
|
|
sign = '-';
|
|
num = - (signed long long)num;
|
|
size--;
|
|
} else if (type & PLUS) {
|
|
sign = '+';
|
|
size--;
|
|
} else if (type & SPACE) {
|
|
sign = ' ';
|
|
size--;
|
|
}
|
|
}
|
|
if (type & SPECIAL) {
|
|
if (base == 16)
|
|
size -= 2;
|
|
else if (base == 8)
|
|
size--;
|
|
}
|
|
i = 0;
|
|
if (num == 0)
|
|
tmp[i++]='0';
|
|
else while (num != 0) {
|
|
tmp[i++] = digits[do_div(num, base)];
|
|
}
|
|
if (i > precision)
|
|
precision = i;
|
|
size -= precision;
|
|
if (!(type&(ZEROPAD+LEFT)))
|
|
while(size-->0)
|
|
*str++ = ' ';
|
|
if (sign)
|
|
*str++ = sign;
|
|
if (type & SPECIAL) {
|
|
if (base==8)
|
|
*str++ = '0';
|
|
else if (base==16) {
|
|
*str++ = '0';
|
|
*str++ = digits[33];
|
|
}
|
|
}
|
|
if (!(type & LEFT))
|
|
while (size-- > 0)
|
|
*str++ = c;
|
|
while (i < precision--)
|
|
*str++ = '0';
|
|
while (i-- > 0)
|
|
*str++ = tmp[i];
|
|
while (size-- > 0)
|
|
*str++ = ' ';
|
|
return str;
|
|
}
|
|
|
|
/* Forward decl. needed for IP address printing stuff... */
|
|
int sprintf(char * buf, const char *fmt, ...);
|
|
|
|
int vsprintf(char *buf, const char *fmt, va_list args)
|
|
{
|
|
int len;
|
|
unsigned long long num;
|
|
int i, base;
|
|
char * str;
|
|
const char *s;
|
|
|
|
int flags; /* flags to number() */
|
|
|
|
int field_width; /* width of output field */
|
|
int precision; /* min. # of digits for integers; max
|
|
number of chars for from string */
|
|
int qualifier; /* 'h', 'l', or 'L' for integer fields */
|
|
/* 'z' support added 23/7/1999 S.H. */
|
|
/* 'z' changed to 'Z' --davidm 1/25/99 */
|
|
|
|
|
|
for (str=buf ; *fmt ; ++fmt) {
|
|
if (*fmt != '%') {
|
|
*str++ = *fmt;
|
|
continue;
|
|
}
|
|
|
|
/* process flags */
|
|
flags = 0;
|
|
repeat:
|
|
++fmt; /* this also skips first '%' */
|
|
switch (*fmt) {
|
|
case '-': flags |= LEFT; goto repeat;
|
|
case '+': flags |= PLUS; goto repeat;
|
|
case ' ': flags |= SPACE; goto repeat;
|
|
case '#': flags |= SPECIAL; goto repeat;
|
|
case '0': flags |= ZEROPAD; goto repeat;
|
|
}
|
|
|
|
/* get field width */
|
|
field_width = -1;
|
|
if (isdigit(*fmt))
|
|
field_width = skip_atoi(&fmt);
|
|
else if (*fmt == '*') {
|
|
++fmt;
|
|
/* it's the next argument */
|
|
field_width = va_arg(args, int);
|
|
if (field_width < 0) {
|
|
field_width = -field_width;
|
|
flags |= LEFT;
|
|
}
|
|
}
|
|
|
|
/* get the precision */
|
|
precision = -1;
|
|
if (*fmt == '.') {
|
|
++fmt;
|
|
if (isdigit(*fmt))
|
|
precision = skip_atoi(&fmt);
|
|
else if (*fmt == '*') {
|
|
++fmt;
|
|
/* it's the next argument */
|
|
precision = va_arg(args, int);
|
|
}
|
|
if (precision < 0)
|
|
precision = 0;
|
|
}
|
|
|
|
/* get the conversion qualifier */
|
|
qualifier = -1;
|
|
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt =='Z') {
|
|
qualifier = *fmt;
|
|
++fmt;
|
|
}
|
|
|
|
/* default base */
|
|
base = 10;
|
|
|
|
switch (*fmt) {
|
|
case 'c':
|
|
if (!(flags & LEFT))
|
|
while (--field_width > 0)
|
|
*str++ = ' ';
|
|
*str++ = (unsigned char) va_arg(args, int);
|
|
while (--field_width > 0)
|
|
*str++ = ' ';
|
|
continue;
|
|
|
|
case 's':
|
|
s = va_arg(args, char *);
|
|
if (!s)
|
|
s = "<NULL>";
|
|
|
|
len = strnlen(s, precision);
|
|
|
|
if (!(flags & LEFT))
|
|
while (len < field_width--)
|
|
*str++ = ' ';
|
|
for (i = 0; i < len; ++i)
|
|
*str++ = *s++;
|
|
while (len < field_width--)
|
|
*str++ = ' ';
|
|
continue;
|
|
|
|
case 'p':
|
|
if (field_width == -1) {
|
|
field_width = 2*sizeof(void *);
|
|
flags |= ZEROPAD;
|
|
}
|
|
str = number(str,
|
|
(unsigned long) va_arg(args, void *), 16,
|
|
field_width, precision, flags);
|
|
continue;
|
|
|
|
|
|
case 'n':
|
|
if (qualifier == 'l') {
|
|
long * ip = va_arg(args, long *);
|
|
*ip = (str - buf);
|
|
} else if (qualifier == 'Z') {
|
|
size_t * ip = va_arg(args, size_t *);
|
|
*ip = (str - buf);
|
|
} else {
|
|
int * ip = va_arg(args, int *);
|
|
*ip = (str - buf);
|
|
}
|
|
continue;
|
|
|
|
case '%':
|
|
*str++ = '%';
|
|
continue;
|
|
|
|
/* integer number formats - set up the flags and "break" */
|
|
case 'o':
|
|
base = 8;
|
|
break;
|
|
|
|
case 'X':
|
|
flags |= LARGE;
|
|
case 'x':
|
|
base = 16;
|
|
break;
|
|
|
|
case 'd':
|
|
case 'i':
|
|
flags |= SIGN;
|
|
case 'u':
|
|
break;
|
|
|
|
default:
|
|
*str++ = '%';
|
|
if (*fmt)
|
|
*str++ = *fmt;
|
|
else
|
|
--fmt;
|
|
continue;
|
|
}
|
|
if (qualifier == 'l') {
|
|
num = va_arg(args, unsigned long);
|
|
if (flags & SIGN)
|
|
num = (signed long) num;
|
|
} else if (qualifier == 'Z') {
|
|
num = va_arg(args, size_t);
|
|
} else if (qualifier == 'h') {
|
|
num = (unsigned short) va_arg(args, int);
|
|
if (flags & SIGN)
|
|
num = (signed short) num;
|
|
} else {
|
|
num = va_arg(args, unsigned int);
|
|
if (flags & SIGN)
|
|
num = (signed int) num;
|
|
}
|
|
str = number(str, num, base, field_width, precision, flags);
|
|
}
|
|
*str = '\0';
|
|
return str-buf;
|
|
}
|
|
|
|
int sprintf(char * buf, const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
int i;
|
|
|
|
va_start(args, fmt);
|
|
i=vsprintf(buf,fmt,args);
|
|
va_end(args);
|
|
return i;
|
|
}
|
|
|
|
static char sprint_buf[1024];
|
|
|
|
void
|
|
printk(char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
int n;
|
|
|
|
va_start(args, fmt);
|
|
n = vsprintf(sprint_buf, fmt, args);
|
|
va_end(args);
|
|
write(stdout, sprint_buf, n);
|
|
}
|
|
|
|
int
|
|
printf(char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
int n;
|
|
|
|
va_start(args, fmt);
|
|
n = vsprintf(sprint_buf, fmt, args);
|
|
va_end(args);
|
|
write(stdout, sprint_buf, n);
|
|
return n;
|
|
}
|