Print.cpp

00001 /*
00002  Print.cpp - Base class that provides print() and println()
00003  Copyright (c) 2008 David A. Mellis.  All right reserved.
00004  
00005  This library is free software; you can redistribute it and/or
00006  modify it under the terms of the GNU Lesser General Public
00007  License as published by the Free Software Foundation; either
00008  version 2.1 of the License, or (at your option) any later version.
00009  
00010  This library is distributed in the hope that it will be useful,
00011  but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013  Lesser General Public License for more details.
00014  
00015  You should have received a copy of the GNU Lesser General Public
00016  License along with this library; if not, write to the Free Software
00017  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
00018  
00019  Modified 23 November 2006 by David A. Mellis
00020  Modified 03 August 2015 by Chuck Todd
00021  */
00022 
00023 #include <string>
00024 #include <cmath>
00025 
00026 #include "Print.h"
00027 
00028 // Public Methods //////////////////////////////////////////////////////////////
00029 
00030 /* default implementation: may be overridden */
00031 size_t Print::write(const uint8_t *buffer, size_t size)
00032 {
00033   size_t n = 0;
00034   while (size--) {
00035     if (write(*buffer++)) n++;
00036     else break;
00037   }
00038   return n;
00039 }
00040 
00041 size_t Print::print(const std::string &s)
00042 {
00043   return write(s.c_str(), s.length());
00044 }
00045 
00046 size_t Print::print(const char str[])
00047 {
00048   return write(str);
00049 }
00050 
00051 size_t Print::print(char c)
00052 {
00053   return write(c);
00054 }
00055 
00056 size_t Print::print(unsigned char b, int base)
00057 {
00058   return print((unsigned long) b, base);
00059 }
00060 
00061 size_t Print::print(int n, int base)
00062 {
00063   return print((long) n, base);
00064 }
00065 
00066 size_t Print::print(unsigned int n, int base)
00067 {
00068   return print((unsigned long) n, base);
00069 }
00070 
00071 size_t Print::print(long n, int base)
00072 {
00073   if (base == 0) {
00074     return write(n);
00075   } else if (base == 10) {
00076     if (n < 0) {
00077       int t = print('-');
00078       n = -n;
00079       return printNumber(n, 10) + t;
00080     }
00081     return printNumber(n, 10);
00082   } else {
00083     return printNumber(n, base);
00084   }
00085 }
00086 
00087 size_t Print::print(unsigned long n, int base)
00088 {
00089   if (base == 0) return write(n);
00090   else return printNumber(n, base);
00091 }
00092 
00093 size_t Print::print(double n, int digits)
00094 {
00095   return printFloat(n, digits);
00096 }
00097 size_t Print::println(void)
00098 {
00099   return write("\r\n");
00100 }
00101 
00102 size_t Print::println(const std::string &s)
00103 {
00104   size_t n = print(s);
00105   n += println();
00106   return n;
00107 }
00108 
00109 size_t Print::println(const char c[])
00110 {
00111   size_t n = print(c);
00112   n += println();
00113   return n;
00114 }
00115 
00116 size_t Print::println(char c)
00117 {
00118   size_t n = print(c);
00119   n += println();
00120   return n;
00121 }
00122 
00123 size_t Print::println(unsigned char b, int base)
00124 {
00125   size_t n = print(b, base);
00126   n += println();
00127   return n;
00128 }
00129 
00130 size_t Print::println(int num, int base)
00131 {
00132   size_t n = print(num, base);
00133   n += println();
00134   return n;
00135 }
00136 
00137 size_t Print::println(unsigned int num, int base)
00138 {
00139   size_t n = print(num, base);
00140   n += println();
00141   return n;
00142 }
00143 
00144 size_t Print::println(long num, int base)
00145 {
00146   size_t n = print(num, base);
00147   n += println();
00148   return n;
00149 }
00150 
00151 size_t Print::println(unsigned long num, int base)
00152 {
00153   size_t n = print(num, base);
00154   n += println();
00155   return n;
00156 }
00157 
00158 size_t Print::println(double num, int digits)
00159 {
00160   size_t n = print(num, digits);
00161   n += println();
00162   return n;
00163 }
00164 
00165 // Private Methods /////////////////////////////////////////////////////////////
00166 
00167 size_t Print::printNumber(unsigned long n, uint8_t base)
00168 {
00169   char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
00170   char *str = &buf[sizeof(buf) - 1];
00171 
00172   *str = '\0';
00173 
00174   // prevent crash if called with base == 1
00175   if (base < 2) base = 10;
00176 
00177   do {
00178     char c = n % base;
00179     n /= base;
00180 
00181     *--str = c < 10 ? c + '0' : c + 'A' - 10;
00182   } while(n);
00183 
00184   return write(str);
00185 }
00186 
00187 size_t Print::printFloat(double number, uint8_t digits) 
00188 { 
00189   size_t n = 0;
00190   
00191   if (isnan(number)) return print("nan");
00192   if (isinf(number)) return print("inf");
00193   if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
00194   if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
00195   
00196   // Handle negative numbers
00197   if (number < 0.0)
00198   {
00199      n += print('-');
00200      number = -number;
00201   }
00202 
00203   // Round correctly so that print(1.999, 2) prints as "2.00"
00204   double rounding = 0.5;
00205   for (uint8_t i=0; i<digits; ++i)
00206     rounding /= 10.0;
00207   
00208   number += rounding;
00209 
00210   // Extract the integer part of the number and print it
00211   unsigned long int_part = (unsigned long)number;
00212   double remainder = number - (double)int_part;
00213   n += print(int_part);
00214 
00215   // Print the decimal point, but only if there are digits beyond
00216   if (digits > 0) {
00217     n += print('.'); 
00218   }
00219 
00220   // Extract digits from the remainder one at a time
00221   while (digits-- > 0)
00222   {
00223     remainder *= 10.0;
00224     unsigned int toPrint = (unsigned int)(remainder);
00225     n += print(toPrint);
00226     remainder -= toPrint; 
00227   } 
00228   
00229   return n;
00230 }