Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| GNU Prolog for Java
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
gnu.prolog.term.Term

Packages that use Term
gnu.prolog.database | Classes related to the storing and creation of the database of Prolog `Predicates`
gnu.prolog.io | Classes used for IO
gnu.prolog.io.parser.gen |
gnu.prolog.term | Contains the various types of `Term` that can be used.
gnu.prolog.vm | The Virtual Machine which is used to run the prolog code.
gnu.prolog.vm.buildins.allsolutions |
gnu.prolog.vm.buildins.arithmetics |
gnu.prolog.vm.buildins.atomicterms |
gnu.prolog.vm.buildins.database |
gnu.prolog.vm.buildins.datetime |
gnu.prolog.vm.buildins.debug |
gnu.prolog.vm.buildins.dialogs |
gnu.prolog.vm.buildins.imphooks |
gnu.prolog.vm.buildins.io |
gnu.prolog.vm.buildins.java |
gnu.prolog.vm.buildins.list |
gnu.prolog.vm.buildins.misc |
gnu.prolog.vm.buildins.termcomparsion |
gnu.prolog.vm.buildins.termcreation |
gnu.prolog.vm.buildins.typetesting |
gnu.prolog.vm.buildins.unification |
gnu.prolog.vm.buildins.uuid |
gnu.prolog.vm.interpreter | `InterpretedCodeCompiler` uses the various classes beginning with I and extending `Instruction` in the `instruction` sub-package to compile clauses to `InterpretedByteCode`.

Uses of Term in gnu.prolog.database

Fields in gnu.prolog.database with type parameters of type Term
`protected List<Term>` | `Predicate.clauses` list of clauses for this predicate
`protected List<Pair<PrologTextLoaderError,Term>>` | `Module.initialization` initialization

Methods in gnu.prolog.database that return Term
`static Term` | `Predicate.prepareBody(Term body)`
`static Term` | `Predicate.prepareClause(Term clause)`
`static Term` | `Predicate.prepareHead(Term head)`

Methods in gnu.prolog.database that return types with arguments of type Term
`List<Term>` | `Predicate.getClauses()` get clauses of predicate You must synchronize on this class when iterating through this list as although it is a synchronized list you are getting a unmodifiable view of that list.
`List<Pair<PrologTextLoaderError,Term>>` | `Module.getInitialization()` get initaliztion

Methods in gnu.prolog.database with parameters of type Term
`void` | `PrologTextLoaderState.addClause(PrologTextLoader loader, Term term)`
`void` | `Predicate.addClauseFirst(Term clause)` Add clause for predicate at the beginning.
`void` | `Predicate.addClauseLast(Term clause)` Add clause for predicate at the end.
`void` | `Module.addInitialization(PrologTextLoaderError prologTextLoaderError, Term term)` add term to initialization list
`void` | `PrologTextLoaderState.addInitialization(PrologTextLoader loader, Term term)`
`void` | `AbstractPrologTextLoaderListener.beforeIncludeFile(PrologTextLoader loader, Term argument)`
`void` | `PrologTextLoaderState.beforeIncludeFile(PrologTextLoader loader, Term argument)`
`void` | `PrologTextLoaderListener.beforeIncludeFile(PrologTextLoader loader, Term argument)` Called before an include file is being processed.
`void` | `PrologTextLoaderState.ensureLoaded(Term term)`
`protected String` | `PrologTextLoaderState.getInputName(Term term)`
`protected InputStream` | `PrologTextLoaderState.getInputStream(Term term)`
`static Term` | `Predicate.prepareBody(Term body)`
`static Term` | `Predicate.prepareClause(Term clause)`
`static Term` | `Predicate.prepareHead(Term head)`
`protected void` | `PrologTextLoader.processBuildInDirective(Term pi, Term className)`
`protected void` | `PrologTextLoader.processCharConversionDirective(Term from, Term to)`
`protected void` | `PrologTextLoader.processClause(Term argument)`
`protected void` | `PrologTextLoader.processControlDirective(Term pi, Term className)`
`protected void` | `PrologTextLoader.processDiscontiguousDirective(Term pi)`
`protected void` | `PrologTextLoader.processDynamicDirective(Term pi)`
`protected void` | `PrologTextLoader.processEnsureLoadedDirective(Term argument)`
`protected void` | `PrologTextLoader.processExternalDirective(Term pi, Term className)`
`protected void` | `PrologTextLoader.processIncludeDirective(Term argument)`
`protected void` | `PrologTextLoader.processInitializationDirective(Term term)`
`protected void` | `PrologTextLoader.processMultifileDirective(Term pi)`
`protected void` | `PrologTextLoader.processOpDirective(Term priority, Term specifier, Term operatorAtom)`
`protected void` | `PrologTextLoader.processSetPrologFlagDirective(Term arg0, Term arg1)`
`void` | `Predicate.removeClause(Term clause)` Remove clause for predicate.

Constructors in gnu.prolog.database with parameters of type Term
`PrologTextLoader(PrologTextLoaderState prologTextLoaderState, Term root)`

Uses of Term in gnu.prolog.io

Fields in gnu.prolog.io declared as Term
`protected Term` | `PrologStream.streamTerm`

Fields in gnu.prolog.io with type parameters of type Term
`protected Map<Term,String>` | `WriteOptions.variable2name` Map from variables to names.
`List<Term>` | `ReadOptions.variables` 'variables' ISO Prolog options

Methods in gnu.prolog.io that return Term
`Term` | `CharConversionTable.charConvert(Term term, Environment environment)` Apply `CharConversionTable` to term if this should happen.
`Term` | `PrologStream.getEndOfStreamState()`
`Term` | `BinaryPrologStream.getEndOfStreamState()`
`Term` | `TextOutputPrologStream.getPosition(Term streamTerm, Interpreter interptreter)`
`abstract Term` | `PrologStream.getPosition(Term streamTerm, Interpreter interpreter)`
`Term` | `TextInputPrologStream.getPosition(Term streamTerm, Interpreter interptreter)`
`Term` | `BinaryPrologStream.getPosition(Term streamTerm, Interpreter interptreter)`
`Term` | `PrologStream.getStreamTerm()`
`Term` | `TermReader.readTerm()`
`Term` | `TermReader.readTerm(OperatorSet set)`
`Term` | `TermReader.readTerm(ReadOptions options)`
`Term` | `TextOutputPrologStream.readTerm(Term streamTerm, Interpreter interptreter, ReadOptions options)`
`abstract Term` | `PrologStream.readTerm(Term streamTerm, Interpreter interpreter, ReadOptions options)`
`Term` | `TextInputPrologStream.readTerm(Term streamTerm, Interpreter interptreter, ReadOptions options)`
`Term` | `BinaryPrologStream.readTerm(Term streamTerm, Interpreter i, ReadOptions o)`
`Term` | `TermReader.readTermEof()`
`Term` | `TermReader.readTermEof(OperatorSet set)`
`Term` | `TermReader.readTermEof(ReadOptions options)`
`static Term` | `TermReader.stringToTerm(ReadOptions options, String str, Environment environment)`
`static Term` | `TermReader.stringToTerm(String str, Environment environment)`

Methods in gnu.prolog.io with parameters of type Term
`Term` | `CharConversionTable.charConvert(Term term, Environment environment)` Apply `CharConversionTable` to term if this should happen.
`protected void` | `TermWriter.displayTerm(WriteOptions options, int priority, Term term)` display term
`void` | `TextOutputPrologStream.flushOutput(Term streamTerm)`
`abstract void` | `PrologStream.flushOutput(Term streamTerm)`
`void` | `TextInputPrologStream.flushOutput(Term streamTerm)`
`void` | `BinaryPrologStream.flushOutput(Term streamTerm)`
`int` | `TextOutputPrologStream.getByte(Term streamTerm, Interpreter interptreter)`
`abstract int` | `PrologStream.getByte(Term streamTerm, Interpreter interpreter)`
`int` | `TextInputPrologStream.getByte(Term streamTerm, Interpreter interptreter)`
`int` | `BinaryPrologStream.getByte(Term streamTerm, Interpreter interptreter)`
`int` | `TextOutputPrologStream.getCode(Term streamTerm, Interpreter interptreter)`
`abstract int` | `PrologStream.getCode(Term streamTerm, Interpreter interpreter)`
`int` | `TextInputPrologStream.getCode(Term streamTerm, Interpreter interptreter)`
`int` | `BinaryPrologStream.getCode(Term streamTerm, Interpreter interptreter)`
`Term` | `TextOutputPrologStream.getPosition(Term streamTerm, Interpreter interptreter)`
`abstract Term` | `PrologStream.getPosition(Term streamTerm, Interpreter interpreter)`
`Term` | `TextInputPrologStream.getPosition(Term streamTerm, Interpreter interptreter)`
`Term` | `BinaryPrologStream.getPosition(Term streamTerm, Interpreter interptreter)`
`int` | `TextOutputPrologStream.peekByte(Term streamTerm, Interpreter interptreter)`
`abstract int` | `PrologStream.peekByte(Term streamTerm, Interpreter interpreter)`
`int` | `TextInputPrologStream.peekByte(Term streamTerm, Interpreter interptreter)`
`int` | `BinaryPrologStream.peekByte(Term streamTerm, Interpreter interptreter)`
`int` | `TextOutputPrologStream.peekCode(Term streamTerm, Interpreter interptreter)`
`abstract int` | `PrologStream.peekCode(Term streamTerm, Interpreter interpreter)`
`int` | `TextInputPrologStream.peekCode(Term streamTerm, Interpreter interptreter)`
`int` | `BinaryPrologStream.peekCode(Term streamTerm, Interpreter interptreter)`
`void` | `TermWriter.print(OperatorSet opSet, Term term)` print term using default write options and specified operator set
`void` | `TermWriter.print(Term term)` print term using default write options
`void` | `TermWriter.print(WriteOptions options, Term term)` print term using specified write options
`void` | `TextOutputPrologStream.putByte(Term streamTerm, Interpreter interptreter, int _byte)`
`abstract void` | `PrologStream.putByte(Term streamTerm, Interpreter interpreter, int _byte)`
`void` | `TextInputPrologStream.putByte(Term streamTerm, Interpreter interptreter, int _byte)`
`void` | `BinaryPrologStream.putByte(Term streamTerm, Interpreter interptreter, int _byte)`
`void` | `TextOutputPrologStream.putCode(Term streamTerm, Interpreter interptreter, int code)`
`abstract void` | `PrologStream.putCode(Term streamTerm, Interpreter interpreter, int code)`
`void` | `TextInputPrologStream.putCode(Term streamTerm, Interpreter interptreter, int code)`
`void` | `BinaryPrologStream.putCode(Term streamTerm, Interpreter interptreter, int code)`
`void` | `TextOutputPrologStream.putCodeSequence(Term streamTerm, Interpreter interptreter, String seq)`
`abstract void` | `PrologStream.putCodeSequence(Term streamTerm, Interpreter interpreter, String seq)`
`void` | `TextInputPrologStream.putCodeSequence(Term streamTerm, Interpreter interptreter, String seq)`
`void` | `BinaryPrologStream.putCodeSequence(Term streamTerm, Interpreter interptreter, String seq)`
`Term` | `TextOutputPrologStream.readTerm(Term streamTerm, Interpreter interptreter, ReadOptions options)`
`abstract Term` | `PrologStream.readTerm(Term streamTerm, Interpreter interpreter, ReadOptions options)`
`Term` | `TextInputPrologStream.readTerm(Term streamTerm, Interpreter interptreter, ReadOptions options)`
`Term` | `BinaryPrologStream.readTerm(Term streamTerm, Interpreter i, ReadOptions o)`
`void` | `TextOutputPrologStream.setPosition(Term streamTerm, Interpreter interptreter, Term position)`
`abstract void` | `PrologStream.setPosition(Term streamTerm, Interpreter interpreter, Term pos)`
`void` | `TextInputPrologStream.setPosition(Term streamTerm, Interpreter interptreter, Term position)`
`void` | `BinaryPrologStream.setPosition(Term streamTerm, Interpreter interptreter, Term position)`
`static String` | `TermWriter.toString(Term term)` convert term passed as argument to string
`static String` | `TermWriter.toString(Term term, WriteOptions options)` convert term passed as argument to string
`void` | `TextOutputPrologStream.writeTerm(Term streamTerm, Interpreter interptreter, WriteOptions options, Term term)`
`abstract void` | `PrologStream.writeTerm(Term streamTerm, Interpreter interpreter, WriteOptions options, Term term)`
`void` | `TextInputPrologStream.writeTerm(Term streamTerm, Interpreter interptreter, WriteOptions options, Term term)`
`void` | `BinaryPrologStream.writeTerm(Term streamTerm, Interpreter i, WriteOptions o, Term t)`

Method parameters in gnu.prolog.io with type arguments of type Term
`void` | `PrologStream.getProperties(List<Term> list)`

Uses of Term in gnu.prolog.io.parser.gen

Methods in gnu.prolog.io.parser.gen that return Term
`Term` | `TermParser.char_code_list()`
`Term` | `TermParser.curly_term(ReadOptions options)`
`Term` | `TermParser.list_term(ReadOptions options)`
`Term` | `TermParser.readTerm(ReadOptions options)`
`Term` | `TermParser.readTermEof(ReadOptions options)`
`Term` | `TermParser.simpleTerm(ReadOptions options)`
`Term` | `TermParser.term(ReadOptions options, int priority)`

Uses of Term in gnu.prolog.term

Subclasses of Term in gnu.prolog.term
`class` | `AtomicTerm` base class for all constant terms
`class` | `AtomTerm` Atom term.
`class` | `ChangeableTerm` Terms for which the value varies depending on prolog flags extend this class.
`class` | `CompoundTerm` Compound terms are the basic method for combining terms.
`class` | `DoubleQuotesTerm` Term for storing a double quoted string as what this resolves to varies depending on the value of the double_quotes flag.
`class` | `FloatTerm` Floating point number term (uses double)
`class` | `IntegerTerm` 32bit Integer term.
`class` | `JavaObjectTerm` Term which is embedding JavaObject This term should never participate in text IO operations.
`class` | `NumericTerm` Abstract class for all Terms which represent numbers
`class` | `VariableTerm` Represents Prolog variables such as X or A.

Fields in gnu.prolog.term declared as Term
`Term[]` | `CompoundTerm.args` term argumets
`Term` | `VariableTerm.value` value of variable term

Fields in gnu.prolog.term with type parameters of type Term
`protected Map<Term,Integer>` | `TermComparator.orderMap`

Methods in gnu.prolog.term that return Term
`Term` | `CompoundTerm.clone(TermCloneContext context)` clone the object using clone context
`abstract Term` | `Term.clone(TermCloneContext context)` clone the object using clone context
`Term` | `VariableTerm.clone(TermCloneContext context)` clone the object using clone context
`Term` | `AtomicTerm.clone(TermCloneContext context)`
`Term` | `Term.dereference()` dereference term.
`Term` | `VariableTerm.dereference()` dereference term.
`abstract Term` | `ChangeableTerm.dereference()` The value may also be altered by this method in child classes.
`Term` | `DoubleQuotesTerm.dereference()`
`static Term` | `TermUtils.getExistentialVariableSet(Term term, Set<Term> set)` get existential variable set
`static Term` | `TermUtils.getFreeVariableSet(Term term1, Term term2, Set<Term> set)` get free variables of term1 with respect to term2
`static Term` | `CompoundTerm.getList(List<Term> list)` get prolog list by java list
`static Term` | `CompoundTerm.getList(Term[] list)` get prolog list by java array
`protected Term` | `ChangeableTerm.getPrologFlag(AtomTerm term)`
`Term` | `TermCloneContext.getTerm(Term term)` get cloned term if it is alrady added to context
`static Term` | `TermUtils.getWitness(Set<Term> set)` get witness of variable set, now just list of variables

Methods in gnu.prolog.term with parameters of type Term
`int` | `TermComparator.compare(Term o1, Term o2)` Compares its two arguments for order.
`static CompoundTerm` | `CompoundTerm.getConjunction(Term head, Term tail)` get conjunction term
`static CompoundTerm` | `CompoundTerm.getDisjunction(Term head, Term tail)` get disjunction term
`static Term` | `TermUtils.getExistentialVariableSet(Term term, Set<Term> set)` get existential variable set
`static Term` | `TermUtils.getFreeVariableSet(Term term1, Term term2, Set<Term> set)` get free variables of term1 with respect to term2
`static Term` | `CompoundTerm.getList(Term[] list)` get prolog list by java array
`static CompoundTerm` | `CompoundTerm.getList(Term head, Term tail)` get list pair
`Term` | `TermCloneContext.getTerm(Term term)` get cloned term if it is alrady added to context
`static void` | `TermUtils.getVariableSet(Term term, Set<Term> set)` get variable set
`static boolean` | `CompoundTerm.isListPair(Term term)`
`static boolean` | `CompoundTermTag.isPredicateIndicator(Term term)` check if term is predicate indicator
`static boolean` | `TermUtils.isVariant(Term term1, Term term2)` Check if one term is variant of another
`protected static boolean` | `TermUtils.isVariant(Term term1, Term term2, Map<Term,Term> map)`
`void` | `TermCloneContext.putTerm(Term term, Term cloned)` put cloned term to context
`static boolean` | `CompoundTerm.toCollection(Term term, Collection<Term> col)`

Method parameters in gnu.prolog.term with type arguments of type Term
`static Term` | `TermUtils.getExistentialVariableSet(Term term, Set<Term> set)` get existential variable set
`static Term` | `TermUtils.getFreeVariableSet(Term term1, Term term2, Set<Term> set)` get free variables of term1 with respect to term2
`static Term` | `CompoundTerm.getList(List<Term> list)` get prolog list by java list
`static void` | `TermUtils.getVariableSet(Term term, Set<Term> set)` get variable set
`static Term` | `TermUtils.getWitness(Set<Term> set)` get witness of variable set, now just list of variables
`protected static boolean` | `TermUtils.isVariant(Term term1, Term term2, Map<Term,Term> map)`
`protected static boolean` | `TermUtils.isVariant(Term term1, Term term2, Map<Term,Term> map)`
`static boolean` | `CompoundTerm.toCollection(Term term, Collection<Term> col)`

Constructors in gnu.prolog.term with parameters of type Term
`CompoundTerm(AtomTerm functor, Term[] args)` get term with specified term functor and arguments.
`CompoundTerm(CompoundTermTag tg, Term arg1)` get term with specified term tag and arguments.
`CompoundTerm(CompoundTermTag tag, Term[] args)` a constructor
`CompoundTerm(CompoundTermTag tg, Term arg1, Term arg2)` get term with specified term tag and arguments.
`CompoundTerm(CompoundTermTag tg, Term arg1, Term arg2, Term arg3)` get term with specified term tag and arguments.
`CompoundTerm(String functor, Term[] args)` get term with specified term functor and arguments.
`DoubleQuotesTerm(Environment environment, Term codes, Term chars, AtomTerm atom)` Construct a DoubleQuotesTerm

Uses of Term in gnu.prolog.vm

Fields in gnu.prolog.vm declared as Term
`protected Term` | `PrologCollectionIterator.destTerm` The term to unify the value with
`protected Term` | `PrologException.term` term of the exception

Fields in gnu.prolog.vm with type parameters of type Term
`protected Map<AtomTerm,Term>` | `Environment.atom2flag` atom to flag

Methods in gnu.prolog.vm that return Term
`static Term` | `Evaluate.evaluate(Term term)`
`protected Term` | `Interpreter.Goal.getGoal()`
`Term` | `Environment.getPrologFlag(AtomTerm term)` get flag for this environment
`Term` | `PrologException.getTerm()` get term of this exception
`Term` | `Environment.open(AtomTerm source_sink, AtomTerm mode, PrologStream.OpenOptions options)`

Methods in gnu.prolog.vm that return types with arguments of type Term
`Map<AtomTerm,Term>` | `Environment.getPrologFlags()` get copy of current state of flags for this environment
`Map<PrologStream,List<Term>>` | `Environment.getStreamProperties()`

Methods in gnu.prolog.vm with parameters of type Term
`protected void` | `Environment.createNewPrologFlag(AtomTerm flag, Term newValue, boolean changable)` create a new flag for this environment
`static void` | `PrologException.domainError(AtomTerm errorType, Term errorTerm)`
`void` | `Environment.ensureLoaded(Term term)` Ensure that prolog text designated by term is loaded You must use `Environment.runInitialization(Interpreter)` after using this and before expecting answers.
`static Term` | `Evaluate.evaluate(Term term)`
`int` | `UndefinedPredicateCode.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`abstract int` | `ExecuteOnlyCode.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `PrologCode.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)` this method is used for execution of code
`static void` | `PrologException.existenceError(AtomTerm errorType, Term errorTerm)`
`static void` | `PrologException.permissionError(AtomTerm operation, AtomTerm permissionType, Term culprit)`
`Interpreter.Goal` | `Interpreter.prepareGoal(Term term)` prepare goal for execution If this is called before the Goal which was previously prepared but has not yet been stopped is stopped then we save that state so we can jump back to it when this goal has been stopped.
`static void` | `PrologException.representationError(Term errorTerm)`
`PrologStream` | `Environment.resolveStream(Term stream_or_alias)`
`int` | `Interpreter.runOnce(Term goalTerm)` Run the provided goalTerm once returning the value returned by `Interpreter.execute(Goal)` and then stop the goal.
`void` | `Environment.setPrologFlag(AtomTerm flag, Term newValue)`
`int` | `Interpreter.simpleUnify(Term t1, Term t2)` unify two terms, no undo done
`static void` | `PrologException.typeError(AtomTerm errorType, Term errorTerm)`
`protected static void` | `Evaluate.typeTestInt(Term term)` Test the term for an integer term
`int` | `Interpreter.unify(Term t1, Term t2)` unify two terms

Constructors in gnu.prolog.vm with parameters of type Term
`Interpreter.Goal(Term goal)`
`PrologCollectionIterator(Iterable<?> iterable, Term destination, int undoPosition)`
`PrologCollectionIterator(Iterator<?> iterable, Term destination, int undoPosition)`
`PrologException(Term term, Throwable inner)` a constructor

Uses of Term in gnu.prolog.vm.buildins.allsolutions

Methods in gnu.prolog.vm.buildins.allsolutions with parameters of type Term
`static void` | `Predicate_findall.checkList(Term list)` Check that list is a valid Prolog list (including an uninstantiated variable)
`int` | `Predicate_bagof.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_findall.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`static int` | `Predicate_findall.findall(Interpreter interpreter, boolean backtrackMode, Term template, Term goal, List<Term> list)`

Method parameters in gnu.prolog.vm.buildins.allsolutions with type arguments of type Term
`static int` | `Predicate_findall.findall(Interpreter interpreter, boolean backtrackMode, Term template, Term goal, List<Term> list)`
`protected void` | `Predicate_bagof.processList(List<Term> curTList)`
`protected void` | `Predicate_setof.processList(List<Term> curTList)`

Uses of Term in gnu.prolog.vm.buildins.arithmetics

Methods in gnu.prolog.vm.buildins.arithmetics with parameters of type Term
`int` | `Predicate_not_equal.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_greater_than.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_less_than_or_equal.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_greater_than_or_equal.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_less_than.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_equal.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_is.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`

Uses of Term in gnu.prolog.vm.buildins.atomicterms

Methods in gnu.prolog.vm.buildins.atomicterms with parameters of type Term
`int` | `Predicate_number_chars.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_atom_concat.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_atom_chars.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_number_codes.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_char_code.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_sub_atom.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_atom_codes.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_atom_length.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`

Uses of Term in gnu.prolog.vm.buildins.database

Methods in gnu.prolog.vm.buildins.database that return Term
`static Term` | `Predicate_assert.prepareBody(Term body, Term term)`

Methods in gnu.prolog.vm.buildins.database with parameters of type Term
`int` | `Predicate_abolish.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_current_predicate.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_clause.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_retract.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_assert.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`static boolean` | `Predicate_clause.isCallable(Term body)`
`static Term` | `Predicate_assert.prepareBody(Term body, Term term)`

Uses of Term in gnu.prolog.vm.buildins.datetime

Methods in gnu.prolog.vm.buildins.datetime that return Term
`protected Term` | `Predicate_date_time_value.getDate9Value(Term keyTerm, CompoundTerm date9)`

Methods in gnu.prolog.vm.buildins.datetime with parameters of type Term
`int` | `Predicate_stamp_date_time.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_format_time.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_date_time_stamp.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_date_time_value.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_parse_time.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_get_time.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`static Date` | `DateTimePrologCode.getDate(Term term)`
`protected Term` | `Predicate_date_time_value.getDate9Value(Term keyTerm, CompoundTerm date9)`

Uses of Term in gnu.prolog.vm.buildins.debug

Methods in gnu.prolog.vm.buildins.debug with parameters of type Term
`int` | `Predicate_nospyall.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_trace.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_spy.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_debugging.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_nospy.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_notrace.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_tracing.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`static CompoundTermTag` | `Predicate_spy.getTag(Term term)`
`static EnumSet<Tracer.TraceLevel>` | `Predicate_spy.getTraceLevel(Term term)`
`protected void` | `Predicate_spy.setSpyPoint(Interpreter interpreter, CompoundTermTag tag, Term arg)`

Uses of Term in gnu.prolog.vm.buildins.dialogs

Fields in gnu.prolog.vm.buildins.dialogs declared as Term
`Term` | `Predicate_confirm.TermOption.result`

Methods in gnu.prolog.vm.buildins.dialogs with parameters of type Term
`protected JFileChooser` | `Predicate_file_save.createFileDialog(Term[] args)`
`int` | `Predicate_prompt.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_message.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_confirm.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_file_open.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_file_save.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`protected Predicate_dialog.DialogOptions` | `Predicate_dialog.processOptions(Term optionsList)` Process dialog options

Constructors in gnu.prolog.vm.buildins.dialogs with parameters of type Term
`Predicate_confirm.TermOption(String res, Term resTerm)`
`TermFileFilter(Term term)`

Uses of Term in gnu.prolog.vm.buildins.imphooks

Methods in gnu.prolog.vm.buildins.imphooks with parameters of type Term
`int` | `Predicate_set_prolog_flag.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_halt.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)` this method is used for execution of code Halts execution by throwing `PrologHalt` DO NOT catch this.
`int` | `Predicate_current_prolog_flag.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`

Uses of Term in gnu.prolog.vm.buildins.io

Methods in gnu.prolog.vm.buildins.io with parameters of type Term
`int` | `Predicate_current_input.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_current_output.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_flush_output.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)` this method is used for execution of code
`int` | `Predicate_set_stream_position.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_set_output.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_peek_char.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_op.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_current_op.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_get_byte.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_ensure_loaded.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_read_term.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_set_input.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_at_end_of_stream.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_put_char.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_char_conversion.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_stream_property.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_peek_byte.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_put_byte.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_current_char_conversion.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_write_term.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_get_char.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_open.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_close.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`

Uses of Term in gnu.prolog.vm.buildins.java

Methods in gnu.prolog.vm.buildins.java with parameters of type Term
`int` | `Predicate_java_classname.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_java_to_string.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`

Uses of Term in gnu.prolog.vm.buildins.list

Fields in gnu.prolog.vm.buildins.list declared as Term
`protected Term` | `Predicate_member.MemberBacktrackInfo.item`
`protected Term` | `Predicate_append.AppendBacktrackInfo.item`
`protected Term` | `Predicate_member.MemberBacktrackInfo.list`
`protected Term` | `Predicate_append.AppendBacktrackInfo.list`
`protected Term` | `Predicate_member.MemberBacktrackInfo.listDest`
`protected Term` | `Predicate_append.AppendBacktrackInfo.listDest`

Methods in gnu.prolog.vm.buildins.list that return types with arguments of type Term
`protected Comparator<? super Term>` | `Predicate_predsort.getComparator(Interpreter interpreter, Term sorter)`

Methods in gnu.prolog.vm.buildins.list with parameters of type Term
`int` | `Predicate_predsort.CallPredComparator.compare(Term o1, Term o2)`
`int` | `Predicate_msort.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_member.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_predsort.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_append.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_sort.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_is_list.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_length.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`protected Comparator<? super Term>` | `Predicate_predsort.getComparator(Interpreter interpreter, Term sorter)`

Uses of Term in gnu.prolog.vm.buildins.misc

Methods in gnu.prolog.vm.buildins.misc with parameters of type Term
`int` | `Predicate_stacktrace.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_current_functor.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_listing.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`

Uses of Term in gnu.prolog.vm.buildins.termcomparsion

Methods in gnu.prolog.vm.buildins.termcomparsion with parameters of type Term
`int` | `Predicate_term_greater_then_or_equal.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_term_not_identical.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_term_less_then_or_equal.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_term_less_then.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_compare.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_term_greater_then.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_term_identical.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`

Uses of Term in gnu.prolog.vm.buildins.termcreation

Fields in gnu.prolog.vm.buildins.termcreation declared as Term
`static Term[]` | `Predicate_univ.termArrayType`

Methods in gnu.prolog.vm.buildins.termcreation with parameters of type Term
`int` | `Predicate_arg.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_univ.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_copy_term.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_functor.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`

Uses of Term in gnu.prolog.vm.buildins.typetesting

Methods in gnu.prolog.vm.buildins.typetesting with parameters of type Term
`int` | `Predicate_atom.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_compound.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_nonvar.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_atomic.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_number.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_var.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_float.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_java_object.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_integer.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`

Uses of Term in gnu.prolog.vm.buildins.unification

Methods in gnu.prolog.vm.buildins.unification with parameters of type Term
`int` | `Predicate_not_unifiable.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_unify_with_occurs_check.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_unify.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`static boolean` | `Predicate_unify_with_occurs_check.occurCheck(VariableTerm variable, Term term)` Perform occur check on variable

Uses of Term in gnu.prolog.vm.buildins.uuid

Methods in gnu.prolog.vm.buildins.uuid with parameters of type Term
`int` | `Predicate_uuid_variant.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_uuid_compare.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_uuid_version.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_uuid3.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`int` | `Predicate_uuid4.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`static UUID` | `Predicate_uuid.getUUID(Term value)` Get the UUID from an atom term.

Uses of Term in gnu.prolog.vm.interpreter

Fields in gnu.prolog.vm.interpreter declared as Term
`Term[]` | `CallBacktrackInfo.args` argument list save for call
`protected Term[]` | `TracerEvent.args`
`Term[]` | `ExecutionState.args` arguments
`Term[]` | `LeaveByteCodeBacktrackInfo.environment`
`Term[]` | `ExecutionState.environment` current environment
`static Term[]` | `Predicate_call.termArrayType` term arry constant

Fields in gnu.prolog.vm.interpreter with type parameters of type Term
`protected List<Term>` | `InterpretedCodeCompiler.passedClauses` clauses to compile
`List<Term>` | `ExecutionState.pushdown` pushdown stack, used for unification and calls
`protected Map<Term,Integer>` | `InterpretedCodeCompiler.variableToEnvironmentIndex` mapping from variables to environment indexes

Methods in gnu.prolog.vm.interpreter that return Term
`Term[]` | `TracerEvent.getArgs()`
`static Term` | `Predicate_call.getClause(Term term, Map<Term,VariableTerm> argumentsToArgumentVariables)` convert callable term to clause
`Term` | `ExecutionState.getEnvironment(int environmentIndex)` get term from environment
`Term` | `ExecutionState.popPushDown()` pop term from pushdown stack
`static Term` | `InterpretedCodeCompiler.rdereferenced(Term term)` recursively dereference term

Methods in gnu.prolog.vm.interpreter with parameters of type Term
`int` | `InterpretedByteCode.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)` this method is used for execution of code
`int` | `Predicate_call.execute(Interpreter interpreter, boolean backtrackMode, Term[] args)`
`CallBacktrackInfo` | `ExecutionState.getCallBacktrackInfo(int codePosition, Term[] args, PrologCode code, CompoundTermTag tag)` get BacktrackInfo for call instruction.
`static Term` | `Predicate_call.getClause(Term term, Map<Term,VariableTerm> argumentsToArgumentVariables)` convert callable term to clause
`void` | `ExecutionState.pushPushDown(Term term)` push term to pushdown stack
`void` | `ExecutionState.putEnvironment(int environmentIndex, Term term)` put term to environment
`static Term` | `InterpretedCodeCompiler.rdereferenced(Term term)` recursively dereference term
`protected void` | `Tracer.sendEvent(Tracer.TraceLevel level, Interpreter interpreter, CompoundTermTag tag, Term[] args)` Notify the listeners
`static int` | `Predicate_call.staticExecute(Interpreter interpreter, boolean backtrackMode, Term arg)` this method is used for execution of code
`void` | `Tracer.traceEvent(Tracer.TraceLevel level, Interpreter interpreter, CompoundTermTag tag, Term[] args)` A trace event

Method parameters in gnu.prolog.vm.interpreter with type arguments of type Term
`static PrologCode` | `InterpretedCodeCompiler.compile(List<Term> passedClauses)` compile set of clauses to interpreted code
`static Term` | `Predicate_call.getClause(Term term, Map<Term,VariableTerm> argumentsToArgumentVariables)` convert callable term to clause

Constructors in gnu.prolog.vm.interpreter with parameters of type Term
`CallBacktrackInfo(int undoPosition, int codePosition, Term[] args, PrologCode code, CompoundTermTag tag)` a constructor
`LeaveByteCodeBacktrackInfo(Term[] environment, BacktrackInfo startBacktrackInfo)` a constructor
`Predicate_call.CallTermBacktrackInfo(Interpreter in, PrologCode code, Term[] args, Term callTerm)`
`Predicate_call.CallTermBacktrackInfo(Interpreter in, PrologCode code, Term[] args, Term callTerm)`
`TracerEvent(Tracer tracer, Tracer.TraceLevel level, CompoundTermTag tag, Term[] args)`

Constructor parameters in gnu.prolog.vm.interpreter with type arguments of type Term
`InterpretedCodeCompiler(List<Term> clauses)` a constructor

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| GNU Prolog for Java
PREV NEXT | FRAMES NO FRAMES