/Users/mourrain/Devel/mmx/basix/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>


namespace mmx {

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

class file_port_rep: public posix_port_rep {
  FILE*  f;
  bool   cf;
  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, const string& name2):
    posix_port_rep (kind, fileno (f2)),
    f (f2), cf (cf2), name (name2), next (-1) {}
  inline ~file_port_rep () {
    if (cf) fclose (f); }
};

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

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

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

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

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

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

port
output_file_port (const string& name) {
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
  FILE* f= fopen (temp, "w");
  free_charp (temp);
  if (f == NULL) return error_port ("file '" * name * "' not writable");
  return output_file_port (f, true, name);
}

port
input_file_port (const string& name) {
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
  FILE* f= fopen (temp, "r");
  free_charp (temp);
  if (f == NULL) return error_port ("file '" * name * "' not found");
  return input_file_port (f, true, name);
}

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

} // namespace mmx