wip: inplace mid-extending vs end-extending

src/c4/yml/common.hpp

@@ -270,7 +270,7 @@ struct FilterResult
     csubstr str;
 };
 /** Abstracts the fact that a filter result may not fit in the intended memory. */
-struct FilterResultInPlace
+struct FilterResultExtending
 {
     C4_ALWAYS_INLINE bool valid() const noexcept { return str.str != nullptr; }
     C4_ALWAYS_INLINE size_t required_len() const noexcept { return reqlen; }

src/c4/yml/filter_processor.hpp

@@ -124,7 +124,125 @@ struct FilterProcessorSrcDst
 #define _c4dbgip(...)
 #endif
 
-struct FilterProcessorInplace
+struct FilterProcessorInplace__
+{
+    substr src;  ///< the subject string
+    size_t wcap; ///< write capacity - the capacity of the subject string's buffer
+    size_t rpos; ///< read position
+    size_t wpos; ///< write position
+
+    C4_ALWAYS_INLINE FilterProcessorInplace__(substr src_, size_t wcap_) noexcept
+        : src(src_)
+        , wcap(wcap_)
+        , rpos(0)
+        , wpos(0)
+    {
+        RYML_ASSERT(wcap >= src.len);
+    }
+
+    C4_ALWAYS_INLINE void setwpos(size_t wpos_) noexcept { wpos = wpos_; }
+    C4_ALWAYS_INLINE void setpos(size_t rpos_, size_t wpos_) noexcept { rpos = rpos_; wpos = wpos_; }
+    C4_ALWAYS_INLINE void set_at_end() noexcept { skip(src.len - rpos); }
+
+    C4_ALWAYS_INLINE bool has_more_chars() const noexcept { return rpos < src.len; }
+    C4_ALWAYS_INLINE bool has_more_chars(size_t maxpos) const noexcept { RYML_ASSERT(maxpos <= src.len); return rpos < maxpos; }
+
+    C4_ALWAYS_INLINE FilterResult result() const noexcept
+    {
+        _c4dbgip("inplace: wpos={} wcap={} unfiltered={} maxcap={}", this->wpos, this->wcap, this->unfiltered_chars, this->maxcap);
+        FilterResult ret;
+        ret.str.str = (wpos <= wcap) ? src.str : nullptr;
+        ret.str.len = wpos;
+        return ret;
+    }
+    C4_ALWAYS_INLINE csubstr sofar() const noexcept { return csubstr(src.str, wpos <= wcap ? wpos : wcap); }
+    C4_ALWAYS_INLINE csubstr rem() const noexcept { return src.sub(rpos); }
+
+    C4_ALWAYS_INLINE char curr() const noexcept { RYML_ASSERT(rpos < src.len); return src[rpos]; }
+    C4_ALWAYS_INLINE char next() const noexcept { return rpos+1 < src.len ? src[rpos+1] : '\0'; }
+
+    C4_ALWAYS_INLINE void skip() noexcept { ++rpos; }
+    C4_ALWAYS_INLINE void skip(size_t num) noexcept { rpos += num; }
+
+    void set_at(size_t pos, char c) noexcept
+    {
+        RYML_ASSERT(pos < wpos);
+        const size_t save = wpos;
+        wpos = pos;
+        set(c);
+        wpos = save;
+    }
+    void set(char c) noexcept
+    {
+        RYML_ASSERT(wpos <= rpos);
+        if(wpos < wcap)  // respect write-capacity
+            src.str[wpos] = c;
+        ++wpos;
+    }
+    void set(char c, size_t num) noexcept
+    {
+        RYML_ASSERT(num);
+        RYML_ASSERT(wpos <= rpos);
+        if(wpos + num <= wcap)  // respect write-capacity
+            memset(src.str + wpos, c, num);
+        wpos += num;
+    }
+
+    void copy() noexcept
+    {
+        RYML_ASSERT(wpos < rpos);
+        RYML_ASSERT(rpos < src.len);
+        if(wpos < wcap)  // respect write-capacity
+            src.str[wpos] = src.str[rpos];
+        ++rpos;
+        ++wpos;
+    }
+    void copy(size_t num) noexcept
+    {
+        RYML_ASSERT(num);
+        RYML_ASSERT(rpos+num <= src.len);
+        RYML_ASSERT(wpos < rpos);
+        if(wpos + num <= wcap)  // respect write-capacity
+        {
+            if(wpos + num <= rpos) // there is no overlap
+                memcpy(src.str + wpos, src.str + rpos, num);
+            else                   // there is overlap
+                memmove(src.str + wpos, src.str + rpos, num);
+        }
+        rpos += num;
+        wpos += num;
+    }
+
+    void translate_esc(char c) noexcept
+    {
+        RYML_ASSERT(rpos + 2 <= src.len);
+        RYML_ASSERT(wpos <= rpos);
+        if(wpos < wcap) // respect write-capacity
+            src.str[wpos] = c;
+        rpos += 2; // add 1u to account for the escape character
+        ++wpos;
+    }
+
+    C4_NO_INLINE void translate_esc(const char *C4_RESTRICT s, size_t nw, size_t nr) noexcept
+    {
+        RYML_ASSERT(nw > 0);
+        RYML_ASSERT(nr > 0);
+        RYML_ASSERT(nw <= nr + 1u);
+        RYML_ASSERT(rpos+nr <= src.len);
+        RYML_ASSERT(wpos <= rpos);
+        const size_t wpos_next = wpos + nw;
+        const size_t rpos_next = rpos + nr + 1u; // add 1u to account for the escape character
+        RYML_ASSERT(wpos_next <= rpos_next);
+        if(wpos_next <= wcap)
+            memcpy(src.str + wpos, s, nw);
+        rpos = rpos_next;
+        wpos = wpos_next;
+    }
+};
+
+
+//struct FilterProcessorInplaceExtending
+struct FilterProcessorInplaceExtending
 {
     substr src;  ///< the subject string
     size_t wcap; ///< write capacity - the capacity of the subject string's buffer
@@ -133,7 +251,7 @@ struct FilterProcessorInplace
     size_t maxcap; ///< the max capacity needed for filtering the string. This may be larger than the final string size.
     bool unfiltered_chars; ///< number of characters that were not added to wpos from lack of capacity
 
-    C4_ALWAYS_INLINE FilterProcessorInplace(substr src_, size_t wcap_) noexcept
+    C4_ALWAYS_INLINE FilterProcessorInplaceExtending(substr src_, size_t wcap_) noexcept
         : src(src_)
         , wcap(wcap_)
         , rpos(0)
@@ -151,10 +269,10 @@ struct FilterProcessorInplace
     C4_ALWAYS_INLINE bool has_more_chars() const noexcept { return rpos < src.len; }
     C4_ALWAYS_INLINE bool has_more_chars(size_t maxpos) const noexcept { RYML_ASSERT(maxpos <= src.len); return rpos < maxpos; }
 
-    C4_ALWAYS_INLINE FilterResultInPlace result() const noexcept
+    C4_ALWAYS_INLINE FilterResultExtending result() const noexcept
     {
         _c4dbgip("inplace: wpos={} wcap={} unfiltered={} maxcap={}", this->wpos, this->wcap, this->unfiltered_chars, this->maxcap);
-        FilterResultInPlace ret;
+        FilterResultExtending ret;
         ret.str.str = (wpos <= wcap && !unfiltered_chars) ? src.str : nullptr;
         ret.str.len = wpos;
         ret.reqlen = maxcap;

src/c4/yml/parse.cpp

@@ -4670,9 +4670,9 @@ FilterResult Parser::filter_scalar_plain(csubstr scalar, substr dst, size_t inde
     return _filter_plain(proc, indentation);
 }
 
-FilterResultInPlace Parser::filter_scalar_plain_in_place(substr dst, size_t cap, size_t indentation) noexcept
+FilterResult Parser::filter_scalar_plain_in_place(substr dst, size_t cap, size_t indentation) noexcept
 {
-    FilterProcessorInplace proc(dst, cap);
+    FilterProcessorInplace__ proc(dst, cap);
     return _filter_plain(proc, indentation);
 }
 
@@ -4774,9 +4774,9 @@ FilterResult Parser::filter_scalar_squoted(csubstr scalar, substr dst) noexcept
     return _filter_squoted(proc);
 }
 
-FilterResultInPlace Parser::filter_scalar_squoted_in_place(substr dst, size_t cap) noexcept
+FilterResult Parser::filter_scalar_squoted_in_place(substr dst, size_t cap) noexcept
 {
-    FilterProcessorInplace proc(dst, cap);
+    FilterProcessorInplace__ proc(dst, cap);
     return _filter_squoted(proc);
 }
 
@@ -5056,9 +5056,9 @@ FilterResult Parser::filter_scalar_dquoted(csubstr scalar, substr dst)
     return _filter_dquoted(proc);
 }
 
-FilterResultInPlace Parser::filter_scalar_dquoted_in_place(substr dst, size_t cap)
+FilterResultExtending Parser::filter_scalar_dquoted_in_place(substr dst, size_t cap)
 {
-    FilterProcessorInplace proc(dst, cap);
+    FilterProcessorInplaceExtending proc(dst, cap);
     return _filter_dquoted(proc);
 }
 
@@ -5396,9 +5396,9 @@ FilterResult Parser::filter_scalar_block_literal(csubstr scalar, substr dst, siz
     return _filter_block_literal(proc, indentation, chomp);
 }
 
-FilterResultInPlace Parser::filter_scalar_block_literal_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp) noexcept
+FilterResult Parser::filter_scalar_block_literal_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp) noexcept
 {
-    FilterProcessorInplace proc(scalar, cap);
+    FilterProcessorInplace__ proc(scalar, cap);
     return _filter_block_literal(proc, indentation, chomp);
 }
 
@@ -5629,9 +5629,9 @@ FilterResult Parser::filter_scalar_block_folded(csubstr scalar, substr dst, size
     return _filter_block_folded(proc, indentation, chomp);
 }
 
-FilterResultInPlace Parser::filter_scalar_block_folded_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp) noexcept
+FilterResult Parser::filter_scalar_block_folded_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp) noexcept
 {
-    FilterProcessorInplace proc(scalar, cap);
+    FilterProcessorInplace__ proc(scalar, cap);
     return _filter_block_folded(proc, indentation, chomp);
 }
 
@@ -5643,7 +5643,7 @@ FilterResultInPlace Parser::filter_scalar_block_folded_in_place(substr scalar, s
 csubstr Parser::_filter_scalar_plain(substr s, size_t indentation)
 {
     _c4dbgpf("filtering plain scalar: s=[{}]~~~{}~~~", s.len, s);
-    FilterResultInPlace r = this->filter_scalar_plain_in_place(s, s.len, indentation);
+    FilterResult r = this->filter_scalar_plain_in_place(s, s.len, indentation);
     _RYML_CB_ASSERT(m_stack.m_callbacks, r.valid());
     _c4dbgpf("filtering plain scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());
     return r.get();
@@ -5654,7 +5654,7 @@ csubstr Parser::_filter_scalar_plain(substr s, size_t indentation)
 csubstr Parser::_filter_scalar_squot(substr s)
 {
     _c4dbgpf("filtering squo scalar: s=[{}]~~~{}~~~", s.len, s);
-    FilterResultInPlace r = this->filter_scalar_squoted_in_place(s, s.len);
+    FilterResult r = this->filter_scalar_squoted_in_place(s, s.len);
     _RYML_CB_ASSERT(this->callbacks(), r.valid());
     _c4dbgpf("filtering squo scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());
     return r.get();
@@ -5665,7 +5665,7 @@ csubstr Parser::_filter_scalar_squot(substr s)
 csubstr Parser::_filter_scalar_dquot(substr s)
 {
     _c4dbgpf("filtering dquo scalar: s=[{}]~~~{}~~~", s.len, s);
-    FilterResultInPlace r = this->filter_scalar_dquoted_in_place(s, s.len);
+    FilterResultExtending r = this->filter_scalar_dquoted_in_place(s, s.len);
     if(C4_LIKELY(r.valid()))
     {
         _c4dbgpf("filtering dquo scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());
@@ -5693,7 +5693,7 @@ csubstr Parser::_filter_scalar_dquot(substr s)
 csubstr Parser::_filter_scalar_block_literal(substr s, BlockChomp_e chomp, size_t indentation)
 {
     _c4dbgpf("filtering block literal scalar: s=[{}]~~~{}~~~", s.len, s);
-    FilterResultInPlace r = this->filter_scalar_block_literal_in_place(s, s.len, indentation, chomp);
+    FilterResult r = this->filter_scalar_block_literal_in_place(s, s.len, indentation, chomp);
     if(C4_LIKELY(r.valid()))
     {
         _c4dbgpf("filtering block literal scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());
@@ -5716,7 +5716,7 @@ csubstr Parser::_filter_scalar_block_literal(substr s, BlockChomp_e chomp, size_
 csubstr Parser::_filter_scalar_block_folded(substr s, BlockChomp_e chomp, size_t indentation)
 {
     _c4dbgpf("filtering block folded scalar: s=[{}]~~~{}~~~", s.len, s);
-    FilterResultInPlace r = this->filter_scalar_block_folded_in_place(s, s.len, indentation, chomp);
+    FilterResult r = this->filter_scalar_block_folded_in_place(s, s.len, indentation, chomp);
     if(C4_LIKELY(r.valid()))
     {
         _c4dbgpf("filtering block folded scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());

src/c4/yml/parse.hpp

@@ -291,27 +291,27 @@ class RYML_EXPORT Parser
     /** filter a plain scalar */
     FilterResult filter_scalar_plain(csubstr scalar, substr dst, size_t indentation) noexcept;
     /** filter a plain scalar in place */
-    FilterResultInPlace filter_scalar_plain_in_place(substr scalar, size_t cap, size_t indentation) noexcept;
+    FilterResult filter_scalar_plain_in_place(substr scalar, size_t cap, size_t indentation) noexcept;
 
     /** filter a single-quoted scalar */
     FilterResult filter_scalar_squoted(csubstr scalar, substr dst) noexcept;
     /** filter a single-quoted scalar in place */
-    FilterResultInPlace filter_scalar_squoted_in_place(substr scalar, size_t cap) noexcept;
+    FilterResult filter_scalar_squoted_in_place(substr scalar, size_t cap) noexcept;
 
     /** filter a double-quoted scalar */
     FilterResult filter_scalar_dquoted(csubstr scalar, substr dst);
     /** filter a double-quoted scalar in place */
-    FilterResultInPlace filter_scalar_dquoted_in_place(substr scalar, size_t cap);
+    FilterResultExtending filter_scalar_dquoted_in_place(substr scalar, size_t cap);
 
     /** filter a block-literal scalar */
     FilterResult filter_scalar_block_literal(csubstr scalar, substr dst, size_t indentation, BlockChomp_e chomp) noexcept;
     /** filter a block-literal scalar in place */
-    FilterResultInPlace filter_scalar_block_literal_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp) noexcept;
+    FilterResult filter_scalar_block_literal_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp) noexcept;
 
     /** filter a block-folded scalar */
     FilterResult filter_scalar_block_folded(csubstr scalar, substr dst, size_t indentation, BlockChomp_e chomp) noexcept;
     /** filter a block-folded scalar in place */
-    FilterResultInPlace filter_scalar_block_folded_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp) noexcept;
+    FilterResult filter_scalar_block_folded_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp) noexcept;
 
     /** @} */
 

test/test_block_folded.cpp

@@ -37,7 +37,7 @@ void test_filter_inplace(blockfolded_case const& blcase)
         std::string subject_(blcase.input.str, blcase.input.len);
         c4::substr dst = to_substr(subject_);
         Parser proc = {};
-        FilterResultInPlace result = proc.filter_scalar_block_folded_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
+        FilterResult result = proc.filter_scalar_block_folded_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
         ASSERT_TRUE(result.valid());
         const csubstr out = result.get();
         if(blcase.chomp != CHOMP_CLIP)
@@ -59,7 +59,7 @@ void test_filter_inplace(blockfolded_case const& blcase)
             c4::substr rem = to_substr(subject_).sub(blcase.expected.len);
             rem.fill('^');
             Parser proc = {};
-            FilterResultInPlace result = proc.filter_scalar_block_folded_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
+            FilterResult result = proc.filter_scalar_block_folded_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
             ASSERT_TRUE(result.valid());
             const csubstr out = result.get();
             if(blcase.chomp != CHOMP_CLIP)
@@ -78,7 +78,7 @@ void test_filter_inplace(blockfolded_case const& blcase)
             subject_.resize(blcase.expected.len);
             c4::substr dst = to_substr(subject_).first(blcase.input.len);
             Parser proc = {};
-            FilterResultInPlace result = proc.filter_scalar_block_folded_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
+            FilterResult result = proc.filter_scalar_block_folded_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
             ASSERT_TRUE(result.valid());
             const csubstr out = result.get();
             if(blcase.chomp != CHOMP_CLIP)
@@ -95,7 +95,7 @@ void test_filter_inplace(blockfolded_case const& blcase)
             std::string subject_(blcase.input.str, blcase.input.len);
             c4::substr dst = to_substr(subject_);
             Parser proc = {};
-            FilterResultInPlace result = proc.filter_scalar_block_folded_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
+            FilterResult result = proc.filter_scalar_block_folded_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
             if(blcase.chomp != CHOMP_CLIP)
             {
                 EXPECT_EQ(result.required_len(), blcase.expected.len);

test/test_block_literal.cpp

@@ -38,7 +38,7 @@ void test_filter_inplace(blocklit_case const& blcase)
         std::string subject_(blcase.input.str, blcase.input.len);
         c4::substr dst = to_substr(subject_);
         Parser proc = {};
-        FilterResultInPlace result = proc.filter_scalar_block_literal_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
+        FilterResult result = proc.filter_scalar_block_literal_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
         ASSERT_TRUE(result.valid());
         const csubstr out = result.get();
         if(blcase.chomp != CHOMP_CLIP)
@@ -60,7 +60,7 @@ void test_filter_inplace(blocklit_case const& blcase)
             c4::substr rem = to_substr(subject_).sub(blcase.expected.len);
             rem.fill('^');
             Parser proc = {};
-            FilterResultInPlace result = proc.filter_scalar_block_literal_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
+            FilterResult result = proc.filter_scalar_block_literal_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
             ASSERT_TRUE(result.valid());
             const csubstr out = result.get();
             if(blcase.chomp != CHOMP_CLIP)
@@ -79,7 +79,7 @@ void test_filter_inplace(blocklit_case const& blcase)
             subject_.resize(blcase.expected.len);
             c4::substr dst = to_substr(subject_).first(blcase.input.len);
             Parser proc = {};
-            FilterResultInPlace result = proc.filter_scalar_block_literal_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
+            FilterResult result = proc.filter_scalar_block_literal_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
             ASSERT_TRUE(result.valid());
             const csubstr out = result.get();
             if(blcase.chomp != CHOMP_CLIP)
@@ -96,7 +96,7 @@ void test_filter_inplace(blocklit_case const& blcase)
             std::string subject_(blcase.input.str, blcase.input.len);
             c4::substr dst = to_substr(subject_);
             Parser proc = {};
-            FilterResultInPlace result = proc.filter_scalar_block_literal_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
+            FilterResult result = proc.filter_scalar_block_literal_in_place(dst, subject_.size(), blcase.indentation, blcase.chomp);
             ASSERT_FALSE(result.valid());
             if(blcase.chomp != CHOMP_CLIP)
             {

test/test_double_quoted.cpp

@@ -76,7 +76,7 @@ void test_filter_inplace(csubstr input, csubstr expected, csubstr leading_input,
         substr dst = full.first(input_sz);
         // filter now
         Parser parser1 = {};
-        FilterResultInPlace result = parser1.filter_scalar_dquoted_in_place(dst, cap);
+        FilterResultExtending result = parser1.filter_scalar_dquoted_in_place(dst, cap);
         Parser parser2 = {};
         Tree tree = parser2.parse_in_arena("file", "# set the tree in the parser");
         csubstr sresult = parser2._filter_scalar_dquot(to_substr(subject_2));

test/test_filter.cpp

@@ -14,7 +14,7 @@ struct InplaceTester
 {
     std::string buf;
     substr subject;
-    FilterProcessorInplace proc;
+    FilterProcessorInplaceExtending proc;
     C4_NO_COPY_OR_MOVE(InplaceTester);
     InplaceTester(const char *str)
         : buf(str)
@@ -33,7 +33,7 @@ struct InplaceTester
     {
         buf.reserve(cap);
         subject = to_substr(buf);
-        proc = FilterProcessorInplace(subject, cap);
+        proc = FilterProcessorInplaceExtending(subject, cap);
     }
 };