/* _http_octs_to_bod(): translate octet-stream noun into body.
*/
static u3_hbod*
_http_octs_to_bod(u3_noun oct)
{
c3_w len_w;
if ( !_(u3a_is_cat(u3h(oct))) ) {
// 2GB max
u3m_bail(c3__fail); return 0;
}
len_w = u3h(oct);
{
u3_hbod* bod_u = c3_malloc(len_w + sizeof(*bod_u));
bod_u->len_w = len_w;
u3r_bytes(0, len_w, bod_u->hun_y, u3t(oct));
bod_u->nex_u = 0;
u3z(oct);
return bod_u;
}
}
u3_noun
u3wcp_ins(u3_noun cor)
{
u3_noun x, a, buf;
if ( (c3n == u3r_mean(cor, u3x_sam, &a, u3x_con_sam, &x, 0)) ||
(c3n == u3du(x)) ||
(c3n == u3ud(buf = u3h(x))) ||
(c3n == u3ud(a)) )
{
return u3m_bail(c3__exit);
} else {
return _po_find(buf, a);
}
}
/* u3n_slam_on(): produce (gat sam).
*/
u3_noun
u3n_slam_on(u3_noun gat, u3_noun sam)
{
u3_noun cor = u3nc(u3k(u3h(gat)), u3nc(sam, u3k(u3t(u3t(gat)))));
#if 0
if ( &u3H->rod_u == u3R ) {
if ( exc_w == 1 ) {
c3_assert(0);
}
exc_w++;
}
#endif
u3z(gat);
return u3n_kick_on(cor);
}
// compute lcs
//
static void
_loss(u3_loss* loc_u)
{
while ( u3_nul != loc_u->hel ) {
u3_noun i_hel = u3h(loc_u->hel);
u3_noun guy = u3kdb_get(u3k(loc_u->sev), u3k(i_hel));
if ( u3_none != guy ) {
u3_noun gay = u3kb_flop(guy);
_merg(loc_u, 0, gay);
u3z(gay);
}
loc_u->hel = u3t(loc_u->hel);
}
}
/* _n_mush_in(): see _n_mush().
*/
static u3_noun
_n_mush_in(u3_noun val)
{
if ( c3n == u3du(val) ) {
return u3_nul;
}
else {
u3_noun h_val = u3h(val);
u3_noun ite;
if ( c3n == u3ud(h_val) ) {
ite = u3nc(c3__leaf, u3_nul);
} else {
ite = u3nc(c3__leaf, u3qe_trip(h_val));
}
return u3nc(ite, _n_mush_in(u3t(val)));
}
}
static u3_noun
_sgcn_a(u3_noun r_gen,
u3_noun nob)
{
if ( c3n == u3du(r_gen) ) {
return u3k(nob);
} else {
u3_noun ir_gen = u3h(r_gen);
u3_noun tr_gen = u3t(r_gen);
u3_noun pir_gen, qir_gen;
u3x_cell(ir_gen, &pir_gen, &qir_gen);
return u3nc(u3nc(u3nt(c3__dtzz, u3_blip, u3k(pir_gen)),
u3nc(c3__zpts, u3k(qir_gen))),
_sgcn_a(tr_gen, nob));
}
}
// initialize loss object
//
static void
_lemp(u3_loss* loc_u,
u3_noun hel,
u3_noun hev)
{
loc_u->hel = hel;
loc_u->lel_w = u3kb_lent(u3k(hel));
// Read hev into array.
{
c3_w i_w;
loc_u->hev = c3_malloc(u3kb_lent(u3k(hev)) * sizeof(u3_noun));
for ( i_w = 0; u3_nul != hev; i_w++ ) {
loc_u->hev[i_w] = u3h(hev);
hev = u3t(hev);
}
loc_u->lev_w = i_w;
}
loc_u->kct_w = 0;
loc_u->kad = c3_malloc(
(1 + c3_min(loc_u->lev_w, loc_u->lel_w)) *
sizeof(u3_noun));
// Compute equivalence classes.
//
loc_u->sev = u3_nul;
{
c3_w i_w;
for ( i_w = 0; i_w < loc_u->lev_w; i_w++ ) {
u3_noun how = loc_u->hev[i_w];
u3_noun hav;
u3_noun teg;
hav = u3kdb_get(u3k(loc_u->sev), u3k(how));
teg = u3nc(u3i_words(1, &i_w),
(hav == u3_none) ? u3_nul : hav);
loc_u->sev = u3kdb_put(loc_u->sev, u3k(how), teg);
}
}
}
static u3_noun
_crop_sint(
u3_noun van,
u3_noun sut,
u3_noun ref,
u3_noun bix)
{
u3_noun p_ref, q_ref;
switch ( u3h(ref) ) {
default: return u3m_bail(c3__fail);
case c3__bull: u3x_cell(u3t(ref), &p_ref, &q_ref);
{
return _crop_dext(van, sut, q_ref, bix);
}
case c3__core:
case c3__cube: {
return u3k(sut);
}
case c3__face: u3x_cell(u3t(ref), &p_ref, &q_ref);
{
return _crop_dext(van, sut, q_ref, bix);
}
case c3__fork: u3x_cell(u3t(ref), &p_ref, &q_ref);
{
u3_noun hin = _crop_dext(van, sut, p_ref, bix);
u3_noun ret = _crop_dext(van, hin, q_ref, bix);
u3z(hin);
return ret;
}
case c3__hold: p_ref = u3t(ref);
{
u3_noun rep = u3qfu_repo(van, ref);
u3_noun ret = _crop_dext(van, sut, rep, bix);
u3z(rep);
return ret;
}
}
}
u3_noun
u3wcp_tos(u3_noun cor)
{
u3_noun x, a, buf;
if ( (c3n == u3r_mean(cor, u3x_sam, &a, u3x_con_sam, &x, 0)) ||
(c3n == u3du(x)) ||
(c3n == u3ud(buf = u3h(x))) ||
(c3n == u3ud(a)) ||
(a >= 256) )
{
return u3m_bail(c3__exit);
}
else {
c3_y byt_y[3];
u3r_bytes((a * 3), 3, byt_y, buf);
return (byt_y[0] | (byt_y[1] << 8) | (byt_y[2] << 16));
}
}
/* just
*/
u3_noun
_cqe_just_fun(u3_noun daf,
u3_noun tub)
{
u3_noun p_tub, q_tub;
u3x_cell(tub, &p_tub, &q_tub);
if ( c3n == u3du(q_tub) ) {
return _fail(tub);
}
else {
u3_noun iq_tub = u3h(q_tub);
if ( c3y == u3r_sing(daf, iq_tub) ) {
return _next(tub);
}
else return _fail(tub);
}
}
static u3_noun
_smcl_in(u3_noun q_gen)
{
u3_noun hq_gen = u3h(q_gen);
u3_noun tq_gen = u3t(q_gen);
if ( c3n == u3du(tq_gen) ) {
return u3nt(c3__tsgr,
u3nc(u3_nul, 3),
u3k(hq_gen));
} else {
return u3nc(c3__cnhp,
u3nq(u3nc(u3_nul, 2),
u3nt(c3__tsgr,
u3nc(u3_nul, 3),
u3k(hq_gen)),
_smcl_in(tq_gen),
u3_nul));
}
}
static u3_noun
_fish_fork(u3_noun van,
u3_noun p_sut,
u3_atom axe,
u3_noun vit)
{
if ( u3_nul == p_sut ) {
return u3nc(1, 1);
}
else {
u3_noun hed = _fish_in(van, u3h(p_sut), axe, vit);
u3_noun tal = _fish_fork(van, u3t(p_sut), axe, vit);
u3_noun pro = u3qf_flor(hed, tal);
u3z(hed);
u3z(tal);
return pro;
}
}
/* _sist_suck(): past failure.
*/
static void
_sist_suck(u3_noun ovo, u3_noun gon)
{
uL(fprintf(uH, "sing: ovum failed!\n"));
{
c3_c* hed_c = u3r_string(u3h(u3t(ovo)));
uL(fprintf(uH, "fail %s\n", hed_c));
free(hed_c);
}
u3_lo_punt(2, u3kb_flop(u3k(u3t(gon))));
// u3_loom_exit();
#if 1
u3_lo_exit();
exit(1);
#else
u3z(ovo); u3z(gon);
#endif
}
/* _unix_write_file_hard(): write to a file, overwriting what's there
*/
static c3_w
_unix_write_file_hard(c3_c* pax_c, u3_noun mim)
{
c3_i fid_i = open(pax_c, O_WRONLY | O_CREAT | O_TRUNC, 0666);
c3_w len_w, rit_w, siz_w, mug_w = 0;
c3_y* dat_y;
u3_noun dat = u3t(u3t(mim));
if ( fid_i < 0 ) {
uL(fprintf(uH, "error opening %s for writing: %s\r\n",
pax_c, strerror(errno)));
u3z(mim);
return 0;
}
siz_w = u3h(u3t(mim));
len_w = u3r_met(3, dat);
dat_y = c3_malloc(siz_w);
memset(dat_y, 0, siz_w);
u3r_bytes(0, len_w, dat_y, dat);
u3z(mim);
rit_w = write(fid_i, dat_y, siz_w);
if ( rit_w != siz_w ) {
uL(fprintf(uH, "error writing %s: %s\r\n",
pax_c, strerror(errno)));
mug_w = 0;
}
else {
mug_w = u3r_mug_bytes(dat_y, len_w);
}
close(fid_i);
free(dat_y);
return mug_w;
}
/** rake
**/
u3_noun
u3qfp_rake(u3_noun gen)
{
u3_noun p_gen, q_gen;
if ( c3y == u3ud(gen) ) {
return u3nc(u3k(gen), u3_nul);
}
else switch ( u3h(gen) ) {
default: return u3m_error("rake-twig");
case u3_nul: return u3nc(u3k(gen), u3_nul);
case c3__cnzy: {
return u3nc(u3k(u3t(gen)), u3_nul);
}
case c3__cnzz: {
return u3k(u3t(gen));
}
case c3__cnts: {
if ( c3n == u3r_cell(u3t(gen), &p_gen, &q_gen) ) {
return u3m_bail(c3__fail);
}
else {
if ( u3_nul != q_gen ) {
return u3m_bail(c3__fail);
}
else {
return u3k(p_gen);
}
}
}
case c3__zpcb: {
if ( c3n == u3r_cell(u3t(gen), &p_gen, &q_gen) ) {
return u3m_bail(c3__fail);
}
else return u3qfp_rake(q_gen);
}
}
}
/* functions
*/
u3_noun
u3qf_flip(
u3_noun hel)
{
if ( c3y == u3r_sing(1, u3h(hel)) ) {
if ( (c3y == u3t(hel)) ) {
return u3nc(1, c3n);
}
else {
c3_assert((c3n == u3t(hel)));
return u3nc(1, c3y);
}
}
else {
return u3nq
(6,
u3k(hel),
u3nc(1, c3n),
u3nc(1, c3y));
}
}
static u3_noun
_mint_cond(
u3_noun pex,
u3_noun yom,
u3_noun woq)
{
if ( 1 == u3h(pex) ) {
if ( 0 == u3t(pex) ) {
u3z(pex);
u3z(woq);
return yom;
}
else if ( 1 == u3t(pex) ) {
u3z(pex);
u3z(yom);
return woq;
}
}
return u3nq(6, pex, yom, woq);
}
/* functions
*/
u3_noun
u3qb_snag(u3_atom a,
u3_noun b)
{
if ( !_(u3a_is_cat(a)) ) {
return u3m_bail(c3__fail);
}
else {
c3_w len_w = a;
while ( len_w ) {
if ( c3n == u3du(b) ) {
return u3m_bail(c3__exit);
}
b = u3t(b);
len_w--;
}
if ( c3n == u3du(b) ) {
return u3m_bail(c3__exit);
}
return u3k(u3h(b));
}
}
static u3_noun
_next(u3_noun tub)
{
u3_noun p_tub, q_tub;
u3_noun zac;
u3x_cell(tub, &p_tub, &q_tub);
if ( c3n == u3du(q_tub) ) {
return _fail(tub);
}
else {
u3_noun iq_tub = u3h(q_tub);
u3_noun tq_tub = u3t(q_tub);
zac = _slip(iq_tub, p_tub);
return u3nc(zac,
u3nq(u3_nul,
u3k(iq_tub),
u3k(zac),
u3k(tq_tub)));
}
}
static u3_noun
_play_sand(u3_noun odo, u3_noun bob)
{
if ( c3y == u3ud(bob) ) {
if ( 'n' == odo ) {
if ( (bob != 0) ) {
return u3m_bail(c3__exit);
} else {
return u3nq(c3__atom, odo, u3_nul, bob);
}
}
if ( 'f' == odo ) {
if ( (bob > 1) ) {
return u3m_bail(c3__exit);
} else {
return _play_bean();
}
}
return u3nt(c3__atom, u3k(odo), u3_nul);
}
else return u3nt(c3__cell, _play_rock(odo, u3h(bob)),
_play_rock(odo, u3t(bob)));
}
/* u3_term_ef_blit(): send %blit list to specific terminal.
*/
void
u3_term_ef_blit(c3_l tid_l,
u3_noun bls)
{
u3_utty* uty_u = _term_ef_get(tid_l);
if ( 0 == uty_u ) {
// uL(fprintf(uH, "no terminal %d\n", tid_l));
// uL(fprintf(uH, "uty_u %p\n", u3_Host.uty_u));
u3z(bls); return;
}
{
u3_noun bis = bls;
while ( c3y == u3du(bis) ) {
_term_ef_blit(uty_u, u3k(u3h(bis)));
bis = u3t(bis);
}
u3z(bls);
}
}
/* _sist_sing(): replay ovum from the past, time already set.
*/
static void
_sist_sing(u3_noun ovo)
{
u3_noun gon = u3m_soft(0, u3v_poke, u3k(ovo));
if ( u3_blip != u3h(gon) ) {
_sist_suck(ovo, gon);
}
else {
u3_noun vir = u3k(u3h(u3t(gon)));
u3_noun cor = u3k(u3t(u3t(gon)));
u3_noun nug;
u3z(gon);
nug = u3v_nick(vir, cor);
if ( u3_blip != u3h(nug) ) {
_sist_suck(ovo, nug);
}
else {
vir = u3h(u3t(nug));
cor = u3k(u3t(u3t(nug)));
while ( u3_nul != vir ) {
u3_noun fex = u3h(vir);
u3_noun fav = u3t(fex);
if ( (c3__init == u3h(fav)) || (c3__inuk == u3h(fav)) ) {
u3A->own = u3nc(u3k(u3t(fav)), u3A->own);
}
vir = u3t(vir);
}
u3z(nug);
u3z(u3A->roc);
u3A->roc = cor;
}
u3z(ovo);
}
}
/* stew
*/
static u3_noun
_stew_wor(u3_noun ort,
u3_noun wan)
{
if ( !_(u3a_is_cat(ort)) ) {
return u3m_bail(c3__fail);
}
else {
if ( c3n == u3du(wan) ) {
if ( !_(u3a_is_cat(wan)) ) {
return u3m_bail(c3__fail);
}
else return (ort < wan) ? c3y : c3n;
}
else {
u3_noun h_wan = u3h(wan);
if ( !_(u3a_is_cat(h_wan)) ) {
return u3m_bail(c3__fail);
}
else return (ort < h_wan) ? c3y : c3n;
}
}
}
static u3_noun
_mint_grow(
u3_noun van,
u3_noun sut,
u3_noun gol,
u3_atom mel,
u3_noun ruf,
u3_noun dab)
{
u3_noun dan = _mint_in(van, sut, c3__noun, ruf);
u3_noun p_dan = u3h(dan);
u3_noun q_dan = u3t(dan);
u3_noun toc = _mint_core
(u3k(p_dan),
u3nt(c3__gold,
u3k(p_dan),
u3nc(u3_nul, u3k(dab))));
u3_noun dez = _mint_bake(van, toc, dab);
u3_noun zod = u3nc(1, dez);
u3_noun cot = _mint_core
(u3k(p_dan),
u3nt(mel,
u3k(p_dan),
u3nc(u3k(dez),
u3k(dab))));
u3_noun ret = u3nc
(
_mint_nice(van, gol, cot),
u3qf_cons(zod, q_dan));
u3z(zod);
u3z(toc);
u3z(dan);
return ret;
}
static void
_merg(u3_loss* loc_u,
c3_w inx_w,
u3_noun gay)
{
if ( (u3_nul == gay) || (inx_w > loc_u->kct_w) ) {
return;
}
else {
u3_noun i_gay = u3h(gay);
c3_w goy_w = u3r_word(0, i_gay);
u3_noun bik;
bik = _bink(loc_u, &inx_w, loc_u->kct_w, goy_w);
if ( c3y == bik ) {
_merg(loc_u, inx_w + 1, u3t(gay));
_lune(loc_u, inx_w, goy_w);
}
else {
_merg(loc_u, inx_w, u3t(gay));
}
}
}
/* functions
*/
u3_noun
u3qdb_put(u3_noun a,
u3_noun b,
u3_noun c)
{
if ( u3_nul == a ) {
return u3nt(
u3nc(u3k(b),
u3k(c)),
u3_nul,
u3_nul);
}
else {
u3_noun l_a, n_a, r_a, pn_a, qn_a;
u3_noun d, l_d, n_d, r_d;
if ( (c3n == u3r_trel(a, &n_a, &l_a, &r_a)) ||
(c3n == u3r_cell(n_a, &pn_a, &qn_a)) )
{
return u3m_bail(c3__exit);
}
else if ( c3y == u3r_sing(pn_a, b) ) {
if ( c3y == u3r_sing(qn_a, c) ) {
return u3k(a);
} else {
return u3nt
(u3nc(u3k(b), u3k(c)),
u3k(l_a),
u3k(r_a));
}
}
else {
if ( c3y == u3qc_gor(b, pn_a) ) {
d = u3qdb_put(l_a, b, c);
if ( c3y == u3qc_vor(pn_a, u3h(u3h(d))) ) {
return u3nt(u3k(n_a),
d,
u3k(r_a));
}
else {
u3r_trel(d, &n_d, &l_d, &r_d);
{
u3_noun e = u3nt
(u3k(n_d),
u3k(l_d),
u3nt(u3k(n_a),
u3k(r_d),
u3k(r_a)));
u3z(d);
return e;
}
}
}
else {
d = u3qdb_put(r_a, b, c);
if ( c3y == u3qc_vor(pn_a, u3h(u3h(d))) ) {
return u3nt(u3k(n_a),
u3k(l_a),
d);
}
else {
u3r_trel(d, &n_d, &l_d, &r_d);
{
u3_noun e = u3nt
(u3k(n_d),
u3nt(u3k(n_a),
u3k(l_a),
u3k(l_d)),
u3k(r_d));
u3z(d);
return e;
}
}
}
}
}
}
/* _n_hint(): process hint.
*/
static u3_noun
_n_hint(u3_noun zep,
u3_noun hod,
u3_noun bus,
u3_noun nex)
{
switch ( zep ) {
default: {
// u3m_p("weird zep", zep);
u3a_lose(zep);
u3a_lose(hod);
return _n_nock_on(bus, nex);
}
case c3__hunk:
case c3__lose:
case c3__mean:
case c3__spot: {
u3_noun tac = u3nc(zep, hod);
u3_noun pro;
u3t_push(tac);
#if 0
{
static int low_i;
if ( !low_i ) {
low_i = 1;
if ( 0 == (u3R->pro.nox_d % 65536ULL) ) {
if ( c3__spot == zep ) {
uL(fprintf(uH, "spot %d/%d : %d/%d\r\n",
u3h(u3h(u3t(hod))),
u3t(u3h(u3t(hod))),
u3h(u3t(u3t(hod))),
u3t(u3t(u3t(hod)))));
}
}
low_i = 0;
}
}
#endif
pro = _n_nock_on(bus, nex);
u3t_drop();
return pro;
}
case c3__live: {
if ( c3y == u3ud(hod) ) {
u3t_off(noc_o);
u3t_heck(hod);
u3t_on(noc_o);
} else {
u3z(hod);
}
return _n_nock_on(bus, nex);
}
case c3__slog: {
if ( !(u3C.wag_w & u3o_quiet) ) {
u3t_off(noc_o);
u3t_slog(hod);
u3t_on(noc_o);
}
return _n_nock_on(bus, nex);
}
case c3__germ: {
u3_noun pro = _n_nock_on(bus, nex);
if ( c3y == u3r_sing(pro, hod) ) {
u3z(pro); return hod;
} else {
u3z(hod); return pro;
}
}
case c3__fast: {
u3_noun pro = _n_nock_on(bus, nex);
u3t_off(noc_o);
u3j_mine(hod, u3k(pro));
u3t_on(noc_o);
return pro;
}
case c3__memo: {
u3z(hod);
#if 0
return _n_nock_on(bus, nex);
#else
{
u3_noun pro = u3z_find_2(c3__nock, bus, nex);
if ( pro != u3_none ) {
u3z(bus); u3z(nex);
return pro;
}
pro = _n_nock_on(u3k(bus), u3k(nex));
if ( &(u3H->rod_u) != u3R ) {
u3z_save_2(c3__nock, bus, nex, pro);
}
u3z(bus); u3z(nex);
return pro;
}
#endif
}
case c3__sole: {
u3z(hod);
{
u3_noun pro = _n_nock_on(bus, nex);
// return u3z_uniq(pro);
return pro;
}
}
}
}
static u3_noun
_play_in(u3_noun van,
u3_noun sut,
u3_noun gen)
{
u3_noun p_gen, q_gen, r_gen;
if ( c3n == u3du(gen) ) {
open: {
u3_noun ter = u3r_at(u3x_con_3, van);
u3_noun rex = u3qfp_open(ter, gen);
u3_noun ret;
if ( c3y == u3r_sing(rex, gen) ) {
u3_noun zix = u3qfu_shep(van, "gene", 'q', u3k(gen));
u3t_push(u3nc(c3__mean, zix));
return u3m_error("play-open");
}
ret = _play_x(van, sut, rex);
u3z(rex);
return ret;
}
}
else if ( c3y == u3du(u3h(gen)) ) {
_play_used();
{
u3_noun dis = _play_x(van, sut, u3h(gen));
u3_noun dat = _play_x(van, sut, u3t(gen));
u3_noun ret = u3qf_cell(dis, dat);
u3z(dis);
u3z(dat);
return ret;
}
}
else switch ( u3h(gen) ) {
default: goto open;
case c3__bcpt: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun sep = u3qfu_seep(van, sut, c3__read, p_gen);
u3_noun axe = u3h(sep);
u3_noun rex = u3qfl_whip(van, q_gen, axe);
u3_noun ret = _play_x(van, sut, rex);
u3z(sep);
u3z(rex);
return ret;
}
case c3__wtts: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
return _play_bean();
}
case c3__wtcl: u3x_trel(u3t(gen), &p_gen, &q_gen, &r_gen);
_play_used();
{
u3_noun fex = u3qfu_gain(van, sut, p_gen);
u3_noun wux = u3qfu_lose(van, sut, p_gen);
u3_noun dez = (fex == c3__void) ? c3__void
: _play_x(van, fex, q_gen);
u3_noun doz = (wux == c3__void) ? c3__void
: _play_x(van, wux, r_gen);
u3_noun ret = u3qf_fork(dez, doz);
u3z(dez); u3z(doz);
u3z(fex); u3z(wux);
return ret;
}
case c3__clhp: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun dis = _play_x(van, sut, p_gen);
u3_noun dat = _play_x(van, sut, q_gen);
u3_noun ret = u3qf_cell(dis, dat);
u3z(dis);
u3z(dat);
return ret;
}
case c3__dtkt: p_gen = u3t(gen);
_play_used();
{
return c3__noun;
}
case c3__dtwt: p_gen = u3t(gen);
_play_used();
{
return _play_bean();
}
case c3__dtts: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
return _play_bean();
}
case c3__dtls: p_gen = u3t(gen);
_play_used();
{
return u3nc(c3__atom, u3_blip);
}
case c3__dtzz: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun boc = (c3n == u3ud(q_gen))
? c3__noun
: u3nc(c3__atom, u3k(p_gen));
u3_noun ret = u3qf_cube(q_gen, boc);
u3z(boc);
return ret;
}
case c3__dttr: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
return c3__noun;
}
case c3__dtzy: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
if ( 'f' == p_gen ) {
if ( (q_gen > 1) ) {
return u3m_bail(c3__exit);
} else {
return _play_bean();
}
}
else return u3nc(c3__atom, u3k(p_gen));
}
case c3__ktbr: p_gen = u3t(gen);
_play_used();
{
u3_noun boc = _play_x(van, sut, p_gen);
u3_noun pro = u3qfu_wrap(van, boc, c3__iron);
u3z(boc);
return pro;
}
case c3__ktpm: p_gen = u3t(gen);
_play_used();
{
u3_noun boc = _play_x(van, sut, p_gen);
u3_noun pro = u3qfu_wrap(van, boc, c3__zinc);
u3z(boc);
return pro;
}
case c3__ktwt: p_gen = u3t(gen);
_play_used();
{
u3_noun boc = _play_x(van, sut, p_gen);
u3_noun pro = u3qfu_wrap(van, boc, c3__lead);
u3z(boc);
return pro;
}
case c3__ktts: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun boc = _play_x(van, sut, q_gen);
u3_noun ret = u3qfu_conk(van, boc, p_gen);
u3z(boc);
return ret;
}
case c3__ktzp: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun boc = _play_x(van, sut, q_gen);
u3_noun ret = u3qfu_conk(van, boc, p_gen);
u3z(boc);
return ret;
}
case c3__ktsg: p_gen = u3t(gen);
_play_used();
{
return _play_x(van, sut, p_gen);
}
case c3__kthx: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
return _play_x(van, sut, p_gen);
}
case c3__ktls: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
return _play_x(van, sut, p_gen);
}
case c3__tsgr: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun boc = _play_x(van, sut, p_gen);
u3_noun ret = _play_x(van, boc, q_gen);
u3z(boc);
return ret;
}
case c3__tstr: u3x_trel(u3t(gen), &p_gen, &q_gen, &r_gen);
_play_used();
{
u3_noun sep = u3qfu_seep(van, sut, c3__both, q_gen);
u3_noun bid = u3nt(u3k(p_gen), u3k(q_gen), sep);
u3_noun boc = u3qf_bull(bid, sut);
u3_noun ret = _play_x(van, boc, r_gen);
u3z(bid);
u3z(boc);
return ret;
}
case c3__cnts: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun sec = u3qfu_seek(van, sut, c3__read, p_gen);
u3_noun lar = _play_foil(sec);
u3_noun q_lar = u3t(lar);
u3_noun qq_lar = u3t(q_lar);
u3_noun mew = u3qfu_snub(van, sut, q_gen);
u3_noun rag = _play_edit(van, sut, mew, u3k(qq_lar));
u3_noun ret = u3qfu_fire(van, sut, rag);
u3z(rag);
u3z(mew);
u3z(lar);
return ret;
}
case c3__pmcl: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun ruf = u3nt(c3__clhp,
u3nc(u3_nul, 1),
u3k(p_gen));
u3_noun ret = _play_grow(van, sut, c3__zinc, ruf, q_gen);
u3z(ruf);
return ret;
}
case c3__brcn: p_gen = u3t(gen);
_play_used();
{
u3_noun ruf = u3nc(u3_nul, 1);
u3_noun ret = _play_grow(van, sut, c3__gold, ruf, p_gen);
u3z(ruf);
return ret;
}
case c3__pmcn: p_gen = u3t(gen);
_play_used();
{
u3_noun ruf = u3nc(u3_nul, 1);
u3_noun ret = _play_grow(van, sut, c3__lead, ruf, p_gen);
u3z(ruf);
return ret;
}
case c3__pmls: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun ruf = u3nt(c3__clhp,
u3nc(u3_nul, 1),
u3k(p_gen));
u3_noun ret = _play_grow(van, sut, c3__iron, ruf, q_gen);
u3z(ruf);
return ret;
}
case c3__sgzp: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun typ = u3qfu_play(van, sut, p_gen);
u3_noun dug = u3qfu_duck(van, typ);
u3_noun ret;
u3t_push(u3nc(c3__mean, dug));
{
ret = _play_x(van, sut, q_gen);
}
u3t_drop();
u3z(typ);
return ret;
}
case c3__sggr: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
return _play_x(van, sut, q_gen);
}
case c3__zpts: p_gen = u3t(gen);
_play_used();
{
return c3__noun;
}
case c3__zpcm: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
return _play_x(van, sut, p_gen);
}
case c3__zpcb: u3x_cell(u3t(gen), &p_gen, &q_gen);
{
u3_noun ret;
u3t_push(u3nc(c3__mean, _play_loc(van, p_gen)));
{
ret = _play_x(van, sut, q_gen);
}
u3t_drop();
return ret;
}
case c3__zpcn:
_play_used();
{
u3_noun pet = u3j_hook(u3k(van), "seed");
u3_noun ret = u3k(u3h(pet));
u3z(pet);
return ret;
}
case c3__zpsm: u3x_cell(u3t(gen), &p_gen, &q_gen);
_play_used();
{
u3_noun zur = _play_x(van, sut, p_gen);
u3_noun vos = _play_x(van, sut, q_gen);
u3_noun ret = u3qf_cell(zur, vos);
u3z(zur);
u3z(vos);
return ret;
}
case c3__zpfs:
case c3__zpzp:
_play_used();
{
return c3__void;
}
}
}
/* _n_nock_on(): produce .*(bus fol). Do not virtualize.
*/
static u3_noun
_n_nock_on(u3_noun bus, u3_noun fol)
{
u3_noun hib, gal;
while ( 1 ) {
hib = u3h(fol);
gal = u3t(fol);
u3R->pro.nox_d += 1;
if ( c3y == u3r_du(hib) ) {
u3_noun poz, riv;
poz = _n_nock_on(u3k(bus), u3k(hib));
riv = _n_nock_on(bus, u3k(gal));
u3a_lose(fol);
return u3i_cell(poz, riv);
}
else switch ( hib ) {
default: return u3m_bail(c3__exit);
case 0: {
if ( c3n == u3r_ud(gal) ) {
return u3m_bail(c3__exit);
}
else {
u3_noun pro = u3k(u3at(gal, bus));
u3a_lose(bus); u3a_lose(fol);
return pro;
}
}
c3_assert(!"not reached");
case 1: {
u3_noun pro = u3k(gal);
u3a_lose(bus); u3a_lose(fol);
return pro;
}
c3_assert(!"not reached");
case 2: {
u3_noun nex = _n_nock_on(u3k(bus), u3k(u3t(gal)));
u3_noun seb = _n_nock_on(bus, u3k(u3h(gal)));
u3a_lose(fol);
bus = seb;
fol = nex;
continue;
}
c3_assert(!"not reached");
case 3: {
u3_noun gof, pro;
gof = _n_nock_on(bus, u3k(gal));
pro = u3r_du(gof);
u3a_lose(gof); u3a_lose(fol);
return pro;
}
c3_assert(!"not reached");
case 4: {
u3_noun gof, pro;
gof = _n_nock_on(bus, u3k(gal));
pro = u3i_vint(gof);
u3a_lose(fol);
return pro;
}
c3_assert(!"not reached");
case 5: {
u3_noun wim = _n_nock_on(bus, u3k(gal));
u3_noun pro = u3r_sing(u3h(wim), u3t(wim));
u3a_lose(wim); u3a_lose(fol);
return pro;
}
c3_assert(!"not reached");
case 6: {
u3_noun b_gal, c_gal, d_gal;
u3x_trel(gal, &b_gal, &c_gal, &d_gal);
{
u3_noun tys = _n_nock_on(u3k(bus), u3k(b_gal));
u3_noun nex;
if ( 0 == tys ) {
nex = u3k(c_gal);
} else if ( 1 == tys ) {
nex = u3k(d_gal);
} else return u3m_bail(c3__exit);
u3a_lose(fol);
fol = nex;
continue;
}
}
c3_assert(!"not reached");
case 7: {
u3_noun b_gal, c_gal;
u3x_cell(gal, &b_gal, &c_gal);
{
u3_noun bod = _n_nock_on(bus, u3k(b_gal));
u3_noun nex = u3k(c_gal);
u3a_lose(fol);
bus = bod;
fol = nex;
continue;
}
}
c3_assert(!"not reached");
case 8: {
u3_noun b_gal, c_gal;
u3x_cell(gal, &b_gal, &c_gal);
{
u3_noun heb = _n_nock_on(u3k(bus), u3k(b_gal));
u3_noun bod = u3nc(heb, bus);
u3_noun nex = u3k(c_gal);
u3a_lose(fol);
bus = bod;
fol = nex;
continue;
}
}
c3_assert(!"not reached");
case 9: {
u3_noun b_gal, c_gal;
u3x_cell(gal, &b_gal, &c_gal);
{
u3_noun seb = _n_nock_on(bus, u3k(c_gal));
u3_noun pro;
u3t_off(noc_o);
pro = u3j_kick(seb, b_gal);
u3t_on(noc_o);
if ( u3_none != pro ) {
u3a_lose(fol);
return pro;
}
else {
if ( c3n == u3r_ud(b_gal) ) {
return u3m_bail(c3__exit);
}
else {
u3_noun nex = u3k(u3at(b_gal, seb));
u3a_lose(fol);
bus = seb;
fol = nex;
continue;
}
}
}
}
c3_assert(!"not reached");
case 10: {
u3_noun p_gal, q_gal;
u3x_cell(gal, &p_gal, &q_gal);
{
u3_noun zep, hod, nex;
if ( c3y == u3r_du(p_gal) ) {
u3_noun b_gal = u3h(p_gal);
u3_noun c_gal = u3t(p_gal);
u3_noun d_gal = q_gal;
zep = u3k(b_gal);
hod = _n_nock_on(u3k(bus), u3k(c_gal));
nex = u3k(d_gal);
}
else {
u3_noun b_gal = p_gal;
u3_noun c_gal = q_gal;
zep = u3k(b_gal);
hod = u3_nul;
nex = u3k(c_gal);
}
u3a_lose(fol);
return _n_hint(zep, hod, bus, nex);
}
}
case 11: {
u3_noun ref = _n_nock_on(u3k(bus), u3k(u3h(gal)));
u3_noun gof = _n_nock_on(bus, u3k(u3t(gal)));
u3_noun val;
u3t_off(noc_o);
val = u3m_soft_esc(ref, u3k(gof));
u3t_on(noc_o);
if ( !_(u3du(val)) ) {
u3m_bail(u3nt(1, gof, 0));
}
if ( !_(u3du(u3t(val))) ) {
//
// replace with proper error stack push
//
u3t_push(u3nc(c3__hunk, _n_mush(gof)));
return u3m_bail(c3__exit);
}
else {
u3_noun pro;
u3z(gof);
u3z(fol);
pro = u3k(u3t(u3t(val)));
u3z(val);
return pro;
}
}
c3_assert(!"not reached");
}
}
}
/* _term_ef_blit(): send blit to terminal.
*/
static void
_term_ef_blit(u3_utty* uty_u,
u3_noun blt)
{
switch ( u3h(blt) ) {
default: break;
case c3__bel: {
if ( c3n == u3_Host.ops_u.dem ) {
_term_it_write_txt(uty_u, uty_u->ufo_u.out.bel_y);
}
} break;
case c3__clr: {
if ( c3n == u3_Host.ops_u.dem ) {
_term_it_show_blank(uty_u);
_term_it_refresh_line(uty_u);
}
} break;
case c3__hop: {
if ( c3n == u3_Host.ops_u.dem ) {
_term_it_show_cursor(uty_u, u3t(blt));
}
} break;
case c3__lin: {
u3_noun lin = u3t(blt);
c3_w len_w = u3kb_lent(u3k(lin));
c3_w* lin_w = c3_malloc(4 * len_w);
{
c3_w i_w;
for ( i_w = 0; u3_nul != lin; i_w++, lin = u3t(lin) ) {
lin_w[i_w] = u3r_word(0, u3h(lin));
}
}
if ( c3n == u3_Host.ops_u.dem ) {
_term_it_show_clear(uty_u);
_term_it_show_line(uty_u, lin_w, len_w);
} else {
_term_it_show_line(uty_u, lin_w, len_w);
}
} break;
case c3__mor: {
_term_it_show_more(uty_u);
} break;
case c3__sav: {
_term_it_save(u3k(u3h(u3t(blt))), u3k(u3t(u3t(blt))));
} break;
case c3__sag: {
u3_noun pib = u3k(u3t(u3t(blt)));
u3_noun jam;
fprintf(stderr, "jamming...\r\n");
jam = u3ke_jam(pib);
fprintf(stderr, "jammed.\r\n");
_term_it_save(u3k(u3h(u3t(blt))), jam);
} break;
}
u3z(blt);
return;
}