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 |
gnu.prolog.io |
gnu.prolog.io.parser.gen |
gnu.prolog.term | Contains the various types of `Term` that can be used.
gnu.prolog.vm |
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
`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 heginning.
`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 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` | `TermReader.readTerm()`
`Term` | `TermReader.readTerm(OperatorSet set)`
`Term` | `TermReader.readTerm(ReadOptions options)`
`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` | `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
`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

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 term.
`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
`class` | `IntegerTerm` 32bit Integer term.
`class` | `JavaObjectTerm` Term which is embedding JavaObject This term should never participate in text IO operations.
`class` | `VariableTerm`

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` | `PrologStream.streamTerm`
`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)`
`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` | `Environment.getPrologFlag(AtomTerm term)` get flag for this environment
`Term` | `PrologStream.getStreamTerm()`
`Term` | `PrologException.getTerm()` get term of this exception
`Term` | `Environment.open(AtomTerm source_sink, AtomTerm mode, PrologStream.OpenOptions 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)`

Methods in gnu.prolog.vm that return types with arguments of type Term
`Map<AtomTerm,Term>` | `Environment.getPrologFlags()` get 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
`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 `#runInitialization()` 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)`
`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)`
`static void` | `PrologException.permissionError(AtomTerm operation, AtomTerm permissionType, Term culprit)`
`Interpreter.Goal` | `Interpreter.prepareGoal(Term term)` prepare goal for execution
`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)`
`static void` | `PrologException.representationError(Term errorTerm)`
`PrologStream` | `Environment.resolveStream(Term stream_or_alias)`
`protected void` | `Environment.setNewPrologFlag(AtomTerm flag, Term newValue, boolean changable)` set flag for this environment
`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)`
`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 interget term
`int` | `Interpreter.unify(Term t1, Term t2)` unify two terms
`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.vm with type arguments of type Term
`void` | `PrologStream.getProperties(List<Term> list)`

Constructors in gnu.prolog.vm with parameters of type Term
`PrologCollectionIterator(Iterable<?> iterable, Term destination, int undoPosition)`
`PrologCollectionIterator(Iterator<?> it, 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 term, 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 term, 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)` preform 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