Update gitignore (sorry)

electron/node_modules/lzma-native/src/util.cpp

@@ -0,0 +1,140 @@
+#include "liblzma-node.hpp"
+#include <cstring>
+
+namespace lzma {
+
+lzma_vli FilterByName(Value name) {
+  std::string cpp_string(name.ToString());
+
+  struct SearchEntry {
+    const char* str;
+    lzma_vli value;
+  };
+
+  static const struct SearchEntry search[] = {
+    { "LZMA_FILTER_X86", LZMA_FILTER_X86 },
+    { "LZMA_FILTER_POWERPC", LZMA_FILTER_POWERPC },
+    { "LZMA_FILTER_IA64", LZMA_FILTER_IA64 },
+    { "LZMA_FILTER_ARM", LZMA_FILTER_ARM },
+    { "LZMA_FILTER_ARMTHUMB", LZMA_FILTER_ARMTHUMB },
+    { "LZMA_FILTER_SPARC", LZMA_FILTER_SPARC },
+    { "LZMA_FILTER_DELTA", LZMA_FILTER_DELTA },
+    { "LZMA_FILTER_LZMA1", LZMA_FILTER_LZMA1 },
+    { "LZMA_FILTER_LZMA2", LZMA_FILTER_LZMA2 },
+    { "LZMA_FILTERS_MAX", LZMA_FILTERS_MAX },
+    { "LZMA_VLI_UNKNOWN", LZMA_VLI_UNKNOWN }
+  };
+
+  for (const struct SearchEntry* p = search; ; ++p)
+    if (p->value == LZMA_VLI_UNKNOWN || cpp_string == p->str)
+      return p->value;
+}
+
+Error lzmaRetError(Env env, lzma_ret rv) {
+  struct ErrorInfo {
+    lzma_ret code;
+    const char* name;
+    const char* desc;
+  };
+
+  /* description strings taken from liblzma/…/api/base.h */
+  static const struct ErrorInfo searchErrorInfo[] = {
+    { LZMA_OK,                "LZMA_OK", "Operation completed successfully" },
+    { LZMA_STREAM_END,        "LZMA_STREAM_END", "End of stream was reached" },
+    { LZMA_NO_CHECK,          "LZMA_NO_CHECK", "Input stream has no integrity check" },
+    { LZMA_UNSUPPORTED_CHECK, "LZMA_UNSUPPORTED_CHECK", "Cannot calculate the integrity check" },
+    { LZMA_GET_CHECK,         "LZMA_GET_CHECK", "Integrity check type is now available" },
+    { LZMA_MEM_ERROR,         "LZMA_MEM_ERROR", "Cannot allocate memory" },
+    { LZMA_MEMLIMIT_ERROR,    "LZMA_MEMLIMIT_ERROR", "Memory usage limit was reached" },
+    { LZMA_FORMAT_ERROR,      "LZMA_FORMAT_ERROR", "File format not recognized" },
+    { LZMA_OPTIONS_ERROR,     "LZMA_OPTIONS_ERROR", "Invalid or unsupported options" },
+    { LZMA_DATA_ERROR,        "LZMA_DATA_ERROR", "Data is corrupt" },
+    { LZMA_PROG_ERROR,        "LZMA_PROG_ERROR", "Programming error" },
+    { LZMA_BUF_ERROR,         "LZMA_BUF_ERROR", "No progress is possible" },
+    { (lzma_ret)-1,           "LZMA_UNKNOWN_ERROR", "Unknown error code" }
+  };
+
+  const struct ErrorInfo* p = searchErrorInfo;
+  while (p->code != rv && p->code != (lzma_ret)-1)
+    ++p;
+
+  Error err = Error::New(env, p->desc);
+  err.Set("code", Number::New(env, rv));
+  err.Set("name", String::New(env, p->name));
+  err.Set("desc", String::New(env, p->desc));
+
+  return err;
+}
+
+Number lzmaRet(Env env, lzma_ret rv) {
+  if (rv != LZMA_OK && rv != LZMA_STREAM_END)
+    throw lzmaRetError(env, rv);
+
+  return Number::New(env, rv);
+}
+
+bool readBufferFromObj(Value buf_, std::vector<uint8_t>* data) {
+  if (!buf_.IsTypedArray()) {
+    throw TypeError::New(buf_.Env(), "Expected Buffer as input");
+    return false;
+  }
+
+  TypedArray buf = buf_.As<TypedArray>();
+  size_t len = buf.ByteLength();
+  const uint8_t* ptr = len > 0 ?
+      static_cast<const uint8_t*>(buf.ArrayBuffer().Data()) + buf.ByteOffset() :
+      reinterpret_cast<const uint8_t*>("");
+
+  *data = std::vector<uint8_t>(ptr, ptr + len);
+
+  return true;
+}
+
+lzma_options_lzma parseOptionsLZMA (Value val) {
+  HandleScope scope(val.Env());
+  Object obj = val.IsUndefined() || val.IsNull() ?
+      Object::New(val.Env()) : val.ToObject();
+
+  lzma_options_lzma r;
+  r.dict_size = GetIntegerProperty(obj, "dictSize", LZMA_DICT_SIZE_DEFAULT);
+  r.lp = GetIntegerProperty(obj, "lp", LZMA_LP_DEFAULT);
+  r.lc = GetIntegerProperty(obj, "lc", LZMA_LC_DEFAULT);
+  r.pb = GetIntegerProperty(obj, "pb", LZMA_PB_DEFAULT);
+  r.mode = (lzma_mode)GetIntegerProperty(obj, "mode", (int64_t)LZMA_MODE_FAST);
+  r.nice_len = GetIntegerProperty(obj, "niceLen", 64);
+  r.mf = (lzma_match_finder)GetIntegerProperty(obj, "mf", (int64_t)LZMA_MF_HC4);
+  r.depth = GetIntegerProperty(obj, "depth", 0);
+  uint64_t preset_ = GetIntegerProperty(obj, "preset", UINT64_MAX);
+
+  r.preset_dict = nullptr;
+
+  if (preset_ != UINT64_MAX)
+    lzma_lzma_preset(&r, preset_);
+
+  return r;
+}
+
+Value Uint64ToNumberMaxNull(Env env, uint64_t in) {
+  if (in == UINT64_MAX)
+    return env.Null();
+  else
+    return Number::New(env, in);
+}
+
+Value Uint64ToNumber0Null(Env env, uint64_t in) {
+  if (in == 0)
+    return env.Null();
+  else
+    return Number::New(env, in);
+}
+
+uint64_t NumberToUint64ClampNullMax(Value in) {
+  if (in.IsNull() || in.IsUndefined())
+    return UINT64_MAX;
+
+  Number n = in.ToNumber();
+
+  return n.Int64Value();
+}
+
+}