!759

static S codeSnippetID = "#1002745";

static Lisp code;

static new L<Lisp> memory;

static LogicEngine engine;

p {

  code = snlToTree(loadSnippet(codeSnippetID));

  print(getProgramID() + ": parse result = " + code);

  load("memory");

}

static class LogicEngine implements IEngine {

  Lisp code;

  new L<Lisp> memory;

  new L<S> log;

  new L<Lisp> stm;

  boolean fireOneRuleOnly = true;

  *() {}

  *(Lisp *code, L<Lisp> *memory) {}

  *(S codeText, L<Lisp> *memory) {

    code = snlToTree(codeText);

  }

  void stmAdd(Lisp statement) {

    stm.add(statement);

  }

  Lisp snlMatchFirst(Lisp pat, L<Lisp> list, SNLMatches m) {

    for (Lisp l : list)

      if (snlMatch2(pat, l, m))

        ret l;

    ret null;

  }

  Lisp scanMem(Lisp pat, SNLMatches m) {

    ret snlMatchFirst(pat, memory, m);

  }

  Lisp scanMem(S pat, SNLMatches m) {

    ret snlMatchFirst(snlToTree_cached(pat), memory, m);

  }

  public void memorize(Lisp l) {

    if (!memory.contains(l)) {

      memory.add(l);

      saveMemory();

    }

  }

  void saveMemory() {} // override this for persistence

  public boolean yo(Lisp snl, SNLMatches m) {

    if (scanMem(snl, m) != null)

      ret true;

    if (snlMatch2("i < don't < know < X", snl, m))

      ret scanMem("* < said < X < is < *", m) == null; // TODO: vars probably don't work

    ret false;

  }

  L<Lisp> runSingle(Lisp code) {

    log.add("runSingle " + code);

    LThread thread = new LThread(this, code);

    thread.log = log;

    thread.statements.addAll(stm);

    //print("Statements: " + structure(thread.statements));

    ret thread.run() ? thread.output : null;

  }

  // run multiple rules

  L<Lisp> runMulti(Lisp code) {

    assertTrue(isJuxta(code));

    new L<Lisp> out;

    for (Lisp sub : code) {

      L<Lisp> l = runSingle(sub);

      if (l != null) { // success

        out.addAll(l);

        if (fireOneRuleOnly)

          break;

      }

    }

    ret out;

  }

  L<Lisp> run() {

    ret isJuxta(code)

      ? runMulti(code) 

      : runSingle(code);

  }

}

!include #1002752 // newest LThread

static S allToText(L<Lisp> trees) {

  new L<S> l;

  for (Lisp tree : trees)

    l.add(snlToText(tree));

  ret joinLines(l);

}

synchronized answer {

  if (!attn()) ret null;

  if (match("log " + parseSnippetID(programID()), s))

    ret engine == null ? "nullie haven't run yet": slackSnippet(fromLines(engine.log));

  if (match("memory " + parseSnippetID(programID()), s))

    ret slackSnippet(allToText(memory));

  // convert to SNL first

  s = or((S) callOpt/*Safe*/(getBot ("#1002700"), "naiveSNL", s), s);

  Lisp in = snlToTree(s);

  Lisp statement = snlToTree("user < says < [" + snlFromTree(in) + "]");

  engine = new LogicEngine(code, memory) {

    void saveMemory() {

      save("memory");

    }

  };

  engine.stmAdd(statement);

  L<Lisp> out = engine.run();

  if (nempty(out))

    ret "[SNL: " + snlFromTree(in) + "])\n" + allToText(out);

}

static Lisp quickrun(L<Lisp> memory, S userInput) {

  engine = new LogicEngine(code, memory);

  Lisp statement = snlToTree("user < says < [" + userInput + "]");

  engine.stmAdd(statement);

  ret snlMakeJuxta(engine.run());

}