ast.h

Go to the documentation of this file.

 
#ifndef __AST_H
#define __AST_H
 
#include "common.h"
 
typedef void (*AttributeValueDOTPrinter)(void*, FILE*);
 
typedef void (*Destructor)(void*);
 
void dummy_free(void*);
 
void dummy_print(void*, FILE*);
 
void int_attr_print(void*, FILE*);
 
 
typedef enum NodeType {
    PROGRAM, VARDECL, FUNCDECL, BLOCK,
    ASSIGNMENT, CONDITIONAL, WHILELOOP, RETURNSTMT, BREAKSTMT, CONTINUESTMT,
    BINARYOP, UNARYOP, LOCATION, FUNCCALL, LITERAL
} NodeType;
 
const char* NodeType_to_string(NodeType type);
 
typedef struct ProgramNode {
    struct NodeList* variables; 
    struct NodeList* functions; 
} ProgramNode;
 
struct ASTNode* ProgramNode_new (struct NodeList* vars, struct NodeList* funcs);
 
typedef struct VarDeclNode {
    char name[MAX_ID_LEN];      
    DecafType type;             
    bool is_array;              
    int array_length;           
} VarDeclNode;
 
struct ASTNode* VarDeclNode_new (const char* name, DecafType type,
                                 bool is_array, int array_length, int source_line);
 
typedef struct Parameter {
    char name[MAX_ID_LEN];      
    DecafType type;             
    struct Parameter* next;     
} Parameter;
 
/*
 * Declare ParameterList to be a linked list of Parameter* elements.
 */
DECL_LIST_TYPE(Parameter, struct Parameter*)
 
 
void ParameterList_add_new (ParameterList* list, const char* name, DecafType type);
 
typedef struct FuncDeclNode {
    char name[MAX_ID_LEN];      
    DecafType return_type;      
    ParameterList* parameters;  
    struct ASTNode* body;       
} FuncDeclNode;
 
struct ASTNode* FuncDeclNode_new (const char* name, DecafType return_type, ParameterList* parameters,
                                  struct ASTNode* body, int source_line);
 
typedef struct BlockNode {
    struct NodeList* variables; 
    struct NodeList* statements;
} BlockNode;
 
struct ASTNode* BlockNode_new (struct NodeList* vars, struct NodeList* stmts, int source_line);
 
typedef struct AssignmentNode {
    struct ASTNode* location;   
    struct ASTNode* value;      
} AssignmentNode;
 
struct ASTNode* AssignmentNode_new (struct ASTNode* location, struct ASTNode* value, int source_line);
 
typedef struct ConditionalNode {
    struct ASTNode* condition;  
    struct ASTNode* if_block;   
    struct ASTNode* else_block; 
} ConditionalNode;
 
struct ASTNode* ConditionalNode_new (struct ASTNode* condition, struct ASTNode* if_block,
                                     struct ASTNode* else_block, int source_line);
 
typedef struct WhileLoopNode {
    struct ASTNode* condition;  
    struct ASTNode* body;       
} WhileLoopNode;
 
struct ASTNode* WhileLoopNode_new (struct ASTNode* condition, struct ASTNode* body, int source_line);
 
typedef struct ReturnNode {
    struct ASTNode* value;      
} ReturnNode;
 
struct ASTNode* ReturnNode_new (struct ASTNode* value, int source_line);
 
struct ASTNode* BreakNode_new (int source_line);
 
struct ASTNode* ContinueNode_new (int source_line);
 
typedef enum BinaryOpType {
    OROP, ANDOP, EQOP, NEQOP, LTOP, LEOP, GEOP, GTOP,
    ADDOP, SUBOP, MULOP, DIVOP, MODOP
} BinaryOpType;
 
const char* BinaryOpToString(BinaryOpType op);
 
typedef struct BinaryOpNode {
    BinaryOpType operator;      
    struct ASTNode* left;       
    struct ASTNode* right;      
} BinaryOpNode;
 
struct ASTNode* BinaryOpNode_new (BinaryOpType operator,
                                  struct ASTNode* left, struct ASTNode* right,
                                  int source_line);
 
typedef enum UnaryOpType {
    NEGOP, NOTOP
} UnaryOpType;
 
const char* UnaryOpToString(UnaryOpType op);
 
typedef struct UnaryOpNode {
    UnaryOpType operator;       
    struct ASTNode* child;      
} UnaryOpNode;
 
struct ASTNode* UnaryOpNode_new (UnaryOpType operator, struct ASTNode* child, int source_line);
 
typedef struct LocationNode {
    char name[MAX_ID_LEN];      
    struct ASTNode* index;      
} LocationNode;
 
struct ASTNode* LocationNode_new (const char* name, struct ASTNode* index, int source_line);
 
typedef struct FuncCallNode {
    char name[MAX_ID_LEN];      
    struct NodeList* arguments; 
} FuncCallNode;
 
struct ASTNode* FuncCallNode_new (const char* name, struct NodeList* args, int source_line);
 
typedef struct LiteralNode {
    DecafType type;                 
    union {
        int integer;                
        bool boolean;               
        char string[MAX_LINE_LEN];  
    };
} LiteralNode;
 
struct ASTNode* LiteralNode_new_int (int value, int source_line);
 
struct ASTNode* LiteralNode_new_bool (bool value, int source_line);
 
struct ASTNode* LiteralNode_new_string (const char* value, int source_line);
 
typedef struct Attribute
{
    const char* key;        
    void* value;            
    AttributeValueDOTPrinter dot_printer;   
    Destructor dtor;        
    struct Attribute* next; 
} Attribute;
 
typedef struct ASTNode
{
    NodeType type;          
    int source_line;        
    Attribute* attributes;  
    struct ASTNode* next;   
    /* anonymous union of type-specific node data (C polymorphism) */
    union {
        struct ProgramNode program;
        struct VarDeclNode vardecl;
        struct FuncDeclNode funcdecl;
        struct BlockNode block;
        struct AssignmentNode assignment;
        struct ConditionalNode conditional;
        struct WhileLoopNode whileloop;
        struct ReturnNode funcreturn;
        struct BinaryOpNode binaryop;
        struct UnaryOpNode unaryop;
        struct LocationNode location;
        struct FuncCallNode funccall;
        struct LiteralNode literal;
    };
} ASTNode;
 
/*
 * Declare NodeList to be a linked list of ASTNode* elements.
 */
DECL_LIST_TYPE(Node, struct ASTNode*)
 
 
ASTNode* ASTNode_new (NodeType type, int line);
 
void ASTNode_set_attribute (ASTNode* node, const char* key, void* value, Destructor dtor);
 
void ASTNode_set_printable_attribute (ASTNode* node, const char* key, void* value,
                                      AttributeValueDOTPrinter dot_printer, Destructor dtor);
 
void ASTNode_set_int_attribute (ASTNode* node, const char* key, int value);
 
bool ASTNode_has_attribute (ASTNode* node, const char* key);
 
void* ASTNode_get_attribute (ASTNode* node, const char* key);
 
int ASTNode_get_int_attribute (ASTNode* node, const char* key);
 
void ASTNode_free (ASTNode* node);
 
#endif