text-unit.CHARACTER

description::
· the-text-format assigns meaning to source-text, which consists of a sequence of characters.
· characters are-assumed to be-represented as valid Unicode (Section 2.4) code-points.
- source ::= char∗
- char ::= U+00 | … | U+D7FF | U+E000 | … | U+10FFFF
· note: while source-text may-contain any Unicode-character in comments or string-literals, the-rest of the-grammar is-formed exclusively from the-characters supported by the-7-bit-ASCII-subset-of-Unicode.
[https://webassembly.github.io/spec/core/text/lexical.html#characters {1-0.2018-03-28}]

name::
* McsEngl.lagWasm'character-of-txt-algo,

text-unit.WHITE-SPACE

description::
· white-space is any sequence of literal-space-characters, formatting-characters, or comments.
· the allowed formatting-characters correspond to a subset of the-ASCII-format-effectors, namely, horizontal-tabulation-(U+09), line-feed-(U+0A), and carriage-return-(U+0D).
space ::= (‘ ’ | format | comment)∗
format ::= U+09 | U+0A | U+0D
· the only relevance of white-space is to separate tokens, it is-ignored otherwise.
[https://webassembly.github.io/spec/core/text/lexical.html#white-space]

name::
* McsEngl.lagWasm'white-space,
* McsEngl.Wasm-text-unit.white-space,

text-unit.TOKEN

description::
· the character stream in the-source-text is-divided, from left to right, into a sequence of tokens, as defined by the following grammar.
- token ::= keyword | uN | sN | fN | string | id | ‘(’ | ‘)’ | reserved
- keyword ::= (‘a’ | … | ‘z’) idchar∗(if occurring as a literal terminal in the grammar)
- reserved ::= idchar+
· tokens are-formed from the input character stream according to the longest match rule.
· that is, the next token always consists of the longest possible sequence of characters that is recognized by the above lexical-grammar.
· tokens can-be-separated by white-space, but except for strings, they cannot themselves contain whitespace.
[https://webassembly.github.io/spec/core/text/lexical.html#tokens {1-0.2018-03-28}]

name::
* McsEngl.lagWasm'token-of-text-algo,

text-unit.COMMENT

description::
· a-comment can either be a-line-comment, started with a double semicolon ‘;;’ and extending to the-end of the-line, or a-block-comment, enclosed in delimiters ‘(;’…‘;)’.
· block-comments can-be-nested.
[https://webassembly.github.io/spec/core/text/lexical.html#comments {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'comment,

example::
(global (;0;) (mut i32) (i32.const 100)) ;;mutable-variable
//(;0;) is a-block-comment denoting the-index of the-global
//;;mutable-variable is a-line-comment

text-sem-unit.STRING

description::
· strings denote sequences of bytes that can-represent both textual and binary data.
· they are-enclosed in quotation-marks and may-contain any character other than ASCII-control-characters, quotation-marks (‘"’), or backslash (‘∖’), except when expressed with an-escape-sequence.
[https://webassembly.github.io/spec/core/text/values.html#strings {1-0.2018-03-28}]

name::
* McsEngl.lagWasm'string,
* McsEngl.Wasm-sem-unit.string,

value.SPECIFIC

name::
* McsEngl.Wasm-value.specific,

specific::
* byte,
* f32,
* f64,
* floating-point,
* i32,
* i64,
* integer,
* result,
* value-type,

value.TYPE

name::
* McsEngl.lagWasm'basic-data-type,
* McsEngl.lagWasm'machine-type,
* McsEngl.lagWasm'value-type,

specific::
* i32,
* i64,
* f32,
* f64,

value.i32

description::
The types i32 and i64 classify 32 and 64 bit integers, respectively. Integers are not inherently signed or unsigned, their interpretation is determined by individual operations.
[https://webassembly.github.io/spec/core/syntax/types.html#value-types {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'i32-sem-unit,
* McsEngl.Wasm-sem-unit.i32,
* McsEngl.Wasm-value.i32,

value.i64

name::
* McsEngl.lagWasm'i64-sem-unit,
* McsEngl.Wasm-sem-unit.i64,
* McsEngl.Wasm-value.i64,

value.f32

description::
The types f32 and f64 classify 32 and 64 bit floating-point data, respectively. They correspond to the respective binary floating-point representations, also known as single and double precision, as defined by the IEEE 754-2008 standard (Section 3.3).
[https://webassembly.github.io/spec/core/syntax/types.html#value-types {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'f32-sem-unit,
* McsEngl.Wasm-sem-unit.f32,
* McsEngl.Wasm-value.f32,

value.f64

name::
* McsEngl.lagWasm'f64-sem-unit,
* McsEngl.Wasm-sem-unit.f64,
* McsEngl.Wasm-value.f64,

value.INTEGER

description::
· different classes of integers with different value ranges are distinguished by their bit-width-N and by whether they are unsigned or signed.
· the main integer types occurring in this specification are u32, u64, s32, s64, i8, i16, i32, i64. However, other sizes occur as auxiliary constructions, e.g., in the definition of floating-point numbers.
[https://webassembly.github.io/spec/core/syntax/values.html#integers {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'integer,
* McsEngl.lagWasm'number.integer,
* McsEngl.Wasm-sem-unit.integer,

value.FLOATING-POINT

description::
·

name::
* McsEngl.lagWasm'floating-point,
* McsEngl.lagWasm'number.floating-point,
* McsEngl.Wasm-sem-unit.floating-point,

value.BYTE

description::
· byte is equal to 8 bits, and it is-used to denote different things.

name::
* McsEngl.lagWasm'byte,
* McsEngl.Wasm-value.byte,

value.LIMIT

description::
· limit is the-size-range of resizeable storage associated with memory-types and table-types.
· limits ::= {min u32, max u32?}
· if no maximum is given, the respective storage can grow to any size.

name::
* McsEngl.lagWasm'limit-type,
* McsEngl.Wasm-sem-unit.limit,

value.RESULT

description::
· result is a sequence of values which is the-output of executing instructions or blocks.
· in current version, at most one value is-allowed.
[https://webassembly.github.io/spec/core/syntax/types.html#result-types {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'result-type,
* McsEngl.Wasm-value.result,

parameter of function

name::
* McsEngl.lagWasm'param-of-function,
* McsEngl.Wasm-function'param,

return-value of function

description::
· the-return-value of a-function is just the final value left on the-stack.
· the-WebAssembly validation-rules ensure the-stack matches exactly: if you declare a (result f32), then the-stack must contain exactly one f32 at the-end.
· If there is no result-type, the-stack must-be-empty.
[https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format]

name::
* McsEngl.lagWasm'result-of-function,
* McsEngl.Wasm-function'result,

type of function

description::
· function-types classify the-signature of functions, mapping a-vector of parameters to a-vector of results, written as follows.
- functype ::= [vec(valtype)] → [vec(valtype)]
· note: in the current version of WebAssembly, the-length of the-result-type-vector of a valid function-type may-be at most 1. This restriction may-be-removed in future versions.
[https://webassembly.github.io/spec/core/syntax/types.html#syntax-functype {1-0.2018-04-05}]
===
· function-type is a generic signature that maps a-vector of parmeters to a-vector of results[a] which[a] in the current version is at most 1.
[https://webassembly.github.io/spec/core/syntax/types.html#syntax-functype {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'type-of-function,
* McsEngl.Wasm-function'signature,
* McsEngl.Wasm-function'type,
* McsEngl.Wasm-function-type,

body of function

description::
· the-body-of-a-function is a-sequence of instructions that describe the-process of the-function:
(i32.mul
 (i32.add (i32.const 5) (get_local $x))
 (i32.const 2)
)
or in the following format:
i32.const 5
get_local $x
i32.add
i32.const 2
i32.mul
· in the-binary-format, the-order of instructions is always sequential.

name::
* McsEngl.Wasm-function'body,
* McsEngl.Wasm-function'code,

index-space of function

description::
· the-index-space for functions, tables, memories and globals includes respective imports declared in the same module.
· the-indices of these imports precede the-indices of other definitions in the same index-space.
[https://webassembly.github.io/spec/core/syntax/modules.html#indices {1-0.2018-03-22}]

name::
* McsEngl.Wasm-function'index-space,

calling of function

description::
· when a-function is-called, it starts with an empty stack which is gradually filled-up and emptied as the body’s instructions are-executed.
===
· Invocation may fail with an error if the arguments do not fit the function type.
[https://webassembly.github.io/spec/core/exec/modules.html#invocation]

name::
* McsEngl.Wasm-function'calling,
* McsEngl.Wasm-function'invocating,

function.START

description::
· modules can-define a-start-function that is automatically executed.
[https://webassembly.github.io/spec/core/intro/overview.html#concepts {1-0.2018-03-22}]
===
· the-start-component of a-module optionally declares the-function-index of a-start-function that is automatically invoked when the-module is-instantiated, after tables and memories have-been-initialized.
- start ::= {func funcidx}
[https://webassembly.github.io/spec/core/syntax/modules.html#start-function {1-0.2018-03-28}]

name::
* McsEngl.lagWasm'start-function,
* McsEngl.Wasm-function.start,
* McsEngl.Wasm-start-function,

function.ADD

description::
· input: 2 i32 numbers.
· output: the-sum of input.

(func (export "f") (param $p1 i32) (param $p2 i32) (result i32)
 get_local $p1
 get_local $p2
 i32.add
)
//=== javascript code:
let f = oModule.instance.exports.f;
console.log(f(8,2)); //outputs 10

name::
* McsEngl.Wasm-function.add,

function.UPPER-CASE

description::
· make upper-case the-english-letters (as numbers) of wasm-memory.
· input: the-length of memory to work with.

(func (export "fWupper") (param $length i32)
  ;; var i = 0
  (local $i i32) ;; store loop index
  (local $sbl i32) ;; store char code

  (block $Lbreak
    ;; while(true)
    (loop $Lloop
      ;; if (i >= length) break
      (br_if $Lbreak (i32.ge_u (get_local $i) (get_local $length)))
      ;; sbl = $memory[i]
      (set_local $sbl (i32.load8_u (get_local $i)))

      ;; if (sbl >= 97 && sbl <= 122)
      (if (i32.ge_u (get_local $sbl) (i32.const 97))
        (if (i32.le_u (get_local $sbl) (i32.const 122))
          ;; $memory[i] = sbl - 32, upper-case
          (i32.store8 (get_local $i) (i32.sub (get_local $sbl) (i32.const 32)))
        )
      )
      ;; ++i
      (set_local $i (i32.add (get_local $i) (i32.const 1)))
      ;; continue
      (br $Lloop)
    )
  )
)
or
(type (;0;) (func (param i32)))
(func (;0;) (type 0) (param i32)
  (local i32 i32)
  block ;; label = @1
    loop ;; label = @2
      get_local 1
      get_local 0
      i32.ge_u
      br_if 1 (;@1;)
      get_local 1
      i32.load8_u
      set_local 2
      get_local 2
      i32.const 97
      i32.ge_u
      if ;; label = @3
        get_local 2
        i32.const 122
        i32.le_u
        if ;; label = @4
          get_local 1
          get_local 2
          i32.const 32
          i32.sub
          i32.store8
        end
      end
      get_local 1
      i32.const 1
      i32.add
      set_local 1
      br 0 (;@2;)
    end
  end
)
[https://github.com/reklatsmasters/webassembly-examples/blob/master/%235-loop/loop.wat]

name::
* McsEngl.Wasm-function.upper-case,

variable.GLOBAL

name::
* McsEngl.lagWasm'global-variable,
* McsEngl.Wasm-global,
* McsEngl.Wasm-variable.global,

variable.LOCAL

description::
· locals are the-variables of functions, parameters AND body variables.
===
· locals are like variables in many higher-level-programming-languages: we can-name them, store values to them and load values from them.
· locals are-named using function-local integer index.
· when defining a-function-body, we can-declare any number of locals for the function's code.
· parameters to a-function are also locals and the “name” index of locals start at 0 with the first function parameter and continue incrementing with each additional parameter and eventually with each listed local of the-function-body.
· locals are always initialized to zero (all their bits are 0.)
[https://rsms.me/wasm-intro]

name::
* McsEngl.lagWasm'local-variable,
* McsEngl.Wasm-local,
* McsEngl.Wasm-variable.local,

declaration of table

description::
Field-Name | Type | Description
element_type | table element type | the element type of the table
resizable | resizable limits | table flags and sizes in units of elements
[https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#table-description]

name::
* McsEngl.lagWasm'table'declaration,
* McsEngl.Wasm-table'declaration,
* McsEngl.Wasm-table'description,

index-space of table

description::
· the-index-space for functions, tables, memories and globals includes respective imports declared in the same module.
· the-indices of these imports precede the-indices of other definitions in the same index-space.
[https://webassembly.github.io/spec/core/syntax/modules.html#indices {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'table'index-space,
* McsEngl.Wasm-table'index-space,

element of table

name::
* McsEngl.lagWasm'element-segment,
* McsEngl.lagWasm'table'element-segment,

table.TEXT

example::
// defines a-table with elements 2 funtions, and export it
(table (export "tbl") anyfunc (elem $f13 $f42))
===
// imports a-table with 2 elements and initializes the 2 elements.
(import "js" "tbl" (table 2 anyfunc))
(elem (i32.const 0) $f42 $f83)

table.BINARY

description::
·

declaration of memory

name::
* McsEngl.Wasm-memory'declaration,
* McsEngl.Wasm-memory'definition,

page of memory

description::
· pages in WebAssembly are 64-KiB, and are the-units used in linear-memory size-declarations and size-operations.
[https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#pages]

name::
* McsEngl.Wasm-memory'page,

index-space of memory

description::
· the-index-space for functions, tables, memories and globals includes respective imports declared in the same module.
· the-indices of these imports precede the-indices of other definitions in the same index-space.
[https://webassembly.github.io/spec/core/syntax/modules.html#indices {1-0.2018-03-22}]

name::
* McsEngl.Wasm-memory'index-space,

instruction of memory (link)

index of named-sem-unit

description::
· definitions are-referenced with zero-based indices.
· each class of definition has its own index-space, as distinguished by the following classes.
- typeidx ::= u32
- funcidx ::= u32
- tableidx ::= u32
- memidx ::= u32
- globalidx ::= u32
- localidx ::= u32
- labelidx ::= u32
[https://webassembly.github.io/spec/core/syntax/modules.html#syntax-index {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'index-of-sem-unit,

identifier of named-sem-unit

description::
· indices can-be-given in both numeric and symbolic form.
· symbolic-identifiers that stand in-lieu-of indices start with ‘$’, followed by any sequence of printable-ASCII-characters that does-not-contain a-space, quotation-mark, comma, semicolon, or bracket.
- id ::= ‘$’ idchar+
- idchar ::= ‘0’ | … | ‘9’
  | ‘A’ | … | ‘Z’
  | ‘a’ | … | ‘z’
  | ‘!’ | ‘#’ | ‘$’ | ‘%’ | ‘&’ | ‘′’ | ‘∗’ | ‘+’ |
  | ‘−’ | ‘.’ | ‘/’
  | ‘:’ | ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘∖’ | ‘ ^’ | ‘_’ | ‘`’ | ‘|’ | ‘~’
[https://webassembly.github.io/spec/core/text/values.html#text-idchar {1-0.2018-03-28}]

name::
* McsEngl.lagWasm'identifier-of-sem-unit,

mnemonic of opcode

name::
* McsEngl.Wasm-instruction'mnemonic,

opcode.SPECIFIC

control-instruction.STRUCTURED

description::
· the block, loop and if instructions are structured-instructions.
· they bracket nested sequences of instructions, called blocks, terminated with, or separated by, end or else pseudo-instructions.
· as the-grammar prescribes, they must-be-well-nested.
· a-structured-instruction can-produce a-value as described by the annotated result-type.
[https://webassembly.github.io/spec/core/syntax/instructions.html#control-instructions {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'structured-control-instruction,
* McsEngl.Wasm-instruction.structured-control,

addressWpg::
* {2018-04-22} Mauro-Bringolf, Structured control flow in WebAssembly by example, https://maurobringolf.ch/,

instruction.block

description::
· block resulttype instr∗ end

name::
* McsEngl.lagWasm'block-instruction,
* McsEngl.Wasm-instruction.0x02-block,
* McsEngl.Wasm-instruction.block-0x02,

example::
* link,

instruction.br

name::
* McsEngl.lagWasm'br-instruction,
* McsEngl.Wasm-instruction.br,

example::
* link,

instruction.br_if

name::
* McsEngl.lagWasm'br_if-instruction,
* McsEngl.Wasm-instruction.0x0D-br_if,
* McsEngl.Wasm-instruction.br_if-0x0D,

example::
(func (export "f") (result i32)
 (local $v1 i32)
 (set_local $v1 (i32.const 1))
 loop
   ;; v1 + 1
   (i32.add (get_local $v1) (i32.const 1))
   ;; if v1 < 10, loop
   (br_if 0 (i32.lt_u (tee_local $v1) (i32.const 10)))
 end
 get_local $v1
)

instruction.br_table

name::
* McsEngl.lagWasm'br_table-instruction,
* McsEngl.Wasm-instruction.br_table,

instruction.else

description::
· marks the else block of an-if.

name::
* McsEngl.lagWasm'else-instruction,
* McsEngl.Wasm-instruction.0x05-else,
* McsEngl.Wasm-instruction.else-0x05,

example::
(module
 (func (export "f") (param i32) (result i32)
   (if (result i32) (i32.lt_s (get_local 0) (i32.const 0))
     ;; if input < 0, then output 1
     (then (i32.const 1))
     ;; else output 2
     (else (i32.const 2))
   )
 )
)
or
(module
 (type (;0;) (func (param i32) (result i32)))
 (func (;0;) (type 0) (param i32) (result i32)
   get_local 0
   i32.const 0
   i32.lt_s
   if (result i32) ;; label = @1
     i32.const 1
   else
     i32.const 2
   end
 )
 (export "f" (func 0))
)

instruction.end

description::
· marks the end of a block, loop, if, or function.
· Blocks are composed of matched pairs of block … end instructions, loops with matched pairs of loop … end instructions, and ifs with either if … end or if … else … end sequences. For each of these constructs the instructions in the ellipsis are said to be enclosed in the construct.
[https://webassembly.org/docs/semantics/]

name::
* McsEngl.lagWasm'end-instruction,
* McsEngl.Wasm-instruction.0x0B-end,
* McsEngl.Wasm-instruction.end-0x0B,

example::
(module
 (type (;0;) (func (param i32) (result i32)))
 (func (;0;) (type 0) (param i32) (result i32)
   get_local 0
   i32.const 0
   i32.lt_s
   if (result i32) ;; label = @1
     i32.const 1
   else
     i32.const 2
   end
 )
 (export "f" (func 0))
)

instruction.if

description::
· if resulttype instr∗ else instr∗ end

name::
* McsEngl.lagWasm'if-instruction,
* McsEngl.Wasm-instruction.0x04-if,
* McsEngl.Wasm-instruction.if-0x04,

example::
(module
 (func (export "f") (param i32) (result i32)
   (if (result i32) (i32.lt_s (get_local 0) (i32.const 0))
     ;; if input < 0, then output 1
     (then (i32.const 1))
     ;; else output 2
     (else (i32.const 2))
   )
 )
)
or
(module
 (type (;0;) (func (param i32) (result i32)))
 (func (;0;) (type 0) (param i32) (result i32)
   get_local 0
   i32.const 0
   i32.lt_s
   if (result i32) ;; label = @1
     i32.const 1
   else
     i32.const 2
   end
 )
 (export "f" (func 0))
)

instruction.loop

description::
· loop resulttype instr∗ end

name::
* McsEngl.lagWasm'loop-instruction,
* McsEngl.Wasm-instruction.0x03-loop,
* McsEngl.Wasm-instruction.loop-0x03,

example::
(func (export "f") (result i32)
 (local $v1 i32)
 (set_local $v1 (i32.const 1))
 loop
   ;; v1 + 1
   (i32.add (get_local $v1) (i32.const 1))
   ;; if v1 < 10, loop
   (br_if 0 (i32.lt_u (tee_local $v1) (i32.const 10)))
 end
 get_local $v1
)
or
(func (export "f") (result i32)
 (local $v1 i32)
 (set_local $v1 (i32.const 1))
 loop &L0
   get_local $v1
   i32.const 1
   i32.add
   tee_local $v1
   i32.const 10
   i32.lt_u
   br_if $L0
 end
 get_local $v1
)

instruction.nop

description::
· the-nop-instruction does nothing.

name::
* McsEngl.lagWasm'nop-instruction,
* McsEngl.Wasm-instruction.0x01-nop,
* McsEngl.Wasm-instruction.nop-0x01,

instruction.return

description::
· return value from function.

name::
* McsEngl.lagWasm'return-instruction,
* McsEngl.Wasm-instruction.0x0F-return,
* McsEngl.Wasm-instruction.return-0x0F,

example::
(func (export "f") (param $a i32) (param $b i32) (result i32)
 ;; if (a > b) return 1, return 2
 (if (i32.gt_s (get_local $a) (get_local $b))
   (return (i32.const 1))
 )
 (return (i32.const 2))
)
or using wasm2wat
(module
 (type (;0;) (func (param i32 i32) (result i32)))
 (func (;0;) (type 0) (param i32 i32) (result i32)
   get_local 0
   get_local 1
   i32.gt_s
   if ;; label = @1
     i32.const 1
     return
   end
   i32.const 2
   return
 )
 (export "f" (func 0))
)

instruction.unreachable

description::
· the-unreachable-instruction causes an unconditional trap.

name::
* McsEngl.lagWasm'unreachable-instruction,
* McsEngl.Wasm-instruction.0x00-unreachable,
* McsEngl.Wasm-instruction.unreachable-0x00,

instruction.call

description::
· the-call-instruction calls a single function, given its index or name.

name::
* McsEngl.lagWasm'call-instruction,
* McsEngl.Wasm-instruction.0x10-call,
* McsEngl.Wasm-instruction.call-0x10,

example::
(func $f1 ...)
(func (export "f2") (result i32)
 call $f1
)

instruction.current_memory

description::
· the-current_memory instruction returns the current size of a-memory.

name::
* McsEngl.lagWasm'current_memory,
* McsEngl.Wasm-instruction.current_memory,

instruction.drop

description::
· the-drop-operator simply throws away a single operand.
[https://webassembly.github.io/spec/core/syntax/instructions.html#parametric-instructions {1-0.2018-03-22}]
===
· binary-format: 0x1A

name::
* McsEngl.lagWasm'drop-instruction,
* McsEngl.Wasm-instruction.0x1A-drop,
* McsEngl.Wasm-instruction.drop-0x1A,

instruction.get_global

name::
* McsEngl.lagWasm'get_global,
* McsEngl.Wasm-instruction.0x23-get_global,
* McsEngl.Wasm-instruction.get_global-0x23,

instruction.get_local

description::
· pushes the-value of a-variable onto the-stack,

name::
* McsEngl.lagWasm'get_local,
* McsEngl.Wasm-instruction.0x20-get_local,
* McsEngl.Wasm-instruction.get_local-0x20,

example::
(func (param $p1 i32) (param $p2 f32) (local $loc i32)
 get_local $p1 ;; pushes param1 on stack
)
===
(func (param i32) (param f32) (local i32)
 get_local 0 ;; pushes first parameter on stack
 get_local 1 ;; pushes second parameter on stack
 get_local 2 ;; pushes first local on stack
)

instruction.grow_memory

description::
· the-grow_memory-instruction grows memory by a given delta and returns the previous size, or −1 if enough memory cannot-be-allocated.
· operate in units of page size.
[https://webassembly.github.io/spec/core/syntax/instructions.html#memory-instructions {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'grow_memory,
* McsEngl.lagWasm'memory.grow,
* McsEngl.Wasm-instruction.0x40-memory.grow,
* McsEngl.Wasm-instruction.memory.grow-0x40,

instruction.i32.add

description::
· i32.add pops two i32 values from the-stack, computes their sum (modulo 2^32) and pushes the resulting i32 value.

name::
* McsEngl.lagWasm'i32.add-instruction,
* McsEngl.Wasm-instruction.0x6A-i32.add,
* McsEngl.Wasm-instruction.i32.add-0x6A,

example::
(func (export "f") (param $a i32) (result i32)
 (i32.add (get_local 0) (i32.const 10))
)
or
(func (export "f") (param $a i32) (result i32)
 get_local 0
 i32.const 10
 i32.add
)

instruction.i32.const

description::
· i32.const just defines a 32-bit integer and pushes it onto the-stack.

name::
* McsEngl.lagWasm'i32.const-instruction,
* McsEngl.Wasm-instruction.0x41-i32.const,
* McsEngl.Wasm-instruction.i32.const-0x41,

example::
// returns 10
(func (export "f") (result i32)
 (i32.const 10)
)
or
(func (export "f") (result i32)
 i32.const 10
)

instruction.i32.mul

description::
· pop two values from the-stack, multiply them, and push the-result onto the-stack.

name::
* McsEngl.lagWasm'i32.mul-instruction,
* McsEngl.Wasm-instruction.0x6C-i32.mul,
* McsEngl.Wasm-instruction.i32.mul-0x6C,

example::
//for input 6 and 5, outputs 30
(func (export "f") (param $a i32) (param $b i32) (result i32)
 (i32.mul (get_local 0) (get_local 1))
)
or
(func (export "f") (param $a i32) (param $b i32) (result i32)
 get_local 0
 get_local 1
 i32.mul
)

instruction.load

description::
· loads memory's bytes on the-stack.
===
· memory is-accessed with load and store instructions for the different value-types.
· they all take a-memory-immediate-memarg that contains an address-offset and an-alignment-hint (in base 2 logarithmic representation).
· integer loads and stores can optionally specify a storage size that is smaller than the bit width of the respective value-type.
· in the-case of loads, a-sign-extension-mode-sx-(u|s) is then required to select appropriate behavior.
· the-static-address offset is added to the-dynamic-address operand, yielding a 33-bit effective-address that is the zero-based index at which the-memory is-accessed.
· all values are read and written in little-endian-byte-order.
· a-trap results if any of the accessed memory bytes lies outside the address range implied by the memory's current size.
· note: future version of WebAssembly might-provide memory-instructions with 64-bit address ranges.
[https://webassembly.github.io/spec/core/syntax/instructions.html#memory-instructions {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'load-memory-instruction,
* McsEngl.Wasm-instruction.load-memory,

example::
//put var1 on stack
//load on stack 1 byte from memory var1 position and zero-extend i8 to i32
(i32.load8_u (get_local $v1)
or
get_local 1
i32.load8_u

specific::
* f32.load: load 4 bytes as f32,
* f64.load: load 8 bytes as f64
* i32.load8_s: load 1 byte and sign-extend i8 to i32
* i32.load8_u: load 1 byte and zero-extend i8 to i32
* i32.load16_s: load 2 bytes and sign-extend i16 to i32
* i32.load16_u: load 2 bytes and zero-extend i16 to i32
* i32.load: load 4 bytes as i32
* i64.load8_s: load 1 byte and sign-extend i8 to i64
* i64.load8_u: load 1 byte and zero-extend i8 to i64
* i64.load16_s: load 2 bytes and sign-extend i16 to i64
* i64.load16_u: load 2 bytes and zero-extend i16 to i64
* i64.load32_s: load 4 bytes and sign-extend i32 to i64
* i64.load32_u: load 4 bytes and zero-extend i32 to i64
* i64.load: load 8 bytes as i64

instruction.select

description::
· a-ternary-operator with two operands, which have the same type as each other, plus a-boolean (i32) condition.
· it returns the first operand if the-condition operand is non-zero, or the-second otherwise.
===
· the-select-operator selects one of its first two operands based on whether its third operand is zero or not.
[https://webassembly.github.io/spec/core/syntax/instructions.html#parametric-instructions {1-0.2018-03-22}]
===
· binary-format: 0x1B

name::
* McsEngl.lagWasm'select-instruction,
* McsEngl.Wasm-instruction.0x1B-select,
* McsEngl.Wasm-instruction.select-0x1B,

example::
(func (export "f") (param $a i32) (param $b i32) (result i32)
 ;; return a > b ? a : b
 (select
   (get_local $a)
   (get_local $b)
   (i32.gt_s (get_local $a) (get_local $b))
 )
)
or
(func (export "f") (param $a i32) (param $b i32) (result i32)
 get_local 0
 get_local 1
 get_local 0
 get_local 1
 i32.gt_s
 select
)

instruction.set_global

name::
* McsEngl.lagWasm'set_global,
* McsEngl.Wasm-instruction.0x24-set_global,
* McsEngl.Wasm-instruction.set_global-0x24,

instruction.set_local

description::
· set the-value of the-stack on a-local.

name::
* McsEngl.lagWasm'set_local,
* McsEngl.Wasm-instruction.0x20-set_local,
* McsEngl.Wasm-instruction.set_local-0x20,

example::
(func (export "f") (param (;0;) i32) (result i32)
 (local (;1;) i32)
 i32.const 7
 set_local 1
 get_local 1 ;;no get_local, compile-error
)

instruction.store

description::
· stores the-stack's last value on memory.

name::
* McsEngl.lagWasm'store-memory-instruction,
* McsEngl.Wasm-instruction.store-memory,

example::
// wrap stack's value to i8 (1 byte), i2 value,
// and store it in memory's i1 position
(i32.store8 (get_local $i1) (get_local $i2))
or
get_local 1
get_local 2
i32.store8

specific::
* f32.store: (no conversion) store 4 bytes
* f64.store: (no conversion) store 8 bytes
* i32.store8: wrap i32 to i8 and store 1 byte
* i32.store16: wrap i32 to i16 and store 2 bytes
* i32.store: (no conversion) store 4 bytes,
* i64.store8: wrap i64 to i8 and store 1 byte
* i64.store16: wrap i64 to i16 and store 2 bytes
* i64.store32: wrap i64 to i32 and store 4 bytes
* i64.store: (no conversion) store 8 bytes

instruction.tee_local

description::
· set the-value of the-stack on a-local AND return it.

name::
* McsEngl.lagWasm'tee_local,
* McsEngl.Wasm-instruction.0x22-tee_local,
* McsEngl.Wasm-instruction.tee_local-0x22,

example::
(func (export "f") (param (;0;) i32) (result i32)
 (local (;1;) i32)
 i32.const 7
 tee_local 1
)

memarg of memory-instruction

description::
· memarg ::= {offset u32, align u32}
[https://webassembly.github.io/spec/core/syntax/instructions.html#memory-instructions {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'memarg,
* McsEngl.Wasm-memory-instruction'memarg,

expression.BINARY

description::
· expressions are-encoded by their instruction sequence terminated with an explicit 0x0B opcode for end.
- expr ::= (in:instr)∗ 0x0B ⇒ in∗ end
[https://webassembly.github.io/spec/core/binary/instructions.html#expressions {1-0.2018-03-28}]

name::
* McsEngl.Wasm-expression.binary,

expression.TEXT

description::
· expressions are-written as instruction sequences.
· no explicit ‘end’ keyword is-included, since they only occur in bracketed positions.
- expr ::= (in:instr)∗ ⇒ in∗ end
{https://webassembly.github.io/spec/core/text/instructions.html#expressions {1-0.2018-03-28}}

name::
* McsEngl.Wasm-expression.text,

export.BINARY

description::
· the-export-section has the-id 7.
· it decodes into a-vector of exports that represent the-exports-component of a-module.
- exportsec ::= ex∗:section7 (vec(export)) ⇒ ex∗
- export ::= nm:name d:exportdesc ⇒ {name nm,desc d}
- exportdesc ::= 0x00 x:funcidx ⇒ func x
  | 0x01 x:tableidx ⇒ table x
  | 0x02 x:memidx ⇒ mem x
  | 0x03 x:globalidx ⇒ global x

name::
* McsEngl.Wasm-export.binary,

example::
02; string length
6632 ; 'f2' export name
00 ; export kind
01 ; export func index

or in text-format
(export "f2" (func 1)))

export.TEXT

description::
· the-syntax for exports mirrors their abstract-syntax directly.
- exportI ::= ‘(’ ‘export’ nm:name d:exportdescI ‘)’ ⇒ {name nm,desc d}
- exportdescI ::= ‘(’ ‘func’ x:funcidxI ‘)’ ⇒ func x
  | ‘(’ ‘table’ x:tableidxI ‘)’ ⇒ table x
  | ‘(’ ‘memory’ x:memidxI ‘)’ ⇒mem x
  | ‘(’ ‘global’ x:globalidxI ‘)’ ⇒ global x
· abbreviations: as an-abbreviation, exports may also be-specified inline with function, table, memory, or global definitions; see the respective sections.

name::
* McsEngl.Wasm-export.text,

example::
(func $fAdd … )
(export "fAdd" (func $fAdd))
or
(func (export "fAdd") ...)
===
//export global
(global (;1;) i32 (i32.const 20))
(export "CONSTA" (global 1))

import.TEXT

example::
//imports the-fImported javascript-function and name it fImp.
//wat file:
(func $fImp (import "oJs" "fImported") (param i32))
//html file:
var oImport = {oJs: {fImported: arg => console.log(arg)} };
WebAssembly.instantiateStreaming(fetch('simple.wasm'), oImport)
===
//the-above with import-sentence
//wat file:
(import "oJs" "fImported" (func $fImp (param i32)))

opcode of binary-section

description::
· the-opcode is required to either indicate a-known-section, or be 0x00, indicating a-custom-section.

name::
* McsEngl.lagWasm'opcode-of-section,
* McsEngl.Wasm-section'id,
* McsEngl.Wasm-section'opcode,

size of binary-section

description::
· each section consists of
- a one-byte section-id,
- the-u32-size of the-contents, in bytes,
- the actual contents, whose structure is depended on the section-id.
[https://webassembly.github.io/spec/core/binary/modules.html#sections {1-0.2018-03-22}]

name::
* McsEngl.Wasm-section'size,

content of binary-section

description::
· each section consists of
- a one-byte section-id,
- the-u32-size of the-contents, in bytes,
- the actual contents, whose structure is depended on the section-id.
[https://webassembly.github.io/spec/core/binary/modules.html#sections {1-0.2018-03-22}]

name::
* McsEngl.Wasm-section'content,
* McsEngl.Wasm-section'payload,

type-section.TEXT

name::
* McsEngl.lagWasm'section.type.text,
* McsEngl.lagWasm'text-type-section,
* McsEngl.lagWasm'type-section.text,
* McsEngl.Wasm-section.type.text,

example::
;;text-format
(type (;0;) (func (param i32 i32) (result i32)))
(type (;1;) (func (param i32) (result i32)))

type-section.BINARY

name::
* McsEngl.lagWasm'binary-type-section,
* McsEngl.lagWasm'section.type.binary,
* McsEngl.lagWasm'type-section.binary,
* McsEngl.Wasm-section.type.binary,

example::
; section "Type" (1)
01 ; section code
00 ; section size (guess)
02 ; num types
; type 0
60 ; func
02 ; num params
7f ; i32
7f ; i32
01 ; num results
7f ; i32
; type 1
60 ; func
01 ; num params
7f ; i32
01 ; num results
7f ; i32

import-section.TEXT

name::
* McsEngl.lagWasm'import-section.text,
* McsEngl.lagWasm'section.import.text,
* McsEngl.lagWasm'text-import-section,
* McsEngl.Wasm-section.import.text,

example::
(import "oJs" "fImport1" (func (;0;) (type 0)))
(import "oJs" "fImport2" (func (;1;) (type 0)))

import-section.BINARY

name::
* McsEngl.lagWasm'binary-import-section,
* McsEngl.lagWasm'import-section.binary,
* McsEngl.lagWasm'section.import.binary,
* McsEngl.Wasm-section.import.binary,

example::
; section "Import" (2)
02 ; section code
00 ; section size (guess)
02 ; num imports
; import header 0
03 ; string length
6f4a 73 ; oJs import module name
08 ; string length
6649 6d70 6f72 7431 ; fImport1 import field name
00 ; import kind
00 ; import signature index
; import header 1
03 ; string length
6f4a 73 ; oJs import module name
08 ; string length
6649 6d70 6f72 7432 ; fImport2 import field name
00 ; import kind
00 ; import signature index

function-section.TEXT

description::
· the-text-function-section contains AND the-body[a] of functions, which[a] in the-binary-format is-included in the-binary-code-section.

name::
* McsEngl.lagWasm'function-section.text,
* McsEngl.lagWasm'section.function.text,
* McsEngl.lagWasm'text-function-section,
* McsEngl.Wasm-section.function.text,

example::
(func $fAddTwo (param i32 i32) (result i32) get_local 0 get_local 1 i32.add)

function-section.BINARY

name::
* McsEngl.lagWasm'function-section.binary,
* McsEngl.lagWasm'section.function.binary,
* McsEngl.lagWasm'binary-function-section,
* McsEngl.Wasm-section.function.binary,

example::
; section "Function" (3)
03 ; section code
00 ; section size (guess)
01 ; num functions
00 ; function 0 type-index

table-section.TEXT

description::
· the-text-table-section includes and the-table initializations, which in the-binary-format is-included in the-element-section.

name::
* McsEngl.lagWasm'table-section.text,
* McsEngl.lagWasm'section.table.text,
* McsEngl.lagWasm'text-table-section,
* McsEngl.Wasm-section.table.text,

example::
(table (export "tbl") anyfunc (elem $f42))

table-section.BINARY

name::
* McsEngl.lagWasm'table-section.binary,
* McsEngl.lagWasm'section.table.binary,
* McsEngl.lagWasm'binary-table-section,
* McsEngl.Wasm-section.table.binary,

example::
; section "Table" (4)
0000013: 04 ; section code
0000014: 00 ; section size (guess)
0000015: 01 ; num tables
; table 0
0000016: 70 ; anyfunc
0000017: 01 ; limits: flags
0000018: 01 ; limits: initial
0000019: 01 ; limits: max
0000014: 05 ; FIXUP section size

memory-section.TEXT

name::
* McsEngl.lagWasm'memory-section.text,
* McsEngl.lagWasm'section.memory.text,
* McsEngl.lagWasm'text-memory-section,
* McsEngl.Wasm-section.memory.text,

example::
(memory 1)
or
(memory (export "mem") 1)

memory-section.BINARY

name::
* McsEngl.lagWasm'binary-memory-section,
* McsEngl.lagWasm'memory-section.binary,
* McsEngl.lagWasm'section.memory.binary,
* McsEngl.Wasm-section.memory.binary,

example::
; memory-section
05 ; section code
03 ; section size
01 ; num memories
00 ; limits: flags
01 ; limits: initial

global-section.TEXT

name::
* McsEngl.lagWasm'text-global-section,
* McsEngl.lagWasm'global-section.text,
* McsEngl.lagWasm'section.global.text,
* McsEngl.Wasm-section.global.text,

example::
(global (;0;) (mut i32) (i32.const 100))
(global (;1;) i32 (i32.const 200))

global-section.BINARY

name::
* McsEngl.lagWasm'binary-global-section,
* McsEngl.lagWasm'global-section.binary,
* McsEngl.lagWasm'section.global.binary,
* McsEngl.Wasm-section.global.binary,

example::
; section "Global" (6)
06 ; section code
00 ; section size (guess)
02 ; num globals
7f ; i32
01 ; global mutability
41 ; i32.const
e400 ; i32 literal
0b ; end
7f ; i32
00 ; global mutability
41 ; i32.const
c801 ; i32 literal
0b ; end

export-section.TEXT

name::
* McsEngl.lagWasm'text-export-section,
* McsEngl.lagWasm'export-section.text,
* McsEngl.lagWasm'section.export.text,
* McsEngl.Wasm-section.export.text,

example::
(export "f" (func 0))
(export "f2" (func 1)))

export-section.BINARY

name::
* McsEngl.lagWasm'binary-export-section,
* McsEngl.lagWasm'export-section.binary,
* McsEngl.lagWasm'section.export.binary,
* McsEngl.Wasm-section.export.binary,

example::
; section "Export" (7)
07 ; section code
00 ; section size (guess)
02 ; num exports
;; export f
01 ; string length
66 ; 'f' export name
00 ; export kind
00 ; export func index
;; export f2
02; string length
6632 ; 'f2' export name
00 ; export kind
01 ; export func index

start-function of start-section (link)

start-section.TEXT

name::
* McsEngl.lagWasm'text-start-section,
* McsEngl.lagWasm'start-section.text,
* McsEngl.lagWasm'section.start.text,
* McsEngl.Wasm-section.start.text,

example::
(start 2)

start-section.BINARY

name::
* McsEngl.lagWasm'binary-start-section,
* McsEngl.lagWasm'start-section.binary,
* McsEngl.lagWasm'section.start.binary,
* McsEngl.Wasm-section.start.binary,

example::
; section "Start" (8)
08 ; section code
00 ; section size (guess)
02 ; start func index

element-section.TEXT

description::
· in text-Wasm, the-element-section is-included in the-table-section.

name::
* McsEngl.lagWasm'text-element-section,
* McsEngl.lagWasm'element-section.text,
* McsEngl.lagWasm'section.element.text,
* McsEngl.Wasm-section.element.text,

example::
(table (export "tbl") anyfunc (elem $f42))

element-section.BINARY

name::
* McsEngl.lagWasm'binary-element-section,
* McsEngl.lagWasm'element-section.binary,
* McsEngl.lagWasm'section.element.binary,
* McsEngl.Wasm-section.element.binary,

example::
; section "Elem" (9)
0000023: 09 ; section code
0000024: 00 ; section size (guess)
0000025: 01 ; num elem segments
; elem segment header 0
0000026: 00 ; table index
0000027: 41 ; i32.const
0000028: 00 ; i32 literal
0000029: 0b ; end
000002a: 01 ; num function indices
000002b: 00 ; function index
0000024: 07 ; FIXUP section size

code-section.TEXT

description::
· in text-Wasm, the-code-section (the-bodies of functions) is-included in the-function-section.

name::
* McsEngl.lagWasm'text-code-section,
* McsEngl.lagWasm'code-section.text,
* McsEngl.lagWasm'section.code.text,
* McsEngl.Wasm-section.code.text,

code-section.BINARY

name::
* McsEngl.lagWasm'binary-code-section,
* McsEngl.lagWasm'code-section.binary,
* McsEngl.lagWasm'section.code.binary,
* McsEngl.Wasm-section.code.binary,

example::
;; (func (result i32) (i32.const 59))
; section "Code" (10)
0a ; section code
06 ; section size (guess)
01 ; num functions
; function body 0
04 ; func body size (guess)
00 ; local decl count
41 ; i32.const
3b ; i32 literal
0b ; end

data-section.TEXT

name::
* McsEngl.lagWasm'text-data-section,
* McsEngl.lagWasm'text-section.binary,
* McsEngl.lagWasm'section.text.binary,
* McsEngl.Wasm-section.text.binary,

example::
(data (i32.const 0) "Hello World")

data-section.BINARY

name::
* McsEngl.lagWasm'binary-data-section,
* McsEngl.lagWasm'data-section.binary,
* McsEngl.lagWasm'section.data.binary,
* McsEngl.Wasm-section.data.binary,

example::
; data-section
0B ; section code
11 ; section size
01 ; num data segments
00 ; memory index
41 ; i32.const
00 ; i32 value
0B ; end
0B ; data segment size
48 65 6C 6C 6F 20 57 6F 72 6C 64 ; Hello World

header of binary-module

description::
· the-header is the first part of a-module.
· the-header consists of the-magic_cookie and the-version parts.

name::
* McsEngl.lagWasm'header-of-module,
* McsEngl.Wasm-binary-module'header,

WHOLE of Wasm-program

whole-chain::
* browser-javascript-program,

production of abstract-grammar

description::
· Terminal symbols (atoms) are written in sans-serif font: i32, end.
· Nonterminal symbols are written in italic font: valtype, instr.
· Productions are written sym ::= A1 | … | An.
· Some productions are augmented with side conditions in parentheses, “(if condition)”, that provide a shorthand for a combinatorial expansion of the production into many separate cases.
[https://webassembly.github.io/spec/core/syntax/conventions.html {1-0.2018-03-28}]

name::
* McsEngl.lagWasm'production-of-abstract-syntax,
* McsEngl.Wasm-abstract-syntax'production,

sequence of abstract-grammar

description::
· Aⁿ is a sequence of n≥0 iterations of A.
· A^∗ is a possibly empty sequence of iterations of A. (This is a shorthand for Aⁿ used where n is not relevant.)
· A⁺ is a non-empty sequence of iterations of A. (This is a shorthand for Aⁿ where n≥1.)
· A^? is an optional occurrence of A. (This is a shorthand for Aⁿ where n≤1.)
· ϵ denotes the empty sequence.
· |s| denotes the length of a sequence s.
· s[i] denotes the i-th element of a sequence s, starting from 0.
· s[i:n] denotes the sub-sequence s[i] … s[i+n−1] of a sequence s.
· swith[i]=A denotes the same sequence as s, except that the i-the element is replaced with A.
· swith[i:n]=Aⁿ denotes the same sequence as s, except that the sub-sequence s[i:n] is replaced with Aⁿ.
· concat(s∗) denotes the flat sequence formed by concatenating all sequences si in s∗.
[https://webassembly.github.io/spec/core/syntax/conventions.html {1-0.2018-03-28}]

name::
* McsEngl.lagWasm'sequence-of-abstract-syntax,
* McsEngl.Wasm-abstract-syntax'sequence,

record of abstract-grammar

description::
·

name::
* McsEngl.lagWasm'record-of-abstract-syntax,
* McsEngl.Wasm-abstract-syntax'record,

vector of abstract-grammar

description::
· vectors are bounded sequences of the-form Aⁿ (or A^∗), where the-A can either be values or complex constructions.
· a-vector can-have at most 2³²−1 elements.
- vec(A) ::= Aⁿ (if n < 2³²)
[https://webassembly.github.io/spec/core/syntax/conventions.html#vectors {1-0.2018-03-28}]

name::
* McsEngl.lagWasm'vector-of-abstract-grammar,
* McsEngl.Wasm-abstract-grammar'vector,

identifier-context of text-grammar

description::
· the-text-format allows to use symbolic-identifiers in place of indices.
· to resolve these identifiers into concrete indices, some grammar production are-indexed by an-identifier-context-I as a-synthesized-attribute that records the declared identifiers in each index-space.
· in addition, the-context records the-types defined in the-module, so that parameter indices can-be-computed for functions.

· it is convenient to define identifier-contexts as records I with abstract-syntax as follows:
- I ::= {types (id^?)∗,
funcs (id^?)∗,
tables (id^?)∗,
mems (id^?)∗,
globals (id^?)∗,
locals (id^?)∗,
labels (id^?)∗,
typedefs functype∗ }

· for each index-space, such a-context contains the list of identifiers assigned to the defined indices.
· unnamed indices are-associated with empty (ϵ) entries in these lists.

· an-identifier-context is well-formed if no index-space contains duplicate identifiers.
[https://webassembly.github.io/spec/core/text/conventions.html#contexts {1-0.2018-03-28}]

name::
* McsEngl.Wasm-text-grammar'identifier-context,

compiler.to-wat

name::
* McsEngl.lagWasm'to-wat-compiler,
* McsEngl.Wasm-compiler.to-wat,

specific::
* online C-to-wat: https://wasdk.github.io/WasmFiddle/,

compiler.to-wasm

name::
* McsEngl.lagWasm'to-wasm-compiler,
* McsEngl.Wasm-compiler.to-wasm,

specific::
* online C-to-wasm: https://wasdk.github.io/WasmFiddle/,
* TypeScript-to-wasm: AssemblyScript https://github.com/AssemblyScript/assemblyscript,
* TypeScript-to-wasm: speedy.js https://github.com/MichaReiser/speedy.js,

compiler.wat-to-wasm

name::
* McsEngl.lagWasm'wat-to-wasm,
* McsEngl.Wasm-compiler.wat-to-wasm,

specific::
* wat2wasm cli-tool (WABT),
* online: https://cdn.rawgit.com/WebAssembly/wabt/aae5a4b7/demo/wat2wasm/,

compiler.wasm-to-wat

name::
* McsEngl.lagWasm'wasm-to-wat,
* McsEngl.Wasm-compiler.wasm-to-wat,

addressWpg::
* online: https://cdn.rawgit.com/WebAssembly/wabt/aae5a4b7/demo/wasm2wat/,
* wat2wasm: WABT cli tool (wat2wasm test.wat -o test.wasm),

compiler.wasm-to-machine

name::
* McsEngl.lagWasm'wasm-to-machine,
* McsEngl.Wasm-compiler.wasm-to-machine,

specific::
* Wasm-runtime-environment,

member of WebAssembly-object

member::
> Object.getOwnPropertyNames(WebAssembly).sort().join(', ')
"CompileError, Instance, LinkError, Memory, Module, RuntimeError, Table, compile, compileStreaming, instantiate, instantiateStreaming, validate"
===
//Node.js 8.11.1
"CompileError, Instance, LinkError, Memory, Module, RuntimeError, Table, compile, instantiate, validate"

WebAssembly.instantiate-function

description::
· the-WebAssembly.instantiate()-function allows you to compile and instantiate WebAssembly-code.
· this function has two overloads:
* the primary overload takes the-WebAssembly-binary-code, in the-form of a-typed-array or ArrayBuffer, and performs both compilation and instantiation in one step. The returned Promise resolves to both a compiled WebAssembly.Module and its first WebAssembly.Instance,
* the secondary overload takes an already-compiled WebAssembly.Module and returns a-Promise that resolves to an Instance of that Module. This overload is useful if the-Module has already been-compiled or retrieved from cache,
· important: this method is-not the most efficient way of fetching and instantiating wasm-modules. If at all possible, you should-use the newer WebAssembly.instantiateStreaming() method instead, which fetches, compiles, and instantiates a-module all in one step, directly from the raw bytecode, so doesn't require conversation to an-ArrayBuffer.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate]

name::
* McsEngl.lagWasm'WebAssembly.instantiate-function,
* McsEngl.WebAssembly.instantiate-function,

WebAssembly.instantiateSteaming-function

description::
· the-WebAssembly.instantiateStreaming()-function compiles and instantiates a-WebAssembly-module directly from a streamed underlying source.
· this is the most efficient, optimized way to load wasm-code.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming]

name::
* McsEngl.lagWasm'WebAssembly.instantiateSteaming-function,
* McsEngl.WebAssembly.instantiateSteaming-function,

WebAssembly.compile-function

description::
· the-WebAssembly.compile()-function compiles a-WebAssembly.Module from WebAssembly-binary-code.
· this function is useful if it is necessary to compile a-module before it can-be-instantiated (otherwise, the-WebAssembly.instantiate()-function should-be-used).
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compile]

name::
* McsEngl.lagWasm'WebAssembly.compile-function,
* McsEngl.WebAssembly.compile-function,

WebAssembly.compileStreaming-function

description::
· the-WebAssembly.compileStreaming()-function compiles a-WebAssembly.Module directly from a streamed underlying source.
· this function is useful if it is necessary to compile a-module before it can-be-instantiated (otherwise, the-WebAssembly.instantiateStreaming()-function should-be-used).
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming]

name::
* McsEngl.lagWasm'WebAssembly.compileStreaming-function,
* McsEngl.WebAssembly.compileStreaming-function,

WebAssembly.validate-function

description::
· the-WebAssembly.validate()-function validates a given typed-array of WebAssembly-binary-code, returning whether the-bytes form a valid wasm-module (true) or not (false).
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/validate]

name::
* McsEngl.lagWasm'WebAssembly.validate-function,
* McsEngl.WebAssembly.validate-function,

example::
fetch('simple.wasm')
.then(oResponse => oResponse.arrayBuffer())
.then(function(oArrayBuffer) { var bValid = WebAssembly.validate(oArrayBuffer); console.log("The given bytes are " + (bValid ? "" : "not ") + "a valid wasm module");
});
[https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/validate.html]

WebAssembly.Module-function

description::
· a-WebAssembly.Module-object contains stateless WebAssembly-code that has already been-compiled by the-browser and can-be efficiently shared with Workers, cached in IndexedDB and instantiated multiple times.
· the-WebAssembly.Module()-constructor-function can-be-called to synchronously compile given WebAssembly-binary-code.
· however, the primary way to get a-Module is through an asynchronous compilation function like WebAssembly.compile() or by reading a-Module out of IndexedDB.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module]

name::
* McsEngl.lagWasm'WebAssembly.Module-function,
* McsEngl.WebAssembly.Module-function,

member::
>Object.getOwnPropertyNames(WebAssembly.Module).sort()
(8) ["arguments", "caller", "customSections", "exports", "imports", "length", "name", "prototype"]

example Module.imports::
//display the-imports of the-simple-program
WebAssembly.compileStreaming(fetch('simple.wasm'))
.then(function(mod) {
 var aImports = WebAssembly.Module.imports(mod);
 console.log(aImports[0]);
});
demo.
[https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/imports.html]

example Module.exports::
//display the-exports of the-simple-program
WebAssembly.compileStreaming(fetch('simple.wasm'))
.then(function(mod) {
 var aExports = WebAssembly.Module.exports(mod);
 console.log(aExports[0]);
});
demo.

WebAssembly.Instance-function

description::
· a-WebAssembly.Instance-object is a stateful, executable instance of a-WebAssembly.Module.
· instance-objects contain all the Exported WebAssembly functions that allow calling into WebAssembly code from JavaScript.
· the-WebAssembly.Instance()-constructor-function can-be-called to synchronously instantiate a given WebAssembly.Module-object.
· however, the primary way to get an Instance is through the asynchronous WebAssembly.instantiateStreaming()-function.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance]

name::
* McsEngl.lagWasm'WebAssembly.Instance-function,
* McsEngl.WebAssembly.Instance-function,

WebAssembly.Memory-function

description::
· the-WebAssembly.Memory()-constructor creates a new Memory-object which is a resizable ArrayBuffer that holds the raw bytes of memory accessed by a-WebAssembly-Instance.
· a-memory created by JavaScript or in WebAssembly-code will-be accessible and mutable from both JavaScript and WebAssembly.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory]

name::
* McsEngl.lagWasm'WebAssembly.Memory-function,
* McsEngl.WebAssembly.Memory-function,

WebAssembly.Table-function

description::
· the-WebAssembly.Table()-constructor creates a new Table-object of the given size and element type.
· this is a-JavaScript wrapper object — an array-like structure representing a-WebAssembly-Table, which stores function-references.
· a-table created by JavaScript or in WebAssembly-code will-be accessible and mutable from both JavaScript and WebAssembly.
· note: tables can currently only store function-references, but this will likely be-expanded in the-future.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table]

name::
* McsEngl.lagWasm'WebAssembly.Table-function,
* McsEngl.WebAssembly.Table-function,

WebAssembly.CompileError-function

description::
· the-WebAssembly.CompileError()-constructor creates a new WebAssembly-CompileError-object, which indicates an-error during WebAssembly decoding or validation.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError]

name::
* McsEngl.lagWasm'WebAssembly.CompileError-function,
* McsEngl.WebAssembly.CompileError-function,

WebAssembly.LinkError-function

description::
· the-WebAssembly.LinkError()-constructor creates a new WebAssembly-LinkError-object, which indicates an-error during module-instantiation (besides traps from the-start-function).
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError]

name::
* McsEngl.lagWasm'WebAssembly.LinkError-function,
* McsEngl.WebAssembly.LinkError-function,

WebAssembly.RuntimeError-function

description::
· the-WebAssembly.RuntimeError()-constructor creates a new WebAssembly-RuntimeError-object — the-type that is-thrown whenever WebAssembly specifies a-trap.
[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError]

name::
* McsEngl.lagWasm'WebAssembly.RuntimeError-function,
* McsEngl.WebAssembly.RuntimeError-function,

instatiating a-Wasm-program

description::
Instantiation. A module instance is the dynamic representation of a module, complete with its own state and execution stack. Instantiation executes the module body itself, given definitions for all its imports. It initializes globals, memories and tables and invokes the module’s start function if defined. It returns the instances of the module’s exports.
[https://webassembly.github.io/spec/core/intro/overview.html#semantic-phases {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'instatiating,

invocating a-Wasm-program

description::
'Invocation. Once instantiated, further WebAssembly computations can be initiated by invoking an exported function on a module instance. Given the required arguments, that executes the respective function and returns its results.'
[https://webassembly.github.io/spec/core/intro/overview.html#semantic-phases {1-0.2018-03-22}]

name::
* McsEngl.lagWasm'invocating,