C-Breeze
C Compiler Infrastructure

[ Project home page]

gc_walker.h

Go to the documentation of this file.
00001 // $Id: gc_walker.h,v 1.4 2003/08/07 23:13:44 pnav Exp $
00002 // ----------------------------------------------------------------------
00003 //
00004 //  C-Breeze
00005 //  C Compiler Framework
00006 // 
00007 //  Copyright (c) 2000 University of Texas at Austin
00008 // 
00009 //  Samuel Z. Guyer
00010 //  Daniel A. Jimenez
00011 //  Calvin Lin
00012 // 
00013 //  Permission is hereby granted, free of charge, to any person
00014 //  obtaining a copy of this software and associated documentation
00015 //  files (the "Software"), to deal in the Software without
00016 //  restriction, including without limitation the rights to use, copy,
00017 //  modify, merge, publish, distribute, sublicense, and/or sell copies
00018 //  of the Software, and to permit persons to whom the Software is
00019 //  furnished to do so, subject to the following conditions:
00020 //  
00021 //  The above copyright notice and this permission notice shall be
00022 //  included in all copies or substantial portions of the Software.
00023 //  
00024 //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
00025 //  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00026 //  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00027 //  NONINFRINGEMENT.  IN NO EVENT SHALL THE UNIVERSITY OF TEXAS AT
00028 //  AUSTIN BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
00029 //  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
00030 //  OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00031 //  THE SOFTWARE.
00032 //
00033 //  We acknowledge the C-to-C Translator from MIT Laboratory for
00034 //  Computer Science for inspiring parts of the C-Breeze design.
00035 //
00036 // ----------------------------------------------------------------------
00037 
00038 #ifndef CBZ_GC_WALKER_H
00039 #define CBZ_GC_WALKER_H
00040 
00041 class gcWalker : public Walker {
00042 public:
00043         gcWalker (void) : Walker (Preorder, Subtree) {
00044                 // mark all nodes as unvisited
00045 
00046                 return;
00047                 for (node_list_p p=Node::nodes.begin();
00048                         p!=Node::nodes.end(); p++) {
00049                         (*p)->mark = false;
00050                 }
00051         }
00052 
00053         static void collect (void) {
00054                 return; // until we can fix the bug
00055                 gcWalker g;
00056                 text_list_p p;
00057                 for (p=CBZ::pragmas.begin(); p!=CBZ::pragmas.end(); p++)
00058                         (*p)->walk (g);
00059                 unit_list_p n;
00060                 for (n=CBZ::Program.begin(); n!=CBZ::Program.end(); n++)
00061                         (*n)->walk (g);
00062                 g.delete_nodes();
00063         }
00064 
00065         void at_unit (unitNode *u, Order) {
00066 
00067                 // mark all the stuff that won't get visited
00068                 // by a normal tree traversal
00069 
00070         
00071                 u->types()->mark_nodes();
00072                 u->tags()->mark_nodes();
00073                 decl_list_p p;
00074                 for (p=u->undef_funcs().begin(); p!=u->undef_funcs().end(); p++)
00075                         (*p)->mark = true;
00076                 suespec_list_p q;
00077                 for (q=u->suespecs().begin(); q!=u->suespecs().end(); q++)
00078                         (*q)->mark = true;
00079         }
00080                 
00081         void at_binary (binaryNode *b, Order o) {
00082                 b->mark = true;
00083                 // because of -> and .
00084                 Node *r = b->right();
00085                 if (r) {
00086                         r->mark = true;
00087                         r->walk (*this);
00088                 }
00089         }
00090 
00091         void at_node (Node *n, Order) {
00092                 n->mark = true;
00093         }
00094 
00095         void delete_nodes (void) {
00096                 int count = 0;
00097                 list <Node *> remaining;
00098                 map <Node *,bool>::iterator p;
00099                 list<Node *>::iterator q;
00100                 for (q=Node::nodes.begin(); q!=Node::nodes.end(); ) {
00101                         Node *n = *q;
00102                         if (n->mark == false) {
00103                                 if (n->typ() == Unit) {
00104                                         q++;
00105                                         continue;
00106                                 }
00107                                 if (!Node::deleted_nodes[n]) delete n;
00108                                 q = Node::nodes.erase (q);
00109                                 count++;
00110                         } else {
00111                                 remaining.push_back (n);
00112                                 q++;
00113                         }
00114                 }
00115                 Node::deleted_nodes.clear();
00116                 cout << "deleted " << count << " nodes.\n";
00117         }
00118 };
00119 
00120 #endif // CBZ_GC_WALKER_H

Generated on February 1, 2006
Back to the C-Breeze home page