Common Lisp Package: LISA

README:

FUNCTION

Public

CURRENT-ENGINE (&OPTIONAL (ERRORP T))

Returns the currently-active inference engine. Usually only invoked by code running within the context of WITH-INFERENCE-ENGINE.

Undocumented

ACTIVE-RULE

AGENDA (&OPTIONAL (CONTEXT-NAME NIL))

ALLOW-DUPLICATE-FACTS

ASSERT-INSTANCE (INSTANCE)

AUTO-FOCUS-P (RULE)

CLEAR

CONSIDER-TAXONOMY

CONTEXTS

DEPENDENCIES

ENGINE

FACTS

FIND-CONTEXT (RETE DEFINED-NAME &OPTIONAL (ERRORP T))

FIND-FACT-BY-ID (RETE FACT-ID)

FIND-FACT-BY-NAME (RETE FACT-NAME)

FIND-RULE (RETE RULE-NAME)

FOCUS (&REST ARGS)

FOCUS-STACK

HALT

IN-RULE-FIRING-P

INFERENCE-ENGINE (&REST ARGS)

MAKE-INFERENCE-ENGINE

MARK-INSTANCE-AS-CHANGED (INSTANCE &KEY (SLOT-ID NIL))

REFOCUS

RESET

RETRACT-INSTANCE (INSTANCE)

RULE

RULE-DEFAULT-NAME (RULE)

RULES (&OPTIONAL (CONTEXT-NAME NIL))

RUN (&OPTIONAL (CONTEXTS NIL))

SHOW-NETWORK (RETE-NETWORK &OPTIONAL (STRM *TERMINAL-IO*))

UNDEFRULE (RULE-NAME)

UNWATCH (EVENT)

USE-DEFAULT-ENGINE

USE-FANCY-ASSERT

WALK (&OPTIONAL (STEP 1))

WATCH (EVENT)

WATCHING

Private

ADD-INTER-PATTERN-NODES (PATTERNS)

The beta memory nodes and tests

ADD-INTRA-PATTERN-NODES (PATTERNS)

The alpha memory nodes and tests

COPY-BINDING (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

FACT-META-OBJECT-CLASS-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FACT-META-OBJECT-SLOT-LIST (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FACT-META-OBJECT-SUPERCLASSES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

FIND-INSTANCE-OF-FACT (FACT)

Retrieves the CLOS instance associated with a fact. FACT is a FACT instance.

FIND-META-FACT (SYMBOLIC-NAME &OPTIONAL (ERRORP T))

Locates the META-FACT instance associated with SYMBOLIC-NAME. If ERRORP is non-nil, signals an error if no binding is found.

FIND-OR-SET-SLOT-BINDING (VAR SLOT-NAME LOCATION)

Given a variable, either retrieve the binding object for it or create a new one.

FIND-SLOT-BINDING (VAR &KEY (ERRORP T))

Given a variable, retrieve the binding object for it.

FIXUP-RUNTIME-BINDINGS (PATTERNS)

Supports the parsing of embedded DEFRULE forms.

GET-SLOT-VALUES (FACT)

Returns a list of slot name / value pairs for every slot in a fact. FACT is a fact instance.

INITIALIZE-FACT-FROM-INSTANCE (FACT INSTANCE META-DATA)

Initializes a fact associated with a user-created CLOS instance. The fact's slot values are taken from the CLOS instance. FACT is a FACT instance; INSTANCE is the CLOS instance associated with this fact.

INITIALIZE-FACT-FROM-TEMPLATE (FACT SLOTS META-DATA)

Initializes a template-bound FACT. An instance of the FACT's associated class is created and the slots of both are synchronized from the SLOTS list. FACT is a FACT instance; SLOTS is a list of symbol/value pairs.

INITIALIZE-SLOT-VALUE (FACT SLOT-NAME VALUE)

Sets the value of a slot in a fact's slot table. FACT is a FACT instance; SLOT-NAME is a symbol; VALUE is the slot's new value.

INTRA-PATTERN-BINDINGS-P (BINDINGS LOCATION)

Is every variable in a pattern 'local'; i.e. does not reference a binding in a previous pattern?

MAKE-FACT (NAME &REST SLOTS)

The default constructor for class FACT. NAME is the symbolic fact name as used in rules; SLOTS is a list of symbol/value pairs.

MAKE-FACT-FROM-INSTANCE (NAME CLOS-INSTANCE)

A constructor for class FACT that creates an instance bound to a user-defined CLOS instance. NAME is the symbolic fact name; CLOS-INSTANCE is a user-supplied CLOS object.

MAKE-FACT-FROM-TEMPLATE (FACT)

Creates a FACT instance using another FACT instance as a template. Basically a clone operation useful for such things as asserting DEFFACTS.

PARSE-ONE-SLOT (FORM LOCATION)

Parses a single raw pattern slot

PARSE-ONE-SLOT-CONSTRAINT (VAR CONSTRAINT-FORM)

Parses a single slot constraint, eg. (slot-name ?var 1) or (slot-name ?var (equal ?var 1))

PARSED-PATTERN-ADDRESS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSED-PATTERN-BINDING-SET (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSED-PATTERN-CLASS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSED-PATTERN-LOGICAL (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSED-PATTERN-PATTERN-BINDING (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSED-PATTERN-SLOTS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSED-PATTERN-SUB-PATTERNS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSED-PATTERN-TEST-BINDINGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PARSED-PATTERN-TYPE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATTERN-SLOT-CONSTRAINT (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATTERN-SLOT-CONSTRAINT-BINDINGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATTERN-SLOT-INTRA-PATTERN-BINDINGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATTERN-SLOT-NAME (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATTERN-SLOT-NEGATED (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATTERN-SLOT-SLOT-BINDING (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

PATTERN-SLOT-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RULE-ACTIONS-ACTIONS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RULE-ACTIONS-BINDINGS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

RUN-QUERY (QUERY-RULE)

Runs a query (RULE instance), and returns both the value of *QUERY-RESULT* and the query name itself.

SET-SLOT-FROM-INSTANCE (FACT INSTANCE SLOT-NAME)

Assigns to a slot the value from the corresponding slot in the fact's CLOS instance. FACT is a FACT instance; META-FACT is a META-FACT instance; INSTANCE is the fact's CLOS instance; SLOT-NAME is a symbol representing the affected slot.

SET-SLOT-VALUE (FACT SLOT-NAME VALUE)

Assigns a new value to a slot in a fact and its associated CLOS instance. SLOT-NAME is a symbol; VALUE is the new value for the slot.

SLOT-VALUE-IS-ATOM-P (VALUE)

Is the slot value a simple constraint?

SLOT-VALUE-IS-NEGATED-ATOM-P (VALUE)

Is the slot value a simple negated constraint?

SLOT-VALUE-IS-VARIABLE-P (VALUE)

Is the slot value a Lisa variable?

SYNCHRONIZE-WITH-INSTANCE (FACT &OPTIONAL (EFFECTIVE-SLOT NIL))

Makes a fact's slot values and its CLOS instance's slot values match. If a slot identifier is provided then only that slot is synchronized. FACT is a FACT instance; EFFECTIVE-SLOT, if supplied, is a symbol representing the CLOS instance's slot.

Undocumented

%MAKE-BINDING (&KEY ((VARIABLE DUM1) NIL) ((ADDRESS DUM2) NIL) ((SLOT-NAME DUM3) NIL))

ACQUIRE-META-DATA (ACTUAL-NAME)

ACTIVATION-FACT-LIST (ACTIVATION &KEY (DETAILP NIL))

ACTIVE-CONTEXT

ACTIVE-ENGINE

ACTIVE-TOKENS

ADD-AUTOFACT (RETE DEFFACT)

ADD-FACT-TO-NETWORK (RETE-NETWORK FACT)

ADD-JOIN-NODE-TESTS (JOIN-NODE PATTERN)

ADD-LOGICAL-DEPENDENCY (RETE FACT DEPENDENCY-SET)

ADD-RULE-TO-CONTEXT (CONTEXT RULE)

ADD-RULE-TO-NETWORK (RETE RULE PATTERNS)

ADD-TERMINAL-NODE (RULE)

ADD-TOKEN-TO-NETWORK (RETE-NETWORK TOKEN-CTOR)

ADD-TOKEN-TO-RIGHT-MEMORY (JOIN-NODE TOKEN)

ADD-TOKENS-TO-LEFT-MEMORY (JOIN-NODE TOKENS)

ASSERT-AUTOFACTS (RETE)

ATTACH-RULE-NODES (RULE NODES)

BIND-LOGICAL-DEPENDENCIES (FACT)

BIND-RULE-ACTIVATION (RULE ACTIVATION TOKENS)

BINDING-ADDRESS (STRUCTURE)

SETFBINDING-ADDRESS (NEW-VALUE STRUCTURE)

BINDING-SLOT-NAME (STRUCTURE)

SETFBINDING-SLOT-NAME (NEW-VALUE STRUCTURE)

BINDING-VARIABLE (STRUCTURE)

SETFBINDING-VARIABLE (NEW-VALUE STRUCTURE)

BOUND-PATTERN-P (PARSED-PATTERN)

BUILD-LAMBDA-EXPRESSION (FORMS)

CALL-SUCCESSOR (SUCCESSOR &REST ARGS)

CLEAR-ACTIVATION-BINDINGS (RULE)

CLEAR-ACTIVATIONS (CONTEXT)

CLEAR-CONTEXT (CONTEXT)

CLEAR-CONTEXTS (RETE)

CLEAR-ENVIRONMENT-HANDLERS

CLEAR-FOCUS-STACK (RETE)

CLEAR-NODE-TEST-TABLE

CLEAR-SYSTEM-ENVIRONMENT

COLLECT-BINDINGS (FORMS &KEY (ERRORP T))

COLLECT-CONSTRAINT-BINDINGS (CONSTRAINT)

COMPILE-RULE (RULE PATTERNS ACTIONS)

COMPILE-RULE-BEHAVIOR (RULE ACTIONS)

COMPILE-RULE-INTO-NETWORK (RETE-NETWORK PATTERNS RULE)

COMPOUND-PATTERN-P (PARSED-PATTERN)

CONSTRAINED-SLOT-P (PATTERN-SLOT)

CONTEXT-ACTIVATION-LIST (CONTEXT)

CONTEXT-RULE-LIST (CONTEXT)

COPY-FACT-META-OBJECT (INSTANCE)

COPY-NETWORK (ENGINE)

COPY-NODE-TEST-TABLE (SRC)

COPY-PARSED-PATTERN (INSTANCE)

COPY-PATTERN-SLOT (INSTANCE)

COPY-RULE (RULE ENGINE)

COPY-RULE-ACTIONS (INSTANCE)

CREATE-TEMPLATE-CLASS-SLOTS (CLASS-NAME SLOT-LIST)

CURRENT-CONTEXT (RETE)

DEFINE-RULE (NAME BODY &KEY (SALIENCE 0) (CONTEXT NIL) (AUTO-FOCUS NIL) (BELIEF NIL))

DISTRIBUTE-TOKEN (RETE-NETWORK TOKEN)

DUPLICATE-FACT-P (RETE FACT)

ELIGIBLE-P (ACTIVATION)

ENSURE-META-DATA-EXISTS (CLASS-NAME)

ENTER-JOIN-NETWORK-FROM-LEFT (NODE2 TOKENS)

ENTER-JOIN-NETWORK-FROM-RIGHT (NODE2 TOKEN)

EXISTENTIAL-PATTERN-P (PATTERN)

EXPAND-SLOTS (BODY)

EXTRACT-RULE-HEADERS (BODY)

SETFFACT-META-OBJECT-CLASS-NAME (NEW-VALUE INSTANCE)

FACT-META-OBJECT-P (OBJECT)

SETFFACT-META-OBJECT-SLOT-LIST (NEW-VALUE INSTANCE)

SETFFACT-META-OBJECT-SUPERCLASSES (NEW-VALUE INSTANCE)

FACT-SYMBOLIC-ID (FACT)

FIND-ACTIVATION-BINDING (RULE TOKENS)

FIND-ANY-LOGICAL-BOUNDARIES (PATTERNS)

FIND-CONDITIONAL-ELEMENT-PARSER (SYMBOL)

FIND-FACT-USING-INSTANCE (RETE INSTANCE)

FIND-LOGICAL-DEPENDENCIES (RETE DEPENDENCY-SET)

FIND-META-OBJECT (RETE SYMBOLIC-NAME)

FIND-TEST (KEY CONSTRUCTOR)

FORGET-ALL-FACTS (RETE)

FORGET-CLOS-INSTANCE (RETE INSTANCE)

FORGET-CLOS-INSTANCES (RETE)

FORGET-CONTEXT (RETE CONTEXT-NAME)

FORGET-FACT (RETE FACT)

FORGET-TOKEN (MEMORY TOKEN)

GENERIC-PATTERN-P (PATTERN)

GET-ACTIVATION-LIST (RETE &OPTIONAL (CONTEXT-NAME NIL))

GET-CLASS-NAME (META-OBJECT)

GET-FACT-LIST (RETE)

GET-RULE-LIST (RETE &OPTIONAL (CONTEXT-NAME NIL))

GET-SLOT-LIST (META-OBJECT)

GET-SUPERCLASSES (META-OBJECT)

HALT-ENGINE (RETE)

HAS-SUPERCLASS (FACT SYMBOLIC-NAME)

IMPORT-CLASS-SPECIFICATION (CLASS-NAME)

INACTIVE-P (ACTIVATION)

INITIAL-CONTEXT (RETE)

INITIAL-CONTEXT-P (CONTEXT)

INTRA-PATTERN-SLOT-P (PATTERN-SLOT)

LEAF-NODE

LEFT-INPUT (ADDRESS)

LEFT-MEMORY-COUNT (JOIN-NODE)

LOGICAL-BLOCK-MARKER

LOGICAL-BLOCK-P (JOIN-NODE)

LOGICAL-ELEMENT-P (PATTERN)

LOGICAL-PATTERN-P (PARSED-PATTERN)

LOGICAL-RULE-P (RULE)

MAKE-ACTIVATION (RULE TOKENS)

MAKE-BEHAVIOR (FUNCTION BINDINGS)

MAKE-BINDING (VAR ADDRESS SLOT-NAME)

MAKE-BINDING-SET

MAKE-BREADTH-FIRST-STRATEGY

MAKE-CLASS-TEST (CLASS)

MAKE-CONTEXT (NAME &KEY (STRATEGY NIL))

MAKE-CONTEXT-NAME (DEFINED-NAME)

MAKE-DEFAULT-INFERENCE-ENGINE

MAKE-DEFFACTS (NAME FACTS)

MAKE-DEPENDENCY-SET (TOKENS MARKER)

MAKE-DEPTH-FIRST-STRATEGY

MAKE-FACT-META-OBJECT (&KEY ((CLASS-NAME DUM23) NIL) ((SLOT-LIST DUM24) NIL) ((SUPERCLASSES DUM25) NIL))

MAKE-INTER-PATTERN-TEST (SLOT)

MAKE-INTRA-PATTERN-CONSTRAINT-TEST (SLOT)

MAKE-INTRA-PATTERN-NODE (SLOT)

MAKE-INTRA-PATTERN-PREDICATE (FORMS BINDINGS NEGATED-P)

MAKE-INTRA-PATTERN-TEST (SLOT)

MAKE-JOIN-NODE (PATTERN)

MAKE-LEFT-JOIN-CONNECTION (JOIN-NODE NODE)

MAKE-NODE-PAIR (CHILD PARENT)

MAKE-NODE1 (TEST)

MAKE-NODE2

MAKE-NODE2-EXISTS

MAKE-NODE2-NOT

MAKE-NODE2-TEST

MAKE-PARSED-PATTERN (&KEY ((CLASS DUM48) NIL) ((SLOTS DUM49) NIL) ((ADDRESS DUM50) 0) ((PATTERN-BINDING DUM51) NIL) ((TEST-BINDINGS DUM52) NIL) ((BINDING-SET DUM53) NIL) ((LOGICAL DUM54) NIL) ((SUB-PATTERNS DUM55) NIL) ((TYPE DUM56) GENERIC))

MAKE-PATTERN-SLOT (&KEY ((NAME DUM0) NIL) ((VALUE DUM1) NIL) ((SLOT-BINDING DUM2) NIL) ((NEGATED DUM3) NIL) ((INTRA-PATTERN-BINDINGS DUM4) NIL) ((CONSTRAINT DUM5) NIL) ((CONSTRAINT-BINDINGS DUM6) NIL))

MAKE-PREDICATE-TEST (FORMS BINDINGS &OPTIONAL (NEGATED-P NIL))

MAKE-QUERY-ENGINE (SOURCE-RETE)

MAKE-RETE

MAKE-RIGHT-JOIN-CONNECTION (JOIN-NODE NODE)

MAKE-ROOT-NODE (CLASS)

MAKE-RULE (NAME ENGINE PATTERNS ACTIONS &KEY (DOC-STRING NIL) (SALIENCE 0) (CONTEXT (ACTIVE-CONTEXT)) (AUTO-FOCUS NIL) (BELIEF NIL) (COMPILED-BEHAVIOR NIL))

MAKE-RULE-ACTIONS (&KEY ((BINDINGS DUM102) NIL) ((ACTIONS DUM103) NIL))

MAKE-SIMPLE-SLOT-TEST (SLOT)

MAKE-SIMPLE-SLOT-TEST-AUX (SLOT-NAME VALUE NEGATED-P)

MAKE-SUCCESSOR (NODE CONNECTOR)

MAKE-TERMINAL-NODE (RULE)

MARK-AS-LOGICAL-BLOCK (JOIN-NODE MARKER)

MERGE-NETWORKS (FROM-RETE TO-RETE)

MERGE-RULE-INTO-NETWORK (TO-NETWORK PATTERNS RULE &KEY (LOADER NIL))

NEGATED-PATTERN-P (PATTERN)

NEGATED-SLOT-P (PATTERN-SLOT)

NEXT-CONTEXT (RETE)

NEXT-FACT-ID (RETE)

NODE-PAIR-CHILD (NODE-PAIR)

NODE-PAIR-PARENT (NODE-PAIR)

PARSE-AND-INSERT-DEFFACTS (NAME BODY)

PARSE-AND-INSERT-INSTANCE (INSTANCE &KEY (BELIEF NIL))

PARSE-AND-RETRACT-INSTANCE (INSTANCE ENGINE)

PARSE-EXISTS-PATTERN (PATTERN LOCATION)

PARSE-GENERIC-PATTERN (PATTERN LOCATION &OPTIONAL PATTERN-BINDING)

PARSE-NOT-PATTERN (PATTERN LOCATION)

PARSE-RULE-BODY (BODY)

PARSE-TEST-PATTERN (PATTERN LOCATION)

SETFPARSED-PATTERN-ADDRESS (NEW-VALUE INSTANCE)

SETFPARSED-PATTERN-BINDING-SET (NEW-VALUE INSTANCE)

SETFPARSED-PATTERN-CLASS (NEW-VALUE INSTANCE)

SETFPARSED-PATTERN-LOGICAL (NEW-VALUE INSTANCE)

PARSED-PATTERN-P (OBJECT)

SETFPARSED-PATTERN-PATTERN-BINDING (NEW-VALUE INSTANCE)

SETFPARSED-PATTERN-SLOTS (NEW-VALUE INSTANCE)

SETFPARSED-PATTERN-SUB-PATTERNS (NEW-VALUE INSTANCE)

SETFPARSED-PATTERN-TEST-BINDINGS (NEW-VALUE INSTANCE)

PARSED-PATTERN-TEST-FORMS (PATTERN)

SETFPARSED-PATTERN-TYPE (NEW-VALUE INSTANCE)

PASS-TOKEN (NODE TOKEN)

PASS-TOKEN-ON-RIGHT (NODE2 TOKEN)

PASS-TOKENS-ON-LEFT (NODE2 TOKENS)

PATTERN-BINDING-P (BINDING)

SETFPATTERN-SLOT-CONSTRAINT (NEW-VALUE INSTANCE)

SETFPATTERN-SLOT-CONSTRAINT-BINDINGS (NEW-VALUE INSTANCE)

SETFPATTERN-SLOT-INTRA-PATTERN-BINDINGS (NEW-VALUE INSTANCE)

SETFPATTERN-SLOT-NAME (NEW-VALUE INSTANCE)

SETFPATTERN-SLOT-NEGATED (NEW-VALUE INSTANCE)

PATTERN-SLOT-P (OBJECT)

SETFPATTERN-SLOT-SLOT-BINDING (NEW-VALUE INSTANCE)

SETFPATTERN-SLOT-VALUE (NEW-VALUE INSTANCE)

POP-CONTEXT (RETE)

PREPROCESS-LEFT-SIDE (LHS)

PUSH-CONTEXT (RETE CONTEXT)

RECONSTRUCT-FACT (FACT)

RECORD-NODE (NODE PARENT)

REDEFINE-DEFRULE (NAME BODY &KEY (SALIENCE 0) (CONTEXT NIL) (BELIEF NIL) (AUTO-FOCUS NIL))

REDEFINE-DEFTEMPLATE (CLASS-NAME BODY)

REGISTER-CLOS-INSTANCE (RETE INSTANCE FACT)

REGISTER-META-OBJECT (RETE KEY META-OBJECT)

REGISTER-NEW-CONTEXT (RETE CONTEXT)

REMEMBER-FACT (RETE FACT)

REMEMBER-TOKEN (MEMORY TOKEN)

REMOVE-AUTOFACTS (RETE)

REMOVE-FACT-FROM-NETWORK (RETE-NETWORK FACT)

REMOVE-RULE-FROM-NETWORK (RETE-NETWORK RULE)

REMOVE-TOKEN-FROM-RIGHT-MEMORY (JOIN-NODE TOKEN)

REMOVE-TOKENS-FROM-LEFT-MEMORY (JOIN-NODE TOKENS)

REPLICATE-TOKEN (TOKEN &KEY (TOKEN-CLASS NIL))

RESET-FOCUS-STACK (RETE)

RESET-NETWORK (RETE-NETWORK)

RETE-FACT-COUNT (RETE)

RETRIEVE-CONTEXTS (RETE)

RIGHT-INPUT (ADDRESS)

RIGHT-MEMORY-COUNT (JOIN-NODE)

SETFRULE-ACTIONS-ACTIONS (NEW-VALUE INSTANCE)

SETFRULE-ACTIONS-BINDINGS (NEW-VALUE INSTANCE)

RULE-ACTIONS-P (OBJECT)

SCHEDULE-DEPENDENCY-REMOVAL (DEPENDENCY-SET)

SET-INITIAL-STATE (RETE)

SET-LEAF-NODE (NODE ADDRESS)

SET-PATTERN-BINDING (VAR LOCATION)

SHARED-NODE-ALL-SUCCESSORS (SHARED-NODE)

SHARED-NODE-SUCCESSOR-NODES (SHARED-NODE)

SHOW-DEFFACTS (DEFFACT)

SIMPLE-BOUND-SLOT-P (PATTERN-SLOT)

SIMPLE-SLOT-P (PATTERN-SLOT)

SLOT-VALUE-IS-NEGATED-VARIABLE-P (VALUE)

STARTING-CONTEXT (RETE)

SUCCESSOR-CONNECTOR (SUCCESSOR)

SUCCESSOR-NODE (SUCCESSOR)

TEST-PATTERN-P (PATTERN)

TEST-PATTERN-PREDICATE (PATTERN)

TOKEN-DECREMENT-EXISTS-COUNTER (TOKEN)

TOKEN-DECREMENT-NOT-COUNTER (TOKEN)

TOKEN-FACT-COUNT (TOKEN)

TOKEN-FIND-FACT (TOKEN ADDRESS)

TOKEN-INCREMENT-EXISTS-COUNTER (TOKEN)

TOKEN-INCREMENT-NOT-COUNTER (TOKEN)

TOKEN-MAKE-FACT-LIST (TOKEN &KEY (DETAILP T) (DEBUGP NIL))

TOKEN-NEGATED-P (TOKEN)

TOKEN-POP-FACT (TOKEN)

TOKEN-PUSH-FACT (TOKEN FACT)

TOKEN-TOP-FACT (TOKEN)

UNBIND-RULE-ACTIVATION (RULE TOKENS)

UNWATCH-EVENT (EVENT)

VARIABLE-P (OBJ)

WATCH-ACTIVATION-DETAIL (ACTIVATION DIRECTION)

WATCH-ASSERT (FACT)

WATCH-DISABLE-ACTIVATION (ACTIVATION)

WATCH-ENABLE-ACTIVATION (ACTIVATION)

WATCH-EVENT (EVENT)

WATCH-FACT-DETAIL (FACT DIRECTION)

WATCH-RETRACT (FACT)

WATCH-RULE-FIRING (ACTIVATION)

WATCHES

MACRO

Public

WITH-INFERENCE-ENGINE ((ENGINE) &BODY BODY)

Evaluates BODY within the context of the inference engine ENGINE. This macro is MP-safe.

WITH-SIMPLE-QUERY ((VAR VALUE) QUERY &BODY BODY)

For each variable/instance pair in a query result, invoke BODY with VAR bound to the query variable and VALUE bound to the instance.

Undocumented

ASSERT ((NAME &BODY BODY) &KEY (BELIEF NIL))

DEFCONTEXT (CONTEXT-NAME &OPTIONAL (STRATEGY NIL))

DEFFACTS (NAME (&KEY &ALLOW-OTHER-KEYS) &BODY BODY)

DEFRULE (NAME (&KEY (SALIENCE 0) (CONTEXT NIL) (BELIEF NIL) (AUTO-FOCUS NIL)) &BODY BODY)

DEFTEMPLATE (NAME (&KEY) &BODY BODY)

MODIFY (FACT &BODY BODY)

RETRIEVE ((&REST VARLIST) &BODY BODY)

UNDEFCONTEXT (CONTEXT-NAME)

Private

COMPILE-FUNCTION (FORMS)

Build and compile an anonymous function, using the body provided in FORMS.

DEFQUERY (NAME &BODY BODY)

Defines a new query identified by the symbol NAME.

Undocumented

CONSTRAINTP (CONSTRAINT)

DEFINE-LISA-LISP

ENSURE-FACT-IS-UNIQUE (RETE FACT)

LITERALP (SYM)

MULTIFIELDP (VAL)

QUOTABLEP (OBJ)

REGISTER-CLEAR-HANDLER (TAG FUNC)

SLOT-VALUEP (VAL)

STARTS-WITH-? (SYM)

TRACE-ASSERT (FACT)

TRACE-DISABLE-ACTIVATION (ACTIVATION)

TRACE-ENABLE-ACTIVATION (ACTIVATION)

TRACE-FIRING (ACTIVATION)

TRACE-RETRACT (FACT)

VARIABLEP (SYM)

WITH-AUTO-NOTIFY ((VAR INSTANCE) &BODY BODY)

WITH-CONTEXT (CONTEXT &BODY BODY)

WITH-RULE-COMPONENTS (((DOC-STRING LHS RHS) RULE-FORM) &BODY BODY)

WITH-RULE-NAME-PARTS ((CONTEXT SHORT-NAME LONG-NAME) SYMBOLIC-NAME &BODY BODY)

WITH-SLOT-COMPONENTS ((SLOT-NAME SLOT-VALUE CONSTRAINT) FORM &BODY BODY)

WITH-TRUTH-MAINTENANCE ((RETE) &BODY BODY)

WITH-UNIQUE-FACT ((RETE FACT) &BODY BODY)

GENERIC-FUNCTION

Public

Undocumented

RETRACT (FACT-OBJECT)

SLOT-VALUE-OF-INSTANCE (OBJECT SLOT-NAME)

SETFSLOT-VALUE-OF-INSTANCE (NEW-VALUE OBJECT SLOT-NAME)

Private

Undocumented

ACCEPT-TOKEN (SELF TOKENS)

ACCEPT-TOKEN-FROM-RIGHT (SELF LEFT-TOKENS)

ACCEPT-TOKENS-FROM-LEFT (SELF LEFT-TOKENS)

ACTIVATION-PRIORITY (SELF)

ADD-ACTIVATION (STRATEGY ACTIVATION)

ADD-NODE-SET (PARENT NODE &OPTIONAL (COUNT-P))

ADD-SUCCESSOR (SELF NEW-NODE CONNECTOR)

ADJUST-BELIEF (RETE FACT BELIEF-FACTOR)

ASSERT-FACT (SELF FACT &KEY BELIEF)

ASSERT-FACT-AUX (SELF FACT)

CLASS-MATCHES-P (INSTANCE FACT CLASS)

CLEAR-MEMORIES (SELF)

CLS-NAME (CONDITION)

COMBINE-TOKENS (LEFT-TOKENS RIGHT-TOKEN)

CONFLICT-SET (SELF)

DECREMENT-USE-COUNT (SELF)

DISABLE-ACTIVATION (SELF ACTIVATION)

DUPLICATE-FACT-EXISTING-FACT (CONDITION)

EQUALS (A B)

FIND-ACTIVATION (STRATEGY RULE TOKEN)

FIND-ALL-ACTIVATIONS (STRATEGY RULE)

FIND-EXISTING-SUCCESSOR (PARENT NODE)

FIND-RULE-IN-CONTEXT (SELF RULE-NAME)

FIRE-ACTIVATION (SELF)

FIRE-RULE (SELF TOKENS)

FORGET-RULE (SELF RULE-NAME)

GET-ALL-ACTIVATIONS (SELF)

GET-NEXT-ACTIVATION (SELF)

GET-SLOT-VALUE (SELF SLOT-NAME)

HASH-KEY (SELF)

INCREMENT-USE-COUNT (SELF)

INSERT-ACTIVATION (SELF ACTIVATION)

JOIN-NODE-ADD-TEST (SELF TEST)

LIST-ACTIVATIONS (STRATEGY)

LOCATION (CONDITION)

LOOKUP-ACTIVATION (SELF RULE TOKENS)

LOOKUP-ACTIVATIONS (SELF RULE)

MAKE-ADD-TOKEN (FACT)

MAKE-REMOVE-TOKEN (FACT)

MAKE-RESET-TOKEN (FACT)

MAKE-RETE-NETWORK (&REST ARGS &ALLOW-OTHER-KEYS)

MARK-CLOS-INSTANCE-AS-CHANGED (SELF INSTANCE &OPTIONAL (SLOT-ID))

MODIFY-FACT (SELF FACT &REST SLOT-CHANGES)

NEXT-ACTIVATION (STRATEGY)

NODE-REFERENCED-P (SELF)

NODE-USE-COUNT (SELF)

PASS-TOKEN-TO-SUCCESSORS (SELF TOKEN)

PASS-TOKENS-TO-SUCCESSOR (SELF LEFT-TOKENS)

REMOVE-ACTIVATIONS (STRATEGY)

REMOVE-NODE-FROM-PARENT (SELF PARENT CHILD)

REMOVE-RULE-FROM-CONTEXT (SELF RULE-NAME)

REMOVE-SUCCESSOR (SELF SUCCESSOR-NODE)

RESET-ACTIVATIONS (SELF)

RESET-ENGINE (SELF)

RETRACT-FACT (SELF FACT)

RUN-ENGINE (SELF &OPTIONAL (STEP))

SLOT-NAME (CONDITION)

TEST-AGAINST-LEFT-MEMORY (SELF RIGHT-TOKEN)

TEST-AGAINST-RIGHT-MEMORY (SELF LEFT-TOKENS)

TEST-TOKENS (SELF LEFT-TOKENS RIGHT-TOKEN)

TEXT (CONDITION)

SLOT-ACCESSOR

Public

Undocumented

CONTEXT-NAME (OBJECT)

FACT-ID (OBJECT)

SETFFACT-ID (NEW-VALUE OBJECT)

FACT-NAME (OBJECT)

RETE-NETWORK (OBJECT)

RULE-COMMENT (OBJECT)

RULE-CONTEXT (OBJECT)

RULE-NAME (CONDITION)

RULE-SALIENCE (OBJECT)

RULE-SHORT-NAME (OBJECT)

Private

Undocumented

ACTIVATION-ELIGIBLE (OBJECT)

SETFACTIVATION-ELIGIBLE (NEW-VALUE OBJECT)

ACTIVATION-RULE (OBJECT)

ACTIVATION-TIMESTAMP (OBJECT)

ACTIVATION-TOKENS (OBJECT)

BELIEF-FACTOR (OBJECT)

SETFBELIEF-FACTOR (NEW-VALUE OBJECT)

CONTEXT-RULES (OBJECT)

CONTEXT-STRATEGY (OBJECT)

DEFFACTS-FACT-LIST (OBJECT)

DEFFACTS-NAME (OBJECT)

FACT-CLOS-INSTANCE (OBJECT)

FACT-ID-TABLE (OBJECT)

SETFFACT-ID-TABLE (NEW-VALUE OBJECT)

FACT-META-DATA (OBJECT)

FACT-SHADOWSP (OBJECT)

FACT-SLOT-TABLE (OBJECT)

HEAP (OBJECT)

JOIN-NODE-LEFT-MEMORY (OBJECT)

JOIN-NODE-LOGICAL-BLOCK (OBJECT)

JOIN-NODE-RIGHT-MEMORY (OBJECT)

JOIN-NODE-SUCCESSOR (OBJECT)

SETFJOIN-NODE-SUCCESSOR (NEW-VALUE OBJECT)

JOIN-NODE-TESTS (OBJECT)

SETFJOIN-NODE-TESTS (NEW-VALUE OBJECT)

NODE-TEST-CACHE (OBJECT)

NODE1-TEST (OBJECT)

RETE-AUTOFACTS (OBJECT)

SETFRETE-AUTOFACTS (NEW-VALUE OBJECT)

RETE-CONTEXTS (OBJECT)

RETE-DEPENDENCY-TABLE (OBJECT)

SETFRETE-DEPENDENCY-TABLE (NEW-VALUE OBJECT)

RETE-FACT-TABLE (OBJECT)

SETFRETE-FACT-TABLE (NEW-VALUE OBJECT)

RETE-FIRING-COUNT (OBJECT)

SETFRETE-FIRING-COUNT (NEW-VALUE OBJECT)

RETE-FOCUS-STACK (OBJECT)

SETFRETE-FOCUS-STACK (NEW-VALUE OBJECT)

RETE-HALTED (OBJECT)

SETFRETE-HALTED (NEW-VALUE OBJECT)

RETE-INSTANCE-TABLE (OBJECT)

RETE-META-DATA (OBJECT)

RETE-NEXT-FACT-ID (OBJECT)

SETFRETE-NEXT-FACT-ID (NEW-VALUE OBJECT)

RETE-ROOTS (OBJECT)

RULE-ACTIONS (OBJECT)

RULE-ACTIVATIONS (OBJECT)

SETFRULE-ACTIVATIONS (NEW-VALUE OBJECT)

RULE-ACTIVE-DEPENDENCIES (OBJECT)

RULE-AUTO-FOCUS (OBJECT)

RULE-BEHAVIOR (OBJECT)

SETFRULE-BEHAVIOR (NEW-VALUE OBJECT)

RULE-BINDING-SET (OBJECT)

RULE-ENGINE (OBJECT)

RULE-LOGICAL-MARKER (OBJECT)

RULE-NODE-LIST (OBJECT)

RULE-PATTERNS (OBJECT)

SHARED-NODE-REFCNT (OBJECT)

SETFSHARED-NODE-REFCNT (NEW-VALUE OBJECT)

SHARED-NODE-SUCCESSORS (OBJECT)

TERMINAL-NODE-RULE (OBJECT)

TOKEN-CONTENTS (OBJECT)

TOKEN-EXISTS-COUNTER (OBJECT)

SETFTOKEN-EXISTS-COUNTER (NEW-VALUE OBJECT)

TOKEN-FACTS (OBJECT)

SETFTOKEN-FACTS (NEW-VALUE OBJECT)

TOKEN-HASH-CODE (OBJECT)

SETFTOKEN-HASH-CODE (NEW-VALUE OBJECT)

TOKEN-NOT-COUNTER (OBJECT)

SETFTOKEN-NOT-COUNTER (NEW-VALUE OBJECT)

VARIABLE

Private

*QUERY-RESULT*

Holds the results of query firings.

Undocumented

*ACTIVATION-TIMESTAMP*

*ACTIVE-CONTEXT*

*ACTIVE-ENGINE*

*ACTIVE-RULE*

*ACTIVE-TOKENS*

*ALLOW-DUPLICATE-FACTS*

*ASSERT-FACT*

*CLEAR-HANDLERS*

*CONDITIONAL-ELEMENTS-TABLE*

*CONSIDER-TAXONOMY-WHEN-REASONING*

*DISABLE-ACTIVATION*

*ENABLE-ACTIVATION*

*FIRE-RULE*

*IN-LOGICAL-PATTERN-P*

*LEAF-NODES*

*NODE-SET*

*RETRACT-FACT*

*ROOT-NODES*

*RULE-SPECIFIC-NODES*

*SPECIAL-INITIAL-ELEMENTS*

*USE-FANCY-ASSERT*

*WATCHES*

CLASS

Public

ACTIVATION

Represents a rule activation.

DEFFACTS (NAME (&KEY &ALLOW-OTHER-KEYS) &BODY BODY)

This class represents 'autoloaded' facts that are asserted automatically as part of an inference engine reset.

FACT

This class represents all facts in the knowledge base.

RULE

Represents production rules after they've been analysed by the language parser.

Undocumented

CONTEXT

INITIAL-FACT

RETE

RETE-NETWORK (OBJECT)

TOKEN

Private

BREADTH-FIRST-STRATEGY

A breadth-first conflict resolution strategy.

BUILTIN-STRATEGY

A base class for all LISA builtin conflict resolution strategies.

DEPTH-FIRST-STRATEGY

A depth-first conflict resolution strategy.

PARSED-PATTERN

Represents the canonical form of a pattern analysed by the DEFRULE parser.

PATTERN-SLOT

Represents the canonical form of a slot within a pattern analysed by the DEFRULE parser.

STRATEGY

Serves as the base class for all classes implementing conflict resolution strategies.

Undocumented

ADD-TOKEN

FACT-META-OBJECT

INFERENCE-ENGINE-OBJECT

JOIN-NODE

NODE1

NODE2

NODE2-EXISTS

NODE2-NOT

NODE2-TEST

PRIORITY-QUEUE-MIXIN

QUERY-FACT

REMOVE-TOKEN

RESET-TOKEN

RULE-ACTIONS (OBJECT)

SHARED-NODE

TERMINAL-NODE

CONDITION

Public

Undocumented

DUPLICATE-FACT

Private

Undocumented

CLASS-PARSING-ERROR

PARSING-ERROR

RULE-PARSING-ERROR

SLOT-PARSING-ERROR

CONSTANT

Private

Undocumented

*RULE-SEPARATOR*