Examples with Term org.jpl7.Term used on opensource projects

Example 46 with Term

use of org.jpl7.Term in project packages-jpl by SWI-Prolog.

the class TestGC method main.

public static void main(String[] argv) {
    int max;
    Query.hasSolution("consult('test.pl')");
    if (argv.length > 0)
        max = Integer.parseInt(argv[0]);
    else
        max = 10;
    System.out.println(max + " iterations");
    for (int i = 0; i < max; i++) {
        Query q = new Query("testpred", new Term[] { new Atom("a" + i) });
        q.oneSolution();
    }
    Query.hasSolution("stats");
}

Example 47 with Term

use of org.jpl7.Term in project packages-jpl by SWI-Prolog.

the class Time method test_3.

static void test_3() {
    Variable Y = new Variable("Y");
    Query query = new Query("noop_nobind", new Term[] { tree, Y });
    System.out.print("noop_nobind");
    for (int i = 0; i < num_trials; ++i) {
        timer.start();
        query.hasSolution();
        timer.stop();
        data[3][i] = timer.getElapsedTimeInMillis();
        System.out.print(".");
    }
    System.out.println("done");
}

Example 48 with Term

use of org.jpl7.Term in project packages-jpl by SWI-Prolog.

the class Time method test_1.

static void test_1() {
    Query query = new Query("traverse", new Term[] { tree });
    System.out.print("traverse");
    for (int i = 0; i < num_trials; ++i) {
        timer.start();
        query.hasSolution();
        timer.stop();
        data[1][i] = timer.getElapsedTimeInMillis();
        System.out.print(".");
    }
    System.out.println("done");
}

Example 49 with Term

use of org.jpl7.Term in project packages-jpl by SWI-Prolog.

the class Term method getTerm.

/**
 * create and return a org.jpl7.Term representation of the given Prolog term
 *
 * @param vars_to_Vars
 *            A Map from Prolog variables to org.jpl7.Variable instances
 * @param term
 *            The Prolog term (in a term_t holder) to convert
 * @return The converted Term subclass instance.
 */
protected static Term getTerm(Map<term_t, Variable> vars_to_Vars, term_t term) {
    StringHolder hString;
    IntHolder hInt;
    Int64Holder hInt64;
    ObjectHolder hObject;
    switch(Prolog.term_type(term)) {
        case // 1
        Prolog.VARIABLE:
            for (Iterator<term_t> i = vars_to_Vars.keySet().iterator(); i.hasNext(); ) {
                // a previously seen Prolog
                term_t varX = (term_t) i.next();
                // variable
                if (Prolog.compare(varX, term) == 0) {
                    // return the
                    return (Term) vars_to_Vars.get(varX);
                // associated JPL
                // Variable
                }
            }
            // otherwise, the Prolog variable in term has not been seen before
            // allocate a new (sequentially
            Variable Var = new Variable();
            // named) Variable to represent it
            // this should become redundant...
            Var.term_ = term;
            // use Hashtable(var,null), but only
            vars_to_Vars.put(term, Var);
            // need set(var)
            return Var;
        case // 2
        Prolog.ATOM:
            hString = new StringHolder();
            // ignore return val; assume
            Prolog.get_atom_chars(term, hString);
            // success...
            return new Atom(hString.value, "text");
        case // 5
        Prolog.STRING:
            hString = new StringHolder();
            // ignore return val; assume
            Prolog.get_string_chars(term, hString);
            // success...
            return new Atom(hString.value, "string");
        case // 3
        Prolog.INTEGER:
            hInt64 = new Int64Holder();
            if (Prolog.get_integer(term, hInt64)) {
                // Java long...
                return new org.jpl7.Integer(hInt64.value);
            } else {
                hString = new StringHolder();
                if (Prolog.get_integer_big(term, hString)) {
                    // System.out.println("bigint = " + hString.value);
                    return new org.jpl7.Integer(new java.math.BigInteger(hString.value));
                } else {
                    // arbitrary
                    return new org.jpl7.Integer(-3);
                }
            }
        case // 4
        Prolog.FLOAT:
            DoubleHolder hFloatValue = new DoubleHolder();
            // assume it succeeds...
            Prolog.get_float(term, hFloatValue);
            return new org.jpl7.Float(hFloatValue.value);
        // 6
        case Prolog.COMPOUND:
        case // 9
        Prolog.LIST_PAIR:
            hString = new StringHolder();
            hInt = new IntHolder();
            // assume it succeeds
            Prolog.get_name_arity(term, hString, hInt);
            Term[] args = new Term[hInt.value];
            // term_t term1 = Prolog.new_term_refs(hArity.value);
            for (int i = 1; i <= hInt.value; i++) {
                term_t termi = Prolog.new_term_ref();
                Prolog.get_arg(i, term, termi);
                args[i - 1] = Term.getTerm(vars_to_Vars, termi);
            }
            return new Compound(hString.value, args);
        case // 7
        Prolog.LIST_NIL:
            return JPL.LIST_NIL;
        case // 8
        Prolog.BLOB:
            hObject = new ObjectHolder();
            if (Prolog.get_jref_object(term, hObject)) {
                if (hObject.value == null) {
                    return JPL.JNULL;
                } else {
                    return new JRef(hObject.value);
                }
            } else {
                throw new JPLException("unsupported blob type passed from Prolog");
            }
        default:
            // should never happen
            throw new JPLException("unknown term type=" + Prolog.term_type(term));
    }
}

Example 50 with Term

use of org.jpl7.Term in project packages-jpl by SWI-Prolog.

the class Variable method put.

/**
 * To put a Variable, we must check whether a (non-anonymous) variable with
 * the same name has already been put in the Term. If one has, then the
 * corresponding Prolog variable has been stashed in the varnames_to_vars
 * Map, keyed by the Variable name, so we can look it up and reuse it (this
 * way, the sharing of variables in the Prolog term reflects the sharing of
 * Variable names in the Term. Otherwise, if this Variable name has not
 * already been seen in the Term, then we put a new Prolog variable and add
 * it into the Map (keyed by this Variable name).
 *
 * @param varnames_to_vars
 *            A Map from variable names to Prolog variables.
 * @param term
 *            A (previously created) term_t which is to be set to a (new or
 *            reused) Prolog variable.
 */
protected final void put(Map<String, term_t> varnames_to_vars, term_t term) {
    term_t var;
    // if this var is anonymous or as yet unseen, put a new Prolog variable
    if (this.name.equals("_") || (var = (term_t) varnames_to_vars.get(this.name)) == null) {
        this.term_ = term;
        // i.e. first var in is #0
        this.index = varnames_to_vars.size();
        // etc.
        Prolog.put_variable(term);
        if (!this.name.equals("_")) {
            varnames_to_vars.put(this.name, term);
        }
    } else {
        this.term_ = var;
        Prolog.put_term(term, var);
    }
}