CaDiCaL::File Class Reference

#include <file.hpp>

Public Member Functions
bool	piping ()
	~File ()
int	get ()
bool	put (char ch)
bool	endl ()
bool	put (unsigned char ch)
bool	put (const char *s)
bool	put (int lit)
bool	put (int64_t l)
bool	put (uint64_t l)
const char *	name () const
uint64_t	lineno () const
uint64_t	bytes () const
void	connect_internal (Internal *i)
bool	closed ()
void	close (bool print=false)
void	flush ()

Static Public Member Functions
static char *	find_program (const char *prg)
static bool	exists (const char *path)
static bool	writable (const char *path)
static size_t	size (const char *path)
static bool	match (Internal *, const char *path, const int *sig)
static File *	read (Internal *, FILE *f, const char *name)
static File *	read (Internal *, const char *path)
static File *	write (Internal *, FILE *, const char *name)
static File *	write (Internal *, const char *path)

Detailed Description

Definition at line 42 of file file.hpp.

Constructor & Destructor Documentation

~File()

CaDiCaL::File::~File

(

)

Definition at line 519 of file cadical_file.cpp.

             {
  if (file)
    close ();
  free (_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

bytes()

uint64_t CaDiCaL::File::bytes ( ) const

inline

Definition at line 208 of file file.hpp.

{ return _bytes; }

Here is the caller graph for this function:

close()

void CaDiCaL::File::close

(

bool

print = false

)

Definition at line 442 of file cadical_file.cpp.

                            {
  CADICAL_assert (file);
#ifndef CADICAL_QUIET
  if (internal->opts.quiet)
    print = false;
  else if (internal->opts.verbose > 0)
    print = true;
#endif
  if (close_file == 0) {
    if (print)
      MSG ("disconnecting from '%s'", name ());
  }
  if (close_file == 1) {
    if (print)
      MSG ("closing file '%s'", name ());
    fclose (file);
  }
  if (close_file == 2) {
    if (print)
      MSG ("closing input pipe to read '%s'", name ());
    pclose (file);
  }
#ifndef _WIN32
  if (close_file == 3) {
    if (print)
      MSG ("closing output pipe to write '%s'", name ());
    fclose (file);
    waitpid (child_pid, 0, 0);
#if defined(__APPLE__) || defined(__MACH__)
    compressed_file_writing_mutex.unlock ();
#endif
  }
#endif
  file = 0; // mark as closed
 
  // TODO what about error checking for 'fclose', 'pclose' or 'waitpid'?
 
#ifndef CADICAL_QUIET
  if (print) {
    if (writing) {
      uint64_t written_bytes = bytes ();
      double written_mb = written_bytes / (double) (1 << 20);
      MSG ("after writing %" PRIu64 " bytes %.1f MB", written_bytes,
           written_mb);
      if (close_file == 3) {
        size_t actual_bytes = size (name ());
        if (actual_bytes) {
          double actual_mb = actual_bytes / (double) (1 << 20);
          MSG ("deflated to %zd bytes %.1f MB", actual_bytes, actual_mb);
          MSG ("factor %.2f (%.2f%% compression)",
               relative (written_bytes, actual_bytes),
               percent (actual_bytes, written_bytes));
        } else
          MSG ("but could not determine actual size of written file");
      }
    } else {
      uint64_t read_bytes = bytes ();
      double read_mb = read_bytes / (double) (1 << 20);
      MSG ("after reading %" PRIu64 " bytes %.1f MB", read_bytes, read_mb);
      if (close_file == 2) {
        size_t actual_bytes = size (name ());
        double actual_mb = actual_bytes / (double) (1 << 20);
        MSG ("inflated from %zd bytes %.1f MB", actual_bytes, actual_mb);
        MSG ("factor %.2f (%.2f%% compression)",
             relative (read_bytes, actual_bytes),
             percent (actual_bytes, read_bytes));
      }
    }
  }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

closed()

bool CaDiCaL::File::closed ( )

inline

Definition at line 211 of file file.hpp.

{ return !file; }

connect_internal()

void CaDiCaL::File::connect_internal ( Internal * i )

inline

Definition at line 210 of file file.hpp.

{ internal = i; }

endl()

bool CaDiCaL::File::endl ( )

inline

Definition at line 124 of file file.hpp.

{ return put ('\n'); }

Here is the call graph for this function:

exists()

bool CaDiCaL::File::exists ( const char * path )

static

Definition at line 76 of file cadical_file.cpp.

                                   {
  struct stat buf;
  if (stat (path, &buf))
    return false;
  if (access (path, R_OK))
    return false;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_program()

char * CaDiCaL::File::find_program ( const char * prg )

static

Definition at line 176 of file cadical_file.cpp.

                                         {
  size_t prglen = strlen (prg);
  const char *c = getenv ("PATH");
  if (!c)
    return 0;
  size_t len = strlen (c);
  char *e = new char[len + 1];
  strcpy (e, c);
  char *res = 0;
  for (char *p = e, *q; !res && p < e + len; p = q) {
    for (q = p; *q && *q != ':'; q++)
      ;
    *q++ = 0;
    size_t pathlen = (q - p) + prglen;
    char *path = new char[pathlen + 1];
    snprintf (path, pathlen + 1, "%s/%s", p, prg);
    CADICAL_assert (strlen (path) == pathlen);
    if (exists (path))
      res = path;
    else
      delete[] path;
  }
  delete[] e;
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

flush()

void CaDiCaL::File::flush

(

)

Definition at line 514 of file cadical_file.cpp.

                  {
  CADICAL_assert (file);
  fflush (file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get()

int CaDiCaL::File::get ( )

inline

Definition at line 106 of file file.hpp.

             {
    CADICAL_assert (!writing);
    int res = cadical_getc_unlocked (file);
    if (res == '\n')
      _lineno++;
    if (res != EOF)
      _bytes++;
    return res;
  }

lineno()

uint64_t CaDiCaL::File::lineno ( ) const

inline

Definition at line 207 of file file.hpp.

{ return _lineno; }

match()

bool CaDiCaL::File::match ( Internal * internal, const char * path, const int * sig )

static

Definition at line 150 of file cadical_file.cpp.

                                                                      {
  CADICAL_assert (path);
  FILE *tmp = fopen (path, "r");
  if (!tmp) {
    WARNING ("failed to open '%s' to check signature", path);
    return false;
  }
  bool res = true;
  for (const int *p = sig; res && (*p != EOF); p++)
    res = (cadical_getc_unlocked (tmp) == *p);
  fclose (tmp);
  if (!res)
    WARNING ("file type signature check for '%s' failed", path);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

name()

const char * CaDiCaL::File::name ( ) const

inline

Definition at line 206 of file file.hpp.

{ return _name; }

Here is the caller graph for this function:

piping()

bool CaDiCaL::File::piping

(

)

Definition at line 128 of file cadical_file.cpp.

                   {
  struct stat stat;
  int fd = fileno (file);
  if (fstat (fd, &stat))
    return true;
  return S_ISFIFO (stat.st_mode);
}

Here is the call graph for this function:

Here is the caller graph for this function:

put() [1/6]

bool CaDiCaL::File::put ( char ch )

inline

Definition at line 116 of file file.hpp.

                     {
    CADICAL_assert (writing);
    if (cadical_putc_unlocked (ch, file) == EOF)
      return false;
    _bytes++;
    return true;
  }

Here is the caller graph for this function:

put() [2/6]

bool CaDiCaL::File::put ( const char * s )

inline

Definition at line 134 of file file.hpp.

                           {
    for (const char *p = s; *p; p++)
      if (!put (*p))
        return false;
    return true;
  }

Here is the call graph for this function:

put() [3/6]

bool CaDiCaL::File::put ( int lit )

inline

Definition at line 141 of file file.hpp.

                     {
    CADICAL_assert (writing);
    if (!lit)
      return put ('0');
    else if (lit == -2147483648) {
      CADICAL_assert (lit == INT_MIN);
      return put ("-2147483648");
    } else {
      char buffer[11];
      int i = sizeof buffer;
      buffer[--i] = 0;
      CADICAL_assert (lit != INT_MIN);
      unsigned idx = abs (lit);
      while (idx) {
        CADICAL_assert (i > 0);
        buffer[--i] = '0' + idx % 10;
        idx /= 10;
      }
      if (lit < 0 && !put ('-'))
        return false;
      return put (buffer + i);
    }
  }

Here is the call graph for this function:

put() [4/6]

bool CaDiCaL::File::put ( int64_t l )

inline

Definition at line 165 of file file.hpp.

                       {
    CADICAL_assert (writing);
    if (!l)
      return put ('0');
    else if (l == INT64_MIN) {
      CADICAL_assert (sizeof l == 8);
      return put ("-9223372036854775808");
    } else {
      char buffer[21];
      int i = sizeof buffer;
      buffer[--i] = 0;
      CADICAL_assert (l != INT64_MIN);
      uint64_t k = l < 0 ? -l : l;
      while (k) {
        CADICAL_assert (i > 0);
        buffer[--i] = '0' + k % 10;
        k /= 10;
      }
      if (l < 0 && !put ('-'))
        return false;
      return put (buffer + i);
    }
  }

Here is the call graph for this function:

put() [5/6]

bool CaDiCaL::File::put ( uint64_t l )

inline

Definition at line 189 of file file.hpp.

                        {
    CADICAL_assert (writing);
    if (!l)
      return put ('0');
    else {
      char buffer[22];
      int i = sizeof buffer;
      buffer[--i] = 0;
      while (l) {
        CADICAL_assert (i > 0);
        buffer[--i] = '0' + l % 10;
        l /= 10;
      }
      return put (buffer + i);
    }
  }

Here is the call graph for this function:

put() [6/6]

bool CaDiCaL::File::put ( unsigned char ch )

inline

Definition at line 126 of file file.hpp.

                              {
    CADICAL_assert (writing);
    if (cadical_putc_unlocked (ch, file) == EOF)
      return false;
    _bytes++;
    return true;
  }

read() [1/2]

File * CaDiCaL::File::read ( Internal * internal, const char * path )

static

Definition at line 385 of file cadical_file.cpp.

                                                      {
  FILE *file;
  int close_input = 2;
  if (has_suffix (path, ".xz")) {
    file = read_pipe (internal, "xz -c -d %s", xzsig, path);
    if (!file)
      goto READ_FILE;
  } else if (has_suffix (path, ".lzma")) {
    file = read_pipe (internal, "lzma -c -d %s", lzmasig, path);
    if (!file)
      goto READ_FILE;
  } else if (has_suffix (path, ".bz2")) {
    file = read_pipe (internal, "bzip2 -c -d %s", bz2sig, path);
    if (!file)
      goto READ_FILE;
  } else if (has_suffix (path, ".gz")) {
    file = read_pipe (internal, "gzip -c -d %s", gzsig, path);
    if (!file)
      goto READ_FILE;
  } else if (has_suffix (path, ".7z")) {
    file = read_pipe (internal, "7z x -so %s 2>/dev/null", sig7z, path);
    if (!file)
      goto READ_FILE;
  } else {
  READ_FILE:
    file = read_file (internal, path);
    close_input = 1;
  }
 
  if (!file)
    return 0;
 
  return new File (internal, false, close_input, 0, file, path);
}

Here is the call graph for this function:

read() [2/2]

File * CaDiCaL::File::read ( Internal * internal, FILE * f, const char * name )

static

Definition at line 377 of file cadical_file.cpp.

                                                            {
  return new File (internal, false, 0, 0, f, n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

size()

size_t CaDiCaL::File::size ( const char * path )

static

Definition at line 166 of file cadical_file.cpp.

                                   {
  struct stat buf;
  if (stat (path, &buf))
    return 0;
  return (size_t) buf.st_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

writable()

bool CaDiCaL::File::writable ( const char * path )

static

Definition at line 85 of file cadical_file.cpp.

                                     {
  int res;
  if (!path)
    res = 1;
  else if (!strcmp (path, "/dev/null"))
    res = 0;
  else {
    if (!*path)
      res = 2;
    else {
      struct stat buf;
      const char *p = strrchr (path, '/');
      if (!p) {
        if (stat (path, &buf))
          res = ((errno == ENOENT) ? 0 : -2);
        else if (S_ISDIR (buf.st_mode))
          res = 3;
        else
          res = (access (path, W_OK) ? 4 : 0);
      } else if (!p[1])
        res = 5;
      else {
        size_t len = p - path;
        char *dirname = new char[len + 1];
        strncpy (dirname, path, len);
        dirname[len] = 0;
        if (stat (dirname, &buf))
          res = 6;
        else if (!S_ISDIR (buf.st_mode))
          res = 7;
        else if (access (dirname, W_OK))
          res = 8;
        else if (stat (path, &buf))
          res = (errno == ENOENT) ? 0 : -3;
        else
          res = access (path, W_OK) ? 9 : 0;
        delete[] dirname;
      }
    }
  }
  return !res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

write() [1/2]

File * CaDiCaL::File::write ( Internal * internal, const char * path )

static

Definition at line 420 of file cadical_file.cpp.

                                                       {
  FILE *file;
  int close_output = 3, child_pid = 0;
#ifndef _WIN32
  if (has_suffix (path, ".xz"))
    file = write_pipe (internal, "xz -c", path, child_pid);
  else if (has_suffix (path, ".bz2"))
    file = write_pipe (internal, "bzip2 -c", path, child_pid);
  else if (has_suffix (path, ".gz"))
    file = write_pipe (internal, "gzip -c", path, child_pid);
  else if (has_suffix (path, ".7z"))
    file = write_pipe (internal, "7z a -an -txz -si -so", path, child_pid);
  else
#endif
    file = write_file (internal, path), close_output = 1;
 
  if (!file)
    return 0;
 
  return new File (internal, true, close_output, child_pid, file, path);
}

Here is the call graph for this function:

write() [2/2]

File * CaDiCaL::File::write ( Internal * internal, FILE * f, const char * name )

static

Definition at line 381 of file cadical_file.cpp.

                                                             {
  return new File (internal, true, 0, 0, f, n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• src/sat/cadical/file.hpp
• src/sat/cadical/cadical_file.cpp