---

changer.h

Go to the documentation of this file.

// ----------------------------------------------------------------------
//
//  C-Breeze
//  C Compiler Framework
// 
//  Copyright (c) 2000 University of Texas at Austin
// 
//  Samuel Z. Guyer
//  Daniel A. Jimenez
//  Calvin Lin
// 
//  Permission is hereby granted, free of charge, to any person
//  obtaining a copy of this software and associated documentation
//  files (the "Software"), to deal in the Software without
//  restriction, including without limitation the rights to use, copy,
//  modify, merge, publish, distribute, sublicense, and/or sell copies
//  of the Software, and to permit persons to whom the Software is
//  furnished to do so, subject to the following conditions:
//  
//  The above copyright notice and this permission notice shall be
//  included in all copies or substantial portions of the Software.
//  
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
//  NONINFRINGEMENT.  IN NO EVENT SHALL THE UNIVERSITY OF TEXAS AT
//  AUSTIN BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
//  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
//  OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//  THE SOFTWARE.
//
//  We acknowledge the C-to-C Translator from MIT Laboratory for
//  Computer Science for inspiring parts of the C-Breeze design.
//
// ----------------------------------------------------------------------

#ifndef CBZ_CHANGER_H
#define CBZ_CHANGER_H

class Changer {

public:

  typedef enum { Preorder, Postorder, Both } Order;
  typedef enum { Subtree, NodeOnly } Depth;

private:

  Order _order;

  Depth _depth;

  bool _delete_old;

public:

  Changer(Order the_order, Depth depth, bool delete_old)
    : _order(the_order),
      _depth(depth),
      _delete_old(delete_old)
  {}


  inline Order order() const { return _order; }

  inline Depth depth() const { return _depth; }

  inline bool delete_old() const { return _delete_old; }





  virtual Node * at_node(Node * the_node, Order ord)
     { return the_node; }

  virtual Node * at_unit(unitNode * the_unit, Order ord)
     { return at_node(the_unit, ord); }

  virtual Node * at_def(defNode * the_def, Order ord)
     { return at_node(the_def, ord); }

  virtual Node * at_decl(declNode * the_decl, Order ord)
     { return at_def(the_decl, ord); }

  virtual Node * at_subdecl(subdeclNode * the_subdecl, Order ord)
     { return at_decl(the_subdecl, ord); }

  virtual Node * at_proc(procNode * the_proc, Order ord)
     { return at_def(the_proc, ord); }

  virtual Node * at_type(typeNode * the_type, Order ord)
     { return at_node(the_type, ord); }

  virtual Node * at_prim(primNode * the_prim, Order ord)
     { return at_type(the_prim, ord); }

  virtual Node * at_tdef(tdefNode * the_tdef, Order ord)
     { return at_type(the_tdef, ord); }

  virtual Node * at_ptr(ptrNode * the_ptr, Order ord)
     { return at_type(the_ptr, ord); }

  virtual Node * at_array(arrayNode * the_array, Order ord)
     { return at_type(the_array, ord); }

  virtual Node * at_func(funcNode * the_func, Order ord)
     { return at_type(the_func, ord); }

  virtual Node * at_sue(sueNode * the_sue, Order ord)
     { return at_type(the_sue, ord); }

  virtual Node * at_struct(structNode * the_struct, Order ord)
     { return at_sue(the_struct, ord); }

  virtual Node * at_union(unionNode * the_union, Order ord)
     { return at_sue(the_union, ord); }

  virtual Node * at_enum(enumNode * the_enum, Order ord)
     { return at_sue(the_enum, ord); }

  virtual Node * at_suespec(suespecNode * the_suespec, Order ord)
     { return at_type(the_suespec, ord); }

  virtual Node * at_expr(exprNode * the_expr, Order ord)
     { return at_node(the_expr, ord); }

  virtual Node * at_const(constNode * the_const, Order ord)
     { return at_expr(the_const, ord); }

  virtual Node * at_id(idNode * the_id, Order ord)
     { return at_expr(the_id, ord); }

  virtual Node * at_binary(binaryNode * the_binary, Order ord)
     { return at_expr(the_binary, ord); }

  virtual Node * at_unary(unaryNode * the_unary, Order ord)
     { return at_expr(the_unary, ord); }

  virtual Node * at_cast(castNode * the_cast, Order ord)
     { return at_expr(the_cast, ord); }

  virtual Node * at_comma(commaNode * the_comma, Order ord)
     { return at_expr(the_comma, ord); }

  virtual Node * at_ternary(ternaryNode * the_ternary, Order ord)
     { return at_expr(the_ternary, ord); }

  virtual Node * at_call(callNode * the_call, Order ord)
     { return at_expr(the_call, ord); }

  virtual Node * at_initializer(initializerNode * the_initializer, Order ord)
     { return at_expr(the_initializer, ord); }

  virtual Node * at_stmt(stmtNode * the_stmt, Order ord)
     { return at_node(the_stmt, ord); }

  virtual Node * at_block(blockNode * the_block, Order ord)
     { return at_stmt(the_block, ord); }

  virtual Node * at_basicblock(basicblockNode * the_basicblock, Order ord)
     { return at_block(the_basicblock, ord); }

  virtual Node * at_exprstmt(exprstmtNode * the_exprstmt, Order ord)
     { return at_stmt(the_exprstmt, ord); }

  virtual Node * at_target(targetNode * the_target, Order ord)
     { return at_stmt(the_target, ord); }

  virtual Node * at_label(labelNode * the_label, Order ord)
     { return at_target(the_label, ord); }

  virtual Node * at_case(caseNode * the_case, Order ord)
     { return at_target(the_case, ord); }

  virtual Node * at_selection(selectionNode * the_selection, Order ord)
     { return at_stmt(the_selection, ord); }

  virtual Node * at_if(ifNode * the_if, Order ord)
     { return at_selection(the_if, ord); }

  virtual Node * at_switch(switchNode * the_switch, Order ord)
     { return at_selection(the_switch, ord); }

  virtual Node * at_loop(loopNode * the_loop, Order ord)
     { return at_stmt(the_loop, ord); }

  virtual Node * at_while(whileNode * the_while, Order ord)
     { return at_loop(the_while, ord); }

  virtual Node * at_do(doNode * the_do, Order ord)
     { return at_loop(the_do, ord); }

  virtual Node * at_for(forNode * the_for, Order ord)
     { return at_loop(the_for, ord); }

  virtual Node * at_jump(jumpNode * the_jump, Order ord)
     { return at_stmt(the_jump, ord); }

  virtual Node * at_goto(gotoNode * the_goto, Order ord)
     { return at_jump(the_goto, ord); }

  virtual Node * at_continue(continueNode * the_continue, Order ord)
     { return at_jump(the_continue, ord); }

  virtual Node * at_break(breakNode * the_break, Order ord)
     { return at_jump(the_break, ord); }

  virtual Node * at_return(returnNode * the_return, Order ord)
     { return at_jump(the_return, ord); }

  virtual Node * at_attrib(attribNode * the_attrib, Order ord)
     { return at_stmt(the_attrib, ord); }

  virtual Node * at_text(textNode * the_text, Order ord)
     { return at_node(the_text, ord); }

private:

  /* -- Deprecated...

  virtual Node * at_index(indexNode * the_index, Order ord)
     { return at_expr(the_index, ord); }

  virtual Node * at_implicitcast(implicitcastNode * the_implicitcast, Order ord)
     { return at_expr(the_implicitcast, ord); }

  virtual Node * at_default(defaultNode * the_default, Order ord)
     { return at_target(the_default, ord); }

  virtual Node * at_ifelse(ifelseNode * the_ifelse, Order ord)
     { return at_selection(the_ifelse, ord); }

  */

};

template< class T >
void change_list(list< T > & l, Changer & the_changer)
{
  for (list< T >::iterator p = l.begin();
       p != l.end(); ++p)
    {
      Node * n = (*p)->change(the_changer);
      if (n != (*p)) {

        if (the_changer.delete_old())
          delete (*p);

        if (n)
          (*p) = (T) n;
        else {
          list< T >::iterator q = p;
          l.erase(q);
        }
      }
    }
}


#endif // CBZ_CHANGER_H

---