Skip to content

Instantly share code, notes, and snippets.

@kawakami-o3

kawakami-o3/eval_0.lisp

Last active July 15, 2018 16:08
Show Gist options
  • Save kawakami-o3/7e4a481c2dedb2925d7a02140f7de983 to your computer and use it in GitHub Desktop.
Save kawakami-o3/7e4a481c2dedb2925d7a02140f7de983 to your computer and use it in GitHub Desktop.
Download ZIP
broken compilation from lisp to c
Raw
eval_0.lisp
(progn
(define _eval
(lambda (form env)
(+ 1 1)))
(define *env* (quote (nil nil)))
(define _assoc
(lambda (item lis)
(if (eq lis nil)
nil
(if (eq (car (car lis)) item)
(car lis)
(_assoc item (cdr lis))))))
(define _updatev
(lambda (alist name value)
(if (eq alist nil)
nil
(if (eq (car (car alist)) name)
(cons (cons name (cons value nil)) (cdr alist))
(cons (car alist) (_updatev (cdr alist) name value))))))
(define _setv
(lambda (name value)
((lambda (pair)
(if (eq pair nil)
(define *env* (cons nil (cons (cons (cons name (cons value nil)) (car (cdr *env*))) nil)))
(define *env* (cons nil (cons (_updatev (car (cdr *env*)) name value) nil)))))
(_assoc name (car (cdr *env*))))))
(define _lookup
(lambda (name env)
((lambda (pair)
(if (eq pair nil)
(if (eq (car env) nil)
(quote :unbound:)
(_lookup name (car env)))
(car (cdr pair))))
(_assoc name (car (cdr env))))))
(define _bind
(lambda (fn-args act-args env)
(if (eq fn-args nil)
nil
(if (eq act-args nil)
(quote :too-few-args:)
(cons (cons (car fn-args) (cons (_eval (car act-args) env) nil))
(_bind (cdr fn-args) (cdr act-args) env))))))
(_setv (quote atom)
(cons (quote :lambda:)
(cons (quote (o))
(cons (lambda (ne) (atom (_lookup (quote o) ne)))
nil))))
(_setv (quote cons)
(cons (quote :lambda:)
(cons (quote (a b))
(cons (lambda (ne) (cons (_lookup (quote a) ne) (_lookup (quote b) ne)))
nil))))
(_setv (quote car)
(cons (quote :lambda:)
(cons (quote (l))
(cons (lambda (ne) (car (_lookup (quote l) ne)))
nil))))
(_setv (quote cdr)
(cons (quote :lambda:)
(cons (quote (l))
(cons (lambda (ne) (cdr (_lookup (quote l) ne)))
nil))))
(_setv (quote eq)
(cons (quote :lambda:)
(cons (quote (a b))
(cons (lambda (ne) (eq (_lookup (quote a) ne) (_lookup (quote b) ne)))
nil))))
(define _eval
(lambda (form env)
(if (atom form)
(if (eq form nil)
nil
(if (eq form t)
form
(_lookup form env)))
(if (eq (cdr form) nil)
nil
(if (eq (car form) (quote if))
(if (_eval (car (cdr form)) env)
(_eval (car (cdr (cdr form))) env)
(_eval (car (cdr (cdr (cdr form)))) env))
(if (eq (car form) (quote quote))
(car (cdr form))
(if (eq (car form) (quote lambda))
(cons (quote :lambda:)
(cons (car (cdr form))
(cons (lambda (ne) (_eval (car (cdr (cdr form))) ne)) nil)))
(if (eq (car form) (quote define))
(_setv (car (cdr form)) (_eval (car (cdr (cdr form))) env))
((lambda (fn)
(if (eq fn (quote :unbound:))
(quote :undefined-op:)
((car (cdr (cdr fn))) (cons env (cons (_bind (car (cdr fn)) (cdr form) env) nil)))))
(_lookup (car form) env))))))))))
(define eval
(lambda (form) (_eval form *env*)))
(print (eval (quote (+ 1 2)))))
Raw
eval_1.c
#include<stdarg.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define INIT_SIZE 8
typedef struct {
int nalloc;
int length;
char *chars;
} String;
String *make_string() {
String *s = malloc(sizeof(String));
s->chars = malloc(INIT_SIZE);
s->nalloc = INIT_SIZE;
s->length = 0;
s->chars[0] = '\0';
return s;
}
static void realloc_string(String *s) {
int newsize = s->nalloc * 2;
char *chars = malloc(newsize);
strcpy(chars, s->chars);
s->chars = chars;
s->nalloc = newsize;
}
void string_append(String *s, char c) {
if (s->nalloc == (s->length + 1)) {
realloc_string(s);
}
s->chars[s->length++] = c;
s->chars[s->length] = '\0';
}
void string_appendf(String *s, char *fmt, ...) {
va_list args;
for (;;) {
int avail = s->nalloc - s->length;
va_start(args, fmt);
int written = vsnprintf(s->chars + s->length, avail, fmt, args);
va_end(args);
if (avail <= written) {
realloc_string(s);
continue;
}
s->length += written;
return;
}
}
enum Type {
NIL,
INT,
STR,
PROC
};
struct List;
typedef struct {
int type;
int i;
String *str;
struct List *(*proc)(struct List*);
} Atom;
typedef struct List {
Atom *atom;
struct List *car;
struct List *cdr;
} List;
//char *atom_to_string(Atom *a, char *s);
List *make_list();
List *make_int(int i);
List *car(List *lst);
List *nil;
List *t;
Atom *make_atom() {
Atom *a = malloc(sizeof(Atom));
return a;
}
/*
char *atom_to_string(Atom *a, char *s) {
sprintf(s, "%d", a->i);
}
*/
List *make_list() {
List *lst = malloc(sizeof(List));
lst->atom = NULL;
lst->car = NULL;
lst->cdr = NULL;
return lst;
}
List *make_int(int i) {
Atom *atom = make_atom();
atom->type = INT;
atom->i = i;
List *lst = make_list();
lst->atom = atom;
return lst;
}
List *make_symbol(char *chars) {
Atom *atom = make_atom();
atom->type = STR;
string_appendf(atom->str, "%s", chars);
List *lst = make_list();
lst->atom = atom;
return lst;
}
struct List *(*proc)(struct List*);
List *make_lambda(List *(*proc)(struct List*)) {
Atom *atom = make_atom();
atom->type = PROC;
atom->proc = proc;
List *lst = make_list();
lst->atom = atom;
return lst;
}
void to_string(String *str, List *lst) {
if (lst == NULL) {
return;
} else if (lst->atom == NULL) {
to_string(str, lst->car);
if (lst->cdr != NULL && lst->cdr != nil) {
to_string(str, lst->cdr);
}
} else {
switch(lst->atom->type) {
case INT:
string_appendf(str, " %d", lst->atom->i);
break;
case STR:
string_appendf(str, " %s", lst->atom->str->chars);
break;
case NIL:
string_appendf(str, " nil");
break;
default:
string_appendf(str, " nil");
}
}
}
/*
List *callProc(List *proc, int argc, ...) {
va_list args;
List *ret;
List *lst = make_list();
va_start(args, argc);
for (int i=0 ; i<argc ; i++) {
List *a = va_arg(args, (List*));
lst = cons(a, lst);
}
va_end(args);
return proc.proc(lst);
}
*/
void printList(List *lst) {
String *s = make_string();
to_string(s, lst);
printf("%s\n", s->chars);
}
List *car(List *lst) {
if (lst->car == NULL) {
printf("error");
exit(-1);
}
return lst->car;
}
List *cdr(List *lst) {
return lst->cdr;
}
List *cons(List *a, List *b) {
List *lst = make_list();
lst->car = a;
lst->cdr = b;
return lst;
}
List *nth(List *lst, int i) {
if (i <= 0) {
return lst->car;
}
if (lst->cdr == NULL) {
return NULL;
}
return nth(lst->cdr, i-1);
}
List *plc_add(List *lst) {
int i = 0;
List *a = lst->car;
List *d = lst->cdr;
while (a != NULL) {
i += a->atom->i;
a = d->car;
d = d->cdr;
}
return make_int(i);
}
List *plc_sub(List *lst) {
List *a = lst->car;
List *d = lst->cdr;
int i = a->atom->i;
a = d->car;
d = d->cdr;
while (a != NULL) {
i -= a->atom->i;
a = d->car;
d = d->cdr;
}
return make_int(i);
}
void init_common() {
nil = make_list();
nil->atom = make_atom();
nil->atom->type = NIL;
t = make_list();
t->atom = make_atom();
nil->atom->type = INT;
t->atom->i = 1;
}
List *_eval;
List *lambda_proc_4(List *args){
List *form = nth(args, 0);
List *env = nth(args, 1);
List *num_1 = make_int(1);
List *num_2 = make_int(1);
List *args_3 = cons(num_1, cons(num_2, nil));
List *plus_3 = plc_add(args_3);
return plus_3;
}
List *_assoc;
List *lambda_proc_17(List *args){
List *item = nth(args, 0);
List *lis = nth(args, 1);
List *if_8;
List *eq_9 = make_int(
lis->atom->i == nil->atom->i
);
if (eq_9->atom->i) {
if_8 = nil;
} else {
List *if_10;
List *car_11 = car(lis);
List *car_12 = car(car_11);
List *eq_13 = make_int(
car_12->atom->i == item->atom->i
);
if (eq_13->atom->i) {
List *car_14 = car(lis);
if_10 = car_14;
} else {
List *cdr_15 = cdr(lis);
List *_assoc_args_16 = cons(item, cons(cdr_15, nil));
if_10 = _assoc->atom->proc(_assoc_args_16);
}
if_8 = if_10;
}
return if_8;
}
List *_updatev;
List *lambda_proc_32(List *args){
List *alist = nth(args, 0);
List *name = nth(args, 1);
List *value = nth(args, 2);
List *if_18;
List *eq_19 = make_int(
alist->atom->i == nil->atom->i
);
if (eq_19->atom->i) {
if_18 = nil;
} else {
List *if_20;
List *car_21 = car(alist);
List *car_22 = car(car_21);
List *eq_23 = make_int(
car_22->atom->i == name->atom->i
);
if (eq_23->atom->i) {
List *cons_24 = cons(value, nil);
List *cons_25 = cons(name, cons_24);
List *cdr_26 = cdr(alist);
List *cons_27 = cons(cons_25, cdr_26);
if_20 = cons_27;
} else {
List *car_28 = car(alist);
List *cdr_29 = cdr(alist);
List *_updatev_args_30 = cons(cdr_29, cons(name, cons(value, nil)));
List *cons_31 = cons(car_28, _updatev->atom->proc(_updatev_args_30));
if_20 = cons_31;
}
if_18 = if_20;
}
return if_18;
}
List *_setv;
List *lambda_proc_47_external;
List *lambda_proc_47(List *args){
List *pair = nth(args, 0);
List *name = nth(lambda_proc_47_external, 0);
List *value = nth(lambda_proc_47_external, 1);
List *_s_env_s_ = nth(lambda_proc_47_external, 2);
List *if_33;
List *eq_34 = make_int(
pair->atom->i == nil->atom->i
);
if (eq_34->atom->i) {
List *cons_35 = cons(value, nil);
List *cons_36 = cons(name, cons_35);
List *cdr_37 = cdr(_s_env_s_);
List *car_38 = car(cdr_37);
List *cons_39 = cons(cons_36, car_38);
List *cons_40 = cons(cons_39, nil);
List *cons_41 = cons(nil, cons_40);
_s_env_s_ = cons_41;
if_33 = _s_env_s_;
} else {
List *cdr_42 = cdr(_s_env_s_);
List *car_43 = car(cdr_42);
List *_updatev_args_44 = cons(car_43, cons(name, cons(value, nil)));
List *cons_45 = cons(_updatev->atom->proc(_updatev_args_44), nil);
List *cons_46 = cons(nil, cons_45);
_s_env_s_ = cons_46;
if_33 = _s_env_s_;
}
return if_33;
}
List *lambda_proc_52_external;
List *lambda_proc_52(List *args){
List *name = nth(args, 0);
List *value = nth(args, 1);
List *_s_env_s_ = nth(lambda_proc_52_external, 0);
lambda_proc_47_external = cons(name, cons(value, cons(_s_env_s_, nil)));
List *lambda_47 = make_lambda(lambda_proc_47);
List *cdr_48 = cdr(_s_env_s_);
List *car_49 = car(cdr_48);
List *_assoc_args_50 = cons(name, cons(car_49, nil));
List *lambda_47_args_51 = cons(_assoc->atom->proc(_assoc_args_50), nil);
return lambda_47->atom->proc(lambda_47_args_51);
}
List *_lookup;
List *lambda_proc_63_external;
List *lambda_proc_63(List *args){
List *pair = nth(args, 0);
List *env = nth(lambda_proc_63_external, 0);
List *name = nth(lambda_proc_63_external, 1);
List *if_53;
List *eq_54 = make_int(
pair->atom->i == nil->atom->i
);
if (eq_54->atom->i) {
List *if_55;
List *car_56 = car(env);
List *eq_57 = make_int(
car_56->atom->i == nil->atom->i
);
if (eq_57->atom->i) {
List *quote_58 = make_symbol("_k_unbound_k_");
if_55 = quote_58;
} else {
List *car_59 = car(env);
List *_lookup_args_60 = cons(name, cons(car_59, nil));
if_55 = _lookup->atom->proc(_lookup_args_60);
}
if_53 = if_55;
} else {
List *cdr_61 = cdr(pair);
List *car_62 = car(cdr_61);
if_53 = car_62;
}
return if_53;
}
List *lambda_proc_68(List *args){
List *name = nth(args, 0);
List *env = nth(args, 1);
lambda_proc_63_external = cons(env, cons(name, nil));
List *lambda_63 = make_lambda(lambda_proc_63);
List *cdr_64 = cdr(env);
List *car_65 = car(cdr_64);
List *_assoc_args_66 = cons(name, cons(car_65, nil));
List *lambda_63_args_67 = cons(_assoc->atom->proc(_assoc_args_66), nil);
return lambda_63->atom->proc(lambda_63_args_67);
}
List *_bind;
List *lambda_proc_83(List *args){
List *fn_m_args = nth(args, 0);
List *act_m_args = nth(args, 1);
List *env = nth(args, 2);
List *if_69;
List *eq_70 = make_int(
fn_m_args->atom->i == nil->atom->i
);
if (eq_70->atom->i) {
if_69 = nil;
} else {
List *if_71;
List *eq_72 = make_int(
act_m_args->atom->i == nil->atom->i
);
if (eq_72->atom->i) {
List *quote_73 = make_symbol("_k_too_m_few_m_args_k_");
if_71 = quote_73;
} else {
List *car_74 = car(fn_m_args);
List *car_75 = car(act_m_args);
List *_eval_args_76 = cons(car_75, cons(env, nil));
List *cons_77 = cons(_eval->atom->proc(_eval_args_76), nil);
List *cons_78 = cons(car_74, cons_77);
List *cdr_79 = cdr(fn_m_args);
List *cdr_80 = cdr(act_m_args);
List *_bind_args_81 = cons(cdr_79, cons(cdr_80, cons(env, nil)));
List *cons_82 = cons(cons_78, _bind->atom->proc(_bind_args_81));
if_71 = cons_82;
}
if_69 = if_71;
}
return if_69;
}
List *lambda_proc_91(List *args){
List *ne = nth(args, 0);
List *quote_88 = make_symbol("o");
List *_lookup_args_89 = cons(quote_88, cons(ne, nil));
List *atom_90 = make_int(_lookup->atom->proc(_lookup_args_89)->atom != NULL);
return atom_90;
}
List *lambda_proc_106(List *args){
List *ne = nth(args, 0);
List *quote_101 = make_symbol("a");
List *_lookup_args_102 = cons(quote_101, cons(ne, nil));
List *quote_103 = make_symbol("b");
List *_lookup_args_104 = cons(quote_103, cons(ne, nil));
List *cons_105 = cons(_lookup->atom->proc(_lookup_args_102), _lookup->atom->proc(_lookup_args_104));
return cons_105;
}
List *lambda_proc_118(List *args){
List *ne = nth(args, 0);
List *quote_115 = make_symbol("l");
List *_lookup_args_116 = cons(quote_115, cons(ne, nil));
List *car_117 = car(_lookup->atom->proc(_lookup_args_116));
return car_117;
}
List *lambda_proc_130(List *args){
List *ne = nth(args, 0);
List *quote_127 = make_symbol("l");
List *_lookup_args_128 = cons(quote_127, cons(ne, nil));
List *cdr_129 = cdr(_lookup->atom->proc(_lookup_args_128));
return cdr_129;
}
List *lambda_proc_145(List *args){
List *ne = nth(args, 0);
List *quote_140 = make_symbol("a");
List *_lookup_args_141 = cons(quote_140, cons(ne, nil));
List *quote_142 = make_symbol("b");
List *_lookup_args_143 = cons(quote_142, cons(ne, nil));
List *eq_144 = make_int(
_lookup->atom->proc(_lookup_args_141)->atom->i == _lookup->atom->proc(_lookup_args_143)->atom->i
);
return eq_144;
}
List *lambda_proc_194_external;
List *lambda_proc_194(List *args){
List *ne = nth(args, 0);
List *form = nth(lambda_proc_194_external, 0);
List *cdr_190 = cdr(form);
List *cdr_191 = cdr(cdr_190);
List *car_192 = car(cdr_191);
List *_eval_args_193 = cons(car_192, cons(ne, nil));
return _eval->atom->proc(_eval_args_193);
}
List *lambda_proc_223_external;
List *lambda_proc_223(List *args){
List *fn = nth(args, 0);
List *env = nth(lambda_proc_223_external, 0);
List *form = nth(lambda_proc_223_external, 1);
List *if_209;
List *quote_210 = make_symbol("_k_unbound_k_");
List *eq_211 = make_int(
fn->atom->i == quote_210->atom->i
);
if (eq_211->atom->i) {
List *quote_212 = make_symbol("_k_undefined_m_op_k_");
if_209 = quote_212;
} else {
List *cdr_213 = cdr(fn);
List *cdr_214 = cdr(cdr_213);
List *car_215 = car(cdr_214);
List *cdr_216 = cdr(fn);
List *car_217 = car(cdr_216);
List *cdr_218 = cdr(form);
List *_bind_args_219 = cons(car_217, cons(cdr_218, cons(env, nil)));
List *cons_220 = cons(_bind->atom->proc(_bind_args_219), nil);
List *cons_221 = cons(env, cons_220);
List *car_215_args_222 = cons(cons_221, nil);
if_209 = car_215->atom->proc(car_215_args_222);
}
return if_209;
}
List *lambda_proc_227(List *args){
List *form = nth(args, 0);
List *env = nth(args, 1);
List *if_150;
List *atom_151 = make_int(form->atom != NULL);
if (atom_151->atom->i) {
List *if_152;
List *eq_153 = make_int(
form->atom->i == nil->atom->i
);
if (eq_153->atom->i) {
if_152 = nil;
} else {
List *if_154;
List *eq_155 = make_int(
form->atom->i == t->atom->i
);
if (eq_155->atom->i) {
if_154 = form;
} else {
List *_lookup_args_156 = cons(form, cons(env, nil));
if_154 = _lookup->atom->proc(_lookup_args_156);
}
if_152 = if_154;
}
if_150 = if_152;
} else {
List *if_157;
List *cdr_158 = cdr(form);
List *eq_159 = make_int(
cdr_158->atom->i == nil->atom->i
);
if (eq_159->atom->i) {
if_157 = nil;
} else {
List *if_160;
List *car_161 = car(form);
List *quote_162 = make_symbol("if");
List *eq_163 = make_int(
car_161->atom->i == quote_162->atom->i
);
if (eq_163->atom->i) {
List *if_164;
List *cdr_165 = cdr(form);
List *car_166 = car(cdr_165);
List *_eval_args_167 = cons(car_166, cons(env, nil));
if (_eval->atom->proc(_eval_args_167)->atom->i) {
List *cdr_168 = cdr(form);
List *cdr_169 = cdr(cdr_168);
List *car_170 = car(cdr_169);
List *_eval_args_171 = cons(car_170, cons(env, nil));
if_164 = _eval->atom->proc(_eval_args_171);
} else {
List *cdr_172 = cdr(form);
List *cdr_173 = cdr(cdr_172);
List *cdr_174 = cdr(cdr_173);
List *car_175 = car(cdr_174);
List *_eval_args_176 = cons(car_175, cons(env, nil));
if_164 = _eval->atom->proc(_eval_args_176);
}
if_160 = if_164;
} else {
List *if_177;
List *car_178 = car(form);
List *quote_179 = make_symbol("quote");
List *eq_180 = make_int(
car_178->atom->i == quote_179->atom->i
);
if (eq_180->atom->i) {
List *cdr_181 = cdr(form);
List *car_182 = car(cdr_181);
if_177 = car_182;
} else {
List *if_183;
List *car_184 = car(form);
List *quote_185 = make_symbol("lambda");
List *eq_186 = make_int(
car_184->atom->i == quote_185->atom->i
);
if (eq_186->atom->i) {
List *quote_187 = make_symbol("_k_lambda_k_");
List *cdr_188 = cdr(form);
List *car_189 = car(cdr_188);
lambda_proc_194_external = cons(form, nil);
List *lambda_194 = make_lambda(lambda_proc_194);
List *cons_195 = cons(lambda_194, nil);
List *cons_196 = cons(car_189, cons_195);
List *cons_197 = cons(quote_187, cons_196);
if_183 = cons_197;
} else {
List *if_198;
List *car_199 = car(form);
List *quote_200 = make_symbol("define");
List *eq_201 = make_int(
car_199->atom->i == quote_200->atom->i
);
if (eq_201->atom->i) {
List *cdr_202 = cdr(form);
List *car_203 = car(cdr_202);
List *cdr_204 = cdr(form);
List *cdr_205 = cdr(cdr_204);
List *car_206 = car(cdr_205);
List *_eval_args_207 = cons(car_206, cons(env, nil));
List *_setv_args_208 = cons(car_203, cons(_eval->atom->proc(_eval_args_207), nil));
if_198 = _setv->atom->proc(_setv_args_208);
} else {
lambda_proc_223_external = cons(env, cons(form, nil));
List *lambda_223 = make_lambda(lambda_proc_223);
List *car_224 = car(form);
List *_lookup_args_225 = cons(car_224, cons(env, nil));
List *lambda_223_args_226 = cons(_lookup->atom->proc(_lookup_args_225), nil);
if_198 = lambda_223->atom->proc(lambda_223_args_226);
}
if_183 = if_198;
}
if_177 = if_183;
}
if_160 = if_177;
}
if_157 = if_160;
}
if_150 = if_157;
}
return if_150;
}
List *eval;
List *lambda_proc_229_external;
List *lambda_proc_229(List *args){
List *form = nth(args, 0);
List *_s_env_s_ = nth(lambda_proc_229_external, 0);
List *_eval_args_228 = cons(form, cons(_s_env_s_, nil));
return _eval->atom->proc(_eval_args_228);
}
int main() {
init_common();
List *lambda_4 = make_lambda(lambda_proc_4);
_eval = lambda_4;
char *str_6 = "nil";
List *sym_6 = make_symbol(str_6);
char *str_7 = "nil";
List *sym_7 = make_symbol(str_7);
List *quote_5 = cons(sym_6, cons(sym_7, nil));
List *_s_env_s_ = quote_5;
List *lambda_17 = make_lambda(lambda_proc_17);
_assoc = lambda_17;
List *lambda_32 = make_lambda(lambda_proc_32);
_updatev = lambda_32;
lambda_proc_52_external = cons(_s_env_s_, nil);
List *lambda_52 = make_lambda(lambda_proc_52);
_setv = lambda_52;
List *lambda_68 = make_lambda(lambda_proc_68);
_lookup = lambda_68;
List *lambda_83 = make_lambda(lambda_proc_83);
_bind = lambda_83;
List *quote_84 = make_symbol("atom");
List *quote_85 = make_symbol("_k_lambda_k_");
char *str_87 = "o";
List *sym_87 = make_symbol(str_87);
List *quote_86 = cons(sym_87, nil);
List *lambda_91 = make_lambda(lambda_proc_91);
List *cons_92 = cons(lambda_91, nil);
List *cons_93 = cons(quote_86, cons_92);
List *cons_94 = cons(quote_85, cons_93);
List *_setv_args_95 = cons(quote_84, cons(cons_94, nil));
List *quote_96 = make_symbol("cons");
List *quote_97 = make_symbol("_k_lambda_k_");
char *str_99 = "a";
List *sym_99 = make_symbol(str_99);
char *str_100 = "b";
List *sym_100 = make_symbol(str_100);
List *quote_98 = cons(sym_99, cons(sym_100, nil));
List *lambda_106 = make_lambda(lambda_proc_106);
List *cons_107 = cons(lambda_106, nil);
List *cons_108 = cons(quote_98, cons_107);
List *cons_109 = cons(quote_97, cons_108);
List *_setv_args_110 = cons(quote_96, cons(cons_109, nil));
List *quote_111 = make_symbol("car");
List *quote_112 = make_symbol("_k_lambda_k_");
char *str_114 = "l";
List *sym_114 = make_symbol(str_114);
List *quote_113 = cons(sym_114, nil);
List *lambda_118 = make_lambda(lambda_proc_118);
List *cons_119 = cons(lambda_118, nil);
List *cons_120 = cons(quote_113, cons_119);
List *cons_121 = cons(quote_112, cons_120);
List *_setv_args_122 = cons(quote_111, cons(cons_121, nil));
List *quote_123 = make_symbol("cdr");
List *quote_124 = make_symbol("_k_lambda_k_");
char *str_126 = "l";
List *sym_126 = make_symbol(str_126);
List *quote_125 = cons(sym_126, nil);
List *lambda_130 = make_lambda(lambda_proc_130);
List *cons_131 = cons(lambda_130, nil);
List *cons_132 = cons(quote_125, cons_131);
List *cons_133 = cons(quote_124, cons_132);
List *_setv_args_134 = cons(quote_123, cons(cons_133, nil));
List *quote_135 = make_symbol("eq");
List *quote_136 = make_symbol("_k_lambda_k_");
char *str_138 = "a";
List *sym_138 = make_symbol(str_138);
char *str_139 = "b";
List *sym_139 = make_symbol(str_139);
List *quote_137 = cons(sym_138, cons(sym_139, nil));
List *lambda_145 = make_lambda(lambda_proc_145);
List *cons_146 = cons(lambda_145, nil);
List *cons_147 = cons(quote_137, cons_146);
List *cons_148 = cons(quote_136, cons_147);
List *_setv_args_149 = cons(quote_135, cons(cons_148, nil));
List *lambda_227 = make_lambda(lambda_proc_227);
_eval = lambda_227;
lambda_proc_229_external = cons(_s_env_s_, nil);
List *lambda_229 = make_lambda(lambda_proc_229);
eval = lambda_229;
char *str_231 = "+";
List *sym_231 = make_symbol(str_231);
List *num_232 = make_int(1);
List *num_233 = make_int(2);
List *quote_230 = cons(sym_231, cons(num_232, cons(num_233, nil)));
List *eval_args_234 = cons(quote_230, nil);
printList(eval->atom->proc(eval_args_234));
char* print_ret_235 = "#<undef>";
int progn_236 = 0;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment