WebSVN – Kolibri OS – Diff – /kernel/trunk/drivers/fdo.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
;
; Formatted Debug Output (FDO)
; Copyright (c) 2005-2006, mike.dld
; Created: 2005-01-29, Changed: 2006-11-10
;
; For questions and bug reports, mail to mike.dld@gmail.com
;
; Available format specifiers are: %s, %d, %u, %x (with partial width support)
;
 
; to be defined:
;   __DEBUG__ equ 1
;   __DEBUG_LEVEL__ equ 5
 
; MOV Immediate.
; Useful for things like movi eax,10:
; shorter than regular mov, but slightly slower,
; do not use it in performance-critical places.
macro movi dst, imm
{
if imm >= -0x80 & imm <= 0x7F
        push    imm
        pop     dst
else
        mov     dst, imm
end if
}
 
macro debug_func name {
 if used name
  name@of@func equ name
}
 
macro debug_beginf {
 align 4
 name@of@func:
}
 
debug_endf fix end if
 
macro DEBUGS _sign,[_str] {
 common
  local tp
  tp equ 0
  match _arg:_num,_str \{
   DEBUGS_N _sign,_num,_arg
   tp equ 1
  \}
  match =0 _arg,tp _str \{
   DEBUGS_N _sign,,_arg
  \}
}
 
macro DEBUGS_N _sign,_num,[_str] {
 common
        pushf
        pushad
  local ..str,..label,is_str
  is_str = 0
 forward
  if _str eqtype ''
   is_str = 1
  end if
 common
  if is_str = 1
        jmp     ..label
   ..str db _str,0
   ..label:
        add     esp, 4*8+4
        mov     edx, ..str
        sub     esp, 4*8+4
  else
        mov     edx, _str
  end if
  if ~_num eq
   if _num eqtype eax
    if _num in 
        mov     esi, _num
    else if ~_num eq esi
        movzx   esi, _num
    end if
   else if _num eqtype 0
        mov     esi, _num
   else
    local tp
    tp equ 0
    match [_arg],_num \{
        mov     esi, dword[_arg]
     tp equ 1
    \}
    match =0 =dword[_arg],tp _num \{
        mov     esi, dword[_arg]
     tp equ 1
    \}
    match =0 =word[_arg],tp _num \{
        movzx   esi, word[_arg]
     tp equ 1
    \}
    match =0 =byte[_arg],tp _num \{
        movzx   esi, byte[_arg]
     tp equ 1
    \}
    match =0,tp \{
     'Error: specified string width is incorrect'
    \}
   end if
  else
        mov     esi, 0x7FFFFFFF
  end if
        call    fdo_debug_outstr
        popad
        popf
}
 
macro DEBUGD _sign,_dec {
 local tp
 tp equ 0
 match _arg:_num,_dec \{
  DEBUGD_N _sign,_num,_arg
  tp equ 1
 \}
 match =0 _arg,tp _dec \{
  DEBUGD_N _sign,,_arg
 \}
}
 
macro DEBUGD_N _sign,_num,_dec {
        pushf
        pushad
 if (~_num eq)
  if (_dec eqtype eax | _dec eqtype 0)
   'Error: precision allowed only for in-memory variables'
  end if
  if (~_num in <1,2,4>)
   if _sign
    'Error: 1, 2 and 4 are only allowed for precision in %d'
   else
    'Error: 1, 2 and 4 are only allowed for precision in %u'
   end if
  end if
 end if
 if _dec eqtype eax
  if _dec in 
        mov     eax, _dec
  else if ~_dec eq eax
   if _sign = 1
        movsx   eax, _dec
   else
        movzx   eax, _dec
   end if
  end if
 else if _dec eqtype 0
        mov     eax, _dec
 else
        add     esp, 4*8+4
  if _num eq
        mov     eax, dword _dec
  else if _num = 1
   if _sign = 1
        movsx   eax, byte _dec
   else
        movzx   eax, byte _dec
   end if
  else if _num = 2
   if _sign = 1
        movsx   eax, word _dec
   else
        movzx   eax, word _dec
   end if
  else
        mov     eax, dword _dec
  end if
        sub     esp, 4*8+4
 end if
        mov     cl, _sign
        call    fdo_debug_outdec
        popad
        popf
}
 
macro DEBUGH _sign,_hex {
 local tp
 tp equ 0
 match _arg:_num,_hex \{
  DEBUGH_N _sign,_num,_arg
  tp equ 1
 \}
 match =0 _arg,tp _hex \{
  DEBUGH_N _sign,,_arg
 \}
}
 
macro DEBUGH_N _sign,_num,_hex {
        pushf
        pushad
 if (~_num eq) & (~_num in <1,2,3,4,5,6,7,8>)
  'Error: 1..8 are only allowed for precision in %x'
 end if
 if _hex eqtype eax
  if _hex in 
   if ~_hex eq eax
        mov     eax, _hex
   end if
        mov     edx, 8
  else if _hex in 
   if ~_hex eq ax
        movzx   eax, _hex
   end if
   if (_num eq)
        mov     edx, 4
   end if
  else if _hex in 
   if ~_hex eq al
        movzx   eax, _hex
   end if
   if (_num eq)
        mov     edx, 2
   end if
  end if
 else if _hex eqtype 0
        mov     eax, _hex
 else
        add     esp, 4*8+4
        mov     eax, dword _hex
        sub     esp, 4*8+4
 end if
 if ~_num eq
        mov     edx, _num
 else
  if ~_hex eqtype eax
        mov     edx, 8
  end if
 end if
        call    fdo_debug_outhex
        popad
        popf
}
 
;-----------------------------------------------------------------------------
 
debug_func fdo_debug_outchar
debug_beginf
        pushad
        movzx   ecx, al
        mov     ebx, 1
;        mov     ecx,sys_msg_board
;        call    ecx ; sys_msg_board
        stdcall SysMsgBoard
        popad
        ret
debug_endf
 
debug_func fdo_debug_outstr
debug_beginf
        mov     ebx, 1
  .l1:
        dec     esi
        js      .l2
        movzx   ecx, byte[edx]
        or      cl, cl
        jz      .l2
;        mov     ecx,sys_msg_board
;        call    ecx ; sys_msg_board
        stdcall SysMsgBoard
        inc     edx
        jmp     .l1
  .l2:
        ret
debug_endf
 
debug_func fdo_debug_outdec
debug_beginf
        or      cl, cl
        jz      @f
        or      eax, eax
        jns     @f
        neg     eax
        push    eax
        mov     al, '-'
        call    fdo_debug_outchar
        pop     eax
    @@:
        movi    ecx, 10
        push    -'0'
  .l1:
        xor     edx, edx
        div     ecx
        push    edx
        test    eax, eax
        jnz     .l1
  .l2:
        pop     eax
        add     al, '0'
        jz      .l3
        call    fdo_debug_outchar
        jmp     .l2
  .l3:
        ret
debug_endf
 
debug_func fdo_debug_outhex
  __fdo_hexdigits db '0123456789ABCDEF'
debug_beginf
        mov     cl, dl
        neg     cl
        add     cl, 8
        shl     cl, 2
        rol     eax, cl
  .l1:
        rol     eax, 4
        push    eax
        and     eax, 0x0000000F
        mov     al, [__fdo_hexdigits+eax]
        call    fdo_debug_outchar
        pop     eax
        dec     edx
        jnz     .l1
        ret
debug_endf
 
;-----------------------------------------------------------------------------
 
macro DEBUGF _level,_format,[_arg] {
 common
 if __DEBUG__ = 1 & _level >= __DEBUG_LEVEL__
  local ..f1,f2,a1,a2,c1,c2,c3,..lbl
  _debug_str_ equ __debug_str_ # a1
  a1 = 0
  c2 = 0
  c3 = 0
  f2 = 0
  repeat ..lbl-..f1
   virtual at 0
    db _format,0,0
    load c1 word from %-1
   end virtual
   if c1 = '%s'
    virtual at 0
     db _format,0,0
     store word 0 at %-1
     load c1 from f2-c2
    end virtual
    if c1 <> 0
     DEBUGS 0,_debug_str_+f2-c2
    end if
    c2 = c2 + 1
    f2 = %+1
    DEBUGF_HELPER S,a1,0,_arg
   else if c1 = '%x'
    virtual at 0
     db _format,0,0
     store word 0 at %-1
     load c1 from f2-c2
    end virtual
    if c1 <> 0
     DEBUGS 0,_debug_str_+f2-c2
    end if
    c2 = c2 + 1
    f2 = %+1
    DEBUGF_HELPER H,a1,0,_arg
   else if c1 = '%d' | c1 = '%u'
    local c4
    if c1 = '%d'
     c4 = 1
    else
     c4 = 0
    end if
    virtual at 0
     db _format,0,0
     store word 0 at %-1
     load c1 from f2-c2
    end virtual
    if c1 <> 0
     DEBUGS 0,_debug_str_+f2-c2
    end if
    c2 = c2 + 1
    f2 = %+1
    DEBUGF_HELPER D,a1,c4,_arg
   else if c1 = '\n'
    c3 = c3 + 1
   end if
  end repeat
  virtual at 0
   db _format,0,0
   load c1 from f2-c2
  end virtual
  if (c1<>0)&(f2<>..lbl-..f1-1)
   DEBUGS 0,_debug_str_+f2-c2
  end if
  virtual at 0
   ..f1 db _format,0
   ..lbl:
   __debug_strings equ __debug_strings,_debug_str_,<_format>,..lbl-..f1-1-c2-c3
  end virtual
 end if
}
 
macro __include_debug_strings dummy,[_id,_fmt,_len] {
 common
  local c1,a1,a2
 forward
  if defined _len & ~_len eq
   _id:
   a1 = 0
   a2 = 0
   repeat _len
    virtual at 0
     db _fmt,0,0
     load c1 word from %+a2-1
    end virtual
    if (c1='%s')|(c1='%x')|(c1='%d')|(c1='%u')
     db 0
     a2 = a2 + 1
    else if (c1='\n')
     dw $0A0D
     a1 = a1 + 1
     a2 = a2 + 1
    else
     db c1 and 0x0FF
    end if
   end repeat
   db 0
  end if
}
 
macro DEBUGF_HELPER _letter,_num,_sign,[_arg] {
 common
  local num
  num = 0
 forward
  if num = _num
   DEBUG#_letter _sign,_arg
  end if
  num = num+1
 common
  _num = _num+1
}
 
macro include_debug_strings {
 if __DEBUG__ = 1
  match dbg_str,__debug_strings \{
   __include_debug_strings dbg_str
  \}
 end if
}

Rev 3598	Rev 3614
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	5	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6		6
7		7
8	;	8	;
9	; Formatted Debug Output (FDO)	9	; Formatted Debug Output (FDO)
10	; Copyright (c) 2005-2006, mike.dld	10	; Copyright (c) 2005-2006, mike.dld
11	; Created: 2005-01-29, Changed: 2006-11-10	11	; Created: 2005-01-29, Changed: 2006-11-10
12	;	12	;
13	; For questions and bug reports, mail to mike.dld@gmail.com	13	; For questions and bug reports, mail to mike.dld@gmail.com
14	;	14	;
15	; Available format specifiers are: %s, %d, %u, %x (with partial width support)	15	; Available format specifiers are: %s, %d, %u, %x (with partial width support)
16	;	16	;
17		17
18	; to be defined:	18	; to be defined:
19	; __DEBUG__ equ 1	19	; __DEBUG__ equ 1
20	; __DEBUG_LEVEL__ equ 5	20	; __DEBUG_LEVEL__ equ 5
21		21
22	; MOV Immediate.	22	; MOV Immediate.
23	; Useful for things like movi eax,10:	23	; Useful for things like movi eax,10:
24	; shorter than regular mov, but slightly slower,	24	; shorter than regular mov, but slightly slower,
25	; do not use it in performance-critical places.	25	; do not use it in performance-critical places.
26	macro movi dst, imm	26	macro movi dst, imm
27	{	27	{
28	if imm >= -0x80 & imm <= 0x7F	28	if imm >= -0x80 & imm <= 0x7F
29	push imm	29	push imm
30	pop dst	30	pop dst
31	else	31	else
32	mov dst, imm	32	mov dst, imm
33	end if	33	end if
34	}	34	}
35		35
36	macro debug_func name {	36	macro debug_func name {
37	if used name	37	if used name
38	name@of@func equ name	38	name@of@func equ name
39	}	39	}
40		40
41	macro debug_beginf {	41	macro debug_beginf {
42	align 4	42	align 4
43	name@of@func:	43	name@of@func:
44	}	44	}
45		45
46	debug_endf fix end if	46	debug_endf fix end if
47		47
48	macro DEBUGS _sign,[_str] {	48	macro DEBUGS _sign,[_str] {
49	common	49	common
50	local tp	50	local tp
51	tp equ 0	51	tp equ 0
52	match _arg:_num,_str \{	52	match _arg:_num,_str \{
53	DEBUGS_N _sign,_num,_arg	53	DEBUGS_N _sign,_num,_arg
54	tp equ 1	54	tp equ 1
55	\}	55	\}
56	match =0 _arg,tp _str \{	56	match =0 _arg,tp _str \{
57	DEBUGS_N _sign,,_arg	57	DEBUGS_N _sign,,_arg
58	\}	58	\}
59	}	59	}
60		60
61	macro DEBUGS_N _sign,_num,[_str] {	61	macro DEBUGS_N _sign,_num,[_str] {
62	common	62	common
63	pushf	63	pushf
64	pushad	64	pushad
65	local ..str,..label,is_str	65	local ..str,..label,is_str
66	is_str = 0	66	is_str = 0
67	forward	67	forward
68	if _str eqtype ''	68	if _str eqtype ''
69	is_str = 1	69	is_str = 1
70	end if	70	end if
71	common	71	common
72	if is_str = 1	72	if is_str = 1
73	jmp ..label	73	jmp ..label
74	..str db _str,0	74	..str db _str,0
75	..label:	75	..label:
76	add esp, 4*8+4	76	add esp, 4*8+4
77	mov edx, ..str	77	mov edx, ..str
78	sub esp, 4*8+4	78	sub esp, 4*8+4
79	else	79	else
80	mov edx, _str	80	mov edx, _str
81	end if	81	end if
82	if ~_num eq	82	if ~_num eq
83	if _num eqtype eax	83	if _num eqtype eax
84	if _num in	84	if _num in
85	mov esi, _num	85	mov esi, _num
86	else if ~_num eq esi	86	else if ~_num eq esi
87	movzx esi, _num	87	movzx esi, _num
88	end if	88	end if
89	else if _num eqtype 0	89	else if _num eqtype 0
90	mov esi, _num	90	mov esi, _num
91	else	91	else
92	local tp	92	local tp
93	tp equ 0	93	tp equ 0
94	match [_arg],_num \{	94	match [_arg],_num \{
95	mov esi, dword[_arg]	95	mov esi, dword[_arg]
96	tp equ 1	96	tp equ 1
97	\}	97	\}
98	match =0 =dword[_arg],tp _num \{	98	match =0 =dword[_arg],tp _num \{
99	mov esi, dword[_arg]	99	mov esi, dword[_arg]
100	tp equ 1	100	tp equ 1
101	\}	101	\}
102	match =0 =word[_arg],tp _num \{	102	match =0 =word[_arg],tp _num \{
103	movzx esi, word[_arg]	103	movzx esi, word[_arg]
104	tp equ 1	104	tp equ 1
105	\}	105	\}
106	match =0 =byte[_arg],tp _num \{	106	match =0 =byte[_arg],tp _num \{
107	movzx esi, byte[_arg]	107	movzx esi, byte[_arg]
108	tp equ 1	108	tp equ 1
109	\}	109	\}
110	match =0,tp \{	110	match =0,tp \{
111	'Error: specified string width is incorrect'	111	'Error: specified string width is incorrect'
112	\}	112	\}
113	end if	113	end if
114	else	114	else
115	mov esi, 0x7FFFFFFF	115	mov esi, 0x7FFFFFFF
116	end if	116	end if
117	call fdo_debug_outstr	117	call fdo_debug_outstr
118	popad	118	popad
119	popf	119	popf
120	}	120	}
121		121
122	macro DEBUGD _sign,_dec {	122	macro DEBUGD _sign,_dec {
123	local tp	123	local tp
124	tp equ 0	124	tp equ 0
125	match _arg:_num,_dec \{	125	match _arg:_num,_dec \{
126	DEBUGD_N _sign,_num,_arg	126	DEBUGD_N _sign,_num,_arg
127	tp equ 1	127	tp equ 1
128	\}	128	\}
129	match =0 _arg,tp _dec \{	129	match =0 _arg,tp _dec \{
130	DEBUGD_N _sign,,_arg	130	DEBUGD_N _sign,,_arg
131	\}	131	\}
132	}	132	}
133		133
134	macro DEBUGD_N _sign,_num,_dec {	134	macro DEBUGD_N _sign,_num,_dec {
135	pushf	135	pushf
136	pushad	136	pushad
137	if (~_num eq)	137	if (~_num eq)
138	if (_dec eqtype eax \| _dec eqtype 0)	138	if (_dec eqtype eax \| _dec eqtype 0)
139	'Error: precision allowed only for in-memory variables'	139	'Error: precision allowed only for in-memory variables'
140	end if	140	end if
141	if (~_num in <1,2,4>)	141	if (~_num in <1,2,4>)
142	if _sign	142	if _sign
143	'Error: 1, 2 and 4 are only allowed for precision in %d'	143	'Error: 1, 2 and 4 are only allowed for precision in %d'
144	else	144	else
145	'Error: 1, 2 and 4 are only allowed for precision in %u'	145	'Error: 1, 2 and 4 are only allowed for precision in %u'
146	end if	146	end if
147	end if	147	end if
148	end if	148	end if
149	if _dec eqtype eax	149	if _dec eqtype eax
150	if _dec in	150	if _dec in
151	mov eax, _dec	151	mov eax, _dec
152	else if ~_dec eq eax	152	else if ~_dec eq eax
153	if _sign = 1	153	if _sign = 1
154	movsx eax, _dec	154	movsx eax, _dec
155	else	155	else
156	movzx eax, _dec	156	movzx eax, _dec
157	end if	157	end if
158	end if	158	end if
159	else if _dec eqtype 0	159	else if _dec eqtype 0
160	mov eax, _dec	160	mov eax, _dec
161	else	161	else
162	add esp, 4*8+4	162	add esp, 4*8+4
163	if _num eq	163	if _num eq
164	mov eax, dword _dec	164	mov eax, dword _dec
165	else if _num = 1	165	else if _num = 1
166	if _sign = 1	166	if _sign = 1
167	movsx eax, byte _dec	167	movsx eax, byte _dec
168	else	168	else
169	movzx eax, byte _dec	169	movzx eax, byte _dec
170	end if	170	end if
171	else if _num = 2	171	else if _num = 2
172	if _sign = 1	172	if _sign = 1
173	movsx eax, word _dec	173	movsx eax, word _dec
174	else	174	else
175	movzx eax, word _dec	175	movzx eax, word _dec
176	end if	176	end if
177	else	177	else
178	mov eax, dword _dec	178	mov eax, dword _dec
179	end if	179	end if
180	sub esp, 4*8+4	180	sub esp, 4*8+4
181	end if	181	end if
182	mov cl, _sign	182	mov cl, _sign
183	call fdo_debug_outdec	183	call fdo_debug_outdec
184	popad	184	popad
185	popf	185	popf
186	}	186	}
187		187
188	macro DEBUGH _sign,_hex {	188	macro DEBUGH _sign,_hex {
189	local tp	189	local tp
190	tp equ 0	190	tp equ 0
191	match _arg:_num,_hex \{	191	match _arg:_num,_hex \{
192	DEBUGH_N _sign,_num,_arg	192	DEBUGH_N _sign,_num,_arg
193	tp equ 1	193	tp equ 1
194	\}	194	\}
195	match =0 _arg,tp _hex \{	195	match =0 _arg,tp _hex \{
196	DEBUGH_N _sign,,_arg	196	DEBUGH_N _sign,,_arg
197	\}	197	\}
198	}	198	}
199		199
200	macro DEBUGH_N _sign,_num,_hex {	200	macro DEBUGH_N _sign,_num,_hex {
201	pushf	201	pushf
202	pushad	202	pushad
203	if (~_num eq) & (~_num in <1,2,3,4,5,6,7,8>)	203	if (~_num eq) & (~_num in <1,2,3,4,5,6,7,8>)
204	'Error: 1..8 are only allowed for precision in %x'	204	'Error: 1..8 are only allowed for precision in %x'
205	end if	205	end if
206	if _hex eqtype eax	206	if _hex eqtype eax
207	if _hex in	207	if _hex in
208	if ~_hex eq eax	208	if ~_hex eq eax
209	mov eax, _hex	209	mov eax, _hex
210	end if	210	end if
211	mov edx, 8	211	mov edx, 8
212	else if _hex in	212	else if _hex in
213	if ~_hex eq ax	213	if ~_hex eq ax
214	movzx eax, _hex	214	movzx eax, _hex
215	end if	215	end if
216	if (_num eq)	216	if (_num eq)
217	mov edx, 4	217	mov edx, 4
218	end if	218	end if
219	else if _hex in	219	else if _hex in
220	if ~_hex eq al	220	if ~_hex eq al
221	movzx eax, _hex	221	movzx eax, _hex
222	end if	222	end if
223	if (_num eq)	223	if (_num eq)
224	mov edx, 2	224	mov edx, 2
225	end if	225	end if
226	end if	226	end if
227	else if _hex eqtype 0	227	else if _hex eqtype 0
228	mov eax, _hex	228	mov eax, _hex
229	else	229	else
230	add esp, 4*8+4	230	add esp, 4*8+4
231	mov eax, dword _hex	231	mov eax, dword _hex
232	sub esp, 4*8+4	232	sub esp, 4*8+4
233	end if	233	end if
234	if ~_num eq	234	if ~_num eq
235	mov edx, _num	235	mov edx, _num
236	else	236	else
237	if ~_hex eqtype eax	237	if ~_hex eqtype eax
238	mov edx, 8	238	mov edx, 8
239	end if	239	end if
240	end if	240	end if
241	call fdo_debug_outhex	241	call fdo_debug_outhex
242	popad	242	popad
243	popf	243	popf
244	}	244	}
245		245
246	;-----------------------------------------------------------------------------	246	;-----------------------------------------------------------------------------
247		247
248	debug_func fdo_debug_outchar	248	debug_func fdo_debug_outchar
249	debug_beginf	249	debug_beginf
250	pushad	250	pushad
251	movzx ebx, al	251	movzx ecx, al
252	mov eax, 1	252	mov ebx, 1
253	; mov ecx,sys_msg_board	253	; mov ecx,sys_msg_board
254	; call ecx ; sys_msg_board	254	; call ecx ; sys_msg_board
255	stdcall SysMsgBoardChar	255	stdcall SysMsgBoard
256	popad	256	popad
257	ret	257	ret
258	debug_endf	258	debug_endf
259		259
260	debug_func fdo_debug_outstr	260	debug_func fdo_debug_outstr
261	debug_beginf	261	debug_beginf
262	mov eax, 1	262	mov ebx, 1
263	.l1:	263	.l1:
264	dec esi	264	dec esi
265	js .l2	265	js .l2
266	movzx ebx, byte[edx]	266	movzx ecx, byte[edx]
267	or bl, bl	267	or cl, cl
268	jz .l2	268	jz .l2
269	; mov ecx,sys_msg_board	269	; mov ecx,sys_msg_board
270	; call ecx ; sys_msg_board	270	; call ecx ; sys_msg_board
271	stdcall SysMsgBoardChar	271	stdcall SysMsgBoard
272	inc edx	272	inc edx
273	jmp .l1	273	jmp .l1
274	.l2:	274	.l2:
275	ret	275	ret
276	debug_endf	276	debug_endf
277		277
278	debug_func fdo_debug_outdec	278	debug_func fdo_debug_outdec
279	debug_beginf	279	debug_beginf
280	or cl, cl	280	or cl, cl
281	jz @f	281	jz @f
282	or eax, eax	282	or eax, eax
283	jns @f	283	jns @f
284	neg eax	284	neg eax
285	push eax	285	push eax
286	mov al, '-'	286	mov al, '-'
287	call fdo_debug_outchar	287	call fdo_debug_outchar
288	pop eax	288	pop eax
289	@@:	289	@@:
290	movi ecx, 10	290	movi ecx, 10
291	push -'0'	291	push -'0'
292	.l1:	292	.l1:
293	xor edx, edx	293	xor edx, edx
294	div ecx	294	div ecx
295	push edx	295	push edx
296	test eax, eax	296	test eax, eax
297	jnz .l1	297	jnz .l1
298	.l2:	298	.l2:
299	pop eax	299	pop eax
300	add al, '0'	300	add al, '0'
301	jz .l3	301	jz .l3
302	call fdo_debug_outchar	302	call fdo_debug_outchar
303	jmp .l2	303	jmp .l2
304	.l3:	304	.l3:
305	ret	305	ret
306	debug_endf	306	debug_endf
307		307
308	debug_func fdo_debug_outhex	308	debug_func fdo_debug_outhex
309	__fdo_hexdigits db '0123456789ABCDEF'	309	__fdo_hexdigits db '0123456789ABCDEF'
310	debug_beginf	310	debug_beginf
311	mov cl, dl	311	mov cl, dl
312	neg cl	312	neg cl
313	add cl, 8	313	add cl, 8
314	shl cl, 2	314	shl cl, 2
315	rol eax, cl	315	rol eax, cl
316	.l1:	316	.l1:
317	rol eax, 4	317	rol eax, 4
318	push eax	318	push eax
319	and eax, 0x0000000F	319	and eax, 0x0000000F
320	mov al, [__fdo_hexdigits+eax]	320	mov al, [__fdo_hexdigits+eax]
321	call fdo_debug_outchar	321	call fdo_debug_outchar
322	pop eax	322	pop eax
323	dec edx	323	dec edx
324	jnz .l1	324	jnz .l1
325	ret	325	ret
326	debug_endf	326	debug_endf
327		327
328	;-----------------------------------------------------------------------------	328	;-----------------------------------------------------------------------------
329		329
330	macro DEBUGF _level,_format,[_arg] {	330	macro DEBUGF _level,_format,[_arg] {
331	common	331	common
332	if __DEBUG__ = 1 & _level >= __DEBUG_LEVEL__	332	if __DEBUG__ = 1 & _level >= __DEBUG_LEVEL__
333	local ..f1,f2,a1,a2,c1,c2,c3,..lbl	333	local ..f1,f2,a1,a2,c1,c2,c3,..lbl
334	_debug_str_ equ __debug_str_ # a1	334	_debug_str_ equ __debug_str_ # a1
335	a1 = 0	335	a1 = 0
336	c2 = 0	336	c2 = 0
337	c3 = 0	337	c3 = 0
338	f2 = 0	338	f2 = 0
339	repeat ..lbl-..f1	339	repeat ..lbl-..f1
340	virtual at 0	340	virtual at 0
341	db _format,0,0	341	db _format,0,0
342	load c1 word from %-1	342	load c1 word from %-1
343	end virtual	343	end virtual
344	if c1 = '%s'	344	if c1 = '%s'
345	virtual at 0	345	virtual at 0
346	db _format,0,0	346	db _format,0,0
347	store word 0 at %-1	347	store word 0 at %-1
348	load c1 from f2-c2	348	load c1 from f2-c2
349	end virtual	349	end virtual
350	if c1 <> 0	350	if c1 <> 0
351	DEBUGS 0,_debug_str_+f2-c2	351	DEBUGS 0,_debug_str_+f2-c2
352	end if	352	end if
353	c2 = c2 + 1	353	c2 = c2 + 1
354	f2 = %+1	354	f2 = %+1
355	DEBUGF_HELPER S,a1,0,_arg	355	DEBUGF_HELPER S,a1,0,_arg
356	else if c1 = '%x'	356	else if c1 = '%x'
357	virtual at 0	357	virtual at 0
358	db _format,0,0	358	db _format,0,0
359	store word 0 at %-1	359	store word 0 at %-1
360	load c1 from f2-c2	360	load c1 from f2-c2
361	end virtual	361	end virtual
362	if c1 <> 0	362	if c1 <> 0
363	DEBUGS 0,_debug_str_+f2-c2	363	DEBUGS 0,_debug_str_+f2-c2
364	end if	364	end if
365	c2 = c2 + 1	365	c2 = c2 + 1
366	f2 = %+1	366	f2 = %+1
367	DEBUGF_HELPER H,a1,0,_arg	367	DEBUGF_HELPER H,a1,0,_arg
368	else if c1 = '%d' \| c1 = '%u'	368	else if c1 = '%d' \| c1 = '%u'
369	local c4	369	local c4
370	if c1 = '%d'	370	if c1 = '%d'
371	c4 = 1	371	c4 = 1
372	else	372	else
373	c4 = 0	373	c4 = 0
374	end if	374	end if
375	virtual at 0	375	virtual at 0
376	db _format,0,0	376	db _format,0,0
377	store word 0 at %-1	377	store word 0 at %-1
378	load c1 from f2-c2	378	load c1 from f2-c2
379	end virtual	379	end virtual
380	if c1 <> 0	380	if c1 <> 0
381	DEBUGS 0,_debug_str_+f2-c2	381	DEBUGS 0,_debug_str_+f2-c2
382	end if	382	end if
383	c2 = c2 + 1	383	c2 = c2 + 1
384	f2 = %+1	384	f2 = %+1
385	DEBUGF_HELPER D,a1,c4,_arg	385	DEBUGF_HELPER D,a1,c4,_arg
386	else if c1 = '\n'	386	else if c1 = '\n'
387	c3 = c3 + 1	387	c3 = c3 + 1
388	end if	388	end if
389	end repeat	389	end repeat
390	virtual at 0	390	virtual at 0
391	db _format,0,0	391	db _format,0,0
392	load c1 from f2-c2	392	load c1 from f2-c2
393	end virtual	393	end virtual
394	if (c1<>0)&(f2<>..lbl-..f1-1)	394	if (c1<>0)&(f2<>..lbl-..f1-1)
395	DEBUGS 0,_debug_str_+f2-c2	395	DEBUGS 0,_debug_str_+f2-c2
396	end if	396	end if
397	virtual at 0	397	virtual at 0
398	..f1 db _format,0	398	..f1 db _format,0
399	..lbl:	399	..lbl:
400	__debug_strings equ __debug_strings,_debug_str_,<_format>,..lbl-..f1-1-c2-c3	400	__debug_strings equ __debug_strings,_debug_str_,<_format>,..lbl-..f1-1-c2-c3
401	end virtual	401	end virtual
402	end if	402	end if
403	}	403	}
404		404
405	macro __include_debug_strings dummy,[_id,_fmt,_len] {	405	macro __include_debug_strings dummy,[_id,_fmt,_len] {
406	common	406	common
407	local c1,a1,a2	407	local c1,a1,a2
408	forward	408	forward
409	if defined _len & ~_len eq	409	if defined _len & ~_len eq
410	_id:	410	_id:
411	a1 = 0	411	a1 = 0
412	a2 = 0	412	a2 = 0
413	repeat _len	413	repeat _len
414	virtual at 0	414	virtual at 0
415	db _fmt,0,0	415	db _fmt,0,0
416	load c1 word from %+a2-1	416	load c1 word from %+a2-1
417	end virtual	417	end virtual
418	if (c1='%s')\|(c1='%x')\|(c1='%d')\|(c1='%u')	418	if (c1='%s')\|(c1='%x')\|(c1='%d')\|(c1='%u')
419	db 0	419	db 0
420	a2 = a2 + 1	420	a2 = a2 + 1
421	else if (c1='\n')	421	else if (c1='\n')
422	dw $0A0D	422	dw $0A0D
423	a1 = a1 + 1	423	a1 = a1 + 1
424	a2 = a2 + 1	424	a2 = a2 + 1
425	else	425	else
426	db c1 and 0x0FF	426	db c1 and 0x0FF
427	end if	427	end if
428	end repeat	428	end repeat
429	db 0	429	db 0
430	end if	430	end if
431	}	431	}
432		432
433	macro DEBUGF_HELPER _letter,_num,_sign,[_arg] {	433	macro DEBUGF_HELPER _letter,_num,_sign,[_arg] {
434	common	434	common
435	local num	435	local num
436	num = 0	436	num = 0
437	forward	437	forward
438	if num = _num	438	if num = _num
439	DEBUG#_letter _sign,_arg	439	DEBUG#_letter _sign,_arg
440	end if	440	end if
441	num = num+1	441	num = num+1
442	common	442	common
443	_num = _num+1	443	_num = _num+1
444	}	444	}
445		445
446	macro include_debug_strings {	446	macro include_debug_strings {
447	if __DEBUG__ = 1	447	if __DEBUG__ = 1
448	match dbg_str,__debug_strings \{	448	match dbg_str,__debug_strings \{
449	__include_debug_strings dbg_str	449	__include_debug_strings dbg_str
450	\}	450	\}
451	end if	451	end if
452	}	452	}

Subversion Repositories Kolibri OS

(root)/kernel/trunk/drivers/fdo.inc – Rev 3598 → 3614