Struct BytecodeFunction 

pub struct BytecodeFunction<'table> {

    pub max_stack_size: u8,
    pub num_params: u8,
    pub upvalue_count: u8,
    pub is_vararg: bool,
    pub flags: u8,
    pub type_info: Vec<u8>,
    pub upvalue_types: Vec<u8>,
    pub local_types: Vec<BytecodeTypedLocal>,
    pub blocks: Vec<BytecodeBlock>,
    pub instructions: Vec<BytecodeInstruction>,
    pub constants: Vec<BytecodeFunctionConstant<'table>>,
    pub immediates: Vec<BytecodeImmediate>,
    pub phis: Vec<BytecodePhi>,
    pub projections: Vec<BytecodeProjection>,
    pub registers: HashMap<BytecodeOperand, Register>,
    pub table_shapes: Vec<TableShape>,
    pub class_shapes: Vec<BytecodeClass>,
    pub entry_block: BytecodeBlockId,
    pub exit_block: BytecodeBlockId,
    pub pc_to_block: Vec<BytecodeBlockId>,
    pub pc_to_instruction: Vec<BytecodeInstructionId>,
    pub protos: Vec<u32>,
    pub line_defined: u32,
    pub debug_name: &'table [u8],
    pub lines: Vec<u32>,
    pub locals: Vec<BytecodeDebugLocal<'table>>,
    pub upvalue_names: Vec<&'table [u8]>,
}

Fields

max_stack_size: u8

num_params: u8

upvalue_count: u8

is_vararg: bool

flags: u8

type_info: Vec<u8>

upvalue_types: Vec<u8>

local_types: Vec<BytecodeTypedLocal>

blocks: Vec<BytecodeBlock>

instructions: Vec<BytecodeInstruction>

constants: Vec<BytecodeFunctionConstant<'table>>

immediates: Vec<BytecodeImmediate>

phis: Vec<BytecodePhi>

projections: Vec<BytecodeProjection>

registers: HashMap<BytecodeOperand, Register>

table_shapes: Vec<TableShape>

class_shapes: Vec<BytecodeClass>

entry_block: BytecodeBlockId

exit_block: BytecodeBlockId

pc_to_block: Vec<BytecodeBlockId>

pc_to_instruction: Vec<BytecodeInstructionId>

protos: Vec<u32>

line_defined: u32

debug_name: &'table [u8]

lines: Vec<u32>

locals: Vec<BytecodeDebugLocal<'table>>

upvalue_names: Vec<&'table [u8]>

Implementations

impl<'table> BytecodeFunction<'table>

pub fn from_function_bytecode<'strings>( data: &[u8], strings: &'table BytecodeStringTable<'strings>, ) -> Result<Self, BytecodeReadError>

pub fn to_function_bytecode(&mut self) -> Result<Vec<u8>, BytecodeWriteError>

Convenience wrapper for Luau’s single-argument toFunctionBytecode(fn) overload.

Use BytecodeBuilder::to_function_bytecode(&mut function) when a caller already owns a builder, matching Luau’s toFunctionBytecode(bcb, fn) overload.

pub fn entry(&self) -> BytecodeBlockId

pub fn exit(&self) -> BytecodeBlockId

pub fn blocks(&self) -> &[BytecodeBlock]

pub fn block(&self, id: BytecodeBlockId) -> &BytecodeBlock

pub fn graph_instruction( &self, id: BytecodeInstructionId, ) -> &BytecodeInstruction

pub fn block_for_pc(&self, pc: InstructionPc) -> Option<BytecodeBlockId>

pub fn instruction_for_pc( &self, pc: InstructionPc, ) -> Option<BytecodeInstructionId>

pub fn immediate(&self, id: BytecodeImmediateId) -> &BytecodeImmediate

pub fn phi(&self, id: BytecodePhiId) -> &BytecodePhi

pub fn projection(&self, id: BytecodeProjectionId) -> &BytecodeProjection

Trait Implementations

impl<'table> Clone for BytecodeFunction<'table>

fn clone(&self) -> BytecodeFunction<'table>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'table> Debug for BytecodeFunction<'table>

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

Formats the value using the given formatter.

impl<'table> PartialEq for BytecodeFunction<'table>

fn eq(&self, other: &BytecodeFunction<'table>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'table> StructuralPartialEq for BytecodeFunction<'table>