Cool Abstract Syntax Trees

Transcription

1 constructors phyla classes lists Cool Abstract Syntax Trees Cool ASTs [Bono] 1

2 Cool AST overview review: abstract syntax tree is a concrete data structure we build while parsing one C++ class per Cool programming construct (e.g., let, plus, dispatch, function definition, class definition) objects of the class are nodes in the AST Cool ASTs [Bono] 2

3 in parser: How are we using the AST? just build the tree call polymorphic dump function to print it out (already written for you) in semantic analysis and code generation: you will write polymorphic functions to traverse the tree. to do things such as: type checking adding type information to tree generating code Cool ASTs [Bono] 3

4 AST terminology cool-tree.aps has a high-level description of tree structure. C++ code is automatically generated from this description. constructor is one kind of AST node the function to build the node (not a C++ constructor) lower case name example: assign Cool ASTs [Bono] 4

5 phylum AST terminology (cont.) categorization of a group of constructors related to their role in the language e.g. RHS of assignment operator can be any expression so we ll categorize all expression node types as one phylum, Expression names start with upper case Note: some phyla have just one constructor. e.g., phylum Class_ constructor class_ Cool ASTs [Bono] 5

6 Example of constructor: assign Using APS notation: (from ~csci410/cool/src/pa3/cool-tree.aps) constructor assign(name: Symbol, expr: Expression): Expression Generates the C function with prototype: (from ~csci410/cool/include/pa3/cool-tree.h) Expression assign(symbol name, Expression expr); Creates an assign node from a name (LHS) and an expr (RHS), returns a pointer to the node (phylum type Expression) Cool ASTs [Bono] 6

7 constructor body What exactly does assign do? Here s the code: (from ~csci410/cool/src/pa3/cool-tree.cc) Expression assign(symbol name, Expression expr) { return new assign_class(name, expr); } C function wrapper which calls C++ constructor. What are the types?... Cool ASTs [Bono] 7

8 AST Classes types use a consistent naming scheme (automatically generated from.aps file) phylum/constructor relationship implemented using inheritance here s the inheritance hierarchy: tree_node... Expression_class... Class class Phylum class (capitalized) plus_class assign_class Constructor class (lower case) NOTE: you don t need to be too familiar with this for parser -- will need to understand more for later parts of compiler. Cool ASTs [Bono] 8

9 AST Classes (cont.) Phylum name is defined as follows: typedef Expression_class * Expression; since assign_class ISA Expression_class, can return Expression from assign constructor: Expression assign(symbol name, Expression expr) { return new assign_class(name, expr); } using pointer to more general type enables us to substitute any specific expression node pointer (e.g., pointer to assign_class) where an Expression node pointer is expected. Cool ASTs [Bono] 9

10 AST Lists Sometimes need a list of tree nodes as part of the AST. E.g.: list of attributes in a class definition list of classes in a program list of actual parameters in a dispatch expression Some phyla are list phyla: a list of tree nodes of that phylum Example from cool-tree.aps: phylum Expressions = LIST[Expression]; Example of the use of Expressions in a constructor: Expression dispatch(expression expr, Symbol name, Expressions actuals); NOTE: Different than the list package in list.h Cool ASTs [Bono] 10

11 Operations on AST lists all have operations for traversing (a.k.a., iterator ops) first(), more(), next(i), nth(i) (the last one returns the appropriate phylum type). see Cool Tour for example of their use (don t need for parsing) Operations for building lists Expressions nil_expression(); Expressions single_expression(expression); Expressions append_expressions(expressions, Expressions); names constructed from phylum name i.e., there are analogous functions for each list phylum. Cool ASTs [Bono] 11

12 Example of using constructors and lists Expression e1, e2, e3; Expression e = plus(e1, e2); // make empty list Expressions p = nil_expressions(); // make list of one element p = append_expressions(single_expressions(e), p); // another way to make a list of one element Expressions q = single_expressions(e); // append to the end of a list q = append_expressions(q, single_expressions(e3)); Cool ASTs [Bono] 12