hwpfilter/source/hiodev.cpp

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: hiodev.cpp,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 /* $Id: hiodev.cpp,v 1.6 2008-04-10 12:05:38 rt Exp $ */
  32
  33 #ifdef __GNUG__
  34 #pragma implementation "hiodev.h"
  35 #endif
  36
  37 #include <stdio.h>
  38 #include <errno.h>
  39 // DVO: add zlib/ prefix
  40 #ifdef SYSTEM_ZLIB
  41 #include <zlib.h>
  42 #else
  43 #include <zlib/zlib.h>
  44 #endif
  45 #ifdef WIN32
  46 # include <io.h>
  47 #else
  48 # include <unistd.h>
  49 #endif
  50
  51 #include "hwplib.h"
  52 #include "hgzip.h"
  53 #include "hiodev.h"
  54 #include "hwpfile.h"
  55 #include "hstream.h"
  56
  57 const int BUFSIZE = 1024;
  58 static uchar rBuf[BUFSIZE];
  59
  60 // HIODev abstract class
  61 HIODev::HIODev()
  62 {
  63     init();
  64 }
  65
  66
  67 HIODev::~HIODev()
  68 {
  69 }
  70
  71
  72 void HIODev::init()
  73 {
  74     compressed = false;
  75 }
  76
  77
  78 int HIODev::read1b(void *ptr, int nmemb)
  79 {
  80     uchar *p = (uchar *) ptr;
  81     int ii;
  82
  83     if (state())
  84         return -1;
  85     for (ii = 0; ii < nmemb; ii++)
  86     {
  87         p[ii] = sal::static_int_cast<uchar>(read1b());
  88         if (state())
  89             break;
  90     }
  91     return ii;
  92 }
  93
  94
  95 int HIODev::read2b(void *ptr, int nmemb)
  96 {
  97     ushort *p = (ushort *) ptr;
  98     int ii;
  99
 100     if (state())
 101         return -1;
 102     for (ii = 0; ii < nmemb; ii++)
 103     {
 104         p[ii] = sal::static_int_cast<uchar>(read2b());
 105         if (state())
 106             break;
 107     }
 108     return ii;
 109 }
 110
 111
 112 int HIODev::read4b(void *ptr, int nmemb)
 113 {
 114     ulong *p = (ulong *) ptr;
 115     int ii;
 116
 117     if (state())
 118         return -1;
 119     for (ii = 0; ii < nmemb; ii++)
 120     {
 121         p[ii] = read4b();
 122         if (state())
 123             break;
 124     }
 125     return ii;
 126 }
 127
 128
 129 // hfileiodev class
 130 HStreamIODev::HStreamIODev(HStream & stream):_stream(stream)
 131 {
 132     init();
 133 }
 134
 135
 136 HStreamIODev::~HStreamIODev()
 137 {
 138     close();
 139 }
 140
 141
 142 void HStreamIODev::init()
 143 {
 144     _gzfp = NULL;
 145     compressed = false;
 146 }
 147
 148
 149 bool HStreamIODev::open()
 150 {
 151     if (!(_stream.available()))
 152         return false;
 153     return true;
 154 }
 155
 156
 157 void HStreamIODev::flush(void)
 158 {
 159     if (_gzfp)
 160         gz_flush(_gzfp, Z_FINISH);
 161 }
 162
 163
 164 void HStreamIODev::close(void)
 165 {
 166 /* ÇÃ·¯½ÃÇÑ ÈÄ ´Ý´Â´Ù. */
 167     this->flush();
 168     if (_gzfp)
 169         gz_close(_gzfp);                          /* gz_close() calls stream_closeInput() */
 170     else
 171         _stream.closeInput();
 172     _gzfp = NULL;
 173 }
 174
 175
 176 int HStreamIODev::state(void) const
 177 {
 178     return 0;
 179 }
 180
 181
 182 /* zlib °ü·Ã ºÎºÐ */
 183 bool HStreamIODev::setCompressed(bool flag)
 184 {
 185     compressed = flag;
 186     if (flag == true)
 187         return 0 != (_gzfp = gz_open(_stream));
 188     else if (_gzfp)
 189     {
 190         gz_flush(_gzfp, Z_FINISH);
 191         gz_close(_gzfp);
 192         _gzfp = 0;
 193     }
 194     return true;
 195 }
 196
 197
 198 // IO routines
 199
 200 #define GZREAD(ptr,len) (_gzfp?gz_read(_gzfp,ptr,len):0)
 201
 202 int HStreamIODev::read1b()
 203 {
 204     int res = (compressed) ? GZREAD(rBuf, 1) : _stream.readBytes(rBuf, 1);
 205
 206     if (res <= 0)
 207         return -1;
 208     else
 209         return (unsigned char) rBuf[0];
 210 }
 211
 212
 213 int HStreamIODev::read2b()
 214 {
 215     int res = (compressed) ? GZREAD(rBuf, 2) : _stream.readBytes(rBuf, 2);
 216
 217     if (res <= 0)
 218         return -1;
 219     else
 220         return ((unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
 221 }
 222
 223
 224 long HStreamIODev::read4b()
 225 {
 226     int res = (compressed) ? GZREAD(rBuf, 4) : _stream.readBytes(rBuf, 4);
 227
 228     if (res <= 0)
 229         return -1;
 230     else
 231         return ((unsigned char) rBuf[3] << 24 | (unsigned char) rBuf[2] << 16 |
 232             (unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
 233 }
 234
 235
 236 int HStreamIODev::readBlock(void *ptr, int size)
 237 {
 238     int count =
 239         (compressed) ? GZREAD(ptr, size) : _stream.readBytes((byte *) ptr,
 240
 241         size);
 242
 243     return count;
 244 }
 245
 246
 247 int HStreamIODev::skipBlock(int size)
 248 {
 249     if (compressed){
 250           if( size <= BUFSIZE )
 251                 return GZREAD(rBuf, size);
 252           else{
 253                 int remain = size;
 254                 while(remain){
 255                      if( remain > BUFSIZE )
 256                           remain -= GZREAD(rBuf, BUFSIZE);
 257                      else{
 258                           remain -= GZREAD(rBuf, remain);
 259                           break;
 260                      }
 261                 }
 262                 return size - remain;
 263           }
 264      }
 265     return _stream.skipBytes(size);
 266 }
 267
 268
 269 HMemIODev::HMemIODev(char *s, int len)
 270 {
 271     init();
 272     ptr = (uchar *) s;
 273     length = len;
 274 }
 275
 276
 277 HMemIODev::~HMemIODev()
 278 {
 279     close();
 280 }
 281
 282
 283 void HMemIODev::init()
 284 {
 285     ptr = 0;
 286     length = 0;
 287     pos = 0;
 288 }
 289
 290
 291 bool HMemIODev::open()
 292 {
 293     return true;
 294 }
 295
 296
 297 void HMemIODev::flush(void)
 298 {
 299 }
 300
 301
 302 void HMemIODev::close(void)
 303 {
 304 }
 305
 306
 307 int HMemIODev::state(void) const
 308 {
 309     if (pos <= length)
 310         return 0;
 311     else
 312         return -1;
 313 }
 314
 315
 316 bool HMemIODev::setCompressed(bool )
 317 {
 318     return false;
 319 }
 320
 321
 322 int HMemIODev::read1b()
 323 {
 324     if (pos <= length)
 325          return ptr[pos++];
 326      else
 327          return 0;
 328 }
 329
 330
 331 int HMemIODev::read2b()
 332 {
 333     pos += 2;
 334     if (pos <= length)
 335          return ptr[pos - 1] << 8 | ptr[pos - 2];
 336      else
 337          return 0;
 338 }
 339
 340
 341 long HMemIODev::read4b()
 342 {
 343     pos += 4;
 344     if (pos <= length)
 345          return DWORD(ptr[pos - 1] << 24 | ptr[pos - 2] << 16 |
 346         ptr[pos - 3] << 8 | ptr[pos - 4]);
 347      else
 348          return 0;
 349 }
 350
 351
 352 int HMemIODev::readBlock(void *p, int size)
 353 {
 354     if (length < pos + size)
 355         size = length - pos;
 356     memcpy(p, ptr + pos, size);
 357     pos += size;
 358     return size;
 359 }
 360
 361
 362 int HMemIODev::skipBlock(int size)
 363 {
 364     if (length < pos + size)
 365         return 0;
 366     pos += size;
 367     return size;
 368 }