/* _nock_pray_mool(): load from namespace, in virtual mode.
*/
static u2_noun
_nock_pray_mool(u2_noun gof, u2_kode *pon) // transfer
{
u2_noun lad = u2_hevn_at(lad);
c3_assert(u2_yes == u2du(lad));
c3_assert(0 == *pon);
{
u2_noun i_lad = u2fh(lad);
u2_noun t_lad = u2ft(lad);
u2_noun pro;
u2_noun hoe;
u2_hevn_at(lad) = t_lad;
if ( 0 != (hoe = u2_cm_trap()) ) {
u2_cm_done();
return u2_cm_bail(u2k(u2h(hoe)));
}
else {
if ( u2_nul == t_lad ) {
pro = u2_cn_mung(u2k(i_lad), u2k(gof));
} else {
pro = _nock_molg(u2k(i_lad), u2k(gof), pon);
}
u2_cm_done();
c3_assert(t_lad == u2_hevn_at(lad));
u2_hevn_at(lad) = lad;
if ( 0 != *pon ) {
u2z(gof);
return pro;
} else {
if ( u2_no == u2du(pro) ) {
*pon = 1;
u2z(pro);
return u2nc(gof, u2_nul);
}
else {
u2_noun res = u2k(u2t(pro));
u2z(gof);
u2z(pro);
return res;
}
}
}
}
}
/* _nock_moog(): u2_cn_mink() with fly set.
*/
static u2_noun
_nock_moog(u2_noun bus,
u2_noun fol)
{
u2_noun res;
u2_kode pon;
pon = 0;
{
u2_noun hoe;
if ( 0 != (hoe = u2_cm_trap()) ) {
if ( u2h(hoe) == c3__exit ) {
res = u2nc(2, u2k(u2t(hoe)));
c3_assert(0);
u2z(hoe);
}
else if ( u2h(hoe) == c3__need ) {
res = u2nc(1, u2k(u2t(hoe)));
u2z(hoe);
}
else {
u2_noun wac = u2k(u2h(hoe));
u2z(hoe);
return u2_cm_bail(wac);
}
}
else {
u2_noun pro = _nock_mool(bus, fol, &pon);
u2_cm_done();
res = u2nc(pon, pro);
}
}
return res;
}
/* _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_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;
}
c3_i
main(c3_i argc,
c3_c** argv)
{
// set both logging systems to unit-ed
//
u2K->inited_t = c3_false;
c3_w kno_w;
_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
_MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
// Parse options.
//
if ( u2_no == _main_getopt(argc, argv) ) {
u2_ve_usage(argc, argv);
return 1;
}
u2_ve_sysopt();
printf("~\n");
printf("welcome.\n");
printf("vere: urbit home is %s\n", u2_Host.cpu_c);
printf("vere: hostname is %s\n", u2_Host.ops_u.nam_c);
if ( u2_yes == u2_Host.ops_u.dem && u2_no == u2_Host.ops_u.bat ) {
printf("Starting daemon\n");
}
// Seed prng. Don't panic -- just for fuzz testing and election timeouts.
//
srand(getpid());
// Instantiate process globals.
{
u2_wr_check_init(u2_Host.cpu_c);
u2_Host.xit_i = 0;
if ( (u2_no == u2_Host.ops_u.nuu) &&
(u2_yes == u2_loom_load()) )
{
u2_Host.wir_r = u2_ray_of(0, 0);
u2_Wire = u2_Host.wir_r;
u2_Host.arv_u = u2_Arv;
u2_Arv->ova.egg_u = u2_Arv->ova.geg_u = 0;
u2_lo_grab("init", u2_none);
// Horrible ancient stuff.
//
kno_w = u2_Host.arv_u->kno_w;
u2_Host.kno_w = kno_w;
u2_ho_push();
}
else {
u2_loom_boot();
u2_Host.wir_r = u2_wr_init(c3__rock, u2_ray_of(0, 0), u2_ray_of(1, 0));
u2_Wire = u2_Host.wir_r;
u2_Host.arv_u = u2_Arv;
}
}
// If we have not loaded from checkpoint, build kernel.
//
if ( 0 != u2_Host.arv_u->ent_d ) {
u2_reck_time(u2_Host.arv_u);
u2_reck_numb(u2_Host.arv_u);
{
c3_c* dyt_c = u2_cr_string(u2_Host.arv_u->wen);
printf("time: %s\n", dyt_c);
free(dyt_c);
}
}
else {
// Set outside bail trap. Should not be used, but you never know...
//
if ( 0 != u2_cm_trap() ) {
u2_ve_panic(argc, argv);
}
else {
// Set boot and goal stages.
{
if ( (0 == u2_Host.ops_u.kno_w) || (u2_Host.ops_u.kno_w > 255) ) {
kno_w = DefaultKernel;
} else {
kno_w = u2_Host.ops_u.kno_w;
}
}
// Load the system.
//
{
u2_Host.kno_w = u2_Host.ops_u.kno_w;
u2_reck_boot(u2_Host.arv_u);
}
u2_cm_done();
}
}
// Install signal handlers and set buffers.
//
// Note that we use the sigmask-restoring variant. Essentially, when
// we get a signal, we force the system back into the just-booted state.
// If anything goes wrong during boot (above), it's curtains.
{
if ( 0 != sigsetjmp(Signal_buf, 1) ) {
switch ( Sigcause ) {
case sig_overflow: printf("[stack overflow]\r\n"); break;
case sig_interrupt: printf("[interrupt]\r\n"); break;
default: printf("[signal error!]\r\n"); break;
}
Sigcause = sig_none;
signal(SIGINT, SIG_DFL);
stackoverflow_deinstall_handler();
// Print the trace, do a GC, etc.
//
// This is half-assed at present, so we exit.
//
u2_lo_sway(0, u2k(u2_wire_tax(u2_Wire)));
u2_lo_bail(u2_Host.arv_u);
exit(1);
}
#if 1
if ( -1 == stackoverflow_install_handler
(overflow_handler, Sigstk, SIGSTKSZ) )
{
fprintf(stderr, "overflow_handler: install failed\n");
exit(1);
}
signal(SIGINT, interrupt_handler);
signal(SIGIO, SIG_IGN);
#endif
}
u2_lo_grab("main", u2_none);
// booted in admin mode: do a task, then exit
// booted in user mode: do command loop
if (u2_Host.ops_u.adm_c != 0) {
if (strcmp(u2_Host.ops_u.adm_c, "edmp") ==0) { u2_egz_admin_dump_egz(); }
else if (strcmp(u2_Host.ops_u.adm_c, "etok") ==0) { u2_kafka_admin_egz_to_kafka(); }
else if (strcmp(u2_Host.ops_u.adm_c, "ktoe") ==0) { u2_kafka_admin_kafka_to_egz(); }
else if (strcmp(u2_Host.ops_u.adm_c, "kcnf") ==0) { u2_lo_loop(); } // do it in the app
else { fprintf(stderr, "unsupported admin mode command %s\n", u2_Host.ops_u.adm_c); exit(1); }
} else {
u2_lo_loop();
}
return 0;
}
