gwr - v0.1.0

gwr/parser

Values

do_parse_instructions_until

</> 
pub fn do_parse_instructions_until(
  reader: byte_reader.ByteReader,
  predicate: fn(spec.Instruction) -> Bool,
  accumulator: List(spec.Instruction),
) -> Result(
  #(byte_reader.ByteReader, List(spec.Instruction)),
  parsing_error.ParsingError,
)

function_index_id

</> 
pub const function_index_id: Int

parser/module_parser

global_index_id

</> 
pub const global_index_id: Int

is_value_type

</> 
pub fn is_value_type(data: BitArray) -> Bool

memory_index_id

</> 
pub const memory_index_id: Int

parse_binary_module

</> 
pub fn parse_binary_module(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.Binary),
  parsing_error.ParsingError,
)

parse_block_type

</> 
pub fn parse_block_type(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.BlockType),
  parsing_error.ParsingError,
)

parse_code

</> 
pub fn parse_code(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.Code),
  parsing_error.ParsingError,
)

parse_export

</> 
pub fn parse_export(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.Export),
  parsing_error.ParsingError,
)

parse_expression

</> 
pub fn parse_expression(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, List(spec.Instruction)),
  parsing_error.ParsingError,
)

parse_function_code

</> 
pub fn parse_function_code(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.FunctionCode),
  parsing_error.ParsingError,
)

parse_function_type

</> 
pub fn parse_function_type(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.FunctionType),
  parsing_error.ParsingError,
)

Decodes a bit array into a FunctionType. The FunctionType bit array begins with 0x60 byte id and follows with 2 vectors, each containing an arbitrary amount of 1-byte ValueType(s). The first vector represents the list of parameter types of the function, while the second vector represents the list of result types returned by the function.

parse_global

</> 
pub fn parse_global(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.Global),
  parsing_error.ParsingError,
)

parse_global_type

</> 
pub fn parse_global_type(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.GlobalType),
  parsing_error.ParsingError,
)

parse_instruction

</> 
pub fn parse_instruction(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.Instruction),
  parsing_error.ParsingError,
)

parser/instruction_parser

parse_instructions_until

</> 
pub fn parse_instructions_until(
  from reader: byte_reader.ByteReader,
  with predicate: fn(spec.Instruction) -> Bool,
) -> Result(
  #(byte_reader.ByteReader, List(spec.Instruction)),
  parsing_error.ParsingError,
)

parse_le32_float

</> 
pub fn parse_le32_float(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, ieee_float.IEEEFloat),
  parsing_error.ParsingError,
)

parse_le64_float

</> 
pub fn parse_le64_float(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, ieee_float.IEEEFloat),
  parsing_error.ParsingError,
)

parse_limits

</> 
pub fn parse_limits(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.Limits),
  parsing_error.ParsingError,
)

parse_locals_declaration

</> 
pub fn parse_locals_declaration(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.LocalsDeclaration),
  parsing_error.ParsingError,
)

parser/binary_parser

parse_memory

</> 
pub fn parse_memory(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.Memory),
  parsing_error.ParsingError,
)

parse_name

</> 
pub fn parse_name(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, String),
  parsing_error.ParsingError,
)

parse_section

</> 
pub fn parse_section(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.Section),
  parsing_error.ParsingError,
)

parse_signed_leb128_integer

</> 
pub fn parse_signed_leb128_integer(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, Int),
  parsing_error.ParsingError,
)

parse_uninterpreted_leb128_integer

</> 
pub fn parse_uninterpreted_leb128_integer(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, Int),
  parsing_error.ParsingError,
)

parse_unsigned_leb128_integer

</> 
pub fn parse_unsigned_leb128_integer(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, Int),
  parsing_error.ParsingError,
)

parser/value_parser

parse_value_type

</> 
pub fn parse_value_type(
  from reader: byte_reader.ByteReader,
) -> Result(
  #(byte_reader.ByteReader, spec.ValueType),
  parsing_error.ParsingError,
)

parser/types_parser

parse_vector

</> 
pub fn parse_vector(
  from reader: byte_reader.ByteReader,
  with parse_element: fn(byte_reader.ByteReader) -> Result(
    #(byte_reader.ByteReader, a),
    parsing_error.ParsingError,
  ),
) -> Result(
  #(byte_reader.ByteReader, List(a)),
  parsing_error.ParsingError,
)

parser/convention_parser

table_index_id

</> 
pub const table_index_id: Int
✨ Search Document