Struct Bytecode

pub struct Bytecode {
    pub elements: Vec<BytecodeElement>,
}

Represents the bytecode produced by the compiler.

Bytecode is a wrapper for a list of bytecode elements. It offers an API to extend it by other bytecode, commands or labels.

use jsyc_compiler::{Bytecode, Operation, Instruction, Operand};

let bytecode = Bytecode::new()
                 .add(Operation::new(Instruction::LoadNum,
                                   vec![Operand::Reg(10), Operand::ShortNum(10)]))
                 .add(Operation::new(Instruction::Add,
                                   vec![Operand::Reg(10), Operand::Reg(9)]));

Fields

elements: Vec<BytecodeElement>

Implementations

impl Bytecode

pub fn new() -> Self

pub fn add(self, command: Operation) -> Self

pub fn add_label(self, label: Label) -> Self

Appends a label as bytecode element.

pub fn add_bytecode(self, other: Bytecode) -> Self

Appends another bytecode onto this bytecode.

pub fn encode_base64(&self) -> String

Returns the base64-encoded bytecode as string.

pub fn last_op_is_return(&self) -> bool

Checks whether the last element is a return instruction.

pub fn commands_iter_mut(&mut self) -> impl Iterator<Item = &mut Operation>

Returns an iterator over all commands in the bytecode.

Trait Implementations

impl Clone for Bytecode

fn clone(&self) -> Bytecode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Bytecode

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

Formats the value using the given formatter.

impl Display for Bytecode

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

Formats the value using the given formatter.

impl FromIterator<Bytecode> for Bytecode

fn from_iter<I: IntoIterator<Item = Bytecode>>(iter: I) -> Self

Creates a value from an iterator.

impl PartialEq for Bytecode

fn eq(&self, other: &Bytecode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToBytes for Bytecode

fn to_bytes(&self) -> Vec<u8>

fn length_in_bytes(&self) -> usize

impl StructuralPartialEq for Bytecode