From bd24b8f6d558bafbbb16d9490ebe3478dbf130bd Mon Sep 17 00:00:00 2001 From: David Robillard Date: Thu, 9 Sep 2021 13:57:43 -0400 Subject: Use more human-readable status codes --- include/serd/serd.h | 53 +++++++++++++++-------------- src/block_dumper.c | 4 +-- src/byte_source.c | 2 +- src/canon.c | 2 +- src/cursor.c | 2 +- src/env.c | 6 ++-- src/env.h | 4 +-- src/input_stream.c | 2 +- src/inserter.c | 2 +- src/log.c | 2 +- src/model.c | 4 +-- src/n3.c | 85 +++++++++++++++++++++++------------------------ src/node.c | 33 +++++++++--------- src/nodes.c | 4 +-- src/output_stream.c | 2 +- src/read_ntriples.c | 75 ++++++++++++++++++----------------------- src/read_utf8.c | 6 ++-- src/reader.c | 18 +++++----- src/reader.h | 7 ++-- src/string.c | 59 +++++++++++++++++--------------- src/writer.c | 27 ++++++++------- test/test_env.c | 4 +-- test/test_log.c | 2 +- test/test_model.c | 14 ++++---- test/test_node.c | 2 +- test/test_overflow.c | 4 +-- test/test_reader.c | 4 +-- test/test_reader_writer.c | 4 +-- test/test_sink.c | 4 +-- test/test_string.c | 6 +++- test/test_writer.c | 16 ++++----- tools/console.c | 20 +++++------ tools/serd-filter.c | 8 ++--- tools/serd-pipe.c | 2 +- tools/serd-sort.c | 4 +-- 35 files changed, 246 insertions(+), 247 deletions(-) diff --git a/include/serd/serd.h b/include/serd/serd.h index 9eb84a6a..b70500c1 100644 --- a/include/serd/serd.h +++ b/include/serd/serd.h @@ -217,24 +217,28 @@ serd_free(void* SERD_NULLABLE ptr); /// Return status code typedef enum { - SERD_SUCCESS, ///< No error - SERD_FAILURE, ///< Non-fatal failure - SERD_ERR_UNKNOWN, ///< Unknown error - SERD_ERR_BAD_SYNTAX, ///< Invalid syntax - SERD_ERR_BAD_ARG, ///< Invalid argument - SERD_ERR_BAD_CURSOR, ///< Use of invalidated cursor - SERD_ERR_NOT_FOUND, ///< Not found - SERD_ERR_ID_CLASH, ///< Encountered clashing blank node IDs - SERD_ERR_BAD_CURIE, ///< Invalid CURIE or unknown namespace prefix - SERD_ERR_INTERNAL, ///< Unexpected internal error - SERD_ERR_OVERFLOW, ///< Stack overflow - SERD_ERR_BAD_TEXT, ///< Invalid text encoding - SERD_ERR_BAD_WRITE, ///< Error writing to file/stream - SERD_ERR_NO_DATA, ///< Unexpected end of input - SERD_ERR_BAD_CALL, ///< Invalid call - SERD_ERR_BAD_URI, ///< Invalid or unresolved URI - SERD_ERR_BAD_INDEX, ///< No optimal model index available - SERD_ERR_INVALID, ///< Invalid data + SERD_SUCCESS, ///< Success + SERD_FAILURE, ///< Non-fatal failure + SERD_UNKNOWN_ERROR, ///< Unknown error + SERD_NO_DATA, ///< Missing input + SERD_OVERFLOW, ///< Insufficient space + + SERD_BAD_ALLOC, ///< Memory allocation failed + SERD_BAD_ARG, ///< Invalid argument + SERD_BAD_CALL, ///< Invalid call + SERD_BAD_CURIE, ///< Invalid CURIE or unknown namespace prefix + SERD_BAD_CURSOR, ///< Use of invalidated cursor + SERD_BAD_EVENT, ///< Invalid event in stream + SERD_BAD_INDEX, ///< No optimal model index available + SERD_BAD_LABEL, ///< Encountered clashing blank node label + SERD_BAD_LITERAL, ///< Invalid literal + SERD_BAD_PATTERN, ///< Invalid statement pattern + SERD_BAD_READ, ///< Error reading from file + SERD_BAD_STACK, ///< Stack overflow + SERD_BAD_SYNTAX, ///< Invalid syntax + SERD_BAD_TEXT, ///< Invalid text encoding + SERD_BAD_URI, ///< Invalid or unresolved URI + SERD_BAD_WRITE, ///< Error writing to file } SerdStatus; /** @@ -255,9 +259,8 @@ typedef struct { /** Number of bytes written or required. - On success, this is the total number of bytes written. On - #SERD_ERR_OVERFLOW, this is the number of bytes of output space that are - required for success. + On success, this is the total number of bytes written. On #SERD_OVERFLOW, + this is the number of bytes of output space that are required for success. */ size_t count; } SerdWriteResult; @@ -674,8 +677,8 @@ typedef enum { Otherwise, it is ignored. @return A result with a `status` and a `count` of bytes written. If the - buffer is too small for the node, then `status` will be #SERD_ERR_OVERFLOW, - and `count` will be set to the number of bytes required to successfully + buffer is too small for the node, then `status` will be #SERD_OVERFLOW, and + `count` will be set to the number of bytes required to successfully construct the node. */ SERD_API @@ -1107,8 +1110,8 @@ serd_get_base64_size(const SerdNode* SERD_NONNULL node); @param buf Buffer where decoded data will be written. @return On success, #SERD_SUCCESS is returned along with the number of bytes - written. If the output buffer is too small, then #SERD_ERR_OVERFLOW is - returned along with the number of bytes required for successful decoding. + written. If the output buffer is too small, then #SERD_OVERFLOW is returned + along with the number of bytes required for successful decoding. */ SERD_API SerdWriteResult diff --git a/src/block_dumper.c b/src/block_dumper.c index 6ffb0013..201b5dbf 100644 --- a/src/block_dumper.c +++ b/src/block_dumper.c @@ -27,7 +27,7 @@ serd_block_dumper_open(SerdBlockDumper* const dumper, const size_t block_size) { if (!block_size) { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } dumper->out = output; @@ -40,7 +40,7 @@ serd_block_dumper_open(SerdBlockDumper* const dumper, } dumper->buf = (char*)serd_allocate_buffer(block_size); - return dumper->buf ? SERD_SUCCESS : SERD_ERR_INTERNAL; + return dumper->buf ? SERD_SUCCESS : SERD_BAD_ALLOC; } void diff --git a/src/byte_source.c b/src/byte_source.c index 47753d83..396e16d0 100644 --- a/src/byte_source.c +++ b/src/byte_source.c @@ -44,7 +44,7 @@ serd_byte_source_page(SerdByteSource* const source) buf[n_read] = '\0'; if (n_read == 0) { source->eof = true; - return (source->in->error(source->in->stream) ? SERD_ERR_UNKNOWN + return (source->in->error(source->in->stream) ? SERD_BAD_READ : SERD_FAILURE); } } diff --git a/src/canon.c b/src/canon.c index 67cf30bf..ac0c91c2 100644 --- a/src/canon.c +++ b/src/canon.c @@ -151,7 +151,7 @@ serd_canon_on_statement(SerdCanonData* const data, exess_strerror(r.status)); if (!lax) { - return SERD_ERR_INVALID; + return SERD_BAD_LITERAL; } } diff --git a/src/cursor.c b/src/cursor.c index 650ac771..1a94142e 100644 --- a/src/cursor.c +++ b/src/cursor.c @@ -186,7 +186,7 @@ serd_cursor_advance(SerdCursor* const cursor) assert(cursor); if (zix_btree_iter_is_end(cursor->iter) || !check_version(cursor)) { - return SERD_ERR_BAD_CURSOR; + return SERD_BAD_CURSOR; } const ZixStatus zst = zix_btree_iter_increment(&cursor->iter); diff --git a/src/env.c b/src/env.c index 0fd603a9..a6f1b5a9 100644 --- a/src/env.c +++ b/src/env.c @@ -206,7 +206,7 @@ serd_env_set_prefix(SerdEnv* const env, } if (!env->base_uri_node) { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } // Resolve potentially relative URI reference to an absolute URI @@ -260,13 +260,13 @@ serd_env_expand_in_place(const SerdEnv* const env, const char* const colon = str ? (const char*)memchr(str, ':', curie.len + 1) : NULL; if (!colon) { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } const size_t name_len = (size_t)(colon - str); const SerdPrefix* const prefix = serd_env_find(env, str, name_len); if (!prefix || !prefix->uri) { - return SERD_ERR_BAD_CURIE; + return SERD_BAD_CURIE; } uri_prefix->buf = prefix->uri ? serd_node_string(prefix->uri) : ""; diff --git a/src/env.h b/src/env.h index cafbeedc..764e036e 100644 --- a/src/env.h +++ b/src/env.h @@ -24,8 +24,8 @@ /** Expand `curie`. - Errors: SERD_ERR_BAD_ARG if `curie` is not valid, or SERD_ERR_BAD_CURIE if - prefix is not defined in `env`. + Errors: SERD_BAD_ARG if `curie` is not valid, or SERD_BAD_CURIE if prefix is + not defined in `env`. */ SerdStatus serd_env_expand_in_place(const SerdEnv* env, diff --git a/src/input_stream.c b/src/input_stream.c index 42dfc6f8..5755ccc3 100644 --- a/src/input_stream.c +++ b/src/input_stream.c @@ -146,5 +146,5 @@ serd_close_input(SerdInputStream* const input) input->stream = NULL; } - return ret ? SERD_ERR_UNKNOWN : SERD_SUCCESS; + return ret ? SERD_BAD_READ : SERD_SUCCESS; } diff --git a/src/inserter.c b/src/inserter.c index 100fc23a..96caf216 100644 --- a/src/inserter.c +++ b/src/inserter.c @@ -68,7 +68,7 @@ serd_inserter_on_statement(SerdInserterData* const data, // Check that every node is expanded so it is context-free for (unsigned i = 0; i < 4; ++i) { if (!can_insert(world, serd_statement_node(statement, (SerdField)i))) { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } } diff --git a/src/log.c b/src/log.c index 16c62860..dd62e5cc 100644 --- a/src/log.c +++ b/src/log.c @@ -129,7 +129,7 @@ serd_vxlogf(const SerdWorld* const world, const int r = vsnprintf(message, sizeof(message), fmt, args); return (r <= 0 || (size_t)r >= sizeof(message)) - ? SERD_ERR_BAD_ARG + ? SERD_BAD_ARG : world->log_func(world->log_handle, level, n_fields, diff --git a/src/model.c b/src/model.c index e6033278..0cf3b842 100644 --- a/src/model.c +++ b/src/model.c @@ -100,7 +100,7 @@ serd_model_drop_index(SerdModel* const model, const SerdStatementOrder order) } if (order == model->default_order) { - return SERD_ERR_BAD_CALL; + return SERD_BAD_CALL; } zix_btree_free(model->indices[order], NULL); @@ -619,7 +619,7 @@ serd_model_add_with_caret(SerdModel* const model, SerdStatement* const statement = serd_statement_new(s, p, o, g, NULL); if (!statement) { - return SERD_ERR_UNKNOWN; + return SERD_BAD_ALLOC; } statement->caret = serd_model_intern_caret(model, caret); diff --git a/src/n3.c b/src/n3.c index 3b12dfec..0ded004d 100644 --- a/src/n3.c +++ b/src/n3.c @@ -107,7 +107,7 @@ read_STRING_LITERAL_LONG(SerdReader* const reader, return r_err(reader, st, "invalid escape `\\%c'", peek_byte(reader)); } } else if (c == EOF) { - st = r_err(reader, SERD_ERR_NO_DATA, "unexpected end of file"); + st = r_err(reader, SERD_NO_DATA, "unexpected end of file"); } else if (c == q) { eat_byte_safe(reader, q); const int q2 = eat_byte_safe(reader, peek_byte(reader)); @@ -136,7 +136,7 @@ read_String(SerdReader* const reader, SerdNode* const node) const int q2 = peek_byte(reader); if (q2 == EOF) { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file"); + return r_err(reader, SERD_BAD_SYNTAX, "unexpected end of file"); } if (q2 != q1) { // Short string (not triple quoted) @@ -146,7 +146,7 @@ read_String(SerdReader* const reader, SerdNode* const node) eat_byte_safe(reader, q2); const int q3 = peek_byte(reader); if (q3 == EOF) { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file"); + return r_err(reader, SERD_BAD_SYNTAX, "unexpected end of file"); } if (q3 != q1) { // Empty short string ("" or '') @@ -171,7 +171,7 @@ read_PERCENT(SerdReader* const reader, SerdNode* const dest) const uint8_t h1 = read_HEX(reader); const uint8_t h2 = read_HEX(reader); if (!h1 || !h2) { - return SERD_ERR_BAD_SYNTAX; + return SERD_BAD_SYNTAX; } if (!(st = push_byte(reader, dest, h1))) { @@ -188,9 +188,8 @@ read_PN_LOCAL_ESC(SerdReader* const reader, SerdNode* const dest) const int c = peek_byte(reader); - return is_PN_LOCAL_ESC(c) - ? push_byte(reader, dest, eat_byte_safe(reader, c)) - : r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid escape"); + return is_PN_LOCAL_ESC(c) ? push_byte(reader, dest, eat_byte_safe(reader, c)) + : r_err(reader, SERD_BAD_SYNTAX, "invalid escape"); } static SerdStatus @@ -277,7 +276,7 @@ read_PN_PREFIX_tail(SerdReader* const reader, SerdNode* const dest) serd_node_string(dest)[serd_node_length(dest) - 1] == '.') { if ((st = read_PN_CHARS(reader, dest))) { return r_err(reader, - st > SERD_FAILURE ? st : SERD_ERR_BAD_SYNTAX, + st > SERD_FAILURE ? st : SERD_BAD_SYNTAX, "prefix ends with `.'"); } } @@ -332,7 +331,7 @@ resolve_IRIREF(SerdReader* const reader, uri = serd_resolve_uri(uri, serd_env_base_uri_view(reader->env)); if (!uri.scheme.len) { return r_err(reader, - SERD_ERR_BAD_SYNTAX, + SERD_BAD_SYNTAX, "failed to resolve relative URI reference <%s>", serd_node_string(dest)); } @@ -340,7 +339,7 @@ resolve_IRIREF(SerdReader* const reader, // Push a new temporary node for constructing the resolved URI SerdNode* const temp = push_node(reader, SERD_URI, "", 0); if (!temp) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } // Write resolved URI to the temporary node @@ -364,7 +363,7 @@ read_IRIREF(SerdReader* const reader, SerdNode** const dest) } if (!(*dest = push_node(reader, SERD_URI, "", 0))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } const size_t string_start_offset = reader->stack.size; @@ -438,7 +437,7 @@ read_0_9(SerdReader* const reader, SerdNode* const str, const bool at_least_one) } if (at_least_one && count == 0) { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected digit"); + return r_err(reader, SERD_BAD_SYNTAX, "expected digit"); } return st; @@ -459,7 +458,7 @@ read_number(SerdReader* const reader, int c = peek_byte(reader); bool has_decimal = false; if (!*dest) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } if (c == '-' || c == '+') { @@ -523,7 +522,7 @@ read_iri(SerdReader* const reader, SerdNode** const dest, bool* const ate_dot) } if (!(*dest = push_node(reader, SERD_LITERAL, "", 0))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } return read_PrefixedName(reader, *dest, true, ate_dot, reader->stack.size); @@ -535,7 +534,7 @@ read_literal(SerdReader* const reader, bool* const ate_dot) { if (!(*dest = push_node(reader, SERD_LITERAL, "", 0))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } SerdStatus st = read_String(reader, *dest); @@ -577,7 +576,7 @@ read_verb(SerdReader* reader, SerdNode** dest) "a", produce that instead. */ if (!(*dest = push_node(reader, SERD_URI, "", 0))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } const size_t string_start_offset = reader->stack.size; @@ -594,7 +593,7 @@ read_verb(SerdReader* reader, SerdNode** dest) serd_stack_pop_to(&reader->stack, orig_stack_size); return ((*dest = push_node(reader, SERD_URI, NS_RDF "type", 47)) ? SERD_SUCCESS - : SERD_ERR_OVERFLOW); + : SERD_BAD_STACK); } if ((st = read_PrefixedName( @@ -602,7 +601,7 @@ read_verb(SerdReader* reader, SerdNode** dest) ate_dot) { *dest = NULL; return r_err( - reader, st > SERD_FAILURE ? st : SERD_ERR_BAD_SYNTAX, "expected verb"); + reader, st > SERD_FAILURE ? st : SERD_BAD_SYNTAX, "expected verb"); } return SERD_SUCCESS; @@ -627,7 +626,7 @@ read_anon(SerdReader* const reader, if (!*dest) { if (!(*dest = blank_id(reader))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } } @@ -644,7 +643,7 @@ read_anon(SerdReader* const reader, TRY(st, read_predicateObjectList(reader, ctx, &ate_dot_in_list)); if (ate_dot_in_list) { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "`.' inside blank"); + return r_err(reader, SERD_BAD_SYNTAX, "`.' inside blank"); } read_ws_star(reader); @@ -683,7 +682,7 @@ read_named_object(SerdReader* const reader, out to actually be "true" or "false", switch it to a boolean literal. */ if (!(*dest = push_node(reader, SERD_URI, "", 0))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } SerdNode* node = *dest; @@ -699,12 +698,12 @@ read_named_object(SerdReader* const reader, node->type = SERD_LITERAL; return push_node(reader, SERD_URI, XSD_BOOLEAN, XSD_BOOLEAN_LEN) ? SERD_SUCCESS - : SERD_ERR_OVERFLOW; + : SERD_BAD_STACK; } // Any other failure is a syntax error if (st) { - st = st > SERD_FAILURE ? st : SERD_ERR_BAD_SYNTAX; + st = st > SERD_FAILURE ? st : SERD_BAD_SYNTAX; return r_err(reader, st, "expected prefixed name or boolean"); } @@ -730,7 +729,7 @@ read_object(SerdReader* const reader, switch (c) { case EOF: case ')': - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected object"); + return r_err(reader, SERD_BAD_SYNTAX, "expected object"); case '$': case '?': st = read_Var(reader, &o); @@ -823,7 +822,7 @@ read_predicateObjectList(SerdReader* const reader, switch (c = peek_byte(reader)) { case EOF: serd_stack_pop_to(&reader->stack, orig_stack_size); - return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file"); + return r_err(reader, SERD_BAD_SYNTAX, "unexpected end of file"); case '.': case ']': case '}': @@ -837,7 +836,7 @@ read_predicateObjectList(SerdReader* const reader, if (!ate_semi) { serd_stack_pop_to(&reader->stack, orig_stack_size); - return r_err(reader, SERD_ERR_BAD_SYNTAX, "missing ';' or '.'"); + return r_err(reader, SERD_BAD_SYNTAX, "missing ';' or '.'"); } } @@ -863,7 +862,7 @@ read_collection(SerdReader* const reader, *dest = end ? reader->rdf_nil : blank_id(reader); if (!*dest) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } if (ctx.subject) { // Reading a collection object @@ -887,7 +886,7 @@ read_collection(SerdReader* const reader, SerdNode* rest = 0; if (!n1) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } ctx.subject = *dest; @@ -951,7 +950,7 @@ read_subject(SerdReader* const reader, } if (ate_dot) { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "subject ends with `.'"); + return r_err(reader, SERD_BAD_SYNTAX, "subject ends with `.'"); } return st; @@ -971,14 +970,14 @@ read_labelOrSubject(SerdReader* const reader, SerdNode** const dest) return st; } *dest = blank_id(reader); - return *dest ? SERD_SUCCESS : SERD_ERR_OVERFLOW; + return *dest ? SERD_SUCCESS : SERD_BAD_STACK; case '_': return read_BLANK_NODE_LABEL(reader, dest, &ate_dot); default: if (!read_iri(reader, dest, &ate_dot)) { return SERD_SUCCESS; } else { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected label or subject"); + return r_err(reader, SERD_BAD_SYNTAX, "expected label or subject"); } } } @@ -1017,7 +1016,7 @@ read_base(SerdReader* const reader, const bool sparql, const bool token) TRY(st, read_IRIREF(reader, &uri)); if (reader->stack.size + sizeof(SerdNode) > reader->stack.buf_size) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } serd_node_zero_pad(uri); @@ -1030,7 +1029,7 @@ read_base(SerdReader* const reader, const bool sparql, const bool token) } if (peek_byte(reader) == '.') { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "full stop after SPARQL BASE"); + return r_err(reader, SERD_BAD_SYNTAX, "full stop after SPARQL BASE"); } return SERD_SUCCESS; @@ -1047,7 +1046,7 @@ read_prefixID(SerdReader* const reader, const bool sparql, const bool token) read_ws_star(reader); SerdNode* name = push_node(reader, SERD_LITERAL, "", 0); if (!name) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } if ((st = read_PN_PREFIX(reader, name)) > SERD_FAILURE) { @@ -1063,7 +1062,7 @@ read_prefixID(SerdReader* const reader, const bool sparql, const bool token) TRY(st, read_IRIREF(reader, &uri)); if (reader->stack.size + sizeof(SerdNode) > reader->stack.buf_size) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } serd_node_zero_pad(name); @@ -1103,8 +1102,7 @@ read_wrappedGraph(SerdReader* const reader, ReadContext* const ctx) } if (read_triples(reader, *ctx, &ate_dot) && s_type != '[') { - return r_err( - reader, SERD_ERR_BAD_SYNTAX, "missing predicate object list"); + return r_err(reader, SERD_BAD_SYNTAX, "missing predicate object list"); } serd_stack_pop_to(&reader->stack, orig_stack_size); @@ -1118,7 +1116,7 @@ read_wrappedGraph(SerdReader* const reader, ReadContext* const ctx) eat_byte_safe(reader, '}'); read_ws_star(reader); if (peek_byte(reader) == '.') { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "graph followed by `.'"); + return r_err(reader, SERD_BAD_SYNTAX, "graph followed by `.'"); } return SERD_SUCCESS; @@ -1146,7 +1144,7 @@ read_turtle_directive(SerdReader* const reader) break; } - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected \"base\" or \"prefix\""); + return r_err(reader, SERD_BAD_SYNTAX, "expected \"base\" or \"prefix\""); } static SerdStatus @@ -1194,7 +1192,7 @@ read_block(SerdReader* const reader, ReadContext* const ctx) read_ws_star(reader); if (peek_byte(reader) == '{') { if (s_type == '(' || (s_type == '[' && !*ctx->flags)) { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid graph name"); + return r_err(reader, SERD_BAD_SYNTAX, "invalid graph name"); } ctx->graph = token; @@ -1203,7 +1201,7 @@ read_block(SerdReader* const reader, ReadContext* const ctx) } if (st) { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected directive or subject"); + return r_err(reader, SERD_BAD_SYNTAX, "expected directive or subject"); } // Our token is really a subject, read some triples @@ -1215,7 +1213,7 @@ read_block(SerdReader* const reader, ReadContext* const ctx) // "Failure" is only allowed for anonymous subjects like "[ ... ] ." if (st && s_type != '[') { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected triples"); + return r_err(reader, SERD_BAD_SYNTAX, "expected triples"); } // Ensure that triples are properly terminated @@ -1244,8 +1242,7 @@ read_n3_statement(SerdReader* const reader) case '{': return (reader->syntax == SERD_TRIG) ? read_wrappedGraph(reader, &ctx) - : r_err( - reader, SERD_ERR_BAD_SYNTAX, "syntax does not support graphs"); + : r_err(reader, SERD_BAD_SYNTAX, "syntax does not support graphs"); default: break; diff --git a/src/node.c b/src/node.c index 550fa732..61a45a03 100644 --- a/src/node.c +++ b/src/node.c @@ -93,9 +93,8 @@ serd_node_malloc(const size_t size) SerdNode* serd_node_try_malloc(const SerdWriteResult r) { - return (r.status && r.status != SERD_ERR_OVERFLOW) - ? NULL - : serd_node_malloc(r.count); + return (r.status && r.status != SERD_OVERFLOW) ? NULL + : serd_node_malloc(r.count); } void @@ -153,7 +152,7 @@ serd_node_construct_simple(const size_t buf_size, { const size_t total_size = sizeof(SerdNode) + serd_node_pad_length(string.len); if (!buf || total_size > buf_size) { - return result(SERD_ERR_OVERFLOW, total_size); + return result(SERD_OVERFLOW, total_size); } SerdNode* const node = (SerdNode*)buf; @@ -221,18 +220,18 @@ serd_node_construct_literal(const size_t buf_size, } if ((flags & SERD_HAS_DATATYPE) && (flags & SERD_HAS_LANGUAGE)) { - return result(SERD_ERR_BAD_ARG, 0); + return result(SERD_BAD_ARG, 0); } if (!meta.len) { - return result(SERD_ERR_BAD_ARG, 0); + return result(SERD_BAD_ARG, 0); } if (((flags & SERD_HAS_DATATYPE) && (!serd_uri_string_has_scheme(meta.buf) || !strcmp(meta.buf, NS_RDF "langString"))) || ((flags & SERD_HAS_LANGUAGE) && !is_langtag(meta))) { - return result(SERD_ERR_BAD_ARG, 0); + return result(SERD_BAD_ARG, 0); } const size_t padded_length = serd_node_pad_length(string.len); @@ -240,7 +239,7 @@ serd_node_construct_literal(const size_t buf_size, const size_t meta_size = sizeof(SerdNode) + serd_node_pad_length(meta.len); const size_t total_size = sizeof(SerdNode) + padded_length + meta_size; if (!buf || total_size > buf_size) { - return result(SERD_ERR_OVERFLOW, total_size); + return result(SERD_OVERFLOW, total_size); } SerdNode* const node = (SerdNode*)buf; @@ -271,7 +270,7 @@ serd_node_construct(const size_t buf_size, return ((type == SERD_LITERAL) ? serd_node_construct_literal(buf_size, buf, string, flags, meta) : (meta.len > 0u) - ? result(SERD_ERR_BAD_ARG, 0) + ? result(SERD_BAD_ARG, 0) : serd_node_construct_token(buf_size, buf, type, string)); } @@ -350,7 +349,7 @@ serd_node_construct_integer(const size_t buf_size, const SerdStringView datatype) { if (datatype.len && !serd_uri_string_has_scheme(datatype.buf)) { - return result(SERD_ERR_BAD_ARG, 0); + return result(SERD_BAD_ARG, 0); } char temp[24] = {0}; @@ -378,7 +377,7 @@ serd_node_construct_base64(const size_t buf_size, // Verify argument sanity if (!value || !value_size || (datatype.len && !serd_uri_string_has_scheme(datatype.buf))) { - return result(SERD_ERR_BAD_ARG, 0); + return result(SERD_BAD_ARG, 0); } // Determine the type to use (default to xsd:base64Binary) @@ -393,7 +392,7 @@ serd_node_construct_base64(const size_t buf_size, const size_t padded_length = serd_node_pad_length(r.count); const size_t total_size = sizeof(SerdNode) + padded_length + type_size; if (!buf || total_size > buf_size) { - return result(SERD_ERR_OVERFLOW, total_size); + return result(SERD_OVERFLOW, total_size); } SerdNode* const node = (SerdNode*)buf; @@ -438,7 +437,7 @@ serd_node_construct_uri(const size_t buf_size, const size_t length = serd_uri_string_length(uri); const size_t required_size = sizeof(SerdNode) + serd_node_pad_length(length); if (!buf || buf_size < required_size) { - return result(SERD_ERR_OVERFLOW, required_size); + return result(SERD_OVERFLOW, required_size); } // Write node header @@ -464,7 +463,7 @@ serd_node_new(const SerdNodeType type, const SerdStringView meta) { SerdWriteResult r = serd_node_construct(0, NULL, type, string, flags, meta); - if (r.status != SERD_ERR_OVERFLOW) { + if (r.status != SERD_OVERFLOW) { return NULL; } @@ -602,8 +601,8 @@ serd_get_base64(const SerdNode* const node, const ExessVariableResult r = exess_read_base64(buf_size, buf, serd_node_string(node)); - return r.status == EXESS_NO_SPACE ? result(SERD_ERR_OVERFLOW, max_size) - : r.status ? result(SERD_ERR_BAD_SYNTAX, 0u) + return r.status == EXESS_NO_SPACE ? result(SERD_OVERFLOW, max_size) + : r.status ? result(SERD_BAD_SYNTAX, 0u) : result(SERD_SUCCESS, r.write_count); } @@ -749,7 +748,7 @@ serd_node_construct_file_uri(const size_t buf_size, } if (!buf || count > buf_size) { - return result(SERD_ERR_OVERFLOW, count); + return result(SERD_OVERFLOW, count); } node->length = length; diff --git a/src/nodes.c b/src/nodes.c index 5c6492e4..b821c004 100644 --- a/src/nodes.c +++ b/src/nodes.c @@ -352,7 +352,7 @@ serd_nodes_literal(SerdNodes* const nodes, // We need to insert a new entry, so determine how much space the node needs SerdWriteResult r = serd_node_construct_literal(0, NULL, string, flags, meta); - if (r.status != SERD_ERR_OVERFLOW) { + if (r.status != SERD_OVERFLOW) { return NULL; } @@ -487,7 +487,7 @@ serd_nodes_parsed_uri(SerdNodes* const nodes, const SerdURIView uri) // Determine how much space the node needs SerdWriteResult r = serd_node_construct_uri(0u, NULL, uri); - assert(r.status == SERD_ERR_OVERFLOW); // Currently no other errors + assert(r.status == SERD_OVERFLOW); // Currently no other errors // Allocate a new entry to write the URI node into NodesEntry* const entry = new_entry(r.count); diff --git a/src/output_stream.c b/src/output_stream.c index 1254aa4f..7beb5e2f 100644 --- a/src/output_stream.c +++ b/src/output_stream.c @@ -85,5 +85,5 @@ serd_close_output(SerdOutputStream* const output) output->stream = NULL; } - return ret ? SERD_ERR_UNKNOWN : SERD_SUCCESS; + return ret ? SERD_BAD_WRITE : SERD_SUCCESS; } diff --git a/src/read_ntriples.c b/src/read_ntriples.c index c107207d..64c823f6 100644 --- a/src/read_ntriples.c +++ b/src/read_ntriples.c @@ -43,12 +43,12 @@ SerdStatus read_LANGTAG(SerdReader* const reader) { if (!is_alpha(peek_byte(reader))) { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected A-Z or a-z"); + return r_err(reader, SERD_BAD_SYNTAX, "expected A-Z or a-z"); } SerdNode* const node = push_node(reader, SERD_LITERAL, "", 0); if (!node) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } // First component must be all letters @@ -80,7 +80,7 @@ SerdStatus read_EOL(SerdReader* const reader) { if (!is_EOL(peek_byte(reader))) { - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected a line ending"); + return r_err(reader, SERD_BAD_SYNTAX, "expected a line ending"); } while (is_EOL(peek_byte(reader))) { @@ -95,10 +95,8 @@ read_IRI_scheme(SerdReader* const reader, SerdNode* const dest) { int c = peek_byte(reader); if (!is_alpha(c)) { - return r_err(reader, - SERD_ERR_BAD_SYNTAX, - "'%c' is not a valid first IRI character", - c); + return r_err( + reader, SERD_BAD_SYNTAX, "'%c' is not a valid first IRI character", c); } SerdStatus st = SERD_SUCCESS; @@ -110,12 +108,12 @@ read_IRI_scheme(SerdReader* const reader, SerdNode* const dest) st = is_uri_scheme_char(c) ? push_byte(reader, dest, eat_byte_safe(reader, c)) : r_err(reader, - SERD_ERR_BAD_SYNTAX, + SERD_BAD_SYNTAX, "U+%04X is not a valid IRI scheme character", (unsigned)c); } - return st ? st : SERD_ERR_BAD_SYNTAX; + return st ? st : SERD_BAD_SYNTAX; } SerdStatus @@ -128,7 +126,7 @@ read_IRIREF_suffix(SerdReader* const reader, SerdNode* const node) const int c = eat_byte(reader); switch (c) { case EOF: - return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected end of file"); + return r_err(reader, SERD_BAD_SYNTAX, "unexpected end of file"); case ' ': case '"': @@ -139,7 +137,7 @@ read_IRIREF_suffix(SerdReader* const reader, SerdNode* const node) case '|': case '}': return r_err( - reader, SERD_ERR_BAD_SYNTAX, "'%c' is not a valid IRI character", c); + reader, SERD_BAD_SYNTAX, "'%c' is not a valid IRI character", c); case '>': return SERD_SUCCESS; @@ -150,10 +148,8 @@ read_IRIREF_suffix(SerdReader* const reader, SerdNode* const node) } if (!code || code == ' ' || code == '<' || code == '>') { - return r_err(reader, - SERD_ERR_BAD_SYNTAX, - "U+%04X is not a valid IRI character", - code); + return r_err( + reader, SERD_BAD_SYNTAX, "U+%04X is not a valid IRI character", code); } break; @@ -161,7 +157,7 @@ read_IRIREF_suffix(SerdReader* const reader, SerdNode* const node) default: if (c <= 0x20) { st = r_err(reader, - SERD_ERR_BAD_SYNTAX, + SERD_BAD_SYNTAX, "control character U+%04X is not a valid IRI character", (uint32_t)c); @@ -193,7 +189,7 @@ read_IRI(SerdReader* const reader, SerdNode** const dest) eat_byte(reader); if (!(*dest = push_node(reader, SERD_URI, "", 0))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } SerdStatus st = SERD_SUCCESS; @@ -225,10 +221,10 @@ read_STRING_LITERAL(SerdReader* const reader, uint32_t code = 0; switch (c) { case EOF: - return r_err(reader, SERD_ERR_BAD_SYNTAX, "end of file in short string"); + return r_err(reader, SERD_BAD_SYNTAX, "end of file in short string"); case '\n': case '\r': - return r_err(reader, SERD_ERR_BAD_SYNTAX, "line end in short string"); + return r_err(reader, SERD_BAD_SYNTAX, "line end in short string"); case '\\': eat_byte_safe(reader, c); if ((st = read_ECHAR(reader, ref)) && @@ -266,7 +262,7 @@ adjust_blank_id(SerdReader* const reader, char* const buf) } else if (tag == 'B' && reader->seen_genid) { // We've seen both b123 and B123 styles, abort due to possible clashes return r_err(reader, - SERD_ERR_ID_CLASH, + SERD_BAD_LABEL, "found both `b' and `B' blank IDs, prefix required"); } } @@ -289,7 +285,7 @@ read_BLANK_NODE_LABEL(SerdReader* const reader, if (!(*dest = push_node( reader, SERD_BLANK, reader->bprefix, reader->bprefix_len))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } // Read first: (PN_CHARS_U | [0-9]) @@ -376,7 +372,7 @@ read_UCHAR(SerdReader* const reader, length = 4; break; default: - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected 'U' or 'u'"); + return r_err(reader, SERD_BAD_SYNTAX, "expected 'U' or 'u'"); } eat_byte_safe(reader, b); @@ -384,7 +380,7 @@ read_UCHAR(SerdReader* const reader, uint8_t buf[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; for (unsigned i = 0; i < length; ++i) { if (!(buf[i] = read_HEX(reader))) { - return SERD_ERR_BAD_SYNTAX; + return SERD_BAD_SYNTAX; } } @@ -396,7 +392,7 @@ read_UCHAR(SerdReader* const reader, if (!size) { *code_point = 0xFFFD; return (reader->strict - ? r_err(reader, SERD_ERR_BAD_SYNTAX, "U+%X is out of range", code) + ? r_err(reader, SERD_BAD_SYNTAX, "U+%X is out of range", code) : push_bytes(reader, node, replacement_char, 3)); } @@ -430,7 +426,7 @@ read_ECHAR(SerdReader* const reader, SerdNode* const dest) case '\'': return push_byte(reader, dest, eat_byte_safe(reader, c)); default: - return SERD_ERR_BAD_SYNTAX; + return SERD_BAD_SYNTAX; } } @@ -455,12 +451,10 @@ read_PN_CHARS_BASE(SerdReader* const reader, SerdNode* const dest) } if (!is_PN_CHARS_BASE((int)code)) { - r_err(reader, - SERD_ERR_BAD_SYNTAX, - "U+%04X is not a valid name character", - code); + r_err( + reader, SERD_BAD_SYNTAX, "U+%04X is not a valid name character", code); if (reader->strict) { - return SERD_ERR_BAD_SYNTAX; + return SERD_BAD_SYNTAX; } } @@ -492,7 +486,7 @@ read_PN_CHARS(SerdReader* const reader, SerdNode* const dest) SerdStatus st = SERD_SUCCESS; if (c == EOF) { - return SERD_ERR_NO_DATA; + return SERD_NO_DATA; } if (is_alpha(c) || is_digit(c) || c == '_' || c == '-') { @@ -511,10 +505,8 @@ read_PN_CHARS(SerdReader* const reader, SerdNode* const dest) if (!is_PN_CHARS_BASE((int)code) && code != 0xB7 && !(code >= 0x0300 && code <= 0x036F) && !(code >= 0x203F && code <= 0x2040)) { - return r_err(reader, - SERD_ERR_BAD_SYNTAX, - "U+%04X is not a valid name character", - code); + return r_err( + reader, SERD_BAD_SYNTAX, "U+%04X is not a valid name character", code); } return st; @@ -529,7 +521,7 @@ read_HEX(SerdReader* const reader) return (uint8_t)eat_byte_safe(reader, c); } - r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid hexadecimal digit `%c'", c); + r_err(reader, SERD_BAD_SYNTAX, "invalid hexadecimal digit `%c'", c); return 0; } @@ -559,12 +551,11 @@ read_Var(SerdReader* const reader, SerdNode** const dest) assert(peek_byte(reader) == '$' || peek_byte(reader) == '?'); if (!(reader->flags & SERD_READ_VARIABLES)) { - return r_err( - reader, SERD_ERR_BAD_SYNTAX, "syntax does not support variables"); + return r_err(reader, SERD_BAD_SYNTAX, "syntax does not support variables"); } if (!(*dest = push_node(reader, SERD_VARIABLE, "", 0))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } serd_byte_source_advance(reader->source); @@ -595,7 +586,7 @@ read_literal(SerdReader* const reader, SerdNode** const dest) SerdStatus st = SERD_SUCCESS; if (!(*dest = push_node(reader, SERD_LITERAL, "", 0))) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } eat_byte_safe(reader, '"'); @@ -642,7 +633,7 @@ read_nt_subject(SerdReader* const reader, SerdNode** const dest) break; } - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected '<' or '_'"); + return r_err(reader, SERD_BAD_SYNTAX, "expected '<' or '_'"); } /// [4] predicate @@ -675,7 +666,7 @@ read_nt_object(SerdReader* const reader, return read_BLANK_NODE_LABEL(reader, dest, ate_dot); default: - return r_err(reader, SERD_ERR_BAD_SYNTAX, "expected '<', '_', or '\"'"); + return r_err(reader, SERD_BAD_SYNTAX, "expected '<', '_', or '\"'"); } } diff --git a/src/read_utf8.c b/src/read_utf8.c index 614ea14f..34d800cb 100644 --- a/src/read_utf8.c +++ b/src/read_utf8.c @@ -29,13 +29,13 @@ skip_invalid_utf8(SerdReader* const reader) b = peek_byte(reader); } - return reader->strict ? SERD_ERR_BAD_SYNTAX : SERD_FAILURE; + return reader->strict ? SERD_BAD_SYNTAX : SERD_FAILURE; } static SerdStatus bad_char(SerdReader* const reader, const char* const fmt, const uint8_t c) { - r_err(reader, SERD_ERR_BAD_SYNTAX, fmt, c); + r_err(reader, SERD_BAD_SYNTAX, fmt, c); return skip_invalid_utf8(reader); } @@ -55,7 +55,7 @@ read_utf8_continuation_bytes(SerdReader* const reader, for (uint32_t i = 1u; i < *size; ++i) { const int b = peek_byte(reader); if (b == EOF) { - return r_err(reader, SERD_ERR_NO_DATA, "unexpected end of input"); + return r_err(reader, SERD_NO_DATA, "unexpected end of input"); } const uint8_t byte = (uint8_t)b; diff --git a/src/reader.c b/src/reader.c index d051c34a..985a9fd2 100644 --- a/src/reader.c +++ b/src/reader.c @@ -90,9 +90,9 @@ tolerate_status(const SerdReader* const reader, const SerdStatus status) return true; } - if (status == SERD_ERR_INTERNAL || status == SERD_ERR_OVERFLOW || - status == SERD_ERR_BAD_WRITE || status == SERD_ERR_NO_DATA || - status == SERD_ERR_BAD_CALL || status == SERD_ERR_BAD_CURSOR) { + if (status == SERD_BAD_STACK || status == SERD_BAD_WRITE || + status == SERD_NO_DATA || status == SERD_BAD_CALL || + status == SERD_BAD_CURSOR) { return false; } @@ -161,7 +161,7 @@ emit_statement_at(SerdReader* const reader, SerdCaret* const caret) { if (reader->stack.size + (2 * sizeof(SerdNode)) > reader->stack.buf_size) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } /* Zero the pad of the object node on the top of the stack. Lower nodes @@ -198,7 +198,7 @@ serd_reader_read_document(SerdReader* const reader) assert(reader); if (!reader->source) { - return SERD_ERR_BAD_CALL; + return SERD_BAD_CALL; } if (!(reader->flags & SERD_READ_GLOBAL)) { @@ -301,8 +301,8 @@ skip_bom(SerdReader* const me) serd_byte_source_advance(me->source) || serd_byte_source_peek(me->source) != 0xBF || serd_byte_source_advance(me->source)) { - r_err(me, SERD_ERR_BAD_SYNTAX, "corrupt byte order mark"); - return SERD_ERR_BAD_SYNTAX; + r_err(me, SERD_BAD_SYNTAX, "corrupt byte order mark"); + return SERD_BAD_SYNTAX; } } @@ -322,7 +322,7 @@ serd_reader_start(SerdReader* const reader, reader->source = serd_byte_source_new_input(input, input_name, block_size); - return reader->source ? SERD_SUCCESS : SERD_ERR_BAD_ARG; + return reader->source ? SERD_SUCCESS : SERD_BAD_ARG; } static SerdStatus @@ -344,7 +344,7 @@ serd_reader_read_chunk(SerdReader* const reader) SerdStatus st = SERD_SUCCESS; if (!reader->source) { - return SERD_ERR_BAD_CALL; + return SERD_BAD_CALL; } if (!reader->source->prepared) { diff --git a/src/reader.h b/src/reader.h index ecf420f4..a001d843 100644 --- a/src/reader.h +++ b/src/reader.h @@ -146,8 +146,7 @@ eat_byte_check(SerdReader* reader, const int byte) { const int c = peek_byte(reader); if (c != byte) { - return r_err( - reader, SERD_ERR_BAD_SYNTAX, "expected `%c', not `%c'", byte, c); + return r_err(reader, SERD_BAD_SYNTAX, "expected `%c', not `%c'", byte, c); } eat_byte_safe(reader, byte); @@ -174,7 +173,7 @@ push_byte(SerdReader* reader, SerdNode* node, const int c) assert(c != EOF); if (reader->stack.size + 1 > reader->stack.buf_size) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } ((uint8_t*)reader->stack.buf)[reader->stack.size - 1] = (uint8_t)c; @@ -194,7 +193,7 @@ push_bytes(SerdReader* reader, SerdNode* ref, const uint8_t* bytes, size_t len) } } - return has_space ? SERD_SUCCESS : SERD_ERR_OVERFLOW; + return has_space ? SERD_SUCCESS : SERD_BAD_STACK; } #endif // SERD_READER_H diff --git a/src/string.c b/src/string.c index b9885d4f..136cb09c 100644 --- a/src/string.c +++ b/src/string.c @@ -35,38 +35,45 @@ serd_strerror(const SerdStatus status) return "Success"; case SERD_FAILURE: return "Non-fatal failure"; - case SERD_ERR_UNKNOWN: + case SERD_NO_DATA: + return "Unexpected end of input"; + case SERD_UNKNOWN_ERROR: break; - case SERD_ERR_BAD_SYNTAX: - return "Invalid syntax"; - case SERD_ERR_BAD_ARG: + case SERD_OVERFLOW: + return "Insufficient space"; + + case SERD_BAD_ALLOC: + return "Memory allocation failed"; + case SERD_BAD_ARG: return "Invalid argument"; - case SERD_ERR_BAD_CURSOR: - return "Invalid cursor"; - case SERD_ERR_NOT_FOUND: - return "Not found"; - case SERD_ERR_ID_CLASH: - return "Blank node ID clash"; - case SERD_ERR_BAD_CURIE: + case SERD_BAD_CALL: + return "Invalid call"; + case SERD_BAD_CURIE: return "Invalid CURIE or unknown namespace prefix"; - case SERD_ERR_INTERNAL: - return "Internal error"; - case SERD_ERR_OVERFLOW: + case SERD_BAD_CURSOR: + return "Invalid cursor"; + case SERD_BAD_EVENT: + return "Invalid event in stream"; + case SERD_BAD_INDEX: + return "No optimal model index available"; + case SERD_BAD_LABEL: + return "Clashing blank node label"; + case SERD_BAD_LITERAL: + return "Invalid literal"; + case SERD_BAD_PATTERN: + return "Invalid statement pattern"; + case SERD_BAD_READ: + return "Error reading from file"; + case SERD_BAD_STACK: return "Stack overflow"; - case SERD_ERR_BAD_TEXT: + case SERD_BAD_SYNTAX: + return "Invalid syntax"; + case SERD_BAD_TEXT: return "Invalid text encoding"; - case SERD_ERR_BAD_WRITE: - return "Error writing to file"; - case SERD_ERR_NO_DATA: - return "Unexpected end of input"; - case SERD_ERR_BAD_CALL: - return "Invalid call"; - case SERD_ERR_BAD_URI: + case SERD_BAD_URI: return "Invalid or unresolved URI"; - case SERD_ERR_BAD_INDEX: - return "No optimal model index available"; - case SERD_ERR_INVALID: - return "Invalid data"; + case SERD_BAD_WRITE: + return "Error writing to file"; } return "Unknown error"; diff --git a/src/writer.c b/src/writer.c index 7cb28d0a..e19518e4 100644 --- a/src/writer.c +++ b/src/writer.c @@ -191,7 +191,7 @@ push_context(SerdWriter* const writer, const SerdNode* const p) { if (writer->anon_stack_size >= anon_stack_capacity) { - return SERD_ERR_OVERFLOW; + return SERD_BAD_STACK; } const WriteContext new_context = {type, @@ -258,10 +258,10 @@ sink(const void* buf, size_t len, SerdWriter* writer) char message[1024] = {0}; serd_system_strerror(errno, message, sizeof(message)); - w_err(writer, SERD_ERR_BAD_WRITE, "write error (%s)", message); + w_err(writer, SERD_BAD_WRITE, "write error (%s)", message); } else { w_err(writer, - SERD_ERR_BAD_WRITE, + SERD_BAD_WRITE, "unknown write error, %zu / %zu bytes written", written, len); @@ -274,7 +274,7 @@ sink(const void* buf, size_t len, SerdWriter* writer) SERD_WARN_UNUSED_RESULT static SerdStatus esink(const void* buf, size_t len, SerdWriter* writer) { - return sink(buf, len, writer) == len ? SERD_SUCCESS : SERD_ERR_BAD_WRITE; + return sink(buf, len, writer) == len ? SERD_SUCCESS : SERD_BAD_WRITE; } // Write a single character as a Unicode escape @@ -289,8 +289,7 @@ write_character(SerdWriter* writer, const uint32_t c = parse_utf8_char(utf8, size); switch (*size) { case 0: - w_err(writer, SERD_ERR_BAD_TEXT, "invalid UTF-8 start: %X", utf8[0]); - *st = SERD_ERR_BAD_TEXT; + *st = w_err(writer, SERD_BAD_TEXT, "invalid UTF-8 start: %X", utf8[0]); return 0; case 1: snprintf(escape, sizeof(escape), "\\u%04X", utf8[0]); @@ -349,7 +348,7 @@ write_uri(SerdWriter* writer, const char* utf8, size_t n_bytes, SerdStatus* st) const size_t n_bulk = sink(&utf8[i], j - i, writer); len += n_bulk; if (n_bulk != j - i) { - *st = SERD_ERR_BAD_WRITE; + *st = SERD_BAD_WRITE; return len; } @@ -384,7 +383,7 @@ ewrite_uri(SerdWriter* writer, const char* utf8, size_t n_bytes) SerdStatus st = SERD_SUCCESS; write_uri(writer, utf8, n_bytes, &st); - return (st == SERD_ERR_BAD_WRITE || !(writer->flags & SERD_WRITE_LAX)) + return (st == SERD_BAD_WRITE || !(writer->flags & SERD_WRITE_LAX)) ? st : SERD_SUCCESS; } @@ -862,7 +861,7 @@ write_uri_node(SerdWriter* const writer, if (!has_scheme && !supports_uriref(writer) && !serd_env_base_uri(writer->env)) { return w_err(writer, - SERD_ERR_BAD_ARG, + SERD_BAD_ARG, "syntax does not support URI reference <%s>", node_str); } @@ -1211,7 +1210,7 @@ serd_writer_write_statement(SerdWriter* const writer, ((flags & SERD_ANON_O) && (flags & SERD_LIST_O)) || // Nonsense ((flags & SERD_ANON_S) && (flags & SERD_TERSE_S)) || // Unsupported ((flags & SERD_ANON_O) && (flags & SERD_TERSE_O))) { // Unsupported - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } switch (writer->syntax) { @@ -1245,7 +1244,7 @@ serd_writer_end_anon(SerdWriter* writer, const SerdNode* node) if (writer->anon_stack_size == 0) { return w_err(writer, - SERD_ERR_BAD_CALL, + SERD_BAD_EVENT, "unexpected end of anonymous node `%s'", serd_node_string(node)); } @@ -1278,7 +1277,7 @@ serd_writer_on_event(SerdWriter* writer, const SerdEvent* event) return serd_writer_end_anon(writer, event->end.node); } - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } SerdStatus @@ -1361,7 +1360,7 @@ serd_writer_set_base_uri(SerdWriter* writer, const SerdNode* uri) assert(writer); if (uri->type != SERD_URI) { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } SerdStatus st = SERD_SUCCESS; @@ -1405,7 +1404,7 @@ serd_writer_set_prefix(SerdWriter* writer, const SerdNode* uri) { if (name->type != SERD_LITERAL || uri->type != SERD_URI) { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } SerdStatus st = SERD_SUCCESS; diff --git a/test/test_env.c b/test/test_env.c index 58455167..3b6e20c9 100644 --- a/test/test_env.c +++ b/test/test_env.c @@ -99,7 +99,7 @@ test_base_uri(void) // Try setting a relative prefix with no base URI assert(serd_env_set_prefix(env, SERD_STRING("eg.3"), SERD_STRING("rel")) == - SERD_ERR_BAD_ARG); + SERD_BAD_ARG); // Set a valid base URI assert(!serd_env_set_base_uri(env, serd_node_string_view(eg))); @@ -128,7 +128,7 @@ test_set_prefix(void) assert(!serd_env_set_prefix(env, name1, eg)); // Test setting a prefix from a relative URI - assert(serd_env_set_prefix(env, name2, rel) == SERD_ERR_BAD_ARG); + assert(serd_env_set_prefix(env, name2, rel) == SERD_BAD_ARG); assert(!serd_env_set_base_uri(env, base)); assert(!serd_env_set_prefix(env, name2, rel)); diff --git a/test/test_log.c b/test/test_log.c index 88d14dc6..707a00f2 100644 --- a/test/test_log.c +++ b/test/test_log.c @@ -52,7 +52,7 @@ test_bad_arg(void) serd_set_log_func(world, custom_log_func, &called); - assert(serd_logf(world, SERD_LOG_LEVEL_ERROR, "%s", "") == SERD_ERR_BAD_ARG); + assert(serd_logf(world, SERD_LOG_LEVEL_ERROR, "%s", "") == SERD_BAD_ARG); serd_world_free(world); } diff --git a/test/test_model.c b/test/test_model.c index 78372997..3e781c7e 100644 --- a/test/test_model.c +++ b/test/test_model.c @@ -164,7 +164,7 @@ test_read(SerdWorld* world, } // Attempt to increment past end - assert(serd_cursor_advance(cursor) == SERD_ERR_BAD_CURSOR); + assert(serd_cursor_advance(cursor) == SERD_BAD_CURSOR); serd_cursor_free(cursor); const SerdStringView s = SERD_STRING("hello"); @@ -453,7 +453,7 @@ test_add_with_iterator(SerdWorld* world, const unsigned n_quads) // Check that iterator has been invalidated assert(!serd_cursor_get(iter)); - assert(serd_cursor_advance(iter) == SERD_ERR_BAD_CURSOR); + assert(serd_cursor_advance(iter) == SERD_BAD_CURSOR); serd_cursor_free(iter); serd_model_free(model); @@ -543,7 +543,7 @@ test_remove_index(SerdWorld* world, const unsigned n_quads) const SerdNode* const o2 = uri(world, 3); // Try to remove default and non-existent indices - assert(serd_model_drop_index(model, SERD_ORDER_SPO) == SERD_ERR_BAD_CALL); + assert(serd_model_drop_index(model, SERD_ORDER_SPO) == SERD_BAD_CALL); assert(serd_model_drop_index(model, SERD_ORDER_PSO) == SERD_FAILURE); // Add a couple of statements so that dropping an index isn't trivial @@ -578,7 +578,7 @@ test_inserter(SerdWorld* world, const unsigned n_quads) serd_set_log_func(world, expected_error, NULL); - assert(serd_sink_write(inserter, 0, s, p, rel, NULL) == SERD_ERR_BAD_ARG); + assert(serd_sink_write(inserter, 0, s, p, rel, NULL) == SERD_BAD_ARG); serd_sink_free(inserter); serd_model_free(model); @@ -612,7 +612,7 @@ test_erase_with_iterator(SerdWorld* world, const unsigned n_quads) // Check that other iterator has been invalidated assert(!serd_cursor_get(iter2)); - assert(serd_cursor_advance(iter2) == SERD_ERR_BAD_CURSOR); + assert(serd_cursor_advance(iter2) == SERD_BAD_CURSOR); // Check that erasing the end iterator does nothing SerdCursor* const end = serd_cursor_copy(serd_model_end(model)); @@ -1290,7 +1290,7 @@ test_write_error_in_list_subject(SerdWorld* world, const unsigned n_quads) const SerdStatus st = serd_describe_range(all, sink, 0); serd_cursor_free(all); - assert(st == SERD_ERR_BAD_WRITE); + assert(st == SERD_BAD_WRITE); serd_writer_free(writer); serd_close_output(&out); @@ -1346,7 +1346,7 @@ test_write_error_in_list_object(SerdWorld* world, const unsigned n_quads) const SerdStatus st = serd_describe_range(all, sink, 0); serd_cursor_free(all); - assert(st == SERD_ERR_BAD_WRITE); + assert(st == SERD_BAD_WRITE); serd_writer_free(writer); serd_close_output(&out); diff --git a/test/test_node.c b/test/test_node.c index 200791af..41ee6209 100644 --- a/test/test_node.c +++ b/test/test_node.c @@ -408,7 +408,7 @@ test_get_base64(void) char small[2] = {0}; const SerdWriteResult r = serd_get_base64(node, sizeof(small), small); - assert(r.status == SERD_ERR_OVERFLOW); + assert(r.status == SERD_OVERFLOW); serd_node_free(node); } diff --git a/test/test_overflow.c b/test/test_overflow.c index ca273b23..2aedc1bb 100644 --- a/test/test_overflow.c +++ b/test/test_overflow.c @@ -67,11 +67,11 @@ test_all_sizes(SerdWorld* const world, // Test with an increasingly smaller stack for (size_t size = max_stack_size; size > min_stack_size; --size) { if ((st = test_size(world, str, syntax, flags, size))) { - assert(st == SERD_ERR_OVERFLOW); + assert(st == SERD_BAD_STACK); } } - assert(st == SERD_ERR_OVERFLOW); + assert(st == SERD_BAD_STACK); } static void diff --git a/test/test_reader.c b/test/test_reader.c index 1c28e3da..37e645e3 100644 --- a/test/test_reader.c +++ b/test/test_reader.c @@ -74,12 +74,12 @@ test_prepare_error(void) SerdInputStream in = serd_open_input_stream(prepare_test_read, prepare_test_error, NULL, f); - assert(serd_reader_start(reader, &in, NULL, 0) == SERD_ERR_BAD_ARG); + assert(serd_reader_start(reader, &in, NULL, 0) == SERD_BAD_ARG); SerdStatus st = serd_reader_start(reader, &in, NULL, 1); assert(!st); - assert(serd_reader_read_document(reader) == SERD_ERR_UNKNOWN); + assert(serd_reader_read_document(reader) == SERD_BAD_READ); serd_close_input(&in); serd_reader_free(reader); diff --git a/test/test_reader_writer.c b/test/test_reader_writer.c index 82af9f20..8bb76083 100644 --- a/test/test_reader_writer.c +++ b/test/test_reader_writer.c @@ -146,8 +146,8 @@ test_reader(const char* path) SerdReader* reader = serd_reader_new(world, SERD_TURTLE, 0u, env, sink, 4096); assert(reader); - assert(serd_reader_read_document(reader) == SERD_ERR_BAD_CALL); - assert(serd_reader_read_chunk(reader) == SERD_ERR_BAD_CALL); + assert(serd_reader_read_document(reader) == SERD_BAD_CALL); + assert(serd_reader_read_chunk(reader) == SERD_BAD_CALL); SerdInputStream in = serd_open_input_file(path); assert(!serd_reader_start(reader, &in, NULL, 4096)); diff --git a/test/test_sink.c b/test/test_sink.c index 29bb793f..8bbfbb2d 100644 --- a/test/test_sink.c +++ b/test/test_sink.c @@ -91,7 +91,7 @@ on_event(void* const handle, const SerdEvent* const event) return on_end(handle, event->end.node); } - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } static void @@ -157,7 +157,7 @@ test_callbacks(void) assert(serd_node_equals(state.last_end, blank)); const SerdEvent junk = {(SerdEventType)42}; - assert(serd_sink_write_event(sink, &junk) == SERD_ERR_BAD_ARG); + assert(serd_sink_write_event(sink, &junk) == SERD_BAD_ARG); serd_sink_free(sink); diff --git a/test/test_string.c b/test/test_string.c index f8534001..c91284bb 100644 --- a/test/test_string.c +++ b/test/test_string.c @@ -32,13 +32,17 @@ test_strerror(void) { const char* msg = serd_strerror(SERD_SUCCESS); assert(!strcmp(msg, "Success")); - for (int i = SERD_FAILURE; i <= SERD_ERR_INVALID; ++i) { + + for (int i = SERD_FAILURE; i <= SERD_BAD_WRITE; ++i) { msg = serd_strerror((SerdStatus)i); assert(strcmp(msg, "Success")); } msg = serd_strerror((SerdStatus)-1); assert(!strcmp(msg, "Unknown error")); + + msg = serd_strerror((SerdStatus)1000000); + assert(!strcmp(msg, "Unknown error")); } static void diff --git a/test/test_writer.c b/test/test_writer.c index 34eafbb2..c719642f 100644 --- a/test/test_writer.c +++ b/test/test_writer.c @@ -52,7 +52,7 @@ test_write_bad_event(void) const SerdEvent event = {(SerdEventType)42}; assert(serd_sink_write_event(serd_writer_sink(writer), &event) == - SERD_ERR_BAD_ARG); + SERD_BAD_ARG); assert(!serd_close_output(&output)); @@ -158,12 +158,12 @@ test_writer_stack_overflow(void) o = next_o; if (st) { - assert(st == SERD_ERR_OVERFLOW); + assert(st == SERD_BAD_STACK); break; } } - assert(st == SERD_ERR_OVERFLOW); + assert(st == SERD_BAD_STACK); serd_writer_free(writer); serd_close_output(&output); @@ -199,8 +199,8 @@ test_strict_write(void) const SerdNode* bad_lit = serd_nodes_string(nodes, bad_view); const SerdNode* bad_uri = serd_nodes_uri(nodes, bad_view); - assert(serd_sink_write(sink, 0, s, p, bad_lit, 0) == SERD_ERR_BAD_TEXT); - assert(serd_sink_write(sink, 0, s, p, bad_uri, 0) == SERD_ERR_BAD_TEXT); + assert(serd_sink_write(sink, 0, s, p, bad_lit, 0) == SERD_BAD_TEXT); + assert(serd_sink_write(sink, 0, s, p, bad_uri, 0) == SERD_BAD_TEXT); serd_writer_free(writer); serd_close_output(&output); @@ -250,7 +250,7 @@ test_write_error(void) assert(writer); SerdStatus st = serd_sink_write(serd_writer_sink(writer), 0u, s, p, o, NULL); - assert(st == SERD_ERR_BAD_WRITE); + assert(st == SERD_BAD_WRITE); serd_writer_free(writer); serd_close_output(&output); @@ -262,7 +262,7 @@ test_write_error(void) assert(writer); assert(serd_sink_write(serd_writer_sink(writer), 0u, s, p, o, NULL) == - SERD_ERR_BAD_WRITE); + SERD_BAD_WRITE); serd_writer_free(writer); serd_close_output(&output); @@ -337,7 +337,7 @@ test_write_bad_uri(void) serd_sink_write(serd_writer_sink(writer), 0u, s, p, rel, NULL); assert(st); - assert(st == SERD_ERR_BAD_ARG); + assert(st == SERD_BAD_ARG); serd_close_output(&output); serd_free(buffer.buf); diff --git a/tools/console.c b/tools/console.c index ab36364d..0e41a2a0 100644 --- a/tools/console.c +++ b/tools/console.c @@ -45,7 +45,7 @@ serd_tool_setup(SerdTool* const tool, "%s: failed to open output file (%s)\n", program, strerror(errno)); - return SERD_ERR_UNKNOWN; + return SERD_UNKNOWN_ERROR; } // We have something to write to, so build the writing environment @@ -61,7 +61,7 @@ serd_tool_setup(SerdTool* const tool, &tool->out, options.block_size))) { fprintf(stderr, "%s: failed to set up writing environment\n", program); - return SERD_ERR_INTERNAL; + return SERD_UNKNOWN_ERROR; } return SERD_SUCCESS; @@ -75,7 +75,7 @@ serd_tool_cleanup(SerdTool tool) // Close the output stream explicitly to check if there were any errors if (serd_close_output(&tool.out)) { perror("write error"); - st = SERD_ERR_BAD_WRITE; + st = SERD_BAD_WRITE; } } @@ -120,7 +120,7 @@ serd_get_argument(OptionIter* const iter, const char** const argument) if (iter->argv[iter->a][iter->f] || (iter->a + 1) == iter->argc) { fprintf( stderr, "%s: option requires an argument -- %c\n", iter->argv[0], flag); - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } *argument = iter->argv[++iter->a]; @@ -141,7 +141,7 @@ serd_get_size_argument(OptionIter* const iter, size_t* const argument) char* endptr = NULL; const long size = strtol(string, &endptr, 10); if (size <= 0 || size == LONG_MAX || *endptr != '\0') { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } *argument = (size_t)size; @@ -181,7 +181,7 @@ serd_set_input_option(const SerdStringView name, } } - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } SerdStatus @@ -238,7 +238,7 @@ serd_set_output_option(const SerdStringView name, } } - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } SerdStatus @@ -384,12 +384,12 @@ serd_set_base_uri_from_path(SerdEnv* const env, const char* const path) { const size_t path_len = path ? strlen(path) : 0u; if (!path_len) { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } char* const real_path = serd_canonical_path(path); if (!real_path) { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } const size_t real_path_len = strlen(real_path); @@ -455,7 +455,7 @@ serd_read_inputs(SerdWorld* const world, // Open the input stream SerdInputStream in = serd_open_tool_input(in_path); if (!in.stream) { - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } // Read the entire file diff --git a/tools/serd-filter.c b/tools/serd-filter.c index ed22373c..0804d6ba 100644 --- a/tools/serd-filter.c +++ b/tools/serd-filter.c @@ -51,7 +51,7 @@ on_pattern_event(void* const handle, const SerdEvent* const event) if (event->type == SERD_STATEMENT) { FilterPattern* const pat = (FilterPattern*)handle; if (pat->s) { - return SERD_ERR_INVALID; + return SERD_BAD_PATTERN; } const SerdStatement* const statement = event->statement.statement; @@ -149,7 +149,7 @@ run(Options opts) if (!pattern.stream) { log_error(app.world, "failed to open pattern"); - return SERD_ERR_UNKNOWN; + return SERD_UNKNOWN_ERROR; } // Set up the output pipeline: filter -> writer @@ -157,7 +157,7 @@ run(Options opts) parse_pattern(app.world, target, &pattern, !opts.invert); if (!filter) { log_error(app.world, "failed to set up filter"); - return SERD_ERR_UNKNOWN; + return SERD_UNKNOWN_ERROR; } serd_close_input(&pattern); @@ -245,7 +245,7 @@ parse_option(OptionIter* const iter, Options* const opts) } ARG_ERRORF("invalid option -- '%c'\n", opt); - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; #undef ARG_ERRORF } diff --git a/tools/serd-pipe.c b/tools/serd-pipe.c index 879a56b5..f2891f9b 100644 --- a/tools/serd-pipe.c +++ b/tools/serd-pipe.c @@ -163,7 +163,7 @@ parse_option(OptionIter* const iter, Options* const opts) } ARG_ERRORF("invalid option -- '%c'\n", opt); - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; #undef ARG_ERRORF } diff --git a/tools/serd-sort.c b/tools/serd-sort.c index 1018350d..7219fa26 100644 --- a/tools/serd-sort.c +++ b/tools/serd-sort.c @@ -162,7 +162,7 @@ parse_statement_order(const char* const string, SerdStatementOrder* const order) } } - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; } static int @@ -237,7 +237,7 @@ parse_option(OptionIter* const iter, Options* const opts) } ARG_ERRORF("invalid option -- '%c'\n", opt); - return SERD_ERR_BAD_ARG; + return SERD_BAD_ARG; #undef ARG_ERRORF } -- cgit v1.2.1