attributes.cc

PL/0源码

    if (left_operand)
        delete left_operand;
    if (right_operand)
        delete right_operand;
}

////////
//  Statements:
//
st_statement_t::st_statement_t(location_t loc, syntax_tree_t *next)
    : syntax_tree_t(loc)
{
    next_statement = next;
}

////////
//  Returns the next statement in a list of statements (i.e. block of code).
//
st_statement_t *st_statement_t::next(void) const
{
    return (st_statement_t *)next_statement;
}

////////
//  Set the pointer to the next statement.
//
void st_statement_t::set_next(syntax_tree_t *next)
{
    next_statement = next;
}

void st_statement_t::dump_object_data(int recurse, int level) const
{
    dump_name("statement", level);
    cout << p2h(next_statement) << "\n";
    dump_syntax_tree(next_statement, recurse, level);
}

st_statement_t::~st_statement_t(void)
{
    if (next_statement)
        delete next_statement;
}

////////
//  Assignments:
//
st_assignment_t::st_assignment_t(location_t loc, st_identifier_t *left,
                                 syntax_tree_t *right, syntax_tree_t *next)
    : st_statement_t(loc, next)
{
    left_side = left;
    right_side = right;
}

void st_assignment_t::dump_object_data(int recurse, int level) const
{
    dump_name("assignment", level);
    cout << p2h(left_side) << " " << p2h(right_side) << " "
        << p2h(next_statement) << "\n";
    dump_syntax_tree(left_side, recurse, level+1);
    dump_syntax_tree(right_side, recurse, level+1);
    dump_syntax_tree(next_statement, recurse, level);
}

st_assignment_t::~st_assignment_t(void)
{
    if (left_side)
        delete left_side;
    if (right_side)
        delete right_side;
}

////////
//  While Statements:
//
st_while_t::st_while_t(location_t loc, syntax_tree_t *cond,
                       syntax_tree_t *bod, syntax_tree_t *next)
    : st_statement_t(loc, next)
{
    condition = cond;
    body = bod;
}

void st_while_t::dump_object_data(int recurse, int level) const
{
    dump_name("while", level);
    cout << p2h(condition) << " " << p2h(body) << " "
        << p2h(next_statement) << "\n";
    dump_syntax_tree(condition, recurse, level+1);
    dump_syntax_tree(body, recurse, level+1);
    dump_syntax_tree(next_statement, recurse, level);
}

st_while_t::~st_while_t(void)
{
    if (condition)
        delete condition;
    if (body)
        delete body;
}

////////
//  If Statements:
//
st_if_t::st_if_t(location_t loc, syntax_tree_t *cond, syntax_tree_t *bod,
          syntax_tree_t *next)
    : st_statement_t(loc, next)
{
    condition = cond;
    body = bod;
}

void st_if_t::dump_object_data(int recurse, int level) const
{
    dump_name("if", level);
    cout << p2h(condition) << " " << p2h(body) << " "
        << p2h(next_statement) << "\n";
    dump_syntax_tree(condition, recurse, level+1);
    dump_syntax_tree(body, recurse, level+1);
    dump_syntax_tree(next_statement, recurse, level);
}

st_if_t::~st_if_t(void)
{
    if (condition)
        delete condition;
    if (body)
        delete body;
}

////////
//  Call Statements:
//
st_call_t::st_call_t(location_t loc, st_identifier_t *proc,
    syntax_tree_t *next) : st_statement_t(loc, next)
{
    procedure = proc;
}

void st_call_t::dump_object_data(int recurse, int level) const
{
    dump_name("call", level);
    cout << p2h(procedure) << " " << p2h(next_statement) << "\n";
    dump_syntax_tree(procedure, recurse, level+1);
    dump_syntax_tree(next_statement, recurse, level);
}

st_call_t::~st_call_t(void)
{
    if (procedure)
        delete procedure;
}

////////
//  Declarations:
//
st_declaration_t::st_declaration_t(location_t loc, st_identifier_t *id,
                                   syntax_tree_t *next)
    : syntax_tree_t(loc)
{
    identifier = id;
    next_declaration = next;
    tail_declaration = this;
}

////////
//  Return the pointer to the next declaration.
//
st_declaration_t *st_declaration_t::next(void) const
{
    return (st_declaration_t *)next_declaration;
}

////////
//  Set the pointer to the next declaration.
//
void st_declaration_t::set_next(syntax_tree_t *next)
{
    next_declaration = (st_declaration_t *)next;
}

////////
//  Return the pointer to the last (tail) declaration in a list.
//
st_declaration_t *st_declaration_t::tail(void) const
{
    return (st_declaration_t *)tail_declaration;
}

////////
//  Set the pointer to the tail of the list of declarations.
//
void st_declaration_t::set_tail(syntax_tree_t *tail)
{
    tail_declaration = (st_declaration_t *)tail;
}

void st_declaration_t::dump_object_data(int recurse, int level) const
{
    dump_name("declaration", level);
    cout << p2h(identifier) << " " << p2h(next_declaration)
        << " (" << p2h(tail_declaration) << ")\n";
    dump_syntax_tree(identifier, recurse, level+1);
    dump_syntax_tree(next_declaration, recurse, level);
}

st_declaration_t::~st_declaration_t(void)
{
    if (identifier)
        delete identifier;
    if (next_declaration)
        delete next_declaration;
}

////////
//  Constant Declarataions:
//
st_constant_t::st_constant_t(location_t loc, st_identifier_t *id,
                             st_number_t *val, syntax_tree_t *next)
    : st_declaration_t(loc, id, next)
{
    value = val;
}

void st_constant_t::dump_object_data(int recurse, int level) const
{
    dump_name("constant", level);
    cout << p2h(identifier) << " " << p2h(value)
        << " " << p2h(next_declaration)
        << " (" << p2h(tail_declaration) << ")\n";
    dump_syntax_tree(identifier, recurse, level+1);
    dump_syntax_tree(value, recurse, level+1);
    dump_syntax_tree(next_declaration, recurse, level);
}

st_constant_t::~st_constant_t(void)
{
    if (value)
        delete value;
}

////////
//  Variable Declarations:
//
st_variable_t::st_variable_t(location_t loc, st_identifier_t *id,
     syntax_tree_t *next) : st_declaration_t(loc, id, next)
{
}

void st_variable_t::dump_object_data(int recurse, int level) const
{
    dump_name("variable", level);
    cout << p2h(identifier) << " " << p2h(next_declaration)
        << " (" << p2h(tail_declaration) << ")\n";
    dump_syntax_tree(identifier, recurse, level+1);
    dump_syntax_tree(next_declaration, recurse, level);
}

st_variable_t::~st_variable_t(void)
{
}

////////
//  Procedures Declarations:
//
st_procedure_t::st_procedure_t(location_t loc, st_identifier_t *id,
                               st_block_t *bl, syntax_tree_t *next)
    : st_declaration_t(loc, id, next)
{
    block = bl;
}

void st_procedure_t::dump_object_data(int recurse, int level) const
{
    dump_name("procedure", level);
    cout << p2h(identifier) << " " << p2h(block)
        << " " << p2h(next_declaration)
        << " (" << p2h(tail_declaration) << ")\n";
    dump_syntax_tree(identifier, recurse, level+1);
    dump_syntax_tree(block, recurse, level+1);
    dump_syntax_tree(next_declaration, recurse, level);
}

st_procedure_t::~st_procedure_t(void)
{
    if (block)
        delete block;
}

////////
//  Blocks:
//
st_block_t::st_block_t(location_t loc, syntax_tree_t *decls,
                       syntax_tree_t *bod)
    : syntax_tree_t(loc)
{
    declarations = decls;
    body = bod;
    symbol = NULL;
}

void st_block_t::dump_object_data(int recurse, int level) const
{
    dump_name("block", level);
    cout << p2h(declarations) << " " << p2h(body) << "\n";
    dump_syntax_tree(declarations, recurse, level+1);
    dump_syntax_tree(body, recurse, level+1);
}

////////
//  Set the symbol pointer for the block.  The symbol pointer points to the
//  symbol table entry for the procedure to which this block is the body.
//  The symbol is used only for code generation in codegen.cc
//
void st_block_t::set_symbol(se_procedure_t *proc)
{
    symbol = proc;
}

st_block_t::~st_block_t(void)
{
    if (declarations)
        delete declarations;
    if (body)
        delete body;
}

// End of File