Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the cl-gamepad Reference Manual, version 2.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Wed Mar 25 17:16:23 2020 GMT+0.
| • Introduction | What cl-gamepad is all about | |
| • Systems | The systems documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
This is a small wrapper library around libstem_gamepad, providing independent gamepad input support.
Precompiled versions of the library are already provided in the repository for most major platforms. However, you may build your own version from the above repository if you so please.
Simply load cl-gamepad with ASDF or Quicklisp
(ql:quickload :cl-gamepad)
Before you can handle any devices, you must call init in order to set the environment up and prepare everything. If you would like to use a notification based mechanism, you should also define overrides for the device-attached, device-removed, button-pressed, button-released, and axis-moved functions. For illustrative purposes we will do so just for two of those here:
(defun cl-gamepad:device-attached (device)
(format T "~&Found new device: ~a" device))
(defun cl-gamepad:device-removed (device)
(format T "~&Device removed: ~a" device))
(cl-gamepad:init)
Next you need to call detect-devices whenever your application is ready to add new devices (this may or may not be always) and call process-events in your game/event/whatever loop to receive and process events. For simplicity's sake we will just call both in a loop here.
(loop (cl-gamepad:detect-devices)
(cl-gamepad:process-events)
(format T "~&Device status: ~&~a" (mapcar #'cl-gamepad:device-plist (cl-gamepad:devices)))
(sleep 0.5))
Note that the button and axis IDs you receive in the callback are just numbers and may differ between controllers and platforms. In order to help standardise this, cl-gamepad includes a device-map functionality. Using axis-label, axis-multiplier, and button-label, the various features can be normalised. See the corresponding docstrings for the defined set of labels and what they mean.
Unfortunately the mapping is not automatable and the current database of known devices included in cl-gamepad is rather small. It is thus very well possible that the functions will just return :unknown instead. However, using the visualizer below you can figure out that mapping and define it yourself. If you have a controller that isn't in the database yet, please take the time to map it out and send the definition to us, either as a PR or as an issue.
You can view and set the complete mapping for a given controller via device-map. It takes the controller's vendor and product IDs to identify the controller kind. Usually however you'll want a more convenient way to define a mapping, which you can do through define-gamepad. An example mapping for the Buffalo BSGP801 controller on Linux looks like this:
(define-gamepad buffalo-bsgp801 (1411 8288)
(:buttons
( 0 :b)
( 1 :a)
( 2 :x)
( 3 :y)
( 4 :l1)
( 5 :r1)
( 6 :select)
( 7 :start))
(:axes
( 0 :dpad-h)
( 1 :dpad-v)))
For a listing of existing device mappings, see the database-lin, database-mac, database-win files.
Finally, during shut down of your application -- or whenever you no longer want to receive input -- you should call shutdown to clean everything up.
(cl-gamepad:shutdown)
Cl-gamepad includes a little visualizer Qt application that lets you view the complete controller state graphically. You can use this to test the library, your controller, or figure out the ID mapping of the buttons and axis.
(ql:quickload :cl-gamepad-visualizer)
(cl-gamepad-visualizer:main)
By clicking on an axis or button you can assign the label you deem fitting to it. Once all the buttons and axes have been assigned, you can click on the export button to get a nicely formatted definition form that you can use to persist the configuration in code.
Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The cl-gamepad system |
Nicolas Hafner <shinmera@tymoon.eu>
Nicolas Hafner <shinmera@tymoon.eu>
(:git "https://github.com/shirakumo/cl-gamepad.git")
zlib
Bindings to libstem_gamepad, allowing the handling of gamepad input.
2.0.0
cl-gamepad.asd (file)
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
Next: The cl-gamepad/package․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
cl-gamepad.asd
cl-gamepad (system)
Next: The cl-gamepad/low-level․lisp file, Previous: The cl-gamepad․asd file, Up: Lisp files [Contents][Index]
cl-gamepad (system)
package.lisp
Next: The cl-gamepad/wrapper․lisp file, Previous: The cl-gamepad/package․lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
cl-gamepad (system)
low-level.lisp
Next: The cl-gamepad/documentation․lisp file, Previous: The cl-gamepad/low-level․lisp file, Up: Lisp files [Contents][Index]
low-level.lisp (file)
cl-gamepad (system)
wrapper.lisp
Next: The cl-gamepad/database-lin․lisp file, Previous: The cl-gamepad/wrapper․lisp file, Up: Lisp files [Contents][Index]
wrapper.lisp (file)
cl-gamepad (system)
documentation.lisp
Previous: The cl-gamepad/documentation․lisp file, Up: Lisp files [Contents][Index]
documentation.lisp (file)
cl-gamepad (system)
database-lin.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The cl-gamepad package | ||
| • The cl-gamepad-cffi package |
Next: The cl-gamepad-cffi package, Previous: Packages, Up: Packages [Contents][Index]
package.lisp (file)
org.shirakumo.fraf.gamepad
Previous: The cl-gamepad package, Up: Packages [Contents][Index]
package.lisp (file)
org.shirakumo.fraf.gamepad.cffi
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions | ||
| • Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported constants | ||
| • Exported macros | ||
| • Exported compiler macros | ||
| • Exported functions | ||
| • Exported generic functions | ||
| • Exported conditions | ||
| • Exported classes |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
Returns the maximum ID that can be referenced from a device-map.
low-level.lisp (file)
Next: Exported compiler macros, Previous: Exported constants, Up: Exported definitions [Contents][Index]
Define the mapping for a particular gamepad device.
The MAP should follow the same schema as the one defined in the
DEVICE-MAP docstring. if the INHERIT option is passed, the defined
mappings are merged together with those of the inherited gamepad
mapping definition. This allows you to easily define gamepads that
are otherwise very similar.
See DEVICE-MAP
See GAMEPAD-DEFINITION
wrapper.lisp (file)
Next: Exported functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
wrapper.lisp (file)
wrapper.lisp (file)
wrapper.lisp (file)
wrapper.lisp (file)
wrapper.lisp (file)
wrapper.lisp (file)
wrapper.lisp (file)
wrapper.lisp (file)
wrapper.lisp (file)
Next: Exported generic functions, Previous: Exported compiler macros, Up: Exported definitions [Contents][Index]
Returns a vector of the state of each axis on the gamepad device.
See DEVICE
See AXIS
wrapper.lisp (file)
Return the current state of a particular axis on the gamepad device.
The axis should be a number from 0 below DEVICE-AXIS-COUNT.
If an invalid axis id is passed, an INDEX-OUT-OF-RANGE error is
signalled.
Returned is a float in the range [-1 1].
The axis direction is normalised per the axis multiplier in the
corresponding device map.
See DEVICE
See AXIS-COUNT
wrapper.lisp (file)
Returns the number of axes the controller seems to have.
See DEVICE
wrapper.lisp (file)
Return the label for the given physical axis on the gamepad device.
The axis should be a number from 0 below DEVICE-AXIS-COUNT.
If an invalid axis id is passed, :UNKNOWN is returned.
Returned is a keyword out of the following set:
:unknown — An unknown axis. The default.
:l-h — The horizontal movement of the left analog stick.
:l-v — The vertical movement of the right analog stick.
:r-h — The horizontal movement of the right analog stick.
:r-v — The vertical movement of the right analog stick-
:dpad-h — The horizontal movement of the dpad.
:dpad-v — The vertical movement of the dpad.
:dpad-l — The movement of the left dpad button.
:dpad-r — The movement of the right dpad button.
:dpad-u — The movement of the up dpad button.
:dpad-d — The movement of the down dpad button.
:button-x — The amount the X (left) button is pressed.
:button-y — The amount the Y (up) button is pressed.
:button-z — The amount the Z button is pressed.
:button-a — The amount the A (down) button is pressed.
:button-b — The amount the B (right) button is pressed.
:button-c — The amount the C button is pressed.
:l1 — The amount the left upper trigger is pressed.
:l2 — The amount the left lower trigger is pressed.
:r1 — The amount the right upper trigger is pressed.
:r2 — The amount the right lower trigger is pressed.
:tilt-x — The tilting of the controller in X direction.
:tilt-y — The tilting of the controller in Y direction.
:tilt-z — The tilting of the controller in Z direction.
:move-x — The acceleration in X direction.
:move-y — The acceleration in Y direction.
:move-z — The acceleration in Z direction.
:wheel — The turning of the wheel.
:accelerator — The amount the accelerator is pressed.
:brake — The amount the brake is pressed.
:x — The movement of the joystick in X direction.
:y — The movement of the joystick in Y direction.
:z — The rotation of the joystick in Z direction.
:throttle — The value of the throttle.
The button map is mostly modelled after the XBOX360 controller.
See DEVICE
See DEVICE-MAP
wrapper.lisp (file)
This function is called whenever an axis is moved.
AXIS is an integer identifying the axis on the controller.
LAST-VALUE is a float representing the value of this axis at
the previous time AXIS-MOVED was called.
VALUE is a float representing the current value of this axis.
TIME is a float representing the time at which the movement
occurred precisely.
LAST-VALUE and VALUE are in the range of [-1 1].
Note that the values are NOT multiplied by the axis-multiplier
defined in the corresponding device map. You are responsible for
normalising the direction yourself.
You should override this function if you want to use a notification mechanism. By default this function does nothing.
This function is called in the same thread as the DETECT-DEVICES
or PROCESS-EVENTS call occurs that triggers it and may thus block
it.
See DEVICE
See DETECT-DEVICES
See PROCESS-EVENTS
low-level.lisp (file)
Return the multiplier for the axis value.
Returns either 1 or -1 depending on whether the value of the
axis should be inverted or not.
The axis should be a number from 0 below DEVICE-AXIS-COUNT.
If an invalid axis id is passed, 1 is returned.
See DEVICE
See DEVICE-MAP
wrapper.lisp (file)
Return the current state of a particular button on the gamepad device.
The button should be a number from 0 below DEVICE-BUTTON-COUNT.
If an invalid button id is passed, an INDEX-OUT-OF-RANGE error is
signalled.
Returned is T for pressed and NIL for released.
See DEVICE
See DEVICE-BUTTON-COUNT
wrapper.lisp (file)
Returns the number of buttons the controller seems to have.
See DEVICE
wrapper.lisp (file)
Return the label for the given physical button on the gamepad device.
The button should be a number from 0 below DEVICE-BUTTON-COUNT.
If an invalid button id is passed, :UNKNOWN is returned.
Returned is a keyword out of the following set:
:unknown — An unknown button. This is the default.
:x — The X (left) button.
:y — The Y (up) button.
:z — The Z button.
:a — The A (down) button.
:b — The B (right) button.
:c — The C button.
:l1 — The left upper trigger.
:l2 — The left lower trigger.
:r1 — The right upper trigger.
:r2 — The right lower trigger.
:l — Whether the left analog stick is pressed in.
:r — Whether the right analog stick is pressed in.
:dpad-l — The left direction of the dpad.
:dpad-r — The right direction of the dpad.
:dpad-u — The up direction of the dpad.
:dpad-d — The down direction of the dpad.
:select — The select (left) button.
:home — The home (center) button.
:start — The start (right) button.
:trigger — The trigger button.
The button map is mostly modelled after the XBOX360 controller.
See DEVICE
See DEVICE-MAP
wrapper.lisp (file)
This function is called whenever a button is pressed.
BUTTON is an integer identifying the button on the controller.
TIME is a float representing the time at which the movement
occurred precisely.
You should override this function if you want to use a notification mechanism. By default this function does nothing.
This function is called in the same thread as the DETECT-DEVICES
or PROCESS-EVENTS call occurs that triggers it and may thus block
it.
See DEVICE
See DETECT-DEVICES
See PROCESS-EVENTS
low-level.lisp (file)
This function is called whenever a button is released.
BUTTON is an integer identifying the button on the controller.
TIME is a float representing the time at which the movement
occurred precisely.
You should override this function if you want to use a notification mechanism. By default this function does nothing.
This function is called in the same thread as the DETECT-DEVICES
or PROCESS-EVENTS call occurs that triggers it and may thus block
it.
See DEVICE
See DETECT-DEVICES
See PROCESS-EVENTS
low-level.lisp (file)
Returns a vector of the state of each button on the gamepad device.
See DEVICE
See BUTTON
wrapper.lisp (file)
Returns the description string for the gamepad device.
See DEVICE
wrapper.lisp (file)
Polls for new devices.
May call DEVICE-ATTACHED BUTTON-PRESSED BUTTON-RELEASED AXIS-MOVED
New devices will not be noticed unless and until you call this function. As such you should call it at any time it is appropriate for new controllers to be introduced to your program.
wrapper.lisp (file)
Returns the device at the specified index.
The index should be a number from 0 below DEVICE-COUNT.
Passing an invalid number results in undefined behaviour, going
as far as potentially crashing your program.
See DEVICE
wrapper.lisp (file)
This function is called whenever a new device is attached.
You should override this function if you want to use a notification mechanism. By default this function does nothing.
This function is called in the same thread as the DETECT-DEVICES
call occurs that triggers it and may thus block it.
See DEVICE
See DETECT-DEVICES
low-level.lisp (file)
Accesses the number of axes the controller seems to have.
See DEVICE
low-level.lisp (file)
(setf device-axis-count) (function)
low-level.lisp (file)
device-axis-count (function)
Accesses the pointer to the float array that describes the state of the various axes.
See DEVICE
See DEVICE-AXIS
low-level.lisp (file)
(setf device-axis-states) (function)
low-level.lisp (file)
device-axis-states (function)
Accesses the number of buttons the controller seems to have.
See DEVICE
low-level.lisp (file)
(setf device-button-count) (function)
low-level.lisp (file)
device-button-count (function)
Accesses the pointer to the bool array that describes the state of the various buttons.
Note that the bools are not strict in the sense that anything greater than 0
should be taken as TRUE.
See DEVICE
See DEVICE-BUTTON
low-level.lisp (file)
(setf device-button-states) (function)
low-level.lisp (file)
device-button-states (function)
Returns an integer of how many devices we know of right now.
wrapper.lisp (file)
Accesses the description string for the gamepad device.
See DEVICE
low-level.lisp (file)
(setf device-description) (function)
low-level.lisp (file)
device-description (function)
Accesses the pointer to the device map that describes the button and axis layout.
See DEVICE
See DEVICE-MAP
low-level.lisp (file)
(setf device-device-map) (function)
low-level.lisp (file)
device-device-map (function)
Accesses the unique identifier for the gamepad device.
Starts at 0 and increases for each new gamepad that is detected.
If a particular gamepad is disconnected and later reconnected,
it will receive a different id.
See DEVICE
low-level.lisp (file)
(setf device-id) (function)
low-level.lisp (file)
device-id (function)
Accessor to the device map for the given vendor and product.
The device map assigns labels to the buttons and axes and normalises
the axes’ direction if necessary. The map is a list of the following
structure:
DEVICE-MAP ::= (BUTTON-MAP AXIS-MAP)
BUTTON-MAP ::= (:buttons BUTTON*)
BUTTON ::= (ID LABEL)
AXIS-MAP ::= (:axes AXIS*)
AXIS ::= (ID LABEL MULTIPLIER)
ID — A numerical ID of a button or axis
LABEL — The keyword label for the button or axis’ functionality.
MULTIPLIER — Either 1 or -1 to potentially reverse the axis’ direction.
See AXIS-LABEL and BUTTON-LABEL for the available labels and their
intended usage. A sample map for the Xbox360 controller as recognised
on Linux platforms follows.
((:axes
( 0 :l-h)
( 1 :l-v)
( 2 :l2)
( 3 :r-h)
( 4 :r-v)
( 5 :r2)
( 6 :dpad-h)
( 7 :dpad-v))
(:buttons
( 0 :a)
( 1 :b)
( 2 :x)
( 3 :y)
( 4 :l1)
( 5 :r1)
( 6 :select)
( 7 :start)
( 8 :home)
( 9 :l)
(10 :r)))
Note that the IDs for each button and axis are unfortunately very
much platform-dependent and a mapping for each platform must be
created individually.
wrapper.lisp (file)
(setf device-map) (function)
wrapper.lisp (file)
device-map (function)
Accessor to the C array of the axis mappings.
See DEVICE-MAP
low-level.lisp (file)
Accessor to the C array of the axis multipliers.
See DEVICE-MAP
low-level.lisp (file)
Accessor to the C array of the button mappings.
See DEVICE-MAP
low-level.lisp (file)
Constructs a plist from the device’s values.
Returned is:
(:ID id
:VENDOR vendor
:PRODUCT product
:DESCRIPTION description
:AXES axes
:BUTTONS buttons)
See ID
See VENDOR
See PRODUCT
See DESCRIPTION
See AXES
See BUTTONS
See DEVICE
wrapper.lisp (file)
Accesses the pointer to the private data of the gamepad device struct.
You should never need this.
See DEVICE
low-level.lisp (file)
(setf device-private-data) (function)
low-level.lisp (file)
device-private-data (function)
Accesses the product ID for the gamepad device.
This along with DEVICE-VENDOR may be useful to detect default
behaviour for a particular controller.
See DEVICE
low-level.lisp (file)
(setf device-product) (function)
low-level.lisp (file)
device-product (function)
This function is called whenever a device is removed.
You should override this function if you want to use a notification mechanism. By default this function does nothing.
This function is called in the same thread as the PROCESS-EVENTS
call occurs that triggers it and may thus block it.
See DEVICE
See PROCESS-EVENTS
low-level.lisp (file)
Accesses the vendor ID for the gamepad device.
This along with DEVICE-PRODUCT may be useful to detect default
behaviour for a particular controller.
See DEVICE
low-level.lisp (file)
(setf device-vendor) (function)
low-level.lisp (file)
device-vendor (function)
Returns a list of all known devices.
See DEVICE-COUNT
See DEVICE
wrapper.lisp (file)
Calls the Gamepad_axisMoveFunc C function, registering the callback function.
low-level.lisp (file)
Calls the Gamepad_buttonDownFunc C function, registering the callback function.
low-level.lisp (file)
Calls the Gamepad_buttonUpFunc C function, registering the callback function.
low-level.lisp (file)
Returns a string representation of a valid mapping definition for the given device.
This function is useful if you want to extract the available device
mapping information to turn it into a static gamepad definition as
used by DEFINE-GAMEPAD.
See DEFINE-GAMEPAD
wrapper.lisp (file)
Calls the Gamepad_detectDevices C function, leading to new devices being recognised.
low-level.lisp (file)
Calls the Gamepad_deviceAtIndex C function, returning a device pointer corresponding to the index.
low-level.lisp (file)
Calls the Gamepad_deviceAttachFunc C function, registering the callback function.
low-level.lisp (file)
Retrieves the device map for the given vendor and product. If no specific map is known, a generic one is returned.
low-level.lisp (file)
Calls the Gamepad_deviceRemoveFunc C function, registering the callback function.
low-level.lisp (file)
Calls the Gamepad_init C function to initialize the library.
low-level.lisp (file)
Calls the Gamepad_numDevices C function, returning the number of devices currently known to the library.
low-level.lisp (file)
Calls the Gamepad_processEvents C function, leading to input events being captured and the callbacks being invoked.
low-level.lisp (file)
Set the device map for a given vendor and product. The struct’s contents are copied, and you should free the one you pass in yourself.
low-level.lisp (file)
Calls the Gamepad_shutdown C function to clean up the library.
low-level.lisp (file)
Returns the unique identifier for the gamepad device.
Starts at 0 and increases for each new gamepad that is detected.
If a particular gamepad is disconnected and later reconnected,
it will receive a different id.
See DEVICE
wrapper.lisp (file)
Sets everything up and prepares the library to process input events.
This function must be called before any of the other functions
are called. It is safe to call this function any number of times
in sequence, but only one "actual" init is performed before
another SHUTDOWN.
See SHUTDOWN
wrapper.lisp (file)
wrapper.lisp (file)
wrapper.lisp (file)
Prints an unreadable representation of DEVICE to STREAM.
Useful for debugging prints.
See DEVICE
wrapper.lisp (file)
Processes input events from all known controllers.
May call DEVICE-REMOVED BUTTON-PRESSED BUTTON-RELEASED AXIS-MOVED
If a device is unplugged, you will not be notified of this until this function is called. The corresponding DEVICE-REMOVED function is then called. If a new device is plugged in, events for it will not be processed until it is registered through DETECT-DEVICES.
See DETECT-DEVICES
wrapper.lisp (file)
Returns the product ID for the gamepad device.
This along with DEVICE-VENDOR may be useful to detect default
behaviour for a particular controller.
See DEVICE
wrapper.lisp (file)
Cleans everything up so that it’s back to being tidy and neat.
No other functions but INIT should ever be called after this
function has been called. It is safe to call this function any
number of times in sequence, but only one "actual" shutdown
is performed before another INIT.
See INIT
wrapper.lisp (file)
Update the device map for a select few records.
Unlike (SETF DEVICE-MAP) this does not clear out the mappings that
are not explicitly given, and instead leaves those to their default
values.
See DEVICE-MAP
wrapper.lisp (file)
Returns the vendor ID for the gamepad device.
This along with DEVICE-PRODUCT may be useful to detect default
behaviour for a particular controller.
See DEVICE
wrapper.lisp (file)
Next: Exported conditions, Previous: Exported functions, Up: Exported definitions [Contents][Index]
Reader to the index that the condition happened on.
See INDEX-OUT-OF-RANGE
wrapper.lisp (file)
Reader to the range that the condition happened on.
See INDEX-OUT-OF-RANGE
wrapper.lisp (file)
Next: Exported classes, Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
Condition signalled when an index is out of its allowed range.
See INDEX
See RANGE
wrapper.lisp (file)
error (condition)
:index
index (generic function)
:range
range (generic function)
Previous: Exported conditions, Up: Exported definitions [Contents][Index]
C struct that contains all relevant information about a gamepad device.
You should never SETF any of its fields unless you really
know what you’re doing. Passing a pointer to this struct
outside of the dynamic-extent in which it was provided will
cause undefined behaviour and even lead as far as crashing
your program. If you need to pass it around, you should use
DEVICE-PLIST to serialise it.
See ID
See VENDOR
See PRODUCT
See DESCRIPTION
See AXIS-COUNT
See AXIS
See AXIS-LABEL
See AXIS-MULTIPLIER
See AXES
See BUTTON-COUNT
See BUTTON
See BUTTON-LABEL
See BUTTONS
See DEVICE-PLIST
See DEVICE-MAP
See UPDATE-DEVICE-MAP
See DEVICE-ID
See DEVICE-VENDOR
See DEVICE-PRODUCT
See DEVICE-DESCRIPTION
See DEVICE-AXIS-COUNT
See DEVICE-AXIS-STATES
See DEVICE-BUTTON-COUNT
See DEVICE-BUTTON-STATES
See DEVICE-DEVICE-MAP
See DEVICE-PRIVATE-DATA
See DETECT-DEVICES
low-level.lisp (file)
Contains information to map physical buttons and axes to standardised labels relating to their function.
The map contains three particular mappings, limited to at most
a physical ID of DEVICE-MAP-MAX minus one.
button map — Each slot maps to a BUTTON enum value that
describes the button’s function.
axis map — Each slot maps to an AXIS enum value that
describes the axis’ function.
axis multiplier — Each slot maps to a char of either 1 or -1
representing a multiplier to standardise the
axis’ direction.
Note that the functionality of the buttons and axes should be
normalised based on the layout of an XBOX 360 controller.
See DEVICE-MAP-MAX
See BUTTON
See AXIS
See DEVICE-MAP-BUTTON-MAP
See DEVICE-MAP-BUTTONS
See DEVICE-MAP-AXIS-MAP
See DEVICE-MAP-AXES
See DEVICE-MAP-AXIS-MULTIPLIER
See DEVICE-MAP-AXIS-MULTIPLIERS
low-level.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal special variables | ||
| • Internal macros | ||
| • Internal functions |
Next: Internal macros, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
low-level.lisp (file)
wrapper.lisp (file)
low-level.lisp (file)
wrapper.lisp (file)
Next: Internal functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
wrapper.lisp (file)
low-level.lisp (file)
Previous: Internal macros, Up: Internal definitions [Contents][Index]
low-level.lisp (file)
low-level.lisp (file)
low-level.lisp (file)
wrapper.lisp (file)
wrapper.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index | ||
| • Function index | ||
| • Variable index | ||
| • Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | C F L |
|---|
| Jump to: | C F L |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | (
A B C D F G I L M P R S U V W |
|---|
| Jump to: | (
A B C D F G I L M P R S U V W |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | *
C D I R S |
|---|
| Jump to: | *
C D I R S |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | C D I P S |
|---|
| Jump to: | C D I P S |
|---|