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,
    output_options: Option<OutputOptions>
) -> 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>

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<()>

Runs the flattening pass.

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

Runs the compiler stages.

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

Returns a compiled Leo program and prints the resulting bytecode.

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

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.