WebSVN – Kolibri OS – Diff – /programs/develop/fasm/trunk/system.inc


; flat assembler
; Copyright (c) 1999-2012, Tomasz Grysztar
; All rights reserved.
 
struc FILEIO
{   .cmd            dd ?
    .offset         dd ?
                    dd ?
    .count          dd ?
    .buff           dd ?
                    db ?
    .name           dd ?
};
 
struc FILEINFO
{   .attr           dd ?
    .flags          dd ?
    .cr_time        dd ?
    .cr_date        dd ?
    .acc_time       dd ?
    .acc_date       dd ?
    .mod_time       dd ?
    .mod_date       dd ?
    .size           dd ?
}
 
 
 
;file_info_open:  dd 0,0,0xffffff,0x20000,0xf0000
fullpath_open:  ;  db '/RD/1/EXAMPLE.ASM'
		    times MAX_PATH db 0
 
 
;file_info_write: dd 1,0,0,0,0xf0000
fullpath_write:; db '/RD/1/EXAMPLE'
		    times MAX_PATH db 0
 
file_info_start:
    dd 7
    dd 0
    dd 0
    dd 0
    dd 0
fullpath_start:  ; db '/RD/1/EXAMPLE'
		    times MAX_PATH db 0
 
file_info_debug:
	dd	7
	dd	0
	dd	fullpath_start
	dd	0, 0
	db	'/SYS/DEVELOP/MTDBG',0
 
_ramdisk	 db '/RD/1/'
filepos 	 dd 0x0
 
 
init_memory:
 
;        mov ecx, 16*1024*1024
;
; allocate_memory:
	mcall	18, 16
	cmp	eax, 0x38000000 shr 9
	jbe	@f
	mov	eax, 0x38000000 shr 9
@@:
	shl	eax, 9
	xchg	eax, ecx
	mov	[memory_setting],ecx
	mcall	68, 12
	or	eax,eax
	jz	out_of_memory
	mov	[memblock], eax
	mov	[additional_memory],eax
	add	eax,[memory_setting]
	mov	[memory_end],eax
	mov	eax,[memory_setting]
	shr	eax,2
	add	eax,[additional_memory]
	mov	[additional_memory_end],eax
	mov	[memory_start],eax
	ret
 
exit_program:
	cmp	[_mode],NORMAL_MODE
	jne	@f
	mcall	68, 13, [memblock]
	jmp	still
@@:
	or	eax,-1
	mcall
 
make_timestamp:
	push	ebx
	mcall	26,9
	imul	eax,10
	pop	ebx
	ret
 
symbol_dump:
 
	push	edi
	mov	edx,[memory_end]
      symb_dump:
	cmp	edx,[labels_list]
	jbe	symbols_dumped
	sub	edx,LABEL_STRUCTURE_SIZE
	cmp	dword [edx+24],0
	je	symb_dump	; do not dump anonymous symbols
	test	byte [edx+8],1
	jz	symb_dump	; do not dump symbols that didn't get defined
	mov	ax,[current_pass]
	cmp	ax,[edx+16]
	jne	symb_dump
	test	byte [edx+8],4 or 2
	jnz	symb_dump	; do not dump assembly-time variables
				; do not dump variables defined with '='
	cmp	word [edx+12], 0
	jnz	symb_dump	; do not dump register-based variables
 
	mov	al, '0'
	stosb
	mov	al, 'x'
	stosb
	mov	eax, [edx+4]
	mov	ecx, 8
@@:
	rol	eax, 4
	test	al, 0xF
	loopz	@b
	jz	.nohigh
	inc	ecx
@@:
	push	eax
	and	al, 0xF
	cmp	al, 10
	sbb	al, 69h
	das
	stosb
	pop	eax
	rol	eax, 4
	loop	@b
	mov	eax, [edx]
	mov	ecx, 8
	jmp	.low
.nohigh:
	mov	eax, [edx]
	mov	ecx, 8
@@:
	rol	eax, 4
	test	al, 0xF
	loopz	@b
	inc	ecx
.low:
	push	eax
	and	al, 0xF
	cmp	al, 10
	sbb	al, 69h
	das
	stosb
	pop	eax
	rol	eax, 4
	loop	.low
 
	mov	al, ' '
	stosb
 
	mov	esi,[edx+24]
	movzx	ecx,byte [esi-1]
	rep	movsb
 
	mov	ax,0A0Dh
	stosw
 
	jmp	symb_dump
 
      symbols_dumped:
	mov	edx,dbgfilename
        push    esi edi
	mov     esi, outfile
	mov     edi, edx
@@:
	lodsb
	stosb
	test	al, al
	jnz	@b
	lea	ecx, [edi-1]
@@:
	dec	edi
	cmp	edi, edx
	jb	@f
	cmp	byte [edi], '/'
	jz	@f
	cmp	byte [edi], '.'
	jnz	@b
	mov	ecx, edi
@@:
	mov	dword [ecx], '.dbg'
	mov     byte [ecx+4], 0
	pop	edi esi
	call	create
	mov	edx,[esp]
	mov	ecx,edi
	sub	ecx,edx
	call	write
	call	close
	pop	edi
 
	ret
 
get_environment_variable:
	mov	ecx,[memory_end]
	sub	ecx,edi
	cmp	ecx,7
	jb	out_of_memory
	cmp	dword[esi],'INCL'
	jne	.finish
	mov	esi,_ramdisk
	mov	ecx,6
	cld
	rep	movsb
  .finish:
;       stc
	ret
 
alloc_handle:
        call    make_fullpaths
        mov     ebx, fileinfos+4
@@:
        cmp     dword [ebx], -1
        jz      .found
        add     ebx, 4+20+MAX_PATH
        cmp     ebx, fileinfos_end
        jb      @b
        stc
        ret
.found:
        and     dword [ebx+4], 0
        and     dword [ebx+8], 0
        push    esi edi ecx
        mov     esi, fullpath_open
        lea     edi, [ebx+20]
        mov     ecx, MAX_PATH
        rep     movsb
        pop     ecx edi esi
        ret	; CF=0
 
create:
        call    alloc_handle
        jc      .ret
        and     dword [ebx-4], 0
        mov     dword [ebx], 2
.ret:
        ret
 
 
open:
;        call    make_fullpaths
 
;;       mov     eax,fullpath_open
;;       DEBUGF  '"%s"\n',eax
 
;        mov     dword[file_info_open+8],-1
;        mcall   58,file_info_open
;        or      eax,eax                 ; found
;        jz      @f
;        cmp     eax,6
;        jne     file_error
;@@: mov [filesize],ebx
;        clc
;        ret
;file_error:
;        stc
;        ret
 
        call    alloc_handle
        jc      .ret
        mov     dword [ebx], 5
        and     dword [ebx+12], 0
        mov     dword [ebx+16], fileinfo
        mov     eax, 70
        push    ebx
        mcall
        pop     ebx
        test    eax, eax
        jnz     .fail
        mov     eax, [fileinfo.size]
        mov     [ebx-4], eax
        and     dword [ebx], 0
.ret:
        ret
.fail:
	or	dword [ebx], -1	; close handle
        stc
        ret
 
read:
;          pusha
;          mov     edi,edx
;          mov     esi,[filepos]
;          add     esi,0x20000
;          cld
;          rep     movsb
;          popa
;;         ret
 
        mov     [ebx+12], ecx
        mov     [ebx+16], edx
        push    ebx
        mov     eax, 70
        mcall
        xchg    eax, [esp]
        add     [eax+4], ebx
        adc     [eax+8], dword 0
        mov     ebx, eax
        pop     eax
        test    eax, eax
        jz      .ok
        cmp     eax, 6
        jz      .ok
        stc
.ok:
        ret
 
close:
        or      dword [ebx], -1
        ret
 
 
; ebx file handle
; ecx count of bytes to write
; edx pointer to buffer
write:
;        pusha
;        mov     [file_info_write+8],ecx
;        mov     [file_info_write+12],edx
;        mov     [filesize],edx
;        mov     eax,58
;        mov     ebx,file_info_write
;        mcall
;        popa
;        ret
 
        mov     [ebx+12], ecx
        mov     [ebx+16], edx
        push    ebx
        mov     eax, 70
        mcall
        xchg    eax, [esp]
        add     [eax+4], ebx
        adc     [eax+8], dword 0
        mov     ebx, eax
        pop     eax
        mov     byte [ebx], 3
        cmp     eax, 1
        cmc
        ret
 
make_fullpaths:
	pusha
	push	edx
 
	mov	esi,path	      ; open
;       DEBUGF  "   '%s'",esi
	mov	edi,fullpath_open
	cld
      newc1:
	movsb
	cmp	byte[esi],0;' '
	jne	newc1
	mov	esi,[esp]
 
	cmp	byte[esi],'/'
	jne	@f
	mov	edi,fullpath_open
 
    @@:
	lodsb
	stosb
	cmp	al,0
	jne	@b
;       mov     ecx,12
;       cld
;       rep     movsb
;       mov     byte[edi],0
 
	mov	esi,path	      ; write
	mov	edi,fullpath_write
	cld
      newc2:
	movsb
	cmp	byte[esi],0;' '
	jne	newc2
	mov	esi,[esp]
 
	cmp	byte[esi],'/'
	jne	@f
	mov	edi,fullpath_write
 
    @@:
	lodsb
	stosb
	cmp	al,0
	jne	@b
;        mov     ecx,12
;        cld
;        rep     movsb
;        mov     byte[edi],0
 
	mov	esi,path	      ; start
	mov	edi,fullpath_start
	cld
      newc3:
	movsb
	cmp  byte[esi],0;' '
	jne  newc3
;        mov  esi,[esp]
	pop	esi
 
	cmp	byte[esi],'/'
	jne	@f
	mov	edi,fullpath_start
 
    @@:
	lodsb
	stosb
	cmp	al,0
	jne	@b
;        mov  ecx,12
;        cld
;        rep  movsb
;        mov  byte[edi],0
 
;        add  esp,4
	popa
	ret
 
 
 
lseek:
	cmp	al,0
	jnz	@f
	and	dword [ebx+4], 0
	and     dword [ebx+8], 0
    @@: cmp	al,2
	jnz	@f
	mov	eax, [ebx-4]
	mov	[ebx+4], eax
	and     dword [ebx+8], 0
    @@: add	dword [ebx+4], edx
        adc     dword [ebx+8], 0
	ret
 
display_character:
	pusha
	cmp	[_mode],NORMAL_MODE
	jne	@f
	cmp	dl,13
	jz	dc2
	cmp	dl,0xa
	jnz	dc1
	and	[textxy],0x0000FFFF
	add	[textxy], 7 shl 16 +53 and 0xFFFF0000 + 10
dc2:
  popa
	ret
dc1:
  mov eax,[textxy]
	cmp	ax,word[bottom_right]
	ja	dc2
	shr	eax,16
	cmp	ax,word[bottom_right+2]
	ja	dc2
	mov	[dc],dl
	mcall	4,[textxy],[sc.work_text],dc,1
	add	[textxy],0x00060000
	popa
	ret
@@:
  mov	eax,63
	mov	ebx,1
	mov	cl,dl
	mcall
	popa
	ret
 
 
display_string:
	pusha
@@:
  cmp	byte[esi],0
	je	@f
	mov	dl,[esi]
	call	display_character
	add	esi,1
	jmp	@b
@@:
  popa
	ret
 
display_number:
	push	ebx
	mov	ecx,1000000000
	xor	edx,edx
	xor	bl,bl
display_loop:
	div	ecx
	push	edx
	cmp	ecx,1
	je	display_digit
	or	bl,bl
	jnz	display_digit
	or	al,al
	jz	digit_ok
	not	bl
display_digit:
	mov	dl,al
	add	dl,30h
	push	ebx ecx
	call	display_character
	pop	ecx ebx
digit_ok:
	mov	eax,ecx
	xor	edx,edx
	mov	ecx,10
	div	ecx
	mov	ecx,eax
	pop	eax
	or	ecx,ecx
	jnz	display_loop
	pop	ebx
	ret
 
display_user_messages:
;    push   [skinh]
;    pop    [textxy]
;    add    [textxy], 7 shl 16 +53
	mov	[displayed_count],0
	call	show_display_buffer
	cmp	[displayed_count],1
	jb	line_break_ok
	je	make_line_break
	mov	ax,word[last_displayed]
	cmp	ax,0A0Dh
	je	line_break_ok
	cmp	ax,0D0Ah
	je	line_break_ok
make_line_break:
	mov	esi,lf
	call	display_string
line_break_ok:
	ret
 
display_block:
	pusha
@@: mov dl,[esi]
	call	display_character
	inc	esi
	loop	@b
	popa
	ret
 
fatal_error:
	mov	esi,error_prefix
	call	display_string
	pop	esi
	call	display_string
	mov	esi,error_suffix
	call	display_string
	mov	esi,lf
	call	display_string
	mov	al,0FFh
	jmp	exit_program
 
assembler_error:
	call	display_user_messages
	push	dword 0
	mov	ebx,[current_line]
get_error_lines:
	push	ebx
	test	byte [ebx+7],80h
	jz	display_error_line
	mov	edx,ebx
find_definition_origin:
	mov	edx,[edx+12]
	test	byte [edx+7],80h
	jnz	find_definition_origin
	push	edx
	mov	ebx,[ebx+8]
	jmp	get_error_lines
display_error_line:
	mov	esi,[ebx]
	call	display_string
	mov	esi,line_number_start
	call	display_string
	mov	eax,[ebx+4]
	and	eax,7FFFFFFFh
	call	display_number
	mov	dl,']'
	call	display_character
	pop	esi
	cmp	ebx,esi
	je	line_number_ok
	mov	dl,20h
	call	display_character
	push	esi
	mov	esi,[esi]
	movzx	ecx,byte [esi]
	inc	esi
	call	display_block
	mov	esi,line_number_start
	call	display_string
	pop	esi
	mov	eax,[esi+4]
	and	eax,7FFFFFFFh
	call	display_number
	mov	dl,']'
	call	display_character
line_number_ok:
	mov	esi,line_data_start
	call	display_string
	mov	esi,ebx
	mov	edx,[esi]
	call	open
	mov	al,2
	xor	edx,edx
	call	lseek
	mov	edx,[esi+8]
	sub	eax,edx
	push	eax
	xor	al,al
	call	lseek
	mov	ecx,[esp]
	mov	edx,[additional_memory]
	lea	eax,[edx+ecx]
	cmp	eax,[additional_memory_end]
	ja	out_of_memory
	call	read
	call	close
	pop	ecx
	mov	esi,[additional_memory]
get_line_data:
	mov	al,[esi]
	cmp	al,0Ah
	je	display_line_data
	cmp	al,0Dh
	je	display_line_data
	cmp	al,1Ah
	je	display_line_data
	or	al,al
	jz	display_line_data
	inc	esi
	loop	get_line_data
display_line_data:
	mov	ecx,esi
	mov	esi,[additional_memory]
	sub	ecx,esi
	call	display_block
	mov	esi,cr_lf
	call	display_string
	pop	ebx
	or	ebx,ebx
	jnz	display_error_line
	mov	esi,error_prefix
	call	display_string
	pop	esi
	call	display_string
	mov	esi,error_suffix
	call	display_string
	jmp	exit_program
 
align 4
fileinfo FILEINFO
 
character   db ?,0
bytes_count dd ?
 
textxy	 dd 0x000500A0
dc	 db 0x0
filesize dd 0x0
 
displayed_count dd ?
last_displayed	rb 2
 
error_prefix	  db 'error: ',0
error_suffix	  db '.',0
line_data_start   db ':'
cr_lf		  db 0Dh,0Ah,0
line_number_start db ' [',0
 
macro dm string { db string,0 }

Rev 2287	Rev 2664
1	; flat assembler	1	; flat assembler
2	; Copyright (c) 1999-2007, Tomasz Grysztar	2	; Copyright (c) 1999-2012, Tomasz Grysztar
3	; All rights reserved.	3	; All rights reserved.
4		4
5	struc FILEIO	5	struc FILEIO
6	{ .cmd dd ?	6	{ .cmd dd ?
7	.offset dd ?	7	.offset dd ?
8	dd ?	8	dd ?
9	.count dd ?	9	.count dd ?
10	.buff dd ?	10	.buff dd ?
11	db ?	11	db ?
12	.name dd ?	12	.name dd ?
13	};	13	};
14		14
15	struc FILEINFO	15	struc FILEINFO
16	{ .attr dd ?	16	{ .attr dd ?
17	.flags dd ?	17	.flags dd ?
18	.cr_time dd ?	18	.cr_time dd ?
19	.cr_date dd ?	19	.cr_date dd ?
20	.acc_time dd ?	20	.acc_time dd ?
21	.acc_date dd ?	21	.acc_date dd ?
22	.mod_time dd ?	22	.mod_time dd ?
23	.mod_date dd ?	23	.mod_date dd ?
24	.size dd ?	24	.size dd ?
25	}	25	}
26		26
27		27
28		28
29	;file_info_open: dd 0,0,0xffffff,0x20000,0xf0000	29	;file_info_open: dd 0,0,0xffffff,0x20000,0xf0000
30	fullpath_open: ; db '/RD/1/EXAMPLE.ASM'	30	fullpath_open: ; db '/RD/1/EXAMPLE.ASM'
31	times MAX_PATH db 0	31	times MAX_PATH db 0
32		32
33		33
34	;file_info_write: dd 1,0,0,0,0xf0000	34	;file_info_write: dd 1,0,0,0,0xf0000
35	fullpath_write:; db '/RD/1/EXAMPLE'	35	fullpath_write:; db '/RD/1/EXAMPLE'
36	times MAX_PATH db 0	36	times MAX_PATH db 0
37		37
38	file_info_start:	38	file_info_start:
39	dd 7	39	dd 7
40	dd 0	40	dd 0
41	dd 0	41	dd 0
42	dd 0	42	dd 0
43	dd 0	43	dd 0
44	fullpath_start: ; db '/RD/1/EXAMPLE'	44	fullpath_start: ; db '/RD/1/EXAMPLE'
45	times MAX_PATH db 0	45	times MAX_PATH db 0
46		46
47	file_info_debug:	47	file_info_debug:
48	dd 7	48	dd 7
49	dd 0	49	dd 0
50	dd fullpath_start	50	dd fullpath_start
51	dd 0, 0	51	dd 0, 0
52	db '/SYS/DEVELOP/MTDBG',0	52	db '/SYS/DEVELOP/MTDBG',0
53		53
54	_ramdisk db '/RD/1/'	54	_ramdisk db '/RD/1/'
55	filepos dd 0x0	55	filepos dd 0x0
56		56
57		57
58	init_memory:	58	init_memory:
59		59
60	; mov ecx, 1610241024	60	; mov ecx, 1610241024
61	;	61	;
62	; allocate_memory:	62	; allocate_memory:
63	mcall 18, 16	63	mcall 18, 16
64	cmp eax, 0x38000000 shr 9	64	cmp eax, 0x38000000 shr 9
65	jbe @f	65	jbe @f
66	mov eax, 0x38000000 shr 9	66	mov eax, 0x38000000 shr 9
67	@@:	67	@@:
68	shl eax, 9	68	shl eax, 9
69	xchg eax, ecx	69	xchg eax, ecx
70	mov [memory_setting],ecx	70	mov [memory_setting],ecx
71	mcall 68, 12	71	mcall 68, 12
72	or eax,eax	72	or eax,eax
73	jz out_of_memory	73	jz out_of_memory
74	mov [memblock], eax	74	mov [memblock], eax
75	mov [additional_memory],eax	75	mov [additional_memory],eax
76	add eax,[memory_setting]	76	add eax,[memory_setting]
77	mov [memory_end],eax	77	mov [memory_end],eax
78	mov eax,[memory_setting]	78	mov eax,[memory_setting]
79	shr eax,2	79	shr eax,2
80	add eax,[additional_memory]	80	add eax,[additional_memory]
81	mov [additional_memory_end],eax	81	mov [additional_memory_end],eax
82	mov [memory_start],eax	82	mov [memory_start],eax
83	ret	83	ret
84		84
85	exit_program:	85	exit_program:
86	cmp [_mode],NORMAL_MODE	86	cmp [_mode],NORMAL_MODE
87	jne @f	87	jne @f
88	mcall 68, 13, [memblock]	88	mcall 68, 13, [memblock]
89	jmp still	89	jmp still
90	@@:	90	@@:
91	or eax,-1	91	or eax,-1
92	mcall	92	mcall
93		93
94	make_timestamp:	94	make_timestamp:
95	push ebx	95	push ebx
96	mcall 26,9	96	mcall 26,9
97	imul eax,10	97	imul eax,10
98	pop ebx	98	pop ebx
99	ret	99	ret
100		100
101	symbol_dump:	101	symbol_dump:
102		102
103	push edi	103	push edi
104	mov edx,[memory_end]	104	mov edx,[memory_end]
105	symb_dump:	105	symb_dump:
106	cmp edx,[labels_list]	106	cmp edx,[labels_list]
107	jbe symbols_dumped	107	jbe symbols_dumped
108	sub edx,LABEL_STRUCTURE_SIZE	108	sub edx,LABEL_STRUCTURE_SIZE
109	cmp dword [edx+24],0	109	cmp dword [edx+24],0
110	je symb_dump ; do not dump anonymous symbols	110	je symb_dump ; do not dump anonymous symbols
111	test byte [edx+8],1	111	test byte [edx+8],1
112	jz symb_dump ; do not dump symbols that didn't get defined	112	jz symb_dump ; do not dump symbols that didn't get defined
113	mov ax,[current_pass]	113	mov ax,[current_pass]
114	cmp ax,[edx+16]	114	cmp ax,[edx+16]
115	jne symb_dump	115	jne symb_dump
116	test byte [edx+8],4 or 2	116	test byte [edx+8],4 or 2
117	jnz symb_dump ; do not dump assembly-time variables	117	jnz symb_dump ; do not dump assembly-time variables
118	; do not dump variables defined with '='	118	; do not dump variables defined with '='
119	cmp word [edx+12], 0	119	cmp word [edx+12], 0
120	jnz symb_dump ; do not dump register-based variables	120	jnz symb_dump ; do not dump register-based variables
121		121
122	mov al, '0'	122	mov al, '0'
123	stosb	123	stosb
124	mov al, 'x'	124	mov al, 'x'
125	stosb	125	stosb
126	mov eax, [edx+4]	126	mov eax, [edx+4]
127	mov ecx, 8	127	mov ecx, 8
128	@@:	128	@@:
129	rol eax, 4	129	rol eax, 4
130	test al, 0xF	130	test al, 0xF
131	loopz @b	131	loopz @b
132	jz .nohigh	132	jz .nohigh
133	inc ecx	133	inc ecx
134	@@:	134	@@:
135	push eax	135	push eax
136	and al, 0xF	136	and al, 0xF
137	cmp al, 10	137	cmp al, 10
138	sbb al, 69h	138	sbb al, 69h
139	das	139	das
140	stosb	140	stosb
141	pop eax	141	pop eax
142	rol eax, 4	142	rol eax, 4
143	loop @b	143	loop @b
144	mov eax, [edx]	144	mov eax, [edx]
145	mov ecx, 8	145	mov ecx, 8
146	jmp .low	146	jmp .low
147	.nohigh:	147	.nohigh:
148	mov eax, [edx]	148	mov eax, [edx]
149	mov ecx, 8	149	mov ecx, 8
150	@@:	150	@@:
151	rol eax, 4	151	rol eax, 4
152	test al, 0xF	152	test al, 0xF
153	loopz @b	153	loopz @b
154	inc ecx	154	inc ecx
155	.low:	155	.low:
156	push eax	156	push eax
157	and al, 0xF	157	and al, 0xF
158	cmp al, 10	158	cmp al, 10
159	sbb al, 69h	159	sbb al, 69h
160	das	160	das
161	stosb	161	stosb
162	pop eax	162	pop eax
163	rol eax, 4	163	rol eax, 4
164	loop .low	164	loop .low
165		165
166	mov al, ' '	166	mov al, ' '
167	stosb	167	stosb
168		168
169	mov esi,[edx+24]	169	mov esi,[edx+24]
170	movzx ecx,byte [esi-1]	170	movzx ecx,byte [esi-1]
171	rep movsb	171	rep movsb
172		172
173	mov ax,0A0Dh	173	mov ax,0A0Dh
174	stosw	174	stosw
175		175
176	jmp symb_dump	176	jmp symb_dump
177		177
178	symbols_dumped:	178	symbols_dumped:
179	mov edx,dbgfilename	179	mov edx,dbgfilename
180	push esi edi	180	push esi edi
181	mov esi, outfile	181	mov esi, outfile
182	mov edi, edx	182	mov edi, edx
183	@@:	183	@@:
184	lodsb	184	lodsb
185	stosb	185	stosb
186	test al, al	186	test al, al
187	jnz @b	187	jnz @b
188	lea ecx, [edi-1]	188	lea ecx, [edi-1]
189	@@:	189	@@:
190	dec edi	190	dec edi
191	cmp edi, edx	191	cmp edi, edx
192	jb @f	192	jb @f
193	cmp byte [edi], '/'	193	cmp byte [edi], '/'
194	jz @f	194	jz @f
195	cmp byte [edi], '.'	195	cmp byte [edi], '.'
196	jnz @b	196	jnz @b
197	mov ecx, edi	197	mov ecx, edi
198	@@:	198	@@:
199	mov dword [ecx], '.dbg'	199	mov dword [ecx], '.dbg'
200	mov byte [ecx+4], 0	200	mov byte [ecx+4], 0
201	pop edi esi	201	pop edi esi
202	call create	202	call create
203	mov edx,[esp]	203	mov edx,[esp]
204	mov ecx,edi	204	mov ecx,edi
205	sub ecx,edx	205	sub ecx,edx
206	call write	206	call write
207	call close	207	call close
208	pop edi	208	pop edi
209		209
210	ret	210	ret
211		211
212	get_environment_variable:	212	get_environment_variable:
213	mov ecx,[memory_end]	213	mov ecx,[memory_end]
214	sub ecx,edi	214	sub ecx,edi
215	cmp ecx,7	215	cmp ecx,7
216	jb out_of_memory	216	jb out_of_memory
217	cmp dword[esi],'INCL'	217	cmp dword[esi],'INCL'
218	jne .finish	218	jne .finish
219	mov esi,_ramdisk	219	mov esi,_ramdisk
220	mov ecx,6	220	mov ecx,6
221	cld	221	cld
222	rep movsb	222	rep movsb
223	.finish:	223	.finish:
224	; stc	224	; stc
225	ret	225	ret
226		226
227	alloc_handle:	227	alloc_handle:
228	call make_fullpaths	228	call make_fullpaths
229	mov ebx, fileinfos+4	229	mov ebx, fileinfos+4
230	@@:	230	@@:
231	cmp dword [ebx], -1	231	cmp dword [ebx], -1
232	jz .found	232	jz .found
233	add ebx, 4+20+MAX_PATH	233	add ebx, 4+20+MAX_PATH
234	cmp ebx, fileinfos_end	234	cmp ebx, fileinfos_end
235	jb @b	235	jb @b
236	stc	236	stc
237	ret	237	ret
238	.found:	238	.found:
239	and dword [ebx+4], 0	239	and dword [ebx+4], 0
240	and dword [ebx+8], 0	240	and dword [ebx+8], 0
241	push esi edi ecx	241	push esi edi ecx
242	mov esi, fullpath_open	242	mov esi, fullpath_open
243	lea edi, [ebx+20]	243	lea edi, [ebx+20]
244	mov ecx, MAX_PATH	244	mov ecx, MAX_PATH
245	rep movsb	245	rep movsb
246	pop ecx edi esi	246	pop ecx edi esi
247	ret ; CF=0	247	ret ; CF=0
248		248
249	create:	249	create:
250	call alloc_handle	250	call alloc_handle
251	jc .ret	251	jc .ret
252	and dword [ebx-4], 0	252	and dword [ebx-4], 0
253	mov dword [ebx], 2	253	mov dword [ebx], 2
254	.ret:	254	.ret:
255	ret	255	ret
256		256
257		257
258	open:	258	open:
259	; call make_fullpaths	259	; call make_fullpaths
260		260
261	;; mov eax,fullpath_open	261	;; mov eax,fullpath_open
262	;; DEBUGF '"%s"\n',eax	262	;; DEBUGF '"%s"\n',eax
263		263
264	; mov dword[file_info_open+8],-1	264	; mov dword[file_info_open+8],-1
265	; mcall 58,file_info_open	265	; mcall 58,file_info_open
266	; or eax,eax ; found	266	; or eax,eax ; found
267	; jz @f	267	; jz @f
268	; cmp eax,6	268	; cmp eax,6
269	; jne file_error	269	; jne file_error
270	;@@: mov [filesize],ebx	270	;@@: mov [filesize],ebx
271	; clc	271	; clc
272	; ret	272	; ret
273	;file_error:	273	;file_error:
274	; stc	274	; stc
275	; ret	275	; ret
276		276
277	call alloc_handle	277	call alloc_handle
278	jc .ret	278	jc .ret
279	mov dword [ebx], 5	279	mov dword [ebx], 5
280	and dword [ebx+12], 0	280	and dword [ebx+12], 0
281	mov dword [ebx+16], fileinfo	281	mov dword [ebx+16], fileinfo
282	mov eax, 70	282	mov eax, 70
283	push ebx	283	push ebx
284	mcall	284	mcall
285	pop ebx	285	pop ebx
286	test eax, eax	286	test eax, eax
287	jnz .fail	287	jnz .fail
288	mov eax, [fileinfo.size]	288	mov eax, [fileinfo.size]
289	mov [ebx-4], eax	289	mov [ebx-4], eax
290	and dword [ebx], 0	290	and dword [ebx], 0
291	.ret:	291	.ret:
292	ret	292	ret
293	.fail:	293	.fail:
294	or dword [ebx], -1 ; close handle	294	or dword [ebx], -1 ; close handle
295	stc	295	stc
296	ret	296	ret
297		297
298	read:	298	read:
299	; pusha	299	; pusha
300	; mov edi,edx	300	; mov edi,edx
301	; mov esi,[filepos]	301	; mov esi,[filepos]
302	; add esi,0x20000	302	; add esi,0x20000
303	; cld	303	; cld
304	; rep movsb	304	; rep movsb
305	; popa	305	; popa
306	;; ret	306	;; ret
307		307
308	mov [ebx+12], ecx	308	mov [ebx+12], ecx
309	mov [ebx+16], edx	309	mov [ebx+16], edx
310	push ebx	310	push ebx
311	mov eax, 70	311	mov eax, 70
312	mcall	312	mcall
313	xchg eax, [esp]	313	xchg eax, [esp]
314	add [eax+4], ebx	314	add [eax+4], ebx
315	adc [eax+8], dword 0	315	adc [eax+8], dword 0
316	mov ebx, eax	316	mov ebx, eax
317	pop eax	317	pop eax
318	test eax, eax	318	test eax, eax
319	jz .ok	319	jz .ok
320	cmp eax, 6	320	cmp eax, 6
321	jz .ok	321	jz .ok
322	stc	322	stc
323	.ok:	323	.ok:
324	ret	324	ret
325		325
326	close:	326	close:
327	or dword [ebx], -1	327	or dword [ebx], -1
328	ret	328	ret
329		329
330		330
331	; ebx file handle	331	; ebx file handle
332	; ecx count of bytes to write	332	; ecx count of bytes to write
333	; edx pointer to buffer	333	; edx pointer to buffer
334	write:	334	write:
335	; pusha	335	; pusha
336	; mov [file_info_write+8],ecx	336	; mov [file_info_write+8],ecx
337	; mov [file_info_write+12],edx	337	; mov [file_info_write+12],edx
338	; mov [filesize],edx	338	; mov [filesize],edx
339	; mov eax,58	339	; mov eax,58
340	; mov ebx,file_info_write	340	; mov ebx,file_info_write
341	; mcall	341	; mcall
342	; popa	342	; popa
343	; ret	343	; ret
344		344
345	mov [ebx+12], ecx	345	mov [ebx+12], ecx
346	mov [ebx+16], edx	346	mov [ebx+16], edx
347	push ebx	347	push ebx
348	mov eax, 70	348	mov eax, 70
349	mcall	349	mcall
350	xchg eax, [esp]	350	xchg eax, [esp]
351	add [eax+4], ebx	351	add [eax+4], ebx
352	adc [eax+8], dword 0	352	adc [eax+8], dword 0
353	mov ebx, eax	353	mov ebx, eax
354	pop eax	354	pop eax
355	mov byte [ebx], 3	355	mov byte [ebx], 3
356	cmp eax, 1	356	cmp eax, 1
357	cmc	357	cmc
358	ret	358	ret
359		359
360	make_fullpaths:	360	make_fullpaths:
361	pusha	361	pusha
362	push edx	362	push edx
363		363
364	mov esi,path ; open	364	mov esi,path ; open
365	; DEBUGF " '%s'",esi	365	; DEBUGF " '%s'",esi
366	mov edi,fullpath_open	366	mov edi,fullpath_open
367	cld	367	cld
368	newc1:	368	newc1:
369	movsb	369	movsb
370	cmp byte[esi],0;' '	370	cmp byte[esi],0;' '
371	jne newc1	371	jne newc1
372	mov esi,[esp]	372	mov esi,[esp]
373		373
374	cmp byte[esi],'/'	374	cmp byte[esi],'/'
375	jne @f	375	jne @f
376	mov edi,fullpath_open	376	mov edi,fullpath_open
377		377
378	@@:	378	@@:
379	lodsb	379	lodsb
380	stosb	380	stosb
381	cmp al,0	381	cmp al,0
382	jne @b	382	jne @b
383	; mov ecx,12	383	; mov ecx,12
384	; cld	384	; cld
385	; rep movsb	385	; rep movsb
386	; mov byte[edi],0	386	; mov byte[edi],0
387		387
388	mov esi,path ; write	388	mov esi,path ; write
389	mov edi,fullpath_write	389	mov edi,fullpath_write
390	cld	390	cld
391	newc2:	391	newc2:
392	movsb	392	movsb
393	cmp byte[esi],0;' '	393	cmp byte[esi],0;' '
394	jne newc2	394	jne newc2
395	mov esi,[esp]	395	mov esi,[esp]
396		396
397	cmp byte[esi],'/'	397	cmp byte[esi],'/'
398	jne @f	398	jne @f
399	mov edi,fullpath_write	399	mov edi,fullpath_write
400		400
401	@@:	401	@@:
402	lodsb	402	lodsb
403	stosb	403	stosb
404	cmp al,0	404	cmp al,0
405	jne @b	405	jne @b
406	; mov ecx,12	406	; mov ecx,12
407	; cld	407	; cld
408	; rep movsb	408	; rep movsb
409	; mov byte[edi],0	409	; mov byte[edi],0
410		410
411	mov esi,path ; start	411	mov esi,path ; start
412	mov edi,fullpath_start	412	mov edi,fullpath_start
413	cld	413	cld
414	newc3:	414	newc3:
415	movsb	415	movsb
416	cmp byte[esi],0;' '	416	cmp byte[esi],0;' '
417	jne newc3	417	jne newc3
418	; mov esi,[esp]	418	; mov esi,[esp]
419	pop esi	419	pop esi
420		420
421	cmp byte[esi],'/'	421	cmp byte[esi],'/'
422	jne @f	422	jne @f
423	mov edi,fullpath_start	423	mov edi,fullpath_start
424		424
425	@@:	425	@@:
426	lodsb	426	lodsb
427	stosb	427	stosb
428	cmp al,0	428	cmp al,0
429	jne @b	429	jne @b
430	; mov ecx,12	430	; mov ecx,12
431	; cld	431	; cld
432	; rep movsb	432	; rep movsb
433	; mov byte[edi],0	433	; mov byte[edi],0
434		434
435	; add esp,4	435	; add esp,4
436	popa	436	popa
437	ret	437	ret
438		438
439		439
440		440
441	lseek:	441	lseek:
442	cmp al,0	442	cmp al,0
443	jnz @f	443	jnz @f
444	and dword [ebx+4], 0	444	and dword [ebx+4], 0
445	and dword [ebx+8], 0	445	and dword [ebx+8], 0
446	@@: cmp al,2	446	@@: cmp al,2
447	jnz @f	447	jnz @f
448	mov eax, [ebx-4]	448	mov eax, [ebx-4]
449	mov [ebx+4], eax	449	mov [ebx+4], eax
450	and dword [ebx+8], 0	450	and dword [ebx+8], 0
451	@@: add dword [ebx+4], edx	451	@@: add dword [ebx+4], edx
452	adc dword [ebx+8], 0	452	adc dword [ebx+8], 0
453	ret	453	ret
454		454
455	display_character:	455	display_character:
456	pusha	456	pusha
457	cmp [_mode],NORMAL_MODE	457	cmp [_mode],NORMAL_MODE
458	jne @f	458	jne @f
459	cmp dl,13	459	cmp dl,13
460	jz dc2	460	jz dc2
461	cmp dl,0xa	461	cmp dl,0xa
462	jnz dc1	462	jnz dc1
463	and [textxy],0x0000FFFF	463	and [textxy],0x0000FFFF
464	add [textxy], 7 shl 16 +53 and 0xFFFF0000 + 10	464	add [textxy], 7 shl 16 +53 and 0xFFFF0000 + 10
465	dc2:	465	dc2:
466	popa	466	popa
467	ret	467	ret
468	dc1:	468	dc1:
469	mov eax,[textxy]	469	mov eax,[textxy]
470	cmp ax,word[bottom_right]	470	cmp ax,word[bottom_right]
471	ja dc2	471	ja dc2
472	shr eax,16	472	shr eax,16
473	cmp ax,word[bottom_right+2]	473	cmp ax,word[bottom_right+2]
474	ja dc2	474	ja dc2
475	mov [dc],dl	475	mov [dc],dl
476	mcall 4,[textxy],[sc.work_text],dc,1	476	mcall 4,[textxy],[sc.work_text],dc,1
477	add [textxy],0x00060000	477	add [textxy],0x00060000
478	popa	478	popa
479	ret	479	ret
480	@@:	480	@@:
481	mov eax,63	481	mov eax,63
482	mov ebx,1	482	mov ebx,1
483	mov cl,dl	483	mov cl,dl
484	mcall	484	mcall
485	popa	485	popa
486	ret	486	ret
487		487
488		488
489	display_string:	489	display_string:
490	pusha	490	pusha
491	@@:	491	@@:
492	cmp byte[esi],0	492	cmp byte[esi],0
493	je @f	493	je @f
494	mov dl,[esi]	494	mov dl,[esi]
495	call display_character	495	call display_character
496	add esi,1	496	add esi,1
497	jmp @b	497	jmp @b
498	@@:	498	@@:
499	popa	499	popa
500	ret	500	ret

Subversion Repositories Kolibri OS

(root)/programs/develop/fasm/trunk/system.inc – Rev 2287 → 2664