diff options
| -rw-r--r-- | NEWS | 2 | ||||
| -rw-r--r-- | serd/serd.h | 54 | ||||
| -rw-r--r-- | src/env.c | 14 | ||||
| -rw-r--r-- | src/node.c | 137 | ||||
| -rw-r--r-- | src/node.h | 2 | ||||
| -rw-r--r-- | src/serdi.c | 6 | ||||
| -rw-r--r-- | src/world.c | 2 | ||||
| -rw-r--r-- | tests/serd_test.c | 105 |
8 files changed, 175 insertions, 147 deletions
@@ -2,7 +2,7 @@ serd (1.0.0) unstable; * Remove serd_uri_to_path() * Use SerdBuffer for mutable buffers instead of abusing SerdChunk - * Add serd_node_new_relative_uri() + * Add serd_new_relative_uri() * Fix construction and comparison of URIs with UTF-8 characters * Use char* for strings in public API * Remove useless character counting diff --git a/serd/serd.h b/serd/serd.h index 33196da1..6b11739d 100644 --- a/serd/serd.h +++ b/serd/serd.h @@ -351,7 +351,7 @@ serd_strtod(const char* str, size_t* end); /** Decode a base64 string. This function can be used to deserialise a blob node created with - serd_node_new_blob(). + serd_new_blob(). @param str Base64 string to decode. @param len The length of `str`. @@ -525,33 +525,42 @@ serd_uri_serialise_relative(const SerdURI* uri, */ SERD_API SerdNode* -serd_node_new_string(const char* str); +serd_new_string(const char* str); /** - Create a new literal node from `str`. + Create a new plain literal node from `str`. - Either `datatype` or `lang` can be given, but not both, unless `datatype` is - rdf:langString in which case it is ignored. + A plain literal has no datatype, but may have a language tag. The `lang` + may be NULL, in which case this is equivalent to `serd_new_string()`. */ SERD_API SerdNode* -serd_node_new_literal(const char* str, - const SerdNode* datatype, - const char* lang); +serd_new_plain_literal(const char* str, const char* lang); + +/** + Create a new typed literal node from `str`. + + A typed literal has no language tag, but may have a datatype. The + `datatype` may be NULL, in which case this is equivalent to + `serd_new_string()`. +*/ +SERD_API +SerdNode* +serd_new_typed_literal(const char* str, const SerdNode* datatype); /** Create a new blank node. */ SERD_API SerdNode* -serd_node_new_blank(const char* str); +serd_new_blank(const char* str); /** Create a new CURIE node. */ SERD_API SerdNode* -serd_node_new_curie(const char* str); +serd_new_curie(const char* str); /** Return a deep copy of `node`. @@ -572,14 +581,14 @@ serd_node_equals(const SerdNode* a, const SerdNode* b); */ SERD_API SerdNode* -serd_node_new_uri(const char* str); +serd_new_uri(const char* str); /** Create a new URI from a string, resolved against a base URI. */ SERD_API SerdNode* -serd_node_new_resolved_uri(const char* str, const SerdNode* base); +serd_new_resolved_uri(const char* str, const SerdNode* base); /** Resolve `node` against `base`. @@ -602,7 +611,7 @@ serd_node_resolve(const SerdNode* node, const SerdNode* base); */ SERD_API SerdNode* -serd_node_new_file_uri(const char* path, const char* hostname, bool escape); +serd_new_file_uri(const char* path, const char* hostname, bool escape); /** Create a new URI from a string, relative to a base URI. @@ -619,9 +628,9 @@ serd_node_new_file_uri(const char* path, const char* hostname, bool escape); */ SERD_API SerdNode* -serd_node_new_relative_uri(const char* str, - const SerdNode* base, - const SerdNode* root); +serd_new_relative_uri(const char* str, + const SerdNode* base, + const SerdNode* root); /** Create a new node by serialising `d` into an xsd:decimal string. @@ -644,7 +653,7 @@ serd_node_new_relative_uri(const char* str, */ SERD_API SerdNode* -serd_node_new_decimal(double d, unsigned frac_digits, const SerdNode* datatype); +serd_new_decimal(double d, unsigned frac_digits, const SerdNode* datatype); /** Create a new node by serialising `i` into an xsd:integer string. @@ -656,7 +665,7 @@ serd_node_new_decimal(double d, unsigned frac_digits, const SerdNode* datatype); */ SERD_API SerdNode* -serd_node_new_integer(int64_t i, const SerdNode* datatype); +serd_new_integer(int64_t i, const SerdNode* datatype); /** Create a node by serialising `buf` into an xsd:base64Binary string. @@ -673,10 +682,11 @@ serd_node_new_integer(int64_t i, const SerdNode* datatype); type xsd:base64Binary. */ SERD_API -SerdNode* serd_node_new_blob(const void* buf, - size_t size, - bool wrap_lines, - const SerdNode* datatype); +SerdNode* +serd_new_blob(const void* buf, + size_t size, + bool wrap_lines, + const SerdNode* datatype); /** Return the type of a node (SERD_URI, SERD_BLANK, or SERD_LITERAL). @@ -80,7 +80,7 @@ serd_env_set_base_uri(SerdEnv* env, } // Resolve base URI and create a new node and URI for it - SerdNode* base_uri_node = serd_node_new_resolved_uri_i( + SerdNode* base_uri_node = serd_new_resolved_uri_i( serd_node_get_string(uri), &env->base_uri); SerdURI base_uri; @@ -145,7 +145,7 @@ serd_env_set_prefix(SerdEnv* env, serd_env_add(env, name, uri); } else { // Resolve relative URI and create a new node and URI for it - SerdNode* abs_uri = serd_node_new_resolved_uri_i( + SerdNode* abs_uri = serd_new_resolved_uri_i( serd_node_get_string(uri), &env->base_uri); // Set prefix to resolved (absolute) URI @@ -160,8 +160,8 @@ serd_env_set_prefix_from_strings(SerdEnv* env, const char* name, const char* uri) { - SerdNode* name_node = serd_node_new_string(name); - SerdNode* uri_node = serd_node_new_uri(uri); + SerdNode* name_node = serd_new_string(name); + SerdNode* uri_node = serd_new_uri(uri); const SerdStatus st = serd_env_set_prefix(env, name_node, uri_node); @@ -240,15 +240,15 @@ serd_env_expand_node(const SerdEnv* env, SerdNode* datatype = serd_env_expand_node( env, serd_node_get_datatype(node)); if (datatype) { - SerdNode* ret = serd_node_new_literal( - serd_node_get_string(node), datatype, NULL); + SerdNode* ret = serd_new_typed_literal( + serd_node_get_string(node), datatype); serd_node_free(datatype); return ret; } } return NULL; case SERD_URI: - return serd_node_new_resolved_uri_i( + return serd_new_resolved_uri_i( serd_node_get_string(node), &env->base_uri); default: return NULL; @@ -54,7 +54,7 @@ DEFINE_XSD_NODE(integer) DEFINE_XSD_NODE(base64Binary) static SerdNode* -serd_node_new_from_uri(const SerdURI* uri, const SerdURI* base); +serd_new_from_uri(const SerdURI* uri, const SerdURI* base); static size_t serd_node_pad_size(const size_t n_bytes) @@ -138,7 +138,7 @@ serd_node_set(SerdNode** dst, const SerdNode* src) } static SerdNode* -serd_node_new_simple(SerdType type, const char* str) +serd_new_simple(SerdType type, const char* str) { if (!str) { return NULL; @@ -153,7 +153,7 @@ serd_node_new_simple(SerdType type, const char* str) } SerdNode* -serd_node_new_string(const char* str) +serd_new_string(const char* str) { if (!str) { return NULL; @@ -169,15 +169,47 @@ serd_node_new_string(const char* str) } SerdNode* -serd_node_new_literal(const char* str, - const SerdNode* datatype, - const char* lang) +serd_new_plain_literal(const char* str, const char* lang) +{ + if (!str) { + return NULL; + } else if (!lang) { + return serd_new_string(str); + } + + uint32_t flags = 0; + const size_t n_bytes = serd_strlen(str, &flags); + const size_t len = serd_node_pad_size(n_bytes); + + SerdNode* node = NULL; + const size_t lang_len = strlen(lang); + const size_t total_len = len + sizeof(SerdNode) + lang_len; + flags |= SERD_HAS_LANGUAGE; + node = serd_node_malloc(total_len, flags, SERD_LITERAL); + memcpy(serd_node_buffer(node), str, n_bytes); + node->n_bytes = n_bytes; + + SerdNode* lang_node = node + 1 + (len / serd_node_align); + lang_node->type = SERD_LITERAL; + lang_node->n_bytes = lang_len; + memcpy(serd_node_buffer(lang_node), lang, lang_len); + serd_node_check_padding(lang_node); + + serd_node_check_padding(node); + return node; +} + +SerdNode* +serd_new_typed_literal(const char* str, const SerdNode* datatype) { serd_node_check_padding(datatype); - if (!str || (lang && datatype && - strcmp(serd_node_buffer_c(datatype), NS_RDF "#langString")) || - (datatype && serd_node_get_type(datatype) != SERD_URI)) { + if (!str) { + return NULL; + } else if (!datatype) { + return serd_new_string(str); + } else if (!strcmp(serd_node_buffer_c(datatype), NS_RDF "#langString") || + serd_node_get_type(datatype) != SERD_URI) { return NULL; } @@ -186,56 +218,37 @@ serd_node_new_literal(const char* str, const size_t len = serd_node_pad_size(n_bytes); SerdNode* node = NULL; - if (lang) { - flags |= SERD_HAS_LANGUAGE; - const size_t lang_len = strlen(lang); - const size_t total_len = len + sizeof(SerdNode) + lang_len; - node = serd_node_malloc(total_len, flags, SERD_LITERAL); - memcpy(serd_node_buffer(node), str, n_bytes); - node->n_bytes = n_bytes; - - SerdNode* lang_node = node + 1 + (len / serd_node_align); - lang_node->type = SERD_LITERAL; - lang_node->n_bytes = lang_len; - memcpy(serd_node_buffer(lang_node), lang, lang_len); - serd_node_check_padding(lang_node); - } else if (datatype) { - flags |= SERD_HAS_DATATYPE; - const size_t datatype_len = strlen(serd_node_buffer_c(datatype)); - const size_t total_len = len + sizeof(SerdNode) + datatype_len; - node = serd_node_malloc(total_len, flags, SERD_LITERAL); - memcpy(serd_node_buffer(node), str, n_bytes); - node->n_bytes = n_bytes; - - SerdNode* datatype_node = node + 1 + (len / serd_node_align); - memcpy(datatype_node, datatype, sizeof(SerdNode) + datatype_len); - serd_node_check_padding(datatype_node); - } else { - node = serd_node_malloc(n_bytes, flags, SERD_LITERAL); - memcpy(serd_node_buffer(node), str, n_bytes); - node->n_bytes = n_bytes; - } + const size_t datatype_len = strlen(serd_node_buffer_c(datatype)); + const size_t total_len = len + sizeof(SerdNode) + datatype_len; + flags |= SERD_HAS_DATATYPE; + node = serd_node_malloc(total_len, flags, SERD_LITERAL); + memcpy(serd_node_buffer(node), str, n_bytes); + node->n_bytes = n_bytes; + + SerdNode* datatype_node = node + 1 + (len / serd_node_align); + memcpy(datatype_node, datatype, sizeof(SerdNode) + datatype_len); + serd_node_check_padding(datatype_node); serd_node_check_padding(node); return node; } SerdNode* -serd_node_new_blank(const char* str) +serd_new_blank(const char* str) { - return serd_node_new_simple(SERD_BLANK, str); + return serd_new_simple(SERD_BLANK, str); } SerdNode* -serd_node_new_curie(const char* str) +serd_new_curie(const char* str) { - return serd_node_new_simple(SERD_CURIE, str); + return serd_new_simple(SERD_CURIE, str); } SerdNode* -serd_node_new_uri(const char* str) +serd_new_uri(const char* str) { - return serd_node_new_simple(SERD_URI, str); + return serd_new_simple(SERD_URI, str); } /** @@ -317,7 +330,7 @@ string_sink(const void* buf, size_t size, size_t nmemb, void* stream) } SerdNode* -serd_node_new_resolved_uri(const char* str, const SerdNode* base) +serd_new_resolved_uri(const char* str, const SerdNode* base) { if (!base || base->type != SERD_URI) { return NULL; @@ -325,7 +338,7 @@ serd_node_new_resolved_uri(const char* str, const SerdNode* base) SerdURI base_uri; serd_uri_parse(serd_node_get_string(base), &base_uri); - return serd_node_new_resolved_uri_i(str, &base_uri); + return serd_new_resolved_uri_i(str, &base_uri); } SerdNode* @@ -340,20 +353,20 @@ serd_node_resolve(const SerdNode* node, const SerdNode* base) serd_uri_parse(serd_node_get_string(node), &uri); serd_uri_parse(serd_node_get_string(base), &base_uri); - return serd_node_new_from_uri(&uri, &base_uri); + return serd_new_from_uri(&uri, &base_uri); } SerdNode* -serd_node_new_resolved_uri_i(const char* str, const SerdURI* base) +serd_new_resolved_uri_i(const char* str, const SerdURI* base) { if (!str || str[0] == '\0') { // Empty URI => Base URI, or nothing if no base is given - return base ? serd_node_new_from_uri(base, NULL) : NULL; + return base ? serd_new_from_uri(base, NULL) : NULL; } SerdURI uri; serd_uri_parse(str, &uri); - return serd_node_new_from_uri(&uri, base); + return serd_new_from_uri(&uri, base); } static inline bool @@ -376,7 +389,7 @@ is_uri_path_char(const char c) } SerdNode* -serd_node_new_file_uri(const char* path, const char* hostname, bool escape) +serd_new_file_uri(const char* path, const char* hostname, bool escape) { const size_t path_len = strlen(path); const size_t hostname_len = hostname ? strlen(hostname) : 0; @@ -407,14 +420,14 @@ serd_node_new_file_uri(const char* path, const char* hostname, bool escape) } serd_buffer_sink_finish(&buffer); - SerdNode* node = serd_node_new_uri((const char*)buffer.buf); + SerdNode* node = serd_new_uri((const char*)buffer.buf); free(buffer.buf); serd_node_check_padding(node); return node; } static SerdNode* -serd_node_new_from_uri(const SerdURI* uri, const SerdURI* base) +serd_new_from_uri(const SerdURI* uri, const SerdURI* base) { SerdURI abs_uri = *uri; if (base) { @@ -434,9 +447,9 @@ serd_node_new_from_uri(const SerdURI* uri, const SerdURI* base) } SerdNode* -serd_node_new_relative_uri(const char* str, - const SerdNode* base, - const SerdNode* root) +serd_new_relative_uri(const char* str, + const SerdNode* base, + const SerdNode* root) { SerdURI uri = SERD_URI_NULL; SerdURI base_uri = SERD_URI_NULL; @@ -472,7 +485,7 @@ serd_digits(double abs) } SerdNode* -serd_node_new_decimal(double d, unsigned frac_digits, const SerdNode* datatype) +serd_new_decimal(double d, unsigned frac_digits, const SerdNode* datatype) { if (isnan(d) || isinf(d)) { return NULL; @@ -535,7 +548,7 @@ serd_node_new_decimal(double d, unsigned frac_digits, const SerdNode* datatype) } SerdNode* -serd_node_new_integer(int64_t i, const SerdNode* datatype) +serd_new_integer(int64_t i, const SerdNode* datatype) { const SerdNode* type = datatype ? datatype : &serd_xsd_integer.node; int64_t abs_i = (i < 0) ? -i : i; @@ -567,10 +580,10 @@ serd_node_new_integer(int64_t i, const SerdNode* datatype) } SerdNode* -serd_node_new_blob(const void* buf, - size_t size, - bool wrap_lines, - const SerdNode* datatype) +serd_new_blob(const void* buf, + size_t size, + bool wrap_lines, + const SerdNode* datatype) { if (!buf || !size) { return NULL; @@ -42,6 +42,6 @@ serd_node_buffer_c(const SerdNode* node) SerdNode* serd_node_malloc(size_t n_bytes, SerdNodeFlags flags, SerdType type); void serd_node_set(SerdNode** dst, const SerdNode* src); void serd_node_zero_pad(SerdNode* node); -SerdNode* serd_node_new_resolved_uri_i(const char* str, const SerdURI* base); +SerdNode* serd_new_resolved_uri_i(const char* str, const SerdURI* base); #endif // SERD_NODE_H diff --git a/src/serdi.c b/src/serdi.c index 22aabf6a..a8430e1b 100644 --- a/src/serdi.c +++ b/src/serdi.c @@ -188,9 +188,9 @@ main(int argc, char** argv) SerdNode* base = NULL; if (a < argc) { // Base URI given on command line - base = serd_node_new_uri((const char*)argv[a]); + base = serd_new_uri((const char*)argv[a]); } else if (!from_string && !from_stdin) { // Use input file URI - base = serd_node_new_file_uri(input, NULL, true); + base = serd_new_file_uri(input, NULL, true); } FILE* out_fd = stdout; @@ -232,7 +232,7 @@ main(int argc, char** argv) serd_world_set_error_sink(world, quiet_error_sink, NULL); } - SerdNode* root = serd_node_new_uri(root_uri); + SerdNode* root = serd_new_uri(root_uri); serd_writer_set_root_uri(writer, root); serd_writer_chop_blank_prefix(writer, chop_prefix); serd_reader_add_blank_prefix(reader, add_prefix); diff --git a/src/world.c b/src/world.c index 9908e4d4..27feeac6 100644 --- a/src/world.c +++ b/src/world.c @@ -76,7 +76,7 @@ serd_world_new(void) { SerdWorld* world = (SerdWorld*)calloc(1, sizeof(SerdWorld)); - world->blank_node = serd_node_new_blank("b0000000000"); + world->blank_node = serd_new_blank("b0000000000"); return world; } diff --git a/tests/serd_test.c b/tests/serd_test.c index 989eda4f..3d05275a 100644 --- a/tests/serd_test.c +++ b/tests/serd_test.c @@ -92,7 +92,7 @@ check_file_uri(const char* hostname, expected_path = path; } - SerdNode* node = serd_node_new_file_uri(path, hostname, escape); + SerdNode* node = serd_new_file_uri(path, hostname, escape); const char* node_str = serd_node_get_string(node); char* out_hostname = NULL; char* out_path = serd_file_uri_parse(node_str, &out_hostname); @@ -113,7 +113,7 @@ check_rel_uri(const char* uri, const SerdNode* root, const char* expected) { - SerdNode* rel = serd_node_new_relative_uri(uri, base, root); + SerdNode* rel = serd_new_relative_uri(uri, base, root); const int ret = strcmp(serd_node_get_string(rel), expected); serd_node_free(rel); assert(!ret); @@ -165,7 +165,7 @@ main(void) assert(delta <= DBL_EPSILON); } - // Test serd_node_new_decimal + // Test serd_new_decimal const double dbl_test_nums[] = { 0.0, 9.0, 10.0, .01, 2.05, -16.00001, 5.000000005, 0.0000000001, NAN, INFINITY @@ -176,7 +176,7 @@ main(void) }; for (unsigned i = 0; i < sizeof(dbl_test_nums) / sizeof(double); ++i) { - SerdNode* node = serd_node_new_decimal(dbl_test_nums[i], 8, NULL); + SerdNode* node = serd_new_decimal(dbl_test_nums[i], 8, NULL); const char* node_str = serd_node_get_string(node); const bool pass = (node_str && dbl_test_strs[i]) ? !strcmp(node_str, dbl_test_strs[i]) @@ -190,7 +190,7 @@ main(void) serd_node_free(node); } - // Test serd_node_new_integer + // Test serd_new_integer const long int_test_nums[] = { 0, -0, -23, 23, -12340, 1000, -1000 @@ -201,7 +201,7 @@ main(void) }; for (unsigned i = 0; i < sizeof(int_test_nums) / sizeof(double); ++i) { - SerdNode* node = serd_node_new_integer(int_test_nums[i], NULL); + SerdNode* node = serd_new_integer(int_test_nums[i], NULL); const char* node_str = serd_node_get_string(node); assert(!strcmp(node_str, int_test_strs[i])); const size_t len = strlen(node_str); @@ -211,7 +211,7 @@ main(void) serd_node_free(node); } - // Test serd_node_new_blob + // Test serd_new_blob for (size_t size = 1; size < 256; ++size) { uint8_t* data = (uint8_t*)malloc(size); for (size_t i = 0; i < size; ++i) { @@ -219,7 +219,7 @@ main(void) } size_t out_size; - SerdNode* blob = serd_node_new_blob(data, size, size % 5, NULL); + SerdNode* blob = serd_new_blob(data, size, size % 5, NULL); const char* blob_str = serd_node_get_string(blob); uint8_t* out = (uint8_t*)serd_base64_decode( blob_str, serd_node_get_length(blob), &out_size); @@ -285,11 +285,11 @@ main(void) // Test serd_node_equals const uint8_t replacement_char_str[] = { 0xEF, 0xBF, 0xBD, 0 }; - SerdNode* lhs = serd_node_new_string((const char*)replacement_char_str); - SerdNode* rhs = serd_node_new_string("123"); + SerdNode* lhs = serd_new_string((const char*)replacement_char_str); + SerdNode* rhs = serd_new_string("123"); assert(!serd_node_equals(lhs, rhs)); - SerdNode* qnode = serd_node_new_curie("foo:bar"); + SerdNode* qnode = serd_new_curie("foo:bar"); assert(!serd_node_equals(lhs, qnode)); serd_node_free(qnode); @@ -298,26 +298,32 @@ main(void) serd_node_free(lhs); serd_node_free(rhs); - // Test serd_node_new_string + // Test serd_new_string - SerdNode* hello = serd_node_new_string("hello\""); + SerdNode* hello = serd_new_string("hello\""); assert(serd_node_get_length(hello) == 6); assert(serd_node_get_flags(hello) == SERD_HAS_QUOTE); assert(!strncmp(serd_node_get_string(hello), "hello\"", 6)); - assert(!serd_node_new_string(NULL)); + assert(!serd_new_string(NULL)); - // Test serd_node_new_literal + // Test serd_new_literal - assert(!serd_node_new_literal(NULL, NULL, NULL)); + assert(!serd_new_plain_literal(NULL, NULL)); + assert(!serd_new_typed_literal(NULL, NULL)); - SerdNode* hello2 = serd_node_new_literal("hello\"", NULL, NULL); + SerdNode* hello2 = serd_new_string("hello\""); assert(serd_node_get_length(hello2) == 6 && serd_node_get_flags(hello2) == SERD_HAS_QUOTE && !strcmp(serd_node_get_string(hello2), "hello\"")); + + SerdNode* hello3 = serd_new_plain_literal("hello\"", NULL); + assert(serd_node_equals(hello2, hello3)); + + serd_node_free(hello3); serd_node_free(hello2); - SerdNode* hello_l = serd_node_new_literal("hello_l\"", NULL, "en"); + SerdNode* hello_l = serd_new_plain_literal("hello_l\"", "en"); assert(serd_node_get_length(hello_l) == 8); assert(!strcmp(serd_node_get_string(hello_l), "hello_l\"")); assert(serd_node_get_flags(hello_l) == @@ -326,10 +332,9 @@ main(void) "en")); serd_node_free(hello_l); - SerdNode* eg_Thing = serd_node_new_uri("http://example.org/Thing"); + SerdNode* eg_Thing = serd_new_uri("http://example.org/Thing"); - SerdNode* hello_dt = - serd_node_new_literal("hello_dt\"", eg_Thing, NULL); + SerdNode* hello_dt = serd_new_typed_literal("hello_dt\"", eg_Thing); assert(serd_node_get_length(hello_dt) == 9); assert(!strcmp(serd_node_get_string(hello_dt), "hello_dt\"")); assert(serd_node_get_flags(hello_dt) == @@ -341,15 +346,15 @@ main(void) // Test absolute URI creation - assert(!serd_node_new_uri(NULL)); + assert(!serd_new_uri(NULL)); - SerdNode* not_a_uri = serd_node_new_string("hello"); - SerdNode* root = serd_node_new_uri("http://example.org/a/b/"); - SerdNode* base = serd_node_new_uri("http://example.org/a/b/c/"); - SerdNode* nil = serd_node_new_resolved_uri(NULL, base); - SerdNode* nil2 = serd_node_new_resolved_uri("", base); - assert(!serd_node_new_resolved_uri("", NULL)); - assert(!serd_node_new_resolved_uri("", not_a_uri)); + SerdNode* not_a_uri = serd_new_string("hello"); + SerdNode* root = serd_new_uri("http://example.org/a/b/"); + SerdNode* base = serd_new_uri("http://example.org/a/b/c/"); + SerdNode* nil = serd_new_resolved_uri(NULL, base); + SerdNode* nil2 = serd_new_resolved_uri("", base); + assert(!serd_new_resolved_uri("", NULL)); + assert(!serd_new_resolved_uri("", not_a_uri)); assert(serd_node_get_type(nil) == SERD_URI); assert(!strcmp(serd_node_get_string(nil), serd_node_get_string(base))); assert(serd_node_get_type(nil2) == SERD_URI); @@ -375,7 +380,7 @@ main(void) assert(!serd_node_resolve(not_a_uri, base)); assert(!serd_node_resolve(nil, not_a_uri)); - SerdNode* rel = serd_node_new_relative_uri( + SerdNode* rel = serd_new_relative_uri( "http://example.org/a/b/c/foo", base, NULL); SerdNode* resolved = serd_node_resolve(rel, base); assert(!strcmp(serd_node_get_string(resolved), @@ -389,11 +394,11 @@ main(void) serd_node_free(base); serd_node_free(root); - // Test serd_node_new_blank + // Test serd_new_blank - assert(!serd_node_new_blank(NULL)); + assert(!serd_new_blank(NULL)); - SerdNode* blank = serd_node_new_blank("b0"); + SerdNode* blank = serd_new_blank("b0"); assert(serd_node_get_length(blank) == 2); assert(serd_node_get_flags(blank) == 0); assert(!strcmp(serd_node_get_string(blank), "b0")); @@ -407,9 +412,9 @@ main(void) return 1; } - SerdNode* u = serd_node_new_uri("http://example.org/foo"); - SerdNode* b = serd_node_new_curie("invalid"); - SerdNode* c = serd_node_new_curie("eg.2:b"); + SerdNode* u = serd_new_uri("http://example.org/foo"); + SerdNode* b = serd_new_curie("invalid"); + SerdNode* c = serd_new_curie("eg.2:b"); SerdEnv* env = serd_env_new(NULL); serd_env_set_prefix_from_strings(env, "eg.2", "http://example.org/"); @@ -429,7 +434,7 @@ main(void) assert(!strcmp(serd_node_get_string(xu), "http://example.org/foo")); serd_node_free(xu); - SerdNode* badpre = serd_node_new_curie("hm:what"); + SerdNode* badpre = serd_new_curie("hm:what"); SerdNode* xbadpre = serd_env_expand_node(env, badpre); assert(!xbadpre); @@ -439,7 +444,7 @@ main(void) assert(serd_env_set_prefix(env, NULL, NULL)); - SerdNode* lit = serd_node_new_string("hello"); + SerdNode* lit = serd_new_string("hello"); assert(serd_env_set_prefix(env, b, lit)); int n_prefixes = 0; @@ -447,7 +452,7 @@ main(void) serd_env_foreach(env, count_prefixes, &n_prefixes); assert(n_prefixes == 1); - SerdNode* shorter_uri = serd_node_new_uri("urn:foo"); + SerdNode* shorter_uri = serd_new_uri("urn:foo"); const SerdNode* prefix_name; assert(!serd_env_qualify(env, shorter_uri, &prefix_name, &suffix)); serd_node_free(shorter_uri); @@ -480,9 +485,9 @@ main(void) assert(serd_writer_get_env(writer) == env); uint8_t buf[] = { 0xEF, 0xBF, 0xBD, 0 }; - SerdNode* s = serd_node_new_uri(""); - SerdNode* p = serd_node_new_uri("http://example.org/pred"); - SerdNode* o = serd_node_new_string((char*)buf); + SerdNode* s = serd_new_uri(""); + SerdNode* p = serd_new_uri("http://example.org/pred"); + SerdNode* o = serd_new_string((char*)buf); // Write 3 invalid statements (should write nothing) const SerdNode* junk[][5] = { { s, p, NULL }, @@ -500,10 +505,10 @@ main(void) iface, 0, junk[i][0], junk[i][1], junk[i][2], 0)); } - SerdNode* urn_Type = serd_node_new_uri("urn:Type"); + SerdNode* urn_Type = serd_new_uri("urn:Type"); - SerdNode* t = serd_node_new_literal((char*)buf, urn_Type, NULL); - SerdNode* l = serd_node_new_literal((char*)buf, NULL, "en"); + SerdNode* t = serd_new_typed_literal((char*)buf, urn_Type); + SerdNode* l = serd_new_plain_literal((char*)buf, "en"); const SerdNode* good[][5] = { { s, p, o }, { s, p, o }, { s, p, t }, @@ -521,8 +526,8 @@ main(void) // Write statements with bad UTF-8 (should be replaced) const char bad_str[] = { (char)0xFF, (char)0x90, 'h', 'i', 0 }; - SerdNode* bad_lit = serd_node_new_string(bad_str); - SerdNode* bad_uri = serd_node_new_uri(bad_str); + SerdNode* bad_lit = serd_new_string(bad_str); + SerdNode* bad_uri = serd_new_uri(bad_str); assert(!serd_sink_write(iface, 0, s, p, bad_lit, 0)); assert(!serd_sink_write(iface, 0, s, p, bad_uri, 0)); serd_node_free(bad_uri); @@ -530,7 +535,7 @@ main(void) // Write 1 valid statement serd_node_free(o); - o = serd_node_new_string("hello"); + o = serd_new_string("hello"); assert(!serd_sink_write(iface, 0, s, p, o, 0)); serd_writer_free(writer); @@ -547,7 +552,7 @@ main(void) writer = serd_writer_new( world, SERD_TURTLE, (SerdStyle)0, env, serd_buffer_sink, &buffer); - o = serd_node_new_uri("http://example.org/base"); + o = serd_new_uri("http://example.org/base"); assert(!serd_writer_set_base_uri(writer, o)); serd_node_free(o); @@ -565,7 +570,7 @@ main(void) SerdReader* reader = serd_reader_new(world, SERD_TURTLE, &sink, 4096); assert(reader); - SerdNode* g = serd_node_new_uri("http://example.org/"); + SerdNode* g = serd_new_uri("http://example.org/"); serd_reader_set_default_graph(reader, g); serd_reader_add_blank_prefix(reader, "tmp"); serd_reader_add_blank_prefix(reader, NULL); |