forked from Telodendria/Telodendria
Add tp, a simple but powerful text preprocessor.
I might rename it, and I have yet to document it in a man page, but I have found this extremely useful so I thought I'd give it a home here.
This commit is contained in:
parent
68b644a4f2
commit
c467d0913d
1 changed files with 754 additions and 0 deletions
754
Cytoplasm/tools/tp.c
Normal file
754
Cytoplasm/tools/tp.c
Normal file
|
@ -0,0 +1,754 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* 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 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.
|
||||||
|
*/
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#include <Args.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Array.h>
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Str.h>
|
||||||
|
#include <Stream.h>
|
||||||
|
|
||||||
|
#define BLOCK 64
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Anything that can be done in the language itself should; to
|
||||||
|
* keep the interpreter minimal. Note that this has the side effect
|
||||||
|
* of allowing the runtime to become corrupted or undefined which
|
||||||
|
* may lead to confusing behavior, but the language primitives
|
||||||
|
* cannot be corrupted, so things can always be corrected.
|
||||||
|
*/
|
||||||
|
static char runtime[] =
|
||||||
|
"[def let; name, value; [eval [(]def [name][;][;][value][)]]]"
|
||||||
|
"[def not; cond; [if [cond];;true]]"
|
||||||
|
"[def (); str; [(][str][)]]"
|
||||||
|
"[def #;;]"
|
||||||
|
"[def //;;]"
|
||||||
|
;
|
||||||
|
|
||||||
|
static Stream *err;
|
||||||
|
static int debug;
|
||||||
|
|
||||||
|
typedef struct Definition
|
||||||
|
{
|
||||||
|
Array *args;
|
||||||
|
char *body;
|
||||||
|
} Definition;
|
||||||
|
|
||||||
|
static char *
|
||||||
|
EvalExpr(char *expr, Array * stack);
|
||||||
|
|
||||||
|
static char *
|
||||||
|
ReadExpr(Stream * in)
|
||||||
|
{
|
||||||
|
size_t len = 0;
|
||||||
|
size_t size = 0;
|
||||||
|
|
||||||
|
size_t level = 1;
|
||||||
|
|
||||||
|
int c;
|
||||||
|
|
||||||
|
char *expr;
|
||||||
|
char *tmp;
|
||||||
|
|
||||||
|
size += BLOCK;
|
||||||
|
expr = Malloc(size * sizeof(char));
|
||||||
|
if (!expr)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
while ((c = StreamGetc(in)) != EOF)
|
||||||
|
{
|
||||||
|
if (len + 1 >= size)
|
||||||
|
{
|
||||||
|
size += BLOCK;
|
||||||
|
tmp = Realloc(expr, size * sizeof(char));
|
||||||
|
if (!tmp)
|
||||||
|
{
|
||||||
|
Free(expr);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
expr = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (c == ']')
|
||||||
|
{
|
||||||
|
if (level > 0)
|
||||||
|
{
|
||||||
|
level--;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!level)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (c == '[')
|
||||||
|
{
|
||||||
|
level++;
|
||||||
|
}
|
||||||
|
|
||||||
|
expr[len] = c;
|
||||||
|
len++;
|
||||||
|
}
|
||||||
|
|
||||||
|
expr[len] = '\0';
|
||||||
|
return expr;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
Eval(char **argp, Array * stack)
|
||||||
|
{
|
||||||
|
size_t len;
|
||||||
|
size_t size;
|
||||||
|
|
||||||
|
char *res;
|
||||||
|
char *tmp;
|
||||||
|
char *arg = *argp;
|
||||||
|
|
||||||
|
len = 0;
|
||||||
|
size = BLOCK;
|
||||||
|
res = Malloc(size * sizeof(char));
|
||||||
|
if (!res)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (*arg)
|
||||||
|
{
|
||||||
|
if (len + 1 >= size)
|
||||||
|
{
|
||||||
|
size += BLOCK;
|
||||||
|
tmp = Realloc(res, size * sizeof(char));
|
||||||
|
if (!tmp)
|
||||||
|
{
|
||||||
|
Free(res);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
res = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (*arg == ';')
|
||||||
|
{
|
||||||
|
res[len] = '\0';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
else if (*arg == '[')
|
||||||
|
{
|
||||||
|
size_t level = 1;
|
||||||
|
char *endp;
|
||||||
|
char *evalRes;
|
||||||
|
char *base;
|
||||||
|
|
||||||
|
arg++;
|
||||||
|
endp = arg;
|
||||||
|
|
||||||
|
while (level && *endp)
|
||||||
|
{
|
||||||
|
if (*endp == ']')
|
||||||
|
{
|
||||||
|
if (level > 0)
|
||||||
|
{
|
||||||
|
level--;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!level)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (*endp == '[')
|
||||||
|
{
|
||||||
|
level++;
|
||||||
|
}
|
||||||
|
|
||||||
|
endp++;
|
||||||
|
}
|
||||||
|
|
||||||
|
*endp = '\0';
|
||||||
|
|
||||||
|
evalRes = EvalExpr(arg, stack);
|
||||||
|
base = evalRes;
|
||||||
|
|
||||||
|
while (*evalRes)
|
||||||
|
{
|
||||||
|
if (len + 1 >= size)
|
||||||
|
{
|
||||||
|
size += BLOCK;
|
||||||
|
tmp = Realloc(res, size * sizeof(char));
|
||||||
|
if (!tmp)
|
||||||
|
{
|
||||||
|
Free(base);
|
||||||
|
Free(res);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
res = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
res[len] = *evalRes;
|
||||||
|
len++;
|
||||||
|
evalRes++;
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(base);
|
||||||
|
*endp = ']';
|
||||||
|
arg = endp;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
res[len] = *arg;
|
||||||
|
len++;
|
||||||
|
}
|
||||||
|
|
||||||
|
arg++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (*arg == ';')
|
||||||
|
{
|
||||||
|
arg++;
|
||||||
|
while (isspace(*arg))
|
||||||
|
{
|
||||||
|
arg++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
res[len] = '\0';
|
||||||
|
*argp = arg;
|
||||||
|
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
EvalExpr(char *expr, Array * stack)
|
||||||
|
{
|
||||||
|
char *argv = expr;
|
||||||
|
char *op = expr;
|
||||||
|
char ops;
|
||||||
|
char *opi;
|
||||||
|
|
||||||
|
char *res;
|
||||||
|
|
||||||
|
while (*argv && !isspace(*argv))
|
||||||
|
{
|
||||||
|
argv++;
|
||||||
|
}
|
||||||
|
|
||||||
|
ops = *argv;
|
||||||
|
opi = argv;
|
||||||
|
|
||||||
|
*argv = '\0';
|
||||||
|
argv++;
|
||||||
|
|
||||||
|
|
||||||
|
if (StrEquals(op, "("))
|
||||||
|
{
|
||||||
|
res = StrDuplicate("[");
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, ")"))
|
||||||
|
{
|
||||||
|
res = StrDuplicate("]");
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, ";"))
|
||||||
|
{
|
||||||
|
res = StrDuplicate(";");
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, "env"))
|
||||||
|
{
|
||||||
|
char *env = Eval(&argv, stack);
|
||||||
|
char *val = getenv(env);
|
||||||
|
|
||||||
|
Free(env);
|
||||||
|
|
||||||
|
if (!val)
|
||||||
|
{
|
||||||
|
val = "";
|
||||||
|
}
|
||||||
|
|
||||||
|
res = StrDuplicate(val);
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, "eval"))
|
||||||
|
{
|
||||||
|
char *expr = Eval(&argv, stack);
|
||||||
|
char *tmp = expr;
|
||||||
|
|
||||||
|
res = Eval(&tmp, stack);
|
||||||
|
Free(expr);
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, "if"))
|
||||||
|
{
|
||||||
|
char *cond = Eval(&argv, stack);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If the condition is false, seek past the true argument
|
||||||
|
* without evaluating it.
|
||||||
|
*/
|
||||||
|
if (StrBlank(cond))
|
||||||
|
{
|
||||||
|
size_t level = 0;
|
||||||
|
|
||||||
|
while (*argv)
|
||||||
|
{
|
||||||
|
switch (*argv)
|
||||||
|
{
|
||||||
|
case '[':
|
||||||
|
level++;
|
||||||
|
break;
|
||||||
|
case ']':
|
||||||
|
if (level > 0)
|
||||||
|
{
|
||||||
|
level--;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case ';':
|
||||||
|
if (!level)
|
||||||
|
{
|
||||||
|
argv++;
|
||||||
|
while (isspace(*argv))
|
||||||
|
{
|
||||||
|
argv++;
|
||||||
|
}
|
||||||
|
goto end_loop;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
argv++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
end_loop:
|
||||||
|
res = Eval(&argv, stack);
|
||||||
|
Free(cond);
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, "eq?"))
|
||||||
|
{
|
||||||
|
char *s1 = Eval(&argv, stack);
|
||||||
|
char *s2 = Eval(&argv, stack);
|
||||||
|
|
||||||
|
if (StrEquals(s1, s2))
|
||||||
|
{
|
||||||
|
res = StrDuplicate("true");
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
res = StrDuplicate("");
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(s1);
|
||||||
|
Free(s2);
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, "def?"))
|
||||||
|
{
|
||||||
|
Definition *def;
|
||||||
|
size_t i;
|
||||||
|
char *directive = Eval(&argv, stack);
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(stack); i++)
|
||||||
|
{
|
||||||
|
HashMap *stackFrame = ArrayGet(stack, i);
|
||||||
|
|
||||||
|
def = HashMapGet(stackFrame, directive);
|
||||||
|
|
||||||
|
if (def)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (def)
|
||||||
|
{
|
||||||
|
res = StrDuplicate("true");
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
res = StrDuplicate("");
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(directive);
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, "print"))
|
||||||
|
{
|
||||||
|
char *msg = Eval(&argv, stack);
|
||||||
|
|
||||||
|
StreamPrintf(err, msg);
|
||||||
|
Free(msg);
|
||||||
|
res = StrDuplicate("");
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, "def"))
|
||||||
|
{
|
||||||
|
char *name = Eval(&argv, stack);
|
||||||
|
char *args = Eval(&argv, stack);
|
||||||
|
char *body = argv;
|
||||||
|
|
||||||
|
char *tok;
|
||||||
|
HashMap *stackFrame;
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
Definition *def = Malloc(sizeof(Definition));
|
||||||
|
|
||||||
|
def->body = StrDuplicate(body);
|
||||||
|
def->args = ArrayCreate();
|
||||||
|
|
||||||
|
if (debug)
|
||||||
|
{
|
||||||
|
StreamPrintf(err, "(def op = '%s', args = [", name);
|
||||||
|
}
|
||||||
|
|
||||||
|
tok = strtok(args, ",");
|
||||||
|
while (tok)
|
||||||
|
{
|
||||||
|
while (isspace(*tok))
|
||||||
|
{
|
||||||
|
tok++;
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayAdd(def->args, StrDuplicate(tok));
|
||||||
|
|
||||||
|
if (debug)
|
||||||
|
{
|
||||||
|
StreamPrintf(err, "'%s', ", tok);
|
||||||
|
}
|
||||||
|
|
||||||
|
tok = strtok(NULL, ",");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (debug)
|
||||||
|
{
|
||||||
|
StreamPrintf(err, "], body = '%s')\n", def->body);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(args);
|
||||||
|
stackFrame = ArrayGet(stack, ArraySize(stack) - 1);
|
||||||
|
def = HashMapSet(stackFrame, name, def);
|
||||||
|
|
||||||
|
if (def)
|
||||||
|
{
|
||||||
|
for (i = 0; i < ArraySize(def->args); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(def->args, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayFree(def->args);
|
||||||
|
Free(def->body);
|
||||||
|
Free(def);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(name);
|
||||||
|
res = StrDuplicate("");
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, "undef"))
|
||||||
|
{
|
||||||
|
char *name = Eval(&argv, stack);
|
||||||
|
HashMap *stackFrame = ArrayGet(stack, ArraySize(stack) - 1);
|
||||||
|
Definition *def = HashMapDelete(stackFrame, name);
|
||||||
|
|
||||||
|
Free(name);
|
||||||
|
|
||||||
|
if (def)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(def->args); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(def->args, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayFree(def->args);
|
||||||
|
Free(def->body);
|
||||||
|
Free(def);
|
||||||
|
}
|
||||||
|
|
||||||
|
res = StrDuplicate("");
|
||||||
|
}
|
||||||
|
else if (StrEquals(op, "include"))
|
||||||
|
{
|
||||||
|
char *fileName = Eval(&argv, stack);
|
||||||
|
Stream *file = StreamOpen(fileName, "r");
|
||||||
|
|
||||||
|
size_t size;
|
||||||
|
size_t len;
|
||||||
|
char c;
|
||||||
|
|
||||||
|
Free(fileName);
|
||||||
|
if (!file)
|
||||||
|
{
|
||||||
|
res = StrDuplicate("");
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
size = BLOCK;
|
||||||
|
len = 0;
|
||||||
|
res = Malloc(size * sizeof(char));
|
||||||
|
|
||||||
|
while ((c = StreamGetc(file)) != EOF)
|
||||||
|
{
|
||||||
|
if (len + 1 >= size)
|
||||||
|
{
|
||||||
|
size += BLOCK;
|
||||||
|
res = Realloc(res, size * sizeof(char));
|
||||||
|
}
|
||||||
|
|
||||||
|
res[len] = c;
|
||||||
|
len++;
|
||||||
|
}
|
||||||
|
|
||||||
|
res[len] = '\0';
|
||||||
|
StreamClose(file);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* Locate macro on stack and execute it */
|
||||||
|
Definition *def;
|
||||||
|
char *body;
|
||||||
|
HashMap *stackFrame;
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(stack); i++)
|
||||||
|
{
|
||||||
|
stackFrame = ArrayGet(stack, i);
|
||||||
|
def = HashMapGet(stackFrame, op);
|
||||||
|
|
||||||
|
if (def)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!def)
|
||||||
|
{
|
||||||
|
res = StrDuplicate("");
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
stackFrame = HashMapCreate();
|
||||||
|
for (i = 0; i < ArraySize(def->args); i++)
|
||||||
|
{
|
||||||
|
char *argName = ArrayGet(def->args, i);
|
||||||
|
char *argVal = Eval(&argv, stack);
|
||||||
|
Definition *argDef = Malloc(sizeof(Definition));
|
||||||
|
|
||||||
|
argDef->args = NULL;
|
||||||
|
argDef->body = argVal;
|
||||||
|
HashMapSet(stackFrame, argName, argDef);
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayInsert(stack, 0, stackFrame);
|
||||||
|
body = def->body;
|
||||||
|
res = Eval(&body, stack);
|
||||||
|
|
||||||
|
ArrayDelete(stack, 0);
|
||||||
|
|
||||||
|
while (HashMapIterate(stackFrame, &body, (void **) &def))
|
||||||
|
{
|
||||||
|
for (i = 0; i < ArraySize(def->args); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(def->args, i));
|
||||||
|
}
|
||||||
|
ArrayFree(def->args);
|
||||||
|
Free(def->body);
|
||||||
|
Free(def);
|
||||||
|
}
|
||||||
|
HashMapFree(stackFrame);
|
||||||
|
}
|
||||||
|
|
||||||
|
finish:
|
||||||
|
*opi = ops;
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
Process(Stream * in, Stream * out, Array * stack)
|
||||||
|
{
|
||||||
|
int c;
|
||||||
|
|
||||||
|
while ((c = StreamGetc(in)) != EOF)
|
||||||
|
{
|
||||||
|
if (c == '[')
|
||||||
|
{
|
||||||
|
char *expr;
|
||||||
|
char *res;
|
||||||
|
|
||||||
|
expr = ReadExpr(in);
|
||||||
|
res = EvalExpr(expr, stack);
|
||||||
|
|
||||||
|
StreamPuts(out, res);
|
||||||
|
StreamFlush(out);
|
||||||
|
|
||||||
|
Free(expr);
|
||||||
|
Free(res);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
StreamPutc(out, c);
|
||||||
|
}
|
||||||
|
StreamFlush(out);
|
||||||
|
}
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
Main(Array * args)
|
||||||
|
{
|
||||||
|
ArgParseState arg;
|
||||||
|
int opt;
|
||||||
|
int ret = EXIT_FAILURE;
|
||||||
|
|
||||||
|
size_t i;
|
||||||
|
Array *stack;
|
||||||
|
|
||||||
|
char *rt;
|
||||||
|
|
||||||
|
Stream *in;
|
||||||
|
Stream *out;
|
||||||
|
Array *eval = ArrayCreate();
|
||||||
|
|
||||||
|
debug = 0;
|
||||||
|
in = StreamStdin();
|
||||||
|
out = StreamStdout();
|
||||||
|
err = StreamStderr();
|
||||||
|
|
||||||
|
ArgParseStateInit(&arg);
|
||||||
|
while ((opt = ArgParse(&arg, args, "i:o:e:d")) != -1)
|
||||||
|
{
|
||||||
|
switch (opt)
|
||||||
|
{
|
||||||
|
case 'i':
|
||||||
|
if (StrEquals(arg.optArg, "-"))
|
||||||
|
{
|
||||||
|
in = StreamStdin();
|
||||||
|
}
|
||||||
|
|
||||||
|
in = StreamOpen(arg.optArg, "r");
|
||||||
|
if (!in)
|
||||||
|
{
|
||||||
|
StreamPrintf(err, "Unable to open '%s' for reading\n", arg.optArg);
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
break;
|
||||||
|
case 'o':
|
||||||
|
if (StrEquals(arg.optArg, "-"))
|
||||||
|
{
|
||||||
|
out = StreamStdout();
|
||||||
|
}
|
||||||
|
|
||||||
|
out = StreamOpen(arg.optArg, "w");
|
||||||
|
if (!out)
|
||||||
|
{
|
||||||
|
StreamPrintf(err, "Unable to open '%s' for writing.\n", arg.optArg);
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 'e':
|
||||||
|
ArrayAdd(eval, StrDuplicate(arg.optArg));
|
||||||
|
break;
|
||||||
|
case 'd':
|
||||||
|
debug = 1;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
stack = ArrayCreate();
|
||||||
|
ArrayAdd(stack, HashMapCreate());
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Evaluate the runtime environment, discarding any
|
||||||
|
* output because the purpose is only to set the initial
|
||||||
|
* state, not to produce extra output.
|
||||||
|
*/
|
||||||
|
rt = runtime;
|
||||||
|
Free(Eval(&rt, stack));
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Evaluate any expressions specified on the command line,
|
||||||
|
* interpolating them in the output if they produce anything
|
||||||
|
* because that is the expected behavior.
|
||||||
|
*/
|
||||||
|
for (i = 0; i < ArraySize(eval); i++)
|
||||||
|
{
|
||||||
|
char *expr = ArrayGet(eval, i);
|
||||||
|
char *res = Eval(&expr, stack);
|
||||||
|
|
||||||
|
StreamPuts(out, res);
|
||||||
|
Free(res);
|
||||||
|
}
|
||||||
|
|
||||||
|
Process(in, out, stack);
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(stack); i++)
|
||||||
|
{
|
||||||
|
HashMap *stackFrame = ArrayGet(stack, i);
|
||||||
|
char *key;
|
||||||
|
Definition *val;
|
||||||
|
|
||||||
|
while (HashMapIterate(stackFrame, &key, (void **) &val))
|
||||||
|
{
|
||||||
|
size_t j;
|
||||||
|
|
||||||
|
for (j = 0; j < ArraySize(val->args); j++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(val->args, j));
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayFree(val->args);
|
||||||
|
|
||||||
|
Free(val->body);
|
||||||
|
Free(val);
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMapFree(stackFrame);
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayFree(stack);
|
||||||
|
|
||||||
|
ret = EXIT_SUCCESS;
|
||||||
|
|
||||||
|
finish:
|
||||||
|
for (i = 0; i < ArraySize(eval); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(eval, i));
|
||||||
|
}
|
||||||
|
ArrayFree(eval);
|
||||||
|
|
||||||
|
if (in != StreamStdin())
|
||||||
|
{
|
||||||
|
StreamClose(in);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (out != StreamStdout())
|
||||||
|
{
|
||||||
|
StreamClose(out);
|
||||||
|
}
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
Loading…
Reference in a new issue