lib/wrappers/s-z - Dropped 'T' from types
This commit is contained in:
pdw
Araq
parent
b2bc5440aa
commit
cbd8da93f4
15 changed files with 613 additions and 540 deletions
|
|
@ -59,12 +59,12 @@ else:
|
|||
{.pragma: mydll.}
|
||||
|
||||
type
|
||||
TZipSourceCmd* = int32
|
||||
ZipSourceCmd* = int32
|
||||
|
||||
TZipSourceCallback* = proc (state: pointer, data: pointer, length: int,
|
||||
cmd: TZipSourceCmd): int {.cdecl.}
|
||||
PZipStat* = ptr TZipStat
|
||||
TZipStat* = object ## the 'zip_stat' struct
|
||||
ZipSourceCallback* = proc (state: pointer, data: pointer, length: int,
|
||||
cmd: ZipSourceCmd): int {.cdecl.}
|
||||
PZipStat* = ptr ZipStat
|
||||
ZipStat* = object ## the 'zip_stat' struct
|
||||
name*: cstring ## name of the file
|
||||
index*: int32 ## index within archive
|
||||
crc*: int32 ## crc of file data
|
||||
|
|
@ -74,14 +74,16 @@ type
|
|||
compMethod*: int16 ## compression method used
|
||||
encryptionMethod*: int16 ## encryption method used
|
||||
|
||||
TZip = object
|
||||
TZipSource = object
|
||||
TZipFile = object
|
||||
|
||||
PZip* = ptr TZip ## represents a zip archive
|
||||
PZipFile* = ptr TZipFile ## represents a file within an archive
|
||||
PZipSource* = ptr TZipSource ## represents a source for an archive
|
||||
Zip = object
|
||||
ZipSource = object
|
||||
ZipFile = object
|
||||
|
||||
PZip* = ptr Zip ## represents a zip archive
|
||||
PZipFile* = ptr ZipFile ## represents a file within an archive
|
||||
PZipSource* = ptr ZipSource ## represents a source for an archive
|
||||
{.deprecated: [TZipSourceCmd: ZipSourceCmd, TZipStat: ZipStat, TZip: Zip,
|
||||
TZipSourceCallback: ZipSourceCallback, TZipSource: ZipSource,
|
||||
TZipFile: ZipFile].}
|
||||
|
||||
# flags for zip_name_locate, zip_fopen, zip_stat, ...
|
||||
const
|
||||
|
|
@ -229,7 +231,7 @@ proc zip_source_filep*(para1: PZip, para2: File, para3: int, para4: int): PZipSo
|
|||
cdecl, mydll, importc: "zip_source_filep".}
|
||||
proc zip_source_free*(para1: PZipSource) {.cdecl, mydll,
|
||||
importc: "zip_source_free".}
|
||||
proc zip_source_function*(para1: PZip, para2: TZipSourceCallback,
|
||||
proc zip_source_function*(para1: PZip, para2: ZipSourceCallback,
|
||||
para3: pointer): PZipSource {.cdecl, mydll,
|
||||
importc: "zip_source_function".}
|
||||
proc zip_source_zip*(para1: PZip, para2: PZip, para3: int32, para4: int32,
|
||||
|
|
|
|||
|
|
@ -17,11 +17,11 @@ type
|
|||
ZOffT* = int32
|
||||
Pbyte* = cstring
|
||||
Pbytef* = cstring
|
||||
TAllocfunc* = proc (p: pointer, items: Uint, size: Uint): pointer{.cdecl.}
|
||||
TFreeFunc* = proc (p: pointer, address: pointer){.cdecl.}
|
||||
TInternalState*{.final, pure.} = object
|
||||
PInternalState* = ptr TInternalState
|
||||
TZStream*{.final, pure.} = object
|
||||
Allocfunc* = proc (p: pointer, items: Uint, size: Uint): pointer{.cdecl.}
|
||||
FreeFunc* = proc (p: pointer, address: pointer){.cdecl.}
|
||||
InternalState*{.final, pure.} = object
|
||||
PInternalState* = ptr InternalState
|
||||
ZStream*{.final, pure.} = object
|
||||
nextIn*: Pbytef
|
||||
availIn*: Uint
|
||||
totalIn*: Ulong
|
||||
|
|
@ -30,16 +30,18 @@ type
|
|||
totalOut*: Ulong
|
||||
msg*: Pbytef
|
||||
state*: PInternalState
|
||||
zalloc*: TAllocfunc
|
||||
zfree*: TFreeFunc
|
||||
zalloc*: Allocfunc
|
||||
zfree*: FreeFunc
|
||||
opaque*: pointer
|
||||
dataType*: int32
|
||||
adler*: Ulong
|
||||
reserved*: Ulong
|
||||
|
||||
TZStreamRec* = TZStream
|
||||
PZstream* = ptr TZStream
|
||||
ZStreamRec* = ZStream
|
||||
PZstream* = ptr ZStream
|
||||
GzFile* = pointer
|
||||
{.deprecated: [TInternalState: InternalState, TAllocfunc: Allocfunc,
|
||||
TFreeFunc: FreeFunc, TZStream: ZStream, TZStreamRec: ZStreamRec].}
|
||||
|
||||
const
|
||||
Z_NO_FLUSH* = 0
|
||||
|
|
@ -70,29 +72,29 @@ const
|
|||
Z_NULL* = 0
|
||||
|
||||
proc zlibVersion*(): cstring{.cdecl, dynlib: libz, importc: "zlibVersion".}
|
||||
proc deflate*(strm: var TZStream, flush: int32): int32{.cdecl, dynlib: libz,
|
||||
proc deflate*(strm: var ZStream, flush: int32): int32{.cdecl, dynlib: libz,
|
||||
importc: "deflate".}
|
||||
proc deflateEnd*(strm: var TZStream): int32{.cdecl, dynlib: libz,
|
||||
proc deflateEnd*(strm: var ZStream): int32{.cdecl, dynlib: libz,
|
||||
importc: "deflateEnd".}
|
||||
proc inflate*(strm: var TZStream, flush: int32): int32{.cdecl, dynlib: libz,
|
||||
proc inflate*(strm: var ZStream, flush: int32): int32{.cdecl, dynlib: libz,
|
||||
importc: "inflate".}
|
||||
proc inflateEnd*(strm: var TZStream): int32{.cdecl, dynlib: libz,
|
||||
proc inflateEnd*(strm: var ZStream): int32{.cdecl, dynlib: libz,
|
||||
importc: "inflateEnd".}
|
||||
proc deflateSetDictionary*(strm: var TZStream, dictionary: Pbytef,
|
||||
proc deflateSetDictionary*(strm: var ZStream, dictionary: Pbytef,
|
||||
dictLength: Uint): int32{.cdecl, dynlib: libz,
|
||||
importc: "deflateSetDictionary".}
|
||||
proc deflateCopy*(dest, source: var TZStream): int32{.cdecl, dynlib: libz,
|
||||
proc deflateCopy*(dest, source: var ZStream): int32{.cdecl, dynlib: libz,
|
||||
importc: "deflateCopy".}
|
||||
proc deflateReset*(strm: var TZStream): int32{.cdecl, dynlib: libz,
|
||||
proc deflateReset*(strm: var ZStream): int32{.cdecl, dynlib: libz,
|
||||
importc: "deflateReset".}
|
||||
proc deflateParams*(strm: var TZStream, level: int32, strategy: int32): int32{.
|
||||
proc deflateParams*(strm: var ZStream, level: int32, strategy: int32): int32{.
|
||||
cdecl, dynlib: libz, importc: "deflateParams".}
|
||||
proc inflateSetDictionary*(strm: var TZStream, dictionary: Pbytef,
|
||||
proc inflateSetDictionary*(strm: var ZStream, dictionary: Pbytef,
|
||||
dictLength: Uint): int32{.cdecl, dynlib: libz,
|
||||
importc: "inflateSetDictionary".}
|
||||
proc inflateSync*(strm: var TZStream): int32{.cdecl, dynlib: libz,
|
||||
proc inflateSync*(strm: var ZStream): int32{.cdecl, dynlib: libz,
|
||||
importc: "inflateSync".}
|
||||
proc inflateReset*(strm: var TZStream): int32{.cdecl, dynlib: libz,
|
||||
proc inflateReset*(strm: var ZStream): int32{.cdecl, dynlib: libz,
|
||||
importc: "inflateReset".}
|
||||
proc compress*(dest: Pbytef, destLen: Pulongf, source: Pbytef, sourceLen: Ulong): cint{.
|
||||
cdecl, dynlib: libz, importc: "compress".}
|
||||
|
|
@ -137,45 +139,45 @@ proc adler32*(adler: Ulong, buf: Pbytef, length: Uint): Ulong{.cdecl,
|
|||
## **Warning**: Adler-32 requires at least a few hundred bytes to get rolling.
|
||||
proc crc32*(crc: Ulong, buf: Pbytef, length: Uint): Ulong{.cdecl, dynlib: libz,
|
||||
importc: "crc32".}
|
||||
proc deflateInitu*(strm: var TZStream, level: int32, version: cstring,
|
||||
proc deflateInitu*(strm: var ZStream, level: int32, version: cstring,
|
||||
streamSize: int32): int32{.cdecl, dynlib: libz,
|
||||
importc: "deflateInit_".}
|
||||
proc inflateInitu*(strm: var TZStream, version: cstring,
|
||||
proc inflateInitu*(strm: var ZStream, version: cstring,
|
||||
streamSize: int32): int32 {.
|
||||
cdecl, dynlib: libz, importc: "inflateInit_".}
|
||||
proc deflateInit*(strm: var TZStream, level: int32): int32
|
||||
proc inflateInit*(strm: var TZStream): int32
|
||||
proc deflateInit2u*(strm: var TZStream, level: int32, `method`: int32,
|
||||
proc deflateInit*(strm: var ZStream, level: int32): int32
|
||||
proc inflateInit*(strm: var ZStream): int32
|
||||
proc deflateInit2u*(strm: var ZStream, level: int32, `method`: int32,
|
||||
windowBits: int32, memLevel: int32, strategy: int32,
|
||||
version: cstring, streamSize: int32): int32 {.cdecl,
|
||||
dynlib: libz, importc: "deflateInit2_".}
|
||||
proc inflateInit2u*(strm: var TZStream, windowBits: int32, version: cstring,
|
||||
proc inflateInit2u*(strm: var ZStream, windowBits: int32, version: cstring,
|
||||
streamSize: int32): int32{.cdecl, dynlib: libz,
|
||||
importc: "inflateInit2_".}
|
||||
proc deflateInit2*(strm: var TZStream,
|
||||
proc deflateInit2*(strm: var ZStream,
|
||||
level, `method`, windowBits, memLevel,
|
||||
strategy: int32): int32
|
||||
proc inflateInit2*(strm: var TZStream, windowBits: int32): int32
|
||||
proc inflateInit2*(strm: var ZStream, windowBits: int32): int32
|
||||
proc zError*(err: int32): cstring{.cdecl, dynlib: libz, importc: "zError".}
|
||||
proc inflateSyncPoint*(z: PZstream): int32{.cdecl, dynlib: libz,
|
||||
importc: "inflateSyncPoint".}
|
||||
proc getCrcTable*(): pointer{.cdecl, dynlib: libz, importc: "get_crc_table".}
|
||||
|
||||
proc deflateInit(strm: var TZStream, level: int32): int32 =
|
||||
result = deflateInitu(strm, level, zlibVersion(), sizeof(TZStream).cint)
|
||||
proc deflateInit(strm: var ZStream, level: int32): int32 =
|
||||
result = deflateInitu(strm, level, zlibVersion(), sizeof(ZStream).cint)
|
||||
|
||||
proc inflateInit(strm: var TZStream): int32 =
|
||||
result = inflateInitu(strm, zlibVersion(), sizeof(TZStream).cint)
|
||||
proc inflateInit(strm: var ZStream): int32 =
|
||||
result = inflateInitu(strm, zlibVersion(), sizeof(ZStream).cint)
|
||||
|
||||
proc deflateInit2(strm: var TZStream,
|
||||
proc deflateInit2(strm: var ZStream,
|
||||
level, `method`, windowBits, memLevel,
|
||||
strategy: int32): int32 =
|
||||
result = deflateInit2u(strm, level, `method`, windowBits, memLevel,
|
||||
strategy, zlibVersion(), sizeof(TZStream).cint)
|
||||
strategy, zlibVersion(), sizeof(ZStream).cint)
|
||||
|
||||
proc inflateInit2(strm: var TZStream, windowBits: int32): int32 =
|
||||
proc inflateInit2(strm: var ZStream, windowBits: int32): int32 =
|
||||
result = inflateInit2u(strm, windowBits, zlibVersion(),
|
||||
sizeof(TZStream).cint)
|
||||
sizeof(ZStream).cint)
|
||||
|
||||
proc zlibAllocMem*(appData: pointer, items, size: int): pointer {.cdecl.} =
|
||||
result = alloc(items * size)
|
||||
|
|
@ -200,7 +202,7 @@ proc uncompress*(sourceBuf: cstring, sourceLen: int): string =
|
|||
## concatenated deflated values properly.
|
||||
assert (not sourceBuf.isNil)
|
||||
|
||||
var z: TZStream
|
||||
var z: ZStream
|
||||
# Initialize input.
|
||||
z.nextIn = sourceBuf
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,8 @@ else:
|
|||
dllname = "libzzip.so"
|
||||
|
||||
type
|
||||
TZZipError* = int32
|
||||
TZZipError* = int32 # Name conflict if we drop the `T`
|
||||
|
||||
const
|
||||
ZZIP_ERROR* = -4096'i32
|
||||
ZZIP_NO_ERROR* = 0'i32 # no error, may be used if user sets it.
|
||||
|
|
@ -54,119 +55,122 @@ const
|
|||
ZZIP_THREADED* = 1'i32 shl 19'i32
|
||||
|
||||
type
|
||||
TZZipDir* {.final, pure.} = object
|
||||
TZZipFile* {.final, pure.} = object
|
||||
TZZipPluginIO* {.final, pure.} = object
|
||||
ZZipDir* {.final, pure.} = object
|
||||
ZZipFile* {.final, pure.} = object
|
||||
ZZipPluginIO* {.final, pure.} = object
|
||||
|
||||
TZZipDirent* {.final, pure.} = object
|
||||
ZZipDirent* {.final, pure.} = object
|
||||
d_compr*: int32 ## compression method
|
||||
d_csize*: int32 ## compressed size
|
||||
st_size*: int32 ## file size / decompressed size
|
||||
d_name*: cstring ## file name / strdupped name
|
||||
|
||||
TZZipStat* = TZZipDirent
|
||||
ZZipStat* = ZZipDirent
|
||||
{.deprecated: [TZZipDir: ZzipDir, TZZipFile: ZzipFile,
|
||||
TZZipPluginIO: ZzipPluginIO, TZZipDirent: ZzipDirent,
|
||||
TZZipStat: ZZipStat].}
|
||||
|
||||
proc zzip_strerror*(errcode: int32): cstring {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_strerror".}
|
||||
proc zzip_strerror_of*(dir: ptr TZZipDir): cstring {.cdecl, dynlib: dllname,
|
||||
proc zzip_strerror_of*(dir: ptr ZZipDir): cstring {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_strerror_of".}
|
||||
proc zzip_errno*(errcode: int32): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_errno".}
|
||||
|
||||
proc zzip_geterror*(dir: ptr TZZipDir): int32 {.cdecl, dynlib: dllname,
|
||||
proc zzip_geterror*(dir: ptr ZZipDir): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_error".}
|
||||
proc zzip_seterror*(dir: ptr TZZipDir, errcode: int32) {.cdecl, dynlib: dllname,
|
||||
proc zzip_seterror*(dir: ptr ZZipDir, errcode: int32) {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_seterror".}
|
||||
proc zzip_compr_str*(compr: int32): cstring {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_compr_str".}
|
||||
proc zzip_dirhandle*(fp: ptr TZZipFile): ptr TZZipDir {.cdecl, dynlib: dllname,
|
||||
proc zzip_dirhandle*(fp: ptr ZZipFile): ptr ZZipDir {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_dirhandle".}
|
||||
proc zzip_dirfd*(dir: ptr TZZipDir): int32 {.cdecl, dynlib: dllname,
|
||||
proc zzip_dirfd*(dir: ptr ZZipDir): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_dirfd".}
|
||||
proc zzip_dir_real*(dir: ptr TZZipDir): int32 {.cdecl, dynlib: dllname,
|
||||
proc zzip_dir_real*(dir: ptr ZZipDir): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_dir_real".}
|
||||
proc zzip_file_real*(fp: ptr TZZipFile): int32 {.cdecl, dynlib: dllname,
|
||||
proc zzip_file_real*(fp: ptr ZZipFile): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_file_real".}
|
||||
proc zzip_realdir*(dir: ptr TZZipDir): pointer {.cdecl, dynlib: dllname,
|
||||
proc zzip_realdir*(dir: ptr ZZipDir): pointer {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_realdir".}
|
||||
proc zzip_realfd*(fp: ptr TZZipFile): int32 {.cdecl, dynlib: dllname,
|
||||
proc zzip_realfd*(fp: ptr ZZipFile): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_realfd".}
|
||||
|
||||
proc zzip_dir_alloc*(fileext: cstringArray): ptr TZZipDir {.cdecl,
|
||||
proc zzip_dir_alloc*(fileext: cstringArray): ptr ZZipDir {.cdecl,
|
||||
dynlib: dllname, importc: "zzip_dir_alloc".}
|
||||
proc zzip_dir_free*(para1: ptr TZZipDir): int32 {.cdecl, dynlib: dllname,
|
||||
proc zzip_dir_free*(para1: ptr ZZipDir): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_dir_free".}
|
||||
|
||||
proc zzip_dir_fdopen*(fd: int32, errcode_p: ptr TZZipError): ptr TZZipDir {.cdecl,
|
||||
proc zzip_dir_fdopen*(fd: int32, errcode_p: ptr TZZipError): ptr ZZipDir {.cdecl,
|
||||
dynlib: dllname, importc: "zzip_dir_fdopen".}
|
||||
proc zzip_dir_open*(filename: cstring, errcode_p: ptr TZZipError): ptr TZZipDir {.
|
||||
proc zzip_dir_open*(filename: cstring, errcode_p: ptr TZZipError): ptr ZZipDir {.
|
||||
cdecl, dynlib: dllname, importc: "zzip_dir_open".}
|
||||
proc zzip_dir_close*(dir: ptr TZZipDir) {.cdecl, dynlib: dllname,
|
||||
proc zzip_dir_close*(dir: ptr ZZipDir) {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_dir_close".}
|
||||
proc zzip_dir_read*(dir: ptr TZZipDir, dirent: ptr TZZipDirent): int32 {.cdecl,
|
||||
proc zzip_dir_read*(dir: ptr ZZipDir, dirent: ptr ZZipDirent): int32 {.cdecl,
|
||||
dynlib: dllname, importc: "zzip_dir_read".}
|
||||
|
||||
proc zzip_opendir*(filename: cstring): ptr TZZipDir {.cdecl, dynlib: dllname,
|
||||
proc zzip_opendir*(filename: cstring): ptr ZZipDir {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_opendir".}
|
||||
proc zzip_closedir*(dir: ptr TZZipDir) {.cdecl, dynlib: dllname,
|
||||
proc zzip_closedir*(dir: ptr ZZipDir) {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_closedir".}
|
||||
proc zzip_readdir*(dir: ptr TZZipDir): ptr TZZipDirent {.cdecl, dynlib: dllname,
|
||||
proc zzip_readdir*(dir: ptr ZZipDir): ptr ZZipDirent {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_readdir".}
|
||||
proc zzip_rewinddir*(dir: ptr TZZipDir) {.cdecl, dynlib: dllname,
|
||||
proc zzip_rewinddir*(dir: ptr ZZipDir) {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_rewinddir".}
|
||||
proc zzip_telldir*(dir: ptr TZZipDir): int {.cdecl, dynlib: dllname,
|
||||
proc zzip_telldir*(dir: ptr ZZipDir): int {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_telldir".}
|
||||
proc zzip_seekdir*(dir: ptr TZZipDir, offset: int) {.cdecl, dynlib: dllname,
|
||||
proc zzip_seekdir*(dir: ptr ZZipDir, offset: int) {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_seekdir".}
|
||||
|
||||
proc zzip_file_open*(dir: ptr TZZipDir, name: cstring, flags: int32): ptr TZZipFile {.
|
||||
proc zzip_file_open*(dir: ptr ZZipDir, name: cstring, flags: int32): ptr ZZipFile {.
|
||||
cdecl, dynlib: dllname, importc: "zzip_file_open".}
|
||||
proc zzip_file_close*(fp: ptr TZZipFile) {.cdecl, dynlib: dllname,
|
||||
proc zzip_file_close*(fp: ptr ZZipFile) {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_file_close".}
|
||||
proc zzip_file_read*(fp: ptr TZZipFile, buf: pointer, length: int): int {.
|
||||
proc zzip_file_read*(fp: ptr ZZipFile, buf: pointer, length: int): int {.
|
||||
cdecl, dynlib: dllname, importc: "zzip_file_read".}
|
||||
proc zzip_open*(name: cstring, flags: int32): ptr TZZipFile {.cdecl,
|
||||
proc zzip_open*(name: cstring, flags: int32): ptr ZZipFile {.cdecl,
|
||||
dynlib: dllname, importc: "zzip_open".}
|
||||
proc zzip_close*(fp: ptr TZZipFile) {.cdecl, dynlib: dllname,
|
||||
proc zzip_close*(fp: ptr ZZipFile) {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_close".}
|
||||
proc zzip_read*(fp: ptr TZZipFile, buf: pointer, length: int): int {.
|
||||
proc zzip_read*(fp: ptr ZZipFile, buf: pointer, length: int): int {.
|
||||
cdecl, dynlib: dllname, importc: "zzip_read".}
|
||||
|
||||
proc zzip_freopen*(name: cstring, mode: cstring, para3: ptr TZZipFile): ptr TZZipFile {.
|
||||
proc zzip_freopen*(name: cstring, mode: cstring, para3: ptr ZZipFile): ptr ZZipFile {.
|
||||
cdecl, dynlib: dllname, importc: "zzip_freopen".}
|
||||
proc zzip_fopen*(name: cstring, mode: cstring): ptr TZZipFile {.cdecl,
|
||||
proc zzip_fopen*(name: cstring, mode: cstring): ptr ZZipFile {.cdecl,
|
||||
dynlib: dllname, importc: "zzip_fopen".}
|
||||
proc zzip_fread*(p: pointer, size: int, nmemb: int,
|
||||
file: ptr TZZipFile): int {.cdecl, dynlib: dllname,
|
||||
file: ptr ZZipFile): int {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_fread".}
|
||||
proc zzip_fclose*(fp: ptr TZZipFile) {.cdecl, dynlib: dllname,
|
||||
proc zzip_fclose*(fp: ptr ZZipFile) {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_fclose".}
|
||||
|
||||
proc zzip_rewind*(fp: ptr TZZipFile): int32 {.cdecl, dynlib: dllname,
|
||||
proc zzip_rewind*(fp: ptr ZZipFile): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_rewind".}
|
||||
proc zzip_seek*(fp: ptr TZZipFile, offset: int, whence: int32): int {.
|
||||
proc zzip_seek*(fp: ptr ZZipFile, offset: int, whence: int32): int {.
|
||||
cdecl, dynlib: dllname, importc: "zzip_seek".}
|
||||
proc zzip_tell*(fp: ptr TZZipFile): int {.cdecl, dynlib: dllname,
|
||||
proc zzip_tell*(fp: ptr ZZipFile): int {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_tell".}
|
||||
|
||||
proc zzip_dir_stat*(dir: ptr TZZipDir, name: cstring, zs: ptr TZZipStat,
|
||||
proc zzip_dir_stat*(dir: ptr ZZipDir, name: cstring, zs: ptr ZZipStat,
|
||||
flags: int32): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_dir_stat".}
|
||||
proc zzip_file_stat*(fp: ptr TZZipFile, zs: ptr TZZipStat): int32 {.cdecl,
|
||||
proc zzip_file_stat*(fp: ptr ZZipFile, zs: ptr ZZipStat): int32 {.cdecl,
|
||||
dynlib: dllname, importc: "zzip_file_stat".}
|
||||
proc zzip_fstat*(fp: ptr TZZipFile, zs: ptr TZZipStat): int32 {.cdecl, dynlib: dllname,
|
||||
proc zzip_fstat*(fp: ptr ZZipFile, zs: ptr ZZipStat): int32 {.cdecl, dynlib: dllname,
|
||||
importc: "zzip_fstat".}
|
||||
|
||||
proc zzip_open_shared_io*(stream: ptr TZZipFile, name: cstring,
|
||||
proc zzip_open_shared_io*(stream: ptr ZZipFile, name: cstring,
|
||||
o_flags: int32, o_modes: int32, ext: cstringArray,
|
||||
io: ptr TZZipPluginIO): ptr TZZipFile {.cdecl,
|
||||
io: ptr ZZipPluginIO): ptr ZZipFile {.cdecl,
|
||||
dynlib: dllname, importc: "zzip_open_shared_io".}
|
||||
proc zzip_open_ext_io*(name: cstring, o_flags: int32, o_modes: int32,
|
||||
ext: cstringArray, io: ptr TZZipPluginIO): ptr TZZipFile {.
|
||||
ext: cstringArray, io: ptr ZZipPluginIO): ptr ZZipFile {.
|
||||
cdecl, dynlib: dllname, importc: "zzip_open_ext_io".}
|
||||
proc zzip_opendir_ext_io*(name: cstring, o_modes: int32,
|
||||
ext: cstringArray, io: ptr TZZipPluginIO): ptr TZZipDir {.
|
||||
ext: cstringArray, io: ptr ZZipPluginIO): ptr ZZipDir {.
|
||||
cdecl, dynlib: dllname, importc: "zzip_opendir_ext_io".}
|
||||
proc zzip_dir_open_ext_io*(filename: cstring, errcode_p: ptr TZZipError,
|
||||
ext: cstringArray, io: ptr TZZipPluginIO): ptr TZZipDir {.
|
||||
ext: cstringArray, io: ptr ZZipPluginIO): ptr ZZipDir {.
|
||||
cdecl, dynlib: dllname, importc: "zzip_dir_open_ext_io".}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue