#include <math.h>
#include <string.h>
#include <stdarg.h>
+#include <stdbool.h>
#include "./builtins.h"
#include "./expr.h"
return eval_failure(SYMBOL(gc, "not-implemented"));
}
-static struct EvalResult length(Gc *gc, struct Expr obj)
-{
- if (!list_p(obj)) {
- return wrong_argument_type(gc, "listp", obj);
- }
-
- return eval_success(NUMBER(gc, length_of_list(obj)));
-}
-
static struct EvalResult eval_atom(Gc *gc, struct Scope *scope, struct Atom *atom)
{
(void) scope;
return eval_success(atom_as_expr(atom));
case ATOM_SYMBOL: {
- if (nil_p(atom_as_expr(atom))) {
- return eval_success(atom_as_expr(atom));
- }
-
struct Expr value = get_scope_value(scope, atom_as_expr(atom));
if (nil_p(value)) {
args));
}
-static struct EvalResult plus_op(Gc *gc, struct Expr args)
-{
- long int result = 0.0f;
-
- while (!nil_p(args)) {
- if (args.type != EXPR_CONS) {
- return eval_failure(CONS(gc,
- SYMBOL(gc, "expected-cons"),
- args));
- }
-
- if (args.cons->car.type != EXPR_ATOM ||
- args.cons->car.atom->type != ATOM_NUMBER) {
- return eval_failure(CONS(gc,
- SYMBOL(gc, "expected-number"),
- args.cons->car));
- }
-
- result += args.cons->car.atom->num;
- args = args.cons->cdr;
- }
-
- return eval_success(atom_as_expr(create_number_atom(gc, result)));
-}
-
static struct EvalResult call_lambda(Gc *gc,
struct Scope *scope,
struct Expr lambda,
static struct EvalResult call_callable(Gc *gc,
struct Scope *scope,
- struct Expr callable,
- struct Expr args) {
- if (callable.type == EXPR_ATOM && callable.atom->type == ATOM_NATIVE) {
- return ((NativeFunction)callable.atom->native.fun)(callable.atom->native.param, gc, scope, args);
+ struct Expr callable_expr,
+ struct Expr args_expr) {
+ struct EvalResult callable_result = eval(gc, scope, callable_expr);
+ if (callable_result.is_error) {
+ return callable_result;
}
- return call_lambda(gc, scope, callable, args);
+ struct EvalResult args_result = symbol_p(callable_expr) && is_special(callable_expr.atom->sym)
+ ? eval_success(args_expr)
+ : eval_all_args(gc, scope, args_expr);
+
+ if (args_result.is_error) {
+ return args_result;
+ }
+
+ if (callable_result.expr.type == EXPR_ATOM &&
+ callable_result.expr.atom->type == ATOM_NATIVE) {
+ return ((NativeFunction)callable_result.expr.atom->native.fun)(
+ callable_result.expr.atom->native.param, gc, scope, args_result.expr);
+ }
+
+ return call_lambda(gc, scope, callable_result.expr, args_result.expr);
}
-static struct EvalResult eval_block(Gc *gc, struct Scope *scope, struct Expr block)
+
+struct EvalResult eval_block(Gc *gc, struct Scope *scope, struct Expr block)
{
assert(gc);
assert(scope);
assert(cons);
(void) scope;
- if (symbol_p(cons->car)) {
- if (strcmp(cons->car.atom->sym, "+") == 0) {
- struct EvalResult args = eval_all_args(gc, scope, cons->cdr);
- if (args.is_error) {
- return args;
- }
- return plus_op(gc, args.expr);
- } else if (strcmp(cons->car.atom->sym, "set") == 0) {
- struct Expr args = cons->cdr;
- struct EvalResult n = length(gc, args);
-
- if (n.is_error) {
- return n;
- }
-
- if (n.expr.atom->num != 2) {
- return eval_failure(list(gc, 3,
- SYMBOL(gc, "wrong-number-of-arguments"),
- SYMBOL(gc, "set"),
- NUMBER(gc, n.expr.atom->num)));
- }
-
- struct Expr name = args.cons->car;
- if (!symbol_p(name)) {
- return eval_failure(list(gc, 3,
- SYMBOL(gc, "wrong-type-argument"),
- SYMBOL(gc, "symbolp"),
- name));
- }
-
- struct EvalResult value = eval(gc, scope, args.cons->cdr.cons->car);
- if (value.is_error) {
- return value;
- }
-
- set_scope_value(gc, scope, name, value.expr);
-
- return eval_success(value.expr);
- } else if (strcmp(cons->car.atom->sym, "quote") == 0) {
- /* TODO(#334): quote does not check the amout of it's arguments */
- return eval_success(cons->cdr.cons->car);
- } else if (strcmp(cons->car.atom->sym, "begin") == 0) {
- return eval_block(gc, scope, CDR(cons_as_expr(cons)));
- } else if (strcmp(cons->car.atom->sym, "lambda") == 0) {
- /* TODO(#335): lambda special form doesn't check if it forms a callable object */
- return eval_success(cons_as_expr(cons));
- } else if (strcmp(cons->car.atom->sym, "when") == 0) {
- struct Expr condition = NIL(gc);
- struct Expr body = NIL(gc);
-
- struct EvalResult result = unpack_args(
- gc, "e*", cons->cdr, &condition, &body);
- if (result.is_error) {
- return result;
- }
-
- result = eval(gc, scope, condition);
- if (result.is_error) {
- return result;
- }
-
- if (!nil_p(result.expr)) {
- return eval_block(gc, scope, body);
- }
-
- return eval_success(NIL(gc));
- }
- }
-
- struct EvalResult r = eval_all_args(gc, scope, cons_as_expr(cons));
-
- if (r.is_error) {
- return r;
+ if (symbol_p(cons->car) && is_lambda(cons)) {
+ /* TODO(#335): lambda special form doesn't check if it forms a callable object */
+ return eval_success(cons_as_expr(cons));
}
- return call_callable(gc, scope, r.expr.cons->car, r.expr.cons->cdr);
+ return call_callable(gc, scope, cons->car, cons->cdr);
}
struct EvalResult eval(Gc *gc, struct Scope *scope, struct Expr expr)
assert(gc);
assert(scope);
- if (!list_p(args)) {
- return wrong_argument_type(gc, "listp", args);
- }
+ struct Expr xs = NIL(gc);
- if (length_of_list(args) != 1) {
- return wrong_number_of_arguments(gc, length_of_list(args));
+ struct EvalResult result = match_list(gc, "e", args, &xs);
+ if (result.is_error) {
+ return result;
}
- struct Expr xs = args.cons->car;
-
if (nil_p(xs)) {
return eval_success(xs);
}
- return eval_success(xs.cons->car);
-}
-
-/* TODO(#536): greaterThan does not support arbitrary amount of arguments */
-static struct EvalResult
-greaterThan(void *param, Gc *gc, struct Scope *scope, struct Expr args)
-{
- assert(gc);
- assert(scope);
- (void) param;
-
- long int x = 0, y = 0;
-
- struct EvalResult result = unpack_args(gc, "dd", args, &x, &y);
- if (result.is_error) {
- return result;
- }
-
- if (x > y) {
- /* TODO(#537): in ebisp t is not a special symbol that evaluates to itself */
- return eval_success(SYMBOL(gc, "t"));
- } else {
- return eval_success(NIL(gc));
+ if (!cons_p(xs)) {
+ return wrong_argument_type(gc, "consp", xs);
}
-}
-void load_std_library(Gc *gc, struct Scope *scope)
-{
- set_scope_value(
- gc,
- scope,
- SYMBOL(gc, "car"),
- NATIVE(gc, car, NULL));
-
- set_scope_value(
- gc,
- scope,
- SYMBOL(gc, ">"),
- NATIVE(gc, greaterThan, NULL));
+ return eval_success(CAR(xs));
}
struct EvalResult
-unpack_args(struct Gc *gc, const char *format, struct Expr args, ...)
+match_list(struct Gc *gc, const char *format, struct Expr xs, ...)
{
va_list args_list;
- va_start(args_list, args);
-
- if (!list_p(args)) {
- va_end(args_list);
- return wrong_argument_type(gc, "listp", args);
- }
+ va_start(args_list, xs);
long int i = 0;
- for (i = 0; *format != 0 && !nil_p(args); ++i) {
- struct Expr arg = CAR(args);
+ for (i = 0; *format != 0 && !nil_p(xs); ++i) {
+ if (!cons_p(xs)) {
+ va_end(args_list);
+ return wrong_argument_type(gc, "consp", xs);
+ }
+
+ struct Expr x = CAR(xs);
switch (*format) {
case 'd': {
- if (!number_p(arg)) {
+ if (!number_p(x)) {
va_end(args_list);
- return wrong_argument_type(gc, "numberp", arg);
+ return wrong_argument_type(gc, "numberp", x);
}
long int *p = va_arg(args_list, long int *);
- *p = arg.atom->num;
+ if (p != NULL) {
+ *p = x.atom->num;
+ }
} break;
case 's': {
- if (!string_p(arg)) {
+ if (!string_p(x)) {
va_end(args_list);
- return wrong_argument_type(gc, "stringp", arg);
+ return wrong_argument_type(gc, "stringp", x);
}
const char **p = va_arg(args_list, const char**);
- *p = arg.atom->str;
+ if (p != NULL) {
+ *p = x.atom->str;
+ }
} break;
case 'q': {
- if (!symbol_p(arg)) {
+ if (!symbol_p(x)) {
va_end(args_list);
- return wrong_argument_type(gc, "symbolp", arg);
+ return wrong_argument_type(gc, "symbolp", x);
}
const char **p = va_arg(args_list, const char**);
- *p = arg.atom->sym;
+ if (p != NULL) {
+ *p = x.atom->sym;
+ }
} break;
case 'e': {
struct Expr *p = va_arg(args_list, struct Expr*);
- *p = arg;
+ *p = x;
} break;
case '*': {
struct Expr *p = va_arg(args_list, struct Expr*);
- *p = args;
- args = NIL(gc);
+ if (p != NULL) {
+ *p = xs;
+ }
+ xs = NIL(gc);
} break;
}
format++;
- if (!nil_p(args)) {
- args = CDR(args);
+ if (!nil_p(xs)) {
+ xs = CDR(xs);
+ }
+ }
+
+ if (*format == '*' && nil_p(xs)) {
+ struct Expr *p = va_arg(args_list, struct Expr*);
+ if (p != NULL) {
+ *p = NIL(gc);
}
+ format++;
}
- if (*format != 0 || !nil_p(args)) {
- return eval_failure(
- CONS(gc,
- SYMBOL(gc, "wrong-number-of-arguments"),
- NUMBER(gc, i)));
+ if (*format != 0 || !nil_p(xs)) {
+ va_end(args_list);
+ return wrong_number_of_arguments(gc, i);
}
+ va_end(args_list);
return eval_success(NIL(gc));
}
+
+static struct Expr
+format_list_rec(Gc *gc, const char *format, va_list args)
+{
+ assert(gc);
+ assert(format);
+
+ if (*format == 0) {
+ return NIL(gc);
+ }
+
+ switch (*format) {
+ case 'd': {
+ long int p = va_arg(args, long int);
+ return CONS(gc, NUMBER(gc, p),
+ format_list_rec(gc, format + 1, args));
+ }
+
+ case 's': {
+ const char* p = va_arg(args, const char*);
+ return CONS(gc, STRING(gc, p),
+ format_list_rec(gc, format + 1, args));
+ }
+
+ case 'q': {
+ const char* p = va_arg(args, const char*);
+ return CONS(gc, SYMBOL(gc, p),
+ format_list_rec(gc, format + 1, args));
+ }
+
+ case 'e': {
+ struct Expr p = va_arg(args, struct Expr);
+ return CONS(gc, p, format_list_rec(gc, format + 1, args));
+ }
+
+ default: {
+ fprintf(stderr, "Wrong format parameter: %c\n", *format);
+ assert(0);
+ }
+ }
+}
+
+struct Expr
+format_list(Gc *gc, const char *format, ...)
+{
+ va_list args;
+ va_start(args, format);
+ struct Expr result = format_list_rec(gc, format, args);
+ va_end(args);
+
+ return result;
+}
projects / nothing.git / blobdiff