Home | History | Annotate | Download | only in src 
      1 // Copyright 2015 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_PENDING_COMPILATION_ERROR_HANDLER_H_
      6 #define V8_PENDING_COMPILATION_ERROR_HANDLER_H_
      7 
      8 #include "src/base/macros.h"
      9 #include "src/globals.h"
     10 #include "src/handles.h"
     11 #include "src/messages.h"
     12 
     13 namespace v8 {
     14 namespace internal {
     15 
     16 class AstRawString;
     17 class Isolate;
     18 class Script;
     19 
     20 // Helper class for handling pending compilation errors consistently in various
     21 // compilation phases.
     22 class PendingCompilationErrorHandler {
     23  public:
     24   PendingCompilationErrorHandler()
     25       : has_pending_error_(false),
     26         start_position_(-1),
     27         end_position_(-1),
     28         message_(MessageTemplate::kNone),
     29         arg_(nullptr),
     30         char_arg_(nullptr),
     31         error_type_(kSyntaxError) {}
     32 
     33   void ReportMessageAt(int start_position, int end_position,
     34                        MessageTemplate::Template message,
     35                        const char* arg = nullptr,
     36                        ParseErrorType error_type = kSyntaxError) {
     37     if (has_pending_error_) return;
     38     has_pending_error_ = true;
     39     start_position_ = start_position;
     40     end_position_ = end_position;
     41     message_ = message;
     42     char_arg_ = arg;
     43     arg_ = nullptr;
     44     error_type_ = error_type;
     45   }
     46 
     47   void ReportMessageAt(int start_position, int end_position,
     48                        MessageTemplate::Template message,
     49                        const AstRawString* arg,
     50                        ParseErrorType error_type = kSyntaxError) {
     51     if (has_pending_error_) return;
     52     has_pending_error_ = true;
     53     start_position_ = start_position;
     54     end_position_ = end_position;
     55     message_ = message;
     56     char_arg_ = nullptr;
     57     arg_ = arg;
     58     error_type_ = error_type;
     59   }
     60 
     61   void ReportMessageAt(int start_position, int end_position,
     62                        MessageTemplate::Template message, Handle<String> arg,
     63                        ParseErrorType error_type = kSyntaxError) {
     64     if (has_pending_error_) return;
     65     has_pending_error_ = true;
     66     start_position_ = start_position;
     67     end_position_ = end_position;
     68     message_ = message;
     69     char_arg_ = nullptr;
     70     arg_ = nullptr;
     71     handle_arg_ = arg;
     72     error_type_ = error_type;
     73   }
     74 
     75   bool has_pending_error() const { return has_pending_error_; }
     76 
     77   void ThrowPendingError(Isolate* isolate, Handle<Script> script);
     78 
     79  private:
     80   bool has_pending_error_;
     81   int start_position_;
     82   int end_position_;
     83   MessageTemplate::Template message_;
     84   const AstRawString* arg_;
     85   const char* char_arg_;
     86   Handle<String> handle_arg_;
     87   ParseErrorType error_type_;
     88 
     89   DISALLOW_COPY_AND_ASSIGN(PendingCompilationErrorHandler);
     90 };
     91 
     92 }  // namespace internal
     93 }  // namespace v8
     94 #endif  // V8_PENDING_COMPILATION_ERROR_HANDLER_H_
     95