Print enhancement to be reviewed

hardware/arduino/cores/arduino/Print.cpp

@@ -1,4 +1,4 @@
-/*
+/* 
  Print.cpp - Base class that provides print() and println()
  Copyright (c) 2008 David A. Mellis.  All right reserved.
 
@@ -17,15 +17,16 @@
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
  Modified 23 November 2006 by David A. Mellis
+ Modified 21 December 2914 by Michael Jonker. Enhanced with fieldControl parameter, most print methods defined through templates definitions in Print.h
  */
 
+#include "Print.h"
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
-#include "Arduino.h"
-
-#include "Print.h"
+//#include "Arduino.h"
 
 // Public Methods //////////////////////////////////////////////////////////////
 
@@ -51,162 +52,25 @@ size_t Print::print(const __FlashStringHelper *ifsh)
   return n;
 }
 
-size_t Print::print(const String &s)
-{
-  return write(s.c_str(), s.length());
-}
-
-size_t Print::print(const char str[])
-{
-  return write(str);
-}
-
-size_t Print::print(char c)
-{
-  return write(c);
-}
-
-size_t Print::print(unsigned char b, int base)
-{
-  return print((unsigned long) b, base);
-}
-
-size_t Print::print(int n, int base)
-{
-  return print((long) n, base);
-}
-
-size_t Print::print(unsigned int n, int base)
-{
-  return print((unsigned long) n, base);
-}
-
-size_t Print::print(long n, 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);
-  }
-}
-
-size_t Print::print(unsigned long n, int base)
-{
-  if (base == 0) return write(n);
-  else return printNumber(n, base);
-}
-
-size_t Print::print(double n, int digits)
-{
-  return printFloat(n, digits);
-}
-
-size_t Print::println(const __FlashStringHelper *ifsh)
-{
-  size_t n = print(ifsh);
-  n += println();
-  return n;
-}
-
-size_t Print::print(const Printable& x)
-{
-  return x.printTo(*this);
-}
-
-size_t Print::println(void)
-{
-  size_t n = print('\r');
-  n += print('\n');
-  return n;
-}
-
-size_t Print::println(const String &s)
-{
-  size_t n = print(s);
-  n += println();
-  return n;
-}
-
-size_t Print::println(const char c[])
-{
-  size_t n = print(c);
-  n += println();
-  return n;
-}
-
-size_t Print::println(char c)
-{
-  size_t n = print(c);
-  n += println();
-  return n;
-}
-
-size_t Print::println(unsigned char b, int base)
-{
-  size_t n = print(b, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(int num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(unsigned int num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(long num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(unsigned long num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(double num, int digits)
-{
-  size_t n = print(num, digits);
-  n += println();
-  return n;
-}
+// Private Methods /////////////////////////////////////////////////////////////
 
-size_t Print::println(const Printable& x)
+size_t Print::printNumber(unsigned long n, unsigned char base, unsigned char fieldControl)
 {
-  size_t n = print(x);
-  n += println();
-  return n;
-}
-
-// Private Methods /////////////////////////////////////////////////////////////
+  // special cases
+  if (base == 0) return write(n); // binary output
+  if (base == 1) base = 10;       // prevent infinite loop
 
-size_t Print::printNumber(unsigned long n, uint8_t base) {
-  char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
+  char buf[8 * sizeof(long) + 2]; // Assumes maximum of 8 characters per byte (binary radix ) + sign character plus + termination byte.
   char *str = &buf[sizeof(buf) - 1];
 
   *str = '\0';
 
-  // prevent crash if called with base == 1
-  if (base < 2) base = 10;
+  // sign handling
+  char sign;
+  if      ( (fieldControl&m_signedItem) and (signed long)n <0 ) { sign = '-';   n = -(signed long)n;} // negative signed value (always add '-' sign)
+  else if (!(fieldControl&m_forceSign)                        )   sign = '\0';                        // no forced sign
+  else if ( n==0 )                                                sign = ' ';                         // forced signed and     zero value (add a space )
+  else                                                            sign = '+';                         // forced signed and non-zero value (add a '+' sign)
 
   do {
     unsigned long m = n;
@@ -215,49 +79,60 @@ size_t Print::printNumber(unsigned long n, uint8_t base) {
     *--str = c < 10 ? c + '0' : c + 'A' - 10;
   } while(n);
 
+  // field size handling
+  int8_t fillLen = (fieldControl & m_fieldSizeMask) +1 - (&buf[sizeof(buf) - 1] - str);
+  if(sign != '\0' and (fieldControl&m_forceSign)==0 ) fillLen--;  // reduce the fill length if we add an unforced sign symbol
+
+  // defines the filling character
+  char fill = (fieldControl & m_fillZeroes) ? '0' : ' ';
+
+  // if there is a sign symbol, and we fill blanks, set the sign now and forget about it
+  if(sign != '\0' and !(fieldControl & m_fillZeroes) ) { *--str = sign; sign ='\0'; }
+
+  while (fillLen-- > 0) *--str = fill;
+
+  // if there is a sign symbol to be added
+  if(sign != '\0') *--str = sign;
+
   return write(str);
 }
 
-size_t Print::printFloat(double number, uint8_t digits) 
+
+size_t Print::printFloat(double number, uint8_t digits, uint8_t fieldControl) 
 { 
   size_t n = 0;
-
+  bool isNegative = number<0; // To handle negative numbers
+
   if (isnan(number)) return print("nan");
   if (isinf(number)) return print("inf");
   if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
   if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
 
-  // Handle negative numbers
-  if (number < 0.0)
-  {
-     n += print('-');
-     number = -number;
-  }
+  if (isNegative) number = -number;
 
   // Round correctly so that print(1.999, 2) prints as "2.00"
   double rounding = 0.5;
-  for (uint8_t i=0; i<digits; ++i)
-    rounding /= 10.0;
+  for (uint8_t i=0; i<digits; ++i) rounding /= 10.0;
 
   number += rounding;
 
   // Extract the integer part of the number and print it
   unsigned long int_part = (unsigned long)number;
   double remainder = number - (double)int_part;
-  n += print(int_part);
+
+  if (isNegative) int_part = ((unsigned long) -int_part); // fold sign back in because printNumber takes care of this
+  n += printNumber(int_part, Print::Radix_DEC, fieldControl|m_signedItem);
 
   // Print the decimal point, but only if there are digits beyond
-  if (digits > 0) {
-    n += print("."); 
-  }
+  if (digits > 0) n += write("."); 
 
   // Extract digits from the remainder one at a time
   while (digits-- > 0)
   {
     remainder *= 10.0;
-    int toPrint = int(remainder);
-    n += print(toPrint);
-    remainder -= toPrint; 
+    unsigned char toPrint = int(remainder);
+    n += write('0' + toPrint);
+    remainder -= toPrint;
   } 
 
   return n;