[llvm-commits] CVS: llvm/runtime/zlib/contrib/iostream/test.cpp zfstream.cpp zfstream.h
John Criswell
criswell at cs.uiuc.edu
Fri Feb 6 10:42:05 PST 2004
Changes in directory llvm/runtime/zlib/contrib/iostream:
test.cpp added (r1.1)
zfstream.cpp added (r1.1)
zfstream.h added (r1.1)
---
Log message:
Initial checking of the zlib library.
---
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
*** /dev/null Fri Feb 6 10:36:50 2004
--- llvm/runtime/zlib/contrib/iostream/test.cpp Fri Feb 6 10:36:40 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
*** /dev/null Fri Feb 6 10:36:50 2004
--- llvm/runtime/zlib/contrib/iostream/zfstream.cpp Fri Feb 6 10:36:40 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
*** /dev/null Fri Feb 6 10:36:50 2004
--- llvm/runtime/zlib/contrib/iostream/zfstream.h Fri Feb 6 10:36:40 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