Adds a line to the miden program output, properly indented

Function to display transpile Yul code and display each step of the transpilation process in the terminal. This function is only used to demonstrate w

Add a comment in to the Miden assembly. Comments are generated throughout transpilation.

Consume n stack values from the top of our stack. This doesn't affect miden's stack.

Function to indent the Miden assembly by four spaces. Ex. if.true push.0

Function to decrease the indent in the Miden assembly by four spaces Ex. if.true push.0 drop

Function to push a u32 value on both the miden stack and our stack

Function to transpile expressions into Miden instructions See the transpilation function for each expression for more detail on each case

Add an unkown value onto our stack, for example if we evaluate `add(1,2)`, we know there's a new value on the stack but it isn't assigned to a variabl

Parses a block into an Expr

Add a new empty line into the Miden assembly

Transpile a block. Loops through an ExprBlock which is a Vec of expressions and transpiles each expression.

Function to parse grammar within an expression rule

Adds a line to execute the given proc, also marks it as used so we can insert the relevant proc later

Walks through each expression in the abstract syntax tree, optimizing the AST where possible. A new, optimized AST is returned Which is then passed in

Function to tell the transpiler to begin a branch during when entering a conditional statement

not pushing but duping to the top, offset is just where the value starts and depending on the type it may have to dup 8 elements

Function to tell the transpiler to end a branch when exiting a conditional statement, updating the state of the stack and variables.

Compiles and executes a compiled Miden program, returning the stack and any Miden errors. The program is passed in as a String, passed to the Miden As

Function to

Returns the stack width that the uint occupies in the Miden VM Miden stack elements can occupy 32bits, a u32 number will occupy one element, where a u

To see examples for each Expr, check out types.rs

Function to check the stack size and determine whether or not the push will overflow into inaccesible stack slots (17+). If it would push values past

Sets the value at the top of the stack to a typed_identifier. For example, when a value gets pushed to the stack, it is unknown. Then once top_is_var(

Fetches an identifier from either memory or the stack, and moves it to the top. Will dup from the stack if dup is true, otherwise will move up

Parses a literal into an Expr Literals can be a number literal, string literal, true/false literal or a hex literal. Literals can also have an optiona

Parses a Yul statement. This function matches a grammar rule and return an Expr struct which is later added into the Abstract Syntax Tree

Parses a typed identifier list for function definitions or variable declarations. This is later used to determine what type of operation to use for sp

Function to remove the top stack value from the stack and save it into memory. If the variable is already stored in memory, the transpiler will update

Transpile a Miden program from a Vec of expressions and return the compiled Miden program as a string

Return the size of the stack, accounting for u256 values taking up 8 values.

Get the data type for a specific variable

Converts the top 8 elements on the top of the stack to a U256 struct This is used during testing to assert that the Miden output is the correct U256 v

Push a value from memory to the top of the stack. If the element is a u32, it takes up one 32bit element of one memory address. When the element is a

Function to return the state of the stack before branching. For more details on a branch, see the Branch struct.

Transpile an assignment Ex. x = 1000 or x = 1000:u256 Note that ExprAssignment has parameters of pub identifiers: Vec<String>, (ie. variable names) pu

Transpile a literal If the value is u32, a single push will occur If the value is u256, 8 elements will be pushed onto the stack. See push_u256 for mo

Modifies the stack to include values from developer written functions in Yul For example, if someone were to write a function called return_two_number

Add the Expr to the abstract syntax tree. Each Expr is added as a tree "leaf".

Adds all procedures defined in the u256.masm file as utility functions that can be called in the transpiled Miden program Ex. u256add_unsafe, u256sub_

Generally we keep all stack values accessible (aka, only use the first 16 slots). This will temporarily disable that protection, for cases where we kn

Function to output Miden assembly to convert a u256 struct, into eight 32bit segments and push them onto the stack

Drops the stack after the nth element. For example if the stack is [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] drop_after(10) will result [

TODO: explain the function and then explain what an offset is

Add a Vec of Expr to an abstract syntax tree and return the tree as a string

Function to load a variable's value from memory and push it to the top of the stack See push_from_memory_to_top_of_stack for more details on how diffe

Returns the amount of addresses in memory the number occupies. Memory addresses in Miden are four words (one word is 32bits). A u32 number will take u

Parses a case statement into an Expr

Parses an identifier into an Expr, which gets transpiled into a variable reference. These variables need to be kept track of during transpilation in c

Parses an identifier list for function definitions or variable declarations. TODO: explain how this gets handled in transpilation, variables stored in

Function to remove the bottom variable from the stack and move it to memory. Under the hood, this function moves the bottom value to the top of the st

Push a u256 value to the stack. See convert_u256_to_pushes for more details on how u256 segments are pushed.

Read in all of the Yul contracts from the contracts directory and return a Vec of Yul Files

Re-enable our overflow protection (saving values that go below the 16 accesible slots, to memory)

TODO: update placeholder

Transpile a case expression Note that ExprCase has two parameters pub literal: ExprLiteral, (this is the case statement) pub block: ExprBlock, (this i

TODO: update placeholder

Transpile a for loop. A for loop is made up of an init block, a conditional, an after block and an interior block. Under the hood, while.true evaluate

Transpiles a function declaration First, the transpiler gets the stack values that the function will push onto the Miden stack and the function parame

Transpile an if statement Branches are created to preserve the state of the stack before and after the if statement. See the Branch struct for more de

TODO: update placeholder

Transpiles a procedure in miden. For example, if a function call is passed in as an expression, the first parameter type is u256 and the function name

Transpiles a repeat expression

Transpiles a switch statement Note that ExprSwitch has four parts pub default_case: Option<ExprBlock>, pub inferred_type: Option<YulType>, pub expr: B

Transpile a variable declaration. Ex. let x := 1000 or let x:u256 := 1000

FIXME: Still needs comments see push identifier to top

Function to update the value of a variable stored in memory. First, the value of the variable is pushed to the top of the stack where it is then saved

TODO: it would be nice if there wasn't so much cloning in here

Print TypedIdentifier

Convert a Vec of YulType to a string

Converts a string representation of u32 or u256 to a YulType

Checks for variables that are only assigned once and returns a hashmap of the variables to convert into constants.

Convert YulType to string