agoo 2.5.7 → 2.6.0

data/ext/agoo/debug.h

@@ -3,62 +3,42 @@
 #ifndef AGOO_DEBUG_H
 #define AGOO_DEBUG_H
 
-#include "atomic.h"
+#include <stdlib.h>
 
 #ifdef MEM_DEBUG
-#define DEBUG_ALLOC(var, ptr) { atomic_fetch_add(&var, 1); debug_add(ptr, #var, FILE, LINE); }
-#define DEBUG_REALLOC(var, orig, ptr) { debug_update(orig, ptr, #var, FILE, LINE); }
-#define DEBUG_FREE(var, ptr) { atomic_fetch_sub(&var, 1); debug_del(ptr, FILE, LINE); }
+
+#define AGOO_MALLOC(size) agoo_malloc(size, __FILE__, __LINE__)
+#define AGOO_ALLOC(ptr, size) agoo_alloc(ptr, size, __FILE__, __LINE__)
+#define AGOO_REALLOC(ptr, size) agoo_realloc(ptr, size, __FILE__, __LINE__)
+#define AGOO_STRDUP(str) agoo_strdup(str, __FILE__, __LINE__)
+#define AGOO_STRNDUP(str, len) agoo_strndup(str, len, __FILE__, __LINE__)
+
+#define AGOO_FREE(ptr) agoo_free(ptr, __FILE__, __LINE__)
+#define AGOO_FREED(ptr) agoo_freed(ptr, __FILE__, __LINE__)
+#define AGOO_MEM_CHECK(ptr) agoo_mem_check(ptr, __FILE__, __LINE__)
+
+extern void*	agoo_malloc(size_t size, const char *file, int line);
+extern void*	agoo_realloc(void *ptr, size_t size, const char *file, int line);
+extern char*	agoo_strdup(const char *str, const char *file, int line);
+extern char*	agoo_strndup(const char *str, size_t len, const char *file, int line);
+extern void	agoo_free(void *ptr, const char *file, int line);
+extern void	agoo_freed(void *ptr, const char *file, int line);
+extern void	agoo_alloc(const void *ptr, size_t size, const char *file, int line);
+extern void	agoo_mem_check(void *ptr, const char *file, int line);
+
 #else
-#define DEBUG_ALLOC(var, ptr) { }
-#define DEBUG_REALLOC(var, orig, ptr) { }
-#define DEBUG_FREE(var, ptr) { }
-#endif
 
-extern atomic_int	mem_bind;
-extern atomic_int	mem_cb;
-extern atomic_int	mem_con;
-extern atomic_int	mem_cslot;
-extern atomic_int	mem_err_stream;
-extern atomic_int	mem_eval_threads;
-extern atomic_int	mem_graphql_arg;
-extern atomic_int	mem_graphql_directive;
-extern atomic_int	mem_graphql_field;
-extern atomic_int	mem_graphql_link;
-extern atomic_int	mem_graphql_slot;
-extern atomic_int	mem_graphql_type;
-extern atomic_int	mem_graphql_value;
-extern atomic_int	mem_group;
-extern atomic_int	mem_group_path;
-extern atomic_int	mem_header;
-extern atomic_int	mem_hook;
-extern atomic_int	mem_hook_pattern;
-extern atomic_int	mem_http_slot;
-extern atomic_int	mem_log_entry;
-extern atomic_int	mem_log_what;
-extern atomic_int	mem_log_tid;
-extern atomic_int	mem_mime_slot;
-extern atomic_int	mem_page;
-extern atomic_int	mem_page_msg;
-extern atomic_int	mem_page_path;
-extern atomic_int	mem_page_slot;
-extern atomic_int	mem_pub;
-extern atomic_int	mem_qitem;
-extern atomic_int	mem_queue_item;
-extern atomic_int	mem_rack_logger;
-extern atomic_int	mem_req;
-extern atomic_int	mem_res;
-extern atomic_int	mem_res_body;
-extern atomic_int	mem_response;
-extern atomic_int	mem_subject;
-extern atomic_int	mem_text;
-extern atomic_int	mem_to_s;
-extern atomic_int	mem_upgraded;
+#define AGOO_MALLOC(size) malloc(size)
+#define AGOO_ALLOC(ptr, size) {}
+#define AGOO_REALLOC(ptr, size) realloc(ptr, size)
+#define AGOO_STRDUP(str) strdup(str)
+#define AGOO_STRNDUP(str, len) strndup(str, len)
+#define AGOO_FREE(ptr) free(ptr)
+#define AGOO_FREED(ptr) {}
+#define AGOO_MEM_CHECK(ptr) {}
+
+#endif
 
-extern void	debug_add(void *ptr, const char *type, const char *file, int line);
-extern void	debug_update(void *orig, void *ptr, const char *type, const char *file, int line);
-extern void	debug_del(void *ptr, const char *file, int line);
 extern void	debug_report();
-extern void	debug_rreport(); // when called from ruby
 
 #endif /* AGOO_DEBUG_H */

data/ext/agoo/doc.c

@@ -1,5 +1,6 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
+#include <math.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -7,6 +8,10 @@
 
 #include "doc.h"
 #include "gqlvalue.h"
+#include "graphql.h"
+
+#define EXP_MAX		100000
+#define DEC_MAX		16
 
 static char	char_map[256] = "\
 .........ww..w..................\
@@ -18,6 +23,16 @@ pttttttttttttttttttttttttttp.p.t\
 ................................\
 ................................";
 
+static char	json_map[256] = "\
+.........ww..w..................\
+wpq.....pp..c.p.ttttttttttp..p..\
+pttttttttttttttttttttttttttp.p.t\
+.ttttttttttttttttttttttttttppp..\
+................................\
+................................\
+................................\
+................................";
+
 void
 agoo_doc_init(agooDoc doc, const char *str, int len) {
     if (0 >= len) {
@@ -41,6 +56,15 @@ agoo_doc_skip_white(agooDoc doc) {
     return (int)(doc->cur - start);
 }
 
+int
+agoo_doc_skip_jwhite(agooDoc doc) {
+    const char	*start = doc->cur;
+    
+    for (; 'w' == json_map[*(uint8_t*)doc->cur]; doc->cur++) {
+    }
+    return (int)(doc->cur - start);
+}
+
 void
 agoo_doc_skip_comment(agooDoc doc) {
     for (; true; doc->cur++) {
@@ -54,6 +78,21 @@ agoo_doc_skip_comment(agooDoc doc) {
     }
 }
 
+// Return true if found, false if not.
+bool
+agoo_doc_skip_to(agooDoc doc, char c) {
+    const char	*orig = doc->cur;
+    
+    for (; doc->cur < doc->end; doc->cur++) {
+	if (c == *doc->cur) {
+	    return true;
+	}
+    }
+    doc->cur = orig;
+
+    return false;
+}
+
 void
 agoo_doc_read_token(agooDoc doc) {
     if ('t' == char_map[*(uint8_t*)doc->cur] && '9' < *doc->cur) {
@@ -150,10 +189,244 @@ agoo_doc_location(agooDoc doc, int *linep, int *colp) {
     *colp = col;
 }
 
-gqlValue
-agoo_doc_read_value(agooErr err, agooDoc doc) {
-    // TBD handle list and object as well as scalars, object is typeless
-    // TBD put this in agoo_doc_read_value
-    return NULL;
+static gqlValue
+read_number(agooErr err, agooDoc doc) {
+    int64_t	i = 0;
+    int64_t	num = 0;
+    int64_t	div = 1;
+    int64_t	di = 0;
+    long	exp = 0;
+    int		neg = false;
+    int		hasExp = false;
+    int		dec_cnt = 0;
+    int		d;
+    
+    if ('-' == *doc->cur) {
+	doc->cur++;
+	neg = true;
+    } else if ('+' == *doc->cur) {
+	doc->cur++;
+    }
+    for (; '0' <= *doc->cur && *doc->cur <= '9'; doc->cur++) {
+	if (0 < i) {
+	    dec_cnt++;
+	}
+	d = *doc->cur - '0';
+	i = i * 10 + d;
+	if (INT64_MAX <= (uint64_t)i) {
+	    agoo_doc_err(doc, err, "number is too large");
+	    return NULL;
+	}
+    }
+    if ('.' == *doc->cur) {
+	doc->cur++;
+	for (; '0' <= *doc->cur && *doc->cur <= '9'; doc->cur++) {
+	    d = (*doc->cur - '0');
+	    if (0 < num || 0 < i) {
+		dec_cnt++;
+	    }
+	    num = num * 10 + d;
+	    div *= 10;
+	    di++;
+	    if (INT64_MAX <= (uint64_t)div || DEC_MAX < dec_cnt) {
+		agoo_doc_err(doc, err, "number has too many digits");
+		return NULL;
+	    }
+	}
+	if ('e' == *doc->cur || 'E' == *doc->cur) {
+	    int	eneg = 0;
+
+	    hasExp = true;
+	    doc->cur++;
+	    if ('-' == *doc->cur) {
+		doc->cur++;
+		eneg = true;
+	    } else if ('+' == *doc->cur) {
+		doc->cur++;
+	    }
+	    for (; '0' <= *doc->cur && *doc->cur <= '9'; doc->cur++) {
+		exp = exp * 10 + (*doc->cur - '0');
+		if (EXP_MAX <= exp) {
+		    // TBD maybe just ignore extra and continue till the end
+		    agoo_doc_err(doc, err, "number has too many digits");
+		    return NULL;
+		}
+	    }
+	    if (eneg) {
+		exp = -exp;
+	    }
+	}
+    }
+    if (hasExp || 0 < num) {
+	long double	d = (long double)i * (long double)div + (long double)num;
+	int		x = (int)((int64_t)exp - di);
+
+	d = roundl(d);
+	if (0 < x) {
+	    d *= powl(10.0L, x);
+	} else if (0 > x) {
+	    d /= powl(10.0L, -x);
+	}
+	if (neg) {
+	    d = -d;
+	}
+	return gql_float_create(err, (double)d);
+
+    }
+    if (INT32_MAX < i) {
+	if (neg) {
+	    return gql_i64_create(err, -i);
+	} else {
+	    return gql_i64_create(err, i);
+	}
+    }
+    if (neg) {
+	return gql_int_create(err, (int32_t)-i);
+    }
+    return gql_int_create(err, (int32_t)i);
 }
 
+gqlValue
+agoo_doc_read_value(agooErr err, agooDoc doc, gqlType type) {
+    gqlValue	value = NULL;
+    const char	*start;
+
+    agoo_doc_skip_white(doc);
+    start = doc->cur;    
+    switch (*doc->cur) {
+    case '$':
+	doc->cur++;
+	start++;
+	agoo_doc_read_token(doc);
+	value = gql_var_create(err, start, doc->cur - start);
+	break;
+    case '"': {
+	const char	*end;
+
+	start++;
+	if (AGOO_ERR_OK != agoo_doc_read_string(err, doc)) {
+	    return NULL;
+	}
+	if ('"' == *start) { // must be a """
+	    start += 2;
+	    end = doc->cur - 3;
+	} else {
+	    end = doc->cur - 1;
+	}
+	value = gql_string_create(err, start, end - start);
+	break;
+    }
+    case '-':
+    case '+':
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+	value = read_number(err, doc);
+	break;
+    case 'n':
+	agoo_doc_read_token(doc);
+	if (doc->cur - start == 4 && 0 == strncmp("null", start, 4)) {
+	    value = gql_null_create(err);
+	} else {
+	    value = gql_token_create(err, start, doc->cur - start, type);
+	}
+	break;
+    case 't':
+	agoo_doc_read_token(doc);
+	if (doc->cur - start == 4 && 0 == strncmp("true", start, 4)) {
+	    value = gql_bool_create(err, true);
+	} else {
+	    value = gql_token_create(err, start, doc->cur - start, type);
+	}
+	break;
+    case 'f':
+	agoo_doc_read_token(doc);
+	if (doc->cur - start == 5 && 0 == strncmp("false", start, 5)) {
+	    value = gql_bool_create(err, false);
+	} else {
+	    value = gql_token_create(err, start, doc->cur - start, type);
+	}
+	break;
+    case '[':
+	if (NULL != type) {
+	    if (GQL_LIST != type->kind) {
+		agoo_doc_err(doc, err, "Not a list type");
+		return NULL;
+	    }
+	    type = type->base;
+	}
+	if (NULL== (value = gql_list_create(err, type))) {
+	    return NULL;
+	}
+	doc->cur++;
+	while (doc->cur < doc->end) {
+	    gqlValue	member;
+	    
+	    agoo_doc_skip_white(doc);
+	    if (']' == *doc->cur) {
+		doc->cur++;
+		break;
+	    }
+	    if (NULL == (member = agoo_doc_read_value(err, doc, type))) {
+		return NULL;
+	    }
+	    if (AGOO_ERR_OK != gql_list_append(err, value, member)) {
+		return NULL;
+	    }
+	}
+	break;
+    case '{':
+	if (NULL == (value = gql_object_create(err))) {
+	    return NULL;
+	}
+	//value->type = type; // values are always the base object type
+	doc->cur++;
+	while (doc->cur < doc->end) {
+	    char	key[256];
+	    gqlValue	member;
+	    
+	    agoo_doc_skip_white(doc);
+	    if ('}' == *doc->cur) {
+		doc->cur++;
+		break;
+	    }
+	    start = doc->cur;
+	    agoo_doc_read_token(doc);
+	    if (start == doc->cur) {
+		agoo_doc_err(doc, err, "Expected a member name.");
+		return NULL;
+	    }
+	    if ((int)sizeof(key) <= doc->cur - start) {
+		agoo_doc_err(doc, err, "Member name too long.");
+		return NULL;
+	    }
+	    strncpy(key, start, doc->cur - start);
+	    key[doc->cur - start] = '\0';
+	    agoo_doc_read_token(doc);
+	    if (':' != *doc->cur) {
+		agoo_doc_err(doc, err, "Expected a ':' after member name.");
+		return NULL;
+	    }
+	    doc->cur++;
+	    if (NULL == (member = agoo_doc_read_value(err, doc, type))) {
+		return NULL;
+	    }
+	    if (AGOO_ERR_OK != gql_object_set(err, value, key, member)) {
+		return NULL;
+	    }
+	}
+	break;
+    default: // Enum value
+	agoo_doc_read_token(doc);
+	value = gql_token_create(err, start, doc->cur - start, type);
+	break;
+    }
+    return value;
+}

data/ext/agoo/doc.h

@@ -4,9 +4,11 @@
 #define AGOO_DOC_H
 
 #include <stdarg.h>
+#include <stdbool.h>
 
 #include "err.h"
 
+struct _gqlType;
 struct _gqlValue;
 
 typedef struct _agooDoc {
@@ -19,8 +21,11 @@ extern void	agoo_doc_init(agooDoc doc, const char *str, int len);
 
 extern int	agoo_doc_skip_white(agooDoc doc);
 extern void	agoo_doc_skip_comment(agooDoc doc);
+extern bool	agoo_doc_skip_to(agooDoc doc, char c);
 extern int	agoo_doc_read_desc(agooErr err, agooDoc doc);
 
+extern int	agoo_doc_skip_jwhite(agooDoc doc);
+
 extern void	agoo_doc_next_token(agooDoc doc);
 extern void	agoo_doc_read_token(agooDoc doc);
 
@@ -29,6 +34,6 @@ extern int	agoo_doc_read_string(agooErr err, agooDoc doc);
 extern int	agoo_doc_err(agooDoc doc, agooErr err, const char *fmt, ...);
 extern void	agoo_doc_location(agooDoc doc, int *linep, int *colp);
 
-extern struct _gqlValue*	agoo_doc_read_value(agooErr err, agooDoc doc);
+extern struct _gqlValue*	agoo_doc_read_value(agooErr err, agooDoc doc, struct _gqlType *type);
 
 #endif // AGOO_DOC_H

data/ext/agoo/err.c

@@ -71,6 +71,7 @@ agoo_err_str(agooErrCode code) {
 	case AGOO_ERR_IN_USE:	str = "in use";			break;
 	case AGOO_ERR_TOO_MANY:	str = "too many";		break;
 	case AGOO_ERR_TYPE:	str = "type error";		break;
+	case AGOO_ERR_EVAL:	str = "eval error";		break;
 	default:		str = "unknown error";		break;
 	}
     }