file.h File Reference

#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "attribute.h"
#include "keatures.h"
#include "global.h"

Include dependency graph for file.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	file

Typedefs
typedef struct file	file

Functions
ABC_NAMESPACE_HEADER_START bool	kissat_file_exists (const char *path)
bool	kissat_file_readable (const char *path)
bool	kissat_file_writable (const char *path)
size_t	kissat_file_size (const char *path)
bool	kissat_find_executable (const char *name)
void	kissat_read_already_open_file (file *, FILE *, const char *path)
void	kissat_write_already_open_file (file *, FILE *, const char *path)
bool	kissat_open_to_read_file (file *, const char *path)
bool	kissat_open_to_write_file (file *, const char *path)
void	kissat_close_file (file *)
bool	kissat_looks_like_a_compressed_file (const char *path)

Typedef Documentation

file

typedef struct file file

Definition at line 21 of file file.h.

Function Documentation

kissat_close_file()

void kissat_close_file

(

file *

file

)

Definition at line 308 of file file.c.

                                    {
  KISSAT_assert (file);
  KISSAT_assert (file->file);
#ifdef KISSAT_HAS_COMPRESSION
  if (file->close && file->compressed)
    pclose (file->file);
#else
  KISSAT_assert (!file->compressed);
#endif
  if (file->close && !file->compressed)
    fclose (file->file);
  file->file = 0;
}

Here is the call graph for this function:

kissat_file_exists()

ABC_NAMESPACE_HEADER_START bool kissat_file_exists

(

const char *

path

)

Definition at line 22 of file file.c.

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

kissat_file_readable()

bool kissat_file_readable

(

const char *

path

)

Definition at line 31 of file file.c.

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

Here is the caller graph for this function:

kissat_file_size()

size_t kissat_file_size

(

const char *

path

)

Definition at line 98 of file file.c.

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

kissat_file_writable()

bool kissat_file_writable

(

const char *

path

)

Definition at line 42 of file file.c.

                                             {
  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)) {
          if (errno == ENOENT)
            res = 0;
          else
            res = -2;
        } else if (S_ISDIR (buf.st_mode))
          res = 3;
        else if (access (path, W_OK))
          res = 4;
        else
          res = 0;
      } else if (!p[1])
        res = 5;
      else {
        const size_t len = p - path;
        char *dirname = (char*)malloc (len + 1);
        if (dirname) {
          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)) {
            if (errno == ENOENT)
              res = 0;
            else
              res = -3;
          } else if (access (path, W_OK))
            res = 9;
          else
            res = 0;
          free (dirname);
        } else
          res = 10;
      }
    }
  }
  return !res;
}

Here is the call graph for this function:

kissat_find_executable()

bool kissat_find_executable

(

const char *

name

)

Definition at line 105 of file file.c.

                                               {
  const size_t name_len = strlen (name);
  const char *environment = getenv ("PATH");
  if (!environment)
    return false;
  const size_t dirs_len = strlen (environment);
  char *dirs = (char*)malloc (dirs_len + 1);
  if (!dirs)
    return false;
  strcpy (dirs, environment);
  bool res = false;
  const char *end = dirs + dirs_len + 1;
  for (char *dir = dirs, *q; !res && dir != end; dir = q) {
    for (q = dir; *q && *q != ':'; q++)
      KISSAT_assert (q + 1 < end);
    *q++ = 0;
    const size_t path_len = (q - dir) + name_len;
    char *path = (char*)malloc (path_len + 1);
    if (!path) {
      free (dirs);
      return false;
    }
    sprintf (path, "%s/%s", dir, name);
    KISSAT_assert (strlen (path) == path_len);
    res = kissat_file_readable (path);
    free (path);
  }
  free (dirs);
  return res;
}

Here is the call graph for this function:

kissat_looks_like_a_compressed_file()

bool kissat_looks_like_a_compressed_file

(

const char *

path

)

Definition at line 219 of file file.c.

                                                            {
#define RETURN_TRUE_IF_COMPRESSED(SUFFIX, SIGNATURE) \
  if (kissat_has_suffix (path, SUFFIX) && \
      match_signature (path, SIGNATURE)) \
  return true
 
  RETURN_TRUE_IF_COMPRESSED (".bz2", bz2sig);
  RETURN_TRUE_IF_COMPRESSED (".gz", gzsig);
  RETURN_TRUE_IF_COMPRESSED (".lzma", lzmasig);
  RETURN_TRUE_IF_COMPRESSED (".7z", sig7z);
  RETURN_TRUE_IF_COMPRESSED (".xz", xzsig);
  RETURN_TRUE_IF_COMPRESSED (".Z", Zsig);
 
  return false;
}

kissat_open_to_read_file()

bool kissat_open_to_read_file	(	file *	file,
		const char *	path )

Definition at line 237 of file file.c.

                                                             {
#ifdef KISSAT_HAS_COMPRESSION
#define READ_PIPE(SUFFIX, CMD, SIG) \
  do { \
    if (kissat_has_suffix (path, SUFFIX)) { \
      file->file = read_pipe (CMD, SIG, path); \
      if (!file->file) \
        break; \
      file->close = true; \
      file->reading = true; \
      file->compressed = true; \
      file->path = path; \
      file->bytes = 0; \
      return true; \
    } \
  } while (0)
  READ_PIPE (".bz2", "bzip2 -c -d %s", bz2sig);
  READ_PIPE (".gz", "gzip -c -d %s", gzsig);
  READ_PIPE (".lzma", "lzma -c -d %s", lzmasig);
  READ_PIPE (".7z", "7z x -so %s 2>/dev/null", sig7z);
  READ_PIPE (".xz", "xz -c -d %s", xzsig);
  READ_PIPE (".Z", "gzip -c -d %s", Zsig);
#endif
  file->file = fopen (path, "r");
  if (!file->file)
    return false;
  file->close = true;
  file->reading = true;
  file->compressed = false;
  file->path = path;
  file->bytes = 0;
 
  return true;
}

Here is the call graph for this function:

kissat_open_to_write_file()

bool kissat_open_to_write_file	(	file *	file,
		const char *	path )

Definition at line 272 of file file.c.

                                                              {
#if defined(KISSAT_HAS_COMPRESSION) && !defined(SAFE)
#define WRITE_PIPE(SUFFIX, CMD) \
  do { \
    if (kissat_has_suffix (path, SUFFIX)) { \
      if (SUFFIX[1] == '7' && kissat_file_readable (path) && \
          unlink (path)) \
        return false; \
      file->file = write_pipe (CMD, path); \
      if (!file->file) \
        return false; \
      file->close = true; \
      file->reading = false; \
      file->compressed = true; \
      file->path = path; \
      file->bytes = 0; \
      return true; \
    } \
  } while (0)
  WRITE_PIPE (".bz2", "bzip2 -c > %s");
  WRITE_PIPE (".gz", "gzip -c > %s");
  WRITE_PIPE (".lzma", "lzma -c > %s");
  WRITE_PIPE (".7z", "7z a -si %s 2>/dev/null");
  WRITE_PIPE (".xz", "xz -c > %s");
#endif
  file->file = fopen (path, "w");
  if (!file->file)
    return false;
  file->close = true;
  file->reading = false;
  file->compressed = false;
  file->path = path;
  file->bytes = 0;
  return true;
}

Here is the call graph for this function:

kissat_read_already_open_file()

void kissat_read_already_open_file	(	file *	file,
		FILE *	f,
		const char *	path )

Definition at line 198 of file file.c.

                                                                           {
  file->file = f;
  file->close = false;
  file->reading = true;
  file->compressed = false;
  file->path = path;
  file->bytes = 0;
}

Here is the call graph for this function:

kissat_write_already_open_file()

void kissat_write_already_open_file	(	file *	file,
		FILE *	f,
		const char *	path )

Definition at line 207 of file file.c.

                                                       {
  file->file = f;
  file->close = false;
  file->reading = false;
  file->compressed = false;
  file->path = path;
  file->bytes = 0;
}

Here is the call graph for this function: