Kwasm.format.text.module

Parses a DataSegment from the receiving List of Tokens.

From the docs:

data_I     ::= ‘(’ ‘data’ x:memidx_I ‘(’ ‘offset’ e:expr_I ‘)’ b*:datastring ‘)’
=> {data x′, offset e, init b*}
datastring ::= (b*:string)*
=> concat((b*)*)

Note:* In the current version of WebAssembly, the only valid memory index is 0 or a symbolic memory identifier resolving to the same value.

Parses an ElementSegment from the receiving List of Tokens.

From the docs:

elem_I ::= ‘(’ ‘elem’ x:tableidx_I ‘(’ ‘offset’ e:expr_I ‘)’ y*:vec(funcidx_I) ‘)’
\          => {table x, offset e, init y*}

Parses an Export from the receiving List of Tokens.

From the docs:

export_I ::= ‘(’ ‘export’ nm:name d:exportdesc_I ‘)’ => {name nm, desc d}

Parses an ExportDescriptor from the receiving List of Tokens.

From the docs:

exportdesc_I    ::= ‘(’ ‘func’ x:funcidx_I ‘)’      => func x
‘(’ ‘table’ x:tableidx_I ‘)’    => table x
‘(’ ‘memory’ x:memidx_I ‘)’     => mem x
‘(’ ‘global’ x:globalidx_I ‘)’  => global x

Parses a Global from the receiving List of Tokens.

From the docs:

global_I   ::= ‘(’ ‘global’ id? gt:globaltype  e:expr_I ‘)’    => {type gt, init e}

Parses an inline Global-Import from the receiving List of Tokens.

From the docs:

‘(’ ‘global’ id? ‘(’ ‘import’ name^1 name^2 ‘)’ globaltype ‘)’
== ‘(’ ‘import’ name^1 name^2 ‘(’ ‘global’ id? globaltype ‘)’ ‘)’

Parses an inline Global-Export from the receiving List of Tokens.

From the docs:

‘(’ ‘global’ id? ‘(’ ‘export’ name ‘)’ ... ‘)’
== ‘(’ ‘export’ name ‘(’ ‘global’ id′ ‘)’ ‘)’ ‘(’ ‘global’ id′ ... ‘)’
(if id′ = id? != ϵ ∨ id′ fresh)

Where “...” can contain another import or export.

Parses an Import from the receiving List of Tokens.

From the docs:

import_I ::= ‘(’ ‘import’ mod:name nm:name d:importdesc_I ‘)’ => {module mod, name nm, desc d}

Parses an ImportDescriptor of type T from the receiving List of Tokens.

From the docs:

importdesc_I  ::= ‘(’ ‘func’ id? x,I':typeuse_I ‘)’  => func x
‘(’ ‘table’ id? tt:tabletype ‘)’   => table tt
‘(’ ‘memory’ id? mt:memtype ‘)’    => mem mt
‘(’ ‘global’ id? gt:globaltype ‘)’ => global gt

Parses an Index from the receiving List of Tokens.

For details on the grammar, see Index.

Parses up to maxes from the receiving List of Tokens starting at fromIndex. If no indices are found, returns a ParseResult with an empty AstNodeList.

Parses a Local from the receiving List of Tokens.

From the docs:

local ::= ‘(’ ‘local’ id? t:valtype ‘)’ => t

Parses an AstNodeList of Locals from the receiving List of Tokens.

See parseLocal.

Parses a Memory from the receiving List of Tokens.

From the docs:

mem_I  ::= ‘(’ 'memory'  id?  mt:memtype ‘)’   =>

Abbreviations

A data segment can be given inline with a memory definition, in which case its offset is 0 the limits of the memory type are inferred from the length of the data, rounded up to page size:

‘(’ ‘memory’  id?  ‘(’ ‘data’  bn:datastring ‘)’  ‘)’
   ≡   ‘(’ ‘memory’  id′  m  m ‘)’ ‘(’ ‘data’  id′  ‘(’ ‘i32.const’  ‘0’ ‘)’  datastring ‘)’
       (if id′ = id? != ϵ ∨ id′ fresh, m=ceil(n/64Ki))

Parses an inline Memory-Import from the receiving List of Tokens.

From the docs:

‘(’ ‘memory’ id? ‘(’ ‘import’ name^1 name^2 ‘)’ memtype ‘)’
== ‘(’ ‘import’ name^1 name^2 ‘(’ ‘memory’ id? memtype ‘)’ ‘)’

Parses an inline Memory-Export from the receiving List of Tokens.

From the docs:

‘(’ ‘memory’ id? ‘(’ ‘export’ name ‘)’ ... ‘)’
== ‘(’ ‘export’ name ‘(’ ‘memory’ id′ ‘)’ ‘)’ ‘(’ ‘memory’ id′ ... ‘)’
(if id′ = id? != ϵ ∨ id′ fresh)

Where “...” can contain another import or export or an inline data segment.

Parses an Offset from the receiving List of Tokens.

Parses a StartFunction from the receiving List of Tokens.

From the docs:

A start function is defined in terms of its index.

start_I ::= ‘(’ ‘start’ x:funcidx_I ‘)’ =>

Parses a Table and (optionally) an ElementType from the receiving List of Tokens.

From the docs:

table_I ::= ‘(’ ‘table’ id? tt:tabletype ‘)’ =>

Abbreviations

An element segment can be given inline with a table definition, in which case its offset is 0 and the limits of the table type are inferred from the length of the given segment:

‘(’ ‘table’ id? elemtype ‘(’ ‘elem’ xn:vec(funcidx) ‘)’ ‘)’
   == ‘(’ ‘table’ id′ n n elemtype ‘)’ ‘(’ ‘elem’ id′ ‘(’ ‘i32.const’ ‘0’ ‘)’ vec(funcidx) ‘)’
       (if id′ == id? != ϵ ∨ id′ fresh)

Parses an inline Table-Import from the receiving List of Tokens.

From the docs:

‘(’ ‘table’ id? ‘(’ ‘import’ name^1 name^2 ‘)’ tabletype ‘)’
== ‘(’ ‘import’ name^1 name^2 ‘(’ ‘table’ id? tabletype ‘)’ ‘)’

Parses an inline Table-Export from the receiving List of Tokens.

From the docs:

‘(’ ‘table’ id? ‘(’ ‘export’ name ‘)’ ... ‘)’
== ‘(’ ‘export’ name ‘(’ ‘table’ id′ ‘)’ ‘)’ ‘(’ ‘table’ id′ ... ‘)’
(if id′ = id? != ϵ ∨ id′ fresh)

Where “...” can contain another import or export or an inline elements segment.

Parses a type as a FunctionType from the receiving List of Tokens.

From the docs:

type ::= ‘(’ ‘type’ id? ft:functype ‘)’ => ft

Parses a TypeUse out of the Token according to the following grammar from the docs.

For the required runtime checks are see TypeUse:

typeuse(I) ::=
empty                                                   => TypeUse(null)
(t_1:param)* (t_2:result)*                              => TypeUse(x, [t_1], [t_2])
‘(’ ‘type’ x:typeidx(I) ‘)’                             => TypeUse(x)
‘(’ ‘type’ x:typeidx(I) ‘)’ (t_1:param)* (t_2:result)*  => TypeUse(x, [t_1], [t_2])

Parses a WasmFunction from the receiving List of Tokens.

From the docs:

func_I ::= ‘(’ ‘func’ id? x,I′:typeuse_I (t:local)* (in:instr_I′‘)‘* ‘)’
=> {type x, locals t*, body in* end}

Parses an inline-import function declaration from the receiving List of Tokens.

From the docs:

‘(’ ‘func’ id? ‘(’ ‘import’ name^1 name^2 ‘)’ typeuse ‘)’
== ‘(’ ‘import’ name^1 name^2 ‘(’ ‘func’ id? typeuse ‘)’ ‘)’

Parses an inline-export function from the receiving List of Tokens.

From the docs:

‘(’ ‘func’ id? ‘(’ ‘export’ name ‘)’ … ‘)’
== ‘(’ ‘export’ name ‘(’ ‘func’ id′ ‘)’ ‘)’ ‘(’ ‘func’ id′ … ‘)’
(if id′ == id? != ϵ ∨ id′ fresh)

Parses a WasmModule from the receiving List of Tokens.

From the docs:

A module consists of a sequence of fields that can occur in any order. All definitions and their respective bound identifiers scope over the entire module, including the text preceding them.

A module may optionally bind an identifier that names the module. The name serves a documentary role only.

module         ::= ‘(’ ‘module’ id? (m:modulefield_I)* ‘)’     => ⨁m*
(if I = ⨁ idc(modulefield)* well-formed)
modulefield_I  ::= ty:type                                     => 
im:import_I                                 => 
fn:func_I                                   => 
ta:table_I                                  => 
me:mem_I                                    => 
gl:global_I                                 => 
ex:export_I                                 => 
st:start_I                                  => 
el:elem_I                                   => 
da:data_I                                   =>