giomba
/
nes-proj
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix code style

This commit is contained in:
George Oikonomou 2017-11-22 00:58:50 +00:00
parent 632ab90161
commit 4e3c7efa5f
7 changed files with 420 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
arch/cpu/arm/common/dbg-io/dbg-printf.c
View File

@ -7,15 +7,17 @@
static StrFormatResult static StrFormatResult
write_str(void *user_data, const char *data, unsigned int len) write_str(void *user_data, const char *data, unsigned int len)
{ {
if (len > 0) dbg_send_bytes((unsigned char*)data, len); if(len > 0) {
dbg_send_bytes((unsigned char *)data, len);
}
return STRFORMAT_OK; return STRFORMAT_OK;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static StrFormatContext ctxt = static StrFormatContext ctxt =
{ {
write_str, write_str,
NULL NULL
}; };
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
int int
printf(const char *fmt, ...) printf(const char *fmt, ...)

3
arch/cpu/arm/common/dbg-io/dbg-putchar.c
View File

@ -21,7 +21,8 @@ putc(int c, FILE *f)
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
int int
__sp(struct _reent *_ptr, int c, FILE *_p) { __sp(struct _reent *_ptr, int c, FILE *_p)
{
dbg_putchar(c); dbg_putchar(c);
return c; return c;
} }

2
arch/cpu/arm/common/dbg-io/dbg-puts.c
View File

@ -6,7 +6,7 @@
int int
puts(const char *str) puts(const char *str)
{ {
dbg_send_bytes((unsigned char*)str, strlen(str)); dbg_send_bytes((unsigned char *)str, strlen(str));
dbg_putchar('\n'); dbg_putchar('\n');
return 0; return 0;
} }

15
arch/cpu/arm/common/dbg-io/dbg-snprintf.c
View File

@ -3,8 +3,7 @@
#include <strformat.h> #include <strformat.h>
#include <string.h> #include <string.h>
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
struct FmtBuffer struct FmtBuffer {
{
char *pos; char *pos;
size_t left; size_t left;
}; };
@ -12,19 +11,20 @@ struct FmtBuffer
static StrFormatResult static StrFormatResult
buffer_str(void *user_data, const char *data, unsigned int len) buffer_str(void *user_data, const char *data, unsigned int len)
{ {
struct FmtBuffer *buffer = (struct FmtBuffer*)user_data; struct FmtBuffer *buffer = (struct FmtBuffer *)user_data;
if (len >= buffer->left) { if(len >= buffer->left) {
len = buffer->left; len = buffer->left;
len--; len--;
} }
memcpy(buffer->pos, data, len); memcpy(buffer->pos, data, len);
buffer->pos += len; buffer->pos += len;
buffer->left -= len; buffer->left -= len;
return STRFORMAT_OK; return STRFORMAT_OK;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
int snprintf(char *str, size_t size, const char *format, ...) int
snprintf(char *str, size_t size, const char *format, ...)
{ {
int res; int res;
va_list ap; va_list ap;
@ -34,7 +34,8 @@ int snprintf(char *str, size_t size, const char *format, ...)
return res; return res;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
int vsnprintf(char *str, size_t size, const char *format, va_list ap) int
vsnprintf(char *str, size_t size, const char *format, va_list ap)
{ {
struct FmtBuffer buffer; struct FmtBuffer buffer;
StrFormatContext ctxt; StrFormatContext ctxt;

4
arch/cpu/arm/common/dbg-io/dbg-sprintf.c
View File

@ -6,8 +6,8 @@
static StrFormatResult static StrFormatResult
buffer_str(void *user_data, const char *data, unsigned int len) buffer_str(void *user_data, const char *data, unsigned int len)
{ {
memcpy(*(char**)user_data, data, len); memcpy(*(char **)user_data, data, len);
(*(char**)user_data) += len; (*(char **)user_data) += len;
return STRFORMAT_OK; return STRFORMAT_OK;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/

740
arch/cpu/arm/common/dbg-io/strformat.c
View File

@ -2,23 +2,23 @@
#include <strformat.h> #include <strformat.h>
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#define HAVE_DOUBLE #define HAVE_DOUBLE
#define HAVE_LONGLONG #define HAVE_LONGLONG
#ifndef LARGEST_SIGNED #ifndef LARGEST_SIGNED
#ifdef HAVE_LONGLONG #ifdef HAVE_LONGLONG
#define LARGEST_SIGNED long long int #define LARGEST_SIGNED long long int
#else #else
#define LARGEST_UNSIGNED long int #define LARGEST_UNSIGNED long int
#endif #endif /* HAVE_LONGLONG */
#endif #endif /* LARGEST_SIGNED */
#ifndef LARGEST_UNSIGNED #ifndef LARGEST_UNSIGNED
#ifdef HAVE_LONGLONG #ifdef HAVE_LONGLONG
#define LARGEST_UNSIGNED unsigned long long int #define LARGEST_UNSIGNED unsigned long long int
#else #else
#define LARGEST_UNSIGNED unsigned long int #define LARGEST_UNSIGNED unsigned long int
#endif #endif /* HAVE_LONGLONG */
#endif #endif /* LARGEST_UNSIGNED */
#ifndef POINTER_INT #ifndef POINTER_INT
#define POINTER_INT unsigned long #define POINTER_INT unsigned long
@ -26,79 +26,78 @@
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
typedef unsigned int FormatFlags; typedef unsigned int FormatFlags;
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#define MAKE_MASK(shift,size) (((1 << size) - 1) << (shift)) #define MAKE_MASK(shift, size) (((1 << size) - 1) << (shift))
/*---------------------------------------------------------------------------*/
#define JUSTIFY_SHIFT 0 #define JUSTIFY_SHIFT 0
#define JUSTIFY_SIZE 1 #define JUSTIFY_SIZE 1
#define JUSTIFY_RIGHT 0x0000 #define JUSTIFY_RIGHT 0x0000
#define JUSTIFY_LEFT 0x0001 #define JUSTIFY_LEFT 0x0001
#define JUSTIFY_MASK MAKE_MASK(JUSTIFY_SHIFT,JUSTIFY_SIZE) #define JUSTIFY_MASK MAKE_MASK(JUSTIFY_SHIFT, JUSTIFY_SIZE)
/*---------------------------------------------------------------------------*/
/* How a positive number is prefixed */ /* How a positive number is prefixed */
#define POSITIVE_SHIFT (JUSTIFY_SHIFT + JUSTIFY_SIZE) #define POSITIVE_SHIFT (JUSTIFY_SHIFT + JUSTIFY_SIZE)
#define POSITIVE_NONE (0x0000 << POSITIVE_SHIFT) #define POSITIVE_NONE (0x0000 << POSITIVE_SHIFT)
#define POSITIVE_SPACE (0x0001 << POSITIVE_SHIFT) #define POSITIVE_SPACE (0x0001 << POSITIVE_SHIFT)
#define POSITIVE_PLUS (0x0003 << POSITIVE_SHIFT) #define POSITIVE_PLUS (0x0003 << POSITIVE_SHIFT)
#define POSITIVE_MASK MAKE_MASK(POSITIVE_SHIFT, POSITIVE_SIZE) #define POSITIVE_MASK MAKE_MASK(POSITIVE_SHIFT, POSITIVE_SIZE)
#define POSITIVE_SIZE 2
#define POSITIVE_SIZE 2
/*---------------------------------------------------------------------------*/
#define ALTERNATE_FORM_SHIFT (POSITIVE_SHIFT + POSITIVE_SIZE) #define ALTERNATE_FORM_SHIFT (POSITIVE_SHIFT + POSITIVE_SIZE)
#define ALTERNATE_FORM_SIZE 1 #define ALTERNATE_FORM_SIZE 1
#define ALTERNATE_FORM (0x0001 << ALTERNATE_FORM_SHIFT) #define ALTERNATE_FORM (0x0001 << ALTERNATE_FORM_SHIFT)
/*---------------------------------------------------------------------------*/
#define PAD_SHIFT (ALTERNATE_FORM_SHIFT + ALTERNATE_FORM_SIZE)
#define PAD_SHIFT (ALTERNATE_FORM_SHIFT + ALTERNATE_FORM_SIZE) #define PAD_SIZE 1
#define PAD_SIZE 1 #define PAD_SPACE (0x0000 << PAD_SHIFT)
#define PAD_SPACE (0x0000 << PAD_SHIFT) #define PAD_ZERO (0x0001 << PAD_SHIFT)
#define PAD_ZERO (0x0001 << PAD_SHIFT) /*---------------------------------------------------------------------------*/
#define SIZE_SHIFT (PAD_SHIFT + PAD_SIZE)
#define SIZE_SHIFT (PAD_SHIFT + PAD_SIZE) #define SIZE_SIZE 3
#define SIZE_SIZE 3 #define SIZE_CHAR (0x0001 << SIZE_SHIFT)
#define SIZE_CHAR (0x0001 << SIZE_SHIFT) #define SIZE_SHORT (0x0002 << SIZE_SHIFT)
#define SIZE_SHORT (0x0002 << SIZE_SHIFT) #define SIZE_INT (0x0000 << SIZE_SHIFT)
#define SIZE_INT (0x0000 << SIZE_SHIFT) #define SIZE_LONG (0x0003 << SIZE_SHIFT)
#define SIZE_LONG (0x0003 << SIZE_SHIFT) #define SIZE_LONGLONG (0x0004 << SIZE_SHIFT)
#define SIZE_LONGLONG (0x0004 << SIZE_SHIFT) #define SIZE_MASK MAKE_MASK(SIZE_SHIFT, SIZE_SIZE)
#define SIZE_MASK MAKE_MASK(SIZE_SHIFT,SIZE_SIZE) /*---------------------------------------------------------------------------*/
#define CONV_SHIFT (SIZE_SHIFT + SIZE_SIZE)
#define CONV_SHIFT (SIZE_SHIFT + SIZE_SIZE) #define CONV_SIZE 3
#define CONV_SIZE 3 #define CONV_INTEGER (0x0001 << CONV_SHIFT)
#define CONV_INTEGER (0x0001 << CONV_SHIFT) #define CONV_FLOAT (0x0002 << CONV_SHIFT)
#define CONV_FLOAT (0x0002 << CONV_SHIFT) #define CONV_POINTER (0x0003 << CONV_SHIFT)
#define CONV_POINTER (0x0003 << CONV_SHIFT) #define CONV_STRING (0x0004 << CONV_SHIFT)
#define CONV_STRING (0x0004 << CONV_SHIFT) #define CONV_CHAR (0x0005 << CONV_SHIFT)
#define CONV_CHAR (0x0005 << CONV_SHIFT) #define CONV_PERCENT (0x0006 << CONV_SHIFT)
#define CONV_PERCENT (0x0006 << CONV_SHIFT) #define CONV_WRITTEN (0x0007 << CONV_SHIFT)
#define CONV_WRITTEN (0x0007 << CONV_SHIFT) #define CONV_MASK MAKE_MASK(CONV_SHIFT, CONV_SIZE)
#define CONV_MASK MAKE_MASK(CONV_SHIFT, CONV_SIZE) /*---------------------------------------------------------------------------*/
#define RADIX_SHIFT (CONV_SHIFT + CONV_SIZE)
#define RADIX_SHIFT (CONV_SHIFT + CONV_SIZE) #define RADIX_SIZE 2
#define RADIX_SIZE 2 #define RADIX_DECIMAL (0x0001 << RADIX_SHIFT)
#define RADIX_DECIMAL (0x0001 << RADIX_SHIFT) #define RADIX_OCTAL (0x0002 << RADIX_SHIFT)
#define RADIX_OCTAL (0x0002 << RADIX_SHIFT) #define RADIX_HEX (0x0003 << RADIX_SHIFT)
#define RADIX_HEX (0x0003 << RADIX_SHIFT) #define RADIX_MASK MAKE_MASK(RADIX_SHIFT, RADIX_SIZE)
#define RADIX_MASK MAKE_MASK(RADIX_SHIFT,RADIX_SIZE) /*---------------------------------------------------------------------------*/
#define SIGNED_SHIFT (RADIX_SHIFT + RADIX_SIZE)
#define SIGNED_SHIFT (RADIX_SHIFT + RADIX_SIZE) #define SIGNED_SIZE 1
#define SIGNED_SIZE 1 #define SIGNED_NO (0x0000 << SIGNED_SHIFT)
#define SIGNED_NO (0x0000 << SIGNED_SHIFT) #define SIGNED_YES (0x0001 << SIGNED_SHIFT)
#define SIGNED_YES (0x0001 << SIGNED_SHIFT) #define SIGNED_MASK MAKE_MASK(SIGNED_SHIFT, SIGNED_SIZE)
#define SIGNED_MASK MAKE_MASK(SIGNED_SHIFT,SIGNED_SIZE) /*---------------------------------------------------------------------------*/
#define CAPS_SHIFT (SIGNED_SHIFT + SIGNED_SIZE)
#define CAPS_SHIFT (SIGNED_SHIFT + SIGNED_SIZE) #define CAPS_SIZE 1
#define CAPS_SIZE 1 #define CAPS_NO (0x0000 << CAPS_SHIFT)
#define CAPS_NO (0x0000 << CAPS_SHIFT) #define CAPS_YES (0x0001 << CAPS_SHIFT)
#define CAPS_YES (0x0001 << CAPS_SHIFT) #define CAPS_MASK MAKE_MASK(CAPS_SHIFT, CAPS_SIZE)
#define CAPS_MASK MAKE_MASK(CAPS_SHIFT,CAPS_SIZE) /*---------------------------------------------------------------------------*/
#define FLOAT_SHIFT (CAPS_SHIFT + CAPS_SIZE)
#define FLOAT_SHIFT (CAPS_SHIFT + CAPS_SIZE) #define FLOAT_SIZE 2
#define FLOAT_SIZE 2 #define FLOAT_NORMAL (0x0000 << FLOAT_SHIFT)
#define FLOAT_NORMAL (0x0000 << FLOAT_SHIFT) #define FLOAT_EXPONENT (0x0001 << FLOAT_SHIFT)
#define FLOAT_EXPONENT (0x0001 << FLOAT_SHIFT) #define FLOAT_DEPENDANT (0x0002 << FLOAT_SHIFT)
#define FLOAT_DEPENDANT (0x0002 << FLOAT_SHIFT) #define FLOAT_HEX (0x0003 << FLOAT_SHIFT)
#define FLOAT_HEX (0x0003 << FLOAT_SHIFT) #define FLOAT_MASK MAKE_MASK(FLOAT_SHIFT, FLOAT_SIZE)
#define FLOAT_MASK MAKE_MASK(FLOAT_SHIFT, FLOAT_SIZE)
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static FormatFlags static FormatFlags
@ -106,7 +105,8 @@ parse_flags(const char **posp)
{ {
FormatFlags flags = 0; FormatFlags flags = 0;
const char *pos = *posp; const char *pos = *posp;
while (1) {
while(1) {
switch(*pos) { switch(*pos) {
case '-': case '-':
flags |= JUSTIFY_LEFT; flags |= JUSTIFY_LEFT;
@ -127,9 +127,9 @@ parse_flags(const char **posp)
*posp = pos; *posp = pos;
return flags; return flags;
} }
pos++; pos++;
} }
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static unsigned int static unsigned int
@ -138,11 +138,14 @@ parse_uint(const char **posp)
unsigned v = 0; unsigned v = 0;
const char *pos = *posp; const char *pos = *posp;
char ch; char ch;
while((ch = *pos) >= '0' && ch <= '9') { while((ch = *pos) >= '0' && ch <= '9') {
v = v * 10 + (ch - '0'); v = v * 10 + (ch - '0');
pos++; pos++;
} }
*posp = pos; *posp = pos;
return v; return v;
} }
@ -158,12 +161,15 @@ output_uint_decimal(char **posp, LARGEST_UNSIGNED v)
{ {
unsigned int len; unsigned int len;
char *pos = *posp; char *pos = *posp;
while (v > 0) {
while(v > 0) {
*--pos = (v % 10) + '0'; *--pos = (v % 10) + '0';
v /= 10; v /= 10;
} }
len = *posp - pos; len = *posp - pos;
*posp = pos; *posp = pos;
return len; return len;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -171,14 +177,17 @@ static unsigned int
output_uint_hex(char **posp, LARGEST_UNSIGNED v, unsigned int flags) output_uint_hex(char **posp, LARGEST_UNSIGNED v, unsigned int flags)
{ {
unsigned int len; unsigned int len;
const char *hex = (flags & CAPS_YES) ?"0123456789ABCDEF":"0123456789abcdef"; const char *hex = (flags & CAPS_YES) ? "0123456789ABCDEF" : "0123456789abcdef";
char *pos = *posp; char *pos = *posp;
while (v > 0) {
while(v > 0) {
*--pos = hex[(v % 16)]; *--pos = hex[(v % 16)];
v /= 16; v /= 16;
} }
len = *posp - pos; len = *posp - pos;
*posp = pos; *posp = pos;
return len; return len;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -187,12 +196,15 @@ output_uint_octal(char **posp, LARGEST_UNSIGNED v)
{ {
unsigned int len; unsigned int len;
char *pos = *posp; char *pos = *posp;
while (v > 0) {
while(v > 0) {
*--pos = (v % 8) + '0'; *--pos = (v % 8) + '0';
v /= 8; v /= 8;
} }
len = *posp - pos; len = *posp - pos;
*posp = pos; *posp = pos;
return len; return len;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -201,12 +213,19 @@ fill_space(const StrFormatContext *ctxt, unsigned int len)
{ {
StrFormatResult res; StrFormatResult res;
static const char buffer[16] = " "; static const char buffer[16] = " ";
while(len > 16) { while(len > 16) {
res = ctxt->write_str(ctxt->user_data, buffer, 16); res = ctxt->write_str(ctxt->user_data, buffer, 16);
if (res != STRFORMAT_OK) return res; if(res != STRFORMAT_OK) {
return res;
}
len -= 16; len -= 16;
} }
if (len == 0) return STRFORMAT_OK;
if(len == 0) {
return STRFORMAT_OK;
}
return ctxt->write_str(ctxt->user_data, buffer, len); return ctxt->write_str(ctxt->user_data, buffer, len);
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -215,12 +234,18 @@ fill_zero(const StrFormatContext *ctxt, unsigned int len)
{ {
StrFormatResult res; StrFormatResult res;
static const char buffer[16] = "0000000000000000"; static const char buffer[16] = "0000000000000000";
while(len > 16) { while(len > 16) {
res = ctxt->write_str(ctxt->user_data, buffer, 16); res = ctxt->write_str(ctxt->user_data, buffer, 16);
if (res != STRFORMAT_OK) return res; if(res != STRFORMAT_OK) {
return res;
}
len -= 16; len -= 16;
} }
if (len == 0) return STRFORMAT_OK;
if(len == 0) {
return STRFORMAT_OK;
}
return ctxt->write_str(ctxt->user_data, buffer, len); return ctxt->write_str(ctxt->user_data, buffer, len);
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -242,67 +267,82 @@ format_str_v(const StrFormatContext *ctxt, const char *format, va_list ap)
{ {
unsigned int written = 0; unsigned int written = 0;
const char *pos = format; const char *pos = format;
while(*pos != '\0') { while(*pos != '\0') {
FormatFlags flags; FormatFlags flags;
unsigned int minwidth = 0; unsigned int minwidth = 0;
int precision = -1; /* Negative means no precision */ int precision = -1; /* Negative means no precision */
char ch; char ch;
const char *start = pos; const char *start = pos;
while( (ch = *pos) != '\0' && ch != '%') pos++;
if (pos != start) { while((ch = *pos) != '\0' && ch != '%') {
pos++;
}
if(pos != start) {
CHECKCB(ctxt->write_str(ctxt->user_data, start, pos - start)); CHECKCB(ctxt->write_str(ctxt->user_data, start, pos - start));
written += pos - start; written += pos - start;
} }
if (*pos == '\0') {
if(*pos == '\0') {
va_end(ap); va_end(ap);
return written; return written;
} }
pos++; pos++;
if (*pos == '\0') {
if(*pos == '\0') {
va_end(ap); va_end(ap);
return written; return written;
} }
flags = parse_flags(&pos); flags = parse_flags(&pos);
/* parse width */ /* parse width */
if (*pos >= '1' && *pos <= '9') { if(*pos >= '1' && *pos <= '9') {
minwidth = parse_uint(&pos); minwidth = parse_uint(&pos);
} else if (*pos == '*') { } else if(*pos == '*') {
int w = va_arg(ap,int); int w = va_arg(ap, int);
if (w < 0) {
flags |= JUSTIFY_LEFT; if(w < 0) {
minwidth = w; flags |= JUSTIFY_LEFT;
minwidth = w;
} else { } else {
minwidth = w; minwidth = w;
} }
pos ++;
pos++;
} }
/* parse precision */ /* parse precision */
if (*pos == '.') { if(*pos == '.') {
pos++; pos++;
if (*pos >= '0' && *pos <= '9') {
precision = parse_uint(&pos); if(*pos >= '0' && *pos <= '9') {
} else if (*pos == '*') { precision = parse_uint(&pos);
pos++; } else if(*pos == '*') {
precision = va_arg(ap,int); pos++;
precision = va_arg(ap, int);
} }
} }
if (*pos == 'l') {
if(*pos == 'l') {
pos++; pos++;
if (*pos == 'l') {
flags |= SIZE_LONGLONG; if(*pos == 'l') {
pos++; flags |= SIZE_LONGLONG;
pos++;
} else { } else {
flags |= SIZE_LONG; flags |= SIZE_LONG;
} }
} else if (*pos == 'h') { } else if(*pos == 'h') {
pos++; pos++;
if (*pos == 'h') {
flags |= SIZE_CHAR; if(*pos == 'h') {
pos++; flags |= SIZE_CHAR;
pos++;
} else { } else {
flags |= SIZE_SHORT; flags |= SIZE_SHORT;
} }
} }
@ -370,251 +410,269 @@ format_str_v(const StrFormatContext *ctxt, const char *format, va_list ap)
return written; return written;
} }
pos++; pos++;
switch(flags & CONV_MASK) { switch(flags & CONV_MASK) {
case CONV_PERCENT: case CONV_PERCENT:
CHECKCB(ctxt->write_str(ctxt->user_data, "%", 1)); CHECKCB(ctxt->write_str(ctxt->user_data, "%", 1));
written++; written++;
break; break;
case CONV_INTEGER: case CONV_INTEGER:
{ {
/* unsigned integers */ /* unsigned integers */
char *prefix = 0; /* sign, "0x" or "0X" */ char *prefix = 0; /* sign, "0x" or "0X" */
unsigned int prefix_len = 0; unsigned int prefix_len = 0;
char buffer[MAXCHARS]; char buffer[MAXCHARS];
char *conv_pos = buffer + MAXCHARS; char *conv_pos = buffer + MAXCHARS;
unsigned int conv_len = 0; unsigned int conv_len = 0;
unsigned int width = 0; unsigned int width = 0;
unsigned int precision_fill; unsigned int precision_fill;
unsigned int field_fill; unsigned int field_fill;
LARGEST_UNSIGNED uvalue = 0; LARGEST_UNSIGNED uvalue = 0;
int negative = 0; int negative = 0;
if (precision < 0) precision = 1;
else flags &= ~PAD_ZERO;
if (flags & SIGNED_YES) {
/* signed integers */
LARGEST_SIGNED value = 0;
switch(flags & SIZE_MASK) {
case SIZE_CHAR:
value = (signed char)va_arg(ap, int);
break;
case SIZE_SHORT:
value = (short)va_arg(ap, int);
break;
case SIZE_INT:
value = va_arg(ap, int);
break;
#ifndef HAVE_LONGLONG
case SIZE_LONGLONG: /* Treat long long the same as long */
#endif
case SIZE_LONG:
value = va_arg(ap, long);
break;
#ifdef HAVE_LONGLONG
case SIZE_LONGLONG:
value = va_arg(ap, long long);
break;
#endif
}
if (value < 0) {
uvalue = -value;
negative = 1;
} else {
uvalue = value;
}
} else {
switch(flags & SIZE_MASK) {
case SIZE_CHAR:
uvalue = (unsigned char)va_arg(ap,unsigned int);
break;
case SIZE_SHORT:
uvalue = (unsigned short)va_arg(ap,unsigned int);
break;
case SIZE_INT:
uvalue = va_arg(ap,unsigned int);
break;
#ifndef HAVE_LONGLONG
case SIZE_LONGLONG: /* Treat long long the same as long */
#endif
case SIZE_LONG:
uvalue = va_arg(ap,unsigned long);
break;
#ifdef HAVE_LONGLONG
case SIZE_LONGLONG:
uvalue = va_arg(ap,unsigned long long);
break;
#endif
}
}
switch(flags & (RADIX_MASK)) {
case RADIX_DECIMAL:
conv_len = output_uint_decimal(&conv_pos,uvalue);
break;
case RADIX_OCTAL:
conv_len = output_uint_octal(&conv_pos,uvalue);
break;
case RADIX_HEX:
conv_len = output_uint_hex(&conv_pos,uvalue, flags);
break;
}
width += conv_len; if(precision < 0) {
precision_fill = (precision > conv_len) ? precision - conv_len : 0; precision = 1;
if ((flags & (RADIX_MASK | ALTERNATE_FORM)) } else {
== (RADIX_OCTAL | ALTERNATE_FORM)) { flags &= ~PAD_ZERO;
if (precision_fill < 1) precision_fill = 1;
}
width += precision_fill;
if ((flags & (RADIX_MASK | ALTERNATE_FORM))
== (RADIX_HEX | ALTERNATE_FORM) && uvalue != 0) {
prefix_len = 2;
if (flags & CAPS_YES) {
prefix = "0X";
} else {
prefix = "0x";
}
}
if (flags & SIGNED_YES) {
if (negative) {
prefix = "-";
prefix_len = 1;
} else {
switch(flags & POSITIVE_MASK) {
case POSITIVE_SPACE:
prefix = " ";
prefix_len = 1;
break;
case POSITIVE_PLUS:
prefix = "+";
prefix_len = 1;
break;
}
}
}
width += prefix_len;
field_fill = (minwidth > width) ? minwidth - width : 0;
if ((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
if (flags & PAD_ZERO) {
precision_fill += field_fill;
field_fill = 0; /* Do not double count padding */
} else {
CHECKCB(fill_space(ctxt,field_fill));
}
}
if (prefix_len > 0)
CHECKCB(ctxt->write_str(ctxt->user_data, prefix, prefix_len));
written += prefix_len;
CHECKCB(fill_zero(ctxt,precision_fill));
written += precision_fill;
CHECKCB(ctxt->write_str(ctxt->user_data, conv_pos,conv_len));
written += conv_len;
if ((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt,field_fill));
}
written += field_fill;
} }
break;
if(flags & SIGNED_YES) {
/* signed integers */
LARGEST_SIGNED value = 0;
switch(flags & SIZE_MASK) {
case SIZE_CHAR:
value = (signed char)va_arg(ap, int);
break;
case SIZE_SHORT:
value = (short)va_arg(ap, int);
break;
case SIZE_INT:
value = va_arg(ap, int);
break;
#ifndef HAVE_LONGLONG
case SIZE_LONGLONG: /* Treat long long the same as long */
#endif
case SIZE_LONG:
value = va_arg(ap, long);
break;
#ifdef HAVE_LONGLONG
case SIZE_LONGLONG:
value = va_arg(ap, long long);
break;
#endif
}
if(value < 0) {
uvalue = -value;
negative = 1;
} else {
uvalue = value;
}
} else {
switch(flags & SIZE_MASK) {
case SIZE_CHAR:
uvalue = (unsigned char)va_arg(ap, unsigned int);
break;
case SIZE_SHORT:
uvalue = (unsigned short)va_arg(ap, unsigned int);
break;
case SIZE_INT:
uvalue = va_arg(ap, unsigned int);
break;
#ifndef HAVE_LONGLONG
case SIZE_LONGLONG: /* Treat long long the same as long */
#endif
case SIZE_LONG:
uvalue = va_arg(ap, unsigned long);
break;
#ifdef HAVE_LONGLONG
case SIZE_LONGLONG:
uvalue = va_arg(ap, unsigned long long);
break;
#endif
}
}
switch(flags & (RADIX_MASK)) {
case RADIX_DECIMAL:
conv_len = output_uint_decimal(&conv_pos, uvalue);
break;
case RADIX_OCTAL:
conv_len = output_uint_octal(&conv_pos, uvalue);
break;
case RADIX_HEX:
conv_len = output_uint_hex(&conv_pos, uvalue, flags);
break;
}
width += conv_len;
precision_fill = (precision > conv_len) ? precision - conv_len : 0;
if((flags & (RADIX_MASK | ALTERNATE_FORM))
== (RADIX_OCTAL | ALTERNATE_FORM)) {
if(precision_fill < 1) {
precision_fill = 1;
}
}
width += precision_fill;
if((flags & (RADIX_MASK | ALTERNATE_FORM))
== (RADIX_HEX | ALTERNATE_FORM) && uvalue != 0) {
prefix_len = 2;
if(flags & CAPS_YES) {
prefix = "0X";
} else {
prefix = "0x";
}
}
if(flags & SIGNED_YES) {
if(negative) {
prefix = "-";
prefix_len = 1;
} else {
switch(flags & POSITIVE_MASK) {
case POSITIVE_SPACE:
prefix = " ";
prefix_len = 1;
break;
case POSITIVE_PLUS:
prefix = "+";
prefix_len = 1;
break;
}
}
}
width += prefix_len;
field_fill = (minwidth > width) ? minwidth - width : 0;
if((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
if(flags & PAD_ZERO) {
precision_fill += field_fill;
field_fill = 0; /* Do not double count padding */
} else {
CHECKCB(fill_space(ctxt, field_fill));
}
}
if(prefix_len > 0) {
CHECKCB(ctxt->write_str(ctxt->user_data, prefix, prefix_len));
}
written += prefix_len;
CHECKCB(fill_zero(ctxt, precision_fill));
written += precision_fill;
CHECKCB(ctxt->write_str(ctxt->user_data, conv_pos, conv_len));
written += conv_len;
if((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt, field_fill));
}
written += field_fill;
}
break;
case CONV_STRING: case CONV_STRING:
{ {
unsigned int field_fill; unsigned int field_fill;
unsigned int len; unsigned int len;
char *str = va_arg(ap,char *); char *str = va_arg(ap, char *);
if (str) {
char *pos = str; if(str) {
while(*pos != '\0') pos++; char *pos = str;
len = pos - str; while(*pos != '\0') pos++;
} else { len = pos - str;
str = "(null)"; } else {
len = 6; str = "(null)";
} len = 6;
if (precision >= 0 && precision < len) len = precision;
field_fill = (minwidth > len) ? minwidth - len : 0;
if ((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
CHECKCB(fill_space(ctxt,field_fill));
}
CHECKCB(ctxt->write_str(ctxt->user_data, str,len));
written += len;
if ((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt,field_fill));
}
written += field_fill;
} }
break;
if(precision >= 0 && precision < len) {
len = precision;
}
field_fill = (minwidth > len) ? minwidth - len : 0;
if((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
CHECKCB(fill_space(ctxt, field_fill));
}
CHECKCB(ctxt->write_str(ctxt->user_data, str, len));
written += len;
if((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt, field_fill));
}
written += field_fill;
}
break;
case CONV_POINTER: case CONV_POINTER:
{ {
LARGEST_UNSIGNED uvalue = LARGEST_UNSIGNED uvalue =
(LARGEST_UNSIGNED)(POINTER_INT)va_arg(ap,void *); (LARGEST_UNSIGNED)(POINTER_INT)va_arg(ap, void *);
char buffer[MAXCHARS_HEX + 3]; char buffer[MAXCHARS_HEX + 3];
char *conv_pos = buffer + MAXCHARS_HEX+3; char *conv_pos = buffer + MAXCHARS_HEX + 3;
unsigned int conv_len; unsigned int conv_len;
unsigned int field_fill; unsigned int field_fill;
conv_len = output_uint_hex(&conv_pos,uvalue,flags);
if (conv_len == 0) {
*--conv_pos = '0';
conv_len++;
}
*--conv_pos = 'x';
*--conv_pos = '0';
*--conv_pos = '#';
conv_len += 3;
field_fill = (minwidth > conv_len) ? minwidth - conv_len : 0; conv_len = output_uint_hex(&conv_pos, uvalue, flags);
if ((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) { if(conv_len == 0) {
CHECKCB(fill_space(ctxt,field_fill)); *--conv_pos = '0';
} conv_len++;
CHECKCB(ctxt->write_str(ctxt->user_data, conv_pos,conv_len));
written += conv_len;
if ((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt,field_fill));
}
written += field_fill;
} }
break;
*--conv_pos = 'x';
*--conv_pos = '0';
*--conv_pos = '#';
conv_len += 3;
field_fill = (minwidth > conv_len) ? minwidth - conv_len : 0;
if((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
CHECKCB(fill_space(ctxt, field_fill));
}
CHECKCB(ctxt->write_str(ctxt->user_data, conv_pos, conv_len));
written += conv_len;
if((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt, field_fill));
}
written += field_fill;
}
break;
case CONV_CHAR: case CONV_CHAR:
{ {
char ch = va_arg(ap,int); char ch = va_arg(ap, int);
unsigned int field_fill = (minwidth > 1) ? minwidth - 1 : 0; unsigned int field_fill = (minwidth > 1) ? minwidth - 1 : 0;
if ((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
CHECKCB(fill_space(ctxt,field_fill));
written += field_fill;
}
CHECKCB(ctxt->write_str(ctxt->user_data, &ch, 1));
written++;
if ((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt,field_fill));
}
written+= field_fill;
}
break;
case CONV_WRITTEN:
{
int *p = va_arg(ap,int*);
*p = written;
}
break;
if((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
CHECKCB(fill_space(ctxt, field_fill));
written += field_fill;
}
CHECKCB(ctxt->write_str(ctxt->user_data, &ch, 1));
written++;
if((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt, field_fill));
}
written += field_fill;
}
break;
case CONV_WRITTEN:
{
int *p = va_arg(ap, int *);
*p = written;
}
break;
} }
} }
return written; return written;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/

3
arch/cpu/arm/common/dbg-io/strformat.h
View File

@ -12,8 +12,7 @@ typedef unsigned int StrFormatResult;
/* The data argument may only be considered valid during the function call */ /* The data argument may only be considered valid during the function call */
typedef StrFormatResult (*StrFormatWrite)(void *user_data, const char *data, unsigned int len); typedef StrFormatResult (*StrFormatWrite)(void *user_data, const char *data, unsigned int len);
typedef struct _StrFormatContext typedef struct _StrFormatContext {
{
StrFormatWrite write_str; StrFormatWrite write_str;
void *user_data; void *user_data;
} StrFormatContext; } StrFormatContext;