Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <stdio.h>
21 : #include <errno.h>
22 :
23 : #ifdef WIN32
24 : # include <io.h>
25 : #else
26 : # include <unistd.h>
27 : #endif
28 :
29 : #include <osl/diagnose.h>
30 :
31 : #include "hwplib.h"
32 : #include "hgzip.h"
33 : #include "hiodev.h"
34 : #include "hwpfile.h"
35 : #include "hstream.h"
36 :
37 : const int BUFSIZE = 1024;
38 : static uchar rBuf[BUFSIZE];
39 :
40 : // HIODev abstract class
41 2 : HIODev::HIODev()
42 : {
43 2 : init();
44 2 : }
45 :
46 :
47 2 : HIODev::~HIODev()
48 : {
49 2 : }
50 :
51 :
52 2 : void HIODev::init()
53 : {
54 2 : compressed = false;
55 2 : }
56 :
57 :
58 1411 : int HIODev::read1b(void *ptr, int nmemb)
59 : {
60 1411 : uchar *p = (uchar *) ptr;
61 : int ii;
62 :
63 1411 : if (state())
64 0 : return -1;
65 3275 : for (ii = 0; ii < nmemb; ii++)
66 : {
67 1864 : p[ii] = sal::static_int_cast<uchar>(read1b());
68 1864 : if (state())
69 0 : break;
70 : }
71 1411 : return ii;
72 : }
73 :
74 :
75 32 : int HIODev::read2b(void *ptr, int nmemb)
76 : {
77 32 : ushort *p = (ushort *) ptr;
78 : int ii;
79 :
80 32 : if (state())
81 0 : return -1;
82 559 : for (ii = 0; ii < nmemb; ii++)
83 : {
84 527 : p[ii] = sal::static_int_cast<uchar>(read2b());
85 527 : if (state())
86 0 : break;
87 : }
88 32 : return ii;
89 : }
90 :
91 :
92 3 : int HIODev::read4b(void *ptr, int nmemb)
93 : {
94 3 : ulong *p = (ulong *) ptr;
95 : int ii;
96 :
97 3 : if (state())
98 0 : return -1;
99 6 : for (ii = 0; ii < nmemb; ii++)
100 : {
101 3 : p[ii] = read4b();
102 3 : if (state())
103 0 : break;
104 : }
105 3 : return ii;
106 : }
107 :
108 :
109 : // hfileiodev class
110 2 : HStreamIODev::HStreamIODev(HStream & stream):_stream(stream)
111 : {
112 2 : init();
113 2 : }
114 :
115 :
116 6 : HStreamIODev::~HStreamIODev()
117 : {
118 2 : close();
119 4 : }
120 :
121 :
122 2 : void HStreamIODev::init()
123 : {
124 2 : _gzfp = NULL;
125 2 : compressed = false;
126 2 : }
127 :
128 :
129 2 : bool HStreamIODev::open()
130 : {
131 2 : if (!(_stream.available()))
132 0 : return false;
133 2 : return true;
134 : }
135 :
136 :
137 2 : void HStreamIODev::flush(void)
138 : {
139 2 : if (_gzfp)
140 1 : gz_flush(_gzfp, Z_FINISH);
141 2 : }
142 :
143 :
144 2 : void HStreamIODev::close(void)
145 : {
146 : /* Ç÷¯½ÃÇÑ ÈÄ ´Ý´Â´Ù. */
147 2 : this->flush();
148 2 : if (_gzfp)
149 1 : gz_close(_gzfp); /* gz_close() calls stream_closeInput() */
150 : else
151 1 : _stream.closeInput();
152 2 : _gzfp = NULL;
153 2 : }
154 :
155 :
156 3840 : int HStreamIODev::state(void) const
157 : {
158 3840 : return 0;
159 : }
160 :
161 :
162 : /* zlib °ü·Ã ºÎºÐ */
163 1 : bool HStreamIODev::setCompressed(bool flag)
164 : {
165 1 : compressed = flag;
166 1 : if (flag == true)
167 1 : return 0 != (_gzfp = gz_open(_stream));
168 0 : else if (_gzfp)
169 : {
170 0 : gz_flush(_gzfp, Z_FINISH);
171 0 : gz_close(_gzfp);
172 0 : _gzfp = 0;
173 : }
174 0 : return true;
175 : }
176 :
177 :
178 : // IO routines
179 :
180 : #define GZREAD(ptr,len) (_gzfp?gz_read(_gzfp,ptr,len):0)
181 :
182 1864 : int HStreamIODev::read1b()
183 : {
184 1864 : int res = (compressed) ? GZREAD(rBuf, 1) : _stream.readBytes(rBuf, 1);
185 :
186 1864 : if (res <= 0)
187 0 : return -1;
188 : else
189 1864 : return (unsigned char) rBuf[0];
190 : }
191 :
192 :
193 1295 : int HStreamIODev::read2b()
194 : {
195 1295 : int res = (compressed) ? GZREAD(rBuf, 2) : _stream.readBytes(rBuf, 2);
196 :
197 1295 : if (res <= 0)
198 0 : return -1;
199 : else
200 1295 : return ((unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
201 : }
202 :
203 :
204 5 : long HStreamIODev::read4b()
205 : {
206 5 : int res = (compressed) ? GZREAD(rBuf, 4) : _stream.readBytes(rBuf, 4);
207 :
208 5 : if (res <= 0)
209 0 : return -1;
210 : else
211 10 : return ((unsigned char) rBuf[3] << 24 | (unsigned char) rBuf[2] << 16 |
212 10 : (unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
213 : }
214 :
215 :
216 717 : int HStreamIODev::readBlock(void *ptr, int size)
217 : {
218 : int count =
219 715 : (compressed) ? GZREAD(ptr, size) : _stream.readBytes((byte *) ptr,
220 :
221 1432 : size);
222 :
223 717 : return count;
224 : }
225 :
226 :
227 0 : int HStreamIODev::skipBlock(int size)
228 : {
229 0 : if (compressed){
230 0 : if( size <= BUFSIZE )
231 0 : return GZREAD(rBuf, size);
232 : else{
233 0 : int remain = size;
234 0 : while(remain){
235 0 : if( remain > BUFSIZE )
236 0 : remain -= GZREAD(rBuf, BUFSIZE);
237 : else{
238 0 : remain -= GZREAD(rBuf, remain);
239 0 : break;
240 : }
241 : }
242 0 : return size - remain;
243 : }
244 : }
245 0 : return _stream.skipBytes(size);
246 : }
247 :
248 :
249 0 : HMemIODev::HMemIODev(char *s, int len)
250 : {
251 0 : init();
252 0 : ptr = (uchar *) s;
253 0 : length = len;
254 0 : }
255 :
256 :
257 0 : HMemIODev::~HMemIODev()
258 : {
259 0 : close();
260 0 : }
261 :
262 :
263 0 : void HMemIODev::init()
264 : {
265 0 : ptr = 0;
266 0 : length = 0;
267 0 : pos = 0;
268 0 : }
269 :
270 :
271 0 : bool HMemIODev::open()
272 : {
273 0 : return true;
274 : }
275 :
276 :
277 0 : void HMemIODev::flush(void)
278 : {
279 0 : }
280 :
281 :
282 0 : void HMemIODev::close(void)
283 : {
284 0 : }
285 :
286 :
287 0 : int HMemIODev::state(void) const
288 : {
289 0 : if (pos <= length)
290 0 : return 0;
291 : else
292 0 : return -1;
293 : }
294 :
295 :
296 0 : bool HMemIODev::setCompressed(bool )
297 : {
298 0 : return false;
299 : }
300 :
301 :
302 0 : int HMemIODev::read1b()
303 : {
304 0 : if (pos <= length)
305 0 : return ptr[pos++];
306 : else
307 0 : return 0;
308 : }
309 :
310 :
311 0 : int HMemIODev::read2b()
312 : {
313 0 : pos += 2;
314 0 : if (pos <= length)
315 0 : return ptr[pos - 1] << 8 | ptr[pos - 2];
316 : else
317 0 : return 0;
318 : }
319 :
320 :
321 0 : long HMemIODev::read4b()
322 : {
323 0 : pos += 4;
324 0 : if (pos <= length)
325 0 : return DWORD(ptr[pos - 1] << 24 | ptr[pos - 2] << 16 |
326 0 : ptr[pos - 3] << 8 | ptr[pos - 4]);
327 : else
328 0 : return 0;
329 : }
330 :
331 :
332 0 : int HMemIODev::readBlock(void *p, int size)
333 : {
334 0 : if (length < pos + size)
335 0 : size = length - pos;
336 0 : memcpy(p, ptr + pos, size);
337 0 : pos += size;
338 0 : return size;
339 : }
340 :
341 :
342 0 : int HMemIODev::skipBlock(int size)
343 : {
344 0 : if (length < pos + size)
345 0 : return 0;
346 0 : pos += size;
347 0 : return size;
348 : }
349 :
350 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
