src/base/cprintf_formats.hh

   1 /*
   2  * Copyright (c) 2003-2005 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Nathan Binkert
  29  */
  30
  31 #ifndef __BASE_CPRINTF_FORMATS_HH__
  32 #define __BASE_CPRINTF_FORMATS_HH__
  33
  34 #include <cstring>
  35 #include <ostream>
  36 #include <sstream>
  37
  38 namespace cp {
  39
  40 struct Format
  41 {
  42     bool alternate_form;
  43     bool flush_left;
  44     bool print_sign;
  45     bool blank_space;
  46     bool fill_zero;
  47     bool uppercase;
  48     enum { dec, hex, oct } base;
  49     enum { none, string, integer, character, floating } format;
  50     enum { best, fixed, scientific } float_format;
  51     int precision;
  52     int width;
  53     bool get_precision;
  54     bool get_width;
  55
  56     Format() { clear(); }
  57
  58     void clear()
  59     {
  60         alternate_form = false;
  61         flush_left = false;
  62         print_sign = false;
  63         blank_space = false;
  64         fill_zero = false;
  65         uppercase = false;
  66         base = dec;
  67         format = none;
  68         precision = -1;
  69         width = 0;
  70         get_precision = false;
  71         get_width = false;
  72     }
  73 };
  74
  75 template <typename T>
  76 inline void
  77 _format_char(std::ostream &out, const T &data, Format &fmt)
  78 {
  79     using namespace std;
  80
  81     out << data;
  82 }
  83
  84 template <typename T>
  85 inline void
  86 _format_integer(std::ostream &out, const T &data, Format &fmt)
  87 {
  88     using namespace std;
  89
  90     switch (fmt.base) {
  91       case Format::hex:
  92         out.setf(std::ios::hex, std::ios::basefield);
  93         break;
  94
  95       case Format::oct:
  96         out.setf(std::ios::oct, std::ios::basefield);
  97         break;
  98
  99       case Format::dec:
 100         out.setf(std::ios::dec, std::ios::basefield);
 101         break;
 102     }
 103
 104     if (fmt.alternate_form) {
 105         if (!fmt.fill_zero)
 106             out.setf(std::ios::showbase);
 107         else {
 108             switch (fmt.base) {
 109               case Format::hex:
 110                 out << "0x";
 111                 fmt.width -= 2;
 112                 break;
 113               case Format::oct:
 114                 out << "0";
 115                 fmt.width -= 1;
 116                 break;
 117               case Format::dec:
 118                 break;
 119             }
 120         }
 121     }
 122
 123     if (fmt.fill_zero)
 124         out.fill('0');
 125
 126     if (fmt.width > 0)
 127         out.width(fmt.width);
 128
 129     if (fmt.flush_left && !fmt.fill_zero)
 130         out.setf(std::ios::left);
 131
 132     if (fmt.print_sign)
 133         out.setf(std::ios::showpos);
 134
 135     if (fmt.uppercase)
 136         out.setf(std::ios::uppercase);
 137
 138     out << data;
 139 }
 140
 141 template <typename T>
 142 inline void
 143 _format_float(std::ostream &out, const T &data, Format &fmt)
 144 {
 145     using namespace std;
 146
 147     switch (fmt.float_format) {
 148       case Format::scientific:
 149         if (fmt.precision != -1) {
 150             if (fmt.width > 0)
 151                 out.width(fmt.width);
 152
 153             if (fmt.precision == 0)
 154                 fmt.precision = 1;
 155             else
 156                 out.setf(std::ios::scientific);
 157
 158             out.precision(fmt.precision);
 159         } else
 160             if (fmt.width > 0)
 161                 out.width(fmt.width);
 162
 163         if (fmt.uppercase)
 164             out.setf(std::ios::uppercase);
 165         break;
 166
 167       case Format::fixed:
 168         if (fmt.precision != -1) {
 169             if (fmt.width > 0)
 170                 out.width(fmt.width);
 171
 172             out.setf(std::ios::fixed);
 173             out.precision(fmt.precision);
 174         } else
 175             if (fmt.width > 0)
 176                 out.width(fmt.width);
 177
 178         break;
 179
 180       default:
 181         if (fmt.precision != -1)
 182             out.precision(fmt.precision);
 183
 184         if (fmt.width > 0)
 185             out.width(fmt.width);
 186
 187         break;
 188     }
 189
 190     out << data;
 191 }
 192
 193 template <typename T>
 194 inline void
 195 _format_string(std::ostream &out, const T &data, Format &fmt)
 196 {
 197     using namespace std;
 198
 199 #if defined(__GNUC__) && (__GNUC__ < 3) || 1
 200     if (fmt.width > 0) {
 201         std::stringstream foo;
 202         foo << data;
 203         int flen = foo.str().size();
 204
 205         if (fmt.width > flen) {
 206             char *spaces = new char[fmt.width - flen + 1];
 207             memset(spaces, ' ', fmt.width - flen);
 208             spaces[fmt.width - flen] = 0;
 209
 210             if (fmt.flush_left)
 211                 out << foo.str() << spaces;
 212             else
 213                 out << spaces << foo.str();
 214
 215             delete [] spaces;
 216         } else
 217             out << data;
 218     } else
 219         out << data;
 220 #else
 221     if (fmt.width > 0)
 222         out.width(fmt.width);
 223     if (fmt.flush_left)
 224         out.setf(std::ios::left);
 225
 226     out << data;
 227 #endif
 228 }
 229
 230 /////////////////////////////////////////////////////////////////////////////
 231 //
 232 //  The code below controls the actual usage of formats for various types
 233 //
 234
 235 //
 236 // character formats
 237 //
 238 template <typename T>
 239 inline void
 240 format_char(std::ostream &out, const T &data, Format &fmt)
 241 { out << "<bad arg type for char format>"; }
 242
 243 inline void
 244 format_char(std::ostream &out, char data, Format &fmt)
 245 { _format_char(out, data, fmt); }
 246
 247 inline void
 248 format_char(std::ostream &out, unsigned char data, Format &fmt)
 249 { _format_char(out, data, fmt); }
 250
 251 inline void
 252 format_char(std::ostream &out, signed char data, Format &fmt)
 253 { _format_char(out, data, fmt); }
 254
 255 inline void
 256 format_char(std::ostream &out, short data, Format &fmt)
 257 { _format_char(out, (char)data, fmt); }
 258
 259 inline void
 260 format_char(std::ostream &out, unsigned short data, Format &fmt)
 261 { _format_char(out, (char)data, fmt); }
 262
 263 inline void
 264 format_char(std::ostream &out, int data, Format &fmt)
 265 { _format_char(out, (char)data, fmt); }
 266
 267 inline void
 268 format_char(std::ostream &out, unsigned int data, Format &fmt)
 269 { _format_char(out, (char)data, fmt); }
 270
 271 inline void
 272 format_char(std::ostream &out, long data, Format &fmt)
 273 { _format_char(out, (char)data, fmt); }
 274
 275 inline void
 276 format_char(std::ostream &out, unsigned long data, Format &fmt)
 277 { _format_char(out, (char)data, fmt); }
 278
 279 inline void
 280 format_char(std::ostream &out, long long data, Format &fmt)
 281 { _format_char(out, (char)data, fmt); }
 282
 283 inline void
 284 format_char(std::ostream &out, unsigned long long data, Format &fmt)
 285 { _format_char(out, (char)data, fmt); }
 286
 287 //
 288 // integer formats
 289 //
 290 template <typename T>
 291 inline void
 292 format_integer(std::ostream &out, const T &data, Format &fmt)
 293 { _format_integer(out, data, fmt); }
 294 inline void
 295 format_integer(std::ostream &out, char data, Format &fmt)
 296 { _format_integer(out, (int)data, fmt); }
 297 inline void
 298 format_integer(std::ostream &out, unsigned char data, Format &fmt)
 299 { _format_integer(out, (int)data, fmt); }
 300 inline void
 301 format_integer(std::ostream &out, signed char data, Format &fmt)
 302 { _format_integer(out, (int)data, fmt); }
 303 #if 0
 304 inline void
 305 format_integer(std::ostream &out, short data, Format &fmt)
 306 { _format_integer(out, data, fmt); }
 307 inline void
 308 format_integer(std::ostream &out, unsigned short data, Format &fmt)
 309 { _format_integer(out, data, fmt); }
 310 inline void
 311 format_integer(std::ostream &out, int data, Format &fmt)
 312 { _format_integer(out, data, fmt); }
 313 inline void
 314 format_integer(std::ostream &out, unsigned int data, Format &fmt)
 315 { _format_integer(out, data, fmt); }
 316 inline void
 317 format_integer(std::ostream &out, long data, Format &fmt)
 318 { _format_integer(out, data, fmt); }
 319 inline void
 320 format_integer(std::ostream &out, unsigned long data, Format &fmt)
 321 { _format_integer(out, data, fmt); }
 322 inline void
 323 format_integer(std::ostream &out, long long data, Format &fmt)
 324 { _format_integer(out, data, fmt); }
 325 inline void
 326 format_integer(std::ostream &out, unsigned long long data, Format &fmt)
 327 { _format_integer(out, data, fmt); }
 328 #endif
 329
 330 //
 331 // floating point formats
 332 //
 333 template <typename T>
 334 inline void
 335 format_float(std::ostream &out, const T &data, Format &fmt)
 336 { out << "<bad arg type for float format>"; }
 337
 338 inline void
 339 format_float(std::ostream &out, float data, Format &fmt)
 340 { _format_float(out, data, fmt); }
 341
 342 inline void
 343 format_float(std::ostream &out, double data, Format &fmt)
 344 { _format_float(out, data, fmt); }
 345
 346 //
 347 // string formats
 348 //
 349 template <typename T>
 350 inline void
 351 format_string(std::ostream &out, const T &data, Format &fmt)
 352 { _format_string(out, data, fmt); }
 353
 354 inline void
 355 format_string(std::ostream &out, const std::stringstream &data, Format &fmt)
 356 { _format_string(out, data.str(), fmt); }
 357
 358 } // namespace cp
 359
 360 #endif // __CPRINTF_FORMATS_HH__