beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-25 00:50:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7
ladybird/AK/Format.h

723 lines
21 KiB
C
Raw Normal View History

AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
/*
* Copyright (c) 2020, the SerenityOS developers.
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
*/
#pragma once
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
#include <AK/CheckedFormatString.h>
AK: Add dbgln() format checking This checks the following things: - No unclosed braces in format string `dbgln("a:{}}", a)` where the '}}' would be interpreted as a literal '}' `dbgln("a:{", a)` where someone with a faulty keyboard like mine could generate - No extra closed braces in format string `dbgln("a:{{}", a)` where the '{{' would interpreted as a literal '{' `dbgln("a:}", a)` where someone with a faulty keyboard could generate - No references to nonexistent arguments `dbgln("a:{} b:{}", a)` where the value of `b` is not in the arguments list - No unconsumed argument `dbgln("a:{1}", not_used, 1)` where `not_used` is extraneous
2021-01-17 08:22:04 +00:00
#include <AK/AllOf.h>
#include <AK/AnyOf.h>
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
#include <AK/Array.h>
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
#include <AK/Error.h>
AK: Add Formatter<FixedPoint<...>> without floating point Rather than casting the FixedPoint to double, format the FixedPoint directly. This avoids using floating point instruction, which in turn enables this to be used even in the kernel.
2021-12-28 01:23:04 +00:00
#include <AK/FixedPoint.h>
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
#include <AK/Forward.h>
AK+Format: Remove TypeErasedFormatParams& from format function.
2020-12-30 11:14:15 +00:00
#include <AK/Optional.h>
AK: Remove strtoull dependency from format. This function is not avaliable in the kernel. In the future it would be nice to have some sort of <charconv> header that does this for all integer types and then call it in strtoull and et cetera. The difference would be that this function say 'from_chars' would return an Optional and not just interpret anything invalid as zero.
2020-09-22 11:05:40 +00:00
#include <AK/StringView.h>
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
AK+Format: Add outln(FILE*, ...) overload. This commit also removes a few functions like raw_out and vwarn. If we want to write raw output, we can do this as follows: out("{}", "Hello, World!"); The vout stuff isn't really public API anyways, so no need for another vwarn.
2020-10-15 11:46:00 +00:00
#ifndef KERNEL
# include <stdio.h>
AK+LibMain: Improve formatter for AK::Error in userspace Print the full associated string metadata by default (if available.)
2021-12-20 10:55:32 +00:00
# include <string.h>
AK+Format: Add outln(FILE*, ...) overload. This commit also removes a few functions like raw_out and vwarn. If we want to write raw output, we can do this as follows: out("{}", "Hello, World!"); The vout stuff isn't really public API anyways, so no need for another vwarn.
2020-10-15 11:46:00 +00:00
#endif
AK: Resolve format related circular dependencies properly. With this commit, <AK/Format.h> has a more supportive role and isn't used directly. Essentially, there now is a public 'vformat' function ('v' for vector) which takes already type erased parameters. The name is choosen to indicate that this function behaves similar to C-style functions taking a va_list equivalent. The interface for frontend users are now 'String::formatted' and 'StringBuilder::appendff'.
2020-09-23 11:21:18 +00:00
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
namespace AK {
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
class TypeErasedFormatParams;
class FormatParser;
class FormatBuilder;
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
template<typename T, typename = void>
AK+Format: Add SFINAE wrapper 'FormatIfSupported'.
2020-10-07 12:01:59 +00:00
struct Formatter {
using __no_formatter_defined = void;
};
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
AK: Add Formatter for Vector For debugging purposes, it is very useful to look at a Vector in a simple list representation. Therefore, the new Formatter for Vector provides a string representation of the following form: ``` [ 1, 2, 3, 4, 5 ] ``` This requires the content type of Vector to be formattable with default arguments. The current implementation ignores width and precision, which may be accounted for later or passed down to the content formatter.
2021-07-06 16:55:36 +00:00
template<typename T, typename = void>
inline constexpr bool HasFormatter = true;
template<typename T>
inline constexpr bool HasFormatter<T, typename Formatter<T>::__no_formatter_defined> = false;
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
constexpr size_t max_format_arguments = 256;
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
struct TypeErasedParameter {
AK+Format: Keep type information for integers in TypeErasedParameter. It's now save to pass a signed integer as parameter and then use it as replacement field (previously, this would just cast it to size_t which would be bad.)
2020-09-27 16:09:14 +00:00
enum class Type {
UInt8,
UInt16,
UInt32,
UInt64,
Int8,
Int16,
Int32,
Int64,
Custom
};
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
template<size_t size, bool is_unsigned>
static consteval Type get_type_from_size()
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
{
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
if constexpr (is_unsigned) {
if constexpr (size == 1)
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
return Type::UInt8;
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
if constexpr (size == 2)
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
return Type::UInt16;
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
if constexpr (size == 4)
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
return Type::UInt32;
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
if constexpr (size == 8)
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
return Type::UInt64;
} else {
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
if constexpr (size == 1)
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
return Type::Int8;
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
if constexpr (size == 2)
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
return Type::Int16;
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
if constexpr (size == 4)
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
return Type::Int32;
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
if constexpr (size == 8)
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
return Type::Int64;
}
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY_NOT_REACHED();
AK+Format: Accept unsigned long in replacement fields. I ran into this exact but at least twenty times in Serenity alone. The C++ Standard dictates that 'unsigned long' and 'unsigned long long' are distinct types even though on most platforms they are usually both 64 bit integers. Also it wasn't possible to evaluate IsIntegral<T> for types that were not integers since it used MakeUnsigned<T> internally.
2020-12-20 16:00:50 +00:00
}
AK+Format: Keep type information for integers in TypeErasedParameter. It's now save to pass a signed integer as parameter and then use it as replacement field (previously, this would just cast it to size_t which would be bad.)
2020-09-27 16:09:14 +00:00
template<typename T>
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
static consteval Type get_type()
AK+Format: Keep type information for integers in TypeErasedParameter. It's now save to pass a signed integer as parameter and then use it as replacement field (previously, this would just cast it to size_t which would be bad.)
2020-09-27 16:09:14 +00:00
{
AK+Everywhere: Make StdLibExtras templates less wrapper-y This commit makes the user-facing StdLibExtras templates and utilities arguably more nice-looking by removing the need to reach into the wrapper structs generated by them to get the value/type needed. The C++ standard library had to invent `_v` and `_t` variants (likely because of backwards compat), but we don't need to cater to any codebase except our own, so might as well have good things for free. :^)
2021-04-10 13:59:06 +00:00
if constexpr (IsIntegral<T>)
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
return get_type_from_size<sizeof(T), IsUnsigned<T>>();
AK+Everywhere: Make StdLibExtras templates less wrapper-y This commit makes the user-facing StdLibExtras templates and utilities arguably more nice-looking by removing the need to reach into the wrapper structs generated by them to get the value/type needed. The C++ standard library had to invent `_v` and `_t` variants (likely because of backwards compat), but we don't need to cater to any codebase except our own, so might as well have good things for free. :^)
2021-04-10 13:59:06 +00:00
else
return Type::Custom;
AK+Format: Keep type information for integers in TypeErasedParameter. It's now save to pass a signed integer as parameter and then use it as replacement field (previously, this would just cast it to size_t which would be bad.)
2020-09-27 16:09:14 +00:00
}
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
template<typename Visitor>
constexpr auto visit(Visitor&& visitor) const
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
{
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
switch (type) {
case TypeErasedParameter::Type::UInt8:
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
return visitor(*static_cast<u8 const*>(value));
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
case TypeErasedParameter::Type::UInt16:
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
return visitor(*static_cast<u16 const*>(value));
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
case TypeErasedParameter::Type::UInt32:
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
return visitor(*static_cast<u32 const*>(value));
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
case TypeErasedParameter::Type::UInt64:
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
return visitor(*static_cast<u64 const*>(value));
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
case TypeErasedParameter::Type::Int8:
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
return visitor(*static_cast<i8 const*>(value));
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
case TypeErasedParameter::Type::Int16:
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
return visitor(*static_cast<i16 const*>(value));
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
case TypeErasedParameter::Type::Int32:
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
return visitor(*static_cast<i32 const*>(value));
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
case TypeErasedParameter::Type::Int64:
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
return visitor(*static_cast<i64 const*>(value));
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
default:
TODO();
}
}
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
AK: Avoid implicit conversions in TypeErasedParameter::to_size() Refactor to a visitor+functor pattern that does an explicit static_cast to size_t after performing suitable range checks for each type.
2021-10-31 23:11:58 +00:00
constexpr size_t to_size() const
{
return visit([]<typename T>(T value) {
if constexpr (sizeof(T) > sizeof(size_t))
VERIFY(value < NumericLimits<size_t>::max());
if constexpr (IsSigned<T>)
VERIFY(value > 0);
return static_cast<size_t>(value);
});
AK/Format: Compute TypeErasedParameter type and size at compile-time Problem: - Type and size information is known at compile-time, but computations are being performed using run-time parameters. Solution: - Move function arguments to be template arguments. - Convert to `consteval` where possible. - Decorate functions with `constexpr` which are used in both run-time and compile-time contexts.
2021-04-21 19:47:03 +00:00
}
AK+Format: Remove TypeErasedFormatParams& from format function.
2020-12-30 11:14:15 +00:00
// FIXME: Getters and setters.
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void const* value;
AK+Format: Keep type information for integers in TypeErasedParameter. It's now save to pass a signed integer as parameter and then use it as replacement field (previously, this would just cast it to size_t which would be bad.)
2020-09-27 16:09:14 +00:00
Type type;
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> (*formatter)(TypeErasedFormatParams&, FormatBuilder&, FormatParser&, void const* value);
AK+Format: Support default index in replacement field. The following does now work: outf("{:0{}}", 1, 3); // 001
2020-09-28 09:44:24 +00:00
};
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
class FormatBuilder {
public:
enum class Align {
Default,
Left,
Center,
Right,
};
enum class SignMode {
OnlyIfNeeded,
Always,
Reserved,
Default = OnlyIfNeeded,
};
explicit FormatBuilder(StringBuilder& builder)
: m_builder(builder)
AK+Format: Support default index in replacement field. The following does now work: outf("{:0{}}", 1, 3); // 001
2020-09-28 09:44:24 +00:00
{
}
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> put_padding(char fill, size_t amount);
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> put_literal(StringView value);
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> put_string(
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
StringView value,
Align align = Align::Left,
size_t min_width = 0,
size_t max_width = NumericLimits<size_t>::max(),
char fill = ' ');
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> put_u64(
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
u64 value,
u8 base = 10,
bool prefix = false,
bool upper_case = false,
bool zero_pad = false,
Align align = Align::Right,
size_t min_width = 0,
char fill = ' ',
SignMode sign_mode = SignMode::OnlyIfNeeded,
bool is_negative = false);
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> put_i64(
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
i64 value,
u8 base = 10,
bool prefix = false,
bool upper_case = false,
bool zero_pad = false,
Align align = Align::Right,
size_t min_width = 0,
char fill = ' ',
SignMode sign_mode = SignMode::OnlyIfNeeded);
AK: Add Formatter<FixedPoint<...>> without floating point Rather than casting the FixedPoint to double, format the FixedPoint directly. This avoids using floating point instruction, which in turn enables this to be used even in the kernel.
2021-12-28 01:23:04 +00:00
ErrorOr<void> put_fixed_point(
i64 integer_value,
u64 fraction_value,
u64 fraction_one,
u8 base = 10,
bool upper_case = false,
bool zero_pad = false,
Align align = Align::Right,
size_t min_width = 0,
size_t precision = 6,
char fill = ' ',
SignMode sign_mode = SignMode::OnlyIfNeeded);
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
#ifndef KERNEL
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> put_f80(
AK: Support long doubles in format strings
2021-05-07 09:32:01 +00:00
long double value,
u8 base = 10,
bool upper_case = false,
Align align = Align::Right,
size_t min_width = 0,
size_t precision = 6,
char fill = ' ',
SignMode sign_mode = SignMode::OnlyIfNeeded);
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> put_f64(
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
double value,
u8 base = 10,
bool upper_case = false,
AK: Add support for keeping trailing zeros in fixed precision floats This uses the same syntax as zero padding integers: String::formatted("{:0.5}", 1.234) => "1.23400"
2021-06-19 14:00:31 +00:00
bool zero_pad = false,
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
Align align = Align::Right,
size_t min_width = 0,
size_t precision = 6,
char fill = ' ',
SignMode sign_mode = SignMode::OnlyIfNeeded);
#endif
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> put_hexdump(
AK: Add a :hex-dump mode to AK::Format This will just hexdump the given value. Note that not all formatters respect this, the ones that do are: - (Readonly)Bytes: formatter added in this commit - StringView / char const* - integral types
2021-06-17 08:41:00 +00:00
ReadonlyBytes,
size_t width,
char fill = ' ');
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
StringBuilder const& builder() const
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
{
return m_builder;
}
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
StringBuilder& builder() { return m_builder; }
private:
StringBuilder& m_builder;
};
class TypeErasedFormatParams {
public:
Span<const TypeErasedParameter> parameters() const { return m_parameters; }
AK+Format: Support default index in replacement field. The following does now work: outf("{:0{}}", 1, 3); // 001
2020-09-28 09:44:24 +00:00
VariadicFormatParams: Use initialized data to create parent class Problem: - m_data is being passed to the constructor of the parent class before it is initialized. This is not really a problem because the compiler knows the location and it is only a span being constructed, but it triggers a warning in clang for use-before-init. Solution: - Initialize using a default constructed array and then overwrite it inside the constructor after the member is initialized.
2020-10-07 15:21:00 +00:00
void set_parameters(Span<const TypeErasedParameter> parameters) { m_parameters = parameters; }
AK+Format: Support default index in replacement field. The following does now work: outf("{:0{}}", 1, 3); // 001
2020-09-28 09:44:24 +00:00
size_t take_next_index() { return m_next_index++; }
private:
Span<const TypeErasedParameter> m_parameters;
size_t m_next_index { 0 };
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
};
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
template<typename T>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> __format_value(TypeErasedFormatParams& params, FormatBuilder& builder, FormatParser& parser, void const* value)
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
{
Formatter<T> formatter;
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
formatter.parse(params, parser);
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return formatter.format(builder, *static_cast<const T*>(value));
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
}
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
template<typename... Parameters>
class VariadicFormatParams : public TypeErasedFormatParams {
public:
static_assert(sizeof...(Parameters) <= max_format_arguments);
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
explicit VariadicFormatParams(Parameters const&... parameters)
VariadicFormatParams: Use initialized data to create parent class Problem: - m_data is being passed to the constructor of the parent class before it is initialized. This is not really a problem because the compiler knows the location and it is only a span being constructed, but it triggers a warning in clang for use-before-init. Solution: - Initialize using a default constructed array and then overwrite it inside the constructor after the member is initialized.
2020-10-07 15:21:00 +00:00
: m_data({ TypeErasedParameter { &parameters, TypeErasedParameter::get_type<Parameters>(), __format_value<Parameters> }... })
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
{
VariadicFormatParams: Use initialized data to create parent class Problem: - m_data is being passed to the constructor of the parent class before it is initialized. This is not really a problem because the compiler knows the location and it is only a span being constructed, but it triggers a warning in clang for use-before-init. Solution: - Initialize using a default constructed array and then overwrite it inside the constructor after the member is initialized.
2020-10-07 15:21:00 +00:00
this->set_parameters(m_data);
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
}
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
private:
Array<TypeErasedParameter, sizeof...(Parameters)> m_data;
};
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
AK+Format: Exclude prefix from width calculation. When we write the format specifier '{:#08x}' we are asking for eight significant digits, zero padding and the prefix '0x'. However, previously we got only six significant digits because the prefix counted towards the width. (The number '8' here is the total width and not the number of significant digits.) Both fmtlib and printf shared this behaviour. However, I am introducing a special case here because when we do zero padding we really only care about the digits and not the width. Notice that zero padding is a special case anyways, because zero padding goes after the prefix as opposed to any other padding which goes before it.
2020-10-06 11:32:00 +00:00
// We use the same format for most types for consistency. This is taken directly from
// std::format. One difference is that we are not counting the width or sign towards the
// total width when calculating zero padding for numbers.
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
// https://en.cppreference.com/w/cpp/utility/format/formatter#Standard_format_specification
struct StandardFormatter {
enum class Mode {
Default,
Binary,
AK+Format: Use the new format backend in the implementation.
2020-09-26 13:26:14 +00:00
BinaryUppercase,
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
Decimal,
Octal,
Hexadecimal,
AK+Format: Use the new format backend in the implementation.
2020-09-26 13:26:14 +00:00
HexadecimalUppercase,
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
Character,
String,
Pointer,
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
Float,
Hexfloat,
HexfloatUppercase,
AK: Add a :hex-dump mode to AK::Format This will just hexdump the given value. Note that not all formatters respect this, the ones that do are: - (Readonly)Bytes: formatter added in this commit - StringView / char const* - integral types
2021-06-17 08:41:00 +00:00
HexDump,
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
};
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
FormatBuilder::Align m_align = FormatBuilder::Align::Default;
FormatBuilder::SignMode m_sign_mode = FormatBuilder::SignMode::OnlyIfNeeded;
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
Mode m_mode = Mode::Default;
bool m_alternative_form = false;
char m_fill = ' ';
bool m_zero_pad = false;
AK+Format: Remove TypeErasedFormatParams& from format function.
2020-12-30 11:14:15 +00:00
Optional<size_t> m_width;
Optional<size_t> m_precision;
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
AK+Format: Do some housekeeping in the format implementation.
2020-10-02 13:21:30 +00:00
void parse(TypeErasedFormatParams&, FormatParser&);
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
};
Everywhere: Switch from EnableIf to requires C++20 provides the `requires` clause which simplifies the ability to limit overload resolution. Prefer it over `EnableIf` With all uses of `EnableIf` being removed, also remove the implementation so future devs are not tempted.
2022-03-17 17:29:46 +00:00
template<Integral T>
struct Formatter<T> : StandardFormatter {
AK: Simplify constructors and conversions from nullptr_t Problem: - Many constructors are defined as `{}` rather than using the ` = default` compiler-provided constructor. - Some types provide an implicit conversion operator from `nullptr_t` instead of requiring the caller to default construct. This violates the C++ Core Guidelines suggestion to declare single-argument constructors explicit (https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c46-by-default-declare-single-argument-constructors-explicit). Solution: - Change default constructors to use the compiler-provided default constructor. - Remove implicit conversion operators from `nullptr_t` and change usage to enforce type consistency without conversion.
2021-01-10 23:29:28 +00:00
Formatter() = default;
AK+Format: Make it possible to format string literals as pointers. String literals are just pointers to a constant character. It should be possible to format them as such. (The default is to print them as strings still.)
2020-10-06 11:57:20 +00:00
explicit Formatter(StandardFormatter formatter)
AK: Move StandardFormatter argument into base class initializer Subclasses of StandardFormatter don't need to use the formatter argument in their constructor, so move() it into the base class initializer.
2021-10-31 23:13:05 +00:00
: StandardFormatter(move(formatter))
AK+Format: Make it possible to format string literals as pointers. String literals are just pointers to a constant character. It should be possible to format them as such. (The default is to print them as strings still.)
2020-10-06 11:57:20 +00:00
{
}
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder&, T);
AK+Format: Make it possible to format string literals as pointers. String literals are just pointers to a constant character. It should be possible to format them as such. (The default is to print them as strings still.)
2020-10-06 11:57:20 +00:00
};
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
template<>
AK: Borrow exact format syntax form std::format. Instead of just implementing format specifiers ad-hog this commit implements the exact syntax std::format uses. There are still a ton of features that are not supported by this implementation, however, the format specifiers should be parsed correctly. In some cases however, the format specifiers aren't quite parsed correctly, for example: String::formatted("{:{}}", 42, 4) should produce the string " 42" however an (unrelated) assertion fails. This is because vformat doesn't consider nested parentheses. I have to spend some time coming up with a simple way of doing this, I don't feel like doing that right now. The fundamental code for this already exists, by limiting the number of format arguments (arbitrarily) to 256 large widths are used to encode that these should be taken from other format parameters.
2020-09-25 11:11:29 +00:00
struct Formatter<StringView> : StandardFormatter {
AK: Simplify constructors and conversions from nullptr_t Problem: - Many constructors are defined as `{}` rather than using the ` = default` compiler-provided constructor. - Some types provide an implicit conversion operator from `nullptr_t` instead of requiring the caller to default construct. This violates the C++ Core Guidelines suggestion to declare single-argument constructors explicit (https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c46-by-default-declare-single-argument-constructors-explicit). Solution: - Change default constructors to use the compiler-provided default constructor. - Remove implicit conversion operators from `nullptr_t` and change usage to enforce type consistency without conversion.
2021-01-10 23:29:28 +00:00
Formatter() = default;
AK: Add formatter for boolean values.
2020-09-30 11:26:24 +00:00
explicit Formatter(StandardFormatter formatter)
AK: Move StandardFormatter argument into base class initializer Subclasses of StandardFormatter don't need to use the formatter argument in their constructor, so move() it into the base class initializer.
2021-10-31 23:13:05 +00:00
: StandardFormatter(move(formatter))
AK: Add formatter for boolean values.
2020-09-30 11:26:24 +00:00
{
}
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder&, StringView);
AK: Resolve format related circular dependencies properly. With this commit, <AK/Format.h> has a more supportive role and isn't used directly. Essentially, there now is a public 'vformat' function ('v' for vector) which takes already type erased parameters. The name is choosen to indicate that this function behaves similar to C-style functions taking a va_list equivalent. The interface for frontend users are now 'String::formatted' and 'StringBuilder::appendff'.
2020-09-23 11:21:18 +00:00
};
AK: Add a :hex-dump mode to AK::Format This will just hexdump the given value. Note that not all formatters respect this, the ones that do are: - (Readonly)Bytes: formatter added in this commit - StringView / char const* - integral types
2021-06-17 08:41:00 +00:00
AK: Support formatting Vectors with any inline_capacity The default Vector type has its inline capacity set to 0, which means any Vector with non-zero inline capacity was unformattable.
2022-02-03 14:23:52 +00:00
template<typename T, size_t inline_capacity>
requires(HasFormatter<T>) struct Formatter<Vector<T, inline_capacity>> : StandardFormatter {
AK: Add Formatter for Vector For debugging purposes, it is very useful to look at a Vector in a simple list representation. Therefore, the new Formatter for Vector provides a string representation of the following form: ``` [ 1, 2, 3, 4, 5 ] ``` This requires the content type of Vector to be formattable with default arguments. The current implementation ignores width and precision, which may be accounted for later or passed down to the content formatter.
2021-07-06 16:55:36 +00:00
Formatter() = default;
explicit Formatter(StandardFormatter formatter)
AK: Move StandardFormatter argument into base class initializer Subclasses of StandardFormatter don't need to use the formatter argument in their constructor, so move() it into the base class initializer.
2021-10-31 23:13:05 +00:00
: StandardFormatter(move(formatter))
AK: Add Formatter for Vector For debugging purposes, it is very useful to look at a Vector in a simple list representation. Therefore, the new Formatter for Vector provides a string representation of the following form: ``` [ 1, 2, 3, 4, 5 ] ``` This requires the content type of Vector to be formattable with default arguments. The current implementation ignores width and precision, which may be accounted for later or passed down to the content formatter.
2021-07-06 16:55:36 +00:00
{
}
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder& builder, Vector<T> value)
AK: Add Formatter for Vector For debugging purposes, it is very useful to look at a Vector in a simple list representation. Therefore, the new Formatter for Vector provides a string representation of the following form: ``` [ 1, 2, 3, 4, 5 ] ``` This requires the content type of Vector to be formattable with default arguments. The current implementation ignores width and precision, which may be accounted for later or passed down to the content formatter.
2021-07-06 16:55:36 +00:00
{
if (m_mode == Mode::Pointer) {
Formatter<FlatPtr> formatter { *this };
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
TRY(formatter.format(builder, reinterpret_cast<FlatPtr>(value.data())));
return {};
AK: Add Formatter for Vector For debugging purposes, it is very useful to look at a Vector in a simple list representation. Therefore, the new Formatter for Vector provides a string representation of the following form: ``` [ 1, 2, 3, 4, 5 ] ``` This requires the content type of Vector to be formattable with default arguments. The current implementation ignores width and precision, which may be accounted for later or passed down to the content formatter.
2021-07-06 16:55:36 +00:00
}
if (m_sign_mode != FormatBuilder::SignMode::Default)
VERIFY_NOT_REACHED();
if (m_alternative_form)
VERIFY_NOT_REACHED();
if (m_zero_pad)
VERIFY_NOT_REACHED();
if (m_mode != Mode::Default)
VERIFY_NOT_REACHED();
if (m_width.has_value() && m_precision.has_value())
VERIFY_NOT_REACHED();
m_width = m_width.value_or(0);
m_precision = m_precision.value_or(NumericLimits<size_t>::max());
Formatter<T> content_fmt;
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
TRY(builder.put_literal("[ "sv));
AK: Add Formatter for Vector For debugging purposes, it is very useful to look at a Vector in a simple list representation. Therefore, the new Formatter for Vector provides a string representation of the following form: ``` [ 1, 2, 3, 4, 5 ] ``` This requires the content type of Vector to be formattable with default arguments. The current implementation ignores width and precision, which may be accounted for later or passed down to the content formatter.
2021-07-06 16:55:36 +00:00
bool first = true;
for (auto& content : value) {
AK: Use new Formatter for each element in Formatter<Vector<T>> The state of the formatter for the previous element should be thrown away for each iteration. This showed up when trying to format a Vector<String>, since Formatter<StringView> was unhappy about some state that gets set when it's called. Add a test for Formatter<Vector>.
2021-07-17 22:27:12 +00:00
if (!first) {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
TRY(builder.put_literal(", "sv));
AK: Use new Formatter for each element in Formatter<Vector<T>> The state of the formatter for the previous element should be thrown away for each iteration. This showed up when trying to format a Vector<String>, since Formatter<StringView> was unhappy about some state that gets set when it's called. Add a test for Formatter<Vector>.
2021-07-17 22:27:12 +00:00
content_fmt = Formatter<T> {};
}
AK: Add Formatter for Vector For debugging purposes, it is very useful to look at a Vector in a simple list representation. Therefore, the new Formatter for Vector provides a string representation of the following form: ``` [ 1, 2, 3, 4, 5 ] ``` This requires the content type of Vector to be formattable with default arguments. The current implementation ignores width and precision, which may be accounted for later or passed down to the content formatter.
2021-07-06 16:55:36 +00:00
first = false;
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
TRY(content_fmt.format(builder, content));
AK: Add Formatter for Vector For debugging purposes, it is very useful to look at a Vector in a simple list representation. Therefore, the new Formatter for Vector provides a string representation of the following form: ``` [ 1, 2, 3, 4, 5 ] ``` This requires the content type of Vector to be formattable with default arguments. The current implementation ignores width and precision, which may be accounted for later or passed down to the content formatter.
2021-07-06 16:55:36 +00:00
}
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
TRY(builder.put_literal(" ]"sv));
return {};
AK: Add Formatter for Vector For debugging purposes, it is very useful to look at a Vector in a simple list representation. Therefore, the new Formatter for Vector provides a string representation of the following form: ``` [ 1, 2, 3, 4, 5 ] ``` This requires the content type of Vector to be formattable with default arguments. The current implementation ignores width and precision, which may be accounted for later or passed down to the content formatter.
2021-07-06 16:55:36 +00:00
}
};
AK: Add a :hex-dump mode to AK::Format This will just hexdump the given value. Note that not all formatters respect this, the ones that do are: - (Readonly)Bytes: formatter added in this commit - StringView / char const* - integral types
2021-06-17 08:41:00 +00:00
template<>
struct Formatter<ReadonlyBytes> : Formatter<StringView> {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder& builder, ReadonlyBytes value)
AK: Add a :hex-dump mode to AK::Format This will just hexdump the given value. Note that not all formatters respect this, the ones that do are: - (Readonly)Bytes: formatter added in this commit - StringView / char const* - integral types
2021-06-17 08:41:00 +00:00
{
if (m_mode == Mode::Pointer) {
Formatter<FlatPtr> formatter { *this };
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return formatter.format(builder, reinterpret_cast<FlatPtr>(value.data()));
}
if (m_mode == Mode::Default || m_mode == Mode::HexDump) {
AK: Add a :hex-dump mode to AK::Format This will just hexdump the given value. Note that not all formatters respect this, the ones that do are: - (Readonly)Bytes: formatter added in this commit - StringView / char const* - integral types
2021-06-17 08:41:00 +00:00
m_mode = Mode::HexDump;
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return Formatter<StringView>::format(builder, value);
AK: Add a :hex-dump mode to AK::Format This will just hexdump the given value. Note that not all formatters respect this, the ones that do are: - (Readonly)Bytes: formatter added in this commit - StringView / char const* - integral types
2021-06-17 08:41:00 +00:00
}
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return Formatter<StringView>::format(builder, value);
AK: Add a :hex-dump mode to AK::Format This will just hexdump the given value. Note that not all formatters respect this, the ones that do are: - (Readonly)Bytes: formatter added in this commit - StringView / char const* - integral types
2021-06-17 08:41:00 +00:00
}
};
template<>
struct Formatter<Bytes> : Formatter<ReadonlyBytes> {
};
AK: Explicitly calculate length of char* when printing This moves out the calculation of the char* out to the formatter. Additionally, we now print (null) when a null pointer is passed.
2022-07-11 19:59:54 +00:00
// FIXME: Printing raw char pointers is inherently dangerous. Remove this and
// its users and prefer StringView over it.
Applications+IRCClient: Use new format functions.
2020-09-23 14:31:34 +00:00
template<>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
struct Formatter<char const*> : Formatter<StringView> {
ErrorOr<void> format(FormatBuilder& builder, char const* value)
AK+Format: Make it possible to format string literals as pointers. String literals are just pointers to a constant character. It should be possible to format them as such. (The default is to print them as strings still.)
2020-10-06 11:57:20 +00:00
{
if (m_mode == Mode::Pointer) {
Formatter<FlatPtr> formatter { *this };
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return formatter.format(builder, reinterpret_cast<FlatPtr>(value));
AK+Format: Make it possible to format string literals as pointers. String literals are just pointers to a constant character. It should be possible to format them as such. (The default is to print them as strings still.)
2020-10-06 11:57:20 +00:00
}
AK: Explicitly calculate length of char* when printing This moves out the calculation of the char* out to the formatter. Additionally, we now print (null) when a null pointer is passed.
2022-07-11 19:59:54 +00:00
return Formatter<StringView>::format(builder, value != nullptr ? StringView { value, __builtin_strlen(value) } : "(null)"sv);
AK+Format: Make it possible to format string literals as pointers. String literals are just pointers to a constant character. It should be possible to format them as such. (The default is to print them as strings still.)
2020-10-06 11:57:20 +00:00
}
Applications+IRCClient: Use new format functions.
2020-09-23 14:31:34 +00:00
};
template<>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
struct Formatter<char*> : Formatter<char const*> {
Applications+IRCClient: Use new format functions.
2020-09-23 14:31:34 +00:00
};
AK: Resolve format related circular dependencies properly. With this commit, <AK/Format.h> has a more supportive role and isn't used directly. Essentially, there now is a public 'vformat' function ('v' for vector) which takes already type erased parameters. The name is choosen to indicate that this function behaves similar to C-style functions taking a va_list equivalent. The interface for frontend users are now 'String::formatted' and 'StringBuilder::appendff'.
2020-09-23 11:21:18 +00:00
template<size_t Size>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
struct Formatter<char[Size]> : Formatter<char const*> {
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
};
AK: Add Formatter<unsigned char[Size]>
2021-05-31 15:06:35 +00:00
template<size_t Size>
struct Formatter<unsigned char[Size]> : Formatter<StringView> {
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> format(FormatBuilder& builder, unsigned char const* value)
AK: Add Formatter<unsigned char[Size]>
2021-05-31 15:06:35 +00:00
{
if (m_mode == Mode::Pointer) {
Formatter<FlatPtr> formatter { *this };
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return formatter.format(builder, reinterpret_cast<FlatPtr>(value));
AK: Add Formatter<unsigned char[Size]>
2021-05-31 15:06:35 +00:00
}
AK: Add missing return in Formatter<unsigned char[Size]>::format() Caught by ENABLE_ALL_THE_DEBUG_MACROS.
2021-11-17 06:44:02 +00:00
return Formatter<StringView>::format(builder, { value, Size });
AK: Add Formatter<unsigned char[Size]>
2021-05-31 15:06:35 +00:00
}
};
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
template<>
AK: Resolve format related circular dependencies properly. With this commit, <AK/Format.h> has a more supportive role and isn't used directly. Essentially, there now is a public 'vformat' function ('v' for vector) which takes already type erased parameters. The name is choosen to indicate that this function behaves similar to C-style functions taking a va_list equivalent. The interface for frontend users are now 'String::formatted' and 'StringBuilder::appendff'.
2020-09-23 11:21:18 +00:00
struct Formatter<String> : Formatter<StringView> {
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
};
AK: Add Formatter for FlyString :^)
2020-10-04 11:50:58 +00:00
template<>
struct Formatter<FlyString> : Formatter<StringView> {
};
AK: Add format function like std::format or fmt::format.
2020-09-19 11:47:35 +00:00
AK: Add formatter for pointer types.
2020-09-30 12:38:47 +00:00
template<typename T>
struct Formatter<T*> : StandardFormatter {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder& builder, T* value)
AK: Add formatter for pointer types.
2020-09-30 12:38:47 +00:00
{
AK+Format: Use pointer mode for pointers by default.
2020-10-07 10:47:35 +00:00
if (m_mode == Mode::Default)
m_mode = Mode::Pointer;
AK: Add formatter for pointer types.
2020-09-30 12:38:47 +00:00
Formatter<FlatPtr> formatter { *this };
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return formatter.format(builder, reinterpret_cast<FlatPtr>(value));
AK: Add formatter for pointer types.
2020-09-30 12:38:47 +00:00
}
};
AK: Add special formatter for char. When we format a character we want to put the ascii value and not the decimal value. The old behaviour can be obtained with '{:d}'.
2020-10-04 11:49:19 +00:00
template<>
AK+Format: Make it possible to format characters as integers.
2020-10-07 12:25:19 +00:00
struct Formatter<char> : StandardFormatter {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder&, char);
AK: Add special formatter for char. When we format a character we want to put the ascii value and not the decimal value. The old behaviour can be obtained with '{:d}'.
2020-10-04 11:49:19 +00:00
};
AK: Add formatter for boolean values.
2020-09-30 11:26:24 +00:00
template<>
AK: Add a basic formatter for wchar_t
2021-09-21 21:07:03 +00:00
struct Formatter<wchar_t> : StandardFormatter {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder& builder, wchar_t);
AK: Add a basic formatter for wchar_t
2021-09-21 21:07:03 +00:00
};
template<>
AK: Add formatter for boolean values.
2020-09-30 11:26:24 +00:00
struct Formatter<bool> : StandardFormatter {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder&, bool);
AK: Add formatter for boolean values.
2020-09-30 11:26:24 +00:00
};
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
#ifndef KERNEL
template<>
struct Formatter<float> : StandardFormatter {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder&, float value);
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
};
template<>
struct Formatter<double> : StandardFormatter {
AK: Simplify constructors and conversions from nullptr_t Problem: - Many constructors are defined as `{}` rather than using the ` = default` compiler-provided constructor. - Some types provide an implicit conversion operator from `nullptr_t` instead of requiring the caller to default construct. This violates the C++ Core Guidelines suggestion to declare single-argument constructors explicit (https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c46-by-default-declare-single-argument-constructors-explicit). Solution: - Change default constructors to use the compiler-provided default constructor. - Remove implicit conversion operators from `nullptr_t` and change usage to enforce type consistency without conversion.
2021-01-10 23:29:28 +00:00
Formatter() = default;
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
explicit Formatter(StandardFormatter formatter)
: StandardFormatter(formatter)
{
}
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder&, double);
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
};
AK: Support long doubles in format strings
2021-05-07 09:32:01 +00:00
template<>
struct Formatter<long double> : StandardFormatter {
Formatter() = default;
explicit Formatter(StandardFormatter formatter)
: StandardFormatter(formatter)
{
}
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder&, long double value);
AK: Support long doubles in format strings
2021-05-07 09:32:01 +00:00
};
AK: Add formatters for floating point numbers.
2020-11-09 10:34:44 +00:00
#endif
AK: Add Formatter<FixedPoint<...>> without floating point Rather than casting the FixedPoint to double, format the FixedPoint directly. This avoids using floating point instruction, which in turn enables this to be used even in the kernel.
2021-12-28 01:23:04 +00:00
template<size_t precision, typename Underlying>
struct Formatter<FixedPoint<precision, Underlying>> : StandardFormatter {
Formatter() = default;
explicit Formatter(StandardFormatter formatter)
: StandardFormatter(formatter)
{
}
ErrorOr<void> format(FormatBuilder& builder, FixedPoint<precision, Underlying> value)
{
u8 base;
bool upper_case;
if (m_mode == Mode::Default || m_mode == Mode::Float) {
base = 10;
upper_case = false;
} else if (m_mode == Mode::Hexfloat) {
base = 16;
upper_case = false;
} else if (m_mode == Mode::HexfloatUppercase) {
base = 16;
upper_case = true;
} else {
VERIFY_NOT_REACHED();
}
m_width = m_width.value_or(0);
m_precision = m_precision.value_or(6);
i64 integer = value.ltrunk();
constexpr u64 one = static_cast<Underlying>(1) << precision;
u64 fraction_raw = value.raw() & (one - 1);
return builder.put_fixed_point(integer, fraction_raw, one, base, upper_case, m_zero_pad, m_align, m_width.value(), m_precision.value(), m_fill, m_sign_mode);
}
};
Piggyback: AK: Add formatter for std::nullptr_t.
2021-01-01 22:34:00 +00:00
template<>
struct Formatter<std::nullptr_t> : Formatter<FlatPtr> {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder& builder, std::nullptr_t)
Piggyback: AK: Add formatter for std::nullptr_t.
2021-01-01 22:34:00 +00:00
{
if (m_mode == Mode::Default)
m_mode = Mode::Pointer;
return Formatter<FlatPtr>::format(builder, 0);
}
};
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> vformat(StringBuilder&, StringView fmtstr, TypeErasedFormatParams&);
AK: Add StringBuilder::appendff using the new format. StringBuilder::appendf was already used, thus this name. If we some day replace all usages of printf, we could rename this method.
2020-09-22 11:11:05 +00:00
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
#ifndef KERNEL
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
void vout(FILE*, StringView fmtstr, TypeErasedFormatParams&, bool newline = false);
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void out(FILE* file, CheckedFormatString<Parameters...>&& fmtstr, Parameters const&... parameters)
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
{
VariadicFormatParams variadic_format_params { parameters... };
vout(file, fmtstr.view(), variadic_format_params);
}
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
AK+Format: Add overloads with const char* for outln, warnln and dbgln. This makes it possible to forward declare 'warnln' in TestSuite.h.
2020-10-07 12:00:59 +00:00
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void outln(FILE* file, CheckedFormatString<Parameters...>&& fmtstr, Parameters const&... parameters)
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
{
VariadicFormatParams variadic_format_params { parameters... };
vout(file, fmtstr.view(), variadic_format_params, true);
}
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
AK+Format: Add outln(FILE*, ...) overload. This commit also removes a few functions like raw_out and vwarn. If we want to write raw output, we can do this as follows: out("{}", "Hello, World!"); The vout stuff isn't really public API anyways, so no need for another vwarn.
2020-10-15 11:46:00 +00:00
inline void outln(FILE* file) { fputc('\n', file); }
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
AK+Format: Add outln(FILE*, ...) overload. This commit also removes a few functions like raw_out and vwarn. If we want to write raw output, we can do this as follows: out("{}", "Hello, World!"); The vout stuff isn't really public API anyways, so no need for another vwarn.
2020-10-15 11:46:00 +00:00
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void out(CheckedFormatString<Parameters...>&& fmtstr, Parameters const&... parameters) { out(stdout, move(fmtstr), parameters...); }
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
AK+Format: Add outln(FILE*, ...) overload. This commit also removes a few functions like raw_out and vwarn. If we want to write raw output, we can do this as follows: out("{}", "Hello, World!"); The vout stuff isn't really public API anyways, so no need for another vwarn.
2020-10-15 11:46:00 +00:00
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void outln(CheckedFormatString<Parameters...>&& fmtstr, Parameters const&... parameters) { outln(stdout, move(fmtstr), parameters...); }
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
AK+Format: Add outln(FILE*, ...) overload. This commit also removes a few functions like raw_out and vwarn. If we want to write raw output, we can do this as follows: out("{}", "Hello, World!"); The vout stuff isn't really public API anyways, so no need for another vwarn.
2020-10-15 11:46:00 +00:00
inline void outln() { outln(stdout); }
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
AK: Add outln_if and warnln_if This uses the same gating mechanism as dbgln_if and should be equivalent to #define flag etc
2021-04-15 20:06:18 +00:00
# define outln_if(flag, fmt, ...) \
do { \
if constexpr (flag) \
outln(fmt, ##__VA_ARGS__); \
} while (0)
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void warn(CheckedFormatString<Parameters...>&& fmtstr, Parameters const&... parameters)
AK: Add outln_if and warnln_if This uses the same gating mechanism as dbgln_if and should be equivalent to #define flag etc
2021-04-15 20:06:18 +00:00
{
out(stderr, move(fmtstr), parameters...);
}
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
AK+Format: Add overloads with const char* for outln, warnln and dbgln. This makes it possible to forward declare 'warnln' in TestSuite.h.
2020-10-07 12:00:59 +00:00
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void warnln(CheckedFormatString<Parameters...>&& fmtstr, Parameters const&... parameters) { outln(stderr, move(fmtstr), parameters...); }
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
AK+Format: Add outln(FILE*, ...) overload. This commit also removes a few functions like raw_out and vwarn. If we want to write raw output, we can do this as follows: out("{}", "Hello, World!"); The vout stuff isn't really public API anyways, so no need for another vwarn.
2020-10-15 11:46:00 +00:00
inline void warnln() { outln(stderr); }
AK: Add outln_if and warnln_if This uses the same gating mechanism as dbgln_if and should be equivalent to #define flag etc
2021-04-15 20:06:18 +00:00
AK: Fix typo in warnln_if()
2022-03-19 17:07:31 +00:00
# define warnln_if(flag, fmt, ...) \
do { \
if constexpr (flag) \
warnln(fmt, ##__VA_ARGS__); \
AK: Add outln_if and warnln_if This uses the same gating mechanism as dbgln_if and should be equivalent to #define flag etc
2021-04-15 20:06:18 +00:00
} while (0)
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
#endif
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
void vdbgln(StringView fmtstr, TypeErasedFormatParams&);
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
AK: Make dbgln_if() avoid evaluating the arguments when disabled Naturally, this makes the `enabled` flag on dbgln() obsolete.
2021-02-23 22:35:43 +00:00
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void dbgln(CheckedFormatString<Parameters...>&& fmtstr, Parameters const&... parameters)
AK: Add enabled template parameter to dbgln.
2021-01-12 21:10:24 +00:00
{
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
VariadicFormatParams variadic_format_params { parameters... };
vdbgln(fmtstr.view(), variadic_format_params);
AK: Add enabled template parameter to dbgln.
2021-01-12 21:10:24 +00:00
}
AK: Add dbgln() format checking This checks the following things: - No unclosed braces in format string `dbgln("a:{}}", a)` where the '}}' would be interpreted as a literal '}' `dbgln("a:{", a)` where someone with a faulty keyboard like mine could generate - No extra closed braces in format string `dbgln("a:{{}", a)` where the '{{' would interpreted as a literal '{' `dbgln("a:}", a)` where someone with a faulty keyboard could generate - No references to nonexistent arguments `dbgln("a:{} b:{}", a)` where the value of `b` is not in the arguments list - No unconsumed argument `dbgln("a:{1}", not_used, 1)` where `not_used` is extraneous
2021-01-17 08:22:04 +00:00
AK: Make dbgln_if() avoid evaluating the arguments when disabled Naturally, this makes the `enabled` flag on dbgln() obsolete.
2021-02-23 22:35:43 +00:00
inline void dbgln() { dbgln(""); }
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
AK: Add set_debug_enabled method.
2021-01-18 16:37:30 +00:00
void set_debug_enabled(bool);
AK+Format: Add dmesgln() to replace klog().
2021-01-23 12:58:23 +00:00
#ifdef KERNEL
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
void vdmesgln(StringView fmtstr, TypeErasedFormatParams&);
AK+Format: Add dmesgln() to replace klog().
2021-01-23 12:58:23 +00:00
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void dmesgln(CheckedFormatString<Parameters...>&& fmt, Parameters const&... parameters)
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
{
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
VariadicFormatParams variadic_format_params { parameters... };
vdmesgln(fmt.view(), variadic_format_params);
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
}
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 19:58:51 +00:00
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
void v_critical_dmesgln(StringView fmtstr, TypeErasedFormatParams&);
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 19:58:51 +00:00
// be very careful to not cause any allocations here, since we could be in
// a very unstable situation
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void critical_dmesgln(CheckedFormatString<Parameters...>&& fmt, Parameters const&... parameters)
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 19:58:51 +00:00
{
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
VariadicFormatParams variadic_format_params { parameters... };
v_critical_dmesgln(fmt.view(), variadic_format_params);
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 19:58:51 +00:00
}
AK+Format: Add dmesgln() to replace klog().
2021-01-23 12:58:23 +00:00
#endif
AK+Format: Add SFINAE wrapper 'FormatIfSupported'.
2020-10-07 12:01:59 +00:00
template<typename T>
class FormatIfSupported {
public:
explicit FormatIfSupported(const T& value)
: m_value(value)
{
}
const T& value() const { return m_value; }
private:
const T& m_value;
};
template<typename T, bool Supported = false>
struct __FormatIfSupported : Formatter<StringView> {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder& builder, FormatIfSupported<T> const&)
AK+Format: Add SFINAE wrapper 'FormatIfSupported'.
2020-10-07 12:01:59 +00:00
{
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return Formatter<StringView>::format(builder, "?");
AK+Format: Add SFINAE wrapper 'FormatIfSupported'.
2020-10-07 12:01:59 +00:00
}
};
template<typename T>
struct __FormatIfSupported<T, true> : Formatter<T> {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder& builder, FormatIfSupported<T> const& value)
AK+Format: Add SFINAE wrapper 'FormatIfSupported'.
2020-10-07 12:01:59 +00:00
{
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return Formatter<T>::format(builder, value.value());
AK+Format: Add SFINAE wrapper 'FormatIfSupported'.
2020-10-07 12:01:59 +00:00
}
};
template<typename T>
AK+Everywhere: Make StdLibExtras templates less wrapper-y This commit makes the user-facing StdLibExtras templates and utilities arguably more nice-looking by removing the need to reach into the wrapper structs generated by them to get the value/type needed. The C++ standard library had to invent `_v` and `_t` variants (likely because of backwards compat), but we don't need to cater to any codebase except our own, so might as well have good things for free. :^)
2021-04-10 13:59:06 +00:00
struct Formatter<FormatIfSupported<T>> : __FormatIfSupported<T, HasFormatter<T>> {
AK+Format: Add SFINAE wrapper 'FormatIfSupported'.
2020-10-07 12:01:59 +00:00
};
AK: Add Formatter<FormatString> as helper class.
2021-01-09 00:00:22 +00:00
// This is a helper class, the idea is that if you want to implement a formatter you can inherit
// from this class to "break down" the formatting.
struct FormatString {
};
template<>
AK: Avoid temporary String allocation in Formatter<FormatString> Creating a String object from the formatted data is unnecessary, as it immediately gets turned into a StringView anyways. With this change, we will no longer allocate on the heap when printing `VirtualAddress`, `VirtualRange` and `InodeIdentifier` objects, which is a step towards stronger OOM hardening.
2021-10-21 17:09:38 +00:00
struct Formatter<FormatString> : Formatter<StringView> {
AK: Add Formatter<FormatString> as helper class.
2021-01-09 00:00:22 +00:00
template<typename... Parameters>
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> format(FormatBuilder& builder, StringView fmtstr, Parameters const&... parameters)
AK: Add Formatter<FormatString> as helper class.
2021-01-09 00:00:22 +00:00
{
Everywhere: Pass AK::Format TypeErasedFormatParams by reference This silences a overeager warning in sonar cloud, warning that slicing could occur with `VariadicFormatParams` which derives from `TypeErasedFormatParams`. Reference: https://sonarcloud.io/project/issues?id=SerenityOS_serenity&issues=AXuVPBO_k92xXUF3qWsm&open=AXuVPBO_k92xXUF3qWsm
2021-08-30 09:58:22 +00:00
VariadicFormatParams variadic_format_params { parameters... };
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
return vformat(builder, fmtstr, variadic_format_params);
}
ErrorOr<void> vformat(FormatBuilder& builder, StringView fmtstr, TypeErasedFormatParams& params);
};
template<>
struct Formatter<Error> : Formatter<FormatString> {
ErrorOr<void> format(FormatBuilder& builder, Error const& error)
{
AK+LibMain: Improve formatter for AK::Error in userspace Print the full associated string metadata by default (if available.)
2021-12-20 10:55:32 +00:00
#if defined(__serenity__) && defined(KERNEL)
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
if (error.is_errno())
return Formatter<FormatString>::format(builder, "Error(errno={})", error.code());
return Formatter<FormatString>::format(builder, "Error({})", error.string_literal());
AK+LibMain: Improve formatter for AK::Error in userspace Print the full associated string metadata by default (if available.)
2021-12-20 10:55:32 +00:00
#else
if (error.is_syscall())
return Formatter<FormatString>::format(builder, "{}: {} (errno={})", error.string_literal(), strerror(error.code()), error.code());
if (error.is_errno())
return Formatter<FormatString>::format(builder, "{} (errno={})", strerror(error.code()), error.code());
return Formatter<FormatString>::format(builder, "{}", error.string_literal());
#endif
AK: Add Formatter<FormatString> as helper class.
2021-01-09 00:00:22 +00:00
}
};
AK: Implement Formatter for ErrorOr<> As the Formatter for Error already exists, this apparently was just accidentally omitted.
2021-11-26 21:33:04 +00:00
template<typename T, typename ErrorType>
struct Formatter<ErrorOr<T, ErrorType>> : Formatter<FormatString> {
ErrorOr<void> format(FormatBuilder& builder, ErrorOr<T, ErrorType> const& error_or)
{
if (error_or.is_error())
return Formatter<FormatString>::format(builder, "{}", error_or.error());
return Formatter<FormatString>::format(builder, "{{{}}}", error_or.value());
}
};
AK: Add StringBuilder::appendff using the new format. StringBuilder::appendf was already used, thus this name. If we some day replace all usages of printf, we could rename this method.
2020-09-22 11:11:05 +00:00
} // namespace AK
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
AK+Format: Add dmesgln() to replace klog().
2021-01-23 12:58:23 +00:00
#ifdef KERNEL
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 19:58:51 +00:00
using AK::critical_dmesgln;
AK+Format: Add dmesgln() to replace klog().
2021-01-23 12:58:23 +00:00
using AK::dmesgln;
#else
AK: Rename new_out to out and new_warn to warn.
2020-11-09 09:47:19 +00:00
using AK::out;
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
using AK::outln;
AK: Rename new_out to out and new_warn to warn.
2020-11-09 09:47:19 +00:00
using AK::warn;
AK: Don't add newline for outf/dbgf/warnf. In the future all (normal) output should be written by any of the following functions: out (currently called new_out) outln dbg (currently called new_dbg) dbgln warn (currently called new_warn) warnln However, there are still a ton of uses of the old out/warn/dbg in the code base so the new functions are called new_out/new_warn/new_dbg. I am going to rename them as soon as all the other usages are gone (this might take a while.) I also added raw_out/raw_dbg/raw_warn which don't do any escaping, this should be useful if no formatting is required and if the input contains tons of curly braces. (I am not entirely sure if this function will stay, but I am adding it for now.)
2020-10-04 13:35:43 +00:00
using AK::warnln;
#endif
using AK::dbgln;
AK+Format: Add SFINAE wrapper 'FormatIfSupported'.
2020-10-07 12:01:59 +00:00
AK+Userland: Extend the compiletime format string check to other functions Thanks to @trflynn89 for the neat implicit consteval ctor trick! This allows us to basically slap `CheckedFormatString` on any formatting function, and have its format argument checked at compiletime. Note that there is a validator bug where it doesn't parse inner replaced fields like `{:~>{}}` correctly (what should be 'left align with next argument as size' is parsed as `{:~>{` following a literal closing brace), so the compiletime checks are disabled on these temporarily by forcing them to be StringViews. This commit also removes the now unused `AK::StringLiteral` type (which was introduced for use with NTTP strings).
2021-02-21 23:07:24 +00:00
using AK::CheckedFormatString;
AK+Format: Add SFINAE wrapper 'FormatIfSupported'.
2020-10-07 12:01:59 +00:00
using AK::FormatIfSupported;
AK: Add Formatter<FormatString> as helper class.
2021-01-09 00:00:22 +00:00
using AK::FormatString;
Everywhere: Replace dbgln<flag>(...) with dbgln_if(flag, ...) Replacement made by `find Kernel Userland -name '*.h' -o -name '*.cpp' | sed -i -Ee 's/dbgln\b<(\w+)>\(/dbgln_if(\1, /g'`
2021-02-07 12:03:24 +00:00
AK: Make dbgln_if() avoid evaluating the arguments when disabled Naturally, this makes the `enabled` flag on dbgln() obsolete.
2021-02-23 22:35:43 +00:00
#define dbgln_if(flag, fmt, ...) \
do { \
if constexpr (flag) \
dbgln(fmt, ##__VA_ARGS__); \
} while (0)
Reference in a new issue Copy permalink