pebblisp/src/tokens.c

#include "tokens.h"
#include <stdlib.h>

#ifdef STANDALONE
#include <stdio.h>
#undef printd
#define printd(...) fprintf(stderr, __VA_ARGS__)
#else
#include <pebble.h>
#undef printd
#define printd(...) printf(__VA_ARGS__)
#endif

/*
 * Grammar:
 * token
 * expr
 * (op expr expr)
 * (list expr expr ... )
 */

// Is the char a standalone token?
static const char singleTokens[] = "()+-*/=";
int isSingle(const char c) {
    int i = 0;
    while(singleTokens[i] != '\0'){
        if(singleTokens[i] == c)
            return singleTokens[i];
        i++;
    }
    return 0;
}

int isDigit(const char c) {
    return c >= '0' && c <= '9';
}

int isWhitespace(const char c) {
    return c == ' ' || c == '\t' || c == '\n';
}

int notWhitespace(const char c) {
    return !isWhitespace(c);
}

// Return needs to be freed, if not null
struct Slice *nf_tokenize(const char *input)
{
    if(!input)
        return NULL;

    struct Slice *slices = malloc(sizeof(struct Slice) * MAX_TOK_CNT);

    int i = 0;
    int slice = 0;

    int parens = 0;
    while(input[i] != '\0') {
        int l = 1;
        // printd("input: '%c'\n", input[i]);

        if(isWhitespace(input[i])) {
            i++;
            continue;
        }

        if(input[i] == '(') {
            parens++;
        } else if (input[i] == ')') {
            parens--;
            if(parens < 0) {
                free(slices);
                return NULL;
            }
        }

        slices[slice].text = &input[i];

        if(isSingle(input[i])) {
            i++;

        } else if(input[i] == '"') {
            while(input[++i] != '"') {
                l++;
            }
            i++;
        } else {
            while(!isWhitespace(input[++i]) && !isSingle(input[i])) {
                l++;
            }
        }

        slices[slice].length = l;
        slice++;
    }

    if(parens){
        free(slices);
        return NULL;
    }

    slices[slice].text = NULL;
    slices[slice].length = 0;

    return slices;
}