Lines Matching refs:Char
407 char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail.
425 template <typename Char>
428 typedef BasicWriter<char> Writer;
431 template <typename Char>
434 template <typename Impl, typename Char>
451 | StringRef | BasicStringRef<char> |
466 template <typename Char>
469 const Char *data_;
474 BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}
479 the size with ``std::char_traits<Char>::length``.
482 BasicStringRef(const Char *s)
483 : data_(s), size_(std::char_traits<Char>::length(s)) {}
492 const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
500 std::basic_string<Char> to_string() const {
501 return std::basic_string<Char>(data_, size_);
505 const Char *data() const { return data_; }
513 int result = std::char_traits<Char>::compare(data_, other.data_, size);
539 typedef BasicStringRef<char> StringRef;
552 | CStringRef | BasicCStringRef<char> |
567 template <typename Char>
570 const Char *data_;
574 BasicCStringRef(const Char *s) : data_(s) {}
583 const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
587 const Char *c_str() const { return data_; }
590 typedef BasicCStringRef<char> CStringRef;
612 FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char);
613 FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char);
803 template <typename Char>
804 class FixedBuffer : public fmt::Buffer<Char> {
806 FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
812 template <typename Char>
816 typedef stdext::checked_array_iterator<Char*> CharPtr;
818 typedef Char *CharPtr;
820 static Char cast(int value) { return static_cast<Char>(value); }
823 template <typename Char>
827 class CharTraits<char> : public BasicCharTraits<char> {
829 // Conversion from wchar_t to char is not allowed.
830 static char convert(wchar_t);
833 static char convert(char value) { return value; }
837 FMT_API static int format_float(char *buffer, std::size_t size,
838 const char *format, unsigned width, int precision, T value);
842 extern template int CharTraits<char>::format_float<double>
843 (char *buffer, std::size_t size,
844 const char* format, unsigned width, int precision, double value);
845 extern template int CharTraits<char>::format_float<long double>
846 (char *buffer, std::size_t size,
847 const char* format, unsigned width, int precision, long double value);
853 static wchar_t convert(char value) { return value; }
905 FMT_API void report_unknown_type(char code, const char *type);
913 static const char DIGITS[];
959 template <typename Char>
960 void operator()(Char *) {}
974 template <typename Char>
975 void operator()(Char *&buffer) {
985 // thousands_sep is a functor that is called after writing each char to
987 template <typename UInt, typename Char, typename ThousandsSep>
988 inline void format_decimal(Char *buffer, UInt value, unsigned num_digits,
1003 *--buffer = static_cast<char>('0' + value);
1012 template <typename UInt, typename Char>
1013 inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
1045 MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
1052 const char *c_str() const { return &buffer_[0]; }
1067 template <typename Char>
1069 const Char *value;
1089 StringValue<char> string;
1090 StringValue<signed char> sstring;
1091 StringValue<unsigned char> ustring;
1099 INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
1112 template <typename Char>
1114 template <typename Char, typename T>
1122 template <typename T, typename Char>
1134 typedef char Yes[1];
1135 typedef char No[2];
1210 LConv *lc, LConvCheck<char *LConv::*, &LConv::thousands_sep> = 0) {
1237 template <typename Formatter, typename Char, typename T>
1238 void format_arg(Formatter &, const Char *, const T &) {
1249 typedef typename Formatter::Char Char;
1255 // of "[const] volatile char *" which is printed as bool by iostreams.
1267 MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
1269 MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
1270 MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
1271 MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
1272 MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
1289 *static_cast<const Char**>(format_str_ptr),
1337 FMT_MAKE_VALUE(signed char, int_value, INT)
1338 FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
1339 FMT_MAKE_VALUE(char, int_value, CHAR)
1342 MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
1345 static uint64_t type(wchar_t) { return Arg::CHAR; }
1352 FMT_MAKE_VALUE(char *, string.value, CSTRING)
1353 FMT_MAKE_VALUE(const char *, string.value, CSTRING)
1354 FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING)
1355 FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
1356 FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING)
1357 FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
1363 MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
1396 // uses char.
1422 template <typename Char>
1424 BasicStringRef<Char> name;
1427 NamedArg(BasicStringRef<Char> argname, const T &value)
1428 : Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname) {}
1431 template <typename Char, typename T>
1432 struct NamedArgWithType : NamedArg<Char> {
1433 NamedArgWithType(BasicStringRef<Char> argname, const T &value)
1434 : NamedArg<Char>(argname, value) {}
1444 template <typename Char>
1468 template <typename Char>
1582 /** Visits a ``char`` or ``wchar_t`` argument. **/
1609 /** Visits a null-terminated C string (``const char *``) argument. **/
1610 Result visit_cstring(const char *) {
1615 Result visit_string(Arg::StringValue<char>) {
1658 case Arg::CHAR:
1686 CHAR_FLAG = 0x10 // Argument has char type - used in error reporting.
1693 template <char TYPE>
1699 char type() const { return TYPE; }
1700 char fill() const { return ' '; }
1706 // Fill is always wchar_t and cast to char if necessary to avoid having
1729 template <char TYPE>
1734 char type() const { return TYPE; }
1741 char type_;
1744 unsigned width = 0, char type = 0, wchar_t fill = ' ')
1749 char type() const { return type_; }
1753 template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
1766 template <typename Char>
1769 const Char *str_;
1773 StrFormatSpec(const Char *str, unsigned width, FillChar fill)
1775 internal::CharTraits<Char>::convert(FillChar());
1778 const Char *str() const { return str_; }
1817 template <char TYPE_CODE, typename Char>
1818 IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
1819 int value, unsigned width, Char fill = ' ');
1838 template <char TYPE_CODE> \
1847 /* can be replaced with one overload making the template argument Char */ \
1848 /* default to char (C++11). */ \
1849 template <char TYPE_CODE, typename Char> \
1850 inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
1851 IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \
1852 unsigned width, Char fill) { \
1853 return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
1863 template <typename Char> \
1864 inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \
1865 TYPE value, unsigned width, Char fill) { \
1866 return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \
1889 template <typename Char>
1890 inline StrFormatSpec<Char> pad(
1891 const Char *str, unsigned width, Char fill = ' ') {
1892 return StrFormatSpec<Char>(str, width, fill);
1896 const wchar_t *str, unsigned width, char fill = ' ') {
1902 template <typename Char>
1906 std::pair<fmt::BasicStringRef<Char>, internal::Arg> > MapType;
1914 const internal::Arg *find(const fmt::BasicStringRef<Char> &name) const {
1925 template <typename Impl, typename Char>
1928 BasicWriter<Char> &writer_;
1940 BasicWriter<Char> &writer() { return writer_; }
1944 const char *str_value = value ? "true" : "false";
1945 Arg::StringValue<char> str = { str_value, std::strlen(str_value) };
1949 void write(const char *value) {
1950 Arg::StringValue<char> str = {value, value ? std::strlen(value) : 0};
1955 ArgFormatterBase(BasicWriter<Char> &w, FormatSpec &s)
1979 FMT_THROW(FormatError("invalid format specifier for char"));
1980 typedef typename BasicWriter<Char>::CharPtr CharPtr;
1981 Char fill = internal::CharTraits<Char>::cast(spec_.fill());
1999 *out = internal::CharTraits<Char>::cast(value);
2002 void visit_cstring(const char *value) {
2008 void visit_string(Arg::StringValue<char> value) {
2014 void visit_wstring(Arg::StringValue<Char> value) {
2031 FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);
2042 Arg next_arg(const char *&error) {
2051 Arg get_arg(unsigned arg_index, const char *&error) {
2055 bool check_no_auto_index(const char *&error) {
2064 template <typename Char>
2065 void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
2067 w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
2089 template <typename Impl, typename Char>
2090 class BasicArgFormatter : public internal::ArgFormatterBase<Impl, Char> {
2092 BasicFormatter<Char, Impl> &formatter_;
2093 const Char *format_;
2104 BasicArgFormatter(BasicFormatter<Char, Impl> &formatter,
2105 FormatSpec &spec, const Char *fmt)
2106 : internal::ArgFormatterBase<Impl, Char>(formatter.writer(), spec),
2116 template <typename Char>
2117 class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char> {
2120 ArgFormatter(BasicFormatter<Char> &formatter,
2121 FormatSpec &spec, const Char *fmt)
2122 : BasicArgFormatter<ArgFormatter<Char>, Char>(formatter, spec, fmt) {}
2130 typedef CharType Char;
2133 BasicWriter<Char> &writer_;
2134 internal::ArgMap<Char> map_;
2142 internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
2145 internal::Arg parse_arg_index(const Char *&s);
2148 internal::Arg parse_arg_name(const Char *&s);
2158 BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
2162 BasicWriter<Char
2165 void format(BasicCStringRef<Char> format_str);
2168 const Char *format(const Char *&format_str, const internal::Arg &arg);
2195 return MakeValue< BasicFormatter<char> >::type(arg);
2259 arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)
2270 ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
2280 ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
2287 fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)
2364 typedef char Char; // For FMT_VARIADIC_CTOR.
2381 const char *filename = "madeup";
2427 | Writer | BasicWriter<char> |
2434 template <typename Char>
2438 Buffer<Char> &buffer_;
2442 typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
2446 static Char *get(CharPtr p) { return p.base(); }
2448 static Char *get(Char *p) { return p; }
2466 Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) {
2468 Char *ptr = get(grow_buffer(prefix_size + num_digits));
2488 const EmptySpec &, const char *prefix, unsigned prefix_size) {
2497 const Spec &spec, const char *prefix, unsigned prefix_size);
2516 // and strings to a char stream. If you want to print a wide string as a
2519 void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
2521 typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
2525 void append_float_length(Char *&format_ptr, long double) {
2530 void append_float_length(Char *&, T) {}
2542 explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
2561 const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; }
2567 const Char *c_str() const {
2579 std::basic_string<Char> str() const {
2580 return std::basic_string<Char>(&buffer_[0], buffer_.size());
2608 void write(BasicCStringRef<Char> format, ArgList args) {
2609 BasicFormatter<Char>(args, *this).format(format);
2611 FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
2660 BasicWriter &operator<<(char value) {
2666 typename internal::WCharHelper<wchar_t, Char>::Supported value) {
2676 BasicWriter &operator<<(fmt::BasicStringRef<Char> value) {
2677 const Char *str = value.data();
2683 Char>::Supported value) {
2684 const char *str = value.data();
2691 internal::CharTraits<Char>::convert(FillChar());
2699 write_str(s, std::char_traits<Char>::length(s), spec);
2705 Buffer<Char> &buffer() FMT_NOEXCEPT { return buffer_; }
2708 template <typename Char>
2710 typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
2715 Char fill = internal::CharTraits<Char>::cast(spec.fill());
2731 template <typename Char>
2733 void BasicWriter<Char>::write_str(
2735 // Check if StrChar is convertible to Char.
2736 internal::CharTraits<Char>::convert(StrChar());
2752 template <typename Char>
2753 typename BasicWriter<Char>::CharPtr
2754 BasicWriter<Char>::fill_padding(
2759 Char fill_char = internal::CharTraits<Char>::cast(fill);
2768 template <typename Char>
2770 typename BasicWriter<Char>::CharPtr
2771 BasicWriter<Char>::prepare_int_buffer(
2773 const char *prefix, unsigned prefix_size) {
2776 Char fill = internal::CharTraits<Char>::cast(spec.fill());
2832 template <typename Char>
2834 void BasicWriter<Char>::write_int(T value, Spec spec) {
2838 char prefix[4] = "";
2864 Char *p = get(prepare_int_buffer(
2867 const char *digits = spec.type() == 'x' ?
2884 Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
2887 *p-- = static_cast<Char>('0' + (n & 1));
2899 Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
2902 *p-- = static_cast<Char>('0' + (n & 7));
2920 spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
2925 template <typename Char>
2927 void BasicWriter<Char>::write_double(T value, const FormatSpec &spec) {
2929 char type = spec.type();
2951 char sign = 0;
2965 const char *nan = upper ? " NAN" : " nan";
2980 const char *inf = upper ? " INF" : " inf";
3002 Char format[MAX_FORMAT_SIZE];
3003 Char *format_ptr = format;
3026 Char fill = internal::CharTraits<Char>::cast(spec.fill());
3028 Char *start = FMT_NULL;
3041 int result = internal::CharTraits<Char>::format_float(
3067 std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
3092 | MemoryWriter | BasicMemoryWriter<char, std::allocator<char>> |
3114 template <typename Char, typename Allocator = std::allocator<Char> >
3115 class BasicMemoryWriter : public BasicWriter<Char> {
3117 internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
3121 : BasicWriter<Char>(buffer_), buffer_(alloc) {}
3131 : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_)) {
3146 typedef BasicMemoryWriter<char> MemoryWriter;
3163 | ArrayWriter | BasicArrayWriter<char> |
3169 template <typename Char>
3170 class BasicArrayWriter : public BasicWriter<Char> {
3172 internal::FixedBuffer<Char> buffer_;
3181 BasicArrayWriter(Char *array, std::size_t size)
3182 : BasicWriter<Char>(buffer_), buffer_(array, size) {}
3191 explicit BasicArrayWriter(Char (&array)[SIZE])
3192 : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
3195 typedef BasicArrayWriter<char> ArrayWriter;
3230 const char *filename = "madeup";
3313 mutable char buffer_[BUFFER_SIZE];
3314 char *str_;
3317 char *format_decimal(ULongLong value) {
3318 char *buffer_end = buffer_ + BUFFER_SIZE - 1;
3329 *--buffer_end = static_cast<char>('0' + value);
3365 const char *data() const { return str_; }
3371 const char *c_str() const {
3388 inline void format_decimal(char *&buffer, T value) {
3397 *buffer++ = static_cast<char>('0' + abs_value);
3421 inline internal::NamedArgWithType<char, T> arg(StringRef name, const T &arg) {
3422 return internal::NamedArgWithType<char, T>(name, arg);
3432 template <typename Char>
3433 void arg(StringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
3434 template <typename Char>
3435 void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
3465 # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
3471 ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
3478 # define FMT_WRAP(Char, ReturnType, func, call, n, ...) \
3483 FMT_GEN(n, FMT_ASSIGN_##Char); \
3488 # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
3492 FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \
3493 FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \
3494 FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \
3495 FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \
3496 FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \
3497 FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \
3498 FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \
3499 FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \
3500 FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \
3501 FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \
3502 FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \
3503 FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \
3504 FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \
3505 FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \
3506 FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__)
3516 void print_error(const char *file, int line, const char *format,
3521 FMT_VARIADIC(void, print_error, const char *, int, const char *)
3529 void print_error(const char *file, int line, const char *format,
3537 FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__)
3572 template <typename Char>
3573 inline bool is_name_start(Char c) {
3579 template <typename Char>
3580 unsigned parse_nonnegative_int(const Char *&s) {
3599 inline void require_numeric_argument(const Arg &arg, char spec) {
3607 template <typename Char>
3608 void check_sign(const Char *&s, const Arg &arg) {
3609 char sign = static_cast<char>(*s);
3619 template <typename Char, typename AF>
3620 inline internal::Arg BasicFormatter<Char, AF>::get_arg(
3621 BasicStringRef<Char> arg_name, const char *&error) {
3632 template <typename Char, typename AF>
3633 inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s) {
3634 const char *error = FMT_NULL;
3644 template <typename Char, typename AF>
3645 inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s) {
3647 const Char *start = s;
3648 Char c;
3652 const char *error = FMT_NULL;
3653 internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
3659 template <typename Char, typename ArgFormatter>
3660 const Char *BasicFormatter<Char, ArgFormatter>::format(
3661 const Char *&format_str, const internal::Arg &arg) {
3663 const Char *s = format_str;
3672 if (Char c = *s) {
3673 const Char *p = s + 1;
3818 spec.type_ = static_cast<char>(*s++);
3829 template <typename Char, typename AF>
3830 void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str) {
3831 const Char *s = format_str.c_str();
3832 const Char *start = s;
3834 Char c = *s++;
3856 template <typename Char>
3858 const Char *str;
3867 template <typename Char>
3869 const Char *str;
3872 NamedArgWithType<Char, T> operator=(T &&value) const {
3891 inline internal::UdlFormat<char>
3892 operator"" _format(const char *s, std::size_t) { return {s}; }
3906 inline internal::UdlArg<char>
3907 operator"" _a(const char *s, std::size_t) { return {s}; }
