Today. Assignments. Lecture Notes CPSC 326 (Spring 2019) Quiz 4. Syntax Analysis: Abstract Syntax Trees. HW3 due. HW4 out (due next Thurs)

Transcription

1 Today Quiz 4 Syntax Analysis: Abstract Syntax Trees Assignments HW3 due HW4 out (due next Thurs) S. Bowers 1 of 6

2 Generating Abstract Syntax Trees (ASTs) 1. The parsing step both checks syntax and builds the AST 2. An AST is typically used for: semantic analysis, e.g., type checking, ensuring items defined before used interpretation, e.g., in an AST interpreter conversion to intermediate representation (like bytecode) 3. An AST is like an expression tree perform in-order traversal (left, node, right) to execute expression tree more types of nodes in an AST, e.g., declarations, loops, var asignment, etc. S. Bowers 2 of 6

3 Running Example stmt_list ::= VAR ASSIGN expr stmt_list_tail stmt_list_tail ::= SEMICOLON stmt_list ɛ expr ::= VAR expr_tail expr_tail ::= PLUS VAR MINUS VAR ɛ Parser class with basic methods and member variables: class Parser(object): def init (self, lexer): self.lexer = lexer self.curr_token = None def parse(self):... # helper functions def advance(self):... def eat(self, tokentype, err_msg):... def error(self, err_msg):... # recursive descent functions def stmt_list(self):... def stmt_list_tail(self):... def expr(self):... def expr_tail(self):... S. Bowers 3 of 6

4 In our example, AST might contain nodes (objects) representing: statement lists an assignment with an identifier and an expression an expression with a single variable an expression with two variables and an operator (StmtList) (AssignStmt) (VarExpr) (OpExpr) Note we d also have Expr as a superclass of VarExpr and OpExpr class StmtList(object): self.smts = [] class AssignStmt(object): self.lhs = None self.rhs = None # list of AssignStmt # Expr class Expr(object): pass class VarExpr(Expr): self.var = None class OpExpr(Expr): self.left_operand self.operator self.right_operand # PLUS or MINUS token S. Bowers 4 of 6

5 Adding AST creation to our Recursive Descent Parser def parse(self): stmt_list_node = ast.stmtlist() self. advance() self. stmt_list(stmt_list_node) self. eat(token.eos, '...') return stmt_list_node def stmt_list(self, stmt_list_node): assign_node = ast.assignstmt() assign_node.lhs = self.curr_token self. eat(token.var, '...') self. eat(token.assign, '...') assign_node.rhs = self. expr() stmt_list_node.smts.append(assign_node) self. stmt_list_tail(stmt_list_node) # create StmtList node # init lexer # descend into stmt_list # ensure EOS # return AST root node # create Assign node # set lhs # ensure VAR # ensure ASSIGN # descend and set rhs # add Assign node # descend to tail Exercise: Rewrite the remaining recursive descent functions to build the AST Exercise: Draw the AST (object graph) resulting from the string A=B+C; B=A S. Bowers 5 of 6

6 The AST Class Hierarchy for MyPL (HW 4) ExprStmt expr : Expr VarDeclStmt var_id : Token var_type : Token var_expr : Expr AssignStmt lhs : LValue rhs : Expr LValue path : [Token] StructDeclStmt struct_id : Token var_decls : [VarDeclStmt] Stmt (abstract) FunDeclStmt fun_name : Token params : [FunParam] return_type : Token stmt_list : StmtList ReturnStmt return_expr : Expr return_token : Token FunParam param_name : Token param_type : Token ASTNode (abstract) StmtList stmts : [Stmt] WhileStmt bool_expr : BoolExpr stmt_list : StmtList IfStmt if_part : BasicIf elseifs : [BasicIf] has_else : bool else_stmts : StmtList BasicIf bool_expr : BoolExpr stmt_list : StmtList Expr (abstract) SimpleExpr term : RValue SimpleRValue val : Token RValue (abstract) ComplexExpr first_operand : Expr math_rel : Token rest : Expr BoolExpr first_expr : Expr bool_rel : Token second_expr : Expr bool_connector : Token rest : BoolExpr negated : bool NewRValue struct_type : Token CallRValue fun : Token args : [Expr] IDRValue path : [Token] S. Bowers 6 of 6