[runtime] Support Proxy setPrototypeOf trap

src/ast/prettyprinter.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/ast/prettyprinter.h"
 
 #include <stdarg.h>
 
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/scopes.h"
@@ skipping 81 matching lines @@
   FindStatements(node->statements());
 }
 
 
 void CallPrinter::VisitVariableDeclaration(VariableDeclaration* node) {}
 
 
 void CallPrinter::VisitFunctionDeclaration(FunctionDeclaration* node) {}
 
 
-void CallPrinter::VisitImportDeclaration(ImportDeclaration* node) {
-}
+void CallPrinter::VisitImportDeclaration(ImportDeclaration* node) {}
 
 
 void CallPrinter::VisitExportDeclaration(ExportDeclaration* node) {}
 
 
 void CallPrinter::VisitExpressionStatement(ExpressionStatement* node) {
   Find(node->expression());
 }
 
 
@@ skipping 344 matching lines @@
 
 
 PrettyPrinter::PrettyPrinter(Isolate* isolate) {
   output_ = NULL;
   size_ = 0;
   pos_ = 0;
   InitializeAstVisitor(isolate);
 }
 
 
-PrettyPrinter::~PrettyPrinter() {
-  DeleteArray(output_);
-}
+PrettyPrinter::~PrettyPrinter() { DeleteArray(output_); }
 
 
 void PrettyPrinter::VisitBlock(Block* node) {
   if (!node->ignore_completion_value()) Print("{ ");
   PrintStatements(node->statements());
   if (node->statements()->length() > 0) Print(" ");
   if (!node->ignore_completion_value()) Print("}");
 }
 
 
@@ skipping 28 matching lines @@
   Print(";");
 }
 
 
 void PrettyPrinter::VisitExpressionStatement(ExpressionStatement* node) {
   Visit(node->expression());
   Print(";");
 }
 
 
-void PrettyPrinter::VisitEmptyStatement(EmptyStatement* node) {
-  Print(";");
-}
+void PrettyPrinter::VisitEmptyStatement(EmptyStatement* node) { Print(";"); }
 
 
 void PrettyPrinter::VisitSloppyBlockFunctionStatement(
     SloppyBlockFunctionStatement* node) {
   Visit(node->statement());
 }
 
 
 void PrettyPrinter::VisitIfStatement(IfStatement* node) {
   Print("if (");
@@ skipping 45 matching lines @@
   Visit(node->statement());
 }
 
 
 void PrettyPrinter::VisitSwitchStatement(SwitchStatement* node) {
   PrintLabels(node->labels());
   Print("switch (");
   Visit(node->tag());
   Print(") { ");
   ZoneList<CaseClause*>* cases = node->cases();
-  for (int i = 0; i < cases->length(); i++)
-    Visit(cases->at(i));
+  for (int i = 0; i < cases->length(); i++) Visit(cases->at(i));
   Print("}");
 }
 
 
 void PrettyPrinter::VisitCaseClause(CaseClause* clause) {
   if (clause->is_default()) {
     Print("default");
   } else {
     Print("case ");
     Visit(clause->label());
   }
   Print(": ");
   PrintStatements(clause->statements());
-  if (clause->statements()->length() > 0)
-    Print(" ");
+  if (clause->statements()->length() > 0) Print(" ");
 }
 
 
 void PrettyPrinter::VisitDoWhileStatement(DoWhileStatement* node) {
   PrintLabels(node->labels());
   Print("do ");
   Visit(node->body());
   Print(" while (");
   Visit(node->cond());
   Print(");");
@@ skipping 297 matching lines @@
 const char* PrettyPrinter::Print(AstNode* node) {
   Init();
   Visit(node);
   return output_;
 }
 
 
 const char* PrettyPrinter::PrintExpression(FunctionLiteral* program) {
   Init();
   ExpressionStatement* statement =
-    program->body()->at(0)->AsExpressionStatement();
+      program->body()->at(0)->AsExpressionStatement();
   Visit(statement->expression());
   return output_;
 }
 
 
 const char* PrettyPrinter::PrintProgram(FunctionLiteral* program) {
   Init();
   PrintStatements(program->body());
   Print("\n");
   return output_;
@@ skipping 15 matching lines @@
   }
   output_[0] = '\0';
   pos_ = 0;
 }
 
 
 void PrettyPrinter::Print(const char* format, ...) {
   for (;;) {
     va_list arguments;
     va_start(arguments, format);
-    int n = VSNPrintF(Vector<char>(output_, size_) + pos_,
-                      format,
-                      arguments);
+    int n = VSNPrintF(Vector<char>(output_, size_) + pos_, format, arguments);
     va_end(arguments);
 
     if (n >= 0) {
       // there was enough space - we are done
       pos_ += n;
       return;
     } else {
       // there was not enough space - allocate more and try again
       const int slack = 32;
       int new_size = size_ + (size_ >> 1) + slack;
@@ skipping 75 matching lines @@
 
 
 void PrettyPrinter::PrintLiteral(const AstRawString* value, bool quote) {
   PrintLiteral(value->string(), quote);
 }
 
 
 void PrettyPrinter::PrintParameters(Scope* scope) {
   Print("(");
   for (int i = 0; i < scope->num_parameters(); i++) {
-    if (i  > 0) Print(", ");
+    if (i > 0) Print(", ");
     PrintLiteral(scope->parameter(i)->name(), false);
   }
   Print(")");
 }
 
 
 void PrettyPrinter::PrintDeclarations(ZoneList<Declaration*>* declarations) {
   for (int i = 0; i < declarations->length(); i++) {
     if (i > 0) Print(" ");
     Visit(declarations->at(i));
   }
 }
 
 
 void PrettyPrinter::PrintFunctionLiteral(FunctionLiteral* function) {
   Print("function ");
   PrintLiteral(function->name(), false);
   PrintParameters(function->scope());
   Print(" { ");
   PrintDeclarations(function->scope()->declarations());
   PrintStatements(function->body());
   Print(" }");
 }
 
 
 //-----------------------------------------------------------------------------
 
 class IndentedScope BASE_EMBEDDED {
  public:
-  IndentedScope(AstPrinter* printer, const char* txt)
-      : ast_printer_(printer) {
+  IndentedScope(AstPrinter* printer, const char* txt) : ast_printer_(printer) {
     ast_printer_->PrintIndented(txt);
     ast_printer_->Print("\n");
     ast_printer_->inc_indent();
   }
 
   IndentedScope(AstPrinter* printer, const char* txt, int pos)
       : ast_printer_(printer) {
     ast_printer_->PrintIndented(txt);
     ast_printer_->Print(" at %d\n", pos);
     ast_printer_->inc_indent();
   }
 
-  virtual ~IndentedScope() {
-    ast_printer_->dec_indent();
-  }
+  virtual ~IndentedScope() { ast_printer_->dec_indent(); }
 
  private:
   AstPrinter* ast_printer_;
 };
 
 
 //-----------------------------------------------------------------------------
 
 
 AstPrinter::AstPrinter(Isolate* isolate) : PrettyPrinter(isolate), indent_(0) {}
 
 
-AstPrinter::~AstPrinter() {
-  DCHECK(indent_ == 0);
-}
+AstPrinter::~AstPrinter() { DCHECK(indent_ == 0); }
 
 
 void AstPrinter::PrintIndented(const char* txt) {
   for (int i = 0; i < indent_; i++) {
     Print(". ");
   }
   Print(txt);
 }
 
 
-void AstPrinter::PrintLiteralIndented(const char* info,
-                                      Handle<Object> value,
+void AstPrinter::PrintLiteralIndented(const char* info, Handle<Object> value,
                                       bool quote) {
   PrintIndented(info);
   Print(" ");
   PrintLiteral(value, quote);
   Print("\n");
 }
 
 
-void AstPrinter::PrintLiteralWithModeIndented(const char* info,
-                                              Variable* var,
+void AstPrinter::PrintLiteralWithModeIndented(const char* info, Variable* var,
                                               Handle<Object> value) {
   if (var == NULL) {
     PrintLiteralIndented(info, value, true);
   } else {
     EmbeddedVector<char, 256> buf;
     int pos = SNPrintF(buf, "%s (mode = %s", info,
                        Variable::Mode2String(var->mode()));
     SNPrintF(buf + pos, ")");
     PrintLiteralIndented(buf.start(), value, true);
   }
 }
 
 
 void AstPrinter::PrintLabelsIndented(ZoneList<const AstRawString*>* labels) {
   if (labels == NULL || labels->length() == 0) return;
   PrintIndented("LABELS ");
   PrintLabels(labels);
   Print("\n");
 }
 
 
 void AstPrinter::PrintIndentedVisit(const char* s, AstNode* node) {
   IndentedScope indent(this, s, node->position());
   Visit(node);
 }
 
 
 const char* AstPrinter::PrintProgram(FunctionLiteral* program) {
   Init();
-  { IndentedScope indent(this, "FUNC", program->position());
+  {
+    IndentedScope indent(this, "FUNC", program->position());
     PrintLiteralIndented("NAME", program->name(), true);
     PrintLiteralIndented("INFERRED NAME", program->inferred_name(), true);
     PrintParameters(program->scope());
     PrintDeclarations(program->scope()->declarations());
     PrintStatements(program->body());
   }
   return Output();
 }
 
 
@@ skipping 36 matching lines @@
   const char* block_txt =
       node->ignore_completion_value() ? "BLOCK NOCOMPLETIONS" : "BLOCK";
   IndentedScope indent(this, block_txt, node->position());
   PrintStatements(node->statements());
 }
 
 
 // TODO(svenpanne) Start with IndentedScope.
 void AstPrinter::VisitVariableDeclaration(VariableDeclaration* node) {
   PrintLiteralWithModeIndented(Variable::Mode2String(node->mode()),
-                               node->proxy()->var(),
-                               node->proxy()->name());
+                               node->proxy()->var(), node->proxy()->name());
 }
 
 
 // TODO(svenpanne) Start with IndentedScope.
 void AstPrinter::VisitFunctionDeclaration(FunctionDeclaration* node) {
   PrintIndented("FUNCTION ");
   PrintLiteral(node->proxy()->name(), true);
   Print(" = function ");
   PrintLiteral(node->fun()->name(), false);
   Print("\n");
@@ skipping 125 matching lines @@
   IndentedScope indent(this, "FOR OF", node->position());
   PrintIndentedVisit("FOR", node->each());
   PrintIndentedVisit("OF", node->iterable());
   PrintIndentedVisit("BODY", node->body());
 }
 
 
 void AstPrinter::VisitTryCatchStatement(TryCatchStatement* node) {
   IndentedScope indent(this, "TRY CATCH", node->position());
   PrintIndentedVisit("TRY", node->try_block());
-  PrintLiteralWithModeIndented("CATCHVAR",
-                               node->variable(),
+  PrintLiteralWithModeIndented("CATCHVAR", node->variable(),
                                node->variable()->name());
   PrintIndentedVisit("CATCH", node->catch_block());
 }
 
 
 void AstPrinter::VisitTryFinallyStatement(TryFinallyStatement* node) {
   IndentedScope indent(this, "TRY FINALLY", node->position());
   PrintIndentedVisit("TRY", node->try_block());
   PrintIndentedVisit("FINALLY", node->finally_block());
 }
@@ skipping 272 matching lines @@
 
 void AstPrinter::VisitSuperCallReference(SuperCallReference* node) {
   IndentedScope indent(this, "SUPER-CALL-REFERENCE", node->position());
 }
 
 
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8