pebblisp/src/env.c

#include "env.h"
#include "pebblisp.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#ifndef STANDALONE
#include <pebble.h>
#undef printf
#define printf(...) APP_LOG(APP_LOG_LEVEL_DEBUG, __VA_ARGS__)
#endif

Object fetchFromEnvironment(const char *name, struct Environment *env)
{
    if(!env)
        return errorObject(NULL_ENV);

    if(env->size == 0)
        return errorObject(EMPTY_ENV);

    printd("Fetching '%s' from env\n", name);
    for(int i = 0; i < env->size; i++) {
        if(env->strings[i] == NULL) {
            printd("Try %d (NULL)\n", i);
            break;
        }

        printd("Try %d (%s)\n", i, env->strings[i]);
        debugObj(&env->objects[i]);
        if(strcmp(name, env->strings[i]) == 0) {
            printd("Returning!\n");
            return cloneObject(env->objects[i]);
        }
    }

    printd("Trying outer %p\n", env->outer);
    if(env->outer) {
        return fetchFromEnvironment(name, env->outer);
    }

    printf("'%s'\n", name);
    return errorObject(DID_NOT_FIND_SYMBOL);
}

struct Environment envForLambda(const Object *params, const Object *arg_forms,
                                struct Environment *outer)
{
    int paramCount = listLength(params);

    struct Environment env = {
        .outer = outer,
        .strings = NULL,
        .objects = NULL,
        .size = paramCount
    };

    if(paramCount == 0)
        return env;

    env.strings = calloc(sizeof(char*), paramCount + 1);
    env.objects = malloc(sizeof(Object) * paramCount + 1);

    const Object *march = arg_forms;
    for(int i = 0; i < paramCount; i++) {
        const char *newObjName = itemAt(params, i)->string;
        // Eval the `march` list
        const Object newEnvObj = eval(march, outer);
        addToEnv(&env, newObjName, newEnvObj); // Could use eval_forms?
        march = march->forward;
    }

    return env;
}

// TODO Maybe extend environment using a new outer, instead of realloc
void addToEnv(struct Environment *env, const char *name, const Object obj)
{
    int i;
    struct Environment *temp_env = env;
    while(temp_env) {
        for(i = 0; i < temp_env->size; i++) {
            if(temp_env->strings[i] == NULL) {
                temp_env->strings[i] = calloc(sizeof(char), strlen(name) + 1);
                strncpy(temp_env->strings[i], name, strlen(name));
                temp_env->objects[i] = cloneObject(obj);
                return;
            }
            if(strcmp(temp_env->strings[i], name) == 0) {
                cleanObject(&temp_env->objects[i]);
                temp_env->objects[i] = cloneObject(obj);
                return;
            }
        }
        temp_env = temp_env->outer;
    }

    printd("Reallocating environment\n");
    const int inc = 5;
    env->size += inc;
    env->strings = realloc(env->strings, sizeof(char*) * env->size);
    env->objects = realloc(env->objects, sizeof(Object) * env->size);

    for(int j = 0; j < inc; j++) {
        env->strings[i + j] = NULL;
    }

    env->strings[i] = malloc(strlen(name) + 1);
    strncpy(env->strings[i], name, strlen(name) + 1);
    env->objects[i] = cloneObject(obj);
}

void printEnv(struct Environment *env)
{
    if(!env) {
        printf("NULL env\n");
        return;
    }
    for(int i = 0; i < env->size; i++) {
        if(env->strings[i] == NULL)
            return;
        printf("env[%d]: '%s'\n  ", i, env->strings[i]);
        printObj(&env->objects[i]);
    }
}

void addFunc(const char *name, Object (*func)(Object, Object, struct Environment*),
             struct Environment *env)
{
    Object o = newObject(TYPE_FUNC);
    o.func = func;
    addToEnv(env, name, o);
}

void deleteEnv(struct Environment *e)
{
    int i = 0;
    while(e->strings[i]) {
        free(e->strings[i]);
        cleanObject(&e->objects[i]);
        i++;
    }
    free(e->strings);
    e->strings = NULL;

    free(e->objects);
    e->objects = NULL;
}

const char *codes[] = {
    // Exponentiate a^b
    "(def exp (fn (a b) "
      "(if (= b 0)"
        "1"
        "(* a (exp a (- b 1)))"
      ")"
    "))",

    // Square a
    "(def sq (fn (a) (* a a)))",

    // Cube a
    "(def cube (fn (a) (exp a 3)))",

    // Return the larger of the two
    "(def max (fn (a b) (if (> a b) a b)))",

    // Return the smaller of the two
    "(def min (fn (a b) (if (< a b) a b)))",

    // A demo tip calculator
    "(def spent (fn (a) \
      (cat \"Tip: $\" (/ a 5) \".\" \
        (/ (* 100 (% a 5)) 5) \
      ) \
     ))",
};

struct symFunc {
    const char *sym;
    Object (*func)(Object, Object, struct Environment*);
};

struct Environment defaultEnv()
{
    struct Environment e = {
        .outer = NULL,
        .strings = calloc(sizeof(char*), MAX_ENV_ELM),
        .objects = malloc(sizeof(Object) * MAX_ENV_ELM),
        .size = MAX_ENV_ELM
    };

    struct symFunc symFuncs[] = {
        {"+", &add}, {"-", &sub}, {"*", &mul}, {"/", &dvi}, {"%", &mod},
        {"=", &equ}, {">", &gth}, {"<", &lth},
        {"cat", &catObjects}, {"fil", &filter}, {"len", &len},
        {"ap", &append}, {"pre", &prepend},
        {"at", &at}, {"rest", &rest}, {"rev", &reverse},
        {"isnum", &isNum},
        {"prn", &print},
    };

    for(unsigned i = 0; i < sizeof(symFuncs)/sizeof(symFuncs[0]); i++) {
        addFunc(symFuncs[i].sym, symFuncs[i].func, &e);
    }

    for(unsigned i = 0; i < sizeof(codes)/sizeof(codes[0]); i++) {
        parseEval(codes[i], &e);
    }

    return e;
}