| 
 | GNU Prolog for Java | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Uses of Term in gnu.prolog.database | 
|---|
| Fields in gnu.prolog.database with type parameters of type Term | |
|---|---|
| protected  List<Term> | Predicate.clauseslist of clauses for this predicate | 
| protected  List<Pair<PrologTextLoaderError,Term>> | Module.initializationinitialization | 
| 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.variable2nameMap 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 CharConversionTableto 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 CharConversionTableto 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 | AtomicTermbase class for all constant terms | 
|  class | AtomTermAtom term. | 
|  class | ChangeableTermTerms for which the value varies depending on prolog flags extend this class. | 
|  class | CompoundTermCompound terms are the basic method for combining terms. | 
|  class | DoubleQuotesTermTerm for storing a double quoted string as what this resolves to varies depending on the value of the double_quotes flag. | 
|  class | FloatTermFloating point number term (uses double) | 
|  class | IntegerTerm32bit Integer term. | 
|  class | JavaObjectTermTerm which is embedding JavaObject This term should never participate in text IO operations. | 
|  class | NumericTermAbstract class for all Terms which represent numbers | 
|  class | VariableTermRepresents Prolog variables such as X or A. | 
| Fields in gnu.prolog.term declared as Term | |
|---|---|
|  Term[] | CompoundTerm.argsterm argumets | 
|  Term | VariableTerm.valuevalue 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.destTermThe term to unify the value with | 
| protected  Term | PrologException.termterm of the exception | 
| Fields in gnu.prolog.vm with type parameters of type Term | |
|---|---|
| protected  Map<AtomTerm,Term> | Environment.atom2flagatom 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 PrologHaltDO 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.argsargument list save for call | 
| protected  Term[] | TracerEvent.args | 
|  Term[] | ExecutionState.argsarguments | 
|  Term[] | LeaveByteCodeBacktrackInfo.environment | 
|  Term[] | ExecutionState.environmentcurrent environment | 
| static Term[] | Predicate_call.termArrayTypeterm arry constant | 
| Fields in gnu.prolog.vm.interpreter with type parameters of type Term | |
|---|---|
| protected  List<Term> | InterpretedCodeCompiler.passedClausesclauses to compile | 
|  List<Term> | ExecutionState.pushdownpushdown stack, used for unification and calls | 
| protected  Map<Term,Integer> | InterpretedCodeCompiler.variableToEnvironmentIndexmapping 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 | |
| 
 | GNU Prolog for Java | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||