/* u2_bx_spot(): declare source position. */ void u2_bx_spot(u2_ray wir_r, u2_noun hod) // transfer { u2_ray bex_r, bas_r; if ( (0 == (bex_r = u2_wire_bex_r(wir_r))) || (0 == (bas_r = u2_wire_bas_r(wir_r))) ) { u2_rl_lose(wir_r, hod); return; } else { u2_noun sud = u2_rl_take(bas_r, hod); u2_rl_lose(wir_r, hod); if ( u2_none == sud ) { return; } else { u2_rl_lose(wir_r, u2_benx_at(bex_r, zat)); u2_benx_at(bex_r, zat) = sud; } } }
/* u2_sh_look(): ** ** Produce hook formula from core, or u2_none. */ u2_weak u2_sh_look(u2_wire wir_r, u2_noun cor, const c3_c* tam_c) { u2_ray bas_r = u2_wire_bas_r(wir_r); u2_noun bat = u2_t(cor); u2_noun fol; if ( u2_none != (fol = u2_ch_find_mixt(u2_bask_hag_r(bas_r), tam_c, bat)) ) { return fol; } else { u2_noun xip = u2_sh_find(wir_r, cor); if ( u2_none == xip ) { return u2_none; } else { u2_axis axe_w = _1; while ( 1 ) { fol = u2_sh_cook(wir_r, xip, tam_c); if ( u2_none == fol ) { u2_noun pet = u2_t(u2_t(xip)); if ( _0 == pet ) { return u2_none; } else { u2_axis pax = u2_h(pet); c3_assert(u2_fly_is_cat(pax)); c3_assert((u2_ax_dep(axe_w) + u2_ax_dep(pax)) <= 30); axe_w = u2_ax_peg(axe_w, pax); xip = u2_t(pet); continue; } } else { fol = u2_rl_take(bas_r, fol); if ( _1 != axe_w ) { /* XX: suboptimal; use comb:lily. */ fol = u2_rt(bas_r, u2_nock_flac, u2_rc(bas_r, u2_nock_frag, axe_w), fol); } fol = u2_ch_save_mixt(bas_r, u2_bask_hag_r(bas_r), tam_c, bat, fol); return fol; } } } } }
/* u2_cm_bury(): store fresh or volatile noun `som` to freezer. */ u2_weak u2_cm_bury(u2_weak som) { if ( u2_none == som ) return som; if ( u2_no == u2_rl_junior(u2_wire_bas_r(u2_Wire), som) ) { return som; } else { u2_noun pro = u2_rl_take(u2_wire_bas_r(u2_Wire), som); u2_cz(som); return pro; } }
/* hill_boot(): create the hill engine. */ struct hill_state* // produce hill_boot(void) { struct hill_state* hil_h = malloc(sizeof(struct hill_state)); u2_ray wir_r; u2_boot(); wir_r = u2_wr_init(c3__rock, u2_ray_of(0, 0), u2_ray_of(1, 0)); Hill = hil_h; Hill->wir_r = wir_r; Hill->soa = u2_none; Hill->sob = u2_none; Hill->soc = u2_none; /* Mint the shoes. Impeccable memory practices. */ { u2_noun soa = u2_none; u2_noun sob = u2_none; u2_noun soc = u2_none; do { /* Boot shoe A. */ if ( u2_no == u2_rl_leap(wir_r, c3__rock) ) { c3_assert(0); } u2_bx_boot(wir_r); { u2_ray kit_r = u2_bl_open(wir_r); if ( u2_bl_set(wir_r) ) { u2_bl_done(wir_r, kit_r); u2_rl_fall(wir_r); fprintf(stderr, "{no boot, a}\n"); break; } else { soa = _hill_z_boot(wir_r, FileA); u2_bl_done(wir_r, kit_r); u2_bx_spot(wir_r, u2_nul); u2_bx_show(wir_r); } } fprintf(stderr, "{cold boot: %s, with %s jets: %x}\n", FileA, FileZ, u2_mug(soa)); Hill->soa = u2_rl_take(u2_wire_bas_r(wir_r), soa); u2_rl_fall(wir_r); /* Boot shoe B. */ if ( u2_no == u2_rl_leap(wir_r, c3__rock) ) { c3_assert(0); } u2_bx_boot(wir_r); { u2_ray kit_r = u2_bl_open(wir_r); if ( u2_bl_set(wir_r) ) { u2_bl_done(wir_r, kit_r); u2_rl_fall(wir_r); fprintf(stderr, "{no boot, b}\n"); break; } else { sob = _hill_a_boot(wir_r, soa, FileB); u2_bl_done(wir_r, kit_r); u2_bx_spot(wir_r, u2_nul); u2_bx_show(wir_r); } } fprintf(stderr, "{warm boot: %s, with %s: %x}\n", FileB, FileA, u2_mug(sob)); Hill->sob = u2_rl_take(u2_wire_bas_r(wir_r), sob); u2_rl_fall(wir_r); /* Boot shoe C. */ if ( u2_no == u2_rl_leap(wir_r, c3__rock) ) { c3_assert(0); } u2_bx_boot(wir_r); { u2_ray kit_r = u2_bl_open(wir_r); if ( u2_bl_set(wir_r) ) { u2_bl_done(wir_r, kit_r); u2_rl_fall(wir_r); fprintf(stderr, "{no boot, c}\n"); u2_bx_show(wir_r); break; } else { soc = _hill_b_eyre(wir_r, soa, sob, FileC); u2_bl_done(wir_r, kit_r); u2_bx_spot(wir_r, u2_nul); u2_bx_show(wir_r); } } fprintf(stderr, "{last boot: %s, with %s: %x}\n", FileC, FileB, u2_mug(soc)); Hill->soc = u2_rl_take(u2_wire_bas_r(wir_r), soc); u2_rl_fall(wir_r); /* Testing basics of soc. */ printf("testing eyre...\n"); { u2_noun foo = u2_rl_string(wir_r, "|!(a=@ (dec a))"); u2_noun bar = u2_nk_nock(wir_r, foo, Hill->soc); if ( u2_none == bar ) { printf("no bar\n"); } else { u2_noun moo = u2_nk_nock(wir_r, _0, bar); if ( u2_none == moo ) { printf("no moo\n"); } else { u2_noun zor = u2_nk_mung(wir_r, moo, 13); u2_err(wir_r, "zor", zor); } } } printf("tested.\n"); #if 1 { u2_noun soa = Hill->soa; u2_noun sob = Hill->sob; u2_noun dat = Hill->soc; u2_noun pak, bag; fprintf(stderr, "jam test: jam\n"); u2_bx_boot(wir_r); pak = _hill_b_jam(wir_r, soa, sob, dat); u2_bx_show(wir_r); fprintf(stderr, "jam test: %d bits\n", u2_met(0, pak)); u2_ux_write(wir_r, pak, "watt/264", "noun"); fprintf(stderr, "jam test: cue\n"); u2_bx_boot(wir_r); bag = _hill_b_cue(wir_r, soa, sob, pak); u2_bx_show(wir_r); if ( u2_yes == u2_sing(bag, dat) ) { fprintf(stderr, "jam test: match\n"); } else { fprintf(stderr, "jam test: NO MATCH\n"); } } #endif return Hill; } while (0); free(Hill); return 0; } }
/* u2_lo_soft(): standard soft wrapper. unifies unix and nock errors. ** ** Produces [%$ result] or [%error (list tank)]. */ u2_noun u2_lo_soft(u2_reck* rec_u, c3_w sec_w, u2_funk fun_f, u2_noun arg) { u2_noun hoe, pro, rop; u2_rl_leap(u2_Wire, c3__rock); // system level setjmp, for signals // c3_assert(u2_nul == u2_wire_tax(u2_Wire)); c3_assert(0 == u2_wire_kit_r(u2_Wire)); // stop signals // u2_unix_ef_hold(); _lo_signal_deep(sec_w); if ( 0 != sigsetjmp(Signal_buf, 1) ) { u2_noun tax, pre, mok; // return to blank state // _lo_signal_done(); // acquire trace and reset memory // tax = u2_wire_tax(u2_Wire); u2_rl_fall(u2_Wire); u2z(arg); tax = u2_rl_take(u2_Wire, tax); u2_wire_tax(u2_Wire) = u2_nul; mok = u2_dc("mook", 2, tax); // other ugly disgusting cleanups { u2_wire_kit_r(u2_Wire) = 0; u2_hevx_be(u2_wire_hev_r(u2_Wire), u2_pryr, god) = 0; u2_hevx_at(u2_wire_hev_r(u2_Wire), lad) = 0; } switch ( Sigcause ) { default: pre = c3__wyrd; break; case sig_none: pre = c3__none; break; case sig_overflow: pre = c3__over; break; case sig_interrupt: pre = c3__intr; break; case sig_terminate: pre = c3__term; break; case sig_memory: pre = c3__full; break; case sig_assert: pre = c3__lame; break; case sig_timer: fprintf(stderr, "timer!!\r\n"); pre = c3__slow; break; } rop = u2nc(pre, u2k(u2t(mok))); u2z(mok); fprintf(stderr, "error computed\r\n"); return rop; } if ( 0 != (hoe = u2_cm_trap()) ) { u2_noun mok; u2_rl_fall(u2_Wire); hoe = u2_rl_take(u2_Wire, hoe); u2_rl_flog(u2_Wire); mok = u2_dc("mook", 2, u2k(u2t(hoe))); rop = u2nc(u2k(u2h(hoe)), u2k(u2t(mok))); u2z(arg); u2z(hoe); u2z(mok); } else { u2_noun pro = fun_f(rec_u, arg); _lo_signal_done(); u2_cm_done(); u2_rl_fall(u2_Wire); pro = u2_rl_take(u2_Wire, pro); u2_rl_flog(u2_Wire); u2z(arg); rop = u2nc(u2_blip, pro); } pro = rop; return pro; }
/* _nock_hint(): hint with code, data, subject, formula. nock/mink. */ static u2_noun // produce _nock_hint(u2_noun zep, // transfer u2_noun hod, // transfer u2_noun bus, // transfer u2_noun nex, // transfer u2_bean* pon) { u2_noun pro; switch ( zep ) { default: u2z(zep); u2z(hod); return pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); case c3__lose: case c3__yelp: case c3__bean: case c3__mean: case c3__spot: { u2_noun tax = u2_wire_tax(u2_Wire); u2_noun tac = u2nc(zep, hod); #if 0 if ( c3__spot == zep ) { printf("spot %d/%d : %d/%d\n", u2h(u2h(u2t(hod))), u2t(u2h(u2t(hod))), u2h(u2t(u2t(hod))), u2t(u2t(u2t(hod)))); } #endif u2_wire_tax(u2_Wire) = u2nc(tac, tax); { pro = pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); } tax = u2k(tax); u2z(u2_wire_tax(u2_Wire)); u2_wire_tax(u2_Wire) = tax; return pro; } case c3__slog: { u2_tx_sys_bit(u2_Wire, u2_yes); u2_tx_slog(u2_Wire, hod); u2_tx_sys_bit(u2_Wire, u2_no); u2z(hod); return pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); } case c3__mine: { pro = pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); if ( !pon || (u2_no != *pon) ) { u2_tx_sys_bit(u2_Wire, u2_yes); pro = u2_ds_mine(u2_Wire, hod, pro); u2_tx_sys_bit(u2_Wire, u2_no); } u2z(hod); return pro; } case c3__germ: { pro = pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); if ( u2_yes == u2_sing(pro, hod) ) { u2z(pro); return hod; } else { u2z(hod); return pro; } } case c3__fast: { pro = pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); if ( !pon || (u2_no != *pon) ) { u2_noun p_hod, q_hod, r_hod; /* XX: translate hod to old clue form. */ if ( u2_no == u2_as_trel(hod, &p_hod, &q_hod, &r_hod) ) { u2z(hod); return pro; } else { u2_noun xod; if ( u2_yes == u2_dust(q_hod) && (_1 == u2_h(q_hod)) && (_0 == u2_t(q_hod)) ) { q_hod = 0; } xod = u2_rt(u2_Wire, u2k(q_hod), u2k(p_hod), u2k(r_hod)); u2z(hod); hod = xod; } u2_tx_sys_bit(u2_Wire, u2_yes); pro = u2_ds_mine(u2_Wire, hod, pro); u2_tx_sys_bit(u2_Wire, u2_no); } u2z(hod); return pro; } #if 0 case c3__leap: { u2z(hod); fprintf(stderr, "leaping!!\r\n"); { u2_noun hoe, tax; tax = u2_wire_tax(u2_Wire); u2_wire_tax(u2_Wire) = u2_nul; u2_rl_leap(u2_Wire, c3__rock); if ( 0 != (hoe = u2_cm_trap()) ) { u2_noun cod; u2_rl_fall(u2_Wire); hoe = u2_rl_take(u2_Wire, hoe); u2_rl_flog(u2_Wire); u2_wire_tax(u2_Wire) = u2_ckb_weld(u2k(u2t(hoe)), tax); cod = u2k(u2h(hoe)); fprintf(stderr, "error in leap: %s\r\n", u2_cr_string(cod)); return u2_cm_bail(cod); } else { u2_noun pro = pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); u2_cm_done(); u2_rl_fall(u2_Wire); pro = u2_rl_take(u2_Wire, pro); u2_rl_flog(u2_Wire); u2_wire_tax(u2_Wire) = tax; fprintf(stderr, "leapt!!\r\n"); u2z(bus); u2z(nex); return pro; } } } #endif case c3__memo: { u2z(hod); { pro = u2_rl_find_cell(u2_Wire, 0, bus, nex); if ( pro != u2_none ) { u2_tx_did_fin(u2_Wire, 1); u2z(bus); u2z(nex); return pro; } else { u2_noun sav; pro = pon ? _nock_mool(u2k(bus), u2k(nex), pon) : _nock_cool(u2k(bus), u2k(nex)); if ( !pon || (u2_no != *pon) ) { u2_tx_sys_bit(u2_Wire, u2_yes); sav = u2_rl_save_cell(u2_Wire, 0, bus, nex, pro); u2_tx_sys_bit(u2_Wire, u2_no); u2_tx_did_pod(u2_Wire, 1); u2_tx_did_fin(u2_Wire, 1); } else sav = pro; u2z(bus); u2z(nex); return sav; } } } case c3__ping: { u2_tx_sys_bit(u2_Wire, u2_yes); u2_tx_did_act(u2_Wire, hod); u2_tx_sys_bit(u2_Wire, u2_no); u2z(hod); return pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); } case c3__live: { u2_bean qox; u2_tx_sys_bit(u2_Wire, u2_yes); qox = u2_tx_task_in(u2_Wire, hod); u2_tx_sys_bit(u2_Wire, u2_no); u2z(hod); if ( u2_no == qox ) { return pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); } else { pro = pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); u2_tx_task_out(u2_Wire); return pro; } } case c3__sole: { u2z(hod); { pro = pon ? _nock_mool(bus, nex, pon) : _nock_cool(bus, nex); if ( u2_none == pro ) { return u2_none; } else if ( !pon || (u2_no != *pon) ) { u2_noun nuu; u2_tx_sys_bit(u2_Wire, u2_yes); nuu = u2_rl_uniq(u2_Wire, pro); u2_tx_sys_bit(u2_Wire, u2_no); u2_tx_did_fin(u2_Wire, 1); if ( nuu == pro ) { u2_tx_did_pod(u2_Wire, 1); } } return pro; } } } }
/* u2_sh_mine(): substitute active, annotated battery. */ u2_weak // transfer u2_sh_mine(u2_ray wir_r, u2_clue clu, // retain u2_noun cor) // transfer { u2_ray bas_r; u2_noun pay, bat; u2_noun sil, bud, nut; u2_chip xip; if ( 0 == (bas_r = u2_wire_bas_r(wir_r)) ) { return cor; } else if ( (u2_none == u2_as_cell(cor, &pay, &bat)) || (u2_no == u2_dust(bat)) ) { return cor; } else if ( u2_none != (xip = u2_ch_find(u2_bask_hag_r(bas_r), bat)) ) { u2_noun cyr; if ( u2_none == (cyr = u2_rc(wir_r, u2_rx(wir_r, pay), u2_h(u2_t(xip)))) ) { return cor; } else { u2_rl_lose(wir_r, cor); return cyr; } } else if ( (u2_no == u2_as_trel(clu, &bud, &sil, &nut)) || (u2_no == _sh_good_bud(bud)) || (u2_no == _sh_good_sil(sil)) || (u2_no == _sh_good_nut(nut)) ) { return cor; } else { u2_noun dac, bot, pet, xop, cyr; dac = bot = pet = xop = cyr = u2_none; while ( 1 ) { /* disc: dac */ { if ( u2_none == (dac = u2_rl_take(bas_r, u2_t(clu))) ) { break; } } /* battery: bot */ { if ( u2_no == u2_rl_junior(bas_r, bat) ) { /* We need the jet battery to be in the shed, so that we ** have a fast algorithm for distinguishing jet batteries ** by ray address. */ bot = u2_rc(bas_r, u2_h(bat), u2_t(bat)); #if 0 printf("battery: in basket: %d.%x\n", u2_ray_a(u2_dog_a(bot)), u2_ray_b(u2_dog_a(bot))); #endif } else { bot = u2_rl_take(bas_r, bat); #if 0 printf("battery: in shed! %d.%x\n", u2_ray_a(u2_dog_a(bot)), u2_ray_b(u2_dog_a(bot))); #endif } if ( u2_none == bot ) { break; } } /* trunk: pet */ { if ( _0 == bud ) { pet = u2_nul; } else { u2_atom p_bud = u2_t(bud); u2_noun car = u2_frag(p_bud, cor); if ( (u2_none == car) || (u2_no == u2_dust(car)) ) { break; } else { u2_noun but = u2_t(car); u2_noun xup, axe; if ( u2_none == (xup = u2_ch_find(u2_bask_hag_r(bas_r), but)) ) { printf("no base!\n"); u2_err(wir_r, "clu", clu); break; } else u2_rl_gain(bas_r, xup); if ( u2_none == (axe = u2_rl_take(bas_r, p_bud)) ) { u2_rl_lose(bas_r, xup); } if ( u2_none == (pet = u2_rc(bas_r, p_bud, xup)) ) { u2_rl_lose(bas_r, axe); u2_rl_lose(bas_r, xup); break; } } } } /* xop: new chip. */ { if ( u2_none == (xop = u2_rt(bas_r, dac, bot, pet)) ) { break; } if ( u2_none == (u2_ch_save(bas_r, u2_bask_hag_r(bas_r), bot, xop)) ) { break; } u2_rl_lose(bas_r, xop); } /* cyr: new core. */ { u2_noun cyr; if ( u2_none == (cyr = u2_rc(wir_r, u2_rx(wir_r, pay), bot)) ) { break; } else { u2_rl_lose(wir_r, cor); return cyr; } } } u2_ho_warn_here(); #if 0 // XXX: an unknown bug is triggered here; // but basket needs a minor rewrite. // if ( dac != u2_none ) u2_rl_lose(bas_r, dac); if ( bot != u2_none ) u2_rl_lose(bas_r, bot); if ( pet != u2_none ) u2_rl_lose(bas_r, pet); if ( xop != u2_none ) u2_rl_lose(bas_r, xop); #endif return cor; } }