src/file_port.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : file_port.cpp
* DESCRIPTION: Ports from file descriptors
* COPYRIGHT  : (C) 2010  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#include <basix/posix_port.hpp>
#include <basix/system.hpp>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>

#if defined(__MINGW__) || defined(__MINGW32__)
#  include <stdio.h>
#  include <share.h>
#endif


namespace mmx {

/******************************************************************************
* Locking
******************************************************************************/

static void
get_lock (FILE* f, int kind) {
#if !(defined(__MINGW__) || defined(__MINGW32__))
  struct flock fl;
  int fd= fileno (f);
  fl.l_type   = kind == 2? F_RDLCK: F_WRLCK;
  fl.l_whence = SEEK_SET;
  fl.l_start  = 0;
  fl.l_len    = 0;
  fl.l_pid    = getpid ();
  fcntl (fd, F_SETLKW, &fl);
  //mmout << "Locked " << fd << lf;
#endif
}

static void
release_lock (FILE* f) {
#if !(defined(__MINGW__) || defined(__MINGW32__))
  struct flock fl;
  int fd= fileno (f);
  fl.l_type   = F_UNLCK;
  fl.l_whence = SEEK_SET;
  fl.l_start  = 0;
  fl.l_len    = 0;
  fl.l_pid    = getpid ();
  fcntl (fd, F_SETLK, &fl);
  //mmout << "Unlocked " << fd << lf;
#endif
}

/******************************************************************************
* File ports
******************************************************************************/

class file_port_rep: public posix_port_rep {
  FILE*  f;
  bool   cf;
  bool   lock;
  string name;
  int    next;

public:
  syntactic expression () const {
    if (this->kind == 1) return syn ("output_file_port", syntactic (name));
    if (this->kind == 2) return syn ("input_file_port", syntactic (name));
    return syn ("input_output_file_port", syntactic (name));
  }

  bool busy () {
    if (this->kind == 2) return can_read () > 0;
    return true;
  }
  nat can_write () {
    if (this->kind == 2) return 0;
    return (nat) (-1);
  }
  nat can_read () {
    if (next != -1) return 1;
    if (this->kind == 1 || feof (f) != 0) return 0;
    next= fgetc (f);
    if (next != -1) return 1;
    return 0;
  }

  void write (const char* s, nat n) {
    for (nat i=0; i<n; i++) fputc (s[i], f); }
  void read (char* s, nat n) {
    if (next != -1 && n > 0) { s[0]= next; s++; n--; next= -1; }
    for (nat i=0; i<n; i++) s[i]= fgetc (f); }

  void flush () { fflush (f); }

public:
  inline file_port_rep (int kind, FILE* f2, bool cf2, bool lock2,
                        const string& name2):
      posix_port_rep (kind, fileno (f2)),
      f (f2), cf (cf2), lock (lock2), name (name2), next (-1) {
    if (lock) get_lock (f, this->kind); }
  inline ~file_port_rep () {
    if (lock) release_lock (f);
    if (cf) fclose (f); }
};

static port
output_file_port (FILE* f, bool close_flag, bool lock, const string& name) {
  return (port_rep*) new file_port_rep (1, f, close_flag, lock, name);
}

static port
input_file_port (FILE* f, bool close_flag, bool lock, const string& name) {
  return (port_rep*) new file_port_rep (2, f, close_flag, lock, name);
}

static port
input_output_file_port (FILE* f, bool cf, bool lock, const string& name) {
  return (port_rep*) new file_port_rep (3, f, cf, lock, name);
}

/******************************************************************************
* Standard constructors
******************************************************************************/

table<int,int> out_count (0);
table<int,int> in_count  (0);

port mmin = input_file_port (stdin , false, false, "mmin");
port mmout= formatting_port (output_file_port (stdout, false, false, "mmout"));
port mmerr= formatting_port (output_file_port (stderr, false, false, "mmerr"));

port
output_file_port (const string& name) {
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
#if defined(__MINGW__) || defined(__MINGW32__)
  FILE* f= _fsopen (temp, "w", _SH_DENYRW);
#else
  FILE* f= fopen (temp, "w");
#endif
  free_charp (temp);
  if (f == NULL) return error_port ("file '" * name * "' not writable");
  return output_file_port (f, true, true, name);
}

port
input_file_port (const string& name) {
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
#if defined(__MINGW__) || defined(__MINGW32__)
  FILE* f= _fsopen (temp, "r", _SH_DENYWR);
#else
  FILE* f= fopen (temp, "r");
#endif
  free_charp (temp);
  if (f == NULL) return error_port ("file '" * name * "' not found");
  return input_file_port (f, true, true, name);
}

port
input_output_file_port (const string& name) {
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
#if defined(__MINGW__) || defined(__MINGW32__)
  FILE* f= _fsopen (temp, "w+", _SH_DENYRW);
#else
  FILE* f= fopen (temp, "w+");
#endif
  free_charp (temp);
  if (f == NULL) return error_port ("file '" * name * "' did not open");
  return input_output_file_port (f, true, true, name);
}

} // namespace mmx

---