[llvm-commits] [parallel] CVS: llvm/runtime/zlib/contrib/iostream2/zstream.h zstream_test.cpp

Misha Brukman brukman at cs.uiuc.edu
Mon Mar 1 18:12:54 PST 2004


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

zstream.h added (r1.1.2.1)
zstream_test.cpp added (r1.1.2.1)

---
Log message:

Merge from trunk

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

Index: llvm/runtime/zlib/contrib/iostream2/zstream.h
diff -c /dev/null llvm/runtime/zlib/contrib/iostream2/zstream.h:1.1.2.1
*** /dev/null	Mon Mar  1 17:58:58 2004
--- llvm/runtime/zlib/contrib/iostream2/zstream.h	Mon Mar  1 17:58:48 2004
***************
*** 0 ****
--- 1,307 ----
+ /*
+  *
+  * Copyright (c) 1997
+  * Christian Michelsen Research AS
+  * Advanced Computing
+  * Fantoftvegen 38, 5036 BERGEN, Norway
+  * http://www.cmr.no
+  *
+  * Permission to use, copy, modify, distribute and sell this software
+  * and its documentation for any purpose is hereby granted without fee,
+  * provided that the above copyright notice appear in all copies and
+  * that both that copyright notice and this permission notice appear
+  * in supporting documentation.  Christian Michelsen Research AS makes no
+  * representations about the suitability of this software for any
+  * purpose.  It is provided "as is" without express or implied warranty.
+  *
+  */
+ 
+ #ifndef ZSTREAM__H
+ #define ZSTREAM__H
+ 
+ /*
+  * zstream.h - C++ interface to the 'zlib' general purpose compression library
+  * $Id: zstream.h,v 1.1.2.1 2004/03/01 23:58:48 brukman Exp $
+  */
+ 
+ #include <strstream.h>
+ #include <string.h>
+ #include <stdio.h>
+ #include "zlib.h"
+ 
+ #if defined(_WIN32)
+ #   include <fcntl.h>
+ #   include <io.h>
+ #   define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+ #else
+ #   define SET_BINARY_MODE(file)
+ #endif
+ 
+ class zstringlen {
+ public:
+     zstringlen(class izstream&);
+     zstringlen(class ozstream&, const char*);
+     size_t value() const { return val.word; }
+ private:
+     struct Val { unsigned char byte; size_t word; } val;
+ };
+ 
+ //  ----------------------------- izstream -----------------------------
+ 
+ class izstream
+ {
+     public:
+         izstream() : m_fp(0) {}
+         izstream(FILE* fp) : m_fp(0) { open(fp); }
+         izstream(const char* name) : m_fp(0) { open(name); }
+         ~izstream() { close(); }
+ 
+         /* Opens a gzip (.gz) file for reading.
+          * open() can be used to read a file which is not in gzip format;
+          * in this case read() will directly read from the file without
+          * decompression. errno can be checked to distinguish two error
+          * cases (if errno is zero, the zlib error is Z_MEM_ERROR).
+          */
+         void open(const char* name) {
+             if (m_fp) close();
+             m_fp = ::gzopen(name, "rb");
+         }
+ 
+         void open(FILE* fp) {
+             SET_BINARY_MODE(fp);
+             if (m_fp) close();
+             m_fp = ::gzdopen(fileno(fp), "rb");
+         }
+ 
+         /* Flushes all pending input if necessary, closes the compressed file
+          * and deallocates all the (de)compression state. The return value is
+          * the zlib error number (see function error() below).
+          */
+         int close() {
+             int r = ::gzclose(m_fp);
+             m_fp = 0; return r;
+         }
+ 
+         /* Binary read the given number of bytes from the compressed file.
+          */
+         int read(void* buf, size_t len) {
+             return ::gzread(m_fp, buf, len);
+         }
+ 
+         /* Returns the error message for the last error which occurred on the
+          * given compressed file. errnum is set to zlib error number. If an
+          * error occurred in the file system and not in the compression library,
+          * errnum is set to Z_ERRNO and the application may consult errno
+          * to get the exact error code.
+          */
+         const char* error(int* errnum) {
+             return ::gzerror(m_fp, errnum);
+         }
+ 
+         gzFile fp() { return m_fp; }
+ 
+     private:
+         gzFile m_fp;
+ };
+ 
+ /*
+  * Binary read the given (array of) object(s) from the compressed file.
+  * If the input file was not in gzip format, read() copies the objects number
+  * of bytes into the buffer.
+  * returns the number of uncompressed bytes actually read
+  * (0 for end of file, -1 for error).
+  */
+ template <class T, class Items>
+ inline int read(izstream& zs, T* x, Items items) {
+     return ::gzread(zs.fp(), x, items*sizeof(T));
+ }
+ 
+ /*
+  * Binary input with the '>' operator.
+  */
+ template <class T>
+ inline izstream& operator>(izstream& zs, T& x) {
+     ::gzread(zs.fp(), &x, sizeof(T));
+     return zs;
+ }
+ 
+ 
+ inline zstringlen::zstringlen(izstream& zs) {
+     zs > val.byte;
+     if (val.byte == 255) zs > val.word;
+     else val.word = val.byte;
+ }
+ 
+ /*
+  * Read length of string + the string with the '>' operator.
+  */
+ inline izstream& operator>(izstream& zs, char* x) {
+     zstringlen len(zs);
+     ::gzread(zs.fp(), x, len.value());
+     x[len.value()] = '\0';
+     return zs;
+ }
+ 
+ inline char* read_string(izstream& zs) {
+     zstringlen len(zs);
+     char* x = new char[len.value()+1];
+     ::gzread(zs.fp(), x, len.value());
+     x[len.value()] = '\0';
+     return x;
+ }
+ 
+ // ----------------------------- ozstream -----------------------------
+ 
+ class ozstream
+ {
+     public:
+         ozstream() : m_fp(0), m_os(0) {
+         }
+         ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
+             : m_fp(0), m_os(0) {
+             open(fp, level);
+         }
+         ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
+             : m_fp(0), m_os(0) {
+             open(name, level);
+         }
+         ~ozstream() {
+             close();
+         }
+ 
+         /* Opens a gzip (.gz) file for writing.
+          * The compression level parameter should be in 0..9
+          * errno can be checked to distinguish two error cases
+          * (if errno is zero, the zlib error is Z_MEM_ERROR).
+          */
+         void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
+             char mode[4] = "wb\0";
+             if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
+             if (m_fp) close();
+             m_fp = ::gzopen(name, mode);
+         }
+ 
+         /* open from a FILE pointer.
+          */
+         void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
+             SET_BINARY_MODE(fp);
+             char mode[4] = "wb\0";
+             if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
+             if (m_fp) close();
+             m_fp = ::gzdopen(fileno(fp), mode);
+         }
+ 
+         /* Flushes all pending output if necessary, closes the compressed file
+          * and deallocates all the (de)compression state. The return value is
+          * the zlib error number (see function error() below).
+          */
+         int close() {
+             if (m_os) {
+                 ::gzwrite(m_fp, m_os->str(), m_os->pcount());
+                 delete[] m_os->str(); delete m_os; m_os = 0;
+             }
+             int r = ::gzclose(m_fp); m_fp = 0; return r;
+         }
+ 
+         /* Binary write the given number of bytes into the compressed file.
+          */
+         int write(const void* buf, size_t len) {
+             return ::gzwrite(m_fp, (voidp) buf, len);
+         }
+ 
+         /* Flushes all pending output into the compressed file. The parameter
+          * _flush is as in the deflate() function. The return value is the zlib
+          * error number (see function gzerror below). flush() returns Z_OK if
+          * the flush_ parameter is Z_FINISH and all output could be flushed.
+          * flush() should be called only when strictly necessary because it can
+          * degrade compression.
+          */
+         int flush(int _flush) {
+             os_flush();
+             return ::gzflush(m_fp, _flush);
+         }
+ 
+         /* Returns the error message for the last error which occurred on the
+          * given compressed file. errnum is set to zlib error number. If an
+          * error occurred in the file system and not in the compression library,
+          * errnum is set to Z_ERRNO and the application may consult errno
+          * to get the exact error code.
+          */
+         const char* error(int* errnum) {
+             return ::gzerror(m_fp, errnum);
+         }
+ 
+         gzFile fp() { return m_fp; }
+ 
+         ostream& os() {
+             if (m_os == 0) m_os = new ostrstream;
+             return *m_os;
+         }
+ 
+         void os_flush() {
+             if (m_os && m_os->pcount()>0) {
+                 ostrstream* oss = new ostrstream;
+                 oss->fill(m_os->fill());
+                 oss->flags(m_os->flags());
+                 oss->precision(m_os->precision());
+                 oss->width(m_os->width());
+                 ::gzwrite(m_fp, m_os->str(), m_os->pcount());
+                 delete[] m_os->str(); delete m_os; m_os = oss;
+             }
+         }
+ 
+     private:
+         gzFile m_fp;
+         ostrstream* m_os;
+ };
+ 
+ /*
+  * Binary write the given (array of) object(s) into the compressed file.
+  * returns the number of uncompressed bytes actually written
+  * (0 in case of error).
+  */
+ template <class T, class Items>
+ inline int write(ozstream& zs, const T* x, Items items) {
+     return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
+ }
+ 
+ /*
+  * Binary output with the '<' operator.
+  */
+ template <class T>
+ inline ozstream& operator<(ozstream& zs, const T& x) {
+     ::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
+     return zs;
+ }
+ 
+ inline zstringlen::zstringlen(ozstream& zs, const char* x) {
+     val.byte = 255;  val.word = ::strlen(x);
+     if (val.word < 255) zs < (val.byte = val.word);
+     else zs < val;
+ }
+ 
+ /*
+  * Write length of string + the string with the '<' operator.
+  */
+ inline ozstream& operator<(ozstream& zs, const char* x) {
+     zstringlen len(zs, x);
+     ::gzwrite(zs.fp(), (voidp) x, len.value());
+     return zs;
+ }
+ 
+ #ifdef _MSC_VER
+ inline ozstream& operator<(ozstream& zs, char* const& x) {
+     return zs < (const char*) x;
+ }
+ #endif
+ 
+ /*
+  * Ascii write with the << operator;
+  */
+ template <class T>
+ inline ostream& operator<<(ozstream& zs, const T& x) {
+     zs.os_flush();
+     return zs.os() << x;
+ }
+ 
+ #endif


Index: llvm/runtime/zlib/contrib/iostream2/zstream_test.cpp
diff -c /dev/null llvm/runtime/zlib/contrib/iostream2/zstream_test.cpp:1.1.2.1
*** /dev/null	Mon Mar  1 17:58:58 2004
--- llvm/runtime/zlib/contrib/iostream2/zstream_test.cpp	Mon Mar  1 17:58:48 2004
***************
*** 0 ****
--- 1,25 ----
+ #include "zstream.h"
+ #include <math.h>
+ #include <stdlib.h>
+ #include <iomanip.h>
+ 
+ void main() {
+     char h[256] = "Hello";
+     char* g = "Goodbye";
+     ozstream out("temp.gz");
+     out < "This works well" < h < g;
+     out.close();
+ 
+     izstream in("temp.gz"); // read it back
+     char *x = read_string(in), *y = new char[256], z[256];
+     in > y > z;
+     in.close();
+     cout << x << endl << y << endl << z << endl;
+ 
+     out.open("temp.gz"); // try ascii output; zcat temp.gz to see the results
+     out << setw(50) << setfill('#') << setprecision(20) << x << endl << y << endl << z << endl;
+     out << z << endl << y << endl << x << endl;
+     out << 1.1234567890123456789 << endl;
+ 
+     delete[] x; delete[] y;
+ }





More information about the llvm-commits mailing list