Пример #1
0
/*
 * (S, N):
 *
 * N is bound to a number with the string representation S.
 */
void integer_of_string(LmnReactCxt *rc,
                       LmnMembrane *mem,
                       LmnAtom a0, LmnLinkAttr t0,
                       LmnAtom a1, LmnLinkAttr t1)
{
  long n;
  char *t;
  const char *s = (const char *)lmn_string_c_str(LMN_STRING(a0));
  t = NULL;
  n = strtol(s, &t, 10);
  if (t == NULL || s == t) {
    LmnSAtom a = lmn_mem_newatom(mem, lmn_functor_intern(ANONYMOUS,
                                                         lmn_intern("fail"),
                                                         1));
    lmn_mem_newlink(mem,
                    a1, t1, LMN_ATTR_GET_VALUE(t1),
                    LMN_ATOM(a), LMN_ATTR_MAKE_LINK(0), 0);
  } else { /* 変換できた */
    lmn_mem_newlink(mem,
                    a1, t1, LMN_ATTR_GET_VALUE(t1),
                    n, LMN_INT_ATTR, 0);
    lmn_mem_push_atom(mem, n, LMN_INT_ATTR);
  }

  lmn_mem_delete_atom(mem, a0, t0);
}
Пример #2
0
BOOL register_initial_rulesets(LmnReactCxt *rc, LmnMembrane *mem, LmnRule rule)
{
  LmnMembrane *m, *next;
  BOOL ok = FALSE;

  for (m = mem->child_head; m; m = next) {
    next = m->next;
    if ((LMN_MEM_NAME_ID(m) == lmn_intern(INITIAL_RULESET_MEM_NAME) ||
         LMN_MEM_NAME_ID(m) == lmn_intern(INITIAL_SYSTEM_RULESET_MEM_NAME)) &&
        lmn_mem_nfreelinks(m, 0) &&
        lmn_mem_atom_num(m) == 0 &&
        lmn_mem_child_mem_num(m) == 0) {
      int i, j;

      for (i = 0; i < lmn_mem_ruleset_num(m); i++) {
        LmnRuleSet rs = lmn_mem_get_ruleset(m, i);

        for (j = 0; j < lmn_ruleset_rule_num(rs); j++) {
          if (LMN_MEM_NAME_ID(m) == lmn_intern(INITIAL_RULESET_MEM_NAME)) {
            lmn_add_initial_rule(lmn_rule_copy(lmn_ruleset_get_rule(rs, j)));
          } else if (LMN_MEM_NAME_ID(m) == lmn_intern(INITIAL_SYSTEM_RULESET_MEM_NAME)) {
            lmn_add_initial_system_rule(lmn_rule_copy(lmn_ruleset_get_rule(rs, j)));
          }
        }
      }

      if (RC_GET_MODE(rc, REACT_MEM_ORIENTED)) {
        lmn_memstack_delete(RC_MEMSTACK(rc), m);
      }
      lmn_mem_delete_mem(mem, m);

      ok = TRUE;
    }
  }

  return ok;
}
Пример #3
0
BOOL register_initial_module(LmnReactCxt *rc, LmnMembrane *mem, LmnRule rule)
{
  static int done = 0;
  int i, j;

  if (done == 1) return FALSE;
  done = 1;

  for (i = 0; i < ARY_SIZEOF(initial_modules); i++) {
    LmnRuleSet rs = lmn_get_module_ruleset(lmn_intern(initial_modules[i]));
    if (rs) {
      for (j = 0; j < lmn_ruleset_rule_num(rs); j++) {
        lmn_add_initial_system_rule(lmn_rule_copy(lmn_ruleset_get_rule(rs, j)));
      }
    }
  }
  return TRUE;
}
Пример #4
0
int lmn_sp_atom_register(const char *name,
                         f_copy f_copy,
                         f_free f_free,
                         f_eq f_eq,
                         f_dump f_dump,
                         f_is_ground f_is_ground)
{
  struct SpecialAtomCallback *c = LMN_MALLOC(struct SpecialAtomCallback);
  c->name = lmn_intern(name),
  c->copy = f_copy;
  c->free = f_free;
  c->eq = f_eq;
  c->dump = f_dump;
  c->is_ground = f_is_ground;

  vec_push(sp_atom_callback_tbl, (LmnWord)c);
  return vec_num(sp_atom_callback_tbl) - 1;
}
Пример #5
0
void init_initial_ruleset(void)
{
  lmn_add_initial_rule(lmn_rule_make_translated(register_initial_rulesets, lmn_intern("register_initial_ruleset")));
  lmn_add_initial_rule(lmn_rule_make_translated(register_initial_module, lmn_intern("register_initial_module")));
}