| // Copyright 2019 Google LLC |
| // |
| // 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. |
| |
| // This header contains functionality related to Emboss text output. |
| #ifndef EMBOSS_PUBLIC_EMBOSS_TEXT_UTIL_H_ |
| #define EMBOSS_PUBLIC_EMBOSS_TEXT_UTIL_H_ |
| |
| #include <array> |
| #include <climits> |
| #include <cmath> |
| #include <cstdio> |
| #include <cstring> |
| #include <limits> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| |
| #include "public/emboss_defines.h" |
| |
| namespace emboss { |
| |
| // TextOutputOptions are used to configure text output. Typically, one can just |
| // use a default TextOutputOptions() (for compact output) or MultilineText() |
| // (for reasonable formatted output). |
| class TextOutputOptions final { |
| public: |
| TextOutputOptions() = default; |
| |
| TextOutputOptions PlusOneIndent() const { |
| TextOutputOptions result = *this; |
| result.current_indent_ += indent(); |
| return result; |
| } |
| |
| TextOutputOptions Multiline(bool new_value) const { |
| TextOutputOptions result = *this; |
| result.multiline_ = new_value; |
| return result; |
| } |
| |
| TextOutputOptions WithIndent(::std::string new_value) const { |
| TextOutputOptions result = *this; |
| result.indent_ = ::std::move(new_value); |
| return result; |
| } |
| |
| TextOutputOptions WithComments(bool new_value) const { |
| TextOutputOptions result = *this; |
| result.comments_ = new_value; |
| return result; |
| } |
| |
| TextOutputOptions WithDigitGrouping(bool new_value) const { |
| TextOutputOptions result = *this; |
| result.digit_grouping_ = new_value; |
| return result; |
| } |
| |
| TextOutputOptions WithNumericBase(int new_value) const { |
| TextOutputOptions result = *this; |
| result.numeric_base_ = new_value; |
| return result; |
| } |
| |
| ::std::string current_indent() const { return current_indent_; } |
| ::std::string indent() const { return indent_; } |
| bool multiline() const { return multiline_; } |
| bool digit_grouping() const { return digit_grouping_; } |
| bool comments() const { return comments_; } |
| ::std::uint8_t numeric_base() const { return numeric_base_; } |
| |
| private: |
| ::std::string indent_; |
| ::std::string current_indent_; |
| bool comments_ = false; |
| bool multiline_ = false; |
| bool digit_grouping_ = false; |
| ::std::uint8_t numeric_base_ = 10; |
| }; |
| |
| namespace support { |
| |
| // TextOutputStream puts a stream-like interface onto a std::string, for use by |
| // DumpToTextStream. It is used by UpdateFromText(). |
| class TextOutputStream final { |
| public: |
| inline explicit TextOutputStream() = default; |
| |
| inline void Write(const ::std::string &text) { |
| text_.write(text.data(), text.size()); |
| } |
| |
| inline void Write(const char *text) { text_.write(text, strlen(text)); } |
| |
| inline void Write(const char c) { text_.put(c); } |
| |
| inline ::std::string Result() { return text_.str(); } |
| |
| private: |
| ::std::ostringstream text_; |
| }; |
| |
| // DecodeInteger decodes an integer from a string. This is very similar to the |
| // many, many existing integer decode routines in the world, except that a) it |
| // accepts integers in any Emboss format, and b) it can run in environments that |
| // do not support std::istream or Google's number conversion routines. |
| // |
| // Ideally, this would be replaced by someone else's code. |
| template <class IntType> |
| bool DecodeInteger(const ::std::string &text, IntType *result) { |
| IntType accumulator = 0; |
| IntType base = 10; |
| bool negative = false; |
| unsigned offset = 0; |
| if (::std::is_signed<IntType>::value && text.size() >= 1 + offset && |
| text[offset] == '-') { |
| negative = true; |
| offset += 1; |
| } |
| if (text.size() >= 2 + offset && text[offset] == '0') { |
| if (text[offset + 1] == 'x' || text[offset + 1] == 'X') { |
| base = 16; |
| offset += 2; |
| } else if (text[offset + 1] == 'b' || text[offset + 1] == 'B') { |
| base = 2; |
| offset += 2; |
| } |
| } |
| // "", "0x", "0b", "-", "-0x", and "-0b" are not valid numbers. |
| if (offset == text.size()) return false; |
| for (; offset < text.size(); ++offset) { |
| char c = text[offset]; |
| IntType digit = 0; |
| if (c == '_') { |
| if (offset == 0) { |
| return false; |
| } |
| continue; |
| } else if (c >= '0' && c <= '9') { |
| digit = c - '0'; |
| } else if (c >= 'A' && c <= 'F') { |
| digit = c - 'A' + 10; |
| } else if (c >= 'a' && c <= 'f') { |
| digit = c - 'a' + 10; |
| } else { |
| return false; |
| } |
| if (digit >= base) { |
| return false; |
| } |
| if (negative) { |
| if (accumulator < |
| (::std::numeric_limits<IntType>::min() + digit) / base) { |
| return false; |
| } |
| accumulator = accumulator * base - digit; |
| } else { |
| if (accumulator > |
| (::std::numeric_limits<IntType>::max() - digit) / base) { |
| return false; |
| } |
| accumulator = accumulator * base + digit; |
| } |
| } |
| *result = accumulator; |
| return true; |
| } |
| |
| template <class Stream> |
| bool DiscardWhitespace(Stream *stream) { |
| char c; |
| bool in_comment = false; |
| do { |
| if (!stream->Read(&c)) return true; |
| if (c == '#') in_comment = true; |
| if (c == '\r' || c == '\n') in_comment = false; |
| } while (in_comment || c == ' ' || c == '\t' || c == '\n' || c == '\r'); |
| return stream->Unread(c); |
| } |
| |
| template <class Stream> |
| bool ReadToken(Stream *stream, ::std::string *token) { |
| ::std::vector<char> result; |
| char c; |
| if (!DiscardWhitespace(stream)) return false; |
| if (!stream->Read(&c)) { |
| *token = ""; |
| return true; |
| } |
| |
| const char *const punctuation = ":{}[],"; |
| if (strchr(punctuation, c) != nullptr) { |
| *token = ::std::string(1, c); |
| return true; |
| } else { |
| // TODO(bolms): Only allow alphanumeric characters here? |
| do { |
| result.push_back(c); |
| if (!stream->Read(&c)) { |
| *token = ::std::string(&result[0], result.size()); |
| return true; |
| } |
| } while (c != ' ' && c != '\t' && c != '\n' && c != '\r' && c != '#' && |
| strchr(punctuation, c) == nullptr); |
| if (!stream->Unread(c)) return false; |
| *token = ::std::string(&result[0], result.size()); |
| return true; |
| } |
| } |
| |
| template <class Stream, class View> |
| bool ReadIntegerFromTextStream(View *view, Stream *stream) { |
| ::std::string token; |
| if (!::emboss::support::ReadToken(stream, &token)) return false; |
| if (token.empty()) return false; |
| typename View::ValueType value; |
| if (!::emboss::support::DecodeInteger(token, &value)) return false; |
| return view->TryToWrite(value); |
| } |
| |
| // WriteIntegerToTextStream encodes the given value in base 2, 10, or 16, with |
| // or without digit group separators ('_'), and then calls stream->Write() with |
| // a char * argument that is a C-style null-terminated string of the encoded |
| // number. |
| // |
| // As with DecodeInteger, above, it would be nice to be able to replace this |
| // with someone else's code, but I (bolms@) was unable to find anything in |
| // standard C++ that would encode numbers in binary, nothing that would add |
| // digit separators to hex numbers, and nothing that would use '_' for digit |
| // separators. |
| template <class Stream, typename IntegralType> |
| void WriteIntegerToTextStream(IntegralType value, Stream *stream, |
| ::std::uint8_t base, bool digit_grouping) { |
| static_assert(::std::numeric_limits< |
| typename ::std::remove_cv<IntegralType>::type>::is_integer, |
| "WriteIntegerToTextStream only supports integer types."); |
| static_assert( |
| !::std::is_same<bool, |
| typename ::std::remove_cv<IntegralType>::type>::value, |
| "WriteIntegerToTextStream only supports integer types."); |
| EMBOSS_CHECK(base == 10 || base == 2 || base == 16); |
| const char *const digits = "0123456789abcdef"; |
| const int grouping = base == 10 ? 3 : base == 16 ? 4 : 8; |
| // The maximum size 32-bit number is -2**31, which is: |
| // |
| // -0b10000000_00000000_00000000_00000000 (38 chars) |
| // -2_147_483_648 (14 chars) |
| // -0x8000_0000 (12 chars) |
| // |
| // Likewise, the maximum size 8-bit number is -128, which is: |
| // -0b10000000 (11 chars) |
| // -128 (4 chars) |
| // -0x80 (5 chars) |
| // |
| // Binary with separators is always the longest value: 9 chars per 8 bits, |
| // minus 1 char for the '_' that does not appear at the front of the number, |
| // plus 2 chars for "0b", plus 1 char for '-', plus 1 extra char for the |
| // trailing '\0', which is (sizeof value) * CHAR_BIT * 9 / 8 - 1 + 2 + 1 + 1. |
| const int buffer_size = (sizeof value) * CHAR_BIT * 9 / 8 + 3; |
| char buffer[buffer_size]; |
| buffer[buffer_size - 1] = '\0'; |
| int next_char = buffer_size - 2; |
| if (value == 0) { |
| EMBOSS_DCHECK_GE(next_char, 0); |
| buffer[next_char] = digits[0]; |
| --next_char; |
| } |
| int sign = value < 0 ? -1 : 1; |
| int digit_count = 0; |
| auto buffer_char = [&](char c) { |
| EMBOSS_DCHECK_GE(next_char, 0); |
| buffer[next_char] = c; |
| --next_char; |
| }; |
| if (value < 0) { |
| if (value == ::std::numeric_limits<decltype(value)>::lowest()) { |
| // The minimum negative two's-complement value has no corresponding |
| // positive value, so 'value = -value' is not useful in that case. |
| // Instead, we do some trickery to buffer the lowest-order digit here. |
| auto digit = -(value + 1) % base + 1; |
| value = -(value + 1) / base; |
| if (digit == base) { |
| digit = 0; |
| ++value; |
| } |
| buffer_char(digits[digit]); |
| ++digit_count; |
| } else { |
| value = -value; |
| } |
| } |
| while (value > 0) { |
| if (digit_count && digit_count % grouping == 0 && digit_grouping) { |
| buffer_char('_'); |
| } |
| buffer_char(digits[value % base]); |
| value /= base; |
| ++digit_count; |
| } |
| if (base == 16) { |
| buffer_char('x'); |
| buffer_char('0'); |
| } else if (base == 2) { |
| buffer_char('b'); |
| buffer_char('0'); |
| } |
| if (sign < 0) { |
| buffer_char('-'); |
| } |
| |
| stream->Write(buffer + 1 + next_char); |
| } |
| |
| // Writes an integer value in the base given in options, plus an optional |
| // comment with the same value in a second base. This is used for the common |
| // output format of IntView, UIntView, and BcdView. |
| template <class Stream, class View> |
| void WriteIntegerViewToTextStream(View *view, Stream *stream, |
| const TextOutputOptions &options) { |
| WriteIntegerToTextStream(view->Read(), stream, options.numeric_base(), |
| options.digit_grouping()); |
| if (options.comments()) { |
| stream->Write(" # "); |
| WriteIntegerToTextStream(view->Read(), stream, |
| options.numeric_base() == 10 ? 16 : 10, |
| options.digit_grouping()); |
| } |
| } |
| |
| // The TextOutputOptions parameter is present so that it can be passed in by |
| // generated code that uses the same form for WriteBooleanViewToTextStream, |
| // WriteIntegerViewToTextStream, and WriteEnumViewToTextStream. |
| template <class Stream, class View> |
| void WriteBooleanViewToTextStream(View *view, Stream *stream, |
| const TextOutputOptions &) { |
| if (view->Read()) { |
| stream->Write("true"); |
| } else { |
| stream->Write("false"); |
| } |
| } |
| |
| // FloatConstants holds various masks for working with IEEE754-compatible |
| // floating-point values at a bit level. These are mostly used here to |
| // implement text format for NaNs, preserving the NaN payload so that the text |
| // format can (in theory) provide a bit-exact round-trip through the text |
| // format. |
| template <class Float> |
| struct FloatConstants; |
| |
| template <> |
| struct FloatConstants<float> { |
| static_assert(sizeof(float) == 4, "Emboss requires 32-bit float."); |
| using MatchingIntegerType = ::std::uint32_t; |
| static constexpr MatchingIntegerType kMantissaMask() { return 0x7fffffU; } |
| static constexpr MatchingIntegerType kExponentMask() { return 0x7f800000U; } |
| static constexpr MatchingIntegerType kSignMask() { return 0x80000000U; } |
| static constexpr int kPrintfPrecision() { return 9; } |
| static constexpr const char *kScanfFormat() { return "%f%n"; } |
| }; |
| |
| template <> |
| struct FloatConstants<double> { |
| static_assert(sizeof(double) == 8, "Emboss requires 64-bit double."); |
| using MatchingIntegerType = ::std::uint64_t; |
| static constexpr MatchingIntegerType kMantissaMask() { |
| return 0xfffffffffffffUL; |
| } |
| static constexpr MatchingIntegerType kExponentMask() { |
| return 0x7ff0000000000000UL; |
| } |
| static constexpr MatchingIntegerType kSignMask() { |
| return 0x8000000000000000UL; |
| } |
| static constexpr int kPrintfPrecision() { return 17; } |
| static constexpr const char *kScanfFormat() { return "%lf%n"; } |
| }; |
| |
| // Decodes a floating-point number from text. |
| template <class Float> |
| bool DecodeFloat(const ::std::string &token, Float *result) { |
| // The state of the world for reading floating-point values is somewhat better |
| // than the situation for writing them, but there are still a few bits that |
| // are underspecified. This function is the mirror of WriteFloatToTextStream, |
| // below, so it specifically decodes infinities and NaNs in the formats that |
| // Emboss uses. |
| // |
| // Because of the use of scanf here, this function accepts hex floating-point |
| // values (0xh.hhhhpeee) *on some systems*. TODO(bolms): make hex float |
| // support universal. |
| |
| using UInt = typename FloatConstants<Float>::MatchingIntegerType; |
| |
| if (token.empty()) return false; |
| |
| // First, check for negative. |
| bool negative = token[0] == '-'; |
| |
| // Second, check for NaN. |
| ::std::size_t i = token[0] == '-' || token[0] == '+' ? 1 : 0; |
| if (token.size() >= i + 3 && (token[i] == 'N' || token[i] == 'n') && |
| (token[i + 1] == 'A' || token[i + 1] == 'a') && |
| (token[i + 2] == 'N' || token[i + 2] == 'n')) { |
| UInt nan_payload; |
| if (token.size() >= i + 4) { |
| if (token[i + 3] == '(' && token[token.size() - 1] == ')') { |
| if (!DecodeInteger(token.substr(i + 4, token.size() - i - 5), |
| &nan_payload)) { |
| return false; |
| } |
| } else { |
| // NaN may not be followed by trailing characters other than a |
| // ()-enclosed payload. |
| return false; |
| } |
| } else { |
| // If no specific NaN was given, take a default NaN from the C++ standard |
| // library. Technically, a conformant C++ implementation might not have |
| // quiet_NaN(), but any IEEE754-based implementation should. |
| // |
| // It is tempting to just write the default NaN directly into the view and |
| // return success, but "-NaN" should be have its sign bit set, and there |
| // is no direct way to set the sign bit of a NaN, so there are fewer code |
| // paths if we extract the default NaN payload, then use it in the |
| // reconstruction step, below. |
| Float default_nan = ::std::numeric_limits<Float>::quiet_NaN(); |
| UInt bits; |
| ::std::memcpy(&bits, &default_nan, sizeof(bits)); |
| nan_payload = bits & FloatConstants<Float>::kMantissaMask(); |
| } |
| if (nan_payload == 0) { |
| // "NaN" with a payload of zero is actually the bit pattern for infinity; |
| // "NaN(0)" should not be an alias for "Inf". |
| return false; |
| } |
| if (nan_payload & (FloatConstants<Float>::kExponentMask() | |
| FloatConstants<Float>::kSignMask())) { |
| // The payload must be small enough to fit in the payload space; it must |
| // not overflow into the exponent or sign bits. |
| // |
| // Note that the DecodeInteger call which decoded the payload will return |
| // false if the payload would overflow the `UInt` type, so cases like |
| // "NaN(0x10000000000000000000000000000)" -- which are so big that they no |
| // longer interfere with the sign or exponent -- are caught above. |
| return false; |
| } |
| UInt bits = FloatConstants<Float>::kExponentMask(); |
| bits |= nan_payload; |
| if (negative) { |
| bits |= FloatConstants<Float>::kSignMask(); |
| } |
| ::std::memcpy(result, &bits, sizeof(bits)); |
| return true; |
| } |
| |
| // If the value is not NaN, check for infinity. |
| if (token.size() >= i + 3 && (token[i] == 'I' || token[i] == 'i') && |
| (token[i + 1] == 'N' || token[i + 1] == 'n') && |
| (token[i + 2] == 'F' || token[i + 2] == 'f')) { |
| if (token.size() > i + 3) { |
| // Infinity must be exactly "Inf" or "-Inf" (case insensitive). There |
| // must not be trailing characters. |
| return false; |
| } |
| // As with quiet_NaN(), a conforming C++ implementation might not have |
| // infinity(), but an IEEE 754-based implementation should. |
| if (negative) { |
| *result = -::std::numeric_limits<Float>::infinity(); |
| return true; |
| } else { |
| *result = ::std::numeric_limits<Float>::infinity(); |
| return true; |
| } |
| } |
| |
| // For non-NaN, non-Inf values, use the C scanf function, mirroring the use of |
| // printf for writing the value, below. |
| int chars_used = -1; |
| if (::std::sscanf(token.c_str(), FloatConstants<Float>::kScanfFormat(), |
| result, &chars_used) < 1) { |
| return false; |
| } |
| if (chars_used < 0 || |
| static_cast</**/ ::std::size_t>(chars_used) < token.size()) { |
| return false; |
| } |
| return true; |
| } |
| |
| // Decodes a floating-point number from a text stream and writes it to the |
| // specified view. |
| template <class Stream, class View> |
| bool ReadFloatFromTextStream(View *view, Stream *stream) { |
| ::std::string token; |
| if (!ReadToken(stream, &token)) return false; |
| typename View::ValueType value; |
| if (!DecodeFloat(token, &value)) return false; |
| return view->TryToWrite(value); |
| } |
| |
| template <class Stream, class Float> |
| void WriteFloatToTextStream(Float n, Stream *stream, |
| const TextOutputOptions &options) { |
| static_assert(::std::is_same<Float, float>::value || |
| ::std::is_same<Float, double>::value, |
| "WriteFloatToTextStream can only write float or double."); |
| // The state of the world w.r.t. rendering floating-points as decimal text is, |
| // ca. 2018, less than ideal. |
| // |
| // In C++ land, there is actually no stable facility in the standard library |
| // until to_chars() in C++17 -- which is not actually implemented yet in |
| // libc++. to_string(), the printf() family, and the iostreams system all |
| // respect the current locale. In most programs, the locale is permanently |
| // left on "C", but this is not guaranteed. to_string() also uses a fixed and |
| // rather unfortunate format. |
| // |
| // For integers, I (bolms@) chose to just implement custom read and write |
| // routines, but those routines are quite small and straightforward compared |
| // to floating point conversion. Even writing correct output is difficult, |
| // and writing correct and minimal output is the subject of a number of |
| // academic papers. |
| // |
| // For the moment, I'm just using snprintf("%.*g", 17, n), which is guaranteed |
| // to be read back as the same number, but can be longer than strictly |
| // necessary. |
| // |
| // TODO(bolms): Import a modified version of the double-to-string conversion |
| // from Swift's standard library, which appears to be best implementation |
| // currently available. |
| |
| if (::std::isnan(n)) { |
| // The printf format for NaN is just "NaN". In the interests of keeping |
| // things bit-exact, Emboss prints the exact NaN. |
| typename FloatConstants<Float>::MatchingIntegerType bits; |
| ::std::memcpy(&bits, &n, sizeof(bits)); |
| ::std::uint64_t nan_payload = bits & FloatConstants<Float>::kMantissaMask(); |
| ::std::uint64_t nan_sign = bits & FloatConstants<Float>::kSignMask(); |
| if (nan_sign) { |
| // NaN still has a sign bit, which is generally treated differently from |
| // the payload. There is no real "standard" text format for NaNs, but |
| // "-NaN" appears to be a common way of indicating a NaN with the sign bit |
| // set. |
| stream->Write("-NaN("); |
| } else { |
| stream->Write("NaN("); |
| } |
| // NaN payloads are always dumped in hex. Note that Emboss is treating the |
| // is_quiet/is_signal bit as just another bit in the payload. |
| WriteIntegerToTextStream(nan_payload, stream, 16, options.digit_grouping()); |
| stream->Write(")"); |
| return; |
| } |
| |
| if (::std::isinf(n)) { |
| if (n < 0.0) { |
| stream->Write("-Inf"); |
| } else { |
| stream->Write("Inf"); |
| } |
| return; |
| } |
| |
| // TODO(bolms): Should the current numeric base be honored here? Should there |
| // be a separate Float numeric base? |
| ::std::array<char, 30> buffer; |
| // TODO(bolms): Figure out how to get ::std::snprintf to work on |
| // microcontroller builds. |
| EMBOSS_CHECK_LE( |
| static_cast</**/ ::std::size_t>(::snprintf( |
| &(buffer[0]), buffer.size(), "%.*g", |
| FloatConstants<Float>::kPrintfPrecision(), static_cast<double>(n))), |
| buffer.size()); |
| stream->Write(&buffer[0]); |
| |
| // TODO(bolms): Support digit grouping. |
| } |
| |
| template <class Stream, class View> |
| void WriteEnumViewToTextStream(View *view, Stream *stream, |
| const TextOutputOptions &options) { |
| const char *name = TryToGetNameFromEnum(view->Read()); |
| if (name != nullptr) { |
| stream->Write(name); |
| } |
| // If the enum value has no known name, then write its numeric value |
| // instead. If it does have a known name, and comments are enabled on the |
| // output, then write the numeric value as a comment. |
| if (name == nullptr || options.comments()) { |
| if (name != nullptr) stream->Write(" # "); |
| WriteIntegerToTextStream( |
| static_cast< |
| typename ::std::underlying_type<typename View::ValueType>::type>( |
| view->Read()), |
| stream, options.numeric_base(), options.digit_grouping()); |
| } |
| } |
| |
| // Updates an array from a text stream. For an array of integers, the most |
| // basic form of the text format looks like: |
| // |
| // { 0, 1, 2 } |
| // |
| // However, the following are all acceptable and equivalent: |
| // |
| // { 0, 1, 2, } |
| // {0 1 2} |
| // { [2]: 2, [1]: 1, [0]: 0 } |
| // {[2]:2, [0]:0, 1} |
| // |
| // Formally, the array must be contained within braces ("{}"). Elements are |
| // represented as an optional index surrounded by brackets ("[]") followed by |
| // the text format of the element, followed by a single optional comma (","). |
| // If no index is present for the first element, the index 0 will be used. If |
| // no index is present for any elements after the first, the index one greater |
| // than the previous index will be used. |
| template <class Array, class Stream> |
| bool ReadArrayFromTextStream(Array *array, Stream *stream) { |
| // The text format allows any given index to be set more than once. In |
| // theory, this function could track indices and fail if an index were |
| // double-set, but doing so would require quite a bit of overhead, and |
| // O(array->ElementCount()) extra space in the worst case. It does not seem |
| // worth it to impose the runtime cost here. |
| ::std::size_t index = 0; |
| ::std::string brace; |
| // Read out the opening brace. |
| if (!ReadToken(stream, &brace)) return false; |
| if (brace != "{") return false; |
| for (;;) { |
| char c; |
| // Check for a closing brace; if present, success. |
| if (!DiscardWhitespace(stream)) return false; |
| if (!stream->Read(&c)) return false; |
| if (c == '}') return true; |
| |
| // If the element has an index, read it. |
| if (c == '[') { |
| ::std::string index_text; |
| if (!ReadToken(stream, &index_text)) return false; |
| if (!::emboss::support::DecodeInteger(index_text, &index)) return false; |
| ::std::string closing_bracket; |
| if (!ReadToken(stream, &closing_bracket)) return false; |
| if (closing_bracket != "]") return false; |
| ::std::string colon; |
| if (!ReadToken(stream, &colon)) return false; |
| if (colon != ":") return false; |
| } else { |
| if (!stream->Unread(c)) return false; |
| } |
| |
| // Read the element. |
| if (index >= array->ElementCount()) return false; |
| if (!(*array)[index].UpdateFromTextStream(stream)) return false; |
| ++index; |
| |
| // If there is a trailing comma, discard it. |
| if (!DiscardWhitespace(stream)) return false; |
| if (!stream->Read(&c)) return false; |
| if (c != ',') { |
| if (c != '}') return false; |
| if (!stream->Unread(c)) return false; |
| } |
| } |
| } |
| |
| // Writes an array to a text stream. This writes the array in a format |
| // compatible with ReadArrayFromTextStream, above. For multiline output, writes |
| // one element per line. |
| // |
| // TODO(bolms): Make the output for arrays of small elements (like bytes) much |
| // more compact. |
| // |
| // This will require several support functions like `MaxTextLength` on every |
| // view type, and will substantially increase the number of tests required for |
| // this function, but will make arrays of small elements much more readable. |
| template <class Array, class Stream> |
| void WriteArrayToTextStream(Array *array, Stream *stream, |
| const TextOutputOptions &options) { |
| TextOutputOptions element_options = options.PlusOneIndent(); |
| if (options.multiline()) { |
| stream->Write("{"); |
| WriteShorthandArrayCommentToTextStream(array, stream, element_options); |
| for (::std::size_t i = 0; i < array->ElementCount(); ++i) { |
| stream->Write("\n"); |
| stream->Write(element_options.current_indent()); |
| stream->Write("["); |
| // TODO(bolms): Put padding in here so that array elements start at the |
| // same column. |
| // |
| // TODO(bolms): (Maybe) figure out how to get padding to work so that |
| // elements with comments can have their comments align to the same |
| // column. |
| WriteIntegerToTextStream(i, stream, options.numeric_base(), |
| options.digit_grouping()); |
| stream->Write("]: "); |
| (*array)[i].WriteToTextStream(stream, element_options); |
| } |
| stream->Write("\n"); |
| stream->Write(options.current_indent()); |
| stream->Write("}"); |
| } else { |
| stream->Write("{"); |
| for (::std::size_t i = 0; i < array->ElementCount(); ++i) { |
| stream->Write(" "); |
| if (i % 8 == 0) { |
| stream->Write("["); |
| WriteIntegerToTextStream(i, stream, options.numeric_base(), |
| options.digit_grouping()); |
| stream->Write("]: "); |
| } |
| (*array)[i].WriteToTextStream(stream, element_options); |
| if (i < array->ElementCount() - 1) { |
| stream->Write(","); |
| } |
| } |
| stream->Write(" }"); |
| } |
| } |
| |
| // TextStream puts a stream-like interface onto a std::string, for use by |
| // UpdateFromTextStream. It is used by UpdateFromText(). |
| class TextStream final { |
| public: |
| // This template handles std::string, std::string_view, and absl::string_view. |
| template <class String> |
| inline explicit TextStream(const String &text) |
| : text_(text.data()), length_(text.size()) {} |
| |
| inline explicit TextStream(const char *text) |
| : text_(text), length_(strlen(text)) {} |
| |
| inline TextStream(const char *text, ::std::size_t length) |
| : text_(text), length_(length) {} |
| |
| inline bool Read(char *result) { |
| if (index_ >= length_) return false; |
| *result = text_[index_]; |
| ++index_; |
| return true; |
| } |
| |
| inline bool Unread(char c) { |
| if (index_ < 1) return false; |
| if (text_[index_ - 1] != c) return false; |
| --index_; |
| return true; |
| } |
| |
| private: |
| // It would be nice to use string_view here, but that's not available until |
| // C++17. |
| const char *text_ = nullptr; |
| ::std::size_t length_ = 0; |
| ::std::size_t index_ = 0; |
| }; |
| |
| } // namespace support |
| |
| // Returns a TextOutputOptions set for reasonable multi-line text output. |
| static inline TextOutputOptions MultilineText() { |
| return TextOutputOptions() |
| .Multiline(true) |
| .WithIndent(" ") |
| .WithComments(true) |
| .WithDigitGrouping(true); |
| } |
| |
| // TODO(bolms): Add corresponding ReadFromText*() verbs which enforce the |
| // constraint that all of a field's dependencies must be present in the text |
| // before the field itself is set. |
| template <typename EmbossViewType> |
| inline bool UpdateFromText(const EmbossViewType &view, |
| const ::std::string &text) { |
| auto text_stream = support::TextStream{text}; |
| return view.UpdateFromTextStream(&text_stream); |
| } |
| |
| template <typename EmbossViewType> |
| inline ::std::string WriteToString(const EmbossViewType &view, |
| TextOutputOptions options) { |
| support::TextOutputStream text_stream; |
| view.WriteToTextStream(&text_stream, options); |
| return text_stream.Result(); |
| } |
| |
| template <typename EmbossViewType> |
| inline ::std::string WriteToString(const EmbossViewType &view) { |
| return WriteToString(view, TextOutputOptions()); |
| } |
| |
| } // namespace emboss |
| |
| #endif // EMBOSS_PUBLIC_EMBOSS_TEXT_UTIL_H_ |