[Top] [Contents] [Index] [ ? ]

The cram-language Reference Manual

This is the cram-language Reference Manual, generated automatically by Declt version 2.0 patchlevel 1 "Benjamin Sisko" on Mon Feb 01 17:49:04 2016 GMT+1.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

1. Systems

The main system appears first, followed by any subsystem dependency.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

1.1 cram-language

Maintainer

Lorenz Moesenlechner <moesenle@cs.tum.edu>

Author

Lorenz Moesenlechner <moesenle@cs.tum.edu>

License

BSD

Description

Coginitive plan language

Long Description

cram-language is a new plan language.

Dependencies
  • trivial-garbage
  • alexandria
  • cram-utilities
  • sb-cltl2
Definition file

cram-language.asd (Lisp file)

Component

src (module)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

2. Modules

Modules are listed depth-first from the system components tree.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

2.1 src/

Parent

cram-language (system)

Location

src/

Components

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

2.2 src/tasks/

Dependencies
Parent

src (module)

Location

src/tasks/

Components

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

2.3 src/fluents/

Dependencies
Parent

src (module)

Location

src/fluents/

Components

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

2.4 src/walker/

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/walker/

Components

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3. Files

Files are sorted by type and then listed depth-first from the systems components trees.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1 Lisp


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.1 cram-language.asd

Location

cram-language.asd


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.2 src/packages.lisp

Parent

src (module)

Location

src/packages.lisp

Packages

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.3 src/utils.lisp

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/utils.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.4 src/task-interface.lisp

Dependencies
Parent

src (module)

Location

src/task-interface.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.5 src/fluent-interface.lisp

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/fluent-interface.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.6 src/logging.lisp

Dependencies
Parent

src (module)

Location

src/logging.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.7 src/with-policy.lisp

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/with-policy.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.8 src/default-policies.lisp

Dependencies
Parent

src (module)

Location

src/default-policies.lisp

Exported Definitions

timeout-policy (special variable)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.9 src/tasks/failures.lisp

Parent

tasks (module)

Location

src/tasks/failures.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.10 src/tasks/task.lisp

Dependency

failures (Lisp file)

Parent

tasks (module)

Location

src/tasks/task.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.11 src/tasks/task-tree.lisp

Dependency

task (Lisp file)

Parent

tasks (module)

Location

src/tasks/task-tree.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.12 src/fluents/fluent.lisp

Parent

fluents (module)

Location

src/fluents/fluent.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.13 src/fluents/value-fluent.lisp

Dependency

fluent (Lisp file)

Parent

fluents (module)

Location

src/fluents/value-fluent.lisp

Exported Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.14 src/fluents/fluent-net.lisp

Dependency

fluent (Lisp file)

Parent

fluents (module)

Location

src/fluents/fluent-net.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.15 src/fluents/pulse-fluent.lisp

Dependency

fluent (Lisp file)

Parent

fluents (module)

Location

src/fluents/pulse-fluent.lisp

Exported Definitions
Internal Definitions

pulse-fluent (class)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.16 src/walker/env.lisp

Parent

walker (module)

Location

src/walker/env.lisp

Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.17 src/walker/env-impl-specific.lisp

Dependency

env (Lisp file)

Parent

walker (module)

Location

src/walker/env-impl-specific.lisp


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.18 src/walker/plan-tree.lisp

Dependency

env-impl-specific (Lisp file)

Parent

walker (module)

Location

src/walker/plan-tree.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.19 src/walker/walker.lisp

Dependency

plan-tree (Lisp file)

Parent

walker (module)

Location

src/walker/walker.lisp

Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.20 src/walker/interface.lisp

Dependency

walker (Lisp file)

Parent

walker (module)

Location

src/walker/interface.lisp

Exported Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.21 src/language.lisp

Dependencies
Parent

src (module)

Location

src/language.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.22 src/plans.lisp

Dependencies
Parent

src (module)

Location

src/plans.lisp

Exported Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.23 src/goals.lisp

Dependencies
Parent

src (module)

Location

src/goals.lisp

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.24 src/fluent-operators.lisp

Dependencies
Parent

src (module)

Location

src/fluent-operators.lisp

Exported Definitions
  • * (function)
  • + (function)
  • - (function)
  • / (function)
  • < (function)
  • = (function)
  • > (function)
  • eq (function)
  • eql (function)
  • not (function)
  • pulsed (function)
  • sleep (function)

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.25 src/swank-indentation.lisp

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/swank-indentation.lisp


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

3.1.26 src/sbcl-hotpatches.lisp

Parent

src (module)

Location

src/sbcl-hotpatches.lisp


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4. Packages

Packages are listed by definition order.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.1 cram-user

Source

packages (Lisp file)

Nickname

cpl-user

Use List

cram-language


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.2 cram-language

Main package of a new planning language similar to RPL.

Source

packages (Lisp file)

Nickname

cpl

Use List
Used By List

cram-user

Exported Definitions
  • * (function)
  • + (function)
  • - (function)
  • / (function)
  • < (function)
  • = (function)
  • > (function)
  • eq (function)
  • eql (function)
  • not (function)
  • pulsed (function)
  • sleep (function)
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.3 cram-language-implementation

Internal implementation package of CPL.

Source

packages (Lisp file)

Nickname

cpl-impl

Use List
  • common-lisp
  • cram-walker
  • cram-utilities
  • trivial-garbage
  • alexandria.0.dev
Used By List

cram-language

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.4 cram-walker

A fairly basic code walker for use in CPL for expanding plans.

Source

packages (Lisp file)

Nickname

walker

Use List

common-lisp

Used By List

cram-language-implementation

Exported Definitions
Internal Definitions

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5. Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1 Exported definitions


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.1 Special variables

Special Variable: *break-on-plan-failures*

Like *BREAK-ON-SIGNALS*, but for plan failures.

Package

cram-language-implementation

Source

failures (Lisp file)

Special Variable: *current-path*

Contains the current path (in reverse order).

Package

cram-language-implementation

Source

task-interface (Lisp file)

Special Variable: *current-task*

Dynamically bound current task.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Special Variable: *debug-on-lisp-errors*

Indicates if the debugger should be entered at the location where a
common lisp error is raised.

Package

cram-language-implementation

Source

failures (Lisp file)

Special Variable: *log-output*

Where should logging output go to?

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: *log-right-margin*

Value for *PRINT-RIGHT-MARGIN* when printing log entries.
Good values between 120 - 150, depending on your window width.

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: *save-tasks*

When t, every task to be executed is pushed to *tasks*.

Package

cram-language-implementation

Source

task (Lisp file)

Special Variable: *task-pprint-verbosity*

Verbosity level for how TASK objects are printed.
A value of 0 means that no information is printed that may depend
on a lock.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Special Variable: *task-tree*

The task tree of the current top-level plan.

Package

cram-language-implementation

Source

task (Lisp file)

Special Variable: *tasks*

Queue of all running tasks.

Package

cram-language-implementation

Source

task (Lisp file)

Special Variable: +alive+

Package

cram-language-implementation

Source

task-interface (Lisp file)

Special Variable: +dead+

Package

cram-language-implementation

Source

task-interface (Lisp file)

Special Variable: +done+

Package

cram-language-implementation

Source

task-interface (Lisp file)

Special Variable: +log-all+

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: +log-default+

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: +log-language+

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: +log-verbose+

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: +log-very-verbose+

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: timeout-policy

Package

cram-language-implementation

Source

default-policies (Lisp file)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.2 Macros

Macro: declare-goal NAME LAMBDA-LIST &body BODY

Declares the goal ‘name’. Before matching goals defined with
‘def-goal’ are executed, ‘body’ is executed with ‘pattern’ lexically
bound to the parameter specified when the goal was called. ‘body’ is
executed in an unnamed block that allows for suppressing the execution
of any goal. The idea behind that is that ‘body’ can verify if the
goal already holds and suppress execution of any code.

Package

cram-language-implementation

Source

goals (Lisp file)

Macro: def-cpl-parameter NAME &optional VAL DOC

Defines a global variable (like DEFPARAMETER) that is implemented as a
fluent. You can access it like a lisp variable with "NAME", and also setf it like a lisp variable "(SETF NAME)" - note there is no need for
"(VALUE NAME)". However the variable being implemented as a fluent means that the access is implicitely synchronized with a lock, and all changes are traced if fluent tracing is enabled.

You cannot directly access the implementing fluent which means that you cannot use it for building fluent nets or in cpl-constructs like
WHENEVER. (Just use a normal variable containing a fluent for those purposes).

You can use this for example for defining global datastructures that need not participate directly in cpl constructs, but should be traced in the execution trace and/or accessed by multiple tasks/threads simultaniously.

Package

cram-language-implementation

Source

value-fluent (Lisp file)

Macro: def-cram-function NAME LAMBDA-LIST &rest BODY

Defines a cram function. All functions that should appear in the
task-tree must be defined with def-cram-function.

CAVEAT: See docstring of def-top-level-cram-function.

Package

cram-language-implementation

Source

plans (Lisp file)

Macro: def-goal (NAME &rest PATTERN) &body BODY

Defines a new goal. Goals always have the form

(<name> [pattern]*)

where patterns can be arbitrary expressions containing
variables (indicated by a ?-prefix) and symbols.
Example: (achieve (loc ?obj ?location)) When defining goals with
similar expressions (e.g. (loc Robot ?l) and (loc ?a ?b)) the most
specific expression must be defined first. Otherwise, the previously
defined expression will be overwritten.

In the lexical environment of ‘body’, the function (SUCCEED [values])
is defined which performs a non-local exit, returning ‘values’ as
return values.

Package

cram-language-implementation

Source

goals (Lisp file)

Macro: def-plan NAME LAMBDA-LIST &rest BODY

Package

cram-language-implementation

Source

plans (Lisp file)

Macro: def-top-level-cram-function NAME ARGS &body BODY

Defines a top-level cram function. Every top-level function has its
own episode-knowledge and task-tree.

CAVEAT: Don’t have surrounding FLET / LABLES / MACROLET /
SYMBOL-MACROLET / LET / etc when using DEF-TOP-LEVEL-CRAM-FUNCTION
or DEF-CRAM-FUNCTION (unless you really know what you are
doing). They could mess with (WITH-TAGS ...) or shadow globally
defined plans, which would not be picked up by WITH-TAGS /
EXPAND-PLAN. See the comment before the definition of WITH-TAGS for
more details.

Package

cram-language-implementation

Source

plans (Lisp file)

Macro: def-top-level-plan NAME LAMBDA-LIST &body BODY

Package

cram-language-implementation

Source

plans (Lisp file)

Macro: define-policy NAME PARAMETERS &rest PROPERTIES

This macro implicitly calls ‘make-policy’, and pushes the generated
policy onto the list of defined policies, thus making it accessible to ‘named-policy’ and ‘with-named-policy’ by its name. The usage is the
same as for ‘make-policy’:

> (define-policy policy-1 (param-1 param-2)
"The documentation string for this policy"
(:init (do-initialization-here))
(:check (do-checking-here))
(:recover (do-recovering-here))
(:clean-up (do-cleaning-up-here)))

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: define-task-variable NAME &optional GLOBAL-VALUE DOCSTRING &key TYPE INIT-FUNCTION IGNORE-PACKAGE-LOCKS

Define a binding for ‘name’ as a special variable, and in
particular as a task variable.

‘global-value’ is the variable’s global value; if not given, the
variable is unbound. ‘docstring’ is its documentation string. ‘type’
is, optionally, its globally proclaimed type.

A task variable is a binding that is established and initialized right
before execution of a task. The binding is task-local, meaning that
assignment to it won’t affect the variable’s global binding, or
bindings within other tasks.

The initialization is performed by ‘init-function’ which must be a
function of three parameters: the TASK object going to be executed,
the TASK object of the parent task, and the previous value of ‘name’
in the parent. In case the task object is a TOPLEVEL-TASK, the second
argument will be NIL, and the third one will be the global value.

Task variables can hence be used for different purposes:

1. to initialize a variable based on the task object to be executed.

2. to initialize a variable based on the task’s parent.

3. to inherit a task variable’s value from its parent.

In case ‘init-function’ is not given, the default behaviour is the
behaviour of the 3rd item.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Macro: log-event &body CLAUSES

Logs an event specified by ‘clauses’ to *LOG-OUTPUT*.

Syntax:

clauses ::= (:CONTEXT fmt-ctrl . fmt-args)
| (:DISPLAY fmt-ctrl . fmt-args)
| (:TAGS tag+)

A log entry will look like

<realtime> , <runtime> - <current task> > <context> ; <display>

Where

<realtime> denotes a timestamp relative to *ZERO-REAL-TIME*,

<runtime> denotes a timestamp relative to *ZERO-RUN-TIME*,

<current task> denotes the name of the currently active task,

<context> denotes the result of the format-control ‘fmt-ctrl’ applied to the format-arguments ‘fmt-args’ of the
given :CONTEXT clause,

<display> ditto but for the :DISPLAY clause.

The :TAGS clause specifies the log tags that must be active for
this LOG-EVENT to emit any output.

It is hence possible to specify the degree of logging in a very fine-grained way: log tags can be dynamically enabled by
LOG-ENABLE, disabled by LOG-DISABLE, and set by LOG-SET.

Most defined log tags correspond to constructs of cpl or the underlying implementation. Use the :debug tag for adding (temporary) debug messages.

For convenience, the following constants are defined to enable a
bunch of tags at once:

+LOG-ALL+ - set of all available tags

+LOG-DEFAULT+ - a predefined default set

+LOG-VERBOSE+ - +LOG-DEFAULT+ + more

+LOG-VERY-VERBOSE+ - +LOG-VERBOSE+ + even more

+LOG-LANGUAGE+ - set of all CRAM language constructs.

See also

LIST-AVAILABLE-LOG-TAGS

LIST-ACTIVE-LOG-TAGS

DEFINE-LOG-TAGS

*LOG-RIGHT-MARGIN*

Package

cram-language-implementation

Source

logging (Lisp file)

Macro: logging-enabled-p &rest TAGS

Is any tag in ‘tags’ active at the moment?

Package

cram-language-implementation

Source

logging (Lisp file)

Macro: make-policy NAME PARAMETERS &rest DOC-AND-PROPERTIES

Generates a policy based on the information supplied. ‘name’
specifies an internal name for the policy, to be used with
‘named-policy’, or ‘with-named-policy’. ‘parameters’ is a list of
parameter symbols to be used by code inside the policy. Every time, a
piece of code inside the policy is executed, these parameters (with
assigned values from the ‘with-policy’, or ‘with-named-policy’ call)
are passed to the code segments. The ‘properties’ variable holds a
list of labelled code segments for execution during certain phases. An
example would look like this:

> (make-policy policy-1 (param-1 param-2)
"The documentation string for this policy"
(:init (do-initialization-here))
(:check (do-checking-here))
(:recover (do-recovering-here))
(:clean-up (do-cleaning-up-here)))

This returns a policy object to be used with ‘with-policy’. For
further information about when each function block is executed, see ‘with-policy’. The semantics of the ‘properties’ variable are like
this:

- Forms given via ‘:init’ are executed exactly once, when the policy
is initialized for usage. In case this function returns ‘nil’,
execution of the ‘body’ code is not started, none of the other
policy code blocks are executed, and a failure of type
‘policy-init-failed’ is thrown.

- A function given under the label ‘:check’ is executed every time ‘with-policy’ checks if the policy condition is met or not. If this
function returns ‘t’, the condition is met, the ‘:recover’ function
block is executed, and the execution of both, the policy, and the
wrapped body code of ‘with-policy’ is stopped.

- Either when the policy (due to a met policy condition), or the
wrapped body of ‘with-policy’ code stopped execution of the current
code block, the ‘:clean-up’ function block is executed to perform
clean-up procedures.

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: mapcar-clean FUNCTION LIST &rest MORE-LISTS

Automatically removes all ‘NIL’ entries from a generated list after
performing a ‘mapcar’.

Package

cram-language-implementation

Source

utils (Lisp file)

Macro: on-suspension WHEN-SUSPENDED-FORM &body BODY

Executes ‘when-suspended-form’ whenever a suspension event occurs
while ‘form’ is being executed.

Non local exits out of ‘when-suspended-form’ are prohibited.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Macro: par &body FORMS

Executes forms in parallel. Fails if one fails. Succeeds if all
succeed.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: par-loop (VAR SEQUENCE) &body BODY

Executes body in parallel for each ‘var’ in ‘sequence’.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: partial-order (&body STEPS) &body ORDERINGS

Specify ordering constraints for ‘steps’. ‘steps’ are executed in
an implicit PAR form. ‘orderings’ is a list of orderings. An ordering
always has the form:

(:order <contstraining-task> <constrained-task>)

‘constraining-task’ and ‘constrained-task’ are task objects. That
means, they can be either be defined in the current lexical
environment (over a :tag) or by either using the function TASK to
reference the task by its absolute path or the function SUB-TASK to
reference it by its path relative to the PARTIAL-ORDER form.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: pursue &body FORMS

Execute forms in parallel. Succeed if one succeeds, fail if one
fails.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: replaceable-function NAME LAMBDA-LIST PARAMETERS PATH-PART &body BODY

Besides the replacement of simple code parts defined with ’with-task-tree-node’, it is necessary to also pass parameters to the replaceable code
parts. For that, replaceable functions can be defined. They are not
real functions, i.e. they do change any symbol-function or change
the lexical environment. ’name’ is used to mark such functions in
the code-sexp. More specifically, the sexp is built like follows: ‘(replaceable-function ,name ,lambda-list ,@body).
The ’parameters’ parameter contains the values to call the function with.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Macro: retry-after-suspension &body BODY

Execute ‘body’, and return its values.

In case a suspension event occurs during the execution, ‘body’ is completely unwound, and the suspension takes place _outside_ of
‘body’. After wakeup, ‘body’ is executed again.

The intended use case is to unwind out of critical sections to
ensure that a task won’t suspend while holding on locks.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Macro: seq &body FORMS

Executes forms sequentially. Fails if one fail. Succeeds if all
succeed.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: top-level &body BODY

Anonymous top-level, e.g. for interactive use. See NAMED-TOP-LEVEL for details.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: try-all &body FORMS

Try forms in parallel. Succeed if one succeeds, fail if all fail.
In the case of a failure, a condition of type ’composite-failure’
is signaled, containing the list of all error messages and data.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: try-each-in-order (VARIABLE LIST) &body BODY

Executes ‘body’ with ‘variable’ bound to each element in ‘list’
sequentially until ‘body’ succeeds, i.e. returns the result of
‘body’ as soon as ‘body’ succeeds and stops iterating.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: try-in-order &body FORMS

Execute forms sequentially. Succeed if one succeeds, fail if all fail.
In case of failure, a composite-failure is signaled.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: whenever (CONDITION-FLUENT &key WAIT-STATUS) &body BODY

Executes ‘body’ whenever ‘condition-fluent’ is pulsed or non-nil.
The ‘body’ forms are executed in an implicit block named NIL. The parameter ‘wait-status’ has the same meaning as in WAIT-FOR

Package

cram-language-implementation

Source

fluent (Lisp file)

Macro: with-failure-handling CLAUSES &body BODY

Macro that replaces handler-case in cram-language. This is
necessary because error handling does not work across multiple
threads. When an error is signaled, it is put into an envelope to
avoid invocation of the debugger multiple times. When handling errors,
this envelope must also be taken into account.

We also need a mechanism to retry since errors can be caused by plan
execution and the environment is highly non-deterministic. Therefore,
it is possible to use the function ‘retry’ that is lexically bound
within with-failure-handling and causes a re-execution of the body.

When an error is unhandled, it is passed up to the next failure
handling form (exactly like handler-bind). Errors are handled by
invoking the retry function or by doing a non-local exit. Note that with-failure-handling implicitly creates an unnamed block,
i.e. ‘return’ can be used.

Package

cram-language-implementation

Source

failures (Lisp file)

Macro: with-named-policies POLICIES-AND-PARAMETERS-LIST &body BODY

The semantics of ‘with-named-policies’ are the same as for ‘with-policies’, except that instead of policy-objects, policy names are used:

> (with-named-policies
((’my-policy (3 1))
(’my-policy (100 4))
(’my-other-policy ("Test")))
(body-code))

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: with-named-policy POLICY-NAME POLICY-PARAMETERS &body BODY

Performs the same as ‘with-policy’, but accepts a policy name
instead of the policy object itself. This calls an implicit
‘named-policy’ to acquire the policy object. Otherwise, it has the
same semantics as ‘with-policy’. Usage:

> (with-named-policy ’policy-name (param-value-1 param-value-2) (body-code))

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: with-policies POLICIES-AND-PARAMETERS-LIST &body BODY

Allows for running a given ‘body’ code segment wrapped in a list of
policies (together with individual parameters for each of them). The ‘policies-and-parameters-list’ parameter describes a list of policy/parameter-list pairs.

The usage is as follows:

> (with-policies
((my-policy-object (3 1))
(my-policy-object (100 4))
(my-other-policy-object ("Test")))
(body-code))

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: with-policy POLICY POLICY-PARAMETERS &body BODY

Wraps the code given as ‘body’ into a ‘pursue’ construct together
with monitoring code supplied by the policy ‘policy’, and given the
parameters ‘policy-parameters’. The ‘policy-parameters’ allow for
custom parameterization of policies. First, the policy is initialized
via the optional ‘:init’ code block. In case this block returns ‘nil’, execution of the ‘body’ code or other policy-related code blocks is
not started. An exception of type ‘policy-init-failed’ is
thrown. Otherwise, the ‘:check’ code block of the policy is executed
in a loop in parallel to the ‘body’ code. If the ‘:check’ code returns
‘t’, the policy condition is met and the ‘:recover’ code block is
executed. The execution of both, the policy, and the ‘body’ code is
the stopped, and the ‘:clean-up’ policy code is executed. If the
policy condition is never met, ‘body’ finishes and returns
normally.

To clarify the order of code execution here:

- Initialization of policy is executed (‘:init’)

- ‘pursue’ code form is started, with up to two forms inside:
- The policy ‘:check’ code block (if present)
- The ‘body’ code

- ‘:check’ is evaluated continuously, in parallel to the normal
execution of ‘body’. If it returns ‘nil’, nothing happens. In any
other case (i.e. return value is unequal to ‘nil’), the execution of
the ‘body’ code is interrupted, and ‘:check’ is not performed again
anymore. The policy code block given in ‘:recover’ is executed (if
present). This means (explicitly) that the ‘:recover’ code is
performed *after* the ‘body’ code got interrupted.

- If ‘:check’ always returns ‘nil’ until the ‘body’ code execution
finishes, ‘:recover’ is never executed.

- In either case (with or without ‘:recover’), the policy ‘:clean-up’
code is performed (if present).

In each of the phases, ‘policy-setf’ and ‘policy-get’ are
available. They can be used to store variables associated with given
symbols for the course of action of the current policy.

Example:

> (define-policy var-test-policy ()
"Variable Test Policy"
(:init (policy-setf ’some-var 10)
t)
(:check (policy-setf ’some-other-var
(+ (policy-get ’some-var) 2))
nil)
(:clean-up (format t "Variables: ~a ~a~%"
(policy-get ’some-var)
(policy-get ’some-other-var))))

Usage of ‘with-policy’:

> (with-policy policy-object (param-value-1 param-value-2)
(body-code))

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: with-retry-counters COUNTER-DEFINITIONS &body BODY

Lexically binds all counters in ‘counter-definitions’ to the intial
values specified in ‘counter-definitions’. ‘counter-definitions’ is
similar to ‘let’ forms with the difference that the counters will
not be available under the specified names in the lexical
environment established by this macro. In addition, the macro
defines the local macro (DO-RETRY <counter> <body-form>*) to
decrement the counter and execute code when the maximal retry count
hasn’t been reached yet and the function ‘(RESET-COUNTER
<counter>).

Package

cram-language-implementation

Source

failures (Lisp file)

Macro: with-scheduling &body BODY

Enable scheduling again.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Macro: with-tags &body BODY &environment LEXENV

Execute body with all tags bound to the corresponding lexically
bound variables.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: with-task-suspended (TASK &key REASON) &body BODY

Execute body with ’task’ being suspended.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: with-task-tree-node (&key PATH-PART NAME SEXP LAMBDA-LIST PARAMETERS LOG-PARAMETERS LOG-PATTERN) &body BODY

Executes a body under a specific path. Sexp, lambda-list and parameters are optional.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Macro: without-scheduling &body BODY

Execute ‘body’ without periodically entering into a task’s event
loop. This prevents all acting on messages (including suspension, evaporation, etc.) from other tasks.

Package

cram-language-implementation

Source

task-interface (Lisp file)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.3 Functions

Function: * &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: + &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: - &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: / &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: < &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: = &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: > &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: clear-tasks TASK-TREE-NODE

Removes recursively all tasks from the tree. Keeps tree structure and
leaves code-replacements in place.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: code-function INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf code-function) (function)

Function: (setf code-function) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

code-function (function)

Function: code-parameters INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf code-parameters) (function)

Function: (setf code-parameters) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

code-parameters (function)

Function: code-sexp INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf code-sexp) (function)

Function: (setf code-sexp) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

code-sexp (function)

Function: code-task INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf code-task) (function)

Function: (setf code-task) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

code-task (function)

Function: current-task

Package

cram-language-implementation

Source

task-interface (Lisp file)

Function: describe-goal GOAL

Package

cram-language-implementation

Source

goals (Lisp file)

Function: eq &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: eql &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: expand-plan FORM

Expand-plan takes a sexp and macroexpands it. Whenever it encounters a call
to a plan it continues by expanding the sexp that defined that plan and thus builds up a hierarchie of plans (plan-tree). Expand-plan returns two values: The resulting plan tree and the macroexpansion of form (with calls to plans still in place) of which the plan tree will be the most interesting. The root of the plan-tree returned by expand-plan doesn’t correspond to a plan call, but the form that was passed to expand-plan.

Package

cram-walker

Source

interface (Lisp file)

Function: fail &rest ARGS

Package

cram-language-implementation

Source

failures (Lisp file)

Function: filter-task-tree PREDICATE TREE

Returns a copy of the task tree which contains only nodes that satisfy ‘predicate’. CAVEAT: If a node does not satisfy ‘predicate’ then none of its descendants will appear in the filtered tre, even if they satisfy ‘preidacte’. Assume that the root saisfies ‘predicate’, otherwise there would be no tree to return.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: find-plan-node PLAN-TREE PATH

Return the plan-tree-node specified by the path. Returns nil, if the path
is not valid.

Package

cram-walker

Source

plan-tree (Lisp file)

Function: fl* &rest FL-ARGS521

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl+ &rest FL-ARGS445

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl- &rest FL-ARGS483

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl-and &rest FL-ARGS635

The and-operator for fluents. It is fundamentally different to the
definition of common-lisp’s and in that it is not implemented as a
macro. That means, all args are evaluated when using fl-and.

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl-apply FUN ARG &rest MORE-ARGS

FIXME

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl-eq &rest FL-ARGS331

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl-eql &rest FL-ARGS369

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl-funcall &rest FL-ARGS720

Generic fluent-operator. Applys args to function whenever a
fluent in args changes.

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl-not &rest FL-ARGS597

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl-or &rest FL-ARGS661

The or-operator for fluents. For more information on why it is a
function please refere to the documentation of fl-and.

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl-pulsed FLUENT &key HANDLE-MISSED-PULSES

Returns a fluent whose value becomes T only and only if its parent
fluent has been pulsed. How long it stays T depends on the parameter ‘handle-missed-pulses’. It can be either :NEVER :ONCE or :ALWAYS:

- :NEVER means that missed pulses are ignored, i.e. the initial
value is always NIL and becomes T only when ‘fluent’ gets
pulsed. It stays T only for exactly one call of VALUE, even if
more than one pulse occured since the last call to VALUE.

- :ONCE is similar to :NEVER but has an initial value of T if
‘fluent’ has been pulsed at least once before.

- :ALWAYS means that the VALUE method returns T for exactly the
number of pulses of ‘fluent’.

Please note that the value of a PULSE-FLUENT changes from one call to
another. That means it is not re-entrant, and FL-PULSED should not be
bound to a variable or passed around. This could lead to unwanted
behavior if one thread catches pulses another one was to handle.

Package

cram-language-implementation

Source

pulse-fluent (Lisp file)

Function: fl-value-changed FLUENT &key TEST KEY

Returns a fluent that gets pulsed and has the value T whenever
‘fluent’ changes its value.

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl/ &rest FL-ARGS559

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl< &rest FL-ARGS217

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl= &rest FL-ARGS293

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: fl> &rest FL-ARGS255

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: flatten-task-tree TASK-TREE

Returns a list of all the nodes in the tree.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: get-top-level-task-tree NAME

Returns the task tree for a named top level (top level plan).

Package

cram-language-implementation

Source

language (Lisp file)

Function: goal-task-tree-node-goal TASK-TREE-NODE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: goal-task-tree-node-p TASK-TREE-NODE

Returns true if ‘task-tree-node’ is a goal task.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: goal-task-tree-node-parameter-bindings TASK-TREE-NODE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: goal-task-tree-node-pattern TASK-TREE-NODE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: list-active-log-tags

List all log tags active at the moment.

Package

cram-language-implementation

Source

logging (Lisp file)

Function: list-available-log-tags

List all available log tags.

Package

cram-language-implementation

Source

logging (Lisp file)

Function: list-saved-tasks

Package

cram-language-implementation

Source

task (Lisp file)

Function: log-disable TAGS

Disable each tag in ‘tags’.
Corresponding LOG-EVENTs will cease to emit any output.

Package

cram-language-implementation

Source

logging (Lisp file)

Function: log-enable TAGS

Enable each tag in ‘tags’.
Corresponding LOG-EVENTs will begin to emit output.

Package

cram-language-implementation

Source

logging (Lisp file)

Function: log-set TAGS

Enable only the tags in ‘tags’, disabling all other tags first.
Corresponding LOG-EVENTs will being / cease to emit output.

Package

cram-language-implementation

Source

logging (Lisp file)

Function: make-fluent &rest ARGS &key CLASS NAME VALUE ALLOW-TRACING MAX-TRACING-FREQ &allow-other-keys

Use this to create fluents. Default class is VALUE-FLUENT.

Pass :ALLOW-TRACING NIL to never trace this fluent (default T).

Pass :MAX-TRACING-FREQ to restrict the frequency with which updates to this fluents are traced. The unit is ’1/second’. Default is NIL (meaning no restriction).

Package

cram-language-implementation

Source

value-fluent (Lisp file)

Function: make-task &key NAME SEXP FUNCTION PATH PARAMETERS

Returns a runnable task for the path

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: make-task-tree-node &key (CODE DUM42) (CODE-REPLACEMENTS DUM43) (PARENT DUM44) (CHILDREN DUM45) (PATH DUM46) (LOCK DUM47)

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: named-policy POLICY-NAME

Returns the policy by the name ‘policy-name’ from the list of
defined policies. If the policy by this name is not in the list, the ‘policy-not-found’ condition is signalled. Usage:

> (named-policy ’policy-name)

Package

cram-language-implementation

Source

with-policy (Lisp file)

Function: not &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: peek-value FLUENT

Return the same value as VALUE, except that this never changes the state of the flunet. E.g. for PULSE-FLUENT the internal counter is not incremented.

Package

cram-language-implementation

Source

fluent (Lisp file)

Function: plan-tree-node-children INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-walker

Source

plan-tree (Lisp file)

Writer

(setf plan-tree-node-children) (function)

Function: (setf plan-tree-node-children) NEW-VALUE INSTANCE

Package

cram-walker

Source

plan-tree (Lisp file)

Reader

plan-tree-node-children (function)

Function: plan-tree-node-parent INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-walker

Source

plan-tree (Lisp file)

Writer

(setf plan-tree-node-parent) (function)

Function: (setf plan-tree-node-parent) NEW-VALUE INSTANCE

Package

cram-walker

Source

plan-tree (Lisp file)

Reader

plan-tree-node-parent (function)

Function: plan-tree-node-path INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-walker

Source

plan-tree (Lisp file)

Writer

(setf plan-tree-node-path) (function)

Function: (setf plan-tree-node-path) NEW-VALUE INSTANCE

Package

cram-walker

Source

plan-tree (Lisp file)

Reader

plan-tree-node-path (function)

Function: plan-tree-node-sexp INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-walker

Source

plan-tree (Lisp file)

Writer

(setf plan-tree-node-sexp) (function)

Function: (setf plan-tree-node-sexp) NEW-VALUE INSTANCE

Package

cram-walker

Source

plan-tree (Lisp file)

Reader

plan-tree-node-sexp (function)

Function: pulsed &rest ARGS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: register-goal NAME PATTERN GOAL-FUN &optional DOC-STRING

Package

cram-language-implementation

Source

goals (Lisp file)

Function: sleep SECONDS

Package

cram-language

Source

fluent-operators (Lisp file)

Function: sleep* SECONDS

Package

cram-language-implementation

Source

utils (Lisp file)

Function: stale-task-tree-node-p NODE

Returns true if node is stale, i.e. it has no associated task object.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: sub-task PATH

Small helper function to get a sub-task of the current task.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: task PATH

Small helper function to get a task from a path.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: task-alive TASK

Returns a fluent indicating if the task is alive

Package

cram-language-implementation

Source

task (Lisp file)

Function: task-dead TASK

Package

cram-language-implementation

Source

task (Lisp file)

Function: task-dead-p TASK

Package

cram-language-implementation

Source

task (Lisp file)

Function: task-done-p TASK

Package

cram-language-implementation

Source

task (Lisp file)

Function: task-failed-p TASK

Package

cram-language-implementation

Source

task (Lisp file)

Function: task-running-p TASK

Package

cram-language-implementation

Source

task (Lisp file)

Function: task-tree-node PATH

Returns the task-tree node for path or nil.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: task-tree-node-children INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf task-tree-node-children) (function)

Function: (setf task-tree-node-children) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

task-tree-node-children (function)

Function: task-tree-node-code INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf task-tree-node-code) (function)

Function: (setf task-tree-node-code) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

task-tree-node-code (function)

Function: task-tree-node-effective-code NODE

Returns the effective code of the node. I.e. the code that is
actually executed. When the node has replacements, the current
replacement is used, otherwise the original code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: task-tree-node-p OBJECT

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: task-tree-node-parameters TASK-TREE-NODE

Return the parameters with which the task was called. Assume node is not stale.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: task-tree-node-parent INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf task-tree-node-parent) (function)

Function: (setf task-tree-node-parent) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

task-tree-node-parent (function)

Function: task-tree-node-path INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf task-tree-node-path) (function)

Function: (setf task-tree-node-path) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

task-tree-node-path (function)

Function: task-tree-node-result TASK-TREE-NODE

Return the tasks result. Assume node is not stale.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: task-tree-node-status-fluent TASK-TREE-NODE

Return the tasks status fluent. Assume node is not stale.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: tv-closure TASK PARENT-TASK CONTINUATION

Establish bindings for task variables and initialize them.

Package

cram-language-implementation

Source

task (Lisp file)

Function: walk-with-tag-handler FORM TAG-HANDLER ENV

Macroexpands form and calls tag-handler once for every (:tag name body)
form it encounters. The two parameters passed to the tag-handler are name and body. Returns the expansion of form.

Package

cram-walker

Source

interface (Lisp file)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.4 Generic functions

Generic Function: composite-failures CONDITION

Package

cram-language-implementation

Methods
Method: composite-failures (CONDITION composite-failure)

Generic Function: envelop-error CONDITION

Package

cram-language-implementation

Methods
Method: envelop-error (CONDITION common-lisp-error-envelope)

Generic Function: evaporate TASK &key REASON SYNC SYNC

Terminates a task.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: evaporate (TASK abstract-task) &key REASON SYNC

Source

task (Lisp file)

Generic Function: get-update-callback FLUENT NAME

Returns the callback with given name or NIL if it doesn’t exist.

Package

cram-language-implementation

Source

fluent-interface (Lisp file)

Methods
Method: get-update-callback (FLUENT fluent) NAME

Source

fluent (Lisp file)

Generic Function: join-task TASK

Waits for ‘task’ to finish.
When ‘task’ fails, this function rethrows the failure; when ‘task’ succeeds, it returns the result values of ‘task’.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: join-task (TASK abstract-task)

Source

task (Lisp file)

Generic Function: name OBJECT

Package

cram-language-implementation

Methods
Method: name (ABSTRACT-TASK abstract-task)

The name of the task. Mostly for debugging reasons.
Should also become the name of the thread executing
the task.

Source

task (Lisp file)

Method: name (POLICY policy)

automatically generated reader method

Source

with-policy (Lisp file)

Method: name (FLUENT fluent)

The name of the fluent. Should be a globally unique symbol.

Source

fluent-interface (Lisp file)

Generic Function: on-def-top-level-plan-hook PLAN-NAME

Executed when a top-level-plan is defined.

Package

cram-language-implementation

Source

plans (Lisp file)

Method Combination

hooks

Generic Function: on-fail DATUM

Hook that is executed whenever a condition is
signaled using FAIL.

Package

cram-language-implementation

Source

failures (Lisp file)

Method Combination

hooks

Generic Function: on-make-fluent-hook FLUENT ALLOW-TRACING MAX-TRACING-FREQ

This is a generic function with hook method
combination. All defined methods are executed after a fluent is created.

Package

cram-language-implementation

Source

value-fluent (Lisp file)

Method Combination

hooks

Generic Function: on-top-level-cleanup-hook TOP-LEVEL-NAME

All defined hooks are exected after the top level task has
been joined. The call is made when the dynamic environment established by the return values of ON-TOP-LEVEL-SETUP-HOOK is still in effect. The call to this hook is protected by an unwind protect.

Package

cram-language-implementation

Source

language (Lisp file)

Method Combination

hooks

Generic Function: on-top-level-setup-hook TOP-LEVEL-NAME TASK-TREE

All defined hooks are executed before the top level task is
created. The task-tree passed is the root of the task-tree used in this top level. Each method must return a cons cell with a list of symbols in the car and a list of values in the cdr. The lists of all methods are concatenated and the passed to a progv to establish the dynamic environment where the top-level task is executed.

Package

cram-language-implementation

Source

language (Lisp file)

Method Combination

hooks

Options: :hook-combination, (lambda (&rest cram-language-implementation::results) (loop cram-language-implementation::for cram-language-implementation::r cram-language-implementation::in cram-language-implementation::results append (car cram-language-implementation::r) cram-language-implementation::into cram-language-implementation::symbols append (cdr cram-language-implementation::r) cram-language-implementation::into values cram-language-implementation::finally (return (cons cram-language-implementation::symbols values))))

Generic Function: parameters OBJECT

Package

cram-language-implementation

Methods
Method: parameters (POLICY policy)

automatically generated reader method

Source

with-policy (Lisp file)

Generic Function: pulse FLUENT

Method to trigger the fluent, i.e. notifying all waiting threads,
but without actually changing the fluent value.

Package

cram-language-implementation

Source

fluent-interface (Lisp file)

Methods
Method: pulse (FLUENT fl-net-cacheable-fluent) around

Source

fluent-net (Lisp file)

Method: pulse (FLUENT fluent)

Source

fluent (Lisp file)

Generic Function: register-update-callback FLUENT NAME UPDATE-FUN

Method to register an update callback under the corresponding
name. When the name is already known, an error is signaled.

Package

cram-language-implementation

Source

fluent-interface (Lisp file)

Methods
Method: register-update-callback (FLUENT fluent) NAME UPDATE-FUN

Source

fluent (Lisp file)

Generic Function: remove-update-callback FLUENT NAME

Method to remove the update callback with the given name.

Package

cram-language-implementation

Source

fluent-interface (Lisp file)

Methods
Method: remove-update-callback (FLUENT fluent) NAME

Source

fluent (Lisp file)

Generic Function: result TASK

Returns the result of the thread. For multiple values, this
function also returns multiple values.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: result (TASK abstract-task)

Source

task (Lisp file)

Generic Function: status TASK

Returns the status fluent of the task.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: status (ABSTRACT-TASK abstract-task)

Fluent indicating the task status.
Cf. STATUS-INDICATOR.

Source

task (Lisp file)

Generic Function: suspend TASK &key REASON SYNC SYNC

Blocks a thread until it is terminated or awaken.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: suspend (TASK abstract-task) &key REASON SYNC

Source

task (Lisp file)

Generic Function: task-path TASK

Returns the path of the task.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: task-path (ABSTRACT-TASK abstract-task)

The path of the task.

Source

task (Lisp file)

Generic Function: value FLUENT

Reader method, returning the fluent’s value

Package

cram-language-implementation

Source

fluent-interface (Lisp file)

Writer

(setf value) (generic function)

Methods
Method: value (FLUENT pulse-fluent)

Source

pulse-fluent (Lisp file)

Method: value (FLUENT fl-net-cacheable-fluent)

Source

fluent-net (Lisp file)

Method: value (FLUENT fl-net-fluent)

Source

fluent-net (Lisp file)

Method: value (FLUENT value-fluent)

Source

value-fluent (Lisp file)

Method: value VAR

Default handler. It seems to be a quite good idea to allow the
usage of value for all types of objects.

Source

fluent (Lisp file)

Generic Function: (setf value) NEW-VALUE FLUENT

Setter method to set the new value of the fluent

Package

cram-language-implementation

Source

value-fluent (Lisp file)

Reader

value (generic function)

Methods
Method: (setf value) NEW-VALUE (FLUENT value-fluent)

Generic Function: wait-for FLUENT &key TIMEOUT TIMEOUT &allow-other-keys

Method to block the current thread until the value of ‘fluent’
becomes non-nil. If ‘timeout’ is specified, waits for at least
timeout and returns.

Package

cram-language-implementation

Source

fluent-interface (Lisp file)

Methods
Method: wait-for (FLUENT fluent) &key TIMEOUT

Source

fluent (Lisp file)

Method: wait-for VAR &key &allow-other-keys

Source

fluent (Lisp file)

Generic Function: wake-up TASK &key REASON SYNC SYNC

Wakes up ‘task’ if it’s suspended; otherwise do nothing.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: wake-up (TASK abstract-task) &key REASON SYNC

Source

task (Lisp file)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.5 Conditions

Condition: common-lisp-error-envelope

Package

cram-language-implementation

Source

failures (Lisp file)

Direct superclasses

plan-failure (condition)

Direct methods

envelop-error (method)

Direct slots
Slot: error
Initargs

:error

Readers

envelop-error (generic function)

Condition: composite-failure

Package

cram-language-implementation

Source

failures (Lisp file)

Direct superclasses

plan-failure (condition)

Direct methods

composite-failures (method)

Direct slots
Slot: failures
Initargs

:failures

Initform

’nil

Readers

composite-failures (generic function)

Condition: plan-failure

Condition which denotes a plan failure.

Package

cram-language-implementation

Source

failures (Lisp file)

Direct superclasses

serious-condition

Direct subclasses
Condition: policy-check-condition-met

Package

cram-language-implementation

Source

with-policy (Lisp file)

Direct superclasses

policy-failure (condition)

Condition: policy-condition

Package

cram-language-implementation

Source

with-policy (Lisp file)

Direct superclasses

condition

Direct subclasses
Direct methods

policy-name (method)

Direct slots
Slot: name
Initargs

:name

Readers

policy-name (generic function)

Condition: policy-failure

Package

cram-language-implementation

Source

with-policy (Lisp file)

Direct superclasses

policy-condition (condition)

Direct subclasses
Direct methods

policy-parameters (method)

Direct slots
Slot: parameters
Initargs

:parameters

Readers

policy-parameters (generic function)

Condition: policy-init-failed

Package

cram-language-implementation

Source

with-policy (Lisp file)

Direct superclasses

policy-failure (condition)

Condition: policy-not-found

Package

cram-language-implementation

Source

with-policy (Lisp file)

Direct superclasses

policy-condition (condition)

Condition: simple-plan-failure

Package

cram-language-implementation

Source

failures (Lisp file)

Direct superclasses

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.6 Structures

Structure: code

Represents a piece of code that can be replaced. It contains the
sexp as well as a function object that can be executed. Further, it
contains the top-level task and all tasks in the lexical environment
of the top-level task. This can be used to get the variable bindings
of a specific task without the need to walk the task tree.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Direct superclasses

structure-object

Direct slots
Slot: sexp
Readers

code-sexp (function)

Writers

(setf code-sexp) (function)

Slot: function
Readers

code-function (function)

Writers

(setf code-function) (function)

Slot: task
Readers

code-task (function)

Writers

(setf code-task) (function)

Slot: parameters
Readers

code-parameters (function)

Writers

(setf code-parameters) (function)

Structure: plan-tree-node

Package

cram-walker

Source

plan-tree (Lisp file)

Direct superclasses

structure-object

Direct methods

print-object

Direct slots
Slot: sexp
Readers

plan-tree-node-sexp (function)

Writers

(setf plan-tree-node-sexp) (function)

Slot: path
Readers

plan-tree-node-path (function)

Writers

(setf plan-tree-node-path) (function)

Slot: parent
Readers

plan-tree-node-parent (function)

Writers

(setf plan-tree-node-parent) (function)

Slot: children
Readers

plan-tree-node-children (function)

Writers

(setf plan-tree-node-children) (function)

Structure: task-tree-node

Package

cram-language-implementation

Source

task-tree (Lisp file)

Direct superclasses

structure-object

Direct methods

print-object

Direct slots
Slot: code
Readers

task-tree-node-code (function)

Writers

(setf task-tree-node-code) (function)

Slot: code-replacements
Initform

(list)

Readers

task-tree-node-code-replacements (function)

Writers

(setf task-tree-node-code-replacements) (function)

Slot: parent
Readers

task-tree-node-parent (function)

Writers

(setf task-tree-node-parent) (function)

Slot: children
Readers

task-tree-node-children (function)

Writers

(setf task-tree-node-children) (function)

Slot: path
Readers

task-tree-node-path (function)

Writers

(setf task-tree-node-path) (function)

Slot: lock
Initform

(sb-thread:make-mutex)

Readers

task-tree-node-lock (function)

Writers

(setf task-tree-node-lock) (function)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.7 Classes

Class: fluent

Package

cram-language-implementation

Source

fluent-interface (Lisp file)

Direct superclasses

standard-object

Direct subclasses
Direct methods
Direct slots
Slot: name

The name of the fluent. Should be a globally unique symbol.

Type

symbol

Initargs

:name

Initform

(gensym "fluent-")

Readers

name (generic function)

Slot: on-update

Hash-table of update callbacks, being executed on every change of
the value. The update callback is a function with no parameters.

Type

hash-table

Initform

(make-hash-table :test ’eq)

Slot: pulse-count

For internal use. Indicates a pulse.

Initargs

:pulse-count

Initform

0

Slot: changed-condition

For internal use. Posix condition variable/waitqueue
used for notification when value changed.

Slot: value-lock

For internal use. Lock to be used with for access synchronization.

Class: task

Package

cram-language-implementation

Source

task (Lisp file)

Direct superclasses

abstract-task (class)

Direct methods

execute (method)

Class: toplevel-task

Package

cram-language-implementation

Source

task (Lisp file)

Direct superclasses

abstract-task (class)

Class: value-fluent

Package

cram-language-implementation

Source

value-fluent (Lisp file)

Direct superclasses
Direct methods
  • value
  • value (method)
  • print-object
Direct slots
Slot: value

The value of the fluent

Initargs

:value

Slot: test

Test to check for value changes (used in setf value).

Initargs

:test

Initform

#’eql


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.1.8 Types

Type: status-indicator

Cf. *STATUS-TRANSITIONS*

Package

cram-language-implementation

Source

task-interface (Lisp file)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2 Internal definitions


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.1 Special variables

Special Variable: *active-log-mask*

A bitmask representing the currently enabled log tags.

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: *cltl2-environment-fns*

The functions for augmenting the environment as defined in CLTL2 are not in the ANSI Standard and thus implementation-spefic. This lists the functions needed and is assigned in env-impl-specific.lisp.

Package

cram-walker

Source

env (Lisp file)

Special Variable: *current-parent*

Contains the current parent when constructing the plan tree during code walking. If we call walk-form with this being nil, it doesnt build a tree, nor follow plan calls.

Package

cram-walker

Source

walker (Lisp file)

Special Variable: *current-path*

Current path during walking and creating the plan tree.

Package

cram-walker

Source

walker (Lisp file)

Special Variable: *current-task-tree-node*

The current task tree node.

Package

cram-language-implementation

Source

task (Lisp file)

Special Variable: *log-tag-table*

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: *peek-value*

This is used to implement PEEK-VALUE.

Package

cram-language-implementation

Source

fluent (Lisp file)

Special Variable: *policies*

List of defined policies

Package

cram-language

Source

with-policy (Lisp file)

Special Variable: *policy-check-consolidation-duration*

Package

cram-language

Source

with-policy (Lisp file)

Special Variable: *scheduling-enabled*

Package

cram-language-implementation

Source

task (Lisp file)

Special Variable: *shadowed-functions*

This picks up the shaddowed function while walking, so we dont need to
access the environment (which is not possible in a standardized way, not even with whats in CLTL2).

Package

cram-walker

Source

walker (Lisp file)

Special Variable: *status-transitions*

Valid transitions from one task’s status to the next.

Package

cram-language-implementation

Source

task (Lisp file)

Special Variable: *suspension-handlers*

Package

cram-language-implementation

Source

task (Lisp file)

Special Variable: *suspension-unwind*

Package

cram-language-implementation

Source

task (Lisp file)

Special Variable: *synchronous-events*

Indicates if we want to use synchronized events

Package

cram-language-implementation

Source

task (Lisp file)

Special Variable: *tag-walker-handlers*

When a (:tag name body) form is encounterd during code walking,
all functions in the list that *tag-walker-handlers* refers to are called with the 2 parameters name and body.

Package

cram-walker

Source

walker (Lisp file)

Special Variable: *task-local-variables*

Package

cram-language-implementation

Source

task-interface (Lisp file)

Special Variable: *task-tree-print-children*

Determines how task-tree-nodes are pretty-printed. One of (nil :count :full). Default :count

Package

cram-language-implementation

Source

task-tree (Lisp file)

Special Variable: *task-tree-print-code*

Determines how task-tree-nodes are pretty-printed. Generalized Boolean. Default nil

Package

cram-language-implementation

Source

task-tree (Lisp file)

Special Variable: *task-tree-print-identity*

Determines how task-tree-nodes are pretty-printed. Generalized Boolean. Default t

Package

cram-language-implementation

Source

task-tree (Lisp file)

Special Variable: *task-tree-print-path*

Determines how task-tree-nodes are pretty-printed. One of (nil :one :full). Default :full

Package

cram-language-implementation

Source

task-tree (Lisp file)

Special Variable: *top-level-task-trees*

The task tree for named top levels (top level plans) is stored in this hash-table by indexed by the plan name (which is a symbol).

Package

cram-language-implementation

Source

language (Lisp file)

Special Variable: *zero-real-time*

Base timestamp to compute relative real-time timestamps from.
This variable gets its value from the top-level task, all sub tasks
will just inherit it.

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: *zero-run-time*

Like *ZERO-REAL-TIME*, but for run-time timestamps.

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: +available-log-tags+

Package

cram-language-implementation

Source

logging (Lisp file)

Special Variable: +time-quantum+

Period in seconds at which an entrance into the event loop is
scheduled.

Package

cram-language-implementation

Source

task (Lisp file)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.2 Macros

Macro: def-fluent-operator &whole W NAME ARGS &body BODY

def-fluent-operator allows to define fluent operators. It creates a
new function with the given name. When it is called with a fluent
in its parameter list, a fluent network is returned, with the
function body as its calculator. Otherwise, the body is called
directly.

We need one special case. Some operators need to always pulse the
returned fluent net. This is solved by havin a second value. When
the body returns a non-nil second value, the fluent net is always
pulsed, otherwise only when the fluent net value has changed.

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Macro: def-plan-macro NAME LAMBDA-LIST &body BODY

Wrapper around DEFMACRO for defining macros constituting cpl constructs
used in plans.

DEF-PLAN-MACRO wraps ‘body’ in code that checks that it is only used within cpl plans. More precicesly the macro includes a check that it is used in a dynamic context where *CURRENT-TASK* is not nil. Otherwise an ERROR condition is signaled (at runtime).

DEF-PLAN-MACRO also adds information about the plan macro (‘lambda-list’ and ‘body’) to the symbol ‘name’, so the plan walker can use this information during plan expansion. This information can also be used for plan transformation.

See Also

WALKER::EXPAND-PLAN

Package

cram-language-implementation

Source

language (Lisp file)

Macro: define-fluent-net-wrapper NAME WRAPPED-FN

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Macro: define-log-tags &body NAMES

Package

cram-language-implementation

Source

logging (Lisp file)

Macro: destructure-event (EVENT &key REASON SYNC) &body CLAUSES

Example:

(let ((event (make-event ‘(:foo 1 2 3) "Odd Reason" t))) (destructure-event (event :reason R :sync S)
((:foo X Y Z)
(values X Y Z R S))))

==> 1, 2, 3, "Odd Reason", T

Package

cram-language-implementation

Source

task (Lisp file)

Macro: log-block BEGIN-HOOK PARAMETERS END-HOOK &body BODY

Package

cram-language-implementation

Source

logging (Lisp file)

Macro: named-top-level (&key NAME) &body BODY

Creates a new task, executes body in it and waits until it is finished. All plan macros can only be used within the dynamic scope of a top-level form.

The ‘name’ is used to save the task tree in *top-level-task-trees*.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: single-form-progv SYMBOLS-AND-VALUES-CONS &body BODY

Like progv, but instead of getting the symbols and values from evaluating
two forms, this version only takes a single form which should return a cons cell with the symbol list in the car and the value list in the cdr.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: with-extended-path TYPE LABEL &body BODY

Package

cram-walker

Source

walker (Lisp file)

Macro: with-fluent-locked FLUENT &body BODY

Package

cram-language-implementation

Source

fluent (Lisp file)

Macro: with-parallel-childs NAME (RUNNING DONE FAILED) CHILD-FORMS &body WATCHER-BODY

Execute ‘child-forms’ in parallel and execute ‘watcher-body’
whenever any child changes its status.

Lexical bindings are established for ‘running’, ‘done’ and ‘failed’
around ‘watcher-body’, and bound to lists of all running, done and
failed tasks. ‘watcher-body’ is executed within an implicit block
named NIL.

‘name’ is supposed to be the name of the plan-macro that’s
implemented on top of WITH-PARALLEL-CHILDS. ‘name’ will be used to
name the tasks spawned for ‘child-forms’.

All spawned child tasks will be terminated on leave.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: with-shadowed-functions BINDS &body BODY

Package

cram-walker

Source

walker (Lisp file)

Macro: with-task (&key CLASS NAME) &body BODY

Executes body in a separate task and joins it.

Package

cram-language-implementation

Source

language (Lisp file)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.3 Functions

Function: %define-log-tags NAMES

Package

cram-language-implementation

Source

logging (Lisp file)

Function: %fail DATUM ARGS

Package

cram-language-implementation

Source

failures (Lisp file)

Function: %log-event CTX-CONTROL CTX-ARGS DISPLAY-CONTROL DISPLAY-ARGS

Package

cram-language-implementation

Source

logging (Lisp file)

Function: %make-event TAG VALUES REASON SYNC

Package

cram-language-implementation

Source

task (Lisp file)

Function: %teardown TASK FINAL-STATUS RESULT REASON SYNC

Package

cram-language-implementation

Source

task (Lisp file)

Function: %timed-wait-for FLUENT TIMEOUT

Package

cram-language-implementation

Source

fluent (Lisp file)

Function: %unwind-on-suspension BODY-THUNK AFTER-SUSPENSION-CONTINUATION

If a suspension occurs during the execution of ‘body-thunk’,
unwind out of ‘body-thunk’, continue the suspension process, and
after wakeup execute ‘after-suspension-continuation’.

Package

cram-language-implementation

Source

task (Lisp file)

Function: adjust-time-quantum &optional NEW

Renew the current time quantum.

Package

cram-language-implementation

Source

task (Lisp file)

Function: assert-status TASK STATUS &rest MORE

Package

cram-language-implementation

Source

task (Lisp file)

Function: aug-env ENV KIND BINDINGS

Returns a new environment that is like env, with the according variable, macro, symbol-macro or function bindings added. Other than CLTL2’s augment-environment, this is designed to be especially convenient to call from within the walker.

Package

cram-walker

Source

env (Lisp file)

Function: augment-environment ENV &key VARIABLE SYMBOL-MACRO FUNCTION MACRO DECLARE

Calls the implementation specific CLTL2 function.

Package

cram-walker

Source

env (Lisp file)

Function: call-as-fluent-operator FUNCTION ARGS &key FLUENTS NAME FORCE-NO-CACHE

The meat of DEF-FLUENT-OPERATOR.

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: call-goal NAME ARGS

Package

cram-language-implementation

Source

goals (Lisp file)

Function: call-on-suspension ON-SUSPENSION-THUNK BODY-THUNK

Package

cram-language-implementation

Source

task (Lisp file)

Function: call-with-event-loop THUNK CONSTRAINTS

Execute ‘thunk’, and periodically enter the event-loop.

Package

cram-language-implementation

Source

task (Lisp file)

Function: call-with-scheduling THUNK

Execute ‘thunk’, and signal TIME-QUANTUM-EXHAUSTED if the current
time quantum is exhausted.

Package

cram-language-implementation

Source

task (Lisp file)

Function: call-without-scheduling THUNK

Package

cram-language-implementation

Source

task (Lisp file)

Function: change-status TASK NEW-STATUS

Package

cram-language-implementation

Source

task (Lisp file)

Function: check-time-quantum

Check whether we already exceeded our current time quantum.

Package

cram-language-implementation

Source

task (Lisp file)

Function: clear-saved-tasks

Package

cram-language-implementation

Source

task (Lisp file)

Function: code-p OBJECT

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: coerce-to-condition DATUM ARGUMENTS DEFAULT-TYPE

Package

cram-language-implementation

Source

failures (Lisp file)

Function: continue-with-adjusted-time-quantum &optional NEW-QUANTUM C

Package

cram-language-implementation

Source

task (Lisp file)

Function: copy-code INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: copy-event INSTANCE

Package

cram-language-implementation

Source

task (Lisp file)

Function: copy-message INSTANCE

Package

cram-language-implementation

Source

task (Lisp file)

Function: copy-plan-tree-node INSTANCE

Package

cram-walker

Source

plan-tree (Lisp file)

Function: copy-task-tree-node INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: enclose LAMBDA-EXPRESSION &optional ENV

Calls the implementation specific CLTL2 function.

Package

cram-walker

Source

env (Lisp file)

Function: ensure-tree-node PATH &optional TASK-TREE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: event-loop CURRENT-TASK &optional EVENT WAIT-FOR-EVENT

Package

cram-language-implementation

Source

task (Lisp file)

Function: event-p OBJECT

Package

cram-language-implementation

Source

task (Lisp file)

Function: event-reason INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task (Lisp file)

Writer

(setf event-reason) (function)

Function: (setf event-reason) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task (Lisp file)

Reader

event-reason (function)

Function: event-sync INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task (Lisp file)

Writer

(setf event-sync) (function)

Function: (setf event-sync) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task (Lisp file)

Reader

event-sync (function)

Function: event-tag INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task (Lisp file)

Writer

(setf event-tag) (function)

Function: (setf event-tag) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task (Lisp file)

Reader

event-tag (function)

Function: event-values INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task (Lisp file)

Writer

(setf event-values) (function)

Function: (setf event-values) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task (Lisp file)

Reader

event-values (function)

Function: execute-task-tree-node NODE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: extend-path TYPE LABEL CURRENT-PATH

Package

cram-walker

Source

walker (Lisp file)

Function: fl-member &rest FL-ARGS407

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Function: float-/ A B

Package

cram-language-implementation

Source

utils (Lisp file)

Function: format-gensym FORMAT-STRING &rest FORMAT-ARGS

Package

cram-language-implementation

Source

utils (Lisp file)

Function: get-alist NAME ALIST &rest KEYS &key KEY TEST TEST-NOT

Function: (setf get-alist) NEW-VALUE NAME ALIST &rest KEYS &key KEY TEST TEST-NOT

Package

cram-language-implementation

Source

utils (Lisp file)

Function: inherit-parent-value TASK PARENT-TASK PARENT-VALUE

Package

cram-language-implementation

Source

task-interface (Lisp file)

Function: invoke-event-loop &optional EVENT

Package

cram-language-implementation

Source

task (Lisp file)

Function: kill-saved-tasks

Package

cram-language-implementation

Source

task (Lisp file)

Function: lambda-list-keyword-p OBJ

Package

cram-walker

Source

env (Lisp file)

Function: log-gc-event

Package

cram-language-implementation

Source

task (Lisp file)

Function: log-mask TAGS

Package

cram-language-implementation

Source

logging (Lisp file)

Function: log-tag-offset TAG

Package

cram-language-implementation

Source

logging (Lisp file)

Function: logfmt STREAM FORMAT-CONTROL &rest FORMAT-ARGS

Package

cram-language-implementation

Source

logging (Lisp file)

Function: make-code &key (SEXP DUM0) (FUNCTION DUM1) (TASK DUM2) (PARAMETERS DUM3)

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: make-dummy-task THREAD

Package

cram-language-implementation

Source

task (Lisp file)

Function: make-event EVENT-DESIGNATOR &optional REASON SYNC

Package

cram-language-implementation

Source

task (Lisp file)

Function: make-goal-fun NAME PATTERN DECLARATIONS BODY

Package

cram-language-implementation

Source

goals (Lisp file)

Function: make-message &key (FROM DUM864) (TO DUM865) (CONTENT DUM866)

Package

cram-language-implementation

Source

task (Lisp file)

Function: make-plan-tree-node &key (SEXP DUM0) (PATH DUM1) (PARENT DUM2) (CHILDREN DUM3)

Package

cram-walker

Source

plan-tree (Lisp file)

Function: matching-goal-fun NAME ARGS &optional GOAL-FUNS

Package

cram-language-implementation

Source

goals (Lisp file)

Function: message-content INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task (Lisp file)

Writer

(setf message-content) (function)

Function: (setf message-content) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task (Lisp file)

Reader

message-content (function)

Function: message-from INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task (Lisp file)

Writer

(setf message-from) (function)

Function: (setf message-from) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task (Lisp file)

Reader

message-from (function)

Function: message-p OBJECT

Package

cram-language-implementation

Source

task (Lisp file)

Function: message-to INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task (Lisp file)

Writer

(setf message-to) (function)

Function: (setf message-to) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task (Lisp file)

Reader

message-to (function)

Function: parse-macro NAME LAMBDA-LIST BODY &optional ENV

Calls the implementation specific CLTL2 function.

Package

cram-walker

Source

env (Lisp file)

Function: parse-macro-function FORM ENV

Combines enclose and parse-macro, to return something that can be passed to augment-environment.

Package

cram-walker

Source

env (Lisp file)

Function: partition PREDICATE LIST &key KEY

Equivalent to (VALUES (REMOVE-IF-NOT P L) (REMOVE-IF P L)).

Package

cram-language-implementation

Source

utils (Lisp file)

Function: path-next-iteration PATH-PART

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: plan-tree-node-p OBJECT

Package

cram-walker

Source

plan-tree (Lisp file)

Function: propagate-event TASK EVENT

Propagate ‘event’ down to the childs of ‘task’.

Package

cram-language-implementation

Source

task (Lisp file)

Function: recalculate-timeout TIMEOUT START-TIME

Package

cram-language-implementation

Source

fluent (Lisp file)

Function: receive-event &key WAIT

If an event is currently pending, return it, otherwise return NIL.
If ‘wait’ is true, block until an event arises.

Package

cram-language-implementation

Source

task (Lisp file)

Function: register-child-plan CHILD

Package

cram-walker

Source

walker (Lisp file)

Function: register-task-code SEXP FUNCTION &key PATH TASK-TREE REPLACE-REGISTERED

Registers a code as the default code of a specific task tree
node. If the parameter ’replace-registered’ is true, old code is
always overwritten. Returns the node.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: remove-top-level-task-tree NAME

Removes the task tree for a named top level from the global hash table
where those all named top level task trees. You usually won’t need this, but you can use it to clean up after using named-top-level directly,
e.g. in a test suite.

Package

cram-language-implementation

Source

language (Lisp file)

Function: replace-task-code SEXP FUNCTION PATH &optional TASK-TREE

Adds a code replacement to a specific task tree node.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Function: scheduling-disabled-p

Package

cram-language-implementation

Source

task (Lisp file)

Function: scheduling-enabled-p

Package

cram-language-implementation

Source

task (Lisp file)

Function: seconds-to-internal-time TIMEOUT

Package

cram-language-implementation

Source

task (Lisp file)

Function: send-event TASK EVENT &optional NO-SYNC

Send ‘event’ to ‘task’.
If ‘no-sync’ is true, no synchronization is performed on ‘event’,
the decision to do so is left to the caller.

Package

cram-language-implementation

Source

task (Lisp file)

Function: setup CHILD-TASK PARENT-TASK

Initialize ‘child-task’ for execution.
Also register it as child to ‘parent-task’.

Package

cram-language-implementation

Source

task (Lisp file)

Function: signal-time-quantum-exhausted

Package

cram-language-implementation

Source

task (Lisp file)

Function: synchronize-on-event EVENT CHILD-TASKS

If ‘event’ is a synchronized event, wait until ‘child-tasks’
acted on it.

Package

cram-language-implementation

Source

task (Lisp file)

Function: tag-form-handler FORM

Package

cram-walker

Source

walker (Lisp file)

Function: task-abbreviated-name TASK &optional LENGTH

Package

cram-language-implementation

Source

logging (Lisp file)

Function: task-tree-node-code-replacements INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf task-tree-node-code-replacements) (function)

Function: (setf task-tree-node-code-replacements) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

task-tree-node-code-replacements (function)

Function: task-tree-node-lock INSTANCE

Return whether debug-block represents elsewhere code.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Writer

(setf task-tree-node-lock) (function)

Function: (setf task-tree-node-lock) NEW-VALUE INSTANCE

Package

cram-language-implementation

Source

task-tree (Lisp file)

Reader

task-tree-node-lock (function)

Function: truncate-string STRING MAX-LENGTH

Truncate ‘string’ if its length exceeds ‘max-length’. We truncate
in the middle of the string because start and end are usually
crucial to discriminate the abbreviation.

Package

cram-language-implementation

Source

logging (Lisp file)

Function: unwind-and-continue HANDLERS UNWIND CONTINUATION

Unwind using ‘unwind’, then invoke ‘handlers’, and call
‘continuation’.

Package

cram-language-implementation

Source

task (Lisp file)

Function: unwind-and-teardown STATUS RESULT REASON SYNC

Package

cram-language-implementation

Source

task (Lisp file)

Function: walk-argument ARG ENV

Walk lambda argument (part of an ordinary lambda list). If it is a list of
at least two elements, walk the cadr. Walk nothing else.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-binding B ENV

Walk variable binding like found in let.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-binding-list LIST ENV LET*-STYLE-BINDINGS

Walk list of variable bindings like found in let or let*. If let*-style-bindings is not nil, the bindings are expanded like in a let*.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-block FORM ENV

Walk all but car and cadr.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-cpl-tag FORM ENV

Package

cram-walker

Source

walker (Lisp file)

Function: walk-flet FORM ENV

Walk the function definitions and the walk the body with the functions
added to the environment.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-form FORM ENV

Takes a form and an environment and walkes the form if neccessary, after macroexpanding it fully and considering special cases.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-funcall FORM ENV

Walk all but car.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-function FORM ENV

Walk the cadr. Handle special case of cadr being (lambda () ...), or (setf ...)

Package

cram-walker

Source

walker (Lisp file)

Function: walk-labels FORM ENV

Add the function definitions to the environment, then walk those
definitions and the body.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-lambda FORM ENV

Walk argument list and body.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-let FORM ENV &key LET*-STYLE-BINDINGS

Walk list of bindings and body.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-let* FORM ENV

Package

cram-walker

Source

walker (Lisp file)

Function: walk-list LIST ENV

Walk each element of the list.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-list-of-lambdas LIST ENV

Walk each element like a lambda form.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-load-time-value FORM ENV

Walk the cadr in a nil lexical environment.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-macrolet FORM ENV

Add macro or symbol-macro definitions to the environment and proceed
expanding the body (wrapped in a locally).

Package

cram-walker

Source

walker (Lisp file)

Function: walk-named-lambda FORM ENV

Walk argument list and body.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-ordinary-lambda-list LIST ENV

Walk lambda argument list (ordinary lambda list).

Package

cram-walker

Source

walker (Lisp file)

Function: walk-plan-form FORM ENV

Handles a plan or tag form and creates a node in the plan tree.

Package

cram-walker

Source

walker (Lisp file)

Function: walk-quote FORM ENV

Don’t walk anything

Package

cram-walker

Source

walker (Lisp file)

Function: what-time-is-it KIND

Current timestamp relative to *ZERO-REAL-TIME*, or *ZERO-RUN-TIME*
depending on ‘kind’.

Package

cram-language-implementation

Source

logging (Lisp file)

Function: who-am-i

Either the name of the current task, or of the current thread.

Package

cram-language-implementation

Source

logging (Lisp file)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.4 Generic functions

Generic Function: check OBJECT

Package

cram-language

Methods
Method: check (POLICY policy)

automatically generated reader method

Source

with-policy (Lisp file)

Generic Function: child-tasks TASK

Returns the (currently unsorted) list of child tasks.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Writer

(setf child-tasks) (generic function)

Methods
Method: child-tasks (ABSTRACT-TASK abstract-task)

The list of child tasks.

Source

task (Lisp file)

Generic Function: (setf child-tasks) NEW-VALUE OBJECT

Package

cram-language-implementation

Reader

child-tasks (generic function)

Methods
Method: (setf child-tasks) NEW-VALUE (ABSTRACT-TASK abstract-task)

The list of child tasks.

Source

task (Lisp file)

Generic Function: clean-up OBJECT

Package

cram-language

Methods
Method: clean-up (POLICY policy)

automatically generated reader method

Source

with-policy (Lisp file)

Generic Function: description OBJECT

Package

cram-language

Methods
Method: description (POLICY policy)

automatically generated reader method

Source

with-policy (Lisp file)

Generic Function: execute TASK

When the task has been instantiated without a thread function or
the function has not been executed yet, it can be executed with
this method. When ‘ignore-no-parent’ is true, no error message is signaled when *CURRENT-TASK* is unbound.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: execute (NEW-TASK abstract-task) after

Source

task (Lisp file)

Method: execute (NEW-TASK abstract-task)

Source

task (Lisp file)

Method: execute (NEW-TASK abstract-task) around

Source

task (Lisp file)

Method: execute (TASK task) before

Source

task (Lisp file)

Method: execute (TASK abstract-task) before

Source

task (Lisp file)

Generic Function: executed TASK

Returns NIL if the task has not been executed yet.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: executed (TASK abstract-task)

Source

task (Lisp file)

Generic Function: init OBJECT

Package

cram-language

Methods
Method: init (POLICY policy)

automatically generated reader method

Source

with-policy (Lisp file)

Generic Function: on-begin-execute-tag-task NAME

Package

cram-language

Source

language (Lisp file)

Method Combination

hooks

Generic Function: on-finish-execute-tag-task ID

Package

cram-language

Source

language (Lisp file)

Method Combination

hooks

Generic Function: on-finishing-named-top-level ID

Package

cram-language

Source

language (Lisp file)

Method Combination

hooks

Generic Function: on-finishing-task-execution ID

Package

cram-language

Source

task-tree (Lisp file)

Method Combination

hooks

Generic Function: on-preparing-named-top-level NAME

Package

cram-language

Source

language (Lisp file)

Method Combination

hooks

Generic Function: on-preparing-task-execution NAME LOG-PARAMETERS LOG-PATTERN

Package

cram-language

Source

task-tree (Lisp file)

Method Combination

hooks

Generic Function: on-with-failure-handling-begin CLAUSES

Package

cram-language

Source

failures (Lisp file)

Method Combination

hooks

Generic Function: on-with-failure-handling-end ID

Package

cram-language

Source

failures (Lisp file)

Method Combination

hooks

Generic Function: on-with-failure-handling-handled ID

Package

cram-language

Source

failures (Lisp file)

Method Combination

hooks

Generic Function: on-with-failure-handling-rethrown ID

Package

cram-language

Source

failures (Lisp file)

Method Combination

hooks

Generic Function: on-with-policy-begin NAME PARAMETERS

Package

cram-language

Source

with-policy (Lisp file)

Method Combination

hooks

Generic Function: on-with-policy-end ID SUCCESS

Package

cram-language

Source

with-policy (Lisp file)

Method Combination

hooks

Generic Function: parent-task TASK

Returns the parent task.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Methods
Method: parent-task (ABSTRACT-TASK abstract-task)

The parent task.

Source

task (Lisp file)

Generic Function: policy-name CONDITION

Package

cram-language

Methods
Method: policy-name (CONDITION policy-condition)

Generic Function: policy-parameters CONDITION

Package

cram-language

Methods
Method: policy-parameters (CONDITION policy-failure)

Generic Function: recover OBJECT

Package

cram-language

Methods
Method: recover (POLICY policy)

automatically generated reader method

Source

with-policy (Lisp file)

Generic Function: task-code OBJECT

Package

cram-language-implementation

Methods
Method: task-code (ABSTRACT-TASK abstract-task)

The code of the path.

Source

task (Lisp file)

Generic Function: task-constraints OBJECT

Generic Function: (setf task-constraints) NEW-VALUE OBJECT

Package

cram-language-implementation

Methods
Method: task-constraints (ABSTRACT-TASK abstract-task)

Method: (setf task-constraints) NEW-VALUE (ABSTRACT-TASK abstract-task)

The list of ordering constraint fluents. The task
is not allowed to start running before all fluents
are true.

Source

task (Lisp file)

Generic Function: task-message-queue OBJECT

Package

cram-language-implementation

Methods
Method: task-message-queue (ABSTRACT-TASK abstract-task)

automatically generated reader method

Source

task (Lisp file)

Generic Function: task-name OBJECT

Package

cram-language-implementation

Methods
Method: task-name (ABSTRACT-TASK abstract-task)

The name of the task. Mostly for debugging reasons.
Should also become the name of the thread executing
the task.

Source

task (Lisp file)

Generic Function: update-value FLUENT

Re-calculates the value of the fluent. This method
returns two values, the new value and T if the value actually
changed.

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Methods
Method: update-value (FLUENT fl-net-cacheable-fluent)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.5 Conditions

Condition: time-quantum-exhausted

Always signaled with an associated restart CONTINUE-WITH-ADJUSTED-TIME-QUANTUM.

Package

cram-language-implementation

Source

task (Lisp file)

Direct superclasses

condition


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.6 Structures

Structure: event

Package

cram-language-implementation

Source

task (Lisp file)

Direct superclasses

structure-object

Direct methods

print-object

Direct slots
Slot: tag
Type

keyword

Initform

(alexandria.0.dev:required-argument ’cram-language-implementation:tag)

Readers

event-tag (function)

Writers

(setf event-tag) (function)

Slot: reason
Type

(or null simple-string)

Readers

event-reason (function)

Writers

(setf event-reason) (function)

Slot: values
Type

list

Readers

event-values (function)

Writers

(setf event-values) (function)

Slot: sync
Type

boolean

Readers

event-sync (function)

Writers

(setf event-sync) (function)

Structure: message

Package

cram-language-implementation

Source

task (Lisp file)

Direct superclasses

structure-object

Direct slots
Slot: from
Type

cram-language-implementation::abstract-task

Initform

(alexandria.0.dev:required-argument ’cram-language-implementation::from)

Readers

message-from (function)

Writers

(setf message-from) (function)

Slot: to
Type

cram-language-implementation::abstract-task

Initform

(alexandria.0.dev:required-argument ’cram-language-implementation::to)

Readers

message-to (function)

Writers

(setf message-to) (function)

Slot: content
Type

cram-language-implementation::event

Initform

(alexandria.0.dev:required-argument ’cram-language-implementation::content)

Readers

message-content (function)

Writers

(setf message-content) (function)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.7 Classes

Class: abstract-task

Package

cram-language-implementation

Source

task (Lisp file)

Direct superclasses

standard-object

Direct subclasses
Direct methods
Direct slots
Slot: name

The name of the task. Mostly for debugging reasons.
Should also become the name of the thread executing
the task.

Type

(or symbol string null)

Initargs

:name

Initform

(gensym "unknown-")

Readers
Slot: thread

The internal thread object of the lisp implementation.

Type

(or sb-thread:thread null)

Slot: parent-task

The parent task.

Type

(or cram-language-implementation::abstract-task null)

Readers

parent-task (generic function)

Slot: child-tasks

The list of child tasks.

Type

(cram-language-implementation::list-of cram-language-implementation::abstract-task)

Initform

(list)

Readers

child-tasks (generic function)

Writers

(setf child-tasks) (generic function)

Slot: status

Fluent indicating the task status.
Cf. STATUS-INDICATOR.

Type

cram-language-implementation:fluent

Readers

status (generic function)

Slot: result

The result of the task. When it terminates
normally, the slot contains the list of return
values. For evaporated tasks, it contains nil and
for failed tasks, it contains the condition
object.

Type

(or list null condition)

Slot: thread-fun

The function of the task.

Type

(or function null)

Initargs

:thread-fun

Slot: path

The path of the task.

Type

list

Initargs

:path

Initform

cram-language-implementation:*current-path*

Readers

task-path (generic function)

Slot: code

The code of the path.

Type

(or cram-language-implementation:code null)

Initform

(and cram-language-implementation::*current-task-tree-node* (cram-language-implementation:task-tree-node-code cram-language-implementation::*current-task-tree-node*))

Readers

task-code (generic function)

Slot: constraints

The list of ordering constraint fluents. The task
is not allowed to start running before all fluents
are true.

Type

(cram-language-implementation::list-of cram-language-implementation:fluent)

Initform

(list)

Readers

task-constraints (generic function)

Writers

(setf task-constraints) (generic function)

Slot: message-queue
Type

sb-concurrency:mailbox

Initform

(sb-concurrency:make-mailbox)

Readers

task-message-queue (generic function)

Class: fl-cacheable-value-mixin

This mixin indicates that the value of this fluent
can be cached, i.e. it doesn’t change wihtout sending a pulse.

Package

cram-language-implementation

Source

fluent-interface (Lisp file)

Direct superclasses

standard-object

Direct subclasses
Class: fl-net-cacheable-fluent

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Direct superclasses
Direct methods
Direct slots
Slot: calculate-value-fun
Initargs

:calculate-value-fun

Slot: value

The cached value of this
fluent network.

Initargs

:value

Class: fl-net-fluent

Class of fluent networks that directly depend on
fluents that are not cachable.

Package

cram-language-implementation

Source

fluent-net (Lisp file)

Direct superclasses

fluent (class)

Direct methods

value (method)

Direct slots
Slot: calculate-value-fun

The function object to
calculate the value of the fluent.

Initargs

:calculate-value-fun

Class: fl-printable-mixin

This mixin indicates the value of the fluent can be
printed by the pretty-printer. This is not the case for PULSE
fluents, for instance.

Package

cram-language-implementation

Source

fluent-interface (Lisp file)

Direct superclasses

standard-object

Direct subclasses
Class: policy

Package

cram-language

Source

with-policy (Lisp file)

Direct superclasses

standard-object

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Slot: parameters
Initargs

:parameters

Readers

parameters (generic function)

Slot: description
Initargs

:description

Readers

description (generic function)

Slot: init
Initargs

:init

Readers

init (generic function)

Slot: check
Initargs

:check

Readers

check (generic function)

Slot: recover
Initargs

:recover

Readers

recover (generic function)

Slot: clean-up
Initargs

:clean-up

Readers

clean-up (generic function)

Class: pulse-fluent

Package

cram-language-implementation

Source

pulse-fluent (Lisp file)

Direct superclasses

fluent (class)

Direct methods

value (method)

Direct slots
Slot: handle-missed-pulses
Initargs

:handle-missed-pulses

Slot: processed-pulse-count

# pulses we have processed
so far. We don’t want to use pulse-count
since it is used in wait-for to determine if something changed. This slot is used to
compute the value.

Initargs

:processed-pulse-count

Initform

0

Slot: reference-pulse-count

The pulse count of the
fluent we are monitoring.

Initargs

:reference-pulse-count

Initform

0


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.2.8 Types

Type: continuation

Package

cram-language-implementation

Source

task (Lisp file)

Type: event-designator

An event-designator is a either a keyword naming the event, or a
list whose car is such a keyword and whose cdr is a list of
values. The list of values represent additional parameters of the
event and can be destructured in DESTRUCTURE-EVENT.

Package

cram-language-implementation

Source

task (Lisp file)

Type: list-of TYPE

Package

cram-language-implementation

Source

utils (Lisp file)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

A. Indexes


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

A.1 Concepts

Jump to:   C   F   L   M   S  
Index Entry Section

C
cram-language.asd3.1.1 cram-language.asd

F
File, Lisp, cram-language.asd3.1.1 cram-language.asd
File, Lisp, src/default-policies.lisp3.1.8 src/default-policies.lisp
File, Lisp, src/fluent-interface.lisp3.1.5 src/fluent-interface.lisp
File, Lisp, src/fluent-operators.lisp3.1.24 src/fluent-operators.lisp
File, Lisp, src/fluents/fluent-net.lisp3.1.14 src/fluents/fluent-net.lisp
File, Lisp, src/fluents/fluent.lisp3.1.12 src/fluents/fluent.lisp
File, Lisp, src/fluents/pulse-fluent.lisp3.1.15 src/fluents/pulse-fluent.lisp
File, Lisp, src/fluents/value-fluent.lisp3.1.13 src/fluents/value-fluent.lisp
File, Lisp, src/goals.lisp3.1.23 src/goals.lisp
File, Lisp, src/language.lisp3.1.21 src/language.lisp
File, Lisp, src/logging.lisp3.1.6 src/logging.lisp
File, Lisp, src/packages.lisp3.1.2 src/packages.lisp
File, Lisp, src/plans.lisp3.1.22 src/plans.lisp
File, Lisp, src/sbcl-hotpatches.lisp3.1.26 src/sbcl-hotpatches.lisp
File, Lisp, src/swank-indentation.lisp3.1.25 src/swank-indentation.lisp
File, Lisp, src/task-interface.lisp3.1.4 src/task-interface.lisp
File, Lisp, src/tasks/failures.lisp3.1.9 src/tasks/failures.lisp
File, Lisp, src/tasks/task-tree.lisp3.1.11 src/tasks/task-tree.lisp
File, Lisp, src/tasks/task.lisp3.1.10 src/tasks/task.lisp
File, Lisp, src/utils.lisp3.1.3 src/utils.lisp
File, Lisp, src/walker/env-impl-specific.lisp3.1.17 src/walker/env-impl-specific.lisp
File, Lisp, src/walker/env.lisp3.1.16 src/walker/env.lisp
File, Lisp, src/walker/interface.lisp3.1.20 src/walker/interface.lisp
File, Lisp, src/walker/plan-tree.lisp3.1.18 src/walker/plan-tree.lisp
File, Lisp, src/walker/walker.lisp3.1.19 src/walker/walker.lisp
File, Lisp, src/with-policy.lisp3.1.7 src/with-policy.lisp

L
Lisp File, cram-language.asd3.1.1 cram-language.asd
Lisp File, src/default-policies.lisp3.1.8 src/default-policies.lisp
Lisp File, src/fluent-interface.lisp3.1.5 src/fluent-interface.lisp
Lisp File, src/fluent-operators.lisp3.1.24 src/fluent-operators.lisp
Lisp File, src/fluents/fluent-net.lisp3.1.14 src/fluents/fluent-net.lisp
Lisp File, src/fluents/fluent.lisp3.1.12 src/fluents/fluent.lisp
Lisp File, src/fluents/pulse-fluent.lisp3.1.15 src/fluents/pulse-fluent.lisp
Lisp File, src/fluents/value-fluent.lisp3.1.13 src/fluents/value-fluent.lisp
Lisp File, src/goals.lisp3.1.23 src/goals.lisp
Lisp File, src/language.lisp3.1.21 src/language.lisp
Lisp File, src/logging.lisp3.1.6 src/logging.lisp
Lisp File, src/packages.lisp3.1.2 src/packages.lisp
Lisp File, src/plans.lisp3.1.22 src/plans.lisp
Lisp File, src/sbcl-hotpatches.lisp3.1.26 src/sbcl-hotpatches.lisp
Lisp File, src/swank-indentation.lisp3.1.25 src/swank-indentation.lisp
Lisp File, src/task-interface.lisp3.1.4 src/task-interface.lisp
Lisp File, src/tasks/failures.lisp3.1.9 src/tasks/failures.lisp
Lisp File, src/tasks/task-tree.lisp3.1.11 src/tasks/task-tree.lisp
Lisp File, src/tasks/task.lisp3.1.10 src/tasks/task.lisp
Lisp File, src/utils.lisp3.1.3 src/utils.lisp
Lisp File, src/walker/env-impl-specific.lisp3.1.17 src/walker/env-impl-specific.lisp
Lisp File, src/walker/env.lisp3.1.16 src/walker/env.lisp
Lisp File, src/walker/interface.lisp3.1.20 src/walker/interface.lisp
Lisp File, src/walker/plan-tree.lisp3.1.18 src/walker/plan-tree.lisp
Lisp File, src/walker/walker.lisp3.1.19 src/walker/walker.lisp
Lisp File, src/with-policy.lisp3.1.7 src/with-policy.lisp

M
Module, src/2.1 src/
Module, src/fluents/2.3 src/fluents/
Module, src/tasks/2.2 src/tasks/
Module, src/walker/2.4 src/walker/

S
src/2.1 src/
src/default-policies.lisp3.1.8 src/default-policies.lisp
src/fluent-interface.lisp3.1.5 src/fluent-interface.lisp
src/fluent-operators.lisp3.1.24 src/fluent-operators.lisp
src/fluents/2.3 src/fluents/
src/fluents/fluent-net.lisp3.1.14 src/fluents/fluent-net.lisp
src/fluents/fluent.lisp3.1.12 src/fluents/fluent.lisp
src/fluents/pulse-fluent.lisp3.1.15 src/fluents/pulse-fluent.lisp
src/fluents/value-fluent.lisp3.1.13 src/fluents/value-fluent.lisp
src/goals.lisp3.1.23 src/goals.lisp
src/language.lisp3.1.21 src/language.lisp
src/logging.lisp3.1.6 src/logging.lisp
src/packages.lisp3.1.2 src/packages.lisp
src/plans.lisp3.1.22 src/plans.lisp
src/sbcl-hotpatches.lisp3.1.26 src/sbcl-hotpatches.lisp
src/swank-indentation.lisp3.1.25 src/swank-indentation.lisp
src/task-interface.lisp3.1.4 src/task-interface.lisp
src/tasks/2.2 src/tasks/
src/tasks/failures.lisp3.1.9 src/tasks/failures.lisp
src/tasks/task-tree.lisp3.1.11 src/tasks/task-tree.lisp
src/tasks/task.lisp3.1.10 src/tasks/task.lisp
src/utils.lisp3.1.3 src/utils.lisp
src/walker/2.4 src/walker/
src/walker/env-impl-specific.lisp3.1.17 src/walker/env-impl-specific.lisp
src/walker/env.lisp3.1.16 src/walker/env.lisp
src/walker/interface.lisp3.1.20 src/walker/interface.lisp
src/walker/plan-tree.lisp3.1.18 src/walker/plan-tree.lisp
src/walker/walker.lisp3.1.19 src/walker/walker.lisp
src/with-policy.lisp3.1.7 src/with-policy.lisp

Jump to:   C   F   L   M   S  

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

A.2 Functions

Jump to:   %   (   *   +   -   /   <   =   >  
A   C   D   E   F   G   I   J   K   L   M   N   O   P   R   S   T   U   V   W  
Index Entry Section

%
%define-log-tags5.2.3 Functions
%fail5.2.3 Functions
%log-event5.2.3 Functions
%make-event5.2.3 Functions
%teardown5.2.3 Functions
%timed-wait-for5.2.3 Functions
%unwind-on-suspension5.2.3 Functions

(
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.3 Functions
(5.1.4 Generic functions
(5.1.4 Generic functions
(5.2.3 Functions
(5.2.3 Functions
(5.2.3 Functions
(5.2.3 Functions
(5.2.3 Functions
(5.2.3 Functions
(5.2.3 Functions
(5.2.3 Functions
(5.2.3 Functions
(5.2.3 Functions
(5.2.4 Generic functions
(5.2.4 Generic functions
(5.2.4 Generic functions
(5.2.4 Generic functions

*
*5.1.3 Functions

+
+5.1.3 Functions

-
-5.1.3 Functions

/
/5.1.3 Functions

<
<5.1.3 Functions

=
=5.1.3 Functions

>
>5.1.3 Functions

A
adjust-time-quantum5.2.3 Functions
assert-status5.2.3 Functions
aug-env5.2.3 Functions
augment-environment5.2.3 Functions

C
call-as-fluent-operator5.2.3 Functions
call-goal5.2.3 Functions
call-on-suspension5.2.3 Functions
call-with-event-loop5.2.3 Functions
call-with-scheduling5.2.3 Functions
call-without-scheduling5.2.3 Functions
change-status5.2.3 Functions
check5.2.4 Generic functions
check5.2.4 Generic functions
check-time-quantum5.2.3 Functions
child-tasks5.2.4 Generic functions
child-tasks5.2.4 Generic functions
clean-up5.2.4 Generic functions
clean-up5.2.4 Generic functions
clear-saved-tasks5.2.3 Functions
clear-tasks5.1.3 Functions
code-function5.1.3 Functions
code-p5.2.3 Functions
code-parameters5.1.3 Functions
code-sexp5.1.3 Functions
code-task5.1.3 Functions
coerce-to-condition5.2.3 Functions
composite-failures5.1.4 Generic functions
composite-failures5.1.4 Generic functions
continue-with-adjusted-time-quantum5.2.3 Functions
copy-code5.2.3 Functions
copy-event5.2.3 Functions
copy-message5.2.3 Functions
copy-plan-tree-node5.2.3 Functions
copy-task-tree-node5.2.3 Functions
current-task5.1.3 Functions

D
declare-goal5.1.2 Macros
def-cpl-parameter5.1.2 Macros
def-cram-function5.1.2 Macros
def-fluent-operator5.2.2 Macros
def-goal5.1.2 Macros
def-plan5.1.2 Macros
def-plan-macro5.2.2 Macros
def-top-level-cram-function5.1.2 Macros
def-top-level-plan5.1.2 Macros
define-fluent-net-wrapper5.2.2 Macros
define-log-tags5.2.2 Macros
define-policy5.1.2 Macros
define-task-variable5.1.2 Macros
describe-goal5.1.3 Functions
description5.2.4 Generic functions
description5.2.4 Generic functions
destructure-event5.2.2 Macros

E
enclose5.2.3 Functions
ensure-tree-node5.2.3 Functions
envelop-error5.1.4 Generic functions
envelop-error5.1.4 Generic functions
eq5.1.3 Functions
eql5.1.3 Functions
evaporate5.1.4 Generic functions
evaporate5.1.4 Generic functions
event-loop5.2.3 Functions
event-p5.2.3 Functions
event-reason5.2.3 Functions
event-sync5.2.3 Functions
event-tag5.2.3 Functions
event-values5.2.3 Functions
execute5.2.4 Generic functions
execute5.2.4 Generic functions
execute5.2.4 Generic functions
execute5.2.4 Generic functions
execute5.2.4 Generic functions
execute5.2.4 Generic functions
execute-task-tree-node5.2.3 Functions
executed5.2.4 Generic functions
executed5.2.4 Generic functions
expand-plan5.1.3 Functions
extend-path5.2.3 Functions

F
fail5.1.3 Functions
filter-task-tree5.1.3 Functions
find-plan-node5.1.3 Functions
fl*5.1.3 Functions
fl+5.1.3 Functions
fl-5.1.3 Functions
fl-and5.1.3 Functions
fl-apply5.1.3 Functions
fl-eq5.1.3 Functions
fl-eql5.1.3 Functions
fl-funcall5.1.3 Functions
fl-member5.2.3 Functions
fl-not5.1.3 Functions
fl-or5.1.3 Functions
fl-pulsed5.1.3 Functions
fl-value-changed5.1.3 Functions
fl/5.1.3 Functions
fl<5.1.3 Functions
fl=5.1.3 Functions
fl>5.1.3 Functions
flatten-task-tree5.1.3 Functions
float-/5.2.3 Functions
format-gensym5.2.3 Functions
Function, %define-log-tags5.2.3 Functions
Function, %fail5.2.3 Functions
Function, %log-event5.2.3 Functions
Function, %make-event5.2.3 Functions
Function, %teardown5.2.3 Functions
Function, %timed-wait-for5.2.3 Functions
Function, %unwind-on-suspension5.2.3 Functions
Function, (setf code-function)5.1.3 Functions
Function, (setf code-parameters)5.1.3 Functions
Function, (setf code-sexp)5.1.3 Functions
Function, (setf code-task)5.1.3 Functions
Function, (setf event-reason)5.2.3 Functions
Function, (setf event-sync)5.2.3 Functions
Function, (setf event-tag)5.2.3 Functions
Function, (setf event-values)5.2.3 Functions
Function, (setf get-alist)5.2.3 Functions
Function, (setf message-content)5.2.3 Functions
Function, (setf message-from)5.2.3 Functions
Function, (setf message-to)5.2.3 Functions
Function, (setf plan-tree-node-children)5.1.3 Functions
Function, (setf plan-tree-node-parent)5.1.3 Functions
Function, (setf plan-tree-node-path)5.1.3 Functions
Function, (setf plan-tree-node-sexp)5.1.3 Functions
Function, (setf task-tree-node-children)5.1.3 Functions
Function, (setf task-tree-node-code)5.1.3 Functions
Function, (setf task-tree-node-code-replacements)5.2.3 Functions
Function, (setf task-tree-node-lock)5.2.3 Functions
Function, (setf task-tree-node-parent)5.1.3 Functions
Function, (setf task-tree-node-path)5.1.3 Functions
Function, *5.1.3 Functions
Function, +5.1.3 Functions
Function, -5.1.3 Functions
Function, /5.1.3 Functions
Function, <5.1.3 Functions
Function, =5.1.3 Functions
Function, >5.1.3 Functions
Function, adjust-time-quantum5.2.3 Functions
Function, assert-status5.2.3 Functions
Function, aug-env5.2.3 Functions
Function, augment-environment5.2.3 Functions
Function, call-as-fluent-operator5.2.3 Functions
Function, call-goal5.2.3 Functions
Function, call-on-suspension5.2.3 Functions
Function, call-with-event-loop5.2.3 Functions
Function, call-with-scheduling5.2.3 Functions
Function, call-without-scheduling5.2.3 Functions
Function, change-status5.2.3 Functions
Function, check-time-quantum5.2.3 Functions
Function, clear-saved-tasks5.2.3 Functions
Function, clear-tasks5.1.3 Functions
Function, code-function5.1.3 Functions
Function, code-p5.2.3 Functions
Function, code-parameters5.1.3 Functions
Function, code-sexp5.1.3 Functions
Function, code-task5.1.3 Functions
Function, coerce-to-condition5.2.3 Functions
Function, continue-with-adjusted-time-quantum5.2.3 Functions
Function, copy-code5.2.3 Functions
Function, copy-event5.2.3 Functions
Function, copy-message5.2.3 Functions
Function, copy-plan-tree-node5.2.3 Functions
Function, copy-task-tree-node5.2.3 Functions
Function, current-task5.1.3 Functions
Function, describe-goal5.1.3 Functions
Function, enclose5.2.3 Functions
Function, ensure-tree-node5.2.3 Functions
Function, eq5.1.3 Functions
Function, eql5.1.3 Functions
Function, event-loop5.2.3 Functions
Function, event-p5.2.3 Functions
Function, event-reason5.2.3 Functions
Function, event-sync5.2.3 Functions
Function, event-tag5.2.3 Functions
Function, event-values5.2.3 Functions
Function, execute-task-tree-node5.2.3 Functions
Function, expand-plan5.1.3 Functions
Function, extend-path5.2.3 Functions
Function, fail5.1.3 Functions
Function, filter-task-tree5.1.3 Functions
Function, find-plan-node5.1.3 Functions
Function, fl*5.1.3 Functions
Function, fl+5.1.3 Functions
Function, fl-5.1.3 Functions
Function, fl-and5.1.3 Functions
Function, fl-apply5.1.3 Functions
Function, fl-eq5.1.3 Functions
Function, fl-eql5.1.3 Functions
Function, fl-funcall5.1.3 Functions
Function, fl-member5.2.3 Functions
Function, fl-not5.1.3 Functions
Function, fl-or5.1.3 Functions
Function, fl-pulsed5.1.3 Functions
Function, fl-value-changed5.1.3 Functions
Function, fl/5.1.3 Functions
Function, fl<5.1.3 Functions
Function, fl=5.1.3 Functions
Function, fl>5.1.3 Functions
Function, flatten-task-tree5.1.3 Functions
Function, float-/5.2.3 Functions
Function, format-gensym5.2.3 Functions
Function, get-alist5.2.3 Functions
Function, get-top-level-task-tree5.1.3 Functions
Function, goal-task-tree-node-goal5.1.3 Functions
Function, goal-task-tree-node-p5.1.3 Functions
Function, goal-task-tree-node-parameter-bindings5.1.3 Functions
Function, goal-task-tree-node-pattern5.1.3 Functions
Function, inherit-parent-value5.2.3 Functions
Function, invoke-event-loop5.2.3 Functions
Function, kill-saved-tasks5.2.3 Functions
Function, lambda-list-keyword-p5.2.3 Functions
Function, list-active-log-tags5.1.3 Functions
Function, list-available-log-tags5.1.3 Functions
Function, list-saved-tasks5.1.3 Functions
Function, log-disable5.1.3 Functions
Function, log-enable5.1.3 Functions
Function, log-gc-event5.2.3 Functions
Function, log-mask5.2.3 Functions
Function, log-set5.1.3 Functions
Function, log-tag-offset5.2.3 Functions
Function, logfmt5.2.3 Functions
Function, make-code5.2.3 Functions
Function, make-dummy-task5.2.3 Functions
Function, make-event5.2.3 Functions
Function, make-fluent5.1.3 Functions
Function, make-goal-fun5.2.3 Functions
Function, make-message5.2.3 Functions
Function, make-plan-tree-node5.2.3 Functions
Function, make-task5.1.3 Functions
Function, make-task-tree-node5.1.3 Functions
Function, matching-goal-fun5.2.3 Functions
Function, message-content5.2.3 Functions
Function, message-from5.2.3 Functions
Function, message-p5.2.3 Functions
Function, message-to5.2.3 Functions
Function, named-policy5.1.3 Functions
Function, not5.1.3 Functions
Function, parse-macro5.2.3 Functions
Function, parse-macro-function5.2.3 Functions
Function, partition5.2.3 Functions
Function, path-next-iteration5.2.3 Functions
Function, peek-value5.1.3 Functions
Function, plan-tree-node-children5.1.3 Functions
Function, plan-tree-node-p5.2.3 Functions
Function, plan-tree-node-parent5.1.3 Functions
Function, plan-tree-node-path5.1.3 Functions
Function, plan-tree-node-sexp5.1.3 Functions
Function, propagate-event5.2.3 Functions
Function, pulsed5.1.3 Functions
Function, recalculate-timeout5.2.3 Functions
Function, receive-event5.2.3 Functions
Function, register-child-plan5.2.3 Functions
Function, register-goal5.1.3 Functions
Function, register-task-code5.2.3 Functions
Function, remove-top-level-task-tree5.2.3 Functions
Function, replace-task-code5.2.3 Functions
Function, scheduling-disabled-p5.2.3 Functions
Function, scheduling-enabled-p5.2.3 Functions
Function, seconds-to-internal-time5.2.3 Functions
Function, send-event5.2.3 Functions
Function, setup5.2.3 Functions
Function, signal-time-quantum-exhausted5.2.3 Functions
Function, sleep5.1.3 Functions
Function, sleep*5.1.3 Functions
Function, stale-task-tree-node-p5.1.3 Functions
Function, sub-task5.1.3 Functions
Function, synchronize-on-event5.2.3 Functions
Function, tag-form-handler5.2.3 Functions
Function, task5.1.3 Functions
Function, task-abbreviated-name5.2.3 Functions
Function, task-alive5.1.3 Functions
Function, task-dead5.1.3 Functions
Function, task-dead-p5.1.3 Functions
Function, task-done-p5.1.3 Functions
Function, task-failed-p5.1.3 Functions
Function, task-running-p5.1.3 Functions
Function, task-tree-node5.1.3 Functions
Function, task-tree-node-children5.1.3 Functions
Function, task-tree-node-code5.1.3 Functions
Function, task-tree-node-code-replacements5.2.3 Functions
Function, task-tree-node-effective-code5.1.3 Functions
Function, task-tree-node-lock5.2.3 Functions
Function, task-tree-node-p5.1.3 Functions
Function, task-tree-node-parameters5.1.3 Functions
Function, task-tree-node-parent5.1.3 Functions
Function, task-tree-node-path5.1.3 Functions
Function, task-tree-node-result5.1.3 Functions
Function, task-tree-node-status-fluent5.1.3 Functions
Function, truncate-string5.2.3 Functions
Function, tv-closure5.1.3 Functions
Function, unwind-and-continue5.2.3 Functions
Function, unwind-and-teardown5.2.3 Functions
Function, walk-argument5.2.3 Functions
Function, walk-binding5.2.3 Functions
Function, walk-binding-list5.2.3 Functions
Function, walk-block5.2.3 Functions
Function, walk-cpl-tag5.2.3 Functions
Function, walk-flet5.2.3 Functions
Function, walk-form5.2.3 Functions
Function, walk-funcall5.2.3 Functions
Function, walk-function5.2.3 Functions
Function, walk-labels5.2.3 Functions
Function, walk-lambda5.2.3 Functions
Function, walk-let5.2.3 Functions
Function, walk-let*5.2.3 Functions
Function, walk-list5.2.3 Functions
Function, walk-list-of-lambdas5.2.3 Functions
Function, walk-load-time-value5.2.3 Functions
Function, walk-macrolet5.2.3 Functions
Function, walk-named-lambda5.2.3 Functions
Function, walk-ordinary-lambda-list5.2.3 Functions
Function, walk-plan-form5.2.3 Functions
Function, walk-quote5.2.3 Functions
Function, walk-with-tag-handler5.1.3 Functions
Function, what-time-is-it5.2.3 Functions
Function, who-am-i5.2.3 Functions

G
Generic Function, (setf child-tasks)5.2.4 Generic functions
Generic Function, (setf task-constraints)5.2.4 Generic functions
Generic Function, (setf value)5.1.4 Generic functions
Generic Function, check5.2.4 Generic functions
Generic Function, child-tasks5.2.4 Generic functions
Generic Function, clean-up5.2.4 Generic functions
Generic Function, composite-failures5.1.4 Generic functions
Generic Function, description5.2.4 Generic functions
Generic Function, envelop-error5.1.4 Generic functions
Generic Function, evaporate5.1.4 Generic functions
Generic Function, execute5.2.4 Generic functions
Generic Function, executed5.2.4 Generic functions
Generic Function, get-update-callback5.1.4 Generic functions
Generic Function, init5.2.4 Generic functions
Generic Function, join-task5.1.4 Generic functions
Generic Function, name5.1.4 Generic functions
Generic Function, on-begin-execute-tag-task5.2.4 Generic functions
Generic Function, on-def-top-level-plan-hook5.1.4 Generic functions
Generic Function, on-fail5.1.4 Generic functions
Generic Function, on-finish-execute-tag-task5.2.4 Generic functions
Generic Function, on-finishing-named-top-level5.2.4 Generic functions
Generic Function, on-finishing-task-execution5.2.4 Generic functions
Generic Function, on-make-fluent-hook5.1.4 Generic functions
Generic Function, on-preparing-named-top-level5.2.4 Generic functions
Generic Function, on-preparing-task-execution5.2.4 Generic functions
Generic Function, on-top-level-cleanup-hook5.1.4 Generic functions
Generic Function, on-top-level-setup-hook5.1.4 Generic functions
Generic Function, on-with-failure-handling-begin5.2.4 Generic functions
Generic Function, on-with-failure-handling-end5.2.4 Generic functions
Generic Function, on-with-failure-handling-handled5.2.4 Generic functions
Generic Function, on-with-failure-handling-rethrown5.2.4 Generic functions
Generic Function, on-with-policy-begin5.2.4 Generic functions
Generic Function, on-with-policy-end5.2.4 Generic functions
Generic Function, parameters5.1.4 Generic functions
Generic Function, parent-task5.2.4 Generic functions
Generic Function, policy-name5.2.4 Generic functions
Generic Function, policy-parameters5.2.4 Generic functions
Generic Function, pulse5.1.4 Generic functions
Generic Function, recover5.2.4 Generic functions
Generic Function, register-update-callback5.1.4 Generic functions
Generic Function, remove-update-callback5.1.4 Generic functions
Generic Function, result5.1.4 Generic functions
Generic Function, status5.1.4 Generic functions
Generic Function, suspend5.1.4 Generic functions
Generic Function, task-code5.2.4 Generic functions
Generic Function, task-constraints5.2.4 Generic functions
Generic Function, task-message-queue5.2.4 Generic functions
Generic Function, task-name5.2.4 Generic functions
Generic Function, task-path5.1.4 Generic functions
Generic Function, update-value5.2.4 Generic functions
Generic Function, value5.1.4 Generic functions
Generic Function, wait-for5.1.4 Generic functions
Generic Function, wake-up5.1.4 Generic functions
get-alist5.2.3 Functions
get-top-level-task-tree5.1.3 Functions
get-update-callback5.1.4 Generic functions
get-update-callback5.1.4 Generic functions
goal-task-tree-node-goal5.1.3 Functions
goal-task-tree-node-p5.1.3 Functions
goal-task-tree-node-parameter-bindings5.1.3 Functions
goal-task-tree-node-pattern5.1.3 Functions

I
inherit-parent-value5.2.3 Functions
init5.2.4 Generic functions
init5.2.4 Generic functions
invoke-event-loop5.2.3 Functions

J
join-task5.1.4 Generic functions
join-task5.1.4 Generic functions

K
kill-saved-tasks5.2.3 Functions

L
lambda-list-keyword-p5.2.3 Functions
list-active-log-tags5.1.3 Functions
list-available-log-tags5.1.3 Functions
list-saved-tasks5.1.3 Functions
log-block5.2.2 Macros
log-disable5.1.3 Functions
log-enable5.1.3 Functions
log-event5.1.2 Macros
log-gc-event5.2.3 Functions
log-mask5.2.3 Functions
log-set5.1.3 Functions
log-tag-offset5.2.3 Functions
logfmt5.2.3 Functions
logging-enabled-p5.1.2 Macros

M
Macro, declare-goal5.1.2 Macros
Macro, def-cpl-parameter5.1.2 Macros
Macro, def-cram-function5.1.2 Macros
Macro, def-fluent-operator5.2.2 Macros
Macro, def-goal5.1.2 Macros
Macro, def-plan5.1.2 Macros
Macro, def-plan-macro5.2.2 Macros
Macro, def-top-level-cram-function5.1.2 Macros
Macro, def-top-level-plan5.1.2 Macros
Macro, define-fluent-net-wrapper5.2.2 Macros
Macro, define-log-tags5.2.2 Macros
Macro, define-policy5.1.2 Macros
Macro, define-task-variable5.1.2 Macros
Macro, destructure-event5.2.2 Macros
Macro, log-block5.2.2 Macros
Macro, log-event5.1.2 Macros
Macro, logging-enabled-p5.1.2 Macros
Macro, make-policy5.1.2 Macros
Macro, mapcar-clean5.1.2 Macros
Macro, named-top-level5.2.2 Macros
Macro, on-suspension5.1.2 Macros
Macro, par5.1.2 Macros
Macro, par-loop5.1.2 Macros
Macro, partial-order5.1.2 Macros
Macro, pursue5.1.2 Macros
Macro, replaceable-function5.1.2 Macros
Macro, retry-after-suspension5.1.2 Macros
Macro, seq5.1.2 Macros
Macro, single-form-progv5.2.2 Macros
Macro, top-level5.1.2 Macros
Macro, try-all5.1.2 Macros
Macro, try-each-in-order5.1.2 Macros
Macro, try-in-order5.1.2 Macros
Macro, whenever5.1.2 Macros
Macro, with-extended-path5.2.2 Macros
Macro, with-failure-handling5.1.2 Macros
Macro, with-fluent-locked5.2.2 Macros
Macro, with-named-policies5.1.2 Macros
Macro, with-named-policy5.1.2 Macros
Macro, with-parallel-childs5.2.2 Macros
Macro, with-policies5.1.2 Macros
Macro, with-policy5.1.2 Macros
Macro, with-retry-counters5.1.2 Macros
Macro, with-scheduling5.1.2 Macros
Macro, with-shadowed-functions5.2.2 Macros
Macro, with-tags5.1.2 Macros
Macro, with-task5.2.2 Macros
Macro, with-task-suspended5.1.2 Macros
Macro, with-task-tree-node5.1.2 Macros
Macro, without-scheduling5.1.2 Macros
make-code5.2.3 Functions
make-dummy-task5.2.3 Functions
make-event5.2.3 Functions
make-fluent5.1.3 Functions
make-goal-fun5.2.3 Functions
make-message5.2.3 Functions
make-plan-tree-node5.2.3 Functions
make-policy5.1.2 Macros
make-task5.1.3 Functions
make-task-tree-node5.1.3 Functions
mapcar-clean5.1.2 Macros
matching-goal-fun5.2.3 Functions
message-content5.2.3 Functions
message-from5.2.3 Functions
message-p5.2.3 Functions
message-to5.2.3 Functions
Method, (setf child-tasks)5.2.4 Generic functions
Method, (setf task-constraints)5.2.4 Generic functions
Method, (setf value)5.1.4 Generic functions
Method, check5.2.4 Generic functions
Method, child-tasks5.2.4 Generic functions
Method, clean-up5.2.4 Generic functions
Method, composite-failures5.1.4 Generic functions
Method, description5.2.4 Generic functions
Method, envelop-error5.1.4 Generic functions
Method, evaporate5.1.4 Generic functions
Method, execute5.2.4 Generic functions
Method, execute5.2.4 Generic functions
Method, execute5.2.4 Generic functions
Method, execute5.2.4 Generic functions
Method, execute5.2.4 Generic functions
Method, executed5.2.4 Generic functions
Method, get-update-callback5.1.4 Generic functions
Method, init5.2.4 Generic functions
Method, join-task5.1.4 Generic functions
Method, name5.1.4 Generic functions
Method, name5.1.4 Generic functions
Method, name5.1.4 Generic functions
Method, parameters5.1.4 Generic functions
Method, parent-task5.2.4 Generic functions
Method, policy-name5.2.4 Generic functions
Method, policy-parameters5.2.4 Generic functions
Method, pulse5.1.4 Generic functions
Method, pulse5.1.4 Generic functions
Method, recover5.2.4 Generic functions
Method, register-update-callback5.1.4 Generic functions
Method, remove-update-callback5.1.4 Generic functions
Method, result5.1.4 Generic functions
Method, status5.1.4 Generic functions
Method, suspend5.1.4 Generic functions
Method, task-code5.2.4 Generic functions
Method, task-constraints5.2.4 Generic functions
Method, task-message-queue5.2.4 Generic functions
Method, task-name5.2.4 Generic functions
Method, task-path5.1.4 Generic functions
Method, update-value5.2.4 Generic functions
Method, value5.1.4 Generic functions
Method, value5.1.4 Generic functions
Method, value5.1.4 Generic functions
Method, value5.1.4 Generic functions
Method, value5.1.4 Generic functions
Method, wait-for5.1.4 Generic functions
Method, wait-for5.1.4 Generic functions
Method, wake-up5.1.4 Generic functions

N
name5.1.4 Generic functions
name5.1.4 Generic functions
name5.1.4 Generic functions
name5.1.4 Generic functions
named-policy5.1.3 Functions
named-top-level5.2.2 Macros
not5.1.3 Functions

O
on-begin-execute-tag-task5.2.4 Generic functions
on-def-top-level-plan-hook5.1.4 Generic functions
on-fail5.1.4 Generic functions
on-finish-execute-tag-task5.2.4 Generic functions
on-finishing-named-top-level5.2.4 Generic functions
on-finishing-task-execution5.2.4 Generic functions
on-make-fluent-hook5.1.4 Generic functions
on-preparing-named-top-level5.2.4 Generic functions
on-preparing-task-execution5.2.4 Generic functions
on-suspension5.1.2 Macros
on-top-level-cleanup-hook5.1.4 Generic functions
on-top-level-setup-hook5.1.4 Generic functions
on-with-failure-handling-begin5.2.4 Generic functions
on-with-failure-handling-end5.2.4 Generic functions
on-with-failure-handling-handled5.2.4 Generic functions
on-with-failure-handling-rethrown5.2.4 Generic functions
on-with-policy-begin5.2.4 Generic functions
on-with-policy-end5.2.4 Generic functions

P
par5.1.2 Macros
par-loop5.1.2 Macros
parameters5.1.4 Generic functions
parameters5.1.4 Generic functions
parent-task5.2.4 Generic functions
parent-task5.2.4 Generic functions
parse-macro5.2.3 Functions
parse-macro-function5.2.3 Functions
partial-order5.1.2 Macros
partition5.2.3 Functions
path-next-iteration5.2.3 Functions
peek-value5.1.3 Functions
plan-tree-node-children5.1.3 Functions
plan-tree-node-p5.2.3 Functions
plan-tree-node-parent5.1.3 Functions
plan-tree-node-path5.1.3 Functions
plan-tree-node-sexp5.1.3 Functions
policy-name5.2.4 Generic functions
policy-name5.2.4 Generic functions
policy-parameters5.2.4 Generic functions
policy-parameters5.2.4 Generic functions
propagate-event5.2.3 Functions
pulse5.1.4 Generic functions
pulse5.1.4 Generic functions
pulse5.1.4 Generic functions
pulsed5.1.3 Functions
pursue5.1.2 Macros

R
recalculate-timeout5.2.3 Functions
receive-event5.2.3 Functions
recover5.2.4 Generic functions
recover5.2.4 Generic functions
register-child-plan5.2.3 Functions
register-goal5.1.3 Functions
register-task-code5.2.3 Functions
register-update-callback5.1.4 Generic functions
register-update-callback5.1.4 Generic functions
remove-top-level-task-tree5.2.3 Functions
remove-update-callback5.1.4 Generic functions
remove-update-callback5.1.4 Generic functions
replace-task-code5.2.3 Functions
replaceable-function5.1.2 Macros
result5.1.4 Generic functions
result5.1.4 Generic functions
retry-after-suspension5.1.2 Macros

S
scheduling-disabled-p5.2.3 Functions
scheduling-enabled-p5.2.3 Functions
seconds-to-internal-time5.2.3 Functions
send-event5.2.3 Functions
seq5.1.2 Macros
setup5.2.3 Functions
signal-time-quantum-exhausted5.2.3 Functions
single-form-progv5.2.2 Macros
sleep5.1.3 Functions
sleep*5.1.3 Functions
stale-task-tree-node-p5.1.3 Functions
status5.1.4 Generic functions
status5.1.4 Generic functions
sub-task5.1.3 Functions
suspend5.1.4 Generic functions
suspend5.1.4 Generic functions
synchronize-on-event5.2.3 Functions

T
tag-form-handler5.2.3 Functions
task5.1.3 Functions
task-abbreviated-name5.2.3 Functions
task-alive5.1.3 Functions
task-code5.2.4 Generic functions
task-code5.2.4 Generic functions
task-constraints5.2.4 Generic functions
task-constraints5.2.4 Generic functions
task-dead5.1.3 Functions
task-dead-p5.1.3 Functions
task-done-p5.1.3 Functions
task-failed-p5.1.3 Functions
task-message-queue5.2.4 Generic functions
task-message-queue5.2.4 Generic functions
task-name5.2.4 Generic functions
task-name5.2.4 Generic functions
task-path5.1.4 Generic functions
task-path5.1.4 Generic functions
task-running-p5.1.3 Functions
task-tree-node5.1.3 Functions
task-tree-node-children5.1.3 Functions
task-tree-node-code5.1.3 Functions
task-tree-node-code-replacements5.2.3 Functions
task-tree-node-effective-code5.1.3 Functions
task-tree-node-lock5.2.3 Functions
task-tree-node-p5.1.3 Functions
task-tree-node-parameters5.1.3 Functions
task-tree-node-parent5.1.3 Functions
task-tree-node-path5.1.3 Functions
task-tree-node-result5.1.3 Functions
task-tree-node-status-fluent5.1.3 Functions
top-level5.1.2 Macros
truncate-string5.2.3 Functions
try-all5.1.2 Macros
try-each-in-order5.1.2 Macros
try-in-order5.1.2 Macros
tv-closure5.1.3 Functions

U
unwind-and-continue5.2.3 Functions
unwind-and-teardown5.2.3 Functions
update-value5.2.4 Generic functions
update-value5.2.4 Generic functions

V
value5.1.4 Generic functions
value5.1.4 Generic functions
value5.1.4 Generic functions
value5.1.4 Generic functions
value5.1.4 Generic functions
value5.1.4 Generic functions

W
wait-for5.1.4 Generic functions
wait-for5.1.4 Generic functions
wait-for5.1.4 Generic functions
wake-up5.1.4 Generic functions
wake-up5.1.4 Generic functions
walk-argument5.2.3 Functions
walk-binding5.2.3 Functions
walk-binding-list5.2.3 Functions
walk-block5.2.3 Functions
walk-cpl-tag5.2.3 Functions
walk-flet5.2.3 Functions
walk-form5.2.3 Functions
walk-funcall5.2.3 Functions
walk-function5.2.3 Functions
walk-labels5.2.3 Functions
walk-lambda5.2.3 Functions
walk-let5.2.3 Functions
walk-let*5.2.3 Functions
walk-list5.2.3 Functions
walk-list-of-lambdas5.2.3 Functions
walk-load-time-value5.2.3 Functions
walk-macrolet5.2.3 Functions
walk-named-lambda5.2.3 Functions
walk-ordinary-lambda-list5.2.3 Functions
walk-plan-form5.2.3 Functions
walk-quote5.2.3 Functions
walk-with-tag-handler5.1.3 Functions
what-time-is-it5.2.3 Functions
whenever5.1.2 Macros
who-am-i5.2.3 Functions
with-extended-path5.2.2 Macros
with-failure-handling5.1.2 Macros
with-fluent-locked5.2.2 Macros
with-named-policies5.1.2 Macros
with-named-policy5.1.2 Macros
with-parallel-childs5.2.2 Macros
with-policies5.1.2 Macros
with-policy5.1.2 Macros
with-retry-counters5.1.2 Macros
with-scheduling5.1.2 Macros
with-shadowed-functions5.2.2 Macros
with-tags5.1.2 Macros
with-task5.2.2 Macros
with-task-suspended5.1.2 Macros
with-task-tree-node5.1.2 Macros
without-scheduling5.1.2 Macros

Jump to:   %   (   *   +   -   /   <   =   >  
A   C   D   E   F   G   I   J   K   L   M   N   O   P   R   S   T   U   V   W  

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

A.3 Variables

Jump to:   *   +  
C   D   E   F   H   I   L   M   N   O   P   R   S   T   V  
Index Entry Section

*
*active-log-mask*5.2.1 Special variables
*break-on-plan-failures*5.1.1 Special variables
*cltl2-environment-fns*5.2.1 Special variables
*current-parent*5.2.1 Special variables
*current-path*5.1.1 Special variables
*current-path*5.2.1 Special variables
*current-task*5.1.1 Special variables
*current-task-tree-node*5.2.1 Special variables
*debug-on-lisp-errors*5.1.1 Special variables
*log-output*5.1.1 Special variables
*log-right-margin*5.1.1 Special variables
*log-tag-table*5.2.1 Special variables
*peek-value*5.2.1 Special variables
*policies*5.2.1 Special variables
*policy-check-consolidation-duration*5.2.1 Special variables
*save-tasks*5.1.1 Special variables
*scheduling-enabled*5.2.1 Special variables
*shadowed-functions*5.2.1 Special variables
*status-transitions*5.2.1 Special variables
*suspension-handlers*5.2.1 Special variables
*suspension-unwind*5.2.1 Special variables
*synchronous-events*5.2.1 Special variables
*tag-walker-handlers*5.2.1 Special variables
*task-local-variables*5.2.1 Special variables
*task-pprint-verbosity*5.1.1 Special variables
*task-tree*5.1.1 Special variables
*task-tree-print-children*5.2.1 Special variables
*task-tree-print-code*5.2.1 Special variables
*task-tree-print-identity*5.2.1 Special variables
*task-tree-print-path*5.2.1 Special variables
*tasks*5.1.1 Special variables
*top-level-task-trees*5.2.1 Special variables
*zero-real-time*5.2.1 Special variables
*zero-run-time*5.2.1 Special variables

+
+alive+5.1.1 Special variables
+available-log-tags+5.2.1 Special variables
+dead+5.1.1 Special variables
+done+5.1.1 Special variables
+log-all+5.1.1 Special variables
+log-default+5.1.1 Special variables
+log-language+5.1.1 Special variables
+log-verbose+5.1.1 Special variables
+log-very-verbose+5.1.1 Special variables
+time-quantum+5.2.1 Special variables

C
calculate-value-fun5.2.7 Classes
calculate-value-fun5.2.7 Classes
changed-condition5.1.7 Classes
check5.2.7 Classes
child-tasks5.2.7 Classes
children5.1.6 Structures
children5.1.6 Structures
clean-up5.2.7 Classes
code5.1.6 Structures
code5.2.7 Classes
code-replacements5.1.6 Structures
constraints5.2.7 Classes
content5.2.6 Structures

D
description5.2.7 Classes

E
error5.1.5 Conditions

F
failures5.1.5 Conditions
from5.2.6 Structures
function5.1.6 Structures

H
handle-missed-pulses5.2.7 Classes

I
init5.2.7 Classes

L
lock5.1.6 Structures

M
message-queue5.2.7 Classes

N
name5.1.5 Conditions
name5.1.7 Classes
name5.2.7 Classes
name5.2.7 Classes

O
on-update5.1.7 Classes

P
parameters5.1.5 Conditions
parameters5.1.6 Structures
parameters5.2.7 Classes
parent5.1.6 Structures
parent5.1.6 Structures
parent-task5.2.7 Classes
path5.1.6 Structures
path5.1.6 Structures
path5.2.7 Classes
processed-pulse-count5.2.7 Classes
pulse-count5.1.7 Classes

R
reason5.2.6 Structures
recover5.2.7 Classes
reference-pulse-count5.2.7 Classes
result5.2.7 Classes

S
sexp5.1.6 Structures
sexp5.1.6 Structures
Slot, calculate-value-fun5.2.7 Classes
Slot, calculate-value-fun5.2.7 Classes
Slot, changed-condition5.1.7 Classes
Slot, check5.2.7 Classes
Slot, child-tasks5.2.7 Classes
Slot, children5.1.6 Structures
Slot, children5.1.6 Structures
Slot, clean-up5.2.7 Classes
Slot, code5.1.6 Structures
Slot, code5.2.7 Classes
Slot, code-replacements5.1.6 Structures
Slot, constraints5.2.7 Classes
Slot, content5.2.6 Structures
Slot, description5.2.7 Classes
Slot, error5.1.5 Conditions
Slot, failures5.1.5 Conditions
Slot, from5.2.6 Structures
Slot, function5.1.6 Structures
Slot, handle-missed-pulses5.2.7 Classes
Slot, init5.2.7 Classes
Slot, lock5.1.6 Structures
Slot, message-queue5.2.7 Classes
Slot, name5.1.5 Conditions
Slot, name5.1.7 Classes
Slot, name5.2.7 Classes
Slot, name5.2.7 Classes
Slot, on-update5.1.7 Classes
Slot, parameters5.1.5 Conditions
Slot, parameters5.1.6 Structures
Slot, parameters5.2.7 Classes
Slot, parent5.1.6 Structures
Slot, parent5.1.6 Structures
Slot, parent-task5.2.7 Classes
Slot, path5.1.6 Structures
Slot, path5.1.6 Structures
Slot, path5.2.7 Classes
Slot, processed-pulse-count5.2.7 Classes
Slot, pulse-count5.1.7 Classes
Slot, reason5.2.6 Structures
Slot, recover5.2.7 Classes
Slot, reference-pulse-count5.2.7 Classes
Slot, result5.2.7 Classes
Slot, sexp5.1.6 Structures
Slot, sexp5.1.6 Structures
Slot, status5.2.7 Classes
Slot, sync5.2.6 Structures
Slot, tag5.2.6 Structures
Slot, task5.1.6 Structures
Slot, test5.1.7 Classes
Slot, thread5.2.7 Classes
Slot, thread-fun5.2.7 Classes
Slot, to5.2.6 Structures
Slot, value5.1.7 Classes
Slot, value5.2.7 Classes
Slot, value-lock5.1.7 Classes
Slot, values5.2.6 Structures
Special Variable, *active-log-mask*5.2.1 Special variables
Special Variable, *break-on-plan-failures*5.1.1 Special variables
Special Variable, *cltl2-environment-fns*5.2.1 Special variables
Special Variable, *current-parent*5.2.1 Special variables
Special Variable, *current-path*5.1.1 Special variables
Special Variable, *current-path*5.2.1 Special variables
Special Variable, *current-task*5.1.1 Special variables
Special Variable, *current-task-tree-node*5.2.1 Special variables
Special Variable, *debug-on-lisp-errors*5.1.1 Special variables
Special Variable, *log-output*5.1.1 Special variables
Special Variable, *log-right-margin*5.1.1 Special variables
Special Variable, *log-tag-table*5.2.1 Special variables
Special Variable, *peek-value*5.2.1 Special variables
Special Variable, *policies*5.2.1 Special variables
Special Variable, *policy-check-consolidation-duration*5.2.1 Special variables
Special Variable, *save-tasks*5.1.1 Special variables
Special Variable, *scheduling-enabled*5.2.1 Special variables
Special Variable, *shadowed-functions*5.2.1 Special variables
Special Variable, *status-transitions*5.2.1 Special variables
Special Variable, *suspension-handlers*5.2.1 Special variables
Special Variable, *suspension-unwind*5.2.1 Special variables
Special Variable, *synchronous-events*5.2.1 Special variables
Special Variable, *tag-walker-handlers*5.2.1 Special variables
Special Variable, *task-local-variables*5.2.1 Special variables
Special Variable, *task-pprint-verbosity*5.1.1 Special variables
Special Variable, *task-tree*5.1.1 Special variables
Special Variable, *task-tree-print-children*5.2.1 Special variables
Special Variable, *task-tree-print-code*5.2.1 Special variables
Special Variable, *task-tree-print-identity*5.2.1 Special variables
Special Variable, *task-tree-print-path*5.2.1 Special variables
Special Variable, *tasks*5.1.1 Special variables
Special Variable, *top-level-task-trees*5.2.1 Special variables
Special Variable, *zero-real-time*5.2.1 Special variables
Special Variable, *zero-run-time*5.2.1 Special variables
Special Variable, +alive+5.1.1 Special variables
Special Variable, +available-log-tags+5.2.1 Special variables
Special Variable, +dead+5.1.1 Special variables
Special Variable, +done+5.1.1 Special variables
Special Variable, +log-all+5.1.1 Special variables
Special Variable, +log-default+5.1.1 Special variables
Special Variable, +log-language+5.1.1 Special variables
Special Variable, +log-verbose+5.1.1 Special variables
Special Variable, +log-very-verbose+5.1.1 Special variables
Special Variable, +time-quantum+5.2.1 Special variables
Special Variable, timeout-policy5.1.1 Special variables
status5.2.7 Classes
sync5.2.6 Structures

T
tag5.2.6 Structures
task5.1.6 Structures
test5.1.7 Classes
thread5.2.7 Classes
thread-fun5.2.7 Classes
timeout-policy5.1.1 Special variables
to5.2.6 Structures

V
value5.1.7 Classes
value5.2.7 Classes
value-lock5.1.7 Classes
values5.2.6 Structures

Jump to:   *   +  
C   D   E   F   H   I   L   M   N   O   P   R   S   T   V  

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

A.4 Data types

Jump to:   A   C   E   F   L   M   P   S   T   V  
Index Entry Section

A
abstract-task5.2.7 Classes

C
Class, abstract-task5.2.7 Classes
Class, fl-cacheable-value-mixin5.2.7 Classes
Class, fl-net-cacheable-fluent5.2.7 Classes
Class, fl-net-fluent5.2.7 Classes
Class, fl-printable-mixin5.2.7 Classes
Class, fluent5.1.7 Classes
Class, policy5.2.7 Classes
Class, pulse-fluent5.2.7 Classes
Class, task5.1.7 Classes
Class, toplevel-task5.1.7 Classes
Class, value-fluent5.1.7 Classes
code5.1.6 Structures
common-lisp-error-envelope5.1.5 Conditions
composite-failure5.1.5 Conditions
Condition, common-lisp-error-envelope5.1.5 Conditions
Condition, composite-failure5.1.5 Conditions
Condition, plan-failure5.1.5 Conditions
Condition, policy-check-condition-met5.1.5 Conditions
Condition, policy-condition5.1.5 Conditions
Condition, policy-failure5.1.5 Conditions
Condition, policy-init-failed5.1.5 Conditions
Condition, policy-not-found5.1.5 Conditions
Condition, simple-plan-failure5.1.5 Conditions
Condition, time-quantum-exhausted5.2.5 Conditions
continuation5.2.8 Types
cram-language1.1 cram-language
cram-language4.2 cram-language
cram-language-implementation4.3 cram-language-implementation
cram-user4.1 cram-user
cram-walker4.4 cram-walker

E
event5.2.6 Structures
event-designator5.2.8 Types

F
fl-cacheable-value-mixin5.2.7 Classes
fl-net-cacheable-fluent5.2.7 Classes
fl-net-fluent5.2.7 Classes
fl-printable-mixin5.2.7 Classes
fluent5.1.7 Classes

L
list-of5.2.8 Types

M
message5.2.6 Structures

P
Package, cram-language4.2 cram-language
Package, cram-language-implementation4.3 cram-language-implementation
Package, cram-user4.1 cram-user
Package, cram-walker4.4 cram-walker
plan-failure5.1.5 Conditions
plan-tree-node5.1.6 Structures
policy5.2.7 Classes
policy-check-condition-met5.1.5 Conditions
policy-condition5.1.5 Conditions
policy-failure5.1.5 Conditions
policy-init-failed5.1.5 Conditions
policy-not-found5.1.5 Conditions
pulse-fluent5.2.7 Classes

S
simple-plan-failure5.1.5 Conditions
status-indicator5.1.8 Types
Structure, code5.1.6 Structures
Structure, event5.2.6 Structures
Structure, message5.2.6 Structures
Structure, plan-tree-node5.1.6 Structures
Structure, task-tree-node5.1.6 Structures
System, cram-language1.1 cram-language

T
task5.1.7 Classes
task-tree-node5.1.6 Structures
time-quantum-exhausted5.2.5 Conditions
toplevel-task5.1.7 Classes
Type, continuation5.2.8 Types
Type, event-designator5.2.8 Types
Type, list-of5.2.8 Types
Type, status-indicator5.1.8 Types

V
value-fluent5.1.7 Classes

Jump to:   A   C   E   F   L   M   P   S   T   V  

[Top] [Contents] [Index] [ ? ]

Table of Contents


[Top] [Contents] [Index] [ ? ]

About This Document

This document was generated by gaya on February 1, 2016 using texi2html 1.82.

The buttons in the navigation panels have the following meaning:

Button Name Go to From 1.2.3 go to
[ < ] Back Previous section in reading order 1.2.2
[ > ] Forward Next section in reading order 1.2.4
[ << ] FastBack Beginning of this chapter or previous chapter 1
[ Up ] Up Up section 1.2
[ >> ] FastForward Next chapter 2
[Top] Top Cover (top) of document  
[Contents] Contents Table of contents  
[Index] Index Index  
[ ? ] About About (help)  

where the Example assumes that the current position is at Subsubsection One-Two-Three of a document of the following structure:

  • 1. Section One
    • 1.1 Subsection One-One
      • ...
    • 1.2 Subsection One-Two
      • 1.2.1 Subsubsection One-Two-One
      • 1.2.2 Subsubsection One-Two-Two
      • 1.2.3 Subsubsection One-Two-Three     <== Current Position
      • 1.2.4 Subsubsection One-Two-Four
    • 1.3 Subsection One-Three
      • ...
    • 1.4 Subsection One-Four

This document was generated by gaya on February 1, 2016 using texi2html 1.82.