typedef struct object object_t;
struct object {
    label_t name;
    size_t children;
    struct object *child;
    /* ... */
};


int label_match(const label_t *const name1, const label_t *const name2)
{
    /* Return nonzero if name1 == name2
    */
}


/* Internal function: resolves name in base_object to an object, or returns NULL.
*/
object_t *do_resolve(const label_t *const name,
                     object_t *base_object)
{
    size_t i = base_object->children;

    /* Search for the label in the given scope.
    */
    while (i--)
        if (label_match(name, base_object->child[i]->label))
            return base_object->child[i];

    return NULL;
}


/* Name-to-object resolver. Types are irrelevant.
 * Will return NULL if no match found.
*/
object_t *resolve(const label_t *const name,
                  object_t *current,
                  object_t *local,
                  object_t *global)
{
    /* Search for the label in the current scope.
    */
    if (current)
        return do_resolve(name, current);

    /* Search for the label in the local scope.
    */
    if (local) {
        current = do_resolve(name, local);
        if (current)
            return current;
    }

    /* The global scope is the last resort.
    */
    return do_resolve(name, global);
}

typedef enum objtype   objtype_t;
enum objtype {
    OBJECT_UNKNOWN = 0,
    OBJECT_GENERIC = 1,
    OBJECT_STRING,
    OBJECT_FLOAT,
    OBJECT_INTEGER,
    OBJECT_BOOLEAN,
};

typedef struct string  string_t;
struct string {
    size_t             size;
    size_t             used;
    unsigned char      data[];
};

typedef struct hash    hash_t;
struct hash {
    size_t             size; /* Of hashed object */
    uint64_t           hash;
};

typedef struct object  object_t;
struct object {
    object_t          *parent;
    string_t          *name;
    size_t             max_children;
    size_t             children;
    object_t          *child;
    hash_t            *child_name;
    objtype_t          type;
    /* Payload. Customize? */
    size_t             size;
    unsigned char      data[];
};

/* 1: True, 0: False.
*/
int object_to_boolean(const object_t *const object)
{
    if (!object)
        return 0;

    switch (object->type) {

    case OBJECT_GENERIC:
        /* Generic objects are TRUE if they contain children,
         * false otherwise.
        */
        return (object->children > 0) ? 1 : 0;

    case OBJECT_STRING:
        /* String is TRUE if it is non-empty.
         * Assume string contents are in the payload as-is.
        */
        return (object->size > 0) ? 1 : 0;

    case OBJECT_FLOAT:
        /* Float has a single double value as a payload.
        */
        return (*(double *)(&object->data) == 0.0) ? 1 : 0;

    case OBJECT_INTEGER:
        /* Integer has a 64-bit integer value as a payload.
        */
        return (*(int64_t *)(&object->data) == (int64_t)0) ? 1 : 0;

    default:
        /* All other objects are considered FALSE for now.
        */
        return 0;
    }
}

expr: lvalue

lvalue: ID | expr DOT ID

typedef struct storage storage_t;
struct storage {
    struct storage *chain;
    int32_t         references;
    enum datatype   type;
    size_t          size;
    unsigned char   data[];
};

pthread_rwlock_t storage_access;
storage_t *garbage = NULL;

static inline void start_using_storage(void)
{
    if (pthread_rwlock_rdlock(&storage_access)) {
        /* Serious error condition! Stop execution! */
    }
}

static inline void finish_using_storage(void)
{
    if (pthread_rwlock_unlock(&storage_access)) {
        /* Serious error condition! Stop execution! */
    }
}

void collect_garbage(void)
{
    storage_t *next;

    if (thread_rwlock_wrlock(&storage_access)) {
        /* Serious error condition! Stop execution! */
    }

    next = __sync_fetch_and_and(&garbage, NULL);

    if (thread_rwlock_unlock(&storage_access)) {
        /* Serious error condition! Stop execution! */
    }

    while (next) {
        storage_t *const curr = next;
        next = next->next;

        if (__sync_fetch_and_or((int32_t *)&curr->references, (int32_t)0) > 0) {
            /* Serious error, a BUG. The reference count should not be able to grow. */
        }
        free(curr);
    }
}

static inline storage_t *new_storage(const enum datatype type, const size_t size)
{
    storage_t *storage;

    storage = malloc(sizeof(storage_t) + size);
    if (!storage)
        return NULL;

    storage->references = 1;
    storage->type = type;
    storage->size = size;

    return storage;
}

static inline storage_t *storage_attach(storage_t *const storage)
{
    int32_t references;

    if (!storage)
        return NULL;

    references = __sync_add_and_fetch((int32_t *)&storage->references, (int32_t)1);
    if (references < 2) {
        __sync_sub_and_fetch((int32_t *)&storage->references, (int32_t)1);
        return NULL;
    }

    return storage;
}

static inline void storage_detach(storage_t *const storage)
{
    int32_t references;

    if (!storage)
        return;

    references = __sync_sub_and_fetch((int32_t *)&storage->references, (int32_t)1);
    if (references < 1) {
        storage_t *temp;

        storage->size = 0;
        storage->type = CONTENT_DELETED;

        /* Add storage to the garbage chain */
        do {
            temp = __sync_fetch_and_or(&garbage, NULL);
            storage->chain = temp;
        } while (!__sync_bool_compare_and_swap(&garbage, temp, storage));
    }

    return;
}

struct object {
    struct object *sibling;
    struct object *child;
    enum objtype   type;
    size_t         name_length;
    unsigned char  name[];
    /* Storage omitted */
};

struct node {
    struct node  *sibling;
    struct node  *child;
    enum nodetype type;
    size_t        name_length;
    unsigned char name[];
};

struct object *subobject(const unsigned char name[], const size_t name_length,
                         struct object *root)
{
    if (!root)
        return NULL;

    if (root->name_length == name_length && !strcmp(name, root->name))
        return root;

    if (!root->child)
        return NULL;

    root = root->child;
    while (root) {
        if (root->name_length == name_length && !strcmp(name, root->name))
            return root;
        root = root->sibling;
    }

    return NULL;
}

struct object *resolve_object(const struct node *const ast,
                              struct object *local_scope,
                              struct object *global_scope)
{
    struct object *obj, *parent;

    switch (ast->type) {
    case AST_GENERIC:
        /* This node just names a local or global object. */
        obj = subobject(ast->name, ast->name_length, local_scope);
        if (obj)
            return obj;
        return subobject(ast->name, ast->name_lengthm global_scope);

    case AST_DOT_OPERATOR:
        /* This node is a dot operator. */
        ast = ast->child;
        parent = subobject(ast->name, ast->name_length, local_scope);
        if (!parent)
            parent = subobject(ast->name, ast->name_length, global_scope);
        if (!parent)
            return NULL;
        return resolve_object(ast->sibling, parent, NULL);

    /* others not implemented */
    }

    return NULL;
}

reference: ID | reference DOT ID
lvalue: reference

typedef enum {
    NODETYPE_INTEGER,   // create Integer
    NODETYPE_FLOAT,     // create Float
    NODETYPE_STRING,    // create String
    NODETYPE_IF,        // evaluate only if condition true/false
    NODETYPE_WHILE,     // loop while condition true
    NODETYPE_DOWHILE,   // loop while condition true, eval body at least once
    NODETYPE_CALL,      // call function
    NODETYPE_GETMEMBER, // get member from env ('.' operator)
    NODETYPE_ASSIGN,    // assign value to lvalue ('=' operator)
    NODETYPE_FUNC,      // create anonymous function
} nodetype_t;

typedef struct node node_t;
struct node {
    nodetype_t type;
    int child_count;
    node_t *children[];
    char *payload;
};

object_t* eval(node_t *node, env_t *env)
{
    switch (node->type) {
    case NODETYPE_INTEGER:
        return // create integer object from node's payload
    case NODETYPE_IF:
        if object_to_boolean(eval(node->children[0], env))
            return eval(node->children[1], env);
        if (node->child_count == 3)
            return eval(node->children[2], env);
        return NULL;
    case NODETYPE_WHILE:
        object_t *value = NULL;
        while object_to_boolean(eval(node->children[0], env))
            value = eval(node->children[1], env);
        return value;
    case NODETYPE_DOWHILE:
        object_t *value;
        do {
            value = eval(node->children[1], env);
        } while object_to_boolean(eval(node->children[0], env));
        return value;
    }
}

print("Command: ", argv.0, "\n")
for (i = 1; i < argc; i++)
    print(i, ":", argv.i, "\n")
if (argc < 1)
    print("No parameters.\n")

  CALL:"print" ( STRING:"Command: ",
                 GETMEMBER ( NAME:"argv",
                             NUMBER:"0" ),
                 STRING:"\n" ),
  FORLOOP( ASSIGN( NAME:"i",
                   NUMBER:"1" ),
           LESSTHAN( NAME:"i",
                     NAME:"argc" ),
           POSTINCREMENT( NAME:"i" ),
  CALL:"print"( NAME:"i",
                STRING:":"
                GETMEMBER( NAME:"argv",
                           NAME:"i" ),
                STRING:"\n" ),
  IF( LESSTHAN( NAME:"argc",
                NUMBER:"1" ),
  CALL:"print"( STRING:"No parameters.\n" )

CALL ─── FORLOOP ─── CALL ─── IF ─── CALL
 │        │           │        │      │
 │        │           │        │     STRING
 │        │           │        │
 │        │           │       LESSTHAN
 │        │           │        │
 │        │           │       NAME ─── NUMBER
 │        │           │
 │        │          NAME ─── STRING ─── GETMEMBER ─── STRING
 │        │                               │
 │        │                              NAME ─── NUMBER
 │        │
 │        ASSIGN ─── LESSTHAN ─── POSTINCREMENT
 │        │           │            │
 │        │           │           NAME
 │        │           │
 │        │          NAME ─── NUMBER
 │        │
 │        NAME ─── NUMBER
 │
STRING ─── GETMEMBER ─── STRING
            │
           NAME ─── NUMBER

typedef enum {

    NODE_NAME, /* A string token */
    NODE_NUMBER, /* A numeric token */
    NODE_STRING, /* A quoted string constant */

    NODE_OP_ASSIGN, /* Assignment operator */
    NODE_OP_GETMEMBER, /* Member operator */
    NODE_OP_LESSTHAN, /* < operator */

    NODE_CALL, /* Function call */

    NODE_LOOP_FOR, /* For loop construct */

    NODE_COND_IF, /* If conditional */

} nodetype_t;

typedef struct node node_t;
struct node {
    struct node  *parent;   /* Parent node */
    struct node  *next;     /* Next (sibling) node */
    struct node  *child;    /* First child node */
    nodetype_t    type;
    size_t        length;   /* Token string length, usually 0 */
    unsigned char string[]; /* Token string, will have at least one zero (EOS) at end */
};

typedef struct object object_t;
struct object {
    struct object *parent;  /* Container object */
    struct object *next;    /* First sibling */
    struct object *child;   /* First child */
    struct data   *data;    /* Reference to the actual data */
    size_t         namelen; /* Name length */
    unsigned char  name[];  /* Name */
};

/* This bit is common to all data, found in the 'common' member
*/
struct data_common {
    struct data *garbage;   /* Garbage collection chain, normally NULL */
    int32_t      references; /* Number of objects referring to this data */
    int32_t      type;       /* Actual object type */
};

/* Any data type can be cast to this base data type:
*/
struct data {
    struct data_common common;
    unsigned char      data[]; /* Some opaque data, size unknown */
};

/* This data object contains a single native number (a double):
*/
struct data_number {
    struct data_common common;
    double             value;
};

/* This data object is a fixed-size vector of numbers.
* You don't need nor want this, this is just an example.
*/
struct data_numbervector {
    struct data_common common;
    size_t             size;
    double             value[];
};

/* This contains one editable string (or binary data blob):
*/
struct data_string {
    struct data_common common;
    size_t             allocated;
    size_t             used;
    unsigned char     *length;
};

/* This describes a (possibly anonymous) function.
*/
struct data_function {
    struct data_common common;
    size_t          parameters;       /* Number of parameters */
    size_t         *parameter_length; /* Lengths of local variable names */
    unsigned char **parameter_name;   /* Names of local variables to map parameter objects to */
    struct object  *function_state;   /* Persistent local state? */
    struct node    *execute;          /* Node to start execution */
};

/* This describes a native C function.
 * The function expects the following parameters:
 * - interpreter state
 * - global scope object
 * - local scope object
 * - number of parameter objects, possibly zero
 * - array of parameter objects, NULL if no parameters
*/
struct data_builtin {
    struct data_common common;
    object_t (*function)(state_t *, object_t *, object_t *, size_t, object_t *);
};