@encharm/cws 4.0.2 → 4.3.0

package/src/headers/10/node_options.h

@@ -1,397 +0,0 @@
-#ifndef SRC_NODE_OPTIONS_H_
-#define SRC_NODE_OPTIONS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <string>
-#include <vector>
-#include <unordered_map>
-#include <memory>
-#include "node_constants.h"
-
-namespace node {
-
-struct HostPort {
-  std::string host_name;
-  int port;
-
-  void Update(const HostPort& other) {
-    if (!other.host_name.empty()) host_name = other.host_name;
-    if (other.port >= 0) port = other.port;
-  }
-};
-
-class Options {
- public:
-  virtual void CheckOptions(std::vector<std::string>* errors) {}
-  virtual ~Options() {}
-};
-
-// These options are currently essentially per-Environment, but it can be nice
-// to keep them separate since they are a group of options applying to a very
-// specific part of Node. It might also make more sense for them to be
-// per-Isolate, rather than per-Environment.
-class DebugOptions : public Options {
- public:
-  bool inspector_enabled = false;
-  bool deprecated_debug = false;
-  bool break_first_line = false;
-  bool break_node_first_line = false;
-  HostPort host_port = {"127.0.0.1", -1};
-  enum { kDefaultInspectorPort = 9229 };
-
-  bool deprecated_invocation() const {
-    return deprecated_debug &&
-      inspector_enabled &&
-      break_first_line;
-  }
-
-  bool invalid_invocation() const {
-    return deprecated_debug && !inspector_enabled;
-  }
-
-  bool wait_for_connect() const {
-    return break_first_line || break_node_first_line;
-  }
-
-  const std::string& host() {
-    return host_port.host_name;
-  }
-
-  int port() {
-    return host_port.port < 0 ? kDefaultInspectorPort : host_port.port;
-  }
-};
-
-class EnvironmentOptions : public Options {
- public:
-  std::shared_ptr<DebugOptions> debug_options { new DebugOptions() };
-  bool abort_on_uncaught_exception = false;
-  bool experimental_modules = false;
-  bool experimental_repl_await = false;
-  bool experimental_vm_modules = false;
-  bool experimental_worker = false;
-  bool expose_internals = false;
-  bool no_deprecation = false;
-  bool no_force_async_hooks_checks = false;
-  bool no_warnings = false;
-  bool pending_deprecation = false;
-  bool preserve_symlinks = false;
-  bool preserve_symlinks_main = false;
-  bool prof_process = false;
-  std::string redirect_warnings;
-  bool throw_deprecation = false;
-  bool trace_deprecation = false;
-  bool trace_sync_io = false;
-  bool trace_warnings = false;
-  std::string unhandled_rejections;
-  std::string userland_loader;
-
-  bool syntax_check_only = false;
-  bool has_eval_string = false;
-  std::string eval_string;
-  bool print_eval = false;
-  bool force_repl = false;
-
-  bool insecure_http_parser = false;
-  bool tls_min_v1_0 = false;
-  bool tls_min_v1_1 = false;
-  bool tls_min_v1_2 = false;
-  bool tls_max_v1_2 = false;
-
-  std::vector<std::string> preload_modules;
-
-  std::vector<std::string> user_argv;
-
-  inline DebugOptions* get_debug_options();
-  void CheckOptions(std::vector<std::string>* errors);
-};
-
-class PerIsolateOptions : public Options {
- public:
-  std::shared_ptr<EnvironmentOptions> per_env { new EnvironmentOptions() };
-  bool track_heap_objects = false;
-
-  inline EnvironmentOptions* get_per_env_options();
-  void CheckOptions(std::vector<std::string>* errors);
-};
-
-class PerProcessOptions : public Options {
- public:
-  std::shared_ptr<PerIsolateOptions> per_isolate { new PerIsolateOptions() };
-
-  std::string title;
-  std::string trace_event_categories;
-  std::string trace_event_file_pattern = "node_trace.${rotation}.log";
-  uint64_t max_http_header_size = 8 * 1024;
-  int64_t v8_thread_pool_size = 4;
-  bool zero_fill_all_buffers = false;
-
-  std::vector<std::string> security_reverts;
-  bool print_bash_completion = false;
-  bool print_help = false;
-  bool print_v8_help = false;
-  bool print_version = false;
-
-#ifdef NODE_HAVE_I18N_SUPPORT
-  std::string icu_data_dir;
-#endif
-
-  // TODO(addaleax): Some of these could probably be per-Environment.
-#if HAVE_OPENSSL
-  std::string openssl_config;
-  std::string tls_cipher_list = DEFAULT_CIPHER_LIST_CORE;
-#ifdef NODE_OPENSSL_CERT_STORE
-  bool ssl_openssl_cert_store = true;
-#else
-  bool ssl_openssl_cert_store = false;
-#endif
-  bool use_openssl_ca = false;
-  bool use_bundled_ca = false;
-#if NODE_FIPS_MODE
-  bool enable_fips_crypto = false;
-  bool force_fips_crypto = false;
-#endif
-#endif
-
-  inline PerIsolateOptions* get_per_isolate_options();
-  void CheckOptions(std::vector<std::string>* errors);
-};
-
-// The actual options parser, as opposed to the structs containing them:
-
-namespace options_parser {
-
-HostPort SplitHostPort(const std::string& arg,
-    std::vector<std::string>* errors);
-void GetOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-enum OptionEnvvarSettings {
-  kAllowedInEnvironment,
-  kDisallowedInEnvironment
-};
-
-enum OptionType {
-  kNoOp,
-  kV8Option,
-  kBoolean,
-  kInteger,
-  kUInteger,
-  kString,
-  kHostPort,
-  kStringList,
-};
-
-template <typename Options>
-class OptionsParser {
- public:
-  virtual ~OptionsParser() {}
-
-  typedef Options TargetType;
-
-  struct NoOp {};
-  struct V8Option {};
-
-  // These methods add a single option to the parser. Optionally, it can be
-  // specified whether the option should be allowed from environment variable
-  // sources (i.e. NODE_OPTIONS).
-  void AddOption(const char* name,
-                 const char* help_text,
-                 bool Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 uint64_t Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 int64_t Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 std::string Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 std::vector<std::string> Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 HostPort Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 NoOp no_op_tag,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 V8Option v8_option_tag,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-
-  // Adds aliases. An alias can be of the form "--option-a" -> "--option-b",
-  // or have a more complex group expansion, like
-  //   "--option-a" -> { "--option-b", "--harmony-foobar", "--eval", "42" }
-  // If `from` has the form "--option-a=", the alias will only be expanded if
-  // the option is presented in that form (i.e. with a '=').
-  // If `from` has the form "--option-a <arg>", the alias will only be expanded
-  // if the option has a non-option argument (not starting with -) following it.
-  void AddAlias(const char* from, const char* to);
-  void AddAlias(const char* from, const std::vector<std::string>& to);
-  void AddAlias(const char* from,
-                const std::initializer_list<std::string>& to);
-
-  // Add implications from some arbitrary option to a boolean one, either
-  // in a way that makes `from` set `to` to true or to false.
-  void Implies(const char* from, const char* to);
-  void ImpliesNot(const char* from, const char* to);
-
-  // Insert options from another options parser into this one, along with
-  // a method that yields the target options type from this parser's options
-  // type.
-  template <typename ChildOptions>
-  void Insert(OptionsParser<ChildOptions>* child_options_parser,
-              ChildOptions* (Options::* get_child)());
-
-  // Parse a sequence of options into an options struct, a list of
-  // arguments that were parsed as options, a list of unknown/JS engine options,
-  // and leave the remainder in the input `args` vector.
-  //
-  // For example, an `args` input of
-  //
-  //   node --foo --harmony-bar --fizzle=42 -- /path/to/cow moo
-  //
-  // expands as
-  //
-  // - `args` -> { "node", "/path/to/cow", "moo" }
-  // - `exec_args` -> { "--foo", "--harmony-bar", "--fizzle=42" }
-  // - `v8_args` -> `{ "node", "--harmony-bar" }
-  // - `options->foo == true`, `options->fizzle == 42`.
-  //
-  // If `*error` is set, the result of the parsing should be discarded and the
-  // contents of any of the argument vectors should be considered undefined.
-  virtual void Parse(std::vector<std::string>* const args,
-                     std::vector<std::string>* const exec_args,
-                     std::vector<std::string>* const v8_args,
-                     Options* const options,
-                     OptionEnvvarSettings required_env_settings,
-                     std::vector<std::string>* const errors);
-
- private:
-  // We support the wide variety of different option types by remembering
-  // how to access them, given a certain `Options` struct.
-
-  // Represents a field within `Options`.
-  class BaseOptionField {
-   public:
-    virtual ~BaseOptionField() {}
-    virtual void* LookupImpl(Options* options) const = 0;
-  };
-
-  // Represents a field of type T within `Options`.
-  template <typename T>
-  class OptionField : public BaseOptionField {
-   public:
-    typedef T Type;
-
-    T* Lookup(Options* options) const {
-      return static_cast<T*>(this->LookupImpl(options));
-    }
-  };
-
-  // Represents a field of type T within `Options` that can be looked up
-  // as a C++ member field.
-  template <typename T>
-  class SimpleOptionField : public OptionField<T> {
-   public:
-    explicit SimpleOptionField(T Options::* field) : field_(field) {}
-    void* LookupImpl(Options* options) const override {
-      return static_cast<void*>(&(options->*field_));
-    }
-
-   private:
-    T Options::* field_;
-  };
-
-  template <typename T>
-  inline T* Lookup(std::shared_ptr<BaseOptionField> field,
-                   Options* options) const {
-    return std::static_pointer_cast<OptionField<T>>(field)->Lookup(options);
-  }
-
-  // An option consists of:
-  // - A type.
-  // - A way to store/access the property value.
-  // - The information of whether it may occur in an env var or not.
-  struct OptionInfo {
-    OptionType type;
-    std::shared_ptr<BaseOptionField> field;
-    OptionEnvvarSettings env_setting;
-    std::string help_text;
-  };
-
-  // An implied option is composed of the information on where to store a
-  // specific boolean value (if another specific option is encountered).
-  struct Implication {
-    std::shared_ptr<OptionField<bool>> target_field;
-    bool target_value;
-  };
-
-  // These are helpers that make `Insert()` support properties of other
-  // options structs, if we know how to access them.
-  template <typename OriginalField, typename ChildOptions>
-  static auto Convert(
-      std::shared_ptr<OriginalField> original,
-      ChildOptions* (Options::* get_child)());
-  template <typename ChildOptions>
-  static auto Convert(
-      typename OptionsParser<ChildOptions>::OptionInfo original,
-      ChildOptions* (Options::* get_child)());
-  template <typename ChildOptions>
-  static auto Convert(
-      typename OptionsParser<ChildOptions>::Implication original,
-      ChildOptions* (Options::* get_child)());
-
-  std::unordered_map<std::string, OptionInfo> options_;
-  std::unordered_map<std::string, std::vector<std::string>> aliases_;
-  std::unordered_multimap<std::string, Implication> implications_;
-
-  template <typename OtherOptions>
-  friend class OptionsParser;
-
-  friend void GetOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
-};
-
-class DebugOptionsParser : public OptionsParser<DebugOptions> {
- public:
-  DebugOptionsParser();
-
-  static DebugOptionsParser instance;
-};
-
-class EnvironmentOptionsParser : public OptionsParser<EnvironmentOptions> {
- public:
-  EnvironmentOptionsParser();
-
-  static EnvironmentOptionsParser instance;
-};
-
-class PerIsolateOptionsParser : public OptionsParser<PerIsolateOptions> {
- public:
-  PerIsolateOptionsParser();
-
-  static PerIsolateOptionsParser instance;
-};
-
-class PerProcessOptionsParser : public OptionsParser<PerProcessOptions> {
- public:
-  PerProcessOptionsParser();
-
-  static PerProcessOptionsParser instance;
-};
-
-}  // namespace options_parser
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_OPTIONS_H_

package/src/headers/10/node_perf.h

@@ -1,134 +0,0 @@
-#ifndef SRC_NODE_PERF_H_
-#define SRC_NODE_PERF_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-#include "node_internals.h"
-#include "node_perf_common.h"
-#include "env.h"
-#include "base_object-inl.h"
-
-#include "v8.h"
-#include "uv.h"
-
-#include <string>
-
-namespace node {
-namespace performance {
-
-using v8::FunctionCallbackInfo;
-using v8::GCType;
-using v8::Local;
-using v8::Object;
-using v8::Value;
-
-extern const uint64_t timeOrigin;
-
-double GetCurrentTimeInMicroseconds();
-
-static inline const char* GetPerformanceMilestoneName(
-    enum PerformanceMilestone milestone) {
-  switch (milestone) {
-#define V(name, label) case NODE_PERFORMANCE_MILESTONE_##name: return label;
-  NODE_PERFORMANCE_MILESTONES(V)
-#undef V
-    default:
-      UNREACHABLE();
-      return 0;
-  }
-}
-
-static inline PerformanceMilestone ToPerformanceMilestoneEnum(const char* str) {
-#define V(name, label)                                                        \
-  if (strcmp(str, label) == 0) return NODE_PERFORMANCE_MILESTONE_##name;
-  NODE_PERFORMANCE_MILESTONES(V)
-#undef V
-  return NODE_PERFORMANCE_MILESTONE_INVALID;
-}
-
-static inline PerformanceEntryType ToPerformanceEntryTypeEnum(
-    const char* type) {
-#define V(name, label)                                                        \
-  if (strcmp(type, label) == 0) return NODE_PERFORMANCE_ENTRY_TYPE_##name;
-  NODE_PERFORMANCE_ENTRY_TYPES(V)
-#undef V
-  return NODE_PERFORMANCE_ENTRY_TYPE_INVALID;
-}
-
-class PerformanceEntry {
- public:
-  static void Notify(Environment* env,
-                     PerformanceEntryType type,
-                     Local<Value> object);
-
-  static void New(const FunctionCallbackInfo<Value>& args);
-
-  PerformanceEntry(Environment* env,
-                   const char* name,
-                   const char* type,
-                   uint64_t startTime,
-                   uint64_t endTime) : env_(env),
-                                       name_(name),
-                                       type_(type),
-                                       startTime_(startTime),
-                                       endTime_(endTime) { }
-
-  virtual ~PerformanceEntry() { }
-
-  virtual const Local<Object> ToObject() const;
-
-  Environment* env() const { return env_; }
-
-  const std::string& name() const { return name_; }
-
-  const std::string& type() const { return type_; }
-
-  PerformanceEntryType kind() {
-    return ToPerformanceEntryTypeEnum(type().c_str());
-  }
-
-  double startTime() const { return startTimeNano() / 1e6; }
-
-  double duration() const { return durationNano() / 1e6; }
-
-  uint64_t startTimeNano() const { return startTime_ - timeOrigin; }
-
-  uint64_t durationNano() const { return endTime_ - startTime_; }
-
- private:
-  Environment* env_;
-  const std::string name_;
-  const std::string type_;
-  const uint64_t startTime_;
-  const uint64_t endTime_;
-};
-
-enum PerformanceGCKind {
-  NODE_PERFORMANCE_GC_MAJOR = GCType::kGCTypeMarkSweepCompact,
-  NODE_PERFORMANCE_GC_MINOR = GCType::kGCTypeScavenge,
-  NODE_PERFORMANCE_GC_INCREMENTAL = GCType::kGCTypeIncrementalMarking,
-  NODE_PERFORMANCE_GC_WEAKCB = GCType::kGCTypeProcessWeakCallbacks
-};
-
-class GCPerformanceEntry : public PerformanceEntry {
- public:
-  GCPerformanceEntry(Environment* env,
-                     PerformanceGCKind gckind,
-                     uint64_t startTime,
-                     uint64_t endTime) :
-                         PerformanceEntry(env, "gc", "gc", startTime, endTime),
-                         gckind_(gckind) { }
-
-  PerformanceGCKind gckind() const { return gckind_; }
-
- private:
-  PerformanceGCKind gckind_;
-};
-
-}  // namespace performance
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_PERF_H_

package/src/headers/10/node_perf_common.h

@@ -1,96 +0,0 @@
-#ifndef SRC_NODE_PERF_COMMON_H_
-#define SRC_NODE_PERF_COMMON_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-#include "v8.h"
-
-#include <algorithm>
-#include <map>
-#include <string>
-
-namespace node {
-namespace performance {
-
-#define PERFORMANCE_NOW() uv_hrtime()
-
-// These occur before the environment is created. Cache them
-// here and add them to the milestones when the env is init'd.
-extern uint64_t performance_node_start;
-extern uint64_t performance_v8_start;
-
-#define NODE_PERFORMANCE_MILESTONES(V)                                        \
-  V(ENVIRONMENT, "environment")                                               \
-  V(NODE_START, "nodeStart")                                                  \
-  V(V8_START, "v8Start")                                                      \
-  V(LOOP_START, "loopStart")                                                  \
-  V(LOOP_EXIT, "loopExit")                                                    \
-  V(BOOTSTRAP_COMPLETE, "bootstrapComplete")
-
-
-#define NODE_PERFORMANCE_ENTRY_TYPES(V)                                       \
-  V(NODE, "node")                                                             \
-  V(MARK, "mark")                                                             \
-  V(MEASURE, "measure")                                                       \
-  V(GC, "gc")                                                                 \
-  V(FUNCTION, "function")                                                     \
-  V(HTTP2, "http2")
-
-enum PerformanceMilestone {
-#define V(name, _) NODE_PERFORMANCE_MILESTONE_##name,
-  NODE_PERFORMANCE_MILESTONES(V)
-#undef V
-  NODE_PERFORMANCE_MILESTONE_INVALID
-};
-
-enum PerformanceEntryType {
-#define V(name, _) NODE_PERFORMANCE_ENTRY_TYPE_##name,
-  NODE_PERFORMANCE_ENTRY_TYPES(V)
-#undef V
-  NODE_PERFORMANCE_ENTRY_TYPE_INVALID
-};
-
-class performance_state {
- public:
-  explicit performance_state(v8::Isolate* isolate) :
-    root(
-      isolate,
-      sizeof(performance_state_internal)),
-    milestones(
-      isolate,
-      offsetof(performance_state_internal, milestones),
-      NODE_PERFORMANCE_MILESTONE_INVALID,
-      root),
-    observers(
-      isolate,
-      offsetof(performance_state_internal, observers),
-      NODE_PERFORMANCE_ENTRY_TYPE_INVALID,
-      root) {
-    for (size_t i = 0; i < milestones.Length(); i++)
-      milestones[i] = -1.;
-  }
-
-  AliasedBuffer<uint8_t, v8::Uint8Array> root;
-  AliasedBuffer<double, v8::Float64Array> milestones;
-  AliasedBuffer<uint32_t, v8::Uint32Array> observers;
-
-  uint64_t performance_last_gc_start_mark = 0;
-
-  void Mark(enum PerformanceMilestone milestone,
-            uint64_t ts = PERFORMANCE_NOW());
-
- private:
-  struct performance_state_internal {
-    // doubles first so that they are always sizeof(double)-aligned
-    double milestones[NODE_PERFORMANCE_MILESTONE_INVALID];
-    uint32_t observers[NODE_PERFORMANCE_ENTRY_TYPE_INVALID];
-  };
-};
-
-}  // namespace performance
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_PERF_COMMON_H_

package/src/headers/10/node_persistent.h

@@ -1,30 +0,0 @@
-#ifndef SRC_NODE_PERSISTENT_H_
-#define SRC_NODE_PERSISTENT_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "v8.h"
-
-namespace node {
-
-template <typename T>
-struct ResetInDestructorPersistentTraits {
-  static const bool kResetInDestructor = true;
-  template <typename S, typename M>
-  // Disallow copy semantics by leaving this unimplemented.
-  inline static void Copy(
-      const v8::Persistent<S, M>&,
-      v8::Persistent<T, ResetInDestructorPersistentTraits<T>>*);
-};
-
-// v8::Persistent does not reset the object slot in its destructor.  That is
-// acknowledged as a flaw in the V8 API and expected to change in the future
-// but for now node::Persistent is the easier and safer alternative.
-template <typename T>
-using Persistent = v8::Persistent<T, ResetInDestructorPersistentTraits<T>>;
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_PERSISTENT_H_