mirror/bl_iot_sdk
1
0
Fork 0
mirror of https://github.com/pine64/bl_iot_sdk.git synced 2024-07-03 03:28:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

clean components/ whitespace issues

Browse Source 
image_conf, make_scripts_riscv -  Delete trailing spaces. Change tabs to 4 space multiples.

    .c and .h get tabs expanded to four spaces for consistency, traliing whitespace whacked.
    Makefiles do NOT get tabs changed.
This commit is contained in:
Robert Lipe 2020-11-08 13:56:51 -06:00
parent e82b9d746d
commit 3bc544d9f3
621 changed files with 83078 additions and 83078 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
components/audio/audio_device/bouffalo.mk
View File

@ -6,18 +6,18 @@ COMPONENT_ADD_INCLUDEDIRS += audio_device/include
## not be exported to project level
COMPONENT_PRIV_INCLUDEDIRS := audio_device/include
## This component's src
## This component's src
ifeq ($(CONFIG_CHIP_NAME),BL602)
COMPONENT_SRCS := bl602_dac/bl602_dac_device.c
COMPONENT_SRCDIRS := bl602_dac
endif
ifeq ($(CONFIG_CHIP_NAME),BL60X)
COMPONENT_SRCS := bl60x_i2s/bl60x_i2s_device.c
COMPONENT_SRCS := bl60x_i2s/bl60x_i2s_device.c
COMPONENT_SRCDIRS := bl60x_i2s
endif
COMPONENT_OBJS := $(patsubst %.c,%.o, $(COMPONENT_SRCS))
##
#CPPFLAGS +=
#CPPFLAGS +=

4
components/audio/audio_framework/bouffalo.mk
View File

@ -6,7 +6,7 @@ COMPONENT_ADD_INCLUDEDIRS += audio_framework/include
## not be exported to project level
COMPONENT_PRIV_INCLUDEDIRS := audio_framework/include
## This component's src
## This component's src
COMPONENT_SRCS := audio_framework/audio_framework.c
COMPONENT_OBJS := $(patsubst %.c,%.o, $(COMPONENT_SRCS))
@ -15,4 +15,4 @@ COMPONENT_SRCDIRS := audio_framework
##
#CPPFLAGS +=
#CPPFLAGS +=

12
components/bl602/bl602/evb/evb.mk
View File

@ -3,12 +3,12 @@ toolchains := gcc
# Component Makefile
#
## These include paths would be exported to project level
COMPONENT_ADD_INCLUDEDIRS +=
## not be exported to project level
COMPONENT_PRIV_INCLUDEDIRS :=
COMPONENT_ADD_INCLUDEDIRS +=
## This component's src
## not be exported to project level
COMPONENT_PRIV_INCLUDEDIRS :=
## This component's src
COMPONENT_SRCS1 := evb/src/boot/$(toolchains)/entry.S \
evb/src/boot/$(toolchains)/start.S \
evb/src/debug.c \
@ -39,7 +39,7 @@ endif
##
COMPONENT_ADD_LDFLAGS += -L $(COMPONENT_PATH)/evb/ld \
$(addprefix -T ,$(LINKER_SCRIPTS))
##
##
COMPONENT_ADD_LINKER_DEPS := $(addprefix evb/ld/,$(LINKER_SCRIPTS))
endif

4
components/bl602/bl602/evb/ld/flash.ld
View File

@ -123,7 +123,7 @@ SECTIONS
*(.srodata.cst4)
*(.srodata.cst2)
*(.srodata .srodata.*)
. = ALIGN(8);
*(._k_queue.static.*)
*(._k_sem.static.*)
@ -196,7 +196,7 @@ SECTIONS
/*BOOT2 sections*/
PROVIDE ( __boot2_pt_addr_src = BOOT2_PT_ADDR );
PROVIDE ( __boot2_flashCfg_src = BOOT2_FLASHCFG_ADDR );
PROVIDE ( __boot2_flashCfg_src = BOOT2_FLASHCFG_ADDR );
PROVIDE(__LD_CONFIG_EM_SEL = __EM_SIZE);
}

8
components/bl602/bl602/evb/ld/flash_rom.ld
View File

@ -72,7 +72,7 @@ SECTIONS
_bl_static_blogpri_code_end = .;
*(.gnu.linkonce.r.*)
/*Framework table section, use ALIGN here to avoid fill section*/
. = ALIGN(4);
_rom_framework_audio_device_start = .;
@ -136,7 +136,7 @@ SECTIONS
*(.srodata.cst4)
*(.srodata.cst2)
*(.srodata .srodata.*)
. = ALIGN(8);
*(._k_queue.static.*)
*(._k_sem.static.*)
@ -213,7 +213,7 @@ SECTIONS
/*BOOT2 sections*/
PROVIDE ( __boot2_pt_addr_src = BOOT2_PT_ADDR );
PROVIDE ( __boot2_flashCfg_src = BOOT2_FLASHCFG_ADDR );
PROVIDE ( __boot2_flashCfg_src = BOOT2_FLASHCFG_ADDR );
PROVIDE(xTaskGetTickCount = 0x0000000021017694);
PROVIDE(xTaskGetTickCountFromISR = 0x00000000210176aa);
@ -269,7 +269,7 @@ SECTIONS
PROVIDE(vTaskStartScheduler = 0x0000000021017610);
PROVIDE(vPortDefineHeapRegions = 0x00000000210197da);
PROVIDE(__LD_CONFIG_EM_SEL = __EM_SIZE);
PROVIDE( _ld_symbol_rom_framework_audio_device_start = _rom_framework_audio_device_start);
PROVIDE( _ld_symbol_rom_framework_audio_device_end = _rom_framework_audio_device_end);

2
components/bl602/bl602/evb/ld/ram.ld
View File

@ -93,5 +93,5 @@ SECTIONS
PROVIDE( _ld_ram_addr1 = 0);
PROVIDE( _ld_ram_size2 = 0);
PROVIDE( _ld_ram_addr2 = 0);
}

0
components/bl602/bl602/evb/src/compat_attribute.h Executable file → Normal file
View File

896
components/bl602/bl602/evb/src/debug.c Executable file → Normal file
View File

@ -34,171 +34,171 @@
#include <stdarg.h>
#include <limits.h>
//#define CHAR_BIT 8
//#define CHAR_BIT 8
//FIXME no ugly declare
extern int bl_uart_data_send(uint8_t id, uint8_t data);
enum flag {
FL_ZERO = 0x01, /* Zero modifier */
FL_MINUS = 0x02, /* Minus modifier */
FL_PLUS = 0x04, /* Plus modifier */
FL_TICK = 0x08, /* ' modifier */
FL_SPACE = 0x10, /* Space modifier */
FL_HASH = 0x20, /* # modifier */
FL_SIGNED = 0x40, /* Number is signed */
FL_UPPER = 0x80 /* Upper case digits */
FL_ZERO = 0x01, /* Zero modifier */
FL_MINUS = 0x02, /* Minus modifier */
FL_PLUS = 0x04, /* Plus modifier */
FL_TICK = 0x08, /* ' modifier */
FL_SPACE = 0x10, /* Space modifier */
FL_HASH = 0x20, /* # modifier */
FL_SIGNED = 0x40, /* Number is signed */
FL_UPPER = 0x80 /* Upper case digits */
};
/* These may have to be adjusted on certain implementations */
enum ranks {
rank_char = -2,
rank_short = -1,
rank_int = 0,
rank_long = 1,
rank_longlong = 2
rank_char = -2,
rank_short = -1,
rank_int = 0,
rank_long = 1,
rank_longlong = 2
};
#define MIN_RANK rank_char
#define MAX_RANK rank_longlong
#define MIN_RANK rank_char
#define MAX_RANK rank_longlong
#define INTMAX_RANK rank_longlong
#define SIZE_T_RANK rank_long
#define PTRDIFF_T_RANK rank_long
#define INTMAX_RANK rank_longlong
#define SIZE_T_RANK rank_long
#define PTRDIFF_T_RANK rank_long
#define EMIT(x) { if (o < n) { *q++ = (x); } o++; }
static size_t
format_int(char *q, size_t n, uintmax_t val, unsigned int flags,
int base, int width, int prec)
int base, int width, int prec)
{
char *qq;
size_t o = 0, oo;
static const char lcdigits[] = "0123456789abcdef";
static const char ucdigits[] = "0123456789ABCDEF";
const char *digits;
uintmax_t tmpval;
int minus = 0;
int ndigits = 0, nchars;
int tickskip, b4tick;
char *qq;
size_t o = 0, oo;
static const char lcdigits[] = "0123456789abcdef";
static const char ucdigits[] = "0123456789ABCDEF";
const char *digits;
uintmax_t tmpval;
int minus = 0;
int ndigits = 0, nchars;
int tickskip, b4tick;
/* Select type of digits */
digits = (flags & FL_UPPER) ? ucdigits : lcdigits;
/* Select type of digits */
digits = (flags & FL_UPPER) ? ucdigits : lcdigits;
/* If signed, separate out the minus */
if (flags & FL_SIGNED && (intmax_t) val < 0) {
minus = 1;
val = (uintmax_t) (-(intmax_t) val);
}
/* If signed, separate out the minus */
if (flags & FL_SIGNED && (intmax_t) val < 0) {
minus = 1;
val = (uintmax_t) (-(intmax_t) val);
}
/* Count the number of digits needed. This returns zero for 0. */
tmpval = val;
while (tmpval) {
tmpval /= base;
ndigits++;
}
/* Count the number of digits needed. This returns zero for 0. */
tmpval = val;
while (tmpval) {
tmpval /= base;
ndigits++;
}
/* Adjust ndigits for size of output */
/* Adjust ndigits for size of output */
if (flags & FL_HASH && base == 8) {
if (prec < ndigits + 1)
prec = ndigits + 1;
}
if (flags & FL_HASH && base == 8) {
if (prec < ndigits + 1)
prec = ndigits + 1;
}
if (ndigits < prec) {
ndigits = prec; /* Mandatory number padding */
} else if (val == 0) {
ndigits = 1; /* Zero still requires space */
}
if (ndigits < prec) {
ndigits = prec; /* Mandatory number padding */
} else if (val == 0) {
ndigits = 1; /* Zero still requires space */
}
/* For ', figure out what the skip should be */
if (flags & FL_TICK) {
tickskip = (base == 16) ? 4 : 3;
} else {
tickskip = ndigits; /* No tick marks */
}
/* For ', figure out what the skip should be */
if (flags & FL_TICK) {
tickskip = (base == 16) ? 4 : 3;
} else {
tickskip = ndigits; /* No tick marks */
}
/* Tick marks aren't digits, but generated by the number converter */
ndigits += (ndigits - 1) / tickskip;
/* Tick marks aren't digits, but generated by the number converter */
ndigits += (ndigits - 1) / tickskip;
/* Now compute the number of nondigits */
nchars = ndigits;
/* Now compute the number of nondigits */
nchars = ndigits;
if (minus || (flags & (FL_PLUS | FL_SPACE)))
nchars++; /* Need space for sign */
if ((flags & FL_HASH) && base == 16) {
nchars += 2; /* Add 0x for hex */
}
if (minus || (flags & (FL_PLUS | FL_SPACE)))
nchars++; /* Need space for sign */
if ((flags & FL_HASH) && base == 16) {
nchars += 2; /* Add 0x for hex */
}
/* Emit early space padding */
if (!(flags & (FL_MINUS | FL_ZERO)) && width > nchars) {
while (width > nchars) {
EMIT(' ');
width--;
}
}
/* Emit early space padding */
if (!(flags & (FL_MINUS | FL_ZERO)) && width > nchars) {
while (width > nchars) {
EMIT(' ');
width--;
}
}
/* Emit nondigits */
if (minus) {
EMIT('-');
} else if (flags & FL_PLUS) {
EMIT('+');
} else if (flags & FL_SPACE) {
EMIT(' ');
}
/* Emit nondigits */
if (minus) {
EMIT('-');
} else if (flags & FL_PLUS) {
EMIT('+');
} else if (flags & FL_SPACE) {
EMIT(' ');
}
if ((flags & FL_HASH) && base == 16) {
EMIT('0');
EMIT((flags & FL_UPPER) ? 'X' : 'x');
}
if ((flags & FL_HASH) && base == 16) {
EMIT('0');
EMIT((flags & FL_UPPER) ? 'X' : 'x');
}
/* Emit zero padding */
if ((flags & (FL_MINUS | FL_ZERO)) == FL_ZERO && width > ndigits) {
while (width > nchars) {
EMIT('0');
width--;
}
}
/* Emit zero padding */
if ((flags & (FL_MINUS | FL_ZERO)) == FL_ZERO && width > ndigits) {
while (width > nchars) {
EMIT('0');
width--;
}
}
/* Generate the number. This is done from right to left. */
q += ndigits; /* Advance the pointer to end of number */
o += ndigits;
qq = q;
oo = o; /* Temporary values */
/* Generate the number. This is done from right to left. */
q += ndigits; /* Advance the pointer to end of number */
o += ndigits;
qq = q;
oo = o; /* Temporary values */
b4tick = tickskip;
while (ndigits > 0) {
if (!b4tick--) {
qq--;
oo--;
ndigits--;
if (oo < n)
*qq = '_';
b4tick = tickskip - 1;
}
qq--;
oo--;
ndigits--;
if (oo < n)
*qq = digits[val % base];
val /= base;
}
b4tick = tickskip;
while (ndigits > 0) {
if (!b4tick--) {
qq--;
oo--;
ndigits--;
if (oo < n)
*qq = '_';
b4tick = tickskip - 1;
}
qq--;
oo--;
ndigits--;
if (oo < n)
*qq = digits[val % base];
val /= base;
}
/* Emit late space padding */
while ((flags & FL_MINUS) && width > nchars) {
EMIT(' ');
width--;
}
/* Emit late space padding */
while ((flags & FL_MINUS) && width > nchars) {
EMIT(' ');
width--;
}
return o;
return o;
}
#define ZEROPAD (1<<0) /* Pad with zero */
#define SIGN (1<<1) /* Unsigned/signed long */
#define PLUS (1<<2) /* Show plus */
#define SPACE (1<<3) /* Spacer */
#define LEFT (1<<4) /* Left justified */
#define HEX_PREP (1<<5) /* 0x */
#define UPPERCASE (1<<6) /* 'ABCDEF' */
#define ZEROPAD (1<<0) /* Pad with zero */
#define SIGN (1<<1) /* Unsigned/signed long */
#define PLUS (1<<2) /* Show plus */
#define SPACE (1<<3) /* Spacer */
#define LEFT (1<<4) /* Left justified */
#define HEX_PREP (1<<5) /* 0x */
#define UPPERCASE (1<<6) /* 'ABCDEF' */
#include <math.h>
#define CVTBUFSIZE 80
@ -295,9 +295,9 @@ char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf)
static void ee_bufcpy(char *d, char *s, int count);
void ee_bufcpy(char *pd, char *ps, int count) {
char *pe=ps+count;
while (ps!=pe)
*pd++=*ps++;
char *pe=ps+count;
while (ps!=pe)
*pd++=*ps++;
}
static void parse_float(double value, char *buffer, char fmt, int precision)
@ -442,7 +442,7 @@ static void cropzeros(char *buffer)
while (*buffer == '0') buffer--;
if (*buffer == '.') buffer--;
while (buffer!=stop)
*++buffer=0;
*++buffer=0;
}
}
@ -505,332 +505,332 @@ static char *flt(char *str, double num, int size, int precision, char fmt, int f
/*use O0 preventing consuming more stack*/
int __attribute__((optimize("O1"))) vsnprintf(char *buffer, size_t n, const char *format, va_list ap)
{
const char *p = format;
char ch;
char *q = buffer;
size_t o = 0; /* Number of characters output */
uintmax_t val = 0;
int rank = rank_int; /* Default rank */
int width = 0;
int prec = -1;
int base;
size_t sz;
unsigned int flags = 0;
enum {
st_normal, /* Ground state */
st_flags, /* Special flags */
st_width, /* Field width */
st_prec, /* Field precision */
st_modifiers /* Length or conversion modifiers */
} state = st_normal;
const char *sarg; /* %s string argument */
char carg; /* %c char argument */
int slen; /* String length */
const char *p = format;
char ch;
char *q = buffer;
size_t o = 0; /* Number of characters output */
uintmax_t val = 0;
int rank = rank_int; /* Default rank */
int width = 0;
int prec = -1;
int base;
size_t sz;
unsigned int flags = 0;
enum {
st_normal, /* Ground state */
st_flags, /* Special flags */
st_width, /* Field width */
st_prec, /* Field precision */
st_modifiers /* Length or conversion modifiers */
} state = st_normal;
const char *sarg; /* %s string argument */
char carg; /* %c char argument */
int slen; /* String length */
while ((ch = *p++)) {
switch (state) {
case st_normal:
if (ch == '%') {
state = st_flags;
flags = 0;
rank = rank_int;
width = 0;
prec = -1;
} else {
EMIT(ch);
}
break;
while ((ch = *p++)) {
switch (state) {
case st_normal:
if (ch == '%') {
state = st_flags;
flags = 0;
rank = rank_int;
width = 0;
prec = -1;
} else {
EMIT(ch);
}
break;
case st_flags:
switch (ch) {
case '-':
flags |= FL_MINUS;
break;
case '+':
flags |= FL_PLUS;
break;
case '\'':
flags |= FL_TICK;
break;
case ' ':
flags |= FL_SPACE;
break;
case '#':
flags |= FL_HASH;
break;
case '0':
flags |= FL_ZERO;
break;
default:
state = st_width;
p--; /* Process this character again */
break;
}
break;
case st_flags:
switch (ch) {
case '-':
flags |= FL_MINUS;
break;
case '+':
flags |= FL_PLUS;
break;
case '\'':
flags |= FL_TICK;
break;
case ' ':
flags |= FL_SPACE;
break;
case '#':
flags |= FL_HASH;
break;
case '0':
flags |= FL_ZERO;
break;
default:
state = st_width;
p--; /* Process this character again */
break;
}
break;
case st_width:
if (ch >= '0' && ch <= '9') {
width = width * 10 + (ch - '0');
} else if (ch == '*') {
width = va_arg(ap, int);
if (width < 0) {
width = -width;
flags |= FL_MINUS;
}
} else if (ch == '.') {
prec = 0; /* Precision given */
state = st_prec;
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_width:
if (ch >= '0' && ch <= '9') {
width = width * 10 + (ch - '0');
} else if (ch == '*') {
width = va_arg(ap, int);
if (width < 0) {
width = -width;
flags |= FL_MINUS;
}
} else if (ch == '.') {
prec = 0; /* Precision given */
state = st_prec;
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_prec:
if (ch >= '0' && ch <= '9') {
prec = prec * 10 + (ch - '0');
} else if (ch == '*') {
prec = va_arg(ap, int);
if (prec < 0)
prec = -1;
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_prec:
if (ch >= '0' && ch <= '9') {
prec = prec * 10 + (ch - '0');
} else if (ch == '*') {
prec = va_arg(ap, int);
if (prec < 0)
prec = -1;
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_modifiers:
switch (ch) {
/* Length modifiers - nonterminal sequences */
case 'h':
rank--; /* Shorter rank */
break;
case 'l':
rank++; /* Longer rank */
break;
case 'j':
rank = INTMAX_RANK;
break;
case 'z':
rank = SIZE_T_RANK;
break;
case 't':
rank = PTRDIFF_T_RANK;
break;
case 'L':
case 'q':
rank += 2;
break;
default:
/* Output modifiers - terminal sequences */
case st_modifiers:
switch (ch) {
/* Length modifiers - nonterminal sequences */
case 'h':
rank--; /* Shorter rank */
break;
case 'l':
rank++; /* Longer rank */
break;
case 'j':
rank = INTMAX_RANK;
break;
case 'z':
rank = SIZE_T_RANK;
break;
case 't':
rank = PTRDIFF_T_RANK;
break;
case 'L':
case 'q':
rank += 2;
break;
default:
/* Output modifiers - terminal sequences */
/* Next state will be normal */
state = st_normal;
/* Next state will be normal */
state = st_normal;
/* Canonicalize rank */
if (rank < MIN_RANK)
rank = MIN_RANK;
else if (rank > MAX_RANK)
rank = MAX_RANK;
/* Canonicalize rank */
if (rank < MIN_RANK)
rank = MIN_RANK;
else if (rank > MAX_RANK)
rank = MAX_RANK;
switch (ch) {
case 'P': /* Upper case pointer */
flags |= FL_UPPER;
switch (ch) {
case 'P': /* Upper case pointer */
flags |= FL_UPPER;
__attribute__ ((fallthrough));
/* fall through */
case 'p': /* Pointer */
base = 16;
prec = (CHAR_BIT*sizeof(void *)+3)/4;
flags |= FL_HASH;
val = (uintmax_t)(uintptr_t)
va_arg(ap, void *);
goto is_integer;
/* fall through */
case 'p': /* Pointer */
base = 16;
prec = (CHAR_BIT*sizeof(void *)+3)/4;
flags |= FL_HASH;
val = (uintmax_t)(uintptr_t)
va_arg(ap, void *);
goto is_integer;
case 'd': /* Signed decimal output */
case 'i':
base = 10;
flags |= FL_SIGNED;
switch (rank) {
case rank_char:
/* Yes, all these casts are
needed... */
val = (uintmax_t)(intmax_t)
(signed char)
va_arg(ap, signed int);
break;
case rank_short:
val = (uintmax_t)(intmax_t)
(signed short)
va_arg(ap, signed int);
break;
case rank_int:
val = (uintmax_t)(intmax_t)
va_arg(ap, signed int);
break;
case rank_long:
val = (uintmax_t)(intmax_t)
va_arg(ap, signed long);
break;
case rank_longlong:
val = (uintmax_t)(intmax_t)
va_arg(ap,
signed long long);
break;
}
goto is_integer;
case 'o': /* Octal */
base = 8;
goto is_unsigned;
case 'u': /* Unsigned decimal */
base = 10;
goto is_unsigned;
case 'X': /* Upper case hexadecimal */
flags |= FL_UPPER;
case 'd': /* Signed decimal output */
case 'i':
base = 10;
flags |= FL_SIGNED;
switch (rank) {
case rank_char:
/* Yes, all these casts are
needed... */
val = (uintmax_t)(intmax_t)
(signed char)
va_arg(ap, signed int);
break;
case rank_short:
val = (uintmax_t)(intmax_t)
(signed short)
va_arg(ap, signed int);
break;
case rank_int:
val = (uintmax_t)(intmax_t)
va_arg(ap, signed int);
break;
case rank_long:
val = (uintmax_t)(intmax_t)
va_arg(ap, signed long);
break;
case rank_longlong:
val = (uintmax_t)(intmax_t)
va_arg(ap,
signed long long);
break;
}
goto is_integer;
case 'o': /* Octal */
base = 8;
goto is_unsigned;
case 'u': /* Unsigned decimal */
base = 10;
goto is_unsigned;
case 'X': /* Upper case hexadecimal */
flags |= FL_UPPER;
__attribute__ ((fallthrough));
/* fall through */
case 'x': /* Hexadecimal */
base = 16;
goto is_unsigned;
/* fall through */
case 'x': /* Hexadecimal */
base = 16;
goto is_unsigned;
is_unsigned:
switch (rank) {
case rank_char:
val = (uintmax_t)
(unsigned char)
va_arg(ap, unsigned
int);
break;
case rank_short:
val = (uintmax_t)
(unsigned short)
va_arg(ap, unsigned
int);
break;
case rank_int:
val = (uintmax_t)
va_arg(ap, unsigned
int);
break;
case rank_long:
val = (uintmax_t)
va_arg(ap, unsigned
long);
break;
case rank_longlong:
val = (uintmax_t)
va_arg(ap, unsigned
long long);
break;
}
/* fall through */
is_unsigned:
switch (rank) {
case rank_char:
val = (uintmax_t)
(unsigned char)
va_arg(ap, unsigned
int);
break;
case rank_short:
val = (uintmax_t)
(unsigned short)
va_arg(ap, unsigned
int);
break;
case rank_int:
val = (uintmax_t)
va_arg(ap, unsigned
int);
break;
case rank_long:
val = (uintmax_t)
va_arg(ap, unsigned
long);
break;
case rank_longlong:
val = (uintmax_t)
va_arg(ap, unsigned
long long);
break;
}
/* fall through */
is_integer:
sz = format_int(q, (o < n) ? n - o : 0,
val, flags, base,
width, prec);
q += sz;
o += sz;
break;
is_integer:
sz = format_int(q, (o < n) ? n - o : 0,
val, flags, base,
width, prec);
q += sz;
o += sz;
break;
case 'c': /* Character */
carg = (char)va_arg(ap, int);
sarg = &carg;
slen = 1;
goto is_string;
case 's': /* String */
sarg = va_arg(ap, const char *);
sarg = sarg ? sarg : "(null)";
slen = strlen(sarg);
goto is_string;
case 'c': /* Character */
carg = (char)va_arg(ap, int);
sarg = &carg;
slen = 1;
goto is_string;
case 's': /* String */
sarg = va_arg(ap, const char *);
sarg = sarg ? sarg : "(null)";
slen = strlen(sarg);
goto is_string;
is_string:
{
char sch;
int i;
is_string:
{
char sch;
int i;
if (prec != -1 && slen > prec)
slen = prec;
if (prec != -1 && slen > prec)
slen = prec;
if (width > slen
&& !(flags & FL_MINUS)) {
char pad =
(flags & FL_ZERO) ?
'0' : ' ';
while (width > slen) {
EMIT(pad);
width--;
}
}
for (i = slen; i; i--) {
sch = *sarg++;
EMIT(sch);
}
if (width > slen
&& (flags & FL_MINUS)) {
while (width > slen) {
EMIT(' ');
width--;
}
}
}
break;
if (width > slen
&& !(flags & FL_MINUS)) {
char pad =
(flags & FL_ZERO) ?
'0' : ' ';
while (width > slen) {
EMIT(pad);
width--;
}
}
for (i = slen; i; i--) {
sch = *sarg++;
EMIT(sch);
}
if (width > slen
&& (flags & FL_MINUS)) {
while (width > slen) {
EMIT(' ');
width--;
}
}
}
break;
case 'n':
{
/* Output the number of
characters written */
case 'n':
{
/* Output the number of
characters written */
switch (rank) {
case rank_char:
*va_arg(ap,
signed char *)
= o;
break;
case rank_short:
*va_arg(ap,
signed short *)
= o;
break;
case rank_int:
*va_arg(ap,
signed int *)
= o;
break;
case rank_long:
*va_arg(ap,
signed long *)
= o;
break;
case rank_longlong:
*va_arg(ap,
signed long long *)
= o;
break;
}
}
break;
switch (rank) {
case rank_char:
*va_arg(ap,
signed char *)
= o;
break;
case rank_short:
*va_arg(ap,
signed short *)
= o;
break;
case rank_int:
*va_arg(ap,
signed int *)
= o;
break;
case rank_long:
*va_arg(ap,
signed long *)
= o;
break;
case rank_longlong:
*va_arg(ap,
signed long long *)
= o;
break;
}
}
break;
#ifndef DISABLE_PRINT_FLOAT
case 'f':
{
q = flt(q, va_arg(ap, double), width, prec, ch, SIGN);
continue;
}
case 'f':
{
q = flt(q, va_arg(ap, double), width, prec, ch, SIGN);
continue;
}
#endif
default: /* Anything else, including % */
EMIT(ch);
break;
}
}
}
}
default: /* Anything else, including % */
EMIT(ch);
break;
}
}
}
}
/* Null-terminate the string */
if (o < n)
*q = '\0'; /* No overflow */
else if (n > 0)
buffer[n - 1] = '\0'; /* Overflow - terminate at end of buffer */
/* Null-terminate the string */
if (o < n)
*q = '\0'; /* No overflow */
else if (n > 0)
buffer[n - 1] = '\0'; /* Overflow - terminate at end of buffer */
return o;
return o;
}
#ifdef SYS_BIG_DEBUG_BUFFER
@ -841,7 +841,7 @@ static char string[512];
int vsprintf(char *buffer, const char *format, va_list ap)
{
return vsnprintf(buffer, sizeof(string) - 32, format, ap);
return vsnprintf(buffer, sizeof(string) - 32, format, ap);
}
extern volatile bool sys_log_all_enable;
@ -902,25 +902,25 @@ int printf(const char *fmt, ...)
int sprintf(char *buffer, const char *format, ...)
{
va_list ap;
int rv;
va_list ap;
int rv;
va_start(ap, format);
rv = vsnprintf(buffer, ~(size_t) 0, format, ap);
va_end(ap);
va_start(ap, format);
rv = vsnprintf(buffer, ~(size_t) 0, format, ap);
va_end(ap);
return rv;
return rv;
}
int snprintf(char *buffer, size_t n, const char *format, ...)
{
va_list ap;
int rv;
va_list ap;
int rv;
va_start(ap, format);
rv = vsnprintf(buffer, n, format, ap);
va_end(ap);
return rv;
va_start(ap, format);
rv = vsnprintf(buffer, n, format, ap);
va_end(ap);
return rv;
}
void vMainUARTPrintString(char *pcString)

12
components/bl602/bl602/evb/src/sscanf.c Executable file → Normal file
View File

@ -40,12 +40,12 @@
int sscanf(const char *str, const char *format, ...)
{
va_list ap;
int rv;
va_list ap;
int rv;
va_start(ap, format);
rv = vsscanf(str, format, ap);
va_end(ap);
va_start(ap, format);
rv = vsscanf(str, format, ap);
va_end(ap);
return rv;
return rv;
}

106
components/bl602/bl602/evb/src/strntoumax.c Executable file → Normal file
View File

@ -44,67 +44,67 @@
static __inline int digitval(int ch)
{
if (ch >= '0' && ch <= '9') {
return ch - '0';
} else if (ch >= 'A' && ch <= 'Z') {
return ch - 'A' + 10;
} else if (ch >= 'a' && ch <= 'z') {
return ch - 'a' + 10;
} else {
return -1;
}
if (ch >= '0' && ch <= '9') {
return ch - '0';
} else if (ch >= 'A' && ch <= 'Z') {
return ch - 'A' + 10;
} else if (ch >= 'a' && ch <= 'z') {
return ch - 'a' + 10;
} else {
return -1;
}
}
uintmax_t strntoumax(const char *nptr, char **endptr, int base, size_t n)
{
int minus = 0;
uintmax_t v = 0;
int d;
int minus = 0;
uintmax_t v = 0;
int d;
while (n && isspace((unsigned char)*nptr)) {
nptr++;
n--;
}
while (n && isspace((unsigned char)*nptr)) {
nptr++;
n--;
}
/* Single optional + or - */
if (n) {
char c = *nptr;
if (c == '-' || c == '+') {
minus = (c == '-');
nptr++;
n--;
}
}
/* Single optional + or - */
if (n) {
char c = *nptr;
if (c == '-' || c == '+') {
minus = (c == '-');
nptr++;
n--;
}
}
if (base == 0) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
base = 16;
} else if (n >= 1 && nptr[0] == '0') {
n--;
nptr++;
base = 8;
} else {
base = 10;
}
} else if (base == 16) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
}
}
if (base == 0) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
base = 16;
} else if (n >= 1 && nptr[0] == '0') {
n--;
nptr++;
base = 8;
} else {
base = 10;
}
} else if (base == 16) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
}
}
while (n && (d = digitval(*nptr)) >= 0 && d < base) {
v = v * base + d;
n--;
nptr++;
}
while (n && (d = digitval(*nptr)) >= 0 && d < base) {
v = v * base + d;
n--;
nptr++;
}
if (endptr)
*endptr = (char *)nptr;
if (endptr)
*endptr = (char *)nptr;
return minus ? -v : v;
return minus ? -v : v;
}

670
components/bl602/bl602/evb/src/vsscanf.c Executable file → Normal file
View File

@ -54,391 +54,391 @@
uintmax_t strntoumax(const char *nptr, char **endptr, int base, size_t n);
enum flag {
FL_SPLAT = 0x01, /* Drop the value, do not assign */
FL_INV = 0x02, /* Character-set with inverse */
FL_WIDTH = 0x04, /* Field width specified */
FL_MINUS = 0x08, /* Negative number */
FL_SPLAT = 0x01, /* Drop the value, do not assign */
FL_INV = 0x02, /* Character-set with inverse */
FL_WIDTH = 0x04, /* Field width specified */
FL_MINUS = 0x08, /* Negative number */
};
enum ranks {
rank_char = -2,
rank_short = -1,
rank_int = 0,
rank_long = 1,
rank_longlong = 2,
rank_ptr = INT_MAX /* Special value used for pointers */
rank_char = -2,
rank_short = -1,
rank_int = 0,
rank_long = 1,
rank_longlong = 2,
rank_ptr = INT_MAX /* Special value used for pointers */
};
#define MIN_RANK rank_char
#define MAX_RANK rank_longlong
#define MIN_RANK rank_char
#define MAX_RANK rank_longlong
#define INTMAX_RANK rank_longlong
#define SIZE_T_RANK rank_long
#define PTRDIFF_T_RANK rank_long
#define INTMAX_RANK rank_longlong
#define SIZE_T_RANK rank_long
#define PTRDIFF_T_RANK rank_long
enum bail {
bail_none = 0, /* No error condition */
bail_eof, /* Hit EOF */
bail_err /* Conversion mismatch */
bail_none = 0, /* No error condition */
bail_eof, /* Hit EOF */
bail_err /* Conversion mismatch */
};
static __inline const char *skipspace(const char *p)
{
while (isspace((unsigned char)*p))
p++;
return p;
while (isspace((unsigned char)*p))
p++;
return p;
}
#undef set_bit
static __inline void set_bit(unsigned long *bitmap, unsigned int bit)
{
bitmap[bit / LONG_BIT] |= 1UL << (bit % LONG_BIT);
bitmap[bit / LONG_BIT] |= 1UL << (bit % LONG_BIT);
}
#undef test_bit
static __inline int test_bit(unsigned long *bitmap, unsigned int bit)
{
return (int)(bitmap[bit / LONG_BIT] >> (bit % LONG_BIT)) & 1;
return (int)(bitmap[bit / LONG_BIT] >> (bit % LONG_BIT)) & 1;
}
int vsscanf(const char *buffer, const char *format, va_list ap)
{
const char *p = format;
char ch;
unsigned char uc;
const char *q = buffer;
const char *qq;
uintmax_t val = 0;
int rank = rank_int; /* Default rank */
unsigned int width = UINT_MAX;
int base;
unsigned int flags = 0;
enum {
st_normal, /* Ground state */
st_flags, /* Special flags */
st_width, /* Field width */
st_modifiers, /* Length or conversion modifiers */
st_match_init, /* Initial state of %[ sequence */
st_match, /* Main state of %[ sequence */
st_match_range, /* After - in a %[ sequence */
} state = st_normal;
char *sarg = NULL; /* %s %c or %[ string argument */
enum bail bail = bail_none;
__UNUSED__ int sign;
int converted = 0; /* Successful conversions */
unsigned long matchmap[((1 << CHAR_BIT) + (LONG_BIT - 1)) / LONG_BIT];
int matchinv = 0; /* Is match map inverted? */
unsigned char range_start = 0;
const char *p = format;
char ch;
unsigned char uc;
const char *q = buffer;
const char *qq;
uintmax_t val = 0;
int rank = rank_int; /* Default rank */
unsigned int width = UINT_MAX;
int base;
unsigned int flags = 0;
enum {
st_normal, /* Ground state */
st_flags, /* Special flags */
st_width, /* Field width */
st_modifiers, /* Length or conversion modifiers */
st_match_init, /* Initial state of %[ sequence */
st_match, /* Main state of %[ sequence */
st_match_range, /* After - in a %[ sequence */
} state = st_normal;
char *sarg = NULL; /* %s %c or %[ string argument */
enum bail bail = bail_none;
__UNUSED__ int sign;
int converted = 0; /* Successful conversions */
unsigned long matchmap[((1 << CHAR_BIT) + (LONG_BIT - 1)) / LONG_BIT];
int matchinv = 0; /* Is match map inverted? */
unsigned char range_start = 0;
while ((ch = *p++) && !bail) {
switch (state) {
case st_normal:
if (ch == '%') {
state = st_flags;
flags = 0;
rank = rank_int;
width = UINT_MAX;
} else if (isspace((unsigned char)ch)) {
q = skipspace(q);
} else {
if (*q == ch)
q++;
else
bail = bail_err; /* Match failure */
}
break;
while ((ch = *p++) && !bail) {
switch (state) {
case st_normal:
if (ch == '%') {
state = st_flags;
flags = 0;
rank = rank_int;
width = UINT_MAX;
} else if (isspace((unsigned char)ch)) {
q = skipspace(q);
} else {
if (*q == ch)
q++;
else
bail = bail_err; /* Match failure */
}
break;
case st_flags:
switch (ch) {
case '*':
flags |= FL_SPLAT;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
width = (ch - '0');
state = st_width;
flags |= FL_WIDTH;
break;
default:
state = st_modifiers;
p--; /* Process this character again */
break;
}
break;
case st_flags:
switch (ch) {
case '*':
flags |= FL_SPLAT;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
width = (ch - '0');
state = st_width;
flags |= FL_WIDTH;
break;
default:
state = st_modifiers;
p--; /* Process this character again */
break;
}
break;
case st_width:
if (ch >= '0' && ch <= '9') {
width = width * 10 + (ch - '0');
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_width:
if (ch >= '0' && ch <= '9') {
width = width * 10 + (ch - '0');
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_modifiers:
switch (ch) {
/* Length modifiers - nonterminal sequences */
case 'h':
rank--; /* Shorter rank */
break;
case 'l':
rank++; /* Longer rank */
break;
case 'j':
rank = INTMAX_RANK;
break;
case 'z':
rank = SIZE_T_RANK;
break;
case 't':
rank = PTRDIFF_T_RANK;
break;
case 'L':
case 'q':
rank = rank_longlong; /* long double/long long */
break;
case st_modifiers:
switch (ch) {
/* Length modifiers - nonterminal sequences */
case 'h':
rank--; /* Shorter rank */
break;
case 'l':
rank++; /* Longer rank */
break;
case 'j':
rank = INTMAX_RANK;
break;
case 'z':
rank = SIZE_T_RANK;
break;
case 't':
rank = PTRDIFF_T_RANK;
break;
case 'L':
case 'q':
rank = rank_longlong; /* long double/long long */
break;
default:
/* Output modifiers - terminal sequences */
/* Next state will be normal */
state = st_normal;
default:
/* Output modifiers - terminal sequences */
/* Next state will be normal */
state = st_normal;
/* Canonicalize rank */
if (rank < MIN_RANK)
rank = MIN_RANK;
else if (rank > MAX_RANK)
rank = MAX_RANK;
/* Canonicalize rank */
if (rank < MIN_RANK)
rank = MIN_RANK;
else if (rank > MAX_RANK)
rank = MAX_RANK;
switch (ch) {
case 'P': /* Upper case pointer */
case 'p': /* Pointer */
rank = rank_ptr;
base = 0;
sign = 0;
goto scan_int;
switch (ch) {
case 'P': /* Upper case pointer */
case 'p': /* Pointer */
rank = rank_ptr;
base = 0;
sign = 0;
goto scan_int;
case 'i': /* Base-independent integer */
base = 0;
sign = 1;
goto scan_int;
case 'i': /* Base-independent integer */
base = 0;
sign = 1;
goto scan_int;
case 'd': /* Decimal integer */
base = 10;
sign = 1;
goto scan_int;
case 'd': /* Decimal integer */
base = 10;
sign = 1;
goto scan_int;
case 'o': /* Octal integer */
base = 8;
sign = 0;
goto scan_int;
case 'o': /* Octal integer */
base = 8;
sign = 0;
goto scan_int;
case 'u': /* Unsigned decimal integer */
base = 10;
sign = 0;
goto scan_int;
case 'u': /* Unsigned decimal integer */
base = 10;
sign = 0;
goto scan_int;
case 'x': /* Hexadecimal integer */
case 'X':
base = 16;
sign = 0;
goto scan_int;
case 'x': /* Hexadecimal integer */
case 'X':
base = 16;
sign = 0;
goto scan_int;
case 'n': /* # of characters consumed */
val = (q - buffer);
goto set_integer;
case 'n': /* # of characters consumed */
val = (q - buffer);
goto set_integer;
scan_int:
q = skipspace(q);
if (!*q) {
bail = bail_eof;
break;
}
val =
strntoumax(q, (char **)&qq, base,
width);
if (qq == q) {
bail = bail_err;
break;
}
q = qq;
if (!(flags & FL_SPLAT))
converted++;
/* fall through */
scan_int:
q = skipspace(q);
if (!*q) {
bail = bail_eof;
break;
}
val =
strntoumax(q, (char **)&qq, base,
width);
if (qq == q) {
bail = bail_err;
break;
}
q = qq;
if (!(flags & FL_SPLAT))
converted++;
/* fall through */
set_integer:
if (!(flags & FL_SPLAT)) {
switch (rank) {
case rank_char:
*va_arg(ap,
unsigned char *)
= val;
break;
case rank_short:
*va_arg(ap,
unsigned short
*) = val;
break;
case rank_int:
*va_arg(ap,
unsigned int *)
= val;
break;
case rank_long:
*va_arg(ap,
unsigned long *)
= val;
break;
case rank_longlong:
*va_arg(ap,
unsigned long
long *) = val;
break;
case rank_ptr:
*va_arg(ap, void **) =
(void *)
(uintptr_t)val;
break;
}
}
break;
set_integer:
if (!(flags & FL_SPLAT)) {
switch (rank) {
case rank_char:
*va_arg(ap,
unsigned char *)
= val;
break;
case rank_short:
*va_arg(ap,
unsigned short
*) = val;
break;
case rank_int:
*va_arg(ap,
unsigned int *)
= val;
break;
case rank_long:
*va_arg(ap,
unsigned long *)
= val;
break;
case rank_longlong:
*va_arg(ap,
unsigned long
long *) = val;
break;
case rank_ptr:
*va_arg(ap, void **) =
(void *)
(uintptr_t)val;
break;
}
}
break;
case 'c': /* Character */
/* Default width == 1 */
width = (flags & FL_WIDTH) ? width : 1;
if (flags & FL_SPLAT) {
while (width--) {
if (!*q) {
bail = bail_eof;
break;
}
}
} else {
sarg = va_arg(ap, char *);
while (width--) {
if (!*q) {
bail = bail_eof;
break;
}
*sarg++ = *q++;
}
if (!bail)
converted++;
}
break;
case 'c': /* Character */
/* Default width == 1 */
width = (flags & FL_WIDTH) ? width : 1;
if (flags & FL_SPLAT) {
while (width--) {
if (!*q) {
bail = bail_eof;
break;
}
}
} else {
sarg = va_arg(ap, char *);
while (width--) {
if (!*q) {
bail = bail_eof;
break;
}
*sarg++ = *q++;
}
if (!bail)
converted++;
}
break;
case 's': /* String */
uc = 1; /* Anything nonzero */
if (flags & FL_SPLAT) {
while (width-- && (uc = *q) &&
!isspace(uc)) {
q++;
}
} else {
char *sp;
sp = sarg = va_arg(ap, char *);
while (width-- && (uc = *q) &&
!isspace(uc)) {
*sp++ = uc;
q++;
}
if (sarg != sp) {
/* Terminate output */
*sp = '\0';
converted++;
}
}
if (!uc)
bail = bail_eof;
break;
case 's': /* String */
uc = 1; /* Anything nonzero */
if (flags & FL_SPLAT) {
while (width-- && (uc = *q) &&
!isspace(uc)) {
q++;
}
} else {
char *sp;
sp = sarg = va_arg(ap, char *);
while (width-- && (uc = *q) &&
!isspace(uc)) {
*sp++ = uc;
q++;
}
if (sarg != sp) {
/* Terminate output */
*sp = '\0';
converted++;
}
}
if (!uc)
bail = bail_eof;
break;
case '[': /* Character range */
sarg = (flags & FL_SPLAT) ? NULL
: va_arg(ap, char *);
state = st_match_init;
matchinv = 0;
memset(matchmap, 0, sizeof matchmap);
break;
case '[': /* Character range */
sarg = (flags & FL_SPLAT) ? NULL
: va_arg(ap, char *);
state = st_match_init;
matchinv = 0;
memset(matchmap, 0, sizeof matchmap);
break;
case '%': /* %% sequence */
if (*q == '%')
q++;
else
bail = bail_err;
break;
case '%': /* %% sequence */
if (*q == '%')
q++;
else
bail = bail_err;
break;
default: /* Anything else */
/* Unknown sequence */
bail = bail_err;
break;
}
}
break;
default: /* Anything else */
/* Unknown sequence */
bail = bail_err;
break;
}
}
break;
case st_match_init: /* Initial state for %[ match */
if (ch == '^' && !(flags & FL_INV)) {
matchinv = 1;
} else {
set_bit(matchmap, (unsigned char)ch);
state = st_match;
}
break;
case st_match_init: /* Initial state for %[ match */
if (ch == '^' && !(flags & FL_INV)) {
matchinv = 1;
} else {
set_bit(matchmap, (unsigned char)ch);
state = st_match;
}
break;
case st_match: /* Main state for %[ match */
if (ch == ']') {
goto match_run;
} else if (ch == '-') {
range_start = (unsigned char)ch;
state = st_match_range;
} else {
set_bit(matchmap, (unsigned char)ch);
}
break;
case st_match: /* Main state for %[ match */
if (ch == ']') {
goto match_run;
} else if (ch == '-') {
range_start = (unsigned char)ch;
state = st_match_range;
} else {
set_bit(matchmap, (unsigned char)ch);
}
break;
case st_match_range: /* %[ match after - */
if (ch == ']') {
/* - was last character */
set_bit(matchmap, (unsigned char)'-');
goto match_run;
} else {
int i;
for (i = range_start; i < (unsigned char)ch;
i++)
set_bit(matchmap, i);
state = st_match;
}
break;
case st_match_range: /* %[ match after - */
if (ch == ']') {
/* - was last character */
set_bit(matchmap, (unsigned char)'-');
goto match_run;
} else {
int i;
for (i = range_start; i < (unsigned char)ch;
i++)
set_bit(matchmap, i);
state = st_match;
}
break;
match_run: /* Match expression finished */
qq = q;
uc = 1; /* Anything nonzero */
while (width && (uc = *q)
&& test_bit(matchmap, uc)^matchinv) {
if (sarg)
*sarg++ = uc;
q++;
}
if (q != qq && sarg) {
*sarg = '\0';
converted++;
} else {
bail = bail_err;
}
if (!uc)
bail = bail_eof;
break;
}
}
match_run: /* Match expression finished */
qq = q;
uc = 1; /* Anything nonzero */
while (width && (uc = *q)
&& test_bit(matchmap, uc)^matchinv) {
if (sarg)
*sarg++ = uc;
q++;
}
if (q != qq && sarg) {
*sarg = '\0';
converted++;
} else {
bail = bail_err;
}
if (!uc)
bail = bail_eof;
break;
}
}
if (bail == bail_eof && !converted)
converted = -1; /* Return EOF (-1) */
if (bail == bail_eof && !converted)
converted = -1; /* Return EOF (-1) */
return converted;
return converted;
}

10
components/bl602/bl602_std/bl602_std/Common/Common.mk
View File

@ -4,14 +4,14 @@ LOCAL_SRCS_FILE:=
MODULE_DIR:= BSP/Common
MODULE_OUT_DIR:= $(TARGET_OUT_PATH)/BSP/Common
COMMON_CFLAGS:=
COMMON_INCLUDE:=
COMMON_CFLAGS:=
COMMON_INCLUDE:=
common_objs_target :=
COM_EXCLUDE_DIR:= BSP/Common/mbedtls
COM_EXCLUDE_DIR:= BSP/Common/mbedtls
COM_ALL_DIRS := $(shell find $(MODULE_DIR) -maxdepth 1 -mindepth 1 -type d)
COM_DIRS=$(filter-out $(COM_EXCLUDE_DIR), $(COM_ALL_DIRS))
COM_DIRS=$(filter-out $(COM_EXCLUDE_DIR), $(COM_ALL_DIRS))
COM_MKS=$(foreach com_dir,$(COM_DIRS),$(wildcard $(com_dir)/*.mk))
#$(info $(COM_MKS))

4
components/bl602/bl602_std/bl602_std/Common/cipher_suite/cipher_suite.mk
View File

@ -6,14 +6,14 @@ CIPHER_SUITE_INC := -I$(SUB_MODULE_DIR)/inc
CIPHER_SUITE_CFLAGS :=
COMMON_INCLUDE += -I $(MODULE_DIR)/cipher_suite/inc
COMMON_INCLUDE += -I $(MODULE_DIR)/cipher_suite/inc
cipher_suite_sources := bflb_crypt.c bflb_hash.c bflb_ecdsa.c bflb_dsa.c
cipher_suite_objs := $(addprefix $(SUB_MODULE_OUT_DIR)/, $(subst .c,.o,$(cipher_suite_sources)))
common_objs_target += $(cipher_suite_objs)
$(SUB_MODULE_OUT_DIR)/%.o:$(SUB_MODULE_SRC_DIR)/%.c
@mkdir -p $(dir $@)
@echo "cc $<"

38
components/bl602/bl602_std/bl602_std/Common/cipher_suite/inc/bflb_crypt.h
View File

@ -8,21 +8,21 @@
#include "bflb_platform.h"
#define bflb_crypt_printf bflb_platform_printf
#define bflb_crypt_printe bflb_platform_printf
#define bflb_crypt_printd bflb_platform_printf
#define bflb_crypt_printw bflb_platform_printf
#define bflb_crypt_printf bflb_platform_printf
#define bflb_crypt_printe bflb_platform_printf
#define bflb_crypt_printd bflb_platform_printf
#define bflb_crypt_printw bflb_platform_printf
#define BFLB_CRYPT_OK 0
#define BFLB_CRYPT_ERROR -1
#define BFLB_CRYPT_TYPE_AES_CBC 0
#define BFLB_CRYPT_TYPE_AES_CTR 1
#define BFLB_CRYPT_TYPE_CHACHA 2
#define BFLB_CRYPT_TYPE_AES_CCM 3
#define BFLB_CRYPT_TYPE_AES_GCM 4
#define BFLB_CRYPT_TYPE_CHACHAPOLY1305 5
#define BFLB_CRYPT_TYPE_AES_CBC 0
#define BFLB_CRYPT_TYPE_AES_CTR 1
#define BFLB_CRYPT_TYPE_CHACHA 2
#define BFLB_CRYPT_TYPE_AES_CCM 3
#define BFLB_CRYPT_TYPE_AES_GCM 4
#define BFLB_CRYPT_TYPE_CHACHAPOLY1305 5
typedef struct tag_bflb_crypt_handle_t
{
@ -35,27 +35,27 @@ typedef struct tag_bflb_crypt_handle_t
int32_t bflb_crypt_init(bflb_crypt_handle_t *crypt_handle,uint8_t type);
int32_t bflb_crypt_setkey(bflb_crypt_handle_t *aes_handle,const uint8_t *key,
uint8_t keytype,uint8_t key_len,const uint8_t *nonce,uint8_t nonce_len,uint8_t dir);
uint8_t keytype,uint8_t key_len,const uint8_t *nonce,uint8_t nonce_len,uint8_t dir);
int32_t bflb_crypt_setadd(bflb_crypt_handle_t *aes_handle,const uint8_t *add,
uint8_t len,uint8_t dir);
uint8_t len,uint8_t dir);
int32_t bflb_crypt_update(bflb_crypt_handle_t *aes_handle,const uint8_t *in,
uint32_t len,uint8_t *out);
uint32_t len,uint8_t *out);
int32_t bflb_crypt_encrypt(bflb_crypt_handle_t *aes_handle,const uint8_t *in,
uint32_t len,size_t offset,uint8_t *out);
uint32_t len,size_t offset,uint8_t *out);
int32_t bflb_crypt_encrypt_tag(bflb_crypt_handle_t *aes_handle,const uint8_t *in,
uint32_t in_len,const uint8_t *add,uint32_t add_len,size_t offset,
uint8_t *out,uint8_t *tag,uint8_t tag_len);
uint32_t in_len,const uint8_t *add,uint32_t add_len,size_t offset,
uint8_t *out,uint8_t *tag,uint8_t tag_len);
int32_t bflb_crypt_auth_decrypt(bflb_crypt_handle_t *aes_handle,const uint8_t *in,
uint32_t in_len,const uint8_t *add,uint32_t add_len,size_t offset,
uint8_t *out,const uint8_t *tag,uint8_t tag_len);
uint32_t in_len,const uint8_t *add,uint32_t add_len,size_t offset,
uint8_t *out,const uint8_t *tag,uint8_t tag_len);
int32_t bflb_crypt_decrypt(bflb_crypt_handle_t *aes_handle,const uint8_t *in,
uint32_t len,size_t offset,uint8_t *out);
uint32_t len,size_t offset,uint8_t *out);
int32_t bflb_crypt_finish(bflb_crypt_handle_t *aes_handle,uint8_t *tag,uint32_t len);

18
components/bl602/bl602_std/bl602_std/Common/cipher_suite/inc/bflb_crypt_port.h
View File

@ -15,9 +15,9 @@
#include "stdlib.h"
#include "string.h"
#define BFLB_CRYPT_KEY_SIZE_MAX 32
#define BFLB_CRYPT_KEY_SIZE_MAX 32
#define BFLB_CRYPT_NONCE_SIZE_MAX 16
#define BFLB_CRYPT_BLK_SIZE 16
#define BFLB_CRYPT_BLK_SIZE 16
#ifndef BFLB_CRYPT_HARDWARE
typedef union tag_bflb_crypt_ctx_t
@ -33,13 +33,13 @@ typedef union tag_bflb_crypt_ctx_t
typedef struct tag_bflb_crypt_cfg_t
{
#ifndef BFLB_CRYPT_HARDWARE
uint8_t key[BFLB_CRYPT_KEY_SIZE_MAX];
//for general cipher,iv is 16 bytes, but for GCM vector test, there is a 60 bytes test
uint8_t iv_nonce[BFLB_CRYPT_NONCE_SIZE_MAX*4];
uint8_t stream_block[BFLB_CRYPT_BLK_SIZE];
uint8_t key_len;
uint8_t nonce_len;
uint8_t dir;
uint8_t key[BFLB_CRYPT_KEY_SIZE_MAX];
//for general cipher,iv is 16 bytes, but for GCM vector test, there is a 60 bytes test
uint8_t iv_nonce[BFLB_CRYPT_NONCE_SIZE_MAX*4];
uint8_t stream_block[BFLB_CRYPT_BLK_SIZE];
uint8_t key_len;
uint8_t nonce_len;
uint8_t dir;
#else
#endif
uint8_t type;

2
components/bl602/bl602_std/bl602_std/Common/cipher_suite/inc/bflb_ecdsa_port.h
View File

@ -13,7 +13,7 @@
typedef union tag_bflb_ecdsa_ctx_t
{
#ifndef BFLB_PKA_HARDWARE
mbedtls_ecdsa_context ctx_ecdsa;
mbedtls_ecdsa_context ctx_ecdsa;
#endif
}bflb_ecdsa_ctx_t;

2
components/bl602/bl602_std/bl602_std/Common/cipher_suite/inc/bflb_hash.h
View File

@ -26,7 +26,7 @@ typedef struct tag_bflb_hash_handle_t
{
bflb_hash_ctx_t hash_ctx;
#ifdef BFLB_CRYPT_HARDWARE
uint32_t sha_padding[64/4]; //for sha finish compute, must located at OCRAM
uint32_t sha_padding[64/4]; //for sha finish compute, must located at OCRAM
#endif
uint8_t type;
}bflb_hash_handle_t;

2
components/bl602/bl602_std/bl602_std/Common/cipher_suite/inc/bflb_hash_port.h
View File

@ -21,7 +21,7 @@ typedef union tag_bflb_hash_ctx_t
mbedtls_sha256_context ctx_sha256;
mbedtls_sha512_context ctx_sha512;
#else
uint32_t sha_buf[64/4]; //for sha finish compute, must located at OCRAM
uint32_t sha_buf[64/4]; //for sha finish compute, must located at OCRAM
#endif
}bflb_hash_ctx_t;

198
components/bl602/bl602_std/bl602_std/Common/cipher_suite/src/bflb_crypt.c
View File

@ -6,28 +6,28 @@ int32_t bflb_crypt_init_do(bflb_crypt_handle_t *crypt_handle,uint8_t type)
int32_t ret = BFLB_CRYPT_OK;
switch(type)
{
case BFLB_CRYPT_TYPE_AES_CBC:
case BFLB_CRYPT_TYPE_AES_CTR:
mbedtls_aes_init((mbedtls_aes_context*)&crypt_handle->crypt_ctx);
break;
case BFLB_CRYPT_TYPE_CHACHA:
memset((ChaCha*)&crypt_handle->crypt_ctx,0,sizeof(ChaCha));
break;
case BFLB_CRYPT_TYPE_AES_CCM:
mbedtls_ccm_init((mbedtls_ccm_context *)&crypt_handle->crypt_ctx);
break;
case BFLB_CRYPT_TYPE_AES_GCM:
mbedtls_gcm_init((mbedtls_gcm_context *)&crypt_handle->crypt_ctx);
break;
case BFLB_CRYPT_TYPE_CHACHAPOLY1305:
memset((ChaChaPoly1305*)&crypt_handle->crypt_ctx,0,sizeof(ChaChaPoly1305));
break;
default:
bflb_crypt_printe("unsupported type\r\n");
ret=BFLB_CRYPT_ERROR;
break;
}
{
case BFLB_CRYPT_TYPE_AES_CBC:
case BFLB_CRYPT_TYPE_AES_CTR:
mbedtls_aes_init((mbedtls_aes_context*)&crypt_handle->crypt_ctx);
break;
case BFLB_CRYPT_TYPE_CHACHA:
memset((ChaCha*)&crypt_handle->crypt_ctx,0,sizeof(ChaCha));
break;
case BFLB_CRYPT_TYPE_AES_CCM:
mbedtls_ccm_init((mbedtls_ccm_context *)&crypt_handle->crypt_ctx);
break;
case BFLB_CRYPT_TYPE_AES_GCM:
mbedtls_gcm_init((mbedtls_gcm_context *)&crypt_handle->crypt_ctx);
break;
case BFLB_CRYPT_TYPE_CHACHAPOLY1305:
memset((ChaChaPoly1305*)&crypt_handle->crypt_ctx,0,sizeof(ChaChaPoly1305));
break;
default:
bflb_crypt_printe("unsupported type\r\n");
ret=BFLB_CRYPT_ERROR;
break;
}
return ret;
}
@ -36,14 +36,14 @@ int32_t bflb_crypt_setkey_do(bflb_crypt_handle_t *crypt_handle,const uint8_t *ke
{
int32_t ret = BFLB_CRYPT_OK;
memset(crypt_handle->crypt_cfg.key,0,sizeof(crypt_handle->crypt_cfg.key));
memset(crypt_handle->crypt_cfg.iv_nonce,0,sizeof(crypt_handle->crypt_cfg.iv_nonce));
memset(crypt_handle->crypt_cfg.stream_block,0,sizeof(crypt_handle->crypt_cfg.stream_block));
memset(crypt_handle->crypt_cfg.key,0,sizeof(crypt_handle->crypt_cfg.key));
memset(crypt_handle->crypt_cfg.iv_nonce,0,sizeof(crypt_handle->crypt_cfg.iv_nonce));
memset(crypt_handle->crypt_cfg.stream_block,0,sizeof(crypt_handle->crypt_cfg.stream_block));
memcpy(crypt_handle->crypt_cfg.key,key,key_len);
memcpy(crypt_handle->crypt_cfg.iv_nonce,nonce,nonce_len);
crypt_handle->crypt_cfg.key_len=key_len;
crypt_handle->crypt_cfg.nonce_len=nonce_len;
memcpy(crypt_handle->crypt_cfg.key,key,key_len);
memcpy(crypt_handle->crypt_cfg.iv_nonce,nonce,nonce_len);
crypt_handle->crypt_cfg.key_len=key_len;
crypt_handle->crypt_cfg.nonce_len=nonce_len;
switch(crypt_handle->crypt_cfg.type)
{
@ -61,9 +61,9 @@ int32_t bflb_crypt_setkey_do(bflb_crypt_handle_t *crypt_handle,const uint8_t *ke
key, key_len*8);
break;
case BFLB_CRYPT_TYPE_CHACHA:
ret|=Chacha_SetIV((ChaCha*)&crypt_handle->crypt_ctx, nonce, nonce_len,0);
ret|=Chacha_SetKey((ChaCha*)&crypt_handle->crypt_ctx, key, key_len);
break;
ret|=Chacha_SetIV((ChaCha*)&crypt_handle->crypt_ctx, nonce, nonce_len,0);
ret|=Chacha_SetKey((ChaCha*)&crypt_handle->crypt_ctx, key, key_len);
break;
case BFLB_CRYPT_TYPE_AES_CCM:
ret=mbedtls_ccm_setkey((mbedtls_ccm_context*)&crypt_handle->crypt_ctx,
MBEDTLS_CIPHER_ID_AES, key, key_len*8 ) ;
@ -73,7 +73,7 @@ int32_t bflb_crypt_setkey_do(bflb_crypt_handle_t *crypt_handle,const uint8_t *ke
MBEDTLS_CIPHER_ID_AES, key, key_len*8 ) ;
break;
case BFLB_CRYPT_TYPE_CHACHAPOLY1305:
break;
break;
default:
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
@ -119,13 +119,13 @@ int32_t bflb_crypt_encrypt_do(bflb_crypt_handle_t *crypt_handle,const uint8_t *i
MBEDTLS_AES_ENCRYPT, len, crypt_handle->crypt_cfg.iv_nonce, in, out);
break;
case BFLB_CRYPT_TYPE_AES_CTR:
result=mbedtls_aes_crypt_ctr((mbedtls_aes_context*)&crypt_handle->crypt_ctx,
len, &offset2, crypt_handle->crypt_cfg.iv_nonce, crypt_handle->crypt_cfg.stream_block,
in, out );
break;
result=mbedtls_aes_crypt_ctr((mbedtls_aes_context*)&crypt_handle->crypt_ctx,
len, &offset2, crypt_handle->crypt_cfg.iv_nonce, crypt_handle->crypt_cfg.stream_block,
in, out );
break;
case BFLB_CRYPT_TYPE_CHACHA:
result=Chacha_Process((ChaCha*)&crypt_handle->crypt_ctx,out,in,len);
break;
result=Chacha_Process((ChaCha*)&crypt_handle->crypt_ctx,out,in,len);
break;
default:
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
@ -153,13 +153,13 @@ int32_t bflb_crypt_encrypt_tag_do(bflb_crypt_handle_t *crypt_handle,const uint8_
add,add_len,in,out,tag_len,tag);
break;
case BFLB_CRYPT_TYPE_CHACHAPOLY1305:
result = ChaCha20Poly1305_Encrypt((ChaChaPoly1305*)&crypt_handle->crypt_ctx,
crypt_handle->crypt_cfg.key,crypt_handle->crypt_cfg.key_len,
crypt_handle->crypt_cfg.iv_nonce,crypt_handle->crypt_cfg.nonce_len,
add,add_len,in,in_len,out,tag,tag_len);
break;
result = ChaCha20Poly1305_Encrypt((ChaChaPoly1305*)&crypt_handle->crypt_ctx,
crypt_handle->crypt_cfg.key,crypt_handle->crypt_cfg.key_len,
crypt_handle->crypt_cfg.iv_nonce,crypt_handle->crypt_cfg.nonce_len,
add,add_len,in,in_len,out,tag,tag_len);
break;
default:
bflb_crypt_printe("unsupported type\r\n");
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
}
@ -209,8 +209,8 @@ int32_t bflb_crypt_decrypt_do(bflb_crypt_handle_t *crypt_handle,const uint8_t *i
in, out );
break;
case BFLB_CRYPT_TYPE_CHACHA:
result=Chacha_Process((ChaCha*)&crypt_handle->crypt_ctx,out,in,len);
break;
result=Chacha_Process((ChaCha*)&crypt_handle->crypt_ctx,out,in,len);
break;
default:
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
@ -239,13 +239,13 @@ int32_t bflb_crypt_auth_decrypt_do(bflb_crypt_handle_t *crypt_handle,const uint8
add,add_len,tag,tag_len,in,out);
break;
case BFLB_CRYPT_TYPE_CHACHAPOLY1305:
result = ChaCha20Poly1305_Decrypt((ChaChaPoly1305*)&crypt_handle->crypt_ctx,
crypt_handle->crypt_cfg.key,crypt_handle->crypt_cfg.key_len,
crypt_handle->crypt_cfg.iv_nonce,crypt_handle->crypt_cfg.nonce_len,
add,add_len,in,in_len,tag,tag_len,out);
break;
result = ChaCha20Poly1305_Decrypt((ChaChaPoly1305*)&crypt_handle->crypt_ctx,
crypt_handle->crypt_cfg.key,crypt_handle->crypt_cfg.key_len,
crypt_handle->crypt_cfg.iv_nonce,crypt_handle->crypt_cfg.nonce_len,
add,add_len,in,in_len,tag,tag_len,out);
break;
default:
bflb_crypt_printe("unsupported type\r\n");
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
}
@ -263,7 +263,7 @@ int32_t bflb_crypt_finish_do(bflb_crypt_handle_t *crypt_handle,uint8_t *tag,uint
tag, len );
break;
default:
bflb_crypt_printe("unsupported type\r\n");
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
}
@ -287,9 +287,9 @@ int32_t bflb_crypt_deinit_do(bflb_crypt_handle_t *crypt_handle)
break;
case BFLB_CRYPT_TYPE_CHACHA:
case BFLB_CRYPT_TYPE_CHACHAPOLY1305:
break;
break;
default:
bflb_crypt_printe("unsupported type\r\n");
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
}
@ -307,40 +307,40 @@ int32_t bflb_crypt_init_do(bflb_crypt_handle_t *crypt_handle,uint8_t type)
int32_t bflb_crypt_setkey_do(bflb_crypt_handle_t *crypt_handle,const uint8_t *key, uint8_t keytype, uint8_t key_len,
const uint8_t *nonce,uint8_t nonce_len,uint8_t dir)
{
int32_t ret = BFLB_CRYPT_OK;
int32_t ret = BFLB_CRYPT_OK;
switch(crypt_handle->crypt_cfg.type)
{
case BFLB_CRYPT_TYPE_AES_CBC:
Sec_Eng_AES_Enable_BE(SEC_ENG_AES_ID0);
switch(crypt_handle->crypt_cfg.type)
{
case BFLB_CRYPT_TYPE_AES_CBC:
Sec_Eng_AES_Enable_BE(SEC_ENG_AES_ID0);
Sec_Eng_AES_Init(&aesCtx,SEC_ENG_AES_ID0,SEC_ENG_AES_CBC,(SEC_ENG_AES_Key_Type)keytype,
BFLB_CRYPT_DIR_ENCRYPT==dir?SEC_ENG_AES_ENCRYPTION:SEC_ENG_AES_DECRYPTION);
break;
case BFLB_CRYPT_TYPE_AES_CTR:
Sec_Eng_AES_Enable_BE(SEC_ENG_AES_ID0);
Sec_Eng_AES_Init(&aesCtx,SEC_ENG_AES_ID0,SEC_ENG_AES_CTR,(SEC_ENG_AES_Key_Type)keytype,
BFLB_CRYPT_DIR_ENCRYPT==dir?SEC_ENG_AES_ENCRYPTION:SEC_ENG_AES_DECRYPTION);
break;
case BFLB_CRYPT_TYPE_AES_CCM:
break;
case BFLB_CRYPT_TYPE_AES_GCM:
break;
case BFLB_CRYPT_TYPE_CHACHA:
case BFLB_CRYPT_TYPE_CHACHAPOLY1305:
break;
default:
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
}
BFLB_CRYPT_DIR_ENCRYPT==dir?SEC_ENG_AES_ENCRYPTION:SEC_ENG_AES_DECRYPTION);
break;
case BFLB_CRYPT_TYPE_AES_CTR:
Sec_Eng_AES_Enable_BE(SEC_ENG_AES_ID0);
Sec_Eng_AES_Init(&aesCtx,SEC_ENG_AES_ID0,SEC_ENG_AES_CTR,(SEC_ENG_AES_Key_Type)keytype,
BFLB_CRYPT_DIR_ENCRYPT==dir?SEC_ENG_AES_ENCRYPTION:SEC_ENG_AES_DECRYPTION);
break;
case BFLB_CRYPT_TYPE_AES_CCM:
break;
case BFLB_CRYPT_TYPE_AES_GCM:
break;
case BFLB_CRYPT_TYPE_CHACHA:
case BFLB_CRYPT_TYPE_CHACHAPOLY1305:
break;
default:
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
}
/* if key len is 0, means key is from efuse and *key value is key_sel value */
if(key_len==0){
Sec_Eng_AES_Set_Key_IV_BE(SEC_ENG_AES_ID0,SEC_ENG_AES_KEY_HW,key,nonce);
}else{
Sec_Eng_AES_Set_Key_IV_BE(SEC_ENG_AES_ID0,SEC_ENG_AES_KEY_SW,key,nonce);
}
/* if key len is 0, means key is from efuse and *key value is key_sel value */
if(key_len==0){
Sec_Eng_AES_Set_Key_IV_BE(SEC_ENG_AES_ID0,SEC_ENG_AES_KEY_HW,key,nonce);
}else{
Sec_Eng_AES_Set_Key_IV_BE(SEC_ENG_AES_ID0,SEC_ENG_AES_KEY_SW,key,nonce);
}
return ret;
return ret;
}
int32_t bflb_crypt_setadd_do(bflb_crypt_handle_t *crypt_handle,const uint8_t *add,uint8_t len,
@ -421,7 +421,7 @@ int32_t bflb_crypt_deinit_do(bflb_crypt_handle_t *crypt_handle)
case BFLB_CRYPT_TYPE_AES_CTR:
break;
default:
bflb_crypt_printe("unsupported type\r\n");
bflb_crypt_printe("unsupported type\r\n");
return BFLB_CRYPT_ERROR;
}
@ -448,8 +448,8 @@ int32_t bflb_crypt_setkey(bflb_crypt_handle_t *crypt_handle,const uint8_t *key,u
result=bflb_crypt_setkey_do(crypt_handle,key,keytype,key_len,nonce,nonce_len,dir);
if(result!=BFLB_CRYPT_OK){
bflb_crypt_printe("crypt set key fail\r\n");
result=BFLB_CRYPT_ERROR;
bflb_crypt_printe("crypt set key fail\r\n");
result=BFLB_CRYPT_ERROR;
}
return result;
@ -463,8 +463,8 @@ int32_t bflb_crypt_setadd(bflb_crypt_handle_t *crypt_handle,const uint8_t *add,u
result = bflb_crypt_setadd_do(crypt_handle,add,len,dir);
if(result!=BFLB_CRYPT_OK){
bflb_crypt_printe("crypt set add fail\r\n");
result=BFLB_CRYPT_ERROR;
bflb_crypt_printe("crypt set add fail\r\n");
result=BFLB_CRYPT_ERROR;
}
return result;
@ -473,7 +473,7 @@ int32_t bflb_crypt_setadd(bflb_crypt_handle_t *crypt_handle,const uint8_t *add,u
int32_t bflb_crypt_encrypt(bflb_crypt_handle_t *crypt_handle,const uint8_t *in,uint32_t len,
size_t offset,uint8_t *out)
{
int32_t result;
int32_t result;
result=bflb_crypt_encrypt_do(crypt_handle,in,len, offset,out);
@ -490,13 +490,13 @@ int32_t bflb_crypt_encrypt_tag(bflb_crypt_handle_t *crypt_handle,const uint8_t *
const uint8_t *add,uint32_t add_len,size_t offset,uint8_t *out,
uint8_t *tag,uint8_t tag_len)
{
int32_t result;
int32_t result;
result= bflb_crypt_encrypt_tag_do(crypt_handle,in,in_len,add,add_len,offset,out,tag,tag_len);
if( result != BFLB_CRYPT_OK)
{
bflb_crypt_printe("crypt encrypt and tag fail\r\n");
bflb_crypt_printe("crypt encrypt and tag fail\r\n");
return BFLB_CRYPT_ERROR;
}
@ -506,7 +506,7 @@ int32_t bflb_crypt_encrypt_tag(bflb_crypt_handle_t *crypt_handle,const uint8_t *
int32_t bflb_crypt_update(bflb_crypt_handle_t *crypt_handle,const uint8_t *in,uint32_t len,
uint8_t *out)
{
int32_t result;
int32_t result;
result=bflb_crypt_update_do(crypt_handle,in,len,out);
@ -523,7 +523,7 @@ int32_t bflb_crypt_update(bflb_crypt_handle_t *crypt_handle,const uint8_t *in,ui
int32_t bflb_crypt_decrypt(bflb_crypt_handle_t *crypt_handle,const uint8_t *in,uint32_t len,
size_t offset,uint8_t *out)
{
int32_t result;
int32_t result;
result=bflb_crypt_decrypt_do(crypt_handle,in,len,offset,out);
@ -540,7 +540,7 @@ int32_t bflb_crypt_auth_decrypt(bflb_crypt_handle_t *crypt_handle,const uint8_t
const uint8_t *add,uint32_t add_len,size_t offset,uint8_t *out,
const uint8_t *tag,uint8_t tag_len)
{
int32_t result;
int32_t result;
result= bflb_crypt_auth_decrypt_do(crypt_handle,in,in_len,add,add_len,offset,out,tag,tag_len);
@ -555,7 +555,7 @@ int32_t bflb_crypt_auth_decrypt(bflb_crypt_handle_t *crypt_handle,const uint8_t
int32_t bflb_crypt_finish(bflb_crypt_handle_t *crypt_handle,uint8_t *tag,uint32_t len)
{
int32_t result;
int32_t result;
result=bflb_crypt_finish_do(crypt_handle,tag,len);
@ -572,7 +572,7 @@ int32_t bflb_crypt_finish(bflb_crypt_handle_t *crypt_handle,uint8_t *tag,uint32_
int32_t bflb_crypt_deinit(bflb_crypt_handle_t *crypt_handle)
{
bflb_crypt_deinit_do(crypt_handle);
bflb_crypt_deinit_do(crypt_handle);
memset(crypt_handle,0,sizeof(bflb_crypt_handle_t));
return BFLB_CRYPT_OK;

8
components/bl602/bl602_std/bl602_std/Common/cipher_suite/src/bflb_ecdsa.c
View File

@ -1021,10 +1021,10 @@ int32_t bflb_ecdh_get_public_key( uint8_t id,const uint32_t *pkX,const uint32_t
int32_t bflb_ecdsa_get_private_key( uint8_t id,uint32_t *private_key)
{
if(bflb_ecc_get_random_value(private_key,(uint32_t *)secp256r1N,32)<0){
return -1;
}
return 0;
if(bflb_ecc_get_random_value(private_key,(uint32_t *)secp256r1N,32)<0){
return -1;
}
return 0;
}
int32_t bflb_ecdsa_sign( uint8_t id,const uint32_t *private_key,const uint32_t *random_k,const uint32_t *hash,uint32_t *r,uint32_t *s)

34
components/bl602/bl602_std/bl602_std/Common/cipher_suite/src/bflb_hash.c
View File

@ -32,8 +32,8 @@ int32_t bflb_hash_init(bflb_hash_handle_t *hash_handle,uint8_t type)
switch(type)
{
case BFLB_HASH_TYPE_SHA1 :
ret=BFLB_HASH_ERROR;
bflb_hash_printe("unsupported type\r\n");
ret=BFLB_HASH_ERROR;
bflb_hash_printe("unsupported type\r\n");
break;
case BFLB_HASH_TYPE_SHA224:
Sec_Eng_SHA256_Init(&shaCtx,SEC_ENG_SHA_ID0,SEC_ENG_SHA224,(uint32_t *)hash_handle->hash_ctx.sha_buf,
@ -45,8 +45,8 @@ int32_t bflb_hash_init(bflb_hash_handle_t *hash_handle,uint8_t type)
break;
case BFLB_HASH_TYPE_SHA384:
case BFLB_HASH_TYPE_SHA512:
ret=BFLB_HASH_ERROR;
bflb_hash_printe("unsupported type\r\n");
ret=BFLB_HASH_ERROR;
bflb_hash_printe("unsupported type\r\n");
break;
default:
bflb_hash_printe("unsupported type\r\n");
@ -71,10 +71,10 @@ int32_t bflb_hash_start(bflb_hash_handle_t *hash_handle)
case BFLB_HASH_TYPE_SHA1:
break;
case BFLB_HASH_TYPE_SHA224:
Sec_Eng_SHA_Start(SEC_ENG_SHA_ID0);
Sec_Eng_SHA_Start(SEC_ENG_SHA_ID0);
break;
case BFLB_HASH_TYPE_SHA256:
Sec_Eng_SHA_Start(SEC_ENG_SHA_ID0);
Sec_Eng_SHA_Start(SEC_ENG_SHA_ID0);
break;
case BFLB_HASH_TYPE_SHA384:
break;
@ -86,7 +86,7 @@ int32_t bflb_hash_start(bflb_hash_handle_t *hash_handle)
}
if(ret!=0){
bflb_hash_printe("hash start fail\r\n");
bflb_hash_printe("hash start fail\r\n");
ret=BFLB_HASH_ERROR;
}
return ret;
@ -100,11 +100,11 @@ int32_t bflb_hash_update(bflb_hash_handle_t *hash_handle,const uint8_t *in,uint3
{
case BFLB_HASH_TYPE_SHA1:
break;
case BFLB_HASH_TYPE_SHA224:
Sec_Eng_SHA256_Update(&shaCtx,SEC_ENG_SHA_ID0,in, len);
break;
case BFLB_HASH_TYPE_SHA224:
Sec_Eng_SHA256_Update(&shaCtx,SEC_ENG_SHA_ID0,in, len);
break;
case BFLB_HASH_TYPE_SHA256:
Sec_Eng_SHA256_Update(&shaCtx,SEC_ENG_SHA_ID0,in, len);
Sec_Eng_SHA256_Update(&shaCtx,SEC_ENG_SHA_ID0,in, len);
break;
case BFLB_HASH_TYPE_SHA384:
break;
@ -116,7 +116,7 @@ int32_t bflb_hash_update(bflb_hash_handle_t *hash_handle,const uint8_t *in,uint3
}
if(ret!=0){
bflb_hash_printe("hash update fail\r\n");
bflb_hash_printe("hash update fail\r\n");
ret=BFLB_HASH_ERROR;
}
@ -132,10 +132,10 @@ int32_t bflb_hash_finish(bflb_hash_handle_t *hash_handle,uint8_t *out)
case BFLB_HASH_TYPE_SHA1:
break;
case BFLB_HASH_TYPE_SHA224:
Sec_Eng_SHA256_Finish(&shaCtx,SEC_ENG_SHA_ID0,out);
break;
Sec_Eng_SHA256_Finish(&shaCtx,SEC_ENG_SHA_ID0,out);
break;
case BFLB_HASH_TYPE_SHA256:
Sec_Eng_SHA256_Finish(&shaCtx,SEC_ENG_SHA_ID0,out);
Sec_Eng_SHA256_Finish(&shaCtx,SEC_ENG_SHA_ID0,out);
break;
case BFLB_HASH_TYPE_SHA384:
break;
@ -147,7 +147,7 @@ int32_t bflb_hash_finish(bflb_hash_handle_t *hash_handle,uint8_t *out)
}
if(ret!=0){
bflb_hash_printe("hash finish fail\r\n");
bflb_hash_printe("hash finish fail\r\n");
ret=BFLB_HASH_ERROR;
}
@ -161,7 +161,7 @@ int32_t bflb_hash_deinit(bflb_hash_handle_t *hash_handle)
case BFLB_HASH_TYPE_SHA1:
break;
case BFLB_HASH_TYPE_SHA224:
break;
break;
case BFLB_HASH_TYPE_SHA256:
break;
case BFLB_HASH_TYPE_SHA384:

16
components/bl602/bl602_std/bl602_std/Common/cipher_suite/src/bflb_rsa.c
View File

@ -15,8 +15,8 @@ int32_t bflb_rsa_set_parameter(bflb_rsa_handle_t *rsa_handle,int type,uint8_t *v
int32_t ret = BFLB_RSA_OK;
mbedtls_rsa_context* rsa=(mbedtls_rsa_context*)&rsa_handle->rsa_ctx;
switch(type)
{
switch(type)
{
case BFLB_RSA_PARA_N:
mbedtls_mpi_read_binary(&rsa->N,value,len);
rsa->len = ( mbedtls_mpi_bitlen( &rsa->N ) + 7 ) >> 3;
@ -45,7 +45,7 @@ int32_t bflb_rsa_set_parameter(bflb_rsa_handle_t *rsa_handle,int type,uint8_t *v
default:
ret=BFLB_RSA_ERROR;
break;
}
}
return ret;
}
@ -55,7 +55,7 @@ int32_t bflb_rsa_check_private(bflb_rsa_handle_t *rsa_handle)
int32_t ret = BFLB_RSA_OK;
mbedtls_rsa_context* rsa=(mbedtls_rsa_context*)&rsa_handle->rsa_ctx;
if( ( ret = mbedtls_rsa_check_privkey( rsa ) ) != 0 )
if( ( ret = mbedtls_rsa_check_privkey( rsa ) ) != 0 )
{
bflb_rsa_printe("failed\r\n!rsa_check_privkey failed with -0x%0x\n", -ret );
return BFLB_RSA_ERROR;
@ -69,7 +69,7 @@ int32_t bflb_rsa_check_public(bflb_rsa_handle_t *rsa_handle)
int32_t ret = BFLB_RSA_OK;
mbedtls_rsa_context* rsa=(mbedtls_rsa_context*)&rsa_handle->rsa_ctx;
if( ( ret = mbedtls_rsa_check_pubkey( rsa ) ) != 0 )
if( ( ret = mbedtls_rsa_check_pubkey( rsa ) ) != 0 )
{
bflb_rsa_printe("failed\r\n!rsa_check_privkey failed with -0x%0x\n", -ret );
return BFLB_RSA_ERROR;
@ -84,8 +84,8 @@ int32_t bflb_rsa_sign( bflb_rsa_handle_t *rsa_handle,const uint8_t *hash,
int32_t ret = BFLB_RSA_OK;
mbedtls_rsa_context* rsa=(mbedtls_rsa_context*)&rsa_handle->rsa_ctx;
ret = mbedtls_rsa_pkcs1_sign( rsa, NULL, NULL, MBEDTLS_RSA_PRIVATE,
(mbedtls_md_type_t)bflb_hash_get_type(hashtype),
ret = mbedtls_rsa_pkcs1_sign( rsa, NULL, NULL, MBEDTLS_RSA_PRIVATE,
(mbedtls_md_type_t)bflb_hash_get_type(hashtype),
hashlen, hash, sig );
if( ret != 0 )
{
@ -103,7 +103,7 @@ int32_t bflb_rsa_verify( bflb_rsa_handle_t *rsa_handle,const uint8_t *hash,
mbedtls_rsa_context* rsa=(mbedtls_rsa_context*)&rsa_handle->rsa_ctx;
ret = mbedtls_rsa_pkcs1_verify( rsa, NULL, NULL, MBEDTLS_RSA_PUBLIC,
(mbedtls_md_type_t)bflb_hash_get_type(hashtype),
(mbedtls_md_type_t)bflb_hash_get_type(hashtype),
hashlen, hash, sig );
if( ret != 0 )
{

26
components/bl602/bl602_std/bl602_std/Common/libc/inc/bits/ctype_base.h
View File

@ -7,22 +7,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct ctype_base
{
// Non-standard typedefs.
typedef const int* __to_type;
typedef const int* __to_type;
// NB: Offsets into ctype<char>::_M_table force a particular size
// on the mask type. Because of this, we don't use an enum.
typedef char mask;
static const mask upper = _U;
static const mask lower = _L;
static const mask alpha = _U | _L;
static const mask digit = _N;
static const mask xdigit = _X | _N;
static const mask space = _S;
static const mask print = _P | _U | _L | _N | _B;
static const mask graph = _P | _U | _L | _N;
static const mask cntrl = _C;
static const mask punct = _P;
static const mask alnum = _U | _L | _N;
typedef char mask;
static const mask upper = _U;
static const mask lower = _L;
static const mask alpha = _U | _L;
static const mask digit = _N;
static const mask xdigit = _X | _N;
static const mask space = _S;
static const mask print = _P | _U | _L | _N | _B;
static const mask graph = _P | _U | _L | _N;
static const mask cntrl = _C;
static const mask punct = _P;
static const mask alnum = _U | _L | _N;
};
_GLIBCXX_END_NAMESPACE_VERSION

52
components/bl602/bl602_std/bl602_std/Common/libc/inc/ctype.h
View File

@ -28,14 +28,14 @@
* blank = '\t' || ' ' (per POSIX requirement)
*/
enum {
__ctype_upper = _U,
__ctype_lower = _L,
__ctype_digit = _N,
__ctype_xdigit = _S,
__ctype_space = _P,
__ctype_print = _C,
__ctype_punct = _X,
__ctype_cntrl = _B
__ctype_upper = _U,
__ctype_lower = _L,
__ctype_digit = _N,
__ctype_xdigit = _S,
__ctype_space = _P,
__ctype_print = _C,
__ctype_punct = _X,
__ctype_cntrl = _B
};
__extern int isalnum(int);
@ -58,69 +58,69 @@ extern const unsigned char __ctypes[];
__must_inline int __ctype_isalnum(int __c)
{
return __ctypes[__c + 1] &
(__ctype_upper | __ctype_lower | __ctype_digit);
return __ctypes[__c + 1] &
(__ctype_upper | __ctype_lower | __ctype_digit);
}
__must_inline int __ctype_isalpha(int __c)
{
return __ctypes[__c + 1] & (__ctype_upper | __ctype_lower);
return __ctypes[__c + 1] & (__ctype_upper | __ctype_lower);
}
__must_inline int __ctype_isascii(int __c)
{
return !(__c & ~0x7f);
return !(__c & ~0x7f);
}
__must_inline int __ctype_isblank(int __c)
{
return (__c == '\t') || (__c == ' ');
return (__c == '\t') || (__c == ' ');
}
__must_inline int __ctype_iscntrl(int __c)
{
return __ctypes[__c + 1] & __ctype_cntrl;
return __ctypes[__c + 1] & __ctype_cntrl;
}
__must_inline int __ctype_isdigit(int __c)
{
return ((unsigned)__c - '0') <= 9;
return ((unsigned)__c - '0') <= 9;
}
__must_inline int __ctype_isgraph(int __c)
{
return __ctypes[__c + 1] &
(__ctype_upper | __ctype_lower | __ctype_digit | __ctype_punct);
return __ctypes[__c + 1] &
(__ctype_upper | __ctype_lower | __ctype_digit | __ctype_punct);
}
__must_inline int __ctype_islower(int __c)
{
return __ctypes[__c + 1] & __ctype_lower;
return __ctypes[__c + 1] & __ctype_lower;
}
__must_inline int __ctype_isprint(int __c)
{
return __ctypes[__c + 1] & __ctype_print;
return __ctypes[__c + 1] & __ctype_print;
}
__must_inline int __ctype_ispunct(int __c)
{
return __ctypes[__c + 1] & __ctype_punct;
return __ctypes[__c + 1] & __ctype_punct;
}
__must_inline int __ctype_isspace(int __c)
{
return __ctypes[__c + 1] & __ctype_space;
return __ctypes[__c + 1] & __ctype_space;
}
__must_inline int __ctype_isupper(int __c)
{
return __ctypes[__c + 1] & __ctype_upper;
return __ctypes[__c + 1] & __ctype_upper;
}
__must_inline int __ctype_isxdigit(int __c)
{
return __ctypes[__c + 1] & __ctype_xdigit;
return __ctypes[__c + 1] & __ctype_xdigit;
}
/* Note: this is decimal, not hex, to avoid accidental promotion to unsigned */
@ -129,12 +129,12 @@ __must_inline int __ctype_isxdigit(int __c)
__must_inline int __ctype_toupper(int __c)
{
return __ctype_islower(__c) ? _toupper(__c) : __c;
return __ctype_islower(__c) ? _toupper(__c) : __c;
}
__must_inline int __ctype_tolower(int __c)
{
return __ctype_isupper(__c) ? _tolower(__c) : __c;
return __ctype_isupper(__c) ? _tolower(__c) : __c;
}
#endif /* _CTYPE_H */
#endif /* _CTYPE_H */

2
components/bl602/bl602_std/bl602_std/Common/libc/inc/extern.h
View File

@ -13,4 +13,4 @@
#define __alias(x) __attribute__((weak, alias(x)))
#endif /* _EXTERN_H */
#endif /* _EXTERN_H */

10
components/bl602/bl602_std/bl602_std/Common/libc/inc/fnmatch.h
View File

@ -3,12 +3,12 @@
#include <extern.h>
#define FNM_NOMATCH 1
#define FNM_NOMATCH 1
#define FNM_PATHNAME 1
#define FNM_FILE_NAME FNM_PATHNAME
#define FNM_NOESCAPE 2
#define FNM_PERIOD 4
#define FNM_PATHNAME 1
#define FNM_FILE_NAME FNM_PATHNAME
#define FNM_NOESCAPE 2
#define FNM_PERIOD 4
__extern int fnmatch(const char *, const char *, int);

290
components/bl602/bl602_std/bl602_std/Common/libc/inc/inttypes.h
View File

@ -12,7 +12,7 @@
static __inline intmax_t imaxabs(intmax_t __n)
{
return (__n < (intmax_t) 0) ? -__n : __n;
return (__n < (intmax_t) 0) ? -__n : __n;
}
__extern intmax_t strtoimax(const char *, char **, int);
@ -24,204 +24,204 @@ __extern uintmax_t strntoumax(const char *, char **, int, size_t);
#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS)
#define PRId8 "d"
#define PRId16 "d"
#define PRId32 "d"
#define PRId64 __PRI64_RANK "d"
#define PRId8 "d"
#define PRId16 "d"
#define PRId32 "d"
#define PRId64 __PRI64_RANK "d"
#define PRIdLEAST8 "d"
#define PRIdLEAST16 "d"
#define PRIdLEAST32 "d"
#define PRIdLEAST64 __PRI64_RANK "d"
#define PRIdLEAST8 "d"
#define PRIdLEAST16 "d"
#define PRIdLEAST32 "d"
#define PRIdLEAST64 __PRI64_RANK "d"
#define PRIdFAST8 "d"
#define PRIdFAST16 __PRIFAST_RANK "d"
#define PRIdFAST32 __PRIFAST_RANK "d"
#define PRIdFAST64 __PRI64_RANK "d"
#define PRIdFAST8 "d"
#define PRIdFAST16 __PRIFAST_RANK "d"
#define PRIdFAST32 __PRIFAST_RANK "d"
#define PRIdFAST64 __PRI64_RANK "d"
#define PRIdMAX __PRI64_RANK "d"
#define PRIdMAX __PRI64_RANK "d"
#define PRIdPTR __PRIPTR_RANK "d"
#define PRIi8 "i"
#define PRIi16 "i"
#define PRIi32 "i"
#define PRIi64 __PRI64_RANK "i"
#define PRIi8 "i"
#define PRIi16 "i"
#define PRIi32 "i"
#define PRIi64 __PRI64_RANK "i"
#define PRIiLEAST8 "i"
#define PRIiLEAST16 "i"
#define PRIiLEAST32 "i"
#define PRIiLEAST64 __PRI64_RANK "i"
#define PRIiLEAST8 "i"
#define PRIiLEAST16 "i"
#define PRIiLEAST32 "i"
#define PRIiLEAST64 __PRI64_RANK "i"
#define PRIiFAST8 "i"
#define PRIiFAST16 __PRIFAST_RANK "i"
#define PRIiFAST32 __PRIFAST_RANK "i"
#define PRIiFAST64 __PRI64_RANK "i"
#define PRIiFAST8 "i"
#define PRIiFAST16 __PRIFAST_RANK "i"
#define PRIiFAST32 __PRIFAST_RANK "i"
#define PRIiFAST64 __PRI64_RANK "i"
#define PRIiMAX __PRI64_RANK "i"
#define PRIiMAX __PRI64_RANK "i"
#define PRIiPTR __PRIPTR_RANK "i"
#define PRIo8 "o"
#define PRIo16 "o"
#define PRIo32 "o"
#define PRIo64 __PRI64_RANK "o"
#define PRIo8 "o"
#define PRIo16 "o"
#define PRIo32 "o"
#define PRIo64 __PRI64_RANK "o"
#define PRIoLEAST8 "o"
#define PRIoLEAST16 "o"
#define PRIoLEAST32 "o"
#define PRIoLEAST64 __PRI64_RANK "o"
#define PRIoLEAST8 "o"
#define PRIoLEAST16 "o"
#define PRIoLEAST32 "o"
#define PRIoLEAST64 __PRI64_RANK "o"
#define PRIoFAST8 "o"
#define PRIoFAST16 __PRIFAST_RANK "o"
#define PRIoFAST32 __PRIFAST_RANK "o"
#define PRIoFAST64 __PRI64_RANK "o"
#define PRIoFAST8 "o"
#define PRIoFAST16 __PRIFAST_RANK "o"
#define PRIoFAST32 __PRIFAST_RANK "o"
#define PRIoFAST64 __PRI64_RANK "o"
#define PRIoMAX __PRI64_RANK "o"
#define PRIoMAX __PRI64_RANK "o"
#define PRIoPTR __PRIPTR_RANK "o"
#define PRIu8 "u"
#define PRIu16 "u"
#define PRIu32 "u"
#define PRIu64 __PRI64_RANK "u"
#define PRIu8 "u"
#define PRIu16 "u"
#define PRIu32 "u"
#define PRIu64 __PRI64_RANK "u"
#define PRIuLEAST8 "u"
#define PRIuLEAST16 "u"
#define PRIuLEAST32 "u"
#define PRIuLEAST64 __PRI64_RANK "u"
#define PRIuLEAST8 "u"
#define PRIuLEAST16 "u"
#define PRIuLEAST32 "u"
#define PRIuLEAST64 __PRI64_RANK "u"
#define PRIuFAST8 "u"
#define PRIuFAST16 __PRIFAST_RANK "u"
#define PRIuFAST32 __PRIFAST_RANK "u"
#define PRIuFAST64 __PRI64_RANK "u"
#define PRIuFAST8 "u"
#define PRIuFAST16 __PRIFAST_RANK "u"
#define PRIuFAST32 __PRIFAST_RANK "u"
#define PRIuFAST64 __PRI64_RANK "u"
#define PRIuMAX __PRI64_RANK "u"
#define PRIuMAX __PRI64_RANK "u"
#define PRIuPTR __PRIPTR_RANK "u"
#define PRIx8 "x"
#define PRIx16 "x"
#define PRIx32 "x"
#define PRIx64 __PRI64_RANK "x"
#define PRIx8 "x"
#define PRIx16 "x"
#define PRIx32 "x"
#define PRIx64 __PRI64_RANK "x"
#define PRIxLEAST8 "x"
#define PRIxLEAST16 "x"
#define PRIxLEAST32 "x"
#define PRIxLEAST64 __PRI64_RANK "x"
#define PRIxLEAST8 "x"
#define PRIxLEAST16 "x"
#define PRIxLEAST32 "x"
#define PRIxLEAST64 __PRI64_RANK "x"
#define PRIxFAST8 "x"
#define PRIxFAST16 __PRIFAST_RANK "x"
#define PRIxFAST32 __PRIFAST_RANK "x"
#define PRIxFAST64 __PRI64_RANK "x"
#define PRIxFAST8 "x"
#define PRIxFAST16 __PRIFAST_RANK "x"
#define PRIxFAST32 __PRIFAST_RANK "x"
#define PRIxFAST64 __PRI64_RANK "x"
#define PRIxMAX __PRI64_RANK "x"
#define PRIxMAX __PRI64_RANK "x"
#define PRIxPTR __PRIPTR_RANK "x"
#define PRIX8 "X"
#define PRIX16 "X"
#define PRIX32 "X"
#define PRIX64 __PRI64_RANK "X"
#define PRIX8 "X"
#define PRIX16 "X"
#define PRIX32 "X"
#define PRIX64 __PRI64_RANK "X"
#define PRIXLEAST8 "X"
#define PRIXLEAST16 "X"
#define PRIXLEAST32 "X"
#define PRIXLEAST64 __PRI64_RANK "X"
#define PRIXLEAST8 "X"
#define PRIXLEAST16 "X"
#define PRIXLEAST32 "X"
#define PRIXLEAST64 __PRI64_RANK "X"
#define PRIXFAST8 "X"
#define PRIXFAST16 __PRIFAST_RANK "X"
#define PRIXFAST32 __PRIFAST_RANK "X"
#define PRIXFAST64 __PRI64_RANK "X"
#define PRIXFAST8 "X"
#define PRIXFAST16 __PRIFAST_RANK "X"
#define PRIXFAST32 __PRIFAST_RANK "X"
#define PRIXFAST64 __PRI64_RANK "X"
#define PRIXMAX __PRI64_RANK "X"
#define PRIXMAX __PRI64_RANK "X"
#define PRIXPTR __PRIPTR_RANK "X"
#define SCNd8 "hhd"
#define SCNd16 "hd"
#define SCNd32 "d"
#define SCNd64 __PRI64_RANK "d"
#define SCNd8 "hhd"
#define SCNd16 "hd"
#define SCNd32 "d"
#define SCNd64 __PRI64_RANK "d"
#define SCNdLEAST8 "hhd"
#define SCNdLEAST16 "hd"
#define SCNdLEAST32 "d"
#define SCNdLEAST64 __PRI64_RANK "d"
#define SCNdLEAST8 "hhd"
#define SCNdLEAST16 "hd"
#define SCNdLEAST32 "d"
#define SCNdLEAST64 __PRI64_RANK "d"
#define SCNdFAST8 "hhd"
#define SCNdFAST16 __PRIFAST_RANK "d"
#define SCNdFAST32 __PRIFAST_RANK "d"
#define SCNdFAST64 __PRI64_RANK "d"
#define SCNdFAST8 "hhd"
#define SCNdFAST16 __PRIFAST_RANK "d"
#define SCNdFAST32 __PRIFAST_RANK "d"
#define SCNdFAST64 __PRI64_RANK "d"
#define SCNdMAX __PRI64_RANK "d"
#define SCNdMAX __PRI64_RANK "d"
#define SCNdPTR __PRIPTR_RANK "d"
#define SCNi8 "hhi"
#define SCNi16 "hi"
#define SCNi32 "i"
#define SCNi64 __PRI64_RANK "i"
#define SCNi8 "hhi"
#define SCNi16 "hi"
#define SCNi32 "i"
#define SCNi64 __PRI64_RANK "i"
#define SCNiLEAST8 "hhi"
#define SCNiLEAST16 "hi"
#define SCNiLEAST32 "i"
#define SCNiLEAST64 __PRI64_RANK "i"
#define SCNiLEAST8 "hhi"
#define SCNiLEAST16 "hi"
#define SCNiLEAST32 "i"
#define SCNiLEAST64 __PRI64_RANK "i"
#define SCNiFAST8 "hhi"
#define SCNiFAST16 __PRIFAST_RANK "i"
#define SCNiFAST32 __PRIFAST_RANK "i"
#define SCNiFAST64 __PRI64_RANK "i"
#define SCNiFAST8 "hhi"
#define SCNiFAST16 __PRIFAST_RANK "i"
#define SCNiFAST32 __PRIFAST_RANK "i"
#define SCNiFAST64 __PRI64_RANK "i"
#define SCNiMAX __PRI64_RANK "i"
#define SCNiMAX __PRI64_RANK "i"
#define SCNiPTR __PRIPTR_RANK "i"
#define SCNo8 "hho"
#define SCNo16 "ho"
#define SCNo32 "o"
#define SCNo64 __PRI64_RANK "o"
#define SCNo8 "hho"
#define SCNo16 "ho"
#define SCNo32 "o"
#define SCNo64 __PRI64_RANK "o"
#define SCNoLEAST8 "hho"
#define SCNoLEAST16 "ho"
#define SCNoLEAST32 "o"
#define SCNoLEAST64 __PRI64_RANK "o"
#define SCNoLEAST8 "hho"
#define SCNoLEAST16 "ho"
#define SCNoLEAST32 "o"
#define SCNoLEAST64 __PRI64_RANK "o"
#define SCNoFAST8 "hho"
#define SCNoFAST16 __PRIFAST_RANK "o"
#define SCNoFAST32 __PRIFAST_RANK "o"
#define SCNoFAST64 __PRI64_RANK "o"
#define SCNoFAST8 "hho"
#define SCNoFAST16 __PRIFAST_RANK "o"
#define SCNoFAST32 __PRIFAST_RANK "o"
#define SCNoFAST64 __PRI64_RANK "o"
#define SCNoMAX __PRI64_RANK "o"
#define SCNoMAX __PRI64_RANK "o"
#define SCNoPTR __PRIPTR_RANK "o"
#define SCNu8 "hhu"
#define SCNu16 "hu"
#define SCNu32 "u"
#define SCNu64 __PRI64_RANK "u"
#define SCNu8 "hhu"
#define SCNu16 "hu"
#define SCNu32 "u"
#define SCNu64 __PRI64_RANK "u"
#define SCNuLEAST8 "hhu"
#define SCNuLEAST16 "hu"
#define SCNuLEAST32 "u"
#define SCNuLEAST64 __PRI64_RANK "u"
#define SCNuLEAST8 "hhu"
#define SCNuLEAST16 "hu"
#define SCNuLEAST32 "u"
#define SCNuLEAST64 __PRI64_RANK "u"
#define SCNuFAST8 "hhu"
#define SCNuFAST16 __PRIFAST_RANK "u"
#define SCNuFAST32 __PRIFAST_RANK "u"
#define SCNuFAST64 __PRI64_RANK "u"
#define SCNuFAST8 "hhu"
#define SCNuFAST16 __PRIFAST_RANK "u"
#define SCNuFAST32 __PRIFAST_RANK "u"
#define SCNuFAST64 __PRI64_RANK "u"
#define SCNuMAX __PRI64_RANK "u"
#define SCNuMAX __PRI64_RANK "u"
#define SCNuPTR __PRIPTR_RANK "u"
#define SCNx8 "hhx"
#define SCNx16 "hx"
#define SCNx32 "x"
#define SCNx64 __PRI64_RANK "x"
#define SCNx8 "hhx"
#define SCNx16 "hx"
#define SCNx32 "x"
#define SCNx64 __PRI64_RANK "x"
#define SCNxLEAST8 "hhx"
#define SCNxLEAST16 "hx"
#define SCNxLEAST32 "x"
#define SCNxLEAST64 __PRI64_RANK "x"
#define SCNxLEAST8 "hhx"
#define SCNxLEAST16 "hx"
#define SCNxLEAST32 "x"
#define SCNxLEAST64 __PRI64_RANK "x"
#define SCNxFAST8 "hhx"
#define SCNxFAST16 __PRIFAST_RANK "x"
#define SCNxFAST32 __PRIFAST_RANK "x"
#define SCNxFAST64 __PRI64_RANK "x"
#define SCNxFAST8 "hhx"
#define SCNxFAST16 __PRIFAST_RANK "x"
#define SCNxFAST32 __PRIFAST_RANK "x"
#define SCNxFAST64 __PRI64_RANK "x"
#define SCNxMAX __PRI64_RANK "x"
#define SCNxMAX __PRI64_RANK "x"
#define SCNxPTR __PRIPTR_RANK "x"
#endif
#endif /* _INTTYPES_H */
#endif /* _INTTYPES_H */

6
components/bl602/bl602_std/bl602_std/Common/libc/inc/libc_compiler.h
View File

@ -17,7 +17,7 @@
/* Most other C compilers have __cdecl as a keyword */
# endif
#else
# define __cdecl /* Meaningless on non-i386 */
# define __cdecl /* Meaningless on non-i386 */
#endif
/* How to declare a function that *must* be inlined */
@ -26,7 +26,7 @@
# if __GNUC__ >= 3
# ifdef __GNUC_STDC_INLINE__
# define __must_inline extern __inline__ \
__attribute__((__gnu_inline__,__always_inline__))
__attribute__((__gnu_inline__,__always_inline__))
# else
# define __must_inline extern __inline__ __attribute__((__always_inline__))
# endif
@ -34,7 +34,7 @@
# define __must_inline extern __inline__
# endif
#else
# define __must_inline __inline /* Just hope this works... */
# define __must_inline __inline /* Just hope this works... */
# define __inline inline
#endif

42
components/bl602/bl602_std/bl602_std/Common/libc/inc/limits.h
View File

@ -5,14 +5,14 @@
#ifndef _LIMITS_H
#define _LIMITS_H
#define CHAR_BIT 8
#define SHRT_BIT 16
#define INT_BIT 32
#define LONGLONG_BIT 64
#define CHAR_BIT 8
#define SHRT_BIT 16
#define INT_BIT 32
#define LONGLONG_BIT 64
#define SCHAR_MIN (-128)
#define SCHAR_MAX 127
#define UCHAR_MAX 255
#define SCHAR_MIN (-128)
#define SCHAR_MAX 127
#define UCHAR_MAX 255
#ifdef __CHAR_UNSIGNED__
# define CHAR_MIN 0
@ -22,22 +22,22 @@
# define CHAR_MAX SCHAR_MAX
#endif
#define SHRT_MIN (-32768)
#define SHRT_MAX 32767
#define USHRT_MAX 65535
#define SHRT_MIN (-32768)
#define SHRT_MAX 32767
#define USHRT_MAX 65535
#define INT_MIN (-2147483647-1)
#define INT_MAX 2147483647
#define UINT_MAX 4294967295U
#define INT_MIN (-2147483647-1)
#define INT_MAX 2147483647
#define UINT_MAX 4294967295U
#define LONGLONG_MIN (-9223372036854775807LL-1)
#define LONGLONG_MAX 9223372036854775807LL
#define ULONGLONG_MAX 18446744073709551615ULL
#define LONGLONG_MIN (-9223372036854775807LL-1)
#define LONGLONG_MAX 9223372036854775807LL
#define ULONGLONG_MAX 18446744073709551615ULL
#define LONG_BIT 32
#define LONG_BIT 32
#define LONG_MIN (-2147483647L-1)
#define LONG_MAX 2147483647L
#define ULONG_MAX 4294967295UL
#define LONG_MIN (-2147483647L-1)
#define LONG_MAX 2147483647L
#define ULONG_MAX 4294967295UL
#endif /* _LIMITS_H */
#endif /* _LIMITS_H */

2
components/bl602/bl602_std/bl602_std/Common/libc/inc/stdbool.h
View File

@ -9,4 +9,4 @@
#define true 1
#define false 0
#endif /* _STDBOOL_H */
#endif /* _STDBOOL_H */

2
components/bl602/bl602_std/bl602_std/Common/libc/inc/stddef.h
View File

@ -26,4 +26,4 @@ typedef signed int wint_t;
#undef offsetof
#define offsetof(t,m) ((size_t)&((t *)0)->m)
#endif /* _STDDEF_H */
#endif /* _STDDEF_H */

164
components/bl602/bl602_std/bl602_std/Common/libc/inc/stdint.h
View File

@ -5,24 +5,24 @@
#ifndef _STDINT_H
#define _STDINT_H
typedef signed char int8_t;
typedef short int int16_t;
typedef int int32_t;
typedef long long int int64_t;
typedef signed char int8_t;
typedef short int int16_t;
typedef int int32_t;
typedef long long int int64_t;
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long int uint64_t;
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long int uint64_t;
typedef int int_fast16_t;
typedef int int_fast32_t;
typedef int int_fast16_t;
typedef int int_fast32_t;
typedef unsigned int uint_fast16_t;
typedef unsigned int uint_fast32_t;
typedef unsigned int uint_fast16_t;
typedef unsigned int uint_fast32_t;
typedef int intptr_t;
typedef unsigned int uintptr_t;
typedef int intptr_t;
typedef unsigned int uintptr_t;
#define __INT64_C(c) c ## LL
#define __UINT64_C(c) c ## ULL
@ -30,99 +30,99 @@ typedef unsigned int uintptr_t;
#define __PRI64_RANK "ll"
#define __PRIFAST_RANK ""
#define __PRIPTR_RANK ""
typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;
typedef int8_t int_fast8_t;
typedef int64_t int_fast64_t;
typedef int8_t int_fast8_t;
typedef int64_t int_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint64_t uint_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint64_t uint_fast64_t;
typedef int64_t intmax_t;
typedef uint64_t uintmax_t;
typedef int64_t intmax_t;
typedef uint64_t uintmax_t;
#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS)
#define INT8_MIN (-128)
#define INT16_MIN (-32768)
#define INT32_MIN (-2147483647-1)
#define INT64_MIN (__INT64_C(-9223372036854775807)-1)
#define INT8_MIN (-128)
#define INT16_MIN (-32768)
#define INT32_MIN (-2147483647-1)
#define INT64_MIN (__INT64_C(-9223372036854775807)-1)
#define INT8_MAX (127)
#define INT16_MAX (32767)
#define INT32_MAX (2147483647)
#define INT64_MAX (__INT64_C(9223372036854775807))
#define INT8_MAX (127)
#define INT16_MAX (32767)
#define INT32_MAX (2147483647)
#define INT64_MAX (__INT64_C(9223372036854775807))
#define UINT8_MAX (255U)
#define UINT16_MAX (65535U)
#define UINT32_MAX (4294967295U)
#define UINT64_MAX (__UINT64_C(18446744073709551615))
#define UINT8_MAX (255U)
#define UINT16_MAX (65535U)
#define UINT32_MAX (4294967295U)
#define UINT64_MAX (__UINT64_C(18446744073709551615))
#define INT_LEAST8_MIN INT8_MIN
#define INT_LEAST16_MIN INT16_MIN
#define INT_LEAST32_MIN INT32_MIN
#define INT_LEAST64_MIN INT64_MIN
#define INT_LEAST8_MIN INT8_MIN
#define INT_LEAST16_MIN INT16_MIN
#define INT_LEAST32_MIN INT32_MIN
#define INT_LEAST64_MIN INT64_MIN
#define INT_LEAST8_MAX INT8_MAX
#define INT_LEAST16_MAX INT16_MAX
#define INT_LEAST32_MAX INT32_MAX
#define INT_LEAST64_MAX INT64_MAX
#define INT_LEAST8_MAX INT8_MAX
#define INT_LEAST16_MAX INT16_MAX
#define INT_LEAST32_MAX INT32_MAX
#define INT_LEAST64_MAX INT64_MAX
#define UINT_LEAST8_MAX UINT8_MAX
#define UINT_LEAST8_MAX UINT8_MAX
#define UINT_LEAST16_MAX UINT16_MAX
#define UINT_LEAST32_MAX UINT32_MAX
#define UINT_LEAST64_MAX UINT64_MAX
#define INT_FAST8_MIN INT8_MIN
#define INT_FAST64_MIN INT64_MIN
#define INT_FAST8_MIN INT8_MIN
#define INT_FAST64_MIN INT64_MIN
#define INT_FAST8_MAX INT8_MAX
#define INT_FAST64_MAX INT64_MAX
#define INT_FAST8_MAX INT8_MAX
#define INT_FAST64_MAX INT64_MAX
#define UINT_FAST8_MAX UINT8_MAX
#define UINT_FAST8_MAX UINT8_MAX
#define UINT_FAST64_MAX UINT64_MAX
#define INTMAX_MIN INT64_MIN
#define INTMAX_MAX INT64_MAX
#define UINTMAX_MAX UINT64_MAX
#define INTMAX_MIN INT64_MIN
#define INTMAX_MAX INT64_MAX
#define UINTMAX_MAX UINT64_MAX
#define INT_FAST16_MIN INT32_MIN
#define INT_FAST32_MIN INT32_MIN
#define INT_FAST16_MAX INT32_MAX
#define INT_FAST32_MAX INT32_MAX
#define INT_FAST16_MIN INT32_MIN
#define INT_FAST32_MIN INT32_MIN
#define INT_FAST16_MAX INT32_MAX
#define INT_FAST32_MAX INT32_MAX
#define UINT_FAST16_MAX UINT32_MAX
#define UINT_FAST32_MAX UINT32_MAX
#define INTPTR_MIN INT32_MIN
#define INTPTR_MAX INT32_MAX
#define UINTPTR_MAX UINT32_MAX
#define INTPTR_MIN INT32_MIN
#define INTPTR_MAX INT32_MAX
#define UINTPTR_MAX UINT32_MAX
#define PTRDIFF_MIN INT32_MIN
#define PTRDIFF_MAX INT32_MAX
#define PTRDIFF_MIN INT32_MIN
#define PTRDIFF_MAX INT32_MAX
#endif
#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS)
#define INT8_C(c) c
#define INT16_C(c) c
#define INT32_C(c) c
#define INT64_C(c) __INT64_C(c)
#define INT8_C(c) c
#define INT16_C(c) c
#define INT32_C(c) c
#define INT64_C(c) __INT64_C(c)
#define UINT8_C(c) c ## U
#define UINT16_C(c) c ## U
#define UINT32_C(c) c ## U
#define UINT64_C(c) __UINT64_C(c)
#define UINT8_C(c) c ## U
#define UINT16_C(c) c ## U
#define UINT32_C(c) c ## U
#define UINT64_C(c) __UINT64_C(c)
#define INT_LEAST8_C(c) INT8_C(c)
#define INT_LEAST8_C(c) INT8_C(c)
#define INT_LEAST16_C(c) INT16_C(c)
#define INT_LEAST32_C(c) INT32_C(c)
#define INT_LEAST64_C(c) INT64_C(c)
@ -132,25 +132,25 @@ typedef uint64_t uintmax_t;
#define UINT_LEAST32_C(c) UINT32_C(c)
#define UINT_LEAST64_C(c) UINT64_C(c)
#define INT_FAST8_C(c) INT8_C(c)
#define INT_FAST8_C(c) INT8_C(c)
#define INT_FAST64_C(c) INT64_C(c)
#define UINT_FAST8_C(c) UINT8_C(c)
#define UINT_FAST64_C(c) UINT64_C(c)
#define INTMAX_C(c) INT64_C(c)
#define UINTMAX_C(c) UINT64_C(c)
#define INTMAX_C(c) INT64_C(c)
#define UINTMAX_C(c) UINT64_C(c)
#define INT_FAST16_C(c) INT32_C(c)
#define INT_FAST16_C(c) INT32_C(c)
#define INT_FAST32_C(c) INT32_C(c)
#define UINT_FAST16_C(c) UINT32_C(c)
#define UINT_FAST32_C(c) UINT32_C(c)
#define INTPTR_C(c) INT32_C(c)
#define UINTPTR_C(c) UINT32_C(c)
#define INTPTR_C(c) INT32_C(c)
#define UINTPTR_C(c) UINT32_C(c)
#define PTRDIFF_C(c) INT32_C(c)
#endif
#endif /* _STDINT_H */
#endif /* _STDINT_H */

2
components/bl602/bl602_std/bl602_std/Common/libc/inc/stdio.h
View File

@ -18,4 +18,4 @@ __extern int vsnprintf(char *, size_t n, const char *, va_list);
__extern int sscanf(const char *, const char *, ...);
__extern int vsscanf(const char *, const char *, va_list);
#endif /* _STDIO_H */
#endif /* _STDIO_H */

10
components/bl602/bl602_std/bl602_std/Common/libc/inc/stdlib.h
View File

@ -14,7 +14,7 @@
static __inline int abs(int __n)
{
return (__n < 0) ? -__n : __n;
return (__n < 0) ? -__n : __n;
}
__extern int atoi(const char *);
__extern double atof(const char *);
@ -22,12 +22,12 @@ __extern long atol(const char *);
__extern long long atoll(const char *);
static __inline long labs(long __n)
{
return (__n < 0L) ? -__n : __n;
return (__n < 0L) ? -__n : __n;
}
static __inline long long llabs(long long __n)
{
return (__n < 0LL) ? -__n : __n;
return (__n < 0LL) ? -__n : __n;
}
__extern long strtol(const char *, char **, int);
@ -37,7 +37,7 @@ __extern unsigned long long strtoull(const char *, char **, int);
typedef int (*__comparefunc_t) (const void *, const void *);
__extern void *bsearch(const void *, const void *, size_t, size_t,
__comparefunc_t);
__comparefunc_t);
__extern void qsort(void *, size_t, size_t, __comparefunc_t);
__extern long jrand48(unsigned short *);
@ -53,4 +53,4 @@ __extern void srand(unsigned int __s);
__extern long random(void);
__extern void srandom(unsigned int __s);
#endif /* _STDLIB_H */
#endif /* _STDLIB_H */

2
components/bl602/bl602_std/bl602_std/Common/libc/inc/string.h
View File

@ -41,4 +41,4 @@ __extern char *strtok(char *, const char *);
__extern char *strtok_r(char *, const char *, char **);
char *index(const char *s, int c);
#endif /* _STRING_H */
#endif /* _STRING_H */

4
components/bl602/bl602_std/bl602_std/Common/libc/inc/sys/types.h
View File

@ -81,13 +81,13 @@ typedef unsigned long useconds_t;
#define FD_ZERO(p) memset((void *)(p), 0, sizeof(*(p)))
typedef struct fd_set {
unsigned char fd_bits[(FD_SETSIZE + 7) / 8];
unsigned char fd_bits[(FD_SETSIZE + 7) / 8];
} fd_set;
#endif /* FD_SET */
#ifndef __ICCARM__
/* wmsdk: Added from sys/times.h and machine/types.h */
#define _CLOCK_T_ unsigned long /* clock() */
#define _CLOCK_T_ unsigned long /* clock() */
#ifndef __clock_t_defined
typedef _CLOCK_T_ clock_t;
#define __clock_t_defined

2
components/bl602/bl602_std/bl602_std/Common/libc/libc.mk
View File

@ -5,7 +5,7 @@ SUB_MODULE_OUT_DIR:= $(MODULE_OUT_DIR)/libc
SUB_MODULE_SRC_DIR := $(SUB_MODULE_DIR)/src
COMMON_INCLUDE += -I $(MODULE_DIR)/libc/inc
libc_sources := atof.c atoi.c atol.c
libc_sources += atoll.c jrand48.c lrand48.c
libc_sources += mrand48.c nrand48.c seed48.c

130
components/bl602/bl602_std/bl602_std/Common/libc/src/atof.c
View File

@ -16,87 +16,87 @@
static inline int digitval(int ch)
{
if (ch >= '0' && ch <= '9') {
return ch - '0';
} else if (ch >= 'A' && ch <= 'Z') {
return ch - 'A' + 10;
} else if (ch >= 'a' && ch <= 'z') {
return ch - 'a' + 10;
} else {
return -1;
}
if (ch >= '0' && ch <= '9') {
return ch - '0';
} else if (ch >= 'A' && ch <= 'Z') {
return ch - 'A' + 10;
} else if (ch >= 'a' && ch <= 'z') {
return ch - 'a' + 10;
} else {
return -1;
}
}
double strntof(const char *nptr, char **endptr, int base, size_t n)
{
int minus = 0;
double v = 0.0, m = 0.0, divisor = 1.0;
int d;
int minus = 0;
double v = 0.0, m = 0.0, divisor = 1.0;
int d;
while (n && isspace((unsigned char)*nptr)) {
nptr++;
n--;
}
while (n && isspace((unsigned char)*nptr)) {
nptr++;
n--;
}
/* Single optional + or - */
if (n) {
char c = *nptr;
if (c == '-' || c == '+') {
minus = (c == '-');
nptr++;
n--;
}
}
/* Single optional + or - */
if (n) {
char c = *nptr;
if (c == '-' || c == '+') {
minus = (c == '-');
nptr++;
n--;
}
}
if (base == 0) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
base = 16;
} else if (n >= 1 && nptr[0] == '0') {
n--;
nptr++;
base = 8;
} else {
base = 10;
}
} else if (base == 16) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
}
}
if (base == 0) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
base = 16;
} else if (n >= 1 && nptr[0] == '0') {
n--;
nptr++;
base = 8;
} else {
base = 10;
}
} else if (base == 16) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
}
}
while (n && (d = digitval(*nptr)) >= 0 && d < base) {
v = v * base + d;
n--;
nptr++;
}
while (n && (d = digitval(*nptr)) >= 0 && d < base) {
v = v * base + d;
n--;
nptr++;
}
if (*nptr == '.') {
n--;
nptr++;
while (n && (d = digitval(*nptr)) >= 0 && d < base) {
m = m * base + d;
n--;
nptr++;
divisor *= 10.0;
}
}
if (*nptr == '.') {
n--;
nptr++;
while (n && (d = digitval(*nptr)) >= 0 && d < base) {
m = m * base + d;
n--;
nptr++;
divisor *= 10.0;
}
}
if (endptr)
*endptr = (char *)nptr;
if (endptr)
*endptr = (char *)nptr;
v = v + (m / divisor);
v = v + (m / divisor);
return minus ? -v : v;
return minus ? -v : v;
}
double atof(const char *nptr)
{
return strntof(nptr, NULL, 0, strlen(nptr));
return strntof(nptr, NULL, 0, strlen(nptr));
}

2
components/bl602/bl602_std/bl602_std/Common/libc/src/atox.c
View File

@ -15,5 +15,5 @@
TYPE NAME(const char *nptr)
{
return (TYPE) strntoumax(nptr, (char **)NULL, 10, ~(size_t) 0);
return (TYPE) strntoumax(nptr, (char **)NULL, 10, ~(size_t) 0);
}

30
components/bl602/bl602_std/bl602_std/Common/libc/src/bsearch.c
View File

@ -9,23 +9,23 @@
#include <stdlib.h>
void *bsearch(const void *key, const void *base, size_t nmemb,
size_t size, int (*cmp) (const void *, const void *))
size_t size, int (*cmp) (const void *, const void *))
{
while (nmemb) {
size_t mididx = nmemb / 2;
const void *midobj = (const unsigned char *) base +
mididx * size;
int diff = cmp(key, midobj);
while (nmemb) {
size_t mididx = nmemb / 2;
const void *midobj = (const unsigned char *) base +
mididx * size;
int diff = cmp(key, midobj);
if (diff == 0)
return (void *)midobj;
if (diff == 0)
return (void *)midobj;
if (diff > 0) {
base = (const unsigned char *) midobj + size;
nmemb -= mididx + 1;
} else
nmemb = mididx;
}
if (diff > 0) {
base = (const unsigned char *) midobj + size;
nmemb -= mididx + 1;
} else
nmemb = mididx;
}
return NULL;
return NULL;
}

18
components/bl602/bl602_std/bl602_std/Common/libc/src/common.c
View File

@ -5,21 +5,21 @@
//#include <stdio.h>
void __assert_func(const char *file, int line,
const char *func, const char *failedexpr)
const char *func, const char *failedexpr)
{
#if 0
printf("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
failedexpr, file, line, func ? ", function: " : "",
func ? func : "");
printf("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
failedexpr, file, line, func ? ", function: " : "",
func ? func : "");
/* Ensure that nothing runs after this */
while (1)
;
/* Ensure that nothing runs after this */
while (1)
;
#endif
}
float strtof(const char *nptr, char **endptr)
{
// printf("Float print not supported yet!\r\n");
return 0;
// printf("Float print not supported yet!\r\n");
return 0;
}

6
components/bl602/bl602_std/bl602_std/Common/libc/src/ctypefunc.h
View File

@ -7,7 +7,7 @@
#define __CTYPE_NO_INLINE
#include <ctype.h>
#define CTYPEFUNC(X) \
int X(int c) { \
return __ctype_##X(c); \
#define CTYPEFUNC(X) \
int X(int c) { \
return __ctype_##X(c); \
}

514
components/bl602/bl602_std/bl602_std/Common/libc/src/ctypes.c
View File

@ -12,277 +12,277 @@
#include <ctype.h>
const unsigned char __ctypes[257] = {
0, /* EOF */
0, /* EOF */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl | __ctype_space, /* BS */
__ctype_cntrl | __ctype_space, /* TAB */
__ctype_cntrl | __ctype_space, /* LF */
__ctype_cntrl | __ctype_space, /* VT */
__ctype_cntrl | __ctype_space, /* FF */
__ctype_cntrl | __ctype_space, /* CR */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl | __ctype_space, /* BS */
__ctype_cntrl | __ctype_space, /* TAB */
__ctype_cntrl | __ctype_space, /* LF */
__ctype_cntrl | __ctype_space, /* VT */
__ctype_cntrl | __ctype_space, /* FF */
__ctype_cntrl | __ctype_space, /* CR */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_print | __ctype_space, /* space */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_space, /* space */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_digit | __ctype_xdigit, /* digit */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper | __ctype_xdigit, /* A-F */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_upper, /* G-Z */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower | __ctype_xdigit, /* a-f */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_cntrl, /* control character */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_lower, /* g-z */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_cntrl, /* control character */
__ctype_print | __ctype_space, /* NBSP */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_space, /* NBSP */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_upper, /* upper accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_punct, /* punctuation */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
__ctype_print | __ctype_lower, /* lower accented */
};

114
components/bl602/bl602_std/bl602_std/Common/libc/src/fnmatch.c
View File

@ -12,65 +12,65 @@
int fnmatch(const char *p, const char *s, int flags)
{
if (flags & FNM_PATHNAME && *s == '/')
return (*p != '/') || fnmatch(p+1, s+1, flags);
if (flags & FNM_PERIOD && *s == '.')
return (*p != '.') || fnmatch(p+1, s+1, flags);
if (flags & FNM_PATHNAME && *s == '/')
return (*p != '/') || fnmatch(p+1, s+1, flags);
if (flags & FNM_PERIOD && *s == '.')
return (*p != '.') || fnmatch(p+1, s+1, flags);
flags &= ~FNM_PERIOD; /* Only applies at beginning */
flags &= ~FNM_PERIOD; /* Only applies at beginning */
if (!(flags & FNM_NOESCAPE) && *p == '\\') {
p++;
return (*p != *s) || fnmatch(p+1, s+1, flags);
}
if (!(flags & FNM_NOESCAPE) && *p == '\\') {
p++;
return (*p != *s) || fnmatch(p+1, s+1, flags);
}
if (*s == '\0') {
while (*p == '*')
p++;
return (*p != '\0');
}
if (*s == '\0') {
while (*p == '*')
p++;
return (*p != '\0');
}
switch (*p) {
case '[':
{
int not = 0;
p++;
if (*p == '!') {
not = 1;
p++;
}
while ((*p != '\0') && (*p != ']')) {
int match = 0;
if (p[1] == '-') {
if ((*s >= *p) && (*s <= p[2]))
match = 1;
p += 3;
} else {
match = (*p == *s);
p++;
}
if (match ^ not) {
while ((*p != '\0') && (*p != ']'))
p++;
if (*p == ']')
return fnmatch(p+1, s+1, flags);
}
}
}
break;
case '*':
if (fnmatch(p, s+1, flags))
return fnmatch(p+1, s, flags);
return 0;
case '\0':
if (*s == '\0') {
return 0;
}
break;
default:
if ((*p == *s) || (*p == '?'))
return fnmatch(p+1, s+1, flags);
break;
}
return 1;
switch (*p) {
case '[':
{
int not = 0;
p++;
if (*p == '!') {
not = 1;
p++;
}
while ((*p != '\0') && (*p != ']')) {
int match = 0;
if (p[1] == '-') {
if ((*s >= *p) && (*s <= p[2]))
match = 1;
p += 3;
} else {
match = (*p == *s);
p++;
}
if (match ^ not) {
while ((*p != '\0') && (*p != ']'))
p++;
if (*p == ']')
return fnmatch(p+1, s+1, flags);
}
}
}
break;
case '*':
if (fnmatch(p, s+1, flags))
return fnmatch(p+1, s, flags);
return 0;
case '\0':
if (*s == '\0') {
return 0;
}
break;
default:
if ((*p == *s) || (*p == '?'))
return fnmatch(p+1, s+1, flags);
break;
}
return 1;
}

20
components/bl602/bl602_std/bl602_std/Common/libc/src/jrand48.c
View File

@ -11,18 +11,18 @@
long jrand48(unsigned short xsubi[3])
{
uint64_t x;
uint64_t x;
/* The xsubi[] array is littleendian by spec */
x = (uint64_t) (uint16_t) xsubi[0] +
((uint64_t) (uint16_t) xsubi[1] << 16) +
((uint64_t) (uint16_t) xsubi[2] << 32);
/* The xsubi[] array is littleendian by spec */
x = (uint64_t) (uint16_t) xsubi[0] +
((uint64_t) (uint16_t) xsubi[1] << 16) +
((uint64_t) (uint16_t) xsubi[2] << 32);
x = (0x5deece66dULL * x) + 0xb;
x = (0x5deece66dULL * x) + 0xb;
xsubi[0] = (unsigned short)(uint16_t) x;
xsubi[1] = (unsigned short)(uint16_t) (x >> 16);
xsubi[2] = (unsigned short)(uint16_t) (x >> 32);
xsubi[0] = (unsigned short)(uint16_t) x;
xsubi[1] = (unsigned short)(uint16_t) (x >> 16);
xsubi[2] = (unsigned short)(uint16_t) (x >> 32);
return (long)(int32_t) (x >> 16);
return (long)(int32_t) (x >> 16);
}

8
components/bl602/bl602_std/bl602_std/Common/libc/src/lrand48.c
View File

@ -9,19 +9,19 @@
#include <stdlib.h>
#include <stdint.h>
unsigned short __rand48_seed[3]; /* Common with mrand48.c, srand48.c */
unsigned short __rand48_seed[3]; /* Common with mrand48.c, srand48.c */
long lrand48(void)
{
return (uint32_t) jrand48(__rand48_seed) >> 1;
return (uint32_t) jrand48(__rand48_seed) >> 1;
}
int rand(void)
{
return (int)lrand48();
return (int)lrand48();
}
long random(void)
{
return lrand48();
return lrand48();
}

18
components/bl602/bl602_std/bl602_std/Common/libc/src/memccpy.c
View File

@ -13,15 +13,15 @@
void *memccpy(void *dst, const void *src, int c, size_t n)
{
char *q = dst;
const char *p = src;
char ch;
char *q = dst;
const char *p = src;
char ch;
while (n--) {
*q++ = ch = *p++;
if (ch == (char)c)
return q;
}
while (n--) {
*q++ = ch = *p++;
if (ch == (char)c)
return q;
}
return NULL; /* No instance of "c" found */
return NULL; /* No instance of "c" found */
}

14
components/bl602/bl602_std/bl602_std/Common/libc/src/memchr.c
View File

@ -11,13 +11,13 @@
void *memchr(const void *s, int c, size_t n)
{
const unsigned char *sp = s;
const unsigned char *sp = s;
while (n--) {
if (*sp == (unsigned char)c)
return (void *)sp;
sp++;
}
while (n--) {
if (*sp == (unsigned char)c)
return (void *)sp;
sp++;
}
return NULL;
return NULL;
}

16
components/bl602/bl602_std/bl602_std/Common/libc/src/memcmp.c
View File

@ -10,14 +10,14 @@
int memcmp(const void *s1, const void *s2, size_t n)
{
const unsigned char *c1 = s1, *c2 = s2;
int d = 0;
const unsigned char *c1 = s1, *c2 = s2;
int d = 0;
while (n--) {
d = (int)*c1++ - (int)*c2++;
if (d)
break;
}
while (n--) {
d = (int)*c1++ - (int)*c2++;
if (d)
break;
}
return d;
return d;
}

12
components/bl602/bl602_std/bl602_std/Common/libc/src/memcpy.c
View File

@ -7,10 +7,10 @@
void *memcpy(void *dst, const void *src, size_t n)
{
const char *p = src;
char *q = dst;
while (n--) {
*q++ = *p++;
}
return dst;
const char *p = src;
char *q = dst;
while (n--) {
*q++ = *p++;
}
return dst;
}

62
components/bl602/bl602_std/bl602_std/Common/libc/src/memmem.c
View File

@ -17,40 +17,40 @@
void *memmem(const void *haystack, size_t n, const void *needle, size_t m)
{
const unsigned char *y = (const unsigned char *)haystack;
const unsigned char *x = (const unsigned char *)needle;
const unsigned char *y = (const unsigned char *)haystack;
const unsigned char *x = (const unsigned char *)needle;
size_t j, k, l;
size_t j, k, l;
if (m > n || !m || !n)
return NULL;
if (m > n || !m || !n)
return NULL;
if (1 != m) {
if (x[0] == x[1]) {
k = 2;
l = 1;
} else {
k = 1;
l = 2;
}
if (1 != m) {
if (x[0] == x[1]) {
k = 2;
l = 1;
} else {
k = 1;
l = 2;
}
j = 0;
while (j <= n - m) {
if (x[1] != y[j + 1]) {
j += k;
} else {
if (!memcmp(x + 2, y + j + 2, m - 2)
&& x[0] == y[j])
return (void *)&y[j];
j += l;
}
}
} else
do {
if (*y == *x)
return (void *)y;
y++;
} while (--n);
j = 0;
while (j <= n - m) {
if (x[1] != y[j + 1]) {
j += k;
} else {
if (!memcmp(x + 2, y + j + 2, m - 2)
&& x[0] == y[j])
return (void *)&y[j];
j += l;
}
}
} else
do {
if (*y == *x)
return (void *)y;
y++;
} while (--n);
return NULL;
return NULL;
}

14
components/bl602/bl602_std/bl602_std/Common/libc/src/memrchr.c
View File

@ -11,13 +11,13 @@
void *memrchr(const void *s, int c, size_t n)
{
const unsigned char *sp = (const unsigned char *)s + n - 1;
const unsigned char *sp = (const unsigned char *)s + n - 1;
while (n--) {
if (*sp == (unsigned char)c)
return (void *)sp;
sp--;
}
while (n--) {
if (*sp == (unsigned char)c)
return (void *)sp;
sp--;
}
return NULL;
return NULL;
}

10
components/bl602/bl602_std/bl602_std/Common/libc/src/memset.c
View File

@ -7,9 +7,9 @@
void *memset(void *dst, int c, size_t n)
{
char *q = dst;
while (n--) {
*q++ = c;
}
return dst;
char *q = dst;
while (n--) {
*q++ = c;
}
return dst;
}

20
components/bl602/bl602_std/bl602_std/Common/libc/src/memswap.c
View File

@ -13,16 +13,16 @@
void memswap(void *m1, void *m2, size_t n)
{
char *p = m1;
char *q = m2;
char tmp;
char *p = m1;
char *q = m2;
char tmp;
while (n--) {
tmp = *p;
*p = *q;
*q = tmp;
while (n--) {
tmp = *p;
*p = *q;
*q = tmp;
p++;
q++;
}
p++;
q++;
}
}

2
components/bl602/bl602_std/bl602_std/Common/libc/src/mrand48.c
View File

@ -14,5 +14,5 @@ extern unsigned short __rand48_seed[3];
long mrand48(void)
{
return jrand48(__rand48_seed);
return jrand48(__rand48_seed);
}

2
components/bl602/bl602_std/bl602_std/Common/libc/src/nrand48.c
View File

@ -11,5 +11,5 @@
long nrand48(unsigned short xsubi[3])
{
return (long)((uint32_t) jrand48(xsubi) >> 1);
return (long)((uint32_t) jrand48(xsubi) >> 1);
}

48
components/bl602/bl602_std/bl602_std/Common/libc/src/qsort.c
View File

@ -16,36 +16,36 @@
static __inline size_t newgap(size_t gap)
{
gap = (gap * 10) / 13;
if (gap == 9 || gap == 10)
gap = 11;
gap = (gap * 10) / 13;
if (gap == 9 || gap == 10)
gap = 11;
if (gap < 1)
gap = 1;
return gap;
if (gap < 1)
gap = 1;
return gap;
}
void qsort(void *base, size_t nmemb, size_t size,
int (*compar) (const void *, const void *))
int (*compar) (const void *, const void *))
{
size_t gap = nmemb;
size_t i, j;
char *p1, *p2;
int swapped;
size_t gap = nmemb;
size_t i, j;
char *p1, *p2;
int swapped;
if (!nmemb)
return;
if (!nmemb)
return;
do {
gap = newgap(gap);
swapped = 0;
do {
gap = newgap(gap);
swapped = 0;
for (i = 0, p1 = base; i < nmemb - gap; i++, p1 += size) {
j = i + gap;
if (compar(p1, p2 = (char *)base + j * size) > 0) {
memswap(p1, p2, size);
swapped = 1;
}
}
} while (gap > 1 || swapped);
for (i = 0, p1 = base; i < nmemb - gap; i++, p1 += size) {
j = i + gap;
if (compar(p1, p2 = (char *)base + j * size) > 0) {
memswap(p1, p2, size);
swapped = 1;
}
}
} while (gap > 1 || swapped);
}

8
components/bl602/bl602_std/bl602_std/Common/libc/src/seed48.c
View File

@ -14,9 +14,9 @@ extern unsigned short __rand48_seed[3];
unsigned short *seed48(unsigned short int xsubi[3])
{
static unsigned short oldseed[3];
memcpy(oldseed, __rand48_seed, sizeof __rand48_seed);
memcpy(__rand48_seed, xsubi, sizeof __rand48_seed);
static unsigned short oldseed[3];
memcpy(oldseed, __rand48_seed, sizeof __rand48_seed);
memcpy(__rand48_seed, xsubi, sizeof __rand48_seed);
return oldseed;
return oldseed;
}

12
components/bl602/bl602_std/bl602_std/Common/libc/src/snprintf.c
View File

@ -11,11 +11,11 @@
int snprintf(char *buffer, size_t n, const char *format, ...)
{
va_list ap;
int rv;
va_list ap;
int rv;
va_start(ap, format);
rv = vsnprintf(buffer, n, format, ap);
va_end(ap);
return rv;
va_start(ap, format);
rv = vsnprintf(buffer, n, format, ap);
va_end(ap);
return rv;
}

12
components/bl602/bl602_std/bl602_std/Common/libc/src/sprintf.c
View File

@ -11,12 +11,12 @@
int sprintf(char *buffer, const char *format, ...)
{
va_list ap;
int rv;
va_list ap;
int rv;
va_start(ap, format);
rv = vsnprintf(buffer, (~(size_t) 0)>>1, format, ap);
va_end(ap);
va_start(ap, format);
rv = vsnprintf(buffer, (~(size_t) 0)>>1, format, ap);
va_end(ap);
return rv;
return rv;
}

10
components/bl602/bl602_std/bl602_std/Common/libc/src/srand48.c
View File

@ -14,17 +14,17 @@ extern unsigned short __rand48_seed[3];
void srand48(long seedval)
{
__rand48_seed[0] = 0x330e;
__rand48_seed[1] = (unsigned short)seedval;
__rand48_seed[2] = (unsigned short)((uint32_t) seedval >> 16);
__rand48_seed[0] = 0x330e;
__rand48_seed[1] = (unsigned short)seedval;
__rand48_seed[2] = (unsigned short)((uint32_t) seedval >> 16);
}
void srand(unsigned int __s)
{
srand48(__s);
srand48(__s);
}
void srandom(unsigned int __s)
{
srand48(__s);
srand48(__s);
}

12
components/bl602/bl602_std/bl602_std/Common/libc/src/sscanf.c
View File

@ -11,12 +11,12 @@
int sscanf(const char *str, const char *format, ...)
{
va_list ap;
int rv;
va_list ap;
int rv;
va_start(ap, format);
rv = vsscanf(str, format, ap);
va_end(ap);
va_start(ap, format);
rv = vsscanf(str, format, ap);
va_end(ap);
return rv;
return rv;
}

6
components/bl602/bl602_std/bl602_std/Common/libc/src/stdlib.c
View File

@ -10,7 +10,7 @@
void *malloc(size_t size)
{
return NULL;
return NULL;
}
void free(void *ptr)
@ -19,10 +19,10 @@ void free(void *ptr)
void *calloc(size_t nmemb, size_t size)
{
return NULL;
return NULL;
}
void *realloc(void *ptr, size_t size)
{
return NULL;
return NULL;
}

24
components/bl602/bl602_std/bl602_std/Common/libc/src/strcasecmp.c
View File

@ -11,18 +11,18 @@
int strcasecmp(const char *s1, const char *s2)
{
const unsigned char *c1 = (const unsigned char *)s1;
const unsigned char *c2 = (const unsigned char *)s2;
unsigned char ch;
int d = 0;
const unsigned char *c1 = (const unsigned char *)s1;
const unsigned char *c2 = (const unsigned char *)s2;
unsigned char ch;
int d = 0;
while (1) {
/* toupper() expects an unsigned char (implicitly cast to int)
as input, and returns an int, which is exactly what we want. */
d = toupper(ch = *c1++) - toupper(*c2++);
if (d || !ch)
break;
}
while (1) {
/* toupper() expects an unsigned char (implicitly cast to int)
as input, and returns an int, which is exactly what we want. */
d = toupper(ch = *c1++) - toupper(*c2++);
if (d || !ch)
break;
}
return d;
return d;
}

4
components/bl602/bl602_std/bl602_std/Common/libc/src/strcat.c
View File

@ -10,6 +10,6 @@
char *strcat(char *dst, const char *src)
{
strcpy(strchr(dst, '\0'), src);
return dst;
strcpy(strchr(dst, '\0'), src);
return dst;
}

12
components/bl602/bl602_std/bl602_std/Common/libc/src/strchr.c
View File

@ -12,11 +12,11 @@
__WEAK__
char *strchr(const char *s, int c)
{
while (*s != (char)c) {
if (!*s)
return NULL;
s++;
}
while (*s != (char)c) {
if (!*s)
return NULL;
s++;
}
return (char *)s;
return (char *)s;
}

20
components/bl602/bl602_std/bl602_std/Common/libc/src/strcmp.c
View File

@ -10,16 +10,16 @@
int strcmp(const char *s1, const char *s2)
{
const unsigned char *c1 = (const unsigned char *)s1;
const unsigned char *c2 = (const unsigned char *)s2;
unsigned char ch;
int d = 0;
const unsigned char *c1 = (const unsigned char *)s1;
const unsigned char *c2 = (const unsigned char *)s2;
unsigned char ch;
int d = 0;
while (1) {
d = (int)(ch = *c1++) - (int)*c2++;
if (d || !ch)
break;
}
while (1) {
d = (int)(ch = *c1++) - (int)*c2++;
if (d || !ch)
break;
}
return d;
return d;
}

14
components/bl602/bl602_std/bl602_std/Common/libc/src/strcpy.c
View File

@ -12,13 +12,13 @@
char *strcpy(char *dst, const char *src)
{
char *q = dst;
const char *p = src;
char ch;
char *q = dst;
const char *p = src;
char ch;
do {
*q++ = ch = *p++;
} while (ch);
do {
*q++ = ch = *p++;
} while (ch);
return dst;
return dst;
}

2
components/bl602/bl602_std/bl602_std/Common/libc/src/strcspn.c
View File

@ -12,5 +12,5 @@
size_t strcspn(const char *s, const char *reject)
{
return __strxspn(s, reject, 1);
return __strxspn(s, reject, 1);
}

34
components/bl602/bl602_std/bl602_std/Common/libc/src/strlcat.c
View File

@ -10,25 +10,25 @@
size_t strlcat(char *dst, const char *src, size_t size)
{
size_t bytes = 0;
char *q = dst;
const char *p = src;
char ch;
size_t bytes = 0;
char *q = dst;
const char *p = src;
char ch;
while (bytes < size && *q) {
q++;
bytes++;
}
if (bytes == size)
return (bytes + strlen(src));
while (bytes < size && *q) {
q++;
bytes++;
}
if (bytes == size)
return (bytes + strlen(src));
while ((ch = *p++)) {
if (bytes + 1 < size)
*q++ = ch;
while ((ch = *p++)) {
if (bytes + 1 < size)
*q++ = ch;
bytes++;
}
bytes++;
}
*q = '\0';
return bytes;
*q = '\0';
return bytes;
}

26
components/bl602/bl602_std/bl602_std/Common/libc/src/strlcpy.c
View File

@ -10,21 +10,21 @@
size_t strlcpy(char *dst, const char *src, size_t size)
{
size_t bytes = 0;
char *q = dst;
const char *p = src;
char ch;
size_t bytes = 0;
char *q = dst;
const char *p = src;
char ch;
while ((ch = *p++)) {
if (bytes + 1 < size)
*q++ = ch;
while ((ch = *p++)) {
if (bytes + 1 < size)
*q++ = ch;
bytes++;
}
bytes++;
}
/* If size == 0 there is no space for a final null... */
if (size)
*q = '\0';
/* If size == 0 there is no space for a final null... */
if (size)
*q = '\0';
return bytes;
return bytes;
}

8
components/bl602/bl602_std/bl602_std/Common/libc/src/strlen.c
View File

@ -10,8 +10,8 @@
size_t strlen(const char *s)
{
const char *ss = s;
while (*ss)
ss++;
return ss - s;
const char *ss = s;
while (*ss)
ss++;
return ss - s;
}

24
components/bl602/bl602_std/bl602_std/Common/libc/src/strncasecmp.c
View File

@ -11,18 +11,18 @@
int strncasecmp(const char *s1, const char *s2, size_t n)
{
const unsigned char *c1 = (const unsigned char *)s1;
const unsigned char *c2 = (const unsigned char *)s2;
unsigned char ch;
int d = 0;
const unsigned char *c1 = (const unsigned char *)s1;
const unsigned char *c2 = (const unsigned char *)s2;
unsigned char ch;
int d = 0;
while (n--) {
/* toupper() expects an unsigned char (implicitly cast to int)
as input, and returns an int, which is exactly what we want. */
d = toupper(ch = *c1++) - toupper(*c2++);
if (d || !ch)
break;
}
while (n--) {
/* toupper() expects an unsigned char (implicitly cast to int)
as input, and returns an int, which is exactly what we want. */
d = toupper(ch = *c1++) - toupper(*c2++);
if (d || !ch)
break;
}
return d;
return d;
}

20
components/bl602/bl602_std/bl602_std/Common/libc/src/strncat.c
View File

@ -10,16 +10,16 @@
char *strncat(char *dst, const char *src, size_t n)
{
char *q = strchr(dst, '\0');
const char *p = src;
char ch;
char *q = strchr(dst, '\0');
const char *p = src;
char ch;
while (n--) {
*q++ = ch = *p++;
if (!ch)
return dst;
}
*q = '\0';
while (n--) {
*q++ = ch = *p++;
if (!ch)
return dst;
}
*q = '\0';
return dst;
return dst;
}

20
components/bl602/bl602_std/bl602_std/Common/libc/src/strncmp.c
View File

@ -10,16 +10,16 @@
int strncmp(const char *s1, const char *s2, size_t n)
{
const unsigned char *c1 = (const unsigned char *)s1;
const unsigned char *c2 = (const unsigned char *)s2;
unsigned char ch;
int d = 0;
const unsigned char *c1 = (const unsigned char *)s1;
const unsigned char *c2 = (const unsigned char *)s2;
unsigned char ch;
int d = 0;
while (n--) {
d = (int)(ch = *c1++) - (int)*c2++;
if (d || !ch)
break;
}
while (n--) {
d = (int)(ch = *c1++) - (int)*c2++;
if (d || !ch)
break;
}
return d;
return d;
}

24
components/bl602/bl602_std/bl602_std/Common/libc/src/strncpy.c
View File

@ -10,19 +10,19 @@
char *strncpy(char *dst, const char *src, size_t n)
{
char *q = dst;
const char *p = src;
char ch;
char *q = dst;
const char *p = src;
char ch;
while (n) {
n--;
*q++ = ch = *p++;
if (!ch)
break;
}
while (n) {
n--;
*q++ = ch = *p++;
if (!ch)
break;
}
/* The specs say strncpy() fills the entire buffer with NUL. Sigh. */
memset(q, 0, n);
/* The specs say strncpy() fills the entire buffer with NUL. Sigh. */
memset(q, 0, n);
return dst;
return dst;
}

16
components/bl602/bl602_std/bl602_std/Common/libc/src/strnlen.c
View File

@ -10,13 +10,13 @@
size_t strnlen(const char *s, size_t maxlen)
{
const char *ss = s;
const char *ss = s;
/* Important: the maxlen test must precede the reference through ss;
since the byte beyond the maximum may segfault */
while ((maxlen > 0) && *ss) {
ss++;
maxlen--;
}
return ss - s;
/* Important: the maxlen test must precede the reference through ss;
since the byte beyond the maximum may segfault */
while ((maxlen > 0) && *ss) {
ss++;
maxlen--;
}
return ss - s;
}

2
components/bl602/bl602_std/bl602_std/Common/libc/src/strntoimax.c
View File

@ -14,5 +14,5 @@
intmax_t strntoimax(const char *nptr, char **endptr, int base, size_t n)
{
return (intmax_t) strntoumax(nptr, endptr, base, n);
return (intmax_t) strntoumax(nptr, endptr, base, n);
}

106
components/bl602/bl602_std/bl602_std/Common/libc/src/strntoumax.c
View File

@ -15,67 +15,67 @@
static __inline int digitval(int ch)
{
if (ch >= '0' && ch <= '9') {
return ch - '0';
} else if (ch >= 'A' && ch <= 'Z') {
return ch - 'A' + 10;
} else if (ch >= 'a' && ch <= 'z') {
return ch - 'a' + 10;
} else {
return -1;
}
if (ch >= '0' && ch <= '9') {
return ch - '0';
} else if (ch >= 'A' && ch <= 'Z') {
return ch - 'A' + 10;
} else if (ch >= 'a' && ch <= 'z') {
return ch - 'a' + 10;
} else {
return -1;
}
}
uintmax_t strntoumax(const char *nptr, char **endptr, int base, size_t n)
{
int minus = 0;
uintmax_t v = 0;
int d;
int minus = 0;
uintmax_t v = 0;
int d;
while (n && isspace((unsigned char)*nptr)) {
nptr++;
n--;
}
while (n && isspace((unsigned char)*nptr)) {
nptr++;
n--;
}
/* Single optional + or - */
if (n) {
char c = *nptr;
if (c == '-' || c == '+') {
minus = (c == '-');
nptr++;
n--;
}
}
/* Single optional + or - */
if (n) {
char c = *nptr;
if (c == '-' || c == '+') {
minus = (c == '-');
nptr++;
n--;
}
}
if (base == 0) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
base = 16;
} else if (n >= 1 && nptr[0] == '0') {
n--;
nptr++;
base = 8;
} else {
base = 10;
}
} else if (base == 16) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
}
}
if (base == 0) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
base = 16;
} else if (n >= 1 && nptr[0] == '0') {
n--;
nptr++;
base = 8;
} else {
base = 10;
}
} else if (base == 16) {
if (n >= 2 && nptr[0] == '0' &&
(nptr[1] == 'x' || nptr[1] == 'X')) {
n -= 2;
nptr += 2;
}
}
while (n && (d = digitval(*nptr)) >= 0 && d < base) {
v = v * base + d;
n--;
nptr++;
}
while (n && (d = digitval(*nptr)) >= 0 && d < base) {
v = v * base + d;
n--;
nptr++;
}
if (endptr)
*endptr = (char *)nptr;
if (endptr)
*endptr = (char *)nptr;
return minus ? -v : v;
return minus ? -v : v;
}

4
components/bl602/bl602_std/bl602_std/Common/libc/src/strpbrk.c
View File

@ -12,7 +12,7 @@
char *strpbrk(const char *s, const char *accept)
{
const char *ss = s + __strxspn(s, accept, 1);
const char *ss = s + __strxspn(s, accept, 1);
return *ss ? (char *)ss : NULL;
return *ss ? (char *)ss : NULL;
}

14
components/bl602/bl602_std/bl602_std/Common/libc/src/strrchr.c
View File

@ -10,13 +10,13 @@
char *strrchr(const char *s, int c)
{
const char *found = NULL;
const char *found = NULL;
while (*s) {
if (*s == (char)c)
found = s;
s++;
}
while (*s) {
if (*s == (char)c)
found = s;
s++;
}
return (char *)found;
return (char *)found;
}

18
components/bl602/bl602_std/bl602_std/Common/libc/src/strsep.c
View File

@ -10,16 +10,16 @@
char *strsep(char **stringp, const char *delim)
{
char *s = *stringp;
char *e;
char *s = *stringp;
char *e;
if (!s)
return NULL;
if (!s)
return NULL;
e = strpbrk(s, delim);
if (e)
*e++ = '\0';
e = strpbrk(s, delim);
if (e)
*e++ = '\0';
*stringp = e;
return s;
*stringp = e;
return s;
}

2
components/bl602/bl602_std/bl602_std/Common/libc/src/strspn.c
View File

@ -12,5 +12,5 @@
size_t strspn(const char *s, const char *accept)
{
return __strxspn(s, accept, 0);
return __strxspn(s, accept, 0);
}

4
components/bl602/bl602_std/bl602_std/Common/libc/src/strstr.c
View File

@ -11,6 +11,6 @@
char *strstr(const char *haystack, const char *needle)
{
return (char *)memmem(haystack, strlen(haystack), needle,
strlen(needle));
return (char *)memmem(haystack, strlen(haystack), needle,
strlen(needle));
}

4
components/bl602/bl602_std/bl602_std/Common/libc/src/strtok.c
View File

@ -10,7 +10,7 @@
char *strtok(char *s, const char *delim)
{
static char *holder;
static char *holder;
return strtok_r(s, delim, &holder);
return strtok_r(s, delim, &holder);
}

12
components/bl602/bl602_std/bl602_std/Common/libc/src/strtok_r.c
View File

@ -6,12 +6,12 @@
char *strtok_r(char *s, const char *delim, char **holder)
{
if (s)
*holder = s;
if (s)
*holder = s;
do {
s = strsep(holder, delim);
} while (s && !*s);
do {
s = strsep(holder, delim);
} while (s && !*s);
return s;
return s;
}

2
components/bl602/bl602_std/bl602_std/Common/libc/src/strtox.c
View File

@ -15,5 +15,5 @@
WEAK TYPE NAME(const char *nptr, char **endptr, int base)
{
return (TYPE) strntoumax(nptr, endptr, base, ~(size_t) 0);
return (TYPE) strntoumax(nptr, endptr, base, ~(size_t) 0);
}

24
components/bl602/bl602_std/bl602_std/Common/libc/src/strxspn.c
View File

@ -14,20 +14,20 @@
size_t __strxspn(const char *s, const char *map, int parity)
{
char matchmap[UCHAR_MAX + 1];
size_t n = 0;
char matchmap[UCHAR_MAX + 1];
size_t n = 0;
/* Create bitmap */
memset(matchmap, 0, sizeof matchmap);
while (*map)
matchmap[(unsigned char)*map++] = 1;
/* Create bitmap */
memset(matchmap, 0, sizeof matchmap);
while (*map)
matchmap[(unsigned char)*map++] = 1;
/* Make sure the null character never matches */
matchmap[0] = parity;
/* Make sure the null character never matches */
matchmap[0] = parity;
/* Calculate span length */
while (matchmap[(unsigned char)*s++] ^ parity)
n++;
/* Calculate span length */
while (matchmap[(unsigned char)*s++] ^ parity)
n++;
return n;
return n;
}

848
components/bl602/bl602_std/bl602_std/Common/libc/src/vsnprintf.c
View File

@ -17,484 +17,484 @@
#include <stdio.h>
enum flag {
FL_ZERO = 0x01, /* Zero modifier */
FL_MINUS = 0x02, /* Minus modifier */
FL_PLUS = 0x04, /* Plus modifier */
FL_TICK = 0x08, /* ' modifier */
FL_SPACE = 0x10, /* Space modifier */
FL_HASH = 0x20, /* # modifier */
FL_SIGNED = 0x40, /* Number is signed */
FL_UPPER = 0x80 /* Upper case digits */
FL_ZERO = 0x01, /* Zero modifier */
FL_MINUS = 0x02, /* Minus modifier */
FL_PLUS = 0x04, /* Plus modifier */
FL_TICK = 0x08, /* ' modifier */
FL_SPACE = 0x10, /* Space modifier */
FL_HASH = 0x20, /* # modifier */
FL_SIGNED = 0x40, /* Number is signed */
FL_UPPER = 0x80 /* Upper case digits */
};
/* These may have to be adjusted on certain implementations */
enum ranks {
rank_char = -2,
rank_short = -1,
rank_int = 0,
rank_long = 1,
rank_longlong = 2
rank_char = -2,
rank_short = -1,
rank_int = 0,
rank_long = 1,
rank_longlong = 2
};
#define MIN_RANK rank_char
#define MAX_RANK rank_longlong
#define MIN_RANK rank_char
#define MAX_RANK rank_longlong
#define INTMAX_RANK rank_longlong
#define SIZE_T_RANK rank_long
#define PTRDIFF_T_RANK rank_long
#define INTMAX_RANK rank_longlong
#define SIZE_T_RANK rank_long
#define PTRDIFF_T_RANK rank_long
#define EMIT(x) { if (o < n) { *q++ = (x); } o++; }
static size_t
format_int(char *q, size_t n, uintmax_t val, unsigned int flags,
int base, int width, int prec)
int base, int width, int prec)
{
char *qq;
size_t o = 0, oo;
static const char lcdigits[] = "0123456789abcdef";
static const char ucdigits[] = "0123456789ABCDEF";
const char *digits;
uintmax_t tmpval;
int minus = 0;
int ndigits = 0, nchars;
int tickskip, b4tick;
char *qq;
size_t o = 0, oo;
static const char lcdigits[] = "0123456789abcdef";
static const char ucdigits[] = "0123456789ABCDEF";
const char *digits;
uintmax_t tmpval;
int minus = 0;
int ndigits = 0, nchars;
int tickskip, b4tick;
/* Select type of digits */
digits = (flags & FL_UPPER) ? ucdigits : lcdigits;
/* Select type of digits */
digits = (flags & FL_UPPER) ? ucdigits : lcdigits;
/* If signed, separate out the minus */
if (flags & FL_SIGNED && (intmax_t) val < 0) {
minus = 1;
val = (uintmax_t) (-(intmax_t) val);
}
/* If signed, separate out the minus */
if (flags & FL_SIGNED && (intmax_t) val < 0) {
minus = 1;
val = (uintmax_t) (-(intmax_t) val);
}
/* Count the number of digits needed. This returns zero for 0. */
tmpval = val;
while (tmpval) {
tmpval /= base;
ndigits++;
}
/* Count the number of digits needed. This returns zero for 0. */
tmpval = val;
while (tmpval) {
tmpval /= base;
ndigits++;
}
/* Adjust ndigits for size of output */
/* Adjust ndigits for size of output */
if (flags & FL_HASH && base == 8) {
if (prec < ndigits + 1)
prec = ndigits + 1;
}
if (flags & FL_HASH && base == 8) {
if (prec < ndigits + 1)
prec = ndigits + 1;
}
if (ndigits < prec) {
ndigits = prec; /* Mandatory number padding */
} else if (val == 0) {
ndigits = 1; /* Zero still requires space */
}
if (ndigits < prec) {
ndigits = prec; /* Mandatory number padding */
} else if (val == 0) {
ndigits = 1; /* Zero still requires space */
}
/* For ', figure out what the skip should be */
if (flags & FL_TICK) {
tickskip = (base == 16) ? 4 : 3;
} else {
tickskip = ndigits; /* No tick marks */
}
/* For ', figure out what the skip should be */
if (flags & FL_TICK) {
tickskip = (base == 16) ? 4 : 3;
} else {
tickskip = ndigits; /* No tick marks */
}
/* Tick marks aren't digits, but generated by the number converter */
ndigits += (ndigits - 1) / tickskip;
/* Tick marks aren't digits, but generated by the number converter */
ndigits += (ndigits - 1) / tickskip;
/* Now compute the number of nondigits */
nchars = ndigits;
/* Now compute the number of nondigits */
nchars = ndigits;
if (minus || (flags & (FL_PLUS | FL_SPACE)))
nchars++; /* Need space for sign */
if ((flags & FL_HASH) && base == 16) {
nchars += 2; /* Add 0x for hex */
}
if (minus || (flags & (FL_PLUS | FL_SPACE)))
nchars++; /* Need space for sign */
if ((flags & FL_HASH) && base == 16) {
nchars += 2; /* Add 0x for hex */
}
/* Emit early space padding */
if (!(flags & (FL_MINUS | FL_ZERO)) && width > nchars) {
while (width > nchars) {
EMIT(' ');
width--;
}
}
/* Emit early space padding */
if (!(flags & (FL_MINUS | FL_ZERO)) && width > nchars) {
while (width > nchars) {
EMIT(' ');
width--;
}
}
/* Emit nondigits */
if (minus) {
EMIT('-');
} else if (flags & FL_PLUS) {
EMIT('+');
} else if (flags & FL_SPACE) {
EMIT(' ');
}
/* Emit nondigits */
if (minus) {
EMIT('-');
} else if (flags & FL_PLUS) {
EMIT('+');
} else if (flags & FL_SPACE) {
EMIT(' ');
}
if ((flags & FL_HASH) && base == 16) {
EMIT('0');
EMIT((flags & FL_UPPER) ? 'X' : 'x');
}
if ((flags & FL_HASH) && base == 16) {
EMIT('0');
EMIT((flags & FL_UPPER) ? 'X' : 'x');
}
/* Emit zero padding */
if ((flags & (FL_MINUS | FL_ZERO)) == FL_ZERO && width > ndigits) {
while (width > nchars) {
EMIT('0');
width--;
}
}
/* Emit zero padding */
if ((flags & (FL_MINUS | FL_ZERO)) == FL_ZERO && width > ndigits) {
while (width > nchars) {
EMIT('0');
width--;
}
}
/* Generate the number. This is done from right to left. */
q += ndigits; /* Advance the pointer to end of number */
o += ndigits;
qq = q;
oo = o; /* Temporary values */
/* Generate the number. This is done from right to left. */
q += ndigits; /* Advance the pointer to end of number */
o += ndigits;
qq = q;
oo = o; /* Temporary values */
b4tick = tickskip;
while (ndigits > 0) {
if (!b4tick--) {
qq--;
oo--;
ndigits--;
if (oo < n)
*qq = '_';
b4tick = tickskip - 1;
}
qq--;
oo--;
ndigits--;
if (oo < n)
*qq = digits[val % base];
val /= base;
}
b4tick = tickskip;
while (ndigits > 0) {
if (!b4tick--) {
qq--;
oo--;
ndigits--;
if (oo < n)
*qq = '_';
b4tick = tickskip - 1;
}
qq--;
oo--;
ndigits--;
if (oo < n)
*qq = digits[val % base];
val /= base;
}
/* Emit late space padding */
while ((flags & FL_MINUS) && width > nchars) {
EMIT(' ');
width--;
}
/* Emit late space padding */
while ((flags & FL_MINUS) && width > nchars) {
EMIT(' ');
width--;
}
return o;
return o;
}
int vsnprintf(char *buffer, size_t n, const char *format, va_list ap)
{
const char *p = format;
char ch;
char *q = buffer;
size_t o = 0; /* Number of characters output */
uintmax_t val = 0;
int rank = rank_int; /* Default rank */
int width = 0;
int prec = -1;
int base;
size_t sz;
unsigned int flags = 0;
enum {
st_normal, /* Ground state */
st_flags, /* Special flags */
st_width, /* Field width */
st_prec, /* Field precision */
st_modifiers /* Length or conversion modifiers */
} state = st_normal;
const char *sarg; /* %s string argument */
char carg; /* %c char argument */
int slen; /* String length */
const char *p = format;
char ch;
char *q = buffer;
size_t o = 0; /* Number of characters output */
uintmax_t val = 0;
int rank = rank_int; /* Default rank */
int width = 0;
int prec = -1;
int base;
size_t sz;
unsigned int flags = 0;
enum {
st_normal, /* Ground state */
st_flags, /* Special flags */
st_width, /* Field width */
st_prec, /* Field precision */
st_modifiers /* Length or conversion modifiers */
} state = st_normal;
const char *sarg; /* %s string argument */
char carg; /* %c char argument */
int slen; /* String length */
while ((ch = *p++)) {
switch (state) {
case st_normal:
if (ch == '%') {
state = st_flags;
flags = 0;
rank = rank_int;
width = 0;
prec = -1;
} else {
EMIT(ch);
}
break;
while ((ch = *p++)) {
switch (state) {
case st_normal:
if (ch == '%') {
state = st_flags;
flags = 0;
rank = rank_int;
width = 0;
prec = -1;
} else {
EMIT(ch);
}
break;
case st_flags:
switch (ch) {
case '-':
flags |= FL_MINUS;
break;
case '+':
flags |= FL_PLUS;
break;
case '\'':
flags |= FL_TICK;
break;
case ' ':
flags |= FL_SPACE;
break;
case '#':
flags |= FL_HASH;
break;
case '0':
flags |= FL_ZERO;
break;
default:
state = st_width;
p--; /* Process this character again */
break;
}
break;
case st_flags:
switch (ch) {
case '-':
flags |= FL_MINUS;
break;
case '+':
flags |= FL_PLUS;
break;
case '\'':
flags |= FL_TICK;
break;
case ' ':
flags |= FL_SPACE;
break;
case '#':
flags |= FL_HASH;
break;
case '0':
flags |= FL_ZERO;
break;
default:
state = st_width;
p--; /* Process this character again */
break;
}
break;
case st_width:
if (ch >= '0' && ch <= '9') {
width = width * 10 + (ch - '0');
} else if (ch == '*') {
width = va_arg(ap, int);
if (width < 0) {
width = -width;
flags |= FL_MINUS;
}
} else if (ch == '.') {
prec = 0; /* Precision given */
state = st_prec;
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_width:
if (ch >= '0' && ch <= '9') {
width = width * 10 + (ch - '0');
} else if (ch == '*') {
width = va_arg(ap, int);
if (width < 0) {
width = -width;
flags |= FL_MINUS;
}
} else if (ch == '.') {
prec = 0; /* Precision given */
state = st_prec;
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_prec:
if (ch >= '0' && ch <= '9') {
prec = prec * 10 + (ch - '0');
} else if (ch == '*') {
prec = va_arg(ap, int);
if (prec < 0)
prec = -1;
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_prec:
if (ch >= '0' && ch <= '9') {
prec = prec * 10 + (ch - '0');
} else if (ch == '*') {
prec = va_arg(ap, int);
if (prec < 0)
prec = -1;
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_modifiers:
switch (ch) {
/* Length modifiers - nonterminal sequences */
case 'h':
rank--; /* Shorter rank */
break;
case 'l':
rank++; /* Longer rank */
break;
case 'j':
rank = INTMAX_RANK;
break;
case 'z':
rank = SIZE_T_RANK;
break;
case 't':
rank = PTRDIFF_T_RANK;
break;
case 'L':
case 'q':
rank += 2;
break;
default:
/* Output modifiers - terminal sequences */
case st_modifiers:
switch (ch) {
/* Length modifiers - nonterminal sequences */
case 'h':
rank--; /* Shorter rank */
break;
case 'l':
rank++; /* Longer rank */
break;
case 'j':
rank = INTMAX_RANK;
break;
case 'z':
rank = SIZE_T_RANK;
break;
case 't':
rank = PTRDIFF_T_RANK;
break;
case 'L':
case 'q':
rank += 2;
break;
default:
/* Output modifiers - terminal sequences */
/* Next state will be normal */
state = st_normal;
/* Next state will be normal */
state = st_normal;
/* Canonicalize rank */
if (rank < MIN_RANK)
rank = MIN_RANK;
else if (rank > MAX_RANK)
rank = MAX_RANK;
/* Canonicalize rank */
if (rank < MIN_RANK)
rank = MIN_RANK;
else if (rank > MAX_RANK)
rank = MAX_RANK;
switch (ch) {
case 'P': /* Upper case pointer */
flags |= FL_UPPER;
/* fall through */
case 'p': /* Pointer */
base = 16;
prec = (CHAR_BIT*sizeof(void *)+3)/4;
flags |= FL_HASH;
val = (uintmax_t)(uintptr_t)
va_arg(ap, void *);
goto is_integer;
switch (ch) {
case 'P': /* Upper case pointer */
flags |= FL_UPPER;
/* fall through */
case 'p': /* Pointer */
base = 16;
prec = (CHAR_BIT*sizeof(void *)+3)/4;
flags |= FL_HASH;
val = (uintmax_t)(uintptr_t)
va_arg(ap, void *);
goto is_integer;
case 'd': /* Signed decimal output */
case 'i':
base = 10;
flags |= FL_SIGNED;
switch (rank) {
case rank_char:
/* Yes, all these casts are
needed... */
val = (uintmax_t)(intmax_t)
(signed char)
va_arg(ap, signed int);
break;
case rank_short:
val = (uintmax_t)(intmax_t)
(signed short)
va_arg(ap, signed int);
break;
case rank_int:
val = (uintmax_t)(intmax_t)
va_arg(ap, signed int);
break;
case rank_long:
val = (uintmax_t)(intmax_t)
va_arg(ap, signed long);
break;
case rank_longlong:
val = (uintmax_t)(intmax_t)
va_arg(ap,
signed long long);
break;
default:
break;
}
goto is_integer;
case 'o': /* Octal */
base = 8;
goto is_unsigned;
case 'u': /* Unsigned decimal */
base = 10;
goto is_unsigned;
case 'X': /* Upper case hexadecimal */
flags |= FL_UPPER;
/* fall through */
case 'x': /* Hexadecimal */
base = 16;
goto is_unsigned;
case 'd': /* Signed decimal output */
case 'i':
base = 10;
flags |= FL_SIGNED;
switch (rank) {
case rank_char:
/* Yes, all these casts are
needed... */
val = (uintmax_t)(intmax_t)
(signed char)
va_arg(ap, signed int);
break;
case rank_short:
val = (uintmax_t)(intmax_t)
(signed short)
va_arg(ap, signed int);
break;
case rank_int:
val = (uintmax_t)(intmax_t)
va_arg(ap, signed int);
break;
case rank_long:
val = (uintmax_t)(intmax_t)
va_arg(ap, signed long);
break;
case rank_longlong:
val = (uintmax_t)(intmax_t)
va_arg(ap,
signed long long);
break;
default:
break;
}
goto is_integer;
case 'o': /* Octal */
base = 8;
goto is_unsigned;
case 'u': /* Unsigned decimal */
base = 10;
goto is_unsigned;
case 'X': /* Upper case hexadecimal */
flags |= FL_UPPER;
/* fall through */
case 'x': /* Hexadecimal */
base = 16;
goto is_unsigned;
is_unsigned:
switch (rank) {
case rank_char:
val = (uintmax_t)
(unsigned char)
va_arg(ap, unsigned
int);
break;
case rank_short:
val = (uintmax_t)
(unsigned short)
va_arg(ap, unsigned
int);
break;
case rank_int:
val = (uintmax_t)
va_arg(ap, unsigned
int);
break;
case rank_long:
val = (uintmax_t)
va_arg(ap, unsigned
long);
break;
case rank_longlong:
val = (uintmax_t)
va_arg(ap, unsigned
long long);
break;
default:
break;
}
/* fall through */
is_unsigned:
switch (rank) {
case rank_char:
val = (uintmax_t)
(unsigned char)
va_arg(ap, unsigned
int);
break;
case rank_short:
val = (uintmax_t)
(unsigned short)
va_arg(ap, unsigned
int);
break;
case rank_int:
val = (uintmax_t)
va_arg(ap, unsigned
int);
break;
case rank_long:
val = (uintmax_t)
va_arg(ap, unsigned
long);
break;
case rank_longlong:
val = (uintmax_t)
va_arg(ap, unsigned
long long);
break;
default:
break;
}
/* fall through */
is_integer:
sz = format_int(q, (o < n) ? n - o : 0,
val, flags, base,
width, prec);
q += sz;
o += sz;
break;
is_integer:
sz = format_int(q, (o < n) ? n - o : 0,
val, flags, base,
width, prec);
q += sz;
o += sz;
break;
case 'c': /* Character */
carg = (char)va_arg(ap, int);
sarg = &carg;
slen = 1;
goto is_string;
case 's': /* String */
sarg = va_arg(ap, const char *);
sarg = sarg ? sarg : "(null)";
slen = strlen(sarg);
goto is_string;
case 'c': /* Character */
carg = (char)va_arg(ap, int);
sarg = &carg;
slen = 1;
goto is_string;
case 's': /* String */
sarg = va_arg(ap, const char *);
sarg = sarg ? sarg : "(null)";
slen = strlen(sarg);
goto is_string;
is_string:
{
char sch;
int i;
is_string:
{
char sch;
int i;
if (prec != -1 && slen > prec)
slen = prec;
if (prec != -1 && slen > prec)
slen = prec;
if (width > slen
&& !(flags & FL_MINUS)) {
char pad =
(flags & FL_ZERO) ?
'0' : ' ';
while (width > slen) {
EMIT(pad);
width--;
}
}
for (i = slen; i; i--) {
sch = *sarg++;
EMIT(sch);
}
if (width > slen
&& (flags & FL_MINUS)) {
while (width > slen) {
EMIT(' ');
width--;
}
}
}
break;
if (width > slen
&& !(flags & FL_MINUS)) {
char pad =
(flags & FL_ZERO) ?
'0' : ' ';
while (width > slen) {
EMIT(pad);
width--;
}
}
for (i = slen; i; i--) {
sch = *sarg++;
EMIT(sch);
}
if (width > slen
&& (flags & FL_MINUS)) {
while (width > slen) {
EMIT(' ');
width--;
}
}
}
break;
case 'n':
{
/* Output the number of
characters written */
case 'n':
{
/* Output the number of
characters written */
switch (rank) {
case rank_char:
*va_arg(ap,
signed char *)
= o;
break;
case rank_short:
*va_arg(ap,
signed short *)
= o;
break;
case rank_int:
*va_arg(ap,
signed int *)
= o;
break;
case rank_long:
*va_arg(ap,
signed long *)
= o;
break;
case rank_longlong:
*va_arg(ap,
signed long long *)
= o;
break;
default:
break;
}
}
break;
switch (rank) {
case rank_char:
*va_arg(ap,
signed char *)
= o;
break;
case rank_short:
*va_arg(ap,
signed short *)
= o;
break;
case rank_int:
*va_arg(ap,
signed int *)
= o;
break;
case rank_long:
*va_arg(ap,
signed long *)
= o;
break;
case rank_longlong:
*va_arg(ap,
signed long long *)
= o;
break;
default:
break;
}
}
break;
default: /* Anything else, including % */
EMIT(ch);
break;
}
}
default: /* Anything else, including % */
EMIT(ch);
break;
}
}
default:
break;
}
}
}
}
/* Null-terminate the string */
if (o < n)
*q = '\0'; /* No overflow */
else if (n > 0)
buffer[n - 1] = '\0'; /* Overflow - terminate at end of buffer */
/* Null-terminate the string */
if (o < n)
*q = '\0'; /* No overflow */
else if (n > 0)
buffer[n - 1] = '\0'; /* Overflow - terminate at end of buffer */
return o;
return o;
}

2
components/bl602/bl602_std/bl602_std/Common/libc/src/vsprintf.c
View File

@ -11,5 +11,5 @@
int vsprintf(char *buffer, const char *format, va_list ap)
{
return vsnprintf(buffer, (~(size_t) 0)>>1, format, ap);
return vsnprintf(buffer, (~(size_t) 0)>>1, format, ap);
}

678
components/bl602/bl602_std/bl602_std/Common/libc/src/vsscanf.c
View File

@ -24,395 +24,395 @@
#endif
enum flag {
FL_SPLAT = 0x01, /* Drop the value, do not assign */
FL_INV = 0x02, /* Character-set with inverse */
FL_WIDTH = 0x04, /* Field width specified */
FL_MINUS = 0x08, /* Negative number */
FL_SPLAT = 0x01, /* Drop the value, do not assign */
FL_INV = 0x02, /* Character-set with inverse */
FL_WIDTH = 0x04, /* Field width specified */
FL_MINUS = 0x08, /* Negative number */
};
enum ranks {
rank_char = -2,
rank_short = -1,
rank_int = 0,
rank_long = 1,
rank_longlong = 2,
rank_ptr = INT_MAX /* Special value used for pointers */
rank_char = -2,
rank_short = -1,
rank_int = 0,
rank_long = 1,
rank_longlong = 2,
rank_ptr = INT_MAX /* Special value used for pointers */
};
#define MIN_RANK rank_char
#define MAX_RANK rank_longlong
#define MIN_RANK rank_char
#define MAX_RANK rank_longlong
#define INTMAX_RANK rank_longlong
#define SIZE_T_RANK rank_long
#define PTRDIFF_T_RANK rank_long
#define INTMAX_RANK rank_longlong
#define SIZE_T_RANK rank_long
#define PTRDIFF_T_RANK rank_long
enum bail {
bail_none = 0, /* No error condition */
bail_eof, /* Hit EOF */
bail_err /* Conversion mismatch */
bail_none = 0, /* No error condition */
bail_eof, /* Hit EOF */
bail_err /* Conversion mismatch */
};
static __inline const char *skipspace(const char *p)
{
while (isspace((unsigned char)*p))
p++;
return p;
while (isspace((unsigned char)*p))
p++;
return p;
}
#undef set_bit
static __inline void set_bit(unsigned long *bitmap, unsigned int bit)
{
bitmap[bit / LONG_BIT] |= 1UL << (bit % LONG_BIT);
bitmap[bit / LONG_BIT] |= 1UL << (bit % LONG_BIT);
}
#undef test_bit
static __inline int test_bit(unsigned long *bitmap, unsigned int bit)
{
return (int)(bitmap[bit / LONG_BIT] >> (bit % LONG_BIT)) & 1;
return (int)(bitmap[bit / LONG_BIT] >> (bit % LONG_BIT)) & 1;
}
int vsscanf(const char *buffer, const char *format, va_list ap)
{
const char *p = format;
char ch;
unsigned char uc;
const char *q = buffer;
const char *qq;
uintmax_t val = 0;
int rank = rank_int; /* Default rank */
unsigned int width = UINT_MAX;
int base;
unsigned int flags = 0;
enum {
st_normal, /* Ground state */
st_flags, /* Special flags */
st_width, /* Field width */
st_modifiers, /* Length or conversion modifiers */
st_match_init, /* Initial state of %[ sequence */
st_match, /* Main state of %[ sequence */
st_match_range, /* After - in a %[ sequence */
} state = st_normal;
char *sarg = NULL; /* %s %c or %[ string argument */
enum bail bail = bail_none;
__UNUSED__ int sign;
int converted = 0; /* Successful conversions */
unsigned long matchmap[((1 << CHAR_BIT) + (LONG_BIT - 1)) / LONG_BIT];
int matchinv = 0; /* Is match map inverted? */
unsigned char range_start = 0;
const char *p = format;
char ch;
unsigned char uc;
const char *q = buffer;
const char *qq;
uintmax_t val = 0;
int rank = rank_int; /* Default rank */
unsigned int width = UINT_MAX;
int base;
unsigned int flags = 0;
enum {
st_normal, /* Ground state */
st_flags, /* Special flags */
st_width, /* Field width */
st_modifiers, /* Length or conversion modifiers */
st_match_init, /* Initial state of %[ sequence */
st_match, /* Main state of %[ sequence */
st_match_range, /* After - in a %[ sequence */
} state = st_normal;
char *sarg = NULL; /* %s %c or %[ string argument */
enum bail bail = bail_none;
__UNUSED__ int sign;
int converted = 0; /* Successful conversions */
unsigned long matchmap[((1 << CHAR_BIT) + (LONG_BIT - 1)) / LONG_BIT];
int matchinv = 0; /* Is match map inverted? */
unsigned char range_start = 0;
while ((ch = *p++) && !bail) {
switch (state) {
case st_normal:
if (ch == '%') {
state = st_flags;
flags = 0;
rank = rank_int;
width = UINT_MAX;
} else if (isspace((unsigned char)ch)) {
q = skipspace(q);
} else {
if (*q == ch)
q++;
else
bail = bail_err; /* Match failure */
}
break;
while ((ch = *p++) && !bail) {
switch (state) {
case st_normal:
if (ch == '%') {
state = st_flags;
flags = 0;
rank = rank_int;
width = UINT_MAX;
} else if (isspace((unsigned char)ch)) {
q = skipspace(q);
} else {
if (*q == ch)
q++;
else
bail = bail_err; /* Match failure */
}
break;
case st_flags:
switch (ch) {
case '*':
flags |= FL_SPLAT;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
width = (ch - '0');
state = st_width;
flags |= FL_WIDTH;
break;
default:
state = st_modifiers;
p--; /* Process this character again */
break;
}
break;
case st_flags:
switch (ch) {
case '*':
flags |= FL_SPLAT;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
width = (ch - '0');
state = st_width;
flags |= FL_WIDTH;
break;
default:
state = st_modifiers;
p--; /* Process this character again */
break;
}
break;
case st_width:
if (ch >= '0' && ch <= '9') {
width = width * 10 + (ch - '0');
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_width:
if (ch >= '0' && ch <= '9') {
width = width * 10 + (ch - '0');
} else {
state = st_modifiers;
p--; /* Process this character again */
}
break;
case st_modifiers:
switch (ch) {
/* Length modifiers - nonterminal sequences */
case 'h':
rank--; /* Shorter rank */
break;
case 'l':
rank++; /* Longer rank */
break;
case 'j':
rank = INTMAX_RANK;
break;
case 'z':
rank = SIZE_T_RANK;
break;
case 't':
rank = PTRDIFF_T_RANK;
break;
case 'L':
case 'q':
rank = rank_longlong; /* long double/long long */
break;
case st_modifiers:
switch (ch) {
/* Length modifiers - nonterminal sequences */
case 'h':
rank--; /* Shorter rank */
break;
case 'l':
rank++; /* Longer rank */
break;
case 'j':
rank = INTMAX_RANK;
break;
case 'z':
rank = SIZE_T_RANK;
break;
case 't':
rank = PTRDIFF_T_RANK;
break;
case 'L':
case 'q':
rank = rank_longlong; /* long double/long long */
break;
default:
/* Output modifiers - terminal sequences */
/* Next state will be normal */
state = st_normal;
default:
/* Output modifiers - terminal sequences */
/* Next state will be normal */
state = st_normal;
/* Canonicalize rank */
if (rank < MIN_RANK)
rank = MIN_RANK;
else if (rank > MAX_RANK)
rank = MAX_RANK;
/* Canonicalize rank */
if (rank < MIN_RANK)
rank = MIN_RANK;
else if (rank > MAX_RANK)
rank = MAX_RANK;
switch (ch) {
case 'P': /* Upper case pointer */
case 'p': /* Pointer */
rank = rank_ptr;
base = 0;
sign = 0;
goto scan_int;
switch (ch) {
case 'P': /* Upper case pointer */
case 'p': /* Pointer */
rank = rank_ptr;
base = 0;
sign = 0;
goto scan_int;
case 'i': /* Base-independent integer */
base = 0;
sign = 1;
goto scan_int;
case 'i': /* Base-independent integer */
base = 0;
sign = 1;
goto scan_int;
case 'd': /* Decimal integer */
base = 10;
sign = 1;
goto scan_int;
case 'd': /* Decimal integer */
base = 10;
sign = 1;
goto scan_int;
case 'o': /* Octal integer */
base = 8;
sign = 0;
goto scan_int;
case 'o': /* Octal integer */
base = 8;
sign = 0;
goto scan_int;
case 'u': /* Unsigned decimal integer */
base = 10;
sign = 0;
goto scan_int;
case 'u': /* Unsigned decimal integer */
base = 10;
sign = 0;
goto scan_int;
case 'x': /* Hexadecimal integer */
case 'X':
base = 16;
sign = 0;
goto scan_int;
case 'x': /* Hexadecimal integer */
case 'X':
base = 16;
sign = 0;
goto scan_int;
case 'n': /* # of characters consumed */
val = (q - buffer);
goto set_integer;
case 'n': /* # of characters consumed */
val = (q - buffer);
goto set_integer;
scan_int:
q = skipspace(q);
if (!*q) {
bail = bail_eof;
break;
}
val =
strntoumax(q, (char **)&qq, base,
width);
if (qq == q) {
bail = bail_err;
break;
}
q = qq;
if (!(flags & FL_SPLAT))
converted++;
/* fall through */
scan_int:
q = skipspace(q);
if (!*q) {
bail = bail_eof;
break;
}
val =
strntoumax(q, (char **)&qq, base,
width);
if (qq == q) {
bail = bail_err;
break;
}
q = qq;
if (!(flags & FL_SPLAT))
converted++;
/* fall through */
set_integer:
if (!(flags & FL_SPLAT)) {
switch (rank) {
case rank_char:
*va_arg(ap,
unsigned char *)
= val;
break;
case rank_short:
*va_arg(ap,
unsigned short
*) = val;
break;
case rank_int:
*va_arg(ap,
unsigned int *)
= val;
break;
case rank_long:
*va_arg(ap,
unsigned long *)
= val;
break;
case rank_longlong:
*va_arg(ap,
unsigned long
long *) = val;
break;
case rank_ptr:
*va_arg(ap, void **) =
(void *)
(uintptr_t)val;
break;
default:
break;
}
}
break;
set_integer:
if (!(flags & FL_SPLAT)) {
switch (rank) {
case rank_char:
*va_arg(ap,
unsigned char *)
= val;
break;
case rank_short:
*va_arg(ap,
unsigned short
*) = val;
break;
case rank_int:
*va_arg(ap,
unsigned int *)
= val;
break;
case rank_long:
*va_arg(ap,
unsigned long *)
= val;
break;
case rank_longlong:
*va_arg(ap,
unsigned long
long *) = val;
break;
case rank_ptr:
*va_arg(ap, void **) =
(void *)
(uintptr_t)val;
break;
default:
break;
}
}
break;
case 'c': /* Character */
/* Default width == 1 */
width = (flags & FL_WIDTH) ? width : 1;
if (flags & FL_SPLAT) {
while (width--) {
if (!*q) {
bail = bail_eof;
break;
}
}
} else {
sarg = va_arg(ap, char *);
while (width--) {
if (!*q) {
bail = bail_eof;
break;
}
*sarg++ = *q++;
}
if (!bail)
converted++;
}
break;
case 'c': /* Character */
/* Default width == 1 */
width = (flags & FL_WIDTH) ? width : 1;
if (flags & FL_SPLAT) {
while (width--) {
if (!*q) {
bail = bail_eof;
break;
}
}
} else {
sarg = va_arg(ap, char *);
while (width--) {
if (!*q) {
bail = bail_eof;
break;
}
*sarg++ = *q++;
}
if (!bail)
converted++;
}
break;
case 's': /* String */
uc = 1; /* Anything nonzero */
if (flags & FL_SPLAT) {
while (width-- && (uc = *q) &&
!isspace(uc)) {
q++;
}
} else {
char *sp;
sp = sarg = va_arg(ap, char *);
while (width-- && (uc = *q) &&
!isspace(uc)) {
*sp++ = uc;
q++;
}
if (sarg != sp) {
/* Terminate output */
*sp = '\0';
converted++;
}
}
if (!uc)
bail = bail_eof;
break;
case 's': /* String */
uc = 1; /* Anything nonzero */
if (flags & FL_SPLAT) {
while (width-- && (uc = *q) &&
!isspace(uc)) {
q++;
}
} else {
char *sp;
sp = sarg = va_arg(ap, char *);
while (width-- && (uc = *q) &&
!isspace(uc)) {
*sp++ = uc;
q++;
}
if (sarg != sp) {
/* Terminate output */
*sp = '\0';
converted++;
}
}
if (!uc)
bail = bail_eof;
break;
case '[': /* Character range */
sarg = (flags & FL_SPLAT) ? NULL
: va_arg(ap, char *);
state = st_match_init;
matchinv = 0;
memset(matchmap, 0, sizeof matchmap);
break;
case '[': /* Character range */
sarg = (flags & FL_SPLAT) ? NULL
: va_arg(ap, char *);
state = st_match_init;
matchinv = 0;
memset(matchmap, 0, sizeof matchmap);
break;
case '%': /* %% sequence */
if (*q == '%')
q++;
else
bail = bail_err;
break;
case '%': /* %% sequence */
if (*q == '%')
q++;
else
bail = bail_err;
break;
default: /* Anything else */
/* Unknown sequence */
bail = bail_err;
break;
}
}
break;
default: /* Anything else */
/* Unknown sequence */
bail = bail_err;
break;
}
}
break;
case st_match_init: /* Initial state for %[ match */
if (ch == '^' && !(flags & FL_INV)) {
matchinv = 1;
} else {
set_bit(matchmap, (unsigned char)ch);
state = st_match;
}
break;
case st_match_init: /* Initial state for %[ match */
if (ch == '^' && !(flags & FL_INV)) {
matchinv = 1;
} else {
set_bit(matchmap, (unsigned char)ch);
state = st_match;
}
break;
case st_match: /* Main state for %[ match */
if (ch == ']') {
goto match_run;
} else if (ch == '-') {
range_start = (unsigned char)ch;
state = st_match_range;
} else {
set_bit(matchmap, (unsigned char)ch);
}
break;
case st_match: /* Main state for %[ match */
if (ch == ']') {
goto match_run;
} else if (ch == '-') {
range_start = (unsigned char)ch;
state = st_match_range;
} else {
set_bit(matchmap, (unsigned char)ch);
}
break;
case st_match_range: /* %[ match after - */
if (ch == ']') {
/* - was last character */
set_bit(matchmap, (unsigned char)'-');
goto match_run;
} else {
int i;
for (i = range_start; i < (unsigned char)ch;
i++)
set_bit(matchmap, i);
state = st_match;
}
break;
case st_match_range: /* %[ match after - */
if (ch == ']') {
/* - was last character */
set_bit(matchmap, (unsigned char)'-');
goto match_run;
} else {
int i;
for (i = range_start; i < (unsigned char)ch;
i++)
set_bit(matchmap, i);
state = st_match;
}
break;
match_run: /* Match expression finished */
qq = q;
uc = 1; /* Anything nonzero */
while (width && (uc = *q)
&& test_bit(matchmap, uc)^matchinv) {
if (sarg)
*sarg++ = uc;
q++;
}
if (q != qq && sarg) {
*sarg = '\0';
converted++;
} else {
bail = bail_err;
}
if (!uc)
bail = bail_eof;
break;
default:
break;
}
}
match_run: /* Match expression finished */
qq = q;
uc = 1; /* Anything nonzero */
while (width && (uc = *q)
&& test_bit(matchmap, uc)^matchinv) {
if (sarg)
*sarg++ = uc;
q++;
}
if (q != qq && sarg) {
*sarg = '\0';
converted++;
} else {
bail = bail_err;
}
if (!uc)
bail = bail_eof;
break;
default:
break;
}
}
if (bail == bail_eof && !converted)
converted = -1; /* Return EOF (-1) */
if (bail == bail_eof && !converted)
converted = -1; /* Return EOF (-1) */
return converted;
return converted;
}

4
components/bl602/bl602_std/bl602_std/Common/partition/partition.mk
View File

@ -3,8 +3,8 @@ SUB_MODULE_OUT_DIR:= $(MODULE_OUT_DIR)/partition
SUB_MODULE_SRC_DIR := $(SUB_MODULE_DIR)
COMMON_INCLUDE += -I $(MODULE_DIR)/partition
COMMON_INCLUDE += -I $(MODULE_DIR)/partition
partition_sources := partition.c
partition_objs := $(addprefix $(SUB_MODULE_OUT_DIR)/, $(subst .c,.o,$(partition_sources)))

8
components/bl602/bl602_std/bl602_std/Common/platform_print/bflb_platform.h
View File

@ -9,10 +9,10 @@
#include "mcu_sdk_version.h"
#endif
void * pvPortMalloc( size_t xWantedSize );
void* pvPortRealloc(void* ptr, size_t newsize);
void* pvPortCalloc(size_t numElements, size_t sizeOfElement);
void vPortFree( void *pv );
void * pvPortMalloc( size_t xWantedSize );
void* pvPortRealloc(void* ptr, size_t newsize);
void* pvPortCalloc(size_t numElements, size_t sizeOfElement);
void vPortFree( void *pv );
#define bflb_platform_malloc pvPortMalloc
#define bflb_platform_free vPortFree

2
components/bl602/bl602_std/bl602_std/Common/ring_buffer/ring_buffer.mk
View File

@ -4,7 +4,7 @@ SUB_MODULE_OUT_DIR:= $(MODULE_OUT_DIR)/ring_buffer
SUB_MODULE_SRC_DIR := $(SUB_MODULE_DIR)
COMMON_INCLUDE += -I $(MODULE_DIR)/ring_buffer \
ring_buffer_sources := ring_buffer.c
ring_buffer_objs := $(addprefix $(SUB_MODULE_OUT_DIR)/, $(subst .c,.o,$(ring_buffer_sources)))

2
components/bl602/bl602_std/bl602_std/Common/sim_print/sim_print.mk
View File

@ -8,7 +8,7 @@ ifeq ($(DV_TEST),y)
COMMON_INCLUDE += -I $(MODULE_DIR)/sim_print
endif
sim_print_sources :=
sim_print_sources :=
sim_print_objs := $(addprefix $(SUB_MODULE_OUT_DIR)/, $(subst .c,.o,$(sim_print_sources)))

2
components/bl602/bl602_std/bl602_std/Common/soft_crc/softcrc.mk
View File

@ -12,7 +12,7 @@ softcrc_sources := softcrc.c
softcrc_objs := $(addprefix $(SUB_MODULE_OUT_DIR)/, $(subst .c,.o,$(softcrc_sources)))
common_objs_target += $(softcrc_objs)
$(SUB_MODULE_OUT_DIR)/%.o:$(SUB_MODULE_SRC_DIR)/%.c
@mkdir -p $(dir $@)
@echo "cc $<"

70
components/bl602/bl602_std/bl602_std/Common/xz/xz.h
View File

@ -12,11 +12,11 @@
#define XZ_H
#ifdef __KERNEL__
# include <linux/stddef.h>
# include <linux/types.h>
# include <linux/stddef.h>
# include <linux/types.h>
#else
# include <stddef.h>
# include <stdint.h>
# include <stddef.h>
# include <stdint.h>
#endif
#ifdef __cplusplus
@ -25,7 +25,7 @@ extern "C" {
/* In Linux, this is used to make extern functions static when needed. */
#ifndef XZ_EXTERN
# define XZ_EXTERN extern
# define XZ_EXTERN extern
#endif
/**
@ -54,9 +54,9 @@ extern "C" {
* be built with fewer features to minimize code size.
*/
enum xz_mode {
XZ_SINGLE,
XZ_PREALLOC,
XZ_DYNALLOC
XZ_SINGLE,
XZ_PREALLOC,
XZ_DYNALLOC
};
/**
@ -110,15 +110,15 @@ enum xz_mode {
* is used instead of XZ_BUF_ERROR.
*/
enum xz_ret {
XZ_OK,
XZ_STREAM_END,
XZ_UNSUPPORTED_CHECK,
XZ_MEM_ERROR,
XZ_MEMLIMIT_ERROR,
XZ_FORMAT_ERROR,
XZ_OPTIONS_ERROR,
XZ_DATA_ERROR,
XZ_BUF_ERROR
XZ_OK,
XZ_STREAM_END,
XZ_UNSUPPORTED_CHECK,
XZ_MEM_ERROR,
XZ_MEMLIMIT_ERROR,
XZ_FORMAT_ERROR,
XZ_OPTIONS_ERROR,
XZ_DATA_ERROR,
XZ_BUF_ERROR
};
/**
@ -138,13 +138,13 @@ enum xz_ret {
* the variables in_pos and out_pos are modified by the XZ code.
*/
struct xz_buf {
const uint8_t *in;
size_t in_pos;
size_t in_size;
const uint8_t *in;
size_t in_pos;
size_t in_size;
uint8_t *out;
size_t out_pos;
size_t out_size;
uint8_t *out;
size_t out_pos;
size_t out_size;
};
/**
@ -244,11 +244,11 @@ XZ_EXTERN void xz_dec_end(struct xz_dec *s);
* care about the functions below.
*/
#ifndef XZ_INTERNAL_CRC32
# ifdef __KERNEL__
# define XZ_INTERNAL_CRC32 0
# else
# define XZ_INTERNAL_CRC32 1
# endif
# ifdef __KERNEL__
# define XZ_INTERNAL_CRC32 0
# else
# define XZ_INTERNAL_CRC32 1
# endif
#endif
/*
@ -256,15 +256,15 @@ XZ_EXTERN void xz_dec_end(struct xz_dec *s);
* implementation is needed too.
*/
#ifndef XZ_USE_CRC64
# undef XZ_INTERNAL_CRC64
# define XZ_INTERNAL_CRC64 0
# undef XZ_INTERNAL_CRC64
# define XZ_INTERNAL_CRC64 0
#endif
#ifndef XZ_INTERNAL_CRC64
# ifdef __KERNEL__
# error Using CRC64 in the kernel has not been implemented.
# else
# define XZ_INTERNAL_CRC64 1
# endif
# ifdef __KERNEL__
# error Using CRC64 in the kernel has not been implemented.
# else
# define XZ_INTERNAL_CRC64 1
# endif
#endif
#if XZ_INTERNAL_CRC32

4
components/bl602/bl602_std/bl602_std/Common/xz/xz.mk
View File

@ -3,8 +3,8 @@ SUB_MODULE_OUT_DIR:= $(MODULE_OUT_DIR)/xz
SUB_MODULE_SRC_DIR := $(SUB_MODULE_DIR)
COMMON_INCLUDE += -I $(MODULE_DIR)/xz
COMMON_INCLUDE += -I $(MODULE_DIR)/xz
xz_sources := xz_crc32.c xz_dec_lzma2.c xz_dec_stream.c xz_decompress.c xz_port.c
xz_objs := $(addprefix $(SUB_MODULE_OUT_DIR)/, $(subst .c,.o,$(xz_sources)))

48
components/bl602/bl602_std/bl602_std/Common/xz/xz_config.h
View File

@ -34,7 +34,7 @@ extern void simple_free(void *p);
#define memzero(buf, size) memset(buf, 0, size)
#ifndef min
# define min(x, y) ((x) < (y) ? (x) : (y))
# define min(x, y) ((x) < (y) ? (x) : (y))
#endif
#define min_t(type, x, y) min(x, y)
@ -59,52 +59,52 @@ extern void simple_free(void *p);
#undef __always_inline
#ifndef __always_inline
# ifdef __GNUC__
# define __always_inline \
inline __attribute__((__always_inline__))
# else
# define __always_inline inline
# endif
# ifdef __GNUC__
# define __always_inline \
inline __attribute__((__always_inline__))
# else
# define __always_inline inline
# endif
#endif
/* Inline functions to access unaligned unsigned 32-bit integers */
#ifndef get_unaligned_le32
static inline uint32_t get_unaligned_le32(const uint8_t *buf)
{
return (uint32_t)buf[0]
| ((uint32_t)buf[1] << 8)
| ((uint32_t)buf[2] << 16)
| ((uint32_t)buf[3] << 24);
return (uint32_t)buf[0]
| ((uint32_t)buf[1] << 8)
| ((uint32_t)buf[2] << 16)
| ((uint32_t)buf[3] << 24);
}
#endif
#ifndef get_unaligned_be32
static inline uint32_t get_unaligned_be32(const uint8_t *buf)
{
return (uint32_t)(buf[0] << 24)
| ((uint32_t)buf[1] << 16)
| ((uint32_t)buf[2] << 8)
| (uint32_t)buf[3];
return (uint32_t)(buf[0] << 24)
| ((uint32_t)buf[1] << 16)
| ((uint32_t)buf[2] << 8)
| (uint32_t)buf[3];
}
#endif
#ifndef put_unaligned_le32
static inline void put_unaligned_le32(uint32_t val, uint8_t *buf)
{
buf[0] = (uint8_t)val;
buf[1] = (uint8_t)(val >> 8);
buf[2] = (uint8_t)(val >> 16);
buf[3] = (uint8_t)(val >> 24);
buf[0] = (uint8_t)val;
buf[1] = (uint8_t)(val >> 8);
buf[2] = (uint8_t)(val >> 16);
buf[3] = (uint8_t)(val >> 24);
}
#endif
#ifndef put_unaligned_be32
static inline void put_unaligned_be32(uint32_t val, uint8_t *buf)
{
buf[0] = (uint8_t)(val >> 24);
buf[1] = (uint8_t)(val >> 16);
buf[2] = (uint8_t)(val >> 8);
buf[3] = (uint8_t)val;
buf[0] = (uint8_t)(val >> 24);
buf[1] = (uint8_t)(val >> 16);
buf[2] = (uint8_t)(val >> 8);
buf[3] = (uint8_t)val;
}
#endif
@ -114,7 +114,7 @@ static inline void put_unaligned_be32(uint32_t val, uint8_t *buf)
* could save a few bytes in code size.
*/
#ifndef get_le32
# define get_le32 get_unaligned_le32
# define get_le32 get_unaligned_le32
#endif
#endif

36
components/bl602/bl602_std/bl602_std/Common/xz/xz_crc32.c
View File

@ -22,7 +22,7 @@
* See <linux/decompress/mm.h> for details.
*/
#ifndef STATIC_RW_DATA
# define STATIC_RW_DATA static
# define STATIC_RW_DATA static
#endif
//STATIC_RW_DATA uint32_t xz_crc32_table[256];
@ -31,31 +31,31 @@ extern const uint32_t crc32Tab[256];
XZ_EXTERN void xz_crc32_init(void)
{
#if 0
const uint32_t poly = 0xEDB88320;
const uint32_t poly = 0xEDB88320;
uint32_t i;
uint32_t j;
uint32_t r;
uint32_t i;
uint32_t j;
uint32_t r;
for (i = 0; i < 256; ++i) {
r = i;
for (j = 0; j < 8; ++j)
r = (r >> 1) ^ (poly & ~((r & 1) - 1));
for (i = 0; i < 256; ++i) {
r = i;
for (j = 0; j < 8; ++j)
r = (r >> 1) ^ (poly & ~((r & 1) - 1));
xz_crc32_table[i] = r;
}
xz_crc32_table[i] = r;
}
#endif
return;
return;
}
XZ_EXTERN uint32_t xz_crc32(const uint8_t *buf, size_t size, uint32_t crc)
{
crc = ~crc;
crc = ~crc;
while (size != 0) {
crc = crc32Tab[*buf++ ^ (crc & 0xFF)] ^ (crc >> 8);
--size;
}
while (size != 0) {
crc = crc32Tab[*buf++ ^ (crc & 0xFF)] ^ (crc >> 8);
--size;
}
return ~crc;
return ~crc;
}

Some files were not shown because too many files have changed in this diff Show More