win32/default: Enforce only 1 successfully putback guarantee

https://en.cppreference.com/w/c/io/ungetc states that only 1 byte
is guaranteed to be put back. Even if linux/mac support 4KB,
windows and other platforms are very strict with 1 character,
and they can fail if you try 2-3-4 ungetc.

To that extent, no more characters than needed are ever consumed.

Also, when parsing from a file, if whitespace has been consumed,
it remains consumed, it's not put back, similar to fscanf.
https://pubs.opengroup.org/onlinepubs/000095399/functions/fscanf.html

Author: spyridon97

include/scn/scan.h

@@ -4418,6 +4418,15 @@ class basic_scan_buffer {
     SCN_NODISCARD range_type get();
     SCN_NODISCARD common_range_type get_common_range();
 
+    void set_skip_whitespace(bool skip)
+    {
+        m_skip_whitespace = skip;
+    }
+    SCN_NODISCARD bool get_skip_whitespace() const
+    {
+        return m_skip_whitespace;
+    }
+
 protected:
     friend class forward_iterator;
     friend class common_forward_iterator;
@@ -4444,6 +4453,7 @@ class basic_scan_buffer {
     std::basic_string_view<char_type> m_current_view{};
     std::basic_string<char_type> m_putback_buffer{};
     bool m_is_contiguous{false};
+    bool m_skip_whitespace{false};
 };
 
 template <typename CharT>

src/scn/impl.cpp

@@ -1822,6 +1822,19 @@ auto scan_int_exhaustive_valid_impl(std::string_view source) -> T
     impl::parse_integer_value_exhaustive_valid(source, value);
     return value;
 }
+
+template <typename Source>
+auto get_failed_sync_position(Source& source) -> std::ptrdiff_t
+{
+    const auto& buffer = source.get_segment_starting_at(0);
+    if (source.get_skip_whitespace() && !buffer.empty()) {
+        auto it = std::find_if(buffer.begin(), buffer.end(), [](auto ch) {
+            return !impl::is_ascii_space(ch);
+        });
+        return std::distance(buffer.begin(), it);
+    }
+    return 0;
+}
 }  // namespace detail
 
 scan_expected<void> vinput(std::string_view format, scan_args args)
@@ -1836,7 +1849,7 @@ scan_expected<void> vinput(std::string_view format, scan_args args)
         }
         return {};
     }
-    if (SCN_UNLIKELY(!buffer.sync_all())) {
+    if (SCN_UNLIKELY(!buffer.sync(detail::get_failed_sync_position(buffer)))) {
         return detail::unexpected_scan_error(
             scan_error::invalid_source_state,
             "Failed to sync with underlying FILE");
@@ -1861,7 +1874,8 @@ scan_expected<std::ptrdiff_t> sync_after_vscan(
         }
     }
     else {
-        if (SCN_UNLIKELY(!source.sync_all())) {
+        if (SCN_UNLIKELY(
+                !source.sync(detail::get_failed_sync_position(source)))) {
             return detail::unexpected_scan_error(
                 scan_error::invalid_source_state,
                 "Failed to sync with underlying source");

src/scn/impl.h

@@ -1197,12 +1197,7 @@ bool basic_scan_file_buffer<FileInterface>::sync(std::ptrdiff_t position)
             static_cast<std::ptrdiff_t>(this->putback_buffer().size())) {
             putback_wrapper wrapper{m_file};
             auto segment = this->get_segment_starting_at(position);
-            for (auto it = segment.rbegin(); it != segment.rend(); ++it) {
-                if (!m_file.putback(*it)) {
-                    return false;
-                }
-            }
-            return true;
+            return segment.empty();
         }
 
         m_file.unsafe_advance_n(position - static_cast<std::ptrdiff_t>(
@@ -1219,12 +1214,7 @@ bool basic_scan_file_buffer<FileInterface>::sync(std::ptrdiff_t position)
     m_file.putback(m_current_view.front());
 
     auto segment = std::string_view{this->putback_buffer()}.substr(position);
-    for (auto it = segment.rbegin(); it != segment.rend(); ++it) {
-        if (!m_file.putback(*it)) {
-            return false;
-        }
-    }
-    return true;
+    return segment.empty();
 }
 
 }  // namespace detail
@@ -1981,6 +1971,7 @@ auto read_exactly_n_code_units(Range range, std::ptrdiff_t count)
 template <typename Iterator, typename CharT>
 struct read_code_point_into_result {
     Iterator iterator;
+    std::size_t codepoint_length;
     std::basic_string<CharT> codepoint;
 
     bool is_valid() const
@@ -1990,7 +1981,7 @@ struct read_code_point_into_result {
 };
 
 template <typename Range>
-auto read_code_point_into(Range range)
+auto extract_code_point_into(Range range)
     -> read_code_point_into_result<ranges::const_iterator_t<Range>,
                                    detail::char_t<Range>>
 {
@@ -2001,24 +1992,72 @@ auto read_code_point_into(Range range)
     const auto len = detail::code_point_length_by_starting_code_unit(*it);
 
     if (SCN_UNLIKELY(len == 0)) {
-        ++it;
-        it = get_start_for_next_code_point(ranges::subrange{it, range.end()});
-        return {it, {}};
+        return {it, len, {}};
     }
-
     if (len == 1) {
+        return {it, len, string_type(1, *it)};
+    }
+    ranges::advance(it, static_cast<std::ptrdiff_t>(len - 1), range.end());
+    const auto real_len = ranges::distance(range.begin(), it) + 1;;
+    SCN_EXPECT(real_len <= 4);
+    if (SCN_LIKELY(real_len == len && it != range.end())) {
+        auto it2 = range.begin();
+        string_type result(len, *it2);
+        for (std::size_t i = 1; i < len; ++i) {
+            result[i] = *(++it2);
+        }
+        return {it, len, std::move(result)};
+    }
+    return {it, len, string_type(range.begin(), it)};
+}
+
+template <typename Range>
+auto advance_code_point_into(
+    Range range,
+    const read_code_point_into_result<ranges::const_iterator_t<Range>,
+                                      detail::char_t<Range>>& result)
+    -> ranges::const_iterator_t<Range>
+{
+    auto it = result.iterator;
+    const auto& len = result.codepoint_length;
+
+    if (SCN_UNLIKELY(len == 0)) {
+        ++it;
+        return get_start_for_next_code_point(ranges::subrange{it, range.end()});
+    }
+    if (it != range.end()) {
         ++it;
-        return {it, string_type(1, *range.begin())};
     }
+    return it;
+}
 
-    ranges::advance(it, static_cast<std::ptrdiff_t>(len), range.end());
-    return {it, string_type{range.begin(), it}};
+template <typename Range>
+auto read_code_point_into(Range range)
+    -> read_code_point_into_result<ranges::const_iterator_t<Range>,
+                                   detail::char_t<Range>>
+{
+    auto result = extract_code_point_into(range);
+    result.iterator = advance_code_point_into(range, result);
+    return result;
 }
 
 template <typename Range>
 auto read_code_point(Range range) -> ranges::const_iterator_t<Range>
 {
-    return read_code_point_into(range).iterator;
+    SCN_EXPECT(!is_range_eof(range));
+
+    auto it = range.begin();
+    const auto len = detail::code_point_length_by_starting_code_unit(*it);
+
+    if (SCN_UNLIKELY(len == 0)) {
+        ++it;
+        return get_start_for_next_code_point(ranges::subrange{it, range.end()});
+    }
+    if (len == 1) {
+        return ++it;
+    }
+    ranges::advance(it, static_cast<std::ptrdiff_t>(len), range.end());
+    return it;
 }
 
 template <typename Range>
@@ -2158,16 +2197,16 @@ auto read_until_code_point(Range range, function_ref<bool(char32_t)> pred)
 {
     auto it = range.begin();
     while (it != range.end()) {
-        const auto val =
-            read_code_point_into(ranges::subrange{it, range.end()});
+        auto subrange = ranges::subrange{it, range.end()};
+        const auto val = extract_code_point_into(subrange);
         if (SCN_LIKELY(val.is_valid())) {
             const auto cp = detail::decode_code_point_exhaustive(
                 std::basic_string_view<detail::char_t<Range>>{val.codepoint});
             if (pred(cp)) {
                 return it;
             }
         }
-        it = val.iterator;
+        it = advance_code_point_into(subrange, val);
     }
 
     return it;
@@ -2242,32 +2281,31 @@ template <typename Range>
 auto read_matching_code_unit(Range range, detail::char_t<Range> ch)
     -> parse_expected<ranges::const_iterator_t<Range>>
 {
-    auto it = read_code_unit(range);
-    if (SCN_UNLIKELY(!it)) {
-        return unexpected(make_eof_parse_error(it.error()));
+    if (auto e = eof_check(range); SCN_UNLIKELY(!e)) {
+        return unexpected(make_eof_parse_error(e));
     }
 
     if (SCN_UNLIKELY(*range.begin() !=
                      static_cast<detail::char_t<Range>>(ch))) {
         return unexpected(parse_error::error);
     }
 
-    return *it;
+    return ranges::next(range.begin());
 }
 
 template <typename Range>
 auto read_matching_code_point(Range range, char32_t cp)
     -> parse_expected<ranges::const_iterator_t<Range>>
 {
-    auto val = read_code_point_into(range);
+    auto val = extract_code_point_into(range);
     if (!val.is_valid()) {
         return unexpected(parse_error::error);
     }
     auto decoded_cp = decode_code_point_exhaustive(val.codepoint);
     if (SCN_UNLIKELY(cp != decoded_cp)) {
         return unexpected(parse_error::error);
     }
-    return val.iterator;
+    return advance_code_point_into(range, val);
 }
 
 template <typename Range>
@@ -2286,33 +2324,6 @@ auto read_matching_string(Range range,
     return it;
 }
 
-template <typename Range>
-auto read_matching_string_classic(Range range, std::string_view str)
-    -> parse_expected<ranges::const_iterator_t<Range>>
-{
-    SCN_TRY(it, read_exactly_n_code_units(
-                    range, static_cast<std::ptrdiff_t>(str.size()))
-                    .transform_error(make_eof_parse_error));
-
-    if constexpr (std::is_same_v<detail::char_t<Range>, char>) {
-        auto sv = make_contiguous_buffer(ranges::subrange{range.begin(), it});
-        if (SCN_UNLIKELY(sv.view() != str)) {
-            return unexpected(parse_error::error);
-        }
-        return it;
-    }
-    else {
-        auto range_it = range.begin();
-        for (size_t i = 0; i < str.size(); ++i, (void)++range_it) {
-            if (SCN_UNLIKELY(*range_it !=
-                             static_cast<detail::char_t<Range>>(str[i]))) {
-                return unexpected(parse_error::error);
-            }
-        }
-        return it;
-    }
-}
-
 // Ripped from fast_float
 constexpr bool fast_streq_nocase(const char* a, const char* b, size_t len)
 {
@@ -2348,16 +2359,15 @@ auto read_matching_string_classic_nocase(Range range, std::string_view str)
                                           static_cast<char_type>('a' - 'A'));
         };
 
-        SCN_TRY(it, read_exactly_n_code_units(
-                        range, static_cast<std::ptrdiff_t>(str.size()))
-                        .transform_error(make_eof_parse_error));
-
-        if (SCN_UNLIKELY(!std::equal(
-                range.begin(), it, str.begin(), [&](auto a, auto b) {
-                    return ascii_tolower(a) ==
-                           static_cast<detail::char_t<Range>>(b);
-                }))) {
-            return unexpected(parse_error::error);
+        auto it = range.begin();
+        for (std::size_t i = 0; i < str.size(); ++i, (void)++it) {
+            if (it == range.end()) {
+                return unexpected(make_eof_parse_error(eof_error::eof));
+            }
+            if (SCN_UNLIKELY(ascii_tolower(*it) !=
+                             static_cast<detail::char_t<Range>>(str[i]))) {
+                return unexpected(parse_error::error);
+            }
         }
 
         return it;
@@ -2368,14 +2378,13 @@ template <typename Range>
 auto read_one_of_code_unit(Range range, std::string_view str)
     -> parse_expected<ranges::const_iterator_t<Range>>
 {
-    auto it = read_code_unit(range);
-    if (SCN_UNLIKELY(!it)) {
-        return unexpected(make_eof_parse_error(it.error()));
+    if (auto e = eof_check(range); SCN_UNLIKELY(!e)) {
+        return unexpected(make_eof_parse_error(e));
     }
 
     for (auto ch : str) {
         if (*range.begin() == static_cast<detail::char_t<Range>>(ch)) {
-            return *it;
+            return ranges::next(range.begin());
         }
     }
 
@@ -5426,11 +5435,11 @@ struct bool_reader_base {
     auto read_textual_classic(Range range, bool& value) const
         -> scan_expected<ranges::const_iterator_t<Range>>
     {
-        if (auto r = read_matching_string_classic(range, "true")) {
+        if (auto r = read_matching_string_classic_nocase(range, "true")) {
             value = true;
             return *r;
         }
-        if (auto r = read_matching_string_classic(range, "false")) {
+        if (auto r = read_matching_string_classic_nocase(range, "false")) {
             value = false;
             return *r;
         }
@@ -5605,15 +5614,15 @@ class code_point_reader<char32_t> {
     auto read(const SourceRange& range, char32_t& cp)
         -> scan_expected<ranges::const_iterator_t<SourceRange>>
     {
-        auto result = read_code_point_into(range);
+        auto result = extract_code_point_into(range);
         if (SCN_UNLIKELY(!result.is_valid())) {
             return detail::unexpected_scan_error(
                 scan_error::invalid_scanned_value, "Invalid code point");
         }
         cp = detail::decode_code_point_exhaustive_valid(
             std::basic_string_view<detail::char_t<SourceRange>>{
                 result.codepoint});
-        return result.iterator;
+        return advance_code_point_into(range, result);
     }
 };
 
@@ -5826,6 +5835,16 @@ auto skip_ws_before_if_required(bool is_required, Range range)
         return unexpected(e);
     }
 
+    if constexpr (std::is_same_v<
+                      ranges::const_iterator_t<Range>,
+                      typename detail::basic_scan_buffer<
+                          detail::char_t<Range>>::forward_iterator>) {
+        auto beg = range.begin();
+        if (beg.stores_parent()) {
+            beg.parent()->set_skip_whitespace(is_required);
+        }
+    }
+
     if (!is_required) {
         return range.begin();
     }

tests/unittests/examples_test_runner.py

@@ -82,5 +82,5 @@ def check(i, input, expected_output):
 check(4, "", "[{1: 2, 3: 4}, {5: 6}]")
 
 check(5, "123 456", "Write two integers:\nTwo integers: 123 456\n")
-check(5, "123 abc", "Write two integers:\nFirst integer: 123, rest of the line:  abc")
+check(5, "123 abc", "Write two integers:\nFirst integer: 123, rest of the line: abc")
 check(5, "abc def", "Write two integers:\nEntire line: abc def")