← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/horae/gutsy

« back to all changes in this revision

Viewing changes to 0CPAN/Compress-Zlib-1.41/Zlib.xs

  • Committer: Bazaar Package Importer
  • Author(s): Carlo Segre
  • Date: 2006-12-28 12:36:48 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20061228123648-9xnjr76wfthd92cq
Tags: 064-1
New upstream release, dropped dependency on libtk-filedialog-perl.

Show diffs side-by-side

added added

removed removed

Lines of Context:
0CPAN/Compress-Zlib-1.41/Zlib.xs
1
 
/* Filename: Zlib.xs
2
 
 * Author  : Paul Marquess, <pmqs@cpan.org>
3
 
 * Created : 30 January 2005
4
 
 * Version : 1.40
5
 
 *
6
 
 *   Copyright (c) 1995-2005 Paul Marquess. All rights reserved.
7
 
 *   This program is free software; you can redistribute it and/or
8
 
 *   modify it under the same terms as Perl itself.
9
 
 *
10
 
 */
11
 
 
12
 
/* Part of this code is based on the file gzio.c */
13
 
 
14
 
/* gzio.c -- IO on .gz files
15
 
 * Copyright (C) 1995 Jean-loup Gailly.
16
 
 * For conditions of distribution and use, see copyright notice in zlib.h
17
 
 */
18
 
 
19
 
 
20
 
 
21
 
#include "EXTERN.h"
22
 
#include "perl.h"
23
 
#include "XSUB.h"
24
 
 
25
 
#include <zlib.h> 
26
 
 
27
 
#ifndef PERL_VERSION
28
 
#include "patchlevel.h"
29
 
#define PERL_REVISION   5
30
 
#define PERL_VERSION    PATCHLEVEL
31
 
#define PERL_SUBVERSION SUBVERSION
32
 
#endif
33
 
 
34
 
#if PERL_REVISION == 5 && (PERL_VERSION < 4 || (PERL_VERSION == 4 && PERL_SUBVERSION <= 75 ))
35
 
 
36
 
#    define PL_sv_undef         sv_undef
37
 
#    define PL_na               na
38
 
#    define PL_curcop           curcop
39
 
#    define PL_compiling        compiling
40
 
 
41
 
#endif
42
 
 
43
 
#ifndef newSVuv
44
 
#    define newSVuv     newSViv
45
 
#endif
46
 
 
47
 
typedef struct di_stream {
48
 
    z_stream stream;
49
 
    uLong    bufsize; 
50
 
    uLong    bufinc; 
51
 
    SV *     dictionary ;
52
 
    uLong    dict_adler ;
53
 
    bool     deflateParams_out_valid ;
54
 
    Bytef    deflateParams_out_byte;
55
 
    int      Level;
56
 
    int      Method;
57
 
    int      WindowBits;
58
 
    int      MemLevel;
59
 
    int      Strategy;
60
 
} di_stream;
61
 
 
62
 
typedef di_stream * deflateStream ;
63
 
typedef di_stream * Compress__Zlib__deflateStream ;
64
 
typedef di_stream * inflateStream ;
65
 
typedef di_stream * Compress__Zlib__inflateStream ;
66
 
 
67
 
/* typedef gzFile Compress__Zlib__gzFile ; */
68
 
typedef struct gzType {
69
 
    gzFile gz ;
70
 
    SV *   buffer ;
71
 
    uLong   offset ;
72
 
    bool   closed ;
73
 
}  gzType ;
74
 
 
75
 
typedef gzType* Compress__Zlib__gzFile ; 
76
 
 
77
 
 
78
 
 
79
 
#define GZERRNO "Compress::Zlib::gzerrno"
80
 
 
81
 
#define ZMALLOC(to, typ) ((to = (typ *)safemalloc(sizeof(typ))), \
82
 
                                Zero(to,1,typ))
83
 
 
84
 
#define adlerInitial adler32(0L, Z_NULL, 0)
85
 
#define crcInitial crc32(0L, Z_NULL, 0)
86
 
 
87
 
#if 1
88
 
static const char * const my_z_errmsg[] = {
89
 
    "need dictionary",     /* Z_NEED_DICT     2 */
90
 
    "stream end",          /* Z_STREAM_END    1 */
91
 
    "",                    /* Z_OK            0 */
92
 
    "file error",          /* Z_ERRNO        (-1) */
93
 
    "stream error",        /* Z_STREAM_ERROR (-2) */
94
 
    "data error",          /* Z_DATA_ERROR   (-3) */
95
 
    "insufficient memory", /* Z_MEM_ERROR    (-4) */
96
 
    "buffer error",        /* Z_BUF_ERROR    (-5) */
97
 
    "incompatible version",/* Z_VERSION_ERROR(-6) */
98
 
    ""};
99
 
#endif
100
 
 
101
 
#if defined(__SYMBIAN32__)
102
 
# define NO_WRITEABLE_DATA
103
 
#endif
104
 
 
105
 
#define TRACE_DEFAULT 0
106
 
 
107
 
#ifdef NO_WRITEABLE_DATA
108
 
#define trace TRACE_DEFAULT
109
 
#else
110
 
static int trace = TRACE_DEFAULT ;
111
 
#endif
112
 
 
113
 
/* Dodge PerlIO hiding of these functions. */
114
 
#undef printf
115
 
 
116
 
static void
117
 
#ifdef CAN_PROTOTYPE
118
 
SetGzErrorNo(int error_no)
119
 
#else
120
 
SetGzErrorNo(error_no)
121
 
int error_no ;
122
 
#endif
123
 
{
124
 
#ifdef dTHX    
125
 
    dTHX;
126
 
#endif    
127
 
    char * errstr ;
128
 
    SV * gzerror_sv = perl_get_sv(GZERRNO, FALSE) ;
129
 
  
130
 
    if (error_no == Z_ERRNO) {
131
 
        error_no = errno ;
132
 
        errstr = Strerror(errno) ;
133
 
    }
134
 
    else
135
 
        /* errstr = gzerror(fil, &error_no) ; */
136
 
        errstr = (char*) my_z_errmsg[2 - error_no]; 
137
 
 
138
 
    if (SvIV(gzerror_sv) != error_no) {
139
 
        sv_setiv(gzerror_sv, error_no) ;
140
 
        sv_setpv(gzerror_sv, errstr) ;
141
 
        SvIOK_on(gzerror_sv) ;
142
 
    }
143
 
 
144
 
}
145
 
 
146
 
static void
147
 
#ifdef CAN_PROTOTYPE
148
 
SetGzError(gzFile file)
149
 
#else
150
 
SetGzError(file)
151
 
gzFile file ;
152
 
#endif
153
 
{
154
 
    int error_no ;
155
 
 
156
 
    (void)gzerror(file, &error_no) ;
157
 
    SetGzErrorNo(error_no) ;
158
 
}
159
 
 
160
 
static void
161
 
#ifdef CAN_PROTOTYPE
162
 
DispHex(void * ptr, int length)
163
 
#else
164
 
DispHex(ptr, length)
165
 
    void * ptr;
166
 
    int length;
167
 
#endif
168
 
{
169
 
    char * p = (char*)ptr;
170
 
    int i;
171
 
    for (i = 0; i < length; ++i) {
172
 
        printf(" %02x", 0xFF & *(p+i));
173
 
    }
174
 
}
175
 
 
176
 
 
177
 
static void
178
 
#ifdef CAN_PROTOTYPE
179
 
DispStream(di_stream * s, char * message)
180
 
#else
181
 
DispStream(s, message)
182
 
    di_stream * s;
183
 
    char * message;
184
 
#endif
185
 
{
186
 
 
187
 
#if 0
188
 
    if (! trace)
189
 
        return ;
190
 
#endif
191
 
 
192
 
    printf("DispStream 0x%p - %s \n", s, message) ;
193
 
 
194
 
    if (!s)  {
195
 
        printf("    stream pointer is NULL\n");
196
 
    }
197
 
    else     {
198
 
        printf("    stream           0x%p\n", &(s->stream));
199
 
        printf("           zalloc    0x%p\n", s->stream.zalloc);
200
 
        printf("           zfree     0x%p\n", s->stream.zfree);
201
 
        printf("           opaque    0x%p\n", s->stream.opaque);
202
 
        if (s->stream.msg)
203
 
            printf("           msg       %s\n", s->stream.msg);
204
 
        else
205
 
            printf("           msg       \n");
206
 
        printf("           next_in   0x%p", s->stream.next_in);
207
 
        if (s->stream.next_in) {
208
 
            printf(" =>");
209
 
            DispHex(s->stream.next_in, 4);
210
 
        }
211
 
        printf("\n");
212
 
 
213
 
        printf("           next_out  0x%p", s->stream.next_out);
214
 
        if (s->stream.next_out){
215
 
            printf(" =>");
216
 
            DispHex(s->stream.next_out, 4);
217
 
        }
218
 
        printf("\n");
219
 
 
220
 
        printf("           avail_in  %ld\n", s->stream.avail_in);
221
 
        printf("           avail_out %ld\n", s->stream.avail_out);
222
 
        printf("           total_in  %ld\n", s->stream.total_in);
223
 
        printf("           total_out %ld\n", s->stream.total_out);
224
 
        printf("           adler     0x%lx\n", s->stream.adler);
225
 
        printf("           reserved  0x%lx\n", s->stream.reserved);
226
 
        printf("    bufsize          %ld\n", s->bufsize);
227
 
        printf("    dictionary       0x%p\n", s->dictionary);
228
 
        printf("    dict_adler       0x%ld\n", s->dict_adler);
229
 
        printf("\n");
230
 
 
231
 
    }
232
 
}
233
 
 
234
 
 
235
 
static di_stream *
236
 
#ifdef CAN_PROTOTYPE
237
 
InitStream(uLong bufsize)
238
 
#else
239
 
InitStream(bufsize)
240
 
    uLong bufsize ;
241
 
#endif
242
 
{
243
 
    di_stream *s ;
244
 
 
245
 
    ZMALLOC(s, di_stream) ;
246
 
 
247
 
    if (s)  {
248
 
        s->bufsize = bufsize ;
249
 
        s->bufinc  = bufsize ;
250
 
    }
251
 
 
252
 
    return s ;
253
 
    
254
 
}
255
 
 
256
 
#define SIZE 4096
257
 
 
258
 
static int
259
 
#ifdef CAN_PROTOTYPE
260
 
gzreadline(Compress__Zlib__gzFile file, SV * output)
261
 
#else
262
 
gzreadline(file, output)
263
 
  Compress__Zlib__gzFile file ;
264
 
  SV * output ;
265
 
#endif
266
 
{
267
 
#ifdef dTHX    
268
 
    dTHX;
269
 
#endif    
270
 
    SV * store = file->buffer ;
271
 
    char *nl = "\n"; 
272
 
    char *p;
273
 
    char *out_ptr = SvPVX(store) ;
274
 
    int n;
275
 
 
276
 
    while (1) {
277
 
 
278
 
        /* anything left from last time */
279
 
        if ((n = SvCUR(store))) {
280
 
 
281
 
            out_ptr = SvPVX(store) + file->offset ;
282
 
            if ((p = ninstr(out_ptr, out_ptr + n - 1, nl, nl))) {
283
 
            /* if (rschar != 0777 && */
284
 
                /* p = ninstr(out_ptr, out_ptr + n - 1, rs, rs+rslen-1)) { */
285
 
 
286
 
                sv_catpvn(output, out_ptr, p - out_ptr + 1);
287
 
 
288
 
                file->offset += (p - out_ptr + 1) ;
289
 
                n = n - (p - out_ptr + 1);
290
 
                SvCUR_set(store, n) ;
291
 
                return SvCUR(output);
292
 
            }
293
 
            else /* no EOL, so append the complete buffer */
294
 
                sv_catpvn(output, out_ptr, n);
295
 
            
296
 
        }
297
 
 
298
 
 
299
 
        SvCUR_set(store, 0) ;
300
 
        file->offset = 0 ;
301
 
        out_ptr = SvPVX(store) ;
302
 
 
303
 
        n = gzread(file->gz, out_ptr, SIZE) ;
304
 
 
305
 
        if (n <= 0) 
306
 
            /* Either EOF or an error */
307
 
            /* so return what we have so far else signal eof */
308
 
            return (SvCUR(output)>0) ? SvCUR(output) : n ;
309
 
 
310
 
        SvCUR_set(store, n) ;
311
 
    }
312
 
}
313
 
 
314
 
static SV* 
315
 
#ifdef CAN_PROTOTYPE
316
 
deRef(SV * sv, char * string)
317
 
#else
318
 
deRef(sv, string)
319
 
SV * sv ;
320
 
char * string;
321
 
#endif
322
 
{
323
 
#ifdef dTHX    
324
 
    dTHX;
325
 
#endif    
326
 
    if (SvROK(sv)) {
327
 
        sv = SvRV(sv) ;
328
 
        switch(SvTYPE(sv)) {
329
 
            case SVt_PVAV:
330
 
            case SVt_PVHV:
331
 
            case SVt_PVCV:
332
 
                croak("%s: buffer parameter is not a SCALAR reference", string);
333
 
        }
334
 
        if (SvROK(sv))
335
 
            croak("%s: buffer parameter is a reference to a reference", string) ;
336
 
    }
337
 
 
338
 
    if (!SvOK(sv)) { 
339
 
        sv = newSVpv("", 0);
340
 
    }   
341
 
    return sv ;
342
 
}
343
 
 
344
 
#include "constants.h"
345
 
 
346
 
MODULE = Compress::Zlib         PACKAGE = Compress::Zlib        PREFIX = Zip_
347
 
 
348
 
REQUIRE:        1.924
349
 
PROTOTYPES:     DISABLE
350
 
 
351
 
INCLUDE: constants.xs
352
 
 
353
 
BOOT:
354
 
    /* Check this version of zlib is == 1 */
355
 
    if (zlibVersion()[0] != '1')
356
 
        croak("Compress::Zlib needs zlib version 1.x\n") ;
357
 
        
358
 
    {
359
 
        /* Create the $gzerror scalar */
360
 
        SV * gzerror_sv = perl_get_sv(GZERRNO, GV_ADDMULTI) ;
361
 
        sv_setiv(gzerror_sv, 0) ;
362
 
        sv_setpv(gzerror_sv, "") ;
363
 
        SvIOK_on(gzerror_sv) ;
364
 
    }
365
 
 
366
 
 
367
 
#define Zip_zlib_version()      (char*)zlib_version
368
 
char*
369
 
Zip_zlib_version()
370
 
 
371
 
unsigned
372
 
ZLIB_VERNUM()
373
 
    CODE:
374
 
#ifdef ZLIB_VERNUM
375
 
        RETVAL = ZLIB_VERNUM ;
376
 
#else
377
 
        /* 1.1.4 => 0x1140 */
378
 
        RETVAL  = (ZLIB_VERSION[0] - '0') << 12 ;
379
 
        RETVAL += (ZLIB_VERSION[2] - '0') <<  8 ;
380
 
        RETVAL += (ZLIB_VERSION[4] - '0') <<  4 ;
381
 
#endif
382
 
    OUTPUT:
383
 
        RETVAL
384
 
 
385
 
    
386
 
 
387
 
void
388
 
DispStream(s, message=NULL)
389
 
        Compress::Zlib::inflateStream   s
390
 
        char *  message
391
 
 
392
 
Compress::Zlib::gzFile
393
 
gzopen_(path, mode)
394
 
        char *  path
395
 
        char *  mode
396
 
        CODE:
397
 
        gzFile  gz ;
398
 
        gz = gzopen(path, mode) ;
399
 
        if (gz) {
400
 
            ZMALLOC(RETVAL, gzType) ;
401
 
            RETVAL->buffer = newSV(SIZE) ;
402
 
            SvPOK_only(RETVAL->buffer) ;
403
 
            SvCUR_set(RETVAL->buffer, 0) ; 
404
 
            RETVAL->offset = 0 ;
405
 
            RETVAL->gz = gz ;
406
 
            RETVAL->closed = FALSE ;
407
 
            SetGzErrorNo(0) ;
408
 
        }
409
 
        else {
410
 
            RETVAL = NULL ;
411
 
            SetGzErrorNo(errno ? Z_ERRNO : Z_MEM_ERROR) ;
412
 
        }
413
 
        OUTPUT:
414
 
          RETVAL
415
 
 
416
 
 
417
 
Compress::Zlib::gzFile
418
 
gzdopen_(fh, mode, offset)
419
 
        int     fh
420
 
        char *  mode
421
 
        long    offset
422
 
        CODE:
423
 
        gzFile  gz ;
424
 
        if (offset != -1)
425
 
            lseek(fh, offset, 0) ; 
426
 
        gz = gzdopen(fh, mode) ;
427
 
        if (gz) {
428
 
            ZMALLOC(RETVAL, gzType) ;
429
 
            RETVAL->buffer = newSV(SIZE) ;
430
 
            SvPOK_only(RETVAL->buffer) ;
431
 
            SvCUR_set(RETVAL->buffer, 0) ;
432
 
            RETVAL->offset = 0 ;
433
 
            RETVAL->gz = gz ;
434
 
            RETVAL->closed = FALSE ;
435
 
            SetGzErrorNo(0) ;
436
 
        }
437
 
        else {
438
 
            RETVAL = NULL ;
439
 
            SetGzErrorNo(errno ? Z_ERRNO : Z_MEM_ERROR) ;
440
 
        }
441
 
        OUTPUT:
442
 
          RETVAL
443
 
 
444
 
 
445
 
MODULE = Compress::Zlib PACKAGE = Compress::Zlib::gzFile PREFIX = Zip_
446
 
 
447
 
#define Zip_gzread(file, buf, len) gzread(file->gz, bufp, len)
448
 
 
449
 
int
450
 
Zip_gzread(file, buf, len=4096)
451
 
        Compress::Zlib::gzFile  file
452
 
        unsigned        len
453
 
        SV *            buf
454
 
        voidp           bufp = NO_INIT
455
 
        uLong           bufsize = 0 ;
456
 
        int             RETVAL = 0 ;
457
 
        CODE:
458
 
        if (SvREADONLY(buf) && PL_curcop != &PL_compiling)
459
 
            croak("gzread: buffer parameter is read-only");
460
 
        SvUPGRADE(buf, SVt_PV);
461
 
        SvPOK_only(buf);
462
 
        SvCUR_set(buf, 0);
463
 
        /* any left over from gzreadline ? */
464
 
        if ((bufsize = SvCUR(file->buffer)) > 0) {
465
 
            uLong movesize ;
466
 
        
467
 
            if (bufsize < len) {
468
 
                movesize = bufsize ;
469
 
                len -= movesize ;
470
 
            }
471
 
            else {
472
 
                movesize = len ;
473
 
                len = 0 ;
474
 
            }
475
 
            RETVAL = movesize ;
476
 
 
477
 
            sv_catpvn(buf, SvPVX(file->buffer) + file->offset, movesize);
478
 
 
479
 
            file->offset += movesize ;
480
 
            SvCUR_set(file->buffer, bufsize - movesize) ;
481
 
        }
482
 
 
483
 
        if (len) {
484
 
            bufp = (Byte*)SvGROW(buf, bufsize+len+1);
485
 
            RETVAL = gzread(file->gz, ((Bytef*)bufp)+bufsize, len) ;
486
 
            SetGzError(file->gz) ; 
487
 
            if (RETVAL >= 0) {
488
 
                RETVAL += bufsize ;
489
 
                SvCUR_set(buf, RETVAL) ;
490
 
                *SvEND(buf) = '\0';
491
 
            }
492
 
        }
493
 
        OUTPUT:
494
 
           RETVAL
495
 
           buf
496
 
 
497
 
int
498
 
gzreadline(file, buf)
499
 
        Compress::Zlib::gzFile  file
500
 
        SV *            buf
501
 
        int             RETVAL = 0;
502
 
        CODE:
503
 
        if (SvREADONLY(buf) && PL_curcop != &PL_compiling) 
504
 
            croak("gzreadline: buffer parameter is read-only"); 
505
 
        SvUPGRADE(buf, SVt_PV);
506
 
        SvPOK_only(buf);
507
 
        /* sv_setpvn(buf, "", SIZE) ; */
508
 
        SvGROW(buf, SIZE) ;
509
 
        SvCUR_set(buf, 0);
510
 
        RETVAL = gzreadline(file, buf) ;
511
 
        SetGzError(file->gz) ; 
512
 
        OUTPUT:
513
 
          RETVAL
514
 
          buf
515
 
        CLEANUP:
516
 
        if (RETVAL >= 0) {
517
 
            /* SvCUR(buf) = RETVAL; */
518
 
            /* Don't need to explicitly terminate with '\0', because
519
 
                sv_catpvn aready has */
520
 
        }
521
 
 
522
 
#define Zip_gzwrite(file, buf) gzwrite(file->gz, buf, (unsigned)len)
523
 
int
524
 
Zip_gzwrite(file, buf)
525
 
        Compress::Zlib::gzFile  file
526
 
        STRLEN          len = NO_INIT
527
 
        voidp           buf = (voidp)SvPV(ST(1), len) ;
528
 
        CLEANUP:
529
 
          SetGzError(file->gz) ;
530
 
 
531
 
#define Zip_gzflush(file, flush) gzflush(file->gz, flush) 
532
 
int
533
 
Zip_gzflush(file, flush)
534
 
        Compress::Zlib::gzFile  file
535
 
        int             flush
536
 
        CLEANUP:
537
 
          SetGzError(file->gz) ;
538
 
 
539
 
#define Zip_gzclose(file) file->closed ? 0 : gzclose(file->gz)
540
 
int
541
 
Zip_gzclose(file)
542
 
        Compress::Zlib::gzFile          file
543
 
        CLEANUP:
544
 
          file->closed = TRUE ;
545
 
          SetGzErrorNo(RETVAL) ;
546
 
 
547
 
 
548
 
#define Zip_gzeof(file) gzeof(file->gz)
549
 
int
550
 
Zip_gzeof(file)
551
 
        Compress::Zlib::gzFile          file
552
 
        CODE:
553
 
#ifdef OLD_ZLIB
554
 
        croak("gzeof needs zlib 1.0.6 or better") ;
555
 
#else
556
 
        RETVAL = gzeof(file->gz);
557
 
#endif
558
 
        OUTPUT:
559
 
            RETVAL
560
 
 
561
 
 
562
 
#define Zip_gzsetparams(file,l,s) gzsetparams(file->gz,l,s)
563
 
int
564
 
Zip_gzsetparams(file, level, strategy)
565
 
        Compress::Zlib::gzFile          file
566
 
        int             level
567
 
        int             strategy
568
 
        CODE:
569
 
#ifdef OLD_ZLIB
570
 
        croak("gzsetparams needs zlib 1.0.6 or better") ;
571
 
#else
572
 
        RETVAL = gzsetparams(file->gz, level, strategy);
573
 
#endif
574
 
        OUTPUT:
575
 
            RETVAL
576
 
 
577
 
void
578
 
DESTROY(file)
579
 
        Compress::Zlib::gzFile          file
580
 
        CODE:
581
 
            if (! file->closed)
582
 
                Zip_gzclose(file) ;
583
 
            SvREFCNT_dec(file->buffer) ;
584
 
            safefree((char*)file) ;
585
 
 
586
 
#define Zip_gzerror(file) (char*)gzerror(file->gz, &errnum)
587
 
 
588
 
char *
589
 
Zip_gzerror(file)
590
 
        Compress::Zlib::gzFile  file
591
 
        int             errnum = NO_INIT
592
 
        CLEANUP:
593
 
            sv_setiv(ST(0), errnum) ;
594
 
            SvPOK_on(ST(0)) ;
595
 
 
596
 
 
597
 
 
598
 
MODULE = Compress::Zlib PACKAGE = Compress::Zlib        PREFIX = Zip_
599
 
 
600
 
 
601
 
#define Zip_adler32(buf, adler) adler32(adler, buf, (uInt)len)
602
 
 
603
 
uLong
604
 
Zip_adler32(buf, adler=adlerInitial)
605
 
        uLong    adler = NO_INIT
606
 
        STRLEN   len = NO_INIT
607
 
        Bytef *  buf = NO_INIT
608
 
        SV *     sv = ST(0) ;
609
 
        INIT:
610
 
        /* If the buffer is a reference, dereference it */
611
 
        sv = deRef(sv, "adler32") ;
612
 
        buf = (Byte*)SvPV(sv, len) ;
613
 
 
614
 
        if (items < 2)
615
 
          adler = adlerInitial;
616
 
        else if (SvOK(ST(1)))
617
 
          adler = SvUV(ST(1)) ;
618
 
        else
619
 
          adler = adlerInitial;
620
 
 
621
 
#define Zip_crc32(buf, crc) crc32(crc, buf, (uInt)len)
622
 
 
623
 
uLong
624
 
Zip_crc32(buf, crc=crcInitial)
625
 
        uLong    crc = NO_INIT
626
 
        STRLEN   len = NO_INIT
627
 
        Bytef *  buf = NO_INIT
628
 
        SV *     sv = ST(0) ;
629
 
        INIT:
630
 
        /* If the buffer is a reference, dereference it */
631
 
        sv = deRef(sv, "crc32") ;
632
 
        buf = (Byte*)SvPV(sv, len) ;
633
 
 
634
 
        if (items < 2)
635
 
          crc = crcInitial;
636
 
        else if (SvOK(ST(1)))
637
 
          crc = SvUV(ST(1)) ;
638
 
        else
639
 
          crc = crcInitial;
640
 
 
641
 
MODULE = Compress::Zlib PACKAGE = Compress::Zlib
642
 
 
643
 
void
644
 
_deflateInit(level, method, windowBits, memLevel, strategy, bufsize, dictionary)
645
 
    int level
646
 
    int method
647
 
    int windowBits
648
 
    int memLevel
649
 
    int strategy
650
 
    uLong bufsize
651
 
    SV * dictionary
652
 
  PPCODE:
653
 
 
654
 
    int err ;
655
 
    deflateStream s ;
656
 
 
657
 
    if (trace)
658
 
        warn("in _deflateInit(level=%d, method=%d, windowBits=%d, memLevel=%d, strategy=%d, bufsize=%d\n",
659
 
        level, method, windowBits, memLevel, strategy, bufsize) ;
660
 
    if ((s = InitStream(bufsize)) ) {
661
 
 
662
 
        s->Level      = level;
663
 
        s->Method     = method;
664
 
        s->WindowBits = windowBits;
665
 
        s->MemLevel   = memLevel;
666
 
        s->Strategy   = strategy;
667
 
 
668
 
        err = deflateInit2(&(s->stream), level, 
669
 
                           method, windowBits, memLevel, strategy);
670
 
 
671
 
        /* Check if a dictionary has been specified */
672
 
        if (err == Z_OK && SvCUR(dictionary)) {
673
 
            err = deflateSetDictionary(&(s->stream), (const Bytef*) SvPVX(dictionary), 
674
 
                                        SvCUR(dictionary)) ;
675
 
            s->dict_adler = s->stream.adler ;
676
 
        }
677
 
 
678
 
        if (err != Z_OK) {
679
 
            Safefree(s) ;
680
 
            s = NULL ;
681
 
        }
682
 
        
683
 
    }
684
 
    else
685
 
        err = Z_MEM_ERROR ;
686
 
 
687
 
    XPUSHs(sv_setref_pv(sv_newmortal(), 
688
 
        "Compress::Zlib::deflateStream", (void*)s));
689
 
    if (GIMME == G_ARRAY) 
690
 
        XPUSHs(sv_2mortal(newSViv(err))) ;
691
 
 
692
 
void
693
 
_inflateInit(windowBits, bufsize, dictionary)
694
 
    int windowBits
695
 
    uLong bufsize
696
 
    SV * dictionary
697
 
  PPCODE:
698
 
 
699
 
    int err = Z_OK ;
700
 
    inflateStream s ;
701
 
 
702
 
    if (trace)
703
 
        warn("in _inflateInit(windowBits=%d, bufsize=%d, dictionary=%d\n",
704
 
                windowBits, bufsize, SvCUR(dictionary)) ;
705
 
    if ((s = InitStream(bufsize)) ) {
706
 
 
707
 
        s->WindowBits = windowBits;
708
 
 
709
 
        err = inflateInit2(&(s->stream), windowBits);
710
 
 
711
 
        if (err != Z_OK) {
712
 
            Safefree(s) ;
713
 
            s = NULL ;
714
 
        }
715
 
        else if (SvCUR(dictionary)) {
716
 
            /* Dictionary specified - take a copy for use in inflate */
717
 
            s->dictionary = newSVsv(dictionary) ;
718
 
        }
719
 
    }
720
 
    else
721
 
        err = Z_MEM_ERROR ;
722
 
 
723
 
    XPUSHs(sv_setref_pv(sv_newmortal(), 
724
 
                   "Compress::Zlib::inflateStream", (void*)s));
725
 
    if (GIMME == G_ARRAY) 
726
 
        XPUSHs(sv_2mortal(newSViv(err))) ;
727
 
 
728
 
 
729
 
 
730
 
MODULE = Compress::Zlib PACKAGE = Compress::Zlib::deflateStream
731
 
 
732
 
void
733
 
DispStream(s, message=NULL)
734
 
        Compress::Zlib::deflateStream   s
735
 
        char *  message
736
 
 
737
 
void 
738
 
deflate (s, buf)
739
 
    Compress::Zlib::deflateStream       s
740
 
    SV *        buf
741
 
    uLong       outsize = NO_INIT 
742
 
    SV *        output = NO_INIT
743
 
    int         err = 0;
744
 
  PPCODE:
745
 
  
746
 
    /* If the buffer is a reference, dereference it */
747
 
    buf = deRef(buf, "deflate") ;
748
 
 
749
 
    /* initialise the input buffer */
750
 
    s->stream.next_in = (Bytef*)SvPV(buf, *(STRLEN*)&s->stream.avail_in) ;
751
 
    /* s->stream.next_in = (Bytef*)SvPVX(buf); */
752
 
    s->stream.avail_in = SvCUR(buf) ;
753
 
 
754
 
    /* and the output buffer */
755
 
    /* output = sv_2mortal(newSVpv("", s->bufinc)) ; */
756
 
    output = sv_2mortal(newSV(s->bufinc)) ;
757
 
    SvPOK_only(output) ;
758
 
    SvCUR_set(output, 0) ; 
759
 
    outsize = s->bufinc ;
760
 
    s->stream.next_out = (Bytef*) SvPVX(output) ;
761
 
    s->stream.avail_out = outsize;
762
 
 
763
 
    /* Check for saved output from deflateParams */
764
 
    if (s->deflateParams_out_valid) {
765
 
        *(s->stream.next_out) = s->deflateParams_out_byte;
766
 
        ++ s->stream.next_out;
767
 
        -- s->stream.avail_out ;
768
 
        s->deflateParams_out_valid = FALSE;
769
 
    }
770
 
 
771
 
    while (s->stream.avail_in != 0) {
772
 
 
773
 
        if (s->stream.avail_out == 0) {
774
 
            s->bufinc *= 2 ;
775
 
            SvGROW(output, outsize + s->bufinc) ;
776
 
            s->stream.next_out = (Bytef*) SvPVX(output) + outsize ;
777
 
            outsize += s->bufinc ;
778
 
            s->stream.avail_out = s->bufinc ;
779
 
        }
780
 
        err = deflate(&(s->stream), Z_NO_FLUSH);
781
 
        if (err != Z_OK) 
782
 
            break;
783
 
    }
784
 
 
785
 
    if (err == Z_OK) {
786
 
        SvPOK_only(output);
787
 
        SvCUR_set(output, outsize - s->stream.avail_out) ;
788
 
    }
789
 
    else
790
 
        output = &PL_sv_undef ;
791
 
    XPUSHs(output) ;
792
 
    if (GIMME == G_ARRAY) 
793
 
        XPUSHs(sv_2mortal(newSViv(err))) ;
794
 
  
795
 
 
796
 
 
797
 
void
798
 
flush(s, f=Z_FINISH)
799
 
    Compress::Zlib::deflateStream       s
800
 
    int f
801
 
    uLong       outsize = NO_INIT
802
 
    SV * output = NO_INIT
803
 
    int err = Z_OK ;
804
 
  PPCODE:
805
 
  
806
 
    s->stream.avail_in = 0; /* should be zero already anyway */
807
 
  
808
 
    /* output = sv_2mortal(newSVpv("", s->bufinc)) ; */
809
 
    output = sv_2mortal(newSV(s->bufinc)) ;
810
 
    SvPOK_only(output) ;
811
 
    SvCUR_set(output, 0) ; 
812
 
    outsize = s->bufinc ;
813
 
    s->stream.next_out = (Bytef*) SvPVX(output) ;
814
 
    s->stream.avail_out = outsize;
815
 
      
816
 
    /* Check for saved output from deflateParams */
817
 
    if (s->deflateParams_out_valid) {
818
 
        *(s->stream.next_out) = s->deflateParams_out_byte;
819
 
        ++ s->stream.next_out;
820
 
        -- s->stream.avail_out ;
821
 
        s->deflateParams_out_valid = FALSE;
822
 
    }
823
 
 
824
 
    for (;;) {
825
 
        if (s->stream.avail_out == 0) {
826
 
            /* consumed all the available output, so extend it */
827
 
            s->bufinc *= 2 ;
828
 
            SvGROW(output, outsize + s->bufinc) ;
829
 
            s->stream.next_out = (Bytef*)SvPVX(output) + outsize ;
830
 
            outsize += s->bufinc ;
831
 
            s->stream.avail_out = s->bufinc ;
832
 
        }
833
 
        err = deflate(&(s->stream), f);
834
 
    
835
 
        /* deflate has finished flushing only when it hasn't used up
836
 
         * all the available space in the output buffer: 
837
 
         */
838
 
        if (s->stream.avail_out != 0 || err != Z_OK )
839
 
            break;
840
 
    }
841
 
  
842
 
    err =  (err == Z_STREAM_END ? Z_OK : err) ;
843
 
  
844
 
    if (err == Z_OK) {
845
 
        SvPOK_only(output);
846
 
        SvCUR_set(output, outsize - s->stream.avail_out) ;
847
 
    }
848
 
    else
849
 
        output = &PL_sv_undef ;
850
 
    XPUSHs(output) ;
851
 
    if (GIMME == G_ARRAY) 
852
 
        XPUSHs(sv_2mortal(newSViv(err))) ;
853
 
 
854
 
int
855
 
_deflateParams(s, flags, level, strategy, bufsize)
856
 
        Compress::Zlib::deflateStream   s
857
 
        int     flags
858
 
        int     level
859
 
        int     strategy
860
 
        uLong   bufsize
861
 
    CODE:
862
 
        if (flags & 1)
863
 
            s->Level = level ;
864
 
        if (flags & 2)
865
 
            s->Strategy = strategy ;
866
 
        if (bufsize) {
867
 
            s->bufsize = bufsize; 
868
 
            s->bufinc  = bufsize; 
869
 
        }
870
 
        s->stream.avail_in = 0; 
871
 
        s->stream.next_out = &(s->deflateParams_out_byte) ;
872
 
        s->stream.avail_out = 1;
873
 
        RETVAL = deflateParams(&(s->stream), s->Level, s->Strategy);
874
 
        s->deflateParams_out_valid = 
875
 
                (RETVAL == Z_OK && s->stream.avail_out == 0) ;
876
 
    OUTPUT:
877
 
        RETVAL
878
 
 
879
 
 
880
 
int
881
 
get_Level(s)
882
 
        Compress::Zlib::deflateStream   s
883
 
    CODE:
884
 
        RETVAL = s->Level ;
885
 
    OUTPUT:
886
 
        RETVAL
887
 
 
888
 
int
889
 
get_Strategy(s)
890
 
        Compress::Zlib::deflateStream   s
891
 
    CODE:
892
 
        RETVAL = s->Strategy ;
893
 
    OUTPUT:
894
 
        RETVAL
895
 
 
896
 
void
897
 
DESTROY(s)
898
 
    Compress::Zlib::deflateStream       s
899
 
  CODE:
900
 
    deflateEnd(&s->stream) ;
901
 
    if (s->dictionary)
902
 
        SvREFCNT_dec(s->dictionary) ;
903
 
    Safefree(s) ;
904
 
 
905
 
 
906
 
uLong
907
 
dict_adler(s)
908
 
        Compress::Zlib::deflateStream   s
909
 
    CODE:
910
 
        RETVAL = s->dict_adler ;
911
 
    OUTPUT:
912
 
        RETVAL
913
 
 
914
 
uLong
915
 
total_in(s)
916
 
        Compress::Zlib::deflateStream   s
917
 
    CODE:
918
 
        RETVAL = s->stream.total_in ;
919
 
    OUTPUT:
920
 
        RETVAL
921
 
 
922
 
uLong
923
 
total_out(s)
924
 
        Compress::Zlib::deflateStream   s
925
 
    CODE:
926
 
        RETVAL = s->stream.total_out ;
927
 
    OUTPUT:
928
 
        RETVAL
929
 
 
930
 
char*
931
 
msg(s)
932
 
        Compress::Zlib::deflateStream   s
933
 
    CODE:
934
 
        RETVAL = s->stream.msg;
935
 
    OUTPUT:
936
 
        RETVAL
937
 
 
938
 
 
939
 
MODULE = Compress::Zlib PACKAGE = Compress::Zlib::inflateStream
940
 
 
941
 
void
942
 
DispStream(s, message=NULL)
943
 
        Compress::Zlib::inflateStream   s
944
 
        char *  message
945
 
 
946
 
void 
947
 
inflate (s, buf)
948
 
    Compress::Zlib::inflateStream       s
949
 
    SV *        buf
950
 
    uLong       outsize = NO_INIT 
951
 
    SV *        output = NO_INIT
952
 
    int         err = Z_OK ;
953
 
  ALIAS:
954
 
    __unc_inflate = 1
955
 
  PPCODE:
956
 
  
957
 
    /* If the buffer is a reference, dereference it */
958
 
    buf = deRef(buf, "inflate") ;
959
 
    
960
 
    /* initialise the input buffer */
961
 
    s->stream.next_in = (Bytef*)SvPVX(buf) ;
962
 
    s->stream.avail_in = SvCUR(buf) ;
963
 
        
964
 
    /* and the output buffer */
965
 
    output = sv_2mortal(newSV(s->bufinc+1)) ;
966
 
    SvPOK_only(output) ;
967
 
    SvCUR_set(output, 0) ; 
968
 
    outsize = s->bufinc ;
969
 
    s->stream.next_out = (Bytef*) SvPVX(output)  ;
970
 
    s->stream.avail_out = outsize;
971
 
 
972
 
    while (1) {
973
 
 
974
 
        if (s->stream.avail_out == 0) {
975
 
            s->bufinc *= 2 ;
976
 
            SvGROW(output, outsize + s->bufinc+1) ;
977
 
            s->stream.next_out = (Bytef*) SvPVX(output) + outsize ;
978
 
            outsize += s->bufinc ;
979
 
            s->stream.avail_out = s->bufinc ;
980
 
        }
981
 
 
982
 
        err = inflate(&(s->stream), Z_SYNC_FLUSH);
983
 
        if (err == Z_BUF_ERROR) {
984
 
            if (s->stream.avail_out == 0)
985
 
                continue ;
986
 
            if (s->stream.avail_in == 0) {
987
 
                err = Z_OK ;
988
 
                break ;
989
 
            }
990
 
        }
991
 
 
992
 
        if (err == Z_NEED_DICT && s->dictionary) {
993
 
            s->dict_adler = s->stream.adler ;
994
 
            err = inflateSetDictionary(&(s->stream), 
995
 
                                        (const Bytef*)SvPVX(s->dictionary),
996
 
                                        SvCUR(s->dictionary));
997
 
        }
998
 
       
999
 
        if (err != Z_OK) 
1000
 
            break;
1001
 
    }
1002
 
 
1003
 
    if (err == Z_OK || err == Z_STREAM_END || err == Z_DATA_ERROR) {
1004
 
        unsigned in ;
1005
 
        
1006
 
        SvPOK_only(output);
1007
 
        SvCUR_set(output, outsize - s->stream.avail_out) ;
1008
 
        *SvEND(output) = '\0';
1009
 
        
1010
 
        /* fix the input buffer */
1011
 
        if (ix == 0) {
1012
 
            in = s->stream.avail_in ;
1013
 
            SvCUR_set(buf, in) ;
1014
 
            if (in)
1015
 
                Move(s->stream.next_in, SvPVX(buf), in, char) ; 
1016
 
            *SvEND(buf) = '\0';
1017
 
            SvSETMAGIC(buf);
1018
 
        }
1019
 
    }
1020
 
    else
1021
 
        output = &PL_sv_undef ;
1022
 
    XPUSHs(output) ;
1023
 
    if (GIMME == G_ARRAY) 
1024
 
        XPUSHs(sv_2mortal(newSViv(err))) ;
1025
 
 
1026
 
int 
1027
 
inflateSync (s, buf)
1028
 
    Compress::Zlib::inflateStream       s
1029
 
    SV *        buf
1030
 
  CODE:
1031
 
  
1032
 
    /* If the buffer is a reference, dereference it */
1033
 
    buf = deRef(buf, "inflateSync") ;
1034
 
    
1035
 
    /* initialise the input buffer */
1036
 
    s->stream.next_in = (Bytef*)SvPVX(buf) ;
1037
 
    s->stream.avail_in = SvCUR(buf) ;
1038
 
        
1039
 
    /* inflateSync doesn't create any output */
1040
 
    s->stream.next_out = (Bytef*) NULL;
1041
 
    s->stream.avail_out = 0;
1042
 
 
1043
 
    RETVAL = inflateSync(&(s->stream));
1044
 
    {
1045
 
        /* fix the input buffer */
1046
 
        unsigned in = s->stream.avail_in ;
1047
 
        
1048
 
        SvCUR_set(buf, in) ;
1049
 
        if (in)
1050
 
            Move(s->stream.next_in, SvPVX(buf), in, char) ;     
1051
 
        *SvEND(buf) = '\0';
1052
 
        SvSETMAGIC(buf);
1053
 
    }
1054
 
    OUTPUT:
1055
 
        RETVAL
1056
 
 
1057
 
void
1058
 
DESTROY(s)
1059
 
    Compress::Zlib::inflateStream       s
1060
 
  CODE:
1061
 
    inflateEnd(&s->stream) ;
1062
 
    if (s->dictionary)
1063
 
        SvREFCNT_dec(s->dictionary) ;
1064
 
    Safefree(s) ;
1065
 
 
1066
 
 
1067
 
uLong
1068
 
dict_adler(s)
1069
 
        Compress::Zlib::inflateStream   s
1070
 
    CODE:
1071
 
        RETVAL = s->dict_adler ;
1072
 
    OUTPUT:
1073
 
        RETVAL
1074
 
 
1075
 
uLong
1076
 
total_in(s)
1077
 
        Compress::Zlib::inflateStream   s
1078
 
    CODE:
1079
 
        RETVAL = s->stream.total_in ;
1080
 
    OUTPUT:
1081
 
        RETVAL
1082
 
 
1083
 
uLong
1084
 
total_out(s)
1085
 
        Compress::Zlib::inflateStream   s
1086
 
    CODE:
1087
 
        RETVAL = s->stream.total_out ;
1088
 
    OUTPUT:
1089
 
        RETVAL
1090
 
 
1091
 
char*
1092
 
msg(s)
1093
 
        Compress::Zlib::inflateStream   s
1094
 
    CODE:
1095
 
        RETVAL = s->stream.msg;
1096
 
    OUTPUT:
1097
 
        RETVAL
1098
 
 
1099