avro-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bru...@apache.org
Subject svn commit: r947385 - in /avro/trunk/lang/c/src: CMakeLists.txt allocator.c allocator.h allocator_system.c allocator_system.h atom_table.c avro.c datafile.c datum.c datum_read.c encoding_binary.c io.c schema.c st.c
Date Sun, 23 May 2010 09:06:56 GMT
Author: brucem
Date: Sun May 23 09:06:55 2010
New Revision: 947385

URL: http://svn.apache.org/viewvc?rev=947385&view=rev
Log:
AVRO-549: Route memory management through an allocator interface.

Added:
    avro/trunk/lang/c/src/allocator.c
    avro/trunk/lang/c/src/allocator.h
    avro/trunk/lang/c/src/allocator_system.c
    avro/trunk/lang/c/src/allocator_system.h
Modified:
    avro/trunk/lang/c/src/CMakeLists.txt
    avro/trunk/lang/c/src/atom_table.c
    avro/trunk/lang/c/src/avro.c
    avro/trunk/lang/c/src/datafile.c
    avro/trunk/lang/c/src/datum.c
    avro/trunk/lang/c/src/datum_read.c
    avro/trunk/lang/c/src/encoding_binary.c
    avro/trunk/lang/c/src/io.c
    avro/trunk/lang/c/src/schema.c
    avro/trunk/lang/c/src/st.c

Modified: avro/trunk/lang/c/src/CMakeLists.txt
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/CMakeLists.txt?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/CMakeLists.txt (original)
+++ avro/trunk/lang/c/src/CMakeLists.txt Sun May 23 09:06:55 2010
@@ -18,6 +18,10 @@
 #
 
 set(AVRO_SRC
+    allocator.c
+    allocator.h
+    allocator_system.c
+    allocator_system.h
     atom_table.c
     avro.c
     avro.h

Added: avro/trunk/lang/c/src/allocator.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/allocator.c?rev=947385&view=auto
==============================================================================
--- avro/trunk/lang/c/src/allocator.c (added)
+++ avro/trunk/lang/c/src/allocator.c Sun May 23 09:06:55 2010
@@ -0,0 +1,34 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to you under the Apache License, Version 2.0 
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+* 
+* http://www.apache.org/licenses/LICENSE-2.0
+* 
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+* implied.  See the License for the specific language governing
+* permissions and limitations under the License. 
+*/
+
+#include "allocator.h"
+#include <string.h>
+
+struct avro_allocator_t_ g_avro_allocator = {
+	NULL,   // malloc
+	NULL,   // calloc
+	NULL,   // realloc
+	NULL    // free
+};
+
+char* 
+avro_strdup(const char* source)
+{
+	char* dest = (char*)g_avro_allocator.malloc(strlen(source) + 1);
+	strcpy(dest, source);
+	return dest;
+}

Added: avro/trunk/lang/c/src/allocator.h
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/allocator.h?rev=947385&view=auto
==============================================================================
--- avro/trunk/lang/c/src/allocator.h (added)
+++ avro/trunk/lang/c/src/allocator.h Sun May 23 09:06:55 2010
@@ -0,0 +1,39 @@
+#ifndef AVRO_ALLOCATOR_H
+#define AVRO_ALLOCATOR_H
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to you under the Apache License, Version 2.0 
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+* 
+* http://www.apache.org/licenses/LICENSE-2.0
+* 
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+* implied.  See the License for the specific language governing
+* permissions and limitations under the License. 
+*/
+
+#include <stddef.h>
+
+typedef void * (*avro_malloc_def)(size_t size);
+typedef void * (*avro_calloc_def)(size_t count, size_t size);
+typedef void * (*avro_realloc_def)(void *ptr, size_t size);
+typedef void   (*avro_free_def)(void *ptr);
+
+struct avro_allocator_t_
+{
+	avro_malloc_def  malloc;
+	avro_calloc_def  calloc;
+	avro_realloc_def realloc;
+	avro_free_def    free;
+};
+
+extern struct avro_allocator_t_ g_avro_allocator;
+
+char* avro_strdup(const char* source);
+
+#endif // AVRO_ALLOCATOR_H

Added: avro/trunk/lang/c/src/allocator_system.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/allocator_system.c?rev=947385&view=auto
==============================================================================
--- avro/trunk/lang/c/src/allocator_system.c (added)
+++ avro/trunk/lang/c/src/allocator_system.c Sun May 23 09:06:55 2010
@@ -0,0 +1,70 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to you under the Apache License, Version 2.0 
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+* 
+* http://www.apache.org/licenses/LICENSE-2.0
+* 
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+* implied.  See the License for the specific language governing
+* permissions and limitations under the License. 
+*/
+
+#include "allocator_system.h"
+#include "allocator.h"
+
+#include <stdlib.h>
+
+//------------------------------------------------------------------------------
+/**
+*/
+void
+avro_allocator_system_initialize(void)
+{
+	g_avro_allocator.malloc  = avro_allocator_system_malloc;
+	g_avro_allocator.calloc  = avro_allocator_system_calloc;
+	g_avro_allocator.realloc = avro_allocator_system_realloc;
+	g_avro_allocator.free    = avro_allocator_system_free;
+}
+
+//------------------------------------------------------------------------------
+/**
+*/
+void*
+avro_allocator_system_malloc(size_t size)
+{
+	return malloc(size);
+}
+
+//------------------------------------------------------------------------------
+/**
+*/
+void*
+avro_allocator_system_calloc(size_t count, size_t size)
+{
+	return calloc(count, size);
+}
+
+//------------------------------------------------------------------------------
+/**
+*/
+void*
+avro_allocator_system_realloc(void *ptr, size_t size)
+{
+	return realloc(ptr, size);
+}
+
+//------------------------------------------------------------------------------
+/**
+*/
+void
+avro_allocator_system_free(void *ptr)
+{
+	free(ptr);
+}
+

Added: avro/trunk/lang/c/src/allocator_system.h
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/allocator_system.h?rev=947385&view=auto
==============================================================================
--- avro/trunk/lang/c/src/allocator_system.h (added)
+++ avro/trunk/lang/c/src/allocator_system.h Sun May 23 09:06:55 2010
@@ -0,0 +1,28 @@
+#ifndef AVRO_ALLOCATOR_SYSTEM_H
+#define AVRO_ALLOCATOR_SYSTEM_H
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to you under the Apache License, Version 2.0 
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+* 
+* http://www.apache.org/licenses/LICENSE-2.0
+* 
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+* implied.  See the License for the specific language governing
+* permissions and limitations under the License. 
+*/
+
+#include <stddef.h>
+
+void  avro_allocator_system_initialize(void);
+void* avro_allocator_system_malloc(size_t size);
+void* avro_allocator_system_calloc(size_t count, size_t size);
+void* avro_allocator_system_realloc(void *ptr, size_t size);
+void  avro_allocator_system_free(void *ptr);
+
+#endif // AVRO_ALLOCATOR_SYSTEM_H

Modified: avro/trunk/lang/c/src/atom_table.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/atom_table.c?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/atom_table.c (original)
+++ avro/trunk/lang/c/src/atom_table.c Sun May 23 09:06:55 2010
@@ -16,7 +16,7 @@
  */
 
 #include "avro_private.h"
-
+#include "allocator.h"
 #include <stdlib.h>
 #include <string.h>
 
@@ -61,11 +61,11 @@ avro_atom_table_t avro_atom_table_create
 	avro_atom_table_t table;
 	int32_t i;
 
-	table = (avro_atom_table_t)malloc(sizeof(struct avro_atom_table_t_));
+	table = (avro_atom_table_t)g_avro_allocator.malloc(sizeof(struct avro_atom_table_t_));
 	table->size = size;
 	table->count = 0;
-	table->entries = malloc(sizeof(avro_atom_entry_t) * table->size);
-	table->hashtab = malloc(sizeof(int32_t) * table->size);
+	table->entries = g_avro_allocator.malloc(sizeof(avro_atom_entry_t) * table->size);
+	table->hashtab = g_avro_allocator.malloc(sizeof(int32_t) * table->size);
 	table->freelist = 0;
 
 	memset(table->entries, 0, sizeof(avro_atom_entry_t) * table->size);
@@ -85,12 +85,12 @@ void avro_atom_table_destroy(avro_atom_t
 	int32_t i;
 	for (i = 0; i < table->size; i++) {
 		if (table->entries[i].str) {
-			free(table->entries[i].str);
+			g_avro_allocator.free(table->entries[i].str);
 		}
 	}
-	free(table->entries);
-	free(table->hashtab);
-	free(table);
+	g_avro_allocator.free(table->entries);
+	g_avro_allocator.free(table->hashtab);
+	g_avro_allocator.free(table);
 }
 
 void avro_atom_table_dump(avro_atom_table_t table)
@@ -141,8 +141,8 @@ avro_atom_t avro_atom_table_add_length(a
 			new_size = table->size * 2;
 		}
 
-		table->entries = realloc(table->entries, sizeof(avro_atom_entry_t) * new_size);
-		table->hashtab = realloc(table->hashtab, sizeof(int32_t) * new_size);
+		table->entries = g_avro_allocator.realloc(table->entries, sizeof(avro_atom_entry_t)
* new_size);
+		table->hashtab = g_avro_allocator.realloc(table->hashtab, sizeof(int32_t) * new_size);
 
 		/* Make new string of freelist. */
 		memset(&(table->entries[table->size]), 0, sizeof(avro_atom_entry_t) * (new_size-table->size));
@@ -169,7 +169,7 @@ avro_atom_t avro_atom_table_add_length(a
 	atom = table->freelist;
 	entry = &(table->entries[atom]);
 	table->freelist = entry->next;
-	entry->str = strdup(str);
+	entry->str = avro_strdup(str);
 	entry->length = length;
 	entry->refcount = 1;
 	entry->hash_value = hash_value;
@@ -235,7 +235,7 @@ void avro_atom_table_decref(avro_atom_ta
 		bucket = _atom_string_hash(table->entries[atom].str) % table->size;
 
 		/* Free the string. */
-		free(table->entries[atom].str);
+		g_avro_allocator.free(table->entries[atom].str);
 		table->entries[atom].str = NULL;
 		table->entries[atom].length = 0;
 		table->entries[atom].hash_value = 0;

Modified: avro/trunk/lang/c/src/avro.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/avro.c?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/avro.c (original)
+++ avro/trunk/lang/c/src/avro.c Sun May 23 09:06:55 2010
@@ -16,12 +16,15 @@
  */
 
 #include "avro_private.h"
+#include "allocator_system.h"
 
 // TODO: Make these configurable in the future somehow
 #define INITIAL_ATOM_TABLE_SIZE 512
 
 void avro_init(void)
 {
+    avro_allocator_system_initialize();
+
 	if (NULL == g_avro_atom_table) {
 		g_avro_atom_table = avro_atom_table_create(INITIAL_ATOM_TABLE_SIZE);
 	}

Modified: avro/trunk/lang/c/src/datafile.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/datafile.c?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/datafile.c (original)
+++ avro/trunk/lang/c/src/datafile.c Sun May 23 09:06:55 2010
@@ -17,6 +17,7 @@
 
 #include "avro_private.h"
 #include "encoding.h"
+#include "allocator.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
@@ -133,13 +134,13 @@ avro_file_writer_create(const char *path
 	if (!path || !is_avro_schema(schema) || !writer) {
 		return EINVAL;
 	}
-	w = malloc(sizeof(struct avro_file_writer_t_));
+	w = g_avro_allocator.malloc(sizeof(struct avro_file_writer_t_));
 	if (!w) {
 		return ENOMEM;
 	}
 	rval = file_writer_create(path, schema, w);
 	if (rval) {
-		free(w);
+		g_avro_allocator.free(w);
 		return rval;
 	}
 	*writer = w;
@@ -200,7 +201,7 @@ static int file_writer_open(const char *
 	/* Position to end of file and get ready to write */
 	rval = file_writer_init_fp(path, "a", w);
 	if (rval) {
-		free(w);
+		g_avro_allocator.free(w);
 	}
 	return rval;
 }
@@ -212,13 +213,13 @@ int avro_file_writer_open(const char *pa
 	if (!path || !writer) {
 		return EINVAL;
 	}
-	w = malloc(sizeof(struct avro_file_writer_t_));
+	w = g_avro_allocator.malloc(sizeof(struct avro_file_writer_t_));
 	if (!w) {
 		return ENOMEM;
 	}
 	rval = file_writer_open(path, w);
 	if (rval) {
-		free(w);
+		g_avro_allocator.free(w);
 		return rval;
 	}
 
@@ -240,7 +241,7 @@ int avro_file_reader(const char *path, a
 {
 	int rval;
 	FILE *fp;
-	avro_file_reader_t r = malloc(sizeof(struct avro_file_reader_t_));
+	avro_file_reader_t r = g_avro_allocator.malloc(sizeof(struct avro_file_reader_t_));
 	if (!r) {
 		return ENOMEM;
 	}

Modified: avro/trunk/lang/c/src/datum.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/datum.c?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/datum.c (original)
+++ avro/trunk/lang/c/src/datum.c Sun May 23 09:06:55 2010
@@ -21,6 +21,7 @@
 #include <errno.h>
 #include "datum.h"
 #include "encoding.h"
+#include "allocator.h"
 
 #define DEFAULT_ARRAY_SIZE 10
 #define DEFAULT_FIELD_COUNT 10
@@ -37,7 +38,7 @@ static avro_datum_t avro_string_private(
 					void (*string_free) (void *ptr))
 {
 	struct avro_string_datum_t *datum =
-	    malloc(sizeof(struct avro_string_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_string_datum_t));
 	if (!datum) {
 		return NULL;
 	}
@@ -50,16 +51,16 @@ static avro_datum_t avro_string_private(
 
 avro_datum_t avro_string(const char *str)
 {
-	char *p = strdup(str);
+	char *p = avro_strdup(str);
 	if (!p) {
 		return NULL;
 	}
-	return avro_string_private(p, free);
+	return avro_string_private(p, g_avro_allocator.free);
 }
 
 avro_datum_t avro_givestring(const char *str)
 {
-	return avro_string_private((char *)str, free);
+	return avro_string_private((char *)str, g_avro_allocator.free);
 }
 
 avro_datum_t avro_wrapstring(const char *str)
@@ -94,21 +95,21 @@ static int avro_string_set_private(avro_
 
 int avro_string_set(avro_datum_t datum, const char *p)
 {
-	char *string_copy = strdup(p);
+	char *string_copy = avro_strdup(p);
 	int rval;
 	if (!string_copy) {
 		return ENOMEM;
 	}
-	rval = avro_string_set_private(datum, p, free);
+	rval = avro_string_set_private(datum, p, g_avro_allocator.free);
 	if (rval) {
-		free(string_copy);
+		g_avro_allocator.free(string_copy);
 	}
 	return rval;
 }
 
 int avro_givestring_set(avro_datum_t datum, const char *p)
 {
-	return avro_string_set_private(datum, p, free);
+	return avro_string_set_private(datum, p, g_avro_allocator.free);
 }
 
 int avro_wrapstring_set(avro_datum_t datum, const char *p)
@@ -120,7 +121,7 @@ static avro_datum_t avro_bytes_private(c
 				       void (*bytes_free) (void *ptr))
 {
 	struct avro_bytes_datum_t *datum;
-	datum = malloc(sizeof(struct avro_bytes_datum_t));
+	datum = g_avro_allocator.malloc(sizeof(struct avro_bytes_datum_t));
 	if (!datum) {
 		return NULL;
 	}
@@ -134,17 +135,17 @@ static avro_datum_t avro_bytes_private(c
 
 avro_datum_t avro_bytes(const char *bytes, int64_t size)
 {
-	char *bytes_copy = malloc(size);
+	char *bytes_copy = g_avro_allocator.malloc(size);
 	if (!bytes_copy) {
 		return NULL;
 	}
 	memcpy(bytes_copy, bytes, size);
-	return avro_bytes_private(bytes_copy, size, free);
+	return avro_bytes_private(bytes_copy, size, g_avro_allocator.free);
 }
 
 avro_datum_t avro_givebytes(const char *bytes, int64_t size)
 {
-	return avro_bytes_private((char *)bytes, size, free);
+	return avro_bytes_private((char *)bytes, size, g_avro_allocator.free);
 }
 
 avro_datum_t avro_wrapbytes(const char *bytes, int64_t size)
@@ -177,14 +178,14 @@ static int avro_bytes_set_private(avro_d
 int avro_bytes_set(avro_datum_t datum, const char *bytes, const int64_t size)
 {
 	int rval;
-	char *bytes_copy = malloc(size);
+	char *bytes_copy = g_avro_allocator.malloc(size);
 	if (!bytes_copy) {
 		return ENOMEM;
 	}
 	memcpy(bytes_copy, bytes, size);
-	rval = avro_bytes_set_private(datum, bytes, size, free);
+	rval = avro_bytes_set_private(datum, bytes, size, g_avro_allocator.free);
 	if (rval) {
-		free(bytes_copy);
+		g_avro_allocator.free(bytes_copy);
 	}
 	return rval;
 }
@@ -192,7 +193,7 @@ int avro_bytes_set(avro_datum_t datum, c
 int avro_givebytes_set(avro_datum_t datum, const char *bytes,
 		       const int64_t size)
 {
-	return avro_bytes_set_private(datum, bytes, size, free);
+	return avro_bytes_set_private(datum, bytes, size, g_avro_allocator.free);
 }
 
 int avro_wrapbytes_set(avro_datum_t datum, const char *bytes,
@@ -214,7 +215,7 @@ int avro_bytes_get(avro_datum_t datum, c
 avro_datum_t avro_int32(int32_t i)
 {
 	struct avro_int32_datum_t *datum =
-	    malloc(sizeof(struct avro_int32_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_int32_datum_t));
 	if (!datum) {
 		return NULL;
 	}
@@ -247,7 +248,7 @@ int avro_int32_set(avro_datum_t datum, c
 avro_datum_t avro_int64(int64_t l)
 {
 	struct avro_int64_datum_t *datum =
-	    malloc(sizeof(struct avro_int64_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_int64_datum_t));
 	if (!datum) {
 		return NULL;
 	}
@@ -280,7 +281,7 @@ int avro_int64_set(avro_datum_t datum, c
 avro_datum_t avro_float(float f)
 {
 	struct avro_float_datum_t *datum =
-	    malloc(sizeof(struct avro_float_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_float_datum_t));
 	if (!datum) {
 		return NULL;
 	}
@@ -313,7 +314,7 @@ int avro_float_get(avro_datum_t datum, f
 avro_datum_t avro_double(double d)
 {
 	struct avro_double_datum_t *datum =
-	    malloc(sizeof(struct avro_double_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_double_datum_t));
 	if (!datum) {
 		return NULL;
 	}
@@ -346,7 +347,7 @@ int avro_double_get(avro_datum_t datum, 
 avro_datum_t avro_boolean(int8_t i)
 {
 	struct avro_boolean_datum_t *datum =
-	    malloc(sizeof(struct avro_boolean_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_boolean_datum_t));
 	if (!datum) {
 		return NULL;
 	}
@@ -388,7 +389,7 @@ avro_datum_t avro_null(void)
 avro_datum_t avro_union(int64_t discriminant, avro_datum_t value)
 {
 	struct avro_union_datum_t *datum =
-	    malloc(sizeof(struct avro_union_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_union_datum_t));
 	if (!datum) {
 		return NULL;
 	}
@@ -402,39 +403,39 @@ avro_datum_t avro_union(int64_t discrimi
 avro_datum_t avro_record(const char *name, const char *space)
 {
 	struct avro_record_datum_t *datum =
-	    malloc(sizeof(struct avro_record_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_record_datum_t));
 	if (!datum) {
 		return NULL;
 	}
-	datum->name = strdup(name);
+	datum->name = avro_strdup(name);
 	if (!datum->name) {
-		free(datum);
+		g_avro_allocator.free(datum);
 		return NULL;
 	}
-	datum->space = space ? strdup(space) : NULL;
+	datum->space = space ? avro_strdup(space) : NULL;
 	if (space && !datum->space) {
-		free((void *)datum->name);
-		free((void *)datum);
+		g_avro_allocator.free((void *)datum->name);
+		g_avro_allocator.free((void *)datum);
 		return NULL;
 	}
 	datum->alloc_fields = DEFAULT_FIELD_COUNT;
-	datum->field_order = (avro_atom_t*)malloc(datum->alloc_fields * sizeof(avro_atom_t));
+	datum->field_order = (avro_atom_t*)g_avro_allocator.malloc(datum->alloc_fields * sizeof(avro_atom_t));
 	if (!datum->field_order) {
 		if (space) {
-			free((void *)datum->space);
+			g_avro_allocator.free((void *)datum->space);
 		}
-		free((char *)datum->name);
-		free(datum);
+		g_avro_allocator.free((char *)datum->name);
+		g_avro_allocator.free(datum);
 		return NULL;
 	}
 	datum->fields_byname = st_init_numtable_with_size(DEFAULT_TABLE_SIZE);
 	if (!datum->fields_byname) {
-		free(datum->field_order);
+		g_avro_allocator.free(datum->field_order);
 		if (space) {
-			free((void *)datum->space);
+			g_avro_allocator.free((void *)datum->space);
 		}
-		free((char *)datum->name);
-		free(datum);
+		g_avro_allocator.free((char *)datum->name);
+		g_avro_allocator.free(datum);
 		return NULL;
 	}
 	datum->num_fields = 0;
@@ -477,7 +478,7 @@ avro_record_set(const avro_datum_t datum
 			    avro_datum_to_record(datum);
 			if ((record->num_fields + 1) > record->alloc_fields) {
 				record->alloc_fields *= 2;
-				record->field_order = (avro_atom_t*)realloc(record->field_order,
+				record->field_order = (avro_atom_t*)g_avro_allocator.realloc(record->field_order,
 				    (record->alloc_fields) * sizeof(avro_atom_t));
 			}
 			avro_atom_incref(field_name);
@@ -495,11 +496,11 @@ avro_record_set(const avro_datum_t datum
 avro_datum_t avro_enum(const char *name, int i)
 {
 	struct avro_enum_datum_t *datum =
-	    malloc(sizeof(struct avro_enum_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_enum_datum_t));
 	if (!datum) {
 		return NULL;
 	}
-	datum->name = strdup(name);
+	datum->name = avro_strdup(name);
 	datum->value = i;
 
 	avro_datum_init(&datum->obj, AVRO_ENUM);
@@ -511,11 +512,11 @@ static avro_datum_t avro_fixed_private(c
 				       void (*fixed_free) (void *ptr))
 {
 	struct avro_fixed_datum_t *datum =
-	    malloc(sizeof(struct avro_fixed_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_fixed_datum_t));
 	if (!datum) {
 		return NULL;
 	}
-	datum->name = strdup(name);
+	datum->name = avro_strdup(name);
 	datum->size = size;
 	datum->bytes = (char *)bytes;
 	datum->free = fixed_free;
@@ -526,12 +527,12 @@ static avro_datum_t avro_fixed_private(c
 
 avro_datum_t avro_fixed(const char *name, const char *bytes, const int64_t size)
 {
-	char *bytes_copy = malloc(size);
+	char *bytes_copy = g_avro_allocator.malloc(size);
 	if (!bytes_copy) {
 		return NULL;
 	}
 	memcpy(bytes_copy, bytes, size);
-	return avro_fixed_private(name, bytes, size, free);
+	return avro_fixed_private(name, bytes, size, g_avro_allocator.free);
 }
 
 avro_datum_t avro_wrapfixed(const char *name, const char *bytes,
@@ -543,7 +544,7 @@ avro_datum_t avro_wrapfixed(const char *
 avro_datum_t avro_givefixed(const char *name, const char *bytes,
 			    const int64_t size)
 {
-	return avro_fixed_private(name, bytes, size, free);
+	return avro_fixed_private(name, bytes, size, g_avro_allocator.free);
 }
 
 static int avro_fixed_set_private(avro_datum_t datum, const char *bytes,
@@ -571,14 +572,14 @@ static int avro_fixed_set_private(avro_d
 int avro_fixed_set(avro_datum_t datum, const char *bytes, const int64_t size)
 {
 	int rval;
-	char *bytes_copy = malloc(size);
+	char *bytes_copy = g_avro_allocator.malloc(size);
 	if (!bytes_copy) {
 		return ENOMEM;
 	}
 	memcpy(bytes_copy, bytes, size);
-	rval = avro_fixed_set_private(datum, bytes, size, free);
+	rval = avro_fixed_set_private(datum, bytes, size, g_avro_allocator.free);
 	if (rval) {
-		free(bytes_copy);
+		g_avro_allocator.free(bytes_copy);
 	}
 	return rval;
 }
@@ -586,7 +587,7 @@ int avro_fixed_set(avro_datum_t datum, c
 int avro_givefixed_set(avro_datum_t datum, const char *bytes,
 		       const int64_t size)
 {
-	return avro_fixed_set_private(datum, bytes, size, free);
+	return avro_fixed_set_private(datum, bytes, size, g_avro_allocator.free);
 }
 
 int avro_wrapfixed_set(avro_datum_t datum, const char *bytes,
@@ -608,13 +609,13 @@ int avro_fixed_get(avro_datum_t datum, c
 avro_datum_t avro_map(void)
 {
 	struct avro_map_datum_t *datum =
-	    malloc(sizeof(struct avro_map_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_map_datum_t));
 	if (!datum) {
 		return NULL;
 	}
 	datum->map = st_init_strtable_with_size(DEFAULT_TABLE_SIZE);
 	if (!datum->map) {
-		free(datum);
+		g_avro_allocator.free(datum);
 		return NULL;
 	}
 
@@ -660,7 +661,7 @@ avro_map_set(const avro_datum_t datum, c
 		avro_datum_decref(old_datum);
 	} else {
 		/* Inserting a new value */
-		save_key = strdup(key);
+		save_key = avro_strdup(key);
 		if (!save_key) {
 			return ENOMEM;
 		}
@@ -674,14 +675,14 @@ avro_map_set(const avro_datum_t datum, c
 avro_datum_t avro_array(void)
 {
 	struct avro_array_datum_t *datum =
-	    malloc(sizeof(struct avro_array_datum_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_array_datum_t));
 	if (!datum) {
 		return NULL;
 	}
 	datum->alloc_els = DEFAULT_ARRAY_SIZE;
- 	datum->els = malloc(datum->alloc_els * sizeof(avro_datum_t));
+ 	datum->els = g_avro_allocator.malloc(datum->alloc_els * sizeof(avro_datum_t));
 	if (!datum->els) {
-		free(datum);
+		g_avro_allocator.free(datum);
 		return NULL;
 	}
  	datum->num_els = 0;
@@ -715,7 +716,7 @@ avro_array_append_datum(const avro_datum
 	array = avro_datum_to_array(array_datum);
 	if ((array->num_els + 1) > array->alloc_els) {
 		array->alloc_els *= 2;
-		array->els = (avro_datum_t *)realloc(array->els,
+		array->els = (avro_datum_t *)g_avro_allocator.realloc(array->els,
 				    (array->alloc_els) * sizeof(avro_datum_t));
 	}
 	array->els[array->num_els++] = avro_datum_incref(datum);
@@ -736,7 +737,7 @@ static int char_datum_free_foreach(char 
 	AVRO_UNUSED(arg);
 
 	avro_datum_decref(datum);
-	free(key);
+	g_avro_allocator.free(key);
 	return ST_DELETE;
 }
 
@@ -750,7 +751,7 @@ static void avro_datum_free(avro_datum_t
 				if (string->free) {
 					string->free(string->s);
 				}
-				free(string);
+				g_avro_allocator.free(string);
 			}
 			break;
 		case AVRO_BYTES:{
@@ -759,37 +760,37 @@ static void avro_datum_free(avro_datum_t
 				if (bytes->free) {
 					bytes->free(bytes->bytes);
 				}
-				free(bytes);
+				g_avro_allocator.free(bytes);
 			}
 			break;
 		case AVRO_INT32:{
 				struct avro_int32_datum_t *i;
 				i = avro_datum_to_int32(datum);
-				free(i);
+				g_avro_allocator.free(i);
 			}
 			break;
 		case AVRO_INT64:{
 				struct avro_int64_datum_t *l;
 				l = avro_datum_to_int64(datum);
-				free(l);
+				g_avro_allocator.free(l);
 			}
 			break;
 		case AVRO_FLOAT:{
 				struct avro_float_datum_t *f;
 				f = avro_datum_to_float(datum);
-				free(f);
+				g_avro_allocator.free(f);
 			}
 			break;
 		case AVRO_DOUBLE:{
 				struct avro_double_datum_t *d;
 				d = avro_datum_to_double(datum);
-				free(d);
+				g_avro_allocator.free(d);
 			}
 			break;
 		case AVRO_BOOLEAN:{
 				struct avro_boolean_datum_t *b;
 				b = avro_datum_to_boolean(datum);
-				free(b);
+				g_avro_allocator.free(b);
 			}
 			break;
 		case AVRO_NULL:
@@ -800,35 +801,35 @@ static void avro_datum_free(avro_datum_t
 				int i;
 				struct avro_record_datum_t *record;
 				record = avro_datum_to_record(datum);
-				free((void *)record->name);
+				g_avro_allocator.free((void *)record->name);
 				if (record->space) {
-					free((void *)record->space);
+					g_avro_allocator.free((void *)record->space);
 				}
 				st_foreach(record->fields_byname,
 					   atom_datum_free_foreach, 0);
 				for (i = 0; i < record->num_fields; i++) {
 					avro_atom_decref(record->field_order[i]);
 				}
-				free(record->field_order);
+				g_avro_allocator.free(record->field_order);
 				st_free_table(record->fields_byname);
-				free(record);
+				g_avro_allocator.free(record);
 			}
 			break;
 		case AVRO_ENUM:{
 				struct avro_enum_datum_t *enump;
 				enump = avro_datum_to_enum(datum);
-				free((void *)enump->name);
-				free(enump);
+				g_avro_allocator.free((void *)enump->name);
+				g_avro_allocator.free(enump);
 			}
 			break;
 		case AVRO_FIXED:{
 				struct avro_fixed_datum_t *fixed;
 				fixed = avro_datum_to_fixed(datum);
-				free((void *)fixed->name);
+				g_avro_allocator.free((void *)fixed->name);
 				if (fixed->free) {
 					fixed->free((void *)fixed->bytes);
 				}
-				free(fixed);
+				g_avro_allocator.free(fixed);
 			}
 			break;
 		case AVRO_MAP:{
@@ -837,7 +838,7 @@ static void avro_datum_free(avro_datum_t
 				st_foreach(map->map, char_datum_free_foreach,
 					   0);
 				st_free_table(map->map);
-				free(map);
+				g_avro_allocator.free(map);
 			}
 			break;
 		case AVRO_ARRAY:{
@@ -847,15 +848,15 @@ static void avro_datum_free(avro_datum_t
 				for (i = 0; i < array->num_els; i++) {
 					avro_datum_decref(array->els[i]);
 				}
-				free(array->els);
-				free(array);
+				g_avro_allocator.free(array->els);
+				g_avro_allocator.free(array);
 			}
 			break;
 		case AVRO_UNION:{
 				struct avro_union_datum_t *unionp;
 				unionp = avro_datum_to_union(datum);
 				avro_datum_decref(unionp->value);
-				free(unionp);
+				g_avro_allocator.free(unionp);
 			}
 			break;
 		case AVRO_LINK:{

Modified: avro/trunk/lang/c/src/datum_read.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/datum_read.c?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/datum_read.c (original)
+++ avro/trunk/lang/c/src/datum_read.c Sun May 23 09:06:55 2010
@@ -22,6 +22,7 @@
 #include "encoding.h"
 #include "schema.h"
 #include "datum.h"
+#include "allocator.h"
 
 int
 avro_schema_match(avro_schema_t writers_schema, avro_schema_t readers_schema)
@@ -197,16 +198,16 @@ read_map(avro_reader_t reader, const avr
 					   avro_schema_to_map(readers_schema)->
 					   values, &value);
 			if (rval) {
-				free(key);
+				g_avro_allocator.free(key);
 				return rval;
 			}
 			rval = avro_map_set(map, key, value);
 			if (rval) {
-				free(key);
+				g_avro_allocator.free(key);
 				return rval;
 			}
 			avro_datum_decref(value);
-			free(key);
+			g_avro_allocator.free(key);
 		}
 		rval = enc->read_long(reader, &block_count);
 		if (rval) {
@@ -392,7 +393,7 @@ avro_read_data(avro_reader_t reader, avr
 			int64_t size =
 			    avro_schema_to_fixed(writers_schema)->size;
 
-			bytes = malloc(size);
+			bytes = g_avro_allocator.malloc(size);
 			if (!bytes) {
 				return ENOMEM;
 			}

Modified: avro/trunk/lang/c/src/encoding_binary.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/encoding_binary.c?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/encoding_binary.c (original)
+++ avro/trunk/lang/c/src/encoding_binary.c Sun May 23 09:06:55 2010
@@ -16,6 +16,7 @@
  */
 
 #include "avro_private.h"
+#include "allocator.h"
 #include "encoding.h"
 #include <stdlib.h>
 #include <limits.h>
@@ -126,7 +127,7 @@ static int read_bytes(avro_reader_t read
 	if (rval) {
 		return rval;
 	}
-	*bytes = malloc(*len + 1);
+	*bytes = g_avro_allocator.malloc(*len + 1);
 	if (!*bytes) {
 		return ENOMEM;
 	}

Modified: avro/trunk/lang/c/src/io.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/io.c?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/io.c (original)
+++ avro/trunk/lang/c/src/io.c Sun May 23 09:06:55 2010
@@ -21,6 +21,7 @@
 #include <errno.h>
 #include <string.h>
 #include "dump.h"
+#include "allocator.h"
 
 enum avro_io_type_t {
 	AVRO_FILE_IO,
@@ -89,7 +90,7 @@ static void writer_init(avro_writer_t wr
 avro_reader_t avro_reader_file(FILE * fp)
 {
 	struct _avro_reader_file_t *file_reader =
-	    malloc(sizeof(struct _avro_reader_file_t));
+	    g_avro_allocator.malloc(sizeof(struct _avro_reader_file_t));
 	if (!file_reader) {
 		return NULL;
 	}
@@ -102,7 +103,7 @@ avro_reader_t avro_reader_file(FILE * fp
 avro_writer_t avro_writer_file(FILE * fp)
 {
 	struct _avro_writer_file_t *file_writer =
-	    malloc(sizeof(struct _avro_writer_file_t));
+	    g_avro_allocator.malloc(sizeof(struct _avro_writer_file_t));
 	if (!file_writer) {
 		return NULL;
 	}
@@ -114,7 +115,7 @@ avro_writer_t avro_writer_file(FILE * fp
 avro_reader_t avro_reader_memory(const char *buf, int64_t len)
 {
 	struct _avro_reader_memory_t *mem_reader =
-	    malloc(sizeof(struct _avro_reader_memory_t));
+	    g_avro_allocator.malloc(sizeof(struct _avro_reader_memory_t));
 	if (!mem_reader) {
 		return NULL;
 	}
@@ -128,7 +129,7 @@ avro_reader_t avro_reader_memory(const c
 avro_writer_t avro_writer_memory(const char *buf, int64_t len)
 {
 	struct _avro_writer_memory_t *mem_writer =
-	    malloc(sizeof(struct _avro_writer_memory_t));
+	    g_avro_allocator.malloc(sizeof(struct _avro_writer_memory_t));
 	if (!mem_writer) {
 		return NULL;
 	}
@@ -346,19 +347,19 @@ void avro_reader_dump(avro_reader_t read
 void avro_reader_free(avro_reader_t reader)
 {
 	if (is_memory_io(reader)) {
-		free(avro_reader_to_memory(reader));
+		g_avro_allocator.free(avro_reader_to_memory(reader));
 	} else if (is_file_io(reader)) {
 		fclose(avro_reader_to_file(reader)->fp);
-		free(avro_reader_to_file(reader));
+		g_avro_allocator.free(avro_reader_to_file(reader));
 	}
 }
 
 void avro_writer_free(avro_writer_t writer)
 {
 	if (is_memory_io(writer)) {
-		free(avro_writer_to_memory(writer));
+		g_avro_allocator.free(avro_writer_to_memory(writer));
 	} else if (is_file_io(writer)) {
 		fclose(avro_writer_to_file(writer)->fp);
-		free(avro_writer_to_file(writer));
+		g_avro_allocator.free(avro_writer_to_file(writer));
 	}
 }

Modified: avro/trunk/lang/c/src/schema.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/schema.c?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/schema.c (original)
+++ avro/trunk/lang/c/src/schema.c Sun May 23 09:06:55 2010
@@ -25,6 +25,7 @@
 #include "jansson.h"
 #include "st.h"
 #include "schema.h"
+#include "allocator.h"
 
 #define DEFAULT_TABLE_SIZE 32
 
@@ -70,7 +71,7 @@ static int record_free_foreach(int i, st
 
 	avro_atom_decref(field->name);
 	avro_schema_decref(field->type);
-	free(field);
+	g_avro_allocator.free(field);
 	return ST_DELETE;
 }
 
@@ -79,7 +80,7 @@ static int enum_free_foreach(int i, char
 	AVRO_UNUSED(i);
 	AVRO_UNUSED(arg);
 
-	free(sym);
+	g_avro_allocator.free(sym);
 	return ST_DELETE;
 }
 
@@ -110,35 +111,35 @@ static void avro_schema_free(avro_schema
 		case AVRO_RECORD:{
 				struct avro_record_schema_t *record;
 				record = avro_schema_to_record(schema);
-				free(record->name);
+				g_avro_allocator.free(record->name);
 				if (record->space) {
-					free(record->space);
+					g_avro_allocator.free(record->space);
 				}
 				st_foreach(record->fields, record_free_foreach,
 					   0);
 				st_free_table(record->fields_byname);
 				st_free_table(record->fields);
-				free(record);
+				g_avro_allocator.free(record);
 			}
 			break;
 
 		case AVRO_ENUM:{
 				struct avro_enum_schema_t *enump;
 				enump = avro_schema_to_enum(schema);
-				free(enump->name);
+				g_avro_allocator.free(enump->name);
 				st_foreach(enump->symbols, enum_free_foreach,
 					   0);
 				st_free_table(enump->symbols);
 				st_free_table(enump->symbols_byname);
-				free(enump);
+				g_avro_allocator.free(enump);
 			}
 			break;
 
 		case AVRO_FIXED:{
 				struct avro_fixed_schema_t *fixed;
 				fixed = avro_schema_to_fixed(schema);
-				free((char *)fixed->name);
-				free(fixed);
+				g_avro_allocator.free((char *)fixed->name);
+				g_avro_allocator.free(fixed);
 			}
 			break;
 
@@ -146,7 +147,7 @@ static void avro_schema_free(avro_schema
 				struct avro_map_schema_t *map;
 				map = avro_schema_to_map(schema);
 				avro_schema_decref(map->values);
-				free(map);
+				g_avro_allocator.free(map);
 			}
 			break;
 
@@ -154,7 +155,7 @@ static void avro_schema_free(avro_schema
 				struct avro_array_schema_t *array;
 				array = avro_schema_to_array(schema);
 				avro_schema_decref(array->items);
-				free(array);
+				g_avro_allocator.free(array);
 			}
 			break;
 		case AVRO_UNION:{
@@ -163,7 +164,7 @@ static void avro_schema_free(avro_schema
 				st_foreach(unionp->branches, union_free_foreach,
 					   0);
 				st_free_table(unionp->branches);
-				free(unionp);
+				g_avro_allocator.free(unionp);
 			}
 			break;
 
@@ -171,7 +172,7 @@ static void avro_schema_free(avro_schema
 				struct avro_link_schema_t *link;
 				link = avro_schema_to_link(schema);
 				avro_schema_decref(link->to);
-				free(link);
+				g_avro_allocator.free(link);
 			}
 			break;
 		}
@@ -277,14 +278,14 @@ avro_schema_t avro_schema_null(void)
 avro_schema_t avro_schema_fixed(const char *name, const int64_t size)
 {
 	struct avro_fixed_schema_t *fixed =
-	    malloc(sizeof(struct avro_fixed_schema_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_fixed_schema_t));
 	if (!fixed) {
 		return NULL;
 	}
 	if (!is_avro_id(name)) {
 		return NULL;
 	}
-	fixed->name = strdup(name);
+	fixed->name = avro_strdup(name);
 	fixed->size = size;
 	avro_schema_init(&fixed->obj, AVRO_FIXED);
 	return &fixed->obj;
@@ -293,13 +294,13 @@ avro_schema_t avro_schema_fixed(const ch
 avro_schema_t avro_schema_union(void)
 {
 	struct avro_union_schema_t *schema =
-	    malloc(sizeof(struct avro_union_schema_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_union_schema_t));
 	if (!schema) {
 		return NULL;
 	}
 	schema->branches = st_init_numtable_with_size(DEFAULT_TABLE_SIZE);
 	if (!schema->branches) {
-		free(schema);
+		g_avro_allocator.free(schema);
 		return NULL;
 	}
 
@@ -325,7 +326,7 @@ avro_schema_union_append(const avro_sche
 avro_schema_t avro_schema_array(const avro_schema_t items)
 {
 	struct avro_array_schema_t *array =
-	    malloc(sizeof(struct avro_array_schema_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_array_schema_t));
 	if (!array) {
 		return NULL;
 	}
@@ -337,7 +338,7 @@ avro_schema_t avro_schema_array(const av
 avro_schema_t avro_schema_map(const avro_schema_t values)
 {
 	struct avro_map_schema_t *map =
-	    malloc(sizeof(struct avro_map_schema_t));
+	    g_avro_allocator.malloc(sizeof(struct avro_map_schema_t));
 	if (!map) {
 		return NULL;
 	}
@@ -353,26 +354,26 @@ avro_schema_t avro_schema_enum(const cha
 	if (!is_avro_id(name)) {
 		return NULL;
 	}
-	enump = malloc(sizeof(struct avro_enum_schema_t));
+	enump = g_avro_allocator.malloc(sizeof(struct avro_enum_schema_t));
 	if (!enump) {
 		return NULL;
 	}
-	enump->name = strdup(name);
+	enump->name = avro_strdup(name);
 	if (!enump->name) {
-		free(enump);
+		g_avro_allocator.free(enump);
 		return NULL;
 	}
 	enump->symbols = st_init_numtable_with_size(DEFAULT_TABLE_SIZE);
 	if (!enump->symbols) {
-		free(enump->name);
-		free(enump);
+		g_avro_allocator.free(enump->name);
+		g_avro_allocator.free(enump);
 		return NULL;
 	}
 	enump->symbols_byname = st_init_strtable_with_size(DEFAULT_TABLE_SIZE);
 	if (!enump->symbols_byname) {
 		st_free_table(enump->symbols);
-		free(enump->name);
-		free(enump);
+		g_avro_allocator.free(enump->name);
+		g_avro_allocator.free(enump);
 		return NULL;
 	}
 	avro_schema_init(&enump->obj, AVRO_ENUM);
@@ -390,7 +391,7 @@ avro_schema_enum_symbol_append(const avr
 		return EINVAL;
 	}
 	enump = avro_schema_to_enum(enum_schema);
-	sym = strdup(symbol);
+	sym = avro_strdup(symbol);
 	if (!sym) {
 		return ENOMEM;
 	}
@@ -413,7 +414,7 @@ avro_schema_record_field_append(const av
 		return EINVAL;
 	}
 	record = avro_schema_to_record(record_schema);
-	new_field = malloc(sizeof(struct avro_record_field_t));
+	new_field = g_avro_allocator.malloc(sizeof(struct avro_record_field_t));
 	if (!new_field) {
 		return ENOMEM;
 	}
@@ -432,35 +433,35 @@ avro_schema_t avro_schema_record(const c
 	if (!is_avro_id(name)) {
 		return NULL;
 	}
-	record = malloc(sizeof(struct avro_record_schema_t));
+	record = g_avro_allocator.malloc(sizeof(struct avro_record_schema_t));
 	if (!record) {
 		return NULL;
 	}
-	record->name = strdup(name);
+	record->name = avro_strdup(name);
 	if (!record->name) {
-		free(record);
+		g_avro_allocator.free(record);
 		return NULL;
 	}
-	record->space = space ? strdup(space) : NULL;
+	record->space = space ? avro_strdup(space) : NULL;
 	if (space && !record->space) {
-		free(record->name);
-		free(record);
+		g_avro_allocator.free(record->name);
+		g_avro_allocator.free(record);
 		return NULL;
 	}
 	record->fields = st_init_numtable_with_size(DEFAULT_TABLE_SIZE);
 	if (!record->fields) {
 		if (record->space) {
-			free(record->space);
+			g_avro_allocator.free(record->space);
 		}
-		free(record->name);
-		free(record);
+		g_avro_allocator.free(record->name);
+		g_avro_allocator.free(record);
 		return NULL;
 	}
 	record->fields_byname = st_init_numtable_with_size(DEFAULT_TABLE_SIZE);
 	if (!record->fields_byname) {
 		st_free_table(record->fields);
-		free(record->name);
-		free(record);
+		g_avro_allocator.free(record->name);
+		g_avro_allocator.free(record);
 		return NULL;
 	}
 	record->num_fields = 0;
@@ -497,7 +498,7 @@ avro_schema_t avro_schema_link(avro_sche
 	if (!is_avro_named_type(to)) {
 		return NULL;
 	}
-	link = malloc(sizeof(struct avro_link_schema_t));
+	link = g_avro_allocator.malloc(sizeof(struct avro_link_schema_t));
 	if (!link) {
 		return NULL;
 	}
@@ -854,7 +855,7 @@ avro_schema_from_json(const char *jsonte
 		return EINVAL;
 	}
 
-	error = malloc(sizeof(struct avro_schema_error_t_));
+	error = g_avro_allocator.malloc(sizeof(struct avro_schema_error_t_));
 	if (!error) {
 		return ENOMEM;
 	}
@@ -862,14 +863,14 @@ avro_schema_from_json(const char *jsonte
 
 	error->named_schemas = st_init_strtable_with_size(DEFAULT_TABLE_SIZE);
 	if (!error->named_schemas) {
-		free(error);
+		g_avro_allocator.free(error);
 		return ENOMEM;
 	}
 
 	root = json_loads(jsontext, &error->json_error);
 	if (!root) {
 		st_free_table(error->named_schemas);
-		free(error);
+		g_avro_allocator.free(error);
 		return EINVAL;
 	}
 
@@ -881,7 +882,7 @@ avro_schema_from_json(const char *jsonte
 	st_free_table(error->named_schemas);
 	if (rval == 0) {
 		/* no need for an error return */
-		free(error);
+		g_avro_allocator.free(error);
 	}
 	return rval;
 }

Modified: avro/trunk/lang/c/src/st.c
URL: http://svn.apache.org/viewvc/avro/trunk/lang/c/src/st.c?rev=947385&r1=947384&r2=947385&view=diff
==============================================================================
--- avro/trunk/lang/c/src/st.c (original)
+++ avro/trunk/lang/c/src/st.c Sun May 23 09:06:55 2010
@@ -13,6 +13,7 @@
 #include <string.h>
 
 #include "st.h"
+#include "allocator.h"
 
 typedef struct st_table_entry st_table_entry;
 
@@ -58,8 +59,8 @@ static void rehash(st_table *);
 #define calloc xcalloc
 #endif
 
-#define alloc(type) (type*)malloc((unsigned)sizeof(type))
-#define Calloc(n,s) (char*)calloc((n),(s))
+#define alloc(type) (type*)g_avro_allocator.malloc((unsigned)sizeof(type))
+#define Calloc(n,s) (char*)g_avro_allocator.calloc((n),(s))
 
 #define EQUAL(table,x,y) ((x)==(y) || (*table->type->compare)((x),(y)) == 0)
 
@@ -207,12 +208,12 @@ st_table *table;
 		ptr = table->bins[i];
 		while (ptr != 0) {
 			next = ptr->next;
-			free(ptr);
+			g_avro_allocator.free(ptr);
 			ptr = next;
 		}
 	}
-	free(table->bins);
-	free(table);
+	g_avro_allocator.free(table->bins);
+	g_avro_allocator.free(table);
 }
 
 #define PTR_NOT_EQUAL(table, ptr, hash_val, key) \
@@ -327,7 +328,7 @@ register st_table *table;
 			ptr = next;
 		}
 	}
-	free(table->bins);
+	g_avro_allocator.free(table->bins);
 	table->num_bins = new_num_bins;
 	table->bins = new_bins;
 }
@@ -349,7 +350,7 @@ st_table *old_table;
 	    Calloc((unsigned)num_bins, sizeof(st_table_entry *));
 
 	if (new_table->bins == 0) {
-		free(new_table);
+		g_avro_allocator.free(new_table);
 		return 0;
 	}
 
@@ -359,8 +360,8 @@ st_table *old_table;
 		while (ptr != 0) {
 			entry = alloc(st_table_entry);
 			if (entry == 0) {
-				free(new_table->bins);
-				free(new_table);
+				g_avro_allocator.free(new_table->bins);
+				g_avro_allocator.free(new_table);
 				return 0;
 			}
 			*entry = *ptr;
@@ -396,7 +397,7 @@ st_data_t *value;
 		if (value != 0)
 			*value = ptr->record;
 		*key = ptr->key;
-		free(ptr);
+		g_avro_allocator.free(ptr);
 		return 1;
 	}
 
@@ -408,7 +409,7 @@ st_data_t *value;
 			if (value != 0)
 				*value = tmp->record;
 			*key = tmp->key;
-			free(tmp);
+			g_avro_allocator.free(tmp);
 			return 1;
 		}
 	}
@@ -515,7 +516,7 @@ st_data_t arg;
 					last->next = ptr->next;
 				}
 				ptr = ptr->next;
-				free(tmp);
+				g_avro_allocator.free(tmp);
 				table->num_entries--;
 			}
 		}



Mime
View raw message