File Manager

X7ROOT File Manager

Current Path: /usr/local/include/node

📁 ..
📄 common.gypi(21.86 KB)
📄 config.gypi(25.84 KB)
📁 cppgc
📄 js_native_api.h(30.96 KB)
📄 js_native_api_types.h(4.44 KB)
📁 libplatform
📄 node.h(56.44 KB)
📄 node_api.h(9.83 KB)
📄 node_api_types.h(1.57 KB)
📄 node_buffer.h(3.6 KB)
📄 node_object_wrap.h(3.78 KB)
📄 node_version.h(3.85 KB)
📁 openssl
📁 uv
📄 uv.h(67.74 KB)
📄 v8-array-buffer.h(15.53 KB)
📄 v8-callbacks.h(14.05 KB)
📄 v8-container.h(3.4 KB)
📄 v8-context.h(13.91 KB)
📄 v8-data.h(1.58 KB)
📄 v8-date.h(1.09 KB)
📄 v8-debug.h(5.04 KB)
📄 v8-embedder-heap.h(6.72 KB)
📄 v8-embedder-state-scope.h(1.51 KB)
📄 v8-exception.h(6.98 KB)
📄 v8-extension.h(1.83 KB)
📄 v8-external.h(924 B)
📄 v8-forward.h(1.62 KB)
📄 v8-function-callback.h(15.02 KB)
📄 v8-function.h(3.91 KB)
📄 v8-initialization.h(10.97 KB)
📄 v8-internal.h(26.03 KB)
📄 v8-isolate.h(61.74 KB)
📄 v8-json.h(1.32 KB)
📄 v8-local-handle.h(14.24 KB)
📄 v8-locker.h(4.31 KB)
📄 v8-maybe.h(3.66 KB)
📄 v8-memory-span.h(1.25 KB)
📄 v8-message.h(6.38 KB)
📄 v8-microtask-queue.h(4.79 KB)
📄 v8-microtask.h(861 B)
📄 v8-object.h(27.4 KB)
📄 v8-persistent-handle.h(18.69 KB)
📄 v8-platform.h(38.07 KB)
📄 v8-primitive-object.h(2.53 KB)
📄 v8-primitive.h(27.47 KB)
📄 v8-profiler.h(37.62 KB)
📄 v8-promise.h(5.17 KB)
📄 v8-proxy.h(1.23 KB)
📄 v8-regexp.h(3.07 KB)
📄 v8-script.h(24.77 KB)
📄 v8-snapshot.h(7.07 KB)
📄 v8-statistics.h(6.8 KB)
📄 v8-template.h(39.96 KB)
📄 v8-traced-handle.h(12.36 KB)
📄 v8-typed-array.h(8.06 KB)
📄 v8-unwinder.h(4.63 KB)
📄 v8-value-serializer.h(9.47 KB)
📄 v8-value.h(12.64 KB)
📄 v8-version.h(773 B)
📄 v8-wasm.h(7.85 KB)
📄 v8-weak-callback-info.h(2.79 KB)
📄 v8.h(3.69 KB)
📄 v8config.h(18.87 KB)
📄 zconf.h(16.77 KB)
📄 zlib.h(94.84 KB)

Editing: v8-exception.h

// 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 "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

/**
 * Create new error objects by calling the corresponding error object
 * constructor with the message.
 */
class V8_EXPORT Exception {
 public:
  static Local<Value> RangeError(Local<String> message);
  static Local<Value> ReferenceError(Local<String> message);
  static Local<Value> SyntaxError(Local<String> message);
  static Local<Value> TypeError(Local<String> message);
  static Local<Value> WasmCompileError(Local<String> message);
  static Local<Value> WasmLinkError(Local<String> message);
  static Local<Value> WasmRuntimeError(Local<String> message);
  static Local<Value> Error(Local<String> message);

/**
   * Creates an error message for the given exception.
   * Will try to reconstruct the original stack trace from the exception value,
   * or capture the current stack trace if not available.
   */
  static Local<Message> CreateMessage(Isolate* isolate, Local<Value> exception);

/**
   * Returns the original stack trace that was captured at the creation time
   * of a given exception, or an empty handle if not available.
   */
  static Local<StackTrace> GetStackTrace(Local<Value> exception);
};

/**
 * An external exception handler.
 */
class V8_EXPORT TryCatch {
 public:
  /**
   * Creates a new try/catch block and registers it with v8.  Note that
   * all TryCatch blocks should be stack allocated because the memory
   * location itself is compared against JavaScript try/catch blocks.
   */
  explicit TryCatch(Isolate* isolate);

/**
   * Unregisters and deletes this try/catch block.
   */
  ~TryCatch();

/**
   * Returns true if an exception has been caught by this try/catch block.
   */
  bool HasCaught() const;

/**
   * For certain types of exceptions, it makes no sense to continue execution.
   *
   * If CanContinue returns false, the correct action is to perform any C++
   * cleanup needed and then return.  If CanContinue returns false and
   * HasTerminated returns true, it is possible to call
   * CancelTerminateExecution in order to continue calling into the engine.
   */
  bool CanContinue() const;

/**
   * Returns true if an exception has been caught due to script execution
   * being terminated.
   *
   * There is no JavaScript representation of an execution termination
   * exception.  Such exceptions are thrown when the TerminateExecution
   * methods are called to terminate a long-running script.
   *
   * If such an exception has been thrown, HasTerminated will return true,
   * indicating that it is possible to call CancelTerminateExecution in order
   * to continue calling into the engine.
   */
  bool HasTerminated() const;

/**
   * Throws the exception caught by this TryCatch in a way that avoids
   * it being caught again by this same TryCatch.  As with ThrowException
   * it is illegal to execute any JavaScript operations after calling
   * ReThrow; the caller must return immediately to where the exception
   * is caught.
   */
  Local<Value> ReThrow();

/**
   * Returns the exception caught by this try/catch block.  If no exception has
   * been caught an empty handle is returned.
   */
  Local<Value> Exception() const;

/**
   * Returns the .stack property of an object.  If no .stack
   * property is present an empty handle is returned.
   */
  V8_WARN_UNUSED_RESULT static MaybeLocal<Value> StackTrace(
      Local<Context> context, Local<Value> exception);

/**
   * Returns the .stack property of the thrown object.  If no .stack property is
   * present or if this try/catch block has not caught an exception, an empty
   * handle is returned.
   */
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> StackTrace(
      Local<Context> context) const;

/**
   * Returns the message associated with this exception.  If there is
   * no message associated an empty handle is returned.
   */
  Local<v8::Message> Message() const;

/**
   * Clears any exceptions that may have been caught by this try/catch block.
   * After this method has been called, HasCaught() will return false. Cancels
   * the scheduled exception if it is caught and ReThrow() is not called before.
   *
   * It is not necessary to clear a try/catch block before using it again; if
   * another exception is thrown the previously caught exception will just be
   * overwritten.  However, it is often a good idea since it makes it easier
   * to determine which operation threw a given exception.
   */
  void Reset();

/**
   * Set verbosity of the external exception handler.
   *
   * By default, exceptions that are caught by an external exception
   * handler are not reported.  Call SetVerbose with true on an
   * external exception handler to have exceptions caught by the
   * handler reported as if they were not caught.
   */
  void SetVerbose(bool value);

/**
   * Returns true if verbosity is enabled.
   */
  bool IsVerbose() const;

/**
   * Set whether or not this TryCatch should capture a Message object
   * which holds source information about where the exception
   * occurred.  True by default.
   */
  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);

/**
   * There are cases when the raw address of C++ TryCatch object cannot be
   * used for comparisons with addresses into the JS stack. The cases are:
   * 1) ARM, ARM64 and MIPS simulators which have separate JS stack.
   * 2) Address sanitizer allocates local C++ object in the heap when
   *    UseAfterReturn mode is enabled.
   * This method returns address that can be used for comparisons with
   * addresses into the JS stack. When neither simulator nor ASAN's
   * UseAfterReturn is enabled, then the address returned will be the address
   * of the C++ try catch handler itself.
   */
  internal::Address JSStackComparableAddressPrivate() {
    return js_stack_comparable_address_;
  }

void ResetInternal();

internal::Isolate* 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;
  bool has_terminated_ : 1;

friend class internal::Isolate;
  friend class internal::ThreadLocalTop;
};

}  // namespace v8

#endif  // INCLUDE_V8_EXCEPTION_H_

X7ROOT File Manager

Editing: v8-exception.h

Upload File

Create Folder