Uses of Interface
jason.asSyntax.Term

Packages that use Term

jason
jason.asSemantics
jason.asSyntax
jason.bb
jason.functions
jason.stdlib	Provides all default internal actions of Jason.

Uses of Term in jason

Fields in jason declared as Term

static Term	JasonException.UNKNOW_ERROR
static Term	JasonException.WRONG_ARGS

Methods in jason with parameters of type Term

void	JasonException.addErrorAnnot(Term t)
static ListTerm	JasonException.createBasicErrorAnnots(Term id, java.lang.String msg)

Constructors in jason with parameters of type Term

JasonException(java.lang.String msg, Term error)
Constructs an instance of JasonException with the specified detail message and error description term.

JasonException(java.lang.String msg, Term error, java.lang.Exception cause)

Uses of Term in jason.asSemantics

Fields in jason.asSemantics with type parameters of type Term

protected java.util.HashMap<VarTerm,Term>

Unifier.function

Methods in jason.asSemantics that return Term

Term	Unifier.get(java.lang.String var) gets the value for a Var, if it is unified with another var, gets this other's value
Term	Unifier.get(VarTerm vtp) gets the value for a Var, if it is unified with another var, gets this other's value
Term	Unifier.getAsTerm()
Term	Intention.getAsTerm()
Term	IntendedMeans.getAsTerm()
Term[]	InternalAction.prepareArguments(Literal body, Unifier un) Prepare body's terms to be used in 'execute', normally it consist of cloning and applying each term
Term[]	DefaultInternalAction.prepareArguments(Literal body, Unifier un)
Term[]	ConcurrentInternalAction.prepareArguments(Literal body, Unifier un)
Term	IntendedMeans.removeCurrentStep() removes the current action of the IM and returns the term of the body

Methods in jason.asSemantics with parameters of type Term

void	Unifier.apply(Term t) Deprecated. use t.apply(un) instead.
protected void	DefaultInternalAction.checkArguments(Term[] args)
double	DefaultArithFunction.evaluate(TransitionSystem ts, Term[] args)
double	ArithFunction.evaluate(TransitionSystem ts, Term[] args) evaluates/computes the function based on the args
java.lang.Object	InternalAction.execute(TransitionSystem ts, Unifier un, Term[] args) Executes the internal action.
java.lang.Object	DefaultInternalAction.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	ConcurrentInternalAction.execute(TransitionSystem ts, Unifier un, Term[] args)
boolean	Unifier.unifies(Term t1, Term t2) this version of unifies undo the variables' mapping if the unification fails.
boolean	Unifier.unifiesNoUndo(Term t1g, Term t2g) this version of unifies does not undo the variables' mapping in case of failure.
protected boolean	Unifier.unifyTerms(Term t1g, Term t2g)

Method parameters in jason.asSemantics with type arguments of type Term

boolean	TransitionSystem.generateGoalDeletion(Intention i, java.util.List<Term> failAnnots) generate a failure event for an intention
static void	ConcurrentInternalAction.resume(TransitionSystem ts, java.lang.String intentionKey, boolean abort, java.util.List<Term> failAnnots)

Uses of Term in jason.asSyntax

Subinterfaces of Term in jason.asSyntax

interface	ListTerm The interface for lists of the AgentSpeak language
interface	LogicalFormula Represents a logical formula (p, p & q, not p, 3 > X, ...) which can be evaluated into a truth value.
interface	NumberTerm The interface for numeric terms of AgentSpeak language
interface	ObjectTerm Interface for terms that encapsulate java objects
interface	PlanBody Interface for elements of a plans's body.
interface	StringTerm The interface for string terms of the AgentSpeak language

Classes in jason.asSyntax that implement Term

class	ArithExpr Represents and solve arithmetic expressions like "10 + 30".
class	ArithFunctionTerm Represents an arithmetic function, like math.max(arg1,arg2) -- a functor (math.max) and two arguments.
class	Atom Represents an atom (a positive literal with no argument and no annotation, e.g.
class	BinaryStructure Represents a binary/unary logical/relational operator.
class	BodyLiteral Deprecated. use PlanBodyImpl instead.
class	DefaultTerm Base class for all terms.
class	InternalActionLiteral A particular type of literal used to represent internal actions (which has a "." in the functor).
class	ListTermImpl Represents a list node as in prolog .(t1,.(t2,.(t3,.))).
class	Literal This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
class	LiteralImpl A Literal extends a Pred with strong negation (~).
class	LogExpr Represents a logical formula with some logical operator ("&", "|", "not").
class	NumberTermImpl Immutable class that implements a term that represents a number
class	ObjectTermImpl
class	Plan Represents an AgentSpack plan (it extends structure to be used as a term)
class	PlanBodyImpl Represents a plan body item (achieve, test, action, ...) and its successors.
class	Pred A Pred extends a Structure with annotations, e.g.: a(1)[an1,an2].
class	RelExpr Represents a relational expression like 10 > 20.
class	Rule A rule is a Literal (head) with a body, as in "a :- b & c".
class	StringTermImpl Immutable class for string terms.
class	Structure Represents a structure: a functor with n arguments, e.g.: val(10,x(3)).
class	Trigger Represents an AgentSpeak trigger (like +!g, +p, ...).
class	UnnamedVar Represents an unnamed variable '_'.
class	VarTerm Represents a variable Term: like X (starts with upper case).

Fields in jason.asSyntax declared as Term

protected static Term[]

Structure.emptyTermArray

Fields in jason.asSyntax with type parameters of type Term

protected static java.util.List<Term>

Structure.emptyTermList

Methods in jason.asSyntax that return Term

Term	VarTerm.clone()
Term	UnnamedVar.clone()
Term	Term.clone()
Term	Structure.clone() make a deep copy of the terms
Term	Pred.clone()
Term	Plan.clone()
Term	LiteralImpl.clone()
abstract Term	DefaultTerm.clone()
Term	Atom.clone()
static Term	Pred.createSource(Term source)
Term	VarTerm.get(int index)
Term	ListTermImpl.get(int index)
Term	VarTerm.getBodyTerm()
Term	PlanBodyImpl.getBodyTerm()
Term	PlanBody.getBodyTerm()
Term	BinaryStructure.getLHS() gets the LHS of this operation
Term	BinaryStructure.getRHS() gets the RHS of this operation
Term	VarTerm.getTerm()
Term	ListTermImpl.getTerm() gets the term of this ListTerm
Term	ListTerm.getTerm()
Term	VarTerm.getTerm(int i)
Term	Trigger.getTerm(int i)
Term	Structure.getTerm(int i)
Term	PlanBodyImpl.getTerm(int i)
Term	Plan.getTerm(int i)
Term	Literal.getTerm(int i) returns the i-th term (first term is 0)
Term	ListTermImpl.getTerm(int i)
Term[]	VarTerm.getTermsArray()
Term[]	Literal.getTermsArray() returns all terms of this literal as an array
Term	VarTerm.getValue() returns the value of this var.
static Term	DefaultTerm.parse(java.lang.String sTerm) Deprecated. it is preferable to use ASSyntax.parseTerm
static Term	ASSyntax.parseTerm(java.lang.String sTerm) creates a new term by parsing a string
Term	VarTerm.remove(int index)
Term	ListTermImpl.remove(int index)
Term	VarTerm.removeBody(int index)
Term	PlanBodyImpl.removeBody(int index)
Term	PlanBody.removeBody(int index)
Term	VarTerm.removeLast()
Term	ListTermImpl.removeLast()
Term	ListTerm.removeLast()
Term	VarTerm.set(int index, Term o)
Term	ListTermImpl.set(int index, Term t)

Methods in jason.asSyntax that return types with arguments of type Term

java.util.List<Term>	VarTerm.getAsList()
java.util.List<Term>	ListTermImpl.getAsList() Returns this ListTerm as a Java List (implemented by ArrayList).
java.util.List<Term>	ListTerm.getAsList()
java.util.List<Term>	VarTerm.getTerms()
java.util.List<Term>	Structure.getTerms()
java.util.List<Term>	Literal.getTerms() returns all terms of this literal
java.util.List<Term>	ListTermImpl.getTerms() return the this ListTerm elements (0=Term, 1=ListTerm)
java.util.Iterator<Term>	VarTerm.iterator()
java.util.Iterator<Term>	ListTermImpl.iterator() returns an iterator where each element is a Term of this list, the tail of the list is not considered.
java.util.ListIterator<Term>	VarTerm.listIterator()
java.util.ListIterator<Term>	ListTermImpl.listIterator()
java.util.ListIterator<Term>	VarTerm.listIterator(int index)
java.util.ListIterator<Term>	ListTermImpl.listIterator(int startIndex)
java.util.List<Term>	VarTerm.subList(int arg0, int arg1)
java.util.List<Term>	ListTermImpl.subList(int arg0, int arg1)
java.util.Iterator<java.util.List<Term>>	VarTerm.subSets(int k)
java.util.Iterator<java.util.List<Term>>	ListTermImpl.subSets(int k) returns all subsets that take k elements of this list
java.util.Iterator<java.util.List<Term>>	ListTerm.subSets(int k) returns all subsets that take k elements of this list

Methods in jason.asSyntax with parameters of type Term

void	VarTerm.add(int index, Term o)
void	ListTermImpl.add(int index, Term o)
Plan	PlanLibrary.add(Plan p, Term source, boolean before) Add a new plan in PL.
Plan	PlanLibrary.add(StringTerm stPlan, Term tSource) Deprecated. parse the plan before (ASSyntax methods) and call add(Plan, ...) methods
Plan	PlanLibrary.add(StringTerm stPlan, Term tSource, boolean before) Deprecated. parse the plan before (ASSyntax methods) and call add(Plan, ...) methods
boolean	VarTerm.add(Term o)
boolean	ListTermImpl.add(Term o)
boolean	VarTerm.addAnnot(Term t)
boolean	Pred.addAnnot(Term t)
boolean	Literal.addAnnot(Term t)
Literal	Pred.addAnnots(Term... l)
Literal	Literal.addAnnots(Term... terms) adds some annots and return this
void	VarTerm.addSource(Term t)
void	Pred.addSource(Term agName)
void	Literal.addSource(Term agName) adds the annotation source(agName)
void	VarTerm.addTerm(Term t)
void	Structure.addTerm(Term t)
void	Literal.addTerm(Term t)
void	ListTermImpl.addTerm(Term t)
Literal	Structure.addTerms(Term... ts)
Literal	Literal.addTerms(Term... ts) adds some terms and return this
ListTerm	VarTerm.append(Term t)
ListTerm	ListTermImpl.append(Term t) Adds a term in the end of the list
ListTerm	ListTerm.append(Term t)
int	VarTerm.compareTo(Term t)
int	UnnamedVar.compareTo(Term t)
int	Structure.compareTo(Term t)
int	StringTermImpl.compareTo(Term o)
int	Pred.compareTo(Term t)
int	NumberTermImpl.compareTo(Term o)
int	LiteralImpl.compareTo(Term t)
int	ListTermImpl.compareTo(Term o)
int	DefaultTerm.compareTo(Term t)
int	Atom.compareTo(Term t)
int	ArithFunctionTerm.compareTo(Term o)
static ListTerm	ASSyntax.createList(Term... terms) Creates a new list with n elements, n can be 0
static Literal	ASSyntax.createLiteral(boolean positive, java.lang.String functor, Term... terms) Creates a new literal, the first argument is either Literal.LPos or Literal.LNeg, the second is the functor (a string), and the n remainder arguments are terms.
static Literal	ASSyntax.createLiteral(java.lang.String functor, Term... terms) Creates a new positive literal, the first argument is the functor (a string) and the n remainder arguments are terms.
static Term	Pred.createSource(Term source)
static Structure	ASSyntax.createStructure(java.lang.String functor, Term... terms) Creates a new structure (compound) term, the first argument is the functor (a string), and the n remainder arguments are terms.
boolean	VarTerm.delAnnot(Term t)
boolean	Pred.delAnnot(Term t)
boolean	Literal.delAnnot(Term t)
boolean	VarTerm.delSource(Term s)
boolean	Pred.delSource(Term agName)
boolean	Literal.delSource(Term agName) deletes one source(agName) annotation, return true if deleted
boolean	VarTerm.hasAnnot(Term t)
boolean	Pred.hasAnnot(Term t)
boolean	Literal.hasAnnot(Term t) returns true if there is some annotation t in the literal
boolean	VarTerm.hasSource(Term s)
boolean	Pred.hasSource(Term agName)
boolean	Literal.hasSource(Term agName) returns true if this literal has a "source(agName)"
ListTerm	VarTerm.insert(Term t)
ListTerm	ListTermImpl.insert(Term t) insert a term in the begin of this list
ListTerm	ListTerm.insert(Term t)
boolean	PlanLibrary.remove(Atom pLabel, Term source) Remove a plan represented by the label pLabel.
Term	VarTerm.set(int index, Term o)
Term	ListTermImpl.set(int index, Term t)
void	VarTerm.setBodyTerm(Term t)
void	PlanBodyImpl.setBodyTerm(Term t)
void	PlanBody.setBodyTerm(Term t)
void	VarTerm.setNext(Term t)
void	ListTermImpl.setNext(Term l)
void	ListTerm.setNext(Term l)
void	VarTerm.setTerm(int i, Term t)
void	Trigger.setTerm(int i, Term t)
void	Structure.setTerm(int i, Term t)
void	PlanBodyImpl.setTerm(int i, Term t)
void	Plan.setTerm(int i, Term t)
void	Literal.setTerm(int i, Term t)
void	ListTermImpl.setTerm(int i, Term t)
void	VarTerm.setTerm(Term t)
void	ListTermImpl.setTerm(Term t)
void	ListTerm.setTerm(Term t)
boolean	VarTerm.setValue(Term vl) grounds a variable, set a value for this var (e.g.
static Trigger	Trigger.tryToGetTrigger(Term t) try to convert the term t into a trigger, in case t is a trigger term, a string that can be parsed to a trigger, a var with value trigger, ....
protected VarTerm	Structure.varToReplace(Term t, Unifier un)

Method parameters in jason.asSyntax with type arguments of type Term

Literal	VarTerm.addAnnots(java.util.List<Term> l)
Literal	Pred.addAnnots(java.util.List<Term> l)
Literal	Literal.addAnnots(java.util.List<Term> l) adds some annots and return this
Literal	VarTerm.addTerms(java.util.List<Term> l)
Literal	Structure.addTerms(java.util.List<Term> l)
Literal	Literal.addTerms(java.util.List<Term> l) adds some terms and return this
static ListTerm	ASSyntax.createList(java.util.Collection<Term> terms) Creates a new list from a collection of terms (each element of the collection is cloned)
boolean	VarTerm.delAnnots(java.util.List<Term> l)
boolean	Pred.delAnnots(java.util.List<Term> l)
boolean	Literal.delAnnots(java.util.List<Term> l) removes all annots in this pred that are in the list l.
Literal	VarTerm.setTerms(java.util.List<Term> l)
Literal	Structure.setTerms(java.util.List<Term> l)
Literal	Literal.setTerms(java.util.List<Term> l) set all terms of the literal and return this

Constructors in jason.asSyntax with parameters of type Term

BinaryStructure(java.lang.String id, Term arg)
Constructor for unary operator

BinaryStructure(Term t1, java.lang.String id, Term t2)
Constructor for binary operator

BodyLiteral(BodyLiteral.BodyType t, Term b)
Deprecated.

PlanBodyImpl(PlanBody.BodyType t, Term b)

RelExpr(Term t1, RelExpr.RelationalOp oper, Term t2)

Uses of Term in jason.bb

Fields in jason.bb declared as Term

static Term	BeliefBase.APercept
static Term	BeliefBase.ASelf
static Term	BeliefBase.TPercept represents the structure 'source(percept)'
static Term	BeliefBase.TSelf represents the structure 'source(self)'

Methods in jason.bb with parameters of type Term

static java.sql.Timestamp

JDBCPersistentBB.structure2timestamp(Term timestamp) translates structure like "timestamp(Y,M,D,H,M,S)" into a SQL timestamp

Uses of Term in jason.functions

Methods in jason.functions with parameters of type Term

double	time.evaluate(TransitionSystem ts, Term[] args)
double	pi.evaluate(TransitionSystem ts, Term[] args)
double	log.evaluate(TransitionSystem ts, Term[] args)
double	floor.evaluate(TransitionSystem ts, Term[] args)
double	e.evaluate(TransitionSystem ts, Term[] args)
double	ceil.evaluate(TransitionSystem ts, Term[] args)
double	Sum.evaluate(TransitionSystem ts, Term[] args)
double	StdDev.evaluate(TransitionSystem ts, Term[] args)
double	Sqrt.evaluate(TransitionSystem ts, Term[] args)
double	RuleToFunction.evaluate(TransitionSystem ts, Term[] args)
double	Round.evaluate(TransitionSystem ts, Term[] args)
double	Random.evaluate(TransitionSystem ts, Term[] args)
double	Min.evaluate(TransitionSystem ts, Term[] args)
double	Max.evaluate(TransitionSystem ts, Term[] args)
double	Length.evaluate(TransitionSystem ts, Term[] args)
double	Count.evaluate(TransitionSystem ts, Term[] args)
double	Average.evaluate(TransitionSystem ts, Term[] args)
double	Abs.evaluate(TransitionSystem ts, Term[] args)

Uses of Term in jason.stdlib

Methods in jason.stdlib that return Term

Term	add_nested_source.addAnnotToList(Unifier unif, Term l, Term source)
protected Term	add_annot.addAnnotToList(Unifier unif, Term l, Term annot)
Term[]	setof.prepareArguments(Literal body, Unifier un)
Term[]	loop.prepareArguments(Literal body, Unifier un)
Term[]	if_then_else.prepareArguments(Literal body, Unifier un)
Term[]	foreach.prepareArguments(Literal body, Unifier un)
Term[]	findall.prepareArguments(Literal body, Unifier un)
Term[]	eval.prepareArguments(Literal body, Unifier un)

Methods in jason.stdlib with parameters of type Term

Term	add_nested_source.addAnnotToList(Unifier unif, Term l, Term source)
protected Term	add_annot.addAnnotToList(Unifier unif, Term l, Term annot)
protected java.lang.String	println.argsToString(Term[] args)
protected void	suspended.checkArguments(Term[] args)
protected void	suspend.checkArguments(Term[] args)
protected void	suffix.checkArguments(Term[] args)
protected void	succeed_goal.checkArguments(Term[] args)
protected void	sublist.checkArguments(Term[] args)
protected void	sort.checkArguments(Term[] args)
protected void	setof.checkArguments(Term[] args)
protected void	send.checkArguments(Term[] args)
protected void	resume.checkArguments(Term[] args)
protected void	range.checkArguments(Term[] args)
protected void	random.checkArguments(Term[] args)
protected void	prefix.checkArguments(Term[] args)
protected void	nth.checkArguments(Term[] args)
protected void	min.checkArguments(Term[] args)
protected void	member.checkArguments(Term[] args)
protected void	loop.checkArguments(Term[] args)
protected void	intend.checkArguments(Term[] args)
protected void	if_then_else.checkArguments(Term[] args)
protected void	foreach.checkArguments(Term[] args)
protected void	findall.checkArguments(Term[] args)
protected void	eval.checkArguments(Term[] args)
protected void	drop_intention.checkArguments(Term[] args)
protected void	difference.checkArguments(Term[] args)
protected void	create_agent.checkArguments(Term[] args)
protected void	count.checkArguments(Term[] args)
protected void	broadcast.checkArguments(Term[] args)
protected void	abolish.checkArguments(Term[] args)
protected boolean	min.compare(Term a, Term t)
protected boolean	max.compare(Term a, Term t)
java.lang.Object	wait.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	union.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	time.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	term2string.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	suspended.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	suspend.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	suffix.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	succeed_goal.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	substring.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	sublist.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	structure.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	string.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	stopMAS.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	sort.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	setof.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	send.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	reverse.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	resume.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	remove_plan.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	relevant_plans.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	range.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	random.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	puts.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	println.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	prefix.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	plan_label.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	perceive.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	number.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	nth.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	my_name.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	min.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	member.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	loop.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	literal.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	list_plans.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	list.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	length.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	kill_agent.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	intersection.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	intend.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	if_then_else.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	ground.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	foreach.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	findall.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	fail_goal.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	fail.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	eval.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	drop_intention.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	drop_event.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	drop_desire.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	drop_all_intentions.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	drop_all_events.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	drop_all_desires.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	difference.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	desire.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	delete.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	date.execute(TransitionSystem ts, Unifier un, Term[] args) date(YY,MM,DD)
java.lang.Object	current_intention.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	create_agent.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	count.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	concat.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	clone.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	broadcast.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	atom.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	at.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	all_names.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	add_plan.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	add_nested_source.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	add_annot.execute(TransitionSystem ts, Unifier un, Term[] args)
java.lang.Object	abolish.execute(TransitionSystem ts, Unifier un, Term[] args)