agoo 2.5.5 → 2.5.6

data/ext/agoo/error_stream.c

@@ -7,9 +7,9 @@
 
 static VALUE	es_class = Qundef;
 
-typedef struct _ErrorStream {
-    Server	server;
-    Text	text;
+typedef struct _errorStream {
+    agooServer	server;
+    agooText	text;
 } *ErrorStream;
 
 static void
@@ -24,10 +24,10 @@ es_free(void *ptr) {
 
 VALUE
 error_stream_new() {
-    ErrorStream	es = ALLOC(struct _ErrorStream);
+    ErrorStream	es = ALLOC(struct _errorStream);
 
     DEBUG_ALLOC(mem_err_stream, es)
-    es->text = text_allocate(1024);
+    es->text = agoo_text_allocate(1024);
     
     return Data_Wrap_Struct(es_class, NULL, es_free, es);
 }
@@ -43,8 +43,8 @@ static VALUE
 es_puts(VALUE self, VALUE str) {
     ErrorStream	es = (ErrorStream)DATA_PTR(self);
 
-    es->text = text_append(es->text, StringValuePtr(str), (int)RSTRING_LEN(str));
-    es->text = text_append(es->text, "\n", 1);
+    es->text = agoo_text_append(es->text, StringValuePtr(str), (int)RSTRING_LEN(str));
+    es->text = agoo_text_append(es->text, "\n", 1);
 
     return Qnil;
 }
@@ -60,7 +60,7 @@ es_write(VALUE self, VALUE str) {
     ErrorStream	es = (ErrorStream)DATA_PTR(self);
     int		cnt = (int)RSTRING_LEN(str);
     
-    es->text = text_append(es->text, StringValuePtr(str), cnt);
+    es->text = agoo_text_append(es->text, StringValuePtr(str), cnt);
 
     return INT2NUM(cnt);
 }
@@ -75,7 +75,7 @@ static VALUE
 es_flush(VALUE self) {
     ErrorStream	es = (ErrorStream)DATA_PTR(self);
 
-    log_cat(&error_cat, "%s", es->text->text);
+    agoo_log_cat(&agoo_error_cat, "%s", es->text->text);
     es->text->len = 0;
 
     return self;

data/ext/agoo/extconf.rb

@@ -10,6 +10,9 @@ $CFLAGS += " -DPLATFORM_LINUX" if 'x86_64-linux' == RUBY_PLATFORM
 # does not work to check args with varargs s just remove the check.
 CONFIG['warnflags'].slice!(/ -Wsuggest-attribute=format/)
 
+have_header('stdatomic.h')
+#have_header('sys/epoll.h')
+
 create_makefile(File.join(extension_name, extension_name))
 
 puts ">>>>> Created Makefile for #{RUBY_DESCRIPTION.split(' ')[0]} version #{RUBY_VERSION} on #{RUBY_PLATFORM} <<<<<"

data/ext/agoo/gqlintro.c

@@ -39,7 +39,7 @@ schema_query_type_resolve(gqlRef target, const char *fieldName, gqlKeyVal *args)
 }
 
 static int
-create_schema_type(Err err) {
+create_schema_type(agooErr err) {
     if (NULL == (schema_type = gql_type_create(err, "__Schema", NULL, -1, true, NULL)) ||
 	NULL == gql_type_field(err, schema_type, "types", type_type, NULL, true, true, true, schema_types_resolve) ||
 	NULL == gql_type_field(err, schema_type, "queryType", type_type, NULL, true, false, false, schema_query_type_resolve) ||
@@ -51,7 +51,7 @@ create_schema_type(Err err) {
     }
     schema_type->core = true;
     
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 // type __Type {
@@ -66,7 +66,7 @@ create_schema_type(Err err) {
 //   ofType: __Type
 // }
 static int
-create_type_type(Err err) {
+create_type_type(agooErr err) {
     gqlField	fields = NULL;
     gqlField	enum_values = NULL;
     gqlValue	dv;
@@ -93,11 +93,11 @@ create_type_type(Err err) {
 
 	return err->code;
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 static int
-create_type_kind_type(Err err) {
+create_type_kind_type(agooErr err) {
     const char	*choices[] = {
 	"SCALAR",
 	"OBJECT",
@@ -114,7 +114,7 @@ create_type_kind_type(Err err) {
     type_kind_type = gql_enum_create(err, "__TypeKind", NULL, -1, true);
     type_kind_type->core = true;
     for (cp = choices; NULL != *cp; cp++) {
-	if (ERR_OK != gql_enum_append(err, type_kind_type, *cp, -1)) {
+	if (AGOO_ERR_OK != gql_enum_append(err, type_kind_type, *cp, -1)) {
 	    return err->code;
 	}
     }
@@ -130,7 +130,7 @@ create_type_kind_type(Err err) {
 //   deprecationReason: String
 // }
 static int
-create_field_type(Err err) {
+create_field_type(agooErr err) {
     if (NULL == (field_type = gql_type_create(err, "__Field", NULL, -1, true, NULL)) ||
 	NULL == gql_type_field(err, field_type, "name", &gql_string_type, NULL, true, false, false, NULL) ||
 	NULL == gql_type_field(err, field_type, "description", &gql_string_type, NULL, false, false, false, NULL) ||
@@ -143,7 +143,7 @@ create_field_type(Err err) {
     }
     field_type->core = true;
     
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 // type __InputValue {
@@ -153,7 +153,7 @@ create_field_type(Err err) {
 //   defaultValue: String
 // }
 static int
-create_input_type(Err err) {
+create_input_type(agooErr err) {
     if (NULL == (input_value_type = gql_type_create(err, "__InputValue", NULL, -1, true, NULL)) ||
 	NULL == gql_type_field(err, input_value_type, "name", &gql_string_type, NULL, true, false, false, NULL) ||
 	NULL == gql_type_field(err, input_value_type, "description", &gql_string_type, NULL, false, false, false, NULL) ||
@@ -164,7 +164,7 @@ create_input_type(Err err) {
     }
     input_value_type->core = true;
     
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 // type __EnumValue {
@@ -174,7 +174,7 @@ create_input_type(Err err) {
 //   deprecationReason: String
 // }
 static int
-create_enum_type(Err err) {
+create_enum_type(agooErr err) {
     if (NULL == (enum_value_type = gql_type_create(err, "__EnumValue", NULL, -1, true, NULL)) ||
 	NULL == gql_type_field(err, enum_value_type, "name", &gql_string_type, NULL, true, false, false, NULL) ||
 	NULL == gql_type_field(err, enum_value_type, "description", &gql_string_type, NULL, false, false, false, NULL) ||
@@ -185,7 +185,7 @@ create_enum_type(Err err) {
     }
     enum_value_type->core = true;
     
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 // type __Directive {
@@ -195,7 +195,7 @@ create_enum_type(Err err) {
 //   args: [__InputValue!]!
 // }
 static int
-create_directive_type(Err err) {
+create_directive_type(agooErr err) {
     if (NULL == (directive_type = gql_type_create(err, "__Directive", NULL, -1, true, NULL)) ||
 	NULL == gql_type_field(err, directive_type, "name", &gql_string_type, NULL, true, false, false, NULL) ||
 	NULL == gql_type_field(err, directive_type, "description", &gql_string_type, NULL, false, false, false, NULL) ||
@@ -206,11 +206,11 @@ create_directive_type(Err err) {
     }
     directive_type->core = true;
     
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 static int
-create_directive_location_type(Err err) {
+create_directive_location_type(agooErr err) {
     const char	*choices[] = {
 	"QUERY",
 	"MUTATION",
@@ -236,7 +236,7 @@ create_directive_location_type(Err err) {
     directive_location_type = gql_enum_create(err, "__DirectiveLocation", NULL, -1, true);
     directive_location_type->core = true;
     for (cp = choices; NULL != *cp; cp++) {
-	if (ERR_OK != gql_enum_append(err, directive_location_type, *cp, -1)) {
+	if (AGOO_ERR_OK != gql_enum_append(err, directive_location_type, *cp, -1)) {
 	    return err->code;
 	}
     }
@@ -244,72 +244,72 @@ create_directive_location_type(Err err) {
 }
 
 static int
-create_dir_skip(Err err) {
+create_dir_skip(agooErr err) {
     gqlDir	dir = gql_directive_create(err, "skip", NULL, -1, true);
 
     if (NULL == dir) {
 	return err->code;
     }
-    if (ERR_OK != gql_directive_on(err, dir, "FIELD", -1) ||
-	ERR_OK != gql_directive_on(err, dir, "FRAGMENT_SPREAD", -1) ||
-	ERR_OK != gql_directive_on(err, dir, "INLINE_FRAGMENT", -1) ||
+    if (AGOO_ERR_OK != gql_directive_on(err, dir, "FIELD", -1) ||
+	AGOO_ERR_OK != gql_directive_on(err, dir, "FRAGMENT_SPREAD", -1) ||
+	AGOO_ERR_OK != gql_directive_on(err, dir, "INLINE_FRAGMENT", -1) ||
 	NULL == gql_dir_arg(err, dir, "if", "Boolean", NULL, -1, NULL, true)) {
 
 	return err->code;
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 static int
-create_dir_include(Err err) {
+create_dir_include(agooErr err) {
     gqlDir	dir = gql_directive_create(err, "include", NULL, -1, true);
 
     if (NULL == dir) {
 	return err->code;
     }
-    if (ERR_OK != gql_directive_on(err, dir, "FIELD", -1) ||
-	ERR_OK != gql_directive_on(err, dir, "FRAGMENT_SPREAD", -1) ||
-	ERR_OK != gql_directive_on(err, dir, "INLINE_FRAGMENT", -1) ||
+    if (AGOO_ERR_OK != gql_directive_on(err, dir, "FIELD", -1) ||
+	AGOO_ERR_OK != gql_directive_on(err, dir, "FRAGMENT_SPREAD", -1) ||
+	AGOO_ERR_OK != gql_directive_on(err, dir, "INLINE_FRAGMENT", -1) ||
 	NULL == gql_dir_arg(err, dir, "if", "Boolean", NULL, -1, NULL, true)) {
 
 	return err->code;
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 static int
-create_dir_deprecated(Err err) {
+create_dir_deprecated(agooErr err) {
     gqlDir	dir = gql_directive_create(err, "deprecated", NULL, -1, true);
     gqlValue	dv;
 
     if (NULL == dir) {
 	return err->code;
     }
-    if (ERR_OK != gql_directive_on(err, dir, "FIELD_DEFINITION", -1) ||
-	ERR_OK != gql_directive_on(err, dir, "ENUM_VALUE", -1) ||
+    if (AGOO_ERR_OK != gql_directive_on(err, dir, "FIELD_DEFINITION", -1) ||
+	AGOO_ERR_OK != gql_directive_on(err, dir, "ENUM_VALUE", -1) ||
 	NULL == (dv = gql_string_create(err, "No longer supported", -1)) ||
 	NULL == gql_dir_arg(err, dir, "reason", "String", NULL, -1, dv, false)) {
 
 	return err->code;
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 int
-gql_intro_init(Err err) {
+gql_intro_init(agooErr err) {
     gqlField	f;
     
-    if (ERR_OK != create_type_kind_type(err) ||
-	ERR_OK != create_input_type(err) ||
-	ERR_OK != create_type_type(err) ||
-	ERR_OK != create_enum_type(err) ||
-	ERR_OK != create_field_type(err) ||
-	ERR_OK != create_directive_location_type(err) ||
-	ERR_OK != create_directive_type(err) ||
-	ERR_OK != create_schema_type(err) ||
-	ERR_OK != create_dir_deprecated(err) ||
-	ERR_OK != create_dir_include(err) ||
-	ERR_OK != create_dir_skip(err)) {
+    if (AGOO_ERR_OK != create_type_kind_type(err) ||
+	AGOO_ERR_OK != create_input_type(err) ||
+	AGOO_ERR_OK != create_type_type(err) ||
+	AGOO_ERR_OK != create_enum_type(err) ||
+	AGOO_ERR_OK != create_field_type(err) ||
+	AGOO_ERR_OK != create_directive_location_type(err) ||
+	AGOO_ERR_OK != create_directive_type(err) ||
+	AGOO_ERR_OK != create_schema_type(err) ||
+	AGOO_ERR_OK != create_dir_deprecated(err) ||
+	AGOO_ERR_OK != create_dir_include(err) ||
+	AGOO_ERR_OK != create_dir_skip(err)) {
 
 	return err->code;
     }
@@ -329,5 +329,5 @@ gql_intro_init(Err err) {
 	    break;
 	}
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }

data/ext/agoo/gqlintro.h

@@ -5,6 +5,6 @@
 
 #include "err.h"
 
-extern int	gql_intro_init(Err err);
+extern int	gql_intro_init(agooErr err);
 
 #endif // AGOO_GQLINTRO_H

data/ext/agoo/gqlvalue.c

@@ -12,9 +12,9 @@
 static const char	spaces[256] = "\n                                                                                                                                                                                                                                                               ";
 
 // Int type
-static Text
-null_to_text(Text text, gqlValue value, int indent, int depth) {
-    return text_append(text, "null", 4);
+static agooText
+null_to_text(agooText text, gqlValue value, int indent, int depth) {
+    return agoo_text_append(text, "null", 4);
 }
 
 struct _gqlType	gql_null_type = {
@@ -29,14 +29,14 @@ struct _gqlType	gql_null_type = {
 };
 
 // Int type
-static Text
-int_to_text(Text text, gqlValue value, int indent, int depth) {
+static agooText
+int_to_text(agooText text, gqlValue value, int indent, int depth) {
     char	num[32];
     int		cnt;
     
     cnt = snprintf(num, sizeof(num), "%lld", (long long)value->i);
 
-    return text_append(text, num, cnt);
+    return agoo_text_append(text, num, cnt);
 }
 
 struct _gqlType	gql_int_type = {
@@ -51,14 +51,14 @@ struct _gqlType	gql_int_type = {
 };
 
 // I64 type, add on type.
-static Text
-i64_to_text(Text text, gqlValue value, int indent, int depth) {
+static agooText
+i64_to_text(agooText text, gqlValue value, int indent, int depth) {
     char	num[32];
     int		cnt;
     
     cnt = snprintf(num, sizeof(num), "%lld", (long long)value->i64);
 
-    return text_append(text, num, cnt);
+    return agoo_text_append(text, num, cnt);
 }
 
 struct _gqlType	gql_i64_type = {
@@ -78,7 +78,7 @@ string_destroy(gqlValue value) {
     free((char*)value->str);
 }
 
-static Text	string_to_text(Text text, gqlValue value, int indent, int depth);
+static agooText	string_to_text(agooText text, gqlValue value, int indent, int depth);
 
 struct _gqlType	gql_string_type = {
     .name = "String",
@@ -103,29 +103,29 @@ struct _gqlType	gql_str16_type = { // unregistered
     .to_json = string_to_text,
 };
 
-static Text
-string_to_text(Text text, gqlValue value, int indent, int depth) {
+static agooText
+string_to_text(agooText text, gqlValue value, int indent, int depth) {
     if (&gql_str16_type == value->type) {
-	text = text_append(text, "\"", 1);
-	text = text_append(text, value->str16, -1);
-	text = text_append(text, "\"", 1);
+	text = agoo_text_append(text, "\"", 1);
+	text = agoo_text_append(text, value->str16, -1);
+	text = agoo_text_append(text, "\"", 1);
     } else if (NULL == value->str) {
-	text = text_append(text, "null", 4);
+	text = agoo_text_append(text, "null", 4);
     } else {
-	text = text_append(text, "\"", 1);
-	text = text_append(text, value->str, -1);
-	text = text_append(text, "\"", 1);
+	text = agoo_text_append(text, "\"", 1);
+	text = agoo_text_append(text, value->str, -1);
+	text = agoo_text_append(text, "\"", 1);
     }
     return text;
 }
 
 // Bool type
-static Text
-bool_to_text(Text text, gqlValue value, int indent, int depth) {
+static agooText
+bool_to_text(agooText text, gqlValue value, int indent, int depth) {
     if (value->b) {
-	text = text_append(text, "true", 4);
+	text = agoo_text_append(text, "true", 4);
     } else {
-	text = text_append(text, "false", 5);
+	text = agoo_text_append(text, "false", 5);
     }
     return text;
 }
@@ -142,14 +142,14 @@ struct _gqlType	gql_bool_type = {
 };
 
 // Float type
-static Text
-float_to_text(Text text, gqlValue value, int indent, int depth) {
+static agooText
+float_to_text(agooText text, gqlValue value, int indent, int depth) {
     char	num[32];
     int		cnt;
     
     cnt = snprintf(num, sizeof(num), "%g", value->f);
 
-    return text_append(text, num, cnt);
+    return agoo_text_append(text, num, cnt);
 }
 
 struct _gqlType	gql_float_type = {
@@ -201,7 +201,7 @@ read_zone(const char *s, int *vp) {
 }
 
 static int64_t
-time_parse(Err err, const char *str, int len) {
+time_parse(agooErr err, const char *str, int len) {
     const char	*s = str;
     const char	*end;
     struct tm	tm;
@@ -214,7 +214,7 @@ time_parse(Err err, const char *str, int len) {
 	len = (int)strlen(str);
     }
     if (len < 10 || 36 < len) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     end = str + len;
@@ -224,7 +224,7 @@ time_parse(Err err, const char *str, int len) {
 	neg = true;
     }
     if (NULL == (s = read_num(s, 4, &tm.tm_year))) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     if (neg) {
@@ -233,24 +233,24 @@ time_parse(Err err, const char *str, int len) {
     }
     tm.tm_year -= 1900;
     if ('-' != *s) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     s++;
 
     if (NULL == (s = read_num(s, 2, &tm.tm_mon))) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     tm.tm_mon--;
     if ('-' != *s) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     s++;
 
     if (NULL == (s = read_num(s, 2, &tm.tm_mday))) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
 
@@ -263,7 +263,7 @@ time_parse(Err err, const char *str, int len) {
 	if (s == end) {
 	    return (int64_t)timegm(&tm) * 1000000000LL;
 	}
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     case '-':
 	neg = true;
@@ -272,7 +272,7 @@ time_parse(Err err, const char *str, int len) {
 	int	v = 0;
 	
 	if (NULL == (s = read_zone(s, &v))) {
-	    err_set(err, ERR_PARSE, "Invalid time format.");
+	    agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	    return 0;
 	}
 	if (neg) {
@@ -281,41 +281,41 @@ time_parse(Err err, const char *str, int len) {
 	if (s == end) {
 	    return ((int64_t)timegm(&tm) - (int64_t)v) * 1000000000LL;
 	}
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     case 'T':
 	break;
     default:
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     // T encountered, need space for time and zone
     if (end - s < 9) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     if (NULL == (s = read_num(s, 2, &tm.tm_hour))) {
 	return 0;
     }
     if (':' != *s) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     s++;
 
     if (NULL == (s = read_num(s, 2, &tm.tm_min))) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     if (':' != *s) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     s++;
 
     if (NULL == (s = read_num(s, 2, &tm.tm_sec))) {
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     switch (*s++) {
@@ -323,7 +323,7 @@ time_parse(Err err, const char *str, int len) {
 	if (s == end) {
 	    return (int64_t)timegm(&tm) * 1000000000LL;
 	}
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     case '-':
 	neg = true;
@@ -332,11 +332,11 @@ time_parse(Err err, const char *str, int len) {
 	int	v = 0;
 
 	if (end - s < 5) {
-	    err_set(err, ERR_PARSE, "Invalid time format.");
+	    agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	    return 0;
 	}
 	if (NULL == (s = read_zone(s, &v))) {
-	    err_set(err, ERR_PARSE, "Invalid time format.");
+	    agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	    return 0;
 	}
 	if (neg) {
@@ -345,18 +345,18 @@ time_parse(Err err, const char *str, int len) {
 	if (s == end) {
 	    return ((int64_t)timegm(&tm) - (int64_t)v) * 1000000000LL;
 	}
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     case '.':
 	break;
     default:
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     for (; 0 < i; i--, s++) {
 	if (end <= s) {
-	    err_set(err, ERR_PARSE, "Invalid time format.");
+	    agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	    return 0;
 	}	
 	if ('0' <= *s && *s <= '9') {
@@ -373,7 +373,7 @@ time_parse(Err err, const char *str, int len) {
 	if (s == end) {
 	    break;
 	}
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     case '-':
 	neg = true;
@@ -382,11 +382,11 @@ time_parse(Err err, const char *str, int len) {
 	int	v = 0;
 
 	if (end - s < 5) {
-	    err_set(err, ERR_PARSE, "Invalid time format.");
+	    agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	    return 0;
 	}
 	if (NULL == (s = read_zone(s, &v))) {
-	    err_set(err, ERR_PARSE, "Invalid time format.");
+	    agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	    return 0;
 	}
 	if (neg) {
@@ -395,12 +395,12 @@ time_parse(Err err, const char *str, int len) {
 	if (s == end) {
 	    return ((int64_t)timegm(&tm) - (int64_t)v) * 1000000000LL + nsecs;
 	}
-	err_set(err, ERR_PARSE, "Invalid time format.");
+	agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	return 0;
     }
     default:
 	if (s != end) {
-	    err_set(err, ERR_PARSE, "Invalid time format.");
+	    agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	    return 0;
 	}
     }
@@ -410,8 +410,8 @@ time_parse(Err err, const char *str, int len) {
     return secs - nsecs;
 }
 
-static Text
-time_to_text(Text text, gqlValue value, int indent, int depth) {
+static agooText
+time_to_text(agooText text, gqlValue value, int indent, int depth) {
     char	str[64];
     int		cnt;
     struct tm	tm;
@@ -427,7 +427,7 @@ time_to_text(Text text, gqlValue value, int indent, int depth) {
 		  1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
 		  tm.tm_hour, tm.tm_min, tm.tm_sec, (long)nsecs);
     
-    return text_append(text, str, cnt);
+    return agoo_text_append(text, str, cnt);
 }
 
 struct _gqlType	gql_time_type = {
@@ -458,7 +458,7 @@ hexVal(int c) {
 
 // 123e4567-e89b-12d3-a456-426655440000
 static int
-parse_uuid(Err err, const char *str, int len, uint64_t *hip, uint64_t *lop) {
+parse_uuid(agooErr err, const char *str, int len, uint64_t *hip, uint64_t *lop) {
     uint64_t	hi = 0;
     uint64_t	lo = 0;
     int		i;
@@ -468,50 +468,50 @@ parse_uuid(Err err, const char *str, int len, uint64_t *hip, uint64_t *lop) {
 	len = (int)strlen(str);
     }
     if (36 != len || '-' != str[8] || '-' != str[13] || '-' != str[18] || '-' != str[23]) {
-	return err_set(err, ERR_PARSE, "not UUID format");
+	return agoo_err_set(err, AGOO_ERR_PARSE, "not UUID format");
     }
     for (i = 0; i < 8; i++, str++) {
 	if (0 > (n = hexVal(*str))) {
-	    return err_set(err, ERR_PARSE, "not UUID format");
+	    return agoo_err_set(err, AGOO_ERR_PARSE, "not UUID format");
 	}
 	hi = (hi << 4) + n;
     }
     str++;
     for (i = 0; i < 4; i++, str++) {
 	if (0 > (n = hexVal(*str))) {
-	    return err_set(err, ERR_PARSE, "not UUID format");
+	    return agoo_err_set(err, AGOO_ERR_PARSE, "not UUID format");
 	}
 	hi = (hi << 4) + n;
     }
     str++;
     for (i = 0; i < 4; i++, str++) {
 	if (0 > (n = hexVal(*str))) {
-	    return err_set(err, ERR_PARSE, "not UUID format");
+	    return agoo_err_set(err, AGOO_ERR_PARSE, "not UUID format");
 	}
 	hi = (hi << 4) + n;
     }
     str++;
     for (i = 0; i < 4; i++, str++) {
 	if (0 > (n = hexVal(*str))) {
-	    return err_set(err, ERR_PARSE, "not UUID format");
+	    return agoo_err_set(err, AGOO_ERR_PARSE, "not UUID format");
 	}
 	lo = (lo << 4) + n;
     }
     str++;
     for (i = 0; i < 12; i++, str++) {
 	if (0 > (n = hexVal(*str))) {
-	    return err_set(err, ERR_PARSE, "not UUID format");
+	    return agoo_err_set(err, AGOO_ERR_PARSE, "not UUID format");
 	}
 	lo = (lo << 4) + n;
     }
     *hip = hi;
     *lop = lo;
 
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
-static Text
-uuid_to_text(Text text, gqlValue value, int indent, int depth) {
+static agooText
+uuid_to_text(agooText text, gqlValue value, int indent, int depth) {
     char	str[64];
     int		cnt = sprintf(str, "\"%08lx-%04lx-%04lx-%04lx-%012lx\"",
 			      (unsigned long)(value->uuid.hi >> 32),
@@ -520,7 +520,7 @@ uuid_to_text(Text text, gqlValue value, int indent, int depth) {
 			      (unsigned long)(value->uuid.lo >> 48),
 			      (unsigned long)(value->uuid.lo & 0x0000FFFFFFFFFFFFUL));
 
-    return text_append(text, str, cnt);
+    return agoo_text_append(text, str, cnt);
 }
 
 struct _gqlType	gql_uuid_type = {
@@ -540,14 +540,14 @@ url_destroy(gqlValue value) {
     free((char*)value->url);
 }
 
-static Text
-url_to_text(Text text, gqlValue value, int indent, int depth) {
+static agooText
+url_to_text(agooText text, gqlValue value, int indent, int depth) {
     if (NULL == value->url) {
-	return text_append(text, "null", 4);
+	return agoo_text_append(text, "null", 4);
     }
-    text = text_append(text, "\"", 1);
-    text = text_append(text, value->url, -1);
-    text = text_append(text, "\"", 1);
+    text = agoo_text_append(text, "\"", 1);
+    text = agoo_text_append(text, value->url, -1);
+    text = agoo_text_append(text, "\"", 1);
 
     return text;
 }
@@ -576,8 +576,8 @@ list_destroy(gqlValue value) {
     }
 }
 
-static Text
-list_to_json(Text text, gqlValue value, int indent, int depth) {
+static agooText
+list_to_json(agooText text, gqlValue value, int indent, int depth) {
     int		i = indent * depth;
     int		i2 = i + indent;
     int		d2 = depth + 1;
@@ -591,18 +591,18 @@ list_to_json(Text text, gqlValue value, int indent, int depth) {
 	i2 = sizeof(spaces) - 1;
 	i = i2 - indent;
     }
-    text = text_append(text, "[", 1);
+    text = agoo_text_append(text, "[", 1);
     for (link = value->members; NULL != link; link = link->next) {
-	text = text_append(text, spaces, i2);
+	text = agoo_text_append(text, spaces, i2);
 	text = link->value->type->to_json(text, link->value, indent, d2);
 	if (NULL != link->next) {
-	    text = text_append(text, ",", 1);
+	    text = agoo_text_append(text, ",", 1);
 	}
     }
     if (0 < indent) {
-	text = text_append(text, spaces, i);
+	text = agoo_text_append(text, spaces, i);
     }
-    text = text_append(text, "]", 1);
+    text = agoo_text_append(text, "]", 1);
 
     return text;
 }
@@ -632,8 +632,8 @@ object_destroy(gqlValue value) {
     }
 }
 
-static Text
-object_to_json(Text text, gqlValue value, int indent, int depth) {
+static agooText
+object_to_json(agooText text, gqlValue value, int indent, int depth) {
     int		i = indent * depth;
     int		i2 = i + indent;
     int		d2 = depth + 1;
@@ -647,25 +647,25 @@ object_to_json(Text text, gqlValue value, int indent, int depth) {
 	i2 = sizeof(spaces) - 1;
 	i = i2 - indent;
     }
-    text = text_append(text, "{", 1);
+    text = agoo_text_append(text, "{", 1);
     for (link = value->members; NULL != link; link = link->next) {
-	text = text_append(text, spaces, i2);
-	text = text_append(text, "\"", 1);
-	text = text_append(text, link->key, -1);
+	text = agoo_text_append(text, spaces, i2);
+	text = agoo_text_append(text, "\"", 1);
+	text = agoo_text_append(text, link->key, -1);
 	if (0 < indent) {
-	    text = text_append(text, "\": ", 3);
+	    text = agoo_text_append(text, "\": ", 3);
 	} else {
-	    text = text_append(text, "\":", 2);
+	    text = agoo_text_append(text, "\":", 2);
 	}
 	text = link->value->type->to_json(text, link->value, indent, d2);
 	if (NULL != link->next) {
-	    text = text_append(text, ",", 1);
+	    text = agoo_text_append(text, ",", 1);
 	}
     }
     if (0 < indent) {
-	text = text_append(text, spaces, i);
+	text = agoo_text_append(text, spaces, i);
     }
-    text = text_append(text, "}", 1);
+    text = agoo_text_append(text, "}", 1);
 
     return text;
 }
@@ -692,18 +692,18 @@ gql_value_destroy(gqlValue value) {
 }
 
 int
-gql_value_init(Err err) {
-    if (ERR_OK != gql_type_set(err, &gql_int_type) ||
-	ERR_OK != gql_type_set(err, &gql_i64_type) ||
-	ERR_OK != gql_type_set(err, &gql_bool_type) ||
-	ERR_OK != gql_type_set(err, &gql_float_type) ||
-	ERR_OK != gql_type_set(err, &gql_time_type) ||
-	ERR_OK != gql_type_set(err, &gql_uuid_type) ||
-	ERR_OK != gql_type_set(err, &gql_url_type) ||
-	ERR_OK != gql_type_set(err, &gql_string_type)) {
+gql_value_init(agooErr err) {
+    if (AGOO_ERR_OK != gql_type_set(err, &gql_int_type) ||
+	AGOO_ERR_OK != gql_type_set(err, &gql_i64_type) ||
+	AGOO_ERR_OK != gql_type_set(err, &gql_bool_type) ||
+	AGOO_ERR_OK != gql_type_set(err, &gql_float_type) ||
+	AGOO_ERR_OK != gql_type_set(err, &gql_time_type) ||
+	AGOO_ERR_OK != gql_type_set(err, &gql_uuid_type) ||
+	AGOO_ERR_OK != gql_type_set(err, &gql_url_type) ||
+	AGOO_ERR_OK != gql_type_set(err, &gql_string_type)) {
 	return err->code;
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 /// set functions /////////////////////////////////////////////////////////////
@@ -738,7 +738,7 @@ gql_string_set(gqlValue value, const char *str, int len) {
 }
 
 int
-gql_url_set(Err err, gqlValue value, const char *url, int len) {
+gql_url_set(agooErr err, gqlValue value, const char *url, int len) {
     value->type = &gql_url_type;
     if (NULL == url) {
 	value->url = NULL;
@@ -748,7 +748,7 @@ gql_url_set(Err err, gqlValue value, const char *url, int len) {
 	}
 	value->url = strndup(url, len);
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 void
@@ -767,7 +767,7 @@ gql_time_set(gqlValue value, int64_t t) {
 }
 
 int
-gql_time_str_set(Err err, gqlValue value, const char *str, int len) {
+gql_time_str_set(agooErr err, gqlValue value, const char *str, int len) {
     if (0 >= len) {
 	len = (int)strlen(str);
     }
@@ -783,27 +783,27 @@ gql_uuid_set(gqlValue value, uint64_t hi, uint64_t lo) {
 }
 
 int
-gql_uuid_str_set(Err err, gqlValue value, const char *str, int len) {
+gql_uuid_str_set(agooErr err, gqlValue value, const char *str, int len) {
     uint64_t	hi = 0;
     uint64_t	lo = 0;
 
-    if (ERR_OK != parse_uuid(err, str, len, &hi, &lo)) {
+    if (AGOO_ERR_OK != parse_uuid(err, str, len, &hi, &lo)) {
 	return err->code;
     }
     value->uuid.hi = hi;
     value->uuid.lo = lo;
 
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 extern void	gql_null_set(gqlValue value);
 
 gqlLink
-link_create(Err err, gqlValue item) {
+link_create(agooErr err, gqlValue item) {
     gqlLink	link = (gqlLink)malloc(sizeof(struct _gqlLink));
 
     if (NULL == link) {
-	err_set(err, ERR_MEMORY, "Failed to allocation memory for a list link.");
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a list link.");
     } else {
 	DEBUG_ALLOC(mem_graphql_link, link);
 	link->next = NULL;
@@ -814,7 +814,7 @@ link_create(Err err, gqlValue item) {
 }
 
 int
-gql_list_append(Err err, gqlValue list, gqlValue item) {
+gql_list_append(agooErr err, gqlValue list, gqlValue item) {
     gqlLink	link = link_create(err, item);
 
     if (NULL != link) {
@@ -828,22 +828,22 @@ gql_list_append(Err err, gqlValue list, gqlValue item) {
 	    last->next = link;
 	}
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 int
-gql_list_prepend(Err err, gqlValue list, gqlValue item) {
+gql_list_prepend(agooErr err, gqlValue list, gqlValue item) {
     gqlLink	link = link_create(err, item);
 
     if (NULL != link) {
 	link->next = list->members;
 	list->members = link;
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 int
-gql_object_set(Err err, gqlValue obj, const char *key, gqlValue item) {
+gql_object_set(agooErr err, gqlValue obj, const char *key, gqlValue item) {
     gqlLink	link = link_create(err, item);
 
     if (NULL != link) {
@@ -859,7 +859,7 @@ gql_object_set(Err err, gqlValue obj, const char *key, gqlValue item) {
 	    last->next = link;
 	}
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 /// create functions //////////////////////////////////////////////////////////
@@ -877,7 +877,7 @@ value_create(gqlType type) {
 }
 
 gqlValue
-gql_int_create(Err err, int32_t i) {
+gql_int_create(agooErr err, int32_t i) {
     gqlValue	v = value_create(&gql_int_type);
     
     if (NULL != v) {
@@ -887,7 +887,7 @@ gql_int_create(Err err, int32_t i) {
 }
 
 gqlValue
-gql_i64_create(Err err, int64_t i) {
+gql_i64_create(agooErr err, int64_t i) {
     gqlValue	v = value_create(&gql_i64_type);
     
     if (NULL != v) {
@@ -897,7 +897,7 @@ gql_i64_create(Err err, int64_t i) {
 }
 
 gqlValue
-gql_string_create(Err err, const char *str, int len) {
+gql_string_create(agooErr err, const char *str, int len) {
     gqlValue	v;
     
     if (0 >= len) {
@@ -917,7 +917,7 @@ gql_string_create(Err err, const char *str, int len) {
 }
 
 gqlValue
-gql_url_create(Err err, const char *url, int len) {
+gql_url_create(agooErr err, const char *url, int len) {
     gqlValue	v = value_create(&gql_url_type);
     
     if (0 >= len) {
@@ -930,7 +930,7 @@ gql_url_create(Err err, const char *url, int len) {
 }
 
 gqlValue
-gql_bool_create(Err err, bool b) {
+gql_bool_create(agooErr err, bool b) {
     gqlValue	v = value_create(&gql_bool_type);
     
     if (NULL != v) {
@@ -940,7 +940,7 @@ gql_bool_create(Err err, bool b) {
 }
 
 gqlValue
-gql_float_create(Err err, double f) {
+gql_float_create(agooErr err, double f) {
     gqlValue	v = value_create(&gql_float_type);
     
     if (NULL != v) {
@@ -950,7 +950,7 @@ gql_float_create(Err err, double f) {
 }
 
 gqlValue
-gql_time_create(Err err, int64_t t) {
+gql_time_create(agooErr err, int64_t t) {
     gqlValue	v = value_create(&gql_time_type);
     
     if (NULL != v) {
@@ -960,7 +960,7 @@ gql_time_create(Err err, int64_t t) {
 }
 
 gqlValue
-gql_time_str_create(Err err, const char *str, int len) {
+gql_time_str_create(agooErr err, const char *str, int len) {
     gqlValue	v = value_create(&gql_time_type);
     
     if (NULL != v) {
@@ -973,7 +973,7 @@ gql_time_str_create(Err err, const char *str, int len) {
 }
 
 gqlValue
-gql_uuid_create(Err err, uint64_t hi, uint64_t lo) {
+gql_uuid_create(agooErr err, uint64_t hi, uint64_t lo) {
     gqlValue	v = value_create(&gql_uuid_type);
     
     if (NULL != v) {
@@ -985,12 +985,12 @@ gql_uuid_create(Err err, uint64_t hi, uint64_t lo) {
 
 // 123e4567-e89b-12d3-a456-426655440000
 gqlValue
-gql_uuid_str_create(Err err, const char *str, int len) {
+gql_uuid_str_create(agooErr err, const char *str, int len) {
     uint64_t	hi = 0;
     uint64_t	lo = 0;
     gqlValue	v;
 
-    if (ERR_OK != parse_uuid(err, str, len, &hi, &lo)) {
+    if (AGOO_ERR_OK != parse_uuid(err, str, len, &hi, &lo)) {
 	return NULL;
     }
     if (NULL != (v = value_create(&gql_uuid_type))) {
@@ -1001,14 +1001,14 @@ gql_uuid_str_create(Err err, const char *str, int len) {
 }
 
 gqlValue
-gql_null_create(Err err) {
+gql_null_create(agooErr err) {
     gqlValue	v = value_create(&gql_null_type);
     
     return v;
 }
 
 gqlValue
-gql_list_create(Err err, gqlType itemType) {
+gql_list_create(agooErr err, gqlType itemType) {
     gqlValue	v = value_create(&list_type);
 
     if (NULL != v) {
@@ -1019,7 +1019,7 @@ gql_list_create(Err err, gqlType itemType) {
 }
 
 gqlValue
-gql_object_create(Err err) {
+gql_object_create(agooErr err) {
     gqlValue	v = value_create(&object_type);
 
     if (NULL != v) {
@@ -1029,7 +1029,7 @@ gql_object_create(Err err) {
     return v;
 }
 
-Text
-gql_value_json(Text text, gqlValue value, int indent, int depth) {
+agooText
+gql_value_json(agooText text, gqlValue value, int indent, int depth) {
     return value->type->to_json(text, value, indent, depth);
 }