From 5a872fa8fbd0923ffb1761ced3dc4194497e16f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?King=20K=C3=A9vin?= <kingkevin@cuvoodoo.info>
Date: Tue, 7 Mar 2017 11:50:04 +0100
Subject: [PATCH] add other format specifiers

---
 lib/print.c | 198 +++++++++++++++++++++++++++++++++++++++-------------
 lib/print.h |   5 +-
 2 files changed, 154 insertions(+), 49 deletions(-)

diff --git a/lib/print.c b/lib/print.c
index 5a2ec97..585b38d 100644
--- a/lib/print.c
+++ b/lib/print.c
@@ -19,40 +19,50 @@
  */
 /* standard libraries */
 #include <stdint.h> // standard integer types
+#include <stdbool.h> // boolean type
 #include <stdarg.h> // variadic utilities
 
 /* own libraries */
 #include "print.h" // printing utilities
 
 /** output \r\n (Carriage Return + Line Feed) for each \r, \n, \r\n, or \n\r for better terminal compatibility */
-#define CRLF 1
+static const bool crlf = true;
 
-void puts(const char* s)
+uint8_t putc(char c)
 {
-	while (*s) { // stop at end of string
-#if CRLF
-		static char newline = 0; // to remember on which character we sent the newline
-
-		if ('\r' == *s || '\n' == *s) { // send CR+LF newline for most carriage return and line feed combination
-			if (0==newline || *s==newline) { // send newline only if not already send (and only once on \r\n or \n\r)
-					putc('\r'); // send CR
-					putc('\n'); // send LF
-					newline = *s; // remember on which character we sent the newline
-			}
-			s++; // go to next character
-			continue; // don't continue processing this character
-		} else {
-			newline = 0; // clear new line
+	uint8_t length = 0; // number of characters printed
+	static char newline = 0; // to remember on which character we sent the newline
+	if (!crlf) {
+		_putc(c); // print character
+		length++; // remember we printed 1 character
+	} else if ('\r' == c || '\n' == c) { // send CR+LF newline for most carriage return and line feed combination
+		if (0==newline || c==newline) { // send newline only if not already send (and only once on \r\n or \n\r)
+				_putc('\r'); // send CR
+				_putc('\n'); // send LF
+				length += 2; // remember we printed 2 characters
+				newline = c; // remember on which character we sent the newline
 		}
-#endif
-		putc(*(s++)); // send character
+	} else {
+		 _putc(c); // print character
+		newline = 0; // clear new line
+		length++; // remember we printed 1 character
 	}
+	return length; // return number of characters printed	
 }
 
-static uint8_t print_unsigned(uint32_t u, uint8_t padding) {
+uint32_t puts(const char* s)
+{
+	uint32_t length = 0; // number of characters printed
+	while (*s) { // stop at end of string
+		length += putc(*(s++)); // send character
+	}
+	return length;
+}
+
+static uint8_t print_unsigned(uint64_t u, uint8_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
-	uint8_t pad = 0; // to count how much padding has been printed
+	uint8_t length = 0; // number of characters printed
 	do {
 		number[digits++] = '0'+(u%10); // store digit
 		u /= 10; // go to next digit
@@ -60,46 +70,117 @@ static uint8_t print_unsigned(uint32_t u, uint8_t padding) {
 	if (digits>sizeof(number)) { // prevent buffer underflow
 		return 0;
 	}
+	if (sign) { // print sign
+		length += putc('+'); // we only have positive numbers
+	}
 	for (uint8_t zeros = digits; zeros<padding; zeros++) { // print padding 0's
-		putc('0'); // print 0
-		pad++; // count printed 0 padding
+		length += putc('0'); // print 0
 	}
 	for (uint8_t digit = 0; digit < digits; digit++) { // go through all digits
-		putc(number[digits-digit-1]); // print digit (in reverse order)
+		length += putc(number[digits-digit-1]); // print digit (in reverse order)
 	}
-	return digits+pad; // return number of digits printed
+	return length; // return number of characters printed
+}
+
+static uint8_t print_signed(int64_t d, uint8_t padding, bool sign) {
+	uint8_t length = 0; // number of characters printed
+	if (d<0) {
+		length += putc('-'); // print sign
+		length += print_unsigned((uint64_t)-d, padding, false); // print number (casting because there is one more negative value then positive value)
+	} else {
+		length += print_unsigned(d, padding, sign); // print number
+	}
+	return length; // return number of characters printed
+}
+
+static uint8_t print_nibble(uint8_t nibble, bool upcase) {
+	uint8_t length = 0; // number of characters printed
+	nibble &= 0x0f; // ensure we only have a nibble
+	if (nibble<10) {
+		length += putc('0'+nibble);
+	} else if (upcase) {
+		length += putc('A'+nibble-10);
+	} else {
+		length += putc('a'+nibble-10);
+	}
+	return length; // return number of characters printed
+}
+
+static uint8_t print_hex(uint32_t hex, uint8_t padding, bool prefix, bool upcase) {
+	uint8_t length = 0; // number of characters printed
+	if (prefix) { // print 0x prefix
+		length += putc('0');
+		length += putc('x');
+	}
+	uint8_t digits = 0; // number of digits to print
+	// figure out number of digits to print
+	if (hex>0x00ffffff) {
+		digits = 8;
+	} else if (hex>0x0000ffff) {
+		digits = 6;
+	} else if (hex>0x000000ff) {
+		digits = 4;
+	} else {
+		digits = 2;
+	}
+	for (uint8_t zeros = digits; zeros<padding; zeros++) { // print padding 0's
+		length += putc('0'); // print 0
+	}
+	for (uint8_t digit = 0; digit < digits; digit++) { // go through all digits
+		length += print_nibble(hex>>((digits-digit-1)*4), upcase); // print nibble (in reverse order)
+	}
+	return length; // return number of characters printed
+} 
+
+static uint8_t print_bits(uint32_t u, uint8_t padding, bool prefix) {
+	char bits[32] = {0}; // construct the bit string in reverse order
+	uint8_t digits = 0; // to count the number of digits
+	uint8_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
+		length += putc('0');
+		length += putc('b');
+	}
+	for (uint8_t zeros = digits; zeros<padding; zeros++) { // print padding 0's
+		length += putc('0'); // print 0
+	}
+	for (uint8_t digit = 0; digit < digits; digit++) { // go through all bits
+		length += putc(bits[digits-digit-1]); // print bit (in reverse order)
+	}
+	return length; // return number of characters printed
 }
 
 uint32_t printf(const char *fmt, ...)
 {
 	uint32_t length = 0; // number of characters printed
 	uint8_t padding = 0; // number of padding 0's
+	bool sign = false; // if sign needs to be printed
 	va_list va; // variable argument list
 	va_start(va, fmt); // initialise variable argument list
 	while (*fmt) { // go through format string
+		padding = 0; // reset padding
+		sign = false; // reset sign
 		if ('%'!=*fmt) { // check for format specifier prefix
-#if CRLF
-			static char newline = 0; // to remember on which character we sent the newline
-			if ('\r' == *fmt || '\n' == *fmt) { // send CR+LF newline for most carriage return and line feed combination
-				if (0==newline || *fmt==newline) { // send newline only if not already send (and only once on \r\n or \n\r)
-						putc('\r'); // send CR
-						putc('\n'); // send LF
-						newline = *fmt; // remember on which character we sent the newline
-						length += 2; // remember we printer the new line
-				}
-				fmt++; // go to next character
-				continue; // don't continue processing this character
-			} else {
-				newline = 0; // clear new line
-			}
-#endif
-			putc(*fmt++); // print character (no interpretation needed)
-			length++; // count printed character
+			length += putc(*fmt++); // print character (no interpretation needed)
 		} else {
 			fmt++; // go to format specifier
 			if (0==*fmt) { // end of string detected
 				goto end;
 			}
+			// check if sign need to be printed
+			if ('+'==*fmt) { // sign required
+				sign = true; // remember sign is required
+				fmt++; // go to padding number
+				if (0==*fmt) { // end of string detected
+					goto end;
+				}
+			}	
 			// check padding
 			if ('0'==*fmt) { // padding required
 				fmt++; // go to padding number
@@ -115,16 +196,39 @@ uint32_t printf(const char *fmt, ...)
 				}
 			}
 			// check format specifier
-			switch (*fmt++) {
-				case 'u':
-					length += print_unsigned(va_arg(va,uint32_t), padding);
+			switch (*fmt) {
+				case 'u': // for uint8_t, uint16_t, uint32_t, unsigned int, unsigned long
+					length += print_unsigned(va_arg(va,uint32_t), padding, sign);
+					break;
+				case 'U': // for uint64_t, unsigned long long
+					length += print_unsigned(va_arg(va,uint64_t), padding, sign);
+					break;
+				case 'd': // for int8_t, int16_t, int32_t, int, long
+					length += print_signed(va_arg(va,int32_t), padding, sign);
+					break;
+				case 'D': // for int64_t, long long
+					length += print_signed(va_arg(va,int64_t), padding, sign);
+					break;
+				case 'c': // for char, unsigned char
+					length += putc((char)(va_arg(va,int))); // needs casting because the returned value is promoted
+					break;
+				case 'x': // for downcase hexadecimal
+					length += print_hex(va_arg(va,uint32_t), padding, sign, false);
+					break;
+				case 'X': // for upcase hexadecimal
+					length += print_hex(va_arg(va,uint32_t), padding, sign, true);
+					break;
+				case 'b': // for bits
+					length += print_bits(va_arg(va,uint32_t), padding, sign);
+					break;
+				case 's': // for strings
+					length += puts(va_arg(va,char*));
 					break;
 				default:
-					putc(*fmt++); // print character (unknown format specifier)
-					length++; // count printed character
+					length += putc(*fmt); // print character (unknown format specifier)
 			}
+			fmt++; // go to next character
 		}
-		padding = 0; // reset padding
 	}
 end:
 	va_end(va);
diff --git a/lib/print.h b/lib/print.h
index b161523..ec03e22 100644
--- a/lib/print.h
+++ b/lib/print.h
@@ -19,6 +19,7 @@
  */
 #pragma once
 
-void putc(char c);
-void puts(const char* s);
+void _putc(char c);
+uint8_t putc(char c);
+uint32_t puts(const char* s);
 uint32_t printf(const char *fmt, ...);