Introduce a BreakTarget subclass of JumpTarget used to represent the...

src/ast.h

 // Copyright 2006-2008 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 182 matching lines @@
   };
 
   // The labels associated with this statement. May be NULL;
   // if it is != NULL, guaranteed to contain at least one entry.
   ZoneStringList* labels() const { return labels_; }
 
   // Type testing & conversion.
   virtual BreakableStatement* AsBreakableStatement() { return this; }
 
   // Code generation
-  JumpTarget* break_target() { return &break_target_; }
+  BreakTarget* break_target() { return &break_target_; }
 
   // Used during code generation for restoring the stack when a
   // break/continue crosses a statement that keeps stuff on the stack.
   int break_stack_height() { return break_stack_height_; }
   void set_break_stack_height(int height) { break_stack_height_ = height; }
 
   // Testers.
   bool is_target_for_anonymous() const { return type_ == TARGET_FOR_ANONYMOUS; }
 
  protected:
   BreakableStatement(ZoneStringList* labels, Type type)
       : labels_(labels), type_(type) {
     ASSERT(labels == NULL || labels->length() > 0);
   }
 
  private:
   ZoneStringList* labels_;
   Type type_;
-  JumpTarget break_target_;
+  BreakTarget break_target_;
   int break_stack_height_;
 };
 
 
 class Block: public BreakableStatement {
  public:
   Block(ZoneStringList* labels, int capacity, bool is_initializer_block)
       : BreakableStatement(labels, TARGET_FOR_NAMED_ONLY),
         statements_(capacity),
         is_initializer_block_(is_initializer_block) { }
@@ skipping 36 matching lines @@
 
 
 class IterationStatement: public BreakableStatement {
  public:
   // Type testing & conversion.
   virtual IterationStatement* AsIterationStatement() { return this; }
 
   Statement* body() const { return body_; }
 
   // Code generation
-  JumpTarget* continue_target()  { return &continue_target_; }
+  BreakTarget* continue_target()  { return &continue_target_; }
 
  protected:
   explicit IterationStatement(ZoneStringList* labels)
       : BreakableStatement(labels, TARGET_FOR_ANONYMOUS), body_(NULL) { }
 
   void Initialize(Statement* body) {
     body_ = body;
   }
 
  private:
   Statement* body_;
-  JumpTarget continue_target_;
+  BreakTarget continue_target_;
 };
 
 
 class LoopStatement: public IterationStatement {
  public:
   enum Type { DO_LOOP, FOR_LOOP, WHILE_LOOP };
 
   LoopStatement(ZoneStringList* labels, Type type)
       : IterationStatement(labels), type_(type), init_(NULL),
         cond_(NULL), next_(NULL) { }
@@ skipping 142 matching lines @@
 class CaseClause: public ZoneObject {
  public:
   CaseClause(Expression* label, ZoneList<Statement*>* statements)
       : label_(label), statements_(statements) { }
 
   bool is_default() const  { return label_ == NULL; }
   Expression* label() const  {
     CHECK(!is_default());
     return label_;
   }
-  JumpTarget* body_target() { return &body_target_; }
+  BreakTarget* body_target() { return &body_target_; }
   ZoneList<Statement*>* statements() const  { return statements_; }
 
  private:
   Expression* label_;
-  JumpTarget body_target_;
+  BreakTarget body_target_;
   ZoneList<Statement*>* statements_;
 };
 
 
 class SwitchStatement: public BreakableStatement {
  public:
   explicit SwitchStatement(ZoneStringList* labels)
       : BreakableStatement(labels, TARGET_FOR_ANONYMOUS),
         tag_(NULL), cases_(NULL) { }
 
@@ skipping 40 matching lines @@
   Expression* condition_;
   Statement* then_statement_;
   Statement* else_statement_;
 };
 
 
 // NOTE: TargetCollectors are represented as nodes to fit in the target
 // stack in the compiler; this should probably be reworked.
 class TargetCollector: public Node {
  public:
-  explicit TargetCollector(ZoneList<JumpTarget*>* targets)
+  explicit TargetCollector(ZoneList<BreakTarget*>* targets)
       : targets_(targets) {
   }
 
   // Adds a jump target to the collector. The collector stores a pointer not
   // a copy of the target to make binding work, so make sure not to pass in
   // references to something on the stack.
-  void AddTarget(JumpTarget* target);
+  void AddTarget(BreakTarget* target);
 
   // Virtual behaviour. TargetCollectors are never part of the AST.
   virtual void Accept(AstVisitor* v) { UNREACHABLE(); }
   virtual TargetCollector* AsTargetCollector() { return this; }
 
-  ZoneList<JumpTarget*>* targets() { return targets_; }
+  ZoneList<BreakTarget*>* targets() { return targets_; }
 
  private:
-  ZoneList<JumpTarget*>* targets_;
+  ZoneList<BreakTarget*>* targets_;
 };
 
 
 class TryStatement: public Statement {
  public:
   explicit TryStatement(Block* try_block)
       : try_block_(try_block), escaping_targets_(NULL) { }
 
-  void set_escaping_targets(ZoneList<JumpTarget*>* targets) {
+  void set_escaping_targets(ZoneList<BreakTarget*>* targets) {
     escaping_targets_ = targets;
   }
 
   Block* try_block() const { return try_block_; }
-  ZoneList<JumpTarget*>* escaping_targets() const { return escaping_targets_; }
+  ZoneList<BreakTarget*>* escaping_targets() const { return escaping_targets_; }
 
  private:
   Block* try_block_;
-  ZoneList<JumpTarget*>* escaping_targets_;
+  ZoneList<BreakTarget*>* escaping_targets_;
 };
 
 
 class TryCatch: public TryStatement {
  public:
   TryCatch(Block* try_block, Expression* catch_var, Block* catch_block)
       : TryStatement(try_block),
         catch_var_(catch_var),
         catch_block_(catch_block) {
     ASSERT(catch_var->AsVariableProxy() != NULL);
@@ skipping 1111 matching lines @@
 #undef DEF_VISIT
 
  private:
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_