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