Uses of Class
jpl.fli.term_t

Packages that use term_t

Package	Description
jpl
jpl.fli

Uses of term_t in jpl

Fields in jpl declared as term_t

Modifier and Type	Field and Description
protected term_t	Variable.term_ A reference to the term_t (a reference to a term in to Prolog Engine) to which this term is bound.

Methods in jpl that return term_t

Modifier and Type	Method and Description
protected static term_t	Term.terms_to_term_ts(Hashtable var_table, Term[] arg) This static method converts an array of Terms to a *consecutive* sequence of term_t objects.

Methods in jpl with parameters of type term_t

Modifier and Type	Method and Description
protected static Term[]	Term.from_term_t(Hashtable vars, int n, term_t term0) This method calls from_term_t on each term in the consecutive list of term_ts.
protected static Term	Variable.from_term_t(Hashtable vars, term_t term) Converts a term_t to a Variable.
protected static Term	Term.from_term_t(Hashtable vars, term_t term) We do some type analysis on the term_t then forward the call to the appropriate class
protected static Term	String_JPL.from_term_t(Hashtable vars, term_t term) Converts a term_t to a String.
protected static Term	Long_JPL.from_term_t(Hashtable vars, term_t term) Converts a term_t to an Atom.
protected static Term	Integer_JPL.from_term_t(Hashtable vars, term_t term) Converts a term_t to an Atom.
protected static Term	Float_JPL.from_term_t(Hashtable vars, term_t term) Converts a term_t to an Atom.
protected static Term	Compound.from_term_t(Hashtable vars, term_t term) Converts a term_t to a Compound.
protected static Term	Atom.from_term_t(Hashtable vars, term_t term) Converts a term_t to an Atom.
protected void	Variable.put(Hashtable var_table, term_t term) To put a Variable, we want to be careful that the variable does not already occur in the Term.
protected abstract void	Term.put(Hashtable var_table, term_t term) Cache the reference to the Prolog term_t here.
protected void	String_JPL.put(Hashtable var_table, term_t term) To put an String in a term, we put the characters of the String into the term_t.
protected void	Long_JPL.put(Hashtable var_table, term_t term) To put an Long in a term, we put an integer.
protected void	Integer_JPL.put(Hashtable var_table, term_t term) To put an Integer in a term, we put an integer.
protected void	Float_JPL.put(Hashtable var_table, term_t term) To put an Float in a term, we put the value field into the term_t as a floet.
protected void	Compound.put(Hashtable var_table, term_t term) To put an Compound in a term, we create a sequence of term_t references from the Term terms_to_term_t method, and then use the Prolog cons_functor_v method to create a Prolog compound.
protected void	Atom.put(Hashtable var_table, term_t term) To put an Atom in a term, we put an atom_t into the term_t.

Uses of term_t in jpl.fli

Methods in jpl.fli that return term_t

Modifier and Type	Method and Description
static term_t	Prolog.copy_term_ref(term_t from)
static term_t	Prolog.exception(qid_t qid)
static term_t	Prolog.new_term_ref()
static term_t	Prolog.new_term_refs(int n)

Methods in jpl.fli with parameters of type term_t

Modifier and Type	Method and Description
static int	Prolog.call_predicate(module_t m, int debug, predicate_t pred, term_t t0)
static int	Prolog.call(term_t t, module_t m)
static void	Prolog.cons_functor_v(term_t h, functor_t fd, term_t a0)
protected static void	Prolog.cons_functor(term_t h, functor_t f, term_t[] terms)
protected static void	Prolog.cons_functor(term_t h, functor_t f, term_t[] terms)
static void	Prolog.cons_list(term_t l, term_t h, term_t t)
static term_t	Prolog.copy_term_ref(term_t from)
static int	Prolog.get_arg(int index, term_t t, term_t a)
static int	Prolog.get_atom_chars(term_t t, StringHolder a)
static int	Prolog.get_atom(term_t t, atom_t a)
static int	Prolog.get_chars(term_t t, StringHolder s, int flags)
static int	Prolog.get_float(term_t t, DoubleHolder d)
static int	Prolog.get_functor(term_t t, functor_t f)
static int	Prolog.get_head(term_t l, term_t h)
static int	Prolog.get_integer(term_t t, IntHolder i)
static int	Prolog.get_list_chars(term_t l, StringHolder s, int flags)
static int	Prolog.get_list(term_t l, term_t h, term_t t)
static int	Prolog.get_long(term_t t, LongHolder l)
static int	Prolog.get_module(term_t t, module_t module)
static int	Prolog.get_name_arity(term_t t, atom_t name, IntHolder arity)
static int	Prolog.get_nil(term_t l)
static int	Prolog.get_pointer(term_t t, PointerHolder ptr)
static int	Prolog.get_string(term_t t, StringHolder s)
static int	Prolog.get_tail(term_t l, term_t t)
static int	Prolog.is_atom(term_t t)
static int	Prolog.is_atomic(term_t t)
static int	Prolog.is_compound(term_t t)
static int	Prolog.is_float(term_t t)
static int	Prolog.is_functor(term_t t, functor_t f)
static int	Prolog.is_integer(term_t t)
static int	Prolog.is_list(term_t t)
static int	Prolog.is_number(term_t t)
static int	Prolog.is_string(term_t t)
static int	Prolog.is_variable(term_t t)
static qid_t	Prolog.open_query(module_t m, int flags, predicate_t pred, term_t t0)
static void	Prolog.put_atom_chars(term_t t, String chars)
static void	Prolog.put_atom(term_t t, atom_t a)
static void	Prolog.put_float(term_t t, double f)
static void	Prolog.put_functor(term_t t, functor_t functor)
static void	Prolog.put_integer(term_t t, long i)
static void	Prolog.put_list_chars(term_t t, String chars)
static void	Prolog.put_list(term_t l)
static void	Prolog.put_nil(term_t l)
static void	Prolog.put_pointer(term_t t, PointerHolder ptr)
static void	Prolog.put_string_chars(term_t t, String chars)
static void	Prolog.put_term(term_t t1, term_t t2)
static void	Prolog.put_variable(term_t t)
static void	Prolog.reset_term_refs(term_t r)
static int	Prolog.strip_module(term_t in, module_t m, term_t out)
static int	Prolog.term_type(term_t t)
static String	term_t.toString(int n, term_t term0) This static method converts a term_t, which is assumed to contain a reference to a *consecutive* list of term_t references to a String representation of a list of terms, in this case, a comma separated list.
static int	Prolog.unify(term_t t1, term_t t2)