WebSVN – Kolibri OS – Diff – /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
 
 
 
 
 
 
;void (m)
;    char *m
align 4
proc z_error, m:dword
;    fprintf(stderr, "%s\n", m);
;    exit(1);
	ret
endp
 
 
; exported to allow conversion of error code to string for compress() and
; uncompress()
 
;const char * (err)
;    int err
align 4
proc zError uses ecx, err:dword
	ERR_MSG [err]
	mov eax,ecx
	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
 
 
 
;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
 
 

Rev 6617	Rev 6639
1	; zutil.asm -- target dependent utility functions for the compression library	1	; zutil.asm -- target dependent utility functions for the compression library
2	; Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.	2	; Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
3	; For conditions of distribution and use, see copyright notice in zlib.inc	3	; For conditions of distribution and use, see copyright notice in zlib.inc
4		4
5	align 4	5	align 4
6	z_errmsg dd ze0,ze1,ze2,ze3,ze4,ze5,ze6,ze7,ze8,ze9	6	z_errmsg dd ze0,ze1,ze2,ze3,ze4,ze5,ze6,ze7,ze8,ze9
7	ze0 db 'need dictionary',0 ;Z_NEED_DICT 2	7	ze0 db 'need dictionary',0 ;Z_NEED_DICT 2
8	ze1 db 'stream end',0 ;Z_STREAM_END 1	8	ze1 db 'stream end',0 ;Z_STREAM_END 1
9	ze2 db '',0 ;Z_OK 0	9	ze2 db '',0 ;Z_OK 0
10	ze3 db 'file error',0 ;Z_ERRNO (-1)	10	ze3 db 'file error',0 ;Z_ERRNO (-1)
11	ze4 db 'stream error',0 ;Z_STREAM_ERROR (-2)	11	ze4 db 'stream error',0 ;Z_STREAM_ERROR (-2)
12	ze5 db 'data error',0 ;Z_DATA_ERROR (-3)	12	ze5 db 'data error',0 ;Z_DATA_ERROR (-3)
13	ze6 db 'insufficient memory',0 ;Z_MEM_ERROR (-4)	13	ze6 db 'insufficient memory',0 ;Z_MEM_ERROR (-4)
14	ze7 db 'buffer error',0 ;Z_BUF_ERROR (-5)	14	ze7 db 'buffer error',0 ;Z_BUF_ERROR (-5)
15	ze8 db 'incompatible version',0 ;Z_VERSION_ERROR (-6)	15	ze8 db 'incompatible version',0 ;Z_VERSION_ERROR (-6)
16	ze9 db '',0	16	ze9 db '',0
17		17
18	;const char * ()	18	;const char * ()
19	align 4	19	align 4
20	proc zlibVersion	20	proc zlibVersion
21	mov eax,ZLIB_VERSION;	21	mov eax,ZLIB_VERSION;
22	ret	22	ret
23	endp	23	endp
24		24
25	;uLong ()	25	;uLong ()
26	align 4	26	align 4
27	proc zlibCompileFlags	27	proc zlibCompileFlags
28	; uLong flags;	28	; uLong flags;
29		29
30	; flags = 0;	30	; flags = 0;
31	; switch ((int)(sizeof(uInt))) {	31	; switch ((int)(sizeof(uInt))) {
32	; case 2: break;	32	; case 2: break;
33	; case 4: flags += 1; break;	33	; case 4: flags += 1; break;
34	; case 8: flags += 2; break;	34	; case 8: flags += 2; break;
35	; default: flags += 3;	35	; default: flags += 3;
36	; }	36	; }
37	; switch ((int)(sizeof(uLong))) {	37	; switch ((int)(sizeof(uLong))) {
38	; case 2: break;	38	; case 2: break;
39	; case 4: flags += 1 << 2; break;	39	; case 4: flags += 1 << 2; break;
40	; case 8: flags += 2 << 2; break;	40	; case 8: flags += 2 << 2; break;
41	; default: flags += 3 << 2;	41	; default: flags += 3 << 2;
42	; }	42	; }
43	; switch ((int)(sizeof(voidpf))) {	43	; switch ((int)(sizeof(voidpf))) {
44	; case 2: break;	44	; case 2: break;
45	; case 4: flags += 1 << 4; break;	45	; case 4: flags += 1 << 4; break;
46	; case 8: flags += 2 << 4; break;	46	; case 8: flags += 2 << 4; break;
47	; default: flags += 3 << 4;	47	; default: flags += 3 << 4;
48	; }	48	; }
49	; switch ((int)(sizeof(z_off_t))) {	49	; switch ((int)(sizeof(z_off_t))) {
50	; case 2: break;	50	; case 2: break;
51	; case 4: flags += 1 << 6; break;	51	; case 4: flags += 1 << 6; break;
52	; case 8: flags += 2 << 6; break;	52	; case 8: flags += 2 << 6; break;
53	; default: flags += 3 << 6;	53	; default: flags += 3 << 6;
54	; }	54	; }
55	;if DEBUG	55	;if DEBUG
56	; flags += 1 << 8;	56	; flags += 1 << 8;
57	;end if	57	;end if
58	;#if defined(ASMV) \|\| defined(ASMINF)	58	;#if defined(ASMV) \|\| defined(ASMINF)
59	; flags += 1 << 9;	59	; flags += 1 << 9;
60	;end if	60	;end if
61	if ZLIB_WINAPI eq 1	61	if ZLIB_WINAPI eq 1
62	; flags += 1 << 10;	62	; flags += 1 << 10;
63	end if	63	end if
64	if BUILDFIXED eq 1	64	if BUILDFIXED eq 1
65	; flags += 1 << 12;	65	; flags += 1 << 12;
66	end if	66	end if
67	if DYNAMIC_CRC_TABLE eq 1	67	if DYNAMIC_CRC_TABLE eq 1
68	; flags += 1 << 13;	68	; flags += 1 << 13;
69	end if	69	end if
70	if NO_GZCOMPRESS eq 1	70	if NO_GZCOMPRESS eq 1
71	; flags += 1L << 16;	71	; flags += 1L << 16;
72	end if	72	end if
73	if NO_GZIP eq 1	73	if NO_GZIP eq 1
74	; flags += 1L << 17;	74	; flags += 1L << 17;
75	end if	75	end if
76	if PKZIP_BUG_WORKAROUND eq 1	76	if PKZIP_BUG_WORKAROUND eq 1
77	; flags += 1L << 20;	77	; flags += 1L << 20;
78	end if	78	end if
79	if FASTEST eq 1	79	if FASTEST eq 1
80	; flags += 1L << 21;	80	; flags += 1L << 21;
81	end if	81	end if
82	;#if defined(STDC) \|\| defined(Z_HAVE_STDARG_H)	82	;#if defined(STDC) \|\| defined(Z_HAVE_STDARG_H)
83	;# ifdef NO_vsnprintf	83	;# ifdef NO_vsnprintf
84	; flags += 1L << 25;	84	; flags += 1L << 25;
85	;# ifdef HAS_vsprintf_void	85	;# ifdef HAS_vsprintf_void
86	; flags += 1L << 26;	86	; flags += 1L << 26;
87	;# endif	87	;# endif
88	;# else	88	;# else
89	;# ifdef HAS_vsnprintf_void	89	;# ifdef HAS_vsnprintf_void
90	; flags += 1L << 26;	90	; flags += 1L << 26;
91	;# endif	91	;# endif
92	;# endif	92	;# endif
93	;#else	93	;#else
94	; flags += 1L << 24;	94	; flags += 1L << 24;
95	;# ifdef NO_snprintf	95	;# ifdef NO_snprintf
96	; flags += 1L << 25;	96	; flags += 1L << 25;
97	;# ifdef HAS_sprintf_void	97	;# ifdef HAS_sprintf_void
98	; flags += 1L << 26;	98	; flags += 1L << 26;
99	;# endif	99	;# endif
100	;# else	100	;# else
101	;# ifdef HAS_snprintf_void	101	;# ifdef HAS_snprintf_void
102	; flags += 1L << 26;	102	; flags += 1L << 26;
103	;# endif	103	;# endif
104	;# endif	104	;# endif
105	;end if	105	;end if
106	; return flags;	106	; return flags;
107	ret	107	ret
108	endp	108	endp
109		-
110	;if DEBUG	-
111		-
112	;# define verbose 0	-
113	;int z_verbose = verbose;	-
114		109
115	;void (m)	110	;void (m)
116	; char *m;	111	; char *m
117	align 4	112	align 4
118	proc z_error, m:dword	113	proc z_error, m:dword
119	; fprintf(stderr, "%s\n", m);	114	; fprintf(stderr, "%s\n", m);
120	; exit(1);	115	; exit(1);
121	ret	116	ret
122	endp	117	endp
123	;end if	-
124		118
125	; exported to allow conversion of error code to string for compress() and	119	; exported to allow conversion of error code to string for compress() and
126	; uncompress()	120	; uncompress()
127		121
128	;const char * (err)	122	;const char * (err)
129	; int err;	123	; int err
130	align 4	124	align 4
131	proc zError, err:dword	125	proc zError uses ecx, err:dword
132	; return ERR_MSG(err);	126	ERR_MSG [err]
-		127	mov eax,ecx
133	ret	128	ret
134	endp	129	endp
135		130
136	;#ifndef HAVE_MEMCPY	131	;#ifndef HAVE_MEMCPY
137		132
138	;void (dest, source, len)	133	;void (dest, source, len)
139	; Bytef* dest;	134	; Bytef* dest
140	; const Bytef* source;	135	; const Bytef* source
141	; uInt len;	136	; uInt len
142	align 4	137	align 4
143	proc zmemcpy uses ecx edi esi, dest:dword, source:dword, len:dword	138	proc zmemcpy uses ecx edi esi, dest:dword, source:dword, len:dword
144	mov ecx,[len]	139	mov ecx,[len]
145	cmp ecx,0	140	cmp ecx,0
146	jle @f	141	jle @f
147	mov edi,[dest]	142	mov edi,[dest]
148	mov esi,[source]	143	mov esi,[source]
149	rep movsb	144	rep movsb
150	jmp .end0	145	jmp .end0
151	@@:	146	@@:
152	zlib_debug 'zmemcpy size = %d',ecx	147	zlib_debug 'zmemcpy size = %d',ecx
153	.end0:	148	.end0:
154	ret	149	ret
155	endp	150	endp
156		151
157	;int (s1, s2, len)	152	;int (s1, s2, len)
158	; const Bytef* s1;	153	; const Bytef* s1
159	; const Bytef* s2;	154	; const Bytef* s2
160	; uInt len;	155	; uInt len
161	align 4	156	align 4
162	proc zmemcmp, s1:dword, s2:dword, len:dword	157	proc zmemcmp, s1:dword, s2:dword, len:dword
163	; uInt j;	158	; uInt j;
164		159
165	; for (j = 0; j < len; j++) {	160	; for (j = 0; j < len; j++) {
166	; if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;	161	; if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
167	; }	162	; }
168	; return 0;	163	; return 0;
169	ret	164	ret
170	endp	165	endp
171		166
172	;void (dest, len)	167	;void (dest, len)
173	; Bytef* dest;	168	; Bytef* dest
174	; uInt len;	169	; uInt len
175	align 4	170	align 4
176	proc zmemzero, dest:dword, len:dword	171	proc zmemzero, dest:dword, len:dword
177	; if (len == 0) return;	172	; if (len == 0) return;
178	; do {	173	; do {
179	; dest++ = 0; / ??? to be unrolled */	174	; dest++ = 0; / ??? to be unrolled */
180	; } while (--len != 0);	175	; } while (--len != 0);
181	ret	176	ret
182	endp	177	endp
183	;end if	178	;end if
184		-
185	;#ifndef Z_SOLO	-
186		179
187	;voidpf (voidpf opaque, unsigned items, unsigned size)	180	;voidpf (voidpf opaque, unsigned items, unsigned size)
188	align 4	181	align 4
189	proc zcalloc uses ebx ecx, opaque:dword, items:dword, size:dword	182	proc zcalloc uses ebx ecx, opaque:dword, items:dword, size:dword
190	mov ecx,[size]	183	mov ecx,[size]
191	imul ecx,[items]	184	imul ecx,[items]
192	mcall SF_SYS_MISC, SSF_MEM_ALLOC	185	mcall SF_SYS_MISC, SSF_MEM_ALLOC
193	ret	186	ret
194	endp	187	endp
195		188
196	;void (voidpf opaque, voidpf ptr)	189	;void (voidpf opaque, voidpf ptr)
197	align 4	190	align 4
198	proc zcfree uses eax ebx ecx, opaque:dword, p2ptr:dword	191	proc zcfree uses eax ebx ecx, opaque:dword, p2ptr:dword
199	mcall SF_SYS_MISC, SSF_MEM_FREE, [p2ptr]	192	mcall SF_SYS_MISC, SSF_MEM_FREE, [p2ptr]
200	ret	193	ret
201	endp	194	endp
202		-
203	;end if /* !Z_SOLO */	-

Subversion Repositories Kolibri OS

(root)/programs/fs/kfar/trunk/zlib/zutil.asm @ 6617 – Rev 6617 → 6639