agoo 2.5.7 → 2.6.0

data/ext/agoo/sdl.h

@@ -5,6 +5,13 @@
 
 #include "err.h"
 
-extern int	sdl_parse(agooErr err, const char *str, int len);
+struct _gqlVar;
+
+extern int		sdl_parse(agooErr err, const char *str, int len);
+
+// Parse a execution definition.
+extern struct _gqlDoc*	sdl_parse_doc(agooErr err, const char *str, int len, struct _gqlVar *vars);
+
+extern gqlVar	gql_op_var_create(agooErr err, const char *name, gqlType type, gqlValue value);
 
 #endif // AGOO_SDL_H

data/ext/agoo/sectime.c

@@ -0,0 +1,136 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#include "sectime.h"
+
+#define SECS_PER_DAY		86400LL
+#define SECS_PER_YEAR		31536000LL
+#define SECS_PER_LEAP		31622400LL
+#define SECS_PER_QUAD_YEAR	(SECS_PER_YEAR * 3 + SECS_PER_LEAP)
+#define SECS_PER_CENT		(SECS_PER_QUAD_YEAR * 24 + SECS_PER_YEAR * 4)
+#define SECS_PER_LEAP_CENT	(SECS_PER_CENT + SECS_PER_DAY)
+#define SECS_PER_QUAD_CENT	(SECS_PER_CENT * 4 + SECS_PER_DAY)
+
+static int64_t	eom_secs[] = {
+    2678400,  // January (31)
+    5097600,  // February (28)	2419200	 2505600
+    7776000,  // March (31)
+    10368000, // April (30  2592000
+    13046400, // May (31)
+    15638400, // June (30)
+    18316800, // July (31)
+    20995200, // August (31)
+    23587200, // September (30)
+    26265600, // October (31)
+    28857600, // November (30)
+    31536000, // December (31)
+};
+
+static int64_t	eom_leap_secs[] = {
+    2678400,  // January (31)
+    5184000,  // February (28)	2419200	 2505600
+    7862400,  // March (31)
+    10454400, // April (30  2592000
+    13132800, // May (31)
+    15724800, // June (30)
+    18403200, // July (31)
+    21081600, // August (31)
+    23673600, // September (30)
+    26352000, // October (31)
+    28944000, // November (30)
+    31622400, // December (31)
+};
+
+
+void
+agoo_sectime(int64_t secs, agooTime at) {
+    int64_t	qc = 0;
+    int64_t	c = 0;
+    int64_t	qy = 0;
+    int64_t	y = 0;
+    bool	leap = false;
+    int64_t	*ms;
+    int		m;
+    int		shift = 0;
+
+    secs += 62167219200LL; // normalize to first day of the year 0
+    if (secs < 0) {
+	shift = -secs / SECS_PER_QUAD_CENT;
+	shift++;
+	secs += shift * SECS_PER_QUAD_CENT;
+    }
+    qc = secs / SECS_PER_QUAD_CENT;
+    secs = secs - qc * SECS_PER_QUAD_CENT;
+    if (secs < SECS_PER_LEAP) {
+	leap = true;
+    } else if (secs < SECS_PER_QUAD_YEAR) {
+	if (SECS_PER_LEAP <= secs) {
+	    secs -= SECS_PER_LEAP;
+	    y = secs / SECS_PER_YEAR;
+	    secs = secs - y * SECS_PER_YEAR;
+	    y++;
+	    leap = true;
+	}
+    } else if (secs < SECS_PER_LEAP_CENT) { // first century in 400 years is a leap century (one extra day)
+	qy = secs / SECS_PER_QUAD_YEAR;
+	secs = secs - qy * SECS_PER_QUAD_YEAR;
+	if (secs < SECS_PER_LEAP) {
+	    leap = true;
+	} else {
+	    secs -= SECS_PER_LEAP;
+	    y = secs / SECS_PER_YEAR;
+	    secs = secs - y * SECS_PER_YEAR;
+	    y++;
+	}
+    } else {
+	secs -= SECS_PER_LEAP_CENT;
+	c = secs / SECS_PER_CENT;
+	secs = secs - c * SECS_PER_CENT;
+	c++;
+	if (secs < SECS_PER_YEAR * 4) {
+	    y = secs / SECS_PER_YEAR;
+	    secs = secs - y * SECS_PER_YEAR;
+	} else {
+	    secs -= SECS_PER_YEAR * 4;
+	    qy = secs / SECS_PER_QUAD_YEAR;
+	    secs = secs - qy * SECS_PER_QUAD_YEAR;
+	    qy++;
+	    if (secs < SECS_PER_LEAP) {
+		leap = true;
+	    } else {
+		secs -= SECS_PER_LEAP;
+		y = secs / SECS_PER_YEAR;
+		secs = secs - y * SECS_PER_YEAR;
+		y++;
+	    }
+	}
+    }
+    at->year = (qc - shift) * 400 + c * 100 + qy * 4 + y;
+    if (leap) {
+	ms = eom_leap_secs;
+    } else {
+	ms = eom_secs;
+    }
+    for (m = 1; m <= 12; m++, ms++) {
+	if (secs < *ms) {
+	    if (1 < m) {
+		secs -= *(ms - 1);
+	    }
+	    at->mon = m;
+	    break;
+	}
+    }
+    at->day = secs / 86400LL;
+    secs = secs - (int64_t)at->day * 86400LL;
+    at->day++;
+    at->hour = secs / 3600LL;
+    secs = secs - (int64_t)at->hour * 3600LL;
+    at->min = secs / 60LL;
+    secs = secs - (int64_t)at->min * 60LL;
+    at->sec = secs;
+}

data/ext/agoo/sectime.h

@@ -0,0 +1,19 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#ifndef AGOO_SECTIME_H
+#define AGOO_SECTIME_H
+
+#include <stdint.h>
+
+typedef struct _agooTime {
+    int sec;
+    int min;
+    int hour;
+    int day;
+    int mon;
+    int year;
+} *agooTime;
+
+extern void	agoo_sectime(int64_t secs, agooTime at);
+
+#endif /* AGOO_SECTIME_H */

data/ext/agoo/server.c

@@ -72,8 +72,6 @@ listen_loop(void *x) {
     uint64_t		cnt = 0;
     agooBind		b;
 
-    // TBD support multiple sockets, count binds, allocate pollfd, setup
-    //
     for (b = agoo_server.binds, p = pa; NULL != b; b = b->next, p++, pcnt++) {
 	p->fd = b->fd;
 	p->events = POLLIN;
@@ -156,7 +154,7 @@ agoo_server_start(agooErr err, const char *app_name, const char *version) {
     agoo_server.con_loops = agoo_conloop_create(err, 0);
     agoo_server.loop_cnt = 1;
     xcnt++;
-    
+
     // If the eval thread count is 1 that implies the eval load is low so
     // might as well create the maximum number of con threads as is
     // reasonable.

data/ext/agoo/subject.c

@@ -9,10 +9,9 @@
 
 agooSubject
 agoo_subject_create(const char *pattern, int plen) {
-    agooSubject	subject = (agooSubject)malloc(sizeof(struct _agooSubject) - 7 + plen);
+    agooSubject	subject = (agooSubject)AGOO_MALLOC(sizeof(struct _agooSubject) - 7 + plen);
 
     if (NULL != subject) {
-	DEBUG_ALLOC(mem_subject, subject);
 	subject->next = NULL;
 	memcpy(subject->pattern, pattern, plen);
 	subject->pattern[plen] = '\0';
@@ -22,8 +21,7 @@ agoo_subject_create(const char *pattern, int plen) {
 
 void
 agoo_subject_destroy(agooSubject subject) {
-    DEBUG_FREE(mem_subject, subject);
-    free(subject);
+    AGOO_FREE(subject);
 }
 
 bool

data/ext/agoo/text.c

@@ -1,18 +1,52 @@
 // Copyright 2016, 2018 by Peter Ohler, All Rights Reserved
 
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "debug.h"
 #include "text.h"
 
+static const char	hex_chars[17] = "0123456789abcdef";
+
+static char	json_chars[256] = "\
+66666666222622666666666666666666\
+11211111111111111111111111111111\
+11111111111111111111111111112111\
+11111111111111111111111111111111\
+11111111111111111111111111111111\
+11111111111111111111111111111111\
+11111111111111111111111111111111\
+11111111111111111111111111111111";
+
+static void
+dump_hex(char *s, uint8_t c) {
+    uint8_t	d = (c >> 4) & 0x0F;
+
+    *s++ = hex_chars[d];
+    d = c & 0x0F;
+    *s++ = hex_chars[d];
+}
+
+static size_t
+json_size(const char *str, size_t len) {
+    uint8_t	*u = (uint8_t*)str;
+    size_t	size = 0;
+    size_t	i = len;
+
+    for (; 0 < i; u++, i--) {
+	size += json_chars[*u];
+    }
+    return size - len * (size_t)'0';
+}
+
+
 agooText
 agoo_text_create(const char *str, int len) {
-    agooText	t = (agooText)malloc(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + len + 1);
+    agooText	t = (agooText)AGOO_MALLOC(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
-	DEBUG_ALLOC(mem_text, t)
 	t->len = len;
 	t->alen = len;
 	t->bin = false;
@@ -25,10 +59,9 @@ agoo_text_create(const char *str, int len) {
 
 agooText
 agoo_text_dup(agooText t0) {
-    agooText	t = (agooText)malloc(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + t0->alen + 1);
+    agooText	t = (agooText)AGOO_MALLOC(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + t0->alen + 1);
 
     if (NULL != t) {
-	DEBUG_ALLOC(mem_text, t)
 	t->len = t0->len;
 	t->alen = t0->alen;
 	t->bin = false;
@@ -40,10 +73,9 @@ agoo_text_dup(agooText t0) {
 
 agooText
 agoo_text_allocate(int len) {
-    agooText	t = (agooText)malloc(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + len + 1);
+    agooText	t = (agooText)AGOO_MALLOC(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
-	DEBUG_ALLOC(mem_text, t)
 	t->len = 0;
 	t->alen = len;
 	t->bin = false;
@@ -61,8 +93,7 @@ agoo_text_ref(agooText t) {
 void
 agoo_text_release(agooText t) {
     if (1 >= atomic_fetch_sub(&t->ref_cnt, 1)) {
-	DEBUG_FREE(mem_text, t);
-	free(t);
+	AGOO_FREE(t);
     }
 }
 
@@ -74,13 +105,10 @@ agoo_text_append(agooText t, const char *s, int len) {
     if (t->alen <= t->len + len) {
 	long	new_len = t->alen + len + t->alen / 2;
 	size_t	size = sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + new_len + 1;
-#ifdef MEM_DEBUG
-	agooText	t0 = t;
-#endif	
-	if (NULL == (t = (agooText)realloc(t, size))) {
+
+	if (NULL == (t = (agooText)AGOO_REALLOC(t, size))) {
 	    return NULL;
 	}
-	DEBUG_REALLOC(mem_text, t0, t);
 	t->alen = new_len;
     }
     memcpy(t->text + t->len, s, len);
@@ -90,6 +118,24 @@ agoo_text_append(agooText t, const char *s, int len) {
     return t;
 }
 
+agooText
+agoo_text_append_char(agooText t, const char c) {
+    if (t->alen <= t->len + 1) {
+	long	new_len = t->alen + 1 + t->alen / 2;
+	size_t	size = sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + new_len + 1;
+
+	if (NULL == (t = (agooText)AGOO_REALLOC(t, size))) {
+	    return NULL;
+	}
+	t->alen = new_len;
+    }
+    *(t->text + t->len) = c;
+    t->len++;
+    t->text[t->len] = '\0';
+
+    return t;
+}
+
 agooText
 agoo_text_prepend(agooText t, const char *s, int len) {
     if (0 >= len) {
@@ -98,14 +144,10 @@ agoo_text_prepend(agooText t, const char *s, int len) {
     if (t->alen <= t->len + len) {
 	long	new_len = t->alen + len + t->alen / 2;
 	size_t	size = sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + new_len + 1;
-#ifdef MEM_DEBUG
-	agooText	t0 = t;
-#endif	
 
-	if (NULL == (t = (agooText)realloc(t, size))) {
+	if (NULL == (t = (agooText)AGOO_REALLOC(t, size))) {
 	    return NULL;
 	}
-	DEBUG_REALLOC(mem_text, t0, t);
 	t->alen = new_len;
     }
     memmove(t->text + len, t->text, t->len + 1);
@@ -114,3 +156,67 @@ agoo_text_prepend(agooText t, const char *s, int len) {
 
     return t;
 }
+
+agooText
+agoo_text_append_json(agooText t, const char *s, int len) {
+    size_t	jlen;
+    
+    if (0 >= len) {
+	len = (int)strlen(s);
+    }
+    jlen = json_size(s, len);
+    if (t->alen <= (long)(t->len + jlen)) {
+	long	new_len = t->alen + jlen + t->alen / 2;
+	size_t	size = sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + new_len + 1;
+
+	if (NULL == (t = (agooText)AGOO_REALLOC(t, size))) {
+	    return NULL;
+	}
+	t->alen = new_len;
+    }
+    if (jlen == (size_t)len) {
+	memcpy(t->text + t->len, s, len);
+    } else {
+	const char	*end = s + len;
+	char		*ts = t->text + t->len;
+
+	for (; s < end; s++) {
+	    switch (json_chars[(uint8_t)*s]) {
+	    case '1':
+		*ts++ = *s;
+		break;
+	    case '2':
+		*ts++ = '\\';
+		switch (*s) {
+		case '\\':	*ts++ = '\\';	break;
+		case '\b':	*ts++ = 'b';	break;
+		case '\t':	*ts++ = 't';	break;
+		case '\n':	*ts++ = 'n';	break;
+		case '\f':	*ts++ = 'f';	break;
+		case '\r':	*ts++ = 'r';	break;
+		default:	*ts++ = *s;	break;
+		}
+		break;
+	    case '6': // control characters
+		*ts++ = '\\';
+		*ts++ = 'u';
+		*ts++ = '0';
+		*ts++ = '0';
+		dump_hex(ts, (uint8_t)*s);
+		ts += 2;
+		break;
+	    default:
+		break; // should never get here
+	    }
+	}
+    }
+    t->len += jlen;
+    t->text[t->len] = '\0';
+
+    return t;
+}
+
+void
+agoo_text_reset(agooText t) {
+    t->len = 0;
+}

data/ext/agoo/text.h

@@ -10,7 +10,7 @@
 #define AGOO_TEXT_MIN_SIZE	8
 
 typedef struct _agooText {
-    long	len; // length of valid text
+    long	len;  // length of valid text
     long	alen; // size of allocated text
     atomic_int	ref_cnt;
     bool	bin;
@@ -24,5 +24,9 @@ extern void	agoo_text_ref(agooText t);
 extern void	agoo_text_release(agooText t);
 extern agooText	agoo_text_append(agooText t, const char *s, int len);
 extern agooText	agoo_text_prepend(agooText t, const char *s, int len);
+extern agooText	agoo_text_append_json(agooText t, const char *s, int len);
+extern agooText	agoo_text_append_char(agooText t, const char c);
+
+extern void	agoo_text_reset(agooText t);
 
 #endif // AGOO_TEXT_H

data/ext/agoo/upgraded.c

@@ -32,8 +32,7 @@ destroy(agooUpgraded up) {
 	up->subjects = up->subjects->next;
 	agoo_subject_destroy(subject);
     }
-    DEBUG_FREE(mem_upgraded, up);
-    free(up);
+    AGOO_FREE(up);
 }
 
 void
@@ -167,10 +166,9 @@ agoo_upgraded_pending(agooUpgraded up) {
 
 agooUpgraded
 agoo_upgraded_create(agooCon c, void * ctx, void *env) {
-    agooUpgraded	up = (agooUpgraded)malloc(sizeof(struct _agooUpgraded));
+    agooUpgraded	up = (agooUpgraded)AGOO_MALLOC(sizeof(struct _agooUpgraded));
 
     if (NULL != up) {
-	DEBUG_ALLOC(mem_upgraded, up);
 	memset(up, 0, sizeof(struct _agooUpgraded));
 	up->con = c;
 	up->ctx = ctx;