The speechless Reference Manual

Table of Contents

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 3.0 "Montgomery Scott" on Wed Oct 13 12:36:19 2021 GMT+0.


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

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.


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

2 Systems

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


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

2.1 speechless

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

Description

A dialogue system language implementation.

Version

1.0.0

Dependencies
Source

speechless.asd (file)

Components

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

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 files   [Contents][Index]

3.1.1 speechless.asd

Location

speechless.asd

Systems

speechless (system)


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

3.1.2 speechless/package.lisp

Parent

speechless (system)

Location

package.lisp

Packages

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

3.1.3 speechless/components.lisp

Dependency

package.lisp (file)

Parent

speechless (system)

Location

components.lisp

Exported Definitions
Internal Definitions

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

3.1.4 speechless/syntax.lisp

Dependency

components.lisp (file)

Parent

speechless (system)

Location

syntax.lisp

Exported Definitions
Internal Definitions

*placeholder-readtable* (special variable)


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

3.1.5 speechless/instructions.lisp

Dependency

syntax.lisp (file)

Parent

speechless (system)

Location

instructions.lisp

Exported Definitions
Internal Definitions

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

3.1.6 speechless/compiler.lisp

Dependency

instructions.lisp (file)

Parent

speechless (system)

Location

compiler.lisp

Exported Definitions
Internal Definitions

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

3.1.7 speechless/optimizers.lisp

Dependency

compiler.lisp (file)

Parent

speechless (system)

Location

optimizers.lisp

Exported Definitions
Internal Definitions

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

3.1.8 speechless/vm.lisp

Dependency

optimizers.lisp (file)

Parent

speechless (system)

Location

vm.lisp

Exported Definitions
Internal Definitions

simulate (function)


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

3.1.9 speechless/documentation.lisp

Dependency

vm.lisp (file)

Parent

speechless (system)

Location

documentation.lisp


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

4 Packages

Packages are listed by definition order.


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

4.1 org.shirakumo.fraf.speechless.syntax

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

*placeholder-readtable* (special variable)


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

4.2 org.shirakumo.fraf.speechless.components

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

4.3 org.shirakumo.fraf.speechless

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [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 (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

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 (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: compile* THING &optional ASSEMBLY

Shorthand to compile and optimise.

See COMPILE
See OPTIMIZE-INSTRUCTIONS

Package

org.shirakumo.fraf.speechless

Source

optimizers.lisp (file)

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 (file)

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 (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Generic functions

Generic Function: arguments OBJECT

Accesses the list of arguments for the camera action.

See CAMERA

Package

org.shirakumo.fraf.speechless.components

Writer

(setf arguments) (generic function)

Methods
Method: arguments (CAMERA camera)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf arguments) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

arguments (generic function)

Methods
Method: (setf arguments) NEW-VALUE (CAMERA camera)

automatically generated writer method

Source

components.lisp (file)

Generic Function: 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

Writer

(setf choices) (generic function)

Methods
Method: choices (CONDITIONAL-PART conditional-part)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf choices) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

choices (generic function)

Methods
Method: (setf choices) NEW-VALUE (CONDITIONAL-PART conditional-part)

automatically generated writer method

Source

components.lisp (file)

Generic Function: 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

Writer

(setf choices) (generic function)

Methods
Method: choices (VM vm)

automatically generated reader method

Source

vm.lisp (file)

Method: choices (CHOICE-REQUEST choice-request)

automatically generated reader method

Source

vm.lisp (file)

Generic Function: (setf choices) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

choices (generic function)

Methods
Method: (setf choices) NEW-VALUE (VM vm)

automatically generated writer method

Source

vm.lisp (file)

Generic Function: 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

Writer

(setf clauses) (generic function)

Methods
Method: clauses (CONDITIONAL conditional)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf clauses) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

clauses (generic function)

Methods
Method: (setf clauses) NEW-VALUE (CONDITIONAL conditional)

automatically generated writer method

Source

components.lisp (file)

Generic Function: 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

Writer

(setf clauses) (generic function)

Methods
Method: clauses (CONDITIONAL conditional)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf clauses) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

clauses (generic function)

Methods
Method: (setf clauses) NEW-VALUE (CONDITIONAL conditional)

automatically generated writer method

Source

instructions.lisp (file)

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 (file)

Method: compile THING (ASSEMBLY symbol)
Source

compiler.lisp (file)

Method: compile THING ASSEMBLY
Source

compiler.lisp (file)

Method: compile (THING component) ASSEMBLY
Source

compiler.lisp (file)

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 (file)

Method: disassemble (THING string)
Source

compiler.lisp (file)

Method: disassemble (INSTRUCTION eval)
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION text)
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION begin-mark)
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION commit-choice)
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION pause)
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION emote)
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION dispatch)
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION conditional)
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION jump)
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION source) after
Source

instructions.lisp (file)

Method: disassemble (INSTRUCTION instruction)
Source

instructions.lisp (file)

Generic Function: duration OBJECT

Accesses the duration of the pause (in seconds).

See PAUSE

Package

org.shirakumo.fraf.speechless

Writer

(setf duration) (generic function)

Methods
Method: duration (PAUSE-REQUEST pause-request)

automatically generated reader method

Source

vm.lisp (file)

Method: duration (PAUSE pause)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf duration) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

duration (generic function)

Methods
Method: (setf duration) NEW-VALUE (PAUSE pause)

automatically generated writer method

Source

instructions.lisp (file)

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 (file)

Generic Function: emote OBJECT

Accesses the name describing the expression of the character.

See EMOTE (type)

Package

org.shirakumo.fraf.speechless.components

Writer

(setf emote) (generic function)

Methods
Method: emote (EMOTE emote)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf emote) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

emote (generic function)

Methods
Method: (setf emote) NEW-VALUE (EMOTE emote)

automatically generated writer method

Source

components.lisp (file)

Generic Function: emote OBJECT

Accesses the designator of the expression that should be displayed.

See EMOTE (type)

Package

org.shirakumo.fraf.speechless

Writer

(setf emote) (generic function)

Methods
Method: emote (EMOTE-REQUEST emote-request)

automatically generated reader method

Source

vm.lisp (file)

Method: emote (EMOTE emote)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf emote) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

emote (generic function)

Methods
Method: (setf emote) NEW-VALUE (EMOTE emote)

automatically generated writer method

Source

instructions.lisp (file)

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 (file)

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 Function: 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

Writer

(setf form) (generic function)

Methods
Method: form (EVAL eval)

automatically generated reader method

Source

components.lisp (file)

Method: form (SETF setf)

automatically generated reader method

Source

components.lisp (file)

Method: form (CONDITIONAL-PART conditional-part)

automatically generated reader method

Source

components.lisp (file)

Method: form (PLACEHOLDER placeholder)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf form) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

form (generic function)

Methods
Method: (setf form) NEW-VALUE (EVAL eval)

automatically generated writer method

Source

components.lisp (file)

Method: (setf form) NEW-VALUE (SETF setf)

automatically generated writer method

Source

components.lisp (file)

Method: (setf form) NEW-VALUE (CONDITIONAL-PART conditional-part)

automatically generated writer method

Source

components.lisp (file)

Method: (setf form) NEW-VALUE (PLACEHOLDER placeholder)

automatically generated writer method

Source

components.lisp (file)

Generic Function: index OBJECT

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

See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Writer

(setf index) (generic function)

Methods
Method: index (INSTRUCTION instruction)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf index) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

index (generic function)

Methods
Method: (setf index) NEW-VALUE (INSTRUCTION instruction)

automatically generated writer method

Source

instructions.lisp (file)

Generic Function: instructions OBJECT

Accesses the vector of instructions of the assembly.

See INSTRUCTION
See ASSEMBLY

Package

org.shirakumo.fraf.speechless

Writer

(setf instructions) (generic function)

Methods
Method: instructions (VM vm)

automatically generated reader method

Source

vm.lisp (file)

Method: instructions (ASSEMBLY assembly)

automatically generated reader method

Source

compiler.lisp (file)

Generic Function: (setf instructions) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

instructions (generic function)

Methods
Method: (setf instructions) NEW-VALUE (VM vm)

automatically generated writer method

Source

vm.lisp (file)

Method: (setf instructions) NEW-VALUE (ASSEMBLY assembly)

automatically generated writer method

Source

compiler.lisp (file)

Generic Function: label OBJECT

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

See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Writer

(setf label) (generic function)

Methods
Method: label (INSTRUCTION instruction)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf label) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

label (generic function)

Methods
Method: (setf label) NEW-VALUE (INSTRUCTION instruction)

automatically generated writer method

Source

instructions.lisp (file)

Generic Function: markup OBJECT

Accesses the identifier for the markup.

See TEXT-REQUEST
See BEGIN-MARK

Package

org.shirakumo.fraf.speechless

Writer

(setf markup) (generic function)

Methods
Method: markup (VM vm)

automatically generated reader method

Source

vm.lisp (file)

Method: markup (TEXT-REQUEST text-request)

automatically generated reader method

Source

vm.lisp (file)

Method: markup (END-MARK end-mark)

automatically generated reader method

Source

instructions.lisp (file)

Method: markup (BEGIN-MARK begin-mark)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf markup) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

markup (generic function)

Methods
Method: (setf markup) NEW-VALUE (VM vm)

automatically generated writer method

Source

vm.lisp (file)

Method: (setf markup) NEW-VALUE (END-MARK end-mark)

automatically generated writer method

Source

instructions.lisp (file)

Method: (setf markup) NEW-VALUE (BEGIN-MARK begin-mark)

automatically generated writer method

Source

instructions.lisp (file)

Generic Function: name OBJECT

Accesses the name of the speaker.

See SOURCE

Package

org.shirakumo.fraf.speechless.components

Writer

(setf name) (generic function)

Methods
Method: name (SOURCE source)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf name) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

name (generic function)

Methods
Method: (setf name) NEW-VALUE (SOURCE source)

automatically generated writer method

Source

components.lisp (file)

Generic Function: name OBJECT

Accesses the name designator the instruction relates to.

See SOURCE

Package

org.shirakumo.fraf.speechless

Writer

(setf name) (generic function)

Methods
Method: name (SOURCE-REQUEST source-request)

automatically generated reader method

Source

vm.lisp (file)

Method: name (SOURCE source)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf name) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

name (generic function)

Methods
Method: (setf name) NEW-VALUE (SOURCE source)

automatically generated writer method

Source

instructions.lisp (file)

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 (file)

Generic Function: place OBJECT

Accesses a form describing the place to set.

Package

org.shirakumo.fraf.speechless.components

Writer

(setf place) (generic function)

Methods
Method: place (SETF setf)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf place) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

place (generic function)

Methods
Method: (setf place) NEW-VALUE (SETF setf)

automatically generated writer method

Source

components.lisp (file)

Generic Function: pop-text VM
Package

org.shirakumo.fraf.speechless

Methods
Method: pop-text (VM vm)
Source

vm.lisp (file)

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 (file)

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 (file)

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 (file)

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

vm.lisp (file)

Method: run ASSEMBLY (VM (eql t))
Source

vm.lisp (file)

Generic Function: run-pass PASS THING
Package

org.shirakumo.fraf.speechless

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

optimizers.lisp (file)

Method: run-pass (PASS noop-elimination-pass) (INSTRUCTION dispatch)
Source

optimizers.lisp (file)

Method: run-pass (PASS noop-elimination-pass) (INSTRUCTION conditional)
Source

optimizers.lisp (file)

Method: run-pass (PASS noop-elimination-pass) (INSTRUCTION jump)
Source

optimizers.lisp (file)

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

optimizers.lisp (file)

Method: run-pass (PASS jump-resolution-pass) (INSTRUCTION jump)
Source

optimizers.lisp (file)

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

optimizers.lisp (file)

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

optimizers.lisp (file)

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

optimizers.lisp (file)

Method: run-pass (PASS symbol) THING
Source

optimizers.lisp (file)

Generic Function: speed OBJECT

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

See SPEED (type)

Package

org.shirakumo.fraf.speechless.components

Writer

(setf speed) (generic function)

Methods
Method: speed (SPEED speed)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf speed) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

speed (generic function)

Methods
Method: (setf speed) NEW-VALUE (SPEED speed)

automatically generated writer method

Source

components.lisp (file)

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 (file)

Generic Function: target OBJECT

Accesses the target of the instruction.

See JUMP
See INSTRUCTION
See TARGET-REQUEST

Package

org.shirakumo.fraf.speechless

Writer

(setf target) (generic function)

Methods
Method: target (TARGET-REQUEST target-request)

automatically generated reader method

Source

vm.lisp (file)

Method: target (JUMP jump)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf target) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

target (generic function)

Methods
Method: (setf target) NEW-VALUE (JUMP jump)

automatically generated writer method

Source

instructions.lisp (file)

Generic Function: targets OBJECT

Accesses the list of target instruction pointers.

See CHOICE-REQUEST

Package

org.shirakumo.fraf.speechless

Writer

(setf targets) (generic function)

Methods
Method: targets (CHOICE-REQUEST choice-request)

automatically generated reader method

Source

vm.lisp (file)

Method: targets (DISPATCH dispatch)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf targets) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

targets (generic function)

Methods
Method: (setf targets) NEW-VALUE (DISPATCH dispatch)

automatically generated writer method

Source

instructions.lisp (file)

Generic Function: text OBJECT

Accesses the text to be output

See TEXT-REQUEST
See TEXT (type)

Package

org.shirakumo.fraf.speechless

Writer

(setf text) (generic function)

Methods
Method: text (VM vm)
Source

vm.lisp (file)

Method: text (TEXT-REQUEST text-request)

automatically generated reader method

Source

vm.lisp (file)

Method: text (TEXT text)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf text) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

text (generic function)

Methods
Method: (setf text) NEW-VALUE (TEXT text)

automatically generated writer method

Source

instructions.lisp (file)

Generic Function: text-buffer OBJECT
Package

org.shirakumo.fraf.speechless

Methods
Method: text-buffer (VM vm)

automatically generated reader method

Source

vm.lisp (file)

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 (file)

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 (COMPOUND compound) (ASSEMBLY assembly) around
Method: walk (SUBTEXT subtext) (ASSEMBLY assembly) around
Method: walk (SUPERTEXT supertext) (ASSEMBLY assembly) around
Method: walk (STRIKETHROUGH strikethrough) (ASSEMBLY assembly) around
Method: walk (ITALIC italic) (ASSEMBLY assembly) around
Method: walk (UNDERLINE underline) (ASSEMBLY assembly) around
Method: walk (BOLD bold) (ASSEMBLY assembly) around
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 (COMPONENT blockquote) (ASSEMBLY assembly) after
Method: walk (COMPONENT blockquote) (ASSEMBLY assembly) before
Method: walk (COMPONENT blockquote-header) (ASSEMBLY assembly)
Method: walk (COMPONENT root-component) (ASSEMBLY assembly)
Method: walk (COMPONENT parent-component) (ASSEMBLY assembly)
Method: walk THING ASSEMBLY around
Method: walk THING (ASSEMBLY (eql t)) around
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 (file)

Methods
Method: wrap-lexenv _ FORM

Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 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 (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: instructions
Initform

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

Readers

instructions (generic function)

Writers

(setf instructions) (generic function)

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 (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: markup
Initargs

:markup

Readers

markup (generic function)

Writers

(setf markup) (generic function)

Slot: end
Initargs

:end

Readers

end (generic function)

Writers

(setf end) (generic function)

Class: camera ()

Instruction to cause a camera action.

See ACTION
See ARGUMENTS

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

fake-instruction (class)

Direct methods
  • parse-instruction (method)
  • arguments (method)
  • arguments (method)
  • action (method)
  • action (method)
Direct slots
Slot: action
Initargs

:action

Initform

(error "action required")

Readers

action (generic function)

Writers

(setf action) (generic function)

Slot: arguments
Initargs

:arguments

Readers

arguments (generic function)

Writers

(setf arguments) (generic function)

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 (file)

Direct superclasses

input-request (class)

Direct methods
Direct slots
Slot: choices
Initargs

:choices

Readers

choices (generic function)

Slot: targets
Initargs

:targets

Readers

targets (generic function)

Class: choose ()

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

See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct methods

execute (method)

Class: clear ()

An instruction to clear the text.

See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct methods

execute (method)

Class: clear-request ()

A request to clear the current text on screen.

See TARGET-REQUEST

Package

org.shirakumo.fraf.speechless

Source

vm.lisp (file)

Direct superclasses

target-request (class)

Class: commit-choice ()

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

See JUMP

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

jump (class)

Direct methods
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 (file)

Direct superclasses

block-directive (class)

Direct methods
  • consume-prefix (method)
  • begin (method)
  • prefix (method)
Class: conditional ()

A component representing a conditional execution path.

See CLAUSES

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

block-component (class)

Direct methods
  • walk (method)
  • children (method)
  • output-component (method)
  • clauses (method)
  • clauses (method)
Direct slots
Slot: clauses
Initform

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

Readers

clauses (generic function)

Writers

(setf clauses) (generic function)

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 (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: clauses
Initargs

:clauses

Readers

clauses (generic function)

Writers

(setf clauses) (generic function)

Class: conditional-part ()

Directive for an inline conditional.

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

Package

org.shirakumo.fraf.speechless.syntax

Source

syntax.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
  • end (method)
  • consume-end (method)
  • invoke (method)
  • begin (method)
  • prefix (method)
Class: conditional-part ()

A component representing an inline conditional.

See FORM
See CHOICES

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

inline-component (class)

Direct methods
  • walk (method)
  • output-component (method)
  • children (method)
  • choices (method)
  • choices (method)
  • form (method)
  • form (method)
Direct slots
Slot: form
Initargs

:form

Initform

(error "form required")

Readers

form (generic function)

Writers

(setf form) (generic function)

Slot: choices
Initform

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

Readers

choices (generic function)

Writers

(setf choices) (generic function)

Class: confirm ()

An instruction to prompt the user to confirm.

See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct methods

execute (method)

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 (file)

Direct superclasses
Class: emote ()

Directive for the expression of the speaking character.

Syntax: "(:emote)"

Package

org.shirakumo.fraf.speechless.syntax

Source

syntax.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
  • begin (method)
  • prefix (method)
Class: emote ()

A component representing an expression of the speaking character.

See EMOTE (function)

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

inline-component (class)

Direct methods
  • walk (method)
  • emote (method)
  • emote (method)
Direct slots
Slot: emote
Initargs

:emote

Initform

(error "emote required")

Readers

emote (generic function)

Writers

(setf emote) (generic function)

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 (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: emote
Initargs

:emote

Readers

emote (generic function)

Writers

(setf emote) (generic function)

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 (file)

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

:emote

Readers

emote (generic function)

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 (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: markup
Readers

markup (generic function)

Writers

(setf markup) (generic function)

Class: end-request ()

A request to end the dialogue.

See REQUEST

Package

org.shirakumo.fraf.speechless

Source

vm.lisp (file)

Direct superclasses

request (class)

Class: eval ()

Instruction to evaluate a piece of Lisp code.

See FORM

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

fake-instruction (class)

Direct methods
  • walk (method)
  • parse-instruction (method)
  • form (method)
  • form (method)
Direct slots
Slot: form
Initargs

:form

Initform

(error "form required")

Readers

form (generic function)

Writers

(setf form) (generic function)

Class: eval ()

An instruction to execute a Lisp function.

See FUNC
See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: func
Initargs

:func

Readers

func (generic function)

Writers

(setf func) (generic function)

Class: go ()

Instruction to jump to a specific component.

See ORG.SHIRAKUMO.MARKLESS.COMPONENTS:TARGET

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

fake-instruction (class)

Direct methods
  • walk (method)
  • parse-instruction (method)
  • target (method)
  • target (method)
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Class: input-request ()

Base class for requests that require user input.

See REQUEST

Package

org.shirakumo.fraf.speechless

Source

vm.lisp (file)

Direct superclasses

request (class)

Direct subclasses
Class: instruction ()

Base class for a dialogue instruction.

See INDEX
See LABEL

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
  • run-pass (method)
  • emit (method)
  • disassemble (method)
  • print-object (method)
  • initialize-instance (method)
  • label (method)
  • label (method)
  • index (method)
  • index (method)
Direct slots
Slot: index
Initargs

:index

Readers

index (generic function)

Writers

(setf index) (generic function)

Slot: label
Initargs

:label

Readers

label (generic function)

Writers

(setf label) (generic function)

Class: jump ()

Directive representing a jump to another label.

Syntax: "< label"

Package

org.shirakumo.fraf.speechless.syntax

Source

syntax.lisp (file)

Direct superclasses

singular-line-directive (class)

Direct methods
  • begin (method)
  • prefix (method)
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 (file)

Direct superclasses

block-component (class)

Direct methods
  • walk (method)
  • target (method)
  • target (method)
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Class: jump ()

An instruction that jumps to another instruction index.

See TARGET
See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct subclasses

commit-choice (class)

Direct methods
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required.")

Readers

target (generic function)

Writers

(setf target) (generic function)

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 (file)

Direct superclasses

pass (class)

Direct methods
Direct slots
Slot: label-map
Initform

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

Readers

label-map (generic function)

Class: label ()

Directive representing a label.

Syntax: "> label"

Package

org.shirakumo.fraf.speechless.syntax

Source

syntax.lisp (file)

Direct superclasses

singular-line-directive (class)

Direct methods
  • invoke (method)
  • begin (method)
  • prefix (method)
Class: move ()

Instruction to move a character to another position.

See ENTITY
See TARGET

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

fake-instruction (class)

Direct methods
  • parse-instruction (method)
  • target (method)
  • target (method)
  • entity (method)
  • entity (method)
Direct slots
Slot: entity
Initargs

:entity

Initform

(error "entity required")

Readers

entity (generic function)

Writers

(setf entity) (generic function)

Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Class: noop ()

A no-operation instruction. Does nothing.

See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct methods

execute (method)

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 (file)

Direct superclasses

pass (class)

Direct methods
Direct slots
Slot: label-map
Initform

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

Readers

label-map (generic function)

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 (file)

Direct superclasses

parser (class)

Direct Default Initargs
InitargValue
:directivesorg.shirakumo.fraf.speechless.syntax:*default-directives*
:instruction-typesorg.shirakumo.fraf.speechless.syntax:*default-instruction-types*
Class: part-separator ()

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

Syntax: "|"

Package

org.shirakumo.fraf.speechless.syntax

Source

syntax.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
  • begin (method)
  • prefix (method)
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 (file)

Direct superclasses

standard-object (class)

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 (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: duration
Initargs

:duration

Readers

duration (generic function)

Writers

(setf duration) (generic function)

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 (file)

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

:duration

Readers

duration (generic function)

Class: placeholder ()

Directive for a dynamic piece of text.

Syntax: "{form}"

Package

org.shirakumo.fraf.speechless.syntax

Source

syntax.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
  • begin (method)
  • prefix (method)
Class: placeholder ()

A component representing a dynamic piece of text.

See FORM

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

inline-component (class)

Direct methods
  • walk (method)
  • form (method)
  • form (method)
Direct slots
Slot: form
Initargs

:form

Initform

(error "form required")

Readers

form (generic function)

Writers

(setf form) (generic function)

Class: placeholder ()

An instruction representing a dynamic piece of text.

See FUNC
See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: func
Initargs

:func

Readers

func (generic function)

Writers

(setf func) (generic function)

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 (file)

Direct superclasses

standard-object (class)

Direct subclasses
Class: setf ()

Instruction to set a place.

See PLACE
See FORM

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

fake-instruction (class)

Direct methods
  • walk (method)
  • parse-instruction (method)
  • form (method)
  • form (method)
  • place (method)
  • place (method)
Direct slots
Slot: place
Initargs

:place

Initform

(error "place required")

Readers

place (generic function)

Writers

(setf place) (generic function)

Slot: form
Initargs

:form

Initform

(error "form required")

Readers

form (generic function)

Writers

(setf form) (generic function)

Class: source ()

Directive for a speaking source.

Syntax: "~ source"

Package

org.shirakumo.fraf.speechless.syntax

Source

syntax.lisp (file)

Direct superclasses

blockquote-header (class)

Direct methods

begin (method)

Class: source ()

A component representing someone speaking.

See NAME

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

blockquote-header (class)

Direct methods
  • name (method)
  • name (method)
Direct slots
Slot: name
Initargs

:name

Initform

(error "name required")

Readers

name (generic function)

Writers

(setf name) (generic function)

Class: source ()

An instruction representing a change in the speaking source.

See NAME
See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Writers

(setf name) (generic function)

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 (file)

Direct superclasses

target-request (class)

Direct methods

name (method)

Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Class: speed ()

Instruction to change the letter scroll speed.

See SPEED (function)

Package

org.shirakumo.fraf.speechless.components

Source

components.lisp (file)

Direct superclasses

fake-instruction (class)

Direct methods
  • parse-instruction (method)
  • speed (method)
  • speed (method)
Direct slots
Slot: speed
Initargs

:speed

Initform

(error "speed required")

Readers

speed (generic function)

Writers

(setf speed) (generic function)

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 (file)

Direct superclasses

request (class)

Direct subclasses
Direct methods

target (method)

Direct slots
Slot: target
Initargs

:target

Readers

target (generic function)

Class: text ()

An instruction to output a piece of text.

See TEXT (function)
See INSTRUCTION

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: text
Initargs

:text

Readers

text (generic function)

Writers

(setf text) (generic function)

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 (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
  • print-object (method)
  • markup (method)
  • text (method)
Direct slots
Slot: text
Initargs

:text

Readers

text (generic function)

Slot: markup
Initargs

:markup

Readers

markup (generic function)

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 (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: instructions
Readers

instructions (generic function)

Writers

(setf instructions) (generic function)

Slot: text-buffer
Initform

(make-string-output-stream)

Readers

text-buffer (generic function)

Slot: choices
Readers

choices (generic function)

Writers

(setf choices) (generic function)

Slot: markup
Readers

markup (generic function)

Writers

(setf markup) (generic function)


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

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

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 (file)

Special Variable: *placeholder-readtable*
Package

org.shirakumo.fraf.speechless.syntax

Source

syntax.lisp (file)

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 (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Functions

Function: compile-form ASSEMBLY FORM
Package

org.shirakumo.fraf.speechless

Source

compiler.lisp (file)

Function: find-new-index TARGET
Package

org.shirakumo.fraf.speechless

Source

optimizers.lisp (file)

Function: print-instruction-type INSTRUCTION
Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Function: random-indicator-p FORM
Package

org.shirakumo.fraf.speechless

Source

compiler.lisp (file)

Function: simulate THING
Package

org.shirakumo.fraf.speechless

Source

vm.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Generic functions

Generic Function: 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

Writer

(setf action) (generic function)

Methods
Method: action (CAMERA camera)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf action) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

action (generic function)

Methods
Method: (setf action) NEW-VALUE (CAMERA camera)

automatically generated writer method

Source

components.lisp (file)

Generic Function: end OBJECT
Generic Function: (setf end) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Methods
Method: end (BEGIN-MARK begin-mark)

automatically generated reader method

Source

instructions.lisp (file)

Method: (setf end) NEW-VALUE (BEGIN-MARK begin-mark)

automatically generated writer method

Source

instructions.lisp (file)

Generic Function: entity OBJECT

Accesses a designator for the entity to move.

See MOVE

Package

org.shirakumo.fraf.speechless.components

Writer

(setf entity) (generic function)

Methods
Method: entity (MOVE move)

automatically generated reader method

Source

components.lisp (file)

Generic Function: (setf entity) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless.components

Reader

entity (generic function)

Methods
Method: (setf entity) NEW-VALUE (MOVE move)

automatically generated writer method

Source

components.lisp (file)

Generic Function: func OBJECT

Accesses the function associated with the instruction.

See DISPATCH
See PLACEHOLDER
See EVAL

Package

org.shirakumo.fraf.speechless

Writer

(setf func) (generic function)

Methods
Method: func (EVAL eval)

automatically generated reader method

Source

instructions.lisp (file)

Method: func (PLACEHOLDER placeholder)

automatically generated reader method

Source

instructions.lisp (file)

Method: func (DISPATCH dispatch)

automatically generated reader method

Source

instructions.lisp (file)

Generic Function: (setf func) NEW-VALUE OBJECT
Package

org.shirakumo.fraf.speechless

Reader

func (generic function)

Methods
Method: (setf func) NEW-VALUE (EVAL eval)

automatically generated writer method

Source

instructions.lisp (file)

Method: (setf func) NEW-VALUE (PLACEHOLDER placeholder)

automatically generated writer method

Source

instructions.lisp (file)

Method: (setf func) NEW-VALUE (DISPATCH dispatch)

automatically generated writer method

Source

instructions.lisp (file)

Generic Function: 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
Method: label-map (NOOP-ELIMINATION-PASS noop-elimination-pass)

automatically generated reader method

Source

optimizers.lisp (file)

Method: label-map (JUMP-RESOLUTION-PASS jump-resolution-pass)

automatically generated reader method

Source

optimizers.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Classes

Class: dispatch ()

An instruction that represents a branching dispatch.

See FUNC
See TARGETS

Package

org.shirakumo.fraf.speechless

Source

instructions.lisp (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: func
Initargs

:func

Readers

func (generic function)

Writers

(setf func) (generic function)

Slot: targets
Initargs

:targets

Readers

targets (generic function)

Writers

(setf targets) (generic function)

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 (file)

Direct superclasses

instruction (class)

Direct subclasses
Direct methods

evaluate-instruction (method)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   S  
Index Entry  Section

F
File, Lisp, speechless.asd: The speechless․asd file
File, Lisp, speechless/compiler.lisp: The speechless/compiler․lisp file
File, Lisp, speechless/components.lisp: The speechless/components․lisp file
File, Lisp, speechless/documentation.lisp: The speechless/documentation․lisp file
File, Lisp, speechless/instructions.lisp: The speechless/instructions․lisp file
File, Lisp, speechless/optimizers.lisp: The speechless/optimizers․lisp file
File, Lisp, speechless/package.lisp: The speechless/package․lisp file
File, Lisp, speechless/syntax.lisp: The speechless/syntax․lisp file
File, Lisp, speechless/vm.lisp: The speechless/vm․lisp file

L
Lisp File, speechless.asd: The speechless․asd file
Lisp File, speechless/compiler.lisp: The speechless/compiler․lisp file
Lisp File, speechless/components.lisp: The speechless/components․lisp file
Lisp File, speechless/documentation.lisp: The speechless/documentation․lisp file
Lisp File, speechless/instructions.lisp: The speechless/instructions․lisp file
Lisp File, speechless/optimizers.lisp: The speechless/optimizers․lisp file
Lisp File, speechless/package.lisp: The speechless/package․lisp file
Lisp File, speechless/syntax.lisp: The speechless/syntax․lisp file
Lisp File, speechless/vm.lisp: The speechless/vm․lisp file

S
speechless.asd: The speechless․asd file
speechless/compiler.lisp: The speechless/compiler․lisp file
speechless/components.lisp: The speechless/components․lisp file
speechless/documentation.lisp: The speechless/documentation․lisp file
speechless/instructions.lisp: The speechless/instructions․lisp file
speechless/optimizers.lisp: The speechless/optimizers․lisp file
speechless/package.lisp: The speechless/package․lisp file
speechless/syntax.lisp: The speechless/syntax․lisp file
speechless/vm.lisp: The speechless/vm․lisp file

Jump to:   F   L   S  

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

A.2 Functions

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

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

A
action: Internal generic functions
action: Internal generic functions
arguments: Exported generic functions
arguments: Exported generic functions

C
choices: Exported generic functions
choices: Exported generic functions
choices: Exported generic functions
choices: Exported generic functions
choices: Exported generic functions
clauses: Exported generic functions
clauses: Exported generic functions
clauses: Exported generic functions
clauses: Exported generic functions
compile: Exported generic functions
compile: Exported generic functions
compile: Exported generic functions
compile: Exported generic functions
compile: Exported generic functions
compile*: Exported functions
compile-form: Internal functions

D
define-markup-walker: Exported macros
define-simple-walker: Exported macros
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
disassemble: Exported generic functions
duration: Exported generic functions
duration: Exported generic functions
duration: Exported generic functions

E
emit: Exported generic functions
emit: Exported generic functions
emote: Exported generic functions
emote: Exported generic functions
emote: Exported generic functions
emote: Exported generic functions
emote: Exported generic functions
end: Internal generic functions
end: Internal generic functions
entity: Internal generic functions
entity: Internal generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions
execute: Exported generic functions

F
find-new-index: Internal functions
form: Exported generic functions
form: Exported generic functions
form: Exported generic functions
form: Exported generic functions
form: Exported generic functions
func: Internal generic functions
func: Internal generic functions
func: Internal generic functions
func: Internal generic functions
Function, compile*: Exported functions
Function, compile-form: Internal functions
Function, find-new-index: Internal functions
Function, optimize-instructions: Exported functions
Function, parse: Exported functions
Function, print-instruction-type: Internal functions
Function, random-indicator-p: Internal functions
Function, resolved-target: Exported functions
Function, simulate: Internal functions

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

I
index: Exported generic functions
index: Exported generic functions
instructions: Exported generic functions
instructions: Exported generic functions
instructions: Exported generic functions

L
label: Exported generic functions
label: Exported generic functions
label-map: Internal generic functions
label-map: Internal generic functions
label-map: Internal generic functions

M
Macro, define-markup-walker: Exported macros
Macro, define-simple-walker: Exported macros
markup: Exported generic functions
markup: Exported generic functions
markup: Exported generic functions
markup: Exported generic functions
markup: Exported generic functions
Method, (setf action): Internal generic functions
Method, (setf arguments): Exported generic functions
Method, (setf choices): Exported generic functions
Method, (setf choices): Exported generic functions
Method, (setf clauses): Exported generic functions
Method, (setf clauses): Exported generic functions
Method, (setf duration): Exported generic functions
Method, (setf emote): Exported generic functions
Method, (setf emote): Exported generic functions
Method, (setf end): Internal generic functions
Method, (setf entity): Internal generic functions
Method, (setf form): Exported generic functions
Method, (setf form): Exported generic functions
Method, (setf form): Exported generic functions
Method, (setf form): Exported generic functions
Method, (setf func): Internal generic functions
Method, (setf func): Internal generic functions
Method, (setf func): Internal generic functions
Method, (setf index): Exported generic functions
Method, (setf instructions): Exported generic functions
Method, (setf instructions): Exported generic functions
Method, (setf label): Exported generic functions
Method, (setf markup): Exported generic functions
Method, (setf markup): Exported generic functions
Method, (setf markup): Exported generic functions
Method, (setf name): Exported generic functions
Method, (setf name): Exported generic functions
Method, (setf place): Exported generic functions
Method, (setf speed): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf targets): Exported generic functions
Method, (setf text): Exported generic functions
Method, action: Internal generic functions
Method, arguments: Exported generic functions
Method, choices: Exported generic functions
Method, choices: Exported generic functions
Method, choices: Exported generic functions
Method, clauses: Exported generic functions
Method, clauses: Exported generic functions
Method, compile: Exported generic functions
Method, compile: Exported generic functions
Method, compile: Exported generic functions
Method, compile: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, disassemble: Exported generic functions
Method, duration: Exported generic functions
Method, duration: Exported generic functions
Method, emit: Exported generic functions
Method, emote: Exported generic functions
Method, emote: Exported generic functions
Method, emote: Exported generic functions
Method, end: Internal generic functions
Method, entity: Internal generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, execute: Exported generic functions
Method, form: Exported generic functions
Method, form: Exported generic functions
Method, form: Exported generic functions
Method, form: Exported generic functions
Method, func: Internal generic functions
Method, func: Internal generic functions
Method, func: Internal generic functions
Method, index: Exported generic functions
Method, instructions: Exported generic functions
Method, instructions: Exported generic functions
Method, label: Exported generic functions
Method, label-map: Internal generic functions
Method, label-map: Internal generic functions
Method, markup: Exported generic functions
Method, markup: Exported generic functions
Method, markup: Exported generic functions
Method, markup: Exported generic functions
Method, name: Exported generic functions
Method, name: Exported generic functions
Method, name: Exported generic functions
Method, next-index: Exported generic functions
Method, place: Exported generic functions
Method, pop-text: Exported generic functions
Method, reset: Exported generic functions
Method, resume: Exported generic functions
Method, run: Exported generic functions
Method, run: Exported generic functions
Method, run: Exported generic functions
Method, run-pass: Exported generic functions
Method, run-pass: Exported generic functions
Method, run-pass: Exported generic functions
Method, run-pass: Exported generic functions
Method, run-pass: Exported generic functions
Method, run-pass: Exported generic functions
Method, run-pass: Exported generic functions
Method, run-pass: Exported generic functions
Method, run-pass: Exported generic functions
Method, run-pass: Exported generic functions
Method, speed: Exported generic functions
Method, suspend: Exported generic functions
Method, target: Exported generic functions
Method, target: Exported generic functions
Method, targets: Exported generic functions
Method, targets: Exported generic functions
Method, text: Exported generic functions
Method, text: Exported generic functions
Method, text: Exported generic functions
Method, text-buffer: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, walk: Exported generic functions
Method, wrap-lexenv: Exported generic functions

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

O
optimize-instructions: Exported functions

P
parse: Exported functions
place: Exported generic functions
place: Exported generic functions
pop-text: Exported generic functions
pop-text: Exported generic functions
print-instruction-type: Internal functions

R
random-indicator-p: Internal functions
reset: Exported generic functions
reset: Exported generic functions
resolved-target: Exported functions
resume: Exported generic functions
resume: Exported generic functions
run: Exported generic functions
run: Exported generic functions
run: Exported generic functions
run: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions
run-pass: Exported generic functions

S
simulate: Internal functions
speed: Exported generic functions
speed: Exported generic functions
suspend: Exported generic functions
suspend: Exported generic functions

T
target: Exported generic functions
target: Exported generic functions
target: Exported generic functions
targets: Exported generic functions
targets: Exported generic functions
targets: Exported generic functions
text: Exported generic functions
text: Exported generic functions
text: Exported generic functions
text: Exported generic functions
text-buffer: Exported generic functions
text-buffer: Exported generic functions

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

Jump to:   (  
A   C   D   E   F   G   I   L   M   N   O   P   R   S   T   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

*
*default-directives*: Exported special variables
*default-instruction-types*: Exported special variables
*optimization-passes*: Internal special variables
*placeholder-readtable*: Internal special variables
*root*: Internal special variables

A
action: Exported classes
arguments: Exported classes

C
choices: Exported classes
choices: Exported classes
choices: Exported classes
clauses: Exported classes
clauses: Exported classes

D
duration: Exported classes
duration: Exported classes

E
emote: Exported classes
emote: Exported classes
emote: Exported classes
end: Exported classes
entity: Exported classes

F
form: Exported classes
form: Exported classes
form: Exported classes
form: Exported classes
func: Exported classes
func: Exported classes
func: Internal classes

I
index: Exported classes
instructions: Exported classes
instructions: Exported classes

L
label: Exported classes
label-map: Exported classes
label-map: Exported classes

M
markup: Exported classes
markup: Exported classes
markup: Exported classes
markup: Exported classes

N
name: Exported classes
name: Exported classes
name: Exported classes

P
place: Exported classes

S
Slot, action: Exported classes
Slot, arguments: Exported classes
Slot, choices: Exported classes
Slot, choices: Exported classes
Slot, choices: Exported classes
Slot, clauses: Exported classes
Slot, clauses: Exported classes
Slot, duration: Exported classes
Slot, duration: Exported classes
Slot, emote: Exported classes
Slot, emote: Exported classes
Slot, emote: Exported classes
Slot, end: Exported classes
Slot, entity: Exported classes
Slot, form: Exported classes
Slot, form: Exported classes
Slot, form: Exported classes
Slot, form: Exported classes
Slot, func: Exported classes
Slot, func: Exported classes
Slot, func: Internal classes
Slot, index: Exported classes
Slot, instructions: Exported classes
Slot, instructions: Exported classes
Slot, label: Exported classes
Slot, label-map: Exported classes
Slot, label-map: Exported classes
Slot, markup: Exported classes
Slot, markup: Exported classes
Slot, markup: Exported classes
Slot, markup: Exported classes
Slot, name: Exported classes
Slot, name: Exported classes
Slot, name: Exported classes
Slot, place: Exported classes
Slot, speed: Exported classes
Slot, target: Exported classes
Slot, target: Exported classes
Slot, target: Exported classes
Slot, target: Exported classes
Slot, target: Exported classes
Slot, targets: Exported classes
Slot, targets: Internal classes
Slot, text: Exported classes
Slot, text: Exported classes
Slot, text-buffer: Exported classes
Special Variable, *default-directives*: Exported special variables
Special Variable, *default-instruction-types*: Exported special variables
Special Variable, *optimization-passes*: Internal special variables
Special Variable, *placeholder-readtable*: Internal special variables
Special Variable, *root*: Internal special variables
speed: Exported classes

T
target: Exported classes
target: Exported classes
target: Exported classes
target: Exported classes
target: Exported classes
targets: Exported classes
targets: Internal classes
text: Exported classes
text: Exported classes
text-buffer: Exported 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   I   J   L   M   N   O   P   R   S   T   V  
Index Entry  Section

A
assembly: Exported classes

B
begin-mark: Exported classes

C
camera: Exported classes
choice-request: Exported classes
choose: Exported classes
Class, assembly: Exported classes
Class, begin-mark: Exported classes
Class, camera: Exported classes
Class, choice-request: Exported classes
Class, choose: Exported classes
Class, clear: Exported classes
Class, clear-request: Exported classes
Class, commit-choice: Exported classes
Class, conditional: Exported classes
Class, conditional: Exported classes
Class, conditional: Exported classes
Class, conditional-part: Exported classes
Class, conditional-part: Exported classes
Class, confirm: Exported classes
Class, confirm-request: Exported classes
Class, dispatch: Internal classes
Class, emote: Exported classes
Class, emote: Exported classes
Class, emote: Exported classes
Class, emote-request: Exported classes
Class, end-mark: Exported classes
Class, end-request: Exported classes
Class, eval: Exported classes
Class, eval: Exported classes
Class, fake-instruction: Internal classes
Class, go: Exported classes
Class, input-request: Exported classes
Class, instruction: Exported classes
Class, jump: Exported classes
Class, jump: Exported classes
Class, jump: Exported classes
Class, jump-resolution-pass: Exported classes
Class, label: Exported classes
Class, move: Exported classes
Class, noop: Exported classes
Class, noop-elimination-pass: Exported classes
Class, parser: Exported classes
Class, part-separator: Exported classes
Class, pass: Exported classes
Class, pause: Exported classes
Class, pause-request: Exported classes
Class, placeholder: Exported classes
Class, placeholder: Exported classes
Class, placeholder: Exported classes
Class, request: Exported classes
Class, setf: Exported classes
Class, source: Exported classes
Class, source: Exported classes
Class, source: Exported classes
Class, source-request: Exported classes
Class, speed: Exported classes
Class, target-request: Exported classes
Class, text: Exported classes
Class, text-request: Exported classes
Class, vm: Exported classes
clear: Exported classes
clear-request: Exported classes
commit-choice: Exported classes
conditional: Exported classes
conditional: Exported classes
conditional: Exported classes
conditional-part: Exported classes
conditional-part: Exported classes
confirm: Exported classes
confirm-request: Exported classes

D
dispatch: Internal classes

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

F
fake-instruction: Internal classes

G
go: Exported classes

I
input-request: Exported classes
instruction: Exported classes

J
jump: Exported classes
jump: Exported classes
jump: Exported classes
jump-resolution-pass: Exported classes

L
label: Exported classes

M
move: Exported classes

N
noop: Exported classes
noop-elimination-pass: Exported classes

O
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
parser: Exported classes
part-separator: Exported classes
pass: Exported classes
pause: Exported classes
pause-request: Exported classes
placeholder: Exported classes
placeholder: Exported classes
placeholder: Exported classes

R
request: Exported classes

S
setf: Exported classes
source: Exported classes
source: Exported classes
source: Exported classes
source-request: Exported classes
speechless: The speechless system
speed: Exported classes
System, speechless: The speechless system

T
target-request: Exported classes
text: Exported classes
text-request: Exported classes

V
vm: Exported classes

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