/// Copy constructor.
buffer(buffer const& other)
: capacity_(other.capacity_)
, data_(0)
, size_(other.size_)
{
if (other.is_ref())
{
data_ = other.data_;
}
else if (other.is_small())
{
data_ = small_;
}
else
{
/// large
data_ = (char*)std::malloc(capacity_);
if (data_ == 0)
{
throw std::bad_alloc();
}
}
if (!is_ref())
{
std::memcpy(data_, other.data_, size_);
}
}
void migrate_value(Value* value, Migration* migration)
{
if (is_ref(value)) {
set_term_ref(value, migrate_term_pointer(as_term_ref(value), migration));
} else if (is_block(value)) {
set_block(value, migrate_block_pointer(as_block(value), migration));
} else if (is_list_based(value)) {
migrate_list_value(value, migration);
} else if (is_hashtable(value)) {
Value oldHashtable;
move(value, &oldHashtable);
set_hashtable(value);
Value* hashtable = value;
for (int i=0; i < hashtable_slot_count(&oldHashtable); i++) {
Value* oldKey = hashtable_key_by_index(&oldHashtable, i);
if (oldKey == NULL || is_null(oldKey))
continue;
Value* oldValue = hashtable_value_by_index(&oldHashtable, i);
Value key;
copy(oldKey, &key);
migrate_value(&key, migration);
Value* newValue = hashtable_insert(hashtable, &key);
copy(oldValue, newValue);
migrate_value(newValue, migration);
}
}
}
void update_all_code_references_in_value(caValue* value, Branch* oldBranch, Branch* newBranch)
{
for (ValueIterator it(value); it.unfinished(); it.advance()) {
caValue* val = *it;
if (is_ref(val)) {
set_term_ref(val, translate_term_across_branches(as_term_ref(val),
oldBranch, newBranch));
} else if (is_branch(val)) {
// If this is just a reference to 'oldBranch' then simply update it to 'newBranch'.
if (as_branch(val) == oldBranch)
set_branch(val, newBranch);
// Noop on null branch.
if (as_branch(val) == NULL)
continue;
// Noop if branch has no owner.
Term* oldTerm = as_branch(val)->owningTerm;
if (oldTerm == NULL)
continue;
Term* newTerm = translate_term_across_branches(oldTerm, oldBranch, newBranch);
if (newTerm == NULL) {
set_branch(val, NULL);
continue;
}
set_branch(val, newTerm->nestedContents);
}
}
}
BIF_RETTYPE is_reference_1(BIF_ALIST_1)
{
if (is_ref(BIF_ARG_1)) {
BIF_RET(am_true);
}
BIF_RET(am_false);
}
/// Assignment.
buffer& operator=(buffer const& rhs)
{
if (this != &rhs)
{
if (rhs.is_ref())
{
dealloc();
capacity_ = 0;
data_ = rhs.data_;
}
else if (rhs.is_small())
{
dealloc();
capacity_ = RESP_SMALL_BUFFER_SIZE;
data_ = small_;
}
else
{
/// rhs is large
if (rhs.capacity_ > capacity_)
{
if (is_ref() || is_small())
{
data_ = 0;
}
data_ = (char*)std::realloc(data_, rhs.capacity_);
if (data_ == 0)
{
throw std::bad_alloc();
}
capacity_ = rhs.capacity_;
}
}
size_ = rhs.size_;
if (!is_ref())
{
std::memcpy(data_, rhs.data_, size_);
}
}
return *this;
}
bool plComponentBase::IsCurMsgLocal()
{
// Was the last notification a message propagated up from a target?
// Ignore it if so.
if (fTargsPB->LastNotifyParamID() != -1)
return false;
// Was the last notification from a ref in the component PB? If so, assume
// it was a propagated message from the ref. Real changes to that ref
// parameter will be signalled with a user ref message.
if (fCompPB->LastNotifyParamID() != -1)
{
ParamID id = fCompPB->LastNotifyParamID();
if (is_ref(fCompPB->GetParamDef(id)))
return false;
}
return true;
}
/// Reserve memory, may change buffer type(ref, small or large).
void reserve(size_t capacity)
{
if (capacity > capacity_)
{
/// Make capacity % RESP_SMALL_BUFFER_SIZE == 0.
capacity =
capacity % RESP_SMALL_BUFFER_SIZE == 0 ?
capacity : RESP_SMALL_BUFFER_SIZE * (capacity / RESP_SMALL_BUFFER_SIZE + 1);
if (is_ref() || is_small())
{
char const* ptr = data_;
bool is_small_before = is_small();
if (capacity > RESP_SMALL_BUFFER_SIZE)
{
capacity_ = capacity;
data_ = (char*)std::malloc(capacity_);
if (data_ == 0)
{
throw std::bad_alloc();
}
}
else
{
capacity_ = RESP_SMALL_BUFFER_SIZE;
data_ = small_;
}
if (!(is_small_before && is_small()))
{
std::memcpy(data_, ptr, size_);
}
}
else
{
/// large
capacity_ = capacity;
data_ = (char*)std::realloc(data_, capacity_);
}
}
}
int enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term)
{
return is_ref(term);
}
/* markdown • parses the input buffer and renders it into the output buffer */
void
markdown(struct buf *ob, struct buf *ib, const struct mkd_renderer *rndrer) {
struct link_ref *lr;
struct buf *text = bufnew(TEXT_UNIT);
size_t i, beg, end;
struct render rndr;
/* filling the render structure */
if (!rndrer) return;
rndr.make = *rndrer;
if (rndr.make.max_work_stack < 1)
rndr.make.max_work_stack = 1;
arr_init(&rndr.refs, sizeof (struct link_ref));
parr_init(&rndr.work);
for (i = 0; i < 256; i += 1) rndr.active_char[i] = 0;
if ((rndr.make.emphasis || rndr.make.double_emphasis
|| rndr.make.triple_emphasis)
&& rndr.make.emph_chars)
for (i = 0; rndr.make.emph_chars[i]; i += 1)
rndr.active_char[(unsigned char)rndr.make.emph_chars[i]]
= char_emphasis;
if (rndr.make.codespan) rndr.active_char['`'] = char_codespan;
if (rndr.make.linebreak) rndr.active_char['\n'] = char_linebreak;
if (rndr.make.image || rndr.make.link)
rndr.active_char['['] = char_link;
rndr.active_char['<'] = char_langle_tag;
rndr.active_char['\\'] = char_escape;
rndr.active_char['&'] = char_entity;
/* first pass: looking for references, copying everything else */
beg = 0;
while (beg < ib->size) /* iterating over lines */
if (is_ref(ib->data, beg, ib->size, &end, &rndr.refs))
beg = end;
else { /* skipping to the next line */
end = beg;
while (end < ib->size
&& ib->data[end] != '\n' && ib->data[end] != '\r')
end += 1;
/* adding the line body if present */
if (end > beg) bufput(text, ib->data + beg, end - beg);
while (end < ib->size
&& (ib->data[end] == '\n' || ib->data[end] == '\r')) {
/* add one \n per newline */
if (ib->data[end] == '\n'
|| (end + 1 < ib->size
&& ib->data[end + 1] != '\n'))
bufputc(text, '\n');
end += 1; }
beg = end; }
/* sorting the reference array */
if (rndr.refs.size)
qsort(rndr.refs.base, rndr.refs.size, rndr.refs.unit,
cmp_link_ref_sort);
/* adding a final newline if not already present */
if (text->size
&& text->data[text->size - 1] != '\n'
&& text->data[text->size - 1] != '\r')
bufputc(text, '\n');
/* second pass: actual rendering */
if (rndr.make.prolog)
rndr.make.prolog(ob, rndr.make.opaque);
parse_block(ob, &rndr, text->data, text->size);
if (rndr.make.epilog)
rndr.make.epilog(ob, rndr.make.opaque);
/* clean-up */
bufrelease(text);
lr = rndr.refs.base;
for (i = 0; i < rndr.refs.size; i += 1) {
bufrelease(lr[i].id);
bufrelease(lr[i].link);
bufrelease(lr[i].title); }
arr_free(&rndr.refs);
assert(rndr.work.size == 0);
for (i = 0; i < rndr.work.asize; i += 1)
bufrelease(rndr.work.item[i]);
parr_free(&rndr.work); }
/* markdown • parses the input buffer and renders it into the output buffer */
void
ups_markdown(struct buf *ob, struct buf *ib, const struct mkd_renderer *rndrer, unsigned int extensions) {
struct link_ref *lr;
struct buf *text;
size_t i, beg, end;
struct render rndr;
/* filling the render structure */
if (!rndrer)
return;
text = bufnew(TEXT_UNIT);
if (!text)
return;
rndr.make = *rndrer;
arr_init(&rndr.refs, sizeof (struct link_ref));
parr_init(&rndr.work);
for (i = 0; i < 256; i += 1)
rndr.active_char[i] = 0;
if (rndr.make.emphasis || rndr.make.double_emphasis || rndr.make.triple_emphasis) {
rndr.active_char['*'] = char_emphasis;
rndr.active_char['_'] = char_emphasis;
if (extensions & MKDEXT_STRIKETHROUGH)
rndr.active_char['~'] = char_emphasis;
}
if (rndr.make.codespan)
rndr.active_char['`'] = char_codespan;
if (rndr.make.linebreak)
rndr.active_char['\n'] = char_linebreak;
if (rndr.make.image || rndr.make.link)
rndr.active_char['['] = char_link;
rndr.active_char['<'] = char_langle_tag;
rndr.active_char['\\'] = char_escape;
rndr.active_char['&'] = char_entity;
if (extensions & MKDEXT_AUTOLINK) {
rndr.active_char['h'] = char_autolink; // http, https
rndr.active_char['H'] = char_autolink;
rndr.active_char['f'] = char_autolink; // ftp
rndr.active_char['F'] = char_autolink;
rndr.active_char['m'] = char_autolink; // mailto
rndr.active_char['M'] = char_autolink;
}
/* Extension data */
rndr.ext_flags = extensions;
rndr.max_nesting = 16;
/* first pass: looking for references, copying everything else */
beg = 0;
while (beg < ib->size) /* iterating over lines */
if (is_ref(ib->data, beg, ib->size, &end, &rndr.refs))
beg = end;
else { /* skipping to the next line */
end = beg;
while (end < ib->size && ib->data[end] != '\n' && ib->data[end] != '\r')
end += 1;
/* adding the line body if present */
if (end > beg)
expand_tabs(text, ib->data + beg, end - beg);
while (end < ib->size && (ib->data[end] == '\n' || ib->data[end] == '\r')) {
/* add one \n per newline */
if (ib->data[end] == '\n' || (end + 1 < ib->size && ib->data[end + 1] != '\n'))
bufputc(text, '\n');
end += 1;
}
beg = end;
}
/* sorting the reference array */
if (rndr.refs.size)
qsort(rndr.refs.base, rndr.refs.size, rndr.refs.unit, cmp_link_ref_sort);
/* adding a final newline if not already present */
if (!text->size)
goto cleanup;
if (text->data[text->size - 1] != '\n' && text->data[text->size - 1] != '\r')
bufputc(text, '\n');
/* second pass: actual rendering */
if (rndr.make.doc_header)
rndr.make.doc_header(ob, rndr.make.opaque);
parse_block(ob, &rndr, text->data, text->size);
if (rndr.make.doc_footer)
rndr.make.doc_footer(ob, rndr.make.opaque);
/* clean-up */
cleanup:
bufrelease(text);
lr = rndr.refs.base;
for (i = 0; i < (size_t)rndr.refs.size; i += 1) {
bufrelease(lr[i].id);
bufrelease(lr[i].link);
bufrelease(lr[i].title);
}
arr_free(&rndr.refs);
assert(rndr.work.size == 0);
for (i = 0; i < (size_t)rndr.work.asize; i += 1)
bufrelease(rndr.work.item[i]);
parr_free(&rndr.work);
}
bool Type::is_boolifiable() const {
return is_top() || is_primitive() || is_ref();
}
