diff options
| -rw-r--r-- | eval.c | 122 | ||||
| -rw-r--r-- | lib.c | 178 | ||||
| -rw-r--r-- | lib.h | 6 |
3 files changed, 156 insertions, 150 deletions
@@ -5218,15 +5218,15 @@ static val mappendv(val fun, struct args *lists) static val lazy_mapcar_func(val env, val lcons) { - cons_bind (fun, list, env); + us_cons_bind (fun, list, env); - rplaca(lcons, funcall1(fun, car(list))); - rplacd(env, cdr(list)); + us_rplaca(lcons, funcall1(fun, car(list))); + us_rplacd(env, cdr(list)); if (cdr(list)) - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); else - rplacd(lcons, nil); + us_rplacd(lcons, nil); return nil; } @@ -5240,17 +5240,17 @@ val lazy_mapcar(val fun, val list) static val lazy_mapcarv_func(val env, val lcons) { - cons_bind (fun, lofl, env); + us_cons_bind (fun, lofl, env); val args = mapcar(car_f, lofl); val next = mapcar(cdr_f, lofl); - rplaca(lcons, apply(fun, z(args))); - rplacd(env, next); + us_rplaca(lcons, apply(fun, z(args))); + us_rplacd(env, next); if (all_satisfy(next, identity_f, identity_f)) - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); else - rplacd(lcons, nil); + us_rplacd(lcons, nil); return nil; } @@ -5459,25 +5459,25 @@ static val mmakunbound(val sym) static val range_func(val env, val lcons) { - cons_bind (from, to_step, env); - cons_bind (to, step, to_step); + us_cons_bind (from, to_step, env); + us_cons_bind (to, step, to_step); val next = if3(functionp(step), funcall1(step, from), plus(from, step)); - rplaca(lcons, from); + us_rplaca(lcons, from); if (to && (numeq(from, to) || ((lt(from, to) && gt(next, to)) || (gt(from, to) && lt(next, to))))) { - rplacd(lcons, nil); + us_rplacd(lcons, nil); return nil; } - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); - rplaca(env, next); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); + us_rplaca(env, next); return nil; } @@ -5493,13 +5493,13 @@ static val range(val from_in, val to_in, val step_in) static val range_star_func(val env, val lcons) { - cons_bind (from, to_step, env); - cons_bind (to, step, to_step); + us_cons_bind (from, to_step, env); + us_cons_bind (to, step, to_step); val next = if3(functionp(step), funcall1(step, from), plus(from, step)); - rplaca(lcons, from); + us_rplaca(lcons, from); if (to && (numeq(next, to) || @@ -5510,8 +5510,8 @@ static val range_star_func(val env, val lcons) return nil; } - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); - rplaca(env, next); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); + us_rplaca(env, next); return nil; } @@ -5570,15 +5570,15 @@ static val rlist_star(struct args *items) static val generate_func(val env, val lcons) { - cons_bind (while_pred, gen_fun, env); + us_cons_bind (while_pred, gen_fun, env); if (!funcall(while_pred)) { rplacd(lcons, nil); } else { val next_item = funcall(gen_fun); - val lcons_next = make_lazy_cons(lcons_fun(lcons)); - rplacd(lcons, lcons_next); - rplaca(lcons_next, next_item); + val lcons_next = make_lazy_cons(us_lcons_fun(lcons)); + us_rplacd(lcons, lcons_next); + us_rplaca(lcons_next, next_item); } return nil; } @@ -5597,13 +5597,13 @@ val generate(val while_pred, val gen_fun) static val giterate_func(val env, val lcons) { - cons_bind (while_pred, gen_fun, env); - val next_item = funcall1(gen_fun, lcons->lc.car); + us_cons_bind (while_pred, gen_fun, env); + val next_item = funcall1(gen_fun, us_car(lcons)); if (funcall1(while_pred, next_item)) { - val lcons_next = make_lazy_cons(lcons_fun(lcons)); - rplacd(lcons, lcons_next); - rplaca(lcons_next, next_item); + val lcons_next = make_lazy_cons(us_lcons_fun(lcons)); + us_rplacd(lcons, lcons_next); + us_rplaca(lcons_next, next_item); } return nil; } @@ -5616,22 +5616,22 @@ static val giterate(val while_pred, val gen_fun, val init_val) return nil; } else { val lc = make_lazy_cons(func_f1(cons(while_pred, gen_fun), giterate_func)); - rplaca(lc, init_val); + us_rplaca(lc, init_val); return lc; } } static val ginterate_func(val env, val lcons) { - cons_bind (while_pred, gen_fun, env); - val next_item = funcall1(gen_fun, lcons->lc.car); + us_cons_bind (while_pred, gen_fun, env); + val next_item = funcall1(gen_fun, us_car(lcons)); if (funcall1(while_pred, next_item)) { - val lcons_next = make_lazy_cons(lcons_fun(lcons)); - rplacd(lcons, lcons_next); - rplaca(lcons_next, next_item); + val lcons_next = make_lazy_cons(us_lcons_fun(lcons)); + us_rplacd(lcons, lcons_next); + us_rplaca(lcons_next, next_item); } else { - rplacd(lcons, cons(next_item, nil)); + us_rplacd(lcons, cons(next_item, nil)); } return nil; } @@ -5652,18 +5652,18 @@ static val ginterate(val while_pred, val gen_fun, val init_val) static val expand_right_fun(val env, val lcons) { - cons_bind (pair, gen_fun, env); - cons_bind (elem, init_val, pair); + us_cons_bind (pair, gen_fun, env); + us_cons_bind (elem, init_val, pair); val next_pair = funcall1(gen_fun, init_val); - rplaca(lcons, elem); + us_rplaca(lcons, elem); if (next_pair) { - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); - rplaca(env, next_pair); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); + us_rplaca(env, next_pair); } else { - rplacd(lcons, nil); + us_rplacd(lcons, nil); } return nil; @@ -5714,31 +5714,31 @@ static val nexpand_left(val gen_fun, val init_val) static val repeat_infinite_func(val env, val lcons) { - if (!car(env)) - rplaca(env, cdr(env)); - rplaca(lcons, pop(valptr(car_l(env)))); - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + if (!us_car(env)) + us_rplaca(env, cdr(env)); + us_rplaca(lcons, pop(valptr(car_l(env)))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); return nil; } static val repeat_times_func(val env, val lcons) { - cons_bind (stack, list_count, env); - cons_bind (list, count, list_count); + us_cons_bind (stack, list_count, env); + us_cons_bind (list, count, list_count); if (!stack) { - rplaca(env, list); - rplacd(list_count, count = minus(count, one)); + us_rplaca(env, list); + us_rplacd(list_count, count = minus(count, one)); } - rplaca(lcons, pop(valptr(car_l(env)))); + us_rplaca(lcons, pop(valptr(car_l(env)))); if (!car(env) && count == one) { - rplacd(lcons, nil); + us_rplacd(lcons, nil); return nil; } - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); return nil; } @@ -5758,19 +5758,19 @@ static val repeat(val list, val count) static val pad_func(val env, val lcons) { - cons_bind (list, item_count, env); + us_cons_bind (list, item_count, env); val next = cdr(list); - rplaca(lcons, car(list)); + us_rplaca(lcons, car(list)); if (next && seqp(next)) { - rplaca(env, next); - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplaca(env, next); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); return nil; } else if (!next) { - val count = cdr(item_count); - rplacd(item_count, nil); - rplacd(lcons, repeat(item_count, count)); + val count = us_cdr(item_count); + us_rplacd(item_count, nil); + us_rplacd(lcons, repeat(item_count, count)); } else { uw_throwf(error_s, lit("pad: cannot pad improper list terminated by ~s"), next, nao); @@ -748,8 +748,8 @@ val conses(val list) static val lazy_conses_func(val env, val lcons) { - val fun = lcons_fun(lcons); - rplaca(lcons, env); + val fun = us_lcons_fun(lcons); + us_rplaca(lcons, env); func_set_env(fun, env = cdr(env)); if (env) @@ -1516,11 +1516,11 @@ static val lazy_appendv_func(val env, val lcons) cons_bind (fl, rl, env); cons_bind (fe, re, fl); - rplaca(lcons, fe); + us_rplaca(lcons, fe); if (re) { - rplaca(env, re); - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplaca(env, re); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); } else if (rl) { do { fl = car(rl); @@ -1529,11 +1529,11 @@ static val lazy_appendv_func(val env, val lcons) if (fl) { if (rl) { - rplaca(env, fl); - rplacd(env, rl); - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplaca(env, fl); + us_rplacd(env, rl); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); } else { - rplacd(lcons, fl); + us_rplacd(lcons, fl); } } } @@ -1974,8 +1974,8 @@ static val rem_lazy_rec(val obj, val list, val env, val func); static val rem_lazy_func(val env, val lcons) { cons_bind (pred, list, env); - val rest = rem_lazy_rec(pred, list, env, lcons_fun(lcons)); - rplacd(lcons, rem_lazy_rec(pred, list, env, lcons_fun(lcons))); + val rest = rem_lazy_rec(pred, list, env, us_lcons_fun(lcons)); + us_rplacd(lcons, rem_lazy_rec(pred, list, env, us_lcons_fun(lcons))); return rest; } @@ -2194,16 +2194,16 @@ static val lazy_flatten_scan(val list, val *escape) static val lazy_flatten_func(val env, val lcons) { - cons_bind (list, escape, env); + us_cons_bind (list, escape, env); val atom = car(list); val next = lazy_flatten_scan(cdr(list), &escape); - rplaca(lcons, atom); - rplaca(env, next); - rplacd(env, escape); + us_rplaca(lcons, atom); + us_rplaca(env, next); + us_rplacd(env, escape); if (next) - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); return nil; } @@ -2250,7 +2250,7 @@ static val lazy_flatcar_scan(val tree, val *cont) static val lazy_flatcar_func(val env, val lcons) { - val tree = car(env); + val tree = us_car(env); val cont = nil; val atom = lazy_flatcar_scan(tree, &cont); @@ -2258,7 +2258,7 @@ static val lazy_flatcar_func(val env, val lcons) rplaca(env, cont); if (cont) - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); return nil; } @@ -2282,8 +2282,8 @@ val lazy_flatcar(val tree) static val tuples_func(val env, val lcons) { list_collect_decl (out, ptail); - cons_bind (seq_in, envr, env); - cons_bind (n, fill, envr); + us_cons_bind (seq_in, envr, env); + us_cons_bind (n, fill, envr); val seq = seq_in; val count; @@ -2294,11 +2294,11 @@ static val tuples_func(val env, val lcons) for (; gt(count, zero); count = minus(count, one)) ptail = list_collect(ptail, fill); - rplaca(env, seq); + us_rplaca(env, seq); if (seq) - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); - rplaca(lcons, make_like(out, seq_in)); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); + us_rplaca(lcons, make_like(out, seq_in)); return nil; } @@ -2317,8 +2317,8 @@ val tuples(val n, val seq, val fill) static val partition_by_func(val env, val lcons) { list_collect_decl (out, ptail); - cons_bind (flast_seq, func, env); - cons_bind (flast, seq_in, flast_seq); + us_cons_bind (flast_seq, func, env); + us_cons_bind (flast, seq_in, flast_seq); val seq = seq_in; val fnext = nil; @@ -2337,13 +2337,13 @@ static val partition_by_func(val env, val lcons) flast = fnext; } - rplaca(flast_seq, fnext); - rplacd(flast_seq, seq); + us_rplaca(flast_seq, fnext); + us_rplacd(flast_seq, seq); if (seq) - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); - rplaca(lcons, make_like(out, seq_in)); + us_rplaca(lcons, make_like(out, seq_in)); return nil; } @@ -2361,8 +2361,8 @@ val partition_by(val func, val seq) static val partition_func(val env, val lcons) { - cons_bind (seq, indices_base, env); - cons_bind (indices, base, indices_base); + us_cons_bind (seq, indices_base, env); + us_cons_bind (indices, base, indices_base); val len = nil; for (;;) { @@ -2379,17 +2379,17 @@ static val partition_func(val env, val lcons) val first = sub(seq, zero, index_rebased); val rest = nullify(sub(seq, index_rebased, t)); - rplaca(env, rest); - rplaca(indices_base, indices); - rplacd(indices_base, index); + us_rplaca(env, rest); + us_rplaca(indices_base, indices); + us_rplacd(indices_base, index); if (rest) - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); - rplaca(lcons, first); + us_rplaca(lcons, first); } } else { - rplaca(lcons, seq); + us_rplaca(lcons, seq); } break; } @@ -2399,8 +2399,8 @@ static val partition_func(val env, val lcons) static val split_func(val env, val lcons) { - cons_bind (seq, indices_base, env); - cons_bind (indices, base, indices_base); + us_cons_bind (seq, indices_base, env); + us_cons_bind (indices, base, indices_base); val len = nil; for (;;) { @@ -2418,18 +2418,18 @@ static val split_func(val env, val lcons) val rsub = sub(seq, index_rebased, t); val rest = nullify(rsub); - rplaca(env, rest); - rplaca(indices_base, indices); - rplacd(indices_base, index); + us_rplaca(env, rest); + us_rplaca(indices_base, indices); + us_rplacd(indices_base, index); - rplacd(lcons, if3(rest, - make_lazy_cons(lcons_fun(lcons)), - cons(rsub, nil))); + us_rplacd(lcons, if3(rest, + make_lazy_cons(us_lcons_fun(lcons)), + cons(rsub, nil))); - rplaca(lcons, first); + us_rplaca(lcons, first); } } else { - rplaca(lcons, seq); + us_rplaca(lcons, seq); } break; } @@ -2439,8 +2439,8 @@ static val split_func(val env, val lcons) static val split_star_func(val env, val lcons) { - cons_bind (seq, indices_base, env); - cons_bind (indices, base, indices_base); + us_cons_bind (seq, indices_base, env); + us_cons_bind (indices, base, indices_base); val len = nil; for (;;) { @@ -2458,18 +2458,18 @@ static val split_star_func(val env, val lcons) val rsub = sub(seq, succ(index_rebased), t); val rest = nullify(rsub); - rplaca(env, rest); - rplaca(indices_base, indices); - rplacd(indices_base, succ(index)); + us_rplaca(env, rest); + us_rplaca(indices_base, indices); + us_rplacd(indices_base, succ(index)); - rplacd(lcons, if3(rest, - make_lazy_cons(lcons_fun(lcons)), - cons(rsub, nil))); + us_rplacd(lcons, if3(rest, + make_lazy_cons(us_lcons_fun(lcons)), + cons(rsub, nil))); - rplaca(lcons, first); + us_rplaca(lcons, first); } } else { - rplaca(lcons, seq); + us_rplaca(lcons, seq); } break; } @@ -2519,8 +2519,8 @@ static val partition_star_func(val env, val lcons) val len = nil; for (;;) { - cons_bind (seq, indices_base, env); - cons_bind (indices, base, indices_base); + us_cons_bind (seq, indices_base, env); + us_cons_bind (indices, base, indices_base); if (indices) { val raw_index = pop(&indices); @@ -2540,19 +2540,19 @@ static val partition_star_func(val env, val lcons) pop(&indices); } - rplaca(env, seq); - rplaca(indices_base, indices); - rplacd(indices_base, base); + us_rplaca(env, seq); + us_rplaca(indices_base, indices); + us_rplacd(indices_base, base); if (!first) continue; - rplaca(lcons, first); + us_rplaca(lcons, first); if (seq) - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); } else { - rplaca(lcons, seq); + us_rplaca(lcons, seq); } break; @@ -8543,16 +8543,16 @@ val window_mappend(val range, val boundary, val fun, val seq) static val lazy_interpose_func(val env, val lcons) { - cons_bind (sep, list, env); + us_cons_bind (sep, list, env); val next = cdr(list); - val fun = lcons_fun(lcons); + val fun = us_lcons_fun(lcons); - rplaca(lcons, car(list)); + us_rplaca(lcons, car(list)); if (next) { - rplacd(env, next); + us_rplacd(env, next); func_set_env(fun, env); - rplacd(lcons, cons(sep, make_lazy_cons(fun))); + us_rplacd(lcons, cons(sep, make_lazy_cons(fun))); } return nil; @@ -9800,16 +9800,16 @@ val ends_with(val little, val big, val testfun, val keyfun) static val take_list_fun(val env, val lcons) { - cons_bind (list, count, env); + us_cons_bind (list, count, env); - rplaca(lcons, pop(&list)); + us_rplaca(lcons, pop(&list)); if3(le((count = pred(count)), zero) || list == nil, - rplacd(lcons, nil), - rplacd(lcons, make_lazy_cons(lcons_fun(lcons)))); + us_rplacd(lcons, nil), + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons)))); - rplaca(env, list); - rplacd(env, count); + us_rplaca(env, list); + us_rplacd(env, count); return nil; } @@ -9835,17 +9835,17 @@ val take(val count, val seq) static val take_while_list_fun(val env, val lcons) { - cons_bind (list, cell, env); - cons_bind (pred, keyfun, cell); + us_cons_bind (list, cell, env); + us_cons_bind (pred, keyfun, cell); - rplaca(lcons, pop(&list)); + us_rplaca(lcons, pop(&list)); if (!list || !funcall1(pred, funcall1(keyfun, car(list)))) - rplacd(lcons, nil); + us_rplacd(lcons, nil); else - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); - rplaca(env, list); + us_rplaca(env, list); return nil; } @@ -9878,18 +9878,18 @@ val take_while(val pred, val seq, val keyfun) static val take_until_list_fun(val env, val lcons) { - cons_bind (list, cell, env); - cons_bind (pred, keyfun, cell); + us_cons_bind (list, cell, env); + us_cons_bind (pred, keyfun, cell); val item = pop(&list); - rplaca(lcons, item); + us_rplaca(lcons, item); if (!list || funcall1(pred, funcall1(keyfun, item))) - rplacd(lcons, nil); + us_rplacd(lcons, nil); else - rplacd(lcons, make_lazy_cons(lcons_fun(lcons))); + us_rplacd(lcons, make_lazy_cons(us_lcons_fun(lcons))); - rplaca(env, list); + us_rplaca(env, list); return nil; } @@ -10801,7 +10801,7 @@ static val lazy_where_hash_func(val hash_iter, val lcons) } { - val cell = make_lazy_cons(lcons_fun(lcons)); + val cell = make_lazy_cons(us_lcons_fun(lcons)); us_rplaca(cell, key); us_rplacd(cell, func); us_rplacd(lcons, cell); @@ -668,6 +668,7 @@ void rcyc_cons(val cons); void rcyc_list(val list); void rcyc_empty(void); val lcons_fun(val lcons); +INLINE val us_lcons_fun(val lcons) { return lcons->lc.func; } val list(val first, ...); /* terminated by nao */ val listv(struct args *); val consp(val obj); @@ -1225,6 +1226,11 @@ loc list_collect_revappend(loc ptail, val obj); obj_t *FROM = from(r_n_g ## FROM ## TO); \ obj_t *TO = ((r_n_g ## FROM ## TO)->rn.to) +#define us_cons_bind(CAR, CDR, CONS) \ + obj_t *c_o_n_s ## CAR ## CDR = CONS; \ + obj_t *CAR = us_car(c_o_n_s ## CAR ## CDR); \ + obj_t *CDR = us_cdr(c_o_n_s ## CAR ## CDR) + #define zero num_fast(0) #define one num_fast(1) #define two num_fast(2) |