CrystalSpace

Public API Reference

csutil/formatter.h

Go to the documentation of this file.
00001 /*
00002     Copyright (C) 2005 by Frank Richter
00003 
00004     This library is free software; you can redistribute it and/or
00005     modify it under the terms of the GNU Library General Public
00006     License as published by the Free Software Foundation; either
00007     version 2 of the License, or (at your option) any later version.
00008 
00009     This library is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012     Library General Public License for more details.
00013 
00014     You should have received a copy of the GNU Library General Public
00015     License along with this library; if not, write to the Free
00016     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00017 */
00018 
00019 #ifndef __CS_CSUTIL_FORMATTER_H__
00020 #define __CS_CSUTIL_FORMATTER_H__
00021 
00027 #include "cssysdef.h"
00028 #include "csgeom/math.h"
00029 #include "csutil/csuctransform.h"
00030 #include "csutil/dirtyaccessarray.h"
00031 #include "csutil/util.h"
00032 
00033 // MinGW uses MS CRT, but it can't grok long double.  VC doesn't have long
00034 // double and CRT printf() doesn't know %Lf, %Lg, or %Le.
00035 #if defined(__MINGW32__) || defined(CS_COMPILER_MSVC)
00036 #define CS_FORMATTER_NO_LONG_DOUBLE_FORMAT
00037 #endif
00038 // MinGWs <inttypes.h> uses the MS-specific 'I64' format specifier in its
00039 // PR?64 macros. Enable support for I64 so the PR?64 macros can be used.
00040 #if defined(__MINGW32__) || defined(CS_COMPILER_MSVC)
00041 #define CS_FORMATTER_PROVIDE_I64
00042 #endif
00043 
00071 template <class T>
00072 class csFmtDefaultReader
00073 {
00074   const T* str;
00075   const T* const startStr;
00076   size_t len;
00077   const size_t startLen;
00078 public:
00080   csFmtDefaultReader (const T* string, size_t length) : startStr (string), 
00081     startLen (length) { Reset(); }
00083   bool GetNext (utf32_char& ch) 
00084   {
00085     int n = csUnicodeTransform::Decode (str, len, ch);
00086     if (n == 0) return false;
00087     str += (size_t)n;
00088     len -= (size_t)n;
00089     return true;
00090   }
00092   void Reset() { str = startStr; len = startLen; }
00094   size_t GetPosition() const { return str - startStr; }
00095 };
00096 
00097 
00103 template <class T>
00104 class csFmtDefaultWriter
00105 {
00106   T* dest;
00107   size_t size;
00108   size_t total;
00109 public:
00111   csFmtDefaultWriter (T* dest, size_t size) : dest (dest), size (size), 
00112     total (0) {}
00114   void Put (utf32_char ch) 
00115   { 
00116     size_t n = (size_t)csUnicodeTransform::Encode (ch, dest, size);
00117     total += n;
00118     n = csMin (size, n);
00119     dest += n;
00120     size -= n;
00121   }
00126   size_t GetTotal() const { return total; }
00127 };
00128 
00134 template <class Twriter, class Treader>
00135 class csPrintfFormatter
00136 {
00137   class Scratch : public csDirtyAccessArray<utf32_char>
00138   {
00139   public:
00140     void WriteTo (Twriter& writer, size_t offset = 0, size_t len = (size_t)~0)
00141     {
00142       const size_t n = MIN (len, Length());
00143       for (size_t i = offset; i < n; i++) writer.Put (Get (i));
00144     }
00145   };
00146   Scratch scratch;
00147 
00149   struct FmtParam
00150   {
00151     union
00152     {
00153       int vInt;
00154       void* vPtr;
00155       long vLong;
00156       longlong vLL;
00157       double vDbl;
00158       long double vLongDbl;
00159       size_t vSzT;
00160       ptrdiff_t vPDT;
00161       intmax_t vIMT;
00162     };
00163   };
00164   enum Conversion
00165   {
00166     convBogus = 0,
00167     convNone,
00168     convInt,
00169     convOctal,
00170     convUint,
00171     convHex,
00172     convFloatFix,
00173     convFloatExp,
00174     convFloatGeneral,
00175     convFloatHex,
00176     convChar,
00177     convStr,
00178     convPtr,
00179     convGetNum,
00180     convErrno
00181   };
00182   enum Type
00183   {
00184     typeNone = 0,
00185     typeLongLong = 3, // The reason for that: see I64 support
00186     typeChar,
00187     typeShort,
00188     typeIntmax,
00189     typeLong,
00190     typePtrDiffT,
00191     typeSizeT
00192   };
00194   struct FormatSpec
00195   {
00196     size_t copyRun;
00197     size_t fmtSkip;
00198 
00199     int paramIdx;
00200     bool leftJustify;
00201     bool plusSign;
00202     bool spacePrefix;
00203     bool basePrefix;
00204     bool padZero;
00205     int width;
00206     int precision;
00207     Conversion conversion;
00208     bool uppercase;
00209     Type type;
00210 
00211     FormatSpec() { Reset(); }
00212     void Reset () 
00213     { 
00214       memset (this, 0, sizeof (*this)); 
00215       precision = -1;
00216     }
00217   };
00218   csArray<FormatSpec> formatSpecs;
00219   csArray<FmtParam> params;
00220   Treader& reader;
00221 
00222   struct SpecParseState
00223   {
00224     utf32_char ch;
00225     FormatSpec currentFormat;
00226     size_t charRun;
00227     int paramIdx;
00228     size_t fmtBegin;
00229 
00230     SpecParseState() : paramIdx(0) {}
00231     void Reset()
00232     {
00233       charRun = 0;
00234       currentFormat.Reset();
00235     }
00236   };
00237 
00238   bool ParseFlag (SpecParseState& state)
00239   {
00240     switch (state.ch)
00241     {
00242       case '-':
00243         {
00244           state.currentFormat.leftJustify = true;
00245           return true;
00246         }
00247       case '+':
00248         {
00249           state.currentFormat.plusSign = true;
00250           return true;
00251         }
00252       case ' ':
00253         {
00254           state.currentFormat.spacePrefix = true;
00255           return true;
00256         }
00257       case '#':
00258         {
00259           state.currentFormat.basePrefix = true;
00260           return true;
00261         }
00262       case '0':
00263         {
00264           state.currentFormat.padZero = true;
00265           return true;
00266         }
00267       case '\'':
00268         {
00269           return true;
00270         }
00271     }
00272     return false;
00273   }
00274   
00275   bool ParseType (SpecParseState& state)
00276   {
00277     switch (state.ch)
00278     {
00279       case 'h':
00280         {
00281           if (state.currentFormat.type == typeNone)
00282             state.currentFormat.type = typeShort;
00283           else if (state.currentFormat.type == typeShort)
00284             state.currentFormat.type = typeChar;
00285           else
00286             return false;
00287           return true;
00288         }
00289       case 'j':
00290         {
00291           if (state.currentFormat.type == typeNone)
00292             state.currentFormat.type = typeIntmax;
00293           else
00294             return false;
00295           return true;
00296         }
00297       case 'l':
00298         {
00299           if (state.currentFormat.type == typeNone)
00300             state.currentFormat.type = typeLong;
00301           else if (state.currentFormat.type == typeLong)
00302             state.currentFormat.type = typeLongLong;
00303           else
00304             return false;
00305           return true;
00306         }
00307       case 'L':
00308       case 'q':
00309         {
00310           if (state.currentFormat.type == typeNone)
00311             state.currentFormat.type = typeLongLong;
00312           else
00313             return false;
00314           return true;
00315         }
00316       case 't':
00317         {
00318           if (state.currentFormat.type == typeNone)
00319             state.currentFormat.type = typePtrDiffT;
00320           else
00321             return false;
00322           return true;
00323         }
00324       case 'z':
00325         {
00326           if (state.currentFormat.type == typeNone)
00327             state.currentFormat.type = typeSizeT;
00328           else
00329             return false;
00330           return true;
00331         }
00332 #ifdef CS_FORMATTER_PROVIDE_I64
00333       case 'I':
00334       case '6':
00335       case '4':
00336         {
00337           static const utf32_char I64spec[3] = {'I', '6', '4'};
00338           const int I64specStartType = typeLongLong - 2;
00339           if (state.ch == I64spec[0])
00340             state.currentFormat.type = (Type)I64specStartType;
00341           else
00342           {
00343             state.currentFormat.type = (Type)(state.currentFormat.type + 1);
00344             if (state.ch != 
00345               I64spec[state.currentFormat.type - I64specStartType])
00346               return false;
00347           }
00348           return true;
00349         }
00350         break;
00351 #endif
00352     }
00353     return false;
00354   }
00355 
00356   bool ParseConversion (SpecParseState& state)
00357   {
00358 #ifdef CS_FORMATTER_PROVIDE_I64
00359     // Check to detect incomplete I64 specifiers
00360     const int I64specStartType = typeLongLong - 2;
00361     if ((state.currentFormat.type >= I64specStartType)
00362       && (state.currentFormat.type < typeLongLong))
00363       return false;
00364 #endif
00365     switch (state.ch)
00366     {
00367       case '%':
00368         {
00369           const size_t fmtLen = (reader.GetPosition() - 1) - state.fmtBegin;
00370           if (fmtLen == 1)
00371           {
00372             state.currentFormat.conversion = convNone;
00373             state.fmtBegin++;
00374             state.currentFormat.copyRun++;
00375             return true;
00376           }
00377           break;
00378         }
00379       case 'd':
00380       case 'i':
00381         {
00382           state.currentFormat.conversion = convInt;
00383           return true;
00384         }
00385       case 'o':
00386         {
00387           state.currentFormat.conversion = convOctal;
00388           return true;
00389         }
00390       case 'u':
00391         {
00392           state.currentFormat.conversion = convUint;
00393           return true;
00394         }
00395       case 'x':
00396       case 'X':
00397         {
00398           state.currentFormat.conversion = convHex;
00399           state.currentFormat.uppercase = (state.ch == 'X');
00400           return true;
00401         }
00402       case 'f':
00403         {
00404           state.currentFormat.conversion = convFloatFix;
00405           return true;
00406         }
00407       case 'e':
00408       case 'E':
00409         {
00410           state.currentFormat.conversion = convFloatExp;
00411           state.currentFormat.uppercase = (state.ch == 'E');
00412           return true;
00413         }
00414       case 'g':
00415       case 'G':
00416         {
00417           state.currentFormat.conversion = convFloatGeneral;
00418           state.currentFormat.uppercase = (state.ch == 'G');
00419           return true;
00420         }
00421       case 'a':
00422       case 'A':
00423         {
00424           state.currentFormat.conversion = convFloatHex;
00425           state.currentFormat.uppercase = (state.ch == 'A');
00426           return true;
00427         }
00428       case 'c':
00429         {
00430           state.currentFormat.conversion = convChar;
00431           return true;
00432         }
00433       case 'C':
00434         {
00435           state.currentFormat.conversion = convChar;
00436           state.currentFormat.type = typeLong;
00437           return true;
00438         }
00439       case 's':
00440         {
00441           state.currentFormat.conversion = convStr;
00442           return true;
00443         }
00444       case 'S':
00445         {
00446           state.currentFormat.conversion = convStr;
00447           state.currentFormat.type = typeLong;
00448           return true;
00449         }
00450       case 'p':
00451         {
00452           state.currentFormat.conversion = convPtr;
00453           return true;
00454         }
00455       case 'n':
00456         {
00457           state.currentFormat.conversion = convGetNum;
00458           return true;
00459         }
00460       case 'm':
00461         {
00462           state.currentFormat.conversion = convErrno;
00463           return true;
00464         }
00465     }
00466     return false;
00467   }
00468 
00469   void ParseSpec ()
00470   {
00471     enum {
00472       scanFormat,
00473       formatParamFlagsWidthPrecTypeConversion,
00474       formatFlagsWidthPrecTypeConversion,
00475       formatParamWidth,
00476       formatDotPrecTypeConversion,
00477       formatPrecTypeConversion,
00478       formatTypeConversion
00479     } parseState = scanFormat;
00480 
00481     // Collect positions of state specifiers from format string
00482     SpecParseState state;
00483     state.Reset();
00484     while (reader.GetNext (state.ch))
00485     {
00486       switch (parseState)
00487       {
00488         // Note: all falling through in this switch() is intentional.
00489         case scanFormat:
00490           {
00491             // Check for a % sign
00492             if (state.ch == '%')
00493             {
00494               parseState = formatParamFlagsWidthPrecTypeConversion;
00495               state.fmtBegin = reader.GetPosition() - 1;
00496               state.currentFormat.copyRun = state.charRun;
00497             }
00498             else
00499               state.charRun++;
00500           }
00501           break;
00502         case formatParamFlagsWidthPrecTypeConversion:
00503           // Check for start of width or param index
00504           if ((state.ch >= '1') && (state.ch <= '9'))
00505           {
00506             state.currentFormat.width = state.ch - '0';
00507             parseState = formatParamWidth;
00508             break;
00509           }
00510           // Check for '*' (fetch width from args)
00511           else if (state.ch == '*')
00512           {
00513             state.currentFormat.width = -2;
00514             parseState = formatDotPrecTypeConversion;
00515             break;
00516           }
00517           // Param delimiter
00518           else if (state.ch == '$')
00519           {
00520             // \todo fix for empty param
00521             parseState = formatFlagsWidthPrecTypeConversion;
00522             break;
00523           }
00524         case formatParamWidth:
00525           if (parseState == formatParamWidth) // != can occur due fallthrough
00526           {
00527             // Subsequent digits width or param index
00528             if ((state.ch >= '0') && (state.ch <= '9'))
00529             {
00530               state.currentFormat.width *= 10;
00531               state.currentFormat.width += state.ch - '0';
00532               break;
00533             }
00534             // Param delimiter
00535             else if (state.ch == '$')
00536             {
00537               state.paramIdx = state.currentFormat.width - 1;
00538               state.currentFormat.width = 0;
00539               parseState = formatFlagsWidthPrecTypeConversion;
00540               break;
00541             }
00542           }
00543         case formatFlagsWidthPrecTypeConversion:
00544           // Check for start of width
00545           if ((state.ch >= '1') && (state.ch <= '9'))
00546           {
00547             state.currentFormat.width *= 10;
00548             state.currentFormat.width += state.ch - '0';
00549             parseState = formatParamWidth;
00550             break;
00551           }
00552           // Check for '*' (fetch width from args)
00553           else if (state.ch == '*')
00554           {
00555             state.currentFormat.width = -2;
00556             parseState = formatDotPrecTypeConversion;
00557             break;
00558           }
00559           // Check for flags (0, -, ...)
00560           else if (ParseFlag (state))
00561           {
00562             parseState = formatFlagsWidthPrecTypeConversion;
00563             break;
00564           }
00565         case formatDotPrecTypeConversion:
00566           // Check for precision delimiter
00567           if (state.ch == '.')
00568           {
00569             parseState = formatPrecTypeConversion;
00570             state.currentFormat.precision = 0;
00571             break;
00572           }
00573         case formatPrecTypeConversion:
00574           // Precision digits
00575           if ((state.ch >= '0') && (state.ch <= '9'))
00576           {
00577             state.currentFormat.precision *= 10;
00578             state.currentFormat.precision += state.ch - '0';
00579             break;
00580           }
00581           // Check for '*' (fetch precision from args)
00582           else if (state.ch == '*')
00583           {
00584             state.currentFormat.precision = -2;
00585             parseState = formatTypeConversion;
00586             break;
00587           }
00588           // Check for param type modifier (l, h, ...)
00589         case formatTypeConversion:
00590           if (ParseType (state))
00591           {
00592             parseState = formatTypeConversion;
00593             break;
00594           }
00595           // Check actual conversion (s, d, ...)
00596           else if (ParseConversion (state))
00597           {
00598             state.currentFormat.fmtSkip =
00599               reader.GetPosition() - state.fmtBegin;
00600             if (state.currentFormat.conversion != convNone)
00601               state.currentFormat.paramIdx = state.paramIdx++;
00602             formatSpecs.Push (state.currentFormat);
00603 
00604             state.Reset();
00605           }
00606           else
00607           {
00608             state.charRun += reader.GetPosition() - state.fmtBegin;
00609             state.currentFormat.Reset();
00610           }
00611           parseState = scanFormat;
00612           break;
00613       }
00614     }
00615   }
00616 
00618   void FetchArgs (va_list args)
00619   {
00620     size_t i;
00621     // Determine order of params
00622     csArray<FormatSpec*> paramOrder;
00623     paramOrder.SetCapacity (formatSpecs.Length());
00624     for (i = 0; i < formatSpecs.Length(); i++)
00625     {
00626       FormatSpec& currentFormat = formatSpecs[i];
00627       if (currentFormat.conversion == convNone) continue;
00628       if (paramOrder.Length() <= (size_t)currentFormat.paramIdx)
00629         paramOrder.SetLength (currentFormat.paramIdx + 1, 0);
00630       paramOrder[currentFormat.paramIdx] = &currentFormat;
00631     }
00632     // Fetch params from stack in order, store at correct place in params array
00633     for (i = 0; i < paramOrder.Length(); i++)
00634     {
00635       FmtParam& param = params.GetExtend (i);
00636       FormatSpec* fmtPtr = paramOrder[i];
00637       if (fmtPtr == 0) 
00638       {
00639         // Can just guess here...
00640         param.vInt = va_arg (args, int);
00641         continue;
00642       }
00643       FormatSpec& currentFormat = *fmtPtr;
00644 
00645       if (currentFormat.width == -2)
00646       {
00647         currentFormat.width = va_arg (args, int);
00648         if (currentFormat.width < 0)
00649         {
00650           currentFormat.width = -currentFormat.width;
00651           currentFormat.leftJustify = true;
00652         }
00653       }
00654       if (currentFormat.precision == -2)
00655       {
00656         int v = va_arg (args, int);
00657         if (v >= 0) 
00658           currentFormat.precision = v;
00659         else
00660           currentFormat.precision = -1;
00661       }
00662       switch (currentFormat.conversion)
00663       {
00664         case convInt:
00665         case convOctal:
00666         case convUint:
00667         case convHex:
00668         default:
00669           {
00670             switch (currentFormat.type)
00671             {
00672               case typeIntmax:
00673                 param.vIMT = va_arg (args, intmax_t);
00674                 break;
00675               case typeLong:
00676                 param.vLong = va_arg (args, long);
00677                 break;
00678               case typeLongLong:
00679                 param.vLL = va_arg (args, longlong);
00680                 break;
00681               case typePtrDiffT:
00682                 param.vPDT = va_arg (args, ptrdiff_t);
00683                 break;
00684               case typeSizeT:
00685                 param.vSzT = va_arg (args, size_t);
00686                 break;
00687               case typeShort:
00688                 param.vInt = (short)(va_arg (args, int));
00689                 break;
00690               case typeChar:
00691                 param.vInt = (char)(va_arg (args, int));
00692                 break;
00693               default:
00694                 param.vInt = va_arg (args, int);
00695                 break;
00696             }
00697           }
00698           break;
00699         case convErrno:
00700           param.vInt = errno;
00701           break;
00702         case convChar:
00703           if (currentFormat.type == typeLong)
00704           {
00705             param.vInt = (wint_t)(va_arg (args, int));
00706           }
00707           else
00708           {
00709             param.vInt = (unsigned char)(va_arg (args, int));
00710           }
00711           break;
00712         case convFloatFix:
00713         case convFloatExp:
00714         case convFloatGeneral:
00715         case convFloatHex:
00716           if (currentFormat.type == typeLongLong)
00717           {
00718             param.vLongDbl = va_arg (args, long double);
00719           }
00720           else
00721           {
00722             param.vDbl = va_arg (args, double);
00723           }
00724           break;
00725         case convStr:
00726         case convPtr:
00727         case convGetNum:
00728           param.vPtr = va_arg (args, void*);
00729           break;
00730         case convNone:
00731           break;
00732       }
00733     }
00734   }
00735 
00736   void Init (va_list args)
00737   {
00738     ParseSpec ();
00739     FetchArgs (args);
00740   }
00741 
00743   template<class T>
00744   void OutputString (Twriter& writer, const FormatSpec& currentFormat,
00745     const T* stringPtr)
00746   {
00747     if (stringPtr == 0)
00748     {
00749       OutputString (writer, currentFormat, (utf8_char*)"(null)");
00750       return;
00751     }
00752 
00753     size_t scratchOffs = scratch.Length();
00754     size_t len = 0;
00755     {
00756       const T* ptr = stringPtr;
00757       while (*ptr++ != 0) len++;
00758     }
00759     if (currentFormat.precision > -1)
00760       len = MIN(len, (size_t)currentFormat.precision);
00761     while (len > 0)
00762     {
00763       utf32_char ch;
00764       int n = csUnicodeTransform::Decode (stringPtr, len, ch);
00765       scratch.Push (ch);
00766       stringPtr += n;
00767       len -= (size_t)n;
00768     }
00769     if (!currentFormat.leftJustify 
00770       && ((size_t)currentFormat.width > (scratch.Length() - scratchOffs)))
00771     {
00772       size_t d = (size_t)currentFormat.width - scratch.Length() + scratchOffs;
00773       while (d-- > 0) writer.Put (' ');
00774     }
00775     scratch.WriteTo (writer, scratchOffs);
00776     if (currentFormat.leftJustify 
00777       && ((size_t)currentFormat.width > (scratch.Length() - scratchOffs)))
00778     {
00779       size_t d = (size_t)currentFormat.width - scratch.Length() + scratchOffs;
00780       while (d-- > 0) writer.Put (' ');
00781     }
00782     scratch.Truncate (scratchOffs);
00783   }
00784 
00786   void DoPadding (const FormatSpec& currentFormat, const size_t scratchOffs,
00787     const size_t insert0offs)
00788   {
00789     if (currentFormat.leftJustify)
00790     {
00791       while ((size_t)currentFormat.width > (scratch.Length() - scratchOffs))
00792       {
00793         scratch.Push (' ');
00794       }
00795     }
00796     else
00797     {
00798       if (currentFormat.padZero)
00799       {
00800         while ((size_t)currentFormat.width > (scratch.Length() - scratchOffs))
00801         {
00802           scratch.Insert (insert0offs, '0');
00803         }
00804       }
00805       else
00806       {
00807         while ((size_t)currentFormat.width > (scratch.Length() - scratchOffs))
00808         {
00809           scratch.Insert (scratchOffs, ' ');
00810         }
00811       }
00812     }
00813   }
00814 
00816   template<class T>
00817   void OutputInt (Twriter& writer, const FormatSpec& currentFormat, T value)
00818   {
00819     const size_t scratchOffs = scratch.Length();
00820     size_t insertOffs = scratchOffs;
00821 
00822     if (value < 0)
00823     {
00824       scratch.Push ('-');
00825       insertOffs++;
00826       value = -value;
00827     }
00828     else if (currentFormat.plusSign)
00829     {
00830       scratch.Push ('+');
00831       insertOffs++;
00832     }
00833     else if (currentFormat.spacePrefix)
00834     {
00835       scratch.Push (' ');
00836       insertOffs++;
00837     }
00838 
00839     int width = 0;
00840     int numDigits = currentFormat.precision;
00841     if (!((value == 0) && (numDigits == 0)))
00842     {
00843       do
00844       {
00845         int d = (int)(value % 10);
00846         scratch.Insert (insertOffs, d + '0');
00847         width++;
00848         value = value / 10;
00849       }
00850       while ((value != 0) || (width < numDigits));
00851     }
00852     DoPadding (currentFormat, scratchOffs, insertOffs);
00853     scratch.WriteTo (writer, scratchOffs);
00854     scratch.Truncate (scratchOffs);
00855   }
00856 
00858   template<class T>
00859   void OutputUint (Twriter& writer, const FormatSpec& currentFormat,
00860     T value, uint radix = 10, const char* prefix = 0)
00861   {
00862     const utf32_char letterFirst = currentFormat.uppercase ? 'A' : 'a';
00863     const size_t scratchOffs = scratch.Length();
00864     size_t insertOffs = scratchOffs;
00865 
00866     if (prefix != 0)
00867     {
00868       while (*prefix != 0)
00869       {
00870         utf32_char ch = (value != 0) ? *prefix : ' ';
00871         scratch.Push (ch);
00872         insertOffs++;
00873         prefix++;
00874       }
00875     }
00876 
00877     int width = 0;
00878     int numDigits = currentFormat.precision;
00879     if (!((value == 0) && (numDigits == 0)))
00880     {
00881       do
00882       {
00883         uint d = (uint)(value % radix);
00884         utf32_char ch;
00885         if (d <= 9)
00886           ch = d + '0';
00887         else
00888           ch = d - 10 + letterFirst;
00889         scratch.Insert (insertOffs, ch);
00890         width++;
00891         value = value / radix;
00892       }
00893       while ((value != 0) || (width < numDigits));
00894     }
00895     DoPadding (currentFormat, scratchOffs, insertOffs);
00896     scratch.WriteTo (writer, scratchOffs);
00897     scratch.Truncate (scratchOffs);
00898   }
00899 
00901   template<class T>
00902   void OutputFloat (Twriter& writer, const FormatSpec& currentFormat,
00903     const T& value, const char* type)
00904   {
00905     char flags[5] = "";
00906     if (currentFormat.plusSign)
00907       strcat (flags, "+");
00908     if (currentFormat.spacePrefix)
00909       strcat (flags, " ");
00910     if (currentFormat.basePrefix)
00911       strcat (flags, "#");
00912     if (currentFormat.padZero)
00913       strcat (flags, "0");
00914     /* (sizeof(x)*25)/10+1 is an approximation of the number of characters
00915      * needed to display x in decimal system. (x can be at most 256^sizeof(x).
00916      * You need log10(256^sizeof(x)) characters, becoming
00917      * sizeof(x)*log10(256). 25/10 is an (over-)approximation of log10(256).
00918      * Add 1 for sign.) */
00919     CS_ALLOC_STACK_ARRAY(char, precStr, 
00920       (sizeof(currentFormat.precision) * 25) / 10 + 2);
00921     if (currentFormat.precision >= 0)
00922       sprintf (precStr, ".%d", currentFormat.precision);
00923     else
00924       precStr[0] = 0;
00925     CS_ALLOC_STACK_ARRAY(char, formatStr, 1 + strlen (flags)
00926       + (sizeof(currentFormat.width) * 25) / 10 + 1 + strlen (precStr) + 2);
00927     sprintf (formatStr, "%%%s%d%s%s", flags, currentFormat.width, precStr,
00928       type);
00929     // Make sure *any* number thrown at us fits
00930     char formattedStr[LDBL_MAX_10_EXP+3]; 
00931     sprintf (formattedStr, formatStr, value);
00932 
00933     char* p = formattedStr;
00934     while (*p != 0)
00935       writer.Put (*p++);
00936   }
00937 
00941   template<class T, class Tbase>
00942   struct IEEEFloatMantissa
00943   {
00944     Tbase mantissa[sizeof(T)/sizeof(Tbase)];
00945 
00946     Tbase& operator[] (int index)
00947     { return mantissa[index]; }
00948     bool Eq0 ()
00949     {
00950       for (uint n = 0; n < sizeof(T)/sizeof(Tbase); n++)
00951       {
00952         if (mantissa[n] != 0) return false;
00953       }
00954       return true;
00955     }
00956     const Tbase operator& (Tbase other) const
00957     { return mantissa[0] & other; }
00958     IEEEFloatMantissa& operator<<= (int shift)
00959     { 
00960       const int ovShift = sizeof(Tbase) * 8 - shift;
00961       Tbase overflow = 0;
00962       for (uint n = 0; n < sizeof(T)/sizeof(Tbase); n++)
00963       {
00964         Tbase newOverflow = mantissa[n] >> ovShift;
00965         mantissa[n] = (mantissa[n] << shift) | overflow;
00966         overflow = newOverflow;
00967       }
00968       return *this;
00969     }
00970     Tbase& Leftmost ()
00971     { return mantissa[sizeof(T)/sizeof(Tbase)-1]; }
00972   };
00973 
00975   template<class T, class Tbase>
00976   struct IEEEFloatSplitter
00977   {
00978     bool sign;
00979     Tbase exp;
00980 
00981     typename csPrintfFormatter<Twriter,Treader>::
00982       template IEEEFloatMantissa<T, Tbase> mantissa;
00983 
00984     IEEEFloatSplitter (const T& val, const int mantissaBits,
00985       const int expBits) 
00986     {
00987       const int baseBits = sizeof(Tbase) * 8;
00988       const int signBit = mantissaBits + expBits;
00989 
00990       union
00991       {
00992         T v;
00993         Tbase vB[sizeof(T)/sizeof(Tbase)];
00994       } toBase;
00995       toBase.v = val;
00996   #ifdef CS_LITTLE_ENDIAN
00997       const int hi = (sizeof (T) / sizeof (Tbase)) - 1;
00998       const int lo = 0;
00999       const int d = 1;
01000   #else
01001       const int hi = 0;
01002       const int lo = (sizeof (T) / sizeof (Tbase)) - 1;
01003       const int d = -1;
01004   #endif
01005       sign = ((toBase.vB[lo + (signBit / baseBits) * d]
01006         & (1 << (signBit % baseBits))) != 0);
01007       exp = (toBase.vB[hi] >> (mantissaBits % (baseBits)))
01008         & ((1 << expBits) - 1);
01009       for (int n = lo, p = 0; n != hi + d; n += d, p++)
01010       {
01011         const int bit = p * baseBits;
01012         const Tbase mask = ((bit + baseBits) <= mantissaBits) ? ~0 
01013           : ((1 << (mantissaBits % baseBits)) - 1);
01014         mantissa[p] = toBase.vB[n] & mask;
01015       }
01016     }
01017   };
01019   template <class T>
01020   void OutputFloatHex (Twriter& writer, const FormatSpec& currentFormat,
01021     const T& value, const int vMantissaBits, const int expBits, const int bias)
01022   {
01023 #ifdef CS_IEEE_DOUBLE_FORMAT
01024     const utf32_char letterFirst = currentFormat.uppercase ? 'A' : 'a';
01025 
01026 #ifdef CS_PROCESSOR_X86
01027     // @@@ x86 long double uses explicit mantissa MSB
01028     const bool hiddenBit = !(vMantissaBits >= 63);
01029 #else
01030     const bool hiddenBit = false;
01031 #endif
01032     const int mantissaBits = vMantissaBits - (hiddenBit ? 1 : 0);
01033     IEEEFloatSplitter<T, uint> vSplit (value, mantissaBits, expBits);
01034     const uint expMax = (1 << (sizeof(T) * 8 - mantissaBits - 1)) - 1;
01035 
01036     if ((vSplit.exp == expMax) && vSplit.mantissa.Eq0())
01037     {
01038       char infStr[5];
01039       if (vSplit.sign)
01040       {
01041         strcpy (infStr, "-");
01042       }
01043       else
01044       {
01045         if (currentFormat.plusSign)
01046           strcpy (infStr, "+");
01047         else if (currentFormat.spacePrefix)
01048           strcpy (infStr, " ");
01049         else
01050           strcpy (infStr, "");
01051       }
01052       strcat (infStr, currentFormat.uppercase ? "INF" : "inf");
01053       OutputString (writer, currentFormat, 
01054         (utf8_char*)infStr);
01055       return;
01056     }
01057     else if ((vSplit.exp == expMax) && !vSplit.mantissa.Eq0())
01058     {
01059       char nanStr[5];
01060       if (vSplit.sign)
01061       {
01062         strcpy (nanStr, "-");
01063       }
01064       else
01065       {
01066         if (currentFormat.plusSign)
01067           strcpy (nanStr, "+");
01068         else if (currentFormat.spacePrefix)
01069           strcpy (nanStr, " ");
01070         else
01071           strcpy (nanStr, "");
01072       }
01073       strcat (nanStr, currentFormat.uppercase ? "NAN" : "nan");
01074       OutputString (writer, currentFormat, 
01075         (utf8_char*)nanStr);
01076       return;
01077     }
01078 
01079     const size_t scratchOffs = scratch.Length();
01080     if (vSplit.sign)
01081     {
01082       scratch.Push ('-');
01083     }
01084     scratch.Push ('0');
01085     scratch.Push (currentFormat.uppercase ? 'X' : 'x');
01086     if (hiddenBit)
01087     {
01088       if (vSplit.exp == 0)
01089         scratch.Push ('0');
01090       else
01091         scratch.Push ('1');
01092     }
01093     else
01094     {
01095       const int bitNum = mantissaBits - 1;
01096       const int baseBits = sizeof (uint) * 8;
01097       const int bitIndex = bitNum / baseBits;
01098       scratch.Push ('0' + ((vSplit.mantissa[bitIndex] 
01099         >> (bitNum % baseBits)) & 1));
01100       vSplit.mantissa <<= 1;
01101     }
01102     if ((currentFormat.precision > 0) || (!vSplit.mantissa.Eq0()))
01103     {
01104       scratch.Push ('.');
01105       
01106       IEEEFloatMantissa<T, uint> m (vSplit.mantissa);
01107       m <<= sizeof(T)*8 - mantissaBits;
01108       int w = 0;
01109       do
01110       {
01111         uint d = m.Leftmost() >> ((sizeof(uint)*8)-4);
01112         utf32_char ch;
01113         if (d <= 9)
01114           ch = d + '0';
01115         else
01116           ch = d - 10 + letterFirst;
01117         scratch.Push (ch);
01118         m <<= 4;
01119         w++;
01120       }
01121       while ((w < currentFormat.precision) 
01122         || ((currentFormat.precision <= 0) && !m.Eq0()));
01123     }
01124     scratch.Push (currentFormat.uppercase ? 'P' : 'p');
01125     int e;
01126     if ((vSplit.exp == 0) && vSplit.mantissa.Eq0())
01127       e = 0;
01128     else
01129       e = (int)vSplit.exp + bias;
01130     if (e < 0)
01131     {
01132       scratch.Push ('-');
01133       e = -e;
01134     }
01135     else
01136       scratch.Push ('+');
01137     const size_t insertOffs = scratch.Length();;
01138     do
01139     {
01140       uint d = e % 10;
01141       scratch.Insert (insertOffs, d + '0');
01142       e = e / 10;
01143     }
01144     while (e != 0);
01145 
01146     DoPadding (currentFormat, scratchOffs, 
01147       vSplit.sign ? scratchOffs + 1 : scratchOffs);
01148     scratch.WriteTo (writer, scratchOffs);
01149     scratch.Truncate (scratchOffs);
01150 #else
01151   #if defined(CS_COMPILER_GCC)
01152     #warning Do not know how to hex-format floats
01153   #elif defined(CS_COMPILER_MSVC)
01154     #pragma message("Do not know how to hex-format floats")
01155   #endif
01156 #endif
01157   }
01158 public:
01160   csPrintfFormatter (Treader* reader, va_list args) : reader (*reader)
01161   {
01162     Init (args);
01163   }
01165   csPrintfFormatter (Treader* reader, ...) : reader (*reader)
01166   {
01167     va_list ap;
01168     va_start(ap, reader);
01169     Init (ap);
01170     va_end(ap);
01171   }
01173   void Format (Twriter& writer)
01174   {
01175     reader.Reset();
01176     size_t i = 0;
01177     utf32_char ch;
01178     while (i < formatSpecs.Length())
01179     {
01180       const FormatSpec& currentFormat = formatSpecs[i];
01181       size_t n;
01182       for (n = 0; n < currentFormat.copyRun; n++)
01183       {
01184         if (!reader.GetNext (ch)) break;
01185         writer.Put (ch);
01186       }
01187 
01188       switch (currentFormat.conversion)
01189       {
01190         case convStr:
01191           {
01192             if (currentFormat.type == typeLong)
01193               OutputString (writer, currentFormat, 
01194               (wchar_t*)(params[currentFormat.paramIdx].vPtr));
01195             else
01196               OutputString (writer, currentFormat, 
01197               (utf8_char*)(params[currentFormat.paramIdx].vPtr));
01198           }
01199           break;
01200         case convChar:
01201           {
01202             writer.Put (params[currentFormat.paramIdx].vInt);
01203           }
01204           break;
01205         case convInt:
01206           {
01207             const FmtParam& param = params[currentFormat.paramIdx];
01208             switch (currentFormat.type)
01209             {
01210               case typeIntmax:
01211                 {
01212                   intmax_t v = param.vIMT;
01213                   OutputInt (writer, currentFormat, v);
01214                 }
01215                 break;
01216               case typeLong:
01217                 {
01218                   long v = param.vLong;
01219                   OutputInt (writer, currentFormat, v);
01220                 }
01221                 break;
01222               case typeLongLong:
01223                 {
01224                   longlong v = param.vLL;
01225                   OutputInt (writer, currentFormat, v);
01226                 }
01227                 break;
01228               case typePtrDiffT:
01229                 {
01230                   ptrdiff_t v = param.vPDT;
01231                   OutputInt (writer, currentFormat, v);
01232                 }
01233                 break;
01234               case typeSizeT:
01235                 {
01236                   size_t v = param.vSzT;
01237                   OutputUint (writer, currentFormat, v);
01238                 }
01239                 break;
01240               default:
01241                 {
01242                   int v = param.vInt;
01243                   OutputInt (writer, currentFormat, v);
01244                 }
01245                 break;
01246             }
01247           }
01248           break;
01249         case convHex:
01250         case convUint:
01251         case convOctal:
01252           {
01253             uint uiradix;
01254             const char* prefix;
01255             if (currentFormat.conversion == convHex)
01256             {
01257               uiradix = 16;
01258               prefix = currentFormat.basePrefix 
01259                 ? (currentFormat.uppercase ? "0X" : "0x") : 0;
01260             }
01261             else if (currentFormat.conversion == convOctal)
01262             {
01263               uiradix = 8;
01264               prefix = currentFormat.basePrefix ? "0" : 0;
01265             }
01266             else
01267             {
01268               uiradix = 10;
01269               prefix = 0;
01270             }
01271             const FmtParam& param = params[currentFormat.paramIdx];
01272             switch (currentFormat.type)
01273             {
01274               case typeIntmax:
01275                 {
01276                   intmax_t v = param.vIMT;
01277                   OutputUint (writer, currentFormat, v, uiradix, prefix);
01278                 }
01279                 break;
01280               case typeLong:
01281                 {
01282                   unsigned long v = param.vLong;
01283                   OutputUint (writer, currentFormat, v, uiradix, prefix);
01284                 }
01285                 break;
01286               case typeLongLong:
01287                 {
01288                   ulonglong v = param.vLL;
01289                   OutputUint (writer, currentFormat, v, uiradix, prefix);
01290                 }
01291                 break;
01292               case typePtrDiffT:
01293                 {
01294                   ptrdiff_t v = param.vPDT;
01295                   OutputUint (writer, currentFormat, v, uiradix, prefix);
01296                 }
01297                 break;
01298               case typeSizeT:
01299                 {
01300                   size_t v = param.vSzT;
01301                   OutputUint (writer, currentFormat, v, uiradix, prefix);
01302                 }
01303                 break;
01304               default:
01305                 {
01306                   uint v = param.vInt;
01307                   OutputUint (writer, currentFormat, v, uiradix, prefix);
01308                 }
01309                 break;
01310             }
01311           }
01312           break;
01313         case convGetNum:
01314           *((int*)(params[currentFormat.paramIdx].vPtr))
01315                 = (int)writer.GetTotal();
01316           break;
01317         case convErrno:
01318           OutputString (writer, currentFormat, 
01319             (utf8_char*)strerror (params[currentFormat.paramIdx].vInt));
01320           break;
01321         case convPtr:
01322           {
01323             FormatSpec fakeFormat;
01324             fakeFormat.leftJustify = currentFormat.leftJustify;
01325             fakeFormat.precision = sizeof (uintptr_t) * 2;
01326             if (params[currentFormat.paramIdx].vPtr == 0)
01327             {
01328               OutputString (writer, fakeFormat, (utf8_char*)"(nil)");
01329             }
01330             else
01331             {
01332               OutputUint (writer, fakeFormat, 
01333                 (uintptr_t)params[currentFormat.paramIdx].vPtr, 16, "0x");
01334             }
01335           }
01336           break;
01337         case convFloatFix:
01338           {
01339             if (currentFormat.type == typeLongLong)
01340             {
01341 #ifdef CS_FORMATTER_NO_LONG_DOUBLE_FORMAT
01342               OutputFloat (writer, currentFormat, 
01343               (double)params[currentFormat.paramIdx].vLongDbl, "f");
01344 #else
01345               OutputFloat (writer, currentFormat, 
01346               params[currentFormat.paramIdx].vLongDbl, "Lf");
01347 #endif
01348             }
01349             else
01350               OutputFloat (writer, currentFormat, 
01351               params[currentFormat.paramIdx].vDbl, "f");
01352           }
01353           break;
01354         case convFloatExp:
01355           {
01356             if (currentFormat.type == typeLongLong)
01357             {
01358 #ifdef CS_FORMATTER_NO_LONG_DOUBLE_FORMAT
01359               OutputFloat (writer, currentFormat, 
01360               (double)params[currentFormat.paramIdx].vLongDbl, 
01361               currentFormat.uppercase ? "E" : "e");
01362 #else
01363               OutputFloat (writer, currentFormat, 
01364               params[currentFormat.paramIdx].vLongDbl, 
01365               currentFormat.uppercase ? "LE" : "Le");
01366 #endif
01367             }
01368             else
01369               OutputFloat (writer, currentFormat, 
01370               params[currentFormat.paramIdx].vDbl, 
01371               currentFormat.uppercase ? "E" : "e");
01372           }
01373           break;
01374         case convFloatGeneral:
01375           {
01376             if (currentFormat.type == typeLongLong)
01377             {
01378 #ifdef CS_FORMATTER_NO_LONG_DOUBLE_FORMAT
01379               OutputFloat (writer, currentFormat, 
01380               (double)params[currentFormat.paramIdx].vLongDbl, 
01381               currentFormat.uppercase ? "G" : "g");
01382 #else
01383               OutputFloat (writer, currentFormat, 
01384               params[currentFormat.paramIdx].vLongDbl, 
01385               currentFormat.uppercase ? "LG" : "Lg");
01386 #endif
01387             }
01388             else
01389               OutputFloat (writer, currentFormat, 
01390               params[currentFormat.paramIdx].vDbl, 
01391               currentFormat.uppercase ? "G" : "g");
01392           }
01393           break;
01394         case convFloatHex:
01395           {
01396             if (currentFormat.type == typeLongLong)
01397               OutputFloatHex (writer, currentFormat, 
01398               params[currentFormat.paramIdx].vLongDbl, LDBL_MANT_DIG, 
01399               csLog2 (LDBL_MAX_EXP) + 1, -(LDBL_MAX_EXP - 1));
01400             else
01401               OutputFloatHex (writer, currentFormat, 
01402               params[currentFormat.paramIdx].vDbl, DBL_MANT_DIG, 
01403               csLog2 (DBL_MAX_EXP) + 1, -(DBL_MAX_EXP - 1));
01404           }
01405           break;
01406         default:
01407           break;
01408       }
01409 
01410       for (n = 0; n < currentFormat.fmtSkip; n++)
01411       {
01412         if (!reader.GetNext (ch)) break;
01413       }
01414       i++;
01415     }
01416     while (reader.GetNext (ch))
01417       writer.Put (ch);
01418     writer.Put (0);
01419   }
01420 };
01421 
01424 #endif // __CS_CSUTIL_FORMATTER_H__

Generated for Crystal Space 1.0.2 by doxygen 1.4.7