The speechless Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The speechless Reference Manual

This is the speechless Reference Manual, version 1.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 06:12:49 2022 GMT+0.

Table of Contents


1 Introduction

# About Speechless
This is a system implementing an advanced dialogue system that is capable of complex dialogue flow including choice trees and conditional branching. Speechless was first developed for the "Kandria"(link https://kandria.com) game, and has since been separated and made public in the hopes that it may find use elsewhere or inspire other developers to build similar systems.

Speechless is based on the "Markless"(link https://shirakumo.github.io/markless) document standard for its syntax and makes use of Markless' ability to be extended to add additional constructs useful for dialogue systems.

Speechless can compile dialogue from its base textual form into an efficient instruction set, which is then executed when the game is run. Execution of the dialogue is completely engine-agnostic, and only requires some "simple integration"(#writing a client) with a client protocol to run.

Thanks to Markless' extensibility, Speechless can also be further extended to include additional syntax and constructs that may be useful for your particular game.

## User Manual
This section covers the syntax and behaviour of Speechless dialogue. With any luck, after reading this you'll be able to write your own dialogue in Speechless. 

### Speech
Let's jump in with the classic:

:: markless
| Hello world!
::

This piece should just show the text ``Hello world!``. However, there's a bit of a problem: we don't know who's saying this! In order to annotate which character is speaking, we can add a source line:

:: markless
~ Hans
| Hello world!
::

Now we know that this is a character called ``Hans`` speaking the line. What the character's name should actually be depends on how your game engine organises things. For now we're assuming that we can just use the character's own name.

Often you'll also want to inform the system about how the character is feeling to accentuate the text and give it some more gravitas.

:: markless
~ Hans
| (:excited)Hello world!
::

Depending on your game this emote might correspond to the character changing their expression on screen as the text scrolls. For further flavour we can also use Markless' markup to change the text style.

:: markless
~ Hans
| (:excited)//Hello// **world**!
::

In Markless itself this would mean italic and bold, respectively, though the actual interpretation of it is up to the current game engine, and might have different effects like text shaking, wobbling, and so forth. Important to know here is only that there are several ways to markup text out of the box:

- ``**bold**``
- ``//italic//``
- ``__underline__``
- ``<-strikethrough->``
- And more, see the "Markless documentation"(https://shirakumo.github.io/markless).

Markup can also be nested, ``//like **so**!//``.

Finally, you can accentuate text by inserting pauses with en (``--``) and em (``---``) dashes. This can be quite useful to control the pacing of the text scroll to be more natural.

:: markless
~ Hans
| Helloooo-- world!
::

After a line of text, Speechless will insert a prompt for the player to continue so that there's no risk of the text scrolling by too fast for the player to read it.

:: markless
~ Hans
| Hey
| (:concerned)Are you still with me?
| (:frantic)Hang in there, Chris!
::

That should cover things for speech. Let's move on to more advanced stuff.

### Player Choice
Speechless allows you to make branching dialogue by presenting the player with a set of options. These options can even be gated behind checks. A basic choice is presented through a simple unordered list.

:: markless
~ Hans
| Are you getting this?
- Yes
- No
::

This will show the options ``Yes`` and ``No`` to the user, though no matter what they end up picking, neither of them actually do anything. Let's change that.

:: markless
~ Hans
| Are you getting this?
- Yes
  | Nice, well done!
- No
  | Sorry to hear that. What are you having trouble with?
::

The consequences of a choice follow after the choice's text, within the same list item. You can insert as many things as you want into the same list item as long as the item actually continues (no empty lines).

:: markless
~ Hans
| Are you getting this?
- Yes
  ~ Hannah
  | See, I told you, they'd get it no problem!
- No
  ~ Hannah
  | Ah what, really? Come on!
::

You can insert as many choices as you want, though obviously for game design reasons it's probably not wise to present too many at once.

Choices can also be nested to create dialogue trees.

! label tree
:: markless
~ Hans
| Are you getting this?
- Yes
  | Alright, are you ready for the next lesson?
  - Let's go
    | Wow, you're really blazing through this!
  - No, not quite yet
    | Ok, let's continue another time then
- No
  | What's bothering you?
  - I just need more time
    | Ok, no problem, let's try again another time then
  - I'm hopelessly confused
    | Give yourself some time then, come back to it later!
  - I hate this
    | Sorry to hear that. You don't have to continue if you don't want to!
::

As you might imagine, this can quickly get hard to see through, though. One way to make it a bit easier to read is to destructure the choices with labels and jumps.

### Labels and Jumps
In order to control flow and to help you section your dialogue, Speechless includes constructs to give points within the dialogue a name and to jump to such a name from another point in the dialogue. Creating a label is simple enough:

:: markless
> start
| How are ya?
::

This associates the label ``start`` with the speech ``How are ya?``, meaning once you jump to ``start`` it will start showing the text. Jumping to a label is also simple enough. For fun, let's recreate the classic "BASIC loop"(https://betanews.com/2014/05/01/10-print-hello-50-years-of-basic-20-goto-10/).

:: markless
> 10
| HELLO WORLD!
< 10
::

This will infinitely repeat, creating a truly never ending experience. All jokes aside, jumps and labels can come in handy when writing branching dialogue, since it allows us to create "empty choices" and to flatten the tree.

:: markless
> start
| Are you sure you want to give me a million dollars?
- Yes!
  | Wow, thanks so much, you're so generous!
- No
  | I implore you to reconsider.
  < start
::

This will cause the dialogue to keep looping back to the question if the player chooses the ``No`` option, effectively creating an empty choice as found in some games.

Similarly we can flatten choice trees by sectioning consequences out to labels. Transforming the "above choice"(#tree) we get this:

:: markless
~ Hans
| Are you getting this?
- Yes
  < Yes
- No
  < No

> Yes
| Alright, are you ready for the next lesson?
- Let's go
  | Wow, you're really blazing through this!
- No, not quite yet
  | Ok, let's continue another time then

> No
| What's bothering you?
- I just need more time
  | Ok, no problem, let's try again another time then
- I'm hopelessly confused
  | Give yourself some time then, come back to it later!
- I hate this
  | Sorry to hear that. You don't have to continue if you don't want to!
::

There's one small problem with this though, namely that once the ``Yes`` tree completes, it will continue execution and also do the ``No`` tree. This is pretty much never what we want, so instead we should be using sections to do this, which is another way of labelling:

:: markless
~ Hans
| Are you getting this?
- Yes
  < Yes
- No
  < No

# Yes
| Alright, are you ready for the next lesson?
- Let's go
  | Wow, you're really blazing through this!
- No, not quite yet
  | Ok, let's continue another time then

# No
| What's bothering you?
- I just need more time
  | Ok, no problem, let's try again another time then
- I'm hopelessly confused
  | Give yourself some time then, come back to it later!
- I hate this
  | Sorry to hear that. You don't have to continue if you don't want to!
::

Sections force an end of dialogue, so that if execution should hit upon a section header without it just jumping there, it'll automatically end. If we now want to go back to the main execution flow after either choice completes however, we can use a normal label again:

:: markless
~ Hans
| Are you getting this?
- Yes
  < Yes
- No
  < No
> Main
| Bye!

# Yes
| Alright, are you ready for the next lesson?
- Let's go
  | Wow, you're really blazing through this!
- No, not quite yet
  | Ok, let's continue another time then
< Main

# No
| What's bothering you?
- I just need more time
  | Ok, no problem, let's try again another time then
- I'm hopelessly confused
  | Give yourself some time then, come back to it later!
- I hate this
  | Sorry to hear that. You don't have to continue if you don't want to!
< Main
::

Note that all labels -- regardless of the syntax used to define them -- are global to a piece of dialogue though, so you can't use the same name twice.

Lets move on to another advanced topic, conditions and branching.

### Conditions
Sometimes dialogue needs to react to game state. Choices might need to be hidden, or a character might need to react in a different way depending on what the player has done so far. Speechless offers a couple of ways to do this. The most basic way is the conditional block.

:: markless
? have-water
| ~ Fireman
| | Quick, use the water to put out the fire!
::

In this dialogue, the Fireman will shout ``Quick, use the water to put out the fire!`` if ``have-water`` is true.

``have-water`` here is a placeholder for some kind of Lisp expression. This expression can be arbitrary Lisp code, and it is up to the game engine to control how that code is evaluated. Often the engine will add a variety of support functions and variables to help manage and check various parts of the game's state. We won't go into Lisp syntax and semantics here, you'll want to consult another tutorial for that as it is a very complex topic.

The above conditional block can also include additional branches, and simply executes the first branch for which the test passes:

:: markless
? have-water
| ~ Fireman
| | Quick, use the water to put out the fire!
|? have-hose
| ~ Fireman
| | Blast it!
|?
| ~ Fireman
| | Someone get us some water, stat!
::

A branch with no condition always passes. The conditional block is thus similar to ``if/else if/else`` chains, or ``cond`` in Lisp.

Often however the full conditional block is too lengthy and bulky. For quick conditional dialogue pieces, the inline branch can also be used:

:: markless
~ Fireman
| [have-water Quick, use the water! | Get some water stat!]
::

Both forms of branching can be used to restrict choices behind a check as well.

:: markless
- [have-water Here, let me help!|]
  ~ Fireman
  | Then don't just stand there!
- I'll go get some water!
  ~ Fireman
  | And make it quick!
::

In this case if the ``have-water`` check fails, the option would not be available to the player.

One thing to watch out for when using conditional blocks to restrict choices is that since the block and speech both use the same syntax, you have to make sure to interrupt the conditional block before you can continue with speech. You can do this with another block like a source, or by using a clear (not empty!) line:

:: markless
- ? have-water
  | Here, let me help!
  
  | Then don't just stand there!
::

Note the two spaces on the seemingly empty line to continue the list item.

Both forms of conditionals can be nested arbitrarily, too, though you cannot nest a conditional block inside an inline conditional.

The inline conditional can also be used for a shorthand of a random text:

:: markless
| [? Hey|Hey there|Hello!|Heya]
::

When this dialogue is run, it'll randomly pick one of ``Hey``, ``Hey there``, ``Hello!``, and ``Heya`` and display that.

### Evaluation
Finally, often it's desired to cause changes to game state, or include dialogue particular to game state. Since integrating with game state is typically extremely specific to the game and engine being made at the time, Speechless just includes basic constructs to splice a Lisp value into text, and to evaluate arbitrary Lisp code.

While not ideal from a user perspective as it forces you to learn some Lisp, typically engine coders can provide enough shorthand functions for the dialogue system such that dialogue authors don't have to learn a lot of Lisp to get going.

The placeholder ``{form}`` evaluates the form and writes whatever the form returns as its value to text. This can be handy when you need to involve dynamic stuff like nicknames in a classic RPG:

:: markless
| Hi, my name is {(name character)}!
::

Dialogue also often needs to trigger changes in game state, be that in response to completing a dialogue or in response to a choice the user made. For this the ``eval`` instruction can be used.

:: markless
! eval (spawn 'dog)
::

Again, which functions and variables are available depends on the game and engine being built. Please consult your internal documentation on that.

### Misc
Markless includes a few additional constructs that can be helpful with Speechless, too. For instance, comments can be used to write notes for yourself about what a piece of dialogue is meant to do or in which context it occurs.

:: markless
; This is a note to myself and won't have any effect!
::

You can also emit warnings or even errors if there's a problem in the dialogue and you would like to make sure the game can't proceed yet.

:: markless
! error This isn't ready yet!
::

Again, consult the "Markless documentation"(http://shirakumo.github.io/markless/) for a complete outline of the Markless syntax and semantics.

This should cover everything that's supported by Speechless out of the box. Your engine may add extra constructs and support syntax. To see how to do that, please "read on"(#extension).

## Writing a Client
The dialogue system in Speechless is game engine agnostic. This means that you get full control over the user input and display of the dialogue.

Before we can get started on implementing the client, you should know that Speechless is a compiled language. Thus you need to compile the dialogue to an ``assembly`` before it can be executed. To do so, you can simply call ``compile*``. If you would like to customise the lexical environment for forms used in the dialogue however, you should also create a subclass of ``assembly``, implement a method on ``wrap-lexenv``, and then pass an instance of that assembly to ``compile*``. All Lisp forms within the dialogue are also compiled down to functions, so no run-time ``eval`` or compilation occurs when dialogue is actually executed.

:: common lisp
(defclass assembly (dialogue:assembly) ())

(defmethod dialogue:wrap-lexenv (form (_ assembly))
  `(let ((example T))
     ,form))

(defvar *dialogue* (dialogue:compile* "| Hey there!" 'assembly))
::

Once armed with a compiled ``assembly``, you'll want to execute it. To do so you need a ``vm`` instance, and prepare it with ``run``.

:: common lisp
(defvar *vm* (make-instance 'dialogue:vm))
(dialogue:run *dialogue* *vm*)
::

From there on executing dialogue is a matter of repeatedly calling ``resume`` on the VM and performing whatever ``request`` it returns. To do so you'll want to implement a loop similar to this:

:: common lisp
(loop with ip = 0
      for request = (dialogue:resume *vm* ip)
      until (typep request 'dialogue:end-request)
      do (setf ip (handle request)))
::

Though typically you won't be able to use a synchronous loop like this, since the game will need to render and perform other functions like scrolling the text or waiting for user input before resuming the VM.

In any case, the interactions with the VM are simple -- all you need to keep track of is the next instruction pointer to resume with once you're ready to continue execution. Each ``request`` that the VM returns to you will have one -- or in the case of a user choice several -- target instruction pointers to resume with.

If you still need help implementing it, you can check the "Kandria sources"(https://gitea.tymoon.eu/shinmera/kandria/src/branch/master/ui/textbox.lisp#L95) for a fully featured reference implementation.

If you have trouble with dialogue execution and it doesn't behave as you expect, you can try debugging it by passing the assembly to ``disassemble``. This behaves similar to ``cl:disassemble`` and will print out the assembled instructions in their execution sequence.

## Extension
If desired you can add your own syntax constructs to Speechless. To do so you will need to implement a corresponding syntax tree ``component``, a ``directive`` to parse it, an ``instruction`` to execute it, and possibly a ``request`` to expose whatever client functionality you need.

Before adding new syntax, you should familiarise yourself with the Markless standard terminology, and the "cl-markless implementation"(https://shirakumo.github.io/cl-markless). As an example here though we'll assume you want to implement a new "singular line directive" -- something that has a prefix at the beginning of the line and consumes the whole line, like ``~ ``.

We're going to add some syntax to let you spawn some objects in the game. The syntax should look like this:

:: markless
+ enemy :at 'camp
::

First we need to define a ``component`` class corresponding to our new syntax.

:: common lisp
(defclass spawn (org.shirakumo.markless.components:block-component)
  ((arguments :initarg :argmunts :accessor arguments)))
::

Next we need to define a directive that will parse the syntax to the new component type.

:: common lisp
(defclass spawn-directive (org.shirakumo.markless:singular-line-directive) ())

(defmethod org.shirakumo.markless:prefix ((_ spawn-directive))
  #("+" " "))

(defmethod org.shirakumo.markless:begin ((_ spawn-directive) parser line cursor)
  (let ((arguments (loop while (< cursor (length line))
                         collect (multiple-value-bind (value next) (read-from-string line NIL NIL :start cursor)
                                   (setf cursor next)
                                   value)))
        (component (make-instance 'spawn :arguments arguments)))
    (org.shirakumo.markless:commit _ component parser))
  (length line))
::

Next we need to add our directive onto the list of used directives for the dialogue.

:: common lisp
(pushnew 'spawn-directive org.shirakumo.fraf.speechless.syntax:*default-directives*)
::

Now that that's done we can already parse our new syntax!

:: common lisp
(dialogue:parse "+ test")
::

To compile this we could re-use an existing instruction like ``eval``, but just to be complete we'll define separate instruction types and requests.

:: common lisp
(defclass spawn-instruction (dialogue:instruction)
  ((type :initarg :type :accessor type)
   (argfun :initarg :argfun :accessor argfun)))

(dialogue:define-simple-walker spawn spawn-instruction
  :type (first (arguments spawn))
  :argfun (compile NIL `(lambda () ,(dialogue:wrap-lexenv `(list ,@(rest (arguments spawn))) dialogue:assembly))))
::

Also see ``walk`` and ``emit`` in case you ever have more complex needs for compilation. The reason we compile the rest of the arguments here is that we probably want them to be evaluated, rather than literals.

Now we can compile our dialogue to an assembly:

:: common lisp
(dialogue:compile* "+ test")
::

Finally we need to define the execution of our instruction. Again, a new request is likely not necessary here, but we'll do it just for completeness of the tutorial.

:: common lisp
(defclass spawn-request (dialogue:target-request)
  ((type :initarg :type :accessor type)
   (initargs :initarg :initargs :accessor initargs)))

(defmethod dialogue:execute ((instruction spawn-instruction) (vm dialogue:vm) ip)
  (dialogue:suspend vm (make-instance 'spawn-request :type (type instruction) :initargs (funcall (argfun instruction)) :target (1+ ip))))
::

When we execute the instruction we call the argument function to evaluate the arguments to a list. We then return that list fully prepared to the client, so that all they need to do now is create the new instance as requested and spawn it into the game.

We also include a ``target`` instruction pointer, which usually is just the instruction immediately following.

And that's it. Now you can fully compile and execute your new dialogue syntax!

For more advanced instruction compilation, optimisation passes, and other stuff, please see the source code.


2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 speechless

A dialogue system language implementation.

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://shirakumo.github.io/speechless

Source Control

(GIT https://github.com/shirakumo/speechless.git)

Bug Tracker

https://github.com/shirakumo/speechless/issues

License

zlib

Version

1.0.0

Dependencies
  • cl-markless (system).
  • documentation-utils (system).
Source

speechless.asd.

Child Components

3 Files

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


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.1 speechless/speechless.asd

Source

speechless.asd.

Parent Component

speechless (system).

ASDF Systems

speechless.


3.1.3 speechless/components.lisp

Dependency

package.lisp (file).

Source

speechless.asd.

Parent Component

speechless (system).

Public Interface
Internals

3.1.4 speechless/syntax.lisp

Dependency

components.lisp (file).

Source

speechless.asd.

Parent Component

speechless (system).

Public Interface
Internals

3.1.5 speechless/instructions.lisp

Dependency

syntax.lisp (file).

Source

speechless.asd.

Parent Component

speechless (system).

Public Interface
Internals

3.1.6 speechless/compiler.lisp

Dependency

instructions.lisp (file).

Source

speechless.asd.

Parent Component

speechless (system).

Public Interface
Internals

3.1.7 speechless/optimizers.lisp

Dependency

compiler.lisp (file).

Source

speechless.asd.

Parent Component

speechless (system).

Public Interface
Internals

3.1.8 speechless/vm.lisp

Dependency

optimizers.lisp (file).

Source

speechless.asd.

Parent Component

speechless (system).

Public Interface
Internals

simulate (function).


3.1.9 speechless/diff.lisp

Dependency

vm.lisp (file).

Source

speechless.asd.

Parent Component

speechless (system).

Public Interface
Internals

3.1.10 speechless/printer.lisp

Dependency

diff.lisp (file).

Source

speechless.asd.

Parent Component

speechless (system).

Public Interface
Internals

3.1.11 speechless/documentation.lisp

Dependency

printer.lisp (file).

Source

speechless.asd.

Parent Component

speechless (system).


4 Packages

Packages are listed by definition order.


4.1 org.shirakumo.fraf.speechless

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

4.2 org.shirakumo.fraf.speechless.components

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

4.3 org.shirakumo.fraf.speechless.syntax

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *default-directives*

Variable holding the list of directives used in a default parser.

See PARSER

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Special Variable: *default-instruction-types*

Variable holding the list of instruction types used in a default parser.

See PARSER

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.


5.1.2 Macros

Macro: define-diff (differ type (a b) &body body)
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Macro: define-markup-walker (component &body markup)

Shorthand macro to define a walker method for markup components.

See WALK

Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.

Macro: define-simple-walker (component instruction &rest initargs)

Shorthand macro to define a walker method that emits a single instruction.

See WALK

Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.


5.1.3 Ordinary functions

Function: compile* (thing &optional assembly)

Shorthand to compile and optimise.

See COMPILE
See OPTIMIZE-INSTRUCTIONS

Package

org.shirakumo.fraf.speechless.

Source

optimizers.lisp.

Function: diff (*source* b &optional differ)
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Function: diff-mismatch (format &rest args)
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Function: highlight (source &key target)
Package

org.shirakumo.fraf.speechless.

Source

printer.lisp.

Function: optimize-instructions (assembly)

Run the assembly through known optimisation passes.

Returns the modified assembly.

See *OPTIMIZATION-PASSES*
See RUN-PASS
See ASSEMBLY

Package

org.shirakumo.fraf.speechless.

Source

optimizers.lisp.

Function: parse (thing)

Parses input to a markless component tree.

See ORG.SHIRAKUMO.MARKLESS:PARSE
See ORG.SHIRAKUMO.FRAF.KANDRIA.DIALOGUE.SYNTAX:PARSER

Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.

Function: resolved-target (component)

Resolves the component’s target to an actual component in the document tree.

Signals an error if the target cannot be resolved to a target
component.

See ORG.SHIRAKUMO.MARKLESS.COMPONENTS:TARGET
See ORG.SHIRAKUMO.MARKLESS.COMPONENTS:LABEL

Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.


5.1.4 Generic functions

Generic Reader: arguments (object)

Accesses the list of arguments for the camera action.

See CAMERA

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: arguments ((camera camera))

automatically generated reader method

Source

components.lisp.

Target Slot

arguments.

Generic Writer: (setf arguments) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf arguments) ((camera camera))

automatically generated writer method

Source

components.lisp.

Target Slot

arguments.

Generic Reader: choices (object)

Accesses the list of choices to present to the user.

Each choice is a string of text to display.

See CHOICE-REQUEST

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: choices ((vm vm))

automatically generated reader method

Source

vm.lisp.

Target Slot

choices.

Reader Method: choices ((choice-request choice-request))

automatically generated reader method

Source

vm.lisp.

Target Slot

choices.

Generic Writer: (setf choices) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf choices) ((vm vm))

automatically generated writer method

Source

vm.lisp.

Target Slot

choices.

Generic Reader: choices (object)

Accesses a vector of choices for the conditional.

Each entry in the vector is a vector of child components.

See CONDITIONAL-PART

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: choices ((conditional-part conditional-part))

automatically generated reader method

Source

components.lisp.

Target Slot

choices.

Generic Writer: (setf choices) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf choices) ((conditional-part conditional-part))

automatically generated writer method

Source

components.lisp.

Target Slot

choices.

Generic Reader: clauses (object)

Accesses the list of clauses of the conditional instruction.

Each entry in the clause list is a cons composed out of a test function and a jump target.

See CONDITIONAL

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: clauses ((conditional conditional))

automatically generated reader method

Source

instructions.lisp.

Target Slot

clauses.

Generic Writer: (setf clauses) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf clauses) ((conditional conditional))

automatically generated writer method

Source

instructions.lisp.

Target Slot

clauses.

Generic Reader: clauses (object)

Accesses a vector of clauses for the conditional component.

Each entry in the vector is a cons of a predicate and child components.

See CONDITIONAL

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: clauses ((conditional conditional))

automatically generated reader method

Source

components.lisp.

Target Slot

clauses.

Generic Writer: (setf clauses) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf clauses) ((conditional conditional))

automatically generated writer method

Source

components.lisp.

Target Slot

clauses.

Generic Function: compile (thing assembly)

Compiles the given input to an assembly.

Unless the input is a component, it is first passed to PARSE before being compiled.

Note that this function only performs direct compilation to instructions. Typically this is not sufficient for execution, as jumps may need to be resolved in an extra optimisation pass.

See ASSEMBLY
See PARSE
See COMPILE*
See WALK

Package

org.shirakumo.fraf.speechless.

Methods
Method: compile (thing (assembly (eql t)))
Source

compiler.lisp.

Method: compile (thing (assembly symbol))
Source

compiler.lisp.

Method: compile (thing assembly)
Source

compiler.lisp.

Method: compile ((thing component) assembly)
Source

compiler.lisp.

Generic Function: disassemble (instruction)

Prints the assembly in a more readable fashion to help with debugging.

Unless the input is an assembly or an instruction, it is first passed to COMPILE* before being disassembled.

See ASSEMBLY
See COMPILE*

Package

org.shirakumo.fraf.speechless.

Methods
Method: disassemble ((assembly assembly))
Source

compiler.lisp.

Method: disassemble ((thing string))
Source

compiler.lisp.

Method: disassemble ((instruction eval))
Source

instructions.lisp.

Method: disassemble ((instruction text))
Source

instructions.lisp.

Method: disassemble ((instruction begin-mark))
Source

instructions.lisp.

Method: disassemble ((instruction commit-choice))
Source

instructions.lisp.

Method: disassemble ((instruction pause))
Source

instructions.lisp.

Method: disassemble ((instruction emote))
Source

instructions.lisp.

Method: disassemble ((instruction dispatch))
Source

instructions.lisp.

Method: disassemble ((instruction conditional))
Source

instructions.lisp.

Method: disassemble ((instruction jump))
Source

instructions.lisp.

Method: disassemble :after ((instruction source))
Source

instructions.lisp.

Method: disassemble ((instruction instruction))
Source

instructions.lisp.

Generic Reader: duration (object)

Accesses the duration of the pause (in seconds).

See PAUSE

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: duration ((pause-request pause-request))

automatically generated reader method

Source

vm.lisp.

Target Slot

duration.

Reader Method: duration ((pause pause))

automatically generated reader method

Source

instructions.lisp.

Target Slot

duration.

Generic Writer: (setf duration) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf duration) ((pause pause))

automatically generated writer method

Source

instructions.lisp.

Target Slot

duration.

Generic Function: emit (instruction assembly)

Emits an instruction into the assembly.

This will assign the instruction index and add it to the vector of instructions in the assembly.

See INSTRUCTION
See ASSEMBLY

Package

org.shirakumo.fraf.speechless.

Methods
Method: emit ((instruction instruction) (assembly assembly))
Source

compiler.lisp.

Generic Reader: emote (object)

Accesses the designator of the expression that should be displayed.

See EMOTE (type)

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: emote ((emote-request emote-request))

automatically generated reader method

Source

vm.lisp.

Target Slot

emote.

Reader Method: emote ((emote emote))

automatically generated reader method

Source

instructions.lisp.

Target Slot

emote.

Generic Writer: (setf emote) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf emote) ((emote emote))

automatically generated writer method

Source

instructions.lisp.

Target Slot

emote.

Generic Reader: emote (object)

Accesses the name describing the expression of the character.

See EMOTE (type)

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: emote ((emote emote))

automatically generated reader method

Source

components.lisp.

Target Slot

emote.

Generic Writer: (setf emote) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf emote) ((emote emote))

automatically generated writer method

Source

components.lisp.

Target Slot

emote.

Generic Function: execute (instruction vm ip)

Executes an instruction in the VM.

You should add methods to this function if you include new instruction types. Should return the new instruction pointer, typically (1+ ip). If an instruction requires execution from the client, it should call SUSPEND with the appropriate request instance.

It is an error to call EXECUTE from outside of the context of a RESUME call.

See VM
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Methods
Method: execute ((instruction source) (vm vm) ip)
Method: execute ((instruction pause) (vm vm) ip)
Method: execute ((instruction emote) (vm vm) ip)
Method: execute ((instruction placeholder) (vm vm) ip)
Method: execute ((instruction end-mark) (vm vm) ip)
Method: execute ((instruction begin-mark) (vm vm) ip)
Method: execute ((instruction eval) (vm vm) ip)
Method: execute ((instruction commit-choice) (vm vm) ip)
Method: execute ((instruction choose) (vm vm) ip)
Method: execute ((instruction conditional) (vm vm) ip)
Method: execute ((instruction dispatch) (vm vm) ip)
Method: execute ((instruction clear) (vm vm) ip)
Method: execute ((instruction confirm) (vm vm) ip)
Method: execute ((instruction text) (vm vm) ip)
Method: execute ((instruction jump) (vm vm) ip)
Method: execute ((instruction noop) (vm vm) ip)
Generic Reader: form (object)

Accesses a Lisp form to be evaluated for the component.

See PLACEHOLDER
See CONDITIONAL-PART
See SETF
See EVAL

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: form ((eval eval))

automatically generated reader method

Source

components.lisp.

Target Slot

form.

Reader Method: form ((setf setf))

automatically generated reader method

Source

components.lisp.

Target Slot

form.

Reader Method: form ((conditional-part conditional-part))

automatically generated reader method

Source

components.lisp.

Target Slot

form.

Reader Method: form ((placeholder placeholder))

automatically generated reader method

Source

components.lisp.

Target Slot

form.

Generic Writer: (setf form) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf form) ((eval eval))

automatically generated writer method

Source

components.lisp.

Target Slot

form.

Writer Method: (setf form) ((setf setf))

automatically generated writer method

Source

components.lisp.

Target Slot

form.

Writer Method: (setf form) ((conditional-part conditional-part))

automatically generated writer method

Source

components.lisp.

Target Slot

form.

Writer Method: (setf form) ((placeholder placeholder))

automatically generated writer method

Source

components.lisp.

Target Slot

form.

Generic Reader: index (object)

Accesses the index at which this instruction occurs in the sequence.

See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: index ((instruction instruction))

automatically generated reader method

Source

instructions.lisp.

Target Slot

index.

Generic Writer: (setf index) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf index) ((instruction instruction))

automatically generated writer method

Source

instructions.lisp.

Target Slot

index.

Generic Reader: instructions (object)

Accesses the vector of instructions of the assembly.

See INSTRUCTION
See ASSEMBLY

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: instructions ((vm vm))

automatically generated reader method

Source

vm.lisp.

Target Slot

instructions.

Reader Method: instructions ((assembly assembly))

automatically generated reader method

Source

compiler.lisp.

Target Slot

instructions.

Generic Writer: (setf instructions) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf instructions) ((vm vm))

automatically generated writer method

Source

vm.lisp.

Target Slot

instructions.

Writer Method: (setf instructions) ((assembly assembly))

automatically generated writer method

Source

compiler.lisp.

Target Slot

instructions.

Generic Reader: label (object)

Accesses the label the instruction is associated with, if any.

See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: label ((instruction instruction))

automatically generated reader method

Source

instructions.lisp.

Target Slot

label.

Generic Writer: (setf label) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf label) ((instruction instruction))

automatically generated writer method

Source

instructions.lisp.

Target Slot

label.

Generic Reader: location (condition)
Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: location ((condition diff-mismatch))
Source

diff.lisp.

Target Slot

location.

Generic Reader: markup (object)

Accesses the identifier for the markup.

See TEXT-REQUEST
See BEGIN-MARK

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: markup ((vm vm))

automatically generated reader method

Source

vm.lisp.

Target Slot

markup.

Reader Method: markup ((text-request text-request))

automatically generated reader method

Source

vm.lisp.

Target Slot

markup.

Reader Method: markup ((end-mark end-mark))

automatically generated reader method

Source

instructions.lisp.

Target Slot

markup.

Reader Method: markup ((begin-mark begin-mark))

automatically generated reader method

Source

instructions.lisp.

Target Slot

markup.

Generic Writer: (setf markup) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf markup) ((vm vm))

automatically generated writer method

Source

vm.lisp.

Target Slot

markup.

Writer Method: (setf markup) ((end-mark end-mark))

automatically generated writer method

Source

instructions.lisp.

Target Slot

markup.

Writer Method: (setf markup) ((begin-mark begin-mark))

automatically generated writer method

Source

instructions.lisp.

Target Slot

markup.

Generic Reader: message (condition)
Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: message ((condition diff-mismatch))
Source

diff.lisp.

Target Slot

message.

Generic Reader: name (object)

Accesses the name designator the instruction relates to.

See SOURCE

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: name ((source-request source-request))

automatically generated reader method

Source

vm.lisp.

Target Slot

name.

Reader Method: name ((source source))

automatically generated reader method

Source

instructions.lisp.

Target Slot

name.

Generic Writer: (setf name) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf name) ((source source))

automatically generated writer method

Source

instructions.lisp.

Target Slot

name.

Generic Reader: name (object)

Accesses the name of the speaker.

See SOURCE

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: name ((source source))

automatically generated reader method

Source

components.lisp.

Target Slot

name.

Generic Writer: (setf name) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf name) ((source source))

automatically generated writer method

Source

components.lisp.

Target Slot

name.

Generic Function: next-index (assembly)

Returns the next instruction index to use.

See ASSEMBLY

Package

org.shirakumo.fraf.speechless.

Methods
Method: next-index ((assembly assembly))
Source

compiler.lisp.

Generic Reader: place (object)

Accesses a form describing the place to set.

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: place ((setf setf))

automatically generated reader method

Source

components.lisp.

Target Slot

place.

Generic Writer: (setf place) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf place) ((setf setf))

automatically generated writer method

Source

components.lisp.

Target Slot

place.

Generic Function: pop-text (vm)
Package

org.shirakumo.fraf.speechless.

Methods
Method: pop-text ((vm vm))
Source

vm.lisp.

Generic Function: reset (vm)

Resets the VM to its initial state.

Returns the VM.

See VM

Package

org.shirakumo.fraf.speechless.

Methods
Method: reset ((vm vm))
Source

vm.lisp.

Generic Function: resume (vm ip)

Resumes execution of the VM.

This will process instructions until a request to the client has to be made. To do this the VM will continuously call EXECUTE and update the instruction pointer. An instruction that requires a request should call SUSPEND to suspend the execution and return from RESUME.

If the assembly runs to completion (the instruction pointer exceeds the instruction vector), an END-REQUEST is returned.

See VM
See SUSPEND
See EXECUTE

Package

org.shirakumo.fraf.speechless.

Methods
Method: resume ((vm vm) ip)
Source

vm.lisp.

Generic Function: run (assembly vm)

Prepare the VM to run an assembly.

This will initialise the VM with the assembly’s instructions and reset its state.

Returns the VM.

See RESET
See VM

Package

org.shirakumo.fraf.speechless.

Methods
Method: run ((string string) (vm vm))
Source

vm.lisp.

Method: run ((assembly assembly) (vm vm))
Source

vm.lisp.

Method: run (assembly (vm (eql t)))
Source

vm.lisp.

Generic Function: run-pass (pass thing)
Package

org.shirakumo.fraf.speechless.

Methods
Method: run-pass :after ((pass noop-elimination-pass) (assembly assembly))
Source

optimizers.lisp.

Method: run-pass ((pass noop-elimination-pass) (instruction dispatch))
Source

optimizers.lisp.

Method: run-pass ((pass noop-elimination-pass) (instruction conditional))
Source

optimizers.lisp.

Method: run-pass ((pass noop-elimination-pass) (instruction jump))
Source

optimizers.lisp.

Method: run-pass :before ((pass noop-elimination-pass) (assembly assembly))
Source

optimizers.lisp.

Method: run-pass ((pass jump-resolution-pass) (instruction jump))
Source

optimizers.lisp.

Method: run-pass :before ((pass jump-resolution-pass) (assembly assembly))
Source

optimizers.lisp.

Method: run-pass ((pass pass) (instruction instruction))
Source

optimizers.lisp.

Method: run-pass ((pass pass) (assembly assembly))
Source

optimizers.lisp.

Method: run-pass ((pass symbol) thing)
Source

optimizers.lisp.

Generic Reader: speed (object)

Accesses the speed at which the text should scroll, relative to base speed.

See SPEED (type)

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: speed ((speed speed))

automatically generated reader method

Source

components.lisp.

Target Slot

speed.

Generic Writer: (setf speed) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf speed) ((speed speed))

automatically generated writer method

Source

components.lisp.

Target Slot

speed.

Generic Function: suspend (vm return)

Suspends execution of the VM to make a request to the client.

This function must only be called from EXECUTE.

See RESUME
See EXECUTE

Package

org.shirakumo.fraf.speechless.

Methods
Method: suspend ((vm vm) return)
Source

vm.lisp.

Generic Reader: target (object)

Accesses the target of the instruction.

See JUMP
See INSTRUCTION
See TARGET-REQUEST

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: target ((target-request target-request))

automatically generated reader method

Source

vm.lisp.

Target Slot

target.

Reader Method: target ((jump jump))

automatically generated reader method

Source

instructions.lisp.

Target Slot

target.

Generic Writer: (setf target) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf target) ((jump jump))

automatically generated writer method

Source

instructions.lisp.

Target Slot

target.

Generic Reader: targets (object)

Accesses the list of target instruction pointers.

See CHOICE-REQUEST

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: targets ((choice-request choice-request))

automatically generated reader method

Source

vm.lisp.

Target Slot

targets.

Reader Method: targets ((dispatch dispatch))

automatically generated reader method

Source

instructions.lisp.

Target Slot

targets.

Generic Writer: (setf targets) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf targets) ((dispatch dispatch))

automatically generated writer method

Source

instructions.lisp.

Target Slot

targets.

Generic Function: text (object)

Accesses the text to be output

See TEXT-REQUEST
See TEXT (type)

Package

org.shirakumo.fraf.speechless.

Methods
Method: text ((vm vm))
Source

vm.lisp.

Reader Method: text ((text-request text-request))

automatically generated reader method

Source

vm.lisp.

Target Slot

text.

Reader Method: text ((text text))

automatically generated reader method

Source

instructions.lisp.

Target Slot

text.

Generic Writer: (setf text) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf text) ((text text))

automatically generated writer method

Source

instructions.lisp.

Target Slot

text.

Generic Reader: text-buffer (object)
Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: text-buffer ((vm vm))

automatically generated reader method

Source

vm.lisp.

Target Slot

text-buffer.

Generic Function: walk (ast assembly)

Walks the AST to emit instructions into the assembly.

This function should have methods for every supported component type to handle it and compile it into a set of instructions.

See EMIT
See ASSEMBLY
See INSTRUCTION
See ORG.SHIRAKUMO.MARKLESS.COMPONENTS:COMPONENT

Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.

Methods
Method: walk ((placeholder placeholder) (assembly assembly))
Method: walk ((em-dash em-dash) (assembly assembly))
Method: walk ((en-dash en-dash) (assembly assembly))
Method: walk ((emote emote) (assembly assembly))
Method: walk ((setf setf) (assembly assembly))
Method: walk ((eval eval) (assembly assembly))
Method: walk ((component newline) (assembly assembly))
Method: walk ((go go) (assembly assembly))
Method: walk ((footnote footnote) (assembly assembly))
Method: walk ((label label) (assembly assembly))
Method: walk ((jump jump) (assembly assembly))
Method: walk :around ((compound compound) (assembly assembly))
Method: walk :around ((subtext subtext) (assembly assembly))
Method: walk :around ((supertext supertext) (assembly assembly))
Method: walk :around ((strikethrough strikethrough) (assembly assembly))
Method: walk :around ((italic italic) (assembly assembly))
Method: walk :around ((underline underline) (assembly assembly))
Method: walk :around ((bold bold) (assembly assembly))
Method: walk ((component header) (assembly assembly))
Method: walk ((component conditional-part) (assembly assembly))
Method: walk ((string string) (assembly assembly))
Method: walk ((component unordered-list) (assembly assembly))
Method: walk ((component conditional) (assembly assembly))
Method: walk :after ((component blockquote) (assembly assembly))
Method: walk :before ((component blockquote) (assembly assembly))
Method: walk ((component blockquote-header) (assembly assembly))
Method: walk ((component root-component) (assembly assembly))
Method: walk ((component parent-component) (assembly assembly))
Method: walk :around (thing assembly)
Method: walk :around (thing (assembly (eql t)))
Method: walk (thing assembly)
Generic Function: wrap-lexenv (assembly form)

Function used to wrap the lexical environment of forms compiled in dialogue.

You should implement a method on this if you want to customise the lexical environment of dialogue forms. The function acts like a
macro; it receives an expression as input, and should return a new expression to be used in its place.

Typically you’ll want to do stuff like surround the form with LETs and FLETs to make special convenience functions and variables available.

See ASSEMBLY

Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.

Methods
Method: wrap-lexenv (_ form)

5.1.5 Standalone methods

Method: begin ((_ source) parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: begin ((_ emote) parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: begin ((_ conditional) parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: begin :around (directive (parser parser) line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: begin ((_ label) parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: begin ((_ part-separator) parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: begin ((_ jump) parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: begin ((_ conditional-part) parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: begin ((_ placeholder) parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: children ((_ conditional-part))
Package

cl-markless-components.

Source

components.lisp.

Method: children ((_ conditional))
Package

cl-markless-components.

Source

syntax.lisp.

Method: consume-end ((_ conditional-part) component parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: consume-prefix ((_ conditional) component parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: end :after ((_ conditional-part) component parser)
Package

cl-markless.

Source

syntax.lisp.

Method: evaluate-instruction ((instruction fake-instruction) parser)
Package

cl-markless.

Source

syntax.lisp.

Method: initialize-instance :after ((instruction instruction) &key)
Source

instructions.lisp.

Method: invoke :around (directive component (parser parser) line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: invoke ((_ label) component parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: invoke ((_ conditional-part) component parser line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: output-component ((c conditional-part) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c conditional) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c eval) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c setf) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c speed) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c go) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c emote) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c placeholder) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c source) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c jump) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c label) (s stream) (_ speechless))
Package

cl-markless.

Source

printer.lisp.

Method: output-component ((c conditional-part) (s stream) (f debug))
Package

cl-markless.

Source

components.lisp.

Method: output-component ((component eval) (stream stream) (_ debug))
Package

cl-markless.

Source

components.lisp.

Method: output-component ((c conditional) (s stream) (f debug))
Package

cl-markless.

Source

components.lisp.

Method: parse-instruction ((proto camera) line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: parse-instruction ((proto eval) line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: parse-instruction ((proto speed) line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: parse-instruction ((proto setf) line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: parse-instruction ((proto move) line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: parse-instruction ((proto go) line cursor)
Package

cl-markless.

Source

syntax.lisp.

Method: prefix ((_ emote))
Package

cl-markless.

Source

syntax.lisp.

Method: prefix ((_ conditional))
Package

cl-markless.

Source

syntax.lisp.

Method: prefix ((_ label))
Package

cl-markless.

Source

syntax.lisp.

Method: prefix ((_ part-separator))
Package

cl-markless.

Source

syntax.lisp.

Method: prefix ((_ jump))
Package

cl-markless.

Source

syntax.lisp.

Method: prefix ((_ conditional-part))
Package

cl-markless.

Source

syntax.lisp.

Method: prefix ((_ placeholder))
Package

cl-markless.

Source

syntax.lisp.

Method: print-object ((conditional conditional) stream)
Source

instructions.lisp.

Method: print-object ((request choice-request) stream)
Source

vm.lisp.

Method: print-object ((request emote-request) stream)
Source

vm.lisp.

Method: print-object ((instruction instruction) stream)
Source

instructions.lisp.

Method: print-object ((source source) stream)
Source

instructions.lisp.

Method: print-object ((request pause-request) stream)
Source

vm.lisp.

Method: print-object ((jump jump) stream)
Source

instructions.lisp.

Method: print-object ((eval eval) stream)
Source

instructions.lisp.

Method: print-object ((request text-request) stream)
Source

vm.lisp.

Method: print-object ((text text) stream)
Source

instructions.lisp.

Method: print-object ((dispatch dispatch) stream)
Source

instructions.lisp.

Method: print-object ((source source) stream)
Source

components.lisp.

Method: print-object ((jump jump) stream)
Source

components.lisp.

Method: print-object ((camera camera) stream)
Source

components.lisp.

Method: print-object ((eval eval) stream)
Source

components.lisp.

Method: print-object ((placeholder placeholder) stream)
Source

components.lisp.

Method: print-object ((speed speed) stream)
Source

components.lisp.

Method: print-object ((setf setf) stream)
Source

components.lisp.

Method: print-object ((move move) stream)
Source

components.lisp.

Method: print-object ((emote emote) stream)
Source

components.lisp.

Method: print-object ((go go) stream)
Source

components.lisp.

Writer Method: (setf target) ((move move))

automatically generated writer method

Package

cl-markless-components.

Source

components.lisp.

Target Slot

target.

Reader Method: target ((move move))

automatically generated reader method

Package

cl-markless-components.

Source

components.lisp.

Target Slot

target.


5.1.6 Conditions

Condition: diff-mismatch
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Direct superclasses

warning.

Direct methods
Direct slots
Slot: location
Initargs

:location

Readers

location.

Writers

This slot is read-only.

Slot: message
Initform

(quote nil)

Initargs

:message

Readers

message.

Writers

This slot is read-only.


Previous: , Up: Public Interface   [Contents][Index]

5.1.7 Classes

Class: assembly

A class representing a set of instructions ready to be executed.

See INSTRUCTIONS
See NEXT-INDEX
See EMIT
See WALK
See DISASSEMBLE
See RUN-PASS
See RUN

Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.

Direct methods
Direct slots
Slot: instructions
Initform

(make-array 0 :adjustable t :fill-pointer t)

Readers

instructions.

Writers

(setf instructions).

Class: begin-mark

An instruction to mark the beginning of a piece of text markup.

See MARKUP
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: markup
Initargs

:markup

Readers

markup.

Writers

(setf markup).

Slot: end
Initargs

:end

Readers

end.

Writers

(setf end).

Class: camera

Instruction to cause a camera action.

See ACTION
See ARGUMENTS

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

fake-instruction.

Direct methods
Direct slots
Slot: action
Initform

(error "action required")

Initargs

:action

Readers

action.

Writers

(setf action).

Slot: arguments
Initargs

:arguments

Readers

arguments.

Writers

(setf arguments).

Class: choice-request

A request that represents a set of choices for the user to choose between.

Each choice in the list of choices has a corresponding instruction pointer in the list of targets that the VM should resume from after the request.

See CHOICES
See TARGETS
See INPUT-REQUEST

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct superclasses

input-request.

Direct methods
Direct slots
Slot: choices
Initargs

:choices

Readers

choices.

Writers

This slot is read-only.

Slot: targets
Initargs

:targets

Readers

targets.

Writers

This slot is read-only.

Class: choose

An instruction representing a request to make the user choose an option.

See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods

execute.

Class: clear

An instruction to clear the text.

See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods

execute.

Class: clear-request

A request to clear the current text on screen.

See TARGET-REQUEST

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct superclasses

target-request.

Class: commit-choice

An instruction to commit the current text buffer as a choice.

See JUMP

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

jump.

Direct methods
Class: conditional

An instruction that represents a chain of branches, similar to COND.

See CLAUSES
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: clauses
Initargs

:clauses

Readers

clauses.

Writers

(setf clauses).

Class: conditional

A component representing a conditional execution path.

See CLAUSES

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

block-component.

Direct methods
Direct slots
Slot: clauses
Initform

(make-array 0 :adjustable t :fill-pointer t)

Readers

clauses.

Writers

(setf clauses).

Class: conditional

Directive for a conditional block.

Syntax: "? form"

Following lines should be either "| " for a conditional body or "|? form" for a branch condition, or "|?" for an otherwise branch.

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Direct superclasses

block-directive.

Direct methods
Class: conditional-part

A component representing an inline conditional.

See FORM
See CHOICES

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

inline-component.

Direct methods
Direct slots
Slot: form
Initform

(error "form required")

Initargs

:form

Readers

form.

Writers

(setf form).

Slot: choices
Initform

(make-array 0 :adjustable t :fill-pointer t)

Readers

choices.

Writers

(setf choices).

Class: conditional-part

Directive for an inline conditional.

Syntax: "[form if-clause | else-clause ]"

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Direct superclasses

inline-directive.

Direct methods
Class: confirm

An instruction to prompt the user to confirm.

See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods

execute.

Class: confirm-request

A request to ask the user to confirm before proceeding with execution.

See INPUT-REQUEST
See TARGET-REQUEST
See TEXT-REQUEST

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct superclasses
Class: differ
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Direct subclasses

localisation-differ.

Direct methods

%diff.

Class: emote

An instruction representing a change in expression for the speaker.

See EMOTE (function)
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: emote
Initargs

:emote

Readers

emote.

Writers

(setf emote).

Class: emote

A component representing an expression of the speaking character.

See EMOTE (function)

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

inline-component.

Direct methods
Direct slots
Slot: emote
Initform

(error "emote required")

Initargs

:emote

Readers

emote.

Writers

(setf emote).

Class: emote

Directive for the expression of the speaking character.

Syntax: "(:emote)"

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Direct superclasses

inline-directive.

Direct methods
Class: emote-request

A request to change the expression of the current speaker.

See TEXT-REQUEST
see TARGET-REQUEST

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: emote
Initargs

:emote

Readers

emote.

Writers

This slot is read-only.

Class: end-mark

An instruction to mark the end of the most recent markup section.

See BEGIN-MARK
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: markup
Readers

markup.

Writers

(setf markup).

Class: end-request

A request to end the dialogue.

See REQUEST

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct superclasses

request.

Class: eval

An instruction to execute a Lisp function.

See FUNC
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: func
Initargs

:func

Readers

func.

Writers

(setf func).

Class: eval

Instruction to evaluate a piece of Lisp code.

See FORM

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

fake-instruction.

Direct methods
Direct slots
Slot: form
Initform

(error "form required")

Initargs

:form

Readers

form.

Writers

(setf form).

Class: go

Instruction to jump to a specific component.

See ORG.SHIRAKUMO.MARKLESS.COMPONENTS:TARGET

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses
Direct methods
Class: highlighted
Package

org.shirakumo.fraf.speechless.

Source

printer.lisp.

Direct superclasses
Direct methods

output-form.

Class: input-request

Base class for requests that require user input.

See REQUEST

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct superclasses

request.

Direct subclasses
Class: instruction

Base class for a dialogue instruction.

See INDEX
See LABEL

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: index
Initargs

:index

Readers

index.

Writers

(setf index).

Slot: label
Initargs

:label

Readers

label.

Writers

(setf label).

Class: jump

An instruction that jumps to another instruction index.

See TARGET
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct subclasses

commit-choice.

Direct methods
Direct slots
Slot: target
Initform

(error "target required.")

Initargs

:target

Readers

target.

Writers

(setf target).

Class: jump

A component representing a jump to another component.

See ORG.SHIRAKUMO.MARKLESS.COMPONENTS:TARGET

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses
  • block-component.
  • targeted.
Direct methods
Class: jump

Directive representing a jump to another label.

Syntax: "< label"

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Direct superclasses

singular-line-directive.

Direct methods
Class: jump-resolution-pass

Pass to resolve jumps to labels to actual instruction indices.

After this pass all jumps should have their target be an instruction index.

See LABEL-MAP
See PASS

Package

org.shirakumo.fraf.speechless.

Source

optimizers.lisp.

Direct superclasses

pass.

Direct methods
Direct slots
Slot: label-map
Initform

(make-hash-table :test (quote eq))

Readers

label-map.

Writers

This slot is read-only.

Class: label

Directive representing a label.

Syntax: "> label"

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Direct superclasses

singular-line-directive.

Direct methods
Class: localisation-differ
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Direct superclasses

differ.

Direct methods
Class: move

Instruction to move a character to another position.

See ENTITY
See TARGET

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

fake-instruction.

Direct methods
Direct slots
Slot: entity
Initform

(error "entity required")

Initargs

:entity

Readers

entity.

Writers

(setf entity).

Slot: target
Initform

(error "target required")

Initargs

:target

Readers

target.

Writers

(setf target).

Class: noop

A no-operation instruction. Does nothing.

See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods

execute.

Class: noop-elimination-pass

Pass to eliminate all noop instructions

This pass rewrites jump instructions to resolve to proper indices without the need for noops. After this pass, no noops should remain in the assembly.

See LABEL-MAP
See PASS

Package

org.shirakumo.fraf.speechless.

Source

optimizers.lisp.

Direct superclasses

pass.

Direct methods
Direct slots
Slot: label-map
Initform

(make-hash-table :test (quote eq))

Readers

label-map.

Writers

This slot is read-only.

Class: parser

Parser class customised to use the correct set of directives and instructions.

See *DEFAULT-DIRECTIVES*
See *DEFAULT-INSTRUCTION-TYPES*
See ORG.SHIRAKUMO.MARKLESS:PARSER

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Direct superclasses

parser.

Direct methods
Direct Default Initargs
InitargValue
:directives*default-directives*
:instruction-types*default-instruction-types*
Direct slots
Slot: location-table
Initform

(make-hash-table :test (quote eq))

Readers

location-table.

Writers

This slot is read-only.

Class: part-separator

Directive for the separator of a part in a compound directive.

Syntax: "|"

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Direct superclasses

inline-directive.

Direct methods
Class: pass

Class representing an optimisation pass.

See RUN-PASS
See OPTIMIZE-INSTRUCTIONS
See COMPILE*
See ASSEMBLY

Package

org.shirakumo.fraf.speechless.

Source

optimizers.lisp.

Direct subclasses
Direct methods
Class: pause

An instruction representing a pause in speech.

See DURATION
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: duration
Initargs

:duration

Readers

duration.

Writers

(setf duration).

Class: pause-request

A request to pause execution for a period of real time.

See TEXT-REQUEST
See TARGET-REQUEST
See DURATION

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: duration
Initargs

:duration

Readers

duration.

Writers

This slot is read-only.

Class: placeholder

An instruction representing a dynamic piece of text.

See FUNC
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: func
Initargs

:func

Readers

func.

Writers

(setf func).

Class: placeholder

A component representing a dynamic piece of text.

See FORM

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

inline-component.

Direct methods
Direct slots
Slot: form
Initform

(error "form required")

Initargs

:form

Readers

form.

Writers

(setf form).

Class: placeholder

Directive for a dynamic piece of text.

Syntax: "{form}"

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Direct superclasses

inline-directive.

Direct methods
Class: request

Base class for all client requests.

A request requires the client to perform some operation before execution can resume.

See INPUT-REQUEST
See TARGET-REQUEST
See TEXT-REQUEST
See CHOICE-REQUEST
See CONFIRM-REQUEST
See CLEAR-REQUEST
See EMOTE-REQUEST
See PAUSE-REQUEST
See SOURCE-REQUEST
See END-REQUEST

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct subclasses
Class: setf

Instruction to set a place.

See PLACE
See FORM

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

fake-instruction.

Direct methods
Direct slots
Slot: place
Initform

(error "place required")

Initargs

:place

Readers

place.

Writers

(setf place).

Slot: form
Initform

(error "form required")

Initargs

:form

Readers

form.

Writers

(setf form).

Class: source

An instruction representing a change in the speaking source.

See NAME
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

(setf name).

Class: source

A component representing someone speaking.

See NAME

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

blockquote-header.

Direct methods
Direct slots
Slot: name
Initform

(error "name required")

Initargs

:name

Readers

name.

Writers

(setf name).

Class: source

Directive for a speaking source.

Syntax: "~ source"

Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Direct superclasses

blockquote-header.

Direct methods

begin.

Class: source-request

A request to change the speaker of the dialogue.

See TARGET-REQUEST
See NAME

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct superclasses

target-request.

Direct methods

name.

Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

This slot is read-only.

Class: speechless
Package

org.shirakumo.fraf.speechless.

Source

printer.lisp.

Direct superclasses
  • markless.
  • output-format.
Direct subclasses

highlighted.

Direct methods
Class: speed

Instruction to change the letter scroll speed.

See SPEED (function)

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

fake-instruction.

Direct methods
Direct slots
Slot: speed
Initform

(error "speed required")

Initargs

:speed

Readers

speed.

Writers

(setf speed).

Class: target-request

Base class for requests that advance the instruction pointer after completion.

See REQUEST
See TARGET

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct superclasses

request.

Direct subclasses
Direct methods

target.

Direct slots
Slot: target
Initargs

:target

Readers

target.

Writers

This slot is read-only.

Class: text

An instruction to output a piece of text.

See TEXT (function)
See INSTRUCTION

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: text
Initargs

:text

Readers

text.

Writers

(setf text).

Class: text-request

Base class for requests that carry some text to be output

See TEXT (function)
See MARKUP

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: text
Initargs

:text

Readers

text.

Writers

This slot is read-only.

Slot: markup
Initargs

:markup

Readers

markup.

Writers

This slot is read-only.

Class: vm

A class to represent the execution state of a dialogue assembly.

In order to execute dialogue you should first compile it to an assembly, then construct a VM instance and pass the assembly to the VM via RUN. This will initialise the VM properly. Afterwards you should call RESUME, which will return a REQUEST instance, informing you of a necessary action to take. You should then continue calling RESUME with the new instruction pointer as instructed by the request until an END-REQUEST is returned.

See REQUEST
See EXECUTE
See SUSPEND
See INSTRUCTIONS
See RUN

Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Direct methods
Direct slots
Slot: instructions
Readers

instructions.

Writers

(setf instructions).

Slot: text-buffer
Initform

(make-string-output-stream)

Readers

text-buffer.

Writers

This slot is read-only.

Slot: choices
Readers

choices.

Writers

(setf choices).

Slot: markup
Readers

markup.

Writers

(setf markup).


5.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.1 Special variables

Special Variable: *component-path*
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Special Variable: *location-table*
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Special Variable: *optimization-passes*

Variable containing a list of optimisation passes to run by default.

See OPTIMIZE-INSTRUCTIONS

Package

org.shirakumo.fraf.speechless.

Source

optimizers.lisp.

Special Variable: *placeholder-readtable*
Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.

Special Variable: *root*

Variable bound to the root of the document for quick access to the label table.

Only bound during compilation.

Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.

Special Variable: *source*
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.


5.2.2 Macros

Macro: %form (s thing)
Package

org.shirakumo.fraf.speechless.

Source

printer.lisp.

Macro: %op (s thing &rest args)
Package

org.shirakumo.fraf.speechless.

Source

printer.lisp.

Macro: mark-component ()
Package

org.shirakumo.fraf.speechless.syntax.

Source

syntax.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.3 Ordinary functions

Function: compare (format b a)
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Function: compile-form (assembly form)
Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.

Function: ensure-parsed (thing)
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Function: find-new-index (target)
Package

org.shirakumo.fraf.speechless.

Source

optimizers.lisp.

Function: format-location-in-source (location source)
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Function: main ()
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Function: maybe-unwrap (thing)
Package

org.shirakumo.fraf.speechless.

Source

printer.lisp.

Function: print-instruction-type (instruction)
Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Function: random-indicator-p (form)
Package

org.shirakumo.fraf.speechless.

Source

compiler.lisp.

Function: simulate (thing)
Package

org.shirakumo.fraf.speechless.

Source

vm.lisp.

Function: unlist (a)
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.4 Generic functions

Generic Function: %diff (a b differ)
Package

org.shirakumo.fraf.speechless.

Source

diff.lisp.

Method Combination

progn.

Options

:most-specific-first

Methods
Method: %diff progn ((a eval) (b eval) (differ localisation-differ))
Method: %diff progn ((a setf) (b setf) (differ localisation-differ))
Method: %diff progn ((a speed) (b speed) (differ localisation-differ))
Method: %diff progn ((a conditional-part) (b conditional-part) (differ localisation-differ))
Method: %diff progn ((a emote) (b emote) (differ localisation-differ))
Method: %diff progn ((a placeholder) (b placeholder) (differ localisation-differ))
Method: %diff progn ((a source) (b source) (differ localisation-differ))
Method: %diff progn ((a conditional) (b conditional) (differ localisation-differ))
Method: %diff progn ((a color-option) (b color-option) (differ localisation-differ))
Method: %diff progn ((a compound) (b compound) (differ localisation-differ))
Method: %diff progn ((a embed) (b embed) (differ localisation-differ))
Method: %diff progn ((a sized) (b sized) (differ localisation-differ))
Method: %diff progn ((a targeted) (b targeted) (differ localisation-differ))
Method: %diff progn ((a include) (b include) (differ localisation-differ))
Method: %diff progn ((a set) (b set) (differ localisation-differ))
Method: %diff progn ((a directives-instruction) (b directives-instruction) (differ localisation-differ))
Method: %diff progn ((a unordered-list) (b unordered-list) (differ localisation-differ))
Method: %diff progn ((a ordered-list-item) (b ordered-list-item) (differ localisation-differ))
Method: %diff progn ((a symbol) (b symbol) (differ localisation-differ))
Method: %diff progn ((a real) (b real) (differ localisation-differ))
Method: %diff progn ((a parent-component) (b parent-component) (differ localisation-differ))
Method: %diff progn ((a cons) (b cons) (differ localisation-differ))
Method: %diff progn ((a vector) (b vector) (differ localisation-differ))
Method: %diff progn (a b (differ localisation-differ))
Method: %diff :around (a b (differ differ))
Generic Reader: action (object)

Accesses the action the camera should perform.

Standard actions are:
- :PAN
- :ROLL
- :PITCH
- :YAW
- :JUMP
- :SHAKE
- :ZOOM

See CAMERA

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: action ((camera camera))

automatically generated reader method

Source

components.lisp.

Target Slot

action.

Generic Writer: (setf action) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf action) ((camera camera))

automatically generated writer method

Source

components.lisp.

Target Slot

action.

Generic Reader: end (object)
Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: end ((begin-mark begin-mark))

automatically generated reader method

Source

instructions.lisp.

Target Slot

end.

Generic Writer: (setf end) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf end) ((begin-mark begin-mark))

automatically generated writer method

Source

instructions.lisp.

Target Slot

end.

Generic Reader: entity (object)

Accesses a designator for the entity to move.

See MOVE

Package

org.shirakumo.fraf.speechless.components.

Methods
Reader Method: entity ((move move))

automatically generated reader method

Source

components.lisp.

Target Slot

entity.

Generic Writer: (setf entity) (object)
Package

org.shirakumo.fraf.speechless.components.

Methods
Writer Method: (setf entity) ((move move))

automatically generated writer method

Source

components.lisp.

Target Slot

entity.

Generic Reader: func (object)

Accesses the function associated with the instruction.

See DISPATCH
See PLACEHOLDER
See EVAL

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: func ((eval eval))

automatically generated reader method

Source

instructions.lisp.

Target Slot

func.

Reader Method: func ((placeholder placeholder))

automatically generated reader method

Source

instructions.lisp.

Target Slot

func.

Reader Method: func ((dispatch dispatch))

automatically generated reader method

Source

instructions.lisp.

Target Slot

func.

Generic Writer: (setf func) (object)
Package

org.shirakumo.fraf.speechless.

Methods
Writer Method: (setf func) ((eval eval))

automatically generated writer method

Source

instructions.lisp.

Target Slot

func.

Writer Method: (setf func) ((placeholder placeholder))

automatically generated writer method

Source

instructions.lisp.

Target Slot

func.

Writer Method: (setf func) ((dispatch dispatch))

automatically generated writer method

Source

instructions.lisp.

Target Slot

func.

Generic Reader: label-map (object)

Accesses the hash table of labels to instructions.

See JUMP-RESOLUTION-PASS
See NOOP-ELIMINATION-PASS

Package

org.shirakumo.fraf.speechless.

Methods
Reader Method: label-map ((noop-elimination-pass noop-elimination-pass))

automatically generated reader method

Source

optimizers.lisp.

Target Slot

label-map.

Reader Method: label-map ((jump-resolution-pass jump-resolution-pass))

automatically generated reader method

Source

optimizers.lisp.

Target Slot

label-map.

Generic Reader: location-table (object)
Package

org.shirakumo.fraf.speechless.syntax.

Methods
Reader Method: location-table ((parser parser))

automatically generated reader method

Source

syntax.lisp.

Target Slot

location-table.

Generic Function: output-form (form target format)
Package

org.shirakumo.fraf.speechless.

Methods
Method: output-form (form target (format highlighted))
Source

printer.lisp.

Method: output-form (form target (format speechless))
Source

printer.lisp.


Previous: , Up: Internals   [Contents][Index]

5.2.5 Classes

Class: dispatch

An instruction that represents a branching dispatch.

See FUNC
See TARGETS

Package

org.shirakumo.fraf.speechless.

Source

instructions.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: func
Initargs

:func

Readers

func.

Writers

(setf func).

Slot: targets
Initargs

:targets

Readers

targets.

Writers

(setf targets).

Class: fake-instruction

A component for instructions that do not cause changes in the markless document.

Package

org.shirakumo.fraf.speechless.components.

Source

components.lisp.

Direct superclasses

instruction.

Direct subclasses
Direct methods

evaluate-instruction.


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   U   W  
Index Entry  Section

%
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%diff: Private generic functions
%form: Private macros
%op: Private macros

(
(setf action): Private generic functions
(setf action): Private generic functions
(setf arguments): Public generic functions
(setf arguments): Public generic functions
(setf choices): Public generic functions
(setf choices): Public generic functions
(setf choices): Public generic functions
(setf choices): Public generic functions
(setf clauses): Public generic functions
(setf clauses): Public generic functions
(setf clauses): Public generic functions
(setf clauses): Public generic functions
(setf duration): Public generic functions
(setf duration): Public generic functions
(setf emote): Public generic functions
(setf emote): Public generic functions
(setf emote): Public generic functions
(setf emote): Public generic functions
(setf end): Private generic functions
(setf end): Private generic functions
(setf entity): Private generic functions
(setf entity): Private generic functions
(setf form): Public generic functions
(setf form): Public generic functions
(setf form): Public generic functions
(setf form): Public generic functions
(setf form): Public generic functions
(setf func): Private generic functions
(setf func): Private generic functions
(setf func): Private generic functions
(setf func): Private generic functions
(setf index): Public generic functions
(setf index): Public generic functions
(setf instructions): Public generic functions
(setf instructions): Public generic functions
(setf instructions): Public generic functions
(setf label): Public generic functions
(setf label): Public generic functions
(setf markup): Public generic functions
(setf markup): Public generic functions
(setf markup): Public generic functions
(setf markup): Public generic functions
(setf name): Public generic functions
(setf name): Public generic functions
(setf name): Public generic functions
(setf name): Public generic functions
(setf place): Public generic functions
(setf place): Public generic functions
(setf speed): Public generic functions
(setf speed): Public generic functions
(setf target): Public generic functions
(setf target): Public generic functions
(setf target): Public standalone methods
(setf targets): Public generic functions
(setf targets): Public generic functions
(setf text): Public generic functions
(setf text): Public generic functions

A
action: Private generic functions
action: Private generic functions
arguments: Public generic functions
arguments: Public generic functions

B
begin: Public standalone methods
begin: Public standalone methods
begin: Public standalone methods
begin: Public standalone methods
begin: Public standalone methods
begin: Public standalone methods
begin: Public standalone methods
begin: Public standalone methods
begin: Public standalone methods

C
children: Public standalone methods
children: Public standalone methods
choices: Public generic functions
choices: Public generic functions
choices: Public generic functions
choices: Public generic functions
choices: Public generic functions
clauses: Public generic functions
clauses: Public generic functions
clauses: Public generic functions
clauses: Public generic functions
compare: Private ordinary functions
compile: Public generic functions
compile: Public generic functions
compile: Public generic functions
compile: Public generic functions
compile: Public generic functions
compile*: Public ordinary functions
compile-form: Private ordinary functions
consume-end: Public standalone methods
consume-prefix: Public standalone methods

D
define-diff: Public macros
define-markup-walker: Public macros
define-simple-walker: Public macros
diff: Public ordinary functions
diff-mismatch: Public ordinary functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
disassemble: Public generic functions
duration: Public generic functions
duration: Public generic functions
duration: Public generic functions

E
emit: Public generic functions
emit: Public generic functions
emote: Public generic functions
emote: Public generic functions
emote: Public generic functions
emote: Public generic functions
emote: Public generic functions
end: Public standalone methods
end: Private generic functions
end: Private generic functions
ensure-parsed: Private ordinary functions
entity: Private generic functions
entity: Private generic functions
evaluate-instruction: Public standalone methods
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions
execute: Public generic functions

F
find-new-index: Private ordinary functions
form: Public generic functions
form: Public generic functions
form: Public generic functions
form: Public generic functions
form: Public generic functions
format-location-in-source: Private ordinary functions
func: Private generic functions
func: Private generic functions
func: Private generic functions
func: Private generic functions
Function, compare: Private ordinary functions
Function, compile*: Public ordinary functions
Function, compile-form: Private ordinary functions
Function, diff: Public ordinary functions
Function, diff-mismatch: Public ordinary functions
Function, ensure-parsed: Private ordinary functions
Function, find-new-index: Private ordinary functions
Function, format-location-in-source: Private ordinary functions
Function, highlight: Public ordinary functions
Function, main: Private ordinary functions
Function, maybe-unwrap: Private ordinary functions
Function, optimize-instructions: Public ordinary functions
Function, parse: Public ordinary functions
Function, print-instruction-type: Private ordinary functions
Function, random-indicator-p: Private ordinary functions
Function, resolved-target: Public ordinary functions
Function, simulate: Private ordinary functions
Function, unlist: Private ordinary functions

G
Generic Function, %diff: Private generic functions
Generic Function, (setf action): Private generic functions
Generic Function, (setf arguments): Public generic functions
Generic Function, (setf choices): Public generic functions
Generic Function, (setf choices): Public generic functions
Generic Function, (setf clauses): Public generic functions
Generic Function, (setf clauses): Public generic functions
Generic Function, (setf duration): Public generic functions
Generic Function, (setf emote): Public generic functions
Generic Function, (setf emote): Public generic functions
Generic Function, (setf end): Private generic functions
Generic Function, (setf entity): Private generic functions
Generic Function, (setf form): Public generic functions
Generic Function, (setf func): Private generic functions
Generic Function, (setf index): Public generic functions
Generic Function, (setf instructions): Public generic functions
Generic Function, (setf label): Public generic functions
Generic Function, (setf markup): Public generic functions
Generic Function, (setf name): Public generic functions
Generic Function, (setf name): Public generic functions
Generic Function, (setf place): Public generic functions
Generic Function, (setf speed): Public generic functions
Generic Function, (setf target): Public generic functions
Generic Function, (setf targets): Public generic functions
Generic Function, (setf text): Public generic functions
Generic Function, action: Private generic functions
Generic Function, arguments: Public generic functions
Generic Function, choices: Public generic functions
Generic Function, choices: Public generic functions
Generic Function, clauses: Public generic functions
Generic Function, clauses: Public generic functions
Generic Function, compile: Public generic functions
Generic Function, disassemble: Public generic functions
Generic Function, duration: Public generic functions
Generic Function, emit: Public generic functions
Generic Function, emote: Public generic functions
Generic Function, emote: Public generic functions
Generic Function, end: Private generic functions
Generic Function, entity: Private generic functions
Generic Function, execute: Public generic functions
Generic Function, form: Public generic functions
Generic Function, func: Private generic functions
Generic Function, index: Public generic functions
Generic Function, instructions: Public generic functions
Generic Function, label: Public generic functions
Generic Function, label-map: Private generic functions
Generic Function, location: Public generic functions
Generic Function, location-table: Private generic functions
Generic Function, markup: Public generic functions
Generic Function, message: Public generic functions
Generic Function, name: Public generic functions
Generic Function, name: Public generic functions
Generic Function, next-index: Public generic functions
Generic Function, output-form: Private generic functions
Generic Function, place: Public generic functions
Generic Function, pop-text: Public generic functions
Generic Function, reset: Public generic functions
Generic Function, resume: Public generic functions
Generic Function, run: Public generic functions
Generic Function, run-pass: Public generic functions
Generic Function, speed: Public generic functions
Generic Function, suspend: Public generic functions
Generic Function, target: Public generic functions
Generic Function, targets: Public generic functions
Generic Function, text: Public generic functions
Generic Function, text-buffer: Public generic functions
Generic Function, walk: Public generic functions
Generic Function, wrap-lexenv: Public generic functions

H
highlight: Public ordinary functions

I
index: Public generic functions
index: Public generic functions
initialize-instance: Public standalone methods
instructions: Public generic functions
instructions: Public generic functions
instructions: Public generic functions
invoke: Public standalone methods
invoke: Public standalone methods
invoke: Public standalone methods

L
label: Public generic functions
label: Public generic functions
label-map: Private generic functions
label-map: Private generic functions
label-map: Private generic functions
location: Public generic functions
location: Public generic functions
location-table: Private generic functions
location-table: Private generic functions

M
Macro, %form: Private macros
Macro, %op: Private macros
Macro, define-diff: Public macros
Macro, define-markup-walker: Public macros
Macro, define-simple-walker: Public macros
Macro, mark-component: Private macros
main: Private ordinary functions
mark-component: Private macros
markup: Public generic functions
markup: Public generic functions
markup: Public generic functions
markup: Public generic functions
markup: Public generic functions
maybe-unwrap: Private ordinary functions
message: Public generic functions
message: Public generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, %diff: Private generic functions
Method, (setf action): Private generic functions
Method, (setf arguments): Public generic functions
Method, (setf choices): Public generic functions
Method, (setf choices): Public generic functions
Method, (setf clauses): Public generic functions
Method, (setf clauses): Public generic functions
Method, (setf duration): Public generic functions
Method, (setf emote): Public generic functions
Method, (setf emote): Public generic functions
Method, (setf end): Private generic functions
Method, (setf entity): Private generic functions
Method, (setf form): Public generic functions
Method, (setf form): Public generic functions
Method, (setf form): Public generic functions
Method, (setf form): Public generic functions
Method, (setf func): Private generic functions
Method, (setf func): Private generic functions
Method, (setf func): Private generic functions
Method, (setf index): Public generic functions
Method, (setf instructions): Public generic functions
Method, (setf instructions): Public generic functions
Method, (setf label): Public generic functions
Method, (setf markup): Public generic functions
Method, (setf markup): Public generic functions
Method, (setf markup): Public generic functions
Method, (setf name): Public generic functions
Method, (setf name): Public generic functions
Method, (setf place): Public generic functions
Method, (setf speed): Public generic functions
Method, (setf target): Public generic functions
Method, (setf target): Public standalone methods
Method, (setf targets): Public generic functions
Method, (setf text): Public generic functions
Method, action: Private generic functions
Method, arguments: Public generic functions
Method, begin: Public standalone methods
Method, begin: Public standalone methods
Method, begin: Public standalone methods
Method, begin: Public standalone methods
Method, begin: Public standalone methods
Method, begin: Public standalone methods
Method, begin: Public standalone methods
Method, begin: Public standalone methods
Method, begin: Public standalone methods
Method, children: Public standalone methods
Method, children: Public standalone methods
Method, choices: Public generic functions
Method, choices: Public generic functions
Method, choices: Public generic functions
Method, clauses: Public generic functions
Method, clauses: Public generic functions
Method, compile: Public generic functions
Method, compile: Public generic functions
Method, compile: Public generic functions
Method, compile: Public generic functions
Method, consume-end: Public standalone methods
Method, consume-prefix: Public standalone methods
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, disassemble: Public generic functions
Method, duration: Public generic functions
Method, duration: Public generic functions
Method, emit: Public generic functions
Method, emote: Public generic functions
Method, emote: Public generic functions
Method, emote: Public generic functions
Method, end: Public standalone methods
Method, end: Private generic functions
Method, entity: Private generic functions
Method, evaluate-instruction: Public standalone methods
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, execute: Public generic functions
Method, form: Public generic functions
Method, form: Public generic functions
Method, form: Public generic functions
Method, form: Public generic functions
Method, func: Private generic functions
Method, func: Private generic functions
Method, func: Private generic functions
Method, index: Public generic functions
Method, initialize-instance: Public standalone methods
Method, instructions: Public generic functions
Method, instructions: Public generic functions
Method, invoke: Public standalone methods
Method, invoke: Public standalone methods
Method, invoke: Public standalone methods
Method, label: Public generic functions
Method, label-map: Private generic functions
Method, label-map: Private generic functions
Method, location: Public generic functions
Method, location-table: Private generic functions
Method, markup: Public generic functions
Method, markup: Public generic functions
Method, markup: Public generic functions
Method, markup: Public generic functions
Method, message: Public generic functions
Method, name: Public generic functions
Method, name: Public generic functions
Method, name: Public generic functions
Method, next-index: Public generic functions
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-component: Public standalone methods
Method, output-form: Private generic functions
Method, output-form: Private generic functions
Method, parse-instruction: Public standalone methods
Method, parse-instruction: Public standalone methods
Method, parse-instruction: Public standalone methods
Method, parse-instruction: Public standalone methods
Method, parse-instruction: Public standalone methods
Method, parse-instruction: Public standalone methods
Method, place: Public generic functions
Method, pop-text: Public generic functions
Method, prefix: Public standalone methods
Method, prefix: Public standalone methods
Method, prefix: Public standalone methods
Method, prefix: Public standalone methods
Method, prefix: Public standalone methods
Method, prefix: Public standalone methods
Method, prefix: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, reset: Public generic functions
Method, resume: Public generic functions
Method, run: Public generic functions
Method, run: Public generic functions
Method, run: Public generic functions
Method, run-pass: Public generic functions
Method, run-pass: Public generic functions
Method, run-pass: Public generic functions
Method, run-pass: Public generic functions
Method, run-pass: Public generic functions
Method, run-pass: Public generic functions
Method, run-pass: Public generic functions
Method, run-pass: Public generic functions
Method, run-pass: Public generic functions
Method, run-pass: Public generic functions
Method, speed: Public generic functions
Method, suspend: Public generic functions
Method, target: Public generic functions
Method, target: Public generic functions
Method, target: Public standalone methods
Method, targets: Public generic functions
Method, targets: Public generic functions
Method, text: Public generic functions
Method, text: Public generic functions
Method, text: Public generic functions
Method, text-buffer: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, wrap-lexenv: Public generic functions

N
name: Public generic functions
name: Public generic functions
name: Public generic functions
name: Public generic functions
name: Public generic functions
next-index: Public generic functions
next-index: Public generic functions

O
optimize-instructions: Public ordinary functions
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-component: Public standalone methods
output-form: Private generic functions
output-form: Private generic functions
output-form: Private generic functions

P
parse: Public ordinary functions
parse-instruction: Public standalone methods
parse-instruction: Public standalone methods
parse-instruction: Public standalone methods
parse-instruction: Public standalone methods
parse-instruction: Public standalone methods
parse-instruction: Public standalone methods
place: Public generic functions
place: Public generic functions
pop-text: Public generic functions
pop-text: Public generic functions
prefix: Public standalone methods
prefix: Public standalone methods
prefix: Public standalone methods
prefix: Public standalone methods
prefix: Public standalone methods
prefix: Public standalone methods
prefix: Public standalone methods
print-instruction-type: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods

R
random-indicator-p: Private ordinary functions
reset: Public generic functions
reset: Public generic functions
resolved-target: Public ordinary functions
resume: Public generic functions
resume: Public generic functions
run: Public generic functions
run: Public generic functions
run: Public generic functions
run: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions
run-pass: Public generic functions

S
simulate: Private ordinary functions
speed: Public generic functions
speed: Public generic functions
suspend: Public generic functions
suspend: Public generic functions

T
target: Public generic functions
target: Public generic functions
target: Public generic functions
target: Public standalone methods
targets: Public generic functions
targets: Public generic functions
targets: Public generic functions
text: Public generic functions
text: Public generic functions
text: Public generic functions
text: Public generic functions
text-buffer: Public generic functions
text-buffer: Public generic functions

U
unlist: Private ordinary functions

W
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
wrap-lexenv: Public generic functions
wrap-lexenv: Public generic functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   U   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
A   C   D   E   F   I   L   M   N   P   S   T  
Index Entry  Section

*
*component-path*: Private special variables
*default-directives*: Public special variables
*default-instruction-types*: Public special variables
*location-table*: Private special variables
*optimization-passes*: Private special variables
*placeholder-readtable*: Private special variables
*root*: Private special variables
*source*: Private special variables

A
action: Public classes
arguments: Public classes

C
choices: Public classes
choices: Public classes
choices: Public classes
clauses: Public classes
clauses: Public classes

D
duration: Public classes
duration: Public classes

E
emote: Public classes
emote: Public classes
emote: Public classes
end: Public classes
entity: Public classes

F
form: Public classes
form: Public classes
form: Public classes
form: Public classes
func: Public classes
func: Public classes
func: Private classes

I
index: Public classes
instructions: Public classes
instructions: Public classes

L
label: Public classes
label-map: Public classes
label-map: Public classes
location: Public conditions
location-table: Public classes

M
markup: Public classes
markup: Public classes
markup: Public classes
markup: Public classes
message: Public conditions

N
name: Public classes
name: Public classes
name: Public classes

P
place: Public classes

S
Slot, action: Public classes
Slot, arguments: Public classes
Slot, choices: Public classes
Slot, choices: Public classes
Slot, choices: Public classes
Slot, clauses: Public classes
Slot, clauses: Public classes
Slot, duration: Public classes
Slot, duration: Public classes
Slot, emote: Public classes
Slot, emote: Public classes
Slot, emote: Public classes
Slot, end: Public classes
Slot, entity: Public classes
Slot, form: Public classes
Slot, form: Public classes
Slot, form: Public classes
Slot, form: Public classes
Slot, func: Public classes
Slot, func: Public classes
Slot, func: Private classes
Slot, index: Public classes
Slot, instructions: Public classes
Slot, instructions: Public classes
Slot, label: Public classes
Slot, label-map: Public classes
Slot, label-map: Public classes
Slot, location: Public conditions
Slot, location-table: Public classes
Slot, markup: Public classes
Slot, markup: Public classes
Slot, markup: Public classes
Slot, markup: Public classes
Slot, message: Public conditions
Slot, name: Public classes
Slot, name: Public classes
Slot, name: Public classes
Slot, place: Public classes
Slot, speed: Public classes
Slot, target: Public classes
Slot, target: Public classes
Slot, target: Public classes
Slot, targets: Public classes
Slot, targets: Private classes
Slot, text: Public classes
Slot, text: Public classes
Slot, text-buffer: Public classes
Special Variable, *component-path*: Private special variables
Special Variable, *default-directives*: Public special variables
Special Variable, *default-instruction-types*: Public special variables
Special Variable, *location-table*: Private special variables
Special Variable, *optimization-passes*: Private special variables
Special Variable, *placeholder-readtable*: Private special variables
Special Variable, *root*: Private special variables
Special Variable, *source*: Private special variables
speed: Public classes

T
target: Public classes
target: Public classes
target: Public classes
targets: Public classes
targets: Private classes
text: Public classes
text: Public classes
text-buffer: Public classes

Jump to:   *  
A   C   D   E   F   I   L   M   N   P   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   B   C   D   E   F   G   H   I   J   L   M   N   O   P   R   S   T   V  
Index Entry  Section

A
assembly: Public classes

B
begin-mark: Public classes

C
camera: Public classes
choice-request: Public classes
choose: Public classes
Class, assembly: Public classes
Class, begin-mark: Public classes
Class, camera: Public classes
Class, choice-request: Public classes
Class, choose: Public classes
Class, clear: Public classes
Class, clear-request: Public classes
Class, commit-choice: Public classes
Class, conditional: Public classes
Class, conditional: Public classes
Class, conditional: Public classes
Class, conditional-part: Public classes
Class, conditional-part: Public classes
Class, confirm: Public classes
Class, confirm-request: Public classes
Class, differ: Public classes
Class, dispatch: Private classes
Class, emote: Public classes
Class, emote: Public classes
Class, emote: Public classes
Class, emote-request: Public classes
Class, end-mark: Public classes
Class, end-request: Public classes
Class, eval: Public classes
Class, eval: Public classes
Class, fake-instruction: Private classes
Class, go: Public classes
Class, highlighted: Public classes
Class, input-request: Public classes
Class, instruction: Public classes
Class, jump: Public classes
Class, jump: Public classes
Class, jump: Public classes
Class, jump-resolution-pass: Public classes
Class, label: Public classes
Class, localisation-differ: Public classes
Class, move: Public classes
Class, noop: Public classes
Class, noop-elimination-pass: Public classes
Class, parser: Public classes
Class, part-separator: Public classes
Class, pass: Public classes
Class, pause: Public classes
Class, pause-request: Public classes
Class, placeholder: Public classes
Class, placeholder: Public classes
Class, placeholder: Public classes
Class, request: Public classes
Class, setf: Public classes
Class, source: Public classes
Class, source: Public classes
Class, source: Public classes
Class, source-request: Public classes
Class, speechless: Public classes
Class, speed: Public classes
Class, target-request: Public classes
Class, text: Public classes
Class, text-request: Public classes
Class, vm: Public classes
clear: Public classes
clear-request: Public classes
commit-choice: Public classes
compiler.lisp: The speechless/compiler․lisp file
components.lisp: The speechless/components․lisp file
Condition, diff-mismatch: Public conditions
conditional: Public classes
conditional: Public classes
conditional: Public classes
conditional-part: Public classes
conditional-part: Public classes
confirm: Public classes
confirm-request: Public classes

D
diff-mismatch: Public conditions
diff.lisp: The speechless/diff․lisp file
differ: Public classes
dispatch: Private classes
documentation.lisp: The speechless/documentation․lisp file

E
emote: Public classes
emote: Public classes
emote: Public classes
emote-request: Public classes
end-mark: Public classes
end-request: Public classes
eval: Public classes
eval: Public classes

F
fake-instruction: Private classes
File, compiler.lisp: The speechless/compiler․lisp file
File, components.lisp: The speechless/components․lisp file
File, diff.lisp: The speechless/diff․lisp file
File, documentation.lisp: The speechless/documentation․lisp file
File, instructions.lisp: The speechless/instructions․lisp file
File, optimizers.lisp: The speechless/optimizers․lisp file
File, package.lisp: The speechless/package․lisp file
File, printer.lisp: The speechless/printer․lisp file
File, speechless.asd: The speechless/speechless․asd file
File, syntax.lisp: The speechless/syntax․lisp file
File, vm.lisp: The speechless/vm․lisp file

G
go: Public classes

H
highlighted: Public classes

I
input-request: Public classes
instruction: Public classes
instructions.lisp: The speechless/instructions․lisp file

J
jump: Public classes
jump: Public classes
jump: Public classes
jump-resolution-pass: Public classes

L
label: Public classes
localisation-differ: Public classes

M
move: Public classes

N
noop: Public classes
noop-elimination-pass: Public classes

O
optimizers.lisp: The speechless/optimizers․lisp file
org.shirakumo.fraf.speechless: The org․shirakumo․fraf․speechless package
org.shirakumo.fraf.speechless.components: The org․shirakumo․fraf․speechless․components package
org.shirakumo.fraf.speechless.syntax: The org․shirakumo․fraf․speechless․syntax package

P
Package, org.shirakumo.fraf.speechless: The org․shirakumo․fraf․speechless package
Package, org.shirakumo.fraf.speechless.components: The org․shirakumo․fraf․speechless․components package
Package, org.shirakumo.fraf.speechless.syntax: The org․shirakumo․fraf․speechless․syntax package
package.lisp: The speechless/package․lisp file
parser: Public classes
part-separator: Public classes
pass: Public classes
pause: Public classes
pause-request: Public classes
placeholder: Public classes
placeholder: Public classes
placeholder: Public classes
printer.lisp: The speechless/printer․lisp file

R
request: Public classes

S
setf: Public classes
source: Public classes
source: Public classes
source: Public classes
source-request: Public classes
speechless: The speechless system
speechless: Public classes
speechless.asd: The speechless/speechless․asd file
speed: Public classes
syntax.lisp: The speechless/syntax․lisp file
System, speechless: The speechless system

T
target-request: Public classes
text: Public classes
text-request: Public classes

V
vm: Public classes
vm.lisp: The speechless/vm․lisp file

Jump to:   A   B   C   D   E   F   G   H   I   J   L   M   N   O   P   R   S   T   V