1// Copyright 2010 The Kyua Authors. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above copyright 11// notice, this list of conditions and the following disclaimer in the 12// documentation and/or other materials provided with the distribution. 13// * Neither the name of Google Inc. nor the names of its contributors 14// may be used to endorse or promote products derived from this software 15// without specific prior written permission. 16// 17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 29#include "utils/format/formatter.hpp" 30 31#include <memory> 32#include <string> 33#include <utility> 34 35#include "utils/format/exceptions.hpp" 36#include "utils/sanity.hpp" 37#include "utils/text/exceptions.hpp" 38#include "utils/text/operations.ipp" 39 40namespace format = utils::format; 41namespace text = utils::text; 42 43 44namespace { 45 46 47/// Finds the next placeholder in a string. 48/// 49/// \param format The original format string provided by the user; needed for 50/// error reporting purposes only. 51/// \param expansion The string containing the placeholder to look for. Any 52/// '%%' in the string will be skipped, and they must be stripped later by 53/// strip_double_percent(). 54/// \param begin The position from which to start looking for the next 55/// placeholder. 56/// 57/// \return The position in the string in which the placeholder is located and 58/// the placeholder itself. If there are no placeholders left, this returns 59/// the length of the string and an empty string. 60/// 61/// \throw bad_format_error If the input string contains a trailing formatting 62/// character. We cannot detect any other kind of invalid formatter because 63/// we do not implement a full parser for them. 64static std::pair< std::string::size_type, std::string > 65find_next_placeholder(const std::string& format, 66 const std::string& expansion, 67 std::string::size_type begin) 68{ 69 begin = expansion.find('%', begin); 70 while (begin != std::string::npos && expansion[begin + 1] == '%') 71 begin = expansion.find('%', begin + 2); 72 if (begin == std::string::npos) 73 return std::make_pair(expansion.length(), ""); 74 if (begin == expansion.length() - 1) 75 throw format::bad_format_error(format, "Trailing %"); 76 77 std::string::size_type end = begin + 1; 78 while (end < expansion.length() && expansion[end] != 's') 79 end++; 80 const std::string placeholder = expansion.substr(begin, end - begin + 1); 81 if (end == expansion.length() || 82 placeholder.find('%', 1) != std::string::npos) 83 throw format::bad_format_error(format, "Unterminated placeholder '" + 84 placeholder + "'"); 85 return std::make_pair(begin, placeholder); 86} 87 88 89/// Converts a string to an integer. 90/// 91/// \param format The format string; for error reporting purposes only. 92/// \param str The string to conver. 93/// \param what The name of the field this integer belongs to; for error 94/// reporting purposes only. 95/// 96/// \return An integer representing the input string. 97inline int 98to_int(const std::string& format, const std::string& str, const char* what) 99{ 100 try { 101 return text::to_type< int >(str); 102 } catch (const text::value_error& e) { 103 throw format::bad_format_error(format, "Invalid " + std::string(what) + 104 "specifier"); 105 } 106} 107 108 109/// Constructs an std::ostringstream based on a formatting placeholder. 110/// 111/// \param format The format placeholder; may be empty. 112/// 113/// \return A new std::ostringstream that is prepared to format a single 114/// object in the manner specified by the format placeholder. 115/// 116/// \throw bad_format_error If the format string is bad. We do minimal 117/// validation on this string though. 118static std::ostringstream* 119new_ostringstream(const std::string& format) 120{ 121 std::auto_ptr< std::ostringstream > output(new std::ostringstream()); 122 123 if (format.length() <= 2) { 124 // If the format is empty, we create a new stream so that we don't have 125 // to check for NULLs later on. We rarely should hit this condition 126 // (and when we do it's a bug in the caller), so this is not a big deal. 127 // 128 // Otherwise, if the format is a regular '%s', then we don't have to do 129 // any processing for additional formatters. So this is just a "fast 130 // path". 131 } else { 132 std::string partial = format.substr(1, format.length() - 2); 133 if (partial[0] == '0') { 134 output->fill('0'); 135 partial.erase(0, 1); 136 } 137 if (!partial.empty()) { 138 const std::string::size_type dot = partial.find('.'); 139 if (dot != 0) 140 output->width(to_int(format, partial.substr(0, dot), "width")); 141 if (dot != std::string::npos) { 142 output->setf(std::ios::fixed, std::ios::floatfield); 143 output->precision(to_int(format, partial.substr(dot + 1), 144 "precision")); 145 } 146 } 147 } 148 149 return output.release(); 150} 151 152 153/// Replaces '%%' by '%' in a given string range. 154/// 155/// \param in The input string to be rewritten. 156/// \param begin The position at which to start the replacement. 157/// \param end The position at which to end the replacement. 158/// 159/// \return The modified string and the amount of characters removed. 160static std::pair< std::string, int > 161strip_double_percent(const std::string& in, const std::string::size_type begin, 162 std::string::size_type end) 163{ 164 std::string part = in.substr(begin, end - begin); 165 166 int removed = 0; 167 std::string::size_type pos = part.find("%%"); 168 while (pos != std::string::npos) { 169 part.erase(pos, 1); 170 ++removed; 171 pos = part.find("%%", pos + 1); 172 } 173 174 return std::make_pair(in.substr(0, begin) + part + in.substr(end), removed); 175} 176 177 178} // anonymous namespace 179 180 181/// Performs internal initialization of the formatter. 182/// 183/// This is separate from the constructor just because it is shared by different 184/// overloaded constructors. 185void 186format::formatter::init(void) 187{ 188 const std::pair< std::string::size_type, std::string > placeholder = 189 find_next_placeholder(_format, _expansion, _last_pos); 190 const std::pair< std::string, int > no_percents = 191 strip_double_percent(_expansion, _last_pos, placeholder.first); 192 193 _oss = new_ostringstream(placeholder.second); 194 195 _expansion = no_percents.first; 196 _placeholder_pos = placeholder.first - no_percents.second; 197 _placeholder = placeholder.second; 198} 199 200 201/// Constructs a new formatter object (internal). 202/// 203/// \param format The format string. 204/// \param expansion The format string with any replacements performed so far. 205/// \param last_pos The position from which to start looking for formatting 206/// placeholders. This must be maintained in case one of the replacements 207/// introduced a new placeholder, which must be ignored. Think, for 208/// example, replacing a "%s" string with "foo %s". 209format::formatter::formatter(const std::string& format, 210 const std::string& expansion, 211 const std::string::size_type last_pos) : 212 _format(format), 213 _expansion(expansion), 214 _last_pos(last_pos), 215 _oss(NULL) 216{ 217 init(); 218} 219 220 221/// Constructs a new formatter object. 222/// 223/// \param format The format string. The formatters in the string are not 224/// validated during construction, but will cause errors when used later if 225/// they are invalid. 226format::formatter::formatter(const std::string& format) : 227 _format(format), 228 _expansion(format), 229 _last_pos(0), 230 _oss(NULL) 231{ 232 init(); 233} 234 235 236format::formatter::~formatter(void) 237{ 238 delete _oss; 239} 240 241 242/// Returns the formatted string. 243/// 244/// \return A string representation of the formatted string. 245const std::string& 246format::formatter::str(void) const 247{ 248 return _expansion; 249} 250 251 252/// Automatic conversion of formatter objects to strings. 253/// 254/// This is provided to allow painless injection of formatter objects into 255/// streams, without having to manually call the str() method. 256format::formatter::operator const std::string&(void) const 257{ 258 return _expansion; 259} 260 261 262/// Specialization of operator% for booleans. 263/// 264/// \param value The boolean to inject into the format string. 265/// 266/// \return A new formatter that has one less format placeholder. 267format::formatter 268format::formatter::operator%(const bool& value) const 269{ 270 (*_oss) << (value ? "true" : "false"); 271 return replace(_oss->str()); 272} 273 274 275/// Replaces the first formatting placeholder with a value. 276/// 277/// \param arg The replacement string. 278/// 279/// \return A new formatter in which the first formatting placeholder has been 280/// replaced by arg and is ready to replace the next item. 281/// 282/// \throw utils::format::extra_args_error If there are no more formatting 283/// placeholders in the input string, or if the placeholder is invalid. 284format::formatter 285format::formatter::replace(const std::string& arg) const 286{ 287 if (_placeholder_pos == _expansion.length()) 288 throw format::extra_args_error(_format, arg); 289 290 const std::string expansion = _expansion.substr(0, _placeholder_pos) 291 + arg + _expansion.substr(_placeholder_pos + _placeholder.length()); 292 return formatter(_format, expansion, _placeholder_pos + arg.length()); 293} 294