attributes.h

PL/0源码

class st_binary_op_t : public st_operator_t
{
protected:
    syntax_tree_t *             left_operand;   // Left hand operand.
    syntax_tree_t *             right_operand;  // Right hand operand.
public:
    st_binary_op_t(location_t loc, st_token_t *id, syntax_tree_t *lopand,
                   syntax_tree_t *ropand);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     allocate_registers(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;
    virtual                     ~st_binary_op_t(void);
};

////////
//  Statements
//
class st_statement_t : public syntax_tree_t
{
protected:
    syntax_tree_t *             next_statement; // Next statement in block.
public:
    st_statement_t(location_t loc, syntax_tree_t *next);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     allocate_registers(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;
    st_statement_t *            next(void) const;
    void                        set_next(syntax_tree_t * next);
    virtual                     ~st_statement_t(void);
};

class st_assignment_t : public st_statement_t
{
protected:
    st_identifier_t *           left_side;      // Left side of assignment.
    syntax_tree_t *             right_side;     // Right side of assignment.
public:
    st_assignment_t(location_t loc, st_identifier_t *left,
                    syntax_tree_t *right, syntax_tree_t *next);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     allocate_registers(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;
    virtual                     ~st_assignment_t(void);
};

class st_while_t : public st_statement_t
{
protected:
    syntax_tree_t *             condition;      // While condition.
    syntax_tree_t *             body;           // Do body code.
public:
    st_while_t(location_t loc, syntax_tree_t *cond, syntax_tree_t *bod,
               syntax_tree_t *next);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     allocate_registers(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;
    virtual                     ~st_while_t(void);
};

class st_if_t : public st_statement_t
{
protected:
    syntax_tree_t *             condition;      // If condition.
    syntax_tree_t *             body;           // Then body code.
public:
    st_if_t(location_t loc, syntax_tree_t *cond, syntax_tree_t *bod,
            syntax_tree_t *next);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     allocate_registers(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;
    virtual                     ~st_if_t(void);
};

class st_call_t : public st_statement_t
{
protected:
    st_identifier_t *           procedure;      // Procedure to call.
public:
    st_call_t(location_t loc, st_identifier_t *proc, syntax_tree_t *next);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     allocate_registers(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;
    virtual                     ~st_call_t(void);
};

////////
//  Declarations
//
class st_declaration_t : public syntax_tree_t
{
protected:
    st_identifier_t *           identifier;     // Identifier to declare.
    syntax_tree_t *             next_declaration; // Next declaration in scope.
    syntax_tree_t *             tail_declaration; // Last declaration in scope.
public:
    st_declaration_t(location_t loc, st_identifier_t *id, syntax_tree_t *next);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     allocate_registers(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;

    st_declaration_t *          next(void) const;
    void                        set_next(syntax_tree_t *next);
    st_declaration_t *          tail(void) const;
    void                        set_tail(syntax_tree_t *tail);

    virtual                     ~st_declaration_t(void);
};

class st_constant_t : public st_declaration_t
{
protected:
    st_number_t *               value;          // Constant's value.
public:
    st_constant_t(location_t loc, st_identifier_t *id, st_number_t *val,
                  syntax_tree_t *next);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;
    virtual                     ~st_constant_t(void);
};

class st_variable_t : public st_declaration_t
{
public:
    st_variable_t(location_t loc, st_identifier_t *id, syntax_tree_t *next);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;
    virtual                     ~st_variable_t(void);
};

class st_procedure_t : public st_declaration_t
{
protected:
    st_block_t *                block;          // Procedure's block code.
public:
    st_procedure_t(location_t loc, st_identifier_t *id, st_block_t *bl,
                   syntax_tree_t *next);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     generate_code(void);
    virtual void                dump_object_data(int recurse, int level) const;
    virtual                     ~st_procedure_t(void);
};

////////
//  Blocks
//
class st_block_t : public syntax_tree_t
{
protected:
    syntax_tree_t *             declarations;   // Declarations for this scope.
    syntax_tree_t *             body;           // Body code.
    se_procedure_t *            symbol;         // Symbol of owning procedure.
public:
    st_block_t(location_t loc, syntax_tree_t *decls, syntax_tree_t *bod);
    virtual void                check_semantics(scope_number_t scope);
    virtual syntax_tree_t *     optimize(void);
    virtual syntax_code_t *     generate_code(void);
    virtual syntax_code_t *     allocate_registers(void);
    virtual void                dump_object_data(int recurse, int level) const;
    void                        set_symbol(se_procedure_t *proc);
    virtual                     ~st_block_t(void);
};

union attrib_stack_t  {
    token_attrib_t              token;          // Token from parser.
    syntax_tree_t *             node;           // Node from other productions.
};

extern attrib_stack_t * lhs;
extern attrib_stack_t * rhs;
extern syntax_tree_t *  ast_root;

void init_attributes(void);

void start_production(int length, int seen_so_far);
void end_production(int& seen_so_far);
void init_token(token_attrib_t attr, int seen_so_far);

void dump_syntax_tree (syntax_tree_t *node, int recurse = 1,
                       int level = 0);
//  For debugging, display all information about the syntax tree.

#endif