mirror of
https://github.com/urbit/shrub.git
synced 2024-12-11 23:48:22 +03:00
498 lines
9.7 KiB
C
498 lines
9.7 KiB
C
/* g/n.c
|
|
**
|
|
*/
|
|
#include "all.h"
|
|
|
|
static u3_noun _n_nock_on(u3_noun bus, u3_noun fol);
|
|
|
|
/* u3_term_io_hija(): hijack console for cooked print.
|
|
*/
|
|
FILE*
|
|
u3_term_io_hija(void);
|
|
|
|
/* u3_term_io_loja(): release console from cooked print.
|
|
*/
|
|
void
|
|
u3_term_io_loja(int x);
|
|
|
|
/* uL, uH: wrap hijack/lojack around fprintf.
|
|
**
|
|
** uL(fprintf(uH, ...));
|
|
*/
|
|
# define uH u3_term_io_hija()
|
|
# define uL(x) u3_term_io_loja(x)
|
|
|
|
|
|
/* _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(144 + 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(144 + 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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* _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)));
|
|
}
|
|
}
|
|
|
|
/* _n_mush(): tank from failed path request.
|
|
*/
|
|
static u3_noun
|
|
_n_mush(u3_noun val)
|
|
{
|
|
u3_noun pro;
|
|
|
|
pro = u3nt(c3__rose,
|
|
u3nt(u3nc('/', u3_nul), u3nc('/', u3_nul), u3_nul),
|
|
_n_mush_in(val));
|
|
u3z(val);
|
|
return pro;
|
|
}
|
|
|
|
/* _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);
|
|
|
|
#ifdef U3_CPU_DEBUG
|
|
u3R->pro.nox_d += 1;
|
|
#endif
|
|
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
|
|
/* u3n_nock_on(): produce .*(bus fol). Do not virtualize.
|
|
*/
|
|
u3_noun
|
|
u3n_nock_on(u3_noun bus, u3_noun fol)
|
|
{
|
|
u3_noun pro;
|
|
|
|
u3t_on(noc_o);
|
|
pro = _n_nock_on(bus, fol);
|
|
u3t_off(noc_o);
|
|
|
|
return pro;
|
|
}
|
|
|
|
/* u3n_kick_on(): fire `gat` without changing the sample.
|
|
*/
|
|
u3_noun
|
|
u3n_kick_on(u3_noun gat)
|
|
{
|
|
return u3j_kink(gat, 2);
|
|
}
|
|
|
|
c3_w exc_w;
|
|
|
|
/* 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);
|
|
}
|
|
|
|
/* u3n_nock_et(): produce .*(bus fol), as ++toon, in namespace.
|
|
*/
|
|
u3_noun
|
|
u3n_nock_et(u3_noun gul, u3_noun bus, u3_noun fol)
|
|
{
|
|
return u3m_soft_run(gul, u3n_nock_on, bus, fol);
|
|
}
|
|
|
|
/* u3n_slam_et(): produce (gat sam), as ++toon, in namespace.
|
|
*/
|
|
u3_noun
|
|
u3n_slam_et(u3_noun gul, u3_noun gat, u3_noun sam)
|
|
{
|
|
return u3m_soft_run(gul, u3n_slam_on, gat, sam);
|
|
}
|
|
|
|
/* u3n_nock_an(): as slam_in(), but with empty fly.
|
|
*/
|
|
u3_noun
|
|
u3n_nock_an(u3_noun bus, u3_noun fol)
|
|
{
|
|
u3_noun gul = u3nt(u3nt(1, 0, 0), 0, 0); // |=(a/{* *} ~)
|
|
|
|
return u3n_nock_et(gul, bus, fol);
|
|
}
|