Upload 7 files

Makefile

@@ -0,0 +1,36 @@
+# Makefile for Shadowclaw
+
+CC = gcc
+CFLAGS = -Wall -Wextra -O2 -D_GNU_SOURCE
+LDFLAGS = -lpthread -lcurl -lm
+
+# Dependency checks
+CHECK_CURL = $(shell pkg-config --exists libcurl && echo yes)
+ifeq ($(CHECK_CURL),)
+$(error libcurl development package not found (install libcurl4-openssl-dev or equivalent))
+endif
+
+# Source files
+OBJS = shadowclaw.o interpreter.o cJSON.o
+
+# Default target
+shadowclaw: $(OBJS)
+	$(CC) -o $@ $(OBJS) $(LDFLAGS)
+
+# Automatic header dependency tracking
+DEPDIR = .deps
+df = $(DEPDIR)/$(*F)
+
+%.o: %.c
+	@mkdir -p $(DEPDIR)
+	$(CC) $(CFLAGS) -MMD -MF $(df).d -c $< -o $@
+	@cp $(df).d $(df).P; sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' -e '/^$$/ d' -e 's/$$/ :/' < $(df).d >> $(df).P; rm -f $(df).d
+
+# Include generated dependencies
+-include $(OBJS:%.o=$(DEPDIR)/%.P)
+
+# Clean
+clean:
+	rm -f shadowclaw $(OBJS) $(DEPDIR)/*.P
+
+.PHONY: clean

cJSON.c

@@ -0,0 +1,3174 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+/* cJSON */
+/* JSON parser in C. */
+
+/* disable warnings about old C89 functions in MSVC */
+#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+#ifdef __GNUC__
+#pragma GCC visibility push(default)
+#endif
+#if defined(_MSC_VER)
+#pragma warning (push)
+/* disable warning about single line comments in system headers */
+#pragma warning (disable : 4001)
+#endif
+
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <ctype.h>
+#include <float.h>
+
+#ifdef ENABLE_LOCALES
+#include <locale.h>
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning (pop)
+#endif
+#ifdef __GNUC__
+#pragma GCC visibility pop
+#endif
+
+#include "cJSON.h"
+
+/* define our own boolean type */
+#ifdef true
+#undef true
+#endif
+#define true ((cJSON_bool)1)
+
+#ifdef false
+#undef false
+#endif
+#define false ((cJSON_bool)0)
+
+/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */
+#ifndef isinf
+#define isinf(d) (isnan((d - d)) && !isnan(d))
+#endif
+#ifndef isnan
+#define isnan(d) (d != d)
+#endif
+
+#ifndef NAN
+#ifdef _WIN32
+#define NAN sqrt(-1.0)
+#else
+#define NAN 0.0/0.0
+#endif
+#endif
+
+typedef struct {
+    const unsigned char *json;
+    size_t position;
+} error;
+static error global_error = { NULL, 0 };
+
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)
+{
+    return (const char*) (global_error.json + global_error.position);
+}
+
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item)
+{
+    if (!cJSON_IsString(item))
+    {
+        return NULL;
+    }
+
+    return item->valuestring;
+}
+
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item)
+{
+    if (!cJSON_IsNumber(item))
+    {
+        return (double) NAN;
+    }
+
+    return item->valuedouble;
+}
+
+/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */
+#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 18)
+    #error cJSON.h and cJSON.c have different versions. Make sure that both have the same.
+#endif
+
+CJSON_PUBLIC(const char*) cJSON_Version(void)
+{
+    static char version[15];
+    sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH);
+
+    return version;
+}
+
+/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */
+static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)
+{
+    if ((string1 == NULL) || (string2 == NULL))
+    {
+        return 1;
+    }
+
+    if (string1 == string2)
+    {
+        return 0;
+    }
+
+    for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++)
+    {
+        if (*string1 == '\0')
+        {
+            return 0;
+        }
+    }
+
+    return tolower(*string1) - tolower(*string2);
+}
+
+typedef struct internal_hooks
+{
+    void *(CJSON_CDECL *allocate)(size_t size);
+    void (CJSON_CDECL *deallocate)(void *pointer);
+    void *(CJSON_CDECL *reallocate)(void *pointer, size_t size);
+} internal_hooks;
+
+#if defined(_MSC_VER)
+/* work around MSVC error C2322: '...' address of dllimport '...' is not static */
+static void * CJSON_CDECL internal_malloc(size_t size)
+{
+    return malloc(size);
+}
+static void CJSON_CDECL internal_free(void *pointer)
+{
+    free(pointer);
+}
+static void * CJSON_CDECL internal_realloc(void *pointer, size_t size)
+{
+    return realloc(pointer, size);
+}
+#else
+#define internal_malloc malloc
+#define internal_free free
+#define internal_realloc realloc
+#endif
+
+/* strlen of character literals resolved at compile time */
+#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
+
+static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc };
+
+static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
+{
+    size_t length = 0;
+    unsigned char *copy = NULL;
+
+    if (string == NULL)
+    {
+        return NULL;
+    }
+
+    length = strlen((const char*)string) + sizeof("");
+    copy = (unsigned char*)hooks->allocate(length);
+    if (copy == NULL)
+    {
+        return NULL;
+    }
+    memcpy(copy, string, length);
+
+    return copy;
+}
+
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)
+{
+    if (hooks == NULL)
+    {
+        /* Reset hooks */
+        global_hooks.allocate = malloc;
+        global_hooks.deallocate = free;
+        global_hooks.reallocate = realloc;
+        return;
+    }
+
+    global_hooks.allocate = malloc;
+    if (hooks->malloc_fn != NULL)
+    {
+        global_hooks.allocate = hooks->malloc_fn;
+    }
+
+    global_hooks.deallocate = free;
+    if (hooks->free_fn != NULL)
+    {
+        global_hooks.deallocate = hooks->free_fn;
+    }
+
+    /* use realloc only if both free and malloc are used */
+    global_hooks.reallocate = NULL;
+    if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))
+    {
+        global_hooks.reallocate = realloc;
+    }
+}
+
+/* Internal constructor. */
+static cJSON *cJSON_New_Item(const internal_hooks * const hooks)
+{
+    cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));
+    if (node)
+    {
+        memset(node, '\0', sizeof(cJSON));
+    }
+
+    return node;
+}
+
+/* Delete a cJSON structure. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)
+{
+    cJSON *next = NULL;
+    while (item != NULL)
+    {
+        next = item->next;
+        if (!(item->type & cJSON_IsReference) && (item->child != NULL))
+        {
+            cJSON_Delete(item->child);
+        }
+        if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
+        {
+            global_hooks.deallocate(item->valuestring);
+            item->valuestring = NULL;
+        }
+        if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
+        {
+            global_hooks.deallocate(item->string);
+            item->string = NULL;
+        }
+        global_hooks.deallocate(item);
+        item = next;
+    }
+}
+
+/* get the decimal point character of the current locale */
+static unsigned char get_decimal_point(void)
+{
+#ifdef ENABLE_LOCALES
+    struct lconv *lconv = localeconv();
+    return (unsigned char) lconv->decimal_point[0];
+#else
+    return '.';
+#endif
+}
+
+typedef struct
+{
+    const unsigned char *content;
+    size_t length;
+    size_t offset;
+    size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */
+    internal_hooks hooks;
+} parse_buffer;
+
+/* check if the given size is left to read in a given parse buffer (starting with 1) */
+#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
+/* check if the buffer can be accessed at the given index (starting with 0) */
+#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
+#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
+/* get a pointer to the buffer at the position */
+#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
+
+/* Parse the input text to generate a number, and populate the result into item. */
+static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)
+{
+    double number = 0;
+    unsigned char *after_end = NULL;
+    unsigned char number_c_string[64];
+    unsigned char decimal_point = get_decimal_point();
+    size_t i = 0;
+
+    if ((input_buffer == NULL) || (input_buffer->content == NULL))
+    {
+        return false;
+    }
+
+    /* copy the number into a temporary buffer and replace '.' with the decimal point
+     * of the current locale (for strtod)
+     * This also takes care of '\0' not necessarily being available for marking the end of the input */
+    for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++)
+    {
+        switch (buffer_at_offset(input_buffer)[i])
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            case '+':
+            case '-':
+            case 'e':
+            case 'E':
+                number_c_string[i] = buffer_at_offset(input_buffer)[i];
+                break;
+
+            case '.':
+                number_c_string[i] = decimal_point;
+                break;
+
+            default:
+                goto loop_end;
+        }
+    }
+loop_end:
+    number_c_string[i] = '\0';
+
+    number = strtod((const char*)number_c_string, (char**)&after_end);
+    if (number_c_string == after_end)
+    {
+        return false; /* parse_error */
+    }
+
+    item->valuedouble = number;
+
+    /* use saturation in case of overflow */
+    if (number >= INT_MAX)
+    {
+        item->valueint = INT_MAX;
+    }
+    else if (number <= (double)INT_MIN)
+    {
+        item->valueint = INT_MIN;
+    }
+    else
+    {
+        item->valueint = (int)number;
+    }
+
+    item->type = cJSON_Number;
+
+    input_buffer->offset += (size_t)(after_end - number_c_string);
+    return true;
+}
+
+/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)
+{
+    if (number >= INT_MAX)
+    {
+        object->valueint = INT_MAX;
+    }
+    else if (number <= (double)INT_MIN)
+    {
+        object->valueint = INT_MIN;
+    }
+    else
+    {
+        object->valueint = (int)number;
+    }
+
+    return object->valuedouble = number;
+}
+
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)
+{
+    char *copy = NULL;
+    /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */
+    if ((object == NULL) || !(object->type & cJSON_String) || (object->type & cJSON_IsReference))
+    {
+        return NULL;
+    }
+    /* return NULL if the object is corrupted */
+    if (object->valuestring == NULL)
+    {
+        return NULL;
+    }
+    if (strlen(valuestring) <= strlen(object->valuestring))
+    {
+        strcpy(object->valuestring, valuestring);
+        return object->valuestring;
+    }
+    copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks);
+    if (copy == NULL)
+    {
+        return NULL;
+    }
+    if (object->valuestring != NULL)
+    {
+        cJSON_free(object->valuestring);
+    }
+    object->valuestring = copy;
+
+    return copy;
+}
+
+typedef struct
+{
+    unsigned char *buffer;
+    size_t length;
+    size_t offset;
+    size_t depth; /* current nesting depth (for formatted printing) */
+    cJSON_bool noalloc;
+    cJSON_bool format; /* is this print a formatted print */
+    internal_hooks hooks;
+} printbuffer;
+
+/* realloc printbuffer if necessary to have at least "needed" bytes more */
+static unsigned char* ensure(printbuffer * const p, size_t needed)
+{
+    unsigned char *newbuffer = NULL;
+    size_t newsize = 0;
+
+    if ((p == NULL) || (p->buffer == NULL))
+    {
+        return NULL;
+    }
+
+    if ((p->length > 0) && (p->offset >= p->length))
+    {
+        /* make sure that offset is valid */
+        return NULL;
+    }
+
+    if (needed > INT_MAX)
+    {
+        /* sizes bigger than INT_MAX are currently not supported */
+        return NULL;
+    }
+
+    needed += p->offset + 1;
+    if (needed <= p->length)
+    {
+        return p->buffer + p->offset;
+    }
+
+    if (p->noalloc) {
+        return NULL;
+    }
+
+    /* calculate new buffer size */
+    if (needed > (INT_MAX / 2))
+    {
+        /* overflow of int, use INT_MAX if possible */
+        if (needed <= INT_MAX)
+        {
+            newsize = INT_MAX;
+        }
+        else
+        {
+            return NULL;
+        }
+    }
+    else
+    {
+        newsize = needed * 2;
+    }
+
+    if (p->hooks.reallocate != NULL)
+    {
+        /* reallocate with realloc if available */
+        newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize);
+        if (newbuffer == NULL)
+        {
+            p->hooks.deallocate(p->buffer);
+            p->length = 0;
+            p->buffer = NULL;
+
+            return NULL;
+        }
+    }
+    else
+    {
+        /* otherwise reallocate manually */
+        newbuffer = (unsigned char*)p->hooks.allocate(newsize);
+        if (!newbuffer)
+        {
+            p->hooks.deallocate(p->buffer);
+            p->length = 0;
+            p->buffer = NULL;
+
+            return NULL;
+        }
+
+        memcpy(newbuffer, p->buffer, p->offset + 1);
+        p->hooks.deallocate(p->buffer);
+    }
+    p->length = newsize;
+    p->buffer = newbuffer;
+
+    return newbuffer + p->offset;
+}
+
+/* calculate the new length of the string in a printbuffer and update the offset */
+static void update_offset(printbuffer * const p)
+{
+    const unsigned char *buffer = NULL;
+    if ((p == NULL) || (p->buffer == NULL))
+    {
+        return;
+    }
+    buffer = p->buffer + p->offset;
+
+    p->offset += strlen((const char*)buffer);
+}
+
+/* securely comparison of floating-point variables */
+static cJSON_bool compare_double(double a, double b)
+{
+    double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b);
+    return (fabs(a - b) <= maxVal * DBL_EPSILON);
+}
+
+/* Render the number nicely from the given item into a string. */
+static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    double d = item->valuedouble;
+    int length = 0;
+    size_t i = 0;
+    unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */
+    unsigned char decimal_point = get_decimal_point();
+    double test = 0.0;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* This checks for NaN and Infinity */
+    if (isnan(d) || isinf(d))
+    {
+        length = sprintf((char*)number_buffer, "null");
+    }
+    else if (d == (double)item->valueint)
+    {
+        length = sprintf((char*)number_buffer, "%d", item->valueint);
+    }
+    else
+    {
+        /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */
+        length = sprintf((char*)number_buffer, "%1.15g", d);
+
+        /* Check whether the original double can be recovered */
+        if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d))
+        {
+            /* If not, print with 17 decimal places of precision */
+            length = sprintf((char*)number_buffer, "%1.17g", d);
+        }
+    }
+
+    /* sprintf failed or buffer overrun occurred */
+    if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1)))
+    {
+        return false;
+    }
+
+    /* reserve appropriate space in the output */
+    output_pointer = ensure(output_buffer, (size_t)length + sizeof(""));
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+
+    /* copy the printed number to the output and replace locale
+     * dependent decimal point with '.' */
+    for (i = 0; i < ((size_t)length); i++)
+    {
+        if (number_buffer[i] == decimal_point)
+        {
+            output_pointer[i] = '.';
+            continue;
+        }
+
+        output_pointer[i] = number_buffer[i];
+    }
+    output_pointer[i] = '\0';
+
+    output_buffer->offset += (size_t)length;
+
+    return true;
+}
+
+/* parse 4 digit hexadecimal number */
+static unsigned parse_hex4(const unsigned char * const input)
+{
+    unsigned int h = 0;
+    size_t i = 0;
+
+    for (i = 0; i < 4; i++)
+    {
+        /* parse digit */
+        if ((input[i] >= '0') && (input[i] <= '9'))
+        {
+            h += (unsigned int) input[i] - '0';
+        }
+        else if ((input[i] >= 'A') && (input[i] <= 'F'))
+        {
+            h += (unsigned int) 10 + input[i] - 'A';
+        }
+        else if ((input[i] >= 'a') && (input[i] <= 'f'))
+        {
+            h += (unsigned int) 10 + input[i] - 'a';
+        }
+        else /* invalid */
+        {
+            return 0;
+        }
+
+        if (i < 3)
+        {
+            /* shift left to make place for the next nibble */
+            h = h << 4;
+        }
+    }
+
+    return h;
+}
+
+/* converts a UTF-16 literal to UTF-8
+ * A literal can be one or two sequences of the form \uXXXX */
+static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)
+{
+    long unsigned int codepoint = 0;
+    unsigned int first_code = 0;
+    const unsigned char *first_sequence = input_pointer;
+    unsigned char utf8_length = 0;
+    unsigned char utf8_position = 0;
+    unsigned char sequence_length = 0;
+    unsigned char first_byte_mark = 0;
+
+    if ((input_end - first_sequence) < 6)
+    {
+        /* input ends unexpectedly */
+        goto fail;
+    }
+
+    /* get the first utf16 sequence */
+    first_code = parse_hex4(first_sequence + 2);
+
+    /* check that the code is valid */
+    if (((first_code >= 0xDC00) && (first_code <= 0xDFFF)))
+    {
+        goto fail;
+    }
+
+    /* UTF16 surrogate pair */
+    if ((first_code >= 0xD800) && (first_code <= 0xDBFF))
+    {
+        const unsigned char *second_sequence = first_sequence + 6;
+        unsigned int second_code = 0;
+        sequence_length = 12; /* \uXXXX\uXXXX */
+
+        if ((input_end - second_sequence) < 6)
+        {
+            /* input ends unexpectedly */
+            goto fail;
+        }
+
+        if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u'))
+        {
+            /* missing second half of the surrogate pair */
+            goto fail;
+        }
+
+        /* get the second utf16 sequence */
+        second_code = parse_hex4(second_sequence + 2);
+        /* check that the code is valid */
+        if ((second_code < 0xDC00) || (second_code > 0xDFFF))
+        {
+            /* invalid second half of the surrogate pair */
+            goto fail;
+        }
+
+
+        /* calculate the unicode codepoint from the surrogate pair */
+        codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));
+    }
+    else
+    {
+        sequence_length = 6; /* \uXXXX */
+        codepoint = first_code;
+    }
+
+    /* encode as UTF-8
+     * takes at maximum 4 bytes to encode:
+     * 0 - 0x7F: 0xxxxxxx
+     * 0x80 - 0x7FF: 110xxxxx 10xxxxxx
+     * 0x800 - 0xFFFF: 1110xxxx 10xxxxxx 10xxxxxx
+     * 0x10000 - 0x10FFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+
+    if (codepoint < 0x80)
+    {
+        /* one byte symbol */
+        utf8_length = 1;
+    }
+    else if (codepoint < 0x800)
+    {
+        /* two byte symbol  */
+        utf8_length = 2;
+    }
+    else if (codepoint < 0x10000)
+    {
+        /* three byte symbol */
+        utf8_length = 3;
+    }
+    else if (codepoint <= 0x10FFFF)
+    {
+        /* four byte symbol */
+        utf8_length = 4;
+    }
+    else
+    {
+        /* invalid unicode codepoint */
+        goto fail;
+    }
+
+    /* encode as utf8 */
+    switch (utf8_length)
+    {
+        case 1:
+            /* first byte */
+            (*output_pointer)[0] = (unsigned char)(codepoint);
+            break;
+        case 2:
+            first_byte_mark = 0xC0; /* 11000000 */
+            (*output_pointer)[0] = (unsigned char)(codepoint >> 6) | first_byte_mark;
+            (*output_pointer)[1] = (unsigned char)(codepoint & 0x3F) | 0x80;
+            break;
+        case 3:
+            first_byte_mark = 0xE0; /* 11100000 */
+            (*output_pointer)[0] = (unsigned char)(codepoint >> 12) | first_byte_mark;
+            (*output_pointer)[1] = (unsigned char)((codepoint >> 6) & 0x3F) | 0x80;
+            (*output_pointer)[2] = (unsigned char)(codepoint & 0x3F) | 0x80;
+            break;
+        case 4:
+            first_byte_mark = 0xF0; /* 11110000 */
+            (*output_pointer)[0] = (unsigned char)(codepoint >> 18) | first_byte_mark;
+            (*output_pointer)[1] = (unsigned char)((codepoint >> 12) & 0x3F) | 0x80;
+            (*output_pointer)[2] = (unsigned char)((codepoint >> 6) & 0x3F) | 0x80;
+            (*output_pointer)[3] = (unsigned char)(codepoint & 0x3F) | 0x80;
+            break;
+        default:
+            /* Should not execute */
+            goto fail;
+    }
+
+    utf8_position = utf8_length;
+    /* skip the \u characters */
+    sequence_length = (sequence_length > 0) ? sequence_length : 0;
+
+    *output_pointer += utf8_position;
+    return sequence_length;
+
+fail:
+    return 0;
+}
+
+/* Parse the input text into an unescaped cinput, and populate item. */
+static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)
+{
+    const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1;
+    const unsigned char *input_end = buffer_at_offset(input_buffer) + 1;
+    unsigned char *output_pointer = NULL;
+    unsigned char *output = NULL;
+
+    /* not a string */
+    if (buffer_at_offset(input_buffer)[0] != '\"')
+    {
+        goto fail;
+    }
+
+    {
+        /* calculate approximate size of the output (overestimate) */
+        size_t allocation_length = 0;
+        size_t skipped_bytes = 0;
+        while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"'))
+        {
+            /* Is escape sequence */
+            if (input_end[0] == '\\')
+            {
+                if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length)
+                {
+                    /* prevent buffer overflow when last input character is a backslash */
+                    goto fail;
+                }
+                skipped_bytes++;
+                input_end++;
+            }
+            input_end++;
+        }
+        if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"'))
+        {
+            goto fail; /* string ended unexpectedly */
+        }
+
+        /* This is at most how much we need for the output */
+        allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
+        output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof(""));
+        if (output == NULL)
+        {
+            goto fail; /* allocation failure */
+        }
+    }
+
+    output_pointer = output;
+    /* loop through the string literal */
+    while (input_pointer < input_end)
+    {
+        if (*input_pointer != '\\')
+        {
+            *output_pointer++ = *input_pointer++;
+        }
+        /* escape sequence */
+        else
+        {
+            unsigned char sequence_length = 2;
+            if ((input_end - input_pointer) < 1)
+            {
+                goto fail;
+            }
+
+            switch (input_pointer[1])
+            {
+                case 'b':
+                    *output_pointer++ = '\b';
+                    break;
+                case 'f':
+                    *output_pointer++ = '\f';
+                    break;
+                case 'n':
+                    *output_pointer++ = '\n';
+                    break;
+                case 'r':
+                    *output_pointer++ = '\r';
+                    break;
+                case 't':
+                    *output_pointer++ = '\t';
+                    break;
+                case '\"':
+                case '\\':
+                case '/':
+                    *output_pointer++ = input_pointer[1];
+                    break;
+
+                /* UTF-16 literal */
+                case 'u':
+                    sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);
+                    if (sequence_length == 0)
+                    {
+                        /* failed to convert UTF-16-literal to UTF-8 */
+                        goto fail;
+                    }
+                    break;
+
+                default:
+                    goto fail;
+            }
+            input_pointer += sequence_length;
+        }
+    }
+
+    /* zero terminate the output */
+    *output_pointer = '\0';
+
+    item->type = cJSON_String;
+    item->valuestring = (char*)output;
+
+    input_buffer->offset = (size_t) (input_end - input_buffer->content);
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if (output != NULL)
+    {
+        input_buffer->hooks.deallocate(output);
+        output = NULL;
+    }
+
+    if (input_pointer != NULL)
+    {
+        input_buffer->offset = (size_t)(input_pointer - input_buffer->content);
+    }
+
+    return false;
+}
+
+/* Render the cstring provided to an escaped version that can be printed. */
+static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)
+{
+    const unsigned char *input_pointer = NULL;
+    unsigned char *output = NULL;
+    unsigned char *output_pointer = NULL;
+    size_t output_length = 0;
+    /* numbers of additional characters needed for escaping */
+    size_t escape_characters = 0;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* empty string */
+    if (input == NULL)
+    {
+        output = ensure(output_buffer, sizeof("\"\""));
+        if (output == NULL)
+        {
+            return false;
+        }
+        strcpy((char*)output, "\"\"");
+
+        output_buffer->offset += 2;
+
+        return true;
+    }
+
+    /* calculate "escape" characters and final string length */
+    for (input_pointer = input; *input_pointer; input_pointer++)
+    {
+        switch (*input_pointer)
+        {
+            case '\"':
+            case '\\':
+            case '\b':
+            case '\f':
+            case '\n':
+            case '\r':
+            case '\t':
+                /* one character escape needed */
+                escape_characters++;
+                break;
+            default:
+                if (*input_pointer < 32)
+                {
+                    /* UTF-16 escape sequence \uXXXX should be printed */
+                    escape_characters += 5;
+                }
+                break;
+        }
+    }
+    output_length = (size_t)(input_pointer - input) + escape_characters;
+
+    output = ensure(output_buffer, output_length + sizeof("\"\""));
+    if (output == NULL)
+    {
+        return false;
+    }
+
+    /* no characters have to be escaped */
+    if (escape_characters == 0)
+    {
+        output[0] = '\"';
+        memcpy(output + 1, input, output_length);
+        output[output_length + 1] = '\"';
+        output[output_length + 2] = '\0';
+
+        output_buffer->offset += output_length + 2;
+
+        return true;
+    }
+
+    output[0] = '\"';
+    output_pointer = output + 1;
+    /* copy the string */
+    for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
+    {
+        if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))
+        {
+            /* normal character, copy */
+            *output_pointer = *input_pointer;
+        }
+        else
+        {
+            /* character needs to be escaped */
+            *output_pointer++ = '\\';
+            switch (*input_pointer)
+            {
+                case '\\':
+                    *output_pointer = '\\';
+                    break;
+                case '\"':
+                    *output_pointer = '\"';
+                    break;
+                case '\b':
+                    *output_pointer = 'b';
+                    break;
+                case '\f':
+                    *output_pointer = 'f';
+                    break;
+                case '\n':
+                    *output_pointer = 'n';
+                    break;
+                case '\r':
+                    *output_pointer = 'r';
+                    break;
+                case '\t':
+                    *output_pointer = 't';
+                    break;
+                default:
+                    /* escape and print as unicode codepoint */
+                    sprintf((char*)output_pointer, "u%04x", *input_pointer);
+                    output_pointer += 4;
+                    break;
+            }
+        }
+    }
+    output[output_length + 1] = '\"';
+    output[output_length + 2] = '\0';
+
+    output_buffer->offset += output_length + 2;
+
+    return true;
+}
+
+/* Invoke print_string_ptr (which is useful) on an item. */
+static cJSON_bool print_string(const cJSON * const item, printbuffer * const p)
+{
+    return print_string_ptr((unsigned char*)item->valuestring, p);
+}
+
+/* Predeclare these prototypes. */
+static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer);
+static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer);
+static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer);
+static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer);
+static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer);
+static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer);
+
+/* Utility to jump whitespace and cr/lf */
+static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
+{
+    if ((buffer == NULL) || (buffer->content == NULL))
+    {
+        return NULL;
+    }
+
+    if (cannot_access_at_index(buffer, 0))
+    {
+        return buffer;
+    }
+
+    while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
+    {
+       buffer->offset++;
+    }
+
+    if (buffer->offset == buffer->length)
+    {
+        buffer->offset--;
+    }
+
+    return buffer;
+}
+
+/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */
+static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)
+{
+    if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0))
+    {
+        return NULL;
+    }
+
+    if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
+    {
+        buffer->offset += 3;
+    }
+
+    return buffer;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
+{
+    size_t buffer_length;
+
+    if (NULL == value)
+    {
+        return NULL;
+    }
+
+    /* Adding null character detection due to parse_parse_string and the way cJSON works */
+    buffer_length = strlen(value) + sizeof("");
+    return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated);
+}
+
+/* Parse an object - create a new root, and populate. */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated)
+{
+    parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
+    cJSON *item = NULL;
+
+    /* reset error position */
+    global_error.json = NULL;
+    global_error.position = 0;
+
+    if (value == NULL || 0 == buffer_length)
+    {
+        goto fail;
+    }
+
+    buffer.content = (const unsigned char*)value;
+    buffer.length = buffer_length;
+    buffer.offset = 0;
+    buffer.hooks = global_hooks;
+
+    item = cJSON_New_Item(&global_hooks);
+    if (item == NULL) /* memory fail */
+    {
+        goto fail;
+    }
+
+    if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer))))
+    {
+        /* parse failure. ep is set. */
+        goto fail;
+    }
+
+    /* if we require null-terminated JSON without appended garbage, skip then and check for a null terminator */
+    if (require_null_terminated)
+    {
+        buffer_skip_whitespace(&buffer);
+        if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0')
+        {
+            goto fail;
+        }
+    }
+    if (return_parse_end)
+    {
+        *return_parse_end = (const char*)buffer_at_offset(&buffer);
+    }
+
+    return item;
+
+fail:
+    if (item != NULL)
+    {
+        cJSON_Delete(item);
+    }
+
+    if (value != NULL)
+    {
+        error local_error;
+        local_error.json = (const unsigned char*)value;
+        local_error.position = 0;
+
+        if (buffer.offset < buffer.length)
+        {
+            local_error.position = buffer.offset;
+        }
+        else if (buffer.length > 0)
+        {
+            local_error.position = buffer.length - 1;
+        }
+
+        if (return_parse_end != NULL)
+        {
+            *return_parse_end = (const char*)local_error.json + local_error.position;
+        }
+
+        global_error = local_error;
+    }
+
+    return NULL;
+}
+
+/* Default options for cJSON_Parse */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)
+{
+    return cJSON_ParseWithOpts(value, 0, 0);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length)
+{
+    return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0);
+}
+
+#define cjson_min(a, b) (((a) < (b)) ? (a) : (b))
+
+static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)
+{
+    static const size_t default_buffer_size = 256;
+    printbuffer buffer[1];
+    unsigned char *printed = NULL;
+
+    memset(buffer, 0, sizeof(buffer));
+
+    /* create buffer */
+    buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
+    buffer->length = default_buffer_size;
+    buffer->format = format;
+    buffer->hooks = *hooks;
+    if (buffer->buffer == NULL)
+    {
+        goto fail;
+    }
+
+    /* print the value */
+    if (!print_value(item, buffer))
+    {
+        goto fail;
+    }
+    update_offset(buffer);
+
+    /* check if reallocate is available */
+    if (hooks->reallocate != NULL)
+    {
+        printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);
+        if (printed == NULL) {
+            goto fail;
+        }
+        buffer->buffer = NULL;
+    }
+    else /* otherwise copy the JSON over to a new buffer */
+    {
+        printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
+        if (printed == NULL)
+        {
+            goto fail;
+        }
+        memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
+        printed[buffer->offset] = '\0'; /* just to be sure */
+
+        /* free the buffer */
+        hooks->deallocate(buffer->buffer);
+        buffer->buffer = NULL;
+    }
+
+    return printed;
+
+fail:
+    if (buffer->buffer != NULL)
+    {
+        hooks->deallocate(buffer->buffer);
+        buffer->buffer = NULL;
+    }
+
+    if (printed != NULL)
+    {
+        hooks->deallocate(printed);
+        printed = NULL;
+    }
+
+    return NULL;
+}
+
+/* Render a cJSON item/entity/structure to text. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item)
+{
+    return (char*)print(item, true, &global_hooks);
+}
+
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item)
+{
+    return (char*)print(item, false, &global_hooks);
+}
+
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
+{
+    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
+
+    if (prebuffer < 0)
+    {
+        return NULL;
+    }
+
+    p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
+    if (!p.buffer)
+    {
+        return NULL;
+    }
+
+    p.length = (size_t)prebuffer;
+    p.offset = 0;
+    p.noalloc = false;
+    p.format = fmt;
+    p.hooks = global_hooks;
+
+    if (!print_value(item, &p))
+    {
+        global_hooks.deallocate(p.buffer);
+        p.buffer = NULL;
+        return NULL;
+    }
+
+    update_offset(&p);
+
+    return (char*)p.buffer;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format)
+{
+    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
+
+    if ((length < 0) || (buffer == NULL))
+    {
+        return false;
+    }
+
+    p.buffer = (unsigned char*)buffer;
+    p.length = (size_t)length;
+    p.offset = 0;
+    p.noalloc = true;
+    p.format = format;
+    p.hooks = global_hooks;
+
+    return print_value(item, &p);
+}
+
+/* Parser core - when encountering text, process appropriately. */
+static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)
+{
+    if ((input_buffer == NULL) || (input_buffer->content == NULL))
+    {
+        return false; /* no input */
+    }
+
+    /* parse the different types of values */
+    /* null */
+    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0))
+    {
+        item->type = cJSON_NULL;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* false */
+    if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0))
+    {
+        item->type = cJSON_False;
+        input_buffer->offset += 5;
+        return true;
+    }
+    /* true */
+    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0))
+    {
+        item->type = cJSON_True;
+        item->valueint = 1;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* string */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"'))
+    {
+        return parse_string(item, input_buffer);
+    }
+    /* number */
+    if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9'))))
+    {
+        return parse_number(item, input_buffer);
+    }
+    /* array */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '['))
+    {
+        return parse_array(item, input_buffer);
+    }
+    /* object */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{'))
+    {
+        return parse_object(item, input_buffer);
+    }
+
+    return false;
+}
+
+/* Render a value to text. */
+static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output = NULL;
+
+    if ((item == NULL) || (output_buffer == NULL))
+    {
+        return false;
+    }
+
+    switch ((item->type) & 0xFF)
+    {
+        case cJSON_NULL:
+            output = ensure(output_buffer, 5);
+            if (output == NULL)
+            {
+                return false;
+            }
+            strcpy((char*)output, "null");
+            output_buffer->offset += 4;
+            return true;
+
+        case cJSON_False:
+            output = ensure(output_buffer, 6);
+            if (output == NULL)
+            {
+                return false;
+            }
+            strcpy((char*)output, "false");
+            output_buffer->offset += 5;
+            return true;
+
+        case cJSON_True:
+            output = ensure(output_buffer, 5);
+            if (output == NULL)
+            {
+                return false;
+            }
+            strcpy((char*)output, "true");
+            output_buffer->offset += 4;
+            return true;
+
+        case cJSON_Number:
+            return print_number(item, output_buffer);
+
+        case cJSON_Raw:
+        {
+            size_t raw_length = 0;
+            if (item->valuestring == NULL)
+            {
+                return false;
+            }
+
+            raw_length = strlen(item->valuestring) + sizeof("");
+            output = ensure(output_buffer, raw_length);
+            if (output == NULL)
+            {
+                return false;
+            }
+            memcpy(output, item->valuestring, raw_length);
+            output_buffer->offset += raw_length - 1;
+            return true;
+        }
+
+        case cJSON_String:
+            return print_string(item, output_buffer);
+
+        case cJSON_Array:
+            return print_array(item, output_buffer);
+
+        case cJSON_Object:
+            return print_object(item, output_buffer);
+
+        default:
+            return false;
+    }
+}
+
+/* Build an array from input text. */
+static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)
+{
+    cJSON *head = NULL; /* head of the linked list */
+    cJSON *current_item = NULL;
+
+    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
+    {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if (buffer_at_offset(input_buffer)[0] != '[')
+    {
+        /* not an array */
+        goto fail;
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']'))
+    {
+        /* empty array */
+        goto success;
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if (cannot_access_at_index(input_buffer, 0))
+    {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do
+    {
+        /* allocate next item */
+        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
+        if (new_item == NULL)
+        {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if (head == NULL)
+        {
+            /* start the linked list */
+            current_item = head = new_item;
+        }
+        else
+        {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev = current_item;
+            current_item = new_item;
+        }
+
+        /* parse next value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_value(current_item, input_buffer))
+        {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    }
+    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']')
+    {
+        goto fail; /* expected end of array */
+    }
+
+success:
+    input_buffer->depth--;
+
+    if (head != NULL) {
+        head->prev = current_item;
+    }
+
+    item->type = cJSON_Array;
+    item->child = head;
+
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if (head != NULL)
+    {
+        cJSON_Delete(head);
+    }
+
+    return false;
+}
+
+/* Render an array to text */
+static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    size_t length = 0;
+    cJSON *current_element = item->child;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* Compose the output array. */
+    /* opening square bracket */
+    output_pointer = ensure(output_buffer, 1);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+
+    *output_pointer = '[';
+    output_buffer->offset++;
+    output_buffer->depth++;
+
+    while (current_element != NULL)
+    {
+        if (!print_value(current_element, output_buffer))
+        {
+            return false;
+        }
+        update_offset(output_buffer);
+        if (current_element->next)
+        {
+            length = (size_t) (output_buffer->format ? 2 : 1);
+            output_pointer = ensure(output_buffer, length + 1);
+            if (output_pointer == NULL)
+            {
+                return false;
+            }
+            *output_pointer++ = ',';
+            if(output_buffer->format)
+            {
+                *output_pointer++ = ' ';
+            }
+            *output_pointer = '\0';
+            output_buffer->offset += length;
+        }
+        current_element = current_element->next;
+    }
+
+    output_pointer = ensure(output_buffer, 2);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+    *output_pointer++ = ']';
+    *output_pointer = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Build an object from the text. */
+static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)
+{
+    cJSON *head = NULL; /* linked list head */
+    cJSON *current_item = NULL;
+
+    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
+    {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{'))
+    {
+        goto fail; /* not an object */
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}'))
+    {
+        goto success; /* empty object */
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if (cannot_access_at_index(input_buffer, 0))
+    {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do
+    {
+        /* allocate next item */
+        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
+        if (new_item == NULL)
+        {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if (head == NULL)
+        {
+            /* start the linked list */
+            current_item = head = new_item;
+        }
+        else
+        {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev = current_item;
+            current_item = new_item;
+        }
+
+        if (cannot_access_at_index(input_buffer, 1))
+        {
+            goto fail; /* nothing comes after the comma */
+        }
+
+        /* parse the name of the child */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_string(current_item, input_buffer))
+        {
+            goto fail; /* failed to parse name */
+        }
+        buffer_skip_whitespace(input_buffer);
+
+        /* swap valuestring and string, because we parsed the name */
+        current_item->string = current_item->valuestring;
+        current_item->valuestring = NULL;
+
+        if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':'))
+        {
+            goto fail; /* invalid object */
+        }
+
+        /* parse the value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_value(current_item, input_buffer))
+        {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    }
+    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}'))
+    {
+        goto fail; /* expected end of object */
+    }
+
+success:
+    input_buffer->depth--;
+
+    if (head != NULL) {
+        head->prev = current_item;
+    }
+
+    item->type = cJSON_Object;
+    item->child = head;
+
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if (head != NULL)
+    {
+        cJSON_Delete(head);
+    }
+
+    return false;
+}
+
+/* Render an object to text. */
+static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    size_t length = 0;
+    cJSON *current_item = item->child;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* Compose the output: */
+    length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */
+    output_pointer = ensure(output_buffer, length + 1);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+
+    *output_pointer++ = '{';
+    output_buffer->depth++;
+    if (output_buffer->format)
+    {
+        *output_pointer++ = '\n';
+    }
+    output_buffer->offset += length;
+
+    while (current_item)
+    {
+        if (output_buffer->format)
+        {
+            size_t i;
+            output_pointer = ensure(output_buffer, output_buffer->depth);
+            if (output_pointer == NULL)
+            {
+                return false;
+            }
+            for (i = 0; i < output_buffer->depth; i++)
+            {
+                *output_pointer++ = '\t';
+            }
+            output_buffer->offset += output_buffer->depth;
+        }
+
+        /* print key */
+        if (!print_string_ptr((unsigned char*)current_item->string, output_buffer))
+        {
+            return false;
+        }
+        update_offset(output_buffer);
+
+        length = (size_t) (output_buffer->format ? 2 : 1);
+        output_pointer = ensure(output_buffer, length);
+        if (output_pointer == NULL)
+        {
+            return false;
+        }
+        *output_pointer++ = ':';
+        if (output_buffer->format)
+        {
+            *output_pointer++ = '\t';
+        }
+        output_buffer->offset += length;
+
+        /* print value */
+        if (!print_value(current_item, output_buffer))
+        {
+            return false;
+        }
+        update_offset(output_buffer);
+
+        /* print comma if not last */
+        length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0));
+        output_pointer = ensure(output_buffer, length + 1);
+        if (output_pointer == NULL)
+        {
+            return false;
+        }
+        if (current_item->next)
+        {
+            *output_pointer++ = ',';
+        }
+
+        if (output_buffer->format)
+        {
+            *output_pointer++ = '\n';
+        }
+        *output_pointer = '\0';
+        output_buffer->offset += length;
+
+        current_item = current_item->next;
+    }
+
+    output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+    if (output_buffer->format)
+    {
+        size_t i;
+        for (i = 0; i < (output_buffer->depth - 1); i++)
+        {
+            *output_pointer++ = '\t';
+        }
+    }
+    *output_pointer++ = '}';
+    *output_pointer = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Get Array size/item / object item. */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)
+{
+    cJSON *child = NULL;
+    size_t size = 0;
+
+    if (array == NULL)
+    {
+        return 0;
+    }
+
+    child = array->child;
+
+    while(child != NULL)
+    {
+        size++;
+        child = child->next;
+    }
+
+    /* FIXME: Can overflow here. Cannot be fixed without breaking the API */
+
+    return (int)size;
+}
+
+static cJSON* get_array_item(const cJSON *array, size_t index)
+{
+    cJSON *current_child = NULL;
+
+    if (array == NULL)
+    {
+        return NULL;
+    }
+
+    current_child = array->child;
+    while ((current_child != NULL) && (index > 0))
+    {
+        index--;
+        current_child = current_child->next;
+    }
+
+    return current_child;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index)
+{
+    if (index < 0)
+    {
+        return NULL;
+    }
+
+    return get_array_item(array, (size_t)index);
+}
+
+static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
+{
+    cJSON *current_element = NULL;
+
+    if ((object == NULL) || (name == NULL))
+    {
+        return NULL;
+    }
+
+    current_element = object->child;
+    if (case_sensitive)
+    {
+        while (current_element != NULL)
+        {
+            if (current_element->string && (strcmp(name, current_element->string) == 0))
+            {
+                return current_element;
+            }
+            current_element = current_element->next;
+        }
+    }
+    else
+    {
+        while (current_element != NULL)
+        {
+            if (current_element->string && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) == 0))
+            {
+                return current_element;
+            }
+            current_element = current_element->next;
+        }
+    }
+
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string)
+{
+    return get_object_item(object, string, false);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string)
+{
+    return get_object_item(object, string, true);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string)
+{
+    return cJSON_GetObjectItem(object, string) ? 1 : 0;
+}
+
+/* Utility for array list handling. */
+static void suffix_object(cJSON *prev, cJSON *item)
+{
+    prev->next = item;
+    item->prev = prev;
+}
+
+/* Utility for handling references. */
+static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)
+{
+    cJSON *reference = NULL;
+    if (item == NULL)
+    {
+        return NULL;
+    }
+
+    reference = cJSON_New_Item(hooks);
+    if (reference == NULL)
+    {
+        return NULL;
+    }
+
+    memcpy(reference, item, sizeof(cJSON));
+    reference->string = NULL;
+    reference->type |= cJSON_IsReference;
+    reference->next = reference->prev = NULL;
+    return reference;
+}
+
+static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)
+{
+    cJSON *child = NULL;
+
+    if ((item == NULL) || (array == NULL) || (array == item))
+    {
+        return false;
+    }
+
+    child = array->child;
+    /*
+     * To find the last item in array quickly, we use prev in array
+     */
+    if (child == NULL)
+    {
+        /* list is empty, start new one */
+        array->child = item;
+        item->prev = item;
+        item->next = NULL;
+    }
+    else
+    {
+        /* append to the end */
+        if (child->prev)
+        {
+            suffix_object(child->prev, item);
+            array->child->prev = item;
+        }
+    }
+
+    return true;
+}
+
+/* Add item to array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item)
+{
+    return add_item_to_array(array, item);
+}
+
+#if defined(__clang__) || (defined(__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+    #pragma GCC diagnostic push
+#endif
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#endif
+/* helper function to cast away const */
+static void* cast_away_const(const void* string)
+{
+    return (void*)string;
+}
+#if defined(__clang__) || (defined(__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+    #pragma GCC diagnostic pop
+#endif
+
+
+static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)
+{
+    char *new_key = NULL;
+    int new_type = cJSON_Invalid;
+
+    if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item))
+    {
+        return false;
+    }
+
+    if (constant_key)
+    {
+        new_key = (char*)cast_away_const(string);
+        new_type = item->type | cJSON_StringIsConst;
+    }
+    else
+    {
+        new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks);
+        if (new_key == NULL)
+        {
+            return false;
+        }
+
+        new_type = item->type & ~cJSON_StringIsConst;
+    }
+
+    if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
+    {
+        hooks->deallocate(item->string);
+    }
+
+    item->string = new_key;
+    item->type = new_type;
+
+    return add_item_to_array(object, item);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
+{
+    return add_item_to_object(object, string, item, &global_hooks, false);
+}
+
+/* Add an item to an object with constant string as key */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)
+{
+    return add_item_to_object(object, string, item, &global_hooks, true);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
+{
+    if (array == NULL)
+    {
+        return false;
+    }
+
+    return add_item_to_array(array, create_reference(item, &global_hooks));
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)
+{
+    if ((object == NULL) || (string == NULL))
+    {
+        return false;
+    }
+
+    return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false);
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name)
+{
+    cJSON *null = cJSON_CreateNull();
+    if (add_item_to_object(object, name, null, &global_hooks, false))
+    {
+        return null;
+    }
+
+    cJSON_Delete(null);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name)
+{
+    cJSON *true_item = cJSON_CreateTrue();
+    if (add_item_to_object(object, name, true_item, &global_hooks, false))
+    {
+        return true_item;
+    }
+
+    cJSON_Delete(true_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name)
+{
+    cJSON *false_item = cJSON_CreateFalse();
+    if (add_item_to_object(object, name, false_item, &global_hooks, false))
+    {
+        return false_item;
+    }
+
+    cJSON_Delete(false_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean)
+{
+    cJSON *bool_item = cJSON_CreateBool(boolean);
+    if (add_item_to_object(object, name, bool_item, &global_hooks, false))
+    {
+        return bool_item;
+    }
+
+    cJSON_Delete(bool_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number)
+{
+    cJSON *number_item = cJSON_CreateNumber(number);
+    if (add_item_to_object(object, name, number_item, &global_hooks, false))
+    {
+        return number_item;
+    }
+
+    cJSON_Delete(number_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string)
+{
+    cJSON *string_item = cJSON_CreateString(string);
+    if (add_item_to_object(object, name, string_item, &global_hooks, false))
+    {
+        return string_item;
+    }
+
+    cJSON_Delete(string_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw)
+{
+    cJSON *raw_item = cJSON_CreateRaw(raw);
+    if (add_item_to_object(object, name, raw_item, &global_hooks, false))
+    {
+        return raw_item;
+    }
+
+    cJSON_Delete(raw_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name)
+{
+    cJSON *object_item = cJSON_CreateObject();
+    if (add_item_to_object(object, name, object_item, &global_hooks, false))
+    {
+        return object_item;
+    }
+
+    cJSON_Delete(object_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name)
+{
+    cJSON *array = cJSON_CreateArray();
+    if (add_item_to_object(object, name, array, &global_hooks, false))
+    {
+        return array;
+    }
+
+    cJSON_Delete(array);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)
+{
+    if ((parent == NULL) || (item == NULL))
+    {
+        return NULL;
+    }
+
+    if (item != parent->child)
+    {
+        /* not the first element */
+        item->prev->next = item->next;
+    }
+    if (item->next != NULL)
+    {
+        /* not the last element */
+        item->next->prev = item->prev;
+    }
+
+    if (item == parent->child)
+    {
+        /* first element */
+        parent->child = item->next;
+    }
+    else if (item->next == NULL)
+    {
+        /* last element */
+        parent->child->prev = item->prev;
+    }
+
+    /* make sure the detached item doesn't point anywhere anymore */
+    item->prev = NULL;
+    item->next = NULL;
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which)
+{
+    if (which < 0)
+    {
+        return NULL;
+    }
+
+    return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which));
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which)
+{
+    cJSON_Delete(cJSON_DetachItemFromArray(array, which));
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string)
+{
+    cJSON *to_detach = cJSON_GetObjectItem(object, string);
+
+    return cJSON_DetachItemViaPointer(object, to_detach);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string)
+{
+    cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string);
+
+    return cJSON_DetachItemViaPointer(object, to_detach);
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string)
+{
+    cJSON_Delete(cJSON_DetachItemFromObject(object, string));
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string)
+{
+    cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string));
+}
+
+/* Replace array/object items with new ones. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
+{
+    cJSON *after_inserted = NULL;
+
+    if (which < 0 || newitem == NULL)
+    {
+        return false;
+    }
+
+    after_inserted = get_array_item(array, (size_t)which);
+    if (after_inserted == NULL)
+    {
+        return add_item_to_array(array, newitem);
+    }
+
+    if (after_inserted != array->child && after_inserted->prev == NULL) {
+        /* return false if after_inserted is a corrupted array item */
+        return false;
+    }
+
+    newitem->next = after_inserted;
+    newitem->prev = after_inserted->prev;
+    after_inserted->prev = newitem;
+    if (after_inserted == array->child)
+    {
+        array->child = newitem;
+    }
+    else
+    {
+        newitem->prev->next = newitem;
+    }
+    return true;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)
+{
+    if ((parent == NULL) || (parent->child == NULL) || (replacement == NULL) || (item == NULL))
+    {
+        return false;
+    }
+
+    if (replacement == item)
+    {
+        return true;
+    }
+
+    replacement->next = item->next;
+    replacement->prev = item->prev;
+
+    if (replacement->next != NULL)
+    {
+        replacement->next->prev = replacement;
+    }
+    if (parent->child == item)
+    {
+        if (parent->child->prev == parent->child)
+        {
+            replacement->prev = replacement;
+        }
+        parent->child = replacement;
+    }
+    else
+    {   /*
+         * To find the last item in array quickly, we use prev in array.
+         * We can't modify the last item's prev pointer from pointer to pointer conversion.
+         */
+        if (replacement->prev != NULL)
+        {
+            replacement->prev->next = replacement;
+        }
+        if (replacement->next == NULL)
+        {
+            parent->child->prev = replacement;
+        }
+    }
+
+    item->next = NULL;
+    item->prev = NULL;
+    cJSON_Delete(item);
+
+    return true;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)
+{
+    if (which < 0)
+    {
+        return false;
+    }
+
+    return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem);
+}
+
+static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)
+{
+    if ((replacement == NULL) || (string == NULL))
+    {
+        return false;
+    }
+
+    /* replace the name in the replacement */
+    if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL))
+    {
+        cJSON_free(replacement->string);
+    }
+    replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
+    if (replacement->string == NULL)
+    {
+        return false;
+    }
+
+    replacement->type &= ~cJSON_StringIsConst;
+
+    return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)
+{
+    return replace_item_in_object(object, string, newitem, false);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem)
+{
+    return replace_item_in_object(object, string, newitem, true);
+}
+
+/* Create basic types: */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_NULL;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_True;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_False;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = boolean ? cJSON_True : cJSON_False;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_Number;
+        item->valuedouble = num;
+
+        /* use saturation in case of overflow */
+        if (num >= INT_MAX)
+        {
+            item->valueint = INT_MAX;
+        }
+        else if (num <= (double)INT_MIN)
+        {
+            item->valueint = INT_MIN;
+        }
+        else
+        {
+            item->valueint = (int)num;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_String;
+        item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
+        if(!item->valuestring)
+        {
+            cJSON_Delete(item);
+            return NULL;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if (item != NULL)
+    {
+        item->type = cJSON_String | cJSON_IsReference;
+        item->valuestring = (char*)cast_away_const(string);
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if (item != NULL) {
+        item->type = cJSON_Object | cJSON_IsReference;
+        item->child = (cJSON*)cast_away_const(child);
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) {
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if (item != NULL) {
+        item->type = cJSON_Array | cJSON_IsReference;
+        item->child = (cJSON*)cast_away_const(child);
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_Raw;
+        item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks);
+        if(!item->valuestring)
+        {
+            cJSON_Delete(item);
+            return NULL;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type=cJSON_Array;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_Object;
+    }
+
+    return item;
+}
+
+/* Create Arrays: */
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (numbers == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateNumber((double)numbers[i]);
+        if (!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if (a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (numbers == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateNumber((double)numbers[i]);
+        if(!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if (a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (numbers == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateNumber(numbers[i]);
+        if(!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if (a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (strings == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateString(strings[i]);
+        if(!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    if (a && a->child) {
+        a->child->prev = n;
+    }
+
+    return a;
+}
+
+/* Duplication */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse)
+{
+    cJSON *newitem = NULL;
+    cJSON *child = NULL;
+    cJSON *next = NULL;
+    cJSON *newchild = NULL;
+
+    /* Bail on bad ptr */
+    if (!item)
+    {
+        goto fail;
+    }
+    /* Create new item */
+    newitem = cJSON_New_Item(&global_hooks);
+    if (!newitem)
+    {
+        goto fail;
+    }
+    /* Copy over all vars */
+    newitem->type = item->type & (~cJSON_IsReference);
+    newitem->valueint = item->valueint;
+    newitem->valuedouble = item->valuedouble;
+    if (item->valuestring)
+    {
+        newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks);
+        if (!newitem->valuestring)
+        {
+            goto fail;
+        }
+    }
+    if (item->string)
+    {
+        newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks);
+        if (!newitem->string)
+        {
+            goto fail;
+        }
+    }
+    /* If non recurse, then we're done! */
+    if (!recurse)
+    {
+        return newitem;
+    }
+    /* Walk the ->next chain for the child. */
+    child = item->child;
+    while (child != NULL)
+    {
+        newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the chain */
+        if (!newchild)
+        {
+            goto fail;
+        }
+        if (next != NULL)
+        {
+            /* If newitem->child already set, then crosswire ->prev and ->next and move on */
+            next->next = newchild;
+            newchild->prev = next;
+            next = newchild;
+        }
+        else
+        {
+            /* Set newitem->child and move to it */
+            newitem->child = newchild;
+            next = newchild;
+        }
+        child = child->next;
+    }
+    if (newitem && newitem->child)
+    {
+        newitem->child->prev = newchild;
+    }
+
+    return newitem;
+
+fail:
+    if (newitem != NULL)
+    {
+        cJSON_Delete(newitem);
+    }
+
+    return NULL;
+}
+
+static void skip_oneline_comment(char **input)
+{
+    *input += static_strlen("//");
+
+    for (; (*input)[0] != '\0'; ++(*input))
+    {
+        if ((*input)[0] == '\n') {
+            *input += static_strlen("\n");
+            return;
+        }
+    }
+}
+
+static void skip_multiline_comment(char **input)
+{
+    *input += static_strlen("/*");
+
+    for (; (*input)[0] != '\0'; ++(*input))
+    {
+        if (((*input)[0] == '*') && ((*input)[1] == '/'))
+        {
+            *input += static_strlen("*/");
+            return;
+        }
+    }
+}
+
+static void minify_string(char **input, char **output) {
+    (*output)[0] = (*input)[0];
+    *input += static_strlen("\"");
+    *output += static_strlen("\"");
+
+
+    for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) {
+        (*output)[0] = (*input)[0];
+
+        if ((*input)[0] == '\"') {
+            (*output)[0] = '\"';
+            *input += static_strlen("\"");
+            *output += static_strlen("\"");
+            return;
+        } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) {
+            (*output)[1] = (*input)[1];
+            *input += static_strlen("\"");
+            *output += static_strlen("\"");
+        }
+    }
+}
+
+CJSON_PUBLIC(void) cJSON_Minify(char *json)
+{
+    char *into = json;
+
+    if (json == NULL)
+    {
+        return;
+    }
+
+    while (json[0] != '\0')
+    {
+        switch (json[0])
+        {
+            case ' ':
+            case '\t':
+            case '\r':
+            case '\n':
+                json++;
+                break;
+
+            case '/':
+                if (json[1] == '/')
+                {
+                    skip_oneline_comment(&json);
+                }
+                else if (json[1] == '*')
+                {
+                    skip_multiline_comment(&json);
+                } else {
+                    json++;
+                }
+                break;
+
+            case '\"':
+                minify_string(&json, (char**)&into);
+                break;
+
+            default:
+                into[0] = json[0];
+                json++;
+                into++;
+        }
+    }
+
+    /* and null-terminate. */
+    *into = '\0';
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Invalid;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_False;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xff) == cJSON_True;
+}
+
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & (cJSON_True | cJSON_False)) != 0;
+}
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_NULL;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Number;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_String;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Array;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Object;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Raw;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive)
+{
+    if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)))
+    {
+        return false;
+    }
+
+    /* check if type is valid */
+    switch (a->type & 0xFF)
+    {
+        case cJSON_False:
+        case cJSON_True:
+        case cJSON_NULL:
+        case cJSON_Number:
+        case cJSON_String:
+        case cJSON_Raw:
+        case cJSON_Array:
+        case cJSON_Object:
+            break;
+
+        default:
+            return false;
+    }
+
+    /* identical objects are equal */
+    if (a == b)
+    {
+        return true;
+    }
+
+    switch (a->type & 0xFF)
+    {
+        /* in these cases and equal type is enough */
+        case cJSON_False:
+        case cJSON_True:
+        case cJSON_NULL:
+            return true;
+
+        case cJSON_Number:
+            if (compare_double(a->valuedouble, b->valuedouble))
+            {
+                return true;
+            }
+            return false;
+
+        case cJSON_String:
+        case cJSON_Raw:
+            if ((a->valuestring == NULL) || (b->valuestring == NULL))
+            {
+                return false;
+            }
+            if (strcmp(a->valuestring, b->valuestring) == 0)
+            {
+                return true;
+            }
+
+            return false;
+
+        case cJSON_Array:
+        {
+            cJSON *a_element = a->child;
+            cJSON *b_element = b->child;
+
+            for (; (a_element != NULL) && (b_element != NULL);)
+            {
+                if (!cJSON_Compare(a_element, b_element, case_sensitive))
+                {
+                    return false;
+                }
+
+                a_element = a_element->next;
+                b_element = b_element->next;
+            }
+
+            /* one of the arrays is longer than the other */
+            if (a_element != b_element) {
+                return false;
+            }
+
+            return true;
+        }
+
+        case cJSON_Object:
+        {
+            cJSON *a_element = NULL;
+            cJSON *b_element = NULL;
+            cJSON_ArrayForEach(a_element, a)
+            {
+                /* TODO This has O(n^2) runtime, which is horrible! */
+                b_element = get_object_item(b, a_element->string, case_sensitive);
+                if (b_element == NULL)
+                {
+                    return false;
+                }
+
+                if (!cJSON_Compare(a_element, b_element, case_sensitive))
+                {
+                    return false;
+                }
+            }
+
+            /* doing this twice, once on a and b to prevent true comparison if a subset of b
+             * TODO: Do this the proper way. */
+            cJSON_ArrayForEach(b_element, b)
+            {
+                a_element = get_object_item(a, b_element->string, case_sensitive);
+                if (a_element == NULL)
+                {
+                    return false;
+                }
+
+                if (!cJSON_Compare(b_element, a_element, case_sensitive))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        default:
+            return false;
+    }
+}
+
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size)
+{
+    return global_hooks.allocate(size);
+}
+
+CJSON_PUBLIC(void) cJSON_free(void *object)
+{
+    global_hooks.deallocate(object);
+}

cJSON.h

@@ -0,0 +1,290 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc) or -xldscope=hidden (for sun cc) to CFLAGS
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 18
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
+      void *(CJSON_CDECL *malloc_fn)(size_t sz);
+      void (CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when no error. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number list, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing item. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant,
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
+#define cJSON_SetBoolValue(object, boolValue) ( \
+    (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
+    (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
+    cJSON_Invalid\
+)
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

interpreter.c

@@ -0,0 +1,214 @@
+#include "interpreter.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdint.h>
+
+/* Global sync request flag (set by commands that modify state) */
+static int sync_requested = 0;
+
+void interpreter_request_sync(void) {
+    sync_requested = 1;
+}
+
+/* Command table – add your own commands here */
+static Command commands[] = {
+    { "boot",   boot_disk },
+    { "diag",   run_diagnostic },
+    { "status", get_status },
+    { "replan", cmd_replan },   /* new command */
+    { NULL, NULL }              /* sentinel */
+};
+
+/* ------------------------------------------------------------------
+ * Dynamic string builder (internal use)
+ * ------------------------------------------------------------------ */
+typedef struct {
+    char *str;
+    size_t len;
+    size_t cap;
+} string_builder;
+
+static void sb_init(string_builder *sb) {
+    sb->str = NULL;
+    sb->len = 0;
+    sb->cap = 0;
+}
+
+static int sb_append_char(string_builder *sb, char c) {
+    if (sb->len + 2 > sb->cap) {
+        size_t new_cap = sb->cap ? sb->cap * 2 : 32;
+        char *new_str = realloc(sb->str, new_cap);
+        if (!new_str) return -1;
+        sb->str = new_str;
+        sb->cap = new_cap;
+    }
+    sb->str[sb->len++] = c;
+    sb->str[sb->len] = '\0';
+    return 0;
+}
+
+static int sb_append_str(string_builder *sb, const char *s) {
+    while (*s) {
+        if (sb_append_char(sb, *s++) < 0) return -1;
+    }
+    return 0;
+}
+
+static void sb_free(string_builder *sb) {
+    free(sb->str);
+    sb->str = NULL;
+    sb->len = sb->cap = 0;
+}
+
+/* ------------------------------------------------------------------
+ * Split quoted string into argv (handles escaped quotes and backslashes)
+ * Returns NULL on error (memory or unterminated quote).
+ * Caller must free each argv[i] and then free argv.
+ * ------------------------------------------------------------------ */
+static char** split_quoted(const char* input, int* argc) {
+    char **argv = NULL;
+    int capacity = 0;
+    *argc = 0;
+    const char *p = input;
+
+    while (*p) {
+        while (isspace(*p)) p++;
+        if (!*p) break;
+
+        if (*argc >= capacity) {
+            capacity = capacity ? capacity * 2 : 8;
+            char **new_argv = realloc(argv, capacity * sizeof(char*));
+            if (!new_argv) goto error;
+            argv = new_argv;
+        }
+
+        string_builder sb;
+        sb_init(&sb);
+        char quote = 0;
+
+        if (*p == '"' || *p == '\'') {
+            quote = *p++;
+        }
+
+        int escaped = 0;
+        while (*p) {
+            if (escaped) {
+                if (sb_append_char(&sb, *p++) < 0) goto error;
+                escaped = 0;
+            } else if (*p == '\\') {
+                escaped = 1;
+                p++;
+            } else if (quote && *p == quote) {
+                p++; /* closing quote */
+                break;
+            } else if (!quote && isspace(*p)) {
+                break;
+            } else {
+                if (sb_append_char(&sb, *p++) < 0) goto error;
+            }
+        }
+
+        if (quote && !*p) {  /* unterminated quote */
+            sb_free(&sb);
+            goto error;
+        }
+
+        argv[(*argc)++] = sb.str;  /* sb.str is now owned by argv */
+    }
+
+    return argv;
+
+error:
+    for (int i = 0; i < *argc; i++) free(argv[i]);
+    free(argv);
+    return NULL;
+}
+
+/* ------------------------------------------------------------------
+ * Main interpreter
+ * ------------------------------------------------------------------ */
+char* interpret_command(const char* input) {
+    if (!input || *input == '\0')
+        return strdup("No input provided.");
+
+    int argc = 0;
+    char **argv = split_quoted(input, &argc);
+    if (!argv) return strdup("Memory error or unterminated quote.");
+
+    if (argc == 0) {
+        free(argv);
+        return strdup("");
+    }
+
+    char *result = NULL;
+    for (Command *c = commands; c->name; c++) {
+        if (strcmp(c->name, argv[0]) == 0) {
+            /* Build argument string safely */
+            string_builder sb;
+            sb_init(&sb);
+            for (int i = 1; i < argc; i++) {
+                if (i > 1) {
+                    if (sb_append_char(&sb, ' ') < 0) {
+                        sb_free(&sb);
+                        for (int j = 0; j < argc; j++) free(argv[j]);
+                        free(argv);
+                        return strdup("Memory error");
+                    }
+                }
+                if (sb_append_str(&sb, argv[i]) < 0) {
+                    sb_free(&sb);
+                    for (int j = 0; j < argc; j++) free(argv[j]);
+                    free(argv);
+                    return strdup("Memory error");
+                }
+            }
+            result = c->fn(sb.str ? sb.str : "");
+            sb_free(&sb);
+            break;
+        }
+    }
+
+    for (int i = 0; i < argc; i++) free(argv[i]);
+    free(argv);
+
+    if (!result) result = strdup("Unknown command.");
+    return result;
+}
+
+/* ------------------------------------------------------------------
+ * Example command implementations
+ * ------------------------------------------------------------------ */
+char* boot_disk(const char* args) {
+    size_t len = strlen("Booting disk with args: ") + strlen(args) + 1;
+    char *buf = malloc(len);
+    if (!buf) return strdup("Memory error");
+    snprintf(buf, len, "Booting disk with args: %s", args);
+    return buf;
+}
+
+char* run_diagnostic(const char* args) {
+    (void)args;
+    return strdup("Running diagnostic...");
+}
+
+char* get_status(const char* args) {
+    (void)args;
+    return strdup("Status: All systems nominal.");
+}
+
+/* ------------------------------------------------------------------
+ * New command: /replan – forces a fresh LLM call
+ * Returns a special marker that the main loop will recognize.
+ * ------------------------------------------------------------------ */
+char* cmd_replan(const char* args) {
+    (void)args;
+    /* Request a soul sync (though this command doesn't modify state) */
+    interpreter_request_sync();
+    /* Return the replan marker */
+    char *marker = malloc(strlen(INTERPRETER_MARKER_REPLAN) + 1);
+    if (!marker) return strdup("Memory error");
+    strcpy(marker, INTERPRETER_MARKER_REPLAN);
+    return marker;
+}

interpreter.h

@@ -0,0 +1,40 @@
+#ifndef INTERPRETER_H
+#define INTERPRETER_H
+
+/* Special return value prefixes (for communication with main loop) */
+#define INTERPRETER_MARKER_REPLAN     "REPLAN"
+#define INTERPRETER_MARKER_TOOL_RESULT "TOOL_RESULT:"
+
+/* Command handler signature:
+ *   Takes arguments string, returns malloc'd response.
+ *   Caller is responsible for freeing the returned string.
+ *   If the returned string starts with one of the INTERPRETER_MARKER_*
+ *   prefixes, the main loop will handle it specially.
+ */
+typedef char* (*CommandFn)(const char* args);
+
+/* Registered command entry */
+typedef struct {
+    const char* name;
+    CommandFn fn;
+} Command;
+
+/* Main interpreter entry point.
+ *   Input: user command line (may contain quoted arguments).
+ *   Returns: malloc'd result string (caller must free).
+ */
+char* interpret_command(const char* input);
+
+/* Call this after executing any command that modifies persistent state
+ * (e.g., adding/removing skills, cron jobs, webhooks, core memory).
+ * The main loop will then sync the soul file.
+ */
+void interpreter_request_sync(void);
+
+/* Example command implementations – replace with real logic */
+char* boot_disk(const char* args);
+char* run_diagnostic(const char* args);
+char* get_status(const char* args);
+char* cmd_replan(const char* args);   /* new: forces a fresh LLM call */
+
+#endif /* INTERPRETER_H */

shadowclaw.c

@@ -0,0 +1,1383 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <time.h>
+#include <curl/curl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <limits.h>
+#include <ctype.h>
+#include "cJSON.h"
+#include "interpreter.h"
+
+// ------------------------------------------------------------------
+// Version & Colors
+// ------------------------------------------------------------------
+#define SHADOWCLAW_VERSION "3.4"
+#define COLOR_RESET   "\033[0m"
+#define COLOR_RED     "\033[31m"
+#define COLOR_GREEN   "\033[32m"
+#define COLOR_YELLOW  "\033[33m"
+#define COLOR_BLUE    "\033[34m"
+#define COLOR_CYAN    "\033[36m"
+#define COLOR_BOLD    "\033[1m"
+
+// ------------------------------------------------------------------
+// Blob Storage (linked list, no fragmentation)
+// ------------------------------------------------------------------
+typedef enum {
+    BLOB_SYSTEM = 1,
+    BLOB_USER,
+    BLOB_ASSISTANT,
+    BLOB_TOOL_CALL,
+    BLOB_TOOL_RESULT,
+    BLOB_CORE_MEMORY,
+    BLOB_SKILL,
+    BLOB_CRONJOB,
+    BLOB_WEBHOOK
+} BlobKind;
+
+typedef struct Blob {
+    uint32_t kind;
+    uint64_t id;
+    size_t size;
+    char *data;
+    struct Blob *next;
+} Blob;
+
+static Blob *blob_list = NULL;
+static uint64_t next_id = 1;
+static int dirty = 0;
+
+void blob_append(BlobKind kind, const char *data) {
+    Blob *b = malloc(sizeof(Blob));
+    if (!b) abort();
+    b->kind = kind;
+    b->id = next_id++;
+    b->size = strlen(data);
+    b->data = malloc(b->size + 1);
+    if (!b->data) abort();
+    strcpy(b->data, data);
+    b->next = blob_list;
+    blob_list = b;
+    dirty = 1;
+}
+
+void blob_foreach_reverse(void (*cb)(Blob*, void*), void *user) {
+    // reverse list to get chronological order
+    Blob *prev = NULL, *curr = blob_list, *next;
+    while (curr) {
+        next = curr->next;
+        curr->next = prev;
+        prev = curr;
+        curr = next;
+    }
+    blob_list = prev;
+    curr = blob_list;
+    while (curr) {
+        cb(curr, user);
+        curr = curr->next;
+    }
+    // restore original order
+    prev = NULL;
+    curr = blob_list;
+    while (curr) {
+        next = curr->next;
+        curr->next = prev;
+        prev = curr;
+        curr = next;
+    }
+    blob_list = prev;
+}
+
+void blob_clear(void) {
+    Blob *b = blob_list;
+    while (b) {
+        Blob *next = b->next;
+        free(b->data);
+        free(b);
+        b = next;
+    }
+    blob_list = NULL;
+    next_id = 1;
+    dirty = 1;
+}
+
+int save_state(const char *filename) {
+    FILE *f = fopen(filename, "wb");
+    if (!f) return -1;
+    uint32_t magic = 0x53484C42; // "SHLB"
+    uint32_t version = 1;
+    fwrite(&magic, 4, 1, f);
+    fwrite(&version, 4, 1, f);
+    fwrite(&next_id, 8, 1, f);
+    // Write blobs in order (oldest first)
+    Blob *prev = NULL, *curr = blob_list, *next;
+    while (curr) {
+        next = curr->next;
+        curr->next = prev;
+        prev = curr;
+        curr = next;
+    }
+    blob_list = prev;
+    curr = blob_list;
+    while (curr) {
+        fwrite(&curr->kind, 4, 1, f);
+        fwrite(&curr->id, 8, 1, f);
+        fwrite(&curr->size, 8, 1, f);
+        fwrite(curr->data, 1, curr->size + 1, f);
+        curr = curr->next;
+    }
+    // restore
+    prev = NULL;
+    curr = blob_list;
+    while (curr) {
+        next = curr->next;
+        curr->next = prev;
+        prev = curr;
+        curr = next;
+    }
+    blob_list = prev;
+    fclose(f);
+    dirty = 0;
+    return 0;
+}
+
+int load_state(const char *filename) {
+    FILE *f = fopen(filename, "rb");
+    if (!f) return -1;
+    uint32_t magic, version;
+    if (fread(&magic, 4, 1, f) != 1 || magic != 0x53484C42) {
+        fclose(f);
+        return -1;
+    }
+    if (fread(&version, 4, 1, f) != 1 || version != 1) {
+        fclose(f);
+        return -1;
+    }
+    if (fread(&next_id, 8, 1, f) != 1) {
+        fclose(f);
+        return -1;
+    }
+    blob_clear();
+    while (!feof(f)) {
+        uint32_t kind;
+        uint64_t id;
+        size_t size;
+        if (fread(&kind, 4, 1, f) != 1) break;
+        if (fread(&id, 8, 1, f) != 1) break;
+        if (fread(&size, 8, 1, f) != 1) break;
+        char *data = malloc(size + 1);
+        if (!data) { fclose(f); return -1; }
+        if (fread(data, 1, size + 1, f) != size + 1) {
+            free(data);
+            fclose(f);
+            return -1;
+        }
+        Blob *b = malloc(sizeof(Blob));
+        if (!b) { free(data); fclose(f); return -1; }
+        b->kind = kind;
+        b->id = id;
+        b->size = size;
+        b->data = data;
+        b->next = blob_list;
+        blob_list = b;
+    }
+    fclose(f);
+    dirty = 0;
+    return 0;
+}
+
+void sync_soul_file(const char *soul_file) {
+    FILE *f = fopen(soul_file, "w");
+    if (!f) return;
+    fprintf(f, "# ShadowSoul - Unified Memory\n");
+    time_t now = time(NULL);
+    fprintf(f, "Last updated: %s", ctime(&now));
+    fprintf(f, "\n## Core Memory\n");
+    Blob *b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_CORE_MEMORY)
+            fprintf(f, "```json\n%s\n```\n\n", b->data);
+        b = b->next;
+    }
+    fprintf(f, "## Skills\n");
+    b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_SKILL)
+            fprintf(f, "- %s\n", b->data);
+        b = b->next;
+    }
+    fprintf(f, "\n## Cron Jobs\n");
+    b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_CRONJOB)
+            fprintf(f, "- %s\n", b->data);
+        b = b->next;
+    }
+    fprintf(f, "\n## Webhooks\n");
+    b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_WEBHOOK)
+            fprintf(f, "- %s\n", b->data);
+        b = b->next;
+    }
+    fprintf(f, "\n## Conversation Log\n");
+    // Print in chronological order
+    Blob *prev = NULL, *curr = blob_list, *next;
+    while (curr) {
+        next = curr->next;
+        curr->next = prev;
+        prev = curr;
+        curr = next;
+    }
+    blob_list = prev;
+    curr = blob_list;
+    while (curr) {
+        if (curr->kind == BLOB_USER || curr->kind == BLOB_ASSISTANT ||
+            curr->kind == BLOB_TOOL_CALL || curr->kind == BLOB_TOOL_RESULT) {
+            const char *role = "";
+            switch (curr->kind) {
+                case BLOB_USER: role = "User"; break;
+                case BLOB_ASSISTANT: role = "Assistant"; break;
+                case BLOB_TOOL_CALL: role = "Tool Call"; break;
+                case BLOB_TOOL_RESULT: role = "Tool Result"; break;
+                default: break;
+            }
+            fprintf(f, "### %s\n%s\n\n", role, curr->data);
+        }
+        curr = curr->next;
+    }
+    // restore
+    prev = NULL;
+    curr = blob_list;
+    while (curr) {
+        next = curr->next;
+        curr->next = prev;
+        prev = curr;
+        curr = next;
+    }
+    blob_list = prev;
+    fclose(f);
+}
+
+// ------------------------------------------------------------------
+// Tools (with runtime filtering)
+// ------------------------------------------------------------------
+typedef struct Tool {
+    const char *name;
+    char *(*func)(const char *args);
+    const char *description;
+    int enabled;
+} Tool;
+
+// Forward declarations
+char* tool_shell(const char *args);
+char* tool_file_read(const char *args);
+char* tool_file_write(const char *args);
+char* tool_http_get(const char *args);
+char* tool_math(const char *args);
+char* tool_list_dir(const char *args);
+char* tool_webhook_add(const char *args);
+char* tool_cron_add(const char *args);
+char* tool_cron_list(const char *args);
+char* tool_cron_remove(const char *args);
+char* tool_skill_add(const char *args);
+char* tool_skill_run(const char *args);
+char* tool_list_skills(const char *args);
+char* tool_update_core_memory(const char *args);
+char* tool_recall(const char *args);
+char* tool_heartbeat(const char *args);
+
+// Implementations (simplified but functional)
+char* tool_shell(const char *args) {
+    (void)args;
+    return strdup("Shell tool is disabled for security.");
+}
+
+#define MAX_FILE_SIZE (10 * 1024 * 1024)
+#define MAX_TOOL_RESULT 2000
+
+char* tool_file_read(const char *args) {
+    FILE *f = fopen(args, "rb");
+    if (!f) return strdup("Error: cannot open file");
+    if (fseek(f, 0, SEEK_END) != 0) { fclose(f); return strdup("Error seeking file"); }
+    long size = ftell(f);
+    if (size == -1 || size > MAX_FILE_SIZE) { fclose(f); return strdup("File too large"); }
+    rewind(f);
+    char *buf = malloc(size + 1);
+    if (!buf) { fclose(f); return strdup("Memory error"); }
+    size_t read = fread(buf, 1, size, f);
+    buf[read] = '\0';
+    fclose(f);
+    if (strlen(buf) > MAX_TOOL_RESULT) buf[MAX_TOOL_RESULT] = '\0';
+    return buf;
+}
+
+char* tool_file_write(const char *args) {
+    const char *space = strchr(args, ' ');
+    if (!space) return strdup("Invalid: need 'filename content'");
+    size_t fname_len = space - args;
+    char *fname = malloc(fname_len + 1);
+    if (!fname) return strdup("Memory error");
+    memcpy(fname, args, fname_len);
+    fname[fname_len] = '\0';
+    const char *content = space + 1;
+    FILE *f = fopen(fname, "w");
+    free(fname);
+    if (!f) return strdup("Cannot write file");
+    fprintf(f, "%s", content);
+    fclose(f);
+    return strdup("File written");
+}
+
+static size_t http_write_cb(void *ptr, size_t size, size_t nmemb, void *user) {
+    size_t total = size * nmemb;
+    char **resp = (char**)user;
+    size_t old_len = *resp ? strlen(*resp) : 0;
+    char *new = realloc(*resp, old_len + total + 1);
+    if (!new) return 0;
+    *resp = new;
+    memcpy(*resp + old_len, ptr, total);
+    (*resp)[old_len + total] = '\0';
+    return total;
+}
+
+char* tool_http_get(const char *args) {
+    CURL *curl = curl_easy_init();
+    if (!curl) return strdup("curl init failed");
+    char *response = NULL;
+    curl_easy_setopt(curl, CURLOPT_URL, args);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, http_write_cb);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
+    CURLcode res = curl_easy_perform(curl);
+    curl_easy_cleanup(curl);
+    if (res != CURLE_OK) {
+        free(response);
+        return strdup("HTTP request failed");
+    }
+    if (response && strlen(response) > MAX_TOOL_RESULT) response[MAX_TOOL_RESULT] = '\0';
+    return response ? response : strdup("");
+}
+
+char* tool_math(const char *args) {
+    // simple eval using bc
+    char cmd[512];
+    snprintf(cmd, sizeof(cmd), "echo '%s' | bc 2>/dev/null", args);
+    FILE *fp = popen(cmd, "r");
+    if (!fp) return strdup("Math error");
+    char buf[256];
+    char *result = NULL;
+    size_t len = 0;
+    while (fgets(buf, sizeof(buf), fp)) {
+        size_t l = strlen(buf);
+        char *new = realloc(result, len + l + 1);
+        if (!new) { free(result); pclose(fp); return strdup("Memory error"); }
+        result = new;
+        memcpy(result + len, buf, l + 1);
+        len += l;
+    }
+    pclose(fp);
+    if (!result) result = strdup("");
+    if (strlen(result) > MAX_TOOL_RESULT) result[MAX_TOOL_RESULT] = '\0';
+    return result;
+}
+
+char* tool_list_dir(const char *args) {
+    DIR *d = opendir(args);
+    if (!d) return strdup("Cannot open directory");
+    char *result = NULL;
+    size_t len = 0;
+    FILE *out = open_memstream(&result, &len);
+    if (!out) { closedir(d); return strdup("Memory error"); }
+    struct dirent *entry;
+    while ((entry = readdir(d)) != NULL) fprintf(out, "%s\n", entry->d_name);
+    closedir(d);
+    fclose(out);
+    if (!result) result = strdup("");
+    if (strlen(result) > MAX_TOOL_RESULT) result[MAX_TOOL_RESULT] = '\0';
+    return result;
+}
+
+char* tool_webhook_add(const char *args) {
+    cJSON *j = cJSON_Parse(args);
+    if (!j) return strdup("Invalid JSON");
+    cJSON *url = cJSON_GetObjectItem(j, "url");
+    cJSON *event = cJSON_GetObjectItem(j, "event");
+    if (!cJSON_IsString(url) || !cJSON_IsString(event)) {
+        cJSON_Delete(j);
+        return strdup("Missing url or event");
+    }
+    cJSON *obj = cJSON_CreateObject();
+    cJSON_AddStringToObject(obj, "url", url->valuestring);
+    cJSON_AddStringToObject(obj, "event", event->valuestring);
+    char *entry = cJSON_PrintUnformatted(obj);
+    cJSON_Delete(obj);
+    cJSON_Delete(j);
+    if (entry) {
+        blob_append(BLOB_WEBHOOK, entry);
+        free(entry);
+        return strdup("Webhook added");
+    }
+    return strdup("Memory error");
+}
+
+char* tool_cron_add(const char *args) {
+    cJSON *j = cJSON_Parse(args);
+    if (!j) return strdup("Invalid JSON");
+    cJSON *sched = cJSON_GetObjectItem(j, "schedule");
+    cJSON *tool = cJSON_GetObjectItem(j, "tool");
+    cJSON *tool_args = cJSON_GetObjectItem(j, "args");
+    if (!cJSON_IsString(sched) || !cJSON_IsString(tool) || !cJSON_IsString(tool_args)) {
+        cJSON_Delete(j);
+        return strdup("Missing schedule, tool, or args");
+    }
+    cJSON *obj = cJSON_CreateObject();
+    cJSON_AddStringToObject(obj, "schedule", sched->valuestring);
+    cJSON_AddStringToObject(obj, "tool", tool->valuestring);
+    cJSON_AddStringToObject(obj, "args", tool_args->valuestring);
+    cJSON_AddNumberToObject(obj, "last_run", 0);
+    char *entry = cJSON_PrintUnformatted(obj);
+    cJSON_Delete(obj);
+    cJSON_Delete(j);
+    if (entry) {
+        blob_append(BLOB_CRONJOB, entry);
+        free(entry);
+        return strdup("Cron job added");
+    }
+    return strdup("Memory error");
+}
+
+char* tool_cron_list(const char *args) {
+    (void)args;
+    char *result = NULL;
+    size_t len = 0;
+    FILE *out = open_memstream(&result, &len);
+    if (!out) return strdup("Memory error");
+    Blob *b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_CRONJOB) fprintf(out, "%s\n", b->data);
+        b = b->next;
+    }
+    fclose(out);
+    if (!result) result = strdup("");
+    if (strlen(result) > MAX_TOOL_RESULT) result[MAX_TOOL_RESULT] = '\0';
+    return result;
+}
+
+char* tool_cron_remove(const char *args) {
+    Blob *prev = NULL, *curr = blob_list;
+    int removed = 0;
+    while (curr) {
+        if (curr->kind == BLOB_CRONJOB && strstr(curr->data, args)) {
+            Blob *next = curr->next;
+            if (prev) prev->next = next;
+            else blob_list = next;
+            free(curr->data);
+            free(curr);
+            curr = next;
+            removed++;
+            dirty = 1;
+        } else {
+            prev = curr;
+            curr = curr->next;
+        }
+    }
+    char msg[64];
+    snprintf(msg, sizeof(msg), "Removed %d cron job(s)", removed);
+    return strdup(msg);
+}
+
+char* tool_skill_add(const char *args) {
+    cJSON *j = cJSON_Parse(args);
+    if (!j) return strdup("Invalid JSON");
+    cJSON *name = cJSON_GetObjectItem(j, "name");
+    cJSON *desc = cJSON_GetObjectItem(j, "desc");
+    cJSON *steps = cJSON_GetObjectItem(j, "steps");
+    if (!cJSON_IsString(name) || !cJSON_IsString(desc) || !cJSON_IsArray(steps)) {
+        cJSON_Delete(j);
+        return strdup("Missing name, desc, or steps array");
+    }
+    cJSON *obj = cJSON_CreateObject();
+    cJSON_AddStringToObject(obj, "name", name->valuestring);
+    cJSON_AddStringToObject(obj, "desc", desc->valuestring);
+    cJSON_AddItemToObject(obj, "steps", cJSON_Duplicate(steps, 1));
+    char *entry = cJSON_PrintUnformatted(obj);
+    cJSON_Delete(obj);
+    cJSON_Delete(j);
+    if (entry) {
+        blob_append(BLOB_SKILL, entry);
+        free(entry);
+        return strdup("Skill added");
+    }
+    return strdup("Memory error");
+}
+
+char* tool_skill_run(const char *args) {
+    char *copy = strdup(args);
+    if (!copy) return strdup("Memory error");
+    char *space = strchr(copy, ' ');
+    if (space) *space = '\0';
+    const char *skill_name = copy;
+    const char *skill_args = space ? space + 1 : "";
+    char *result = NULL;
+    asprintf(&result, "RUN_SKILL:%s:%s", skill_name, skill_args);
+    free(copy);
+    return result ? result : strdup("");
+}
+
+char* tool_list_skills(const char *args) {
+    (void)args;
+    char *result = NULL;
+    size_t len = 0;
+    FILE *out = open_memstream(&result, &len);
+    if (!out) return strdup("Memory error");
+    Blob *b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_SKILL) {
+            cJSON *j = cJSON_Parse(b->data);
+            if (j) {
+                cJSON *name = cJSON_GetObjectItem(j, "name");
+                if (cJSON_IsString(name)) fprintf(out, "%s\n", name->valuestring);
+                cJSON_Delete(j);
+            }
+        }
+        b = b->next;
+    }
+    fclose(out);
+    if (!result) result = strdup("");
+    if (strlen(result) > MAX_TOOL_RESULT) result[MAX_TOOL_RESULT] = '\0';
+    return result;
+}
+
+char* tool_update_core_memory(const char *args) {
+    cJSON *updates = cJSON_Parse(args);
+    if (!updates) return strdup("Invalid JSON");
+    // Find existing core memory
+    cJSON *core = NULL;
+    Blob *b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_CORE_MEMORY) {
+            core = cJSON_Parse(b->data);
+            break;
+        }
+        b = b->next;
+    }
+    if (!core) core = cJSON_CreateObject();
+    // Merge updates
+    cJSON *child = NULL;
+    cJSON_ArrayForEach(child, updates) {
+        cJSON_AddItemToObject(core, child->string, cJSON_Duplicate(child, 1));
+    }
+    char *new_core = cJSON_PrintUnformatted(core);
+    cJSON_Delete(core);
+    cJSON_Delete(updates);
+    if (!new_core) return strdup("Memory error");
+    // Delete old core blob
+    Blob *prev = NULL, *curr = blob_list;
+    while (curr) {
+        if (curr->kind == BLOB_CORE_MEMORY) {
+            if (prev) prev->next = curr->next;
+            else blob_list = curr->next;
+            free(curr->data);
+            free(curr);
+            break;
+        }
+        prev = curr;
+        curr = curr->next;
+    }
+    blob_append(BLOB_CORE_MEMORY, new_core);
+    free(new_core);
+    dirty = 1;
+    return strdup("Core memory updated");
+}
+
+char* tool_recall(const char *args) {
+    char *result = NULL;
+    size_t len = 0;
+    FILE *out = open_memstream(&result, &len);
+    if (!out) return strdup("Memory error");
+    Blob *b = blob_list;
+    while (b) {
+        if ((b->kind == BLOB_USER || b->kind == BLOB_ASSISTANT) && strcasestr(b->data, args)) {
+            const char *role = (b->kind == BLOB_USER) ? "User" : "Assistant";
+            fprintf(out, "[%s] %s\n", role, b->data);
+        }
+        b = b->next;
+    }
+    fclose(out);
+    if (!result) result = strdup("");
+    if (strlen(result) > MAX_TOOL_RESULT) result[MAX_TOOL_RESULT] = '\0';
+    return result;
+}
+
+char* tool_heartbeat(const char *args) {
+    (void)args;
+    return strdup("Heartbeat");
+}
+
+static Tool tools[] = {
+    {"shell", tool_shell, "Execute shell command (disabled)", 0},
+    {"file_read", tool_file_read, "Read a file", 1},
+    {"file_write", tool_file_write, "Write a file", 1},
+    {"http_get", tool_http_get, "HTTP GET request", 1},
+    {"math", tool_math, "Evaluate arithmetic expression", 1},
+    {"list_dir", tool_list_dir, "List directory contents", 1},
+    {"webhook_add", tool_webhook_add, "Add a webhook", 1},
+    {"cron_add", tool_cron_add, "Add a cron job", 1},
+    {"cron_list", tool_cron_list, "List cron jobs", 1},
+    {"cron_remove", tool_cron_remove, "Remove cron jobs", 1},
+    {"skill_add", tool_skill_add, "Add a skill", 1},
+    {"skill_run", tool_skill_run, "Run a skill", 1},
+    {"list_skills", tool_list_skills, "List skills", 1},
+    {"update_core_memory", tool_update_core_memory, "Update core memory", 1},
+    {"recall", tool_recall, "Search conversation history", 1},
+    {"heartbeat", tool_heartbeat, "Internal heartbeat", 1},
+    {NULL, NULL, NULL, 0}
+};
+
+char* execute_tool(const char *name, const char *args) {
+    for (Tool *t = tools; t->name; t++) {
+        if (strcmp(t->name, name) == 0 && t->enabled) {
+            return t->func(args);
+        }
+    }
+    return strdup("Unknown or disabled tool");
+}
+
+// ------------------------------------------------------------------
+// LLM Communication
+// ------------------------------------------------------------------
+static int no_llm_mode = 0;
+static int dry_run = 0;
+static char state_filename[256] = "shadowclaw.bin";
+static char soul_filename[256] = "shadowclaw_data/shadowsoul.md";
+static const char *ollama_endpoint = "http://localhost:11434";
+static const char *ollama_model = "qwen2.5:0.5b";
+static long llm_connect_timeout = 15;
+static long llm_total_timeout = 180;
+static int llm_retry_attempts = 5;
+static int shell_enabled = 0;
+
+static int ollama_healthy(void) {
+    CURL *curl = curl_easy_init();
+    if (!curl) return 0;
+    curl_easy_setopt(curl, CURLOPT_URL, ollama_endpoint);
+    curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 2L);
+    CURLcode res = curl_easy_perform(curl);
+    curl_easy_cleanup(curl);
+    return (res == CURLE_OK);
+}
+
+typedef struct {
+    char *data;
+    size_t len;
+} RespBuf;
+
+static size_t llm_write_cb(void *ptr, size_t size, size_t nmemb, void *stream) {
+    RespBuf *buf = (RespBuf*)stream;
+    size_t total = size * nmemb;
+    char *new = realloc(buf->data, buf->len + total + 1);
+    if (!new) return 0;
+    buf->data = new;
+    memcpy(buf->data + buf->len, ptr, total);
+    buf->len += total;
+    buf->data[buf->len] = '\0';
+    return total;
+}
+
+static char* call_llm(const char *prompt) {
+    if (!ollama_healthy()) {
+        fprintf(stderr, COLOR_YELLOW "Ollama unreachable. Switching to no-llm mode.\n" COLOR_RESET);
+        no_llm_mode = 1;
+        return NULL;
+    }
+    CURL *curl = curl_easy_init();
+    if (!curl) return NULL;
+    char url[256];
+    snprintf(url, sizeof(url), "%s/api/generate", ollama_endpoint);
+    cJSON *req = cJSON_CreateObject();
+    cJSON_AddStringToObject(req, "model", ollama_model);
+    cJSON_AddStringToObject(req, "prompt", prompt);
+    cJSON_AddBoolToObject(req, "stream", 0);
+    char *req_str = cJSON_PrintUnformatted(req);
+    cJSON_Delete(req);
+    struct curl_slist *headers = NULL;
+    headers = curl_slist_append(headers, "Content-Type: application/json");
+    RespBuf resp = {0};
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, req_str);
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, llm_write_cb);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
+    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, llm_connect_timeout);
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, llm_total_timeout);
+    CURLcode res = curl_easy_perform(curl);
+    free(req_str);
+    curl_slist_free_all(headers);
+    curl_easy_cleanup(curl);
+    if (res != CURLE_OK) {
+        fprintf(stderr, COLOR_RED "LLM request failed: %s\n" COLOR_RESET, curl_easy_strerror(res));
+        free(resp.data);
+        return NULL;
+    }
+    cJSON *root = cJSON_Parse(resp.data);
+    free(resp.data);
+    if (!root) return NULL;
+    cJSON *response = cJSON_GetObjectItem(root, "response");
+    char *result = response && cJSON_IsString(response) ? strdup(response->valuestring) : NULL;
+    cJSON_Delete(root);
+    return result;
+}
+
+static char* build_simple_prompt(const char *user_msg) {
+    // Build list of available tools (filter by enabled)
+    char tools_list[1024] = "";
+    for (Tool *t = tools; t->name; t++) {
+        if (t->enabled) {
+            strcat(tools_list, t->name);
+            strcat(tools_list, ", ");
+        }
+    }
+    if (strlen(tools_list) > 2) tools_list[strlen(tools_list)-2] = '\0';
+    // Collect core memory
+    char *core = strdup("{}");
+    Blob *b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_CORE_MEMORY) {
+            free(core);
+            core = strdup(b->data);
+            break;
+        }
+        b = b->next;
+    }
+    // Collect last 5 conversation turns (chronological)
+    char history[4096] = "";
+    Blob *prev = NULL, *curr = blob_list, *next;
+    while (curr) {
+        next = curr->next;
+        curr->next = prev;
+        prev = curr;
+        curr = next;
+    }
+    blob_list = prev;
+    int count = 0;
+    curr = blob_list;
+    while (curr && count < 10) { // 5 pairs
+        if (curr->kind == BLOB_USER || curr->kind == BLOB_ASSISTANT ||
+            curr->kind == BLOB_TOOL_CALL || curr->kind == BLOB_TOOL_RESULT) {
+            const char *role = "";
+            switch (curr->kind) {
+                case BLOB_USER: role = "User"; break;
+                case BLOB_ASSISTANT: role = "Assistant"; break;
+                case BLOB_TOOL_CALL: role = "Tool call"; break;
+                case BLOB_TOOL_RESULT: role = "Tool result"; break;
+            }
+            char line[512];
+            snprintf(line, sizeof(line), "%s: %s\n", role, curr->data);
+            strcat(history, line);
+            count++;
+        }
+        curr = curr->next;
+    }
+    // restore list
+    prev = NULL;
+    curr = blob_list;
+    while (curr) {
+        next = curr->next;
+        curr->next = prev;
+        prev = curr;
+        curr = next;
+    }
+    blob_list = prev;
+    char *prompt;
+    asprintf(&prompt,
+        "You are Shadowclaw, an AI assistant with access to tools.\n"
+        "Core memory: %s\n\n"
+        "Recent conversation:\n%s\n\n"
+        "Available tools: %s\n"
+        "To use a tool, output exactly:\n```tool\n{\"tool\":\"name\",\"args\":\"arguments\"}\n```\n"
+        "Otherwise, respond normally.\n\n"
+        "User: %s\n",
+        core, history, tools_list, user_msg);
+    free(core);
+    return prompt;
+}
+
+static char* extract_tool_json(const char *response) {
+    const char *start = strstr(response, "```tool");
+    if (!start) return NULL;
+    start += 7;
+    while (*start == ' ' || *start == '\n') start++;
+    const char *end = strstr(start, "```");
+    if (!end) return NULL;
+    size_t len = end - start;
+    char *json = malloc(len + 1);
+    if (!json) return NULL;
+    memcpy(json, start, len);
+    json[len] = '\0';
+    return json;
+}
+
+static int parse_tool_call(const char *json_str, char **tool_name, char **tool_args) {
+    cJSON *root = cJSON_Parse(json_str);
+    if (!root) return 0;
+    cJSON *name = cJSON_GetObjectItem(root, "tool");
+    cJSON *args = cJSON_GetObjectItem(root, "args");
+    if (!cJSON_IsString(name)) {
+        cJSON_Delete(root);
+        return 0;
+    }
+    *tool_name = strdup(name->valuestring);
+    if (cJSON_IsString(args)) {
+        *tool_args = strdup(args->valuestring);
+    } else if (cJSON_IsArray(args)) {
+        int size = cJSON_GetArraySize(args);
+        size_t total = 0;
+        for (int i = 0; i < size; i++) {
+            cJSON *elem = cJSON_GetArrayItem(args, i);
+            if (cJSON_IsString(elem)) total += strlen(elem->valuestring) + 1;
+        }
+        *tool_args = malloc(total + 1);
+        if (*tool_args) {
+            (*tool_args)[0] = '\0';
+            for (int i = 0; i < size; i++) {
+                cJSON *elem = cJSON_GetArrayItem(args, i);
+                if (cJSON_IsString(elem)) {
+                    if (i > 0) strcat(*tool_args, " ");
+                    strcat(*tool_args, elem->valuestring);
+                }
+            }
+        } else {
+            *tool_args = strdup("");
+        }
+    } else {
+        *tool_args = strdup("");
+    }
+    cJSON_Delete(root);
+    return 1;
+}
+
+// Webhook retry
+static int http_post_with_retry(const char *url, const char *payload) {
+    int delays[] = {1, 2, 4};
+    for (int i = 0; i < 3; i++) {
+        CURL *curl = curl_easy_init();
+        if (!curl) continue;
+        struct curl_slist *headers = NULL;
+        headers = curl_slist_append(headers, "Content-Type: application/json");
+        curl_easy_setopt(curl, CURLOPT_URL, url);
+        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
+        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 5L);
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, fwrite); // discard
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, stdout);
+        CURLcode res = curl_easy_perform(curl);
+        curl_easy_cleanup(curl);
+        curl_slist_free_all(headers);
+        if (res == CURLE_OK) return 0;
+        sleep(delays[i]);
+    }
+    fprintf(stderr, COLOR_RED "Webhook POST failed after retries\n" COLOR_RESET);
+    return -1;
+}
+
+static void trigger_webhooks(const char *event, const char *data) {
+    Blob *b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_WEBHOOK) {
+            cJSON *j = cJSON_Parse(b->data);
+            if (j) {
+                cJSON *url = cJSON_GetObjectItem(j, "url");
+                cJSON *ev = cJSON_GetObjectItem(j, "event");
+                if (cJSON_IsString(url) && cJSON_IsString(ev) && strcmp(ev->valuestring, event) == 0) {
+                    cJSON *payload = cJSON_CreateObject();
+                    cJSON_AddStringToObject(payload, "event", event);
+                    cJSON_AddStringToObject(payload, "data", data);
+                    char *payload_str = cJSON_PrintUnformatted(payload);
+                    cJSON_Delete(payload);
+                    if (payload_str) {
+                        http_post_with_retry(url->valuestring, payload_str);
+                        free(payload_str);
+                    }
+                }
+                cJSON_Delete(j);
+            }
+        }
+        b = b->next;
+    }
+}
+
+// Cron processing in main loop
+static void process_cron_jobs(void) {
+    time_t now = time(NULL);
+    Blob *b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_CRONJOB) {
+            cJSON *j = cJSON_Parse(b->data);
+            if (!j) { b = b->next; continue; }
+            cJSON *sched = cJSON_GetObjectItem(j, "schedule");
+            cJSON *tool = cJSON_GetObjectItem(j, "tool");
+            cJSON *args = cJSON_GetObjectItem(j, "args");
+            cJSON *last_run_json = cJSON_GetObjectItem(j, "last_run");
+            if (cJSON_IsString(sched) && cJSON_IsString(tool) && cJSON_IsString(args) && cJSON_IsNumber(last_run_json)) {
+                time_t last_run = (time_t)last_run_json->valuedouble;
+                int interval = 0;
+                if (strcmp(sched->valuestring, "@heartbeat") == 0) interval = 120;
+                else if (strncmp(sched->valuestring, "@every ", 7) == 0) {
+                    int val = atoi(sched->valuestring + 7);
+                    interval = val;
+                } else if (strcmp(sched->valuestring, "@hourly") == 0) interval = 3600;
+                else if (strcmp(sched->valuestring, "@daily") == 0) interval = 86400;
+                else if (strcmp(sched->valuestring, "@weekly") == 0) interval = 604800;
+                if (interval > 0 && (now - last_run) >= interval) {
+                    if (strcmp(tool->valuestring, "heartbeat") == 0) {
+                        // run heartbeat immediately
+                        char *result = execute_tool("heartbeat", "");
+                        printf(COLOR_CYAN "[Cron] Heartbeat: %s\n" COLOR_RESET, result);
+                        free(result);
+                    } else {
+                        // queue? For simplicity, just execute now
+                        char *result = execute_tool(tool->valuestring, args->valuestring);
+                        printf(COLOR_CYAN "[Cron] %s(%s) -> %s\n" COLOR_RESET, tool->valuestring, args->valuestring, result);
+                        free(result);
+                    }
+                    // update last_run in blob
+                    cJSON_SetNumberValue(last_run_json, (double)now);
+                    char *new_data = cJSON_PrintUnformatted(j);
+                    if (new_data) {
+                        // replace blob
+                        Blob *prev = NULL, *curr = blob_list;
+                        while (curr) {
+                            if (curr == b) {
+                                if (prev) prev->next = curr->next;
+                                else blob_list = curr->next;
+                                free(curr->data);
+                                free(curr);
+                                break;
+                            }
+                            prev = curr;
+                            curr = curr->next;
+                        }
+                        blob_append(BLOB_CRONJOB, new_data);
+                        free(new_data);
+                        dirty = 1;
+                        break; // restart iteration
+                    }
+                }
+            }
+            cJSON_Delete(j);
+        }
+        b = b->next;
+    }
+}
+
+// ------------------------------------------------------------------
+// Slash Commands (restored full menu)
+// ------------------------------------------------------------------
+static void print_help(void) {
+    printf(COLOR_BOLD "\nShadowclaw v%s commands:\n" COLOR_RESET, SHADOWCLAW_VERSION);
+    printf("  %-12s %s\n", "/help", "Show this help");
+    printf("  %-12s %s\n", "/tools", "List available tools");
+    printf("  %-12s %s\n", "/state", "Show arena memory stats and soul file info");
+    printf("  %-12s %s\n", "/clear", "Clear conversation history");
+    printf("  %-12s %s\n", "/exit", "Exit Shadowclaw");
+    printf("  %-12s %s\n", "/loop", "Schedule a recurring task: /loop <schedule> <tool> [args...]");
+    printf("  %-12s %s\n", "/crons", "List scheduled cron jobs");
+    printf("  %-12s %s\n", "/webhooks", "List registered webhooks");
+    printf("  %-12s %s\n", "/skills", "List dynamic skills");
+    printf("  %-12s %s\n", "/compact", "Manually compact arena (remove deleted blobs)");
+    printf("  %-12s %s\n", "/soul", "Show path to shadowsoul.md and last update");
+    printf("  %-12s %s\n", "/reconnect", "Reconnect to Ollama (if LLM mode is off)");
+
+    printf(COLOR_BOLD "\nBuilt-in tools:\n" COLOR_RESET);
+    for (Tool *t = tools; t->name; t++) printf("  %s\n", t->name);
+
+    int skill_count = 0;
+    Blob *b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_SKILL) {
+            cJSON *j = cJSON_Parse(b->data);
+            if (j) {
+                cJSON *name = cJSON_GetObjectItem(j, "name");
+                cJSON *desc = cJSON_GetObjectItem(j, "desc");
+                if (cJSON_IsString(name) && cJSON_IsString(desc)) {
+                    if (skill_count == 0) printf(COLOR_BOLD "\nDynamic skills:\n" COLOR_RESET);
+                    printf("  %-12s %s\n", name->valuestring, desc->valuestring);
+                    skill_count++;
+                }
+                cJSON_Delete(j);
+            }
+        }
+        b = b->next;
+    }
+    if (skill_count == 0) printf("\nNo dynamic skills loaded. Use skill_add to create one.\n");
+
+    struct stat st;
+    if (stat(soul_filename, &st) == 0) {
+        char timebuf[128];
+        struct tm *tm_info = localtime(&st.st_mtime);
+        strftime(timebuf, sizeof(timebuf), "%c", tm_info);
+        printf("\nSoul file: %s (%ld bytes, last modified: %s\n", soul_filename, st.st_size, timebuf);
+    } else {
+        printf("\nSoul file not yet created.\n");
+    }
+    printf("\n");
+}
+
+static void list_tools(void) {
+    printf(COLOR_BOLD "Enabled tools:\n" COLOR_RESET);
+    for (Tool *t = tools; t->name; t++) {
+        if (t->enabled)
+            printf("  %-12s %s\n", t->name, t->description);
+    }
+}
+
+static void show_state(void) {
+    size_t total_size = 0;
+    Blob *b = blob_list;
+    while (b) {
+        total_size += sizeof(Blob) + b->size + 1;
+        b = b->next;
+    }
+    printf("Blob count: %llu (next id: %llu)\n", (unsigned long long)(next_id - 1), (unsigned long long)next_id);
+    printf("Estimated memory usage: ~%zu bytes\n", total_size);
+    struct stat st;
+    if (stat(soul_filename, &st) == 0) {
+        char timebuf[128];
+        struct tm *tm_info = localtime(&st.st_mtime);
+        strftime(timebuf, sizeof(timebuf), "%c", tm_info);
+        printf("Soul file: %s (%ld bytes, last modified: %s\n", soul_filename, st.st_size, timebuf);
+    } else {
+        printf("Soul file not yet created.\n");
+    }
+}
+
+static void clear_conversation(void) {
+    // Keep system, core memory, skills, cron jobs, webhooks
+    Blob *new_list = NULL;
+    Blob *b = blob_list;
+    while (b) {
+        Blob *next = b->next;
+        if (b->kind == BLOB_SYSTEM || b->kind == BLOB_CORE_MEMORY ||
+            b->kind == BLOB_SKILL || b->kind == BLOB_CRONJOB || b->kind == BLOB_WEBHOOK) {
+            // move to new list (preserve order)
+            b->next = new_list;
+            new_list = b;
+        } else {
+            free(b->data);
+            free(b);
+        }
+        b = next;
+    }
+    blob_list = new_list;
+    dirty = 1;
+    printf("Conversation history cleared (system, core memory, skills, cron, webhooks preserved).\n");
+}
+
+static void compact_arena(void) {
+    // Rebuild blob list without any deleted markers (we don't use deleted markers, so just reorder?)
+    // Actually we want to reorder by id to remove gaps and keep chronological? 
+    // For simplicity, we just leave as is; compaction is automatic via save/load.
+    // Calling save and reload compacts.
+    if (save_state(state_filename) == 0) {
+        load_state(state_filename);
+        printf("Arena compacted (state saved and reloaded).\n");
+    } else {
+        printf("Compaction failed.\n");
+    }
+}
+
+static const char* parse_schedule_string(const char *sched) {
+    static char buf[32];
+    if (strcmp(sched, "hourly") == 0) return "@hourly";
+    if (strcmp(sched, "daily") == 0) return "@daily";
+    if (strcmp(sched, "weekly") == 0) return "@weekly";
+    char *end;
+    long val = strtol(sched, &end, 10);
+    if (end != sched && *end) {
+        if (strcmp(end, "s") == 0) { snprintf(buf, sizeof(buf), "@every %lds", val); return buf; }
+        if (strcmp(end, "m") == 0) { snprintf(buf, sizeof(buf), "@every %ldm", val); return buf; }
+        if (strcmp(end, "h") == 0) { snprintf(buf, sizeof(buf), "@every %ldh", val); return buf; }
+    }
+    return NULL;
+}
+
+// ------------------------------------------------------------------
+// Main
+// ------------------------------------------------------------------
+int main(int argc, char **argv) {
+    for (int i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "--no-llm") == 0) no_llm_mode = 1;
+        else if (strcmp(argv[i], "--dry-run") == 0) dry_run = 1;
+        else if (strcmp(argv[i], "--enable-shell") == 0) {
+            shell_enabled = 1;
+            for (Tool *t = tools; t->name; t++)
+                if (strcmp(t->name, "shell") == 0) t->enabled = 1;
+        } else if (strcmp(argv[i], "--model") == 0 && i+1 < argc) ollama_model = argv[++i];
+        else if (strcmp(argv[i], "-f") == 0 && i+1 < argc) strncpy(state_filename, argv[++i], 255);
+    }
+
+    curl_global_init(CURL_GLOBAL_ALL);
+    
+    // Ensure soul directory exists
+    char *soul_dir = strdup(soul_filename);
+    char *last_slash = strrchr(soul_dir, '/');
+    if (last_slash) {
+        *last_slash = '\0';
+        mkdir(soul_dir, 0755);
+    }
+    free(soul_dir);
+    
+    if (load_state(state_filename) != 0) {
+        printf("No saved state found. Starting fresh.\n");
+        blob_append(BLOB_SYSTEM, "You are Shadowclaw, a helpful AI assistant with access to tools.");
+        blob_append(BLOB_CORE_MEMORY, "{}");
+        save_state(state_filename);
+    }
+    sync_soul_file(soul_filename);
+
+    printf(COLOR_BOLD "\nShadowclaw v%s – Ollama-Enhanced\n" COLOR_RESET, SHADOWCLAW_VERSION);
+    if (no_llm_mode) printf(COLOR_YELLOW "LLM mode disabled. Using local interpreter.\n" COLOR_RESET);
+    else printf(COLOR_GREEN "LLM mode enabled (model: %s)\n" COLOR_RESET, ollama_model);
+    
+    // Ensure heartbeat cron job exists
+    int has_heartbeat = 0;
+    Blob *b = blob_list;
+    while (b) {
+        if (b->kind == BLOB_CRONJOB && strstr(b->data, "\"tool\":\"heartbeat\"")) {
+            has_heartbeat = 1;
+            break;
+        }
+        b = b->next;
+    }
+    if (!has_heartbeat) {
+        char *heartbeat_json = NULL;
+        asprintf(&heartbeat_json, "{\"schedule\":\"@every 120s\",\"tool\":\"heartbeat\",\"args\":\"\",\"last_run\":0}");
+        if (heartbeat_json) {
+            blob_append(BLOB_CRONJOB, heartbeat_json);
+            free(heartbeat_json);
+            dirty = 1;
+        }
+    }
+
+    char line[4096];
+    while (1) {
+        process_cron_jobs();
+        printf(COLOR_GREEN "> " COLOR_RESET);
+        fflush(stdout);
+        if (!fgets(line, sizeof(line), stdin)) break;
+        line[strcspn(line, "\n")] = 0;
+        if (strlen(line) == 0) continue;
+
+        if (line[0] == '/') {
+            if (strcmp(line, "/help") == 0) {
+                print_help();
+            } else if (strcmp(line, "/tools") == 0) {
+                list_tools();
+            } else if (strcmp(line, "/state") == 0) {
+                show_state();
+            } else if (strcmp(line, "/clear") == 0) {
+                clear_conversation();
+                save_state(state_filename);
+                sync_soul_file(soul_filename);
+            } else if (strcmp(line, "/exit") == 0) {
+                break;
+            } else if (strncmp(line, "/loop", 5) == 0) {
+                char *p = line + 5;
+                while (*p == ' ') p++;
+                if (*p == '\0') {
+                    printf("Usage: /loop <schedule> <tool> [args...]\n"
+                           "Examples:\n  /loop 1h http_get https://example.com/news\n"
+                           "  /loop daily file_read ~/notes.txt\n");
+                    continue;
+                }
+                char *sched_start = p;
+                while (*p && !isspace(*p)) p++;
+                if (!*p) { printf("Missing tool after schedule.\n"); continue; }
+                *p++ = '\0';
+                const char *sched_str = parse_schedule_string(sched_start);
+                if (!sched_str) {
+                    printf("Unrecognized schedule format. Use e.g., 1h, 30m, daily, hourly, weekly.\n");
+                    continue;
+                }
+                while (*p == ' ') p++;
+                if (*p == '\0') { printf("Missing tool name.\n"); continue; }
+                char *tool_start = p;
+                while (*p && !isspace(*p)) p++;
+                if (*p) *p++ = '\0';
+                while (*p == ' ') p++;
+                char *args = p;
+                
+                cJSON *obj = cJSON_CreateObject();
+                cJSON_AddStringToObject(obj, "schedule", sched_str);
+                cJSON_AddStringToObject(obj, "tool", tool_start);
+                cJSON_AddStringToObject(obj, "args", args);
+                cJSON_AddNumberToObject(obj, "last_run", 0);
+                char *json = cJSON_PrintUnformatted(obj);
+                cJSON_Delete(obj);
+                if (json) {
+                    blob_append(BLOB_CRONJOB, json);
+                    free(json);
+                    save_state(state_filename);
+                    sync_soul_file(soul_filename);
+                    printf("Scheduled: %s every %s\n", tool_start, sched_str);
+                } else {
+                    printf("Failed to create cron job.\n");
+                }
+            } else if (strcmp(line, "/crons") == 0) {
+                Blob *b = blob_list;
+                printf("Scheduled cron jobs:\n");
+                int count = 0;
+                while (b) {
+                    if (b->kind == BLOB_CRONJOB) {
+                        printf("  %s\n", b->data);
+                        count++;
+                    }
+                    b = b->next;
+                }
+                if (count == 0) printf("  None\n");
+            } else if (strcmp(line, "/webhooks") == 0) {
+                Blob *b = blob_list;
+                printf("Registered webhooks:\n");
+                int count = 0;
+                while (b) {
+                    if (b->kind == BLOB_WEBHOOK) {
+                        printf("  %s\n", b->data);
+                        count++;
+                    }
+                    b = b->next;
+                }
+                if (count == 0) printf("  None\n");
+            } else if (strcmp(line, "/skills") == 0) {
+                Blob *b = blob_list;
+                printf("Dynamic skills:\n");
+                int count = 0;
+                while (b) {
+                    if (b->kind == BLOB_SKILL) {
+                        cJSON *j = cJSON_Parse(b->data);
+                        if (j) {
+                            cJSON *name = cJSON_GetObjectItem(j, "name");
+                            cJSON *desc = cJSON_GetObjectItem(j, "desc");
+                            if (cJSON_IsString(name) && cJSON_IsString(desc)) {
+                                printf("  %s: %s\n", name->valuestring, desc->valuestring);
+                                count++;
+                            }
+                            cJSON_Delete(j);
+                        }
+                    }
+                    b = b->next;
+                }
+                if (count == 0) printf("  None\n");
+            } else if (strcmp(line, "/compact") == 0) {
+                compact_arena();
+                sync_soul_file(soul_filename);
+            } else if (strcmp(line, "/soul") == 0) {
+                struct stat st;
+                if (stat(soul_filename, &st) == 0) {
+                    char timebuf[128];
+                    struct tm *tm_info = localtime(&st.st_mtime);
+                    strftime(timebuf, sizeof(timebuf), "%c", tm_info);
+                    printf("Soul file: %s (%ld bytes, last modified: %s\n", soul_filename, st.st_size, timebuf);
+                } else {
+                    printf("Soul file not found.\n");
+                }
+            } else if (strcmp(line, "/reconnect") == 0) {
+                if (ollama_healthy()) {
+                    no_llm_mode = 0;
+                    printf("Reconnected to Ollama. LLM mode enabled.\n");
+                } else {
+                    printf("Ollama still unreachable.\n");
+                }
+            } else {
+                // Fallback to interpreter for other slash commands
+                char *resp = interpret_command(line);
+                printf("%s\n", resp);
+                free(resp);
+            }
+            if (dirty) {
+                save_state(state_filename);
+                sync_soul_file(soul_filename);
+                dirty = 0;
+            }
+            continue;
+        }
+
+        if (no_llm_mode) {
+            char *resp = interpret_command(line);
+            printf(COLOR_BLUE "%s\n" COLOR_RESET, resp);
+            free(resp);
+            continue;
+        }
+
+        blob_append(BLOB_USER, line);
+        sync_soul_file(soul_filename);
+        int max_iter = 3;
+        char *last_response = NULL;
+        for (int iter = 0; iter < max_iter; iter++) {
+            char *prompt = build_simple_prompt(line);
+            char *llm_out = call_llm(prompt);
+            free(prompt);
+            if (!llm_out) {
+                printf("LLM call failed. Try again or use /reconnect.\n");
+                break;
+            }
+            char *tool_json = extract_tool_json(llm_out);
+            if (!tool_json) {
+                // final response
+                printf(COLOR_BLUE "Assistant: %s\n" COLOR_RESET, llm_out);
+                blob_append(BLOB_ASSISTANT, llm_out);
+                last_response = llm_out;
+                break;
+            }
+            char *tool_name = NULL, *tool_args = NULL;
+            if (parse_tool_call(tool_json, &tool_name, &tool_args)) {
+                if (dry_run) {
+                    printf(COLOR_YELLOW "[DRY RUN] would execute %s(%s)\n" COLOR_RESET, tool_name, tool_args);
+                } else {
+                    char *result = execute_tool(tool_name, tool_args);
+                    printf(COLOR_YELLOW "\n[Tool %s] → %s\n" COLOR_RESET, tool_name, result);
+                    blob_append(BLOB_TOOL_CALL, tool_json);
+                    blob_append(BLOB_TOOL_RESULT, result);
+                    trigger_webhooks(tool_name, result);
+                    // feed result back to LLM and continue loop
+                    char *next_prompt;
+                    asprintf(&next_prompt, "Tool result: %s\nContinue.", result);
+                    free(llm_out);
+                    llm_out = call_llm(next_prompt);
+                    free(next_prompt);
+                    free(result);
+                    if (!llm_out) break;
+                    // use llm_out as next response candidate, loop continues
+                    free(tool_json);
+                    free(tool_name);
+                    free(tool_args);
+                    continue;
+                }
+            } else {
+                printf(COLOR_RED "Invalid tool JSON: %s\n" COLOR_RESET, tool_json);
+                blob_append(BLOB_ASSISTANT, llm_out);
+                last_response = llm_out;
+            }
+            free(tool_json);
+            free(tool_name);
+            free(tool_args);
+            break;
+        }
+        if (last_response) free(last_response);
+        save_state(state_filename);
+        sync_soul_file(soul_filename);
+    }
+
+    save_state(state_filename);
+    curl_global_cleanup();
+    return 0;
+}

start.sh

@@ -0,0 +1,153 @@
+#!/usr/bin/env bash
+# Shadowclaw Startup Script v3.2+ (Fixed)
+# Location: /home/kali/shadowclaw-v2/start.sh
+
+set -e
+
+# ---------- Configuration ----------
+PROGRAM_NAME="shadowclaw"
+PROGRAM_PATH="./$PROGRAM_NAME"
+STATE_FILE="shadowclaw.bin"
+DATA_DIR="shadowclaw_data"
+SOUL_FILE="$DATA_DIR/shadowsoul.md"
+
+# Ollama settings (can be overridden by environment)
+OLLAMA_ENDPOINT="${OLLAMA_ENDPOINT:-http://localhost:11434}"
+OLLAMA_MODEL="${OLLAMA_MODEL:-qwen2.5:0.5b}"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+NC='\033[0m' # No Color
+
+# ---------- Helper Functions ----------
+print_status() { echo -e "${CYAN}[*]${NC} $1"; }
+print_success() { echo -e "${GREEN}[✓]${NC} $1"; }
+print_warning() { echo -e "${YELLOW}[!]${NC} $1"; }
+print_error() { echo -e "${RED}[✗]${NC} $1"; }
+
+# ---------- Environment Variables for Timeouts ----------
+export SHADOWCLAW_CONNECT_TIMEOUT="${SHADOWCLAW_CONNECT_TIMEOUT:-15}"
+export SHADOWCLAW_TOTAL_TIMEOUT="${SHADOWCLAW_TOTAL_TIMEOUT:-180}"
+export SHADOWCLAW_RETRY_ATTEMPTS="${SHADOWCLAW_RETRY_ATTEMPTS:-5}"
+
+print_status "Timeout settings: connect=${SHADOWCLAW_CONNECT_TIMEOUT}s, total=${SHADOWCLAW_TOTAL_TIMEOUT}s, retries=${SHADOWCLAW_RETRY_ATTEMPTS}"
+
+# ---------- Dependency Checks ----------
+print_status "Checking dependencies..."
+
+if ! command -v curl &> /dev/null; then
+    print_error "curl not found. Please install curl (sudo apt install curl)."
+    exit 1
+fi
+
+# ---------- Ollama Availability & Model Check ----------
+NO_LLM_MODE=0
+FORCE_LLM=0
+
+for arg in "$@"; do
+    if [ "$arg" = "--force-llm" ]; then
+        FORCE_LLM=1
+    fi
+done
+
+check_ollama() {
+    if ! curl -s --max-time 2 "$OLLAMA_ENDPOINT/api/tags" > /dev/null 2>&1; then
+        return 1
+    fi
+    if ! curl -s "$OLLAMA_ENDPOINT/api/tags" 2>/dev/null | grep -q "\"name\":\"$OLLAMA_MODEL\""; then
+        return 2
+    fi
+    return 0
+}
+
+if [ $FORCE_LLM -eq 1 ]; then
+    print_warning "--force-llm flag set: will attempt to use LLM even if checks fail."
+    NO_LLM_MODE=0
+else
+    check_ollama
+    case $? in
+        0)
+            print_success "Ollama is reachable and model '$OLLAMA_MODEL' is available."
+            ;;
+        1)
+            print_warning "Ollama not reachable at $OLLAMA_ENDPOINT. Auto-enabling --no-llm mode."
+            NO_LLM_MODE=1
+            ;;
+        2)
+            print_warning "Model '$OLLAMA_MODEL' not found in Ollama. Auto-enabling --no-llm mode."
+            print_status "Pull it with: ollama pull $OLLAMA_MODEL"
+            NO_LLM_MODE=1
+            ;;
+    esac
+fi
+
+# ---------- Binary Existence & Permissions ----------
+cd "$(dirname "$0")" || { print_error "Failed to change to script directory."; exit 1; }
+
+if [ ! -f "$PROGRAM_PATH" ]; then
+    print_error "Binary '$PROGRAM_NAME' not found in current directory."
+    print_status "Compiling Shadowclaw..."
+    if [ -f "shadowclaw.c" ] && [ -f "interpreter.c" ] && [ -f "cJSON.c" ]; then
+        make clean 2>/dev/null || true
+        if make; then
+            print_success "Compilation successful."
+        else
+            print_error "Compilation failed. Check dependencies (libcurl, libpthread, readline)."
+            exit 1
+        fi
+    else
+        print_error "Source files missing. Please ensure shadowclaw.c, interpreter.c, cJSON.c are present."
+        exit 1
+    fi
+fi
+
+if [ ! -x "$PROGRAM_PATH" ]; then
+    print_warning "Binary not executable. Fixing permissions..."
+    chmod +x "$PROGRAM_PATH"
+fi
+
+# ---------- Environment Setup ----------
+if [ ! -d "$DATA_DIR" ]; then
+    mkdir -p "$DATA_DIR"
+    print_success "Created data directory: $DATA_DIR"
+fi
+
+# ---------- Display Information (Full ASCII Banner) ----------
+clear
+echo -e "${BOLD}╔══════════════════════════════════════════════════════════════╗${NC}"
+echo -e "${BOLD}║  ____  _               _                   _                 ║${NC}"
+echo -e "${BOLD}║ / ___|| |__   __ _  __| | _____      _____| | __ ___      __ ║${NC}"
+echo -e "${BOLD}║ \___ \| '_ \ / _\` |/ _\` |/ _ \ \ /\ / / __| |/ _\` \ \ /\ / / ║${NC}"
+echo -e "${BOLD}║  ___) | | | | (_| | (_| | (_) \ V  V / (__| | (_| |\ V  V /  ║${NC}"
+echo -e "${BOLD}║ |____/|_| |_|\__,_|\__,_|\___/ \_/\_/ \___|_|\__,_| \_/\_/   ║${NC}"
+echo -e "${BOLD}║                  Shadowclaw AI Agent v3.4                    ║${NC}"
+echo -e "${BOLD}╚══════════════════════════════════════════════════════════════╝${NC}"
+echo ""
+print_status "Working directory: $(pwd)"
+print_status "State file: $STATE_FILE"
+print_status "Soul memory: $SOUL_FILE"
+if [ $NO_LLM_MODE -eq 1 ]; then
+    print_warning "Starting in NO-LLM mode (local interpreter only)."
+else
+    print_success "LLM mode enabled (model: $OLLAMA_MODEL)."
+fi
+echo ""
+
+# ---------- Build final argument list ----------
+ARGS=()
+if [ $NO_LLM_MODE -eq 1 ]; then
+    ARGS+=("--no-llm")
+fi
+for arg in "$@"; do
+    if [ "$arg" != "--force-llm" ]; then
+        ARGS+=("$arg")
+    fi
+done
+
+# ---------- Launch ----------
+print_success "Launching Shadowclaw..."
+exec "$PROGRAM_PATH" "${ARGS[@]}"