src/dynpmc/gziphandle.pmc

   1 /*
   2 Copyright (C) 2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/dynpmc/gziphandle.pmc - GzipHandle PMC
   8
   9 =head1 DESCRIPTION
  10
  11 The GzipHandle PMC performs I/O operations on a source or destination file.
  12
  13 This PMC wraps the zlib.
  14
  15 =head2 Vtable Functions
  16
  17 =over 4
  18
  19 =cut
  20
  21 */
  22
  23 #include <zlib.h>
  24 #include "parrot/extend.h"
  25
  26 /* HEADERIZER HFILE: none */
  27 /* HEADERIZER BEGIN: static */
  28 /* HEADERIZER END: static */
  29
  30 pmclass GzipHandle extends Handle dynpmc auto_attrs {
  31     ATTR void *file;
  32
  33 /*
  34
  35 =item C<void init()>
  36
  37 Initializes a newly created FileHandle object.
  38
  39 =cut
  40
  41 */
  42     VTABLE void init() {
  43         PARROT_GZIPHANDLE(SELF)->file = NULL;
  44     }
  45
  46 /*
  47
  48 =item C<INTVAL get_bool()>
  49
  50 Returns whether the GzipHandle has reached the end of the file.
  51
  52 =cut
  53
  54 */
  55     VTABLE INTVAL get_bool() {
  56         gzFile file;
  57         GET_ATTR_file(INTERP, SELF, file);
  58         return !gzeof(file);
  59     }
  60
  61 /*
  62
  63 =back
  64
  65 =head2 Stream-Oriented Methods
  66
  67 =over 4
  68
  69 =item C<METHOD open(STRING *filename, STRING *mode :optional)>
  70
  71 Opens the file at the given filename (including path) with the given mode. The
  72 invocant is modified and becomes an open filehandle.
  73
  74 =cut
  75
  76 */
  77     METHOD open(STRING *filename, STRING *mode :optional,
  78                                INTVAL has_mode :opt_flag) {
  79         char * const path  = Parrot_str_to_cstring(INTERP, filename);
  80         gzFile file;
  81
  82         if (has_mode) {
  83             char * const mod = Parrot_str_to_cstring(INTERP, mode);
  84             file      = gzopen(path, mod);
  85             Parrot_str_free_cstring(mod);
  86         }
  87         else
  88             file = gzopen(path, "rb");
  89
  90         Parrot_str_free_cstring(path);
  91
  92         if (!file)
  93             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
  94                 "gzopen fails");
  95
  96         SET_ATTR_file(INTERP, SELF, file);
  97         RETURN(PMC SELF);
  98     }
  99
 100 /*
 101
 102 =item C<METHOD close()>
 103
 104 Close the gziphandle.
 105
 106 =cut
 107
 108 */
 109     METHOD close() {
 110         INTVAL status;
 111         gzFile file;
 112         GET_ATTR_file(INTERP, SELF, file);
 113         status = gzclose(file);
 114         RETURN(INTVAL status);
 115     }
 116
 117 /*
 118
 119 =item C<METHOD eof()>
 120
 121 Returns true if the filehandle is at end-of-file, returns false otherwise.
 122
 123 =cut
 124
 125 */
 126     METHOD eof() {
 127         INTVAL status;
 128         gzFile file;
 129         GET_ATTR_file(INTERP, SELF, file);
 130         status = gzeof(file);
 131         RETURN(INTVAL status);
 132     }
 133
 134 /*
 135
 136 =item C<METHOD flush()>
 137
 138 Flushes the gziphandle.
 139
 140 =cut
 141
 142 */
 143     METHOD flush() {
 144         INTVAL status;
 145         gzFile file;
 146         GET_ATTR_file(INTERP, SELF, file);
 147         status = gzflush(file, Z_SYNC_FLUSH);
 148         RETURN(INTVAL status);
 149     }
 150
 151 /*
 152
 153 =item C<METHOD print([INTVAL|FLOATVAL|STRING *|PMC*] value)>
 154
 155 Print the passed in integer, number, string, or PMC to the gziphandle.
 156 (Integers, numbers, and strings are auto-boxed as PMCs.)
 157
 158 =cut
 159
 160 */
 161     METHOD print(PMC *value) {
 162         gzFile file;
 163         STRING * const str = VTABLE_get_string(INTERP, value);
 164         char   * const buf = Parrot_str_to_cstring(INTERP, str);
 165         const UINTVAL  len =  Parrot_str_byte_length(INTERP, str);
 166
 167         GET_ATTR_file(INTERP, SELF, file);
 168         (void)gzwrite(file, buf, len);
 169         Parrot_str_free_cstring(buf);
 170     }
 171
 172
 173 /*
 174
 175 =item C<METHOD puts(STRING *value)>
 176
 177 Print the string to the gziphandle.
 178
 179 =cut
 180
 181 */
 182     METHOD puts(STRING *value) {
 183         INTVAL status;
 184         gzFile file;
 185         char * const  buf = Parrot_str_to_cstring(INTERP, value);
 186         const UINTVAL len =  Parrot_str_byte_length(INTERP, value);
 187
 188         GET_ATTR_file(INTERP, SELF, file);
 189         status =  gzwrite(file, buf, len);
 190         Parrot_str_free_cstring(buf);
 191         RETURN(INTVAL status);
 192     }
 193
 194 /*
 195
 196 =item C<METHOD read(INTVAL bytes)>
 197
 198 Read the given number of bytes from the gziphandle and return them in a string.
 199
 200 =cut
 201
 202 */
 203     METHOD read(INTVAL length) {
 204         int result;
 205         gzFile file;
 206         STRING *str = STRINGNULL;
 207         char * const buf = mem_allocate_n_zeroed_typed(length, char);
 208         GET_ATTR_file(INTERP, SELF, file);
 209         result = gzread(file, buf, length);
 210         if (result > 0) {
 211             str = Parrot_str_new(INTERP, buf, result);
 212         }
 213         mem_sys_free(buf);
 214         RETURN(STRING *str);
 215     }
 216
 217 /*
 218
 219 =back
 220
 221 =head2 Basic Methods
 222
 223 =over 4
 224
 225 =item C<METHOD version()>
 226
 227 Returns a string with the zlib version.
 228
 229 =back
 230
 231 =cut
 232
 233 */
 234
 235     METHOD version() {
 236         STRING *version = Parrot_str_new_constant(INTERP, zlibVersion());
 237         RETURN(STRING *version);
 238     }
 239
 240     METHOD compress(STRING *str) {
 241         int rc;
 242         char *buf;
 243         STRING *dst = STRINGNULL;
 244         UINTVAL srcLen, dstLen;
 245         char * const src = Parrot_str_to_cstring(INTERP, str);
 246
 247         if (!src)
 248             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
 249                 "failed to allocate");
 250
 251         srcLen = Parrot_str_byte_length(INTERP, str);
 252         dstLen = 12 + srcLen + srcLen / 1000;
 253         buf    = mem_allocate_n_zeroed_typed(dstLen, char);
 254
 255         if (!buf) {
 256             Parrot_str_free_cstring(src);
 257             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
 258                 "failed to allocate");
 259         }
 260
 261         rc = compress((Bytef *)buf, &dstLen, (const Bytef *)src, srcLen);
 262         Parrot_str_free_cstring(src);
 263
 264         switch (rc) {
 265           case Z_OK:
 266             dst = Parrot_str_new(INTERP, buf, dstLen);
 267             mem_sys_free(buf);
 268             break;
 269
 270           case Z_MEM_ERROR:
 271             mem_sys_free(buf);
 272             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
 273                 "not enough memory");
 274             break;
 275
 276           case Z_BUF_ERROR:
 277             mem_sys_free(buf);
 278             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
 279                 "output buffer error");
 280             break;
 281
 282           default:
 283             /* these are the only three documented return values */
 284             break;
 285         }
 286
 287         RETURN(STRING *dst);
 288     }
 289
 290     METHOD uncompress(STRING *str) {
 291         int rc;
 292         char *buf;
 293         STRING *dst = STRINGNULL;
 294         UINTVAL srcLen, dstLen;
 295         char * const src = Parrot_str_to_cstring(INTERP, str);
 296
 297         if (!src)
 298             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
 299                 "failed to allocate");
 300
 301         srcLen = Parrot_str_byte_length(INTERP, str);
 302         dstLen = 2 * srcLen;
 303     REDO:
 304         buf = mem_allocate_n_zeroed_typed(dstLen, char);
 305
 306         if (!buf) {
 307             Parrot_str_free_cstring(src);
 308             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
 309                 "failed to allocate");
 310         }
 311
 312         rc = uncompress((Bytef *)buf, &dstLen, (const Bytef *)src, srcLen);
 313
 314         switch (rc) {
 315           case Z_OK:
 316             Parrot_str_free_cstring(src);
 317             dst = Parrot_str_new(INTERP, buf, dstLen);
 318             mem_sys_free(buf);
 319             break;
 320
 321           case Z_MEM_ERROR:
 322             Parrot_str_free_cstring(src);
 323             mem_sys_free(buf);
 324             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
 325                 "not enough memory");
 326             break;
 327
 328           case Z_BUF_ERROR:
 329             mem_sys_free(buf);
 330             dstLen *= 2;
 331             goto REDO;
 332
 333           case Z_DATA_ERROR:
 334             Parrot_str_free_cstring(src);
 335             mem_sys_free(buf);
 336             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
 337                 "input data corrupted");
 338             break;
 339
 340           default:
 341             /* these are the only four documented return values */
 342             break;
 343         }
 344
 345         RETURN(STRING *dst);
 346     }
 347
 348     METHOD crc32(INTVAL crc, STRING *str) {
 349         UINTVAL srcLen;
 350         char * const src = Parrot_str_to_cstring(INTERP, str);
 351
 352         if (!src)
 353             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_ILL_INHERIT,
 354                 "failed to allocate");
 355
 356         srcLen  = Parrot_str_byte_length(INTERP, str);
 357
 358         crc = crc32(crc, (const Bytef *)src, srcLen);
 359         RETURN(INTVAL crc);
 360     }
 361 }
 362
 363 /*
 364  * Local variables:
 365  *   c-file-style: "parrot"
 366  * End:
 367  * vim: expandtab shiftwidth=4:
 368  */
 369