//
// Init and free
//
static void adios_copyspec_init_from_bufs(adios_subvolume_copy_spec *copy_spec,
int ndim, const uint64_t *subv_dims,
const uint64_t *dst_dims,
const uint64_t *dst_subv_offsets,
const uint64_t *src_dims,
const uint64_t *src_subv_offsets) {
const int dimsize = ndim * sizeof(uint64_t);
copy_spec->ndim = ndim;
copy_spec->subv_dims = subv_dims ? bufdup(subv_dims, 1, dimsize) : malloc(dimsize);
copy_spec->dst_dims = dst_dims ? bufdup(dst_dims, 1, dimsize) : malloc(dimsize);
copy_spec->dst_subv_offsets = dst_subv_offsets ? bufdup(dst_subv_offsets, 1, dimsize) : malloc(dimsize);
copy_spec->src_dims = src_dims ? bufdup(src_dims, 1, dimsize) : malloc(dimsize);
copy_spec->src_subv_offsets = src_subv_offsets ? bufdup(src_subv_offsets, 1, dimsize) : malloc(dimsize);
}
/* bufset • safely assigns a buffer to another */
void
bufset(struct buf **dest, struct buf *src) {
if (src) {
if (!src->asize) src = bufdup(src, 1);
else src->ref += 1; }
bufrelease(*dest);
*dest = src; }
int adios_transform_copy_var_transform(struct adios_var_struct *dst_var, const struct adios_var_struct *src_var) {
adios_transform_init_transform_var(dst_var);
// Clean out the "none" transform spec added in adios_transform_init_transform_var
if (dst_var->transform_spec)
adios_transform_free_spec(&dst_var->transform_spec);
// Copy simple fields
dst_var->transform_type = src_var->transform_type;
dst_var->pre_transform_type = src_var->pre_transform_type;
// Dereferemce all dimensions, forcing them to be literal values ("rank" fields), as
// required by the function that calls this, adios_copy_var_written().
dereference_dimensions_var(&dst_var->pre_transform_dimensions, src_var->pre_transform_dimensions);
// Copy transform spec structure
if (!dst_var->transform_spec)
dst_var->transform_spec = adios_transform_parse_spec("none", NULL);
adios_transform_spec_copy(dst_var->transform_spec, src_var->transform_spec);
// Copy any transform-specific metadata
dst_var->transform_metadata_len = src_var->transform_metadata_len;
if (src_var->transform_metadata_len && src_var->transform_metadata) {
dst_var->transform_metadata = bufdup(src_var->transform_metadata, 1, src_var->transform_metadata_len);
} else {
dst_var->transform_metadata = 0;
}
return 1;
}
bool sslice_deep_copy(SSlice *dst, SSlice *src) {
char *data = bufdup(src->data, src->len);
if (!data) {
return false;
}
dst->data = data;
dst->len = src->len;
return true;
}
static PyObject *
misaka_render(const char *text, unsigned int extensions,
unsigned int render_flags, char toc_only)
{
struct buf *ib, *ob;
struct mkd_renderer renderer;
/* Input buffer */
ib = bufnew(1);
bufputs(ib, text);
/* Output buffer */
ob = bufnew(ib->size * 1.2);
/* Parse Markdown */
if (toc_only != -1) {
upshtml_toc_renderer(&renderer);
} else {
upshtml_renderer(&renderer, render_flags);
}
ups_markdown(ob, ib, &renderer, extensions);
upshtml_free_renderer(&renderer);
/* Smartypants actions */
if (render_flags & HTML_SMARTYPANTS)
{
struct buf *sb = bufnew(1);
upshtml_smartypants(sb, ob);
ob = bufdup(sb, sb->size); /* Duplicate Smartypants buffer to output buffer */
bufrelease(sb); /* Cleanup Smartypants buffer */
}
/* Append a null terminator to the output buffer and make a Python string */
bufnullterm(ob);
PyObject *html = Py_BuildValue("s", ob->data);
/* Cleanup */
bufrelease(ib);
bufrelease(ob);
return html;
}
// Return a link, an image, or a literal close bracket.
static cmark_node* handle_close_bracket(subject* subj, cmark_node *parent)
{
int initial_pos;
int starturl, endurl, starttitle, endtitle, endall;
int n;
int sps;
cmark_reference *ref;
bool is_image = false;
cmark_chunk url_chunk, title_chunk;
unsigned char *url, *title;
delimiter *opener;
cmark_node *link_text;
cmark_node *inl;
cmark_chunk raw_label;
int found_label;
advance(subj); // advance past ]
initial_pos = subj->pos;
// look through list of delimiters for a [ or !
opener = subj->last_delim;
while (opener) {
if (opener->delim_char == '[' || opener->delim_char == '!') {
break;
}
opener = opener->previous;
}
if (opener == NULL) {
return make_str(cmark_chunk_literal("]"));
}
if (!opener->active) {
// take delimiter off stack
remove_delimiter(subj, opener);
return make_str(cmark_chunk_literal("]"));
}
// If we got here, we matched a potential link/image text.
is_image = opener->delim_char == '!';
link_text = opener->inl_text->next;
// Now we check to see if it's a link/image.
// First, look for an inline link.
if (peek_char(subj) == '(' &&
((sps = scan_spacechars(&subj->input, subj->pos + 1)) > -1) &&
((n = scan_link_url(&subj->input, subj->pos + 1 + sps)) > -1)) {
// try to parse an explicit link:
starturl = subj->pos + 1 + sps; // after (
endurl = starturl + n;
starttitle = endurl + scan_spacechars(&subj->input, endurl);
// ensure there are spaces btw url and title
endtitle = (starttitle == endurl) ? starttitle :
starttitle + scan_link_title(&subj->input, starttitle);
endall = endtitle + scan_spacechars(&subj->input, endtitle);
if (peek_at(subj, endall) == ')') {
subj->pos = endall + 1;
url_chunk = cmark_chunk_dup(&subj->input, starturl, endurl - starturl);
title_chunk = cmark_chunk_dup(&subj->input, starttitle, endtitle - starttitle);
url = cmark_clean_url(&url_chunk);
title = cmark_clean_title(&title_chunk);
cmark_chunk_free(&url_chunk);
cmark_chunk_free(&title_chunk);
goto match;
} else {
goto noMatch;
}
}
// Next, look for a following [link label] that matches in refmap.
// skip spaces
subj->pos = subj->pos + scan_spacechars(&subj->input, subj->pos);
raw_label = cmark_chunk_literal("");
found_label = link_label(subj, &raw_label);
if (!found_label || raw_label.len == 0) {
cmark_chunk_free(&raw_label);
raw_label = cmark_chunk_dup(&subj->input, opener->position,
initial_pos - opener->position - 1);
}
if (!found_label) {
// If we have a shortcut reference link, back up
// to before the spacse we skipped.
subj->pos = initial_pos;
}
ref = cmark_reference_lookup(subj->refmap, &raw_label);
cmark_chunk_free(&raw_label);
if (ref != NULL) { // found
url = bufdup(ref->url);
title = bufdup(ref->title);
goto match;
} else {
goto noMatch;
}
noMatch:
// If we fall through to here, it means we didn't match a link:
remove_delimiter(subj, opener); // remove this opener from delimiter list
subj->pos = initial_pos;
return make_str(cmark_chunk_literal("]"));
match:
inl = opener->inl_text;
inl->type = is_image ? NODE_IMAGE : NODE_LINK;
cmark_chunk_free(&inl->as.literal);
inl->first_child = link_text;
process_emphasis(subj, opener->previous);
inl->as.link.url = url;
inl->as.link.title = title;
inl->next = NULL;
if (link_text) {
cmark_node *tmp;
link_text->prev = NULL;
for (tmp = link_text; tmp->next != NULL; tmp = tmp->next) {
tmp->parent = inl;
}
tmp->parent = inl;
inl->last_child = tmp;
}
parent->last_child = inl;
// process_emphasis will remove this delimiter and all later ones.
// Now, if we have a link, we also want to deactivate earlier link
// delimiters. (This code can be removed if we decide to allow links
// inside links.)
if (!is_image) {
opener = subj->last_delim;
while (opener != NULL) {
if (opener->delim_char == '[') {
if (!opener->active) {
break;
} else {
opener->active = false;
}
}
opener = opener->previous;
}
}
return NULL;
}
/*
* This is a bit complicated because we attempt to stuff everything
* we've already sent that hasn't been acked into this packet, along
* with the new data.
*
* XXX check the endpoint window and MSS to make sure we don't overflow it.
*
*/
static int tcp_send_data(struct tcp_socket *sk, const unsigned char *data, int datalen)
{
unsigned char *pkt;
struct tcphdr *hdr;
struct tcpvec *cur;
unsigned short flags = 0;
unsigned long seqnum;
/* First, enqueue the new data and increment the next seqnum */
if (data && datalen)
tcp_txenqueue(sk, 0, sk->snd_nxt, bufdup(data, datalen), datalen);
for (cur = sk->txqueue, datalen = 0, seqnum = sk->snd_nxt;
cur && (datalen < sk->rcv_max); cur = cur->next) {
if (cur->txcount >= TCP_MAX_RETRIES) {
tcp_changestate(sk, STATE_TIME_WAIT);
tcp_send_fin(sk);
return -1;
}
flags |= cur->flags;
if (cur->seqnum < seqnum)
seqnum = cur->seqnum; /* get the lowest seqnum queued */
datalen += cur->len;
}
dprintf("tcp_send_data: procesing %d queued bytes\n", datalen);
if (!(pkt = RimMalloc(20+datalen)))
return -1;
hdr = (struct tcphdr *)pkt;
hdr->srcport = htons(sk->localport);
hdr->dstport = htons(sk->remoteport);
if (sk->snd_nxt < sk->snd_una)
sk->snd_una = sk->snd_nxt;
hdr->seqnum = htonl(seqnum);
hdr->acknum = htonl(sk->rcv_nxt);
hdr->hdrlen = 5; /* 20 / 4 = 5 */
hdr->reserved1 = hdr->reserved2 = 0;
hdr->cntrlbits = TCPBIT_ACK | flags | (!flags ? TCPBIT_PSH : 0);
hdr->window = htons(TCP_DEFAULT_WINDOW);
hdr->csum = 0;
hdr->urgptr = 0;
for (cur = sk->txqueue, flags = 20; cur; cur = cur->next) {
memcpy(pkt+flags, cur->buf+cur->start, cur->len);
flags += cur->len;
cur->lasttx = RimGetTicks();
cur->txcount++;
}
hdr->csum = tcp_checksum(pkt, (hdr->hdrlen*4)+datalen,
htonl(INTERMOBI_OURIP), htonl(sk->remoteaddr));
ip_send(htonl(sk->remoteaddr), IPPROTO_TCP, pkt, 20+datalen);
RimFree(pkt);
return 0;
}
// Extracts a selection corresponding to the subvolume within the destination buffer
ADIOS_SELECTION * adios_copyspec_to_dst_selection(adios_subvolume_copy_spec *copy_spec) {
return common_read_selection_boundingbox(copy_spec->ndim,
bufdup(copy_spec->dst_subv_offsets, sizeof(uint64_t), copy_spec->ndim),
bufdup(copy_spec->subv_dims, sizeof(uint64_t), copy_spec->ndim));
}
