269 lines
19 KiB
C
269 lines
19 KiB
C
#include "samd51j18a.h"
|
|
#include "stdarg.h"
|
|
#include "spfssf.h"
|
|
#include "usb_util.h"
|
|
|
|
int vspf(char *_Dest, const char *_Format, va_list va)
|
|
{
|
|
//va_list va; //Variable argument list variable
|
|
char *d = _Dest; //Pointer to dest
|
|
|
|
//va_start(va,_Format); //Initialize the variable argument list
|
|
while (*_Format) //While not end of format string
|
|
{
|
|
if (*_Format == SPF_SPEC_START) //If current format string character is the specifier start character
|
|
{
|
|
_Format++; //Skip over the character
|
|
while (*_Format && *_Format <= 64) _Format++; //Forward past any options
|
|
if (*_Format == SPF_SPEC_START) *d++ = *_Format; //If the character is the specifier start character, output the character and advance dest
|
|
else if (*_Format == SPF_SPEC_LONG) //If the character is the long type
|
|
{
|
|
_Format++; //Skip over the character
|
|
if (*_Format == SPF_SPEC_DECIMAL) //If the character is the decimal type
|
|
{
|
|
int64_t buf = va_arg(va,int64_t); //Get the next value from the va list
|
|
//if (buf < 0) { *d++ = '-'; buf = -buf; } //If the given number is negative, add a negative sign to the dest and invert number
|
|
//spf_uint2str_32_3t(&d,buf,32); //Perform the conversion
|
|
d += UTIL_ltoa_radix(buf, d, 10);
|
|
}
|
|
else if (*_Format == SPF_SPEC_UNSIGNED) //If the character is the unsigned type
|
|
{
|
|
uint64_t num = va_arg(va,uint64_t); //Get the next value from the va list
|
|
//spf_uint2str_32_3t(&d,num,32); //Perform the conversion
|
|
d += UTIL_ltoa_radix(num, d, 10);
|
|
}
|
|
else if (*_Format == SPF_SPEC_UHINT || *_Format == SPF_SPEC_UHINT_UP) //If the character is the unsigned type
|
|
{
|
|
uint64_t buf = va_arg(va,uint64_t); //Get the next value from the va list
|
|
//spf_uint2hex_32(&d,(unsigned long) buf);
|
|
d += UTIL_ltoa_radix(buf, d, 16);
|
|
}
|
|
else //If the character was not a known type
|
|
{
|
|
*d++ = SPF_SPEC_START; //Output the start specifier
|
|
*d++ = SPF_SPEC_LONG; //Output the long type
|
|
*d++ = *_Format; //Output the unknown type
|
|
}
|
|
}
|
|
else if (*_Format == SPF_SPEC_DECIMAL) //If the character is the decimal type
|
|
{
|
|
int buf = va_arg(va,int); //Get the next value from the va list
|
|
//if (buf < 0) { *d++ = '-'; buf = -buf; } //If the given number is negative, add a negative sign to the dest and invert number
|
|
//spf_uint2str_32_3t(&d,buf,16); //Perform the conversion
|
|
d += UTIL_itoa(buf, d);
|
|
}
|
|
else if (*_Format == SPF_SPEC_INT) //If the character is the integer type
|
|
{
|
|
int buf = va_arg(va,int); //Get the next value from the va list
|
|
//if (buf < 0) { *d++ = '-'; buf = -buf; } //If the given number is negative, add a negative sign to the dest and inverted number
|
|
//spf_uint2str_32_3t(&d,buf,16); //Perform the conversion
|
|
d += UTIL_itoa(buf, d);
|
|
}
|
|
else if (*_Format == SPF_SPEC_UINT) //If the character is the unsigned integer type
|
|
{
|
|
int buf = va_arg(va,int); //Get the next value from the va list
|
|
//spf_uint2str_32_3t(&d,buf,16); //Perform the conversion
|
|
d += UTIL_utoa(buf, d);
|
|
}
|
|
else if (*_Format == SPF_SPEC_STRING) //If the character is the string type
|
|
{
|
|
char *buf = va_arg(va,char*); //Get the next value from the va list
|
|
while (*buf) *d++ = *buf++; //Perform the conversion (simply output characters and adcance pointers)
|
|
}
|
|
else if (*_Format == SPF_SPEC_UHINT || *_Format == SPF_SPEC_UHINT_UP) //If the character is the short type
|
|
{
|
|
int buf = va_arg(va,unsigned int); //Get the next value from the va list
|
|
//spf_uint2hex_32(&d,(unsigned long) buf); //Perform the conversion
|
|
d += UTIL_utoa(buf, d);
|
|
}
|
|
else //If the character type is unknown
|
|
{
|
|
*d++ = SPF_SPEC_START; //Output the start specifier
|
|
*d++ = *_Format; //Output the unknown type
|
|
}
|
|
}
|
|
else *d++ = *_Format; //If the character is unknown, output it to dest and advance dest
|
|
_Format++; //Advance the format buffer pointer to next character
|
|
}
|
|
//va_end(va); //End the variable argument list
|
|
|
|
*d = '\0'; //Cap off the destination string with a zero
|
|
|
|
return d - _Dest; //Return the length of the destintion buffer
|
|
}
|
|
|
|
int spf(char *_Dest, const char *_Format, ...)
|
|
{
|
|
va_list va; //Variable argument list variable
|
|
int result;
|
|
|
|
va_start(va,_Format); //Initialize the variable argument list
|
|
result = vspf(_Dest, _Format, va);
|
|
va_end(va);
|
|
return result;
|
|
}
|
|
|
|
//sscanf string to number (integer types)
|
|
int64_t ssf_ston(const char **_Src, uint32_t count, uint32_t *conv_count)
|
|
{
|
|
int64_t value = 0; //Return value accumulator
|
|
uint32_t counter=count; //Counter to keep track of numbers converted
|
|
const char* p; //Pointer to first non space character
|
|
|
|
while (*(*_Src) == SSF_SKIP_SPACE) (*_Src)++; //Forward through the whitespace to next non whitespace
|
|
|
|
p = (*_Src); //Set pointer to first non space character
|
|
if (*p == '+' || *p == '-') (*_Src)++; //Skip over sign if any
|
|
while (*(*_Src) >= ASCII_NUM_START &&
|
|
*(*_Src) <= ASCII_NUM_END &&
|
|
counter) //While the source character is a digit and counter is not zero
|
|
{
|
|
value *= 10; //Multiply result by 10 to make room for next 1's place number
|
|
value += *(*_Src)++ - ASCII_NUM_START; //Add source number to value
|
|
counter--; //Decrement counter
|
|
}
|
|
if (counter - count == 0) return 0; //If no number conversion were performed, return 0
|
|
if (*p == '-') value = -value; //If the number given was negative, make the result negative
|
|
|
|
if (conv_count) (*conv_count)++; //Increment the converted count
|
|
return value; //Return the value
|
|
}
|
|
|
|
uint64_t ssf_hton(const char **_Src, uint32_t count,uint32_t *conv_count)
|
|
{
|
|
int64_t value=0; //Return value accumulator
|
|
uint32_t counter=count; //Counter to keep track of numbers converted
|
|
//const char* p; //Pointer to first non space character
|
|
char c;
|
|
|
|
while (*(*_Src) == SSF_SKIP_SPACE) (*_Src)++; //Forward through the whitespace to next non whitespace
|
|
|
|
//p = (*_Src); //Set pointer to first non space character
|
|
|
|
while (counter)
|
|
{
|
|
c = *(*_Src)++;
|
|
if (c >= 'a' && c <= 'f') c -= ('a'-'A'); //toupper
|
|
if (c < '0' || (c > '9' && c < 'A') || c > 'F') break;
|
|
value *= 16; //Multiply result by 10 to make room for next 1's place number
|
|
c = c - '0';
|
|
if (c > 9) c -= 7;
|
|
value += c; //Add source number to value
|
|
counter--; //Decrement counter
|
|
}
|
|
|
|
if (counter - count == 0) return 0; //If no number conversion were performed, return 0
|
|
//if (*p == '-') value = -value; //If the number given was negative, make the result negative
|
|
|
|
if (conv_count) (*conv_count)++; //Increment the converted count
|
|
return value;
|
|
}
|
|
|
|
//sscanf
|
|
int ssf(const char *_Src, const char *_Format, ...)
|
|
{
|
|
va_list va; //Variable argument list variable
|
|
unsigned char looking_for=0; //Static char specified in format to be found in source
|
|
uint32_t conv_count=0; //Count of conversions made
|
|
|
|
va_start(va,_Format); //Initialize the variable argument list
|
|
while (*_Format) //While the format string has not been fully read
|
|
{
|
|
if (looking_for != 0) //If we are looking for a matching character in the source string
|
|
{
|
|
while (*_Src != looking_for && *_Src) _Src++; //While the character is not found in the source string and not the end of the source
|
|
// string, increment the pointer position
|
|
if (*_Src == looking_for) _Src++; //If the character was found, step over it
|
|
else break; //Else the end was reached and the scan is now invalid (Could not find static character)
|
|
looking_for = 0; //Clear the looking for character
|
|
}
|
|
if (*_Format == SSF_SPEC_START) //If the current format character is the specifier start character
|
|
{
|
|
_Format++; //Step over the specifier start character
|
|
if (*_Format == SSF_SPEC_DECIMAL) //If the decimal specifier type is found
|
|
{
|
|
int *value=va_arg(va,int*); //User given destination address
|
|
//*value = (int)ssf_ston(&_Src,5,&conv_count); //Run conversion
|
|
*value = (int)ssf_ston(&_Src,10,&conv_count); //Run conversion
|
|
}
|
|
else if (*_Format == SSF_SPEC_LONG) //If the long specifier type is found
|
|
{
|
|
_Format++; //Skip over the specifier type
|
|
if (*_Format == SSF_SPEC_DECIMAL) //If the decimal specifier type is found
|
|
{
|
|
int64_t *value=va_arg(va,int64_t*); //User given destination address
|
|
//*value = (int64_t)ssf_ston(&_Src,10,&conv_count); //Run conversion
|
|
*value = (int64_t)ssf_ston(&_Src,19,&conv_count); //Run conversion
|
|
}
|
|
else if (*_Format == SSF_SPEC_UHINT) //If the decimal specifier type is found
|
|
{
|
|
uint64_t *value=va_arg(va,uint64_t *); //User given destination address
|
|
//*value = (uint64_t int)ssf_hton(&_Src,12,&conv_count); //Run conversion
|
|
*value = (uint64_t)ssf_hton(&_Src,16,&conv_count); //Run conversion
|
|
}
|
|
}
|
|
else if (*_Format == SSF_SPEC_SHORTINT) //If the short int specifier type is found
|
|
{
|
|
_Format++; //Skip over the specifier type
|
|
if (*_Format == SSF_SPEC_SHORTINT) //If the short int specifier type is found
|
|
{
|
|
_Format++; //Skip over the specifier type
|
|
if (*_Format == SSF_SPEC_DECIMAL) //If the decimal specifier type is found
|
|
{
|
|
unsigned char *value=va_arg(va,unsigned char*); //User given destination address
|
|
//*value = (unsigned char)ssf_ston(&_Src,3,&conv_count); //Run conversion
|
|
*value = (unsigned char)ssf_ston(&_Src,5,&conv_count); //Run conversion
|
|
}
|
|
}
|
|
}
|
|
else if (*_Format == SSF_SPEC_STRING) //If the specifier type is string
|
|
{
|
|
char *value=va_arg(va,char*); //User given destination address, max chars read pointer
|
|
while (*_Src == SSF_SKIP_SPACE) _Src++; //Forward through the whitespace to next non whitespace
|
|
while (*_Src != SSF_SKIP_SPACE && *_Src) *value++ = *_Src++; //While any character but space and not end of string and not end location, copy char to dest
|
|
*value = 0; //Cap off the string pointer with zero
|
|
conv_count++; //Increment the converted count
|
|
}
|
|
else if (*_Format == SSF_SPEC_VERSION) //If the specifier type is string
|
|
{
|
|
char *value=va_arg(va,char*); //User given destination address, max chars read pointer
|
|
while (*_Src == SSF_SKIP_SPACE) _Src++; //Forward through the whitespace to next non whitespace
|
|
while (*_Src != SSF_DELIM_COMMA && *_Src) *value++ = *_Src++; //While any character but space and not end of string and not end location, copy char to dest
|
|
*value = 0; //Cap off the string pointer with zero
|
|
conv_count++; //Increment the converted count
|
|
}
|
|
else if (*_Format >= ASCII_NUM_START && *_Format <= ASCII_NUM_END)
|
|
{
|
|
uint32_t len = (uint32_t)ssf_ston(&_Format,3,NULL); //Convert the given length
|
|
if (*_Format == SSF_SPEC_STRING) //If the specifier type is string
|
|
{
|
|
char *value=va_arg(va,char*),*e; //User given destination address, max chars read pointer
|
|
while (*_Src == SSF_SKIP_SPACE) _Src++; //Forward through the whitespace to next non whitespace
|
|
e = (char*)_Src+len; //Set a maximum length pointer location
|
|
while (*_Src != SSF_SKIP_SPACE && *_Src && _Src != e) *value++ = *_Src++; //While any character but space and not end of string and not end location, copy char to dest
|
|
*value = 0; //Cap off the string pointer with zero
|
|
conv_count++; //Increment the converted count
|
|
}
|
|
else if (*_Format == SSF_SPEC_VERSION) //If the specifier type is string
|
|
{
|
|
char *value=va_arg(va,char*),*e; //User given destination address, max chars read pointer
|
|
while (*_Src == SSF_SKIP_SPACE) _Src++; //Forward through the whitespace to next non whitespace
|
|
e = (char*)_Src+len; //Set a maximum length pointer location
|
|
while (*_Src != SSF_DELIM_COMMA && *_Src && _Src != e) *value++ = *_Src++; //While any character but space and not end of string and not end location, copy char to dest
|
|
*value = 0; //Cap off the string pointer with zero
|
|
conv_count++; //Increment the converted count
|
|
}
|
|
}
|
|
else if (*_Format == SSF_SPEC_START) looking_for = *_Format; //If another start specifier character is found, output a specifier character
|
|
else break; //Scan is now invalid (Uknown type specified)
|
|
}
|
|
else if (*_Format == SSF_SKIP_SPACE) { } //If a space is found, ignore it
|
|
else looking_for = *_Format; //If any other character is found, it is static and should be found in src as well
|
|
_Format++; //Skip over current format character
|
|
}
|
|
|
|
va_end(va); //End the variable argument list
|
|
return conv_count; //Return the number of conversions made
|
|
}
|
|
|