filesystem.h

Go to the documentation of this file.

#pragma once
 
#include <cstdio> /* FILE */
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <vector>

 
namespace file_operations
{
inline constexpr const char *ESBMC_VFS_ROOT = "/esbmc-vfs";

bool is_bundled_source(std::string_view file);

class file_data
{
  std::string _owned;
  std::string_view _borrowed;
  bool _bundled = true;
 
public:
  file_data() = default;
  file_data(const file_data &) = delete;
  file_data &operator=(const file_data &) = delete;
  file_data(file_data &&) = default;
  file_data &operator=(file_data &&) = default;

  static file_data bundled(const char *data, size_t size);

  static file_data owned(std::string data);
 
  std::string_view view() const noexcept;
  size_t size() const noexcept;
  bool is_bundled() const noexcept;
};

class tmp_path
{
  std::string _path;
  int _lock_fd = -1;
 
protected:
  bool _keep = true;
 
public:
  tmp_path() = default;
  tmp_path(std::string path, bool keep = false);
  tmp_path(const tmp_path &) = delete;
  tmp_path(tmp_path &&o);
 
  ~tmp_path();
 
  tmp_path &operator=(tmp_path o);
 
  friend void swap(tmp_path &a, tmp_path &b)
  {
    using std::swap;
    swap(a._path, b._path);
    swap(a._keep, b._keep);
    swap(a._lock_fd, b._lock_fd);
  }
 
  const std::string &path() const noexcept;
 
  tmp_path &keep(bool yes) & noexcept;
  tmp_path &&keep(bool yes) && noexcept;
};

class tmp_file : public tmp_path
{
  FILE *_file;
 
public:
  tmp_file() = default;
  tmp_file(FILE *f, tmp_path path);
  tmp_file(const tmp_file &) = delete;
  tmp_file(tmp_file &&o) = default;
 
  ~tmp_file();
 
  tmp_file &operator=(tmp_file o);
 
  friend void swap(tmp_file &a, tmp_file &b)
  {
    using std::swap;
    swap(static_cast<tmp_path &>(a), static_cast<tmp_path &>(b));
    swap(a._file, b._file);
  }
 
  FILE *file() noexcept;
};

class tmp_dir_override
{
  bool _was_set;
  std::string _old;
 
public:
  explicit tmp_dir_override(const std::string &dir);
  tmp_dir_override(const tmp_dir_override &) = delete;
  tmp_dir_override &operator=(const tmp_dir_override &) = delete;
  ~tmp_dir_override();
};

const std::string get_unique_tmp_path(const std::string &format);

tmp_file create_tmp_file(
  const std::string &format = "esbmc.%%%%-%%%%-%%%%",
  const char *mode = "w+");
 
tmp_path create_tmp_dir(const std::string &format = "esbmc.%%%%-%%%%-%%%%");

void create_path_and_write(const std::string &path, const char *s, size_t n);


void register_tmp_for_cleanup(const std::string &path);
void cleanup_registered_tmps();

void register_pgroup_for_cleanup(long pgid);
void unregister_pgroup(long pgid);
void kill_registered_pgroups();
 
#ifndef _WIN32
void kill_registered_pgroups_from_signal();
void remove_registered_tmps_from_signal();
#endif

class filesystemt
{
  std::map<std::string, std::string_view> _bundled;
  std::map<std::string, tmp_path> _materialized;
 
  template <typename F>
  void for_each_under(const std::string &prefix, F &&f) const
  {
    for (auto it = _bundled.lower_bound(prefix);
         it != _bundled.end() &&
         it->first.compare(0, prefix.size(), prefix) == 0;
         ++it)
      /* Whole components only: "/x/libc" must not select "/x/libcxx/y". */
      if (it->first.size() == prefix.size() || it->first[prefix.size()] == '/')
        f(it->first, it->second);
  }
 
public:
  static filesystemt &get();

  void add_bundled(const std::string &path, const char *data, size_t size);

  std::optional<file_data> read(const std::string &path) const;
 
  bool exists(const std::string &path) const;

  bool readable(const std::string &path) const;

  size_t bundled_count() const noexcept;

  std::vector<std::string> list(const std::string &prefix) const;

  const std::string &
  materialize(const std::string &prefix, const std::string &format);
};
} // namespace file_operations