enhancement: more print format constants defined; function printNumber(..) adapted.

cores/arduino/Print.cpp

@@ -69,41 +69,39 @@ size_t Print::print(char c)
   return write(c);
 }
 
-size_t Print::print(unsigned char b, int base)
+size_t Print::print(char num, int base)
 {
-  return print((unsigned long) b, base);
+  return printNumber ((long) num, num < 0, sizeof(char), base);
 }
 
-size_t Print::print(int n, int base)
+size_t Print::print(signed char num, int base)
 {
-  return print((long) n, base);
+  return printNumber ((long) num, num < 0, sizeof(char), base);
 }
 
-size_t Print::print(unsigned int n, int base)
+size_t Print::print(unsigned char num, int base)
 {
-  return print((unsigned long) n, base);
+  return printNumber ((unsigned long) num, false, sizeof(char), base);
 }
 
-size_t Print::print(long n, int base)
+size_t Print::print(int num, int base)
 {
-  if (base == 0) {
-    return write(n);
-  } else if (base == 10) {
-    if (n < 0) {
-      int t = print('-');
-      n = -n;
-      return printNumber(n, 10) + t;
-    }
-    return printNumber(n, 10);
-  } else {
-    return printNumber(n, base);
-  }
+  return printNumber ((long) num, num < 0, sizeof(int), base);
 }
 
-size_t Print::print(unsigned long n, int base)
+size_t Print::print(unsigned int num, int base)
 {
-  if (base == 0) return write(n);
-  else return printNumber(n, base);
+  return printNumber ((unsigned long) num, false, sizeof(int), base);
+}
+
+size_t Print::print(long num, int base)
+{
+  return printNumber (num, num < 0, sizeof(long), base);
+}
+
+size_t Print::print(unsigned long num, int base)
+{
+  return printNumber (num, false, sizeof(long), base);
 }
 
 size_t Print::print(double n, int digits)
@@ -149,9 +147,23 @@ size_t Print::println(char c)
   return n;
 }
 
-size_t Print::println(unsigned char b, int base)
+size_t Print::println(char num, int base)
+{
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t Print::println(signed char num, int base)
+{
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t Print::println(unsigned char num, int base)
 {
-  size_t n = print(b, base);
+  size_t n = print(num, base);
   n += println();
   return n;
 }
@@ -200,24 +212,55 @@ size_t Print::println(const Printable& x)
 
 // Private Methods /////////////////////////////////////////////////////////////
 
-size_t Print::printNumber(unsigned long n, uint8_t base)
+size_t Print::printNumber(unsigned long n, bool negative, size_t bytes, uint16_t base)
 {
+  if (base == 0) return write(n);
+
+  int t = 0;
+  if (base == 10 && negative) {
+    t = print('-');
+    n = -n;
+  }
+
   char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
   char *str = &buf[sizeof(buf) - 1];
 
   *str = '\0';
 
+  uint8_t minDigits = 1;
+  uint8_t maxDigits = sizeof(buf) - 1;
+  if (base > 0xFF) {
+    minDigits = base >> 8;
+    base = base & 0xFF;
+  }
+  if (minDigits > maxDigits) minDigits = maxDigits;
+
   // prevent crash if called with base == 1
   if (base < 2) base = 10;
 
+  uint8_t nominalDigits = 255;
+  switch (base) {
+    case 2:  nominalDigits = bytes * 8; break;
+    case 4:  nominalDigits = bytes * 4; break;
+    case 8:  nominalDigits = (bytes * 8 + 2) / 3; break;  // +2 is for round up
+    case 16: nominalDigits = bytes * 2; break;
+  }
+
+  uint8_t usedDigits = 0;
   do {
     char c = n % base;
     n /= base;
 
     *--str = c < 10 ? c + '0' : c + 'A' - 10;
-  } while(n);
+    usedDigits++;
+  } while(n && usedDigits < nominalDigits);
 
-  return write(str);
+  char fillChar = negative ? (base <= 10 ? base + '0' - 1 : base + 'A' - 11) : '0';
+  while (usedDigits++ < minDigits) {
+    *--str = fillChar;
+  }
+
+  return write(str) + t;
 }
 
 size_t Print::printFloat(double number, uint8_t digits) 

cores/arduino/Print.h

@@ -27,18 +27,26 @@
 #include "Printable.h"
 
 #define DEC 10
-#define HEX 16
+#define HEX  0x0010
+#define HEX2 0x0210
+#define HEX4 0x0410
+#define HEX8 0x0810
 #define OCT 8
 #ifdef BIN // Prevent warnings if BIN is previously defined in "iotnx4.h" or similar
 #undef BIN
 #endif
-#define BIN 2
+#define BIN   0x0002
+#define BIN2  0x0202
+#define BIN4  0x0402
+#define BIN8  0x0802
+#define BIN16 0x1002
+#define BIN32 0x2002
 
 class Print
 {
   private:
     int write_error;
-    size_t printNumber(unsigned long, uint8_t);
+    size_t printNumber(unsigned long, bool, size_t, uint16_t);
     size_t printFloat(double, uint8_t);
   protected:
     void setWriteError(int err = 1) { write_error = err; }
@@ -66,10 +74,12 @@ class Print
     size_t print(const String &);
     size_t print(const char[]);
     size_t print(char);
+    size_t print(         char, int);
+    size_t print(  signed char, int = DEC);
     size_t print(unsigned char, int = DEC);
-    size_t print(int, int = DEC);
-    size_t print(unsigned int, int = DEC);
-    size_t print(long, int = DEC);
+    size_t print(          int, int = DEC);
+    size_t print(unsigned  int, int = DEC);
+    size_t print(         long, int = DEC);
     size_t print(unsigned long, int = DEC);
     size_t print(double, int = 2);
     size_t print(const Printable&);
@@ -78,10 +88,12 @@ class Print
     size_t println(const String &s);
     size_t println(const char[]);
     size_t println(char);
+    size_t println(         char, int);
+    size_t println(  signed char, int = DEC);
     size_t println(unsigned char, int = DEC);
-    size_t println(int, int = DEC);
-    size_t println(unsigned int, int = DEC);
-    size_t println(long, int = DEC);
+    size_t println(         int , int = DEC);
+    size_t println(unsigned int , int = DEC);
+    size_t println(         long, int = DEC);
     size_t println(unsigned long, int = DEC);
     size_t println(double, int = 2);
     size_t println(const Printable&);