| // Copyright 2020 The Abseil 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 "absl/strings/internal/str_format/parser.h" |
| |
| #include <assert.h> |
| #include <string.h> |
| #include <wchar.h> |
| #include <cctype> |
| #include <cstdint> |
| |
| #include <algorithm> |
| #include <initializer_list> |
| #include <limits> |
| #include <ostream> |
| #include <string> |
| #include <unordered_set> |
| |
| namespace absl { |
| ABSL_NAMESPACE_BEGIN |
| namespace str_format_internal { |
| |
| // Define the array for non-constexpr uses. |
| constexpr ConvTag ConvTagHolder::value[256]; |
| |
| ABSL_ATTRIBUTE_NOINLINE const char* ConsumeUnboundConversionNoInline( |
| const char* p, const char* end, UnboundConversion* conv, int* next_arg) { |
| return ConsumeUnboundConversion(p, end, conv, next_arg); |
| } |
| |
| std::string LengthModToString(LengthMod v) { |
| switch (v) { |
| case LengthMod::h: |
| return "h"; |
| case LengthMod::hh: |
| return "hh"; |
| case LengthMod::l: |
| return "l"; |
| case LengthMod::ll: |
| return "ll"; |
| case LengthMod::L: |
| return "L"; |
| case LengthMod::j: |
| return "j"; |
| case LengthMod::z: |
| return "z"; |
| case LengthMod::t: |
| return "t"; |
| case LengthMod::q: |
| return "q"; |
| case LengthMod::none: |
| return ""; |
| } |
| return ""; |
| } |
| |
| struct ParsedFormatBase::ParsedFormatConsumer { |
| explicit ParsedFormatConsumer(ParsedFormatBase *parsedformat) |
| : parsed(parsedformat), data_pos(parsedformat->data_.get()) {} |
| |
| bool Append(string_view s) { |
| if (s.empty()) return true; |
| |
| size_t text_end = AppendText(s); |
| |
| if (!parsed->items_.empty() && !parsed->items_.back().is_conversion) { |
| // Let's extend the existing text run. |
| parsed->items_.back().text_end = text_end; |
| } else { |
| // Let's make a new text run. |
| parsed->items_.push_back({false, text_end, {}}); |
| } |
| return true; |
| } |
| |
| bool ConvertOne(const UnboundConversion &conv, string_view s) { |
| size_t text_end = AppendText(s); |
| parsed->items_.push_back({true, text_end, conv}); |
| return true; |
| } |
| |
| size_t AppendText(string_view s) { |
| memcpy(data_pos, s.data(), s.size()); |
| data_pos += s.size(); |
| return static_cast<size_t>(data_pos - parsed->data_.get()); |
| } |
| |
| ParsedFormatBase *parsed; |
| char* data_pos; |
| }; |
| |
| ParsedFormatBase::ParsedFormatBase( |
| string_view format, bool allow_ignored, |
| std::initializer_list<FormatConversionCharSet> convs) |
| : data_(format.empty() ? nullptr : new char[format.size()]) { |
| has_error_ = !ParseFormatString(format, ParsedFormatConsumer(this)) || |
| !MatchesConversions(allow_ignored, convs); |
| } |
| |
| bool ParsedFormatBase::MatchesConversions( |
| bool allow_ignored, |
| std::initializer_list<FormatConversionCharSet> convs) const { |
| std::unordered_set<int> used; |
| auto add_if_valid_conv = [&](int pos, char c) { |
| if (static_cast<size_t>(pos) > convs.size() || |
| !Contains(convs.begin()[pos - 1], c)) |
| return false; |
| used.insert(pos); |
| return true; |
| }; |
| for (const ConversionItem &item : items_) { |
| if (!item.is_conversion) continue; |
| auto &conv = item.conv; |
| if (conv.precision.is_from_arg() && |
| !add_if_valid_conv(conv.precision.get_from_arg(), '*')) |
| return false; |
| if (conv.width.is_from_arg() && |
| !add_if_valid_conv(conv.width.get_from_arg(), '*')) |
| return false; |
| if (!add_if_valid_conv(conv.arg_position, |
| FormatConversionCharToChar(conv.conv))) |
| return false; |
| } |
| return used.size() == convs.size() || allow_ignored; |
| } |
| |
| } // namespace str_format_internal |
| ABSL_NAMESPACE_END |
| } // namespace absl |