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

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

Packages that use CompoundTermTag
gnu.prolog.database | Classes related to the storing and creation of the database of Prolog `Predicates`
gnu.prolog.io | Classes used for IO
gnu.prolog.io.parser.gen |
gnu.prolog.term | Contains the various types of `Term` that can be used.
gnu.prolog.vm | The Virtual Machine which is used to run the prolog code.
gnu.prolog.vm.buildins.datetime |
gnu.prolog.vm.buildins.debug |
gnu.prolog.vm.buildins.dialogs |
gnu.prolog.vm.buildins.list |
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`.
gnu.prolog.vm.interpreter.instruction |

Uses of CompoundTermTag in gnu.prolog.database

Fields in gnu.prolog.database declared as CompoundTermTag
`static CompoundTermTag` | `PrologTextLoader.build_inTag`
`static CompoundTermTag` | `PrologTextLoader.char_conversionTag`
`static CompoundTermTag` | `PrologTextLoader.controlTag`
`static CompoundTermTag` | `PrologTextLoader.discontiguousTag`
`static CompoundTermTag` | `PrologTextLoader.dynamicTag`
`static CompoundTermTag` | `PrologTextLoader.ensure_loadedTag`
`static CompoundTermTag` | `PrologTextLoader.externalTag`
`static CompoundTermTag` | `PrologTextLoader.file1Tag`
`protected static CompoundTermTag` | `PrologTextLoaderState.fileTag`
`static CompoundTermTag` | `PrologTextLoader.includeTag`
`static CompoundTermTag` | `PrologTextLoader.initializationTag`
`static CompoundTermTag` | `PrologTextLoader.multifileTag`
`static CompoundTermTag` | `PrologTextLoader.opTag`
`static CompoundTermTag` | `PrologTextLoader.resource1Tag`
`protected static CompoundTermTag` | `PrologTextLoaderState.resourceTag`
`static CompoundTermTag` | `PrologTextLoader.set_prolog_flagTag`
`protected CompoundTermTag` | `PredicateUpdatedEvent.tag`
`protected CompoundTermTag` | `Predicate.tag` a tag of predicate head
`static CompoundTermTag` | `PrologTextLoader.url1Tag`
`protected static CompoundTermTag` | `PrologTextLoaderState.urlTag`

Fields in gnu.prolog.database with type parameters of type CompoundTermTag
`protected Map<CompoundTermTag,Predicate>` | `Module.tag2predicate` map from tag to predicates

Methods in gnu.prolog.database that return CompoundTermTag
`CompoundTermTag` | `PredicateUpdatedEvent.getTag()` get tag of changed predicate
`CompoundTermTag` | `Predicate.getTag()` get tag of predicate

Methods in gnu.prolog.database that return types with arguments of type CompoundTermTag
`Set<CompoundTermTag>` | `Module.getPredicateTags()` get predicate tags

Methods in gnu.prolog.database with parameters of type CompoundTermTag
`Predicate` | `Module.createDefinedPredicate(CompoundTermTag tag)` create new predicate defined in this module
`void` | `PrologTextLoaderState.declareDiscontiguous(PrologTextLoader loader, CompoundTermTag tag)`
`boolean` | `PrologTextLoaderState.declareDynamic(PrologTextLoader loader, CompoundTermTag tag)`
`void` | `PrologTextLoaderState.declareMultifile(PrologTextLoader loader, CompoundTermTag tag)`
`protected Predicate` | `PrologTextLoaderState.findOrCreatePredicate(CompoundTermTag tag)`
`Predicate` | `Module.getDefinedPredicate(CompoundTermTag tag)` get predicate defined in this module
`void` | `Module.predicateUpdated(CompoundTermTag tag)`
`void` | `Module.removeDefinedPredicate(CompoundTermTag tag)`

Constructors in gnu.prolog.database with parameters of type CompoundTermTag
`Predicate(Module module, CompoundTermTag tag)` constructor of predicate
`PredicateUpdatedEvent(Module module, CompoundTermTag tag)`

Uses of CompoundTermTag in gnu.prolog.io

Fields in gnu.prolog.io declared as CompoundTermTag
`static CompoundTermTag` | `PrologStream.aliasTag`
`protected static CompoundTermTag` | `TermWriter.curly1Tag`
`static CompoundTermTag` | `PrologStream.endOfStreamTag`
`static CompoundTermTag` | `PrologStream.eofActionTag`
`static CompoundTermTag` | `PrologStream.filenameTag`
`static CompoundTermTag` | `PrologStream.modeTag`
`protected static CompoundTermTag` | `TermWriter.numbervarsTag`
`static CompoundTermTag` | `PrologStream.positionTag`
`static CompoundTermTag` | `PrologStream.repositionTag`
`CompoundTermTag` | `Operator.tag`
`static CompoundTermTag` | `PrologStream.typeTag`

Methods in gnu.prolog.io with parameters of type CompoundTermTag
`Operator` | `OperatorSet.getOperatorForTag(CompoundTermTag tag)`

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

Methods in gnu.prolog.io.parser.gen that return CompoundTermTag
`CompoundTermTag` | `TermParser.op(ReadOptions options, int priority)`
`CompoundTermTag` | `TermParser.op2(ReadOptions options, int priority)`

Uses of CompoundTermTag in gnu.prolog.term

Fields in gnu.prolog.term declared as CompoundTermTag
`static CompoundTermTag` | `CompoundTermTag.comma` comma tag
`static CompoundTermTag` | `CompoundTermTag.curly1` '{}'/1 tag
`static CompoundTermTag` | `CompoundTermTag.divide2` '/'/2 tag
`static CompoundTermTag` | `CompoundTermTag.minus2` '-'/2 tag
`CompoundTermTag` | `CompoundTerm.tag` term tag

Methods in gnu.prolog.term that return CompoundTermTag
`static CompoundTermTag` | `CompoundTermTag.get(AtomTerm functor, int arity)` get compound term tag
`static CompoundTermTag` | `CompoundTermTag.get(CompoundTerm predicateIndicator)` get compound term tag
`static CompoundTermTag` | `CompoundTermTag.get(String functor, int arity)` get compound term tag

Constructors in gnu.prolog.term with parameters of type CompoundTermTag
`CompoundTerm(CompoundTermTag tag)` a contructor
`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.

Uses of CompoundTermTag in gnu.prolog.vm

Fields in gnu.prolog.vm declared as CompoundTermTag
`static CompoundTermTag` | `Evaluate.abs1`
`static CompoundTermTag` | `Evaluate.add2`
`static CompoundTermTag` | `Evaluate.atan1`
`static CompoundTermTag` | `Evaluate.band2`
`static CompoundTermTag` | `Evaluate.blshift2`
`static CompoundTermTag` | `Evaluate.bnot1`
`static CompoundTermTag` | `Evaluate.bor2`
`static CompoundTermTag` | `Evaluate.brshift2`
`static CompoundTermTag` | `TermConstants.callTag`
`static CompoundTermTag` | `Evaluate.ceiling1`
`static CompoundTermTag` | `TermConstants.clauseTag`
`static CompoundTermTag` | `TermConstants.conjunctionTag` tag for conjunction
`static CompoundTermTag` | `Evaluate.cos1`
`static CompoundTermTag` | `TermConstants.directiveTag`
`static CompoundTermTag` | `TermConstants.disjunctionTag` tag for disjunction
`static CompoundTermTag` | `Evaluate.div2`
`static CompoundTermTag` | `PrologException.domainErrorTag`
`static CompoundTermTag` | `PrologException.errorTag`
`static CompoundTermTag` | `PrologException.evaluationErrorTag`
`static CompoundTermTag` | `PrologException.existenceErrorTag`
`static CompoundTermTag` | `Evaluate.exp1`
`static CompoundTermTag` | `Evaluate.float1`
`static CompoundTermTag` | `Evaluate.floor1`
`static CompoundTermTag` | `Evaluate.fractpart1`
`static CompoundTermTag` | `TermConstants.ifTag` tag for if
`static CompoundTermTag` | `TermConstants.ignoreOpsTag`
`static CompoundTermTag` | `Evaluate.intdiv2`
`static CompoundTermTag` | `Evaluate.intpart1`
`static CompoundTermTag` | `TermConstants.listTag`
`static CompoundTermTag` | `Evaluate.log1`
`static CompoundTermTag` | `Evaluate.mod2`
`static CompoundTermTag` | `Evaluate.mul2`
`static CompoundTermTag` | `Evaluate.neg1`
`static CompoundTermTag` | `TermConstants.numbervarsTag`
`static CompoundTermTag` | `PrologException.permissionErrorTag`
`static CompoundTermTag` | `Environment.plusTag`
`static CompoundTermTag` | `Evaluate.power2`
`protected CompoundTermTag` | `UndefinedPredicateCode.predicateTag` predicate tag
`static CompoundTermTag` | `TermConstants.quotedTag`
`static CompoundTermTag` | `Evaluate.random1` Implementation of the random/1 predicate defined in SWI-Prolog random(+IntExpr) Evaluates to a random integer i for which 0 =< i < IntExpr.
`static CompoundTermTag` | `Evaluate.rem2`
`static CompoundTermTag` | `PrologException.representationErrorTag`
`static CompoundTermTag` | `Evaluate.round1`
`static CompoundTermTag` | `Evaluate.sign1`
`static CompoundTermTag` | `Evaluate.sin1`
`static CompoundTermTag` | `TermConstants.singletonsTag`
`static CompoundTermTag` | `Evaluate.sqrt1`
`static CompoundTermTag` | `Evaluate.sub2`
`static CompoundTermTag` | `PrologException.syntaxErrorTag`
`static CompoundTermTag` | `Evaluate.truncate1`
`static CompoundTermTag` | `PrologException.typeErrorTag`
`static CompoundTermTag` | `TermConstants.unifyTag`
`static CompoundTermTag` | `TermConstants.variableNamesTag`
`static CompoundTermTag` | `TermConstants.variablesTag`

Fields in gnu.prolog.vm with type parameters of type CompoundTermTag
`protected Map<CompoundTermTag,PrologCode>` | `Environment.tag2code` PredicateTag to code mapping
`protected Map<CompoundTermTag,List<gnu.prolog.vm.Environment.PrologCodeListenerRef>>` | `Environment.tag2listeners`

Methods in gnu.prolog.vm that return CompoundTermTag
`CompoundTermTag` | `PrologCodeUpdatedEvent.getPredicateTag()` get tag of predicate

Methods in gnu.prolog.vm with parameters of type CompoundTermTag
`void` | `Environment.addPrologCodeListener(CompoundTermTag tag, PrologCodeListener listener)` add prolog code listener
`PrologCode` | `Environment.getPrologCode(CompoundTermTag tag)` get prolog code
`PrologCode` | `Environment.getUndefinedPredicateCode(CompoundTermTag tag)` get undefined predicate code
`PrologCode` | `Environment.loadPrologCode(CompoundTermTag tag)` load code for prolog
`void` | `Environment.removePrologCodeListener(CompoundTermTag tag, PrologCodeListener listener)` remove prolog code listener

Constructors in gnu.prolog.vm with parameters of type CompoundTermTag
`PrologCodeUpdatedEvent(Environment environment, CompoundTermTag tag)` a constructor
`UndefinedPredicateCode(CompoundTermTag predicateTag)` construct new instance of undefined predicate

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

Fields in gnu.prolog.vm.buildins.datetime declared as CompoundTermTag
`static CompoundTermTag` | `DateTimePrologCode.date3Tag`
`static CompoundTermTag` | `DateTimePrologCode.date9Tag`
`static CompoundTermTag` | `DateTimePrologCode.timeTag`

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

Methods in gnu.prolog.vm.buildins.debug that return CompoundTermTag
`static CompoundTermTag` | `Predicate_spy.getTag(Term term)`

Methods in gnu.prolog.vm.buildins.debug with parameters of type CompoundTermTag
`protected void` | `Predicate_spy.setSpyPoint(Interpreter interpreter, CompoundTermTag tag, Term arg)`

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

Fields in gnu.prolog.vm.buildins.dialogs declared as CompoundTermTag
`static CompoundTermTag` | `Predicate_dialog.FILEMASK_TAG`
`static CompoundTermTag` | `Predicate_dialog.MESSAGE_TAG`
`static CompoundTermTag` | `Predicate_dialog.SELECTION_TAG`
`static CompoundTermTag` | `Predicate_dialog.TITLE_TAG`
`static CompoundTermTag` | `Predicate_dialog.TYPE_TAG`

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

Fields in gnu.prolog.vm.buildins.list declared as CompoundTermTag
`static CompoundTermTag` | `Predicate_predsort.COMPARE_TAG`

Uses of CompoundTermTag in gnu.prolog.vm.interpreter

Fields in gnu.prolog.vm.interpreter declared as CompoundTermTag
`protected CompoundTermTag[]` | `Tracer.callStack`
`static CompoundTermTag` | `InterpretedCodeCompiler.catchTag` catch tag
`protected CompoundTermTag` | `InterpretedCodeCompiler.codeTag` this predicate tag
`protected CompoundTermTag` | `InterpretedByteCode.codeTag` tag of this code
`CompoundTermTag` | `CallBacktrackInfo.tag`
`protected CompoundTermTag` | `TracerEvent.tag`
`protected CompoundTermTag[]` | `InterpretedByteCode.tags` tags used by code
`static CompoundTermTag` | `InterpretedCodeCompiler.throwTag` throw tag
`static CompoundTermTag` | `InterpretedCodeCompiler.unifyTag` unify tag

Fields in gnu.prolog.vm.interpreter with type parameters of type CompoundTermTag
`protected Map<CompoundTermTag,EnumSet<Tracer.TraceLevel>>` | `Tracer.tracePoints` Current active trace points
`static Set<CompoundTermTag>` | `Tracer.UNTRACEABLE`

Methods in gnu.prolog.vm.interpreter that return CompoundTermTag
`CompoundTermTag[]` | `Tracer.getCallStack()`
`CompoundTermTag` | `TracerEvent.getTag()`

Methods in gnu.prolog.vm.interpreter with parameters of type CompoundTermTag
`void` | `Tracer.addTrace(CompoundTermTag pred, EnumSet<Tracer.TraceLevel> levels)` Set a trace point
`void` | `Tracer.addTrace(CompoundTermTag pred, Tracer.TraceLevel level)`
`CallBacktrackInfo` | `ExecutionState.getCallBacktrackInfo(int codePosition, Term[] args, PrologCode code, CompoundTermTag tag)` get BacktrackInfo for call instruction.
`void` | `Tracer.removeTrace(CompoundTermTag pred)` Remove a trace point
`void` | `Tracer.removeTrace(CompoundTermTag pred, EnumSet<Tracer.TraceLevel> levels)` Remove a given level
`void` | `Tracer.removeTrace(CompoundTermTag pred, Tracer.TraceLevel level)`
`protected void` | `Tracer.sendEvent(Tracer.TraceLevel level, Interpreter interpreter, CompoundTermTag tag, Term[] args)` Notify the listeners
`void` | `Tracer.setTrace(CompoundTermTag pred, EnumSet<Tracer.TraceLevel> levels)`
`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 CompoundTermTag
`protected void` | `InterpretedByteCode.pass1(Instruction[] isrc, int[] ipos, Map<CompoundTermTag,Integer> tag2idx, Map<AtomicTerm,Integer> constant2idx)`
`protected void` | `InterpretedByteCode.pass2(Instruction[] isrc, int[] ipos, Map<CompoundTermTag,Integer> tag2idx, Map<AtomicTerm,Integer> constant2idx)`

Constructors in gnu.prolog.vm.interpreter with parameters of type CompoundTermTag
`CallBacktrackInfo(int undoPosition, int codePosition, Term[] args, PrologCode code, CompoundTermTag tag)` a constructor
`InterpretedByteCode(CompoundTermTag codeTag, Instruction[] isrc, ExceptionHandlerInfo[] ehs)` constructor of code
`TracerEvent(Tracer tracer, Tracer.TraceLevel level, CompoundTermTag tag, Term[] args)`

Uses of CompoundTermTag in gnu.prolog.vm.interpreter.instruction

Fields in gnu.prolog.vm.interpreter.instruction declared as CompoundTermTag
`CompoundTermTag` | `ICreateCompoundTerm.tag` position of term in environment
`CompoundTermTag` | `ICall.tag` tag of predicate to call

Constructors in gnu.prolog.vm.interpreter.instruction with parameters of type CompoundTermTag
`ICall(CompoundTermTag tag)` a constructor
`ICreateCompoundTerm(CompoundTermTag tag)` a constructor

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