URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [iostream/] [zfstream.cpp] - Blame information for rev 849

Go to most recent revision | Details | Compare with Previous | View Log


 
#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() { }

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [iostream/] [zfstream.cpp] - Blame information for rev 849

Line No.	Rev	Author	Line
1	745	jeremybenn
2			`#include "zfstream.h"`
3
4			`gzfilebuf::gzfilebuf() :`
5			`file(NULL),`
6			`mode(0),`
7			`own_file_descriptor(0)`
8			`{ }`
9
10			`gzfilebuf::~gzfilebuf() {`
11
12			`sync();`
13			`if ( own_file_descriptor )`
14			`close();`
15
16			`}`
17
18			`gzfilebuf gzfilebuf::open( const char name,`
19			`int io_mode ) {`
20
21			`if ( is_open() )`
22			`return NULL;`
23
24			`char char_mode[10];`
25			`char *p = char_mode;`
26
27			`if ( io_mode & ios::in ) {`
28			`mode = ios::in;`
29			`*p++ = 'r';`
30			`} else if ( io_mode & ios::app ) {`
31			`mode = ios::app;`
32			`*p++ = 'a';`
33			`} else {`
34			`mode = ios::out;`
35			`*p++ = 'w';`
36			`}`
37
38			`if ( io_mode & ios::binary ) {`
39			`mode \|= ios::binary;`
40			`*p++ = 'b';`
41			`}`
42
43			`// Hard code the compression level`
44			`if ( io_mode & (ios::out\|ios::app )) {`
45			`*p++ = '9';`
46			`}`
47
48			`// Put the end-of-string indicator`
49			`*p = '\0';`
50
51			`if ( (file = gzopen(name, char_mode)) == NULL )`
52			`return NULL;`
53
54			`own_file_descriptor = 1;`
55
56			`return this;`
57
58			`}`
59
60			`gzfilebuf *gzfilebuf::attach( int file_descriptor,`
61			`int io_mode ) {`
62
63			`if ( is_open() )`
64			`return NULL;`
65
66			`char char_mode[10];`
67			`char *p = char_mode;`
68
69			`if ( io_mode & ios::in ) {`
70			`mode = ios::in;`
71			`*p++ = 'r';`
72			`} else if ( io_mode & ios::app ) {`
73			`mode = ios::app;`
74			`*p++ = 'a';`
75			`} else {`
76			`mode = ios::out;`
77			`*p++ = 'w';`
78			`}`
79
80			`if ( io_mode & ios::binary ) {`
81			`mode \|= ios::binary;`
82			`*p++ = 'b';`
83			`}`
84
85			`// Hard code the compression level`
86			`if ( io_mode & (ios::out\|ios::app )) {`
87			`*p++ = '9';`
88			`}`
89
90			`// Put the end-of-string indicator`
91			`*p = '\0';`
92
93			`if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )`
94			`return NULL;`
95
96			`own_file_descriptor = 0;`
97
98			`return this;`
99
100			`}`
101
102			`gzfilebuf *gzfilebuf::close() {`
103
104			`if ( is_open() ) {`
105
106			`sync();`
107			`gzclose( file );`
108			`file = NULL;`
109
110			`}`
111
112			`return this;`
113
114			`}`
115
116			`int gzfilebuf::setcompressionlevel( int comp_level ) {`
117
118			`return gzsetparams(file, comp_level, -2);`
119
120			`}`
121
122			`int gzfilebuf::setcompressionstrategy( int comp_strategy ) {`
123
124			`return gzsetparams(file, -2, comp_strategy);`
125
126			`}`
127
128
129			`streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) {`
130
131			`return streampos(EOF);`
132
133			`}`
134
135			`int gzfilebuf::underflow() {`
136
137			`// If the file hasn't been opened for reading, error.`
138			`if ( !is_open() \|\| !(mode & ios::in) )`
139			`return EOF;`
140
141			`// if a buffer doesn't exists, allocate one.`
142			`if ( !base() ) {`
143
144			`if ( (allocate()) == EOF )`
145			`return EOF;`
146			`setp(0,0);`
147
148			`} else {`
149
150			`if ( in_avail() )`
151			`return (unsigned char) *gptr();`
152
153			`if ( out_waiting() ) {`
154			`if ( flushbuf() == EOF )`
155			`return EOF;`
156			`}`
157
158			`}`
159
160			`// Attempt to fill the buffer.`
161
162			`int result = fillbuf();`
163			`if ( result == EOF ) {`
164			`// disable get area`
165			`setg(0,0,0);`
166			`return EOF;`
167			`}`
168
169			`return (unsigned char) *gptr();`
170
171			`}`
172
173			`int gzfilebuf::overflow( int c ) {`
174
175			`if ( !is_open() \|\| !(mode & ios::out) )`
176			`return EOF;`
177
178			`if ( !base() ) {`
179			`if ( allocate() == EOF )`
180			`return EOF;`
181			`setg(0,0,0);`
182			`} else {`
183			`if (in_avail()) {`
184			`return EOF;`
185			`}`
186			`if (out_waiting()) {`
187			`if (flushbuf() == EOF)`
188			`return EOF;`
189			`}`
190			`}`
191
192			`int bl = blen();`
193			`setp( base(), base() + bl);`
194
195			`if ( c != EOF ) {`
196
197			`*pptr() = c;`
198			`pbump(1);`
199
200			`}`
201
202			`return 0;`
203
204			`}`
205
206			`int gzfilebuf::sync() {`
207
208			`if ( !is_open() )`
209			`return EOF;`
210
211			`if ( out_waiting() )`
212			`return flushbuf();`
213
214			`return 0;`
215
216			`}`
217
218			`int gzfilebuf::flushbuf() {`
219
220			`int n;`
221			`char *q;`
222
223			`q = pbase();`
224			`n = pptr() - q;`
225
226			`if ( gzwrite( file, q, n) < n )`
227			`return EOF;`
228
229			`setp(0,0);`
230
231			`return 0;`
232
233			`}`
234
235			`int gzfilebuf::fillbuf() {`
236
237			`int required;`
238			`char *p;`
239
240			`p = base();`
241
242			`required = blen();`
243
244			`int t = gzread( file, p, required );`
245
246			`if ( t <= 0) return EOF;`
247
248			`setg( base(), base(), base()+t);`
249
250			`return t;`
251
252			`}`
253
254			`gzfilestream_common::gzfilestream_common() :`
255			`ios( gzfilestream_common::rdbuf() )`
256			`{ }`
257
258			`gzfilestream_common::~gzfilestream_common()`
259			`{ }`
260
261			`void gzfilestream_common::attach( int fd, int io_mode ) {`
262
263			`if ( !buffer.attach( fd, io_mode) )`
264			`clear( ios::failbit \| ios::badbit );`
265			`else`
266			`clear();`
267
268			`}`
269
270			`void gzfilestream_common::open( const char *name, int io_mode ) {`
271
272			`if ( !buffer.open( name, io_mode ) )`
273			`clear( ios::failbit \| ios::badbit );`
274			`else`
275			`clear();`
276
277			`}`
278
279			`void gzfilestream_common::close() {`
280
281			`if ( !buffer.close() )`
282			`clear( ios::failbit \| ios::badbit );`
283
284			`}`
285
286			`gzfilebuf *gzfilestream_common::rdbuf()`
287			`{`
288			`return &buffer;`
289			`}`
290
291			`gzifstream::gzifstream() :`
292			`ios( gzfilestream_common::rdbuf() )`
293			`{`
294			`clear( ios::badbit );`
295			`}`
296
297			`gzifstream::gzifstream( const char *name, int io_mode ) :`
298			`ios( gzfilestream_common::rdbuf() )`
299			`{`
300			`gzfilestream_common::open( name, io_mode );`
301			`}`
302
303			`gzifstream::gzifstream( int fd, int io_mode ) :`
304			`ios( gzfilestream_common::rdbuf() )`
305			`{`
306			`gzfilestream_common::attach( fd, io_mode );`
307			`}`
308
309			`gzifstream::~gzifstream() { }`
310
311			`gzofstream::gzofstream() :`
312			`ios( gzfilestream_common::rdbuf() )`
313			`{`
314			`clear( ios::badbit );`
315			`}`
316
317			`gzofstream::gzofstream( const char *name, int io_mode ) :`
318			`ios( gzfilestream_common::rdbuf() )`
319			`{`
320			`gzfilestream_common::open( name, io_mode );`
321			`}`
322
323			`gzofstream::gzofstream( int fd, int io_mode ) :`
324			`ios( gzfilestream_common::rdbuf() )`
325			`{`
326			`gzfilestream_common::attach( fd, io_mode );`
327			`}`
328
329			`gzofstream::~gzofstream() { }`