v8-exception.h

Go to the documentation of this file.

// Copyright 2021 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.
 
#ifndef INCLUDE_V8_EXCEPTION_H_
#define INCLUDE_V8_EXCEPTION_H_
 
#include <stddef.h>
 
#include "v8-local-handle.h"  // NOLINT(build/include_directory)
#include "v8-object.h"        // NOLINT(build/include_directory)
#include "v8config.h"         // NOLINT(build/include_directory)
 
namespace v8 {
 
class Context;
class Isolate;
class Message;
class StackTrace;
class String;
class Value;
 
namespace internal {
class Isolate;
class ThreadLocalTop;
}  // namespace internal
 
class V8_EXPORT Exception {
 public:
  static Local<Value> RangeError(Local<String> message,
                                 Local<Value> options = {});
  static Local<Value> ReferenceError(Local<String> message,
                                     Local<Value> options = {});
  static Local<Value> SyntaxError(Local<String> message,
                                  Local<Value> options = {});
  static Local<Value> TypeError(Local<String> message,
                                Local<Value> options = {});
  static Local<Value> WasmCompileError(Local<String> message,
                                       Local<Value> options = {});
  static Local<Value> WasmLinkError(Local<String> message,
                                    Local<Value> options = {});
  static Local<Value> WasmRuntimeError(Local<String> message,
                                       Local<Value> options = {});
  static Local<Value> WasmSuspendError(Local<String> message,
                                       Local<Value> options = {});
  static Local<Value> Error(Local<String> message, Local<Value> options = {});
 
  static Local<Message> CreateMessage(Isolate* isolate, Local<Value> exception);
 
  static Local<StackTrace> GetStackTrace(Local<Value> exception);
 
  static Maybe<bool> CaptureStackTrace(Local<Context> context,
                                       Local<Object> object);
};
 
enum class ExceptionContext : uint32_t {
  kUnknown,
  kConstructor,
  kOperation,
  kAttributeGet,
  kAttributeSet,
  kIndexedQuery,
  kIndexedGetter,
  kIndexedDescriptor,
  kIndexedSetter,
  kIndexedDefiner,
  kIndexedDeleter,
  kNamedQuery,
  kNamedGetter,
  kNamedDescriptor,
  kNamedSetter,
  kNamedDefiner,
  kNamedDeleter,
  kNamedEnumerator
};
 
class ExceptionPropagationMessage {
 public:
  ExceptionPropagationMessage(v8::Isolate* isolate, Local<Object> exception,
                              Local<String> interface_name,
                              Local<String> property_name,
                              ExceptionContext exception_context)
      : isolate_(isolate),
        exception_(exception),
        interface_name_(interface_name),
        property_name_(property_name),
        exception_context_(exception_context) {}
 
  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
  V8_INLINE Local<Object> GetException() const { return exception_; }
  V8_INLINE Local<String> GetInterfaceName() const { return interface_name_; }
  V8_INLINE Local<String> GetPropertyName() const { return property_name_; }
  V8_INLINE ExceptionContext GetExceptionContext() const {
    return exception_context_;
  }
 
 private:
  Isolate* isolate_;
  Local<Object> exception_;
  Local<String> interface_name_;
  Local<String> property_name_;
  ExceptionContext exception_context_;
};
 
using ExceptionPropagationCallback =
    void (*)(ExceptionPropagationMessage message);
 
class V8_EXPORT TryCatch {
 public:
  explicit TryCatch(Isolate* isolate);
 
  ~TryCatch();
 
  bool HasCaught() const;
 
  bool CanContinue() const;
 
  bool HasTerminated() const;
 
  Local<Value> ReThrow();
 
  Local<Value> Exception() const;
 
  V8_WARN_UNUSED_RESULT static MaybeLocal<Value> StackTrace(
      Local<Context> context, Local<Value> exception);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> StackTrace(
      Local<Context> context) const;
 
  Local<v8::Message> Message() const;
 
  void Reset();
 
  void SetVerbose(bool value);
 
  bool IsVerbose() const;
 
  void SetCaptureMessage(bool value);
 
  TryCatch(const TryCatch&) = delete;
  void operator=(const TryCatch&) = delete;
 
 private:
  // Declaring operator new and delete as deleted is not spec compliant.
  // Therefore declare them private instead to disable dynamic alloc
  void* operator new(size_t size);
  void* operator new[](size_t size);
  void operator delete(void*, size_t);
  void operator delete[](void*, size_t);
 
  internal::Address JSStackComparableAddressPrivate() {
    return js_stack_comparable_address_;
  }
 
  void ResetInternal();
 
  internal::Isolate* i_isolate_;
  TryCatch* next_;
  void* exception_;
  void* message_obj_;
  internal::Address js_stack_comparable_address_;
  bool is_verbose_ : 1;
  bool can_continue_ : 1;
  bool capture_message_ : 1;
  bool rethrow_ : 1;
 
  friend class internal::Isolate;
  friend class internal::ThreadLocalTop;
};
 
}  // namespace v8
 
#endif  // INCLUDE_V8_EXCEPTION_H_