hwpfilter/source/hiodev.cxx

   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 // DVO: add zlib/ prefix
  23 #ifdef SYSTEM_ZLIB
  24 #include <zlib.h>
  25 #else
  26 #include <zlib/zlib.h>
  27 #endif
  28 #ifdef WIN32
  29 # include <io.h>
  30 #else
  31 # include <unistd.h>
  32 #endif
  33
  34 #include <osl/diagnose.h>
  35
  36 #include "hwplib.h"
  37 #include "hgzip.h"
  38 #include "hiodev.h"
  39 #include "hwpfile.h"
  40 #include "hstream.h"
  41
  42 const int BUFSIZE = 1024;
  43 static uchar rBuf[BUFSIZE];
  44
  45 // HIODev abstract class
  46 HIODev::HIODev()
  47 {
  48     init();
  49 }
  50
  51
  52 HIODev::~HIODev()
  53 {
  54 }
  55
  56
  57 void HIODev::init()
  58 {
  59     compressed = false;
  60 }
  61
  62
  63 int HIODev::read1b(void *ptr, int nmemb)
  64 {
  65     uchar *p = (uchar *) ptr;
  66     int ii;
  67
  68     if (state())
  69         return -1;
  70     for (ii = 0; ii < nmemb; ii++)
  71     {
  72         p[ii] = sal::static_int_cast<uchar>(read1b());
  73         if (state())
  74             break;
  75     }
  76     return ii;
  77 }
  78
  79
  80 int HIODev::read2b(void *ptr, int nmemb)
  81 {
  82     ushort *p = (ushort *) ptr;
  83     int ii;
  84
  85     if (state())
  86         return -1;
  87     for (ii = 0; ii < nmemb; ii++)
  88     {
  89         p[ii] = sal::static_int_cast<uchar>(read2b());
  90         if (state())
  91             break;
  92     }
  93     return ii;
  94 }
  95
  96
  97 int HIODev::read4b(void *ptr, int nmemb)
  98 {
  99     ulong *p = (ulong *) ptr;
 100     int ii;
 101
 102     if (state())
 103         return -1;
 104     for (ii = 0; ii < nmemb; ii++)
 105     {
 106         p[ii] = read4b();
 107         if (state())
 108             break;
 109     }
 110     return ii;
 111 }
 112
 113
 114 // hfileiodev class
 115 HStreamIODev::HStreamIODev(HStream & stream):_stream(stream)
 116 {
 117     init();
 118 }
 119
 120
 121 HStreamIODev::~HStreamIODev()
 122 {
 123     close();
 124 }
 125
 126
 127 void HStreamIODev::init()
 128 {
 129     _gzfp = NULL;
 130     compressed = false;
 131 }
 132
 133
 134 bool HStreamIODev::open()
 135 {
 136     if (!(_stream.available()))
 137         return false;
 138     return true;
 139 }
 140
 141
 142 void HStreamIODev::flush(void)
 143 {
 144     if (_gzfp)
 145         gz_flush(_gzfp, Z_FINISH);
 146 }
 147
 148
 149 void HStreamIODev::close(void)
 150 {
 151 /* ÇÃ·¯½ÃÇÑ ÈÄ ´Ý´Â´Ù. */
 152     this->flush();
 153     if (_gzfp)
 154         gz_close(_gzfp);                          /* gz_close() calls stream_closeInput() */
 155     else
 156         _stream.closeInput();
 157     _gzfp = NULL;
 158 }
 159
 160
 161 int HStreamIODev::state(void) const
 162 {
 163     return 0;
 164 }
 165
 166
 167 /* zlib °ü·Ã ºÎºÐ */
 168 bool HStreamIODev::setCompressed(bool flag)
 169 {
 170     compressed = flag;
 171     if (flag == true)
 172         return 0 != (_gzfp = gz_open(_stream));
 173     else if (_gzfp)
 174     {
 175         gz_flush(_gzfp, Z_FINISH);
 176         gz_close(_gzfp);
 177         _gzfp = 0;
 178     }
 179     return true;
 180 }
 181
 182
 183 // IO routines
 184
 185 #define GZREAD(ptr,len) (_gzfp?gz_read(_gzfp,ptr,len):0)
 186
 187 int HStreamIODev::read1b()
 188 {
 189     int res = (compressed) ? GZREAD(rBuf, 1) : _stream.readBytes(rBuf, 1);
 190
 191     if (res <= 0)
 192         return -1;
 193     else
 194         return (unsigned char) rBuf[0];
 195 }
 196
 197
 198 int HStreamIODev::read2b()
 199 {
 200     int res = (compressed) ? GZREAD(rBuf, 2) : _stream.readBytes(rBuf, 2);
 201
 202     if (res <= 0)
 203         return -1;
 204     else
 205         return ((unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
 206 }
 207
 208
 209 long HStreamIODev::read4b()
 210 {
 211     int res = (compressed) ? GZREAD(rBuf, 4) : _stream.readBytes(rBuf, 4);
 212
 213     if (res <= 0)
 214         return -1;
 215     else
 216         return ((unsigned char) rBuf[3] << 24 | (unsigned char) rBuf[2] << 16 |
 217             (unsigned char) rBuf[1] << 8 | (unsigned char) rBuf[0]);
 218 }
 219
 220
 221 int HStreamIODev::readBlock(void *ptr, int size)
 222 {
 223     int count =
 224         (compressed) ? GZREAD(ptr, size) : _stream.readBytes((byte *) ptr,
 225
 226         size);
 227
 228     return count;
 229 }
 230
 231
 232 int HStreamIODev::skipBlock(int size)
 233 {
 234     if (compressed){
 235           if( size <= BUFSIZE )
 236                 return GZREAD(rBuf, size);
 237           else{
 238                 int remain = size;
 239                 while(remain){
 240                      if( remain > BUFSIZE )
 241                           remain -= GZREAD(rBuf, BUFSIZE);
 242                      else{
 243                           remain -= GZREAD(rBuf, remain);
 244                           break;
 245                      }
 246                 }
 247                 return size - remain;
 248           }
 249      }
 250     return _stream.skipBytes(size);
 251 }
 252
 253
 254 HMemIODev::HMemIODev(char *s, int len)
 255 {
 256     init();
 257     ptr = (uchar *) s;
 258     length = len;
 259 }
 260
 261
 262 HMemIODev::~HMemIODev()
 263 {
 264     close();
 265 }
 266
 267
 268 void HMemIODev::init()
 269 {
 270     ptr = 0;
 271     length = 0;
 272     pos = 0;
 273 }
 274
 275
 276 bool HMemIODev::open()
 277 {
 278     return true;
 279 }
 280
 281
 282 void HMemIODev::flush(void)
 283 {
 284 }
 285
 286
 287 void HMemIODev::close(void)
 288 {
 289 }
 290
 291
 292 int HMemIODev::state(void) const
 293 {
 294     if (pos <= length)
 295         return 0;
 296     else
 297         return -1;
 298 }
 299
 300
 301 bool HMemIODev::setCompressed(bool )
 302 {
 303     return false;
 304 }
 305
 306
 307 int HMemIODev::read1b()
 308 {
 309     if (pos <= length)
 310          return ptr[pos++];
 311      else
 312          return 0;
 313 }
 314
 315
 316 int HMemIODev::read2b()
 317 {
 318     pos += 2;
 319     if (pos <= length)
 320          return ptr[pos - 1] << 8 | ptr[pos - 2];
 321      else
 322          return 0;
 323 }
 324
 325
 326 long HMemIODev::read4b()
 327 {
 328     pos += 4;
 329     if (pos <= length)
 330          return DWORD(ptr[pos - 1] << 24 | ptr[pos - 2] << 16 |
 331         ptr[pos - 3] << 8 | ptr[pos - 4]);
 332      else
 333          return 0;
 334 }
 335
 336
 337 int HMemIODev::readBlock(void *p, int size)
 338 {
 339     if (length < pos + size)
 340         size = length - pos;
 341     memcpy(p, ptr + pos, size);
 342     pos += size;
 343     return size;
 344 }
 345
 346
 347 int HMemIODev::skipBlock(int size)
 348 {
 349     if (length < pos + size)
 350         return 0;
 351     pos += size;
 352     return size;
 353 }
 354
 355 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */