Class BeerParser

Private current

Private tokens

Private advance

• advance(): Token

• Returns Token

  consumes the current token and returns it

Private and

• and(): Expr

• Grammar for Logic And

  expression → logic_and; logic_and → equality ( "and" equality )* ;

  Returns Expr

  logic_and

Private assignment

• assignment(): Expr

• Grammar for Assignment

  assignment → IDENTIFIER "=" assignment | logic_or ;

  Returns Expr

  assignment

Private block

• block(): Stmt[]

• Grammar for block

  block → "{" declaration* "}" ;

  Returns Stmt[]

  ast.Stmt

Private call

• call(): Expr

• Grammar for call

  expression → call ; call → primary ( "(" arguments? ")" )* ;

  Returns Expr

  ast.Expr

Private check

• check(type): boolean

• Parameters

  • type: TokenType

    {TokenType} to check

  Returns boolean

  true if the current token is of the given type

Private class_declaration

• class_declaration(): Stmt

• Returns Stmt

Private comparison

• comparison(): Expr

• Grammar for Comparison

  expression → comparism; comparison → term ( ( ">" | ">=" | "<" | "<=" ) term )* ;

  Returns Expr

  comparison

Private consume

• consume(type, message): Token

• Parameters

  • type: TokenType

    {TokenType} to consume

  • message: string

    {string} to throw if type is not found

  Returns Token

  Throws

  returns the token if found, else throws an error

Private declaration

• declaration(): Stmt

• Grammar for declearation

  declaration → classDecl | funcDecl; | varDecl | statement ;

  Returns Stmt

  ast.Stmt

Private equality

• equality(): Expr

• Grammar for Equality

  expression → equality ; equality → comparison ( ( "!=" | "==" ) comparison )* ;

  Returns Expr

  ast.Expr equality

Private expression

• expression(): Expr

• Grammar for Expression

  expression → assignment; assignment → IDENTIFIER "=" assignment

  Returns Expr

  current token

Private expression_statement

• expression_statement(): Stmt

• Evaluation of Expression

  expressionStmt → expression

  Returns Stmt

  ast.Stmt

Private factor

• factor(): Expr

• Grammar for Factor

  expression → factor ; factor → unary ( ( "/" | "*" ) unary )* ;

  Returns Expr

  ast.Expr factor

Private finish_call

• finish_call(callee): Expr

• Parse the call expressions using the callee

  Parameters

  • callee: Expr

    ast.Expr

  Returns Expr

Private for_statement

• for_statement(): Stmt

• Evaluation of for statement

  forStmt → "for" "(" ( varDecl | exprStmt | ";" ) expression? ";" expression? ")" statement ;

  Returns Stmt

  ast.Stmt

Private function_declaration

• function_declaration(kind): FunctionStmt

• Implementation of for function declearations

  Parameters

  • kind: string

    The kind of function to be declared

  Returns FunctionStmt

  ast.FunctionStmt

Private if_statement

• if_statement(): Stmt

• Evaluation of if statement

  ifStmt → "if" "(" expression ")" statement ( "else" statement )? ;

  Returns Stmt

  ast.Stmt

Private is_at_end

• is_at_end(): boolean

• Returns boolean

  true if the current token is at the end

Private match

• match(...types): boolean

• Check if current token is in the given list of types. If so, consume it and return true.

  Parameters

  • Rest ...types: TokenType[]

    {TokenType[]} to match

  Returns boolean

Private or

• or(): Expr

• Grammar for Logic Or

  expression → logic_or; logic_or → logic_and ( "or" logic_and )* ;

  Returns Expr

  logic_or

Private peek

• peek(): Token

• Returns Token

  the current token

Private previous

• previous(): Token

• Returns Token

  the previous token

Private primary

• primary(): Expr

• Grammar for Literal

  expression → literal; literal -> primary primary → NUMBER | STRING | "true" | "false" | "nil" ;

  Returns Expr

  equality

Private print_statement

• print_statement(): Stmt

• Evaluation of Print

  printStmt → expression | "print" expression

  Returns Stmt

  ast.Stmt ast of print

Private return_statement

• return_statement(): Stmt

• Returns Stmt

Private statement

• statement(): Stmt

• Ecaluation of statements

  statement → expressionStmt | ifStmt ; | printStmt ; | returnStmt ; | whileStmt; | BlockStmt;

  Returns Stmt

  ast.Stmt

Private synchronize

• synchronize(): void

• Synchronize the parser after an error.

  Returns void

Private term

• term(): Expr

• Grammar for Term

  expression → term ; term → factor ( ( "-" | "+" ) factor )* ;

  Returns Expr

  ast.Expr term

Private unary

• unary(): Expr

• Grammar for Unary

  expression → unary | call ; unary → ( "!" | "-" ) Unary | primary;

  Returns Expr

  ast.Expr unary

Private var_declaration

• var_declaration(): Stmt

• Grammar for var declaration

  varDecl → "var" IDENTIFIER ( "=" expression )? ";" ;

  Returns Stmt

  ast.Stmt

Private while_statement

• while_statement(): Stmt

• Evaluation of while statement

  whileStmt → "while" "(" expression ")" statement ;

  Returns Stmt

  ast.Stmt