Add custom allocator support

1 files changed, 74 insertions, 53 deletions

diff --git a/src/node_syntax.c b/src/node_syntax.c
index 261d4b03..166fad0e 100644
--- a/src/node_syntax.c
+++ b/src/node_syntax.c
@@ -15,21 +15,28 @@
 */
 
 #include "env.h"
+#include "memory.h"
 #include "writer.h"
 
 #include "serd/serd.h"
 
 #include <assert.h>
 #include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
 
+typedef struct {
+  SerdAllocator* allocator;
+  SerdNode*      object;
+} NodeSyntaxContext;
+
 static SerdStatus
-on_node_string_event(void* const handle, const SerdEvent* const event)
+on_syntax_event(void* const handle, const SerdEvent* const event)
 {
+  NodeSyntaxContext* const ctx = (NodeSyntaxContext*)handle;
+
   if (event->type == SERD_STATEMENT) {
-    *(SerdNode**)handle =
-      serd_node_copy(serd_statement_object(event->statement.statement));
+    ctx->object = serd_node_copy(
+      ctx->allocator, serd_statement_object(event->statement.statement));
   }
 
   return SERD_SUCCESS;
@@ -46,44 +53,46 @@ serd_node_from_syntax_in(SerdWorld* const  world,
   static const char* const prelude =
     "_:s <http://www.w3.org/2000/01/rdf-schema#object>";
 
-  const size_t str_len = strlen(str);
-  const size_t doc_len = strlen(prelude) + str_len + 4;
-  char* const  doc     = (char*)calloc(doc_len + 1, 1);
-
-  snprintf(doc, doc_len + 1, "%s %s .", prelude, str);
-
-  SerdNode*       object = NULL;
-  SerdSink* const sink =
-    serd_sink_new(world, &object, on_node_string_event, NULL);
-
-  SerdReader* const reader =
-    serd_reader_new(world,
-                    syntax,
-                    SERD_READ_RELATIVE | SERD_READ_GLOBAL | SERD_READ_GENERATED,
-                    env,
-                    sink,
-                    1024 + doc_len);
-
-  const SerdNode* string_name =
-    serd_nodes_string(serd_world_nodes(world), SERD_STRING("string"));
-
-  const char*     position = doc;
-  SerdInputStream in       = serd_open_input_string(&position);
-  serd_reader_start(reader, &in, string_name, 1);
-  serd_reader_read_document(reader);
-  serd_reader_finish(reader);
-  serd_close_input(&in);
-  serd_reader_free(reader);
+  const size_t      str_len = strlen(str);
+  const size_t      doc_len = strlen(prelude) + str_len + 4;
+  NodeSyntaxContext ctx     = {serd_world_allocator(world), NULL};
+  char* const       doc     = (char*)serd_wcalloc(world, doc_len + 1, 1);
+  SerdSink* const   sink    = serd_sink_new(world, &ctx, on_syntax_event, NULL);
+
+  if (doc && sink) {
+    snprintf(doc, doc_len + 1, "%s %s .", prelude, str);
+
+    SerdReader* const reader = serd_reader_new(
+      world,
+      syntax,
+      SERD_READ_RELATIVE | SERD_READ_GLOBAL | SERD_READ_GENERATED,
+      env,
+      sink,
+      1024 + doc_len);
+
+    if (reader) {
+      const char*     position = doc;
+      SerdInputStream in       = serd_open_input_string(&position);
+      serd_reader_start(reader, &in, NULL, 1);
+      serd_reader_read_document(reader);
+      serd_reader_finish(reader);
+      serd_close_input(&in);
+    }
+
+    serd_reader_free(reader);
+  }
+
   serd_sink_free(sink);
-  free(doc);
+  serd_wfree(world, doc);
 
-  return object;
+  return ctx.object;
 }
 
 SerdNode*
-serd_node_from_syntax(const char* const str,
-                      const SerdSyntax  syntax,
-                      SerdEnv* const    env)
+serd_node_from_syntax(SerdAllocator* const allocator,
+                      const char* const    str,
+                      const SerdSyntax     syntax,
+                      SerdEnv* const       env)
 {
   assert(str);
 
@@ -91,7 +100,7 @@ serd_node_from_syntax(const char* const str,
     return serd_node_from_syntax_in(serd_env_world(env), str, syntax, env);
   }
 
-  SerdWorld* const temp_world = serd_world_new();
+  SerdWorld* const temp_world = serd_world_new(allocator);
   if (!temp_world) {
     return NULL;
   }
@@ -116,27 +125,34 @@ serd_node_to_syntax_in(SerdWorld* const      world,
                        const SerdSyntax      syntax,
                        const SerdEnv* const  env)
 {
-  SerdBuffer        buffer = {NULL, 0};
+  SerdBuffer        buffer = {serd_world_allocator(world), NULL, 0};
   SerdOutputStream  out    = serd_open_output_buffer(&buffer);
   SerdWriter* const writer = serd_writer_new(world, syntax, 0, env, &out, 1);
+  if (!writer) {
+    return NULL;
+  }
 
   char* result = NULL;
-  if (!serd_writer_write_node(writer, node) && !serd_writer_finish(writer) &&
-      !serd_close_output(&out)) {
-    result = (char*)buffer.buf;
+  if (!serd_writer_write_node(writer, node) && !serd_writer_finish(writer)) {
+    if (!serd_close_output(&out)) {
+      result = (char*)buffer.buf;
+    }
   } else {
     serd_close_output(&out);
-    free(buffer.buf);
   }
 
   serd_writer_free(writer);
-  serd_close_output(&out);
+
+  if (!result) {
+    serd_wfree(world, buffer.buf);
+  }
 
   return result;
 }
 
 char*
-serd_node_to_syntax(const SerdNode* const node,
+serd_node_to_syntax(SerdAllocator* const  allocator,
+                    const SerdNode* const node,
                     const SerdSyntax      syntax,
                     const SerdEnv* const  env)
 {
@@ -146,16 +162,21 @@ serd_node_to_syntax(const SerdNode* const node,
     return serd_node_to_syntax_in(serd_env_world(env), node, syntax, env);
   }
 
-  SerdWorld* const temp_world = serd_world_new();
-  SerdEnv* const   temp_env   = serd_env_new(temp_world, SERD_EMPTY_STRING());
-  if (temp_env) {
-    char* const string =
-      serd_node_to_syntax_in(temp_world, node, syntax, temp_env);
+  SerdWorld* const temp_world = serd_world_new(allocator);
+  if (!temp_world) {
+    return NULL;
+  }
 
-    serd_env_free(temp_env);
+  SerdEnv* const temp_env = serd_env_new(temp_world, SERD_EMPTY_STRING());
+  if (!temp_env) {
     serd_world_free(temp_world);
-    return string;
+    return NULL;
   }
 
-  return NULL;
+  char* const string =
+    serd_node_to_syntax_in(temp_world, node, syntax, temp_env);
+
+  serd_env_free(temp_env);
+  serd_world_free(temp_world);
+  return string;
 }