enum dylan_type_enum
dylan_type (D instance) {
if ((DUMINT)instance & 3) {
if ((DUMINT)instance & 1)
return(integer_type);
else if ((DUMINT)instance & 2)
return(character_type);
else
return(unknown_type);
} else { /* dylan pointer */
if (float_p(instance))
return(float_type);
else if (boolean_p(instance))
return(dylan_boolean_type);
else if (string_p(instance))
return(string_type);
else if (vector_p(instance))
return(vector_type);
else if (pair_p(instance))
return(pair_type);
else if (empty_list_p(instance))
return(empty_list_type);
else if (symbol_p(instance))
return(symbol_type);
else if (simple_condition_p(instance))
return(simple_condition_type);
else if (class_p(instance))
return(class_type);
else if (function_p(instance))
return(function_type);
else
return(user_defined_type);
}
}
cons_t *do_macros(cons_t *rprog, dict_t **scope) {
dict_t *symbol;
value_t val;
cons_t *stack = NULL;
while (rprog != NULL) {
val = list_peek(rprog);
if (symbol_p(val) && macro_p(unwrap_symbol(val))) {
symbol = unwrap_symbol(val);
unwrap_native(value(symbol))(&stack, scope);
} else {
list_push(&stack, val);
}
rprog = list_next(rprog);
}
return stack;
}
object *eval (object *o)
{
/* printf("%s: Trying to eval object type: %d\n", __func__, o->type); */
if (is_truthy (atom (o))) {
if (symbol_p (o)) {
/* printf("%s: Looking for symbol\n", __func__); */
return env_find_symbol_value (current_env, o);
} else {
/* printf("%s: Not eval-ing\n", __func__); */
return o;
}
} else {
/* printf("%s: Function call\n", __func__); */
object *symbol = car (o);
object *arguments = cdr (o);
return call_function (symbol, arguments);
}
}
/*
* ~~ a brief interlude about the executor ~~
*
* The executor takes a function, which is a list of values, the
* current stack, which it may modify, and a scope, which it will not modify.
*
* It uses the following algorithm to execute the function:
* 1. Get the next value. if there are no more values, end.
* a. if the value is a number, push it onto the stack
* b. if the value is a function, call it with the current stack and scope
* 1. if the function is a native, call it directly
* 2. otherwise, call execute() on it
* 2. Go to 1.
*/
void execute(cons_t *prog, cons_t **stack, dict_t **scope) {
dict_t *symbol;
value_t val;
while (prog != NULL) {
val = CAR(prog);
if (number_p(val)) {
list_push(stack, val);
} else if (symbol_p(val)) {
symbol = unwrap_symbol(val);
val = value(symbol);
if (null_p(val)) {
fprintf(stderr, "%s? ", key(symbol));
break;
} else {
unwrap_native(val)(stack, scope);
}
} else {
printf("OH DANG BRO %d:%ld\n", val.storage, val.value.literal);
}
prog = list_next(prog);
}
}
