Version 3.5.5.

src/full-codegen.h

 // Copyright 2011 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 122 matching lines @@
     virtual Breakable* AsBreakable() { return NULL; }
     virtual Iteration* AsIteration() { return NULL; }
     virtual TryCatch* AsTryCatch() { return NULL; }
     virtual TryFinally* AsTryFinally() { return NULL; }
     virtual Finally* AsFinally() { return NULL; }
     virtual ForIn* AsForIn() { return NULL; }
 
     virtual bool IsContinueTarget(Statement* target) { return false; }
     virtual bool IsBreakTarget(Statement* target) { return false; }
 
-    // Generate code to leave the nested statement. This includes
-    // cleaning up any stack elements in use and restoring the
-    // stack to the expectations of the surrounding statements.
-    // Takes a number of stack elements currently on top of the
-    // nested statement's stack, and returns a number of stack
-    // elements left on top of the surrounding statement's stack.
-    // The generated code must preserve the result register (which
-    // contains the value in case of a return).
-    virtual int Exit(int stack_depth) {
-      // Default implementation for the case where there is
-      // nothing to clean up.
-      return stack_depth;
+    // Notify the statement that we are exiting it via break, continue, or
+    // return and give it a chance to generate cleanup code.  Return the
+    // next outer statement in the nesting stack.  We accumulate in
+    // *stack_depth the amount to drop the stack and in *context_length the
+    // number of context chain links to unwind as we traverse the nesting
+    // stack from an exit to its target.
+    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+      return previous_;
     }
-    NestedStatement* outer() { return previous_; }
 
  protected:
     MacroAssembler* masm() { return codegen_->masm(); }
 
- private:
     FullCodeGenerator* codegen_;
     NestedStatement* previous_;
     DISALLOW_COPY_AND_ASSIGN(NestedStatement);
   };
 
   class Breakable : public NestedStatement {
    public:
     Breakable(FullCodeGenerator* codegen,
               BreakableStatement* break_target)
         : NestedStatement(codegen),
@@ skipping 28 matching lines @@
   };
 
   // The environment inside the try block of a try/catch statement.
   class TryCatch : public NestedStatement {
    public:
     explicit TryCatch(FullCodeGenerator* codegen, Label* catch_entry)
         : NestedStatement(codegen), catch_entry_(catch_entry) { }
     virtual ~TryCatch() {}
     virtual TryCatch* AsTryCatch() { return this; }
     Label* catch_entry() { return catch_entry_; }
-    virtual int Exit(int stack_depth);
+    virtual NestedStatement* Exit(int* stack_depth, int* context_length);
    private:
     Label* catch_entry_;
     DISALLOW_COPY_AND_ASSIGN(TryCatch);
   };
 
   // The environment inside the try block of a try/finally statement.
   class TryFinally : public NestedStatement {
    public:
     explicit TryFinally(FullCodeGenerator* codegen, Label* finally_entry)
         : NestedStatement(codegen), finally_entry_(finally_entry) { }
     virtual ~TryFinally() {}
     virtual TryFinally* AsTryFinally() { return this; }
     Label* finally_entry() { return finally_entry_; }
-    virtual int Exit(int stack_depth);
+    virtual NestedStatement* Exit(int* stack_depth, int* context_length);
    private:
     Label* finally_entry_;
     DISALLOW_COPY_AND_ASSIGN(TryFinally);
   };
 
   // A FinallyEnvironment represents being inside a finally block.
   // Abnormal termination of the finally block needs to clean up
   // the block's parameters from the stack.
   class Finally : public NestedStatement {
    public:
     explicit Finally(FullCodeGenerator* codegen) : NestedStatement(codegen) { }
     virtual ~Finally() {}
     virtual Finally* AsFinally() { return this; }
-    virtual int Exit(int stack_depth) {
-      return stack_depth + kFinallyStackElementCount;
+    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+      *stack_depth += kFinallyStackElementCount;
+      return previous_;
     }
    private:
     // Number of extra stack slots occupied during a finally block.
     static const int kFinallyStackElementCount = 2;
     DISALLOW_COPY_AND_ASSIGN(Finally);
   };
 
   // A ForInEnvironment represents being inside a for-in loop.
   // Abnormal termination of the for-in block needs to clean up
   // the block's temporary storage from the stack.
   class ForIn : public Iteration {
    public:
     ForIn(FullCodeGenerator* codegen,
           ForInStatement* statement)
         : Iteration(codegen, statement) { }
     virtual ~ForIn() {}
     virtual ForIn* AsForIn() { return this; }
-    virtual int Exit(int stack_depth) {
-      return stack_depth + kForInStackElementCount;
+    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+      *stack_depth += kForInStackElementCount;
+      return previous_;
     }
    private:
     static const int kForInStackElementCount = 5;
     DISALLOW_COPY_AND_ASSIGN(ForIn);
   };
 
+
+  // A WithOrCatch represents being inside the body of a with or catch
+  // statement.  Exiting the body needs to remove a link from the context
+  // chain.
+  class WithOrCatch : public NestedStatement {
+   public:
+    explicit WithOrCatch(FullCodeGenerator* codegen)
+        : NestedStatement(codegen) {
+    }
+    virtual ~WithOrCatch() {}
+
+    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+      ++(*context_length);
+      return previous_;
+    }
+  };
+
   // The forward bailout stack keeps track of the expressions that can
   // bail out to just before the control flow is split in a child
   // node. The stack elements are linked together through the parent
   // link when visiting expressions in test contexts after requesting
   // bailout in child forwarding.
   class ForwardBailoutStack BASE_EMBEDDED {
    public:
     ForwardBailoutStack(Expression* expr, ForwardBailoutStack* parent)
         : expr_(expr), parent_(parent) { }
 
@@ skipping 529 matching lines @@
 
   friend class NestedStatement;
 
   DISALLOW_COPY_AND_ASSIGN(FullCodeGenerator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_