From e318211893359798f875b628f804717e90221612 Mon Sep 17 00:00:00 2001 From: Joao Paulo Magalhaes Date: Mon, 10 Feb 2020 03:11:06 +0100 Subject: [PATCH] use RYML_ASSERT() instead of C4_ASSERT() --- .lgtm.yml | 2 + src/c4/yml/common.hpp | 2 +- src/c4/yml/detail/print.hpp | 4 +- src/c4/yml/detail/stack.hpp | 50 ++++---- src/c4/yml/emit.def.hpp | 12 +- src/c4/yml/node.hpp | 82 ++++++------ src/c4/yml/parse.cpp | 240 ++++++++++++++++++------------------ src/c4/yml/parse.hpp | 6 +- src/c4/yml/tree.cpp | 210 +++++++++++++++---------------- src/c4/yml/tree.hpp | 134 ++++++++++---------- src/c4/yml/writer.hpp | 4 +- 11 files changed, 374 insertions(+), 372 deletions(-) create mode 100644 .lgtm.yml diff --git a/.lgtm.yml b/.lgtm.yml new file mode 100644 index 00000000..c1376d23 --- /dev/null +++ b/.lgtm.yml @@ -0,0 +1,2 @@ +queries: +- exclude: cpp/unsigned-comparison-zero diff --git a/src/c4/yml/common.hpp b/src/c4/yml/common.hpp index cbcca17a..6bc83025 100644 --- a/src/c4/yml/common.hpp +++ b/src/c4/yml/common.hpp @@ -200,7 +200,7 @@ struct Allocator inline void free(void *mem, size_t num_bytes) { - C4_ASSERT(r != nullptr); + RYML_ASSERT(r != nullptr); r->free(mem, num_bytes); } }; diff --git a/src/c4/yml/detail/print.hpp b/src/c4/yml/detail/print.hpp index b77a6bd0..27b79854 100644 --- a/src/c4/yml/detail/print.hpp +++ b/src/c4/yml/detail/print.hpp @@ -7,7 +7,7 @@ namespace c4 { namespace yml { - + inline size_t print_node(Tree const& p, size_t node, int level, size_t count, bool print_children) { @@ -38,7 +38,7 @@ inline size_t print_node(Tree const& p, size_t node, int level, size_t count, bo } else { - C4_ASSERT( ! p.has_key_tag(node)); + RYML_ASSERT( ! p.has_key_tag(node)); } if(p.has_val(node)) { diff --git a/src/c4/yml/detail/stack.hpp b/src/c4/yml/detail/stack.hpp index bd879fc4..5210686c 100644 --- a/src/c4/yml/detail/stack.hpp +++ b/src/c4/yml/detail/stack.hpp @@ -100,25 +100,25 @@ public: T const& C4_RESTRICT pop() { - C4_ASSERT(m_size > 0); + RYML_ASSERT(m_size > 0); --m_size; return m_stack[m_size]; } - C4_ALWAYS_INLINE T const& C4_RESTRICT top() const { C4_ASSERT(m_size > 0); return m_stack[m_size - 1]; } - C4_ALWAYS_INLINE T & C4_RESTRICT top() { C4_ASSERT(m_size > 0); return m_stack[m_size - 1]; } + C4_ALWAYS_INLINE T const& C4_RESTRICT top() const { RYML_ASSERT(m_size > 0); return m_stack[m_size - 1]; } + C4_ALWAYS_INLINE T & C4_RESTRICT top() { RYML_ASSERT(m_size > 0); return m_stack[m_size - 1]; } - C4_ALWAYS_INLINE T const& C4_RESTRICT bottom() const { C4_ASSERT(m_size > 0); return m_stack[0]; } - C4_ALWAYS_INLINE T & C4_RESTRICT bottom() { C4_ASSERT(m_size > 0); return m_stack[0]; } + C4_ALWAYS_INLINE T const& C4_RESTRICT bottom() const { RYML_ASSERT(m_size > 0); return m_stack[0]; } + C4_ALWAYS_INLINE T & C4_RESTRICT bottom() { RYML_ASSERT(m_size > 0); return m_stack[0]; } - C4_ALWAYS_INLINE T const& C4_RESTRICT top(size_t i) const { C4_ASSERT(i >= 0 && i < m_size); return m_stack[m_size - 1 - i]; } - C4_ALWAYS_INLINE T & C4_RESTRICT top(size_t i) { C4_ASSERT(i >= 0 && i < m_size); return m_stack[m_size - 1 - i]; } + C4_ALWAYS_INLINE T const& C4_RESTRICT top(size_t i) const { RYML_ASSERT(i >= 0 && i < m_size); return m_stack[m_size - 1 - i]; } + C4_ALWAYS_INLINE T & C4_RESTRICT top(size_t i) { RYML_ASSERT(i >= 0 && i < m_size); return m_stack[m_size - 1 - i]; } - C4_ALWAYS_INLINE T const& C4_RESTRICT bottom(size_t i) const { C4_ASSERT(i >= 0 && i < m_size); return m_stack[i]; } - C4_ALWAYS_INLINE T & C4_RESTRICT bottom(size_t i) { C4_ASSERT(i >= 0 && i < m_size); return m_stack[i]; } + C4_ALWAYS_INLINE T const& C4_RESTRICT bottom(size_t i) const { RYML_ASSERT(i >= 0 && i < m_size); return m_stack[i]; } + C4_ALWAYS_INLINE T & C4_RESTRICT bottom(size_t i) { RYML_ASSERT(i >= 0 && i < m_size); return m_stack[i]; } - C4_ALWAYS_INLINE T const& C4_RESTRICT operator[](size_t i) const { C4_ASSERT(i >= 0 && i < m_size); return m_stack[i]; } - C4_ALWAYS_INLINE T & C4_RESTRICT operator[](size_t i) { C4_ASSERT(i >= 0 && i < m_size); return m_stack[i]; } + C4_ALWAYS_INLINE T const& C4_RESTRICT operator[](size_t i) const { RYML_ASSERT(i >= 0 && i < m_size); return m_stack[i]; } + C4_ALWAYS_INLINE T & C4_RESTRICT operator[](size_t i) { RYML_ASSERT(i >= 0 && i < m_size); return m_stack[i]; } public: @@ -168,7 +168,7 @@ void stack::reserve(size_t sz) template void stack::_free() { - C4_ASSERT(m_stack != nullptr); // this structure cannot be memset() to zero + RYML_ASSERT(m_stack != nullptr); // this structure cannot be memset() to zero if(m_stack != m_buf) { m_alloc.free(m_stack, m_capacity * sizeof(T)); @@ -176,7 +176,7 @@ void stack::_free() } else { - C4_ASSERT(m_capacity == N); + RYML_ASSERT(m_capacity == N); } } @@ -188,15 +188,15 @@ void stack::_cp(stack const* C4_RESTRICT that) { if(that->m_stack != that->m_buf) { - C4_ASSERT(m_stack != m_buf); - C4_ASSERT(that->m_capacity > N); - C4_ASSERT(that->m_size > N); - C4_ASSERT(that->m_size <= that->m_capacity); + RYML_ASSERT(m_stack != m_buf); + RYML_ASSERT(that->m_capacity > N); + RYML_ASSERT(that->m_size > N); + RYML_ASSERT(that->m_size <= that->m_capacity); } else { - C4_ASSERT(that->m_capacity <= N); - C4_ASSERT(that->m_size <= that->m_capacity); + RYML_ASSERT(that->m_capacity <= N); + RYML_ASSERT(that->m_size <= that->m_capacity); } memcpy(m_stack, that->m_stack, that->m_size * sizeof(T)); m_size = that->m_size; @@ -212,15 +212,15 @@ void stack::_mv(stack * that) { if(that->m_stack != that->m_buf) { - C4_ASSERT(that->m_capacity > N); - C4_ASSERT(that->m_size > N); - C4_ASSERT(that->m_size <= that->m_capacity); + RYML_ASSERT(that->m_capacity > N); + RYML_ASSERT(that->m_size > N); + RYML_ASSERT(that->m_size <= that->m_capacity); m_stack = that->m_stack; } else { - C4_ASSERT(that->m_capacity <= N); - C4_ASSERT(that->m_size <= that->m_capacity); + RYML_ASSERT(that->m_capacity <= N); + RYML_ASSERT(that->m_size <= that->m_capacity); memcpy(m_buf, that->m_buf, that->m_size * sizeof(T)); m_stack = m_buf; } @@ -228,7 +228,7 @@ void stack::_mv(stack * that) m_capacity = that->m_size; m_alloc = that->m_alloc; // make sure no deallocation happens on destruction - C4_ASSERT(that->m_stack != m_buf); + RYML_ASSERT(that->m_stack != m_buf); that->m_stack = that->m_buf; that->m_capacity = N; that->m_size = 0; diff --git a/src/c4/yml/emit.def.hpp b/src/c4/yml/emit.def.hpp index b2d71558..2c435f73 100644 --- a/src/c4/yml/emit.def.hpp +++ b/src/c4/yml/emit.def.hpp @@ -41,7 +41,7 @@ template void Emitter::_do_visit(Tree const& t, size_t id, size_t ilevel, size_t do_indent) { RepC ind = indent_to(do_indent * ilevel); - C4_ASSERT(t.is_root(id) || (t.parent_is_map(id) || t.parent_is_seq(id))); + RYML_ASSERT(t.is_root(id) || (t.parent_is_map(id) || t.parent_is_seq(id))); if(t.is_doc(id)) { @@ -63,7 +63,7 @@ void Emitter::_do_visit(Tree const& t, size_t id, size_t ilevel, size_t } else if(t.is_keyval(id)) { - C4_ASSERT(t.has_parent(id)); + RYML_ASSERT(t.has_parent(id)); this->Writer::_do_write(ind); _writek(t, id); this->Writer::_do_write(": "); @@ -73,7 +73,7 @@ void Emitter::_do_visit(Tree const& t, size_t id, size_t ilevel, size_t } else if(t.is_val(id)) { - C4_ASSERT(t.has_parent(id)); + RYML_ASSERT(t.has_parent(id)); this->Writer::_do_write(ind); this->Writer::_do_write("- "); _writev(t, id); @@ -82,7 +82,7 @@ void Emitter::_do_visit(Tree const& t, size_t id, size_t ilevel, size_t } else if(t.is_container(id)) { - C4_ASSERT(t.is_map(id) || t.is_seq(id)); + RYML_ASSERT(t.is_map(id) || t.is_seq(id)); bool spc = false; // write a space bool nl = false; // write a newline @@ -232,8 +232,8 @@ void Emitter::_write(NodeScalar const& sc, NodeType flags) } if(flags.has_anchor()) { - C4_ASSERT(flags.is_ref() != flags.has_anchor()); - C4_ASSERT( ! sc.anchor.empty()); + RYML_ASSERT(flags.is_ref() != flags.has_anchor()); + RYML_ASSERT( ! sc.anchor.empty()); this->Writer::_do_write('&'); this->Writer::_do_write(sc.anchor); this->Writer::_do_write(' '); diff --git a/src/c4/yml/node.hpp b/src/c4/yml/node.hpp index c454aa61..13c06263 100644 --- a/src/c4/yml/node.hpp +++ b/src/c4/yml/node.hpp @@ -80,16 +80,16 @@ public: inline NodeData * get() { return m_tree->get(m_id); } inline NodeData const* get() const { return m_tree->get(m_id); } -#define _C4RV() C4_ASSERT(valid() && !is_seed()) // save some typing (and some reading too!) +#define _C4RV() RYML_ASSERT(valid() && !is_seed()) // save some typing (and some reading too!) - inline bool operator== (NodeRef const& that) const { _C4RV(); C4_ASSERT(that.valid() && !that.is_seed()); C4_ASSERT(that.m_tree == m_tree); return m_id == that.m_id; } + inline bool operator== (NodeRef const& that) const { _C4RV(); RYML_ASSERT(that.valid() && !that.is_seed()); RYML_ASSERT(that.m_tree == m_tree); return m_id == that.m_id; } inline bool operator!= (NodeRef const& that) const { return ! this->operator==(that); } inline bool operator== (std::nullptr_t) const { return m_tree == nullptr || m_id == NONE || is_seed(); } inline bool operator!= (std::nullptr_t) const { return ! this->operator== (nullptr); } - inline bool operator== (csubstr val) const { _C4RV(); C4_ASSERT(has_val()); return m_tree->val(m_id) == val; } - inline bool operator!= (csubstr val) const { _C4RV(); C4_ASSERT(has_val()); return m_tree->val(m_id) != val; } + inline bool operator== (csubstr val) const { _C4RV(); RYML_ASSERT(has_val()); return m_tree->val(m_id) == val; } + inline bool operator!= (csubstr val) const { _C4RV(); RYML_ASSERT(has_val()); return m_tree->val(m_id) != val; } //inline operator bool () const { return m_tree == nullptr || m_id == NONE || is_seed(); } @@ -103,7 +103,7 @@ public: public: inline NodeType_e type() const { _C4RV(); return m_tree->type(m_id); } - inline const char* type_str() const { _C4RV(); C4_ASSERT(valid() && ! is_seed()); return m_tree->type_str(m_id); } + inline const char* type_str() const { _C4RV(); RYML_ASSERT(valid() && ! is_seed()); return m_tree->type_str(m_id); } inline csubstr const& key () const { _C4RV(); return m_tree->key(m_id); } inline csubstr const& key_tag() const { _C4RV(); return m_tree->key_tag(m_id); } @@ -262,8 +262,8 @@ public: /** O(num_children) */ NodeRef operator[] (csubstr const& k) { - C4_ASSERT( ! is_seed()); - C4_ASSERT(valid()); + RYML_ASSERT( ! is_seed()); + RYML_ASSERT(valid()); size_t ch = m_tree->find_child(m_id, k); NodeRef r = ch != NONE ? NodeRef(m_tree, ch) : NodeRef(m_tree, m_id, k); return r; @@ -272,8 +272,8 @@ public: /** O(num_children) */ NodeRef operator[] (size_t pos) { - C4_ASSERT( ! is_seed()); - C4_ASSERT(valid()); + RYML_ASSERT( ! is_seed()); + RYML_ASSERT(valid()); size_t ch = m_tree->child(m_id, pos); NodeRef r = ch != NONE ? NodeRef(m_tree, ch) : NodeRef(m_tree, m_id, pos); return r; @@ -284,10 +284,10 @@ public: /** O(num_children) */ NodeRef const operator[] (csubstr const& k) const { - C4_ASSERT( ! is_seed()); - C4_ASSERT(valid()); + RYML_ASSERT( ! is_seed()); + RYML_ASSERT(valid()); size_t ch = m_tree->find_child(m_id, k); - C4_ASSERT(ch != NONE); + RYML_ASSERT(ch != NONE); NodeRef const r(m_tree, ch); return r; } @@ -295,10 +295,10 @@ public: /** O(num_children) */ NodeRef const operator[] (size_t pos) const { - C4_ASSERT( ! is_seed()); - C4_ASSERT(valid()); + RYML_ASSERT( ! is_seed()); + RYML_ASSERT(valid()); size_t ch = m_tree->child(m_id, pos); - C4_ASSERT(ch != NONE); + RYML_ASSERT(ch != NONE); NodeRef const r(m_tree, ch); return r; } @@ -377,7 +377,7 @@ public: { _apply_seed(); write(this, s); - C4_ASSERT(get()->val() == s); + RYML_ASSERT(get()->val() == s); return *this; } @@ -408,9 +408,9 @@ public: template inline NodeRef const& operator>> (T &v) const { - C4_ASSERT( ! is_seed()); - C4_ASSERT(valid()); - C4_ASSERT(get() != nullptr); + RYML_ASSERT( ! is_seed()); + RYML_ASSERT(valid()); + RYML_ASSERT(get() != nullptr); if( ! read(*this, &v)) { c4::yml::error("could not parse value"); @@ -421,9 +421,9 @@ public: template inline NodeRef const& operator>> (Key v) const { - C4_ASSERT( ! is_seed()); - C4_ASSERT(valid()); - C4_ASSERT(get() != nullptr); + RYML_ASSERT( ! is_seed()); + RYML_ASSERT(valid()); + RYML_ASSERT(get() != nullptr); from_chars(key(), &v.k); return *this; } @@ -460,7 +460,7 @@ private: { if(m_seed.str) // we have a seed key: use it to create the new child { - //C4_ASSERT(i.key.scalar.empty() || m_key == i.key.scalar || m_key.empty()); + //RYML_ASSERT(i.key.scalar.empty() || m_key == i.key.scalar || m_key.empty()); m_id = m_tree->append_child(m_id); m_tree->_set_key(m_id, m_seed); m_seed.str = nullptr; @@ -468,14 +468,14 @@ private: } else if(m_seed.len != NONE) // we have a seed index: create a child at that position { - C4_ASSERT(m_tree->num_children(m_id) == m_seed.len); + RYML_ASSERT(m_tree->num_children(m_id) == m_seed.len); m_id = m_tree->append_child(m_id); m_seed.str = nullptr; m_seed.len = NONE; } else { - C4_ASSERT(valid()); + RYML_ASSERT(valid()); } } @@ -499,7 +499,7 @@ public: inline NodeRef insert_child(NodeRef after) { _C4RV(); - C4_ASSERT(after.m_tree == m_tree); + RYML_ASSERT(after.m_tree == m_tree); NodeRef r(m_tree, m_tree->insert_child(m_id, after.m_id)); return r; } @@ -507,7 +507,7 @@ public: inline NodeRef insert_child(NodeInit const& i, NodeRef after) { _C4RV(); - C4_ASSERT(after.m_tree == m_tree); + RYML_ASSERT(after.m_tree == m_tree); NodeRef r(m_tree, m_tree->insert_child(m_id, after.m_id)); r._apply(i); return r; @@ -548,7 +548,7 @@ public: inline NodeRef insert_sibling(NodeRef const after) { _C4RV(); - C4_ASSERT(after.m_tree == m_tree); + RYML_ASSERT(after.m_tree == m_tree); NodeRef r(m_tree, m_tree->insert_sibling(m_id, after.m_id)); return r; } @@ -556,7 +556,7 @@ public: inline NodeRef insert_sibling(NodeInit const& i, NodeRef const after) { _C4RV(); - C4_ASSERT(after.m_tree == m_tree); + RYML_ASSERT(after.m_tree == m_tree); NodeRef r(m_tree, m_tree->insert_sibling(m_id, after.m_id)); r._apply(i); return r; @@ -597,8 +597,8 @@ public: inline void remove_child(NodeRef & child) { _C4RV(); - C4_ASSERT(has_child(child)); - C4_ASSERT(child.parent().id() == id()); + RYML_ASSERT(has_child(child)); + RYML_ASSERT(child.parent().id() == id()); m_tree->remove(child.id()); child.clear(); } @@ -607,9 +607,9 @@ public: inline void remove_child(size_t pos) { _C4RV(); - C4_ASSERT(pos >= 0 && pos < num_children()); + RYML_ASSERT(pos >= 0 && pos < num_children()); size_t child = m_tree->child(m_id, pos); - C4_ASSERT(child != NONE); + RYML_ASSERT(child != NONE); m_tree->remove(child); } @@ -618,7 +618,7 @@ public: { _C4RV(); size_t child = m_tree->find_child(m_id, key); - C4_ASSERT(child != NONE); + RYML_ASSERT(child != NONE); m_tree->remove(child); } @@ -637,7 +637,7 @@ public: inline void move(NodeRef const parent, NodeRef const after) { _C4RV(); - C4_ASSERT(parent.m_tree == after.m_tree); + RYML_ASSERT(parent.m_tree == after.m_tree); if(parent.m_tree == m_tree) { m_tree->move(m_id, parent.m_id, after.m_id); @@ -652,7 +652,7 @@ public: inline NodeRef duplicate(NodeRef const parent, NodeRef const after) const { _C4RV(); - C4_ASSERT(parent.m_tree == after.m_tree); + RYML_ASSERT(parent.m_tree == after.m_tree); if(parent.m_tree == m_tree) { size_t dup = m_tree->duplicate(m_id, parent.m_id, after.m_id); @@ -670,7 +670,7 @@ public: inline void duplicate_children(NodeRef const parent, NodeRef const after) const { _C4RV(); - C4_ASSERT(parent.m_tree == after.m_tree); + RYML_ASSERT(parent.m_tree == after.m_tree); if(parent.m_tree == m_tree) { m_tree->duplicate_children(m_id, parent.m_id, after.m_id); @@ -693,14 +693,14 @@ private: child_iterator(Tree * t, size_t id) : m_tree(t), m_child_id(id) {} - child_iterator& operator++ () { C4_ASSERT(m_child_id != NONE); m_child_id = m_tree->next_sibling(m_child_id); return *this; } - child_iterator& operator-- () { C4_ASSERT(m_child_id != NONE); m_child_id = m_tree->prev_sibling(m_child_id); return *this; } + child_iterator& operator++ () { RYML_ASSERT(m_child_id != NONE); m_child_id = m_tree->next_sibling(m_child_id); return *this; } + child_iterator& operator-- () { RYML_ASSERT(m_child_id != NONE); m_child_id = m_tree->prev_sibling(m_child_id); return *this; } Nd operator* () const { return Nd(m_tree, m_child_id); } Nd operator-> () const { return Nd(m_tree, m_child_id); } - bool operator!= (child_iterator that) const { C4_ASSERT(m_tree == that.m_tree); return m_child_id != that.m_child_id; } - bool operator== (child_iterator that) const { C4_ASSERT(m_tree == that.m_tree); return m_child_id == that.m_child_id; } + bool operator!= (child_iterator that) const { RYML_ASSERT(m_tree == that.m_tree); return m_child_id != that.m_child_id; } + bool operator== (child_iterator that) const { RYML_ASSERT(m_tree == that.m_tree); return m_child_id == that.m_child_id; } }; public: diff --git a/src/c4/yml/parse.cpp b/src/c4/yml/parse.cpp index 9e678c2c..c7ee3b4e 100644 --- a/src/c4/yml/parse.cpp +++ b/src/c4/yml/parse.cpp @@ -110,7 +110,7 @@ void Parser::_reset() { m_stack.pop(); } - C4_ASSERT(m_stack.size() == 1); + RYML_ASSERT(m_stack.size() == 1); m_stack.clear(); m_stack.push({}); m_state = &m_stack.top(); @@ -176,7 +176,7 @@ void Parser::_handle_line() _c4dbgq("\n-----------"); _c4dbgt("handling line %zd", m_state->pos.line); - C4_ASSERT( ! m_state->line_contents.rem.empty()); + RYML_ASSERT( ! m_state->line_contents.rem.empty()); if(has_any(RSEQ)) { @@ -235,7 +235,7 @@ bool Parser::_handle_unk() csubstr rem = m_state->line_contents.rem; const bool start_as_child = (node(m_state) == nullptr); - C4_ASSERT(has_none(RNXT|RSEQ|RMAP)); + RYML_ASSERT(has_none(RNXT|RSEQ|RMAP)); if(m_state->indref > 0) { csubstr ws = rem.left_of(rem.first_not_of(' ')); @@ -373,7 +373,7 @@ bool Parser::_handle_unk() } else { - C4_ASSERT( ! has_any(SSCL)); + RYML_ASSERT( ! has_any(SSCL)); csubstr scalar; size_t indentation = m_state->line_contents.indentation; // save if(_scan_scalar(&scalar)) @@ -431,8 +431,8 @@ bool Parser::_handle_seq_expl() _c4dbgpf("handle_seq_expl: node_id=%zd level=%zd", m_state->node_id, m_state->level); csubstr rem = m_state->line_contents.rem; - C4_ASSERT(has_none(RKEY)); - C4_ASSERT(has_all(EXPL)); + RYML_ASSERT(has_none(RKEY)); + RYML_ASSERT(has_all(EXPL)); if(rem.begins_with(' ')) { @@ -459,7 +459,7 @@ bool Parser::_handle_seq_expl() if(has_any(RVAL)) { - C4_ASSERT(has_none(RNXT)); + RYML_ASSERT(has_none(RNXT)); if(_scan_scalar(&rem)) { _c4dbgp("it's a scalar"); @@ -502,10 +502,10 @@ bool Parser::_handle_seq_expl() } else if(has_any(RNXT)) { - C4_ASSERT(has_none(RVAL)); + RYML_ASSERT(has_none(RVAL)); if(rem.begins_with(", ")) { - C4_ASSERT(has_all(EXPL)); + RYML_ASSERT(has_all(EXPL)); _c4dbgp("seq: expect next val"); addrem_flags(RVAL, RNXT); _line_progressed(2); @@ -513,7 +513,7 @@ bool Parser::_handle_seq_expl() } else if(rem.begins_with(',')) { - C4_ASSERT(has_all(EXPL)); + RYML_ASSERT(has_all(EXPL)); _c4dbgp("seq: expect next val"); addrem_flags(RVAL, RNXT); _line_progressed(1); @@ -538,8 +538,8 @@ bool Parser::_handle_seq_impl() _c4dbgpf("handle_seq_impl: node_id=%zd level=%zd", m_state->node_id, m_state->level); csubstr rem = m_state->line_contents.rem; - C4_ASSERT(has_none(RKEY)); - C4_ASSERT(has_none(EXPL)); + RYML_ASSERT(has_none(RKEY)); + RYML_ASSERT(has_none(EXPL)); if(rem.begins_with('#')) { @@ -550,7 +550,7 @@ bool Parser::_handle_seq_impl() if(has_any(RNXT)) { - C4_ASSERT(has_none(RVAL)); + RYML_ASSERT(has_none(RVAL)); if(_handle_indentation()) { @@ -573,7 +573,7 @@ bool Parser::_handle_seq_impl() } else if(rem.begins_with(' ')) { - C4_ASSERT( ! _at_line_begin()); + RYML_ASSERT( ! _at_line_begin()); rem = rem.left_of(rem.first_not_of(' ')); _c4dbgpf("skipping %zd spaces", rem.len); _line_progressed(rem.len); @@ -728,7 +728,7 @@ bool Parser::_handle_seq_impl() bool Parser::_rval_dash_start_or_continue_seq() { size_t ind = m_state->line_contents.current_col(); - C4_ASSERT(ind >= m_state->indref); + RYML_ASSERT(ind >= m_state->indref); size_t delta_ind = ind - m_state->indref; if( ! delta_ind) { @@ -751,7 +751,7 @@ bool Parser::_handle_map_expl() _c4dbgpf("handle_map_expl: node_id=%zd level=%zd", m_state->node_id, m_state->level); csubstr rem = m_state->line_contents.rem; - C4_ASSERT(has_all(EXPL)); + RYML_ASSERT(has_all(EXPL)); if(has_any(EXPL)) // explicit flow, ie, inside {}, separated by commas { @@ -786,7 +786,7 @@ bool Parser::_handle_map_expl() if(has_any(RNXT)) { - C4_ASSERT(has_none(RKEY|RVAL)); + RYML_ASSERT(has_none(RKEY|RVAL)); if(rem.begins_with(", ")) { _c4dbgp("seq: expect next keyval"); @@ -808,9 +808,9 @@ bool Parser::_handle_map_expl() } else if(has_any(RKEY)) { - C4_ASSERT(has_none(RNXT)); - C4_ASSERT(has_none(RVAL)); - C4_ASSERT(has_none(SSCL)); + RYML_ASSERT(has_none(RNXT)); + RYML_ASSERT(has_none(RVAL)); + RYML_ASSERT(has_none(SSCL)); if(_scan_scalar(&rem)) { @@ -867,8 +867,8 @@ bool Parser::_handle_map_expl() } else if(has_any(RVAL)) { - C4_ASSERT(has_none(RNXT|RKEY)); - C4_ASSERT(has_all(SSCL)); + RYML_ASSERT(has_none(RNXT|RKEY)); + RYML_ASSERT(has_all(SSCL)); if(_scan_scalar(&rem)) { _c4dbgp("it's a scalar"); @@ -934,7 +934,7 @@ bool Parser::_handle_map_impl() _c4dbgpf("handle_map_impl: node_id=%zd level=%zd", m_state->node_id, m_state->level); csubstr rem = m_state->line_contents.rem; - C4_ASSERT(has_none(EXPL)); + RYML_ASSERT(has_none(EXPL)); if(rem.begins_with('#')) { @@ -945,8 +945,8 @@ bool Parser::_handle_map_impl() if(has_any(RNXT)) { - C4_ASSERT(has_none(RKEY)); - C4_ASSERT(has_none(RVAL)); + RYML_ASSERT(has_none(RKEY)); + RYML_ASSERT(has_none(RVAL)); // actually, we don't need RNXT in indent-based maps. addrem_flags(RKEY, RNXT); @@ -960,8 +960,8 @@ bool Parser::_handle_map_impl() if(has_any(RKEY)) { - C4_ASSERT(has_none(RNXT)); - C4_ASSERT(has_none(RVAL)); + RYML_ASSERT(has_none(RNXT)); + RYML_ASSERT(has_none(RVAL)); if(_scan_scalar(&rem)) // this also progresses the line { @@ -982,7 +982,7 @@ bool Parser::_handle_map_impl() rem = m_state->line_contents.rem; if(rem.begins_with(' ')) { - C4_ASSERT( ! _at_line_begin()); + RYML_ASSERT( ! _at_line_begin()); rem = rem.left_of(rem.first_not_of(' ')); _c4dbgpf("skip %zd spaces", rem.len); _line_progressed(rem.len); @@ -992,7 +992,7 @@ bool Parser::_handle_map_impl() } else if(rem.begins_with(' ')) { - //C4_ASSERT( ! _at_line_begin()); + //RYML_ASSERT( ! _at_line_begin()); rem = rem.left_of(rem.first_not_of(' ')); _c4dbgpf("skip %zd spaces", rem.len); _line_progressed(rem.len); @@ -1013,7 +1013,7 @@ bool Parser::_handle_map_impl() rem = m_state->line_contents.rem; if(rem.begins_with(' ')) { - C4_ASSERT( ! _at_line_begin()); + RYML_ASSERT( ! _at_line_begin()); rem = rem.left_of(rem.first_not_of(' ')); _c4dbgpf("skip %zd spaces", rem.len); _line_progressed(rem.len); @@ -1049,8 +1049,8 @@ bool Parser::_handle_map_impl() } else if(has_any(RVAL)) { - C4_ASSERT(has_none(RNXT)); - C4_ASSERT(has_none(RKEY)); + RYML_ASSERT(has_none(RNXT)); + RYML_ASSERT(has_none(RKEY)); csubstr s; if(_scan_scalar(&s)) // this also progresses the line @@ -1181,7 +1181,7 @@ bool Parser::_handle_top() } // use the full line, as the following tokens can appear only at top level - C4_ASSERT(rem == m_state->line_contents.stripped + RYML_ASSERT(rem == m_state->line_contents.stripped || (m_state->indref > 0 && (rem.begin() > m_state->line_contents.stripped.begin() && m_state->indref + m_state->line_contents.stripped.begin() == rem.begin()))); @@ -1231,16 +1231,16 @@ bool Parser::_handle_top() csubstr Parser::_scan_ref() { csubstr rem = m_state->line_contents.rem; - C4_ASSERT(rem.begins_with("<<")); + RYML_ASSERT(rem.begins_with("<<")); size_t pos = rem.find(": "); // for now we require the target anchor to be in the same line - C4_ASSERT(pos != npos); + RYML_ASSERT(pos != npos); _line_progressed(pos + 2); csubstr ref = rem.right_of(pos); pos = ref.first_of('*'); - C4_ASSERT(pos != npos); + RYML_ASSERT(pos != npos); ref = ref.right_of(pos); _line_progressed(pos); ref = ref.left_of(ref.first_of(' ')); @@ -1253,12 +1253,12 @@ csubstr Parser::_scan_ref() //----------------------------------------------------------------------------- bool Parser::_handle_key_anchors_and_refs() { - C4_ASSERT(!has_any(RVAL)); + RYML_ASSERT(!has_any(RVAL)); csubstr rem = m_state->line_contents.rem; if(rem.begins_with('&')) { _c4dbgp("found a key anchor!!!"); - C4_ASSERT(m_key_anchor.empty()); + RYML_ASSERT(m_key_anchor.empty()); csubstr anchor = rem.left_of(rem.first_of(' ')); _line_progressed(anchor.len); anchor = anchor.sub(1); // skip the first character @@ -1279,12 +1279,12 @@ bool Parser::_handle_key_anchors_and_refs() //----------------------------------------------------------------------------- bool Parser::_handle_val_anchors_and_refs() { - C4_ASSERT(!has_any(RKEY)); + RYML_ASSERT(!has_any(RKEY)); csubstr rem = m_state->line_contents.rem; if(rem.begins_with('&')) { _c4dbgp("found a val anchor!!!"); - C4_ASSERT(m_val_anchor.empty()); + RYML_ASSERT(m_val_anchor.empty()); csubstr anchor = rem.left_of(rem.first_of(' ')); _line_progressed(anchor.len); anchor = anchor.sub(1); // skip the first character @@ -1312,7 +1312,7 @@ bool Parser::_handle_types() { _c4dbgp("begins with '!!'"); t = rem.left_of(rem.first_of(' ')); - C4_ASSERT(t.len >= 2); + RYML_ASSERT(t.len >= 2); //t = t.sub(2); if(t == "!!set") { @@ -1323,21 +1323,21 @@ bool Parser::_handle_types() { _c4dbgp("begins with '!<'"); t = rem.left_of(rem.first_of(' ')); - C4_ASSERT(t.len >= 2); + RYML_ASSERT(t.len >= 2); //t = t.sub(2, t.len-1); } else if(rem.begins_with("!h!")) { _c4dbgp("begins with '!h!'"); t = rem.left_of(rem.first_of(' ')); - C4_ASSERT(t.len >= 3); + RYML_ASSERT(t.len >= 3); //t = t.sub(3); } else if(rem.begins_with('!')) { _c4dbgp("begins with '!'"); t = rem.left_of(rem.first_of(' ')); - C4_ASSERT(t.len > 1); + RYML_ASSERT(t.len > 1); //t = t.sub(1); } @@ -1410,7 +1410,7 @@ bool Parser::_scan_scalar(csubstr *scalar) } else if(has_any(RSEQ)) { - C4_ASSERT( ! has_all(RKEY)); + RYML_ASSERT( ! has_all(RKEY)); if(has_all(RVAL)) { _c4dbgp("RSEQ|RVAL"); @@ -1451,7 +1451,7 @@ bool Parser::_scan_scalar(csubstr *scalar) if(colon_space == npos) { colon_space = s.find(":"); - C4_ASSERT(s.len > 0); + RYML_ASSERT(s.len > 0); if(colon_space != s.len-1) { colon_space = npos; @@ -1463,7 +1463,7 @@ bool Parser::_scan_scalar(csubstr *scalar) if(has_any(CPLX)) { _c4dbgp("RMAP|RKEY|CPLX"); - C4_ASSERT(has_any(RMAP)); + RYML_ASSERT(has_any(RMAP)); s = s.left_of(colon_space); } else @@ -1490,7 +1490,7 @@ bool Parser::_scan_scalar(csubstr *scalar) else if(has_all(RVAL)) { _c4dbgp("RMAP|RVAL"); - C4_ASSERT(has_none(CPLX)); + RYML_ASSERT(has_none(CPLX)); if( ! _is_scalar_next__rmap_val(s)) { return false; @@ -1564,7 +1564,7 @@ bool Parser::_scan_scalar(csubstr *scalar) _c4dbgpf("reading scalar: append another line: '%.*s'", _c4prsp(n)); _line_ended(); // advances to the peeked-at line, consuming all remaining (probably newline) characters on the current line _scan_line(); // puts the peeked-at line in the buffer - C4_ASSERT(n == m_state->line_contents.rem); + RYML_ASSERT(n == m_state->line_contents.rem); if(_finished_file()) break; _line_progressed(n.end() - (m_buf.str + m_state->pos.offset)); n = _peek_next_line(m_state->pos.offset); @@ -1585,7 +1585,7 @@ bool Parser::_scan_scalar(csubstr *scalar) pos = n.len; _line_ended(); // advances to the peeked-at line, consuming all remaining (probably newline) characters on the current line _scan_line(); // puts the peeked-at line in the buffer - C4_ASSERT(n == m_state->line_contents.rem); + RYML_ASSERT(n == m_state->line_contents.rem); if(_finished_file()) break; _line_progressed(n.end() - (m_buf.str + m_state->pos.offset)); n = _peek_next_line(m_state->pos.offset); @@ -1680,14 +1680,14 @@ void Parser::_line_progressed(size_t ahead) _c4dbgpf("line[%zd] (%zd cols) progressed by %zd: col %zd --> %zd offset %zd --> %zd", m_state->pos.line, m_state->line_contents.full.len, ahead, m_state->pos.col, m_state->pos.col+ahead, m_state->pos.offset, m_state->pos.offset+ahead); m_state->pos.offset += ahead; m_state->pos.col += ahead; - C4_ASSERT(m_state->pos.col <= m_state->line_contents.stripped.len+1); + RYML_ASSERT(m_state->pos.col <= m_state->line_contents.stripped.len+1); m_state->line_contents.rem = m_state->line_contents.rem.sub(ahead); } void Parser::_line_ended() { _c4dbgpf("line[%zd] (%zd cols) ended! offset %zd --> %zd", m_state->pos.line, m_state->line_contents.full.len, m_state->pos.offset, m_state->pos.offset+m_state->line_contents.full.len - m_state->line_contents.stripped.len); - C4_ASSERT(m_state->pos.col == m_state->line_contents.stripped.len+1); + RYML_ASSERT(m_state->pos.col == m_state->line_contents.stripped.len+1); m_state->pos.offset += m_state->line_contents.full.len - m_state->line_contents.stripped.len; ++m_state->pos.line; m_state->pos.col = 1; @@ -1701,9 +1701,9 @@ void Parser::_set_indentation(size_t indentation) } void Parser::_save_indentation(size_t behind) { - C4_ASSERT(m_state->line_contents.rem.begin() >= m_state->line_contents.full.begin()); + RYML_ASSERT(m_state->line_contents.rem.begin() >= m_state->line_contents.full.begin()); m_state->indref = m_state->line_contents.rem.begin() - m_state->line_contents.full.begin(); - C4_ASSERT(behind <= m_state->indref); + RYML_ASSERT(behind <= m_state->indref); m_state->indref -= behind; _c4dbgpf("state[%zd]: saving indentation: %zd", m_state-m_stack.begin(), m_state->indref); } @@ -1711,7 +1711,7 @@ void Parser::_save_indentation(size_t behind) //----------------------------------------------------------------------------- void Parser::_write_key_anchor(size_t node_id) { - C4_ASSERT(m_tree->has_key(node_id)); + RYML_ASSERT(m_tree->has_key(node_id)); if( ! m_key_anchor.empty()) { _c4dbgpf("node=%zd: set key anchor to '%.*s'", node_id, _c4prsp(m_key_anchor)); @@ -1770,11 +1770,11 @@ void Parser::_write_val_anchor(size_t node_id) void Parser::_push_level(bool explicit_flow_chars) { _c4dbgpf("pushing level! currnode=%zd currlevel=%zd", m_state->node_id, m_state->level); - C4_ASSERT(m_state == &m_stack.top()); + RYML_ASSERT(m_state == &m_stack.top()); if(node(m_state) == nullptr) { _c4dbgp("pushing level! actually no, current node is null"); - //C4_ASSERT( ! explicit_flow_chars); + //RYML_ASSERT( ! explicit_flow_chars); return; } size_t st = RUNK; @@ -1806,7 +1806,7 @@ void Parser::_pop_level() { _stop_doc(); } - C4_ASSERT(m_stack.size() > 1); + RYML_ASSERT(m_stack.size() > 1); _prepare_pop(); m_stack.pop(); m_state = &m_stack.top(); @@ -1816,7 +1816,7 @@ void Parser::_pop_level() }*/ if(m_state->line_contents.indentation == 0) { - //C4_ASSERT(has_none(RTOP)); + //RYML_ASSERT(has_none(RTOP)); add_flags(RTOP); } _c4dbgpf("popping level: now, currnode=%zd currlevel=%zd", m_state->node_id, m_state->level); @@ -1835,11 +1835,11 @@ void Parser::_start_doc(bool as_child) { _c4dbgpf("start_doc (as child=%d)", as_child); add_flags(RUNK|RTOP); - C4_ASSERT(node(m_stack.bottom()) == node(m_root_id)); + RYML_ASSERT(node(m_stack.bottom()) == node(m_root_id)); size_t parent_id = m_stack.size() < 2 ? m_root_id : m_stack.top(1).node_id; - C4_ASSERT(parent_id != NONE); - C4_ASSERT(m_tree->is_root(parent_id)); - C4_ASSERT(node(m_state) == nullptr || node(m_state) == node(m_root_id)); + RYML_ASSERT(parent_id != NONE); + RYML_ASSERT(m_tree->is_root(parent_id)); + RYML_ASSERT(node(m_state) == nullptr || node(m_state) == node(m_root_id)); if(as_child) { if( ! m_tree->is_stream(parent_id)) @@ -1851,7 +1851,7 @@ void Parser::_start_doc(bool as_child) } else { - C4_ASSERT(m_tree->is_seq(parent_id) || m_tree->empty(parent_id)); + RYML_ASSERT(m_tree->is_seq(parent_id) || m_tree->empty(parent_id)); m_state->node_id = parent_id; if( ! m_tree->is_doc(parent_id)) { @@ -1865,12 +1865,12 @@ void Parser::_start_doc(bool as_child) void Parser::_stop_doc() { _c4dbgp("stop_doc"); - C4_ASSERT(node(m_state)->is_doc()); + RYML_ASSERT(node(m_state)->is_doc()); } void Parser::_end_stream() { - C4_ASSERT( ! m_stack.empty()); + RYML_ASSERT( ! m_stack.empty()); if(has_any(SSCL)) { if(m_tree->type(m_state->node_id) == NOTYPE) @@ -1904,7 +1904,7 @@ void Parser::_end_stream() while(m_stack.size() > 1) { _c4dbgpf("popping level: %zu (stack sz=%zu...", m_state->level, m_stack.size()); - C4_ASSERT( ! has_any(SSCL, &m_stack.top())); + RYML_ASSERT( ! has_any(SSCL, &m_stack.top())); _pop_level(); } @@ -1913,7 +1913,7 @@ void Parser::_end_stream() void Parser::_start_new_doc(csubstr rem) { _c4dbgp("_start_new_doc"); - C4_ASSERT(rem.begins_with("---")); + RYML_ASSERT(rem.begins_with("---")); _end_stream(); @@ -1939,10 +1939,10 @@ void Parser::_start_map(bool as_child) { _c4dbgpf("start_map (as child=%d)", as_child); addrem_flags(RMAP|RVAL, RKEY|RUNK); - C4_ASSERT(node(m_stack.bottom()) == node(m_root_id)); + RYML_ASSERT(node(m_stack.bottom()) == node(m_root_id)); size_t parent_id = m_stack.size() < 2 ? m_root_id : m_stack.top(1).node_id; - C4_ASSERT(parent_id != NONE); - C4_ASSERT(node(m_state) == nullptr || node(m_state) == node(m_root_id)); + RYML_ASSERT(parent_id != NONE); + RYML_ASSERT(node(m_state) == nullptr || node(m_state) == node(m_root_id)); if(as_child) { m_state->node_id = m_tree->append_child(parent_id); @@ -1962,7 +1962,7 @@ void Parser::_start_map(bool as_child) } else { - C4_ASSERT(m_tree->is_map(parent_id) || m_tree->empty(parent_id)); + RYML_ASSERT(m_tree->is_map(parent_id) || m_tree->empty(parent_id)); m_state->node_id = parent_id; _c4dbgpf("start_map: id=%zd", m_state->node_id); int as_doc = 0; @@ -1990,7 +1990,7 @@ void Parser::_start_map(bool as_child) void Parser::_stop_map() { _c4dbgp("stop_map"); - C4_ASSERT(node(m_state)->is_map()); + RYML_ASSERT(node(m_state)->is_map()); } //----------------------------------------------------------------------------- @@ -1998,16 +1998,16 @@ void Parser::_start_seq(bool as_child) { _c4dbgpf("start_seq (as child=%d)", as_child); addrem_flags(RSEQ|RVAL, RUNK); - C4_ASSERT(node(m_stack.bottom()) == node(m_root_id)); + RYML_ASSERT(node(m_stack.bottom()) == node(m_root_id)); size_t parent_id = m_stack.size() < 2 ? m_root_id : m_stack.top(1).node_id; - C4_ASSERT(parent_id != NONE); - C4_ASSERT(node(m_state) == nullptr || node(m_state) == node(m_root_id)); + RYML_ASSERT(parent_id != NONE); + RYML_ASSERT(node(m_state) == nullptr || node(m_state) == node(m_root_id)); if(as_child) { m_state->node_id = m_tree->append_child(parent_id); if(has_all(SSCL)) { - C4_ASSERT(node(parent_id)->is_map()); + RYML_ASSERT(node(parent_id)->is_map()); csubstr name = _consume_scalar(); m_tree->to_seq(m_state->node_id, name); _c4dbgpf("start_seq: id=%zd name='%.*s'", m_state->node_id, _c4prsp(node(m_state)->key())); @@ -2024,7 +2024,7 @@ void Parser::_start_seq(bool as_child) } else { - C4_ASSERT(m_tree->is_seq(parent_id) || m_tree->empty(parent_id)); + RYML_ASSERT(m_tree->is_seq(parent_id) || m_tree->empty(parent_id)); m_state->node_id = parent_id; int as_doc = 0; if(node(m_state)->is_doc()) as_doc |= DOC; @@ -2044,15 +2044,15 @@ void Parser::_start_seq(bool as_child) void Parser::_stop_seq() { _c4dbgp("stop_seq"); - C4_ASSERT(node(m_state)->is_seq()); + RYML_ASSERT(node(m_state)->is_seq()); } //----------------------------------------------------------------------------- NodeData* Parser::_append_val(csubstr const& val) { - C4_ASSERT( ! has_all(SSCL)); - C4_ASSERT(node(m_state) != nullptr); - C4_ASSERT(node(m_state)->is_seq()); + RYML_ASSERT( ! has_all(SSCL)); + RYML_ASSERT(node(m_state) != nullptr); + RYML_ASSERT(node(m_state)->is_seq()); _c4dbgpf("append val: '%.*s' to parent id=%zd (level=%zd)", _c4prsp(val), m_state->node_id, m_state->level); size_t nid = m_tree->append_child(m_state->node_id); m_tree->to_val(nid, val); @@ -2069,7 +2069,7 @@ NodeData* Parser::_append_val(csubstr const& val) NodeData* Parser::_append_key_val(csubstr const& val) { - C4_ASSERT(node(m_state)->is_map()); + RYML_ASSERT(node(m_state)->is_map()); csubstr key = _consume_scalar(); _c4dbgpf("append keyval: '%.*s' '%.*s' to parent id=%zd (level=%zd)", _c4prsp(key), _c4prsp(val), m_state->node_id, m_state->level); size_t nid = m_tree->append_child(m_state->node_id); @@ -2096,7 +2096,7 @@ NodeData* Parser::_append_key_val(csubstr const& val) void Parser::_store_scalar(csubstr const& s) { _c4dbgpf("state[%zd]: storing scalar '%.*s' (flag: %zd) (old scalar='%.*s')", m_state-m_stack.begin(), _c4prsp(s), m_state->flags & SSCL, _c4prsp(m_state->scalar)); - C4_ASSERT(has_none(SSCL)); + RYML_ASSERT(has_none(SSCL)); add_flags(SSCL); m_state->scalar = s; } @@ -2104,7 +2104,7 @@ void Parser::_store_scalar(csubstr const& s) csubstr Parser::_consume_scalar() { _c4dbgpf("state[%zd]: consuming scalar '%.*s' (flag: %zd))", m_state-m_stack.begin(), _c4prsp(m_state->scalar), m_state->flags & SSCL); - C4_ASSERT(m_state->flags & SSCL); + RYML_ASSERT(m_state->flags & SSCL); csubstr s = m_state->scalar; rem_flags(SSCL); m_state->scalar.clear(); @@ -2115,8 +2115,8 @@ void Parser::_move_scalar_from_top() { if(m_stack.size() < 2) return; State &prev = m_stack.top(1); - C4_ASSERT(m_state == &m_stack.top()); - C4_ASSERT(m_state != &prev); + RYML_ASSERT(m_state == &m_stack.top()); + RYML_ASSERT(m_state != &prev); if(prev.flags & SSCL) { _c4dbgpf("moving scalar '%.*s' from state[%zd] to state[%zd] (overwriting '%.*s')", _c4prsp(prev.scalar), &prev-m_stack.begin(), m_state-m_stack.begin(), _c4prsp(m_state->scalar)); @@ -2130,7 +2130,7 @@ void Parser::_move_scalar_from_top() //----------------------------------------------------------------------------- bool Parser::_handle_indentation() { - C4_ASSERT(has_none(EXPL)); + RYML_ASSERT(has_none(EXPL)); if( ! _at_line_begin()) return false; size_t ind = m_state->line_contents.indentation; @@ -2178,17 +2178,17 @@ bool Parser::_handle_indentation() _c4dbgp("there was an empty val -- appending"); if(has_all(RMAP)) { - C4_ASSERT(has_all(SSCL)); + RYML_ASSERT(has_all(SSCL)); _append_key_val("~"); } else if(has_all(RSEQ)) { - C4_ASSERT(has_none(SSCL)); + RYML_ASSERT(has_none(SSCL)); _append_val("~"); } } State const* popto = nullptr; - C4_ASSERT(m_stack.is_contiguous()); // this search relies on the stack being contiguous + RYML_ASSERT(m_stack.is_contiguous()); // this search relies on the stack being contiguous for(State const* s = m_state-1; s >= m_stack.begin(); --s) { _c4dbgpf("searching for state with indentation %zd. curr=%zd (curr level=%zd)", ind, s->indref, s->level); @@ -2209,7 +2209,7 @@ bool Parser::_handle_indentation() _c4dbgpf("popping level %zd (indentation=%zd)", m_state->level, m_state->indref); _pop_level(); } - C4_ASSERT(m_state->indref == ind); + RYML_ASSERT(m_state->indref == ind); _line_progressed(ind); return true; } @@ -2255,7 +2255,7 @@ bool Parser::_handle_indentation() csubstr Parser::_scan_comment() { csubstr s = m_state->line_contents.rem; - C4_ASSERT(s.begins_with('#')); + RYML_ASSERT(s.begins_with('#')); _line_progressed(s.len); // skip the # character s = s.sub(1); @@ -2268,7 +2268,7 @@ csubstr Parser::_scan_comment() //----------------------------------------------------------------------------- csubstr Parser::_scan_quoted_scalar(const char q) { - C4_ASSERT(q == '\'' || q == '"'); + RYML_ASSERT(q == '\'' || q == '"'); // quoted scalars can spread over multiple lines! // nice explanation here: http://yaml-multiline.info/ @@ -2284,7 +2284,7 @@ csubstr Parser::_scan_quoted_scalar(const char q) _line_progressed((size_t)(s.begin() - m_buf.sub(b).begin())); } b = m_state->pos.offset; // take this into account - C4_ASSERT(s.begins_with(q)); + RYML_ASSERT(s.begins_with(q)); // skip the opening quote _line_progressed(1); @@ -2361,8 +2361,8 @@ csubstr Parser::_scan_quoted_scalar(const char q) } else { - C4_ASSERT(pos >= 0 && pos < m_buf.len); - C4_ASSERT(m_buf[m_state->pos.offset + pos] == q); + RYML_ASSERT(pos >= 0 && pos < m_buf.len); + RYML_ASSERT(m_buf[m_state->pos.offset + pos] == q); _line_progressed(pos + 1); // progress beyond the quote pos = m_state->pos.offset - b - 1; // but we stop before it break; @@ -2379,12 +2379,12 @@ csubstr Parser::_scan_quoted_scalar(const char q) else if(pos == 0) { s.clear(); - C4_ASSERT( ! needs_filter); + RYML_ASSERT( ! needs_filter); } else { - C4_ASSERT(s.end() >= m_buf.begin() && s.end() <= m_buf.end()); - C4_ASSERT(s.end() == m_buf.end() || *s.end() == q); + RYML_ASSERT(s.end() >= m_buf.begin() && s.end() <= m_buf.end()); + RYML_ASSERT(s.end() == m_buf.end() || *s.end() == q); s = s.sub(0, pos-1); } @@ -2399,7 +2399,7 @@ csubstr Parser::_scan_quoted_scalar(const char q) { ret = _filter_dquot_scalar(s); } - C4_ASSERT(ret.len < s.len || s.empty()); + RYML_ASSERT(ret.len < s.len || s.empty()); _c4dbgpf("final scalar: \"%.*s\"", _c4prsp(ret)); return ret; } @@ -2421,7 +2421,7 @@ csubstr Parser::_scan_block() _line_progressed(trimmed.str - s.str); s = trimmed; } - C4_ASSERT(s.begins_with('|') || s.begins_with('>')); + RYML_ASSERT(s.begins_with('|') || s.begins_with('>')); _c4dbgpf("scanning block: specs=\"%.*s\"", _c4prsp(s)); @@ -2433,7 +2433,7 @@ csubstr Parser::_scan_block() if(s.len > 1) { csubstr t = s.sub(1); - C4_ASSERT(t.len >= 1); + RYML_ASSERT(t.len >= 1); if(t[0] == '-') { chomp = CHOMP_STRIP; @@ -2472,7 +2472,7 @@ csubstr Parser::_scan_block() // start with a zero-length block, already pointing at the right place substr raw_block(m_buf.data() + m_state->pos.offset, size_t(0));// m_state->line_contents.full.sub(0, 0); - C4_ASSERT(raw_block.begin() == m_state->line_contents.full.begin()); + RYML_ASSERT(raw_block.begin() == m_state->line_contents.full.begin()); // read every full line into a raw block, // from which newlines are to be stripped as needed @@ -2487,7 +2487,7 @@ csubstr Parser::_scan_block() _next_line(); ++num_lines; } - C4_ASSERT(m_state->pos.line == (first + num_lines)); + RYML_ASSERT(m_state->pos.line == (first + num_lines)); (void)num_lines; // prevent warning (void)first; @@ -2528,7 +2528,7 @@ csubstr Parser::_filter_plain_scalar(substr s, size_t indentation) } } - C4_ASSERT(s.len >= r.len); + RYML_ASSERT(s.len >= r.len); _c4dbgpf("filtering plain scalar: num filtered chars=%zd", s.len - r.len); _c4dbgpf("filtering plain scalar: after='%.*s'", _c4prsp(r)); @@ -2573,7 +2573,7 @@ csubstr Parser::_filter_squot_scalar(substr s) } } - C4_ASSERT(s.len >= r.len); + RYML_ASSERT(s.len >= r.len); _c4dbgpf("filtering single-quoted scalar: num filtered chars=%zd", s.len - r.len); _c4dbgpf("filtering single-quoted scalar: after=\"%.*s\"", _c4prsp(r)); @@ -2633,7 +2633,7 @@ csubstr Parser::_filter_dquot_scalar(substr s) } } - C4_ASSERT(s.len >= r.len); + RYML_ASSERT(s.len >= r.len); _c4dbgpf("filtering double-quoted scalar: num filtered chars=%zd", s.len - r.len); _c4dbgpf("filtering double-quoted scalar: after='%.*s'", _c4prsp(r)); @@ -2663,9 +2663,9 @@ substr Parser::_filter_whitespace(substr r, size_t indentation, bool leading_whi { csubstr ss = r.sub(i); ss = ss.left_of(ss.first_not_of(' ')); - C4_ASSERT(ss.len > 1); + RYML_ASSERT(ss.len > 1); size_t num = ss.len; - C4_ASSERT(num >= indentation); + RYML_ASSERT(num >= indentation); if(indentation) { num = indentation; @@ -2706,14 +2706,14 @@ csubstr Parser::_filter_block_scalar(substr s, BlockStyle_e style, BlockChomp_e { _c4dbgpf("filtering block: '%.*s'", _c4prsp(s)); - C4_ASSERT(s.ends_with('\n') || s.ends_with('\r')); + RYML_ASSERT(s.ends_with('\n') || s.ends_with('\r')); substr r = s; if(indentation > 0) { r = _filter_whitespace(s, indentation, /*leading whitespace*/false); - C4_ASSERT(r.begins_with(' ', indentation)); + RYML_ASSERT(r.begins_with(' ', indentation)); r = r.erase(0, indentation); } @@ -2726,20 +2726,20 @@ csubstr Parser::_filter_block_scalar(substr s, BlockStyle_e style, BlockChomp_e case CHOMP_STRIP: // strip everything { auto pos = r.last_not_of("\r\n"); - C4_ASSERT(pos != npos); + RYML_ASSERT(pos != npos); r = r.left_of(pos, /*include_pos*/true); break; } case CHOMP_CLIP: // clip to a single newline { auto pos = r.last_not_of("\r\n"); - C4_ASSERT(pos != npos && pos+1 < r.len); + RYML_ASSERT(pos != npos && pos+1 < r.len); ++pos; if(r[pos] == '\r') // deal with \r\n sequences { - C4_ASSERT(pos+1 < s.len); + RYML_ASSERT(pos+1 < s.len); ++pos; - C4_ASSERT(r[pos] == '\n'); + RYML_ASSERT(r[pos] == '\n'); } r = r.left_of(pos, /*include_pos*/true); break; @@ -2757,8 +2757,8 @@ csubstr Parser::_filter_block_scalar(substr s, BlockStyle_e style, BlockChomp_e case BLOCK_FOLD: { auto pos = r.last_not_of("\r\n"); // do not fold trailing newlines - C4_ASSERT(pos != npos); - C4_ASSERT(pos < r.len); + RYML_ASSERT(pos != npos); + RYML_ASSERT(pos < r.len); ++pos; // point pos at the first newline char substr t = r.sub(0, pos); for(size_t i = 0; i < t.len; ++i) @@ -2780,7 +2780,7 @@ csubstr Parser::_filter_block_scalar(substr s, BlockStyle_e style, BlockChomp_e } // copy over the trailing newlines substr nl = r.sub(pos); - C4_ASSERT(t.len + nl.len <= r.len); + RYML_ASSERT(t.len + nl.len <= r.len); for(size_t i = 0; i < nl.len; ++i) { r[t.len + i] = nl[i]; @@ -2808,7 +2808,7 @@ csubstr Parser::_filter_block_scalar(substr s, BlockStyle_e style, BlockChomp_e //----------------------------------------------------------------------------- bool Parser::_read_decimal(csubstr const& str, size_t *decimal) { - C4_ASSERT(str.len >= 1); + RYML_ASSERT(str.len >= 1); size_t n = 0; for(size_t i = 0; i < str.len; ++i) { diff --git a/src/c4/yml/parse.hpp b/src/c4/yml/parse.hpp index 117a6a10..37fd37e6 100644 --- a/src/c4/yml/parse.hpp +++ b/src/c4/yml/parse.hpp @@ -203,8 +203,8 @@ private: size_t current_col(csubstr s) const { - C4_ASSERT(s.str >= full.str); - C4_ASSERT(full.contains(s)); + RYML_ASSERT(s.str >= full.str); + RYML_ASSERT(full.contains(s)); size_t col = s.str - full.str; return col; } @@ -260,7 +260,7 @@ private: void _prepare_pop() { - C4_ASSERT(m_stack.size() > 1); + RYML_ASSERT(m_stack.size() > 1); State const& curr = m_stack.top(); State & next = m_stack.top(1); next.pos = curr.pos; diff --git a/src/c4/yml/tree.cpp b/src/c4/yml/tree.cpp index 61c64234..137883dd 100644 --- a/src/c4/yml/tree.cpp +++ b/src/c4/yml/tree.cpp @@ -171,8 +171,8 @@ void Tree::_move(Tree & that) void Tree::_relocate(substr const& next_arena) { - C4_ASSERT(next_arena.not_empty()); - C4_ASSERT(next_arena.len >= m_arena.len); + RYML_ASSERT(next_arena.not_empty()); + RYML_ASSERT(next_arena.len >= m_arena.len); memcpy(next_arena.str, m_arena.str, m_arena_pos); for(NodeData *n = m_buf, *e = m_buf + m_cap; n != e; ++n) { @@ -204,20 +204,20 @@ void Tree::reserve(size_t cap) if(m_free_head != NONE) { - C4_ASSERT(m_buf != nullptr); - C4_ASSERT(m_free_tail != NONE); + RYML_ASSERT(m_buf != nullptr); + RYML_ASSERT(m_free_tail != NONE); m_buf[m_free_tail].m_next_sibling = first; m_buf[first].m_prev_sibling = m_free_tail; m_free_tail = cap-1; } else { - C4_ASSERT(m_free_tail == NONE); + RYML_ASSERT(m_free_tail == NONE); m_free_head = first; m_free_tail = cap-1; } - C4_ASSERT(m_free_head == NONE || (m_free_head >= 0 && m_free_head < cap)); - C4_ASSERT(m_free_tail == NONE || (m_free_tail >= 0 && m_free_tail < cap)); + RYML_ASSERT(m_free_head == NONE || (m_free_head >= 0 && m_free_head < cap)); + RYML_ASSERT(m_free_tail == NONE || (m_free_tail >= 0 && m_free_tail < cap)); if( ! m_size) { @@ -234,7 +234,7 @@ void Tree::clear() m_size = 0; if(m_buf) { - C4_ASSERT(m_cap >= 0); + RYML_ASSERT(m_cap >= 0); m_free_head = 0; m_free_tail = m_cap-1; _claim_root(); @@ -249,7 +249,7 @@ void Tree::clear() void Tree::_claim_root() { size_t r = _claim(); - C4_ASSERT(r == 0); + RYML_ASSERT(r == 0); _set_hierarchy(r, NONE, NONE); } @@ -258,7 +258,7 @@ void Tree::_claim_root() void Tree::_clear_range(size_t first, size_t num) { if(num == 0) return; // prevent overflow when subtracting - C4_ASSERT(first >= 0 && first + num <= m_cap); + RYML_ASSERT(first >= 0 && first + num <= m_cap); memset(m_buf + first, 0, num * sizeof(NodeData)); for(size_t i = first, e = first + num; i < e; ++i) { @@ -280,7 +280,7 @@ void Tree::_clear_range(size_t first, size_t num) //----------------------------------------------------------------------------- void Tree::_release(size_t i) { - C4_ASSERT(i >= 0 && i < m_cap); + RYML_ASSERT(i >= 0 && i < m_cap); _rem_hierarchy(i); _free_list_add(i); @@ -293,7 +293,7 @@ void Tree::_release(size_t i) // add to the front of the free list void Tree::_free_list_add(size_t i) { - C4_ASSERT(i >= 0 && i < m_cap); + RYML_ASSERT(i >= 0 && i < m_cap); NodeData &C4_RESTRICT w = m_buf[i]; w.m_parent = NONE; @@ -327,11 +327,11 @@ size_t Tree::_claim() size_t sz = 2 * m_cap; sz = sz ? sz : 16; reserve(sz); - C4_ASSERT(m_free_head != NONE); + RYML_ASSERT(m_free_head != NONE); } - C4_ASSERT(m_size < m_cap); - C4_ASSERT(m_free_head >= 0 && m_free_head < m_cap); + RYML_ASSERT(m_size < m_cap); + RYML_ASSERT(m_free_head >= 0 && m_free_head < m_cap); size_t ichild = m_free_head; NodeData *child = m_buf + ichild; @@ -341,7 +341,7 @@ size_t Tree::_claim() if(m_free_head == NONE) { m_free_tail = NONE; - C4_ASSERT(m_size == m_cap); + RYML_ASSERT(m_size == m_cap); } _clear(ichild); @@ -352,8 +352,8 @@ size_t Tree::_claim() //----------------------------------------------------------------------------- void Tree::_set_hierarchy(size_t ichild, size_t iparent, size_t iprev_sibling) { - C4_ASSERT(iparent == NONE || (iparent >= 0 && iparent < m_cap)); - C4_ASSERT(iprev_sibling == NONE || (iprev_sibling >= 0 && iprev_sibling < m_cap)); + RYML_ASSERT(iparent == NONE || (iparent >= 0 && iparent < m_cap)); + RYML_ASSERT(iprev_sibling == NONE || (iprev_sibling >= 0 && iprev_sibling < m_cap)); NodeData *C4_RESTRICT child = get(ichild); @@ -363,8 +363,8 @@ void Tree::_set_hierarchy(size_t ichild, size_t iparent, size_t iprev_sibling) if(iparent == NONE) { - C4_ASSERT(ichild == 0); - C4_ASSERT(iprev_sibling == NONE); + RYML_ASSERT(ichild == 0); + RYML_ASSERT(iprev_sibling == NONE); } if(iparent == NONE) return; @@ -376,23 +376,23 @@ void Tree::_set_hierarchy(size_t ichild, size_t iparent, size_t iprev_sibling) if(psib) { - C4_ASSERT(next_sibling(iprev_sibling) == id(nsib)); + RYML_ASSERT(next_sibling(iprev_sibling) == id(nsib)); child->m_prev_sibling = id(psib); psib->m_next_sibling = id(child); - C4_ASSERT(psib->m_prev_sibling != psib->m_next_sibling || psib->m_prev_sibling == NONE); + RYML_ASSERT(psib->m_prev_sibling != psib->m_next_sibling || psib->m_prev_sibling == NONE); } if(nsib) { - C4_ASSERT(prev_sibling(inext_sibling) == id(psib)); + RYML_ASSERT(prev_sibling(inext_sibling) == id(psib)); child->m_next_sibling = id(nsib); nsib->m_prev_sibling = id(child); - C4_ASSERT(nsib->m_prev_sibling != nsib->m_next_sibling || nsib->m_prev_sibling == NONE); + RYML_ASSERT(nsib->m_prev_sibling != nsib->m_next_sibling || nsib->m_prev_sibling == NONE); } if(parent->m_first_child == NONE) { - C4_ASSERT(parent->m_last_child == NONE); + RYML_ASSERT(parent->m_last_child == NONE); parent->m_first_child = id(child); parent->m_last_child = id(child); } @@ -412,7 +412,7 @@ void Tree::_set_hierarchy(size_t ichild, size_t iparent, size_t iprev_sibling) //----------------------------------------------------------------------------- void Tree::_rem_hierarchy(size_t i) { - C4_ASSERT(i >= 0 && i < m_cap); + RYML_ASSERT(i >= 0 && i < m_cap); NodeData &C4_RESTRICT w = m_buf[i]; @@ -474,8 +474,8 @@ size_t Tree::_do_reorder(size_t *node, size_t count) //----------------------------------------------------------------------------- void Tree::_swap(size_t n_, size_t m_) { - C4_ASSERT((parent(n_) != NONE) || type(n_) == NOTYPE); - C4_ASSERT((parent(m_) != NONE) || type(m_) == NOTYPE); + RYML_ASSERT((parent(n_) != NONE) || type(n_) == NOTYPE); + RYML_ASSERT((parent(m_) != NONE) || type(m_) == NOTYPE); NodeType tn = type(n_); NodeType tm = type(m_); if(tn != NOTYPE && tm != NOTYPE) @@ -580,15 +580,15 @@ void Tree::_swap_hierarchy(size_t ia, size_t ib) { if(a.m_next_sibling == ib) // n will go after m { - C4_ASSERT(b.m_prev_sibling == ia); + RYML_ASSERT(b.m_prev_sibling == ia); if(a.m_prev_sibling != NONE) { - C4_ASSERT(a.m_prev_sibling != ib); + RYML_ASSERT(a.m_prev_sibling != ib); _p(a.m_prev_sibling)->m_next_sibling = ib; } if(b.m_next_sibling != NONE) { - C4_ASSERT(b.m_next_sibling != ia); + RYML_ASSERT(b.m_next_sibling != ia); _p(b.m_next_sibling)->m_prev_sibling = ia; } size_t ns = b.m_next_sibling; @@ -599,15 +599,15 @@ void Tree::_swap_hierarchy(size_t ia, size_t ib) } else if(a.m_prev_sibling == ib) // m will go after n { - C4_ASSERT(b.m_next_sibling == ia); + RYML_ASSERT(b.m_next_sibling == ia); if(b.m_prev_sibling != NONE) { - C4_ASSERT(b.m_prev_sibling != ia); + RYML_ASSERT(b.m_prev_sibling != ia); _p(b.m_prev_sibling)->m_next_sibling = ia; } if(a.m_next_sibling != NONE) { - C4_ASSERT(a.m_next_sibling != ib); + RYML_ASSERT(a.m_next_sibling != ib); _p(a.m_next_sibling)->m_prev_sibling = ib; } size_t ns = b.m_prev_sibling; @@ -621,10 +621,10 @@ void Tree::_swap_hierarchy(size_t ia, size_t ib) C4_NEVER_REACH(); } } - C4_ASSERT(a.m_next_sibling != ia); - C4_ASSERT(a.m_prev_sibling != ia); - C4_ASSERT(b.m_next_sibling != ib); - C4_ASSERT(b.m_prev_sibling != ib); + RYML_ASSERT(a.m_next_sibling != ia); + RYML_ASSERT(a.m_prev_sibling != ia); + RYML_ASSERT(b.m_next_sibling != ib); + RYML_ASSERT(b.m_prev_sibling != ib); if(a.m_parent != ib && b.m_parent != ia) { @@ -695,9 +695,9 @@ void Tree::_swap_props(size_t n_, size_t m_) //----------------------------------------------------------------------------- void Tree::move(size_t node, size_t after) { - C4_ASSERT(node != NONE); - C4_ASSERT( ! is_root(node)); - C4_ASSERT(has_sibling(node, after) && has_sibling(after, node)); + RYML_ASSERT(node != NONE); + RYML_ASSERT( ! is_root(node)); + RYML_ASSERT(has_sibling(node, after) && has_sibling(after, node)); _rem_hierarchy(node); _set_hierarchy(node, parent(node), after); @@ -707,9 +707,9 @@ void Tree::move(size_t node, size_t after) void Tree::move(size_t node, size_t new_parent, size_t after) { - C4_ASSERT(node != NONE); - C4_ASSERT(new_parent != NONE); - C4_ASSERT( ! is_root(node)); + RYML_ASSERT(node != NONE); + RYML_ASSERT(new_parent != NONE); + RYML_ASSERT( ! is_root(node)); _rem_hierarchy(node); _set_hierarchy(node, new_parent, after); @@ -717,8 +717,8 @@ void Tree::move(size_t node, size_t new_parent, size_t after) size_t Tree::move(Tree *src, size_t node, size_t new_parent, size_t after) { - C4_ASSERT(node != NONE); - C4_ASSERT(new_parent != NONE); + RYML_ASSERT(node != NONE); + RYML_ASSERT(new_parent != NONE); size_t dup = duplicate(src, node, new_parent, after); src->remove(node); @@ -733,10 +733,10 @@ size_t Tree::duplicate(size_t node, size_t parent, size_t after) size_t Tree::duplicate(Tree const* src, size_t node, size_t parent, size_t after) { - C4_ASSERT(src != nullptr); - C4_ASSERT(node != NONE); - C4_ASSERT(parent != NONE); - C4_ASSERT( ! src->is_root(node)); + RYML_ASSERT(src != nullptr); + RYML_ASSERT(node != NONE); + RYML_ASSERT(parent != NONE); + RYML_ASSERT( ! src->is_root(node)); size_t copy = _claim(); @@ -755,10 +755,10 @@ size_t Tree::duplicate_children(size_t node, size_t parent, size_t after) size_t Tree::duplicate_children(Tree const* src, size_t node, size_t parent, size_t after) { - C4_ASSERT(src != nullptr); - C4_ASSERT(node != NONE); - C4_ASSERT(parent != NONE); - C4_ASSERT(after == NONE || has_child(parent, after)); + RYML_ASSERT(src != nullptr); + RYML_ASSERT(node != NONE); + RYML_ASSERT(parent != NONE); + RYML_ASSERT(after == NONE || has_child(parent, after)); size_t prev = after; for(size_t i = src->first_child(node); i != NONE; i = src->next_sibling(i)) @@ -777,9 +777,9 @@ void Tree::duplicate_contents(size_t node, size_t where) void Tree::duplicate_contents(Tree const *src, size_t node, size_t where) { - C4_ASSERT(src != nullptr); - C4_ASSERT(node != NONE); - C4_ASSERT(where != NONE); + RYML_ASSERT(src != nullptr); + RYML_ASSERT(node != NONE); + RYML_ASSERT(where != NONE); _copy_props_wo_key(where, src, node); duplicate_children(src, node, where, last_child(where)); } @@ -792,9 +792,9 @@ size_t Tree::duplicate_children_no_rep(size_t node, size_t parent, size_t after) size_t Tree::duplicate_children_no_rep(Tree const *src, size_t node, size_t parent, size_t after) { - C4_ASSERT(node != NONE); - C4_ASSERT(parent != NONE); - C4_ASSERT(after == NONE || has_child(parent, after)); + RYML_ASSERT(node != NONE); + RYML_ASSERT(parent != NONE); + RYML_ASSERT(after == NONE || has_child(parent, after)); // don't loop using pointers as there may be a relocation @@ -810,7 +810,7 @@ size_t Tree::duplicate_children_no_rep(Tree const *src, size_t node, size_t pare break; } } - C4_ASSERT(after_pos != NONE); + RYML_ASSERT(after_pos != NONE); } // for each child to be duplicated... @@ -823,7 +823,7 @@ size_t Tree::duplicate_children_no_rep(Tree const *src, size_t node, size_t pare } else { - C4_ASSERT(is_map(parent)); + RYML_ASSERT(is_map(parent)); // does the parent already have a node with key equal to that of the current duplicate? size_t rep = NONE, rep_pos = NONE; for(size_t j = first_child(parent), jcount = 0; j != NONE; ++jcount, j = next_sibling(j)) @@ -870,10 +870,10 @@ size_t Tree::duplicate_children_no_rep(Tree const *src, size_t node, size_t pare void Tree::merge_with(Tree const *src, size_t src_node, size_t dst_node) { - C4_ASSERT(src != nullptr); + RYML_ASSERT(src != nullptr); if(src_node == NONE) src_node = src->root_id(); if(dst_node == NONE) dst_node = root_id(); - C4_ASSERT(src->has_val(src_node) || src->is_seq(src_node) || src->is_map(src_node)); + RYML_ASSERT(src->has_val(src_node) || src->is_seq(src_node) || src->is_map(src_node)); // CASE 1: (KEY)VALUE NODES if(src->has_val(src_node)) @@ -1038,7 +1038,7 @@ struct ReferenceResolver { for(size_t i = t->first_child(n); i != NONE; i = t->next_sibling(i)) { - C4_ASSERT(t->num_children(i) == 0); + RYML_ASSERT(t->num_children(i) == 0); refs.push({true, i, npos, npos, n, t->next_sibling(n)}); } return; @@ -1065,9 +1065,9 @@ struct ReferenceResolver size_t lookup_(size_t refnode, refdata *C4_RESTRICT ra) { - C4_ASSERT(t->has_val(refnode)); + RYML_ASSERT(t->has_val(refnode)); csubstr refname = t->val(refnode); - C4_ASSERT(refname.begins_with('*')); + RYML_ASSERT(refname.begins_with('*')); refname = refname.sub(1); while(ra->prev_anchor != npos) { @@ -1116,7 +1116,7 @@ void Tree::resolve() if( ! rd.is_ref) continue; if(rd.parent_ref != NONE) { - C4_ASSERT(is_seq(rd.parent_ref)); + RYML_ASSERT(is_seq(rd.parent_ref)); size_t after, p = parent(rd.parent_ref); if(prev_parent_ref != rd.parent_ref) { @@ -1135,7 +1135,7 @@ void Tree::resolve() { if(has_key(rd.node) && key(rd.node) == "<<") { - C4_ASSERT(is_keyval(rd.node)); + RYML_ASSERT(is_keyval(rd.node)); size_t p = parent(rd.node); size_t after = prev_sibling(rd.node); duplicate_children_no_rep(rd.target, p, after); @@ -1178,7 +1178,7 @@ size_t Tree::num_children(size_t node) const size_t Tree::child(size_t node, size_t pos) const { - C4_ASSERT(node != NONE); + RYML_ASSERT(node != NONE); if(_p(node)->is_val()) return NONE; size_t count = 0; for(size_t i = first_child(node); i != NONE; i = next_sibling(i)) @@ -1201,18 +1201,18 @@ size_t Tree::child_pos(size_t node, size_t ch) const size_t Tree::find_child(size_t node, csubstr const& name) const { - C4_ASSERT(node != NONE); + RYML_ASSERT(node != NONE); if(_p(node)->is_val()) return NONE; - C4_ASSERT(_p(node)->is_map()); - C4_ASSERT( ! name.empty()); + RYML_ASSERT(_p(node)->is_map()); + RYML_ASSERT( ! name.empty()); if(get(node)->m_first_child == NONE) { - C4_ASSERT(_p(node)->m_last_child == NONE); + RYML_ASSERT(_p(node)->m_last_child == NONE); return NONE; } else { - C4_ASSERT(_p(node)->m_last_child != NONE); + RYML_ASSERT(_p(node)->m_last_child != NONE); } for(size_t i = first_child(node); i != NONE; i = next_sibling(i)) { @@ -1229,8 +1229,8 @@ size_t Tree::find_child(size_t node, csubstr const& name) const void Tree::to_val(size_t node, csubstr const& val, type_bits more_flags) { - C4_ASSERT( ! has_children(node)); - C4_ASSERT(parent(node) == NONE || ! parent_is_map(node)); + RYML_ASSERT( ! has_children(node)); + RYML_ASSERT(parent(node) == NONE || ! parent_is_map(node)); _set_flags(node, VAL|more_flags); _p(node)->m_key.clear(); _p(node)->m_val = val; @@ -1238,9 +1238,9 @@ void Tree::to_val(size_t node, csubstr const& val, type_bits more_flags) void Tree::to_keyval(size_t node, csubstr const& key, csubstr const& val, type_bits more_flags) { - C4_ASSERT( ! has_children(node)); - //C4_ASSERT( ! key.empty()); - C4_ASSERT(parent(node) == NONE || parent_is_map(node)); + RYML_ASSERT( ! has_children(node)); + //RYML_ASSERT( ! key.empty()); + RYML_ASSERT(parent(node) == NONE || parent_is_map(node)); _set_flags(node, KEYVAL|more_flags); _p(node)->m_key = key; _p(node)->m_val = val; @@ -1248,8 +1248,8 @@ void Tree::to_keyval(size_t node, csubstr const& key, csubstr const& val, type_b void Tree::to_map(size_t node, type_bits more_flags) { - C4_ASSERT( ! has_children(node)); - C4_ASSERT(parent(node) == NONE || ! parent_is_map(node)); + RYML_ASSERT( ! has_children(node)); + RYML_ASSERT(parent(node) == NONE || ! parent_is_map(node)); _set_flags(node, MAP|more_flags); _p(node)->m_key.clear(); _p(node)->m_val.clear(); @@ -1257,9 +1257,9 @@ void Tree::to_map(size_t node, type_bits more_flags) void Tree::to_map(size_t node, csubstr const& key, type_bits more_flags) { - C4_ASSERT( ! has_children(node)); - C4_ASSERT( ! key.empty()); - C4_ASSERT(parent(node) == NONE || parent_is_map(node)); + RYML_ASSERT( ! has_children(node)); + RYML_ASSERT( ! key.empty()); + RYML_ASSERT(parent(node) == NONE || parent_is_map(node)); _set_flags(node, KEY|MAP|more_flags); _p(node)->m_key = key; _p(node)->m_val.clear(); @@ -1267,7 +1267,7 @@ void Tree::to_map(size_t node, csubstr const& key, type_bits more_flags) void Tree::to_seq(size_t node, type_bits more_flags) { - C4_ASSERT( ! has_children(node)); + RYML_ASSERT( ! has_children(node)); _set_flags(node, SEQ|more_flags); _p(node)->m_key.clear(); _p(node)->m_val.clear(); @@ -1275,8 +1275,8 @@ void Tree::to_seq(size_t node, type_bits more_flags) void Tree::to_seq(size_t node, csubstr const& key, type_bits more_flags) { - C4_ASSERT( ! has_children(node)); - C4_ASSERT(parent(node) == NONE || parent_is_map(node)); + RYML_ASSERT( ! has_children(node)); + RYML_ASSERT(parent(node) == NONE || parent_is_map(node)); _set_flags(node, KEY|SEQ|more_flags); _p(node)->m_key = key; _p(node)->m_val.clear(); @@ -1284,7 +1284,7 @@ void Tree::to_seq(size_t node, csubstr const& key, type_bits more_flags) void Tree::to_doc(size_t node, type_bits more_flags) { - C4_ASSERT( ! has_children(node)); + RYML_ASSERT( ! has_children(node)); _set_flags(node, DOC|more_flags); _p(node)->m_key.clear(); _p(node)->m_val.clear(); @@ -1292,7 +1292,7 @@ void Tree::to_doc(size_t node, type_bits more_flags) void Tree::to_stream(size_t node, type_bits more_flags) { - C4_ASSERT( ! has_children(node)); + RYML_ASSERT( ! has_children(node)); _set_flags(node, STREAM|more_flags); _p(node)->m_key.clear(); _p(node)->m_val.clear(); @@ -1349,7 +1349,7 @@ size_t Tree::lookup_path_or_modify(csubstr default_value, csubstr path, size_t s } else { - C4_ASSERT(parent_is_map(r.target)); + RYML_ASSERT(parent_is_map(r.target)); to_val(r.target, default_value); } return r.target; @@ -1386,11 +1386,11 @@ size_t Tree::_next_node(lookup_result * r, bool modify, _lookup_path_token *pare if(type == MAP || type == SEQ) { - C4_ASSERT(!tk.begins_with('[')); - //C4_ASSERT(is_container(r->closest) || r->closest == NONE); + RYML_ASSERT(!tk.begins_with('[')); + //RYML_ASSERT(is_container(r->closest) || r->closest == NONE); if( ! modify) { - C4_ASSERT(is_map(r->closest)); + RYML_ASSERT(is_map(r->closest)); node = find_child(r->closest, tk); if(node == NONE) goto failure; } @@ -1407,11 +1407,11 @@ size_t Tree::_next_node(lookup_result * r, bool modify, _lookup_path_token *pare to_map(r->closest); } } - C4_ASSERT(is_map(r->closest)); + RYML_ASSERT(is_map(r->closest)); node = find_child(r->closest, tk); if(node == NONE) { - C4_ASSERT(is_map(r->closest)); + RYML_ASSERT(is_map(r->closest)); node = append_child(r->closest); NodeData *n = _p(node); n->m_key.scalar = tk; @@ -1421,7 +1421,7 @@ size_t Tree::_next_node(lookup_result * r, bool modify, _lookup_path_token *pare } else if(type == KEYVAL) { - C4_ASSERT(r->unresolved().empty()); + RYML_ASSERT(r->unresolved().empty()); if(is_map(r->closest)) { node = find_child(r->closest, tk); @@ -1437,7 +1437,7 @@ size_t Tree::_next_node(lookup_result * r, bool modify, _lookup_path_token *pare NodeData *c = _p(r->closest); c->m_type.add(MAP); } - C4_ASSERT(is_map(r->closest)); + RYML_ASSERT(is_map(r->closest)); node = append_child(r->closest); NodeData *n = _p(node); n->m_key.scalar = tk; @@ -1447,7 +1447,7 @@ size_t Tree::_next_node(lookup_result * r, bool modify, _lookup_path_token *pare } else if(type == KEY) { - C4_ASSERT(tk.begins_with('[') && tk.ends_with(']')); + RYML_ASSERT(tk.begins_with('[') && tk.ends_with(']')); tk = tk.offs(1, 1).trim(' '); size_t idx; if( ! from_chars(tk, &idx)) @@ -1472,11 +1472,11 @@ size_t Tree::_next_node(lookup_result * r, bool modify, _lookup_path_token *pare to_seq(r->closest); } } - C4_ASSERT(is_container(r->closest)); + RYML_ASSERT(is_container(r->closest)); node = child(r->closest, idx); if(node == NONE) { - C4_ASSERT(num_children(r->closest) <= idx); + RYML_ASSERT(num_children(r->closest) <= idx); for(size_t i = num_children(r->closest); i <= idx; ++i) { node = append_child(r->closest); @@ -1505,7 +1505,7 @@ size_t Tree::_next_node(lookup_result * r, bool modify, _lookup_path_token *pare return node; failure: - C4_ASSERT(node == NONE); + RYML_ASSERT(node == NONE); if( ! modify) // rollback { csubstr p = r->path.sub(r->path_pos); @@ -1555,15 +1555,15 @@ Tree::_lookup_path_token Tree::_next_token(lookup_result *r, _lookup_path_token } // it's either a map or a seq - C4_ASSERT(unres[pos] == '.' || unres[pos] == '['); + RYML_ASSERT(unres[pos] == '.' || unres[pos] == '['); if(unres[pos] == '.') { - C4_ASSERT(pos != 0); + RYML_ASSERT(pos != 0); _advance(r, pos + 1); return {unres.first(pos), MAP}; } - C4_ASSERT(unres[pos] == '['); + RYML_ASSERT(unres[pos] == '['); _advance(r, pos); return {unres.first(pos), SEQ}; } diff --git a/src/c4/yml/tree.hpp b/src/c4/yml/tree.hpp index f563bea1..f10b50e4 100644 --- a/src/c4/yml/tree.hpp +++ b/src/c4/yml/tree.hpp @@ -252,13 +252,13 @@ public: bool _check() const { // key cannot be empty - C4_ASSERT(key.scalar.empty() == ((type & KEY) == 0)); + RYML_ASSERT(key.scalar.empty() == ((type & KEY) == 0)); // key tag cannot be empty - C4_ASSERT(key.tag.empty() == ((type & KEYTAG) == 0)); + RYML_ASSERT(key.tag.empty() == ((type & KEYTAG) == 0)); // val may be empty even though VAL is set. But when VAL is not set, val must be empty - C4_ASSERT(((type & VAL) != 0) || val.scalar.empty()); + RYML_ASSERT(((type & VAL) != 0) || val.scalar.empty()); // val tag cannot be empty - C4_ASSERT(val.tag.empty() == ((type & VALTAG) == 0)); + RYML_ASSERT(val.tag.empty() == ((type & VALTAG) == 0)); return true; } }; @@ -299,15 +299,15 @@ public: const char* type_str() const { return type_str(m_type); } static const char* type_str(NodeType_e ty); - csubstr const& key() const { C4_ASSERT(has_key()); return m_key.scalar; } - csubstr const& key_tag() const { C4_ASSERT(has_key_tag()); return m_key.tag; } + csubstr const& key() const { RYML_ASSERT(has_key()); return m_key.scalar; } + csubstr const& key_tag() const { RYML_ASSERT(has_key_tag()); return m_key.tag; } csubstr const& key_anchor() const { return m_key.anchor; } - NodeScalar const& keysc() const { C4_ASSERT(has_key()); return m_key; } + NodeScalar const& keysc() const { RYML_ASSERT(has_key()); return m_key; } - csubstr const& val() const { C4_ASSERT(has_val()); return m_val.scalar; } - csubstr const& val_tag() const { C4_ASSERT(has_val_tag()); return m_val.tag; } - csubstr const& val_anchor() const { C4_ASSERT(has_val_tag()); return m_val.anchor; } - NodeScalar const& valsc() const { C4_ASSERT(has_val()); return m_val; } + csubstr const& val() const { RYML_ASSERT(has_val()); return m_val.scalar; } + csubstr const& val_tag() const { RYML_ASSERT(has_val_tag()); return m_val.tag; } + csubstr const& val_anchor() const { RYML_ASSERT(has_val_tag()); return m_val.anchor; } + NodeScalar const& valsc() const { RYML_ASSERT(has_val()); return m_val; } public: @@ -366,11 +366,11 @@ public: inline size_t size () const { return m_size; } inline size_t capacity() const { return m_cap; } - inline size_t slack() const { C4_ASSERT(m_cap >= m_size); return m_cap - m_size; } + inline size_t slack() const { RYML_ASSERT(m_cap >= m_size); return m_cap - m_size; } inline size_t arena_size() const { return m_arena_pos; } inline size_t arena_capacity() const { return m_arena.len; } - inline size_t arena_slack() const { C4_ASSERT(m_arena.len >= m_arena_pos); return m_arena.len - m_arena_pos; } + inline size_t arena_slack() const { RYML_ASSERT(m_arena.len >= m_arena_pos); return m_arena.len - m_arena_pos; } Allocator const& allocator() const { return m_alloc; } @@ -379,13 +379,13 @@ public: size_t id(NodeData const* n) { if( ! n) return NONE; - C4_ASSERT(n >= m_buf && n < m_buf + m_cap); + RYML_ASSERT(n >= m_buf && n < m_buf + m_cap); return n - m_buf; } size_t id(NodeData const* n) const { if( ! n) return NONE; - C4_ASSERT(n >= m_buf && n < m_buf + m_cap); + RYML_ASSERT(n >= m_buf && n < m_buf + m_cap); return n - m_buf; } @@ -393,27 +393,27 @@ public: inline NodeData *get(size_t i) { if(i == NONE) return nullptr; - C4_ASSERT(i >= 0 && i < m_cap); + RYML_ASSERT(i >= 0 && i < m_cap); return m_buf + i; } inline NodeData const *get(size_t i) const { if(i == NONE) return nullptr; - C4_ASSERT(i >= 0 && i < m_cap); + RYML_ASSERT(i >= 0 && i < m_cap); return m_buf + i; } // a shorter form of [] - inline NodeData * _p(size_t i) { C4_ASSERT(i != NONE && i >= 0 && i < m_cap); return m_buf + i; } - inline NodeData const * _p(size_t i) const { C4_ASSERT(i != NONE && i >= 0 && i < m_cap); return m_buf + i; } + inline NodeData * _p(size_t i) { RYML_ASSERT(i != NONE && i >= 0 && i < m_cap); return m_buf + i; } + inline NodeData const * _p(size_t i) const { RYML_ASSERT(i != NONE && i >= 0 && i < m_cap); return m_buf + i; } /** resolve references in the tree */ void resolve(); public: - size_t root_id() { if(m_cap == 0) { reserve(16); } C4_ASSERT(m_cap > 0 && m_size > 0); return 0; } - size_t root_id() const { C4_ASSERT(m_cap > 0 && m_size > 0); return 0; } + size_t root_id() { if(m_cap == 0) { reserve(16); } RYML_ASSERT(m_cap > 0 && m_size > 0); return 0; } + size_t root_id() const { RYML_ASSERT(m_cap > 0 && m_size > 0); return 0; } NodeRef rootref(); NodeRef const rootref() const; @@ -429,24 +429,24 @@ public: NodeType_e type(size_t node) const { return (NodeType_e)(_p(node)->m_type & _TYMASK); } const char* type_str(size_t node) const { return NodeType::type_str(_p(node)->m_type); } - csubstr const& key (size_t node) const { C4_ASSERT(has_key(node)); return _p(node)->m_key.scalar; } - csubstr const& key_tag (size_t node) const { C4_ASSERT(has_key_tag(node)); return _p(node)->m_key.tag; } - csubstr const& key_ref (size_t node) const { C4_ASSERT(is_key_ref(node) && ! has_key_anchor(node)); return _p(node)->m_key.anchor; } - csubstr const& key_anchor(size_t node) const { C4_ASSERT( ! is_key_ref(node) && has_key_anchor(node)); return _p(node)->m_key.anchor; } - NodeScalar const& keysc (size_t node) const { C4_ASSERT(has_key(node)); return _p(node)->m_key; } + csubstr const& key (size_t node) const { RYML_ASSERT(has_key(node)); return _p(node)->m_key.scalar; } + csubstr const& key_tag (size_t node) const { RYML_ASSERT(has_key_tag(node)); return _p(node)->m_key.tag; } + csubstr const& key_ref (size_t node) const { RYML_ASSERT(is_key_ref(node) && ! has_key_anchor(node)); return _p(node)->m_key.anchor; } + csubstr const& key_anchor(size_t node) const { RYML_ASSERT( ! is_key_ref(node) && has_key_anchor(node)); return _p(node)->m_key.anchor; } + NodeScalar const& keysc (size_t node) const { RYML_ASSERT(has_key(node)); return _p(node)->m_key; } - csubstr const& val (size_t node) const { C4_ASSERT(has_val(node)); return _p(node)->m_val.scalar; } - csubstr const& val_tag (size_t node) const { C4_ASSERT(has_val_tag(node)); return _p(node)->m_val.tag; } - csubstr const& val_ref (size_t node) const { C4_ASSERT(is_val_ref(node) && ! has_val_anchor(node)); return _p(node)->m_val.anchor; } - csubstr const& val_anchor(size_t node) const { C4_ASSERT( ! is_val_ref(node) && has_val_anchor(node)); return _p(node)->m_val.anchor; } - NodeScalar const& valsc (size_t node) const { C4_ASSERT(has_val(node)); return _p(node)->m_val; } + csubstr const& val (size_t node) const { RYML_ASSERT(has_val(node)); return _p(node)->m_val.scalar; } + csubstr const& val_tag (size_t node) const { RYML_ASSERT(has_val_tag(node)); return _p(node)->m_val.tag; } + csubstr const& val_ref (size_t node) const { RYML_ASSERT(is_val_ref(node) && ! has_val_anchor(node)); return _p(node)->m_val.anchor; } + csubstr const& val_anchor(size_t node) const { RYML_ASSERT( ! is_val_ref(node) && has_val_anchor(node)); return _p(node)->m_val.anchor; } + NodeScalar const& valsc (size_t node) const { RYML_ASSERT(has_val(node)); return _p(node)->m_val; } public: // node predicates - bool is_root(size_t node) const { C4_ASSERT(_p(node)->m_parent != NONE || node == 0); return _p(node)->m_parent == NONE; } + bool is_root(size_t node) const { RYML_ASSERT(_p(node)->m_parent != NONE || node == 0); return _p(node)->m_parent == NONE; } bool is_stream(size_t node) const { return (_p(node)->m_type & STREAM) == STREAM; } bool is_doc(size_t node) const { return (_p(node)->m_type & DOC) != 0; } bool is_container(size_t node) const { return (_p(node)->m_type & (MAP|SEQ|STREAM|DOC)) != 0; } @@ -465,8 +465,8 @@ public: bool is_ref(size_t node) const { return (_p(node)->m_type & (KEYREF|VALREF)) != 0; } bool is_anchor(size_t node) const { return (_p(node)->m_type & (KEYANCH|VALANCH)) != 0; } - bool parent_is_seq(size_t node) const { C4_ASSERT(has_parent(node)); return is_seq(_p(node)->m_parent); } - bool parent_is_map(size_t node) const { C4_ASSERT(has_parent(node)); return is_map(_p(node)->m_parent); } + bool parent_is_seq(size_t node) const { RYML_ASSERT(has_parent(node)); return is_seq(_p(node)->m_parent); } + bool parent_is_map(size_t node) const { RYML_ASSERT(has_parent(node)); return is_map(_p(node)->m_parent); } /** true when name and value are empty, and has no children */ bool empty(size_t node) const { return ! has_children(node) && _p(node)->m_key.empty() && (( ! (_p(node)->m_type & VAL)) || _p(node)->m_val.empty()); } @@ -511,8 +511,8 @@ public: /** counts with this */ size_t num_siblings(size_t node) const { return is_root(node) ? 1 : num_children(_p(node)->m_parent); } /** does not count with this */ - size_t num_other_siblings(size_t node) const { size_t ns = num_siblings(node); C4_ASSERT(ns > 0); return ns-1; } - size_t sibling_pos(size_t node, size_t sib) const { C4_ASSERT( ! is_root(node) || node == root_id()); return child_pos(_p(node)->m_parent, sib); } + size_t num_other_siblings(size_t node) const { size_t ns = num_siblings(node); RYML_ASSERT(ns > 0); return ns-1; } + size_t sibling_pos(size_t node, size_t sib) const { RYML_ASSERT( ! is_root(node) || node == root_id()); return child_pos(_p(node)->m_parent, sib); } size_t first_sibling(size_t node) const { return is_root(node) ? node : _p(_p(node)->m_parent)->m_first_child; } size_t last_sibling(size_t node) const { return is_root(node) ? node : _p(_p(node)->m_parent)->m_last_child; } size_t sibling(size_t node, size_t pos) const { return child(_p(node)->m_parent, pos); } @@ -529,21 +529,21 @@ public: void to_seq(size_t node, type_bits more_flags=0); void to_doc(size_t node, type_bits more_flags=0); - void set_key(size_t node, csubstr key) { C4_ASSERT(has_key(node)); _p(node)->m_key.scalar = key; } - void set_val(size_t node, csubstr val) { C4_ASSERT(has_val(node)); _p(node)->m_val.scalar = val; } + void set_key(size_t node, csubstr key) { RYML_ASSERT(has_key(node)); _p(node)->m_key.scalar = key; } + void set_val(size_t node, csubstr val) { RYML_ASSERT(has_val(node)); _p(node)->m_val.scalar = val; } - void set_key_tag(size_t node, csubstr const& tag) { C4_ASSERT(has_key(node)); _p(node)->m_key.tag = tag; _add_flags(node, KEYTAG); } - void set_val_tag(size_t node, csubstr const& tag) { C4_ASSERT(has_val(node) || is_container(node)); _p(node)->m_val.tag = tag; _add_flags(node, VALTAG); } + void set_key_tag(size_t node, csubstr const& tag) { RYML_ASSERT(has_key(node)); _p(node)->m_key.tag = tag; _add_flags(node, KEYTAG); } + void set_val_tag(size_t node, csubstr const& tag) { RYML_ASSERT(has_val(node) || is_container(node)); _p(node)->m_val.tag = tag; _add_flags(node, VALTAG); } - void set_key_anchor(size_t node, csubstr anchor) { C4_ASSERT( ! is_key_ref(node)); _p(node)->m_key.anchor = anchor; _add_flags(node, KEYANCH); } - void set_val_anchor(size_t node, csubstr anchor) { C4_ASSERT( ! is_val_ref(node)); _p(node)->m_val.anchor = anchor; _add_flags(node, VALANCH); } - void set_key_ref (size_t node, csubstr ref ) { C4_ASSERT( ! has_key_anchor(node)); _p(node)->m_key.anchor = ref; _add_flags(node, KEYREF); } - void set_val_ref (size_t node, csubstr ref ) { C4_ASSERT( ! has_val_anchor(node)); _p(node)->m_val.anchor = ref; _add_flags(node, VALREF); } + void set_key_anchor(size_t node, csubstr anchor) { RYML_ASSERT( ! is_key_ref(node)); _p(node)->m_key.anchor = anchor; _add_flags(node, KEYANCH); } + void set_val_anchor(size_t node, csubstr anchor) { RYML_ASSERT( ! is_val_ref(node)); _p(node)->m_val.anchor = anchor; _add_flags(node, VALANCH); } + void set_key_ref (size_t node, csubstr ref ) { RYML_ASSERT( ! has_key_anchor(node)); _p(node)->m_key.anchor = ref; _add_flags(node, KEYREF); } + void set_val_ref (size_t node, csubstr ref ) { RYML_ASSERT( ! has_val_anchor(node)); _p(node)->m_val.anchor = ref; _add_flags(node, VALREF); } - void rem_key_anchor(size_t node) { C4_ASSERT( ! is_key_ref(node)); _p(node)->m_key.anchor.clear(); _rem_flags(node, KEYANCH); } - void rem_val_anchor(size_t node) { C4_ASSERT( ! is_val_ref(node)); _p(node)->m_val.anchor.clear(); _rem_flags(node, VALANCH); } - void rem_key_ref (size_t node) { C4_ASSERT( ! has_key_anchor(node)); _p(node)->m_key.anchor.clear(); _rem_flags(node, KEYREF); } - void rem_val_ref (size_t node) { C4_ASSERT( ! has_val_anchor(node)); _p(node)->m_val.anchor.clear(); _rem_flags(node, VALREF); } + void rem_key_anchor(size_t node) { RYML_ASSERT( ! is_key_ref(node)); _p(node)->m_key.anchor.clear(); _rem_flags(node, KEYANCH); } + void rem_val_anchor(size_t node) { RYML_ASSERT( ! is_val_ref(node)); _p(node)->m_val.anchor.clear(); _rem_flags(node, VALANCH); } + void rem_key_ref (size_t node) { RYML_ASSERT( ! has_key_anchor(node)); _p(node)->m_key.anchor.clear(); _rem_flags(node, KEYREF); } + void rem_val_ref (size_t node) { RYML_ASSERT( ! has_val_anchor(node)); _p(node)->m_val.anchor.clear(); _rem_flags(node, VALREF); } void rem_anchor_ref(size_t node) { _p(node)->m_key.anchor.clear(); _p(node)->m_val.anchor.clear(); _rem_flags(node, KEYANCH|VALANCH|KEYREF|VALREF); } public: @@ -553,9 +553,9 @@ public: * first child, set after to NONE */ inline size_t insert_child(size_t parent, size_t after) { - C4_ASSERT(parent != NONE); - C4_ASSERT(is_container(parent) || is_root(parent)); - C4_ASSERT(after == NONE || has_child(parent, after)); + RYML_ASSERT(parent != NONE); + RYML_ASSERT(is_container(parent) || is_root(parent)); + RYML_ASSERT(after == NONE || has_child(parent, after)); size_t child = _claim(); _set_hierarchy(child, parent, after); return child; @@ -568,10 +568,10 @@ public: //! create and insert a new sibling of n. insert after "after" inline size_t insert_sibling(size_t node, size_t after) { - C4_ASSERT(node != NONE); - C4_ASSERT( ! is_root(node)); - C4_ASSERT(parent(node) != NONE); - C4_ASSERT(after == NONE || (has_sibling(node, after) && has_sibling(after, node))); + RYML_ASSERT(node != NONE); + RYML_ASSERT( ! is_root(node)); + RYML_ASSERT(parent(node) != NONE); + RYML_ASSERT(after == NONE || (has_sibling(node, after) && has_sibling(after, node))); return insert_child(get(node)->m_parent, after); } inline size_t prepend_sibling(size_t node) { return insert_sibling(node, NONE); } @@ -664,7 +664,7 @@ public: { rem = _grow_arena(num); num = to_chars(rem, a); - C4_ASSERT(num <= rem.len); + RYML_ASSERT(num <= rem.len); } rem = _request_span(num); return rem; @@ -688,7 +688,7 @@ public: substr copy_to_arena(csubstr s) { substr cp = alloc_arena(s.len); - C4_ASSERT(cp.len == s.len); + RYML_ASSERT(cp.len == s.len); memcpy(cp.str, s.str, s.len); return cp; } @@ -702,7 +702,7 @@ public: buf.len = arena_cap; if(m_arena.str) { - C4_ASSERT(m_arena.len >= 0); + RYML_ASSERT(m_arena.len >= 0); _relocate(buf); // does a memcpy and changes nodes using the arena m_alloc.free(m_arena.str, m_arena.len); } @@ -774,12 +774,12 @@ private: substr _relocated(csubstr s, substr next_arena) const { - C4_ASSERT(m_arena.contains(s)); - C4_ASSERT(m_arena.sub(0, m_arena_pos).contains(s)); + RYML_ASSERT(m_arena.contains(s)); + RYML_ASSERT(m_arena.sub(0, m_arena_pos).contains(s)); auto pos = (s.str - m_arena.str); substr r(next_arena.str + pos, s.len); - C4_ASSERT(r.str - next_arena.str == pos); - C4_ASSERT(next_arena.sub(0, m_arena_pos).contains(r)); + RYML_ASSERT(r.str - next_arena.str == pos); + RYML_ASSERT(next_arena.sub(0, m_arena_pos).contains(r)); return r; } @@ -857,17 +857,17 @@ public: } void _set_val(size_t node, NodeScalar const& val, type_bits more_flags=0) { - C4_ASSERT(num_children(node) == 0); - C4_ASSERT( ! is_container(node)); + RYML_ASSERT(num_children(node) == 0); + RYML_ASSERT( ! is_container(node)); _p(node)->m_val = val; _add_flags(node, VAL|more_flags); } void _set(size_t node, NodeInit const& i) { - C4_ASSERT(i._check()); + RYML_ASSERT(i._check()); NodeData *n = _p(node); - C4_ASSERT(n->m_key.scalar.empty() || i.key.scalar.empty() || i.key.scalar == n->m_key.scalar); + RYML_ASSERT(n->m_key.scalar.empty() || i.key.scalar.empty() || i.key.scalar == n->m_key.scalar); _add_flags(node, i.type); if(n->m_key.scalar.empty()) { @@ -905,7 +905,7 @@ public: void _seq2map(size_t node) { - C4_ASSERT(is_seq(node)); + RYML_ASSERT(is_seq(node)); for(size_t i = first_child(node); i != NONE; i = next_sibling(i)) { NodeData *C4_RESTRICT ch = _p(i); diff --git a/src/c4/yml/writer.hpp b/src/c4/yml/writer.hpp index f45c8227..276d38d5 100644 --- a/src/c4/yml/writer.hpp +++ b/src/c4/yml/writer.hpp @@ -157,7 +157,7 @@ struct WriterBuf template inline void _do_write(const char (&a)[N]) { - C4_ASSERT( ! m_buf.overlaps(a)); + RYML_ASSERT( ! m_buf.overlaps(a)); if(m_pos + N-1 <= m_buf.len) { memcpy(&(m_buf[m_pos]), a, N-1); @@ -168,7 +168,7 @@ struct WriterBuf inline void _do_write(csubstr sp) { if(sp.empty()) return; - C4_ASSERT( ! sp.overlaps(m_buf)); + RYML_ASSERT( ! sp.overlaps(m_buf)); if(m_pos + sp.len <= m_buf.len) { memcpy(&(m_buf[m_pos]), sp.str, sp.len);