// class for linking Java methods to NL

static class Native {

  Lisp snl;

  SNLMatches m;

  SNLMatches trans;

  boolean printExceptions;

  int exceptions;

  L<S> ins, strings;

  *() {} // good to have

  *(Lisp *snl) {}

  // assume it's a Lisp structure from another bot -

  // restructure to import it

  /* *(O o) {

    snl = (Lisp) restructure(o);

  }*/

  *(S s) { snl = snlToTree(s); }

  boolean match(S pat) {

    m = new SNLMatches;

    trans = new SNLMatches;

    Lisp tree = snlToTree_cached(pat);

    ins = new L;

    strings = new L;

    tree = findInVariables(tree, ins, strings);

    //print("tree now: " + tree);

    if (!snlMatch2(tree, snl, trans))

      ret false;

    for (S in : ins)

      if (get(in) == null)

        ret false;

    for (S string : strings)

      if (get(string) == null || !get(string).isEmpty())

        ret false;

    ret true;

  }

  Lisp findInVariables(Lisp tree, L<S> ins, L<S> strings) {

    if (tree == null) ret tree;

    if (tree.isEmpty()) {

      if (tree.head.startsWith("in S ")) {

        S var = dropPrefix("in S ", tree.head);

        if (startsWithUpperCase(var)) {

          if (!strings.contains(var))

            strings.add(var);

          ret lisp(var);

        }

      }

      if (tree.head.startsWith("in ")) {

        S var = dropPrefix("in ", tree.head);

        if (startsWithUpperCase(var)) {

          if (!ins.contains(var))

            ins.add(var);

          ret lisp(var);

        }

      }

      ret tree;

    } else {

      // recurse

      Lisp lisp = new Lisp(tree.head);

      for (Lisp child : tree)

        lisp.add(findInVariables(child, ins, strings));

      ret lisp;

    }

  }

  Lisp get(S var) {

    Lisp val = trans.get(var);

    if (!isVar(val)) ret val;

    ret getOuter(val.raw());

  }

  // if only one in var

  Lisp get() {

    ret get(anyInVar());

  }

  // ditto  

  S str() {

    ret str(anyInVar());

  }

  S anyInVar() {

    if (!empty(ins)) ret first(ins);

    ret first(strings);

  }

  boolean isVar(Lisp l) {

    ret l != null && l.isEmpty() && startsWithUpperCase(l.raw());

  }

  // called from outside native

  Lisp getOuter(S var) {

    ret m.get(var);

  }

  // called from inside native

  S str(S var) {

    Lisp val = get(var);

    if (val == null) fail("variable " + quote(var) + " not set");

    if (!val.isEmpty()) fail("variable " + quote(var) + " not a string: " + struct(val));

    ret unquote(val.raw());

  }

  S strOuter(S var) {

    Lisp val = getOuter(var);

    if (val == null) fail("variable " + quote(var) + " not set");

    if (!val.isEmpty()) fail("variable " + quote(var) + " not a string: " + struct(val));

    ret unquote(val.raw());

  }

  // may throw an exception if variable problem (already set to different value)

  void set(S var, O val) {

    if (val instanceof List) val = structure(val); // TODO

    Lisp lisp = val instanceof Lisp ? (Lisp) val : lisp(quote(main.str(val)));

    Lisp outer = trans.get(var);

    if (isVar(outer)) {

      if (!m.put(trans.raw(var), lisp))

        fail();

    } else

      if (!eq(lisp, outer)) {

        //print("neq " + lisp + " != " + outer);

        fail();

      }

  }

  boolean callExternal(O bot) {

    try {

      O copy = newObject(main.getClass(bot, "main$Native"), quickExport(snl, bot));

      //O copy = quickExport(this, bot);

      if (!isTrue(callOpt(bot, "yo", copy)))

        ret false;

      m = (SNLMatches) quickImport(main.get(copy, "m"));

      ret true;

    } catch (Exception e) {

      handle(e);

      ret false;

    }

  }

  boolean callExternal(Method yo) {

    try {

      Class c = yo.getDeclaringClass();

      //print("Declaring class: " + c + " (" + identityHashCode(c) + ")");

      O copy = newObject(main.getClass(c, "main$Native"), quickExport(snl, c));

      if (!isTrue(yo.invoke(null, copy)))

        ret false;

      m = (SNLMatches) quickImport(main.get(copy, "m"));

      ret true;

    } catch (Exception e) {

      handle(e);

      ret false;

    }

  }

  void handle(Throwable t) {

    if (printExceptions)

      printStackTrace(t);

    ++exceptions;

  }

}