The wasm-encoder Reference Manual

This is the wasm-encoder Reference Manual, version 0.2, generated automatically by Declt version 3.0 "Montgomery Scott" on Sun May 15 06:26:51 2022 GMT+0.

1 Introduction

= WASM-ENCODER =
:AUTHOR: Alexander Gutev
:EMAIL: 
:toc: preamble
:toclevels: 4
:icons: font
:idprefix:

ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:caution-caption: :fire:
:important-caption: :exclamation:
:warning-caption: :warning:
endif::[]

This is a simple library for serializing a representation of
WebAssembly modules to the binary wasm format.

== Documentation ==

[[value_types]]
=== Value Types ===

The value types of various entities, such as global variables,
function arguments and return values, local and global variables, are
identified by the following symbols:

.Numeric Types
`I32`:: 32-bit integer
`I64`:: 64-bit integer
`F32`:: 32-bit single precision floating point value
`F64`:: 64-bit double precision floating point value

.Reference Types
`FUNCREF`:: Function reference
`EXTERNREF`:: All reference objects that can be passed to WebAssembly

NOTE: A symbol is considered equivalent to one of the above if its
symbol name is equivalent, regardless of its package. Thus you don't
have to import `I32`, etc from the `WASM-ENCODER` package.

=== Instructions ===

A WebAssembly instruction is represented by a symbol of which the
symbol name is equal to the instruction's mnemonic. Any symbol, in any
package, with a symbol name that is equal to a WebAssembly instruction
mnemonic can be used.

Instructions which accept static options are represented by a list in
which the first element (the `CAR`) is the instruction mnemonic and
the remaining elements are the options. The interpretation of the
options depends on the instruction.

==== Branch Instructions ====

The `BR` and `BR_IF` branch instructions each take a single option, an
unsigned integer interpreted as the index of the block which is the
branch target.

The `BR_TABLE` takes a variable number of options, where each option
is an unsigned integer, interpreted as a block index.

.Examples
--------------------------------------------------
(BR 0)            ;; Branch to block 0
(BR_IF 2)         ;; Branch to block 2
(BR_TABLE 0 1 2)
--------------------------------------------------

==== Call Instructions ====

The `CALL` instruction takes a single option, an unsigned integer
interpreted as the index of the function being called.

The `CALL_INDIRECT` instruction takes a single option, an unsigned
integer interpreted as the index, within the type section, of the
function's type signature.

.Examples
--------------------------------------------------
(CALL 5)             ;; Call function 5
(CALL_INDIRECT 2)    ;; Indirect call to a function with type signature index 2
--------------------------------------------------

==== Select Instruction ====

The select instruction takes an optional list of type identifier which
represent the value types of the operands to be selected. If there is
more than one type specifier then there is more than one value per
operand.

.Example
--------------------------------------------------
(select f32 f64)
--------------------------------------------------

In the above example `SELECT` consumes, off the stack, two operands,
following the condition, each consisting of two values the first being
an `F32` and the second being an `F64`. The two values of the result
operand, of type `F32` and `F64`, are pushed back onto the stack.

If `SELECT` is not given the type identifier of it's operand values,
the operands must be of a numeric type.

NOTE: In the current version of WebAssembly `SELECT` may only specify
a single value type, for a single value per operand. This library
supports `SELECT` with multiple operand value types.

==== Local and Global Variable Instructions ====

The instructions for retrieving/setting the value of a local/global
variable, each take a single options, an unsigned integer interpreted
as the local/global variable index.

 - `LOCAL.GET`
 - `LOCAL.SET`
 - `LOCAL.TEE`
 - `GLOBAL.GET`
 - `GLOBAL.SET`

==== Memory Instructions ====

Memory load/store instructions take an optional list specifying the
expected alignment and offset. These operands take the following form:

--------------------------------------------------
(I32.STORE (ALIGN a) (OFFSET o)) ;; Alignment = a, Offset = o
--------------------------------------------------

The alignment option is a list of two elements where the first element
is a symbol, with name `ALIGN`, and the second element is an unsigned
integer specifying the alignment as a power of two. If the alignment
option is omitted a default alignment of `2` is assumed.

The offset option is a list of two elements where the first element is
a symbol, with name `OFFSET`, and the second element is an unsigned
integer specifying the offset. If this option is omitted a default
offset of `0` is assumed.

TIP: As with the instruction mnemonics any symbol, in any package,
with symbol name `ALIGN` or `OFFSET` can be used to specify the
alignment and offset options.

The alignment and offset options can be specified in any order and
either one, or both, can be omitted. If both options are omitted the
instruction can either take the form of a list containing only the
instruction mnemonic, or the instruction mnemonic symbol by itself.

.Examples:
--------------------------------------------------
(I32.LOAD (OFFSET 8)) ;; Offset = 8
(I32.STORE (ALIGN 1)) ;; Alignment = 1
I64.STORE             ;; Default Alignment = 2 and Offset = 0
--------------------------------------------------

The instructions falling within this group are all the typed `xx.LOAD`
and `xx.STORE` instructions (where `xx` is the value type), including
the instructions with a storage size which is smaller than the size of
the type.

==== Constant Instructions ====

Constant instructions take a single option which is the literal
constant value.

- `I32.CONST` and `I64.CONST` take either a signed or unsigned 32-bit
  (64-bit in the case of `I64.CONST`) integer option. However,
  regardless of whether the operand value is signed or not, the value
  itself is always encoded as a signed integer in twos-complement.

- `F32.CONST` takes a single precision floating-point
  (`SINGLE-FLOAT`) value as its option.

- `F64.CONST` takes either a single or double precision floating-point
   value as its option.

==== Reference Instructions ====

The `REF.NULL` instruction takes a single option which is interpreted
as the reference type identifier, either `FUNCREF` or `EXTERNREF`. See
<>.

The `REF.FUNC` instruction takes a single option, an unsigned integer
interpreted as the index of the function, within the function section,
to which to return a reference.

==== Memory and Table Instructions ====

The `MEMORY.INIT` and `DATA.DROP` instructions both take a single
option, an unsigned integer which is interpreted as the index of a
data segment within the data section.

The `TABLE.INIT` and `TABLE.COPY` instructions take two options, both
unsigned integers which are interpreted as a table index and element
segment index.

The `ELEM.DROP` instruction takes a single instruction, an unsigned
integer interpreted as an element segment index.

The `TABLE.GET`, `TABLE.SET`, `TABLE.SIZE`, `TABLE.GROW` and
`TABLE.FILL` instructions each take a single option, an unsigned
integer interpreted as a table index.

==== Structured Block Instructions ====

Structured block instructions are represented by a list with the block
type in the first element being and the instructions, comprising the
body of the block, in the remaining elements.

The second element of the list may be either an instruction, in which
case it is the first instruction of the block, or one of the
following:

`(RESULT type)`:: Indicates the type of value returned (on the stack)
by the block, where `type` is the value type identifier, see
<>.

`(TYPE index)`:: Indicates the of the values consumed (from the stack)
and returned by the block, where `index` is the index of a function
type specifier, with the type section, see <>.

If neither a result type nor type signature is specified, then it is
assumed that the block neither consumes nor returns a value and hence
does not have a return value type.

The `BLOCK` and `LOOP` block instructions follow this representation
exactly.

.Example: Simple block (no result type)
--------------------------------------------------
(block
  (local.get 1)
  (br_if 0)
  (call 0))
--------------------------------------------------

.Example: Block with result type
--------------------------------------------------
(block (result i32)
  (local.get 1)
  (br_if 0)

  (local.get 2)
  (local.get 3)
  i32.add)
--------------------------------------------------

.Example: Block with type signature
--------------------------------------------------
(block (type 1) ;; (i32 i32 i32) => i32
  i32.add
  i32.mul)
--------------------------------------------------

.Example: Simple loop
--------------------------------------------------
(loop
  (call 0)
  (local.get 1)
  (i32.const 5)
  i32.lt
  (br_if 0))
--------------------------------------------------

The `IF` instruction is represented by a list of the following form:

--------------------------------------------------
(IF (THEN instructions...)
    (ELSE instructions...))
--------------------------------------------------

Where `instructions` are the instructions comprising the body of the
`THEN` and `ELSE` branches. The `(ELSE ...)` element may be omitted in
which case the if instruction does not have an else branch.

The `IF` instruction may also have an optional result type or type
signature specified in the second element by `(RESULT type)` or `(TYPE
index)`. If this is omitted the `IF` instruction is assumed to have no
result type.

.Example: If without else branch
--------------------------------------------------
(local.get 0)
(if (then (call 0))
--------------------------------------------------

.Example: If with else branch
--------------------------------------------------
(local.get 0)
(if (then (call 0))
    (else (call 1)))
--------------------------------------------------

.Example: If with result type
--------------------------------------------------
(local.get 0)
(i32.const 0)
i32.ge

(if (result i32)
    (then (local.get 0))
    (else (local.get 0)
          (i32.const -1)
          i32.mul))
--------------------------------------------------

=== Modules ===

A WebAssembly module is represented by the `WASM-MODULE` structure,
which contains a slot for each section. A `WASM-MODULE` object can be
serialized to an output stream using the `SERIALIZE-MODULE` function.

==== WASM-MODULE ====

Structure: `WASM-MODULE`

Represents a WebAssembly module with a lot for each section:

Slots:

- `TYPES`
- `IMPORTS`
- `FUNCTIONS`
- `TABLES`
- `MEMORY`
- `GLOBALS`
- `EXPORTS`
- `START`
- `ELEMENTS`
- `DATA`

==== SERIALIZE-MODULE ====

Function: `SERIALIZE-MODULE MODULE STREAM`

Serialize a module to the wasm binary format and write the output to a
given stream.

`MODULE`:: The `WASM-MODULE` to serialize.
`STREAM`:: Output stream to which to serialize the module. This must
be a binary output stream with element type `(UNSIGNED-BYTE 8)`.

[[type_section]]
=== Type Section ===

The `TYPES` slot, of `WASM-MODULE` ,is a list of `WASM-FUNCTION-TYPE`
objects which represent the function type signatures of the module's
functions.

==== WASM-FUNCTION-TYPE ====

Structure: `WASM-FUNCTION-TYPE`

Represents a function type signature.

Slots:

`PARAMS`:: List of the argument types
`RESULTS`:: List of the return value types

=== Imports Section ===

The `IMPORTS` slot, of `WASM-MODULE`, is a list of `WASM-IMPORT`
objects which represent the module's imports.

[[wasm_import]]
==== WASM-IMPORT ====

Structure: `WASM-IMPORT`

Represents an imported entity.

Slots:

`MODULE`:: Module component (first level) of the import name

`NAME`:: Name component (second level) of the import name

`TYPE`:: Keyword identifying type of imported entity:
+
--
`:FUNC`:: The imported entity is a function
`:TABLE`:: The imported entity is a table object
`:MEMORY`:: The imported entity is a memory object
`:GLOBAL`:: The imported entity is a global variable
--

`DESC`:: Description of the imported entity, which depends on `TYPE`:
+
--
`:FUNC`:: Index of the function's type signature within the module's
type section.

`:TABLE`:: A `WASM-TABLE` object specifying the table type and limits.

`:MEMORY`:: A `WASM-LIMIT` object specifying the memory limits.

`:GLOBAL`:: A list of the form `(TYPE MUTABLE-P)` where `TYPE` is the
value type of the variable and `MUTABLE-P` is a flag, which if true,
indicates that the variable is mutable.
--

=== Functions ===

The slot `FUNCTIONS`, of `WASM-MODULE`, is a list of `WASM-FUNCTION`
objects which represent the module's functions.

==== WASM-FUNCTION ====

Structure: `WASM-FUNCTION`

Represents a function.

Slots:

`TYPE`:: Index of the function's type signature within the type section.

`LOCALS`:: List of the types of the local variables.

`CODE`:: List of instructions comprising the body of the function.


=== Memory and Table Sections ===

The `MEMORY` slot is a list of `WASM-LIMIT` objects which specify the
limits of the module's memory objects.

The slot `TABLES`, of `WASM-MODULE`, is a list of `WASM-TABLE` objects
which specify the type and limits of the module's table objects.

NOTE: In the current version of WebAssembly, modules may contain a
maximum of one table and memory object. This library supports
serializing modules with more than one memory and table object.

==== WASM-LIMIT ====

Structure: `WASM-LIMIT`

Specifies the limits of a memory and table objects.

Slots:

`MIN`:: The lower-bound of the memory / table limit. Must be greater
than or equal to 0.

`MAX`:: The upper-bound of the limit. If NIL the limit has no
upper-bound.


==== WASM-TABLE ====

Structure: `WASM-TABLE (:INCLUDE WASM-LIMIT)`

Specifies the type and limits of a table object. Includes the slots of
the structure `WASM-LIMIT`.

Slots:

`TYPE`:: Table element type, either `FUNCREF` (the default) or `EXTERNREF`.

NOTE: In the current version of WebAssembly only tables of type
`FUNCREF` are supported.


=== Global Variable Section ===

The `GLOBALS` slot, of `WASM-MODULE`, is a list of `WASM-GLOBAL`
objects which represent the module's global variables.

==== WASM-GLOBAL ====

Structure: `WASM-GLOBAL`

Represents a global variable

.Slots

`TYPE`:: Value type of the variable.

`MUTABLE-P`:: Flag, which if true, indicates the variable is
mutable. Otherwise the variable is immutable.

`INIT`:: Expression which computes the variable's initial value. May
be `NIL`.


=== Exports Section ===

The `EXPORTS` slot, of `WASM-MODULE`, is a list of `WASM-EXPORT`
objects which represent the entities exported by the module.

==== WASM-EXPORT ====

Structure: `WASM-EXPORT`

Represents an exported entity.

.Slots

`NAME`:: The name (as a string) under which the entity is exported.

`TYPE`:: Keyword describing the type of entity. See the `TYPE` slot of
<>.

`INDEX`:: Index of the exported entity within its sections.


=== Start Function ===

The `START` slot, of `WASM-MODULE`, is the index of the function, with
functions list in the `FUNCTIONS` slot, of the function which serves
as the module's entry point. If `NIL` the module does not have an
entry point.

=== Element Section ===

The `ELEMENTS` slot, of `WASM-MODULE`, is a list of `WASM-ELEMENT`
objects which represent the module's element segments.

Each element segment specifies the initial values of a range of
elements in a table object.

==== WASM-ELEMENT ====

Structure `WASM-ELEMENT`

Represents an element segment.

.Slots

`MODE`:: Keyword specifying the element segment mode.
+
--
`:ACTIVE`:: An 'active' segment , which is used to initialize the
table elements during module instantiation. This is the default.

`:PASSIVE`:: A 'passive' segment, which can be used to initialize the
table elements at runtime with the `TABLE.INIT` instruction.

`:DECLARATIVE`:: A 'declarative' segment, which is used only to
forward declare the function references that will be added to the
table, using the `REF.FUNC` instruction.
--

`INDEX`:: Index of the table object, 0 by default, which this element
initializes. This slot is only used when `MODE` is `:ACTIVE`.
+
--
NOTE: In the current version of WebAssembly the only valid index is 0.
--

`OFFSET`:: Expression which computes the starting index of the
location within the table where the elements in this segment are
copied to.

`INIT`:: Object specifying the values of the elements in this
segment. This can be either a `WASM-ELEMENT-INIT-INDEX` or
`WASM-ELEMENT-INIT-EXPRESSIONS` object.

==== WASM-ELEMENT-INIT-INDEX ====

Structure `WASM-ELEMENT-INIT-INDEX`

Represents a table element segment where the initial element values
are function indices.

.Slots

`FUNCTIONS`:: List of indices of the functions, within the function
section (`FUNCTIONs` slot), to which the table elements are set.

==== WASM-ELEMENT-INIT-EXPRESSIONS ====

Structure `WASM-ELEMENT-INIT-EXPRESSIONS`

Represents a table element segment where the initial element values
are computed by expressions.

.Slots

`TYPE`:: Table element type, either `FUNCREF` (default) or
`EXTERNREF`.

`EXPRESSIONS`:: List of expressions which compute the initial element
values. Each expression should leave a function reference on the
stack, which is obtained with the `REF.FUNC` instruction.

=== Data Section ===

The `DATA` slot, of `WASM-MODULE`, is a list of `WASM-DATA` objects
which represent the module's data segments.

Each data segment specifies the initial values of a range of bytes
in a memory object.

==== WASM-DATA ====

Structure `WASM-DATA`

Represents a data segment.

.Slots

`MODE`:: Keyword specifying the element segment mode.
+
--
`:ACTIVE`:: An 'active' segment, which is used to initialize the
memory object during module instantiation. This is the default.

`:PASSIVE`:: A 'passive' segment, which can be used to initialize the
memory object at runtime with the `MEMORY.INIT` instruction.
--

`MEMORY`:: Index of the memory object, 0 by default, which this element
initializes. This slot is only used when `MODE` is `:ACTIVE`.
+
--
NOTE: In the current version of WebAssembly the only valid index is 0.
--

`OFFSET`:: Expression which computes the starting index of the
location within the memory object where the bytes in this segment are
copied to.

`BYTES`:: Byte array containing the values to which the bytes in the
memory object are set.

2 Systems

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

2.1 `wasm-encoder`

Author

Alexander Gutev <alex.gutev@mail.bg>

License

MIT

Description

Library for serializing WebAssembly modules to binary .wasm files

Version

0.2

Dependencies

generic-cl
agutil
alexandria
trivia
ieee-floats
babel
flexi-streams

Source

wasm-encoder.asd (file)

Component

src (module)

3 Modules

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

3.1 `wasm-encoder/src`

Parent

wasm-encoder (system)

Location

src/

Components

package.lisp (file)
wasm-encoder.lisp (file)

4 Files

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

4.1 Lisp

4.1.1 `wasm-encoder.asd`

Location: wasm-encoder.asd
Systems: wasm-encoder (system)

4.1.2 `wasm-encoder/src/package.lisp`

Parent: src (module)
Location: src/package.lisp
Packages: wasm-encoder

4.1.3 `wasm-encoder/src/wasm-encoder.lisp`

Dependency

package.lisp (file)

Parent

src (module)

Location

src/wasm-encoder.lisp

Exported Definitions

make-wasm-data (function)
make-wasm-element (function)
make-wasm-element-init-expressions (function)
make-wasm-element-init-index (function)
make-wasm-export (function)
make-wasm-function (function)
make-wasm-function-type (function)
make-wasm-global (function)
make-wasm-import (function)
make-wasm-limit (function)
make-wasm-module (function)
make-wasm-table (function)
serialize-module (function)
wasm-data (structure)
wasm-data-bytes (function)
(setf wasm-data-bytes) (function)
wasm-data-memory (function)
(setf wasm-data-memory) (function)
wasm-data-mode (function)
(setf wasm-data-mode) (function)
wasm-data-offset (function)
(setf wasm-data-offset) (function)
wasm-data-p (function)
wasm-element (structure)
wasm-element-index (function)
(setf wasm-element-index) (function)
wasm-element-init (function)
(setf wasm-element-init) (function)
wasm-element-init-expressions (structure)
wasm-element-init-expressions-expressions (function)
(setf wasm-element-init-expressions-expressions) (function)
wasm-element-init-expressions-p (function)
wasm-element-init-index (structure)
wasm-element-init-index-functions (function)
(setf wasm-element-init-index-functions) (function)
wasm-element-init-index-p (function)
wasm-element-mode (function)
(setf wasm-element-mode) (function)
wasm-element-offset (function)
(setf wasm-element-offset) (function)
wasm-element-p (function)
wasm-export (structure)
wasm-export-index (function)
(setf wasm-export-index) (function)
wasm-export-name (function)
(setf wasm-export-name) (function)
wasm-export-p (function)
wasm-export-type (function)
(setf wasm-export-type) (function)
wasm-function (structure)
wasm-function-code (function)
(setf wasm-function-code) (function)
wasm-function-locals (function)
(setf wasm-function-locals) (function)
wasm-function-p (function)
wasm-function-type (function)
(setf wasm-function-type) (function)
wasm-function-type (structure)
wasm-function-type-p (function)
wasm-function-type-params (function)
(setf wasm-function-type-params) (function)
wasm-function-type-results (function)
(setf wasm-function-type-results) (function)
wasm-global (structure)
wasm-global-init (function)
(setf wasm-global-init) (function)
wasm-global-mutable-p (function)
(setf wasm-global-mutable-p) (function)
wasm-global-p (function)
wasm-global-type (function)
(setf wasm-global-type) (function)
wasm-import (structure)
wasm-import-desc (function)
(setf wasm-import-desc) (function)
wasm-import-module (function)
(setf wasm-import-module) (function)
wasm-import-name (function)
(setf wasm-import-name) (function)
wasm-import-p (function)
wasm-import-type (function)
(setf wasm-import-type) (function)
wasm-limit (structure)
wasm-limit-max (function)
(setf wasm-limit-max) (function)
wasm-limit-min (function)
(setf wasm-limit-min) (function)
wasm-limit-p (function)
wasm-module (structure)
wasm-module-data (function)
(setf wasm-module-data) (function)
wasm-module-data-count (function)
(setf wasm-module-data-count) (function)
wasm-module-elements (function)
(setf wasm-module-elements) (function)
wasm-module-exports (function)
(setf wasm-module-exports) (function)
wasm-module-functions (function)
(setf wasm-module-functions) (function)
wasm-module-globals (function)
(setf wasm-module-globals) (function)
wasm-module-imports (function)
(setf wasm-module-imports) (function)
wasm-module-memory (function)
(setf wasm-module-memory) (function)
wasm-module-p (function)
wasm-module-start (function)
(setf wasm-module-start) (function)
wasm-module-types (function)
(setf wasm-module-types) (function)
wasm-table (structure)
wasm-table-max (function)
(setf wasm-table-max) (function)
wasm-table-min (function)
(setf wasm-table-min) (function)
wasm-table-p (function)
wasm-table-type (function)
(setf wasm-table-type) (function)

Internal Definitions

+code-section-id+ (constant)
+custom-section-id+ (constant)
+data-count-section-id+ (constant)
+data-section-id+ (constant)
+element-section-id+ (constant)
+export-section-id+ (constant)
+function-section-id+ (constant)
+global-section-id+ (constant)
+import-section-id+ (constant)
+memory-section-id+ (constant)
+op-codes+ (constant)
+start-section-id+ (constant)
+table-section-id+ (constant)
+type-section-id+ (constant)
copy-wasm-data (function)
copy-wasm-element (function)
copy-wasm-element-init-expressions (function)
copy-wasm-element-init-index (function)
copy-wasm-export (function)
copy-wasm-function (function)
copy-wasm-function-type (function)
copy-wasm-global (function)
copy-wasm-import (function)
copy-wasm-limit (function)
copy-wasm-module (function)
copy-wasm-table (function)
data-segment-type-code (function)
i32 (type)
i64 (type)
intern-symbol (function)
intern-symbols (function)
serialize-32-bit (function)
serialize-64-bit (function)
serialize-block (function)
serialize-branch (function)
serialize-data (function)
serialize-data-count-section (function)
serialize-data-section (function)
serialize-double-float (function)
serialize-export (function)
serialize-export-section (function)
serialize-expression (function)
serialize-float (function)
serialize-ftype (function)
serialize-function (function)
serialize-function-types (function)
serialize-functions (function)
serialize-global (function)
serialize-global-section (function)
serialize-i32 (function)
serialize-import (function)
serialize-imports (function)
serialize-instruction (function)
serialize-instruction-operands (generic function)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instructions (function)
serialize-limit (function)
serialize-memory (function)
serialize-memory-instruction (function)
serialize-memory-types (function)
serialize-nil-type (function)
serialize-ref-type (function)
serialize-section (function)
serialize-signed (function)
serialize-start-section (function)
serialize-string (function)
serialize-table (function)
serialize-table-element (function)
serialize-table-element-init (function)
serialize-table-elements (function)
serialize-table-instruction (method)
serialize-table-types (function)
serialize-type (function)
serialize-types (function)
serialize-u32 (function)
serialize-unsigned (function)
serialize-variable-instruction (method)
serialize-vector (function)
serialize-with-byte-size (function)
table-element-type-code (function)
u32 (type)
u64 (type)
wasm-element-init-expressions-type (function)
(setf wasm-element-init-expressions-type) (function)
wasm-module-tables (function)
(setf wasm-module-tables) (function)

5 Packages

Packages are listed by definition order.

5.1 `wasm-encoder`

Source

package.lisp (file)

Use List

babel-encodings
babel
ieee-floats
trivia.level2
alexandria
agutil
generic-cl

Exported Definitions

make-wasm-data (function)
make-wasm-element (function)
make-wasm-element-init-expressions (function)
make-wasm-element-init-index (function)
make-wasm-export (function)
make-wasm-function (function)
make-wasm-function-type (function)
make-wasm-global (function)
make-wasm-import (function)
make-wasm-limit (function)
make-wasm-module (function)
make-wasm-table (function)
serialize-module (function)
wasm-data (structure)
wasm-data-bytes (function)
(setf wasm-data-bytes) (function)
wasm-data-memory (function)
(setf wasm-data-memory) (function)
wasm-data-mode (function)
(setf wasm-data-mode) (function)
wasm-data-offset (function)
(setf wasm-data-offset) (function)
wasm-data-p (function)
wasm-element (structure)
wasm-element-index (function)
(setf wasm-element-index) (function)
wasm-element-init (function)
(setf wasm-element-init) (function)
wasm-element-init-expressions (structure)
wasm-element-init-expressions-expressions (function)
(setf wasm-element-init-expressions-expressions) (function)
wasm-element-init-expressions-p (function)
wasm-element-init-index (structure)
wasm-element-init-index-functions (function)
(setf wasm-element-init-index-functions) (function)
wasm-element-init-index-p (function)
wasm-element-mode (function)
(setf wasm-element-mode) (function)
wasm-element-offset (function)
(setf wasm-element-offset) (function)
wasm-element-p (function)
wasm-export (structure)
wasm-export-index (function)
(setf wasm-export-index) (function)
wasm-export-name (function)
(setf wasm-export-name) (function)
wasm-export-p (function)
wasm-export-type (function)
(setf wasm-export-type) (function)
wasm-function (structure)
wasm-function-code (function)
(setf wasm-function-code) (function)
wasm-function-locals (function)
(setf wasm-function-locals) (function)
wasm-function-p (function)
wasm-function-type (function)
(setf wasm-function-type) (function)
wasm-function-type (structure)
wasm-function-type-p (function)
wasm-function-type-params (function)
(setf wasm-function-type-params) (function)
wasm-function-type-results (function)
(setf wasm-function-type-results) (function)
wasm-global (structure)
wasm-global-init (function)
(setf wasm-global-init) (function)
wasm-global-mutable-p (function)
(setf wasm-global-mutable-p) (function)
wasm-global-p (function)
wasm-global-type (function)
(setf wasm-global-type) (function)
wasm-import (structure)
wasm-import-desc (function)
(setf wasm-import-desc) (function)
wasm-import-module (function)
(setf wasm-import-module) (function)
wasm-import-name (function)
(setf wasm-import-name) (function)
wasm-import-p (function)
wasm-import-type (function)
(setf wasm-import-type) (function)
wasm-limit (structure)
wasm-limit-max (function)
(setf wasm-limit-max) (function)
wasm-limit-min (function)
(setf wasm-limit-min) (function)
wasm-limit-p (function)
wasm-module (structure)
wasm-module-data (function)
(setf wasm-module-data) (function)
wasm-module-data-count (function)
(setf wasm-module-data-count) (function)
wasm-module-elements (function)
(setf wasm-module-elements) (function)
wasm-module-exports (function)
(setf wasm-module-exports) (function)
wasm-module-functions (function)
(setf wasm-module-functions) (function)
wasm-module-globals (function)
(setf wasm-module-globals) (function)
wasm-module-imports (function)
(setf wasm-module-imports) (function)
wasm-module-memory (function)
(setf wasm-module-memory) (function)
wasm-module-p (function)
wasm-module-start (function)
(setf wasm-module-start) (function)
wasm-module-types (function)
(setf wasm-module-types) (function)
wasm-table (structure)
wasm-table-max (function)
(setf wasm-table-max) (function)
wasm-table-min (function)
(setf wasm-table-min) (function)
wasm-table-p (function)
wasm-table-type (function)
(setf wasm-table-type) (function)

Internal Definitions

+code-section-id+ (constant)
+custom-section-id+ (constant)
+data-count-section-id+ (constant)
+data-section-id+ (constant)
+element-section-id+ (constant)
+export-section-id+ (constant)
+function-section-id+ (constant)
+global-section-id+ (constant)
+import-section-id+ (constant)
+memory-section-id+ (constant)
+op-codes+ (constant)
+start-section-id+ (constant)
+table-section-id+ (constant)
+type-section-id+ (constant)
copy-wasm-data (function)
copy-wasm-element (function)
copy-wasm-element-init-expressions (function)
copy-wasm-element-init-index (function)
copy-wasm-export (function)
copy-wasm-function (function)
copy-wasm-function-type (function)
copy-wasm-global (function)
copy-wasm-import (function)
copy-wasm-limit (function)
copy-wasm-module (function)
copy-wasm-table (function)
data-segment-type-code (function)
i32 (type)
i64 (type)
intern-symbol (function)
intern-symbols (function)
serialize-32-bit (function)
serialize-64-bit (function)
serialize-block (function)
serialize-branch (function)
serialize-data (function)
serialize-data-count-section (function)
serialize-data-section (function)
serialize-double-float (function)
serialize-export (function)
serialize-export-section (function)
serialize-expression (function)
serialize-float (function)
serialize-ftype (function)
serialize-function (function)
serialize-function-types (function)
serialize-functions (function)
serialize-global (function)
serialize-global-section (function)
serialize-i32 (function)
serialize-import (function)
serialize-imports (function)
serialize-instruction (function)
serialize-instruction-operands (compiler macro)
serialize-instruction-operands (generic function)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instruction-operands (method)
serialize-instructions (function)
serialize-limit (function)
serialize-memory (function)
serialize-memory-instruction (function)
serialize-memory-types (function)
serialize-nil-type (function)
serialize-ref-type (function)
serialize-section (function)
serialize-signed (function)
serialize-start-section (function)
serialize-string (function)
serialize-table (function)
serialize-table-element (function)
serialize-table-element-init (function)
serialize-table-elements (function)
serialize-table-instruction (generic function)
serialize-table-instruction (method)
serialize-table-types (function)
serialize-type (function)
serialize-types (function)
serialize-u32 (function)
serialize-unsigned (function)
serialize-variable-instruction (generic function)
serialize-variable-instruction (method)
serialize-vector (function)
serialize-with-byte-size (function)
table-element-type-code (function)
u32 (type)
u64 (type)
wasm-element-init-expressions-type (function)
(setf wasm-element-init-expressions-type) (function)
wasm-module-tables (function)
(setf wasm-module-tables) (function)

6 Definitions

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

6.1 Exported definitions

6.1.1 Functions

Function: make-wasm-data &key (MODE MODE) (OFFSET OFFSET) (BYTES BYTES) (MEMORY MEMORY)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-element &key (MODE MODE) (INDEX INDEX) (OFFSET OFFSET) (INIT INIT)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-element-init-expressions &key (TYPE TYPE) (EXPRESSIONS EXPRESSIONS)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-element-init-index &key (FUNCTIONS FUNCTIONS)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-export &key (NAME NAME) (TYPE TYPE) (INDEX INDEX)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-function &key (TYPE TYPE) (LOCALS LOCALS) (CODE CODE)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-function-type &key (PARAMS PARAMS) (RESULTS RESULTS)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-global &key (TYPE TYPE) (MUTABLE-P MUTABLE-P) (INIT INIT)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-import &key (MODULE MODULE) (NAME NAME) (TYPE TYPE) (DESC DESC)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-limit &key (MIN MIN) (MAX MAX)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-module &key (TYPES TYPES) (IMPORTS IMPORTS) (FUNCTIONS FUNCTIONS) (TABLES TABLES) (MEMORY MEMORY) (GLOBALS GLOBALS) (EXPORTS EXPORTS) (START START) (ELEMENTS ELEMENTS) (DATA DATA) (DATA-COUNT DATA-COUNT)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: make-wasm-table &key (MIN MIN) (MAX MAX) (TYPE TYPE)

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-module MODULE STREAM

Serialize a WebAssembly module to an output stream.

MODULE is a ‘WASM-MODULE’ object.

STREAM is the output stream, which must be a binary stream with element type (unsigned-byte 8).

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-data-bytes INSTANCE

Function: (setf wasm-data-bytes) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-data-memory INSTANCE

Function: (setf wasm-data-memory) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-data-mode INSTANCE

Function: (setf wasm-data-mode) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-data-offset INSTANCE

Function: (setf wasm-data-offset) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-data-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-index INSTANCE

Function: (setf wasm-element-index) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-init INSTANCE

Function: (setf wasm-element-init) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-init-expressions-expressions INSTANCE

Function: (setf wasm-element-init-expressions-expressions) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-init-expressions-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-init-index-functions INSTANCE

Function: (setf wasm-element-init-index-functions) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-init-index-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-mode INSTANCE

Function: (setf wasm-element-mode) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-offset INSTANCE

Function: (setf wasm-element-offset) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-export-index INSTANCE

Function: (setf wasm-export-index) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-export-name INSTANCE

Function: (setf wasm-export-name) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-export-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-export-type INSTANCE

Function: (setf wasm-export-type) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-function-code INSTANCE

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

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-function-locals INSTANCE

Function: (setf wasm-function-locals) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-function-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-function-type INSTANCE

Function: (setf wasm-function-type) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-function-type-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-function-type-params INSTANCE

Function: (setf wasm-function-type-params) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-function-type-results INSTANCE

Function: (setf wasm-function-type-results) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-global-init INSTANCE

Function: (setf wasm-global-init) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-global-mutable-p INSTANCE

Function: (setf wasm-global-mutable-p) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-global-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-global-type INSTANCE

Function: (setf wasm-global-type) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-import-desc INSTANCE

Function: (setf wasm-import-desc) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-import-module INSTANCE

Function: (setf wasm-import-module) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-import-name INSTANCE

Function: (setf wasm-import-name) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-import-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-import-type INSTANCE

Function: (setf wasm-import-type) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-limit-max INSTANCE

Function: (setf wasm-limit-max) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-limit-min INSTANCE

Function: (setf wasm-limit-min) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-limit-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-data INSTANCE

Function: (setf wasm-module-data) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-data-count INSTANCE

Function: (setf wasm-module-data-count) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-elements INSTANCE

Function: (setf wasm-module-elements) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-exports INSTANCE

Function: (setf wasm-module-exports) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-functions INSTANCE

Function: (setf wasm-module-functions) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-globals INSTANCE

Function: (setf wasm-module-globals) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-imports INSTANCE

Function: (setf wasm-module-imports) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-memory INSTANCE

Function: (setf wasm-module-memory) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-start INSTANCE

Function: (setf wasm-module-start) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-types INSTANCE

Function: (setf wasm-module-types) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-table-max INSTANCE

Function: (setf wasm-table-max) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-table-min INSTANCE

Function: (setf wasm-table-min) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-table-p OBJECT

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-table-type INSTANCE

Function: (setf wasm-table-type) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

6.1.2 Structures

Structure: wasm-data ()

Represents a data segment.

Data segments specify the initial values of memory objects.

MODE is a keyword specifying the data segment mode:

:ACTIVE - An active element initialized on module loading (the default) :PASSIVE - A passive element which can be used with MEMORY.INIT

MEMORY is the index of the memory object to initialize. This field
is only used when MODE is :ACTIVE. By default this is 0, which is
the only valid index in the current version of WebAssembly.

OFFSET is an expression (list of instructions) which compute the
starting index of the range to initialize. This field is only used
when MODE is :ACTIVE.

BYTES is the byte array containing the values to which the bytes, starting at OFFSET (in the case of an active data segment), are initialized.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: mode

Initform: :active
Readers: wasm-data-mode (function)
Writers: (setf wasm-data-mode) (function)

Slot: offset

Readers: wasm-data-offset (function)
Writers: (setf wasm-data-offset) (function)

Slot: bytes

Readers: wasm-data-bytes (function)
Writers: (setf wasm-data-bytes) (function)

Slot: memory

Initform: 0
Readers: wasm-data-memory (function)
Writers: (setf wasm-data-memory) (function)

Structure: wasm-element ()

Represents an element segment.

Element segments specify the initial values of table elements.

MODE is a keyword specifying the element segment mode:

:ACTIVE - An active element initialized on instantiation (the default) :PASSIVE - A passive element which can be used with TABLE.INIT :DECLARATIVE - A forward declaration of table contents.

INDEX is the index of the table to initialize. This slot is only
used when MODE is :ACTIVE. By default this is 0, which is the only
valid index in the current version of WebAssembly.

OFFSET is an expression (list of instructions) which compute the starting index of the range to initialize. This field is only used
when MODE is :ACTIVE.

INIT is an object specifying the initial values of the table
elements, which can be of the following can be either a ‘WASM-ELEMENT-INIT-INDEX’ or ‘WASM-ELEMENT-INIT-EXPRESSIONS’
object.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: mode

Initform: :active
Readers: wasm-element-mode (function)
Writers: (setf wasm-element-mode) (function)

Slot: index

Initform: 0
Readers: wasm-element-index (function)
Writers: (setf wasm-element-index) (function)

Slot: offset

Readers: wasm-element-offset (function)
Writers: (setf wasm-element-offset) (function)

Slot: init

Readers: wasm-element-init (function)
Writers: (setf wasm-element-init) (function)

Structure: wasm-element-init-expressions ()

Represents a table element segment initialization with expressions.

TYPE is the table element type, either FUNCREF (default) or EXTERNREF. In the current version of WebAssembly only FUNCREF is supported.

EXPRESSIONS is a list of expressions, where each expression is a list of instructions, which compute the initial values of the table elements, starting from the index OFFSET (of the WASM-ELEMENT object).

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: type

Initform: (quote wasm-encoder::funcref)
Readers: wasm-element-init-expressions-type (function)
Writers: (setf wasm-element-init-expressions-type) (function)

Slot: expressions

Readers: wasm-element-init-expressions-expressions (function)
Writers: (setf wasm-element-init-expressions-expressions) (function)

Structure: wasm-element-init-index ()

Represents a table element segment initialization with function indices.

FUNCTIONS is a list of function indices to which the table elements
are initialized, starting from the index OFFSET (of the WASM-ELEMENT object).

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: functions

Readers: wasm-element-init-index-functions (function)
Writers: (setf wasm-element-init-index-functions) (function)

Structure: wasm-export ()

Represents an exported entity.

NAME is the name at which the entity is exported.

TYPE is a keyword specifying the kind of entity that is exported:

:FUNC - function
:TABLE - table object
:MEMORY - memory object
:GLOBAL - global variable

INDEX is the index of the exported entity within the module section in which it is contained.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: name

Readers: wasm-export-name (function)
Writers: (setf wasm-export-name) (function)

Slot: type

Readers: wasm-export-type (function)
Writers: (setf wasm-export-type) (function)

Slot: index

Readers: wasm-export-index (function)
Writers: (setf wasm-export-index) (function)

Structure: wasm-function ()

Represents a WebAssembly function.

TYPE is the index of the functions type signature, within the type section.

LOCALS is the list of the value types of the functions local variables.

CODE is the list of instructions comprising the function.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: type

Readers: wasm-function-type (function)
Writers: (setf wasm-function-type) (function)

Slot: locals

Readers: wasm-function-locals (function)
Writers: (setf wasm-function-locals) (function)

Slot: code

Readers: wasm-function-code (function)
Writers: (setf wasm-function-code) (function)

Structure: wasm-function-type ()

Represents a function type signature.

PARAMS is a list of the argument types.

RESULTS is a list of the return value types.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: params

Readers: wasm-function-type-params (function)
Writers: (setf wasm-function-type-params) (function)

Slot: results

Readers: wasm-function-type-results (function)
Writers: (setf wasm-function-type-results) (function)

Structure: wasm-global ()

Represents a global variable.

TYPE is the value type of the variable.

MUTABLE-P is a flag, which if true indicates the variable is mutable.

INIT is an optional expression (a list of instructions) which compute the variables initial value. If NIL the variable has no initial value.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: type

Readers: wasm-global-type (function)
Writers: (setf wasm-global-type) (function)

Slot: mutable-p

Readers: wasm-global-mutable-p (function)
Writers: (setf wasm-global-mutable-p) (function)

Slot: init

Readers: wasm-global-init (function)
Writers: (setf wasm-global-init) (function)

Structure: wasm-import ()

Represents an imported entity.

The two-level import name is given by MODULE and NAME.

TYPE is a keyword specifying the kind of entity that is imported:

:FUNC - function
:TABLE - table object
:MEMORY - memory object
:GLOBAL - global variable

DESC is a description of the imported entity, which depends on TYPE:

:FUNC - Index of the function’s type signature within the module’s type section.

:TABLE - A ‘WASM-TABLE’ object specifying the table type and limits.

:MEMORY - A ‘WASM-LIMIT’ object specifying the memory limits.

:GLOBAL - A list of the form (TYPE MUTABLE-P) where TYPE is the value type of the variable and MUTABLE-P is a flag for whether the variable is mutable.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: module

Readers: wasm-import-module (function)
Writers: (setf wasm-import-module) (function)

Slot: name

Readers: wasm-import-name (function)
Writers: (setf wasm-import-name) (function)

Slot: type

Readers: wasm-import-type (function)
Writers: (setf wasm-import-type) (function)

Slot: desc

Readers: wasm-import-desc (function)
Writers: (setf wasm-import-desc) (function)

Structure: wasm-limit ()

Represents a limit of memory or table object.

MIN is the lower bound, which must be greater than or equal to 0.

MAX is the upper bound. If NIL the limit has no upper bound.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

wasm-table (structure)

Direct slots

Slot: min

Readers: wasm-limit-min (function)
Writers: (setf wasm-limit-min) (function)

Slot: max

Readers: wasm-limit-max (function)
Writers: (setf wasm-limit-max) (function)

Structure: wasm-module ()

Represents a WebAssembly module that can be serialized to the binary wasm format.

Each slot contains a list of the entities comprising a particular
section of the module. The entities are serialized in the order
given in the list.

TYPES is a list of ‘WASM-FUNCTION-TYPE’ objects representing the
function type signatures of the module’s functions.

IMPORTS is a list of ‘WASM-IMPORT’ objects representing the
module’s imports.

FUNCTIONS is a list of ‘WASM-FUNCTION’ objects representing the
module’s functions, including both the signatures and code.

TABLES is a list of ‘WASM-TABLE’ objects specifying the limits, and
types, of the module’s tables. In the current version of
WebAssembly, a module may have at most one table of type FUNCREF,
however this library supports multiple tables of both type FUNCREF
and EXTERNREF.

MEMORY is a list of ‘WASM-LIMIT’ objects specifying the limits of
the module’s memory objects. Currently a module may have at most
one memory object, however this library supports multiple memory objects.

GLOBALS is a list of ‘WASM-GLOBAL’ objects representing the
module’s global variables.

EXPORTS is a list ‘WASM-EXPORT’ objects representing the module’s exports.

START is the index of the function serving as the module’s entry
point. If NIL the module does not have an entry point.

ELEMENTS is a list of ‘WASM-ELEMET’ objects representing the
module’s element segments, for initializing the module’s tables.

DATA is a list of ‘WASM-DATA’ objects representing the module’s
data segments for initializing the module’s memory.

DATA-COUNT is a flag, which if true, a data count section is
emitted, prior to the code section, storing the number of data segments.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: types

Readers: wasm-module-types (function)
Writers: (setf wasm-module-types) (function)

Slot: imports

Readers: wasm-module-imports (function)
Writers: (setf wasm-module-imports) (function)

Slot: functions

Readers: wasm-module-functions (function)
Writers: (setf wasm-module-functions) (function)

Slot: tables

Readers: wasm-module-tables (function)
Writers: (setf wasm-module-tables) (function)

Slot: memory

Readers: wasm-module-memory (function)
Writers: (setf wasm-module-memory) (function)

Slot: globals

Readers: wasm-module-globals (function)
Writers: (setf wasm-module-globals) (function)

Slot: exports

Readers: wasm-module-exports (function)
Writers: (setf wasm-module-exports) (function)

Slot: start

Readers: wasm-module-start (function)
Writers: (setf wasm-module-start) (function)

Slot: elements

Readers: wasm-module-elements (function)
Writers: (setf wasm-module-elements) (function)

Slot: data

Readers: wasm-module-data (function)
Writers: (setf wasm-module-data) (function)

Slot: data-count

Initform: t
Readers: wasm-module-data-count (function)
Writers: (setf wasm-module-data-count) (function)

Structure: wasm-table ()

Represents a table object type.

TYPE is the type of element stored in the table, either FUNCREF or EXTERNREF.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Direct superclasses

wasm-limit (structure)

Direct slots

Slot: type

Initform: (quote wasm-encoder::funcref)
Readers: wasm-table-type (function)
Writers: (setf wasm-table-type) (function)

6.2 Internal definitions

6.2.1 Constants

Constant: +code-section-id+

Function body section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +custom-section-id+

Custom section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +data-count-section-id+

Data count section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +data-section-id+

Data section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +element-section-id+

Element section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +export-section-id+

Export section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +function-section-id+

Identifier of the section containing the types of the functions, in the module.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +global-section-id+

Global variable section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +import-section-id+

Import section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +memory-section-id+

Memory section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +op-codes+

WebAssembly Instruction Opcode Map.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +start-section-id+

Module entry point section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +table-section-id+

Table section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Constant: +type-section-id+

Function type signature section identifier.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

6.2.2 Compiler macros

Compiler Macro: serialize-instruction-operands WHOLE &optional ENV

A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.

Package: wasm-encoder
Source: /home/quickref/quicklisp/dists/quicklisp/software/static-dispatch-20211209-git/src/sbcl.lisp

6.2.3 Functions

Function: copy-wasm-data INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-element INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-element-init-expressions INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-element-init-index INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-export INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-function INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-function-type INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-global INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-import INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-limit INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-module INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: copy-wasm-table INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: data-segment-type-code DATA

Determine the type code of a data segment.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: intern-symbol SYM

Intern the symbol SYM in the package WASM-ENCODER.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: intern-symbols SYMS

If SYMS is a symbol intern it into WASM-ENCODER. If SYMS is a list, apply INTERN-SYMBOLS on each of element otherwise return SYMS as is.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-32-bit VALUE STREAM

Serialize an integer value to 4 bytes in little endian order.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-64-bit VALUE STREAM

Serialize an integer value to 8 bytes in little endian order.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-block BODY STREAM

Serialize a structured block instruction containing the instructions in BODY.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-branch OPERANDS STREAM

Serialize the branch index of a branch instruction.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-data DATA STREAM

Serialize a data segment.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-data-count-section COUNT STREAM

Serialize the data count section.

COUNT is the number of data segments.

STREAM is the output stream.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-data-section DATA STREAM

Serialize the data section (containing the initialization of the module’s memory), with the memory initialization
entries (represented by WASM-DATA objects) in DATA.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-double-float VALUE STREAM

Serialize a DOUBLE-FLOAT to IEEE 64-bit floating point representation.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-export EXPORT STREAM

Serialize a single export entry, represented as a WASM-EXPORT object.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-export-section EXPORTS STREAM

Serialize the export section consisting of the entries, represented by WASM-EXPORT objects, in EXPORTS.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-expression INSTRUCTIONS STREAM

Serialize a list of instructions (an expression) followed by the block end instruction.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-float VALUE STREAM

Serialize a single FLOAT to IEEE 32-bit floating point representation.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-ftype TYPE STREAM

Serialize a function type signature, represented by a WASM-FUNCTION-TYPE object.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-function FUNCTION STREAM

Serialize the a single function, represented by a WASM-FUNCTION object. Only the local variable types and instructions of the function are serialized.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-function-types TYPES STREAM

Serialize the function type section (containing the indices of the type signatures of the functions defined in the module), consisting of the function type indices in TYPES.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-functions FUNCTIONS STREAM

Serialize the code section (containing the actual instructions comprising the functions in the module), consisting of the functions, represented by WASM-FUNCTION objects, in FUNCTIONS.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-global TYPE MUTABLE? STREAM

Serialize a global variable with value type TYPE. If MUTABLE? is true a mutable global variable is serialized.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-global-section GLOBALS STREAM

Serialize the global variable section, consisting of the global variables, represented by WASM-GLOBAL objects, in GLOBALS.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-i32 VALUE STREAM

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-import IMPORT STREAM

Serialize a single import entry IMPORT, represented by a WASM-IMPORT object.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-imports IMPORTS STREAM

Serialize the import section, consisting of the import entries, represented by WASM-IMPORT objects, in IMPORTS.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-instruction INSTRUCTION STREAM

Serialize a WebAssembly instruction to STREAM. The instruction may either be a symbol, naming the instruction, or a list in which the first element is the symbol naming the instruction and the remaining elements are the instruction operands.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-instructions INSTRUCTIONS STREAM

Serialize the instructions, in INSTRUCTIONS, to STREAM.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-limit LIMIT STREAM

Serialize a memory/table limit represented by a WASM-LIMIT object.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-memory LIMIT STREAM

Serialize a memory object entry with limit, represented by a WASM-LIMIT object, given by LIMIT.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-memory-instruction OPERANDS STREAM

Serialize the offset and alignment operands of a memory load/store instruction.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-memory-types MEMORY STREAM

Serialize the memory section, consisting of a memory object for each limit, represented as a WASM-LIMIT, given in MEMORY.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-nil-type STREAM

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-ref-type TYPE STREAM

Serialize a WebAssembly function reference type.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-section ID FN STREAM

Serialize a section, with identifier ID, to STREAM.

FN is called with a single argument – the stream to which the contents of the section should be written. The section id and the number of bytes are then written to STREAM followed by the bytes written by FN.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-signed VALUE STREAM

Serialize a signed integer to LEB128 format

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-start-section INDEX STREAM

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-string VALUE STREAM

Serialize a string to a UTF-8 encoded string without BOM.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-table TABLE STREAM

Serialize a table object entry with limit, represented by a WASM-LIMIT object, given by LIMIT.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-table-element TABLE STREAM

Serialize a single table element initialization entry, represented by a WASM-ELEMENT object.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-table-element-init MODE INDEX INIT STREAM

Serialize a table element initializer.

MODE is the table element mode.

INDEX is the table index.

INIT is the table element initializer.

STREAM is the output stream

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-table-elements ELEMENTS STREAM

Serialize the table element section, consisting of the table element initializations, represented by WASM-ELEMNT objects, in ELEMENTS.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-table-types TABLES STREAM

Serialize the table section, consisting of a table for each table limit, represented as a WASM-TABLE, given in TABLES.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-type TYPE STREAM

Serialize a WebAssembly value type.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-types TYPES STREAM

Serialize the function type section consisting of the function type signatures, represented by WASM-FUNCTION-TYPE objects, in TYPES.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-u32 VALUE STREAM

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-unsigned VALUE STREAM

Serialize an unsigned integer to LEB128 format

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-vector FN VECTOR STREAM

Serialize a vector of values.

The length VECTOR is written to STREAM first, after which FN is called on each element of the vector. FN should write each element it is called on to the stream passed to it in the second argument

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: serialize-with-byte-size FN STREAM

Serialize a sequence of bytes to STREAM, preceded by the number of bytes.

FN is called with a single argument – the stream to which the contents of the section should be written. The number of bytes is then written to STREAM followed by the bytes written by FN.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: table-element-type-code ELEMENT

Return the type code for a table element.

ELEMENT is the table element.

Returns the type code as a byte.

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-element-init-expressions-type INSTANCE

Function: (setf wasm-element-init-expressions-type) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Function: wasm-module-tables INSTANCE

Function: (setf wasm-module-tables) VALUE INSTANCE

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

6.2.4 Generic functions

Generic Function: serialize-instruction-operands OP OPERANDS STREAM

Serialize the operands (OPERANDS) of the instruction OP.

Package

wasm-encoder

Source

wasm-encoder.lisp (file)

Methods

Method: serialize-instruction-operands (OP (eql ref.func)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql ref.null)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql f64.const)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql f32.const)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.const)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i32.const)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql data.drop)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql memory.init)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql memory.fill)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql memory.copy)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql memory.grow)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql memory.size)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.store32)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.store16)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.store8)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i32.store16)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i32.store8)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql f64.store)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql f32.store)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.store)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i32.store)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.load32_u)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.load32_s)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.load16_u)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.load16_s)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.load8_u)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.load8_s)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i32.load16_u)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i32.load16_s)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i32.load8_u)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i32.load8_s)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql f64.load)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql f32.load)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i64.load)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql i32.load)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql table.fill)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql table.size)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql table.grow)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql elem.drop)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql table.copy)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql table.init)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql table.set)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql table.get)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql global.set)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql global.get)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql local.tee)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql local.set)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql local.get)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql call_indirect)) OPERANDS STREAM: Serialize the type signature of a call indirect instruction.

Method: serialize-instruction-operands (OP (eql br_table)) OPERANDS STREAM: Serialize the branches indices of a branch table instruction.

Method: serialize-instruction-operands (OP (eql call)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql br_if)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql br)) OPERANDS STREAM

Method: serialize-instruction-operands (OP (eql if)) BODY STREAM: Serialize the body of an IF structured instruction.

Method: serialize-instruction-operands (OP (eql select)) OPERANDS STREAM: Serialize the value types of the a select t* instruction

Method: serialize-instruction-operands (OP (eql loop)) BODY STREAM

Method: serialize-instruction-operands (OP (eql block)) BODY STREAM

Method: serialize-instruction-operands OP OPERANDS STREAM: Default Method, does nothing.

Generic Function: serialize-table-instruction OPERANDS STREAM

Package

wasm-encoder

Methods

Method: serialize-table-instruction OPERANDS STREAM

Serialize the table index of a table instruction.

Source: wasm-encoder.lisp (file)

Generic Function: serialize-variable-instruction OPERANDS STREAM

Package

wasm-encoder

Methods

Method: serialize-variable-instruction OPERANDS STREAM

Serialize the local variable index of a local variable instruction.

Source: wasm-encoder.lisp (file)

6.2.5 Types

Type: i32 ()

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Type: i64 ()

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Type: u32 ()

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Type: u64 ()

Package: wasm-encoder
Source: wasm-encoder.lisp (file)

Appendix A Indexes

A.1 Concepts

Jump to:	F L M W

	Index Entry	Section

F
	File, Lisp, `wasm-encoder.asd`:	The wasm-encoder․asd file
	File, Lisp, `wasm-encoder/src/package.lisp`:	The wasm-encoder/src/package․lisp file
	File, Lisp, `wasm-encoder/src/wasm-encoder.lisp`:	The wasm-encoder/src/wasm-encoder․lisp file

L
	Lisp File, `wasm-encoder.asd`:	The wasm-encoder․asd file
	Lisp File, `wasm-encoder/src/package.lisp`:	The wasm-encoder/src/package․lisp file
	Lisp File, `wasm-encoder/src/wasm-encoder.lisp`:	The wasm-encoder/src/wasm-encoder․lisp file

M
	Module, `wasm-encoder/src`:	The wasm-encoder/src module

W
	`wasm-encoder.asd`:	The wasm-encoder․asd file
	`wasm-encoder/src`:	The wasm-encoder/src module
	`wasm-encoder/src/package.lisp`:	The wasm-encoder/src/package․lisp file
	`wasm-encoder/src/wasm-encoder.lisp`:	The wasm-encoder/src/wasm-encoder․lisp file

Jump to:	F L M W

A.2 Functions

Jump to:	( C D F G I M S T W

	Index Entry	Section

(
	`(setf wasm-data-bytes)`:	Exported functions
	`(setf wasm-data-memory)`:	Exported functions
	`(setf wasm-data-mode)`:	Exported functions
	`(setf wasm-data-offset)`:	Exported functions
	`(setf wasm-element-index)`:	Exported functions
	`(setf wasm-element-init)`:	Exported functions
	`(setf wasm-element-init-expressions-expressions)`:	Exported functions
	`(setf wasm-element-init-expressions-type)`:	Internal functions
	`(setf wasm-element-init-index-functions)`:	Exported functions
	`(setf wasm-element-mode)`:	Exported functions
	`(setf wasm-element-offset)`:	Exported functions
	`(setf wasm-export-index)`:	Exported functions
	`(setf wasm-export-name)`:	Exported functions
	`(setf wasm-export-type)`:	Exported functions
	`(setf wasm-function-code)`:	Exported functions
	`(setf wasm-function-locals)`:	Exported functions
	`(setf wasm-function-type)`:	Exported functions
	`(setf wasm-function-type-params)`:	Exported functions
	`(setf wasm-function-type-results)`:	Exported functions
	`(setf wasm-global-init)`:	Exported functions
	`(setf wasm-global-mutable-p)`:	Exported functions
	`(setf wasm-global-type)`:	Exported functions
	`(setf wasm-import-desc)`:	Exported functions
	`(setf wasm-import-module)`:	Exported functions
	`(setf wasm-import-name)`:	Exported functions
	`(setf wasm-import-type)`:	Exported functions
	`(setf wasm-limit-max)`:	Exported functions
	`(setf wasm-limit-min)`:	Exported functions
	`(setf wasm-module-data)`:	Exported functions
	`(setf wasm-module-data-count)`:	Exported functions
	`(setf wasm-module-elements)`:	Exported functions
	`(setf wasm-module-exports)`:	Exported functions
	`(setf wasm-module-functions)`:	Exported functions
	`(setf wasm-module-globals)`:	Exported functions
	`(setf wasm-module-imports)`:	Exported functions
	`(setf wasm-module-memory)`:	Exported functions
	`(setf wasm-module-start)`:	Exported functions
	`(setf wasm-module-tables)`:	Internal functions
	`(setf wasm-module-types)`:	Exported functions
	`(setf wasm-table-max)`:	Exported functions
	`(setf wasm-table-min)`:	Exported functions
	`(setf wasm-table-type)`:	Exported functions

C
	`Compiler Macro, serialize-instruction-operands`:	Internal compiler macros
	`copy-wasm-data`:	Internal functions
	`copy-wasm-element`:	Internal functions
	`copy-wasm-element-init-expressions`:	Internal functions
	`copy-wasm-element-init-index`:	Internal functions
	`copy-wasm-export`:	Internal functions
	`copy-wasm-function`:	Internal functions
	`copy-wasm-function-type`:	Internal functions
	`copy-wasm-global`:	Internal functions
	`copy-wasm-import`:	Internal functions
	`copy-wasm-limit`:	Internal functions
	`copy-wasm-module`:	Internal functions
	`copy-wasm-table`:	Internal functions

D
	`data-segment-type-code`:	Internal functions

F
	`Function, (setf wasm-data-bytes)`:	Exported functions
	`Function, (setf wasm-data-memory)`:	Exported functions
	`Function, (setf wasm-data-mode)`:	Exported functions
	`Function, (setf wasm-data-offset)`:	Exported functions
	`Function, (setf wasm-element-index)`:	Exported functions
	`Function, (setf wasm-element-init)`:	Exported functions
	`Function, (setf wasm-element-init-expressions-expressions)`:	Exported functions
	`Function, (setf wasm-element-init-expressions-type)`:	Internal functions
	`Function, (setf wasm-element-init-index-functions)`:	Exported functions
	`Function, (setf wasm-element-mode)`:	Exported functions
	`Function, (setf wasm-element-offset)`:	Exported functions
	`Function, (setf wasm-export-index)`:	Exported functions
	`Function, (setf wasm-export-name)`:	Exported functions
	`Function, (setf wasm-export-type)`:	Exported functions
	`Function, (setf wasm-function-code)`:	Exported functions
	`Function, (setf wasm-function-locals)`:	Exported functions
	`Function, (setf wasm-function-type)`:	Exported functions
	`Function, (setf wasm-function-type-params)`:	Exported functions
	`Function, (setf wasm-function-type-results)`:	Exported functions
	`Function, (setf wasm-global-init)`:	Exported functions
	`Function, (setf wasm-global-mutable-p)`:	Exported functions
	`Function, (setf wasm-global-type)`:	Exported functions
	`Function, (setf wasm-import-desc)`:	Exported functions
	`Function, (setf wasm-import-module)`:	Exported functions
	`Function, (setf wasm-import-name)`:	Exported functions
	`Function, (setf wasm-import-type)`:	Exported functions
	`Function, (setf wasm-limit-max)`:	Exported functions
	`Function, (setf wasm-limit-min)`:	Exported functions
	`Function, (setf wasm-module-data)`:	Exported functions
	`Function, (setf wasm-module-data-count)`:	Exported functions
	`Function, (setf wasm-module-elements)`:	Exported functions
	`Function, (setf wasm-module-exports)`:	Exported functions
	`Function, (setf wasm-module-functions)`:	Exported functions
	`Function, (setf wasm-module-globals)`:	Exported functions
	`Function, (setf wasm-module-imports)`:	Exported functions
	`Function, (setf wasm-module-memory)`:	Exported functions
	`Function, (setf wasm-module-start)`:	Exported functions
	`Function, (setf wasm-module-tables)`:	Internal functions
	`Function, (setf wasm-module-types)`:	Exported functions
	`Function, (setf wasm-table-max)`:	Exported functions
	`Function, (setf wasm-table-min)`:	Exported functions
	`Function, (setf wasm-table-type)`:	Exported functions
	`Function, copy-wasm-data`:	Internal functions
	`Function, copy-wasm-element`:	Internal functions
	`Function, copy-wasm-element-init-expressions`:	Internal functions
	`Function, copy-wasm-element-init-index`:	Internal functions
	`Function, copy-wasm-export`:	Internal functions
	`Function, copy-wasm-function`:	Internal functions
	`Function, copy-wasm-function-type`:	Internal functions
	`Function, copy-wasm-global`:	Internal functions
	`Function, copy-wasm-import`:	Internal functions
	`Function, copy-wasm-limit`:	Internal functions
	`Function, copy-wasm-module`:	Internal functions
	`Function, copy-wasm-table`:	Internal functions
	`Function, data-segment-type-code`:	Internal functions
	`Function, intern-symbol`:	Internal functions
	`Function, intern-symbols`:	Internal functions
	`Function, make-wasm-data`:	Exported functions
	`Function, make-wasm-element`:	Exported functions
	`Function, make-wasm-element-init-expressions`:	Exported functions
	`Function, make-wasm-element-init-index`:	Exported functions
	`Function, make-wasm-export`:	Exported functions
	`Function, make-wasm-function`:	Exported functions
	`Function, make-wasm-function-type`:	Exported functions
	`Function, make-wasm-global`:	Exported functions
	`Function, make-wasm-import`:	Exported functions
	`Function, make-wasm-limit`:	Exported functions
	`Function, make-wasm-module`:	Exported functions
	`Function, make-wasm-table`:	Exported functions
	`Function, serialize-32-bit`:	Internal functions
	`Function, serialize-64-bit`:	Internal functions
	`Function, serialize-block`:	Internal functions
	`Function, serialize-branch`:	Internal functions
	`Function, serialize-data`:	Internal functions
	`Function, serialize-data-count-section`:	Internal functions
	`Function, serialize-data-section`:	Internal functions
	`Function, serialize-double-float`:	Internal functions
	`Function, serialize-export`:	Internal functions
	`Function, serialize-export-section`:	Internal functions
	`Function, serialize-expression`:	Internal functions
	`Function, serialize-float`:	Internal functions
	`Function, serialize-ftype`:	Internal functions
	`Function, serialize-function`:	Internal functions
	`Function, serialize-function-types`:	Internal functions
	`Function, serialize-functions`:	Internal functions
	`Function, serialize-global`:	Internal functions
	`Function, serialize-global-section`:	Internal functions
	`Function, serialize-i32`:	Internal functions
	`Function, serialize-import`:	Internal functions
	`Function, serialize-imports`:	Internal functions
	`Function, serialize-instruction`:	Internal functions
	`Function, serialize-instructions`:	Internal functions
	`Function, serialize-limit`:	Internal functions
	`Function, serialize-memory`:	Internal functions
	`Function, serialize-memory-instruction`:	Internal functions
	`Function, serialize-memory-types`:	Internal functions
	`Function, serialize-module`:	Exported functions
	`Function, serialize-nil-type`:	Internal functions
	`Function, serialize-ref-type`:	Internal functions
	`Function, serialize-section`:	Internal functions
	`Function, serialize-signed`:	Internal functions
	`Function, serialize-start-section`:	Internal functions
	`Function, serialize-string`:	Internal functions
	`Function, serialize-table`:	Internal functions
	`Function, serialize-table-element`:	Internal functions
	`Function, serialize-table-element-init`:	Internal functions
	`Function, serialize-table-elements`:	Internal functions
	`Function, serialize-table-types`:	Internal functions
	`Function, serialize-type`:	Internal functions
	`Function, serialize-types`:	Internal functions
	`Function, serialize-u32`:	Internal functions
	`Function, serialize-unsigned`:	Internal functions
	`Function, serialize-vector`:	Internal functions
	`Function, serialize-with-byte-size`:	Internal functions
	`Function, table-element-type-code`:	Internal functions
	`Function, wasm-data-bytes`:	Exported functions
	`Function, wasm-data-memory`:	Exported functions
	`Function, wasm-data-mode`:	Exported functions
	`Function, wasm-data-offset`:	Exported functions
	`Function, wasm-data-p`:	Exported functions
	`Function, wasm-element-index`:	Exported functions
	`Function, wasm-element-init`:	Exported functions
	`Function, wasm-element-init-expressions-expressions`:	Exported functions
	`Function, wasm-element-init-expressions-p`:	Exported functions
	`Function, wasm-element-init-expressions-type`:	Internal functions
	`Function, wasm-element-init-index-functions`:	Exported functions
	`Function, wasm-element-init-index-p`:	Exported functions
	`Function, wasm-element-mode`:	Exported functions
	`Function, wasm-element-offset`:	Exported functions
	`Function, wasm-element-p`:	Exported functions
	`Function, wasm-export-index`:	Exported functions
	`Function, wasm-export-name`:	Exported functions
	`Function, wasm-export-p`:	Exported functions
	`Function, wasm-export-type`:	Exported functions
	`Function, wasm-function-code`:	Exported functions
	`Function, wasm-function-locals`:	Exported functions
	`Function, wasm-function-p`:	Exported functions
	`Function, wasm-function-type`:	Exported functions
	`Function, wasm-function-type-p`:	Exported functions
	`Function, wasm-function-type-params`:	Exported functions
	`Function, wasm-function-type-results`:	Exported functions
	`Function, wasm-global-init`:	Exported functions
	`Function, wasm-global-mutable-p`:	Exported functions
	`Function, wasm-global-p`:	Exported functions
	`Function, wasm-global-type`:	Exported functions
	`Function, wasm-import-desc`:	Exported functions
	`Function, wasm-import-module`:	Exported functions
	`Function, wasm-import-name`:	Exported functions
	`Function, wasm-import-p`:	Exported functions
	`Function, wasm-import-type`:	Exported functions
	`Function, wasm-limit-max`:	Exported functions
	`Function, wasm-limit-min`:	Exported functions
	`Function, wasm-limit-p`:	Exported functions
	`Function, wasm-module-data`:	Exported functions
	`Function, wasm-module-data-count`:	Exported functions
	`Function, wasm-module-elements`:	Exported functions
	`Function, wasm-module-exports`:	Exported functions
	`Function, wasm-module-functions`:	Exported functions
	`Function, wasm-module-globals`:	Exported functions
	`Function, wasm-module-imports`:	Exported functions
	`Function, wasm-module-memory`:	Exported functions
	`Function, wasm-module-p`:	Exported functions
	`Function, wasm-module-start`:	Exported functions
	`Function, wasm-module-tables`:	Internal functions
	`Function, wasm-module-types`:	Exported functions
	`Function, wasm-table-max`:	Exported functions
	`Function, wasm-table-min`:	Exported functions
	`Function, wasm-table-p`:	Exported functions
	`Function, wasm-table-type`:	Exported functions

G
	`Generic Function, serialize-instruction-operands`:	Internal generic functions
	`Generic Function, serialize-table-instruction`:	Internal generic functions
	`Generic Function, serialize-variable-instruction`:	Internal generic functions

I
	`intern-symbol`:	Internal functions
	`intern-symbols`:	Internal functions

M
	`make-wasm-data`:	Exported functions
	`make-wasm-element`:	Exported functions
	`make-wasm-element-init-expressions`:	Exported functions
	`make-wasm-element-init-index`:	Exported functions
	`make-wasm-export`:	Exported functions
	`make-wasm-function`:	Exported functions
	`make-wasm-function-type`:	Exported functions
	`make-wasm-global`:	Exported functions
	`make-wasm-import`:	Exported functions
	`make-wasm-limit`:	Exported functions
	`make-wasm-module`:	Exported functions
	`make-wasm-table`:	Exported functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-instruction-operands`:	Internal generic functions
	`Method, serialize-table-instruction`:	Internal generic functions
	`Method, serialize-variable-instruction`:	Internal generic functions

S
	`serialize-32-bit`:	Internal functions
	`serialize-64-bit`:	Internal functions
	`serialize-block`:	Internal functions
	`serialize-branch`:	Internal functions
	`serialize-data`:	Internal functions
	`serialize-data-count-section`:	Internal functions
	`serialize-data-section`:	Internal functions
	`serialize-double-float`:	Internal functions
	`serialize-export`:	Internal functions
	`serialize-export-section`:	Internal functions
	`serialize-expression`:	Internal functions
	`serialize-float`:	Internal functions
	`serialize-ftype`:	Internal functions
	`serialize-function`:	Internal functions
	`serialize-function-types`:	Internal functions
	`serialize-functions`:	Internal functions
	`serialize-global`:	Internal functions
	`serialize-global-section`:	Internal functions
	`serialize-i32`:	Internal functions
	`serialize-import`:	Internal functions
	`serialize-imports`:	Internal functions
	`serialize-instruction`:	Internal functions
	`serialize-instruction-operands`:	Internal compiler macros
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instruction-operands`:	Internal generic functions
	`serialize-instructions`:	Internal functions
	`serialize-limit`:	Internal functions
	`serialize-memory`:	Internal functions
	`serialize-memory-instruction`:	Internal functions
	`serialize-memory-types`:	Internal functions
	`serialize-module`:	Exported functions
	`serialize-nil-type`:	Internal functions
	`serialize-ref-type`:	Internal functions
	`serialize-section`:	Internal functions
	`serialize-signed`:	Internal functions
	`serialize-start-section`:	Internal functions
	`serialize-string`:	Internal functions
	`serialize-table`:	Internal functions
	`serialize-table-element`:	Internal functions
	`serialize-table-element-init`:	Internal functions
	`serialize-table-elements`:	Internal functions
	`serialize-table-instruction`:	Internal generic functions
	`serialize-table-instruction`:	Internal generic functions
	`serialize-table-types`:	Internal functions
	`serialize-type`:	Internal functions
	`serialize-types`:	Internal functions
	`serialize-u32`:	Internal functions
	`serialize-unsigned`:	Internal functions
	`serialize-variable-instruction`:	Internal generic functions
	`serialize-variable-instruction`:	Internal generic functions
	`serialize-vector`:	Internal functions
	`serialize-with-byte-size`:	Internal functions

T
	`table-element-type-code`:	Internal functions

W
	`wasm-data-bytes`:	Exported functions
	`wasm-data-memory`:	Exported functions
	`wasm-data-mode`:	Exported functions
	`wasm-data-offset`:	Exported functions
	`wasm-data-p`:	Exported functions
	`wasm-element-index`:	Exported functions
	`wasm-element-init`:	Exported functions
	`wasm-element-init-expressions-expressions`:	Exported functions
	`wasm-element-init-expressions-p`:	Exported functions
	`wasm-element-init-expressions-type`:	Internal functions
	`wasm-element-init-index-functions`:	Exported functions
	`wasm-element-init-index-p`:	Exported functions
	`wasm-element-mode`:	Exported functions
	`wasm-element-offset`:	Exported functions
	`wasm-element-p`:	Exported functions
	`wasm-export-index`:	Exported functions
	`wasm-export-name`:	Exported functions
	`wasm-export-p`:	Exported functions
	`wasm-export-type`:	Exported functions
	`wasm-function-code`:	Exported functions
	`wasm-function-locals`:	Exported functions
	`wasm-function-p`:	Exported functions
	`wasm-function-type`:	Exported functions
	`wasm-function-type-p`:	Exported functions
	`wasm-function-type-params`:	Exported functions
	`wasm-function-type-results`:	Exported functions
	`wasm-global-init`:	Exported functions
	`wasm-global-mutable-p`:	Exported functions
	`wasm-global-p`:	Exported functions
	`wasm-global-type`:	Exported functions
	`wasm-import-desc`:	Exported functions
	`wasm-import-module`:	Exported functions
	`wasm-import-name`:	Exported functions
	`wasm-import-p`:	Exported functions
	`wasm-import-type`:	Exported functions
	`wasm-limit-max`:	Exported functions
	`wasm-limit-min`:	Exported functions
	`wasm-limit-p`:	Exported functions
	`wasm-module-data`:	Exported functions
	`wasm-module-data-count`:	Exported functions
	`wasm-module-elements`:	Exported functions
	`wasm-module-exports`:	Exported functions
	`wasm-module-functions`:	Exported functions
	`wasm-module-globals`:	Exported functions
	`wasm-module-imports`:	Exported functions
	`wasm-module-memory`:	Exported functions
	`wasm-module-p`:	Exported functions
	`wasm-module-start`:	Exported functions
	`wasm-module-tables`:	Internal functions
	`wasm-module-types`:	Exported functions
	`wasm-table-max`:	Exported functions
	`wasm-table-min`:	Exported functions
	`wasm-table-p`:	Exported functions
	`wasm-table-type`:	Exported functions

Jump to:	( C D F G I M S T W

A.3 Variables

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

	Index Entry	Section

+
	`+code-section-id+`:	Internal constants
	`+custom-section-id+`:	Internal constants
	`+data-count-section-id+`:	Internal constants
	`+data-section-id+`:	Internal constants
	`+element-section-id+`:	Internal constants
	`+export-section-id+`:	Internal constants
	`+function-section-id+`:	Internal constants
	`+global-section-id+`:	Internal constants
	`+import-section-id+`:	Internal constants
	`+memory-section-id+`:	Internal constants
	`+op-codes+`:	Internal constants
	`+start-section-id+`:	Internal constants
	`+table-section-id+`:	Internal constants
	`+type-section-id+`:	Internal constants

B
	`bytes`:	Exported structures

C
	`code`:	Exported structures
	`Constant, +code-section-id+`:	Internal constants
	`Constant, +custom-section-id+`:	Internal constants
	`Constant, +data-count-section-id+`:	Internal constants
	`Constant, +data-section-id+`:	Internal constants
	`Constant, +element-section-id+`:	Internal constants
	`Constant, +export-section-id+`:	Internal constants
	`Constant, +function-section-id+`:	Internal constants
	`Constant, +global-section-id+`:	Internal constants
	`Constant, +import-section-id+`:	Internal constants
	`Constant, +memory-section-id+`:	Internal constants
	`Constant, +op-codes+`:	Internal constants
	`Constant, +start-section-id+`:	Internal constants
	`Constant, +table-section-id+`:	Internal constants
	`Constant, +type-section-id+`:	Internal constants

D
	`data`:	Exported structures
	`data-count`:	Exported structures
	`desc`:	Exported structures

E
	`elements`:	Exported structures
	`exports`:	Exported structures
	`expressions`:	Exported structures

F
	`functions`:	Exported structures
	`functions`:	Exported structures

G
	`globals`:	Exported structures

I
	`imports`:	Exported structures
	`index`:	Exported structures
	`index`:	Exported structures
	`init`:	Exported structures
	`init`:	Exported structures

L
	`locals`:	Exported structures

M
	`max`:	Exported structures
	`memory`:	Exported structures
	`memory`:	Exported structures
	`min`:	Exported structures
	`mode`:	Exported structures
	`mode`:	Exported structures
	`module`:	Exported structures
	`mutable-p`:	Exported structures

N
	`name`:	Exported structures
	`name`:	Exported structures

O
	`offset`:	Exported structures
	`offset`:	Exported structures

P
	`params`:	Exported structures

R
	`results`:	Exported structures

S
	`Slot, bytes`:	Exported structures
	`Slot, code`:	Exported structures
	`Slot, data`:	Exported structures
	`Slot, data-count`:	Exported structures
	`Slot, desc`:	Exported structures
	`Slot, elements`:	Exported structures
	`Slot, exports`:	Exported structures
	`Slot, expressions`:	Exported structures
	`Slot, functions`:	Exported structures
	`Slot, functions`:	Exported structures
	`Slot, globals`:	Exported structures
	`Slot, imports`:	Exported structures
	`Slot, index`:	Exported structures
	`Slot, index`:	Exported structures
	`Slot, init`:	Exported structures
	`Slot, init`:	Exported structures
	`Slot, locals`:	Exported structures
	`Slot, max`:	Exported structures
	`Slot, memory`:	Exported structures
	`Slot, memory`:	Exported structures
	`Slot, min`:	Exported structures
	`Slot, mode`:	Exported structures
	`Slot, mode`:	Exported structures
	`Slot, module`:	Exported structures
	`Slot, mutable-p`:	Exported structures
	`Slot, name`:	Exported structures
	`Slot, name`:	Exported structures
	`Slot, offset`:	Exported structures
	`Slot, offset`:	Exported structures
	`Slot, params`:	Exported structures
	`Slot, results`:	Exported structures
	`Slot, start`:	Exported structures
	`Slot, tables`:	Exported structures
	`Slot, type`:	Exported structures
	`Slot, type`:	Exported structures
	`Slot, type`:	Exported structures
	`Slot, type`:	Exported structures
	`Slot, type`:	Exported structures
	`Slot, type`:	Exported structures
	`Slot, types`:	Exported structures
	`start`:	Exported structures

T
	`tables`:	Exported structures
	`type`:	Exported structures
	`type`:	Exported structures
	`type`:	Exported structures
	`type`:	Exported structures
	`type`:	Exported structures
	`type`:	Exported structures
	`types`:	Exported structures

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

A.4 Data types

Jump to:	I P S T U W

	Index Entry	Section

I
	`i32`:	Internal types
	`i64`:	Internal types

P
	`Package, wasm-encoder`:	The wasm-encoder package

S
	`Structure, wasm-data`:	Exported structures
	`Structure, wasm-element`:	Exported structures
	`Structure, wasm-element-init-expressions`:	Exported structures
	`Structure, wasm-element-init-index`:	Exported structures
	`Structure, wasm-export`:	Exported structures
	`Structure, wasm-function`:	Exported structures
	`Structure, wasm-function-type`:	Exported structures
	`Structure, wasm-global`:	Exported structures
	`Structure, wasm-import`:	Exported structures
	`Structure, wasm-limit`:	Exported structures
	`Structure, wasm-module`:	Exported structures
	`Structure, wasm-table`:	Exported structures
	`System, wasm-encoder`:	The wasm-encoder system

T
	`Type, i32`:	Internal types
	`Type, i64`:	Internal types
	`Type, u32`:	Internal types
	`Type, u64`:	Internal types

U
	`u32`:	Internal types
	`u64`:	Internal types

W
	`wasm-data`:	Exported structures
	`wasm-element`:	Exported structures
	`wasm-element-init-expressions`:	Exported structures
	`wasm-element-init-index`:	Exported structures
	`wasm-encoder`:	The wasm-encoder system
	`wasm-encoder`:	The wasm-encoder package
	`wasm-export`:	Exported structures
	`wasm-function`:	Exported structures
	`wasm-function-type`:	Exported structures
	`wasm-global`:	Exported structures
	`wasm-import`:	Exported structures
	`wasm-limit`:	Exported structures
	`wasm-module`:	Exported structures
	`wasm-table`:	Exported structures

Jump to:	I P S T U W

• Introduction		What wasm-encoder is all about
• Systems		The systems documentation
• Modules		The modules documentation
• Files		The files documentation
• Packages		The packages documentation
• Definitions		The symbols documentation
• Indexes		Concepts, functions, variables and data types

• Internal constants
• Internal compiler macros
• Internal functions
• Internal generic functions
• Internal types

• Concept index
• Function index
• Variable index
• Data type index

• The wasm-encoder.asd file
• The wasm-encoder/src/package.lisp file
• The wasm-encoder/src/wasm-encoder.lisp file

The wasm-encoder Reference Manual

Table of Contents

The wasm-encoder Reference Manual

1 Introduction

2 Systems

2.1 wasm-encoder

3 Modules

3.1 wasm-encoder/src

4 Files

4.1 Lisp

4.1.1 wasm-encoder.asd

4.1.2 wasm-encoder/src/package.lisp

4.1.3 wasm-encoder/src/wasm-encoder.lisp

5 Packages

5.1 wasm-encoder

6 Definitions

6.1 Exported definitions

6.1.1 Functions

6.1.2 Structures

6.2 Internal definitions

6.2.1 Constants

6.2.2 Compiler macros

6.2.3 Functions

6.2.4 Generic functions

6.2.5 Types

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types

2.1 `wasm-encoder`

3.1 `wasm-encoder/src`

4.1.1 `wasm-encoder.asd`

4.1.2 `wasm-encoder/src/package.lisp`

4.1.3 `wasm-encoder/src/wasm-encoder.lisp`

5.1 `wasm-encoder`