Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision: 593 $

;

; 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

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

  else if _hex in 

   if ~_hex eq ax

    movzx eax,_hex

   end if

   shl eax,16

   if (_num eq)

    mov edx,4

   end if

  else if _hex in 

   if ~_hex eq al

    movzx eax,_hex

   end if

   shl eax,24

   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   ebx,al

        mov     eax,1

        mov     ecx,sys_msg_board

        call    ecx ; sys_msg_board

        popad

        ret

debug_endf

debug_func fdo_debug_outstr

debug_beginf

        mov     eax,1

  .l1:  dec     esi

        js      .l2

        movzx   ebx,byte[edx]

        or      bl,bl

        jz      .l2

        mov     ecx,sys_msg_board

        call    ecx ; sys_msg_board

        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

    @@: push    10

        pop     ecx

        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

}