/* gensio.hpp -- generic char buffer and I/O facilities
* by [email protected] at Tue Feb 26 13:30:02 CET 2002
*/

#ifdef __GNUC__
#ifndef __clang__
#pragma interface
#endif
#endif

#ifndef GENSIO_HPP
#define GENSIO_HPP 1

#include "config2.h"
#include <stdarg.h> /* va_list */
#include "gensi.hpp"
#include <stdio.h>

/* Naming conventions: *Encode is a specific, well-known PostScript or PDF
* encoding filter documented by Adobe, *Encoder is something more general.
*/

/** Writing 0 bytes for vi_write is interpreted as a close() operation.
* Constructor must not write anything to the underlying (lower-level)
* Encoder. Implementors must redefine vi_write(). Encoders may be stacked
* atop of each other.
*/
class Encoder: public GenBuffer::Writable { public:
 /** Default: calls vi_write. */
 virtual void vi_putcc(char c);
 /** vi_write() must be called with positive slen_t for normal writing, and
  * vi_write(?,0); must be called to signal EOF. After that, it is prohibited
  * to call vi_write() either way.
  */
 virtual void vi_write(char const*buf, slen_t len) =0;
 /** Copies all data (till EOF) from stream `f' to (this). */
 static void writeFrom(GenBuffer::Writable& out, FILE *f);
 /** Copies all data (till EOF) from stream `f' to (this). */
 static void writeFrom(GenBuffer::Writable& out, GenBuffer::Readable &in);
}; /* class Encoder */

/** Implementors must redefine vi_read(), and they may redefine vi_getcc().
* A .vi_read(?,0) has special meaning in a Decoder (but not in a normal
* Readable).
*/
class Decoder: public GenBuffer::Readable { public:
 /** Calls vi_read(&ret,1). Note that this is the inverse of
  * GenBuffer::Readable, because there vi_read() calls vi_getcc(). Decoders
  * may be stacked atop of each other.
  */
 virtual int vi_getcc();
 /** vi_read() must be called with positive slen_t for normal reading, and
  * vi_read(?,0); must be called to signal that the caller would not read from
  * the Decoder again, so the decoder is allowed to release the resources
  * used. After that, it is prohibited to call vi_read() either way.
  */
 virtual slen_t vi_read(char *to_buf, slen_t max) =0;
}; /* class Decoder */

class DecoderTeller: public Decoder { public:
 /** Equivalent of ftell() */
 virtual long vi_tell() const=0;
};

class Filter { public:
 /** Starts a child process (with popen(pipe_tmpl,"wb")), pipes data to it,
  * writes output to a temporary file. After _everything_ is written, the
  * temporary file is read and fed to out_.
  */
 class PipeE: public Encoder {
  public:
   PipeE(GenBuffer::Writable &out_, char const*pipe_tmpl, slendiff_t i=0);
   virtual ~PipeE();
   virtual void vi_write(char const*buf, slen_t len);
  protected:
   FILE *p;
   SimBuffer::B tmpname;
   GenBuffer::Writable &out;
   SimBuffer::B tmpename, redir_cmd;
   /** Temporary source file name `%S', forces system() instead of popen() */
   SimBuffer::B tmpsname;
   /** vi_check() is called by this->vi_write(...) (and also when Broken Pipe)
    * to check whether the encoding succeeded. vi_check() should raise an Error
    * if it detects failure or simply return if it detects success. Default
    * implementation: empty body which simly returns.
    */
   virtual void vi_check();
  protected:
   /** Copies the rest of (seekable) file `f' to `out' (subsequent filters).
    * `f' is initially positioned at the beginning. Must call fclose(f).
    * vi_copy() should raise Error::...s. The default implementation
    * just copies the data bytes verbatim. `out.vi_write(0,0);' will be called
    * by vi_write().
    */
   virtual void vi_copy(FILE *f);
 };

 /** Gobbles all data written to it, just like /dev/null */
 class NullE: public Encoder {
  public:
   inline NullE() {}
   inline virtual ~NullE() {}
   inline virtual void vi_putcc(char) {}
   inline virtual void vi_write(char const*, slen_t) {}
 };

 class VerbatimE: public Encoder {
  public:
   inline VerbatimE(GenBuffer::Writable& out_): out(&out_) {}
   inline virtual void vi_write(char const*buf, slen_t len) { out->vi_write(buf,len); }
   inline void setOut(GenBuffer::Writable& out_) { out=&out_; }
   inline GenBuffer::Writable& getOut() const { return *out; }
  protected:
   GenBuffer::Writable* out;
 };

 class VerbatimCountE: public Encoder {
  public:
   inline VerbatimCountE(GenBuffer::Writable& out_): out(&out_), count(0) {}
   inline virtual void vi_write(char const*buf, slen_t len) { out->vi_write(buf,len); count+=len; }
   inline void setOut(GenBuffer::Writable& out_) { out=&out_; }
   inline GenBuffer::Writable& getOut() const { return *out; }
   inline slen_t getCount() const { return count; }
  protected:
   GenBuffer::Writable* out;
   /** Number of bytes already written */
   slen_t count;
 };

 class FILEE: public Encoder {
  public:
   inline FILEE(FILE *f_,bool closep_): f(f_), closep(closep_) {}
   FILEE(char const* filename);
   inline virtual void vi_putcc(char c) { MACRO_PUTC(c,f); }
   virtual void vi_write(char const*buf, slen_t len);
   void close();
  protected:
   FILE *f;
   bool closep;
 };

 class PipeD: public Decoder { public:
   PipeD(GenBuffer::Readable &in_, char const*pipe_tmpl, slendiff_t i=0);
   virtual ~PipeD();
   /** Equivalent to vi_read(&ret,1). */
   virtual int vi_getcc();
   /** Upon the first non-zero call, opens `p', calls vi_precopy() and
    * closes `in'. Upon all non-zero calls,
    * reads the temporary file with fread(). Upon vi_read(?,0), removes the
    * the temporary files.
    */
   virtual slen_t vi_read(char *to_buf, slen_t max);
  protected:
   /** 0: never-read (initial state), 1: vi_precopy() already called, 2: EOF reached, `in' closed */
   int state;
   /** opened with popen(?,"w") in state:0->1, then with fopen(?,"rb") in state==1 */
   FILE *p;
   /** Temporary destination file name `%D' */
   SimBuffer::B tmpname;
   GenBuffer::Readable &in;
   SimBuffer::B tmpename, redir_cmd;
   /** Temporary source file name `%S', forces system() instead of popen() */
   SimBuffer::B tmpsname;

   /** Copies the whole `in' to writable pipe `p'. `p' will be closed by the
    * caller; in.read(0,0) will be called by the caller.
    * vi_precopy() should raise Error::...s. The default implementation
    * just copies the data bytes verbatim.
    */
   virtual void vi_precopy();
   /** vi_check() is called by this->vi_write(...) (and also when Broken Pipe)
    * to check whether the encoding succeeded. vi_check() should raise an Error
    * if it detects failure or simply return if it detects success. Default
    * implementation: empty body which simly returns.
    */
   virtual void vi_check();
  private:
   void do_close();
 };

 class VerbatimD: public Decoder {
  public:
   inline VerbatimD(GenBuffer::Readable& in_): in(in_) {}
   /** Works fine even if len==0. */
   inline virtual slen_t vi_read(char *buf, slen_t len) { return in.vi_read(buf,len); }
  protected:
   GenBuffer::Readable& in;
 };

 class FILED: public DecoderTeller {
  public:
   inline FILED(FILE *f_,bool closep_): f(f_), closep(closep_) {}
   FILED(char const* filename);
   inline virtual ~FILED() { close(); }
   inline virtual int vi_getcc() { return MACRO_GETC(f); }
   virtual slen_t vi_read(char *buf, slen_t len);
   void close();
   inline virtual long vi_tell() const { return ftell(f); }
  protected:
   FILE *f;
   bool closep;
 };

 /**
  * Sat Apr 19 12:05:49 CEST 2003
  * Always opens the file in binary mode.
  * First reads from the unget buffer, then reads from a FILE*. A typical
  * usage is:
  *   { Filter::UngetFILED f("in.txt"); // fopen("in.txt","rb"), true);
  *     f.getUnget() << "Prepend this in front of first line.\n";
  *     int c;
  *     while ((c=f.vi_getcc()!=-1)) putchar(c);
  *   }
  */
 class UngetFILED: public DecoderTeller {
  public:
   GenBuffer::Writable& getUnget() { return unget; }
   BEGIN_STATIC_ENUM(unsigned char, closeMode_t)
     CM_closep=1,
     CM_unlinkp=2,
     CM_keep_stdinp=4, /* CM_unlinkp, but keep STDIN open */
     CM_seekablep=8, /* it is sure that this->f is seekable */
     CM_MAX=4
   END_STATIC_ENUM()
   inline UngetFILED(FILE *f_, closeMode_t closep_): f(f_), closeMode(closep_), ftell_at(0), ofs(0) {}
   UngetFILED(char const* filename_, FILE* stdin_f=(FILE*)NULLP, closeMode_t closeMode_=CM_closep);
   inline virtual ~UngetFILED() { close(); }
   virtual int vi_getcc();
   virtual slen_t vi_read(char *buf, slen_t len);
   /** Appends a line to buf, including delimiter unless EOF.
    * @param delimiter: a char or negative to read to EOF
    */
   void appendLine(GenBuffer::Writable &buf, int delimiter='\n');
   void close();
   // void checkFILE();
   inline virtual long vi_tell() const { return ftell_at; } // return ftell_add+ofs+(f!=NULLP ? ftell(f) : 0); }
   /**
    * @return equivalent to getc(f) if this->f is not seekable, but returns
    *   -2 if this->f is seekable.
    */
   int getc_seekable();
   /**
    * Actively tests whether FILE* is seekable. Doesn't work for regular files
    * of 0 bytes.
    */
   bool isSeekable();
   /** Reading (this) and reading the returned FILE* will be equivalent
    * (unless this->getUnget() is used later).
    * Creates a temporary file if this->unget is not empty.
    * @param seekable_p if true, the returned FILE* must be seekable. Possibly
    *   creates a temporary file.
    */
   FILE* getFILE(bool seekable_p);
   /** Implies a getFILE() */
   void seek(long abs_ofs);
   /** Tries to do an fseek(f, -slen, SEEK_CUR). On failure, appends to unget.
    * The user should only unread() data obtained from vi_read().
    */
   void unread(char const *s, slen_t slen);
   inline char const* getFilename() const { return filename; }
   inline char const* getFilenameDefault(char const *def) const { return filename==NULLP ? def : filename; }
   inline bool hadError() const { return f!=NULLP && ferror(f); }
  protected:
   FILE *f;
   unsigned char closeMode;
   slen_t ftell_at;
   slen_t ofs;
   SimBuffer::B unget;
   char const* filename;
 };

 /** Reads from a memory of a GenBuffer via first_sub and next_sub. The
  * GenBuffer should not be changed during the read. The GenBuffer isn't
  * delete()d by (this)
  */
 class BufR: public GenBuffer::Readable {
  public:
   BufR(GenBuffer const& buf_);
   virtual int vi_getcc();
   virtual slen_t vi_read(char *to_buf, slen_t max);
   virtual void vi_rewind();
  protected:
   GenBuffer const* bufp;
   GenBuffer::Sub sub;
 };

 /** Reads from a consecutive memory area, which won't be
  * delete()d by (this)
  */
 class FlatD: public DecoderTeller /*GenBuffer::Readable*/ {
  public:
   FlatD(char const* s_, slen_t slen_);
   FlatD(char const* s_);
   virtual int vi_getcc();
   virtual slen_t vi_read(char *to_buf, slen_t max);
   virtual void vi_rewind();
   inline int getcc() { return slen!=0 ? (slen--, *(unsigned char const*)s++) : -1; }
   inline virtual long vi_tell() const { return s-sbeg; }
   inline long tell() const { return s-sbeg; }
  protected:
   char const *s, *sbeg;
   slen_t slen;
 };
}; /* class Filter */

class Files {
public:
 /** Formerly `class WritableFILE' */
 class FILEW: public GenBuffer::Writable {
  public:
   inline FILEW(FILE *f_): f(f_) {}
   inline virtual void vi_putcc(char c) { MACRO_PUTC(c,f); }
   inline virtual void vi_write(char const*buf, slen_t len) { fwrite(buf, 1, len, f); }
   virtual GenBuffer::Writable& vformat(slen_t n, char const *fmt, va_list ap);
   /** appends; uses SimBuffer::B as temp */
   virtual GenBuffer::Writable& vformat(char const *fmt, va_list ap);
   inline void close() { fclose(f); }
   inline void setF(FILE *f_) { f=f_; }
  private:
   FILE *f;
 };

 /** Formerly `class ReadableFILE'. Doesn't close the its FILE* automatically. */
 class FILER: public GenBuffer::Readable {
  public:
   inline FILER(FILE *f_): f(f_) {}
   inline virtual int vi_getcc() { return MACRO_GETC(f); }
   inline virtual slen_t vi_read(char *to_buf, slen_t max) { return fread(to_buf, 1, max, f); }
   inline void close() { fclose(f); }
   inline virtual void vi_rewind() { rewind(f); }
  private:
   FILE *f;
 };

 /** @return the beginning of the last substring in param filename that does
  * not contain '/' (dir separator)
  */
 static char const* only_fext(char const*filename);

 /** true iff temporary files should be removed at program finish end */
 static bool tmpRemove;
 /** @param fname must start with '/' (dir separator)
  * @return true if file successfully created
  */
 static FILE *try_dir(SimBuffer::B &dir, SimBuffer::B const&fname, char const*s1, char const*s2, char const*open_mode="wb");
 /* The file will be opened for writing only. It won't be registered for
  * for automatic removal.
  * @param dir `dir' is empty: appends a unique filename for a temporary
  *        file. Otherwise: returns a unique filename in the specified directory.
  *        Creates the new file with 0 size.
  * @param extension NULLP or a string specifying the extension of the file
  *        to create (should beginn with ".")
  * @param open_mode "w", "wb" or "wb+"
  * @return FILE* opened for writing for success, NULLP on failure
  * --return true on success, false on failure
  */
 static FILE *open_tmpnam(SimBuffer::B &dir, char const*open_mode="wb", char const*extension=(char const*)NULLP);
 // static FILE *open_tmpnam(SimBuffer::B &dir, bool binary_p=true, char const*extension=(char const*)NULLP);
 static bool find_tmpnam(SimBuffer::B &dir);
 /** Calls lstat().
  * @return (slen_t)-1 on error, the size otherwise
  */
 static slen_t statSize(char const* filename);
 /** Ensures that file will be removed (if possible...) when the process
  * terminates. Makes a copy of the filename array, it won't use filename
  * after returning.
  */
 static void tmpRemoveCleanup(char const* filename);
 /** Ensures that file will be removed (if possible...) when the process
  * terminates. Copies the string filename. The file will be removed iff
  * (*p!=NULLP) when the cleanup handler runs. The cleanup handler fclose()s
  * the file before removing it.
  */
 static void tmpRemoveCleanup(char const* filename, FILE**p);
 /** Removes the file/entity if exists.
  * @return 0 on success (file hadn't existed, a directory component
  *   hadn't existed, or the file has been successfully removed),
  *   1 otherwise
  */
 static int removeIf(char const *filename);

 /** Sat Sep  7 20:58:54 CEST 2002 */
 static void doSignalCleanup();

 /** Set the specified file descriptor to binary mode. Useful for stdin (0),
  * stdout (1), stderr (2) on Win32 and DOS systems. On these systems, this
  * call has the effect of `fopen(..., "rb");' On UNIX, file
  * descriptors are always binary.
  */
 #if HAVE_DOS_BINARY
   static void set_binary_mode(int fd, bool binary);
 #else
   static inline void set_binary_mode(int,bool) {}
 #endif

 /** Like the system(3) call, but it is able to run a string containing
  * multiple lines of commands. On Win32, it creates a batch file if
  * necessary.
  */
 static int system3(char const *commands);
};

#endif

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.