Mirrors/rapidyaml
0
0
Fork 0
mirror of https://github.com/biojppm/rapidyaml.git synced 2026-01-18 13:31:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

use RYML_ASSERT() instead of C4_ASSERT()

Browse Source
This commit is contained in:
Joao Paulo Magalhaes
2020-02-10 03:11:06 +01:00
parent 4bf3243cd5
commit e318211893
11 changed files with 374 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.lgtm.yml Normal file
View File

@@ -0,0 +1,2 @@
queries:
- exclude: cpp/unsigned-comparison-zero

2
src/c4/yml/common.hpp
View File

@@ -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);
}
};

2
src/c4/yml/detail/print.hpp
View File

@@ -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))
{

50
src/c4/yml/detail/stack.hpp
View File

@@ -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<T, N>::reserve(size_t sz)
template<class T, size_t N>
void stack<T, N>::_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<T, N>::_free()
}
else
{
C4_ASSERT(m_capacity == N);
RYML_ASSERT(m_capacity == N);
}
}
@@ -188,15 +188,15 @@ void stack<T, N>::_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<T, N>::_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<T, N>::_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;

12
src/c4/yml/emit.def.hpp
View File

@@ -41,7 +41,7 @@ template<class Writer>
void Emitter<Writer>::_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<Writer>::_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<Writer>::_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<Writer>::_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<Writer>::_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(' ');

82
src/c4/yml/node.hpp
View File

@@ -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<class T>
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<class T>
inline NodeRef const& operator>> (Key<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);
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:

240
src/c4/yml/parse.cpp
View File

@@ -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)
{

6
src/c4/yml/parse.hpp
View File

@@ -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;

210
src/c4/yml/tree.cpp
View File

@@ -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};
}

134
src/c4/yml/tree.hpp
View File

@@ -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);

4
src/c4/yml/writer.hpp
View File

@@ -157,7 +157,7 @@ struct WriterBuf
template<size_t N>
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);