Rename: ExpressionBuilder => ExpressionCfgBuilder, StatementBuilder =>...

src/cfg.h

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 641 matching lines @@
   void Print();
 #endif
 
  private:
   // Entry and exit nodes.
   CfgNode* entry_;
   CfgNode* exit_;
 };
 
 
-// An implementation of a set of locations (currently slot locations).
+// An implementation of a set of locations (currently slot locations), most
+// of the operations are destructive.
 class LocationSet BASE_EMBEDDED {
  public:
   // Construct an empty location set.
   LocationSet() : parameters_(0), locals_(0) {}
 
   // Raw accessors.
   uintptr_t parameters() { return parameters_; }
   uintptr_t locals() { return locals_; }
 
+  // Make this the empty set.
+  void Empty() {
+    parameters_ = locals_ = 0;
+  }
+
   // Insert an element.
   void AddElement(SlotLocation* location) {
     if (location->type() == Slot::PARAMETER) {
       // Parameter indexes begin with -1 ('this').
       ASSERT(location->index() < kPointerSize - 1);
       parameters_ |= (1 << (location->index() + 1));
     } else {
       ASSERT(location->type() == Slot::LOCAL);
       ASSERT(location->index() < kPointerSize);
       locals_ |= (1 << location->index());
@@ skipping 16 matching lines @@
       return (locals_ & (1 << location->index()));
     }
   }
 
  private:
   uintptr_t parameters_;
   uintptr_t locals_;
 };
 
 
-// An ExpressionBuilder traverses an expression and returns an open CFG
+// An ExpressionCfgBuilder traverses an expression and returns an open CFG
 // fragment (currently a possibly empty list of instructions represented by
 // a singleton instruction block) and the expression's value.
 //
-// Failure is to build the CFG is indicated by a NULL CFG.
-class ExpressionBuilder : public AstVisitor {
+// Failure to build the CFG is indicated by a NULL CFG.
+class ExpressionCfgBuilder : public AstVisitor {
  public:
-  ExpressionBuilder() : value_(NULL), graph_(NULL), destination_(NULL) {}
+  ExpressionCfgBuilder() : destination_(NULL), value_(NULL), graph_(NULL) {}
 
   // Result accessors.
   Value* value() { return value_; }
   Cfg* graph() { return graph_; }
   LocationSet* assigned_vars() { return &assigned_vars_; }
 
   // Build the cfg for an expression and remember its value.  The
   // destination is a 'hint' where the value should go which may be ignored.
   // NULL is used to indicate no preference.
   //
   // Concretely, if the expression needs to generate a temporary for its
   // value, it should use the passed destination or generate one if NULL.
   void Build(Expression* expr, Location* destination) {
     value_ = NULL;
     graph_ = new Cfg();
+    assigned_vars_.Empty();
     destination_ = destination;
     Visit(expr);
   }
 
   // AST node visitors.
 #define DECLARE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
  private:
-  // State for the visitor.  Output parameters.
+  // State for the visitor.  Input parameters:
+  Location* destination_;
+
+  // Output parameters:
   Value* value_;
   Cfg* graph_;
   LocationSet assigned_vars_;
-
-  // Input parameters.
-  Location* destination_;
 };
 
 
-// A StatementBuilder maintains a CFG fragment accumulator.  When it visits
-// a statement, it concatenates the CFG for the statement to the end of the
-// accumulator.
-class StatementBuilder : public AstVisitor {
+// A StatementCfgBuilder maintains a CFG fragment accumulator.  When it
+// visits a statement, it concatenates the CFG for the statement to the end
+// of the accumulator.
+class StatementCfgBuilder : public AstVisitor {
  public:
-  StatementBuilder() : graph_(new Cfg()) {}
+  StatementCfgBuilder() : graph_(new Cfg()) {}
 
   Cfg* graph() { return graph_; }
 
   void VisitStatements(ZoneList<Statement*>* stmts);
 
   // AST node visitors.
 #define DECLARE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
  private:
+  // State for the visitor.  Input/output parameter:
   Cfg* graph_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_CFG_H_