Struct Body 

pub(super) struct Body<'a, 'b, 'p, M: Module> {
    pub b: &'a mut FunctionBuilder<'b>,
    pub module: &'a mut M,
    pub shared: &'a mut Shared<'p>,
    pub context: Value,
    pub frame: Value,
    pub locals: &'a [Type],
    pub aliases: HashMap<LocalId, Alias>,
    pub returns: Option<Returns>,
    fail: Option<Block>,
    scratch: Option<StackSlot>,
    temporaries: Vec<(Value, Type)>,
}

Fields

b: &'a mut FunctionBuilder<'b>

module: &'a mut M

shared: &'a mut Shared<'p>

context: Value

frame: Value

The locals’ slots.

locals: &'a [Type]

The type of each of the frame’s locals.

aliases: HashMap<LocalId, Alias>

returns: Option<Returns>

fail: Option<Block>

scratch: Option<StackSlot>

Where calls write their results, read straight after each call.

temporaries: Vec<(Value, Type)>

Owned values held across statements, such as the list a loop walks, released if the function returns from inside.

Implementations

impl<M: Module> Body<'_, '_, '_, M>

pub(super) fn download( &mut self, download: &Download, span: Span, ) -> Result<(), CodegenError>

Asks for a download once the event finishes. The places are worked out after the address, folder and settings, as in the interpreter, so each borrowed value is held across everything worked out after it.

fn download_bindings( &mut self, places: &[(u8, Value)], ) -> Result<Value, CodegenError>

Each field’s code and place, as an array of nifty_rt::DownloadBindings on the stack, and its address.

pub(super) fn download_command( &mut self, command: DownloadCommand, id: &Expr, ) -> Result<(), CodegenError>

cancel_download(id) and the like: asks for it, done once the event finishes.

pub(super) fn format_bytes( &mut self, bytes: &Expr, ) -> Result<Value, CodegenError>

format_bytes(n): an owned string.

impl<'a, 'b, 'p, M: Module> Body<'a, 'b, 'p, M>

pub fn new( b: &'a mut FunctionBuilder<'b>, module: &'a mut M, shared: &'a mut Shared<'p>, context: Value, frame: Value, locals: &'a [Type], ) -> Self

pub fn finish(self)

Returns true from where the body ended, then emits the failure block.

pub fn succeed_here(&mut self)

Returns true here, and carries on in a new block.

fn succeed(&mut self)

fn continue_after_terminator(&mut self)

Continues in a new block, after a terminator.

pub fn call(&mut self, function: FuncId, args: &[Value]) -> Vec<Value>

pub fn call1(&mut self, function: FuncId, args: &[Value]) -> Value

pub fn call_checked(&mut self, function: FuncId, args: &[Value])

Makes a call that returns whether it succeeded, going to the failure block if not.

fn check(&mut self, ok: Value)

fn fail_block(&mut self) -> Block

fn fail_if( &mut self, condition: Value, failure: FuncId, span: Span, ) -> Result<(), CodegenError>

Fails with failure at span when condition holds.

pub fn span(&mut self, span: Span) -> Result<Value, CodegenError>

pub fn u32(&mut self, value: usize) -> Result<Value, CodegenError>

fn usize(&mut self, value: usize) -> Result<Value, CodegenError>

pub fn address(&mut self, data: DataId) -> Value

pub fn desc(&mut self, ty: &Type) -> Result<Value, CodegenError>

fn stack(&mut self, size: usize) -> Result<Value, CodegenError>

A stack slot of size bytes, aligned for slots, and its address.

fn scratch(&mut self) -> Value

The address of the slot calls write their results to.

fn array(&mut self, values: &[Value]) -> Result<Value, CodegenError>

values, stored in order in a stack array, and its address.

fn load(&mut self, address: Value) -> Value

pub fn own( &mut self, operand: Operand, ty: &Type, ) -> Result<Value, CodegenError>

operand, owned: retained if it was borrowed.

pub fn discard( &mut self, operand: Operand, ty: &Type, ) -> Result<(), CodegenError>

Lets go of operand: released if it was owned.

pub fn release(&mut self, value: Value, ty: &Type) -> Result<(), CodegenError>

pub fn store( &mut self, place: Value, value: Value, ty: &Type, ) -> Result<(), CodegenError>

Writes an owned value of type ty to the slot at place, releasing what was there.

pub fn slot(&mut self, local: usize) -> Result<Value, CodegenError>

pub fn release_locals(&mut self) -> Result<(), CodegenError>

Releases every local of the frame, as a function does before it returns.

pub fn path(&mut self, place: &Place) -> Result<Alias, CodegenError>

Where place is: its root, then its steps, with its list positions worked out now.

fn index(&mut self, index: Index) -> Result<Value, CodegenError>

pub fn pointer( &mut self, path: &Alias, span: Span, ) -> Result<Value, CodegenError>

The slot path leads to, made its only owner’s at each step so it can be changed. Writing through it marks a state root changed.

pub fn read(&mut self, path: &Alias, span: Span) -> Result<Value, CodegenError>

The value path leads to, borrowed.

pub fn list_item( &mut self, list: Value, index: Value, span: Span, ) -> Result<Value, CodegenError>

The item at index of the borrowed list, borrowed from it.

pub fn block(&mut self, stmts: &Stmts) -> Result<(), CodegenError>

fn stmt(&mut self, stmt: &Stmt) -> Result<(), CodegenError>

fn assign( &mut self, place: &Place, op: Option<BinaryOp>, value: &Expr, ) -> Result<(), CodegenError>

The value is worked out before the place, as in the interpreter.

fn if_stmt( &mut self, branches: &[(Expr, Stmts)], otherwise: Option<&Stmts>, ) -> Result<(), CodegenError>

fn for_value( &mut self, head: &Loop, list: &Expr, body: &Stmts, ) -> Result<(), CodegenError>

Walks a copy of the list, putting each item in the loop’s item.

fn for_place( &mut self, head: &Loop, place: &Place, body: &Stmts, ) -> Result<(), CodegenError>

Walks the list at place, with the loop’s item standing for each of its items in turn. The length is read each time round, so the body may change the list.

fn for_range( &mut self, local: LocalId, start: &Expr, end: &Expr, body: &Stmts, ) -> Result<(), CodegenError>

Counts local from start up to, but not including, end.

fn set_index( &mut self, index: Option<LocalId>, position: Value, ) -> Result<(), CodegenError>

Puts a round’s position in the loop’s index, when the loop names one.

pub fn count_up( &mut self, len: Value, step: impl FnMut(&mut Self, Value) -> Result<(), CodegenError>, ) -> Result<(), CodegenError>

Runs step with each index from 0 up to len.

pub fn count( &mut self, start: Value, end: Value, step: impl FnMut(&mut Self, Value) -> Result<(), CodegenError>, ) -> Result<(), CodegenError>

Runs step with each count from start up to, but not including, end.

fn count_with( &mut self, counter: Variable, start: Value, end: impl FnMut(&mut Self) -> Result<Value, CodegenError>, step: impl FnMut(&mut Self, Value) -> Result<(), CodegenError>, ) -> Result<(), CodegenError>

Runs step with each value of counter from start while it is below what end gives; end is worked out again each time round.

fn return_stmt(&mut self, value: Option<&Expr>) -> Result<(), CodegenError>

fn int(&mut self, expr: &Expr) -> Result<Value, CodegenError>

An int (or bool) expression’s value.

pub fn expr(&mut self, expr: &Expr) -> Result<Operand, CodegenError>

fn nothing(&mut self) -> Operand

What an expression of type void gives.

fn aggregate( &mut self, parts: &[Expr], ty: &Type, ) -> Result<Value, CodegenError>

A list or struct of type ty holding parts, worked out in order.

fn push(&mut self, place: &Place, value: &Expr) -> Result<(), CodegenError>

The value is worked out before the place, as in the interpreter.

fn remove( &mut self, place: &Place, index: &Expr, span: Span, ) -> Result<(), CodegenError>

fn owned_all(&mut self, exprs: &[Expr]) -> Result<Vec<Value>, CodegenError>

Each expression’s value, owned, in order.

fn hold( &mut self, operand: Operand, ty: &Type, next: &Expr, ) -> Result<Operand, CodegenError>

operand, kept while next is worked out: owned unless next can’t change state.

fn hold_across<'e>( &mut self, operand: Operand, ty: &Type, later: impl IntoIterator<Item = &'e Expr>, ) -> Result<Operand, CodegenError>

operand, kept while each of later is worked out: owned unless none of them can change state.

fn part_of( &mut self, container: Operand, container_ty: &Type, part: Value, part_ty: &Type, ) -> Result<Operand, CodegenError>

A part borrowed from container: still borrowed if the container was, and otherwise owned, since the container is released.

fn string(&mut self, text: &str) -> Result<Value, CodegenError>

fn interpolate(&mut self, segments: &[Segment]) -> Result<Value, CodegenError>

fn len(&mut self, value: &Expr) -> Result<Value, CodegenError>

fn float(&mut self, bits: Value) -> Value

fn bits(&mut self, float: Value) -> Value

fn binary( &mut self, op: BinaryOp, lhs: &Expr, rhs: &Expr, span: Span, ) -> Result<Operand, CodegenError>

fn short_circuit( &mut self, op: BinaryOp, lhs: &Expr, rhs: &Expr, ) -> Result<Operand, CodegenError>

pub fn apply( &mut self, op: BinaryOp, ty: &Type, left: Operand, right: Operand, span: Span, ) -> Result<Operand, CodegenError>

Applies op to operands of type ty, releasing whichever are owned.

fn int_op( &mut self, op: BinaryOp, a: Value, b: Value, span: Span, ) -> Result<Value, CodegenError>

fn float_op( &mut self, op: BinaryOp, a: Value, b: Value, ) -> Result<Value, CodegenError>

fn call_fn( &mut self, function: usize, args: &[Expr], ty: &Type, span: Span, ) -> Result<Operand, CodegenError>

Calls Nifty function function. Its arguments are worked out before the call depth is checked, as in the interpreter.

fn dialog(&mut self, dialog: &Dialog, span: Span) -> Result<(), CodegenError>

pick_file($path, …) and the other file dialogs: asks for one, shown once the event finishes, whose answer goes to the bound state.

fn window_request( &mut self, action: WindowAction, window: WindowId, ) -> Result<(), CodegenError>

open_window(…) or close_window(…): asks for it, done once the event finishes.

fn fail_now(&mut self, fail: FuncId, span: Span) -> Result<(), CodegenError>

Calls the runtime’s fail(context, span) and leaves through the failure block.

fn place_desc(&mut self, path: &Alias) -> Result<Option<Value>, CodegenError>

path as a nifty_rt::PlaceDesc on the stack, or None if it isn’t in state.