visus
/
teensy-sdfat
Vērot 1
Pievienot zvaigznīti 0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
58 Revīzijas
1 Atzars
Koks: abb5b5538f
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'abb5b5538f'
${ noResults }
teensy-sdfat/src/sdfat/common/PrintTemplates.h

501 rinda
11KB
Neapstrādāts Vainot Vēsture 

  1. /**

  2.  * Copyright (c) 2011-2019 Bill Greiman

  3.  * This file is part of the SdFat library for SD memory cards.

  4.  *

  5.  * MIT License

  6.  *

  7.  * Permission is hereby granted, free of charge, to any person obtaining a

  8.  * copy of this software and associated documentation files (the "Software"),

  9.  * to deal in the Software without restriction, including without limitation

  10.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,

  11.  * and/or sell copies of the Software, and to permit persons to whom the

  12.  * Software is furnished to do so, subject to the following conditions:

  13.  *

  14.  * The above copyright notice and this permission notice shall be included

  15.  * in all copies or substantial portions of the Software.

  16.  *

  17.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

  18.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  19.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  20.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  21.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

  22.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

  23.  * DEALINGS IN THE SOFTWARE.

  24.  */

  25. #ifndef PrintTemplates_h

  26. #define PrintTemplates_h

  27. /**

  28.  * \file

  29.  * \brief templates for printf

  30.  */

  31. #include <stdarg.h>

  32. #include "FmtNumber.h"

  33. /** test for digit */

  34. #define isDigit(d) ('0' <= (d) && (d) <= '9')

  35. /** control for supported floating formats */

  36. #define PRINTF_USE_FLOAT 2

  37. //-----------------------------------------------------------------------------

  38. /** Formatted print.

  39.  *

  40.  * \param[in] file destination file or device.

  41.  * \param[in] fmt format string.

  42.  * \param[in] ap argument list.

  43.  *

  44.  * \return number of character printed for success else a negative value.

  45.  */

  46. template<typename F>

  47. int vfprintf(F* file, const char *fmt, va_list ap) {

  48. #if PRINTF_USE_FLOAT

  49.   char buf[30];

  50.   double f;

  51. #else  // PRINTF_USE_FLOAT

  52.    char buf[15];

  53. #endif  // PRINTF_USE_FLOAT

  54.   char prefix[3];

  55.   unsigned base;

  56.   int n;

  57.   int nc = 0;

  58.   int nf;

  59.   int nz;

  60.   int prec;

  61.   int width;

  62.   size_t np;

  63.   size_t ns;

  64.   size_t nw;

  65.   long ln;

  66.   char c;

  67.   char plusSign;

  68.   char* ptr;  // end of string

  69.   char* str;  // start of string

  70.   bool altForm;

  71.   bool leftAdjust;

  72.   bool isLong;

  73.   bool zeroPad;

  74. 

  75.   while (true) {

  76.     const char* bgn = fmt;

  77.     while ((c = *fmt++) && c!= '%') {}

  78.     nw = fmt - bgn - 1;

  79.     if (nw) {

  80.       nc += nw;

  81.       if (nw != file->write(bgn, nw)) {

  82.         goto fail;

  83.       }

  84.     }

  85.     if (!c) break;

  86.     altForm = false;

  87.     leftAdjust = false;

  88.     np = 0;

  89.     nz = 0;

  90.     zeroPad = false;

  91.     plusSign = 0;

  92.     c = *fmt++;

  93. 

  94.     while (true) {

  95.       if (c == '-') {

  96.         leftAdjust = true;

  97.       } else if (c == '+') {

  98.         plusSign = '+';

  99.       } else if (c == ' ') {

  100.         if (plusSign == 0) {

  101.           plusSign = ' ';

  102.         }

  103.       } else if (c == '0') {

  104.         zeroPad = true;

  105.       } else if (c == '#') {

  106.         altForm = true;

  107.       } else {

  108.         break;

  109.       }

  110.       c = *fmt++;

  111.     }

  112. 

  113.     width = 0;

  114. 	  if (isDigit(c)) {

  115. 		  while(isDigit(c)) {

  116. 		    width = 10 * width + c - '0';

  117. 		    c = *fmt++;

  118. 		  }

  119. 	  } else if (c == '*') {

  120. 		  width = va_arg(ap, int);

  121. 		  c = *fmt++;

  122. 		  if (width < 0) {

  123. 		    leftAdjust = true;

  124. 		    width = -width;

  125. 		  }

  126. 	  }

  127.     if (leftAdjust) {

  128.       zeroPad = false;

  129.     }

  130. 

  131.     prec = -1;

  132. 	  if (c == '.') {

  133.       zeroPad = false;

  134. 		  prec = 0;

  135. 		  c = *fmt++;

  136. 		  if (isDigit(c)) {

  137. 		    while(isDigit(c)) {

  138. 			    prec = 10 * prec + c - '0';

  139. 			    c = *fmt++;

  140. 		    }

  141. 		  } else if (c == '*') {

  142. 		    prec = va_arg(ap, int);

  143. 		    c = *fmt++;

  144. 		  }

  145. 	  }

  146. 

  147.     isLong = false;

  148.     if (c == 'l' || c =='L') {

  149.       isLong = true;

  150.       c = *fmt++;

  151.     }

  152. 

  153.     if (!c) break;

  154. 

  155.     str = buf + sizeof(buf);

  156.     ptr = str;

  157.     switch(c) {

  158.       case 'c':

  159.         *--str = va_arg(ap, int);

  160.         break;

  161. 

  162.       case 's':

  163.         str = va_arg(ap, char *);

  164.         if (!str) {

  165.           str = (char*)"(null)";

  166.         }

  167.         ns = strlen(str);

  168.         ptr = str + (prec >= 0 && (size_t)prec < ns ? prec : ns);

  169.         break;

  170. 

  171.       case 'd':

  172.       case 'i':

  173.         ln = isLong ? va_arg(ap, long) : va_arg(ap, int);

  174.         if (prec || ln) {

  175.           if (ln < 0) {

  176.             prefix[np++] = '-';

  177.             ln = -ln;

  178.           } else if (plusSign) {

  179.             prefix[np++] = plusSign;

  180.           }

  181.           str = fmtUnsigned(str, ln, 10, true);

  182.           nz = prec + str - ptr;

  183.         }

  184.         break;

  185. 

  186. #if PRINTF_USE_FLOAT > 1

  187.       case 'e':

  188.       case 'E':

  189.       case 'f':

  190.       case 'F':

  191.         f = va_arg(ap, double);

  192.         if (f < 0) {

  193.           f = -f;

  194.           prefix[np++] = '-';

  195.         } else if (plusSign) {

  196.           prefix[np++] = plusSign;

  197.         }

  198.         str = fmtDouble(str, f, prec < 0 ? 6 : prec, altForm, c);

  199.         break;

  200. #elif PRINTF_USE_FLOAT > 0

  201.       case 'f':

  202.       case 'F':

  203.         f = va_arg(ap, double);

  204.         if (f < 0) {

  205.           f = -f;

  206.           prefix[np++] = '-';

  207.         } else if (plusSign) {

  208.           prefix[np++] = plusSign;

  209.         }

  210.         str = fmtDouble(str, f, prec < 0 ? 6 : prec, altForm);

  211.         break;

  212. #endif  // PRINTF_USE_FLOAT

  213. 

  214.       case 'o':

  215.         base = 8;

  216.         goto printUnsigned;

  217. 

  218.       case 'u':

  219.         base = 10;

  220.         altForm = false;

  221.         goto printUnsigned;

  222. 

  223.       case 'x':

  224.       case 'X':

  225.         base = 16;

  226.         goto printUnsigned;

  227. 

  228.       printUnsigned:

  229.         ln = isLong ? va_arg(ap, long) : va_arg(ap, int);

  230.         if (prec || ln) {

  231.           str = fmtUnsigned(str, ln, base, c == 'X');

  232.           nz = prec + str - ptr;

  233.         }

  234.         if (altForm && ln) {

  235.           if (c == 'o') {

  236.             *--str = '0';

  237.           } else {

  238.             prefix[np++] = '0';

  239.             prefix[np++] = c;

  240.           }

  241.         }

  242.         break;

  243. 

  244.       default:

  245.         *--str = c;

  246.         break;

  247.     }

  248.     ns = (ptr - str);

  249.     if (nz < 0) nz = 0;

  250.     n = ns + np + nz;

  251.     if (width < n) {

  252.       nc += n;

  253.       nf = 0;

  254.     } else {

  255.       nc += width;

  256.       if (zeroPad) {

  257.         nz += width - n;

  258.         nf = 0;

  259.       } else {

  260.         nf = width - n;

  261.       }

  262.     }

  263.     // Do right blank padding.

  264.     if (!leftAdjust) {

  265.       for (; nf > 0; nf--) {

  266.         if (1 != file->write(' ')) {

  267.           goto fail;

  268.         }

  269.       }

  270.     }

  271.     // Don't call write if no prefix.

  272.     if (np && np != file->write(prefix, np)) {

  273.       goto fail;

  274.     }

  275.     // Do zero padding.

  276.     for (; nz > 0; nz--) {

  277.       if (1 != file->write('0')) {

  278.         goto fail;

  279.       }

  280.     }

  281.     // Main item.

  282.     if (ns != file->write(str, ns)) {

  283.       goto fail;

  284.     }

  285.     // Right blank padding.

  286.     for (; nf > 0; nf--) {

  287.       if (1 != file->write(' ')) {

  288.         goto fail;

  289.       }

  290.     }

  291. 	}

  292.   return nc;

  293.  fail:

  294.   return -1;

  295. }

  296. //-----------------------------------------------------------------------------

  297. /** Formatted print.

  298.  *

  299.  * \param[in] file destination file or device.

  300.  * \param[in] fmt format string.

  301.  *

  302.  * \return number of character printed for success else a negative value.

  303.  */

  304. template<typename T>

  305. int fprintf(T *file, const char* fmt, ...) {

  306.   va_list ap;

  307. 	va_start(ap, fmt);

  308.   int rtn = vfprintf(file, fmt, ap);

  309.   va_end(ap);

  310.   return rtn;

  311. }

  312. //-----------------------------------------------------------------------------

  313. /** Minimal formatted print.

  314.  *

  315.  * \param[in] file destination file or device.

  316.  * \param[in] fmt format string.

  317.  * \param[in] ap argument list.

  318.  *

  319.  * \return number of character printed for success else a negative value.

  320.  */

  321. template<typename F>

  322. int vmprintf(F* file, const char *fmt, va_list ap) {

  323.   char buf[15];

  324.   char* ptr;

  325.   char* str;

  326.   bool isLong;

  327.   char c;

  328.   int nc = 0;

  329.   size_t ns;

  330.   long n;

  331. 

  332.   while (true) {

  333.     const char* bgn = fmt;

  334.     while ((c = *fmt++) && c!= '%') {}

  335.     ns = fmt - bgn - 1;

  336.     if (ns) {

  337.       nc += file->write(bgn, ns);

  338.     }

  339.     if (!c) {

  340.       break;

  341.     }

  342.     c = *fmt++;

  343.     if (c == 'l') {

  344.       isLong = true;

  345.       c = *fmt++;

  346.     } else {

  347.       isLong = false;

  348.     }

  349.     if (!c) {

  350.       break;

  351.     }

  352.     ptr = str = buf + sizeof(buf);

  353.     switch (c) {

  354.       case 'c':

  355.         *--str = va_arg(ap, int);

  356.         break;

  357. 

  358.       case 's':

  359.         str = va_arg(ap, char*);

  360.         ptr = str ? str + strlen(str) : nullptr;

  361.         break;

  362. 

  363.       case 'd':

  364.         n = isLong ? va_arg(ap, long) : va_arg(ap, int);

  365.         str = fmtSigned(str, n, 10, true);

  366.         break;

  367. 

  368.       case 'u':

  369.         n = isLong ? va_arg(ap, long) : va_arg(ap, int);

  370.         str = fmtUnsigned(str, n, 10, true);

  371.         break;

  372. 

  373.       case 'x':

  374.       case 'X':

  375.         n = isLong ? va_arg(ap, long) : va_arg(ap, int);

  376.         str = fmtUnsigned(str, n, 16, c == 'X');

  377.         break;

  378. 

  379.       default:

  380.         *--str = c;;

  381.         break;

  382.     }

  383.     ns = ptr - str;

  384.     nc += file->write(str, ns);

  385.   }

  386.   return nc;

  387. }

  388. //-----------------------------------------------------------------------------

  389. /** Minimal formatted print.

  390.  *

  391.  * \param[in] file destination file or device.

  392.  * \param[in] fmt format string.

  393.  *

  394.  * \return number of character printed for success else a negative value.

  395.  */

  396. template<typename T>

  397. int mprintf(T *file, const char* fmt, ...) {

  398.   va_list ap;

  399. 	va_start(ap, fmt);

  400.   int rtn = vmprintf(file, fmt, ap);

  401.   va_end(ap);

  402.   return rtn;

  403. }

  404. //------------------------------------------------------------------------------

  405. #ifdef __AVR__

  406. /** Minimal formatted print.

  407.  *

  408.  * \param[in] file destination file or device.

  409.  * \param[in] ifsh format string using F() macro.

  410.  * \param[in] ap argument list.

  411.  *

  412.  * \return number of character printed for success else a negative value.

  413.  */

  414. template<typename F>

  415. int vmprintf(F file, const __FlashStringHelper *ifsh, va_list ap) {

  416.   bool isLong;

  417.   char buf[15];

  418.   char c;

  419.   char* ptr;

  420.   char* str;

  421.   size_t ns;

  422.   int nc = 0;

  423.   long n;

  424. 

  425.   PGM_P fmt = reinterpret_cast<PGM_P>(ifsh);

  426.   while (true) {

  427. 	  while ((c = pgm_read_byte(fmt++)) && c != '%') {

  428. 		  nc += file->write(c);

  429.     }

  430.     if (!c) {

  431.       break;

  432.     }

  433.     c = pgm_read_byte(fmt++);

  434.     if (c == 'l') {

  435.       isLong = true;

  436.       c = pgm_read_byte(fmt++);

  437.     } else {

  438.       isLong = false;

  439.     }

  440.     if (!c) {

  441.       break;

  442.     }

  443.     ptr = str = buf + sizeof(buf);

  444.     switch (c) {

  445.       case 'c':

  446.         *--str = va_arg(ap, int);

  447.         break;

  448. 

  449.       case 's':

  450.         str = va_arg(ap, char*);

  451.         ptr = str ? str + strlen(str) : nullptr;

  452.         break;

  453. 

  454.       case 'd':

  455.         n = isLong ? va_arg(ap, long) : va_arg(ap, int);

  456.         str = fmtSigned(str, n, 10, true);

  457.         break;

  458. 

  459.       case 'u':

  460.         n = isLong ? va_arg(ap, long) : va_arg(ap, int);

  461.         str = fmtUnsigned(str, n, 10, true);

  462.         break;

  463. 

  464.       case 'x':

  465.       case 'X':

  466.         n = isLong ? va_arg(ap, long) : va_arg(ap, int);

  467.         str = fmtUnsigned(str, n, 16, c == 'X');

  468.         break;

  469. 

  470.       default:

  471.         *--str = c;;

  472.         break;

  473.     }

  474.     ns = ptr - str;

  475.     nc += file->write(str, ns);

  476.   }

  477.   return nc;

  478. }

  479. #endif  // __AVR__

  480. //-----------------------------------------------------------------------------

  481. /** Minimal formatted print.

  482.  *

  483.  * \param[in] file destination file or device.

  484.  * \param[in] ifsh format string using F() macro.

  485.  *

  486.  * \return number of character printed for success else a negative value.

  487.  */

  488. template<typename F>

  489. int mprintf(F* file, const __FlashStringHelper *ifsh, ...) {

  490.   va_list ap;

  491. 	va_start(ap, ifsh);

  492. #ifdef __AVR__

  493.   int rtn = vmprintf(file, ifsh, ap);

  494. #else  // __AVR__

  495.   int rtn = vmprintf(file, (const char*)ifsh, ap);

  496. #endif  // __AVR__

  497.   va_end(ap);

  498.   return rtn;

  499. }

  500. #endif  // PrintTemplates_h