CuVoodoo STM32F1 firmware template
print.c
Go to the documentation of this file.
1 /* This program is free software: you can redistribute it and/or modify
2  * it under the terms of the GNU General Public License as published by
3  * the Free Software Foundation, either version 3 of the License, or
4  * (at your option) any later version.
5  *
6  * This program is distributed in the hope that it will be useful,
7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9  * GNU General Public License for more details.
10  *
11  * You should have received a copy of the GNU General Public License
12  * along with this program. If not, see <http://www.gnu.org/licenses/>.
13  *
14  */
20 /* standard libraries */
21 #include <stdint.h> // standard integer types
22 #include <stdlib.h> // standard definitions
23 #include <stdbool.h> // boolean types
24 #include <stdarg.h> // variadic utilities
25 #include <math.h> // mathematics utilities to handle floating points
26 
27 /* own libraries */
28 #include "print.h" // printing utilities
29 
30 uint8_t print_error;
31 
36 static void print_printed(size_t* length, size_t printed)
37 {
38  if (NULL==length) { // check if total is provided
39  return;
40  }
41  if (*length>SIZE_MAX-printed) { // prevent integer overflow
42  *length = SIZE_MAX; // set to maximum
43  print_error |= PRINT_ERROR_MAX; // set error
44  } else {
45  *length += printed; // save printed length
46  }
47 }
48 
55 static size_t print_char(char** str, size_t* size, char c)
56 {
57  size_t length = 1; // remember how many characters have been printed or should have been added on string (normally just one)
58  if (0==c) { // don't print string termination character
59  length = 0; // remember we didn't print anything
60  } else if (NULL==str || NULL==*str || NULL==size) { // character should not be saved on string
61  length = putc(c); // print on user define output
62  } else if (*size>1) { // there is enough space in the string to store the character
63  **str = c; // add provided character to string
64  *str += 1; // go to next character on string
65  *size -= 1; // remember we used one character on string
66  } else { // string is reached its end
67  print_error |= PRINT_ERROR_TRUNCATED; // indicate we did not save the character
68  }
69  return length;
70 }
71 
78 static size_t print_string(char** str, size_t* size, const char* s)
79 {
80  size_t length = 0; // number of characters printed
81  while (*s) { // stop at end of string
82  print_printed(&length, print_char(str, size, *(s++))); // print character
83  }
84  return length;
85 }
86 
95 static size_t print_unsigned(char** str, size_t* size, uint64_t u, uint32_t padding, bool sign) {
96  char number[20] = {0}; // construct the number in reverse order (20 chars are required to store UINT64_MAX)
97  uint8_t digits = 0; // to count the number of digits
98  size_t length = 0; // number of characters printed
99  do {
100  number[digits++] = '0'+(u%10); // store digit
101  u /= 10; // go to next digit
102  } while (u>0);
103  if (sign) { // print sign
104  print_printed(&length, print_char(str, size, '+')); // we only have positive numbers
105  }
106  for (uint32_t zeros = digits; zeros<padding; zeros++) { // print padding 0's
107  print_printed(&length, print_char(str, size, '0')); // print 0
108  }
109  for (uint8_t digit = 0; digit < digits; digit++) { // go through all digits
110  print_printed(&length, print_char(str, size, number[digits-digit-1])); // print digit (in reverse order)
111  }
112  return length; // return number of characters printed
113 }
114 
123 static size_t print_signed(char** str, size_t* size, int64_t d, uint32_t padding, bool sign) {
124  size_t length = 0; // number of characters printed
125  if (d<0) {
126  print_printed(&length, print_char(str, size, '-')); // print sign
127  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)
128  } else {
129  print_printed(&length, print_unsigned(str, size, d, padding, sign)); // print number
130  }
131  return length; // return number of characters printed
132 }
133 
143 static size_t print_float(char** str, size_t* size, double f, uint32_t padding, uint32_t fractional, bool sign) {
144  size_t length = 0; // number of characters printed
145  if (isnan(f)) { // not a number
146  print_printed(&length, print_string(str, size, "NaN")); // print NaN
147  } else if (isinf(f)) { // infinite
148  if (-1==isinf(f)) {
149  print_printed(&length, print_char(str, size, '-')); // print sign
150  } else if (sign) {
151  print_printed(&length, print_char(str, size, '+')); // print sign
152  }
153  print_printed(&length, print_string(str, size, "inf")); // print inf
154  } else if (isnormal(f)) { // it should be not 0
155  if (f<0) {
156  print_printed(&length, print_char(str, size, '-')); // print sign
157  } else if (sign) {
158  print_printed(&length, print_char(str, size, '+')); // print sign
159  }
160  double f_abs = fabs(f); // only work using the absolute value now that the sign is printed
161  // get the exponent
162  int8_t exponent = 0; // exponent min/max for double is 37
163  if (f_abs<1.0) {
164  while (f_abs<pow(10.0, exponent-1)) { // find negative exponent, base 10
165  exponent -= 1; // decrement in deci
166  }
167  if (padding) { // respect padding wish
168  exponent -= padding;
169  }
170  } else {
171  while (f_abs>=pow(10.0, exponent)) { // find the positive exponent, base 10
172  exponent += 3; // increment in kilo
173  }
174  if (padding) { // respect padding wish
175  exponent -= padding;
176  } else {
177  exponent -= 3;
178  }
179  }
180  // print integer part
181  f_abs /= pow(10.0, exponent); // convert to scientific format
182  print_printed(&length, print_unsigned(str, size, f_abs, padding, false)); // print integer part as scientific number
183  // print fractional part
184  if (fractional) {
185  print_printed(&length, print_char(str, size, '.')); // print decimal point
186  f_abs -= (uint64_t)f_abs; // remove integer part
187  for (uint32_t frac=0; frac<fractional; frac++) { // print fractional parts
188  f_abs *= 10.0;
189  print_printed(&length, print_unsigned(str, size, f_abs, 0, false));
190  f_abs -= (uint64_t)f_abs;
191  }
192  }
193  // print exponent
194  if (exponent) {
195  print_printed(&length, print_char(str, size, 'E')); // print exponent mark
196  print_printed(&length, print_signed(str, size, exponent, 0, false));
197  }
198  } else { // f=0
199  // print sign
200  if (f<0) {
201  print_printed(&length, print_char(str, size, '-')); // print sign
202  } else if (sign) {
203  print_printed(&length, print_char(str, size, '+')); // print sign
204  }
205  print_printed(&length, print_unsigned(str, size, 0, padding, false)); // print integer part
206  if (fractional) {
207  print_printed(&length, print_char(str, size, '.')); // print decimal point
208  print_printed(&length, print_unsigned(str, size, 0, fractional, false)); // print fractional part
209  }
210  }
211  return length; // return number of characters printed
212 }
213 
221 static size_t print_nibble(char** str, size_t* size, uint8_t nibble, bool upcase) {
222  size_t length = 0; // number of characters printed
223  nibble &= 0x0f; // ensure we only have a nibble
224  if (nibble<10) {
225  print_printed(&length, print_char(str, size, '0'+nibble));
226  } else if (upcase) {
227  print_printed(&length, print_char(str, size, 'A'+nibble-10));
228  } else {
229  print_printed(&length, print_char(str, size, 'a'+nibble-10));
230  }
231  return length; // return number of characters printed
232 }
233 
243 static size_t print_hex(char** str, size_t* size, uint64_t hex, uint32_t padding, bool prefix, bool upcase) {
244  size_t length = 0; // number of characters printed
245  if (prefix) { // print 0x prefix
246  print_printed(&length, print_char(str, size, '0'));
247  print_printed(&length, print_char(str, size, 'x'));
248  }
249  uint8_t digits = 0; // number of digits to print
250  // figure out number of digits to print
251  if (hex>0xffffffffffffffUL) {
252  digits = 16;
253  } else if (hex>0xffffffffffffUL) {
254  digits = 14;
255  } else if (hex>0xffffffffffUL) {
256  digits = 12;
257  } else if (hex>0xffffffffUL) {
258  digits = 10;
259  } else if (hex>0xffffffUL) {
260  digits = 8;
261  } else if (hex>0xffffUL) {
262  digits = 6;
263  } else if (hex>0xffUL) {
264  digits = 4;
265  } else {
266  digits = 2;
267  }
268  for (uint32_t zeros = digits; zeros<padding; zeros++) { // print padding 0's
269  print_printed(&length, print_char(str, size, '0')); // print 0
270  }
271  for (uint8_t digit = 0; digit < digits; digit++) { // go through all digits
272  print_printed(&length, print_nibble(str, size, hex>>((digits-digit-1)*4), upcase)); // print nibble (in reverse order)
273  }
274  return length; // return number of characters printed
275 }
276 
285 static size_t print_bits(char** str, size_t* size, uint64_t u, uint32_t padding, bool prefix) {
286  char bits[64] = {0}; // construct the bit string in reverse order
287  uint8_t digits = 0; // to count the number of digits
288  size_t length = 0; // number of characters printed
289  do {
290  bits[digits++] = '0'+(u&0x1); // store bit
291  u >>= 1; // go to next bit
292  } while (u>0);
293  if (digits>sizeof(bits)) { // prevent buffer underflow
294  return 0;
295  }
296  if (prefix) { // print prefix
297  print_printed(&length, print_char(str, size, '0'));
298  print_printed(&length, print_char(str, size, 'b'));
299  }
300  for (uint32_t zeros = digits; zeros<padding; zeros++) { // print padding 0's
301  print_printed(&length, print_char(str, size, '0')); // print 0
302  }
303  for (uint8_t digit = 0; digit < digits; digit++) { // go through all bits
304  print_printed(&length, print_char(str, size, bits[digits-digit-1])); // print bit (in reverse order)
305  }
306  return length; // return number of characters printed
307 }
308 
316 static size_t vsnprintf(char** str, size_t* size, const char *format, va_list va)
317 {
318  size_t length = 0; // total number of characters printed
319  uint32_t padding = 0; // number of padding 0's
320  uint32_t fractional = 0; // number or fractional digits for floating point numbers
321  bool sign = false; // if sign needs to be printed
322  while (*format) { // go through format string
323  padding = 0; // reset padding
324  sign = false; // reset sign
325  if ('%'!=*format) { // check for format specifier prefix
326  print_printed(&length, print_char(str, size, *format++)); // print character (no interpretation needed)
327  } else {
328  format++; // go to format specifier
329  if (0==*format) { // end of string detected
330  print_error |= PRINT_ERROR_MALFORMED; // set error
331  goto end;
332  }
333  // check if sign need to be printed
334  if ('+'==*format) { // sign required
335  sign = true; // remember sign is required
336  format++; // go to padding number
337  if (0==*format) { // end of string detected
338  print_error |= PRINT_ERROR_MALFORMED; // set error
339  goto end;
340  }
341  }
342  // check padding
343  if ('0'==*format) { // padding required
344  format++; // go to padding number
345  while (*format>='0' && *format<='9') {
346  if (padding>UINT32_MAX/10) { // check for overflow
347  print_error |= PRINT_ERROR_UNSUPPORTED; // set error
348  goto end;
349  }
350  padding *= 10; // go to next magnitude
351  if (padding>UINT32_MAX-(*format-'0')) { // check for overflow
352  print_error |= PRINT_ERROR_UNSUPPORTED; // set error
353  goto end;
354  }
355  padding += *format-'0'; // save digit
356  format++; // go to next character
357  }
358  if (0==*format) { // end of string detected
359  print_error |= PRINT_ERROR_MALFORMED; // set error
360  goto end;
361  }
362  }
363  // check fractional
364  if ('.'==*format) { // fractional required
365  format++; // go to fractional number
366  while (*format>='0' && *format<='9') {
367  if (fractional>UINT32_MAX/10) { // check for overflow
368  print_error |= PRINT_ERROR_UNSUPPORTED; // set error
369  goto end;
370  }
371  fractional *= 10; // go to next magnitude
372  if (fractional>UINT32_MAX-(*format-'0')) { // check for overflow
373  print_error |= PRINT_ERROR_UNSUPPORTED; // set error
374  goto end;
375  }
376  fractional += *format-'0'; // save digit
377  format++; // go to next character
378  }
379  if (0==*format) { // end of string detected
380  print_error |= PRINT_ERROR_MALFORMED; // set error
381  goto end;
382  }
383  } else {
384  fractional = 2; // default fractional precision
385  }
386  // check format specifier
387  switch (*format) {
388  case 'c': // for char, unsigned char
389  print_printed(&length, print_char(str, size, (char)(va_arg(va,int)))); // needs casting because the returned value is promoted
390  break;
391  case 's': // for strings
392  print_printed(&length, print_string(str, size, va_arg(va,char*)));
393  break;
394  case 'u': // for uint8_t, uint16_t, uint32_t, unsigned int, unsigned long
395  print_printed(&length, print_unsigned(str, size, va_arg(va,uint32_t), padding, sign));
396  break;
397  case 'U': // for uint64_t, unsigned long long
398  print_printed(&length, print_unsigned(str, size, va_arg(va,uint64_t), padding, sign));
399  break;
400  case 'd': // for int8_t, int16_t, int32_t, int, long
401  print_printed(&length, print_signed(str, size, va_arg(va,int32_t), padding, sign));
402  break;
403  case 'D': // for int64_t, long long
404  print_printed(&length, print_signed(str, size, va_arg(va,int64_t), padding, sign));
405  break;
406  case 'f':
407  print_printed(&length, print_float(str, size, va_arg(va,double), padding, fractional, sign));
408  break;
409  case 'x': // for uint8_t, uint16_t, uint32_t downcase hexadecimal
410  print_printed(&length, print_hex(str, size, va_arg(va,uint32_t), padding, sign, false));
411  break;
412  case 'X': // for uint64_t downcase hexadecimal
413  print_printed(&length, print_hex(str, size, va_arg(va,uint64_t), padding, sign, false));
414  break;
415  case 'h': // for uint8_t, uint16_t, uint32_t upcase hexadecimal
416  print_printed(&length, print_hex(str, size, va_arg(va,uint32_t), padding, sign, true));
417  break;
418  case 'H': // for uint64_t upcase hexadecimal
419  print_printed(&length, print_hex(str, size, va_arg(va,uint64_t), padding, sign, true));
420  break;
421  case 'b': // for uint8_t, uint16_t, uint32_t bits
422  print_printed(&length, print_bits(str, size, va_arg(va,uint32_t), padding, sign));
423  break;
424  case 'B': // for uint64_t bits
425  print_printed(&length, print_bits(str, size, va_arg(va,uint64_t), padding, sign));
426  break;
427  default:
428  print_error |= PRINT_ERROR_UNSUPPORTED; // set error
429  print_printed(&length, print_char(str, size, *format)); // print character (unknown format specifier)
430  }
431  format++; // go to next character
432  }
433  }
434 end:
435  if (NULL!=str && NULL!=*str && NULL!=size) { // when working on a string
436  **str='\0'; // enforce null termination
437  if (*size>0) {
438  *size -= 1; // remember we used memory
439  } else {
440  print_error |= PRINT_ERROR_TRUNCATED; // indicate we truncated the string
441  }
442  }
443  return length; // return number of characters it should have written (not including the '\0' null termination character)
444 }
445 
446 size_t printf(const char *format, ...)
447 {
448  print_error = PRINT_ERROR_NONE; // clear error
449  va_list arglist;
450  va_start(arglist, format);
451  size_t length = vsnprintf(NULL, NULL, format, arglist);
452  va_end(arglist);
453  return length;
454 }
455 
456 size_t snprintf(char* str, size_t size, const char* format, ...)
457 {
458  print_error = PRINT_ERROR_NONE; // clear error
459  va_list arglist;
460  va_start(arglist, format);
461  size_t length = vsnprintf(&str, &size, format, arglist);
462  va_end(arglist);
463  return length;
464 }
size_t putc(char c)
print a single character on user output
Definition: application.c:58