Change ScriptCompiler::CompileOptions and add d8 --cache.

src/parser.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/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 236 matching lines @@
   return Data()[PreparseDataConstants::kVersionOffset];
 }
 
 
 int ParseData::FunctionsSize() {
   return static_cast<int>(Data()[PreparseDataConstants::kFunctionsSizeOffset]);
 }
 
 
 void Parser::SetCachedData() {
-  if (cached_data_mode() == NO_CACHED_DATA) {
+  if (compile_options() == ScriptCompiler::kNoCompileOptions) {
     cached_parse_data_ = NULL;
   } else {
     ASSERT(info_->cached_data() != NULL);
-    if (cached_data_mode() == CONSUME_CACHED_DATA) {
+    if (compile_options() == ScriptCompiler::kConsumeParserCache) {
       cached_parse_data_ = new ParseData(*info_->cached_data());
     }
   }
 }
 
 
 Scope* Parser::NewScope(Scope* parent, ScopeType scope_type) {
   ASSERT(ast_value_factory_);
   Scope* result =
       new (zone()) Scope(parent, scope_type, ast_value_factory_, zone());
@@ skipping 461 matching lines @@
   Handle<String> source(String::cast(script_->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   fni_ = new(zone()) FuncNameInferrer(ast_value_factory_, zone());
 
   // Initialize parser state.
   CompleteParserRecorder recorder;
-  if (cached_data_mode() == PRODUCE_CACHED_DATA) {
+
+  if (compile_options_ == ScriptCompiler::kProduceParserCache) {
     log_ = &recorder;
-  } else if (cached_data_mode() == CONSUME_CACHED_DATA) {
+  } else if (compile_options_ == ScriptCompiler::kConsumeParserCache) {
     cached_parse_data_->Initialize();
   }
 
   source = String::Flatten(source);
   FunctionLiteral* result;
   if (source->IsExternalTwoByteString()) {
     // Notice that the stream is destroyed at the end of the branch block.
     // The last line of the blocks can't be moved outside, even though they're
     // identical calls.
     ExternalTwoByteStringUtf16CharacterStream stream(
@@ skipping 12 matching lines @@
       PrintF("[parsing eval");
     } else if (info()->script()->name()->IsString()) {
       String* name = String::cast(info()->script()->name());
       SmartArrayPointer<char> name_chars = name->ToCString();
       PrintF("[parsing script: %s", name_chars.get());
     } else {
       PrintF("[parsing script");
     }
     PrintF(" - took %0.3f ms]\n", ms);
   }
-  if (cached_data_mode() == PRODUCE_CACHED_DATA) {
+  if (compile_options_ == ScriptCompiler::kConsumeParserCache) {
     if (result != NULL) *info_->cached_data() = recorder.GetScriptData();
     log_ = NULL;
   }
   return result;
 }
 
 
 FunctionLiteral* Parser::DoParseProgram(CompilationInfo* info,
                                         Handle<String> source) {
   ASSERT(scope_ == NULL);
@@ skipping 2744 matching lines @@
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
 }
 
 
 void Parser::SkipLazyFunctionBody(const AstRawString* function_name,
                                   int* materialized_literal_count,
                                   int* expected_property_count,
                                   bool* ok) {
   int function_block_pos = position();
-  if (cached_data_mode() == CONSUME_CACHED_DATA) {
+  if (compile_options_ == ScriptCompiler::kConsumeParserCache) {
     // If we have cached data, we use it to skip parsing the function body. The
     // data contains the information we need to construct the lazy function.
     FunctionEntry entry =
         cached_parse_data_->GetFunctionEntry(function_block_pos);
     // Check that cached data is valid.
     CHECK(entry.is_valid());
     // End position greater than end of stream is safe, and hard to check.
     CHECK(entry.end_pos() > function_block_pos);
     scanner()->SeekForward(entry.end_pos() - 1);
 
@@ skipping 29 matching lines @@
     scope_->set_end_position(logger.end());
     Expect(Token::RBRACE, ok);
     if (!*ok) {
       return;
     }
     isolate()->counters()->total_preparse_skipped()->Increment(
         scope_->end_position() - function_block_pos);
     *materialized_literal_count = logger.literals();
     *expected_property_count = logger.properties();
     scope_->SetStrictMode(logger.strict_mode());
-    if (cached_data_mode() == PRODUCE_CACHED_DATA) {
+    if (compile_options_ == ScriptCompiler::kProduceParserCache) {
       ASSERT(log_);
       // Position right after terminal '}'.
       int body_end = scanner()->location().end_pos;
       log_->LogFunction(function_block_pos, body_end,
                         *materialized_literal_count,
                         *expected_property_count,
                         scope_->strict_mode());
     }
   }
 }
@@ skipping 1134 matching lines @@
     info()->SetAstValueFactory(ast_value_factory_);
   }
   ast_value_factory_ = NULL;
 
   InternalizeUseCounts();
 
   return (result != NULL);
 }
 
 } }  // namespace v8::internal