Struct Parser

struct Parser<'a> {
    lexer: Lexer<'a>,
    token: SpannedToken,
    max_witness_index: u32,
}

Fields

lexer: Lexer<'a>

token: SpannedToken

max_witness_index: u32

Implementations

impl<'a> Parser<'a>

fn new(source: &'a str) -> Result<Self, ParserError>

fn parse_program(&mut self) -> Result<Program<FieldElement>, ParserError>

Parse multiple Circuit blocks and return a Program.

pub(crate) fn parse_circuit( &mut self, ) -> Result<Circuit<FieldElement>, ParserError>

fn parse_private_parameters(&mut self) -> Result<BTreeSet<Witness>, ParserError>

fn parse_public_parameters(&mut self) -> Result<BTreeSet<Witness>, ParserError>

fn parse_return_values(&mut self) -> Result<BTreeSet<Witness>, ParserError>

fn parse_witness_vector(&mut self) -> Result<Vec<Witness>, ParserError>

fn parse_witness_ordered_set( &mut self, ) -> Result<BTreeSet<Witness>, ParserError>

fn parse_opcodes(&mut self) -> Result<Vec<Opcode<FieldElement>>, ParserError>

fn parse_assert_zero_expression( &mut self, ) -> Result<Expression<FieldElement>, ParserError>

fn parse_terms_or_error(&mut self) -> Result<Vec<Term>, ParserError>

fn parse_term_or_error(&mut self) -> Result<Term, ParserError>

fn parse_linear_or_multiplication_term( &mut self, coefficient: FieldElement, w1: Witness, ) -> Result<Term, ParserError>

fn parse_arithmetic_expression( &mut self, ) -> Result<Expression<FieldElement>, ParserError>

fn parse_blackbox_func_call( &mut self, ) -> Result<BlackBoxFuncCall<FieldElement>, ParserError>

fn parse_blackbox_inputs_array<const N: usize>( &mut self, keyword: Keyword, ) -> Result<Box<[FunctionInput<FieldElement>; N]>, ParserError>

fn parse_blackbox_inputs( &mut self, keyword: Keyword, ) -> Result<Vec<FunctionInput<FieldElement>>, ParserError>

fn parse_blackbox_input( &mut self, keyword: Keyword, ) -> Result<FunctionInput<FieldElement>, ParserError>

fn parse_blackbox_input_no_keyword( &mut self, ) -> Result<FunctionInput<FieldElement>, ParserError>

fn parse_blackbox_output(&mut self) -> Result<Witness, ParserError>

fn parse_blackbox_outputs_array<const N: usize>( &mut self, ) -> Result<Box<[Witness; N]>, ParserError>

fn parse_blackbox_outputs(&mut self) -> Result<Vec<Witness>, ParserError>

fn parse_blackbox_u32(&mut self, keyword: Keyword) -> Result<u32, ParserError>

fn parse_memory_init(&mut self) -> Result<Opcode<FieldElement>, ParserError>

fn parse_block_type(&mut self) -> Result<BlockType, ParserError>

fn parse_memory_read(&mut self) -> Result<Opcode<FieldElement>, ParserError>

fn parse_memory_write(&mut self) -> Result<Opcode<FieldElement>, ParserError>

fn parse_brillig_call(&mut self) -> Result<Opcode<FieldElement>, ParserError>

fn parse_brillig_inputs( &mut self, ) -> Result<Vec<BrilligInputs<FieldElement>>, ParserError>

fn parse_brillig_input( &mut self, ) -> Result<BrilligInputs<FieldElement>, ParserError>

fn parse_brillig_outputs(&mut self) -> Result<Vec<BrilligOutputs>, ParserError>

fn parse_brillig_output(&mut self) -> Result<BrilligOutputs, ParserError>

fn parse_call(&mut self) -> Result<Opcode<FieldElement>, ParserError>

fn eat_predicate( &mut self, ) -> Result<Option<Expression<FieldElement>>, ParserError>

fn parse_bracketed_list<T, F>( &mut self, parser: F, ) -> Result<Vec<T>, ParserError>

where F: Fn(&mut Parser<'a>) -> Result<T, ParserError>,

fn eat_ident_or_error(&mut self) -> Result<String, ParserError>

fn eat_ident(&mut self) -> Result<Option<String>, ParserError>

fn eat_field_element(&mut self) -> Result<Option<FieldElement>, ParserError>

fn eat_field_or_error(&mut self) -> Result<FieldElement, ParserError>

fn eat_u32_or_error(&mut self) -> Result<u32, ParserError>

fn bump(&mut self) -> Result<SpannedToken, ParserError>

fn read_token_internal(&mut self) -> Result<SpannedToken, ParserError>

fn eat_keyword(&mut self, keyword: Keyword) -> Result<bool, ParserError>

fn eat_keyword_or_error(&mut self, keyword: Keyword) -> Result<(), ParserError>

fn peek_keyword(&self) -> Option<Keyword>

fn eat_witness(&mut self) -> Result<Option<Witness>, ParserError>

fn eat_witness_or_error(&mut self) -> Result<Witness, ParserError>

fn eat_block_id(&mut self) -> Result<Option<BlockId>, ParserError>

fn eat_block_id_or_error(&mut self) -> Result<BlockId, ParserError>

fn eat_comma_or_error(&mut self) -> Result<(), ParserError>

fn eat_or_error(&mut self, token: Token) -> Result<(), ParserError>

fn at(&mut self, token: Token) -> bool

fn eat(&mut self, token: Token) -> Result<bool, ParserError>

Returns true if the token is eaten and bumps to the next token. Otherwise will return false and no bump will occur.

fn try_vec_to_array<const N: usize, T: Clone>( &self, vec: Vec<T>, keyword: Keyword, ) -> Result<Box<[T; N]>, ParserError>

fn expected_identifier<T>(&mut self) -> Result<T, ParserError>

fn expected_field_element<T>(&mut self) -> Result<T, ParserError>

fn expected_witness<T>(&mut self) -> Result<T, ParserError>

fn expected_block_id<T>(&mut self) -> Result<T, ParserError>

fn expected_term<T>(&mut self) -> Result<T, ParserError>

fn expected_token<T>(&mut self, token: Token) -> Result<T, ParserError>

fn expected_one_of_tokens<T>( &mut self, tokens: &[Token], ) -> Result<T, ParserError>