FOREIGN MODULE java_util_zip;

IMPORT
    java_lang,
    java_io,
    java_util;

TYPE

  Adler32* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Checksum)
             STATIC
               PROCEDURE Init*() : Adler32,CONSTRUCTOR;
             END;

  CheckedInputStream* = POINTER TO EXTENSIBLE RECORD (java_io.FilterInputStream)
                        STATIC
                          PROCEDURE Init*(p0 : java_io.InputStream;
                                          p1 : Checksum) : CheckedInputStream,CONSTRUCTOR;
                        END;

  CheckedOutputStream* = POINTER TO EXTENSIBLE RECORD (java_io.FilterOutputStream)
                         STATIC
                           PROCEDURE Init*(p0 : java_io.OutputStream;
                                           p1 : Checksum) : CheckedOutputStream,CONSTRUCTOR;
                         END;

  Checksum* = POINTER TO INTERFACE RECORD (java_lang.Object)
              END;

  CRC32* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + ARRAY OF BigInteger)
           STATIC
             PROCEDURE Init*() : CRC32,CONSTRUCTOR;
           END;

  DataFormatException* = POINTER TO EXTENSIBLE RECORD (java_lang.Exception)
                         STATIC
                           PROCEDURE Init*() : DataFormatException,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : java_lang.String) : DataFormatException,CONSTRUCTOR;
                         END;

  Deflater* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
              STATIC
                DEFLATED* = 8;
                NO_COMPRESSION* = 0;
                BEST_SPEED* = 1;
                BEST_COMPRESSION* = 9;
                DEFAULT_COMPRESSION* = -1;
                FILTERED* = 1;
                HUFFMAN_ONLY* = 2;
                DEFAULT_STRATEGY* = 0;
                PROCEDURE Init*() : Deflater,CONSTRUCTOR;
                PROCEDURE Init*(p0 : INTEGER) : Deflater,CONSTRUCTOR;
                PROCEDURE Init*(p0 : INTEGER;
                                p1 : BOOLEAN) : Deflater,CONSTRUCTOR;
              END;

  DeflaterOutputStream* = POINTER TO EXTENSIBLE RECORD (java_io.FilterOutputStream)
                            def! : Deflater;
                            buf! : POINTER TO ARRAY OF BYTE;
                          STATIC
                            PROCEDURE Init*(p0 : java_io.OutputStream) : DeflaterOutputStream,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : java_io.OutputStream;
                                            p1 : Deflater) : DeflaterOutputStream,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : java_io.OutputStream;
                                            p1 : Deflater;
                                            p2 : INTEGER) : DeflaterOutputStream,CONSTRUCTOR;
                          END;

  GZIPInputStream* = POINTER TO EXTENSIBLE RECORD (InflaterInputStream)
                       crc! : CRC32;
                       eos! : BOOLEAN;
                     STATIC
                       GZIP_MAGIC* = 35615;
                       PROCEDURE Init*(p0 : java_io.InputStream) : GZIPInputStream,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : java_io.InputStream;
                                       p1 : INTEGER) : GZIPInputStream,CONSTRUCTOR;
                     END;

  GZIPOutputStream* = POINTER TO EXTENSIBLE RECORD (DeflaterOutputStream)
                        crc! : CRC32;
                      STATIC
                        PROCEDURE Init*(p0 : java_io.OutputStream) : GZIPOutputStream,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : java_io.OutputStream;
                                        p1 : INTEGER) : GZIPOutputStream,CONSTRUCTOR;
                      END;

  Inflater* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
              STATIC
                PROCEDURE Init*() : Inflater,CONSTRUCTOR;
                PROCEDURE Init*(p0 : BOOLEAN) : Inflater,CONSTRUCTOR;
              END;

  InflaterInputStream* = POINTER TO EXTENSIBLE RECORD (java_io.FilterInputStream)
                           inf! : Inflater;
                           buf! : POINTER TO ARRAY OF BYTE;
                           len! : INTEGER;
                         STATIC
                           PROCEDURE Init*(p0 : java_io.InputStream) : InflaterInputStream,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : java_io.InputStream;
                                           p1 : Inflater) : InflaterInputStream,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : java_io.InputStream;
                                           p1 : Inflater;
                                           p2 : INTEGER) : InflaterInputStream,CONSTRUCTOR;
                         END;

  ZipEntry* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + ZipConstants + java_lang.Cloneable)
              STATIC
                STORED* = 0;
                DEFLATED* = 8;
                PROCEDURE Init*(p0 : java_lang.String) : ZipEntry,CONSTRUCTOR;
                PROCEDURE Init*(p0 : ZipEntry) : ZipEntry,CONSTRUCTOR;
              END;

  ZipException* = POINTER TO EXTENSIBLE RECORD (java_io.IOException)
                  STATIC
                    PROCEDURE Init*() : ZipException,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : java_lang.String) : ZipException,CONSTRUCTOR;
                  END;

  ZipFile* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + ZipConstants)
             STATIC
               PROCEDURE Init*(p0 : java_io.File) : ZipFile,CONSTRUCTOR;
               PROCEDURE Init*(p0 : java_lang.String) : ZipFile,CONSTRUCTOR;
             END;

  ZipInputStream* = POINTER TO EXTENSIBLE RECORD (InflaterInputStream + ZipConstants)
                    STATIC
                      PROCEDURE Init*(p0 : java_io.InputStream) : ZipInputStream,CONSTRUCTOR;
                    END;

  ZipOutputStream* = POINTER TO EXTENSIBLE RECORD (DeflaterOutputStream + ZipConstants)
                     STATIC
                       STORED* = 0;
                       DEFLATED* = 8;
                       PROCEDURE Init*(p0 : java_io.OutputStream) : ZipOutputStream,CONSTRUCTOR;
                     END;




PROCEDURE (self:Adler32) getValue*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:Adler32) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:Adler32) update*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Adler32) update*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:Adler32) update*(IN  p0 : ARRAY OF BYTE;
                                     p1 : INTEGER;
                                     p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:CheckedInputStream) getChecksum*() : Checksum,NEW,EXTENSIBLE;

PROCEDURE (self:CheckedInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:CheckedInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                              p1 : INTEGER;
                                              p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:CheckedInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:CheckedOutputStream) getChecksum*() : Checksum,NEW,EXTENSIBLE;

PROCEDURE (self:CheckedOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:CheckedOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                                p1 : INTEGER;
                                                p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:Checksum) getValue*() : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:Checksum) reset*(),NEW,ABSTRACT;

PROCEDURE (self:Checksum) update*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:Checksum) update*(IN  p0 : ARRAY OF BYTE;
                                      p1 : INTEGER;
                                      p2 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:CRC32) getValue*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:CRC32) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:CRC32) update*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:CRC32) update*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:CRC32) update*(IN  p0 : ARRAY OF BYTE;
                                   p1 : INTEGER;
                                   p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) deflate*(IN  p0 : ARRAY OF BYTE) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) deflate*(IN  p0 : ARRAY OF BYTE;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) end*(),NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) finalize!(),EXTENSIBLE;

PROCEDURE (self:Deflater) finish*(),NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) finished*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) getAdler*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) getTotalIn*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) getTotalOut*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) needsInput*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) setDictionary*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) setDictionary*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) setInput*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) setInput*(IN  p0 : ARRAY OF BYTE;
                                        p1 : INTEGER;
                                        p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) setLevel*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Deflater) setStrategy*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:DeflaterOutputStream) close*(),EXTENSIBLE;

PROCEDURE (self:DeflaterOutputStream) deflate!(),NEW,EXTENSIBLE;

PROCEDURE (self:DeflaterOutputStream) finish*(),NEW,EXTENSIBLE;

PROCEDURE (self:DeflaterOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:DeflaterOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                                 p1 : INTEGER;
                                                 p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:GZIPInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:GZIPInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                           p1 : INTEGER;
                                           p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:GZIPOutputStream) close*(),EXTENSIBLE;

PROCEDURE (self:GZIPOutputStream) finish*(),EXTENSIBLE;

PROCEDURE (self:GZIPOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:Inflater) end*(),NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) finalize!(),EXTENSIBLE;

PROCEDURE (self:Inflater) finished*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) getAdler*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) getRemaining*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) getTotalIn*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) getTotalOut*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) inflate*(IN  p0 : ARRAY OF BYTE) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) inflate*(IN  p0 : ARRAY OF BYTE;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) needsDictionary*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) needsInput*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) setDictionary*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) setDictionary*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) setInput*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:Inflater) setInput*(IN  p0 : ARRAY OF BYTE;
                                        p1 : INTEGER;
                                        p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:InflaterInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:InflaterInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:InflaterInputStream) fill!(),NEW,EXTENSIBLE;

PROCEDURE (self:InflaterInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:InflaterInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                               p1 : INTEGER;
                                               p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:InflaterInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:ZipEntry) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ZipEntry) getComment*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) getCompressedSize*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) getCrc*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) getExtra*() : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) getMethod*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) getName*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) getSize*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) getTime*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:ZipEntry) isDirectory*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) setComment*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) setCompressedSize*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) setCrc*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) setExtra*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) setMethod*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) setSize*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) setTime*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:ZipEntry) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:ZipFile) close*(),NEW,EXTENSIBLE;

PROCEDURE (self:ZipFile) entries*() : java_util.Enumeration,NEW,EXTENSIBLE;

PROCEDURE (self:ZipFile) getEntry*(p0 : java_lang.String) : ZipEntry,NEW,EXTENSIBLE;

PROCEDURE (self:ZipFile) getInputStream*(p0 : ZipEntry) : java_io.InputStream,NEW,EXTENSIBLE;

PROCEDURE (self:ZipFile) getName*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ZipFile) size*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ZipInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:ZipInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:ZipInputStream) closeEntry*(),NEW,EXTENSIBLE;

PROCEDURE (self:ZipInputStream) createZipEntry!(p0 : java_lang.String) : ZipEntry,NEW,EXTENSIBLE;

PROCEDURE (self:ZipInputStream) getNextEntry*() : ZipEntry,NEW,EXTENSIBLE;

PROCEDURE (self:ZipInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                          p1 : INTEGER;
                                          p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:ZipInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:ZipOutputStream) close*(),EXTENSIBLE;

PROCEDURE (self:ZipOutputStream) closeEntry*(),NEW,EXTENSIBLE;

PROCEDURE (self:ZipOutputStream) finish*(),EXTENSIBLE;

PROCEDURE (self:ZipOutputStream) putNextEntry*(p0 : ZipEntry),NEW,EXTENSIBLE;

PROCEDURE (self:ZipOutputStream) setComment*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:ZipOutputStream) setLevel*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ZipOutputStream) setMethod*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ZipOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                            p1 : INTEGER;
                                            p2 : INTEGER),EXTENSIBLE;

END java_util_zip.