/* u2_cm_trip(): descend into a memory region. ** ** Memory allocated in the heap above is senior & frozen. */ void u2_cm_trip() { #if 0 if ( u2_no == u2_rl_leap(u2_Wire, c3__rock) ) { u2_cm_bail(c3__fail); } #endif }
/* 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; } }
/* zuse_line(): execute a zuse line, as command and argument. */ void zuse_line(struct zuse_state* fod_f, const c3_c* cmd_c, const c3_c* arg_c) { u2_ray wir_r = fod_f->wir_r; u2_ray cap_r = u2_rail_cap_r(wir_r); LoomStop = 0; u2_bx_boot(wir_r); u2_rl_leap(wir_r, c3__rock); { u2_ray jub_r = u2_bl_open(wir_r); if ( u2_bl_set(wir_r) ) { u2_bl_done(wir_r, jub_r); } else { if ( !strcmp(cmd_c, "test") ) { // zuse_test(fod_f, "watt/t1-273"); zuse_test3(fod_f, "watt/270", arg_c); } else if ( !strcmp(cmd_c, "next") ) { zuse_next4(fod_f, "watt/270", "watt/269", "watt/268", arg_c); } else { #if 0 u2_noun cmd = u2_bn_string(wir_r, cmd_c); u2_noun cor = u2_bn_mung(wir_r, fod_f->ryd, cmd); u2_burp(wir_r, 0, u2_fj_prep_noun(wir_r, cor)); if ( arg_c ) { u2_noun arg = u2_bn_string(wir_r, arg_c); u2_noun sam = u2_bn_mung(wir_r, fod_f->ryd, arg); u2_burp(wir_r, 0, u2_fj_prep_noun(wir_r, sam)); } #else u2_noun gat, sam, pro; /* Construct gate from command. */ gat = _zuse_from(fod_f, cmd_c); /* Construct sample from argument. */ sam = _zuse_from(fod_f, arg_c); /* Construct product. */ pro = u2_nk_mung(wir_r, gat, sam); /* Print, if applicable. */ { if ( u2_none != pro ) { u2_prep pap = u2_fj_prep_noun(wir_r, pro); u2_burp(wir_r, 0, pap); u2_bx_spot(wir_r, u2_nul); } } } #endif } } u2_nk_show(wir_r, stderr); u2_rl_fall(wir_r); u2_rail_cap_r(wir_r) = cap_r; u2_bx_show(wir_r); }
/* 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; } } } }