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