oh-my-devpod 0.14.2

package/runtime/vendor/zsh/powerlevel10k/gitstatus/src/arena.h

@@ -0,0 +1,273 @@
+// Copyright 2019 Roman Perepelitsa.
+//
+// This file is part of GitStatus.
+//
+// GitStatus is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// GitStatus is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with GitStatus. If not, see <https://www.gnu.org/licenses/>.
+
+#ifndef ROMKATV_GITSTATUS_ARENA_H_
+#define ROMKATV_GITSTATUS_ARENA_H_
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <new>
+#include <type_traits>
+#include <vector>
+
+#include "string_view.h"
+
+namespace gitstatus {
+
+// Thread-compatible. Very fast and very flexible w.r.t. allocation size and alignment.
+//
+// Natural API extensions:
+//
+//   // Donates a block to the arena. When the time comes, it'll be freed with
+//   // free(p, size, userdata).
+//   void Donate(void* p, size_t size, void* userdata, void(*free)(void*, size_t, void*));
+class Arena {
+ public:
+  struct Options {
+    // The first call to Allocate() will allocate a block of this size. There is one exception when
+    // the first requested allocation size is larger than this limit. Subsequent blocks will be
+    // twice as large as the last until they saturate at max_block_size.
+    size_t min_block_size = 64;
+
+    // Allocate blocks at most this large. There is one exception when the requested allocation
+    // size is larger than this limit.
+    size_t max_block_size = 8 << 10;
+
+    // When the size of the first allocation in a block is larger than this threshold, the block
+    // size will be equal to the allocation size. This is meant to reduce memory waste when making
+    // many allocations with sizes slightly over max_block_size / 2. With max_alloc_threshold equal
+    // to max_block_size / N, the upper bound on wasted memory when making many equally-sized
+    // allocations is 100.0 / (N + 1) percent. When making allocations of different sizes, the upper
+    // bound on wasted memory is 50%.
+    size_t max_alloc_threshold = 1 << 10;
+
+    // Natural extensions:
+    //
+    //   void* userdata;
+    //   void (*alloc)(size_t size, size_t alignment, void* userdata);
+    //   void (*free)(void* p, size_t size, void* userdata);
+  };
+
+  // Requires: opt.min_block_size <= opt.max_block_size.
+  //
+  // Doesn't allocate any memory.
+  Arena(Options opt);
+  Arena() : Arena(Options()) {}
+  Arena(Arena&&);
+  ~Arena();
+
+  Arena& operator=(Arena&& other);
+
+  // Requires: alignment is a power of 2.
+  //
+  // Result is never null and always aligned. If size is zero, the result may be equal to the last.
+  // Alignment above alignof(std::max_align_t) is supported. There is no requirement for alignment
+  // to be less than size or to divide it.
+  inline void* Allocate(size_t size, size_t alignment) {
+    assert(alignment && !(alignment & (alignment - 1)));
+    uintptr_t p = Align(top_->tip, alignment);
+    uintptr_t e = p + size;
+    if (e <= top_->end) {
+      top_->tip = e;
+      return reinterpret_cast<void*>(p);
+    }
+    return AllocateSlow(size, alignment);
+  }
+
+  template <class T>
+  inline T* Allocate(size_t n) {
+    static_assert(!std::is_reference<T>(), "");
+    return static_cast<T*>(Allocate(n * sizeof(T), alignof(T)));
+  }
+
+  template <class T>
+  inline T* Allocate() {
+    return Allocate<T>(1);
+  }
+
+  inline char* MemDup(const char* p, size_t len) {
+    char* res = Allocate<char>(len);
+    std::memcpy(res, p, len);
+    return res;
+  }
+
+  // Copies the null-terminated string (including the trailing null character) to the arena and
+  // returns a pointer to the copy.
+  inline char* StrDup(const char* s) {
+    size_t len = std::strlen(s);
+    return MemDup(s, len + 1);
+  }
+
+  // Guarantees: !StrDup(p, len)[len].
+  inline char* StrDup(const char* p, size_t len) {
+    char* res = Allocate<char>(len + 1);
+    std::memcpy(res, p, len);
+    res[len] = 0;
+    return res;
+  }
+
+  // Guarantees: !StrDup(s)[s.len].
+  inline char* StrDup(StringView s) {
+    return StrDup(s.ptr, s.len);
+  }
+
+  template <class... Ts>
+  inline char* StrCat(const Ts&... ts) {
+    return [&](std::initializer_list<StringView> ss) {
+      size_t len = 0;
+      for (StringView s : ss) len += s.len;
+      char* p = Allocate<char>(len + 1);
+      for (StringView s : ss) {
+        std::memcpy(p, s.ptr, s.len);
+        p += s.len;
+      }
+      *p = 0;
+      return p - len;
+    }({ts...});
+  }
+
+  // Copies/moves `val` to the arena and returns a pointer to it.
+  template <class T>
+  inline std::remove_const_t<std::remove_reference_t<T>>* Dup(T&& val) {
+    return DirectInit<std::remove_const_t<std::remove_reference_t<T>>>(std::forward<T>(val));
+  }
+
+  // The same as `new T{args...}` but on the arena.
+  template <class T, class... Args>
+  inline T* DirectInit(Args&&... args) {
+    T* res = Allocate<T>();
+    ::new (const_cast<void*>(static_cast<const void*>(res))) T(std::forward<Args>(args)...);
+    return res;
+  }
+
+  // The same as `new T(args...)` but on the arena.
+  template <class T, class... Args>
+  inline T* BraceInit(Args&&... args) {
+    T* res = Allocate<T>();
+    ::new (const_cast<void*>(static_cast<const void*>(res))) T{std::forward<Args>(args)...};
+    return res;
+  }
+
+  // Tip() and TipSize() allow you to allocate the remainder of the current block. They can be
+  // useful if you are flexible w.r.t. the allocation size.
+  //
+  // Invariant:
+  //
+  //   const void* tip = Tip();
+  //   void* p = Allocate(TipSize(), 1);  // grab the remainder of the current block
+  //   assert(p == tip);
+  const void* Tip() const { return reinterpret_cast<const void*>(top_->tip); }
+  size_t TipSize() const { return top_->end - top_->tip; }
+
+  // Invalidates all allocations (without running destructors of allocated objects) and frees all
+  // blocks except at most the specified number of blocks. The retained blocks will be used to
+  // fulfil future allocation requests.
+  void Reuse(size_t num_blocks = std::numeric_limits<size_t>::max());
+
+ private:
+  struct Block {
+    size_t size() const { return end - start; }
+    uintptr_t start;
+    uintptr_t tip;
+    uintptr_t end;
+  };
+
+  inline static size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); };
+
+  void AddBlock(size_t size, size_t alignment);
+  bool ReuseBlock(size_t size, size_t alignment);
+
+  __attribute__((noinline)) void* AllocateSlow(size_t size, size_t alignment);
+
+  Options opt_;
+  std::vector<Block> blocks_;
+  // Invariant: !blocks_.empty() <= reusable_ && reusable_ <= blocks_.size().
+  size_t reusable_ = 0;
+  // Invariant: (top_ == &g_empty_block) == blocks_.empty().
+  // Invariant: blocks_.empty() || top_ == &blocks_.back() || top_ < blocks_.data() + reusable_.
+  Block* top_;
+
+  static Block g_empty_block;
+};
+
+// Copies of ArenaAllocator use the same thread-compatible Arena without synchronization.
+template <class T>
+class ArenaAllocator {
+ public:
+  using value_type = T;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+  using propagate_on_container_move_assignment = std::true_type;
+  template <class U>
+  struct rebind {
+    using other = ArenaAllocator<U>;
+  };
+  using is_always_equal = std::false_type;
+
+  ArenaAllocator(Arena* arena = nullptr) : arena_(*arena) {}
+
+  Arena& arena() const { return arena_; }
+
+  pointer address(reference x) const { return &x; }
+  const_pointer address(const_reference x) const { return &x; }
+  pointer allocate(size_type n, const void* hint = nullptr) { return arena_.Allocate<T>(n); }
+  void deallocate(T* p, std::size_t n) {}
+  size_type max_size() const { return std::numeric_limits<size_type>::max() / sizeof(value_type); }
+
+  template <class U, class... Args>
+  void construct(U* p, Args&&... args) {
+    ::new (const_cast<void*>(static_cast<const void*>(p))) U(std::forward<Args>(args)...);
+  }
+
+  template <class U>
+  void destroy(U* p) {
+    p->~U();
+  }
+
+  bool operator==(const ArenaAllocator& other) const { return &arena_ == &other.arena_; }
+  bool operator!=(const ArenaAllocator& other) const { return &arena_ != &other.arena_; }
+
+ private:
+  Arena& arena_;
+};
+
+template <class C>
+struct LazyWithArena;
+
+template <template <class, class> class C, class T1, class A>
+struct LazyWithArena<C<T1, A>> {
+  using type = C<T1, ArenaAllocator<typename C<T1, A>::value_type>>;
+};
+
+template <template <class, class, class> class C, class T1, class T2, class A>
+struct LazyWithArena<C<T1, T2, A>> {
+  using type = C<T1, T2, ArenaAllocator<typename C<T1, T2, A>::value_type>>;
+};
+
+template <class C>
+using WithArena = typename LazyWithArena<C>::type;
+
+}  // namespace gitstatus
+
+#endif  // ROMKATV_GITSTATUS_DIR_H_

package/runtime/vendor/zsh/powerlevel10k/gitstatus/src/bits.h

@@ -0,0 +1,29 @@
+// Copyright 2019 Roman Perepelitsa.
+//
+// This file is part of GitStatus.
+//
+// GitStatus is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// GitStatus is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with GitStatus. If not, see <https://www.gnu.org/licenses/>.
+
+#ifndef ROMKATV_GITSTATUS_BITS_H_
+#define ROMKATV_GITSTATUS_BITS_H_
+
+#include <cstddef>
+
+namespace gitstatus {
+
+inline size_t NextPow2(size_t n) { return n < 2 ? 1 : (~size_t{0} >> __builtin_clzll(n - 1)) + 1; }
+
+}  // namespace gitstatus
+
+#endif  // ROMKATV_GITSTATUS_BITS_H_

package/runtime/vendor/zsh/powerlevel10k/gitstatus/src/check.h

@@ -0,0 +1,61 @@
+// Copyright 2019 Roman Perepelitsa.
+//
+// This file is part of GitStatus.
+//
+// GitStatus is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// GitStatus is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with GitStatus. If not, see <https://www.gnu.org/licenses/>.
+
+#ifndef ROMKATV_GITSTATUS_CHECK_H_
+#define ROMKATV_GITSTATUS_CHECK_H_
+
+#include "logging.h"
+
+#include <stdexcept>
+
+// The argument must be an expression convertible to bool.
+// Does nothing if the expression evaluates to true. Otherwise
+// it's equivalent to LOG(FATAL).
+#define CHECK(cond...) \
+  static_cast<void>(0), (!!(cond)) ? static_cast<void>(0) : LOG(FATAL) << #cond << ": "
+
+#define VERIFY(cond...)                                               \
+  static_cast<void>(0), ::gitstatus::internal_check::Thrower(!(cond)) \
+                            ? static_cast<void>(0)                    \
+                            : LOG(ERROR) << #cond << ": "
+
+namespace gitstatus {
+
+struct Exception : std::exception {
+  const char* what() const noexcept override { return "Exception"; }
+};
+
+namespace internal_check {
+
+class Thrower {
+ public:
+  Thrower(bool should_throw) : throw_(should_throw) {}
+  Thrower(Thrower&&) = delete;
+  explicit operator bool() const { return !throw_; }
+  ~Thrower() noexcept(false) {
+    if (throw_) throw Exception();
+  }
+
+ private:
+  bool throw_;
+};
+
+}  // namespace internal_check
+
+}  // namespace gitstatus
+
+#endif  // ROMKATV_GITSTATUS_CHECK_H_

package/runtime/vendor/zsh/powerlevel10k/gitstatus/src/check_dir_mtime.cc

@@ -0,0 +1,157 @@
+// Copyright 2019 Roman Perepelitsa.
+//
+// This file is part of GitStatus.
+//
+// GitStatus is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// GitStatus is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with GitStatus. If not, see <https://www.gnu.org/licenses/>.
+
+#include "check_dir_mtime.h"
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <ctime>
+#include <string>
+#include <vector>
+
+#include "check.h"
+#include "dir.h"
+#include "logging.h"
+#include "print.h"
+#include "scope_guard.h"
+#include "stat.h"
+
+namespace gitstatus {
+
+namespace {
+
+constexpr char kDirPrefix[] = ".gitstatus.";
+
+void Touch(const char* path) {
+  int fd = creat(path, 0444);
+  VERIFY(fd >= 0) << Errno();
+  CHECK(!close(fd)) << Errno();
+}
+
+bool StatChanged(const char* path, const struct stat& prev) {
+  struct stat cur;
+  VERIFY(!lstat(path, &cur)) << Errno();
+  return !StatEq(prev, cur);
+}
+
+void RemoveStaleDirs(const char* root_dir) {
+  int dir_fd = open(root_dir, O_DIRECTORY | O_CLOEXEC);
+  if (dir_fd < 0) return;
+  ON_SCOPE_EXIT(&) { CHECK(!close(dir_fd)) << Errno(); };
+
+  Arena arena;
+  std::vector<char*> entries;
+  const std::time_t now = std::time(nullptr);
+  if (!ListDir(dir_fd, arena, entries,
+               /* precompose_unicode = */ false,
+               /* case_sensitive = */ true)) {
+    return;
+  }
+
+  std::string path = root_dir;
+  const size_t root_dir_len = path.size();
+
+  for (const char* entry : entries) {
+    if (std::strlen(entry) < std::strlen(kDirPrefix)) continue;
+    if (std::memcmp(entry, kDirPrefix, std::strlen(kDirPrefix))) continue;
+
+    struct stat st;
+    if (fstatat(dir_fd, entry, &st, AT_SYMLINK_NOFOLLOW)) {
+      LOG(WARN) << "Cannot stat " << Print(entry) << " in " << Print(root_dir) << ": " << Errno();
+      continue;
+    }
+    if (MTim(st).tv_sec + 10 > now) continue;
+
+    path.resize(root_dir_len);
+    path += entry;
+    size_t dir_len = path.size();
+
+    path += "/b/1";
+    if (unlink(path.c_str()) && errno != ENOENT) {
+      LOG(WARN) << "Cannot unlink " << Print(path) << ": " << Errno();
+      continue;
+    }
+
+    for (const char* d : {"/a/1", "/a", "/b", ""}) {
+      path.resize(dir_len);
+      path += d;
+      if (rmdir(path.c_str()) && errno != ENOENT) {
+        LOG(WARN) << "Cannot remove " << Print(path) << ": " << Errno();
+        break;
+      }
+    }
+  }
+}
+
+}  // namespace
+
+bool CheckDirMtime(const char* root_dir) {
+  try {
+    RemoveStaleDirs(root_dir);
+
+    std::string tmp = std::string() + root_dir + kDirPrefix + "XXXXXX";
+    VERIFY(mkdtemp(&tmp[0])) << Errno();
+    ON_SCOPE_EXIT(&) { rmdir(tmp.c_str()); };
+
+    std::string a_dir = tmp + "/a";
+    VERIFY(!mkdir(a_dir.c_str(), 0755)) << Errno();
+    ON_SCOPE_EXIT(&) { rmdir(a_dir.c_str()); };
+    struct stat a_st;
+    VERIFY(!lstat(a_dir.c_str(), &a_st)) << Errno();
+
+    std::string b_dir = tmp + "/b";
+    VERIFY(!mkdir(b_dir.c_str(), 0755)) << Errno();
+    ON_SCOPE_EXIT(&) { rmdir(b_dir.c_str()); };
+    struct stat b_st;
+    VERIFY(!lstat(b_dir.c_str(), &b_st)) << Errno();
+
+    while (sleep(1)) {
+      // zzzz
+    }
+
+    std::string a1 = a_dir + "/1";
+    VERIFY(!mkdir(a1.c_str(), 0755)) << Errno();
+    ON_SCOPE_EXIT(&) { rmdir(a1.c_str()); };
+    if (!StatChanged(a_dir.c_str(), a_st)) {
+      LOG(WARN) << "Creating a directory doesn't change mtime of the parent: " << Print(root_dir);
+      return false;
+    }
+
+    std::string b1 = b_dir + "/1";
+    Touch(b1.c_str());
+    ON_SCOPE_EXIT(&) { unlink(b1.c_str()); };
+    if (!StatChanged(b_dir.c_str(), b_st)) {
+      LOG(WARN) << "Creating a file doesn't change mtime of the parent: " << Print(root_dir);
+      return false;
+    }
+
+    LOG(INFO) << "All mtime checks have passes. Enabling untracked cache: " << Print(root_dir);
+    return true;
+  } catch (const Exception&) {
+    LOG(WARN) << "Error while testing for mtime capability: " << Print(root_dir);
+    return false;
+  }
+}
+
+}  // namespace gitstatus

package/runtime/vendor/zsh/powerlevel10k/gitstatus/src/check_dir_mtime.h

@@ -0,0 +1,31 @@
+// Copyright 2019 Roman Perepelitsa.
+//
+// This file is part of GitStatus.
+//
+// GitStatus is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// GitStatus is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with GitStatus. If not, see <https://www.gnu.org/licenses/>.
+
+#ifndef ROMKATV_GITSTATUS_CHECK_DIR_MTIME_H_
+#define ROMKATV_GITSTATUS_CHECK_DIR_MTIME_H_
+
+namespace gitstatus {
+
+// Similar to `git update-index --test-untracked-cache` but performs all tests
+// in parallel, so the total testing time is one second regardless of the number
+// of tests. It also performs fewer tests because gitstatus imposes fewer
+// requirements on the filesystem in order to take advantage of untracked cache.
+bool CheckDirMtime(const char* root_dir);
+
+}  // namespace gitstatus
+
+#endif  // ROMKATV_GITSTATUS_CHECK_DIR_MTIME_H_