/* _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;
      }
    }
  }
}
Exemple #2
0
/* nock_mool(): fast internal mink interface.  Arguments transferred.
*/
u2_noun
_nock_mool(u2_noun  bus,
           u2_noun  fol,
           u2_kode* pon)
{
    u2_noun hib, gal;

    c3_assert(u2_yes == *pon);

    while ( 1 ) {
        u2_tx_did_hop(u2_Wire, 1);

        if ( u2_no == u2du(fol) ) {
            *pon = 2;
            u2z(bus);
            u2z(fol);
            return u2_cm_wail();
        }
        else {
            hib = u2fh(fol);
            gal = u2ft(fol);
        }

        if ( u2_yes == u2du(hib) ) {
            u2_noun poz, riv;
            u2_kode h_pon = 0, t_pon = 0;

            poz = _nock_mool(u2k(bus), u2k(hib), &h_pon);
            if ( 2 == h_pon ) {
                *pon = 2;
                u2z(bus);
                u2z(fol);
                return poz;
            }

            riv = _nock_mool(bus, u2k(gal), &t_pon);
            u2z(fol);
            if ( 2 == t_pon ) {
                *pon = 2;
                u2z(poz);
                return riv;
            }

            if ( (1 == h_pon) || (1 == t_pon) ) {
                u2_noun lal;

                *pon = 1;

                if ( 0 == h_pon ) {
                    u2z(poz);
                    lal = riv;
                } else if ( 0 == t_pon ) {
                    u2z(riv);
                    lal = poz;
                } else {
                    lal = u2_ckb_weld(poz, riv);
                }
                return lal;
            }
            return u2_cn_cell(poz, riv);
        }
        else switch ( hib ) {
            default:
                *pon = 2;
                u2z(bus);
                u2z(fol);
                return u2_cm_wail();

            case 0: {
                if ( u2_no == u2_cr_ud(gal) ) {
                    *pon = 2;
                    u2z(bus);
                    u2z(fol);
                    return u2_cm_wail();
                }
                else {
                    u2_weak pro = u2_cr_at(gal, bus);

                    if ( u2_none == pro ) {
                        *pon = 2;
                        u2z(bus);
                        u2z(fol);
                        return u2_cm_wail();
                    }
                    else {
                        pro = u2k(pro);
                        u2z(bus);
                        u2z(fol);

                        return pro;
                    }
                }
            }
            case 1: {
                u2_noun pro = u2k(gal);

                u2z(bus);
                u2z(fol);
                return pro;
            }
            c3_assert(!"not reached");

            case 2: {
                if ( (u2_no == u2du(gal)) || (u2_no == u2du(u2fh(gal))) ) {
                    *pon = 2;
                    u2z(bus);
                    u2z(fol);
                    return u2_cm_wail();
                }
                else {
                    u2_noun neb;

                    neb = _nock_mool(bus, u2k(gal), pon);
                    u2z(fol);
                    if ( 0 != *pon ) {
                        return neb;
                    }

                    bus = u2k(u2fh(neb));
                    fol = u2k(u2ft(neb));
                    u2z(neb);
                    continue;
                }
            }
            c3_assert(!"not reached");

            case 3: {
                u2_noun gof, pro;

                gof = _nock_mool(bus, u2k(gal), pon);
                u2z(fol);
                if ( 0 != *pon ) {
                    return gof;
                }

                pro = u2du(gof);
                u2z(gof);

                return pro;
            }
            c3_assert(!"not reached");

            case 4: {
                u2_noun gof, pro;

                gof = _nock_mool(bus, u2k(gal), pon);
                u2z(fol);
                if ( 0 != *pon ) {
                    return gof;
                }

                if ( u2_none == (pro = u2_rl_vint(u2_Wire, gof)) ) {
                    *pon = 2;
                    u2z(gof);
                    return u2_cm_wail();
                }
                u2z(gof);

                return pro;
            }
            c3_assert(!"not reached");

            case 5: {
                u2_noun gof, pro;

                gof = _nock_mool(bus, u2k(gal), pon);
                u2z(fol);
                if ( 0 != *pon ) {
                    return gof;
                }

                if ( u2_no == u2du(gof) ) {
                    *pon = 2;
                    u2z(gof);
                    return u2_cm_wail();
                }
                pro = u2_cr_sing(u2h(gof), u2t(gof));
                u2z(gof);

                return pro;
            }
            c3_assert(!"not reached");

            case 6: {
                u2_noun b_gal, cd_gal, c_gal, d_gal;

                if ( u2_no == u2_cr_cell(gal, &b_gal, &cd_gal) ) {
                    *pon = 2;
                    u2z(bus);
                    u2z(fol);
                    return u2_cm_wail();
                }
                else {
                    u2_noun tys, nex;

                    tys = _nock_mool(u2k(bus), u2k(b_gal), pon);
                    if ( 0 != *pon ) {
                        u2z(bus);
                        u2z(fol);
                        return tys;
                    }

                    if ( u2_no == u2_cr_cell(cd_gal, &c_gal, &d_gal) ) {
                        *pon = 2;
                        u2z(bus);
                        u2z(fol);
                        return u2_cm_wail();
                    }

                    if ( 0 == tys ) {
                        nex = u2k(c_gal);
                    } else if ( 1 == tys ) {
                        nex = u2k(d_gal);
                    } else {
                        *pon = 2;
                        u2z(bus);
                        u2z(fol);
                        return u2_cm_wail();
                    }

                    u2z(fol);
                    fol = nex;
                    continue;
                }
            }
            c3_assert(!"not reached");

            case 7: {
                u2_noun b_gal, c_gal;

                if ( u2_no == u2_cr_cell(gal, &b_gal, &c_gal) ) {
                    *pon = 2;
                    u2z(bus);
                    u2z(fol);
                    return u2_cm_wail();
                }
                else {
                    u2_noun bod, nex;

                    bod = _nock_mool(bus, u2k(b_gal), pon);
                    if ( 0 != *pon ) {
                        u2z(fol);
                        return bod;
                    }

                    nex = u2k(c_gal);
                    u2z(fol);

                    bus = bod;
                    fol = nex;
                    continue;
                }
            }
            c3_assert(!"not reached");

            case 8: {
                u2_noun b_gal, c_gal;

                // c3_assert(!"got 8 (mink)!");
                if ( u2_no == u2_cr_cell(gal, &b_gal, &c_gal) ) {
                    *pon = 2;
                    u2z(bus);
                    u2z(fol);
                    return u2_cm_wail();
                }
                else {
                    u2_noun wib, bod, nex;

                    wib = _nock_mool(u2k(bus), u2k(b_gal), pon);
                    if ( 0 != *pon ) {
                        u2z(bus);
                        u2z(fol);
                        return wib;
                    }

                    bod = u2nc(wib, bus);
                    nex = u2k(c_gal);
                    u2z(fol);

                    bus = bod;
                    fol = nex;
                    continue;
                }
            }
            c3_assert(!"not reached");

            case 9: {
                u2_noun b_gal, c_gal;

                if ( (u2_no == u2_cr_cell(gal, &b_gal, &c_gal)) ||
                        (u2_no == u2ud(b_gal)) )
                {
                    *pon = 2;
                    u2z(bus);
                    u2z(fol);
                    return u2_cm_wail();
                }
                else {
                    u2_noun seb;
                    u2_weak xip;

                    seb = _nock_mool(bus, u2k(c_gal), pon);
                    u2z(fol);
                    if ( 0 != *pon ) {
                        return seb;
                    }

                    u2_tx_sys_bit(u2_Wire, u2_yes);
                    xip = u2_ds_find(u2_Wire, seb);
                    u2_tx_sys_bit(u2_Wire, u2_no);

                    if ( u2_none != xip ) {
                        u2_noun pro;

                        u2_tx_sys_bit(u2_Wire, u2_yes);
                        pro = u2_ho_kicq(u2_Wire, xip, seb, b_gal, pon);
                        u2_tx_sys_bit(u2_Wire, u2_no);
                        u2z(seb);

                        if ( u2_none == pro ) {
                            *pon = 2;
                            return u2_cm_wail();
                        }
                        else return pro;
                    }
                    else {
                        u2_noun nex = u2_cr_at(b_gal, seb);

                        if ( u2_none == nex ) {
                            *pon = 2;
                            u2z(seb);
                            return u2_cm_wail();
                        }
                        bus = seb;
                        fol = u2k(nex);
                        continue;
                    }
                }
            }
            c3_assert(!"not reached");

            case 10: {
                u2_noun p_gal, q_gal;

                if ( u2_no == u2_cr_cell(gal, &p_gal, &q_gal) ) {
                    *pon = 2;
                    u2z(bus);
                    u2z(fol);
                    return u2_cm_wail();
                }
                else {
                    u2_noun zep, hod, nex;

                    if ( u2_yes == u2du(p_gal) ) {
                        u2_noun b_gal = u2fh(p_gal);
                        u2_noun c_gal = u2ft(p_gal);
                        u2_noun d_gal = q_gal;

                        hod = _nock_mool(u2k(bus), u2_ct(c_gal), pon);
                        if ( 0 != *pon ) {
                            u2z(fol);
                            return hod;
                        }

                        zep = u2k(b_gal);
                        nex = u2k(d_gal);
                        u2z(fol);
                    }
                    else {
                        u2_noun b_gal = p_gal;
                        u2_noun c_gal = q_gal;

                        zep = u2k(b_gal);
                        hod = u2_nul;
                        nex = u2k(c_gal);

                        u2z(fol);
                    }

                    return _nock_hint(zep, hod, bus, nex, pon);
                }
            }

            case 11: {
                u2_noun gof;

                gof = _nock_mool(bus, u2k(gal), pon);
                u2z(fol);
                if ( 0 != *pon ) {
                    return gof;
                }

                return _nock_pray_mool(gof, pon);
            }
            c3_assert(!"not reached");
            }
    }
}
Exemple #3
0
  u2_noun                                                         //  produce
  j2_mbc(Pt5, repg)(u2_wire wir_r,
                    u2_noun lub,
                    u2_noun rad,
                    u2_noun rep)                                  //  retain
  {
    c3_y* lub_y = u2_cr_tape(lub);
    c3_y* rad_y = u2_cr_tape(rad);
    c3_y* rep_y = u2_cr_tape(rep);



    char* rec = (char*)lub_y;
    char* end;
    while(*rec != 0) {
      if(*rec == '\\') {
        rec++;
        switch (*rec) {
        case 'P':
        case 'p':
          free(lub_y);
          free(rad_y);
          return u2_nul;
        case 'Q':
          end = strstr(rec, "\\E");
          if(end == NULL) rec += strlen(rec) - 1;
          else rec = end;
        }
        rec++;
      }
      else if(*rec == '(') {
        rec++;
        if(*rec == '?') {
          rec++;
          if(*rec != ':') {
            free(lub_y);
            free(rad_y);
            return u2_nul;
          }
          rec++;
        }
      }
      else
        rec++;
    }

    cre2_regexp_t * rex;
    cre2_options_t * opt;

    opt = cre2_opt_new();
    if (opt) {
      cre2_opt_set_log_errors(opt, 0);
      cre2_opt_set_encoding(opt, CRE2_Latin1);
      cre2_opt_set_perl_classes(opt, 1);
      cre2_opt_set_one_line(opt, 1);
      cre2_opt_set_longest_match(opt, 1);
      rex = cre2_new((const char *)lub_y, strlen((char *)lub_y), opt);
      if (rex) {
        if (!cre2_error_code(rex)) {
          int text_len = strlen((char *)rad_y);
          cre2_string_t matches[1];
          int ic = 0;

          u2_noun ret = u2_nul;
          while (ic <= text_len) {
            int match = cre2_match(rex, (const char*)rad_y, text_len, ic, text_len, CRE2_ANCHOR_START, matches, 1);

            if (!match) {
              if(rad_y[ic])
                ret = u2_cn_cell((u2_atom)rad_y[ic], ret);
              ic++;
            }
            else {
              int mlen = matches[0].length;
              if (mlen == 0) {
                ret = u2_ckb_weld(u2_ckb_flop(u2_ci_tape((char *) rad_y+ic)), u2_ckb_flop(u2_ci_tape((char *)rep_y)));
                ic = text_len + 1;
              }
              else {
                ret = u2_ckb_weld(u2_ckb_flop(u2_ci_tape((char *)rep_y)), ret);
                ic += mlen;
              }
            }
          }
          cre2_opt_delete(opt);
          cre2_delete(rex);
          free(lub_y);
          free(rad_y);
          free(rep_y);
          return u2_cn_cell(u2_nul, u2_ckb_flop(ret));
        }
        else {
          // Compiling the regular expression failed
          cre2_opt_delete(opt);
          cre2_delete(rex);
          free(lub_y);
          free(rad_y);
          return u2_nul;
        }
        cre2_opt_delete(opt);
        cre2_delete(rex);
      }
      else {
        // rex Allocation Error
        cre2_opt_delete(opt);
        free(lub_y);
        free(rad_y);
        u2_bl_bail(wir_r, c3__exit);
      }
      cre2_opt_delete(opt);
    }
    // opt Allocation Error
    free(lub_y);
    free(rad_y);
    u2_bl_bail(wir_r, c3__exit);
    return u2_nul;
  }