Example #1
0
/* functions
*/
  u2_noun                                                         //  produce
  j2_mcx(Pt6, ut, swab)(u2_wire wir_r, 
                        u2_noun van,                              //  retain
                        u2_noun sut,                              //  retain
                        u2_noun men,                              //  retain
                        u2_noun har)                              //  retain
  {
    if ( u2_no == u2_dust(har) ) {
      return u2_nul;
    } else {
      u2_noun i_har = u2_h(har);
      u2_noun t_har = u2_t(har);
      u2_noun pi_har = u2_h(i_har);
      u2_noun qi_har = u2_t(i_har);
      u2_noun roz = j2_mcy(Pt6, ap, rake)(wir_r, pi_har);
      u2_noun peh = j2_mbc(Pt2, flop)(wir_r, roz);
      u2_noun nuk = _snub(wir_r, van, sut, peh, men, qi_har, u2_nul);
      u2_noun ret = u2_bc(wir_r, u2_bc(wir_r, peh, nuk),
                                 j2_mcx(Pt6, ut, swab)
                                    (wir_r, van, sut, men, t_har));

      u2_rz(wir_r, roz);
      return ret;
    }
  }
Example #2
0
  static u2_noun                                                  //  transfer
  _seek_silk_yew(u2_wire wir_r, 
                 u2_noun van,                                     //  retain
                 u2_noun syx,                                     //  retain
                 u2_noun qq_tor)                                  //  retain
  {
    if ( u2_nul == qq_tor ) {
      return u2_nul;
    }
    else {
      u2_noun iqq_tor  = u2_h(qq_tor);
      u2_noun qiqq_tor = u2_t(iqq_tor);
      u2_noun yon      = _seek_silk_yew(wir_r, van, syx, u2_t(qq_tor));

      if ( c3__yew != u2_h(qiqq_tor) ) {
        return yon;
      } else {
        u2_noun nuy = j2_mby(Pt6, look)(wir_r, syx, u2_t(qiqq_tor));

        if ( u2_nul == nuy ) {
          return u2_bl_error(wir_r, "silk");
        }
        else {
          yon = u2_bc(wir_r, u2_rx(wir_r, u2_t(nuy)), yon);
          u2_rz(wir_r, nuy);
          return yon;
        }
      }
    } 
  }
  /* _lily_hike_belt_l(): factor (pac) left.
  */
  static u2_list
  _lily_hike_belt_l(u2_ray  wir_r,
                    u2_list pac)
  {
    if ( (u2_nul == pac) ) {
      return u2_nul;
    }
    else {
      u2_axis axis       = u2_h(u2_h(pac));
      u2_tool tool       = u2_t(u2_h(pac));
      u2_list belt_l = _lily_hike_belt_l(wir_r, u2_t(pac));

      {
        if ( (_1 != axis) &&
             (u2_yes == u2_sing(_2, j2_mbc(Pt3, cap)(wir_r, axis))) )
        {
          u2_axis axis_tap = j2_mbc(Pt3, mas)(wir_r, axis);

          return u2_bc(wir_r,
                       u2_bc(wir_r,
                             u2_rx(wir_r, axis_tap),
                             u2_rx(wir_r, tool)),
                       belt_l);
        }
        else return belt_l;
      }
    }
  }
  /* _lily_hike_belt_r(): factor (pac) right.
  */
  static u2_list                                                  //  transfer
  _lily_hike_belt_r(u2_ray  wir_r,
                    u2_list pac)                                  //  retain
  {
    if ( (u2_nul == pac) ) {
      return u2_nul;
    }
    else {
      u2_axis axis       = u2_h(u2_h(pac));
      u2_tool tool       = u2_t(u2_h(pac));
      u2_list belt_r = _lily_hike_belt_r(wir_r, u2_t(pac));

      {
        if ( (_1 != axis) &&
             (u2_yes == u2_sing(_3, j2_mbc(Pt3, cap)(wir_r, axis))) )
        {
          u2_axis axis_tap = j2_mbc(Pt3, mas)(wir_r, axis);

          return u2_bc(wir_r,
                       u2_bc(wir_r, u2_rx(wir_r, axis_tap),
                                    u2_rx(wir_r, tool)),
                       belt_r);
        }
        else return belt_r;
      }
    }
  }
Example #5
0
  static u2_noun                                                  //  produce
  _play_edit(u2_wire wir_r,
             u2_noun van,                                         //  retain
             u2_noun sut,                                         //  retain
             u2_noun mew,                                         //  retain
             u2_noun rag)                                         //  submit
  {
    while ( 1 ) {
      if ( u2_no == u2_dust(mew) ) {
        return rag;
      } else {
        u2_noun i_mew = u2_h(mew);
        u2_noun t_mew = u2_t(mew);
        u2_noun pi_mew = u2_h(i_mew);
        u2_noun qi_mew = u2_t(i_mew);
        u2_noun laf = _play_in(wir_r, van, sut, qi_mew);
        u2_noun ruz = j2_mcy(Pt6, ut, tock)(wir_r, van, sut, pi_mew, laf, rag);
   
        u2_rz(wir_r, laf);
        u2_rz(wir_r, rag);
        rag = u2_rx(wir_r, u2_t(ruz));
        u2_rz(wir_r, ruz);

        mew = t_mew;
      }
    }
  }
Example #6
0
/* functions
*/
  u2_weak                                                         //  transfer
  j2_mcc(Pt4, by, gas)(u2_wire wir_r, 
                       u2_noun a,                                 //  retain
                       u2_noun b)                                 //  retain
  {
    if ( u2_nul == b ) {
      return u2_rx(wir_r, a);
    }
    else {
      if ( u2_no == u2_dust(b) ) {
        return u2_bl_bail(wir_r, c3__exit);
      } else {
        u2_noun i_b = u2_h(b);
        u2_noun t_b = u2_t(b);

        if ( u2_no == u2_dust(i_b) ) {
          return u2_bl_bail(wir_r, c3__exit);
        } else {
          u2_noun pi_b = u2_h(i_b);
          u2_noun qi_b = u2_t(i_b);
          u2_noun c;

          if ( u2_none == (c = j2_mcc(Pt4, by, put)(wir_r, a, pi_b, qi_b)) ) {
            return u2_bl_bail(wir_r, c3__exit);
          } else {
            u2_noun d = j2_mcc(Pt4, by, gas)(wir_r, c, t_b);

            u2_rl_lose(wir_r, c);
            return d;
          }
        }
      }
    }
  }
Example #7
0
  static u2_noun                                                  //  produce
  _mint_foil(u2_wire wir_r,
             u2_noun pok)                                         //  submit
  {
    u2_noun p_pok = u2_h(pok);
    u2_noun q_pok = u2_t(pok);
    u2_noun ret;

    if ( u2_yes == u2_h(q_pok) ) {
      u2_noun pq_pok = u2_t(q_pok);

      ret = u2_bc(wir_r, 
                  u2_rx(wir_r, p_pok),
                  u2_bc(wir_r, u2_nul,
                               u2_bc(wir_r,
                                     u2_bc(wir_r, 
                                           u2_rx(wir_r, pq_pok),
                                           u2_bt(wir_r, c3__elm, u2_nul, _1)),
                                     u2_nul)));
    }
    else {
      u2_noun pq_pok = u2_h(u2_t(q_pok));
      u2_noun qq_pok = u2_t(u2_t(q_pok));

      ret = u2_bc(wir_r, u2_rx(wir_r, p_pok),
                         u2_bc(wir_r, u2_rx(wir_r, pq_pok),
                                      u2_rx(wir_r, qq_pok)));
    }
    u2_rz(wir_r, pok);
    return ret;
  }
Example #8
0
/* glue
*/
  u2_noun                                                         //  produce
  j2_mcx(Pt5, glue, fun)(u2_wire wir_r,
                         u2_noun bus,                             //  retain
                         u2_noun vex,                             //  retain
                         u2_noun sab)                             //  retain
  {
    u2_noun p_vex, q_vex;

    u2_bi_cell(wir_r, vex, &p_vex, &q_vex);
    if ( u2_no == u2_dust(q_vex) ) {
      return u2_rx(wir_r, vex);
    } 
    else {
      u2_noun uq_vex = u2_t(q_vex);
      u2_noun puq_vex, quq_vex;
      u2_noun yit, yur;
      u2_noun p_yit, q_yit;
      u2_noun ret;

      u2_bi_cell(wir_r, uq_vex, &puq_vex, &quq_vex);
      yit = u2_bl_good(wir_r, u2_nk_mong(wir_r, bus, u2_rx(wir_r, quq_vex)));
      
      u2_bi_cell(wir_r, yit, &p_yit, &q_yit);
      yur = _last(wir_r, p_vex, p_yit);

      if ( u2_no == u2_dust(q_yit) ) {
        ret = u2_bc(wir_r, yur, u2_nul);
      } 
      else {
        u2_noun uq_yit = u2_t(q_yit);
        u2_noun puq_yit, quq_yit;
        u2_noun wam, p_wam, q_wam, goy;
         
        u2_bi_cell(wir_r, uq_yit, &puq_yit, &quq_yit);
        wam = u2_bl_good(wir_r, u2_nk_mong(wir_r, sab, u2_rx(wir_r, quq_yit)));

        u2_bi_cell(wir_r, wam, &p_wam, &q_wam);
        goy = _last(wir_r, yur, p_wam);
        u2_rz(wir_r, yur);

        if ( u2_no == u2_dust(q_wam) ) {
          ret = u2_bc(wir_r, goy, u2_nul);
        } else {
          u2_noun uq_wam = u2_t(q_wam);
          u2_noun puq_wam, quq_wam;

          u2_bi_cell(wir_r, uq_wam, &puq_wam, &quq_wam);
          ret = u2_bq(wir_r, goy,
                             u2_nul,
                             u2_bc(wir_r, u2_rx(wir_r, puq_vex),
                                          u2_rx(wir_r, puq_wam)),
                             u2_rx(wir_r, quq_wam));
        }
        u2_rz(wir_r, wam);
      }
      u2_rz(wir_r, yit);
      return ret;
    }
  }
Example #9
0
/* u2_cke_cue(): expand saved pill.
*/
  static u2_noun                                                  //  produce
  _cue_in(u2_wire wir_r,
          u2_atom a,                                              //  retain
          u2_atom b,                                              //  retain
          u2_ray  t_r)                                            //  retain
  {
    u2_noun p, q;

    if ( _0 == j2_mbc(Pt3, cut)(wir_r, 0, b, 1, a) ) {
      u2_noun x = j2_mbc(Pt1, inc)(wir_r, b);
      u2_noun c = j2_mby(Pt5, rub)(wir_r, x, a);

      p = j2_mbc(Pt1, inc)(wir_r, u2_h(c));
      q = u2_rx(wir_r, u2_t(c));
      q = u2_cs_save(wir_r, t_r, 0, b, q);

      u2_rz(wir_r, c);
      u2_rz(wir_r, x);
    }
    else {
      u2_noun c = j2_mbc(Pt1, add)(wir_r, _2, b);
      u2_noun l = j2_mbc(Pt1, inc)(wir_r, b);

      if ( _0 == j2_mbc(Pt3, cut)(wir_r, 0, l, 1, a) ) {
        u2_noun u, v, w;
        u2_noun x, y;

        u = _cue_in(wir_r, a, c, t_r);
        x = j2_mbc(Pt1, add)(wir_r, u2_h(u), c);
        v = _cue_in(wir_r, a, x, t_r);

        w = u2_bc(wir_r, u2_rx(wir_r, u2_t(u)),
                         u2_rx(wir_r, u2_t(v)));

        y = j2_mbc(Pt1, add)(wir_r, u2_h(u), u2_h(v));

        p = j2_mbc(Pt1, add)(wir_r, _2, y);
        q = u2_cs_save(wir_r, t_r, 0, b, w);

        u2_rz(wir_r, u); u2_rz(wir_r, v); u2_rz(wir_r, x); u2_rz(wir_r, y);
      }
      else {
        u2_noun d = j2_mby(Pt5, rub)(wir_r, c, a);
        u2_weak x = u2_cs_find(wir_r, t_r, 0, u2_t(d));

        p = j2_mbc(Pt1, add)(wir_r, _2, u2_h(d));

        if ( u2_none == x ) {
          return u2_bl_bail(wir_r, c3__fail);
        }
        q = u2_rx(wir_r, x);

        u2_rz(wir_r, d);
      }
      u2_rz(wir_r, l);
      u2_rz(wir_r, c);
    }
    return u2_bc(wir_r, p, q);
  }
Example #10
0
File: shed.c Project: Gruelty/urbit
/* 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;
        }
      }
    }
  }
}
Example #11
0
/* zuse_test3(): accurate use of a true kernel.
*/
void
zuse_test3(struct zuse_state* fod_f,
           const char*        src_c,
           const char*        arg_c)
{
  u2_wire wir_r = fod_f->wir_r;
  u2_noun src   = u2_ux_read(wir_r, src_c, "watt");

  if ( u2_none == src ) {
    printf("test3: %s: no file\n", src_c);
    u2_bl_bail(wir_r);
  }
  else {
    u2_noun gen = j2_mbc(watt_271, ream)(wir_r, src);

    // u2_err(wir_r, "gene", gen);
    if ( u2_none == gen ) {
      printf("test3: %s: no gene\n", src_c);
      return;
    }
    else {
      u2_noun lof = _zuse_ol_mint(wir_r, fod_f->pit, c3__noun, c3__noun, gen); 

      if ( u2_none == lof ) {
        printf("test: failed\n");
      }
      else {
        printf("::::  ::::  ::::  ::::\n");
        u2_bx_spot(wir_r, u2_nul); 
#if 0
        u2_err(wir_r, "type", u2_h(lof));
        u2_err(wir_r, "tool", u2_t(lof));
#endif
        if ( arg_c ) {
          u2_noun typ = u2_h(lof);
          u2_noun tul = u2_t(lof);
          u2_noun pug = u2_bn_nock(wir_r, _0, tul);
          u2_noun src = u2_rl_string(wir_r, arg_c);
          u2_noun ger = j2_mbc(watt_271, ream)(wir_r, src);
          u2_noun hup = _zuse_ol_mint(wir_r, fod_f->pit, typ, c3__noun, ger);

          if ( (u2_none != hup) && (u2_none != pug) ) {
            u2_weak muf = u2_nk_nock(wir_r, pug, u2_t(hup));

            _zuse_dump_type(wir_r, fod_f->pit, 0, u2_h(hup));
            if ( muf != u2_none ) {
              u2_err(wir_r, 0, muf);
            }
            u2_bx_spot(wir_r, u2_nul);
          }
        }
      }
    }
  }
}
Example #12
0
/* bend
*/
  u2_noun                                                         //  produce
  j2_mcx(Pt5, bend, fun)(u2_wire wir_r,
                         u2_noun raq,                             //  retain
                         u2_noun vex,                             //  retain
                         u2_noun sab)                             //  retain
  {
    u2_noun p_vex, q_vex;

    u2_bi_cell(wir_r, vex, &p_vex, &q_vex);
    if ( u2_no == u2_dust(q_vex) ) {
      return u2_rx(wir_r, vex);
    } else {
      u2_noun uq_vex = u2_t(q_vex);
      u2_noun puq_vex, quq_vex;
      u2_noun yit, yur;
      u2_noun p_yit, q_yit;
      u2_noun ret;

      u2_bi_cell(wir_r, uq_vex, &puq_vex, &quq_vex);
      yit = u2_bl_good(wir_r, u2_nk_mong(wir_r, sab, u2_rx(wir_r, quq_vex)));
      
      u2_bi_cell(wir_r, yit, &p_yit, &q_yit);
      yur = _last(wir_r, p_vex, p_yit);

      if ( u2_no == u2_dust(q_yit) ) {
        ret = u2_bc(wir_r, yur, u2_rx(wir_r, q_vex));
      } 
      else {
        u2_noun uq_yit = u2_t(q_yit);
        u2_noun puq_yit, quq_yit;
        u2_noun vux;
         
        u2_bi_cell(wir_r, uq_yit, &puq_yit, &quq_yit);

        vux = u2_bl_good
                    (wir_r, 
                     u2_nk_mong
                       (wir_r, raq, 
                               u2_bc(wir_r, u2_rx(wir_r, puq_vex),
                                            u2_rx(wir_r, puq_yit))));
        if ( u2_nul == vux ) {
          ret = u2_bc(wir_r, yur, u2_rx(wir_r, q_vex));
        }
        else {
          ret = u2_bq(wir_r, yur,
                             u2_nul,
                             u2k(u2t(vux)),
                             u2_rx(wir_r, quq_yit));
          u2z(vux);
        }
      }
      u2_rz(wir_r, yit);
      return ret;
    }
  }
Example #13
0
/* logic
*/
  u2_noun                                                         //  transfer
  j2_mcy(Pt6, ut, repo)(u2_wire wir_r, 
                        u2_noun van,                              //  retain
                        u2_noun sut)                              //  retain
  {
    u2_noun p_sut, q_sut;

    if ( u2_no == u2_dust(sut) ) switch ( sut ) {
      default: return u2_rx(wir_r, sut);

      case c3__noun: 
        return u2_bt(wir_r, c3__fork, 
                            u2_bc(wir_r, c3__atom, u2_blip),
                            u2_bt(wir_r, c3__cell, c3__noun, c3__noun));
    }
    else switch ( u2_h(sut) ) {
      default: {
        return u2_bl_error(wir_r, "repo-flat");
      }

      case c3__bull: {
        if ( u2_no == u2_as_cell(u2_t(sut), &p_sut, &q_sut)) {
          return u2_bl_bail(wir_r, c3__fail);
        } else {
          return u2_rx(wir_r, q_sut);
        }
      }
      case c3__core: {
        if ( u2_no == u2_as_cell(u2_t(sut), &p_sut, &q_sut) ) {
          return u2_bl_bail(wir_r, c3__fail);
        } else {
          return u2_bt(wir_r, c3__cell, c3__noun, u2_rx(wir_r, p_sut));
        }
      }
      case c3__cube: {
        if ( u2_no == u2_as_cell(u2_t(sut), &p_sut, &q_sut)) {
          return u2_bl_bail(wir_r, c3__fail);
        } else {
          return u2_rx(wir_r, q_sut);
        }
      }
      case c3__face: {
        if ( u2_no == u2_as_cell(u2_t(sut), &p_sut, &q_sut)) {
          return u2_bl_bail(wir_r, c3__fail);
        } else {
          return u2_rx(wir_r, q_sut);
        }
      }
      case c3__hold: {
        p_sut = u2_t(sut);
        return j2_mcy(Pt6, ut, rest)(wir_r, van, sut, p_sut);
      }
    }
  }
Example #14
0
/* _hill_z_make_gen(): execute gene against shoe.
*/
static hi_shoz                                                    //  produce
_hill_z_make_gen(u2_wire wir_r,
                 hi_shoz sho,                                     //  retain
                 u2_noun gen)                                     //  retain
{
  u2_noun gam = _hill_z_mint_gen(wir_r, u2_h(sho), c3__noun, gen);
  u2_noun pro = _hill_nock(wir_r, u2_t(sho), u2_t(gam));
  u2_noun ret = u2_bc(wir_r, u2_rx(wir_r, u2_h(gam)), pro);

  u2_rz(wir_r, gam);
  return ret;
}
Example #15
0
/* _hill_print_tent(): print wrapper for trace entry.
*/
static void
_hill_print_tent(u2_wire wir_r,
                 FILE*   fil_f,                                   //  retain
                 u2_noun tax)                                     //  retain
{
  if ( u2_yes == u2_dust(tax) ) switch ( u2_h(tax) ) {
    case c3__spot: _hill_print_spot(wir_r, fil_f, u2_t(tax)); return;
    case c3__bean: _hill_print_bean(wir_r, fil_f, u2_t(tax)); return;
    case c3__mean: _hill_print_mean(wir_r, fil_f, u2_t(tax)); return;
  }
  fprintf(fil_f, "  {tent!}\n");
}
Example #16
0
File: benx.c Project: Gruelty/urbit
/* u2_bx_bean_print(): print bean stack to FILE *.
*/
void
u2_bx_bean_print(u2_ray  wir_r,
                 FILE *  fil_F,
                 u2_noun zof)                                     //  retain
{
  while ( u2_yes == u2_dust(zof) ) {
    u2_noun i_zof = u2_h(zof);
    u2_noun t_zof = u2_t(zof);

    if ( u2_yes == u2_stud(i_zof) ) {
      _print_term(i_zof, fil_F);
      fprintf(fil_F, "\n");
    } else {
      u2_noun hi_zof = u2_h(i_zof);
      u2_noun ti_zof = u2_t(i_zof);
      u2_weak gol;

      gol = u2_nk_kick(wir_r, ti_zof);
      if ( u2_none == gol ) {
        _print_term(hi_zof, fil_F);
        fprintf(fil_F, ":!\n");
      }
      else {
        u2_noun gal = gol;

        if ( u2_nul == hi_zof ) {
          while ( u2_yes == u2_dust(gal) ) {
            _print_tape(u2_h(gal), fil_F);
            fprintf(fil_F, "\n");
            gal = u2_t(gal);
          }
        }
        else {
          c3_w feq_w = u2_met(3, hi_zof);

          _print_term(hi_zof, fil_F);
          printf(": ");

          while ( u2_yes == u2_dust(gal) ) {
            if ( gal != gol ) {
              _print_space(feq_w + 2, fil_F);
            }
            _print_tape(u2_h(gal), fil_F);
            fprintf(fil_F, "\n");
            gal = u2_t(gal);
          }
        }
        u2_rl_lose(wir_r, gol);
      }
    }
    zof = t_zof;
  }
}
Example #17
0
  static u2_noun                                                  //  produce
  _mint_bake(u2_wire wir_r, 
             u2_noun van,                                         //  retain
             u2_noun sut,                                         //  retain
             u2_noun dab)                                         //  retain
  {
    if ( (u2_nul == dab) ) {
      return _0;
    }
    else {
      u2_noun n_dab, l_dab, r_dab; 
     
      u2_as_trel(dab, &n_dab, &l_dab, &r_dab);
      if ( u2_no == u2_dust(n_dab) ) {
        return u2_bl_bail(wir_r, c3__fail);
      } 
      else {
        u2_noun qn_dab = u2_t(n_dab);
        u2_noun vad;

        switch ( u2_h(qn_dab) ) {
          default: return u2_bl_bail(wir_r, c3__exit);
          case c3__ash: {
            vad = _mint_brew(wir_r, van, sut, u2_yes, u2_t(qn_dab));
            break;
          }
          case c3__elm: {
            vad = _mint_brew(wir_r, van, sut, u2_no, u2_t(qn_dab));
            break;
          }
        }

        if ( (u2_nul == l_dab) && (u2_nul == r_dab) ) {
          return vad;
        }
        else if ( (u2_nul == l_dab) ) {
          return u2_bc
            (wir_r, vad, _mint_bake(wir_r, van, sut, r_dab));
        }
        else if ( (u2_nul == r_dab) ) {
          return u2_bc
            (wir_r, vad, _mint_bake(wir_r, van, sut, l_dab));
        }
        else {
          return u2_bt
            (wir_r, vad,
                    _mint_bake(wir_r, van, sut, l_dab),
                    _mint_bake(wir_r, van, sut, r_dab));
        }
      }
    }
  }
Example #18
0
/* _hill_a_make_gen(): execute gene against core.
*/
static hi_shoa                                                    //  produce
_hill_a_make_gen(u2_wire wir_r,
                 hi_shoz soa,                                     //  retain
                 hi_shoa cor,                                     //  retain
                 u2_noun gen)                                     //  retain
{
  u2_noun gam = _hill_a_mint_gen(wir_r, soa, u2_h(cor), c3__noun, gen);
  u2_noun pro = _hill_nock(wir_r, u2_t(cor), u2_t(gam));
  u2_noun ret = u2_bc(wir_r, u2_rx(wir_r, u2_h(gam)), pro);

  u2_rz(wir_r, gam);
  return ret;
}
Example #19
0
/* _hill_b_fire(): execute and print expression over pit C (with shoe B).
*/
static void                                                       //  produce
_hill_b_fire(u2_wire     wir_r,
             u2_noun     soa,                                     //  retain
             u2_noun     sob,                                     //  retain
             u2_noun     soc,                                     //  retain
             const c3_c* exp_c,                                   //  retain
             const c3_c* out_c)                                   //  retain
{
  u2_noun txt, gam, som;

  txt = u2_bn_string(wir_r, exp_c);
  gam = _hill_b_mint_txt(wir_r, soa, sob, u2_h(soc), c3__noun, txt);

  _hill_b_print_type(wir_r, soa, sob, 0, 0, u2_h(gam));

  if ( out_c && !strcmp("p", out_c) ) {
    u2_rz(wir_r, txt);
    u2_rz(wir_r, gam);
    return;
  }
  u2_bx_boot(wir_r);
  som = _hill_nock(wir_r, u2_t(soc), u2_t(gam));
  u2_bx_show(wir_r);

  if ( u2_none == som ) {
    fprintf(stderr, "{none}\n");
  }
  else {
    if ( !out_c ) {
      _hill_print_noun(wir_r, 0, 0, som);
    } else if ( !strcmp("w", out_c) ) {
      _hill_print_wall(wir_r, 0, 0, som);
    }
    else if ( !strcmp("t", out_c) ) {
      _hill_print_tape(wir_r, 0, som); printf("\n");
    }
    else if ( !strcmp("d", out_c) ) {
      _hill_print_delm(wir_r, 0, som); printf("\n");
    }
    else if ( !strcmp("e", out_c) ) {
      _hill_print_term(wir_r, 0, som); printf("\n");
    }
    else if ( !strcmp("y", out_c) ) {
      _hill_print_type(wir_r, 0, 0, som);
    }
  }
  u2_rz(wir_r, txt);
  u2_rz(wir_r, gam);
  u2_rz(wir_r, som);
}
Example #20
0
/* internals
*/
  static u2_noun                                                  //  transfer
  _tack_in(u2_wire wir_r, 
           u2_noun van,                                           //  retain
           u2_noun sut,                                           //  retain
           u2_noun peh,                                           //  retain
           u2_noun mur,                                           //  retain
           u2_atom axe)                                           //  retain
  {
    if ( u2_no == u2_dust(peh) ) {
      return u2_bc(wir_r, u2_rx(wir_r, axe), u2_rx(wir_r, mur));
    } 
    else {
      u2_noun i_peh = u2_h(peh);
      u2_noun t_peh = u2_t(peh);

      if ( (u2_yes == u2_stud(i_peh)) || (u2_no == u2_h(i_peh)) ) 
      {
        u2_noun pi_peh = (u2_yes == u2_stud(i_peh)) ? 0 : u2_h(u2_t(i_peh));
        u2_noun qi_peh = (u2_yes == u2_stud(i_peh)) ? i_peh : u2_t(u2_t(i_peh));
        u2_noun pok   = j2_mcy(Pt6, ut, fink)
                              (wir_r, van, sut, pi_peh, c3__rite, qi_peh);
        u2_noun wuf   = j2_mby(Pt6, flay)(wir_r, pok);
        u2_noun p_wuf = u2_h(wuf);
        u2_noun q_wuf = u2_t(wuf);
        u2_noun nax   = j2_mbc(Pt3, peg)(wir_r, axe, p_wuf); 
        u2_noun gav   = _tack_in(wir_r, van, q_wuf, t_peh, mur, nax);
        u2_noun p_gav = u2_h(gav);
        u2_noun q_gav = u2_t(gav);
        u2_noun qog   = u2_bc(wir_r, u2_nul, u2_rx(wir_r, qi_peh));
        u2_noun ret   = u2_bc
          (wir_r, u2_rx(wir_r, p_gav),
                  j2_mcy(Pt6, ut, heal)(wir_r, van, sut, qog, p_wuf, q_gav));

        u2_rz(wir_r, qog);
        u2_rz(wir_r, gav);
        u2_rz(wir_r, nax);
        u2_rz(wir_r, wuf);
        u2_rz(wir_r, pok);

        return ret;
      }
      else {
        u2_noun bax   = u2_t(i_peh);
        u2_noun vas   = j2_mcy(Pt6, ut, peek)(wir_r, van, sut, c3__rite, bax);
        u2_noun nax   = j2_mbc(Pt3, peg)(wir_r, axe, bax); 
        u2_noun gav   = _tack_in(wir_r, van, vas, t_peh, mur, nax);
        u2_noun p_gav = u2_h(gav);
        u2_noun q_gav = u2_t(gav);
        u2_noun ret   = u2_bc
          (wir_r, u2_rx(wir_r, p_gav),
                  j2_mcy(Pt6, ut, heal)(wir_r, van, sut, u2_nul, bax, q_gav));
        
        u2_rz(wir_r, gav);
        u2_rz(wir_r, nax);
        u2_rz(wir_r, vas);

        return ret;
      }
    }
  }
Example #21
0
 static u2_noun                                                  //  transfer
 _seek_silk_fum(u2_noun wir_r,
                u2_noun hey,                                     //  retain
                u2_noun qq_tor)
 {
   if ( u2_nul == qq_tor ) {
     return u2_nul;
   }
   c3_assert(u2_nul != hey);
   return u2_bc
     (wir_r, u2_bc(wir_r, u2_rx(wir_r, u2_h(u2_h(qq_tor))),
                          u2_rx(wir_r, u2_t(u2_h(hey)))),
             _seek_silk_fum(wir_r, u2_t(hey), u2_t(qq_tor)));
 }
Example #22
0
/* u2_ds_mine(): 
**
**   Register and/or save core.
*/
u2_noun                                                           //  transfer
u2_ds_mine(u2_wire wir_r,
           u2_noun clu,                                           //  retain
           u2_noun cor)                                           //  transfer
{
  u2_noun bas_r = u2_wire_bas_r(wir_r);

  if ( u2_no == u2_dust(cor) ) {
    return cor;
  } else {
    u2_noun pay = u2_t(cor);
    u2_noun bat = u2_h(cor);
    u2_noun pug = u2_cs_find(bas_r, u2_wire_des_r(wir_r), 0, bat);
    u2_noun xip, bat_xip;
    u2_noun gop;

    if ( u2_none == pug ) {
      pug = u2_nul;
    }
    if ( u2_none == (xip = _ds_scan(pug, cor)) ) {
      gop = u2_rc(bas_r, (xip = _ds_chip(wir_r, clu, cor)), u2_rx(bas_r, pug));

      if ( u2_none == gop ) {
        return cor;
      } else {
        bat_xip = u2_h(u2_t(xip));

        // {c3_c* xip_c=u2_ho_cstring(xip); printf("%s\n", xip_c); free(xip_c);}
        gop = u2_cs_save(bas_r, u2_wire_des_r(wir_r), 0, bat_xip, gop);
        u2_rz(bas_r, gop);
      }
    }
    else bat_xip = u2_h(u2_t(xip));

    if ( bat_xip != bat ) {
      u2_noun cyr = u2_rc(wir_r, u2_rx(wir_r, pay), bat_xip);

      if ( u2_none == cyr ) {
        return cor;
      }
      else {
        u2_rz(wir_r, cor);
        return cyr;
      }
    }
    else return cor;
  }
}
Example #23
0
  static u2_noun                                                  //  transfer
  _seek_silk(u2_wire wir_r, 
             u2_noun van,                                         //  retain
             u2_noun syx,                                         //  retain
             u2_noun tor)                                         //  retain
  {
    u2_noun p_tor, q_tor, pq_tor, qq_tor;
    u2_noun hey, ret;

    u2_as_cell(tor, &p_tor, &q_tor);
    if ( u2_yes == u2_h(q_tor) ) {
      return u2_nul;
    }
    u2_as_cell(u2_t(q_tor), &pq_tor, &qq_tor);
   
    hey = _seek_silk_yew(wir_r, van, syx, qq_tor);
    if ( u2_nul == hey ) {
      return u2_nul;
    }
    if ( u2_ckb_lent(u2_rx(wir_r, hey)) != 
         u2_ckb_lent(u2_rx(wir_r, qq_tor)) ) 
    {
      return u2_bl_error(wir_r, "silk");
    }

    ret = u2_bq
      (wir_r, u2_nul, 
              u2_no,
              j2_mbc(Pt3, peg)(wir_r, pq_tor, _seek_silk_yaw(wir_r, hey)),
              _seek_silk_fum(wir_r, hey, qq_tor));

    u2_rz(wir_r, hey);
    return ret;
  }
Example #24
0
  u2_noun                                                         //  transfer
  j2_mcy(Pt6, ut, gain)(u2_wire wir_r,
                        u2_noun van,                              //  retain
                        u2_noun sut,                              //  retain
                        u2_noun gen)                              //  retain
  {
    u2_ho_jet *jet_j = &j2_mcj(Pt6, ut, gain)[0];

    if ( jet_j->sat_s == u2_jet_live ) {
      return j2_mcx(Pt6, ut, gain)(wir_r, van, sut, gen);
    }
    else {
      u2_noun cor, fol, pro;

      cor = j2_mci(Pt6, ut, gain)(wir_r, van, sut, gen);
      fol = u2_t(cor);

      pro = u2_ho_use(wir_r, jet_j, cor, fol);
      if ( u2_none == pro ) return u2_bl_bail(wir_r, c3__fail);

      u2_rz(wir_r, cor);
      u2_rz(wir_r, fol);

      return pro;
    }
  }
Example #25
0
/* logic
*/
  u2_noun                                                         //  transfer
  j2_mcx(Pt6, ut, bust)(u2_wire wir_r, 
                        u2_noun van,                              //  retain
                        u2_noun sut,                              //  retain
                        u2_noun dib)                              //  retain
  {
    u2_noun yam = j2_mcy(Pt6, ut, burn)(wir_r, van, sut);
    u2_noun yib = u2_bc
      (wir_r,
       u2_bc(wir_r, u2_rx(wir_r, u2_bi_h(wir_r, u2_bi_h(wir_r, yam))),
                    u2_rx(wir_r, dib)),
       u2_rx(wir_r, u2_bi_t(wir_r, yam)));
    u2_noun woo = u2_bc(wir_r, c3__cnbc, u2_blip);
    u2_noun wox = j2_mcy(Pt6, ut, mint)(wir_r, van, sut, c3__noun, woo);
    u2_noun ret = u2_nk_nock(wir_r, yib, u2_t(wox));

    if ( u2_none == ret ) {
      return u2_bl_error(wir_r, "bust-nock");
    }
    u2_rz(wir_r, wox);
    u2_rz(wir_r, woo);
    u2_rz(wir_r, yam);

    return ret;
  }
Example #26
0
/* stag
*/
  u2_noun                                                         //  produce
  j2_mcx(Pt5, stag, fun)(u2_wire wir_r,
                         u2_noun gob,                             //  retain
                         u2_noun sef,                             //  retain
                         u2_noun tub)                             //  retain
  {
    u2_noun vex = u2_bl_good(wir_r, u2_nk_mong(wir_r, sef, u2_rx(wir_r, tub)));
    u2_noun p_vex, q_vex;

    u2_bi_cell(wir_r, vex, &p_vex, &q_vex);

    if ( u2_no == u2_dust(q_vex) ) {
      return vex;
    }
    else {
      u2_noun uq_vex = u2_t(q_vex);
      u2_noun puq_vex, quq_vex;
      u2_noun wag;
      u2_noun ret;

      u2_bi_cell(wir_r, uq_vex, &puq_vex, &quq_vex);
      wag = u2_bc(wir_r, u2_rx(wir_r, gob), u2_rx(wir_r, puq_vex));
      ret = u2_bq(wir_r, u2_rx(wir_r, p_vex),
                         u2_nul,
                         wag,
                         u2_rx(wir_r, quq_vex));

      u2_rz(wir_r, vex);
      return ret;
    }
  }
Example #27
0
/* pfix
*/
  u2_noun                                                         //  produce
  j2_mbx(Pt5, pfix)(u2_wire wir_r, 
                    u2_noun vex,                                  //  retain
                    u2_noun sab)                                  //  retain
  {
    u2_noun p_vex, q_vex;
    
    u2_bi_cell(wir_r, vex, &p_vex, &q_vex);
    if ( u2_no == u2_dust(q_vex) ) {
      return u2_rx(wir_r, vex);
    } 
    else {
      u2_noun uq_vex = u2_t(q_vex);
      u2_noun puq_vex, quq_vex;
      u2_noun yit, p_yit, q_yit;
      u2_noun ret;

      u2_bi_cell(wir_r, uq_vex, &puq_vex, &quq_vex);
      yit = u2_bl_good(wir_r, u2_nk_mong(wir_r, sab, u2_rx(wir_r, quq_vex)));

      u2_bi_cell(wir_r, yit, &p_yit, &q_yit);
      ret = u2_bc
        (wir_r,
         _last(wir_r, p_vex, p_yit),
         u2_rx(wir_r, q_yit));

      u2_rz(wir_r, yit);
      return ret;
    }
  }
Example #28
0
  static u2_noun                                                  //  produce
  _next(u2_wire wir_r,
        u2_noun tub)                                              //  retain
  {
    u2_noun p_tub, q_tub;
    u2_noun zac;

    u2_bi_cell(wir_r, tub, &p_tub, &q_tub);
    if ( u2_no == u2_dust(q_tub) ) {
      return _fail(wir_r, tub);
    } 
    else {
      u2_noun iq_tub = u2_h(q_tub);
      u2_noun tq_tub = u2_t(q_tub);

      zac = _slip(wir_r, iq_tub, p_tub);

      return u2_bc
        (wir_r, zac,
                u2_bq(wir_r, u2_nul,
                             u2_rx(wir_r, iq_tub),
                             u2_rx(wir_r, zac),
                             u2_rx(wir_r, tq_tub)));
    }
  }
Example #29
0
  static u2_noun
  _mint_brew(u2_wire wir_r,
             u2_noun van,
             u2_noun sut,
             u2_flag tov,
             u2_noun gen)
  {
    u2_noun von;
    
    switch ( tov ) {
      default: return u2_bl_bail(wir_r, c3__fail);
      case u2_yes: 
        von = u2_rx(wir_r, van); break;
      case u2_no: 
        von = u2_bn_molt(wir_r, van, j2_ut_van_vet, u2_no, 0); break;
    }
    {
      u2_noun mil = j2_mcy(Pt6, ut, mint)(wir_r, von, sut, c3__noun, gen);
      u2_noun fol = u2_rx(wir_r, u2_t(mil));

      u2_rl_lose(wir_r, mil);
      u2_rl_lose(wir_r, von);
      return fol;
    }
  }
Example #30
0
/* cold
*/
  u2_noun                                                         //  produce
  j2_mcx(Pt5, cold, fun)(u2_wire wir_r,
                         u2_noun cus,                             //  retain
                         u2_noun sef,                             //  retain
                         u2_noun tub)                             //  retain
  {
    u2_noun vex = u2_bl_good(wir_r, u2_nk_mong(wir_r, sef, u2_rx(wir_r, tub)));
    u2_noun p_vex, q_vex;

    u2_bi_cell(wir_r, vex, &p_vex, &q_vex);

    if ( u2_no == u2_dust(q_vex) ) {
      return vex;
    }
    else {
      u2_noun uq_vex = u2_t(q_vex);
      u2_noun quq_vex;
      u2_noun ret;

      u2_bi_cell(wir_r, uq_vex, 0, &quq_vex);
      ret = u2_bq(wir_r, u2_rx(wir_r, p_vex),
                         u2_nul,
                         u2_rx(wir_r, cus),
                         u2_rx(wir_r, quq_vex));

      u2_rz(wir_r, vex);
      return ret;
    }
  }