Home | History | Annotate | Download | only in src 
      1 // Copyright 2011 the V8 project authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef V8_PREPARSE_DATA_H_
      6 #define V8_PREPARSE_DATA_H_
      7 
      8 #include "src/allocation.h"
      9 #include "src/hashmap.h"
     10 #include "src/utils-inl.h"
     11 
     12 namespace v8 {
     13 namespace internal {
     14 
     15 
     16 // Abstract interface for preparse data recorder.
     17 class ParserRecorder {
     18  public:
     19   ParserRecorder() { }
     20   virtual ~ParserRecorder() { }
     21 
     22   // Logs the scope and some details of a function literal in the source.
     23   virtual void LogFunction(int start,
     24                            int end,
     25                            int literals,
     26                            int properties,
     27                            StrictMode strict_mode) = 0;
     28 
     29   // Logs an error message and marks the log as containing an error.
     30   // Further logging will be ignored, and ExtractData will return a vector
     31   // representing the error only.
     32   virtual void LogMessage(int start,
     33                           int end,
     34                           const char* message,
     35                           const char* argument_opt,
     36                           bool is_reference_error) = 0;
     37  private:
     38   DISALLOW_COPY_AND_ASSIGN(ParserRecorder);
     39 };
     40 
     41 
     42 class SingletonLogger : public ParserRecorder {
     43  public:
     44   SingletonLogger()
     45       : has_error_(false), start_(-1), end_(-1), is_reference_error_(false) {}
     46   virtual ~SingletonLogger() {}
     47 
     48   void Reset() { has_error_ = false; }
     49 
     50   virtual void LogFunction(int start,
     51                            int end,
     52                            int literals,
     53                            int properties,
     54                            StrictMode strict_mode) {
     55     ASSERT(!has_error_);
     56     start_ = start;
     57     end_ = end;
     58     literals_ = literals;
     59     properties_ = properties;
     60     strict_mode_ = strict_mode;
     61   }
     62 
     63   // Logs an error message and marks the log as containing an error.
     64   // Further logging will be ignored, and ExtractData will return a vector
     65   // representing the error only.
     66   virtual void LogMessage(int start,
     67                           int end,
     68                           const char* message,
     69                           const char* argument_opt,
     70                           bool is_reference_error) {
     71     if (has_error_) return;
     72     has_error_ = true;
     73     start_ = start;
     74     end_ = end;
     75     message_ = message;
     76     argument_opt_ = argument_opt;
     77     is_reference_error_ = is_reference_error;
     78   }
     79 
     80   bool has_error() const { return has_error_; }
     81 
     82   int start() const { return start_; }
     83   int end() const { return end_; }
     84   int literals() const {
     85     ASSERT(!has_error_);
     86     return literals_;
     87   }
     88   int properties() const {
     89     ASSERT(!has_error_);
     90     return properties_;
     91   }
     92   StrictMode strict_mode() const {
     93     ASSERT(!has_error_);
     94     return strict_mode_;
     95   }
     96   int is_reference_error() const { return is_reference_error_; }
     97   const char* message() {
     98     ASSERT(has_error_);
     99     return message_;
    100   }
    101   const char* argument_opt() const {
    102     ASSERT(has_error_);
    103     return argument_opt_;
    104   }
    105 
    106  private:
    107   bool has_error_;
    108   int start_;
    109   int end_;
    110   // For function entries.
    111   int literals_;
    112   int properties_;
    113   StrictMode strict_mode_;
    114   // For error messages.
    115   const char* message_;
    116   const char* argument_opt_;
    117   bool is_reference_error_;
    118 };
    119 
    120 
    121 class CompleteParserRecorder : public ParserRecorder {
    122  public:
    123   struct Key {
    124     bool is_one_byte;
    125     Vector<const byte> literal_bytes;
    126   };
    127 
    128   CompleteParserRecorder();
    129   virtual ~CompleteParserRecorder() {}
    130 
    131   virtual void LogFunction(int start,
    132                            int end,
    133                            int literals,
    134                            int properties,
    135                            StrictMode strict_mode) {
    136     function_store_.Add(start);
    137     function_store_.Add(end);
    138     function_store_.Add(literals);
    139     function_store_.Add(properties);
    140     function_store_.Add(strict_mode);
    141   }
    142 
    143   // Logs an error message and marks the log as containing an error.
    144   // Further logging will be ignored, and ExtractData will return a vector
    145   // representing the error only.
    146   virtual void LogMessage(int start,
    147                           int end,
    148                           const char* message,
    149                           const char* argument_opt,
    150                           bool is_reference_error_);
    151   Vector<unsigned> ExtractData();
    152 
    153  private:
    154   bool has_error() {
    155     return static_cast<bool>(preamble_[PreparseDataConstants::kHasErrorOffset]);
    156   }
    157 
    158   void WriteString(Vector<const char> str);
    159 
    160   // Write a non-negative number to the symbol store.
    161   void WriteNumber(int number);
    162 
    163   Collector<unsigned> function_store_;
    164   unsigned preamble_[PreparseDataConstants::kHeaderSize];
    165 
    166 #ifdef DEBUG
    167   int prev_start_;
    168 #endif
    169 };
    170 
    171 
    172 } }  // namespace v8::internal.
    173 
    174 #endif  // V8_PREPARSE_DATA_H_
    175