/****************** * Public methods * ******************/ bool CanvasX11::reset() { release_fbo(); if (!reset_context()) return false; if (!do_make_current()) return false; if (!supports_gl2()) { Log::error("Glmark2 needs OpenGL(ES) version >= 2.0 to run" " (but version string is: '%s')!\n", glGetString(GL_VERSION)); return false; } glViewport(0, 0, width_, height_); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); clear(); return true; }
/** * fdisk_unref_context: * @cxt: fdisk context * * Deallocates context struct. */ void fdisk_unref_context(struct fdisk_context *cxt) { int i; if (!cxt) return; cxt->refcount--; if (cxt->refcount <= 0) { DBG(CXT, ul_debugobj(cxt, "freeing context %p for %s", cxt, cxt->dev_path)); reset_context(cxt); /* this is sensitive to parent<->child relationship! */ /* deallocate label's private stuff */ for (i = 0; i < cxt->nlabels; i++) { if (!cxt->labels[i]) continue; if (cxt->labels[i]->op->free) cxt->labels[i]->op->free(cxt->labels[i]); else free(cxt->labels[i]); } fdisk_unref_context(cxt->parent); cxt->parent = NULL; free(cxt); } }
SERD_API SerdStatus serd_writer_end_anon(SerdWriter* writer, const SerdNode* node) { if (writer->syntax == SERD_NTRIPLES) { return SERD_SUCCESS; } if (serd_stack_is_empty(&writer->anon_stack)) { fprintf(stderr, "Unexpected end of anonymous node\n"); return SERD_ERR_UNKNOWN; } assert(writer->indent > 0); --writer->indent; serd_writer_write_delim(writer, '\n'); writer->sink("]", 1, writer->stream); reset_context(writer); writer->context = *anon_stack_top(writer); serd_stack_pop(&writer->anon_stack, sizeof(WriteContext)); const bool is_subject = serd_node_equals(node, &writer->context.subject); if (is_subject) { serd_node_free(&writer->context.predicate); writer->context.subject = serd_node_copy(node); writer->context.predicate = SERD_NODE_NULL; } return SERD_SUCCESS; }
static inline gboolean ensure_context_is_wrapped (GstVaapiDisplayEGL * display, EGLContext gl_context) { return (display->egl_context && display->egl_context->base.handle.p == gl_context) || reset_context (display, gl_context); }
SERD_API SerdStatus serd_writer_end_anon(SerdWriter* writer, const SerdNode* node) { if (writer->syntax == SERD_NTRIPLES) { return SERD_SUCCESS; } if (serd_stack_is_empty(&writer->anon_stack) || writer->indent == 0) { w_err(writer, SERD_ERR_UNKNOWN, "unexpected end of anonymous node\n"); return SERD_ERR_UNKNOWN; } --writer->indent; write_sep(writer, SEP_ANON_END); reset_context(writer, true); writer->context = *anon_stack_top(writer); serd_stack_pop(&writer->anon_stack, sizeof(WriteContext)); const bool is_subject = serd_node_equals(node, &writer->context.subject); if (is_subject) { copy_node(&writer->context.subject, node); writer->context.predicate.type = SERD_NOTHING; } return SERD_SUCCESS; }
/* * Free or reset the forall_context: * - if flag del is true: delete * - otherwise, just reset */ static void clear_forall_context(ef_solver_t *solver, bool del) { assert(solver->forall_context != NULL); if (del) { delete_context(solver->forall_context); safe_free(solver->forall_context); solver->forall_context = NULL; } else { reset_context(solver->forall_context); } }
SERD_API SerdStatus serd_writer_finish(SerdWriter* writer) { if (writer->context.subject.buf) { writer->sink(" .\n", 3, writer->stream); } reset_context(writer); return SERD_SUCCESS; }
SERD_API SerdStatus serd_writer_finish(SerdWriter* writer) { if (writer->context.subject.type) { sink(" .\n", 3, writer); } if (writer->style & SERD_STYLE_BULK) { serd_bulk_sink_flush(&writer->bulk_sink); } writer->indent = 0; return reset_context(writer, true); }
static void destroy_parser(struct exmpp_xml_data *edd) { if (edd->parser != NULL) { /* Destroy the parser. */ XML_ParserFree(edd->parser); edd->parser = NULL; /* Reset generic context. */ reset_context(&edd->ctx); } }
SERD_API SerdStatus serd_writer_set_base_uri(SerdWriter* writer, const SerdNode* uri) { if (!serd_env_set_base_uri(writer->env, uri)) { serd_env_get_base_uri(writer->env, &writer->base_uri); if (writer->syntax != SERD_NTRIPLES) { if (writer->context.graph.buf || writer->context.subject.buf) { writer->sink(" .\n\n", 4, writer->stream); reset_context(writer); } writer->sink("@base <", 7, writer->stream); writer->sink(uri->buf, uri->n_bytes, writer->stream); writer->sink("> .\n", 4, writer->stream); } reset_context(writer); return SERD_SUCCESS; } return SERD_ERR_UNKNOWN; }
SERD_API SerdStatus serd_writer_set_base_uri(SerdWriter* writer, const SerdNode* uri) { if (!serd_env_set_base_uri(writer->env, uri)) { serd_env_get_base_uri(writer->env, &writer->base_uri); if (writer->syntax != SERD_NTRIPLES) { if (writer->context.graph.type || writer->context.subject.type) { sink(" .\n\n", 4, writer); reset_context(writer, false); } sink("@base <", 7, writer); sink(uri->buf, uri->n_bytes, writer); sink("> .\n", 4, writer); } writer->indent = 0; return reset_context(writer, false); } return SERD_ERR_UNKNOWN; }
SERD_API SerdStatus serd_writer_set_prefix(SerdWriter* writer, const SerdNode* name, const SerdNode* uri) { if (!serd_env_set_prefix(writer->env, name, uri)) { if (writer->syntax != SERD_NTRIPLES) { if (writer->context.graph.type || writer->context.subject.type) { sink(" .\n\n", 4, writer); reset_context(writer, false); } sink("@prefix ", 8, writer); sink(name->buf, name->n_bytes, writer); sink(": <", 3, writer); write_uri(writer, uri->buf, uri->n_bytes); sink("> .\n", 4, writer); } writer->indent = 0; return reset_context(writer, false); } return SERD_ERR_UNKNOWN; }
SERD_API SerdStatus serd_writer_set_prefix(SerdWriter* writer, const SerdNode* name, const SerdNode* uri) { if (!serd_env_set_prefix(writer->env, name, uri)) { if (writer->syntax != SERD_NTRIPLES) { if (writer->context.graph.buf || writer->context.subject.buf) { writer->sink(" .\n\n", 4, writer->stream); reset_context(writer); } writer->sink("@prefix ", 8, writer->stream); writer->sink(name->buf, name->n_bytes, writer->stream); writer->sink(": <", 3, writer->stream); write_text(writer, WRITE_URI, uri->buf, uri->n_bytes, '>'); writer->sink("> .\n", 4, writer->stream); } reset_context(writer); return SERD_SUCCESS; } return SERD_ERR_UNKNOWN; }
/** * fdisk_context_assign_device: * @fname: path to the device to be handled * @readonly: how to open the device * * If the @readonly flag is set to false, fdisk will attempt to open * the device with read-write mode and will fallback to read-only if * unsuccessful. * * Returns: 0 on success, < 0 on error. */ int fdisk_context_assign_device(struct fdisk_context *cxt, const char *fname, int readonly) { int fd; DBG(CONTEXT, dbgprint("assigning device %s", fname)); assert(cxt); reset_context(cxt); if (readonly == 1 || (fd = open(fname, O_RDWR|O_CLOEXEC)) < 0) { if ((fd = open(fname, O_RDONLY|O_CLOEXEC)) < 0) return -errno; readonly = 1; } cxt->dev_fd = fd; cxt->dev_path = strdup(fname); if (!cxt->dev_path) goto fail; fdisk_discover_topology(cxt); fdisk_discover_geometry(cxt); if (fdisk_read_firstsector(cxt) < 0) goto fail; /* detect labels and apply labes specific stuff (e.g geomery) * to the context */ fdisk_probe_labels(cxt); /* let's apply user geometry *after* label prober * to make it possible to override in-label setting */ fdisk_apply_user_device_properties(cxt); /* warn about obsolete stuff on the device if we aren't in * list-only mode and there is not PT yet */ if (!fdisk_context_listonly(cxt) && !fdisk_dev_has_disklabel(cxt)) warn_wipe(cxt); DBG(CONTEXT, dbgprint("context %p initialized for %s [%s]", cxt, fname, readonly ? "READ-ONLY" : "READ-WRITE")); return 0; fail: DBG(CONTEXT, dbgprint("failed to assign device")); return -errno; }
/*Each thread will called this function*/ void *worker_compress(void *arg) { int ret, jdx; uint32_t count = 0; uint32_t point = 0; char header[128] = { 0 }; ctx_t ctx1; margs_t *args = (margs_t *) arg; ctx_t *ctx = &(args->nums); file_container_t *fnames = args->fnames; int idx = args->idx; int bitsToLoss = args->bitsToLoss; sprintf(header, "thread %d", idx); init_context(&ctx1); point = fnames->size / 10 + 1; if (point < 10) { point = 10; } while (get_next_file(fnames, &jdx) > -1) { reset_context(&ctx1); ret = zip_compress(&ctx1, fnames->srcs[jdx], fnames->dsts[jdx], bitsToLoss); if (ret != 0) { continue; } print_context_info(&ctx1, "Context Info in Worker Compress"); update_context(ctx, &ctx1); count += 1; if (count % point == 0) { //print the speeds for all the files //ctx_print_more(ctx, header); print_context_info(ctx, header); } } return 0; }
static void destroy_parser(struct exmpp_xml_data *edd) { if (edd->parser != NULL) { /* Destroy the parser. */ XML_ParserFree(edd->parser); edd->parser = NULL; /* Reset generic context. */ reset_context(&edd->ctx); /* Reset the declared_nss list. */ if (edd->declared_nss != NULL) edd->declared_nss->index = 0; } }
void *worker_uncompress(void *arg) { int ret, file_idx; uint32_t count = 0; uint32_t point = 0; char header[128] = { 0 }; ctx_t ctx2; margs_t *args = (margs_t *) arg; ctx_t *ctx = &(args->nums); file_container_t *fnames = args->fnames; int idx = args->idx; sprintf(header, "thread %d", idx); init_context(&ctx2); point = fnames->size / 10 + 1; if (point < 10) { point = 10; } while (get_next_file(fnames, &file_idx) > -1) { reset_context(&ctx2); ret = zip_uncompress(&ctx2, fnames->srcs[file_idx], fnames->dsts[file_idx]); if (ret != 0) { continue; } count += 1; //print the speeds for current file print_context_info(&ctx2, "Context Info in Worker Uncompress"); update_context(ctx, &ctx2); if (count % point == 0) { print_context_info(ctx, header); } } return 0; }
/** * fdisk_free_context: * @cxt: fdisk context * * Deallocates context struct. */ void fdisk_free_context(struct fdisk_context *cxt) { int i; if (!cxt) return; DBG(CONTEXT, dbgprint("freeing context %p for %s", cxt, cxt->dev_path)); reset_context(cxt); /* deallocate label's private stuff */ for (i = 0; i < cxt->nlabels; i++) { if (!cxt->labels[i]) continue; if (cxt->labels[i]->op->free) cxt->labels[i]->op->free(cxt->labels[i]); else free(cxt->labels[i]); } free(cxt); }
/** * fdisk_unref_context: * @cxt: fdisk context * * Deallocates context struct. */ void fdisk_unref_context(struct fdisk_context *cxt) { int i; if (!cxt) return; cxt->refcount--; if (cxt->refcount <= 0) { DBG(CXT, ul_debugobj(cxt, "freeing context %p for %s", cxt, cxt->dev_path)); reset_context(cxt); /* deallocate label's private stuff */ for (i = 0; i < cxt->nlabels; i++) { if (!cxt->labels[i]) continue; if (cxt->labels[i]->op->free) cxt->labels[i]->op->free(cxt->labels[i]); else free(cxt->labels[i]); } free(cxt); } }
static int exmpp_xml_control(ErlDrvData drv_data, unsigned int command, char *buf, int len, char **rbuf, int rlen) { struct exmpp_xml_data *edd; ei_x_buff *to_return; ErlDrvBinary *bin; int size, ret; edd = (struct exmpp_xml_data *)drv_data; size = 0; bin = NULL; to_return = NULL; switch (command) { /* * Parsing. */ case COMMAND_PARSE: case COMMAND_PARSE_FINAL: if (edd->parser == NULL) { /* Start a parser. */ if (create_parser(edd) != 0) { to_return = exmpp_new_xbuf(); if (to_return == NULL) return (-1); ret = RET_ERROR; ei_x_encode_atom(to_return, "parser_setup_failed"); break; } } /* Control the total size of data to parse. */ if (!is_data_size_under_limit(&edd->ctx, len)) { to_return = exmpp_new_xbuf(); if (to_return == NULL) return (-1); ret = RET_ERROR; ei_x_encode_atom(to_return, "stanza_too_big"); break; } /* Run XML document parsing. */ ret = XML_Parse(edd->parser, buf, len, command == COMMAND_PARSE_FINAL); if (!ret) { enum XML_Error errcode; const char *errmsg; /* An error occured during parsing; most probably, * XML wasn't well-formed. */ errcode = XML_GetErrorCode(edd->parser); errmsg = XML_ErrorString(errcode); to_return = exmpp_new_xbuf(); if (to_return == NULL) return (-1); ret = RET_ERROR; ei_x_encode_tuple_header(to_return, 2); ei_x_encode_atom(to_return, "parsing_failed"); ei_x_encode_tuple_header(to_return, 2); ei_x_encode_long(to_return, errcode); ei_x_encode_string(to_return, errmsg); break; } /* Return the complete tree(s). */ ret = RET_OK; if (edd->ctx.complete_trees_ready) { /* Terminate the complete trees list. */ ei_x_encode_empty_list(edd->ctx.complete_trees); to_return = edd->ctx.complete_trees; size = 1 + to_return->index; bin = driver_alloc_binary(size); if (bin == NULL) return (-1); bin->orig_bytes[0] = (char)ret; memcpy(bin->orig_bytes + 1, to_return->buff, to_return->index); } else { /* We need more data to produce a tree. */ to_return = exmpp_new_xbuf(); if (to_return == NULL) return (-1); ei_x_encode_atom(to_return, command == COMMAND_PARSE ? "continue" : "done"); } if (command == COMMAND_PARSE) { /* Update the size of processed data. */ add_data_size(&edd->ctx, len); /* Reset the complete trees list. */ reset_complete_trees(&edd->ctx); } else { /* We're done with the parser. */ destroy_parser(edd); } break; case COMMAND_RESET_PARSER: if (edd->parser != NULL) { reset_context(&edd->ctx); XML_ParserReset(edd->parser, "UTF-8"); init_parser(edd); } ret = RET_OK; break; /* * Misc. */ case COMMAND_PORT_REVISION: /* Store the revision in the buffer. */ to_return = exmpp_new_xbuf(); if (to_return == NULL) return (-1); ret = RET_OK; ei_x_encode_string(to_return, "$Revision$"); break; default: /* Other commands are handled in 'exmpp_xml.c' */ to_return = exmpp_new_xbuf(); if (to_return == NULL) return (-1); ret = control(&edd->ctx, command, buf, to_return); if (ret < 0) return (-1); } if (bin == NULL) { if (to_return != NULL) { size = 1 + to_return->index; bin = driver_alloc_binary(size); if (bin == NULL) return (-1); bin->orig_bytes[0] = (char)ret; if (to_return->index > 0) memcpy(bin->orig_bytes + 1, to_return->buff, to_return->index); exmpp_free_xbuf(to_return); } else { /* The command called doesn't return anything. */ size = 1; bin = driver_alloc_binary(size); bin->orig_bytes[0] = RET_OK; } } /* Set the returned buffer. */ *rbuf = (char *)bin; /* Return the size of this buffer. */ return (size); }
/** * fdisk_assign_device: * @cxt: context * @fname: path to the device to be handled * @readonly: how to open the device * * Open the device, discovery topology, geometry, detect disklabel and switch * the current label driver to reflect the probing result. * * Note that this function resets all generic setting in context. If the @cxt * is nested context then the device is assigned to the parental context and * necessary properties are copied to the @cxt. The change is propagated in * child->parent direction only. It's impossible to use a different device for * primary and nested contexts. * * Returns: 0 on success, < 0 on error. */ int fdisk_assign_device(struct fdisk_context *cxt, const char *fname, int readonly) { int fd; DBG(CXT, ul_debugobj(cxt, "assigning device %s", fname)); assert(cxt); /* redirect request to parent */ if (cxt->parent) { int rc, org = fdisk_is_listonly(cxt->parent); /* assign_device() is sensitive to "listonly" mode, so let's * follow the current context setting for the parent to avoid * unwanted extra warnings. */ fdisk_enable_listonly(cxt->parent, fdisk_is_listonly(cxt)); rc = fdisk_assign_device(cxt->parent, fname, readonly); fdisk_enable_listonly(cxt->parent, org); if (!rc) rc = init_nested_from_parent(cxt, 0); if (!rc) fdisk_probe_labels(cxt); return rc; } reset_context(cxt); fd = open(fname, (readonly ? O_RDONLY : O_RDWR ) | O_CLOEXEC); if (fd < 0) return -errno; cxt->readonly = readonly; cxt->dev_fd = fd; cxt->dev_path = strdup(fname); if (!cxt->dev_path) goto fail; fdisk_discover_topology(cxt); fdisk_discover_geometry(cxt); if (fdisk_read_firstsector(cxt) < 0) goto fail; /* detect labels and apply labes specific stuff (e.g geomery) * to the context */ fdisk_probe_labels(cxt); /* let's apply user geometry *after* label prober * to make it possible to override in-label setting */ fdisk_apply_user_device_properties(cxt); /* warn about obsolete stuff on the device if we aren't in * list-only mode and there is not PT yet */ if (!fdisk_is_listonly(cxt) && !fdisk_has_label(cxt)) warn_wipe(cxt); DBG(CXT, ul_debugobj(cxt, "initialized for %s [%s]", fname, readonly ? "READ-ONLY" : "READ-WRITE")); return 0; fail: DBG(CXT, ul_debugobj(cxt, "failed to assign device")); return -errno; }
static inline gboolean ensure_context (GstVaapiDisplayEGL * display) { return display->egl_context || reset_context (display, EGL_NO_CONTEXT); }
void set_nodes(const std::string &aNS, const std::initializer_list<const xml::context::entry_ref> &entries, buffer::match_type match=buffer::match_case) { mNodes.set(aNS, entries, match); reset_context(); }
void set_attrs(const ns &aNS, const std::initializer_list<const xml::context::entry_ref> &entries, buffer::match_type match=buffer::match_case) { mAttrs.set(aNS, entries, match); reset_context(); }
SERD_API SerdStatus serd_writer_write_statement(SerdWriter* writer, SerdStatementFlags flags, const SerdNode* graph, const SerdNode* subject, const SerdNode* predicate, const SerdNode* object, const SerdNode* datatype, const SerdNode* lang) { if (!subject || !predicate || !object || !subject->buf || !predicate->buf || !object->buf || !is_resource(subject) || !is_resource(predicate)) { return SERD_ERR_BAD_ARG; } #define TRY(write_result) \ if (!write_result) { \ return SERD_ERR_UNKNOWN; \ } switch (writer->syntax) { case SERD_NTRIPLES: TRY(write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags)); sink(" ", 1, writer); TRY(write_node(writer, predicate, NULL, NULL, FIELD_PREDICATE, flags)); sink(" ", 1, writer); TRY(write_node(writer, object, datatype, lang, FIELD_OBJECT, flags)); sink(" .\n", 3, writer); return SERD_SUCCESS; default: break; } if ((flags & SERD_LIST_CONT)) { if (write_list_obj(writer, flags, predicate, object, datatype, lang)) { // Reached end of list if (--writer->list_depth == 0 && writer->list_subj.type) { reset_context(writer, true); writer->context.subject = writer->list_subj; writer->list_subj = SERD_NODE_NULL; } return SERD_SUCCESS; } } else if (serd_node_equals(subject, &writer->context.subject)) { if (serd_node_equals(predicate, &writer->context.predicate)) { // Abbreviate S P if (!(flags & SERD_ANON_O_BEGIN)) { ++writer->indent; } write_sep(writer, SEP_END_O); write_node(writer, object, datatype, lang, FIELD_OBJECT, flags); if (!(flags & SERD_ANON_O_BEGIN)) { --writer->indent; } } else { // Abbreviate S Sep sep = writer->context.predicate.type ? SEP_END_P : SEP_S_P; write_sep(writer, sep); write_pred(writer, flags, predicate); write_node(writer, object, datatype, lang, FIELD_OBJECT, flags); } } else { // No abbreviation if (writer->context.subject.type) { assert(writer->indent > 0); --writer->indent; if (serd_stack_is_empty(&writer->anon_stack)) { write_sep(writer, SEP_END_S); } } else if (!writer->empty) { write_sep(writer, SEP_S_P); } if (!(flags & SERD_ANON_CONT)) { write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags); ++writer->indent; write_sep(writer, SEP_S_P); } else { ++writer->indent; } reset_context(writer, true); copy_node(&writer->context.subject, subject); if (!(flags & SERD_LIST_S_BEGIN)) { write_pred(writer, flags, predicate); } write_node(writer, object, datatype, lang, FIELD_OBJECT, flags); } if (flags & (SERD_ANON_S_BEGIN|SERD_ANON_O_BEGIN)) { WriteContext* ctx = (WriteContext*)serd_stack_push( &writer->anon_stack, sizeof(WriteContext)); *ctx = writer->context; WriteContext new_context = { serd_node_copy(graph), serd_node_copy(subject), SERD_NODE_NULL }; if ((flags & SERD_ANON_S_BEGIN)) { new_context.predicate = serd_node_copy(predicate); } writer->context = new_context; } else { copy_node(&writer->context.graph, graph); copy_node(&writer->context.subject, subject); copy_node(&writer->context.predicate, predicate); } return SERD_SUCCESS; }
SERD_API SerdStatus serd_writer_write_statement(SerdWriter* writer, SerdStatementFlags flags, const SerdNode* graph, const SerdNode* subject, const SerdNode* predicate, const SerdNode* object, const SerdNode* object_datatype, const SerdNode* object_lang) { assert(subject && predicate && object); switch (writer->syntax) { case SERD_NTRIPLES: write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags); writer->sink(" ", 1, writer->stream); write_node(writer, predicate, NULL, NULL, FIELD_PREDICATE, flags); writer->sink(" ", 1, writer->stream); if (!write_node(writer, object, object_datatype, object_lang, FIELD_OBJECT, flags)) { return SERD_ERR_UNKNOWN; } writer->sink(" .\n", 3, writer->stream); return SERD_SUCCESS; case SERD_TURTLE: break; } if (serd_node_equals(subject, &writer->context.subject)) { if (serd_node_equals(predicate, &writer->context.predicate)) { // Abbreviate S P if ((flags & SERD_ANON_O_BEGIN)) { writer->sink(" , ", 3, writer->stream); // ] , [ } else { ++writer->indent; serd_writer_write_delim(writer, ','); } write_node(writer, object, object_datatype, object_lang, FIELD_OBJECT, flags); if (!(flags & SERD_ANON_O_BEGIN)) { --writer->indent; } } else { // Abbreviate S if (writer->context.predicate.buf) { serd_writer_write_delim(writer, ';'); } else { serd_writer_write_delim(writer, '\n'); } write_node(writer, predicate, NULL, NULL, FIELD_PREDICATE, flags); if (writer->context.predicate.buf) serd_node_free(&writer->context.predicate); writer->context.predicate = serd_node_copy(predicate); writer->sink(" ", 1, writer->stream); write_node(writer, object, object_datatype, object_lang, FIELD_OBJECT, flags); } } else { if (writer->context.subject.buf) { if (writer->indent > 0) { --writer->indent; } if (serd_stack_is_empty(&writer->anon_stack)) { serd_writer_write_delim(writer, '.'); serd_writer_write_delim(writer, '\n'); } } else if (!writer->empty) { serd_writer_write_delim(writer, '\n'); } if (!(flags & SERD_ANON_CONT)) { write_node(writer, subject, NULL, NULL, FIELD_SUBJECT, flags); ++writer->indent; if (!(flags & SERD_ANON_S_BEGIN)) { serd_writer_write_delim(writer, '\n'); } } else { ++writer->indent; } reset_context(writer); writer->context.subject = serd_node_copy(subject); writer->context.predicate = SERD_NODE_NULL; write_node(writer, predicate, NULL, NULL, FIELD_PREDICATE, flags); writer->context.predicate = serd_node_copy(predicate); writer->sink(" ", 1, writer->stream); write_node(writer, object, object_datatype, object_lang, FIELD_OBJECT, flags); } if (writer->syntax != SERD_NTRIPLES && ((flags & SERD_ANON_S_BEGIN) || (flags & SERD_ANON_O_BEGIN))) { WriteContext* ctx = (WriteContext*)serd_stack_push( &writer->anon_stack, sizeof(WriteContext)); *ctx = writer->context; writer->context = WRITE_CONTEXT_NULL; // Prevent deletion... } const WriteContext new_context = { serd_node_copy(graph), serd_node_copy(subject), serd_node_copy(predicate) }; reset_context(writer); // ... here writer->context = new_context; return SERD_SUCCESS; }