kingkevin
/
stm32f1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

print: add error handling with user output

This commit is contained in:
King Kévin 2017-12-13 13:48:29 +01:00
parent d001ed14e6
commit dba76454af
2 changed files with 77 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
lib/print.c
View File

@ -26,11 +26,24 @@
/* own libraries */
#include "print.h" // printing utilities
/** @defgroup print_crlf output \r\n (Carriage Return + Line Feed) for each \r, \n, \r\n, or \n\r for better terminal compatibility
* @{
**/
#define CRLF true /**< if CR+LN new line should be enforced */
/** @} */
uint8_t print_error;
/** add printed length to total printed length, and sets error if maximum size is exceeded
* @param[in,out] length total printed length
* @param[in] printed printed length
*/
static void print_printed(size_t* length, size_t printed)
{
if (NULL==length) { // check if total is provided
return;
}
if (*length>SIZE_MAX-printed) { // prevent integer overflow
*length = SIZE_MAX; // set to maximum
print_error |= PRINT_ERROR_MAX; // set error
} else {
*length += printed; // save printed length
}
}
/** print character
* @param[out] str string to print character on (use NULL to print on user output)
@ -45,13 +58,12 @@ static size_t print_char(char** str, size_t* size, char c)
length = 0; // remember we didn't print anything
} else if (NULL==str || NULL==*str || NULL==size) { // character should not be saved on string
length = putc(c); // print on user define output
} else if (*size>1) { // // there is enough space in the string to store the character
} else if (*size>1) { // there is enough space in the string to store the character
**str = c; // add provided character to string
*str += 1; // go to next character on string
*size -= 1; // remember we used one character on string
} else if (1==*size) { // string is reaching it's end
**str = '\0'; // add termination character to string (don't go to next character)
*size -= 1; // remember we used one character on string
} else { // string is reached its end
print_error |= PRINT_ERROR_TRUNCATED; // indicate we did not save the character
}
return length;
}
@ -66,7 +78,7 @@ static size_t print_string(char** str, size_t* size, const char* s)
{
size_t length = 0; // number of characters printed
while (*s) { // stop at end of string
length += print_char(str, size, *(s++)); // print character
print_printed(&length, print_char(str, size, *(s++))); // print character
}
return length;
}
@ -87,17 +99,14 @@ static size_t print_unsigned(char** str, size_t* size, uint64_t u, uint32_t padd
number[digits++] = '0'+(u%10); // store digit
u /= 10; // go to next digit
} while (u>0);
if (digits>sizeof(number)) { // prevent buffer underflow
return 0;
}
if (sign) { // print sign
length += print_char(str, size, '+'); // we only have positive numbers
print_printed(&length, print_char(str, size, '+')); // we only have positive numbers
}
for (uint32_t zeros = digits; zeros<padding; zeros++) { // print padding 0's
length += print_char(str, size, '0'); // print 0
print_printed(&length, print_char(str, size, '0')); // print 0
}
for (uint8_t digit = 0; digit < digits; digit++) { // go through all digits
length += print_char(str, size, number[digits-digit-1]); // print digit (in reverse order)
print_printed(&length, print_char(str, size, number[digits-digit-1])); // print digit (in reverse order)
}
return length; // return number of characters printed
}
@ -113,10 +122,10 @@ static size_t print_unsigned(char** str, size_t* size, uint64_t u, uint32_t padd
static size_t print_signed(char** str, size_t* size, int64_t d, uint32_t padding, bool sign) {
size_t length = 0; // number of characters printed
if (d<0) {
length += print_char(str, size, '-'); // print sign
length += print_unsigned(str, size, (uint64_t)-d, padding, false); // print number (casting because there is one more negative value then positive value)
print_printed(&length, print_char(str, size, '-')); // print sign
print_printed(&length, print_unsigned(str, size, (uint64_t)-d, padding, false)); // print number (casting because there is one more negative value then positive value)
} else {
length += print_unsigned(str, size, d, padding, sign); // print number
print_printed(&length, print_unsigned(str, size, d, padding, sign)); // print number
}
return length; // return number of characters printed
}
@ -132,11 +141,11 @@ static size_t print_nibble(char** str, size_t* size, uint8_t nibble, bool upcase
size_t length = 0; // number of characters printed
nibble &= 0x0f; // ensure we only have a nibble
if (nibble<10) {
length += print_char(str, size, '0'+nibble);
print_printed(&length, print_char(str, size, '0'+nibble));
} else if (upcase) {
length += print_char(str, size, 'A'+nibble-10);
print_printed(&length, print_char(str, size, 'A'+nibble-10));
} else {
length += print_char(str, size, 'a'+nibble-10);
print_printed(&length, print_char(str, size, 'a'+nibble-10));
}
return length; // return number of characters printed
}
@ -153,8 +162,8 @@ static size_t print_nibble(char** str, size_t* size, uint8_t nibble, bool upcase
static size_t print_hex(char** str, size_t* size, uint32_t hex, uint32_t padding, bool prefix, bool upcase) {
size_t length = 0; // number of characters printed
if (prefix) { // print 0x prefix
length += print_char(str, size, '0');
length += print_char(str, size, 'x');
print_printed(&length, print_char(str, size, '0'));
print_printed(&length, print_char(str, size, 'x'));
}
uint8_t digits = 0; // number of digits to print
// figure out number of digits to print
@ -168,10 +177,10 @@ static size_t print_hex(char** str, size_t* size, uint32_t hex, uint32_t padding
digits = 2;
}
for (uint32_t zeros = digits; zeros<padding; zeros++) { // print padding 0's
length += print_char(str, size, '0'); // print 0
print_printed(&length, print_char(str, size, '0')); // print 0
}
for (uint8_t digit = 0; digit < digits; digit++) { // go through all digits
length += print_nibble(str, size, hex>>((digits-digit-1)*4), upcase); // print nibble (in reverse order)
print_printed(&length, print_nibble(str, size, hex>>((digits-digit-1)*4), upcase)); // print nibble (in reverse order)
}
return length; // return number of characters printed
}
@ -196,14 +205,14 @@ static size_t print_bits(char** str, size_t* size, uint32_t u, uint32_t padding,
return 0;
}
if (prefix) { // print prefix
length += print_char(str, size, '0');
length += print_char(str, size, 'b');
print_printed(&length, print_char(str, size, '0'));
print_printed(&length, print_char(str, size, 'b'));
}
for (uint32_t zeros = digits; zeros<padding; zeros++) { // print padding 0's
length += print_char(str, size, '0'); // print 0
print_printed(&length, print_char(str, size, '0')); // print 0
}
for (uint8_t digit = 0; digit < digits; digit++) { // go through all bits
length += print_char(str, size, bits[digits-digit-1]); // print bit (in reverse order)
print_printed(&length, print_char(str, size, bits[digits-digit-1])); // print bit (in reverse order)
}
return length; // return number of characters printed
}
@ -217,17 +226,18 @@ static size_t print_bits(char** str, size_t* size, uint32_t u, uint32_t padding,
**/
static size_t vsnprintf(char** str, size_t* size, const char *format, va_list va)
{
size_t length = 0; // number of characters printed
size_t length = 0; // total number of characters printed
uint32_t padding = 0; // number of padding 0's
bool sign = false; // if sign needs to be printed
while (*format) { // go through format string
padding = 0; // reset padding
sign = false; // reset sign
if ('%'!=*format) { // check for format specifier prefix
length += print_char(str, size, *format++); // print character (no interpretation needed)
print_printed(&length, print_char(str, size, *format++)); // print character (no interpretation needed)
} else {
format++; // go to format specifier
if (0==*format) { // end of string detected
print_error |= PRINT_ERROR_MALFORMED; // set error
goto end;
}
// check if sign need to be printed
@ -235,6 +245,7 @@ static size_t vsnprintf(char** str, size_t* size, const char *format, va_list va
sign = true; // remember sign is required
format++; // go to padding number
if (0==*format) { // end of string detected
print_error |= PRINT_ERROR_MALFORMED; // set error
goto end;
}
}
@ -243,50 +254,54 @@ static size_t vsnprintf(char** str, size_t* size, const char *format, va_list va
format++; // go to padding number
while (*format>='0' && *format<='9') {
if (padding>UINT32_MAX/10) { // check for overflow
print_error |= PRINT_ERROR_UNSUPPORTED; // set error
goto end;
}
padding *= 10; // go to next magnitude
if (padding>UINT32_MAX-(*format-'0')) { // check for overflow
print_error |= PRINT_ERROR_UNSUPPORTED; // set error
goto end;
}
padding += *format-'0';
padding += *format-'0'; // save digit
format++; // go to next character
}
if (0==*format) { // end of string detected
print_error |= PRINT_ERROR_MALFORMED; // set error
goto end;
}
}
// check format specifier
switch (*format) {
case 'u': // for uint8_t, uint16_t, uint32_t, unsigned int, unsigned long
length += print_unsigned(str, size, va_arg(va,uint32_t), padding, sign);
print_printed(&length, print_unsigned(str, size, va_arg(va,uint32_t), padding, sign));
break;
case 'U': // for uint64_t, unsigned long long
length += print_unsigned(str, size, va_arg(va,uint64_t), padding, sign);
print_printed(&length, print_unsigned(str, size, va_arg(va,uint64_t), padding, sign));
break;
case 'd': // for int8_t, int16_t, int32_t, int, long
length += print_signed(str, size, va_arg(va,int32_t), padding, sign);
print_printed(&length, print_signed(str, size, va_arg(va,int32_t), padding, sign));
break;
case 'D': // for int64_t, long long
length += print_signed(str, size, va_arg(va,int64_t), padding, sign);
print_printed(&length, print_signed(str, size, va_arg(va,int64_t), padding, sign));
break;
case 'c': // for char, unsigned char
length += print_char(str, size, (char)(va_arg(va,int))); // needs casting because the returned value is promoted
print_printed(&length, print_char(str, size, (char)(va_arg(va,int)))); // needs casting because the returned value is promoted
break;
case 'x': // for downcase hexadecimal
length += print_hex(str, size, va_arg(va,uint32_t), padding, sign, false);
print_printed(&length, print_hex(str, size, va_arg(va,uint32_t), padding, sign, false));
break;
case 'X': // for upcase hexadecimal
length += print_hex(str, size, va_arg(va,uint32_t), padding, sign, true);
print_printed(&length, print_hex(str, size, va_arg(va,uint32_t), padding, sign, true));
break;
case 'b': // for bits
length += print_bits(str, size, va_arg(va,uint32_t), padding, sign);
print_printed(&length, print_bits(str, size, va_arg(va,uint32_t), padding, sign));
break;
case 's': // for strings
length += print_string(str, size, va_arg(va,char*));
print_printed(&length, print_string(str, size, va_arg(va,char*)));
break;
default:
length += print_char(str, size, *format); // print character (unknown format specifier)
print_error |= PRINT_ERROR_UNSUPPORTED; // set error
print_printed(&length, print_char(str, size, *format)); // print character (unknown format specifier)
}
format++; // go to next character
}
@ -294,26 +309,31 @@ static size_t vsnprintf(char** str, size_t* size, const char *format, va_list va
end:
if (NULL!=str && NULL!=*str && NULL!=size) { // when working on a string
**str='\0'; // enforce null termination
if (*size>0) {
*size -= 1; // remember we used memory
} else {
print_error |= PRINT_ERROR_TRUNCATED; // indicate we truncated the string
}
}
return length; // return number of characters it should have written
return length; // return number of characters it should have written (not including the '\0' null termination character)
}
size_t printf(const char *format, ...)
{
size_t length = 0;
print_error = PRINT_ERROR_NONE; // clear error
va_list arglist;
va_start(arglist, format);
length = vsnprintf(NULL, NULL, format, arglist);
size_t length = vsnprintf(NULL, NULL, format, arglist);
va_end(arglist);
return length;
}
size_t snprintf(char* str, size_t size, const char* format, ...)
{
size_t length = 0;
print_error = PRINT_ERROR_NONE; // clear error
va_list arglist;
va_start(arglist, format);
length = vsnprintf(&str, &size, format, arglist);
size_t length = vsnprintf(&str, &size, format, arglist);
va_end(arglist);
return length;
}

10
lib/print.h
View File

@ -13,7 +13,7 @@
*
*/
/** printing utilities to replace the large printf from the standard library (API)
* @note use % as format specifier prefix, followed by + to enforce sign of prefix, 0 and 0-9 for padding, and format specifier
* @note use % as format specifier prefix, followed by + to enforce sign or 0x prefix, 0 followed by n for padding, . followed by n for number for fractional, and format specifier
* format specifier supported are: c for far, s for string, u for uint32_t, d for int32_t, U for uint64_t, D for int64_t, x for lower case hex up to uint32_t, X for upper case hex up to uint32_t, b for bits up to uint32_t
* @file print.h
* @author King Kévin <kingkevin@cuvoodoo.info>
@ -21,6 +21,14 @@
*/
#pragma once
extern uint8_t print_error; /**< flags to indicate which error(s) occurred within printf or snprintf */
#define PRINT_ERROR_NONE 0 /**< no error occurred */
#define PRINT_ERROR_MALFORMED 0x1 /**< input format string is malformed */
#define PRINT_ERROR_UNSUPPORTED 0x2 /**< input format string is not supported */
#define PRINT_ERROR_MAX 0x04 /**< maximum returned printed length reached but more has been printed */
#define PRINT_ERROR_TRUNCATED 0x08 /**< output string size is not large enough to include complete printed string */
/** print a single character on user output
* @warning this must be implemented by the user (using the desired output interface)
* @param[in] c character to be printed