OpenCores
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 767

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

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.