Struct leo_compiler::Compiler

pub struct Compiler<'a> {
    pub program_name: String,
    pub network: String,
    pub ast: Ast,
    pub input_ast: Option<InputAst>,
    /* private fields */
}

The primary entry point of the Leo compiler.

Fields

program_name: String

The program name,

network: String

The network name,

ast: Ast

The AST for the program.

input_ast: Option<InputAst>

The input ast for the program if it exists.

Implementations

impl<'a> Compiler<'a>

pub fn new( program_name: String, network: String, handler: &'a Handler, main_file_path: PathBuf, output_directory: PathBuf, compiler_options: Option<CompilerOptions> ) -> Self

Returns a new Leo compiler.

pub fn checksum(&self) -> Result<String>

Returns a SHA256 checksum of the program file.

pub fn parse_program_from_string( &mut self, program_string: &str, name: FileName ) -> Result<()>

Parses and stores a program file content from a string, constructs a syntax tree, and generates a program.

pub fn parse_program(&mut self) -> Result<()>

Parses and stores the main program file, constructs a syntax tree, and generates a program.

pub fn parse_input(&mut self, input_file_path: PathBuf) -> Result<()>

Parses and stores the input file, constructs a syntax tree, and generates a program input.

pub fn symbol_table_pass(&self) -> Result<SymbolTable>

Runs the symbol table pass.

pub fn type_checker_pass( &'a self, symbol_table: SymbolTable ) -> Result<(SymbolTable, StructGraph, CallGraph)>

Runs the type checker pass.

pub fn loop_unrolling_pass( &mut self, symbol_table: SymbolTable ) -> Result<SymbolTable>

Runs the loop unrolling pass.

pub fn static_single_assignment_pass( &mut self, symbol_table: &SymbolTable ) -> Result<Assigner>

Runs the static single assignment pass.

pub fn flattening_pass( &mut self, symbol_table: &SymbolTable, assigner: Assigner ) -> Result<Assigner>

Runs the flattening pass.

pub fn function_inlining_pass( &mut self, call_graph: &CallGraph, assigner: Assigner ) -> Result<Assigner>

Runs the function inlining pass.

pub fn dead_code_elimination_pass(&mut self) -> Result<()>

Runs the dead code elimination pass.

pub fn code_generation_pass( &mut self, symbol_table: &SymbolTable, struct_graph: &StructGraph, call_graph: &CallGraph ) -> Result<String>

Runs the code generation pass.

pub fn compiler_stages( &mut self ) -> Result<(SymbolTable, StructGraph, CallGraph)>

Runs the compiler stages.

pub fn compile(&mut self) -> Result<(SymbolTable, String)>

Returns a compiled Leo program.

Trait Implementations

impl<'a> Clone for Compiler<'a>

fn clone(&self) -> Compiler<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.