|
GNU Prolog for Java | |||||||||
PREV NEXT | FRAMES NO FRAMES |
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 |
|
GNU Prolog for Java | |||||||||
PREV NEXT | FRAMES NO FRAMES |