/* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
*/
/** printing utilities to replace the large printf from the standard library (code)
* @file print.c
* @author King Kévin
* @date 2017
*/
/* standard libraries */
#include // standard integer types
#include // standard definitions
#include // boolean types
#include // variadic utilities
#include // mathematics utilities to handle floating points
/* own libraries */
#include "print.h" // printing utilities
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)
* @param[in,out] size size of string
* @param[in] c character to be printed
* @return number of characters printed
**/
static size_t print_char(char** str, size_t* size, char c)
{
size_t length = 1; // remember how many characters have been printed or should have been added on string (normally just one)
if (0==c) { // don't print string termination character
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
**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 { // string is reached its end
print_error |= PRINT_ERROR_TRUNCATED; // indicate we did not save the character
}
return length;
}
/** print string
* @param[out] str string to print string on (use NULL to print on user output)
* @param[in,out] size size of string
* @param[in] s string to be printed
* @return number of characters printed
**/
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
print_printed(&length, print_char(str, size, *(s++))); // print character
}
return length;
}
/** print unsigned integer
* @param[out] str string to print unsigned integer on (use NULL to print on user output)
* @param[in,out] size size of string
* @param[in] u unsigned integer to be printed
* @param[in] padding number of 0's to pad
* @param[in] sign if sign should be printed
* @return number of characters printed
**/
static size_t print_unsigned(char** str, size_t* size, uint64_t u, uint32_t padding, bool sign) {
char number[20] = {0}; // construct the number in reverse order (20 chars are required to store UINT64_MAX)
uint8_t digits = 0; // to count the number of digits
size_t length = 0; // number of characters printed
do {
number[digits++] = '0'+(u%10); // store digit
u /= 10; // go to next digit
} while (u>0);
if (sign) { // print sign
print_printed(&length, print_char(str, size, '+')); // we only have positive numbers
}
for (uint32_t zeros = digits; zeros=pow(10.0, exponent)) { // find the positive exponent, base 10
exponent += 3; // increment in kilo
}
if (padding) { // respect padding wish
exponent -= padding;
} else {
exponent -= 3;
}
}
// print integer part
f_abs /= pow(10.0, exponent); // convert to scientific format
print_printed(&length, print_unsigned(str, size, f_abs, padding, false)); // print integer part as scientific number
// print fractional part
if (fractional) {
print_printed(&length, print_char(str, size, '.')); // print decimal point
f_abs -= (uint64_t)f_abs; // remove integer part
for (uint32_t frac=0; frac0xffffffffffffffUL) {
digits = 16;
} else if (hex>0xffffffffffffUL) {
digits = 14;
} else if (hex>0xffffffffffUL) {
digits = 12;
} else if (hex>0xffffffffUL) {
digits = 10;
} else if (hex>0xffffffUL) {
digits = 8;
} else if (hex>0xffffUL) {
digits = 6;
} else if (hex>0xffUL) {
digits = 4;
} else {
digits = 2;
}
for (uint32_t zeros = digits; zeros>((digits-digit-1)*4), upcase)); // print nibble (in reverse order)
}
return length; // return number of characters printed
}
/** print bits
* @param[out] str string to print bits on (use NULL to print on user output)
* @param[in,out] size size of string
* @param[in] u bits to be printed
* @param[in] padding number of 0's to pad
* @param[in] prefix if 0b prefix should be printed
* @return number of characters printed
**/
static size_t print_bits(char** str, size_t* size, uint64_t u, uint32_t padding, bool prefix) {
char bits[64] = {0}; // construct the bit string in reverse order
uint8_t digits = 0; // to count the number of digits
size_t length = 0; // number of characters printed
do {
bits[digits++] = '0'+(u&0x1); // store bit
u >>= 1; // go to next bit
} while (u>0);
if (digits>sizeof(bits)) { // prevent buffer underflow
return 0;
}
if (prefix) { // print prefix
print_printed(&length, print_char(str, size, '0'));
print_printed(&length, print_char(str, size, 'b'));
}
for (uint32_t zeros = digits; zeros='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'; // save digit
format++; // go to next character
}
if (0==*format) { // end of string detected
print_error |= PRINT_ERROR_MALFORMED; // set error
goto end;
}
}
// check fractional
if ('.'==*format) { // fractional required
format++; // go to fractional number
while (*format>='0' && *format<='9') {
if (fractional>UINT32_MAX/10) { // check for overflow
print_error |= PRINT_ERROR_UNSUPPORTED; // set error
goto end;
}
fractional *= 10; // go to next magnitude
if (fractional>UINT32_MAX-(*format-'0')) { // check for overflow
print_error |= PRINT_ERROR_UNSUPPORTED; // set error
goto end;
}
fractional += *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;
}
} else {
fractional = 2; // default fractional precision
}
// check format specifier
switch (*format) {
case 'c': // for char, unsigned char
print_printed(&length, print_char(str, size, (char)(va_arg(va,int)))); // needs casting because the returned value is promoted
break;
case 's': // for strings
print_printed(&length, print_string(str, size, va_arg(va,char*)));
break;
case 'u': // for uint8_t, uint16_t, uint32_t, unsigned int, unsigned long
print_printed(&length, print_unsigned(str, size, va_arg(va,uint32_t), padding, sign));
break;
case 'U': // for uint64_t, unsigned long long
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
print_printed(&length, print_signed(str, size, va_arg(va,int32_t), padding, sign));
break;
case 'D': // for int64_t, long long
print_printed(&length, print_signed(str, size, va_arg(va,int64_t), padding, sign));
break;
case 'f':
print_printed(&length, print_float(str, size, va_arg(va,double), padding, fractional, sign));
break;
case 'x': // for uint8_t, uint16_t, uint32_t downcase hexadecimal
print_printed(&length, print_hex(str, size, va_arg(va,uint32_t), padding, sign, false));
break;
case 'X': // for uint64_t downcase hexadecimal
print_printed(&length, print_hex(str, size, va_arg(va,uint64_t), padding, sign, false));
break;
case 'h': // for uint8_t, uint16_t, uint32_t upcase hexadecimal
print_printed(&length, print_hex(str, size, va_arg(va,uint32_t), padding, sign, true));
break;
case 'H': // for uint64_t upcase hexadecimal
print_printed(&length, print_hex(str, size, va_arg(va,uint64_t), padding, sign, true));
break;
case 'b': // for uint8_t, uint16_t, uint32_t bits
print_printed(&length, print_bits(str, size, va_arg(va,uint32_t), padding, sign));
break;
case 'B': // for uint64_t bits
print_printed(&length, print_bits(str, size, va_arg(va,uint64_t), padding, sign));
break;
default:
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
}
}
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 (not including the '\0' null termination character)
}
size_t printf(const char *format, ...)
{
print_error = PRINT_ERROR_NONE; // clear error
va_list arglist;
va_start(arglist, format);
size_t length = vsnprintf(NULL, NULL, format, arglist);
va_end(arglist);
return length;
}
size_t snprintf(char* str, size_t size, const char* format, ...)
{
print_error = PRINT_ERROR_NONE; // clear error
va_list arglist;
va_start(arglist, format);
size_t length = vsnprintf(&str, &size, format, arglist);
va_end(arglist);
return length;
}