!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());
}

Began life as a copy of #1002815