Uses of Class
com.svincent.moksa.PrologTerm

Packages that use PrologTerm

com.svincent.moksa

An implementation of a Warren's Abstract Machine and associated builtin predicates, to conform to ISO Prolog.

Uses of PrologTerm in com.svincent.moksa

Subclasses of PrologTerm in com.svincent.moksa

class	CompoundTerm A compoundTerm is a Prolog tree constant (normally of the form f(x1, x2, ..., xn), where f is known as the compoundTerm's functor, and x1 through xn are known as the term's subterms.
static class	Io.PrologInput An identifier for an input stream.
class	Io.PrologInputStream A wrapper for a Java InputStream.
static class	Io.PrologOutput An identifier for an output stream.
static class	Io.PrologOutputStream
class	Io.PrologReader A wrapper for a Java Reader.
static class	Io.PrologWriter
static class	Io.StreamIdentifier An identifier for a currently open input or output stream.
class	JavaTerm A subclass of PrologTerm which contains a reference to a Java object.
class	Variable Represents a Variable: a WAM term that contains (possibly) a reference to another WAM term.
class	WamFloat A WamFloat is a Prolog constant for a floating-point number
class	WamInteger A WamInteger is a Prolog constant for an integral number.

Fields in com.svincent.moksa declared as PrologTerm

static PrologTerm[]

PrologTerm.EmptyArray A static empty array of PrologTerms.

Methods in com.svincent.moksa that return PrologTerm

PrologTerm	PrologTerm.getNameConstant()
PrologTerm	PrologTerm.deref() Dereferences this PrologTerm, retrieving the PrologTerm that it represents.
PrologTerm	PrologTerm.clonePrologTerm()
abstract PrologTerm	PrologTerm.clonePrologTerm(java.util.Map objs)
PrologTerm	PrologTerm.evaluateExpression() Evaluates this term as an expression.
PrologTerm	WamFloat.getNameConstant() Retrieves this WamInteger's name as a term.
PrologTerm	WamFloat.clonePrologTerm(java.util.Map objs)
PrologTerm	WamFloat.evaluateExpression() Evaluates this term as an expression.
PrologTerm	Wam.getRegister(int idx) Get the value of register 'idx'.
PrologTerm	Wam.ExceptionHandler.getException()
PrologTerm	Variable.getValue() Retrieves this Variable's value.
PrologTerm	Variable.deref() Dereferences this PrologTerm, retrieving the PrologTerm that it represents.
PrologTerm	Variable.clonePrologTerm(java.util.Map objs)
abstract PrologTerm	PrologParser.parseClause(Io.PrologInput in) Parse a Prolog clause.
abstract PrologTerm	PrologParser.parseTerm(Io.PrologInput in) Parse a Prolog term.
PrologTerm	PrologParser.parseClause(Io io, java.lang.String term) Parses a Prolog clause, given a String.
PrologTerm	PrologParser.parseTerm(Io io, java.lang.String term) Parses a Prolog term, given a String.
PrologTerm[]	PrologParser.parseFile(Io.PrologInput in) Parses an entire file, quickly and succinctly, into a list of clauses
PrologTerm	MiniPrologParser.parseClause(Io.PrologInput in)
PrologTerm	MiniPrologParser.parseTerm(Io.PrologInput in)
abstract PrologTerm	Rule.getTerm(PrologFactory factory) Return the Prolog term corresponding to this Rule.
PrologTerm	Builtin.BuiltinRule.getTerm(PrologFactory factory)
PrologTerm	Builtin.BuiltinRule.makeTerm(PrologFactory factory)
PrologTerm	Io.StreamIdentifier.clonePrologTerm(java.util.Map objs)
PrologTerm	Io.PrologInput.readCharTerm() Returns the next character in the stream as a PrologTerm (either an Integer or an Atom: 'end_of_file').
PrologTerm	CompiledRule.getTerm(PrologFactory factory)
abstract PrologTerm	CompiledRule.makeTerm(PrologFactory factory)
PrologTerm	WamInteger.getNameConstant() Retrieves this WamInteger's name as a term.
PrologTerm	WamInteger.clonePrologTerm(java.util.Map objs)
PrologTerm	WamInteger.evaluateExpression() Evaluates this term as an expression.
abstract PrologTerm	PrologEngine.ArithmeticHandler.evaluate(PrologTerm[] operands)
PrologTerm	PrologEngine.AddHandler.evaluate(PrologTerm[] operands)
PrologTerm	PrologEngine.NegateHandler.evaluate(PrologTerm[] operands)
PrologTerm	PrologEngine.SubtractHandler.evaluate(PrologTerm[] operands)
static PrologTerm	JavaInterface.makeJavaError(PrologFactory factory, java.lang.Throwable ex)
static PrologTerm	JavaInterface.makeJavaError(PrologFactory factory, java.lang.String atom)
static PrologTerm	JavaInterface.makeJavaError(PrologFactory factory, java.lang.String atom1, java.lang.String atom2)
PrologTerm	CompoundTerm.getNameConstant()
PrologTerm	CompoundTerm.getSubterm(int idx) Retrieves this CompoundTerm's value.
PrologTerm	CompoundTerm.getSubtermDeref(int idx)
PrologTerm	CompoundTerm.clonePrologTerm(java.util.Map objs)
PrologTerm	CompoundTerm.evaluateExpression() Evaluates this term as an expression.
PrologTerm	CompoundTerm.ListWrapper.findUnifiable(PrologTerm key) Finds the first term in this list which can unify (without variable binding) with the given key.
PrologTerm	CompoundTerm.PrologIterator.nextPrologTerm()
PrologTerm	CompoundTerm.PrologIterator.terminator()
PrologTerm	JavaTerm.clonePrologTerm(java.util.Map objs)
PrologTerm	IsoPrologParser.parseClause(Io.PrologInput in)
PrologTerm	IsoPrologParser.parseTerm(Io.PrologInput in)
PrologTerm	InterpretedRule.getTerm(PrologFactory factory)
PrologTerm	PrologException.UnhandledPrologException.getPrologException()

Methods in com.svincent.moksa with parameters of type PrologTerm

boolean	PrologTerm.unify(PrologTerm that) Unification algorithm.
boolean	PrologTerm.unifyWithoutBindings(PrologTerm that)
abstract boolean	PrologTerm.unify(PrologTerm that, boolean doBindings) Unification algorithm.
boolean	WamFloat.unify(PrologTerm _that, boolean doBindings) Unification algorithm.
void	Wam.setRegister(int idx, PrologTerm v) Set the value of register 'idx'.
boolean	Wam.badparm(int parmIdx, PrologTerm desiredValue) Called when facts are processing their parameters.
boolean	Wam.invoke(PrologTerm _goal) Invoke a goal.
Continuation	Wam.findExceptionHandler(PrologTerm exception)
void	Variable.bind(PrologTerm newValue) Binds this variable to the given new value.
boolean	Variable.unify(PrologTerm that, boolean doBindings) Unification algorithm.
Io.StreamIdentifier	Io.getStream(PrologTerm term) Retrieves a StreamIdentifier, given a PrologTerm.
boolean	Io.StreamIdentifier.unify(PrologTerm _that, boolean bindVars)
static Continuation	Continuation.make(PrologEngine engine, PrologTerm goal, Continuation next) Make a new Continuation for the given (possibly compound) goal 'goal'.
java.lang.Object	PrologTermVisitor.visitPrologTerm(PrologTerm v, java.lang.Object parm)
abstract boolean	Builtin.ArithmeticComparisonRule.compare(PrologTerm x, PrologTerm y)
boolean	Builtin.Equals_2.compare(PrologTerm x, PrologTerm y)
boolean	Builtin.NotEquals_2.compare(PrologTerm x, PrologTerm y)
boolean	Builtin.LessThan_2.compare(PrologTerm x, PrologTerm y)
boolean	Builtin.GreaterThan_2.compare(PrologTerm x, PrologTerm y)
boolean	Builtin.LessThanEquals_2.compare(PrologTerm x, PrologTerm y)
boolean	Builtin.GreaterThanEquals_2.compare(PrologTerm x, PrologTerm y)
CompiledRule	Prologc.PrologRuleCompiler.compileRule(PrologTerm term) Compile a term into a Rule.
SmallClass	Prologc.PrologRuleCompiler.makeRuleClass(PrologTerm term) Make a new SmallClass instance from a Rule.
SmallClass	Prologc.PrologRuleCompiler.makeRuleClass(java.lang.String packageName, PrologTerm term)
java.lang.Object	Prologc.PrologTermCompiler.visitPrologTerm(PrologTerm v, java.lang.Object parm)
boolean	WamInteger.unify(PrologTerm _that, boolean doBindings) Unification algorithm.
void	PrologEngine.asserta(PrologTerm term) Asserts a new clause before all clauses of the definition of the given predicate.
void	PrologEngine.assertz(PrologTerm term) Asserts a new clause after all clauses of the definition of the given predicate.
Rule	PrologEngine.compileRule(PrologTerm term)
abstract PrologTerm	PrologEngine.ArithmeticHandler.evaluate(PrologTerm[] operands)
PrologTerm	PrologEngine.AddHandler.evaluate(PrologTerm[] operands)
PrologTerm	PrologEngine.NegateHandler.evaluate(PrologTerm[] operands)
PrologTerm	PrologEngine.SubtractHandler.evaluate(PrologTerm[] operands)
static java.lang.Object	JavaInterface.Java_method_3.convertToJava(PrologTerm o)
static java.util.Collection	VariableCollector.getVariables(PrologTerm a) Primary interface method.
static java.util.Map	VariableCollector.getVariableMap(PrologTerm a)
boolean	CompoundTerm.unify(PrologTerm _that, boolean doBindings) Unification algorithm.
PrologTerm	CompoundTerm.ListWrapper.findUnifiable(PrologTerm key) Finds the first term in this list which can unify (without variable binding) with the given key.
java.lang.String	CompoundTerm.ListWrapper.getOption(PrologTerm key)
CompoundTerm	PrologFactory.makeCompoundTerm(java.lang.String name, PrologTerm[] subterms, int priority)
CompoundTerm	PrologFactory.makeCompoundTerm(java.lang.String name, PrologTerm[] subterms)
CompoundTerm	PrologFactory.makeList(PrologTerm[] elements) Convenience constructor for making Lists.
CompoundTerm	PrologFactory.makeCompoundTerm(java.lang.String _name, PrologTerm sub1) Convenience constructor for 1 subterm
CompoundTerm	PrologFactory.makeCompoundTerm(java.lang.String _name, PrologTerm sub1, PrologTerm sub2) Convenience constructor for 2 subterms
CompoundTerm	PrologFactory.makeCompoundTerm(java.lang.String _name, PrologTerm sub1, PrologTerm sub2, PrologTerm sub3) Convenience constructor for 3 subterms
CompoundTerm	PrologFactory.makeCompoundTerm(java.lang.String _name, PrologTerm sub1, PrologTerm sub2, PrologTerm sub3, PrologTerm sub4) Convenience constructor for 4 subterms
CompoundTerm	PrologFactory.makeCompoundTerm(java.lang.String _name, PrologTerm sub1, PrologTerm sub2, PrologTerm sub3, PrologTerm sub4, PrologTerm sub5) Convenience constructor for 5 subterms
Continuation	PrologFactory.makeContinuation(Rule rule, PrologTerm[] registers, Continuation next) Make a new Continuation.
Continuation	PrologFactory.callThrowTypeError(java.lang.String desiredType, PrologTerm offendingTerm)
Continuation	PrologFactory.callThrowDomainError(java.lang.String desiredDomain, PrologTerm offendingTerm)
Continuation	PrologFactory.callThrowPermissionError(java.lang.String desiredPermission, PrologTerm offendingTerm)
Continuation	PrologFactory.callThrowPermissionError(java.lang.String desiredPermission, java.lang.String auxilliaryAtom, PrologTerm offendingTerm)
Continuation	PrologFactory.callThrowExistenceError(java.lang.String desiredExistor, PrologTerm offendingTerm)
Continuation	PrologFactory.callThrow(PrologTerm exception)
boolean	JavaTerm.unify(PrologTerm _that, boolean bindVars)

Constructors in com.svincent.moksa with parameters of type PrologTerm

Wam.ExceptionHandler.Wam.ExceptionHandler(Wam _wam, PrologTerm _goal, PrologTerm _exception, Continuation _handler)

Continuation.Continuation(Rule _rule, PrologTerm[] _registers, Continuation _next)
Construct a new Continuation which will call the given goal, then proceed on to the 'next' continuation.

CompoundTerm.CompoundTerm(PrologEngine _engine, java.lang.String _name, PrologTerm[] _subterms, int _priority)
Builds a new CompoundTerm with the given name.

PrologException.UnhandledPrologException.PrologException.UnhandledPrologException(PrologTerm _exception)