Struct hlbc::Bytecode

pub struct Bytecode {

    pub version: u8,
    pub entrypoint: RefFun,
    pub ints: Vec<i32>,
    pub floats: Vec<f64>,
    pub strings: Vec<Str>,
    pub bytes: Option<(Vec<u8>, Vec<usize>)>,
    pub debug_files: Option<Vec<Str>>,
    pub types: Vec<Type>,
    pub globals: Vec<RefType>,
    pub natives: Vec<Native>,
    pub functions: Vec<Function>,
    pub constants: Option<Vec<ConstantDef>>,
    pub globals_initializers: HashMap<RefGlobal, usize>,
    /* private fields */
}

Bytecode structure containing all the information. Every field is public for flexibility, but you aren’t encouraged to modify them.

This type is like an arena, you usually work with custom

Fields

version: u8

Bytecode format version

entrypoint: RefFun

Program entrypoint

ints: Vec<i32>

i32 constant pool

floats: Vec<f64>

f64 constant pool

strings: Vec<Str>

String constant pool

bytes: Option<(Vec<u8>, Vec<usize>)>

Bytes constant pool

Since bytecode v5

debug_files: Option<Vec<Str>>

Debug file names constant pool

types: Vec<Type>

Types, contains every possible types expressed in the program

globals: Vec<RefType>

Globals, holding static variables and such

natives: Vec<Native>

Native functions references

functions: Vec<Function>

Code functions pool

constants: Option<Vec<ConstantDef>>

Constants, initializers for globals

Since bytecode v4

globals_initializers: HashMap<RefGlobal, usize>

Implementations

impl Bytecode

pub fn ops(&self) -> impl Iterator<Item = (&Function, (usize, &Opcode))>

Iterate on every instruction of every function

impl Bytecode

pub fn deserialize(r: &mut impl Read) -> Result<Bytecode>

Load the bytecode from any source. Must be a valid hashlink bytecode binary.

pub fn from_file(path: impl AsRef<Path>) -> Result<Self>

impl Bytecode

pub fn serialize(&self, w: &mut impl Write) -> Result<()>

Serialize the bytecode to any sink. Bytecode is serialized to the same format.

impl Bytecode

pub fn entrypoint(&self) -> &Function

Get the entrypoint function.

pub fn main(&self) -> &Function

Get the main function. This will panic if there is no main function in the bytecode (there should always be one)

pub fn function_by_name(&self, name: &str) -> Option<&Function>

Get a function by its name.

pub fn findex_max(&self) -> usize

pub fn functions<'a>(&'a self) -> impl Iterator<Item = FunPtr<'a>> + 'a

Trait Implementations

impl Debug for Bytecode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Bytecode

fn default() -> Self

Returns the “default value” for a type.

impl Index<RefFloat> for Bytecode

type Output = f64

The returned type after indexing.

fn index(&self, index: RefFloat) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RefInt> for Bytecode

type Output = i32

The returned type after indexing.

fn index(&self, index: RefInt) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RefString> for Bytecode

type Output = FlexStr<flexstr::::FlexStrBase::{constant#0}, flexstr::::FlexStrBase::{constant#1}, flexstr::::FlexStrBase::{constant#2}, Arc<str>>

The returned type after indexing.

fn index(&self, index: RefString) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RefType> for Bytecode

type Output = Type

The returned type after indexing.

fn index(&self, index: RefType) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Resolve<RefFloat> for Bytecode

type Output<'a> = f64

fn get(&self, index: RefFloat) -> Self::Output<'_>

impl Resolve<RefFun> for Bytecode

type Output<'a> = FunPtr<'a>

fn get(&self, index: RefFun) -> Self::Output<'_>

impl Resolve<RefInt> for Bytecode

type Output<'a> = i32

fn get(&self, index: RefInt) -> Self::Output<'_>

impl Resolve<RefString> for Bytecode

type Output<'a> = FlexStr<flexstr::::FlexStrBase::{constant#0}, flexstr::::FlexStrBase::{constant#1}, flexstr::::FlexStrBase::{constant#2}, Arc<str>>

fn get(&self, index: RefString) -> Self::Output<'_>

impl Resolve<RefType> for Bytecode

type Output<'a> = &'a Type

fn get(&self, index: RefType) -> Self::Output<'_>