Merge pull request #7040 from dok-net/print64bit

Extend Print class for 64bit integers.

cores/esp8266/Print.cpp

@@ -146,35 +146,39 @@ size_t Print::print(unsigned int n, int base) {
 }
 
 size_t Print::print(long n, int base) {
-    if(base == 0) {
+    int t = 0;
-        return write(n);
+    if (base == 10 && n < 0) {
-    } else if(base == 10) {
+        t = print('-');
-        if(n < 0) {
+        n = -n;
-            int t = print('-');
-            n = -n;
-            return printNumber(n, 10) + t;
-        }
-        return printNumber(n, 10);
-    } else {
-        return printNumber(n, base);
     }
+    return printNumber(static_cast<unsigned long>(n), base) + t;
 }
 
 size_t Print::print(unsigned long n, int base) {
-    if(base == 0)
+    if (base == 0) {
         return write(n);
-    else
+    }
-        return printNumber(n, base);
+    return printNumber(n, base);
+}
+
+size_t Print::print(long long n, int base) {
+    int t = 0;
+    if (base == 10 && n < 0) {
+        t = print('-');
+        n = -n;
+    }
+    return printNumber(static_cast<unsigned long long>(n), base) + t;
+}
+
+size_t Print::print(unsigned long long n, int base) {
+    if (base == 0) {
+        return write(n);
+    }
+    return printNumber(n, base);
 }
 
 size_t Print::print(double n, int digits) {
-    return printFloat(n, digits);
+    return printNumber(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) {
@@ -185,89 +189,90 @@ size_t Print::println(void) {
     return print("\r\n");
 }
 
+size_t Print::println(const __FlashStringHelper* ifsh) {
+    return _println<const __FlashStringHelper*>(ifsh);
+}
+
 size_t Print::println(const String &s) {
-    size_t n = print(s);
+    return _println(s);
-    n += println();
-    return n;
 }
 
 size_t Print::println(const char c[]) {
-    size_t n = print(c);
+    return _println(c);
-    n += println();
-    return n;
 }
 
 size_t Print::println(char c) {
-    size_t n = print(c);
+    return _println(c);
-    n += println();
-    return n;
 }
 
 size_t Print::println(unsigned char b, int base) {
-    size_t n = print(b, base);
+    return _println(b, base);
-    n += println();
-    return n;
 }
 
 size_t Print::println(int num, int base) {
-    size_t n = print(num, base);
+    return _println(num, base);
-    n += println();
-    return n;
 }
 
 size_t Print::println(unsigned int num, int base) {
-    size_t n = print(num, base);
+    return _println(num, base);
-    n += println();
-    return n;
 }
 
 size_t Print::println(long num, int base) {
-    size_t n = print(num, base);
+    return _println(num, base);
-    n += println();
-    return n;
 }
 
 size_t Print::println(unsigned long num, int base) {
-    size_t n = print(num, base);
+    return _println(num, base);
-    n += println();
+}
-    return n;
+
+size_t Print::println(long long num, int base) {
+    return _println(num, base);
+}
+
+size_t Print::println(unsigned long long num, int base) {
+    return _println(num, base);
 }
 
 size_t Print::println(double num, int digits) {
-    size_t n = print(num, digits);
+    return _println(num, digits);
-    n += println();
-    return n;
 }
 
 size_t Print::println(const Printable& x) {
-    size_t n = print(x);
+    return _println<const Printable&>(x);
-    n += println();
-    return n;
 }
 
 // Private Methods /////////////////////////////////////////////////////////////
 
-size_t Print::printNumber(unsigned long n, uint8_t base) {
+template<typename T, typename... P> inline size_t Print::_println(T v, P... args)
-    char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
+{
-    char *str = &buf[sizeof(buf) - 1];
+    size_t n = print(v, args...);
+    n += println();
+    return n;
+};
+
+template<typename T> size_t Print::printNumber(T n, uint8_t base) {
+    char buf[8 * sizeof(n) + 1]; // Assumes 8-bit chars plus zero byte.
+    char* str = &buf[sizeof(buf) - 1];
 
     *str = '\0';
 
     // prevent crash if called with base == 1
-    if(base < 2)
+    if (base < 2) {
         base = 10;
+    }
 
     do {
-        unsigned long m = n;
+        auto m = n;
         n /= base;
         char c = m - base * n;
+
         *--str = c < 10 ? c + '0' : c + 'A' - 10;
-    } while(n);
+    } while (n);
 
     return write(str);
 }
 
-size_t Print::printFloat(double number, uint8_t digits) {
+template<> size_t Print::printNumber(double number, uint8_t digits) {
     char buf[40];
     return write(dtostrf(number, 0, digits, buf));
 }

cores/esp8266/Print.h

@@ -36,9 +36,9 @@
 class Print {
     private:
         int write_error;
-        size_t printNumber(unsigned long, uint8_t);
+        template<typename T> size_t printNumber(T n, uint8_t base);
-        size_t printFloat(double, uint8_t);
+        template<typename T, typename... P> inline size_t _println(T v, P... args);
-    protected:
+protected:
         void setWriteError(int err = 1) {
             write_error = err;
         }
@@ -71,6 +71,8 @@ class Print {
         inline size_t write(unsigned int t) { return write((uint8_t)t); }
         inline size_t write(long t) { return write((uint8_t)t); }
         inline size_t write(unsigned long t) { return write((uint8_t)t); }
+        inline size_t write(long long t) { return write((uint8_t)t); }
+        inline size_t write(unsigned long long t) { return write((uint8_t)t); }
         // Enable write(char) to fall through to write(uint8_t)
         inline size_t write(char c) { return write((uint8_t) c); }
         inline size_t write(int8_t c) { return write((uint8_t) c); }
@@ -86,6 +88,8 @@ class Print {
         size_t print(unsigned int, int = DEC);
         size_t print(long, int = DEC);
         size_t print(unsigned long, int = DEC);
+        size_t print(long long, int = DEC);
+        size_t print(unsigned long long, int = DEC);
         size_t print(double, int = 2);
         size_t print(const Printable&);
 
@@ -98,6 +102,8 @@ class Print {
         size_t println(unsigned int, int = DEC);
         size_t println(long, int = DEC);
         size_t println(unsigned long, int = DEC);
+        size_t println(long long, int = DEC);
+        size_t println(unsigned long long, int = DEC);
         size_t println(double, int = 2);
         size_t println(const Printable&);
         size_t println(void);
@@ -105,4 +111,6 @@ class Print {
         virtual void flush() { /* Empty implementation for backward compatibility */ }
 };
 
+template<> size_t Print::printNumber(double number, uint8_t digits);
+
 #endif