home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ddkx86v5.zip / DDKX86 / SRC / DEV / DASD / CDROM / ATAPI / DPRINTF.ASM < prev    next >
Encoding:
Assembly Source File  |  1995-04-14  |  16.1 KB  |  596 lines
  1. ;*DDK*************************************************************************/
  2. ;
  3. ; COPYRIGHT    Copyright (C) 1995 IBM Corporation
  4. ;
  5. ;    The following IBM OS/2 WARP source code is provided to you solely for
  6. ;    the purpose of assisting you in your development of OS/2 WARP device
  7. ;    drivers. You may use this code in accordance with the IBM License
  8. ;    Agreement provided in the IBM Device Driver Source Kit for OS/2. This
  9. ;    Copyright statement may not be removed.;
  10. ;*****************************************************************************/
  11. ; 
  12. ;****************************************************************************
  13. ;*
  14. ;* dprintf - this routine displays information on the debug terminal. it
  15. ;*         provides limited formatting, which is a subset of c's printf
  16. ;*         function
  17. ;*
  18. ;*    calling sequence:    push selector for insert 'n'
  19. ;*                push offset for insert 'n'
  20. ;*                push selector for 'n-1'
  21. ;*                push offset for 'n-1'
  22. ;*                   ...
  23. ;*                push selector for second insert
  24. ;*                push offset for second insert
  25. ;*                push selector for first insert
  26. ;*                push offset for first insert
  27. ;*                push selector raw string
  28. ;*                push offset for raw string
  29. ;*                call dprintf
  30. ;*                add sp,4 + ('n' * 4)
  31. ;*
  32. ;*            for "%w", just push one word containing the data to
  33. ;*                  be displayed. make sure that the "add sp"
  34. ;*                  cleans the stack correctly.
  35. ;*
  36. ;*            for "%z", just the repeat count, then the selector
  37. ;*                  of the area to display, and then the offset.
  38. ;*                  make sure that the "add sp" cleans the stack
  39. ;*                  correctly.
  40. ;*
  41. ;*    formatting:    prior to being displayed, the raw string is formatted
  42. ;*            by scanning it for format control sequences. as each
  43. ;*            format control sequence is encountered, it is replaced
  44. ;*            by appropriately formatted text obtained from the
  45. ;*            corresponding pointer
  46. ;*
  47. ;*            the following format control sequences are supported:
  48. ;*
  49. ;*            %c -  the corresponding far ptr points to a byte
  50. ;*                  which replaces the "%c"
  51. ;*
  52. ;*            %u -  the corresponding far ptr points to a word
  53. ;*                  which is displayed as an unsigned decimal
  54. ;*                  integer, replacing the "%u"
  55. ;*
  56. ;*            %x -  the corresponding far ptr points to a word
  57. ;*                  which is displayed as upper case hex,
  58. ;*                  replacing the "%X"
  59. ;*
  60. ;*            %lx - the corresponding far ptr points to a double
  61. ;*                  word which is displayed as upper case hex,
  62. ;*                  replacing the "%X"
  63. ;*
  64. ;*            %s -  the corresponding far ptr points to a null
  65. ;*                  terminated string which is displayed unchanged,
  66. ;*                  replacing the "%s"
  67. ;*
  68. ;*            %p -  the corresponding far ptr is displayed as upper
  69. ;*                  case hex in the format "ssss:oooo"
  70. ;*
  71. ;*            %w -  the corresponding word is displayed as upper
  72. ;*                  case hex replacing the "%w". note that in this
  73. ;*                  case, only one word is pushed onto the stack
  74. ;*                  for the %w insert
  75. ;*
  76. ;*            %z -  using the corresponding repeat count and far
  77. ;*                  pointer, a memory dump is produced. note that
  78. ;*                  in this case the stack contains a repeat count
  79. ;*                  and a far pointer to the area to dump
  80. ;*
  81. ;*            %% -  the character "%" is displayed, replacing the
  82. ;*                  "%%"
  83. ;*
  84. ;*
  85.  
  86.  
  87. .286p
  88.  
  89.  
  90. COM1_PORT    EQU    03f8h
  91. COM2_PORT    EQU    02f8h
  92.  
  93.  
  94. DEFAULT_PORT    EQU    COM1_PORT
  95.  
  96. CAR_RET     EQU    0DH
  97. LINE_FEED    EQU    0AH
  98. BELL        EQU    07H
  99. COM_LSR     EQU    05H
  100. COM_DAT     EQU    00H
  101.  
  102.  
  103.  
  104. s_frame     struc
  105.  
  106. s_bp        dw    ?        ; callers bp.
  107. s_ptr_delta    dw    ?        ; delta (in bytes) to current pointer
  108.                     ; from first pointer.
  109. s_ret        dw    ?        ; callers ip.
  110. s_string    dd    ?        ; far pointer to raw string.
  111. s_ptrs        dd    ?        ; pointer to first variable.
  112.  
  113. s_frame     ends
  114.  
  115. ;word_10000     dw     10000
  116. ;word_1000     dw     1000
  117. ;word_100     dw     100
  118. ;word_10     dw     10
  119.  
  120.  
  121. _DATA           segment dword public 'DATA'
  122.  
  123.                 extrn  _ComPort:word
  124.  
  125. _DATA           ends
  126.  
  127.  
  128. _TEXT    segment dword public 'code'
  129.     assume    cs:_TEXT,ds:_DATA
  130.  
  131. _dprintf    proc    near
  132.         public    _dprintf
  133.  
  134.  
  135.         push    0        ; zero the delta to current pointer.
  136.  
  137.         push    bp        ; save our callers bp register.
  138.         mov    bp,sp        ; point to our stack frame.
  139.  
  140.         push    ds        ; save our callers ds register.
  141.         push    es        ; save our callers es register.
  142.         pusha            ; save all other caller registers.
  143.         pushf
  144.         cli
  145.  
  146.         lds    si,ss:[bp+s_string] ; point to the raw string.
  147.  
  148. dprintf_loop:    lodsb            ; pick up a byte of the string.
  149.  
  150.         or    al,al        ; is it the end of the string?
  151.         jnz    dprintf_more    ; no, go check for format control.
  152.  
  153.         popf
  154.         popa            ; restore all other caller registers.
  155.         pop    es        ; restore our callers es register.
  156.         pop    ds        ; restore our callers ds register.
  157.         pop    bp        ; restore our callers bp register.
  158.         add    sp,2        ; unstack s_ptr_delta.
  159.  
  160.         ret            ; return to our caller.
  161.  
  162. dprintf_more:    cmp    al,'%'          ; no, is it the start of a format
  163.                     ; control sequence?
  164.         je    dprintf_type    ; yes, go see what type of sequence.
  165.         jmp    dprintf_put_ch    ; no, go display character and return.
  166.  
  167. dprintf_type:    lodsb            ; pick up a byte of the string.
  168.         cmp    al,'%'          ; is caller trying to display "%"?
  169.  
  170.         jne    dprintf_try_c    ; no, go see if it is a "c".
  171.  
  172.         mov    al,'%'          ; yes, go display it
  173.         jmp    dprintf_put_ch    ; and exit.
  174.  
  175. dprintf_try_c:    cmp    al,'c'          ; is it a string display?
  176.         jne    dprintf_try_s    ; no, go see if it is a "s".
  177.  
  178.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  179.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  180.         les    bx,ss:[bx]           ; pointer.
  181.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  182.  
  183.         mov    al,es:[bx]    ; pick up a byte.
  184.         jmp    dprintf_put_ch    ; go display character and return.
  185.  
  186. dprintf_try_s:    cmp    al,'s'          ; is it a string display?
  187.         jne    dprintf_try_u    ; no, go see if it is a "u".
  188.  
  189.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  190.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  191.         les    bx,ss:[bx]           ; pointer.
  192.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  193.  
  194. dprintf_next_s: mov    al,es:[bx]    ; pick up a byte.
  195.  
  196.         or    al,al        ; is it the end of the string?
  197.         jz    dprintf_loop    ; yes, go do next raw string byte.
  198.  
  199.         call    put_char    ; no, display the character.
  200.  
  201.         inc    bx        ; move down to the next character
  202.         jmp    dprintf_next_s    ; and go round again.
  203.  
  204. dprintf_try_u:    cmp    al,'u'          ; is it an unsigned short display?
  205.         jne    dprintf_try_x    ; no, go see if it is a "X".
  206.  
  207.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  208.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  209.         les    bx,ss:[bx]           ; pointer.
  210.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  211.  
  212.         mov    ax,es:[bx]    ; pick up the word to display.
  213.  
  214.         xor    dx,dx        ; convert the
  215.         mov    cx, 10000
  216.         div    cx        ; ten thousands
  217. ;        div    word_10000    ; ten thousands
  218.         or    al,'0'          ; digit and
  219.         call    put_char    ; display it.
  220.  
  221.         mov    ax,dx        ; convert the
  222.         xor    dx,dx        ; thousands
  223.         mov    cx, 1000
  224.         div    cx        ; digit
  225. ;        div    word_1000    ; digit
  226.         or    al,'0'          ; and
  227.         call    put_char    ; display it.
  228.  
  229.         mov    ax,dx        ; convert the
  230.         xor    dx,dx        ; hundreds
  231.         mov    cx, 100
  232.         div    cx        ; digit
  233. ;        div    word_100    ; digit
  234.         or    al,'0'          ; and
  235.         call    put_char    ; display it.
  236.  
  237.         mov    ax,dx        ; convert the
  238.         xor    dx,dx        ; tens
  239.         mov    cx, 10
  240.         div    cx        ; digit
  241. ;        div    word_10     ; digit
  242.         or    al,'0'          ; and
  243.         call    put_char    ; display it.
  244.  
  245.         mov    al,dl        ; convert the units digit
  246.         or    al,'0'          ; and go display it
  247.         jmp    dprintf_put_ch    ; and return.
  248.  
  249. dprintf_try_x:    cmp    al,'x'          ; is it an unsigned short hex display?
  250.         jne    dprintf_try_lx    ; no, go see if it is a "lX".
  251.  
  252.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  253.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  254.         les    bx,ss:[bx]           ; pointer.
  255.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  256.  
  257.         call    put_hex_word    ; convert and display the word.
  258.  
  259.         jmp    dprintf_loop    ; go do next raw string byte.
  260.  
  261. dprintf_try_lx: cmp    al,'l'          ; is it an unsigned long hex display?
  262.         jne    dprintf_try_p    ; no, go see if it is a "p".
  263.         lodsb            ; maybe, pick up a byte of the string.
  264.         cmp    al,'x'          ; is the second byte correct?
  265.         je    dprintf_do_lx    ; no, go report
  266.         jmp    dprintf_error    ; the error.
  267.  
  268. dprintf_do_lx:    lea    bx,[bp]+s_ptrs           ; yes, pick up the
  269.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  270.         les    bx,ss:[bx]           ; pointer.
  271.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  272.  
  273.         add    bx,2        ; move down to the second word.
  274.         call    put_hex_word    ; convert and display the second word.
  275.         sub    bx,2        ; move back to the first word.
  276.         call    put_hex_word    ; convert and display the first word.
  277.  
  278.         jmp    dprintf_loop    ; go do next raw string byte.
  279.  
  280. dprintf_try_p:    cmp    al,'p'          ; is it a far pointer display?
  281.         jne    dprintf_try_w    ; no, go see if it is a "w".
  282.  
  283.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  284.         add    bx,ss:[bp+s_ptr_delta] ; corresponding pointer.
  285.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  286.  
  287.         push    es        ; save the callers data selector.
  288.  
  289.         push    ss        ; set up the proper
  290.         pop    es        ; selector.
  291.  
  292.         add    bx,2        ; move down to the second word.
  293.         call    put_hex_word    ; convert and display the selector.
  294.         mov    al,':'          ; display
  295.         call    put_char    ; the ":".
  296.         sub    bx,2        ; move back to the first word.
  297.         call    put_hex_word    ; convert and display the offset.
  298.  
  299.         mov    al,' '          ; display
  300.         call    put_char    ; a couple
  301.         mov    al,' '          ; of
  302.         call    put_char    ; spaces.
  303.  
  304.         pop    es        ; recover the callers data selector.
  305.  
  306.         jmp    dprintf_loop    ; go do next raw string byte.
  307.  
  308. dprintf_try_w:    cmp    al,'w'          ; is it an immediate word display?
  309.         jne    dprintf_try_z    ; no, go see if it is a "z".
  310.  
  311.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  312.         add    bx,ss:[bp+s_ptr_delta] ; corresponding pointer.
  313.         add    ss:[bp+s_ptr_delta],2  ; move down to next pointer.
  314.  
  315.         push    es        ; save the callers data selector.
  316.  
  317.         push    ss        ; set up the proper
  318.         pop    es        ; selector.
  319.  
  320.         call    put_hex_word    ; convert and display the word.
  321.  
  322.         pop    es        ; recover the callers data selector.
  323.  
  324.         jmp    dprintf_loop    ; go do next raw string byte.
  325.  
  326. dprintf_try_z:    cmp    al,'z'          ; is it a memory dump display?
  327.         je    dprintf_do_z    ; no, go report
  328.         jmp    dprintf_error    ; the error.
  329.  
  330. dprintf_do_z:
  331.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  332.         add    bx,ss:[bp+s_ptr_delta] ; corresponding pointer.
  333.         add    ss:[bp+s_ptr_delta],6  ; move down to next pointer.
  334.  
  335.         mov    cx,ss:[bx+4]    ; pick up the repeat count.
  336.  
  337.         push    es        ; save the callers data selector.
  338.  
  339.         les    bx,ss:[bx]    ; point to the area to display.
  340.  
  341. dprintf_z_a:    mov    ax,es        ; pick up the selector to display.
  342.         xchg    ah,al        ; set up to process the first byte.
  343.         call    put_left_nib    ; display the first byte
  344.         call    put_right_nib    ; of the selector.
  345.         xchg    ah,al        ; set up to process the second byte.
  346.         call    put_left_nib    ; display the second byte
  347.         call    put_right_nib    ; of the selector.
  348.  
  349.         mov    al,':'          ; display a
  350.         call    put_char    ; colon.
  351.  
  352.         mov    ax,bx        ; pick up the offset to display.
  353.         xchg    ah,al        ; set up to process the first byte.
  354.         call    put_left_nib    ; display the first byte
  355.         call    put_right_nib    ; of the offset.
  356.         xchg    ah,al        ; set up to process the second byte.
  357.         call    put_left_nib    ; display the second byte
  358.         call    put_right_nib    ; of the offset.
  359.  
  360.         mov    al,' '          ; display
  361.         call    put_char    ; two
  362.         mov    al,' '          ; seperating
  363.         call    put_char    ; spaces.
  364.  
  365.         push    cx        ; save the repeat count for later.
  366.  
  367.         mov    dx,16*3+1    ; initialize the fill count.
  368.  
  369.         cmp    cx,16        ; are there more than 16 bytes left?
  370.         jbe    dprintf_z_b    ; yes, limit it to 16 bytes
  371.         mov    cx,16        ; for this line.
  372.  
  373. dprintf_z_b:    push    bx        ; save offset and display count
  374.         push    cx        ; for the character display.
  375.  
  376. dprintf_z_c:    mov    al,es:[bx]    ; pick up a byte to display.
  377.         call    put_hex_byte    ; display it in hex.
  378.  
  379.         mov    al,' '          ; set up to display a space.
  380.         cmp    dx,9*3+1    ; should it be a dash?
  381.         jne    dprintf_z_e    ; no, bypass changing it.
  382.         mov    al,'-'          ; yes, set up to display a dash.
  383. dprintf_z_e:    call    put_char    ; display the dash or space.
  384.  
  385.         sub    dx,3        ; down the fill count by one position.
  386.  
  387.         inc    bx        ; move down to the next byte.
  388.  
  389.         loop    dprintf_z_c    ; more to do? yes, go round again?
  390.  
  391.         mov    cx,dx        ; no, pick up remaining fill count.
  392.  
  393. dprintf_z_g:    mov    al,' '          ; display a
  394.         call    put_char    ; space.
  395.  
  396.         loop    dprintf_z_g    ; more to do? yes, go round again.
  397.  
  398.         pop    cx        ; recover the offset and
  399.         pop    bx        ; display count.
  400.  
  401. dprintf_z_i:    mov    al,'.'          ; set up to display a dot.
  402.  
  403.         mov    ah,es:[bx]    ; does the byte
  404.         cmp    ah,20h        ; contain a
  405.         jb    dprintf_z_k    ; valid ascii
  406.         cmp    ah,7fh        ; code?
  407.         ja    dprintf_z_k    ; no, go display the dot.
  408.  
  409.         xchg    al,ah        ; yes, set up to do byte's contents.
  410.  
  411. dprintf_z_k:    call    put_char    ; display a dot or the byte contents.
  412.  
  413.         inc    bx        ; move down to the next byte.
  414.  
  415.         loop    dprintf_z_i    ; more to do on this line?
  416.                     ; yes, go round again.
  417.  
  418.         pop    cx        ; no, recover the repeat count.
  419.  
  420.         sub    cx,16        ; down the repeat count by one line.
  421.  
  422.         jle    dprintf_z_z    ; more to do? no, go exit.
  423.  
  424.         mov    al,CAR_RET    ; perform
  425.         call    put_char    ; a
  426.         mov    al,LINE_FEED    ; new line
  427.         call    put_char    ; operation.
  428.  
  429.         jmp    dprintf_z_a    ; go round and display another line.
  430.  
  431. dprintf_z_z:    pop    es        ; recover the callers data selector.
  432.  
  433.         jmp    dprintf_loop    ; go do next raw string byte.
  434.  
  435. dprintf_error:    mov    ah,al        ; display
  436.         mov    al,'?'          ; an
  437.         call    put_char    ; eye
  438.         mov    al,'\'          ; catching
  439.         call    put_char    ; "invalid
  440.         mov    al,ah        ; format
  441.         call    put_char    ; control"
  442.         mov    al,'\'          ; message
  443.         call    put_char    ; and
  444.         mov    al,BELL     ; beep.
  445.  
  446. dprintf_put_ch: call    put_char    ; display the character.
  447.         jmp    dprintf_loop    ; go process next raw string byte.
  448.  
  449. _dprintf    endp
  450.  
  451. put_left_nib    proc    near
  452.  
  453.         push    ax        ; save the callers ax register.
  454.  
  455.         shr    al,4        ; convert the
  456.         add    al,'0'          ; left nibble
  457.         cmp    al,'9'          ; to an ascii
  458.         jbe    put_left_nib_a    ; hex
  459.         add    al,'A'-'9'-1    ; representation.
  460. put_left_nib_a: call    put_char    ; display the character.
  461.  
  462.         pop    ax        ; restore the callers ax register.
  463.  
  464.         ret            ; return to our caller.
  465.  
  466. put_left_nib    endp
  467.  
  468. put_right_nib    proc    near
  469.  
  470.         push    ax        ; save the callers ax register.
  471.  
  472.         and    al,0fh        ; convert the
  473.         add    al,'0'          ; right nibble
  474.         cmp    al,'9'          ; to an
  475.         jbe    put_rght_nib_a    ; ascii hex
  476.         add    al,'A'-'9'-1    ; representation.
  477. put_rght_nib_a: call    put_char    ; display the character.
  478.  
  479.         pop    ax        ; restore the callers ax register.
  480.  
  481.         ret            ; return to our caller
  482.  
  483. put_right_nib    endp
  484.  
  485. put_hex_byte    proc    near
  486.  
  487.         mov    al,es:[bx]    ; display the left nibble
  488.         call    put_left_nib    ; in ascii hex.
  489.  
  490.         mov    al,es:[bx]    ; display the right nibble
  491.         call    put_right_nib    ; in ascii hex.
  492.  
  493.         ret            ; return to our caller.
  494.  
  495. put_hex_byte    endp
  496.  
  497.  
  498. put_hex_word    proc    near
  499.  
  500.         inc    bx        ; set up to process second byte first.
  501.  
  502.         call    put_hex_byte    ; display the byte in hex.
  503.  
  504.         dec    bx        ; move back to the first byte.
  505.  
  506.         call    put_hex_byte    ; display the byte in hex.
  507.  
  508.         ret            ; return to our caller.
  509.  
  510. put_hex_word    endp
  511.  
  512.  
  513. ;         public  portadr
  514. ;portadr     dw     DEFAULT_PORT     ; change config.h to change this.
  515.                     ; use: com2=02f8H, com1=03f8H
  516.  
  517. IODelay Macro
  518.     local a
  519.     jmp a
  520. a:
  521. endm
  522.  
  523. PollC    PROC    NEAR
  524.     public    PollC
  525.  
  526. ;    mov    dx, cs:PortAdr
  527.     mov    dx, _ComPort
  528.     add    dx, COM_LSR
  529.  
  530.     in    al,dx            ; get input status
  531. ;    IODelay
  532.  
  533.     and    al,1            ; is there a char in RECV buffer?
  534.     jz    plc1            ; no, go return empty
  535.  
  536. ;    mov    dx, cs:PortAdr
  537.     mov    dx, _ComPort
  538.     add    dx, COM_DAT
  539.  
  540.     in    al,dx            ;      char out of buffer
  541. ;    IODelay
  542.  
  543.     and    al,07fh         ; strip off        parity crap
  544. plc1:    ret
  545. PollC    ENDP
  546.  
  547.  
  548. ;**    PUTC - output a single char to COM2 handling ^S
  549.  
  550.  
  551. put_char    proc    near
  552.         public    put_char
  553.  
  554.     push    dx
  555.     push    ax
  556.  
  557. ;    See if ^S
  558.  
  559.     call    PollC            ; is there a char at input
  560.     jz    pc2            ; no, go output our char
  561.     cmp    al,'S' - 'A' + 1    ; is it ^S?
  562.     jnz    pc2            ; no, go output our char
  563.  
  564. ;    Saw ^S.  Wait for and eat next char.
  565.  
  566. pc1:    call    PollC            ; look for next char
  567.     jz    pc1            ; no char, go look again
  568.     cmp    al,'S' - 'A' + 1    ; is it ^S again?
  569.     jz    pc1            ; yes, go look for something else
  570.  
  571. ;pc2:     mov     dx, cs:PortAdr
  572. pc2:    mov    dx, _ComPort
  573.     add    dx, COM_LSR
  574.     in    al,dx
  575. ;    IODelay
  576.     test    al,020h
  577.     jz    pc2
  578.  
  579. ;    ready.    crank it out!
  580.  
  581. ;    mov    dx, cs:PortAdr
  582.     mov    dx, _ComPort
  583.     add    dx, COM_DAT
  584.     pop    ax
  585.     out    dx,al
  586.  
  587.         pop    dx        ; restore the callers dx register.
  588.  
  589.     ret
  590.  
  591. put_char    endp
  592.  
  593. _TEXT    ends
  594.     end
  595.  
  596.