!752

!1002813 // gnu prolog

import gnu.prolog.vm.*;

import gnu.prolog.term.*;

import gnu.prolog.database.*;

static S prolog = [[

  here([]).

  here2([hello]).

]];

static int query(Interpreter intp, Term term) ctex {

  try {

    Interpreter.Goal goal = intp.prepareGoal(term);

	  ret intp.execute(goal);

	  // todo: stop goal?

	 } catch (Exception e) {

	   print("fail " + e);

	   ret 0;

	 }

}

static Interpreter interpreter;

p {

  new Environment env;

  S streamName = "someinput";

  Reader reader = new StringReader(prolog);

  new PrologTextLoader(env.getPrologTextLoaderState(), reader, streamName);

	List<PrologTextLoaderError> errors = env.getLoadingErrors();

	for (PrologTextLoaderError error : errors) {

		printStackTrace(error);

	}

  interpreter = env.createInterpreter();

  env.runInitialization(interpreter);

  getIt("here");

  getIt("here2");

}

static void getIt(S function) {

  VariableTerm x = new VariableTerm("X");

  printVar(x);

  Term term = new CompoundTerm(function, new Term[] {x});

  print("Term: " + term);

  print(query(interpreter, term));

  printVar(x);

}

static void printVar(VariableTerm x) {

  Term t = x.dereference();

  print(x.name + " = " + t + " (" + t.getClass().getName() + ")");

  print("  Lisp: " + toLisp(t));

}

static Lisp toLisp(Term term) {

  if (term instanceof AtomTerm)

    ret lisp(((AtomTerm) term).value);

  if (term instanceof VariableTerm)

    ret lisp(((VariableTerm) term).name);

  if (term instanceof CompoundTerm) {

    CompoundTerm c = cast term;

    Lisp l = new Lisp(c.tag.functor.value);

    for (Term arg : c.args)

      l.add(toLisp(arg));

    ret l;

  }

  ret lisp("? " + term.getClass().getName());

}