[llvm-commits] [parallel] CVS: llvm/runtime/zlib/contrib/iostream/test.cpp zfstream.cpp zfstream.h

Misha Brukman brukman at cs.uiuc.edu
Mon Mar 1 18:13:16 PST 2004


Changes in directory llvm/runtime/zlib/contrib/iostream:

test.cpp added (r1.1.2.1)
zfstream.cpp added (r1.1.2.1)
zfstream.h added (r1.1.2.1)

---
Log message:

Merge from trunk

---
Diffs of the changes:  (+481 -0)

Index: llvm/runtime/zlib/contrib/iostream/test.cpp
diff -c /dev/null llvm/runtime/zlib/contrib/iostream/test.cpp:1.1.2.1
*** /dev/null	Mon Mar  1 17:58:58 2004
--- llvm/runtime/zlib/contrib/iostream/test.cpp	Mon Mar  1 17:58:48 2004
***************
*** 0 ****
--- 1,24 ----
+ 
+ #include "zfstream.h"
+ 
+ int main() {
+ 
+   // Construct a stream object with this filebuffer.  Anything sent
+   // to this stream will go to standard out.
+   gzofstream os( 1, ios::out );
+ 
+   // This text is getting compressed and sent to stdout.
+   // To prove this, run 'test | zcat'.
+   os << "Hello, Mommy" << endl;
+ 
+   os << setcompressionlevel( Z_NO_COMPRESSION );
+   os << "hello, hello, hi, ho!" << endl;
+ 
+   setcompressionlevel( os, Z_DEFAULT_COMPRESSION )
+     << "I'm compressing again" << endl;
+ 
+   os.close();
+ 
+   return 0;
+ 
+ }


Index: llvm/runtime/zlib/contrib/iostream/zfstream.cpp
diff -c /dev/null llvm/runtime/zlib/contrib/iostream/zfstream.cpp:1.1.2.1
*** /dev/null	Mon Mar  1 17:58:58 2004
--- llvm/runtime/zlib/contrib/iostream/zfstream.cpp	Mon Mar  1 17:58:48 2004
***************
*** 0 ****
--- 1,329 ----
+ 
+ #include "zfstream.h"
+ 
+ gzfilebuf::gzfilebuf() :
+   file(NULL),
+   mode(0),
+   own_file_descriptor(0)
+ { }
+ 
+ gzfilebuf::~gzfilebuf() {
+ 
+   sync();
+   if ( own_file_descriptor )
+     close();
+ 
+ }
+ 
+ gzfilebuf *gzfilebuf::open( const char *name,
+                             int io_mode ) {
+ 
+   if ( is_open() )
+     return NULL;
+ 
+   char char_mode[10];
+   char *p = char_mode;
+ 
+   if ( io_mode & ios::in ) {
+     mode = ios::in;
+     *p++ = 'r';
+   } else if ( io_mode & ios::app ) {
+     mode = ios::app;
+     *p++ = 'a';
+   } else {
+     mode = ios::out;
+     *p++ = 'w';
+   }
+ 
+   if ( io_mode & ios::binary ) {
+     mode |= ios::binary;
+     *p++ = 'b';
+   }
+ 
+   // Hard code the compression level
+   if ( io_mode & (ios::out|ios::app )) {
+     *p++ = '9';
+   }
+ 
+   // Put the end-of-string indicator
+   *p = '\0';
+ 
+   if ( (file = gzopen(name, char_mode)) == NULL )
+     return NULL;
+ 
+   own_file_descriptor = 1;
+ 
+   return this;
+ 
+ }
+ 
+ gzfilebuf *gzfilebuf::attach( int file_descriptor,
+                               int io_mode ) {
+ 
+   if ( is_open() )
+     return NULL;
+ 
+   char char_mode[10];
+   char *p = char_mode;
+ 
+   if ( io_mode & ios::in ) {
+     mode = ios::in;
+     *p++ = 'r';
+   } else if ( io_mode & ios::app ) {
+     mode = ios::app;
+     *p++ = 'a';
+   } else {
+     mode = ios::out;
+     *p++ = 'w';
+   }
+ 
+   if ( io_mode & ios::binary ) {
+     mode |= ios::binary;
+     *p++ = 'b';
+   }
+ 
+   // Hard code the compression level
+   if ( io_mode & (ios::out|ios::app )) {
+     *p++ = '9';
+   }
+ 
+   // Put the end-of-string indicator
+   *p = '\0';
+ 
+   if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )
+     return NULL;
+ 
+   own_file_descriptor = 0;
+ 
+   return this;
+ 
+ }
+ 
+ gzfilebuf *gzfilebuf::close() {
+ 
+   if ( is_open() ) {
+ 
+     sync();
+     gzclose( file );
+     file = NULL;
+ 
+   }
+ 
+   return this;
+ 
+ }
+ 
+ int gzfilebuf::setcompressionlevel( int comp_level ) {
+ 
+   return gzsetparams(file, comp_level, -2);
+ 
+ }
+ 
+ int gzfilebuf::setcompressionstrategy( int comp_strategy ) {
+ 
+   return gzsetparams(file, -2, comp_strategy);
+ 
+ }
+ 
+ 
+ streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) {
+ 
+   return streampos(EOF);
+ 
+ }
+ 
+ int gzfilebuf::underflow() {
+ 
+   // If the file hasn't been opened for reading, error.
+   if ( !is_open() || !(mode & ios::in) )
+     return EOF;
+ 
+   // if a buffer doesn't exists, allocate one.
+   if ( !base() ) {
+ 
+     if ( (allocate()) == EOF )
+       return EOF;
+     setp(0,0);
+ 
+   } else {
+ 
+     if ( in_avail() )
+       return (unsigned char) *gptr();
+ 
+     if ( out_waiting() ) {
+       if ( flushbuf() == EOF )
+         return EOF;
+     }
+ 
+   }
+ 
+   // Attempt to fill the buffer.
+ 
+   int result = fillbuf();
+   if ( result == EOF ) {
+     // disable get area
+     setg(0,0,0);
+     return EOF;
+   }
+ 
+   return (unsigned char) *gptr();
+ 
+ }
+ 
+ int gzfilebuf::overflow( int c ) {
+ 
+   if ( !is_open() || !(mode & ios::out) )
+     return EOF;
+ 
+   if ( !base() ) {
+     if ( allocate() == EOF )
+       return EOF;
+     setg(0,0,0);
+   } else {
+     if (in_avail()) {
+         return EOF;
+     }
+     if (out_waiting()) {
+       if (flushbuf() == EOF)
+         return EOF;
+     }
+   }
+ 
+   int bl = blen();
+   setp( base(), base() + bl);
+ 
+   if ( c != EOF ) {
+ 
+     *pptr() = c;
+     pbump(1);
+ 
+   }
+ 
+   return 0;
+ 
+ }
+ 
+ int gzfilebuf::sync() {
+ 
+   if ( !is_open() )
+     return EOF;
+ 
+   if ( out_waiting() )
+     return flushbuf();
+ 
+   return 0;
+ 
+ }
+ 
+ int gzfilebuf::flushbuf() {
+ 
+   int n;
+   char *q;
+ 
+   q = pbase();
+   n = pptr() - q;
+ 
+   if ( gzwrite( file, q, n) < n )
+     return EOF;
+ 
+   setp(0,0);
+ 
+   return 0;
+ 
+ }
+ 
+ int gzfilebuf::fillbuf() {
+ 
+   int required;
+   char *p;
+ 
+   p = base();
+ 
+   required = blen();
+ 
+   int t = gzread( file, p, required );
+ 
+   if ( t <= 0) return EOF;
+ 
+   setg( base(), base(), base()+t);
+ 
+   return t;
+ 
+ }
+ 
+ gzfilestream_common::gzfilestream_common() :
+   ios( gzfilestream_common::rdbuf() )
+ { }
+ 
+ gzfilestream_common::~gzfilestream_common()
+ { }
+ 
+ void gzfilestream_common::attach( int fd, int io_mode ) {
+ 
+   if ( !buffer.attach( fd, io_mode) )
+     clear( ios::failbit | ios::badbit );
+   else
+     clear();
+ 
+ }
+ 
+ void gzfilestream_common::open( const char *name, int io_mode ) {
+ 
+   if ( !buffer.open( name, io_mode ) )
+     clear( ios::failbit | ios::badbit );
+   else
+     clear();
+ 
+ }
+ 
+ void gzfilestream_common::close() {
+ 
+   if ( !buffer.close() )
+     clear( ios::failbit | ios::badbit );
+ 
+ }
+ 
+ gzfilebuf *gzfilestream_common::rdbuf()
+ {
+   return &buffer;
+ }
+ 
+ gzifstream::gzifstream() :
+   ios( gzfilestream_common::rdbuf() )
+ {
+   clear( ios::badbit );
+ }
+ 
+ gzifstream::gzifstream( const char *name, int io_mode ) :
+   ios( gzfilestream_common::rdbuf() )
+ {
+   gzfilestream_common::open( name, io_mode );
+ }
+ 
+ gzifstream::gzifstream( int fd, int io_mode ) :
+   ios( gzfilestream_common::rdbuf() )
+ {
+   gzfilestream_common::attach( fd, io_mode );
+ }
+ 
+ gzifstream::~gzifstream() { }
+ 
+ gzofstream::gzofstream() :
+   ios( gzfilestream_common::rdbuf() )
+ {
+   clear( ios::badbit );
+ }
+ 
+ gzofstream::gzofstream( const char *name, int io_mode ) :
+   ios( gzfilestream_common::rdbuf() )
+ {
+   gzfilestream_common::open( name, io_mode );
+ }
+ 
+ gzofstream::gzofstream( int fd, int io_mode ) :
+   ios( gzfilestream_common::rdbuf() )
+ {
+   gzfilestream_common::attach( fd, io_mode );
+ }
+ 
+ gzofstream::~gzofstream() { }


Index: llvm/runtime/zlib/contrib/iostream/zfstream.h
diff -c /dev/null llvm/runtime/zlib/contrib/iostream/zfstream.h:1.1.2.1
*** /dev/null	Mon Mar  1 17:58:58 2004
--- llvm/runtime/zlib/contrib/iostream/zfstream.h	Mon Mar  1 17:58:48 2004
***************
*** 0 ****
--- 1,128 ----
+ 
+ #ifndef zfstream_h
+ #define zfstream_h
+ 
+ #include <fstream.h>
+ #include "zlib.h"
+ 
+ class gzfilebuf : public streambuf {
+ 
+ public:
+ 
+   gzfilebuf( );
+   virtual ~gzfilebuf();
+ 
+   gzfilebuf *open( const char *name, int io_mode );
+   gzfilebuf *attach( int file_descriptor, int io_mode );
+   gzfilebuf *close();
+ 
+   int setcompressionlevel( int comp_level );
+   int setcompressionstrategy( int comp_strategy );
+ 
+   inline int is_open() const { return (file !=NULL); }
+ 
+   virtual streampos seekoff( streamoff, ios::seek_dir, int );
+ 
+   virtual int sync();
+ 
+ protected:
+ 
+   virtual int underflow();
+   virtual int overflow( int = EOF );
+ 
+ private:
+ 
+   gzFile file;
+   short mode;
+   short own_file_descriptor;
+ 
+   int flushbuf();
+   int fillbuf();
+ 
+ };
+ 
+ class gzfilestream_common : virtual public ios {
+ 
+   friend class gzifstream;
+   friend class gzofstream;
+   friend gzofstream &setcompressionlevel( gzofstream &, int );
+   friend gzofstream &setcompressionstrategy( gzofstream &, int );
+ 
+ public:
+   virtual ~gzfilestream_common();
+ 
+   void attach( int fd, int io_mode );
+   void open( const char *name, int io_mode );
+   void close();
+ 
+ protected:
+   gzfilestream_common();
+ 
+ private:
+   gzfilebuf *rdbuf();
+ 
+   gzfilebuf buffer;
+ 
+ };
+ 
+ class gzifstream : public gzfilestream_common, public istream {
+ 
+ public:
+ 
+   gzifstream();
+   gzifstream( const char *name, int io_mode = ios::in );
+   gzifstream( int fd, int io_mode = ios::in );
+ 
+   virtual ~gzifstream();
+ 
+ };
+ 
+ class gzofstream : public gzfilestream_common, public ostream {
+ 
+ public:
+ 
+   gzofstream();
+   gzofstream( const char *name, int io_mode = ios::out );
+   gzofstream( int fd, int io_mode = ios::out );
+ 
+   virtual ~gzofstream();
+ 
+ };
+ 
+ template<class T> class gzomanip {
+   friend gzofstream &operator<<(gzofstream &, const gzomanip<T> &);
+ public:
+   gzomanip(gzofstream &(*f)(gzofstream &, T), T v) : func(f), val(v) { }
+ private:
+   gzofstream &(*func)(gzofstream &, T);
+   T val;
+ };
+ 
+ template<class T> gzofstream &operator<<(gzofstream &s, const gzomanip<T> &m)
+ {
+   return (*m.func)(s, m.val);
+ }
+ 
+ inline gzofstream &setcompressionlevel( gzofstream &s, int l )
+ {
+   (s.rdbuf())->setcompressionlevel(l);
+   return s;
+ }
+ 
+ inline gzofstream &setcompressionstrategy( gzofstream &s, int l )
+ {
+   (s.rdbuf())->setcompressionstrategy(l);
+   return s;
+ }
+ 
+ inline gzomanip<int> setcompressionlevel(int l)
+ {
+   return gzomanip<int>(&setcompressionlevel,l);
+ }
+ 
+ inline gzomanip<int> setcompressionstrategy(int l)
+ {
+   return gzomanip<int>(&setcompressionstrategy,l);
+ }
+ 
+ #endif





More information about the llvm-commits mailing list