Diff 377857

libcxx/include/CMakeLists.txt

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines	set(files
__format/format_arg.h		__format/format_arg.h
__format/format_args.h		__format/format_args.h
__format/format_context.h		__format/format_context.h
__format/format_error.h		__format/format_error.h
__format/format_fwd.h		__format/format_fwd.h
__format/format_parse_context.h		__format/format_parse_context.h
__format/format_string.h		__format/format_string.h
__format/formatter.h		__format/formatter.h
		__format/formatter_char.h
__format/formatter_integer.h		__format/formatter_integer.h
__format/formatter_integral.h		__format/formatter_integral.h
__format/formatter_string.h		__format/formatter_string.h
__format/parser_std_format_spec.h		__format/parser_std_format_spec.h
__function_like.h		__function_like.h
__functional_base		__functional_base
__functional/binary_function.h		__functional/binary_function.h
__functional/binary_negate.h		__functional/binary_negate.h
▲ Show 20 Lines • Show All 341 Lines • Show Last 20 Lines

libcxx/include/__format/formatter_char.h

This file was added.

				// -- C++ --
				//===----------------------------------------------------------------------===//
				//
				// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
				// See https://llvm.org/LICENSE.txt for license information.
				// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
				//
				//===----------------------------------------------------------------------===//

				#ifndef _LIBCPP___FORMAT_FORMATTER_CHAR_H
				#define _LIBCPP___FORMAT_FORMATTER_CHAR_H

				#include <__availability>
				#include <__config>
				#include <__format/format_error.h>
				#include <__format/format_fwd.h>
				#include <__format/formatter.h>
				#include <__format/formatter_integral.h>
				#include <__format/parser_std_format_spec.h>

				#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
				#pragma GCC system_header
				#endif

				_LIBCPP_BEGIN_NAMESPACE_STD

				#if _LIBCPP_STD_VER > 17

				// TODO FMT Remove this once we require compilers with proper C++20 support.
				// If the compiler has no concepts support, the format header will be disabled.
				// Without concepts support enable_if needs to be used and that too much effort
				// to support compilers with partial C++20 support.
				#if !defined(_LIBCPP_HAS_NO_CONCEPTS)

				namespace __format_spec {

				template <class _CharT>
				class _LIBCPP_TEMPLATE_VIS __parser_char : public __parser_integral<_CharT> {
				public:
				_LIBCPP_HIDE_FROM_ABI constexpr auto parse(auto& __parse_ctx)
				-> decltype(__parse_ctx.begin()) {
				auto __it = __parser_integral<_CharT>::__parse(__parse_ctx);

				switch (this->__type) {
				case _Flags::_Type::__default:
				this->__type = _Flags::_Type::__char;
				[[fallthrough]];
				MordanteAuthorUnsubmitted Done Reply Inline Actions `s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/` here and all other occurrences in this patch. Mordante: `s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/` here and all other occurrences in this…
				case _Flags::_Type::__char:
				this->__handle_char();
				break;

				case _Flags::_Type::__binary_lower_case:
				case _Flags::_Type::__binary_upper_case:
				case _Flags::_Type::__octal:
				case _Flags::_Type::__decimal:
				case _Flags::_Type::__hexadecimal_lower_case:
				case _Flags::_Type::__hexadecimal_upper_case:
				this->__handle_integer();
				break;

				default:
				__throw_format_error(
				"The format-spec type has a type not supported for a char argument");
				}

				return __it;
				}
				};

				template <class _CharT>
				using __formatter_char = __formatter_integral<__parser_char<_CharT>>;

				} // namespace __format_spec

				// [format.formatter.spec]/2.1 The specializations

				template <>
				struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, char>
				: public __format_spec::__formatter_char<char> {};

				template <>
				struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, wchar_t>
				: public __format_spec::__formatter_char<wchar_t> {
				using _Base = __format_spec::__formatter_char<wchar_t>;

				_LIBCPP_HIDE_FROM_ABI auto format(char __value, auto& __ctx)
				-> decltype(__ctx.out()) {
				return _Base::format(static_cast<wchar_t>(__value), __ctx);
				}
				};

				template <>
				struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
				formatter<wchar_t, wchar_t>
				: public __format_spec::__formatter_char<wchar_t> {};

				#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)

				#endif //_LIBCPP_STD_VER > 17

				_LIBCPP_END_NAMESPACE_STD

				#endif // _LIBCPP___FORMAT_FORMATTER_CHAR_H

libcxx/include/format

Show First 20 Lines • Show All 273 Lines • ▼ Show 20 Lines
#include <__format/format_arg.h>		#include <__format/format_arg.h>
#include <__format/format_args.h>		#include <__format/format_args.h>
#include <__format/format_context.h>		#include <__format/format_context.h>
#include <__format/format_error.h>		#include <__format/format_error.h>
#include <__format/format_fwd.h>		#include <__format/format_fwd.h>
#include <__format/format_parse_context.h>		#include <__format/format_parse_context.h>
#include <__format/format_string.h>		#include <__format/format_string.h>
#include <__format/formatter.h>		#include <__format/formatter.h>
		#include <__format/formatter_char.h>
#include <__format/formatter_integer.h>		#include <__format/formatter_integer.h>
#include <__format/formatter_string.h>		#include <__format/formatter_string.h>
#include <__format/parser_std_format_spec.h>		#include <__format/parser_std_format_spec.h>
#include <__variant/monostate.h>		#include <__variant/monostate.h>
#include <array>		#include <array>
#include <concepts>		#include <concepts>
#include <string>		#include <string>
#include <string_view>		#include <string_view>
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines	make_format_args(const _Args&... __args) {
return {basic_format_arg<_Context>(__args)...};		return {basic_format_arg<_Context>(__args)...};
}		}

template <class... _Args>		template <class... _Args>
_LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...>		_LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...>
make_wformat_args(const _Args&... __args) {		make_wformat_args(const _Args&... __args) {
return _VSTD::make_format_args<wformat_context>(__args...);		return _VSTD::make_format_args<wformat_context>(__args...);
}		}

namespace __format {		namespace __format {
template <class _Tp, class _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_char {
_LIBCPP_HIDE_FROM_ABI
auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
// TODO FMT Implement this function.
return __parse_ctx.begin();
}

_LIBCPP_HIDE_FROM_ABI
auto format(_Tp __c, auto& __ctx) -> decltype(__ctx.out()) {
// TODO FMT Implement the parsed formatting arguments.
auto __out_it = __ctx.out();
*__out_it++ = _CharT(__c);
return __out_it;
}
};

template <class _Tp, class _CharT>		template <class _Tp, class _CharT>
requires(is_arithmetic_v<_Tp> &&		requires(is_arithmetic_v<_Tp> &&
!same_as<_Tp, bool>) struct _LIBCPP_HIDE_FROM_ABI		!same_as<_Tp, bool>) struct _LIBCPP_HIDE_FROM_ABI
__formatter_arithmetic {		__formatter_arithmetic {
_LIBCPP_HIDE_FROM_ABI		_LIBCPP_HIDE_FROM_ABI
auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {		auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) {
// TODO FMT Implement		// TODO FMT Implement
Show All 33 Lines	_LIBCPP_HIDDEN auto __handle_format(_Uv __value, auto& __ctx)
return __out_it;		return __out_it;
}		}
};		};
} // namespace __format		} // namespace __format

// These specializations are helper stubs and not proper formatters.		// These specializations are helper stubs and not proper formatters.
// TODO FMT Implement the proper formatter specializations.		// TODO FMT Implement the proper formatter specializations.

// [format.formatter.spec]/2.1 The specializations

template <>
struct _LIBCPP_TEMPLATE_VIS formatter<char, char>
: public __format::__formatter_char<char, char> {};

template <>
struct _LIBCPP_TEMPLATE_VIS formatter<char, wchar_t>
: public __format::__formatter_char<char, wchar_t> {};

template <>
struct _LIBCPP_TEMPLATE_VIS formatter<wchar_t, wchar_t>
: public __format::__formatter_char<wchar_t, wchar_t> {};

// [format.formatter.spec]/2.3		// [format.formatter.spec]/2.3
// For each charT, for each cv-unqualified arithmetic type ArithmeticT other		// For each charT, for each cv-unqualified arithmetic type ArithmeticT other
// than char, wchar_t, char8_t, char16_t, or char32_t, a specialization		// than char, wchar_t, char8_t, char16_t, or char32_t, a specialization

// Boolean.		// Boolean.
template <class _CharT>		template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS formatter<bool, _CharT> {		struct _LIBCPP_TEMPLATE_VIS formatter<bool, _CharT> {
_LIBCPP_HIDE_FROM_ABI		_LIBCPP_HIDE_FROM_ABI
▲ Show 20 Lines • Show All 367 Lines • Show Last 20 Lines

libcxx/include/module.modulemap

Show First 20 Lines • Show All 444 Lines • ▼ Show 20 Lines	module __format {
export optional		export optional
export locale		export locale
}		}
module format_error { private header "__format/format_error.h" }		module format_error { private header "__format/format_error.h" }
module format_fwd { private header "__format/format_fwd.h" }		module format_fwd { private header "__format/format_fwd.h" }
module format_parse_context { private header "__format/format_parse_context.h" }		module format_parse_context { private header "__format/format_parse_context.h" }
module format_string { private header "__format/format_string.h" }		module format_string { private header "__format/format_string.h" }
module formatter { private header "__format/formatter.h" }		module formatter { private header "__format/formatter.h" }
		module formatter_char { private header "__format/formatter_char.h" }
module formatter_integer { private header "__format/formatter_integer.h" }		module formatter_integer { private header "__format/formatter_integer.h" }
module formatter_integral { private header "__format/formatter_integral.h" }		module formatter_integral { private header "__format/formatter_integral.h" }
module formatter_string { private header "__format/formatter_string.h" }		module formatter_string { private header "__format/formatter_string.h" }
module parser_std_format_spec { private header "__format/parser_std_format_spec.h" }		module parser_std_format_spec { private header "__format/parser_std_format_spec.h" }
}		}
}		}
module forward_list {		module forward_list {
header "forward_list"		header "forward_list"
▲ Show 20 Lines • Show All 514 Lines • Show Last 20 Lines

libcxx/test/libcxx/diagnostics/detail.headers/format/formatter_char.module.verify.cpp

This file was added.

				// -- C++ --
				//===----------------------------------------------------------------------===//
				//
				// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
				// See https://llvm.org/LICENSE.txt for license information.
				// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
				//
				//===----------------------------------------------------------------------===//

				// REQUIRES: modules-build

				// WARNING: This test was generated by 'generate_private_header_tests.py'
				// and should not be edited manually.

				// expected-error@: {{use of private header from outside its module: '__format/formatter_char.h'}}
				#include <__format/formatter_char.h>

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_char.pass.cpp

This file was added.

				//===----------------------------------------------------------------------===//
				// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
				// See https://llvm.org/LICENSE.txt for license information.
				// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
				//
				//===----------------------------------------------------------------------===//

				// UNSUPPORTED: c++03, c++11, c++14, c++17
				// UNSUPPORTED: libcpp-no-concepts
				// UNSUPPORTED: libcpp-has-no-incomplete-format

				// <format>

				// Tests the parsing of the format string as specified in [format.string.std].
				// It validates whether the std-format-spec is valid for a char type.

				#include <format>
				#include <cassert>
				#ifndef _LIBCPP_HAS_NO_LOCALIZATION
				# include <iostream>
				#endif

				#include "concepts_precision.h"
				#include "test_macros.h"
				#include "make_string.h"
				#include "test_exception.h"

				#define CSTR(S) MAKE_CSTRING(CharT, S)

				using namespace std::__format_spec;

				template <class CharT>
				using Parser = __parser_char<CharT>;

				template <class CharT>
				struct Expected {
				CharT fill = CharT(' ');
				_Flags::_Alignment alignment = _Flags::_Alignment::__left;
				_Flags::_Sign sign = _Flags::_Sign::__default;
				bool alternate_form = false;
				bool zero_padding = false;
				uint32_t width = 0;
				bool width_as_arg = false;
				bool locale_specific_form = false;
				_Flags::_Type type = _Flags::_Type::__char;
				};

				template <class CharT>
				constexpr void test(Expected<CharT> expected, size_t size,
				std::basic_string_view<CharT> fmt) {
				// Initialize parser with sufficient arguments to avoid the parsing to fail
				// due to insufficient arguments.
				std::basic_format_parse_context<CharT> parse_ctx(fmt,
				std::__format::__number_max);
				auto begin = parse_ctx.begin();
				auto end = parse_ctx.end();
				Parser<CharT> parser;
				auto it = parser.parse(parse_ctx);

				assert(begin == parse_ctx.begin());
				assert(end == parse_ctx.end());

				assert(begin + size == it);
				assert(parser.__fill == expected.fill);
				assert(parser.__alignment == expected.alignment);
				assert(parser.__sign == expected.sign);
				assert(parser.__alternate_form == expected.alternate_form);
				assert(parser.__zero_padding == expected.zero_padding);
				assert(parser.__width == expected.width);
				assert(parser.__width_as_arg == expected.width_as_arg);
				assert(parser.__locale_specific_form == expected.locale_specific_form);
				assert(parser.__type == expected.type);
				}

				template <class CharT>
				constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
				// The format-spec is valid if completely consumed or terminates at a '}'.
				// The valid inputs all end with a '}'. The test is executed twice:
				// - first with the terminating '}',
				// - second consuming the entire input.
				std::basic_string_view<CharT> fmt{f};
				assert(fmt.back() == CharT('}') && "Pre-condition failure");

				test(expected, size, fmt);
				fmt.remove_suffix(1);
				test(expected, size, fmt);
				}

				template <class CharT>
				constexpr void test_as_char() {

				test({}, 1, CSTR("c}"));

				// * Align-fill *
				test({.alignment = _Flags::_Alignment::__left}, 1, CSTR("<}"));
				test({.alignment = _Flags::_Alignment::__center}, 1, "^}");
				test({.alignment = _Flags::_Alignment::__right}, 1, ">}");

				test({.alignment = _Flags::_Alignment::__left}, 2, CSTR("<c}"));
				test({.alignment = _Flags::_Alignment::__center}, 2, "^c}");
				test({.alignment = _Flags::_Alignment::__right}, 2, ">c}");

				test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 2,
				CSTR("L<}"));
				test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 2,
				CSTR("#^}"));
				test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 2,
				CSTR("0>}"));

				test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 3,
				CSTR("L<c}"));
				test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 3,
				CSTR("#^c}"));
				test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 3,
				CSTR("0>c}"));

				// * Sign *
				test_exception<Parser<CharT>>(
				"A sign field isn't allowed in this format-spec", CSTR("-"));
				test_exception<Parser<CharT>>(
				"A sign field isn't allowed in this format-spec", CSTR("+"));
				test_exception<Parser<CharT>>(
				"A sign field isn't allowed in this format-spec", CSTR(" "));

				test_exception<Parser<CharT>>(
				"A sign field isn't allowed in this format-spec", CSTR("-c"));
				test_exception<Parser<CharT>>(
				"A sign field isn't allowed in this format-spec", CSTR("+c"));
				test_exception<Parser<CharT>>(
				"A sign field isn't allowed in this format-spec", CSTR(" c"));

				// * Alternate form *
				test_exception<Parser<CharT>>(
				"An alternate form field isn't allowed in this format-spec", CSTR("#}"));
				test_exception<Parser<CharT>>(
				"An alternate form field isn't allowed in this format-spec", CSTR("#c}"));

				// * Zero padding *
				test_exception<Parser<CharT>>(
				"A zero-padding field isn't allowed in this format-spec", CSTR("0}"));
				test_exception<Parser<CharT>>(
				"A zero-padding field isn't allowed in this format-spec", CSTR("0c}"));

				// * Width *
				test({.width = 0, .width_as_arg = false}, 0, CSTR("}"));
				test({.width = 1, .width_as_arg = false}, 1, CSTR("1}"));
				test({.width = 10, .width_as_arg = false}, 2, CSTR("10}"));
				test({.width = 1000, .width_as_arg = false}, 4, CSTR("1000}"));
				test({.width = 1000000, .width_as_arg = false}, 7, CSTR("1000000}"));

				test({.width = 0, .width_as_arg = true}, 2, CSTR("{}}"));
				test({.width = 0, .width_as_arg = true}, 3, CSTR("{0}}"));
				test({.width = 1, .width_as_arg = true}, 3, CSTR("{1}}"));

				test_exception<Parser<CharT>>(
				"A format-spec width field shouldn't have a leading zero", CSTR("00"));

				static_assert(std::__format::__number_max == 2'147'483'647,
				"Update the assert and the test.");
				test({.width = 2'147'483'647, .width_as_arg = false}, 10,
				CSTR("2147483647}"));
				test_exception<Parser<CharT>>(
				"The numeric value of the format-spec is too large", CSTR("2147483648"));
				test_exception<Parser<CharT>>(
				"The numeric value of the format-spec is too large", CSTR("5000000000"));
				test_exception<Parser<CharT>>(
				"The numeric value of the format-spec is too large", CSTR("10000000000"));

				test_exception<Parser<CharT>>("End of input while parsing format-spec arg-id",
				CSTR("{"));
				test_exception<Parser<CharT>>(
				"A format-spec arg-id should terminate at a '}'", CSTR("{0"));
				test_exception<Parser<CharT>>(
				"The arg-id of the format-spec starts with an invalid character",
				CSTR("{a"));
				test_exception<Parser<CharT>>(
				vitautUnsubmitted Done Reply Inline Actions You already have this assert above. vitaut: You already have this assert above.
				MordanteAuthorUnsubmitted Done Reply Inline Actions True, but I like these kind of asserts closely "attached" to where they're needed. Mordante: True, but I like these kind of asserts closely "attached" to where they're needed.
				"A format-spec arg-id should terminate at a '}'", CSTR("{1"));
				test_exception<Parser<CharT>>(
				"A format-spec arg-id should terminate at a '}'", CSTR("{9"));
				test_exception<Parser<CharT>>(
				"A format-spec arg-id should terminate at a '}'", CSTR("{9:"));
				test_exception<Parser<CharT>>(
				"A format-spec arg-id should terminate at a '}'", CSTR("{9a"));

				static_assert(std::__format::__number_max == 2'147'483'647,
				"Update the assert and the test.");
				// Note the static_assert tests whether the arg-id is valid.
				// Therefore the following should be true arg-id < __format::__number_max.
				test({.width = 2'147'483'646, .width_as_arg = true}, 12,
				CSTR("{2147483646}}"));
				test_exception<Parser<CharT>>(
				"The numeric value of the format-spec is too large",
				CSTR("{2147483648}"));
				test_exception<Parser<CharT>>(
				"The numeric value of the format-spec is too large",
				CSTR("{5000000000}"));
				test_exception<Parser<CharT>>(
				"The numeric value of the format-spec is too large",
				CSTR("{10000000000}"));

				// * Precision *
				test_exception<Parser<CharT>>(
				"The format-spec should consume the input or end with a '}'", CSTR("."));
				test_exception<Parser<CharT>>(
				"The format-spec should consume the input or end with a '}'", CSTR(".1"));

				// * Locale-specific form *
				// Note the flag is allowed, but has no effect.
				test({.locale_specific_form = true}, 1, CSTR("L}"));
				test({.locale_specific_form = true}, 2, CSTR("Lc}"));
				}

				template <class CharT>
				constexpr void test_as_integer() {

				test({.alignment = _Flags::_Alignment::__right,
				.type = _Flags::_Type::__decimal},
				1, CSTR("d}"));

				// * Align-fill *
				test({.alignment = _Flags::_Alignment::__left,
				.type = _Flags::_Type::__decimal},
				2, CSTR("<d}"));
				test({.alignment = _Flags::_Alignment::__center,
				.type = _Flags::_Type::__decimal},
				2, "^d}");
				test({.alignment = _Flags::_Alignment::__right,
				.type = _Flags::_Type::__decimal},
				2, ">d}");

				test({.fill = CharT('L'),
				.alignment = _Flags::_Alignment::__left,
				.type = _Flags::_Type::__decimal},
				3, CSTR("L<d}"));
				test({.fill = CharT('#'),
				.alignment = _Flags::_Alignment::__center,
				.type = _Flags::_Type::__decimal},
				3, CSTR("#^d}"));
				test({.fill = CharT('0'),
				.alignment = _Flags::_Alignment::__right,
				.type = _Flags::_Type::__decimal},
				3, CSTR("0>d}"));

				// * Sign *
				test({.alignment = _Flags::_Alignment::__right,
				.sign = _Flags::_Sign::__minus,
				.type = _Flags::_Type::__decimal},
				2, CSTR("-d}"));
				test({.alignment = _Flags::_Alignment::__right,
				.sign = _Flags::_Sign::__plus,
				.type = _Flags::_Type::__decimal},
				2, CSTR("+d}"));
				test({.alignment = _Flags::_Alignment::__right,
				.sign = _Flags::_Sign::__space,
				.type = _Flags::_Type::__decimal},
				2, CSTR(" d}"));

				// * Alternate form *
				test({.alignment = _Flags::_Alignment::__right,
				.alternate_form = true,
				.type = _Flags::_Type::__decimal},
				2, CSTR("#d}"));

				// * Zero padding *
				test({.alignment = _Flags::_Alignment::__default,
				.zero_padding = true,
				.type = _Flags::_Type::__decimal},
				2, CSTR("0d}"));
				test({.alignment = _Flags::_Alignment::__center,
				.type = _Flags::_Type::__decimal},
				3, CSTR("^0d}"));

				// * Width *
				test({.alignment = _Flags::_Alignment::__right,
				.width = 0,
				.width_as_arg = false,
				.type = _Flags::_Type::__decimal},
				1, CSTR("d}"));
				test({.alignment = _Flags::_Alignment::__right,
				.width = 1,
				.width_as_arg = false,
				.type = _Flags::_Type::__decimal},
				2, CSTR("1d}"));
				test({.alignment = _Flags::_Alignment::__right,
				.width = 10,
				.width_as_arg = false,
				.type = _Flags::_Type::__decimal},
				3, CSTR("10d}"));
				test({.alignment = _Flags::_Alignment::__right,
				.width = 1000,
				.width_as_arg = false,
				.type = _Flags::_Type::__decimal},
				5, CSTR("1000d}"));
				test({.alignment = _Flags::_Alignment::__right,
				.width = 1000000,
				.width_as_arg = false,
				.type = _Flags::_Type::__decimal},
				8, CSTR("1000000d}"));

				test({.alignment = _Flags::_Alignment::__right,
				.width = 0,
				.width_as_arg = true,
				.type = _Flags::_Type::__decimal},
				3, CSTR("{}d}"));
				test({.alignment = _Flags::_Alignment::__right,
				.width = 0,
				.width_as_arg = true,
				.type = _Flags::_Type::__decimal},
				4, CSTR("{0}d}"));
				test({.alignment = _Flags::_Alignment::__right,
				.width = 1,
				.width_as_arg = true,
				.type = _Flags::_Type::__decimal},
				4, CSTR("{1}d}"));

				// * Precision *
				test_exception<Parser<CharT>>(
				"The format-spec should consume the input or end with a '}'", CSTR("."));
				test_exception<Parser<CharT>>(
				"The format-spec should consume the input or end with a '}'", CSTR(".1"));

				// * Locale-specific form *
				test({.alignment = _Flags::_Alignment::__right,
				.locale_specific_form = true,
				.type = _Flags::_Type::__decimal},
				2, CSTR("Ld}"));
				}

				template <class CharT>
				constexpr void test() {
				Parser<CharT> parser;

				assert(parser.__fill == CharT(' '));
				assert(parser.__alignment == _Flags::_Alignment::__default);
				assert(parser.__sign == _Flags::_Sign::__default);
				assert(parser.__alternate_form == false);
				assert(parser.__zero_padding == false);
				assert(parser.__width == 0);
				assert(parser.__width_as_arg == false);
				static_assert(!has_precision<decltype(parser)>);
				static_assert(!has_precision_as_arg<decltype(parser)>);
				assert(parser.__locale_specific_form == false);
				assert(parser.__type == _Flags::_Type::__default);

				test({}, 0, CSTR("}"));

				test_as_char<CharT>();
				test_as_integer<CharT>();

				// * Type *
				{
				const char* unsuported_type =
				"The format-spec type has a type not supported for a char argument";
				const char* not_a_type =
				"The format-spec should consume the input or end with a '}'";

				test_exception<Parser<CharT>>(unsuported_type, CSTR("A}"));
				test({.alignment = _Flags::_Alignment::__right,
				.type = _Flags::_Type::__binary_upper_case},
				1, CSTR("B}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("C}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("D}"));
				test_exception<Parser<CharT>>(unsuported_type, CSTR("E}"));
				test_exception<Parser<CharT>>(unsuported_type, CSTR("F}"));
				test_exception<Parser<CharT>>(unsuported_type, CSTR("G}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("H}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("I}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("J}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("K}"));
				test({.locale_specific_form = true}, 1, CSTR("L}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("M}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("N}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("O}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("P}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("Q}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("R}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("S}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("T}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("U}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("V}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("W}"));
				test({.alignment = _Flags::_Alignment::__right,
				.type = _Flags::_Type::__hexadecimal_upper_case},
				1, CSTR("X}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("Y}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("Z}"));

				test_exception<Parser<CharT>>(unsuported_type, CSTR("a}"));
				test({.alignment = _Flags::_Alignment::__right,
				.type = _Flags::_Type::__binary_lower_case},
				1, CSTR("b}"));
				test({.type = _Flags::_Type::__char}, 1, CSTR("c}"));
				test({.alignment = _Flags::_Alignment::__right,
				.type = _Flags::_Type::__decimal},
				1, CSTR("d}"));
				test_exception<Parser<CharT>>(unsuported_type, CSTR("e}"));
				test_exception<Parser<CharT>>(unsuported_type, CSTR("f}"));
				test_exception<Parser<CharT>>(unsuported_type, CSTR("g}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("h}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("i}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("j}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("k}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("l}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("m}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("n}"));
				test({.alignment = _Flags::_Alignment::__right,
				.type = _Flags::_Type::__octal},
				1, CSTR("o}"));
				test_exception<Parser<CharT>>(unsuported_type, CSTR("p}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("q}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("r}"));
				test_exception<Parser<CharT>>(unsuported_type, CSTR("s}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("t}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("u}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("v}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("w}"));
				test({.alignment = _Flags::_Alignment::__right,
				.type = _Flags::_Type::__hexadecimal_lower_case},
				1, CSTR("x}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("y}"));
				test_exception<Parser<CharT>>(not_a_type, CSTR("z}"));
				}

				// ** General *
				test_exception<Parser<CharT>>(
				"The format-spec should consume the input or end with a '}'", CSTR("ss"));
				}

				constexpr bool test() {
				test<char>();
				test<wchar_t>();

				return true;
				}

				int main(int, char**) {
				#ifndef _WIN32
				// TODO FMT Investigate why this doesn't work.
				ldionneUnsubmitted Done Reply Inline Actions Can you add a comment explaining why that's not satisfied on Windows? ldionne: Can you add a comment explaining why that's not satisfied on Windows?
				MordanteAuthorUnsubmitted Done Reply Inline Actions I added a TODO FMT. LWG 3576 will probably change the size of the `Parser`. Mordante: I added a TODO FMT. LWG 3576 will probably change the size of the `Parser`.
				// (Wait until LWG-3576 has been resolved.)
				// Make sure the parsers match the expectations. The layout of the
				// subobjects is chosen to minimize the size required.
				static_assert(sizeof(Parser<char>) == 2 * sizeof(uint32_t));
				static_assert(
				sizeof(Parser<wchar_t>) ==
				(sizeof(wchar_t) <= 2 ? 2 * sizeof(uint32_t) : 3 * sizeof(uint32_t)));
				#endif

				test();
				static_assert(test());

				return 0;
				}

libcxx/test/std/utilities/format/format.functions/format_tests.h

Show First 20 Lines • Show All 582 Lines • ▼ Show 20 Lines	check(STR("18446744073709551615"), STR("{:#}"),
std::numeric_limits<uint64_t>::max());		std::numeric_limits<uint64_t>::max());
check(STR("0xffffffffffffffff"), STR("{:#x}"),		check(STR("0xffffffffffffffff"), STR("{:#x}"),
std::numeric_limits<uint64_t>::max());		std::numeric_limits<uint64_t>::max());

// TODO FMT Add __uint128_t test after implementing full range.		// TODO FMT Add __uint128_t test after implementing full range.
}		}

template <class CharT, class TestFunction, class ExceptionTest>		template <class CharT, class TestFunction, class ExceptionTest>
		void format_test_char(TestFunction check, ExceptionTest check_exception) {

		// *** Char type ***
		// * align-fill & width *
		check(STR("answer is '* '"), STR("answer is '{:6}'"), CharT('*'));
		check(STR("answer is ' '"), STR("answer is '{:>6}'"), CharT(''));
		check(STR("answer is '* '"), STR("answer is '{:<6}'"), CharT('*'));
		check(STR("answer is ' * '"), STR("answer is '{:^6}'"), CharT('*'));

		check(STR("answer is '* '"), STR("answer is '{:6c}'"), CharT('*'));
		check(STR("answer is ' '"), STR("answer is '{:>6c}'"), CharT(''));
		check(STR("answer is '* '"), STR("answer is '{:<6c}'"), CharT('*'));
		check(STR("answer is ' * '"), STR("answer is '{:^6c}'"), CharT('*'));

		check(STR("answer is '-----'"), STR("answer is '{:->6}'"), CharT(''));
		check(STR("answer is '-----'"), STR("answer is '{:-<6}'"), CharT(''));
		check(STR("answer is '-----'"), STR("answer is '{:-^6}'"), CharT(''));

		check(STR("answer is '-----'"), STR("answer is '{:->6c}'"), CharT(''));
		check(STR("answer is '-----'"), STR("answer is '{:-<6c}'"), CharT(''));
		check(STR("answer is '-----'"), STR("answer is '{:-^6c}'"), CharT(''));

		// * Sign *
		check_exception("A sign field isn't allowed in this format-spec", STR("{:-}"),
		CharT('*'));
		check_exception("A sign field isn't allowed in this format-spec", STR("{:+}"),
		CharT('*'));
		check_exception("A sign field isn't allowed in this format-spec", STR("{: }"),
		CharT('*'));

		check_exception("A sign field isn't allowed in this format-spec",
		STR("{:-c}"), CharT('*'));
		check_exception("A sign field isn't allowed in this format-spec",
		STR("{:+c}"), CharT('*'));
		check_exception("A sign field isn't allowed in this format-spec",
		STR("{: c}"), CharT('*'));

		// * alternate form *
		check_exception("An alternate form field isn't allowed in this format-spec",
		STR("{:#}"), CharT('*'));
		check_exception("An alternate form field isn't allowed in this format-spec",
		STR("{:#c}"), CharT('*'));

		// * zero-padding *
		check_exception("A zero-padding field isn't allowed in this format-spec",
		STR("{:0}"), CharT('*'));
		check_exception("A zero-padding field isn't allowed in this format-spec",
		STR("{:0c}"), CharT('*'));

		// * precision *
		check_exception("The format-spec should consume the input or end with a '}'",
		STR("{:.}"), CharT('*'));
		check_exception("The format-spec should consume the input or end with a '}'",
		STR("{:.0}"), CharT('*'));
		check_exception("The format-spec should consume the input or end with a '}'",
		STR("{:.42}"), CharT('*'));

		check_exception("The format-spec should consume the input or end with a '}'",
		STR("{:.c}"), CharT('*'));
		check_exception("The format-spec should consume the input or end with a '}'",
		STR("{:.0c}"), CharT('*'));
		check_exception("The format-spec should consume the input or end with a '}'",
		STR("{:.42c}"), CharT('*'));

		// * locale-specific form *
		// Note it has no effect but it's allowed.
		check(STR("answer is ''"), STR("answer is '{:L}'"), '');
		check(STR("answer is ''"), STR("answer is '{:Lc}'"), '');

		// * type *
		for (const auto& fmt : invalid_types<CharT>("bBcdoxX"))
		check_exception(
		"The format-spec type has a type not supported for a char argument",
		fmt, CharT('*'));
		}

		template <class CharT, class TestFunction, class ExceptionTest>
		void format_test_char_as_integer(TestFunction check,
		ExceptionTest check_exception) {
		// * align-fill & width *
		check(STR("answer is '42'"), STR("answer is '{:<1d}'"), CharT('*'));

		check(STR("answer is '42'"), STR("answer is '{:<2d}'"), CharT('*'));
		check(STR("answer is '42 '"), STR("answer is '{:<3d}'"), CharT('*'));

		check(STR("answer is ' 42'"), STR("answer is '{:7d}'"), CharT('*'));
		check(STR("answer is ' 42'"), STR("answer is '{:>7d}'"), CharT('*'));
		check(STR("answer is '42 '"), STR("answer is '{:<7d}'"), CharT('*'));
		check(STR("answer is ' 42 '"), STR("answer is '{:^7d}'"), CharT('*'));

		check(STR("answer is '****42'"), STR("answer is '{:>7d}'"), CharT('*'));
		check(STR("answer is '42****'"), STR("answer is '{:<7d}'"), CharT('*'));
		check(STR("answer is '42'"), STR("answer is '{:^7d}'"), CharT('*'));

		// Test whether zero padding is ignored
		check(STR("answer is ' 42'"), STR("answer is '{:>07d}'"), CharT('*'));
		check(STR("answer is '42 '"), STR("answer is '{:<07d}'"), CharT('*'));
		check(STR("answer is ' 42 '"), STR("answer is '{:^07d}'"), CharT('*'));

		// * Sign *
		check(STR("answer is 42"), STR("answer is {:d}"), CharT('*'));
		check(STR("answer is 42"), STR("answer is {:-d}"), CharT('*'));
		check(STR("answer is +42"), STR("answer is {:+d}"), CharT('*'));
		check(STR("answer is 42"), STR("answer is {: d}"), CharT('*'));

		// * alternate form *
		check(STR("answer is +42"), STR("answer is {:+#d}"), CharT('*'));
		check(STR("answer is +101010"), STR("answer is {:+b}"), CharT('*'));
		check(STR("answer is +0b101010"), STR("answer is {:+#b}"), CharT('*'));
		check(STR("answer is +0B101010"), STR("answer is {:+#B}"), CharT('*'));
		check(STR("answer is +52"), STR("answer is {:+o}"), CharT('*'));
		check(STR("answer is +052"), STR("answer is {:+#o}"), CharT('*'));
		check(STR("answer is +2a"), STR("answer is {:+x}"), CharT('*'));
		check(STR("answer is +0x2a"), STR("answer is {:+#x}"), CharT('*'));
		check(STR("answer is +2A"), STR("answer is {:+X}"), CharT('*'));
		check(STR("answer is +0X2A"), STR("answer is {:+#X}"), CharT('*'));

		// * zero-padding & width *
		check(STR("answer is +00000000042"), STR("answer is {:+#012d}"), CharT('*'));
		check(STR("answer is +00000101010"), STR("answer is {:+012b}"), CharT('*'));
		check(STR("answer is +0b000101010"), STR("answer is {:+#012b}"), CharT('*'));
		check(STR("answer is +0B000101010"), STR("answer is {:+#012B}"), CharT('*'));
		check(STR("answer is +00000000052"), STR("answer is {:+012o}"), CharT('*'));
		check(STR("answer is +00000000052"), STR("answer is {:+#012o}"), CharT('*'));
		check(STR("answer is +0000000002a"), STR("answer is {:+012x}"), CharT('*'));
		check(STR("answer is +0x00000002a"), STR("answer is {:+#012x}"), CharT('*'));
		check(STR("answer is +0000000002A"), STR("answer is {:+012X}"), CharT('*'));

		check(STR("answer is +0X00000002A"), STR("answer is {:+#012X}"), CharT('*'));

		// * precision *
		check_exception("The format-spec should consume the input or end with a '}'",
		STR("{:.d}"), CharT('*'));
		check_exception("The format-spec should consume the input or end with a '}'",
		STR("{:.0d}"), CharT('*'));
		check_exception("The format-spec should consume the input or end with a '}'",
		STR("{:.42d}"), CharT('*'));

		// * locale-specific form *
		// See locale-specific_form.pass.cpp

		// * type *
		for (const auto& fmt : invalid_types<CharT>("bBcdoxX"))
		check_exception(
		"The format-spec type has a type not supported for a char argument",
		fmt, '*');
		}

		template <class CharT, class TestFunction, class ExceptionTest>
void format_tests(TestFunction check, ExceptionTest check_exception) {		void format_tests(TestFunction check, ExceptionTest check_exception) {
// * Test escaping *		// * Test escaping *
check(STR("{"), STR("{{"));		check(STR("{"), STR("{{"));
check(STR("}"), STR("}}"));		check(STR("}"), STR("}}"));

// * Test argument ID *		// * Test argument ID *
check(STR("hello 01"), STR("hello {0:}{1:}"), false, true);		check(STR("hello 01"), STR("hello {0:}{1:}"), false, true);
check(STR("hello 10"), STR("hello {1:}{0:}"), false, true);		check(STR("hello 10"), STR("hello {1:}{0:}"), false, true);
Show All 18 Lines	void format_tests(TestFunction check, ExceptionTest check_exception) {
check_exception("Argument index out of bounds", STR("hello {0}"));		check_exception("Argument index out of bounds", STR("hello {0}"));
check_exception("Argument index out of bounds", STR("hello {1}"), 42);		check_exception("Argument index out of bounds", STR("hello {1}"), 42);

// * Test char format argument *		// * Test char format argument *
// The `char` to `wchar_t` formatting is tested separately.		// The `char` to `wchar_t` formatting is tested separately.
check(STR("hello 09azAZ!"), STR("hello {}{}{}{}{}{}{}"), CharT('0'),		check(STR("hello 09azAZ!"), STR("hello {}{}{}{}{}{}{}"), CharT('0'),
CharT('9'), CharT('a'), CharT('z'), CharT('A'), CharT('Z'), CharT('!'));		CharT('9'), CharT('a'), CharT('z'), CharT('A'), CharT('Z'), CharT('!'));

		format_test_char<CharT>(check, check_exception);
		format_test_char_as_integer<CharT>(check, check_exception);

// * Test string format argument *		// * Test string format argument *
{		{
CharT buffer[] = {CharT('0'), CharT('9'), CharT('a'), CharT('z'),		CharT buffer[] = {CharT('0'), CharT('9'), CharT('a'), CharT('z'),
CharT('A'), CharT('Z'), CharT('!'), 0};		CharT('A'), CharT('Z'), CharT('!'), 0};
CharT* data = buffer;		CharT* data = buffer;
check(STR("hello 09azAZ!"), STR("hello {}"), data);		check(STR("hello 09azAZ!"), STR("hello {}"), data);
}		}
{		{
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[libc++][format] Adds char formatter.
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 377857

libcxx/include/CMakeLists.txt

libcxx/include/__format/formatter_char.h

libcxx/include/format

libcxx/include/module.modulemap

libcxx/test/libcxx/diagnostics/detail.headers/format/formatter_char.module.verify.cpp

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_char.pass.cpp

libcxx/test/std/utilities/format/format.functions/format_tests.h

This is an archive of the discontinued LLVM Phabricator instance.

[libc++][format] Adds char formatter.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 377857

libcxx/include/CMakeLists.txt

libcxx/include/__format/formatter_char.h

libcxx/include/format

libcxx/include/module.modulemap

libcxx/test/libcxx/diagnostics/detail.headers/format/formatter_char.module.verify.cpp

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_char.pass.cpp

libcxx/test/std/utilities/format/format.functions/format_tests.h

[libc++][format] Adds char formatter.
ClosedPublic