kolibrios/programs/fs/kfar/trunk/zlib/zutil.asm

; zutil.asm -- target dependent utility functions for the compression library
; Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
; For conditions of distribution and use, see copyright notice in zlib.inc

align 4
z_errmsg dd ze0,ze1,ze2,ze3,ze4,ze5,ze6,ze7,ze8,ze9
ze0 db 'need dictionary',0 ;Z_NEED_DICT       2
ze1 db 'stream end',0      ;Z_STREAM_END      1
ze2 db '',0                ;Z_OK              0
ze3 db 'file error',0      ;Z_ERRNO         (-1)
ze4 db 'stream error',0    ;Z_STREAM_ERROR  (-2)
ze5 db 'data error',0      ;Z_DATA_ERROR    (-3)
ze6 db 'insufficient memory',0  ;Z_MEM_ERROR     (-4)
ze7 db 'buffer error',0         ;Z_BUF_ERROR     (-5)
ze8 db 'incompatible version',0 ;Z_VERSION_ERROR (-6)
ze9 db '',0

;const char * ()
align 4
proc zlibVersion
	mov eax,ZLIB_VERSION;
	ret
endp

;uLong ()
align 4
proc zlibCompileFlags
;    uLong flags;

;    flags = 0;
;    switch ((int)(sizeof(uInt))) {
;    case 2:     break;
;    case 4:     flags += 1;     break;
;    case 8:     flags += 2;     break;
;    default:    flags += 3;
;    }
;    switch ((int)(sizeof(uLong))) {
;    case 2:     break;
;    case 4:     flags += 1 << 2;        break;
;    case 8:     flags += 2 << 2;        break;
;    default:    flags += 3 << 2;
;    }
;    switch ((int)(sizeof(voidpf))) {
;    case 2:     break;
;    case 4:     flags += 1 << 4;        break;
;    case 8:     flags += 2 << 4;        break;
;    default:    flags += 3 << 4;
;    }
;    switch ((int)(sizeof(z_off_t))) {
;    case 2:     break;
;    case 4:     flags += 1 << 6;        break;
;    case 8:     flags += 2 << 6;        break;
;    default:    flags += 3 << 6;
;    }
;if DEBUG
;    flags += 1 << 8;
;end if
;#if defined(ASMV) || defined(ASMINF)
;    flags += 1 << 9;
;end if
if ZLIB_WINAPI eq 1
;    flags += 1 << 10;
end if
if BUILDFIXED eq 1
;    flags += 1 << 12;
end if
if DYNAMIC_CRC_TABLE eq 1
;    flags += 1 << 13;
end if
if NO_GZCOMPRESS eq 1
;    flags += 1L << 16;
end if
if NO_GZIP eq 1
;    flags += 1L << 17;
end if
if PKZIP_BUG_WORKAROUND eq 1
;    flags += 1L << 20;
end if
if FASTEST eq 1
;    flags += 1L << 21;
end if
;#if defined(STDC) || defined(Z_HAVE_STDARG_H)
;#  ifdef NO_vsnprintf
;    flags += 1L << 25;
;#    ifdef HAS_vsprintf_void
;    flags += 1L << 26;
;#    endif
;#  else
;#    ifdef HAS_vsnprintf_void
;    flags += 1L << 26;
;#    endif
;#  endif
;#else
;    flags += 1L << 24;
;#  ifdef NO_snprintf
;    flags += 1L << 25;
;#    ifdef HAS_sprintf_void
;    flags += 1L << 26;
;#    endif
;#  else
;#    ifdef HAS_snprintf_void
;    flags += 1L << 26;
;#    endif
;#  endif
;end if
;    return flags;
	ret
endp

;if DEBUG

;#    define verbose 0
;int z_verbose = verbose;

;void (m)
;    char *m;
align 4
proc z_error, m:dword
;    fprintf(stderr, "%s\n", m);
;    exit(1);
	ret
endp
;end if

; exported to allow conversion of error code to string for compress() and
; uncompress()

;const char * (err)
;    int err;
align 4
proc zError, err:dword
;    return ERR_MSG(err);
	ret
endp

;#ifndef HAVE_MEMCPY

;void (dest, source, len)
;    Bytef* dest;
;    const Bytef* source;
;    uInt  len;
align 4
proc zmemcpy uses ecx edi esi, dest:dword, source:dword, len:dword
	mov ecx,[len]
	cmp ecx,0
	jle @f
		mov edi,[dest]
		mov esi,[source]
		rep movsb
		jmp .end0
	@@:
zlib_debug 'zmemcpy size = %d',ecx
	.end0:
	ret
endp

;int (s1, s2, len)
;    const Bytef* s1;
;    const Bytef* s2;
;    uInt  len;
align 4
proc zmemcmp, s1:dword, s2:dword, len:dword
;    uInt j;

;    for (j = 0; j < len; j++) {
;        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
;    }
;    return 0;
	ret
endp

;void (dest, len)
;    Bytef* dest;
;    uInt  len;
align 4
proc zmemzero, dest:dword, len:dword
;    if (len == 0) return;
;    do {
;        *dest++ = 0;  /* ??? to be unrolled */
;    } while (--len != 0);
	ret
endp
;end if

;#ifndef Z_SOLO

;voidpf (voidpf opaque, unsigned items, unsigned size)
align 4
proc zcalloc uses ebx ecx, opaque:dword, items:dword, size:dword
	mov ecx,[size]
	imul ecx,[items]
	mcall SF_SYS_MISC, SSF_MEM_ALLOC
	ret
endp

;void (voidpf opaque, voidpf ptr)
align 4
proc zcfree uses eax ebx ecx, opaque:dword, p2ptr:dword
	mcall SF_SYS_MISC, SSF_MEM_FREE, [p2ptr]
	ret
endp

;end if /* !Z_SOLO */