pw_tokenizer/decode.cc - pigweed/sandbox - Git at Google

 // Copyright 2020 The Pigweed Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
 // use this file except in compliance with the License. You may obtain a copy of
 // the License at
 //
 //     https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 // License for the specific language governing permissions and limitations under
 // the License.

 #include "pw_tokenizer/internal/decode.h"

 #include <algorithm>
 #include <array>
 #include <cctype>
 #include <cstring>
 #include <string>

 #include "pw_varint/varint.h"

 namespace pw::tokenizer {
 namespace {

 // Functions for parsing a printf format specifier.
 size_t SkipFlags(const char* str) {
   size_t i = 0;
   while (str[i] == '-' || str[i] == '+' || str[i] == '#' || str[i] == ' ' ||
          str[i] == '0') {
     i += 1;
   }
   return i;
 }

 size_t SkipAsteriskOrInteger(const char* str) {
   if (str[0] == '*') {
     return 1;
   }

   size_t i = (str[0] == '-' || str[0] == '+') ? 1 : 0;

   while (std::isdigit(str[i])) {
     i += 1;
   }
   return i;
 }

 std::array<char, 2> ReadLengthModifier(const char* str) {
   // Check for ll or hh.
   if (str[0] == str[1] && (str[0] == 'l' || str[0] == 'h')) {
     return {str[0], str[1]};
   }
   if (std::strchr("hljztL", str[0]) != nullptr) {
     return {str[0]};
   }
   return {};
 }

 // Returns the error message that is used in place of a decoded arg when an
 // error occurs.
 std::string ErrorMessage(ArgStatus status,
                          std::string_view spec,
                          std::string_view value) {
   const char* message;
   if (status.HasError(ArgStatus::kSkipped)) {
     message = "SKIPPED";
   } else if (status.HasError(ArgStatus::kMissing)) {
     message = "MISSING";
   } else if (status.HasError(ArgStatus::kDecodeError)) {
     message = "ERROR";
   } else {
     message = "INTERNAL ERROR";
   }

   std::string result(PW_TOKENIZER_ARG_DECODING_ERROR_PREFIX);
   result.append(spec);
   result.push_back(' ');
   result.append(message);

   if (!value.empty()) {
     result.push_back(' ');
     result.push_back('(');
     result.append(value);
     result.push_back(')');
   }

   result.append(PW_TOKENIZER_ARG_DECODING_ERROR_SUFFIX);
   return result;
 }

 DecodedArg MakeErrorArg(ArgStatus status,
                         std::string_view spec,
                         size_t total_arguments_size,
                         size_t bytes_consumed) {
   return DecodedArg(status,
                     spec,
                     status.HasError(ArgStatus::kDecodeError)
                         ? total_arguments_size
                         : bytes_consumed);
 }
 }  // namespace

 DecodedArg::DecodedArg(ArgStatus error,
                        std::string_view spec,
                        size_t raw_size_bytes,
                        std::string_view value)
     : value_(ErrorMessage(error, spec, value)),
       spec_(spec),
       raw_data_size_bytes_(raw_size_bytes),
       status_(error) {}

 StringSegment StringSegment::ParseFormatSpec(const char* format) {
   if (format[0] != '%' || format[1] == '\0') {
     return StringSegment();
   }

   // Parse the format specifier.
   size_t i = 1;

   // Skip the flags.
   i += SkipFlags(&format[i]);

   // Skip the field width.
   const size_t width_asterisk_pos = format[i] == '*' ? i : kNoAsterisk;
   i += SkipAsteriskOrInteger(&format[i]);

   // Skip the precision.
   size_t precision_asterisk_pos = kNoAsterisk;
   if (format[i] == '.') {
     i += 1;
     if (format[i] == '*') {
       precision_asterisk_pos = i;
     }
     i += SkipAsteriskOrInteger(&format[i]);
   }

   // Read the length modifier.
   const std::array<char, 2> length = ReadLengthModifier(&format[i]);
   i += (length[0] == '\0' ? 0 : 1) + (length[1] == '\0' ? 0 : 1);

   // Read the conversion specifier.
   const char spec = format[i];

   Type type;
   if (spec == 's') {
     type = kString;
   } else if (spec == 'c' || spec == 'd' || spec == 'i') {
     type = kSignedInt;
   } else if (std::strchr("oxXup", spec) != nullptr) {
     // The source size matters for unsigned integers because they need to be
     // masked off to their correct length, since zig-zag decode sign extends.
     // TODO(hepler): 64-bit targets likely have 64-bit l, j, z, and t. Also, p
     // needs to be 64-bit on these targets.
     type = length[0] == 'j' || length[1] == 'l' ? kUnsigned64 : kUnsigned32;
   } else if (std::strchr("fFeEaAgG", spec) != nullptr) {
     type = kFloatingPoint;
   } else if (spec == '%' && i == 1) {
     type = kPercent;
   } else {
     return StringSegment();
   }

   return StringSegment(std::string_view(format, i + 1),
                        type,
                        VarargSize(length, spec),
                        width_asterisk_pos,
                        precision_asterisk_pos);
 }

 StringSegment::ArgSize StringSegment::VarargSize(std::array<char, 2> length,
                                                  char spec) {
   // Use pointer size for %p or any other type (for which this doesn't matter).
   if (std::strchr("cdioxXu", spec) == nullptr) {
     return VarargSize<void*>();
   }
   if (length[0] == 'l') {
     return length[1] == 'l' ? VarargSize<long long>() : VarargSize<long>();
   }
   if (length[0] == 'j') {
     return VarargSize<intmax_t>();
   }
   if (length[0] == 'z') {
     return VarargSize<size_t>();
   }
   if (length[0] == 't') {
     return VarargSize<ptrdiff_t>();
   }
   return VarargSize<int>();
 }

 DecodedArg StringSegment::DecodeString(const span<const uint8_t>& arguments,
                                        const char* format,
                                        size_t raw_size_bytes) const {
   if (arguments.empty()) {
     return DecodedArg(ArgStatus::kMissing, text_);
   }

   ArgStatus status =
       (arguments[0] & 0x80u) == 0u ? ArgStatus::kOk : ArgStatus::kTruncated;

   const uint_fast8_t size = arguments[0] & 0x7Fu;

   if (arguments.size() - 1 < size) {
     status.Update(ArgStatus::kDecodeError);
     span<const uint8_t> arg_val = arguments.subspan(1);
     return DecodedArg(
         status,
         text_,
         arguments.size(),
         {reinterpret_cast<const char*>(arg_val.data()), arg_val.size()});
   }

   std::string value(reinterpret_cast<const char*>(arguments.data() + 1), size);

   if (status.HasError(ArgStatus::kTruncated)) {
     value.append("[...]");
   }

   return DecodedArg::FromValue(
       text_.c_str(), format, value.c_str(), raw_size_bytes + 1 + size, status);
 }

 DecodedArg StringSegment::DecodeInteger(const span<const uint8_t>& arguments,
                                         const char* format,
                                         size_t raw_size_bytes) const {
   if (arguments.empty()) {
     return DecodedArg(ArgStatus::kMissing, text_);
   }

   int64_t value;
   const size_t bytes = varint::Decode(as_bytes(arguments), &value);

   if (bytes == 0u) {
     return DecodedArg(ArgStatus::kDecodeError,
                       text_,
                       std::min(varint::kMaxVarint64SizeBytes,
                                static_cast<size_t>(arguments.size())));
   }

   // Unsigned ints need to be masked to their bit width due to sign extension.
   if (type_ == kUnsigned32) {
     value &= 0xFFFFFFFFu;
   }

   if (local_size_ == k32Bit) {
     return DecodedArg::FromValue(text_.c_str(),
                                  format,
                                  static_cast<uint32_t>(value),
                                  raw_size_bytes + bytes);
   }
   return DecodedArg::FromValue(
       text_.c_str(), format, value, raw_size_bytes + bytes);
 }

 DecodedArg StringSegment::DecodeFloatingPoint(
     const span<const uint8_t>& arguments,
     const char* format,
     size_t raw_size_bytes) const {
   static_assert(sizeof(float) == 4u);
   if (arguments.size() < sizeof(float)) {
     return DecodedArg(ArgStatus::kMissing, text_);
   }

   float value;
   std::memcpy(&value, arguments.data(), sizeof(value));
   return DecodedArg::FromValue(
       text_.c_str(), format, value, raw_size_bytes + sizeof(value));
 }

 DecodedArg StringSegment::DecodeStringOrNumber(
     const span<const uint8_t>& arguments,
     const char* format,
     size_t raw_size_bytes) const {
   if (type_ == kString) {
     return DecodeString(arguments, format, raw_size_bytes);
   }
   if (type_ == kSignedInt || type_ == kUnsigned32 || type_ == kUnsigned64) {
     return DecodeInteger(arguments, format, raw_size_bytes);
   }
   if (type_ == kFloatingPoint) {
     return DecodeFloatingPoint(arguments, format, raw_size_bytes);
   }
   return DecodedArg(ArgStatus::kDecodeError, text_);
 }

 DecodedArg StringSegment::Decode(const span<const uint8_t>& arguments) const {
   if (type_ == kLiteral) {
     return DecodedArg(text_);
   }
   if (type_ == kPercent) {
     return DecodedArg("%");
   }

   if (width_asterisk_pos_ == kNoAsterisk &&
       precision_asterisk_pos_ == kNoAsterisk) {
     return DecodeStringOrNumber(arguments, text_.c_str(), 0);
   }

   return DecodeArgWithAsterisks(arguments);
 }

 DecodedArg StringSegment::DecodeArgWithAsterisks(
     const span<const uint8_t>& arguments) const {
   size_t bytes_consumed = 0;
   ArgStatus status = ArgStatus::kOk;
   span<const uint8_t> remaining_arguments = arguments;

   auto decode_asterisk =
       [&remaining_arguments, &status, &bytes_consumed](int64_t& val) -> bool {
     if (remaining_arguments.empty()) {
       status.Update(ArgStatus::kMissing);
       return false;
     }
     size_t bytes = varint::Decode(as_bytes(remaining_arguments), &val);
     if (bytes == 0u) {
       status.Update(ArgStatus::kDecodeError);
       return false;
     }
     bytes_consumed += bytes;
     remaining_arguments = remaining_arguments.subspan(bytes);
     return true;
   };

   int64_t width_val = 0;
   if (width_asterisk_pos_ != kNoAsterisk && !decode_asterisk(width_val)) {
     return MakeErrorArg(status, text_, arguments.size(), bytes_consumed);
   }
   int64_t precision_val = 0;
   if (precision_asterisk_pos_ != kNoAsterisk &&
       !decode_asterisk(precision_val)) {
     return MakeErrorArg(status, text_, arguments.size(), bytes_consumed);
   }

   std::string resolved = text_;
   if (precision_asterisk_pos_ != kNoAsterisk) {
     // Ignore negative precision, as required by the C99 standard.
     if (precision_val < 0) {
       resolved.erase(precision_asterisk_pos_ - 1, 2);
     } else {
       resolved.replace(
           precision_asterisk_pos_, 1, std::to_string(precision_val));
     }
   }
   if (width_asterisk_pos_ != kNoAsterisk) {
     resolved.replace(width_asterisk_pos_, 1, std::to_string(width_val));
   }

   return DecodeStringOrNumber(
       remaining_arguments, resolved.c_str(), bytes_consumed);
 }

 DecodedArg StringSegment::Skip() const {
   switch (type_) {
     case kLiteral:
       return DecodedArg(text_);
     case kPercent:
       return DecodedArg("%");
     case kString:
     case kSignedInt:
     case kUnsigned32:
     case kUnsigned64:
     case kFloatingPoint:
     default:
       return DecodedArg(ArgStatus::kSkipped, text_);
   }
 }

 std::string DecodedFormatString::value() const {
   std::string output;

   for (const DecodedArg& arg : segments_) {
     output.append(arg.ok() ? arg.value() : arg.spec());
   }

   return output;
 }

 std::string DecodedFormatString::value_with_errors() const {
   std::string output;

   for (const DecodedArg& arg : segments_) {
     output.append(arg.value());
   }

   return output;
 }

 size_t DecodedFormatString::argument_count() const {
   return static_cast<size_t>(
       std::count_if(segments_.begin(), segments_.end(), [](const auto& arg) {
         return !arg.spec().empty();
       }));
 }

 size_t DecodedFormatString::decoding_errors() const {
   return static_cast<size_t>(
       std::count_if(segments_.begin(), segments_.end(), [](const auto& arg) {
         return !arg.ok();
       }));
 }

 FormatString::FormatString(const char* format) {
   const char* text_start = format;

   while (format[0] != '\0') {
     if (StringSegment spec = StringSegment::ParseFormatSpec(format);
         !spec.empty()) {
       // Add the text segment seen so far (if any).
       if (text_start < format) {
         segments_.emplace_back(std::string_view(
             text_start, static_cast<size_t>(format - text_start)));
       }

       // Move along the index and text segment start.
       format += spec.text().size();
       text_start = format;

       // Add the format specifier that was just found.
       segments_.push_back(std::move(spec));
     } else {
       format += 1;
     }
   }

   if (text_start < format) {
     segments_.emplace_back(
         std::string_view(text_start, static_cast<size_t>(format - text_start)));
   }
 }

 DecodedFormatString FormatString::Format(span<const uint8_t> arguments) const {
   std::vector<DecodedArg> results;
   bool skip = false;

   for (const auto& segment : segments_) {
     if (skip) {
       results.push_back(segment.Skip());
     } else {
       results.push_back(segment.Decode(arguments));
       arguments = arguments.subspan(results.back().raw_size_bytes());

       // If an error occurred, skip decoding the remaining arguments.
       if (!results.back().ok()) {
         skip = true;
       }
     }
   }

   return DecodedFormatString(std::move(results), arguments.size());
 }

 std::string FormatString::text() const {
   std::string full_string;
   for (const StringSegment& seg : segments_) {
     full_string.append(seg.text());
   }
   return full_string;
 }

 }  // namespace pw::tokenizer
	// Copyright 2020 The Pigweed Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License"); you may not
	// use this file except in compliance with the License. You may obtain a copy of
	// the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	// License for the specific language governing permissions and limitations under
	// the License.

	#include "pw_tokenizer/internal/decode.h"

	#include <algorithm>
	#include <array>
	#include <cctype>
	#include <cstring>
	#include <string>

	#include "pw_varint/varint.h"

	namespace pw::tokenizer {
	namespace {

	// Functions for parsing a printf format specifier.
	size_t SkipFlags(const char* str) {
	size_t i = 0;
	while (str[i] == '-' \|\| str[i] == '+' \|\| str[i] == '#' \|\| str[i] == ' ' \|\|
	str[i] == '0') {
	i += 1;
	}
	return i;
	}

	size_t SkipAsteriskOrInteger(const char* str) {
	if (str[0] == '*') {
	return 1;
	}

	size_t i = (str[0] == '-' \|\| str[0] == '+') ? 1 : 0;

	while (std::isdigit(str[i])) {
	i += 1;
	}
	return i;
	}

	std::array<char, 2> ReadLengthModifier(const char* str) {
	// Check for ll or hh.
	if (str[0] == str[1] && (str[0] == 'l' \|\| str[0] == 'h')) {
	return {str[0], str[1]};
	}
	if (std::strchr("hljztL", str[0]) != nullptr) {
	return {str[0]};
	}
	return {};
	}

	// Returns the error message that is used in place of a decoded arg when an
	// error occurs.
	std::string ErrorMessage(ArgStatus status,
	std::string_view spec,
	std::string_view value) {
	const char* message;
	if (status.HasError(ArgStatus::kSkipped)) {
	message = "SKIPPED";
	} else if (status.HasError(ArgStatus::kMissing)) {
	message = "MISSING";
	} else if (status.HasError(ArgStatus::kDecodeError)) {
	message = "ERROR";
	} else {
	message = "INTERNAL ERROR";
	}

	std::string result(PW_TOKENIZER_ARG_DECODING_ERROR_PREFIX);
	result.append(spec);
	result.push_back(' ');
	result.append(message);

	if (!value.empty()) {
	result.push_back(' ');
	result.push_back('(');
	result.append(value);
	result.push_back(')');
	}

	result.append(PW_TOKENIZER_ARG_DECODING_ERROR_SUFFIX);
	return result;
	}

	DecodedArg MakeErrorArg(ArgStatus status,
	std::string_view spec,
	size_t total_arguments_size,
	size_t bytes_consumed) {
	return DecodedArg(status,
	spec,
	status.HasError(ArgStatus::kDecodeError)
	? total_arguments_size
	: bytes_consumed);
	}
	} // namespace

	DecodedArg::DecodedArg(ArgStatus error,
	std::string_view spec,
	size_t raw_size_bytes,
	std::string_view value)
	: value_(ErrorMessage(error, spec, value)),
	spec_(spec),
	raw_data_size_bytes_(raw_size_bytes),
	status_(error) {}

	StringSegment StringSegment::ParseFormatSpec(const char* format) {
	if (format[0] != '%' \|\| format[1] == '\0') {
	return StringSegment();
	}

	// Parse the format specifier.
	size_t i = 1;

	// Skip the flags.
	i += SkipFlags(&format[i]);

	// Skip the field width.
	const size_t width_asterisk_pos = format[i] == '*' ? i : kNoAsterisk;
	i += SkipAsteriskOrInteger(&format[i]);

	// Skip the precision.
	size_t precision_asterisk_pos = kNoAsterisk;
	if (format[i] == '.') {
	i += 1;
	if (format[i] == '*') {
	precision_asterisk_pos = i;
	}
	i += SkipAsteriskOrInteger(&format[i]);
	}

	// Read the length modifier.
	const std::array<char, 2> length = ReadLengthModifier(&format[i]);
	i += (length[0] == '\0' ? 0 : 1) + (length[1] == '\0' ? 0 : 1);

	// Read the conversion specifier.
	const char spec = format[i];

	Type type;
	if (spec == 's') {
	type = kString;
	} else if (spec == 'c' \|\| spec == 'd' \|\| spec == 'i') {
	type = kSignedInt;
	} else if (std::strchr("oxXup", spec) != nullptr) {
	// The source size matters for unsigned integers because they need to be
	// masked off to their correct length, since zig-zag decode sign extends.
	// TODO(hepler): 64-bit targets likely have 64-bit l, j, z, and t. Also, p
	// needs to be 64-bit on these targets.
	type = length[0] == 'j' \|\| length[1] == 'l' ? kUnsigned64 : kUnsigned32;
	} else if (std::strchr("fFeEaAgG", spec) != nullptr) {
	type = kFloatingPoint;
	} else if (spec == '%' && i == 1) {
	type = kPercent;
	} else {
	return StringSegment();
	}

	return StringSegment(std::string_view(format, i + 1),
	type,
	VarargSize(length, spec),
	width_asterisk_pos,
	precision_asterisk_pos);
	}

	StringSegment::ArgSize StringSegment::VarargSize(std::array<char, 2> length,
	char spec) {
	// Use pointer size for %p or any other type (for which this doesn't matter).
	if (std::strchr("cdioxXu", spec) == nullptr) {
	return VarargSize<void*>();
	}
	if (length[0] == 'l') {
	return length[1] == 'l' ? VarargSize<long long>() : VarargSize<long>();
	}
	if (length[0] == 'j') {
	return VarargSize<intmax_t>();
	}
	if (length[0] == 'z') {
	return VarargSize<size_t>();
	}
	if (length[0] == 't') {
	return VarargSize<ptrdiff_t>();
	}
	return VarargSize<int>();
	}

	DecodedArg StringSegment::DecodeString(const span<const uint8_t>& arguments,
	const char* format,
	size_t raw_size_bytes) const {
	if (arguments.empty()) {
	return DecodedArg(ArgStatus::kMissing, text_);
	}

	ArgStatus status =
	(arguments[0] & 0x80u) == 0u ? ArgStatus::kOk : ArgStatus::kTruncated;

	const uint_fast8_t size = arguments[0] & 0x7Fu;

	if (arguments.size() - 1 < size) {
	status.Update(ArgStatus::kDecodeError);
	span<const uint8_t> arg_val = arguments.subspan(1);
	return DecodedArg(
	status,
	text_,
	arguments.size(),
	{reinterpret_cast<const char*>(arg_val.data()), arg_val.size()});
	}

	std::string value(reinterpret_cast<const char*>(arguments.data() + 1), size);

	if (status.HasError(ArgStatus::kTruncated)) {
	value.append("[...]");
	}

	return DecodedArg::FromValue(
	text_.c_str(), format, value.c_str(), raw_size_bytes + 1 + size, status);
	}

	DecodedArg StringSegment::DecodeInteger(const span<const uint8_t>& arguments,
	const char* format,
	size_t raw_size_bytes) const {
	if (arguments.empty()) {
	return DecodedArg(ArgStatus::kMissing, text_);
	}

	int64_t value;
	const size_t bytes = varint::Decode(as_bytes(arguments), &value);

	if (bytes == 0u) {
	return DecodedArg(ArgStatus::kDecodeError,
	text_,
	std::min(varint::kMaxVarint64SizeBytes,
	static_cast<size_t>(arguments.size())));
	}

	// Unsigned ints need to be masked to their bit width due to sign extension.
	if (type_ == kUnsigned32) {
	value &= 0xFFFFFFFFu;
	}

	if (local_size_ == k32Bit) {
	return DecodedArg::FromValue(text_.c_str(),
	format,
	static_cast<uint32_t>(value),
	raw_size_bytes + bytes);
	}
	return DecodedArg::FromValue(
	text_.c_str(), format, value, raw_size_bytes + bytes);
	}

	DecodedArg StringSegment::DecodeFloatingPoint(
	const span<const uint8_t>& arguments,
	const char* format,
	size_t raw_size_bytes) const {
	static_assert(sizeof(float) == 4u);
	if (arguments.size() < sizeof(float)) {
	return DecodedArg(ArgStatus::kMissing, text_);
	}

	float value;
	std::memcpy(&value, arguments.data(), sizeof(value));
	return DecodedArg::FromValue(
	text_.c_str(), format, value, raw_size_bytes + sizeof(value));
	}

	DecodedArg StringSegment::DecodeStringOrNumber(
	const span<const uint8_t>& arguments,
	const char* format,
	size_t raw_size_bytes) const {
	if (type_ == kString) {
	return DecodeString(arguments, format, raw_size_bytes);
	}
	if (type_ == kSignedInt \|\| type_ == kUnsigned32 \|\| type_ == kUnsigned64) {
	return DecodeInteger(arguments, format, raw_size_bytes);
	}
	if (type_ == kFloatingPoint) {
	return DecodeFloatingPoint(arguments, format, raw_size_bytes);
	}
	return DecodedArg(ArgStatus::kDecodeError, text_);
	}

	DecodedArg StringSegment::Decode(const span<const uint8_t>& arguments) const {
	if (type_ == kLiteral) {
	return DecodedArg(text_);
	}
	if (type_ == kPercent) {
	return DecodedArg("%");
	}

	if (width_asterisk_pos_ == kNoAsterisk &&
	precision_asterisk_pos_ == kNoAsterisk) {
	return DecodeStringOrNumber(arguments, text_.c_str(), 0);
	}

	return DecodeArgWithAsterisks(arguments);
	}

	DecodedArg StringSegment::DecodeArgWithAsterisks(
	const span<const uint8_t>& arguments) const {
	size_t bytes_consumed = 0;
	ArgStatus status = ArgStatus::kOk;
	span<const uint8_t> remaining_arguments = arguments;

	auto decode_asterisk =
	[&remaining_arguments, &status, &bytes_consumed](int64_t& val) -> bool {
	if (remaining_arguments.empty()) {
	status.Update(ArgStatus::kMissing);
	return false;
	}
	size_t bytes = varint::Decode(as_bytes(remaining_arguments), &val);
	if (bytes == 0u) {
	status.Update(ArgStatus::kDecodeError);
	return false;
	}
	bytes_consumed += bytes;
	remaining_arguments = remaining_arguments.subspan(bytes);
	return true;
	};

	int64_t width_val = 0;
	if (width_asterisk_pos_ != kNoAsterisk && !decode_asterisk(width_val)) {
	return MakeErrorArg(status, text_, arguments.size(), bytes_consumed);
	}
	int64_t precision_val = 0;
	if (precision_asterisk_pos_ != kNoAsterisk &&
	!decode_asterisk(precision_val)) {
	return MakeErrorArg(status, text_, arguments.size(), bytes_consumed);
	}

	std::string resolved = text_;
	if (precision_asterisk_pos_ != kNoAsterisk) {
	// Ignore negative precision, as required by the C99 standard.
	if (precision_val < 0) {
	resolved.erase(precision_asterisk_pos_ - 1, 2);
	} else {
	resolved.replace(
	precision_asterisk_pos_, 1, std::to_string(precision_val));
	}
	}
	if (width_asterisk_pos_ != kNoAsterisk) {
	resolved.replace(width_asterisk_pos_, 1, std::to_string(width_val));
	}

	return DecodeStringOrNumber(
	remaining_arguments, resolved.c_str(), bytes_consumed);
	}

	DecodedArg StringSegment::Skip() const {
	switch (type_) {
	case kLiteral:
	return DecodedArg(text_);
	case kPercent:
	return DecodedArg("%");
	case kString:
	case kSignedInt:
	case kUnsigned32:
	case kUnsigned64:
	case kFloatingPoint:
	default:
	return DecodedArg(ArgStatus::kSkipped, text_);
	}
	}

	std::string DecodedFormatString::value() const {
	std::string output;

	for (const DecodedArg& arg : segments_) {
	output.append(arg.ok() ? arg.value() : arg.spec());
	}

	return output;
	}

	std::string DecodedFormatString::value_with_errors() const {
	std::string output;

	for (const DecodedArg& arg : segments_) {
	output.append(arg.value());
	}

	return output;
	}

	size_t DecodedFormatString::argument_count() const {
	return static_cast<size_t>(
	std::count_if(segments_.begin(), segments_.end(), [](const auto& arg) {
	return !arg.spec().empty();
	}));
	}

	size_t DecodedFormatString::decoding_errors() const {
	return static_cast<size_t>(
	std::count_if(segments_.begin(), segments_.end(), [](const auto& arg) {
	return !arg.ok();
	}));
	}

	FormatString::FormatString(const char* format) {
	const char* text_start = format;

	while (format[0] != '\0') {
	if (StringSegment spec = StringSegment::ParseFormatSpec(format);
	!spec.empty()) {
	// Add the text segment seen so far (if any).
	if (text_start < format) {
	segments_.emplace_back(std::string_view(
	text_start, static_cast<size_t>(format - text_start)));
	}

	// Move along the index and text segment start.
	format += spec.text().size();
	text_start = format;

	// Add the format specifier that was just found.
	segments_.push_back(std::move(spec));
	} else {
	format += 1;
	}
	}

	if (text_start < format) {
	segments_.emplace_back(
	std::string_view(text_start, static_cast<size_t>(format - text_start)));
	}
	}

	DecodedFormatString FormatString::Format(span<const uint8_t> arguments) const {
	std::vector<DecodedArg> results;
	bool skip = false;

	for (const auto& segment : segments_) {
	if (skip) {
	results.push_back(segment.Skip());
	} else {
	results.push_back(segment.Decode(arguments));
	arguments = arguments.subspan(results.back().raw_size_bytes());

	// If an error occurred, skip decoding the remaining arguments.
	if (!results.back().ok()) {
	skip = true;
	}
	}
	}

	return DecodedFormatString(std::move(results), arguments.size());
	}

	std::string FormatString::text() const {
	std::string full_string;
	for (const StringSegment& seg : segments_) {
	full_string.append(seg.text());
	}
	return full_string;
	}

	} // namespace pw::tokenizer