home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ddkx86v5.zip / DDKX86 / SRC / DEV / DASD / IBM / IBM2SCSI / DPRINTF.ASM next >
Encoding:
Assembly Source File  |  1995-04-14  |  16.0 KB  |  589 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. _TEXT    segment word public 'code'
  122.     assume    cs:_TEXT
  123.  
  124. _dprintf    proc    near
  125.         public    _dprintf
  126.  
  127.  
  128.         push    0        ; zero the delta to current pointer.
  129.  
  130.         push    bp        ; save our callers bp register.
  131.         mov    bp,sp        ; point to our stack frame.
  132.  
  133.         push    ds        ; save our callers ds register.
  134.         push    es        ; save our callers es register.
  135.         pusha            ; save all other caller registers.
  136.         pushf
  137.         cli
  138.  
  139.         lds    si,ss:[bp+s_string] ; point to the raw string.
  140.  
  141. dprintf_loop:    lodsb            ; pick up a byte of the string.
  142.  
  143.         or    al,al        ; is it the end of the string?
  144.         jnz    dprintf_more    ; no, go check for format control.
  145.  
  146.         popf
  147.         popa            ; restore all other caller registers.
  148.         pop    es        ; restore our callers es register.
  149.         pop    ds        ; restore our callers ds register.
  150.         pop    bp        ; restore our callers bp register.
  151.         add    sp,2        ; unstack s_ptr_delta.
  152.  
  153.  
  154.         ret            ; return to our caller.
  155.  
  156. dprintf_more:    cmp    al,'%'          ; no, is it the start of a format
  157.                     ; control sequence?
  158.         je    dprintf_type    ; yes, go see what type of sequence.
  159.         jmp    dprintf_put_ch    ; no, go display character and return.
  160.  
  161. dprintf_type:    lodsb            ; pick up a byte of the string.
  162.         cmp    al,'%'          ; is caller trying to display "%"?
  163.  
  164.         jne    dprintf_try_c    ; no, go see if it is a "c".
  165.  
  166.         mov    al,'%'          ; yes, go display it
  167.         jmp    dprintf_put_ch    ; and exit.
  168.  
  169. dprintf_try_c:    cmp    al,'c'          ; is it a string display?
  170.         jne    dprintf_try_s    ; no, go see if it is a "s".
  171.  
  172.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  173.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  174.         les    bx,ss:[bx]           ; pointer.
  175.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  176.  
  177.         mov    al,es:[bx]    ; pick up a byte.
  178.         jmp    dprintf_put_ch    ; go display character and return.
  179.  
  180. dprintf_try_s:    cmp    al,'s'          ; is it a string display?
  181.         jne    dprintf_try_u    ; no, go see if it is a "u".
  182.  
  183.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  184.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  185.         les    bx,ss:[bx]           ; pointer.
  186.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  187.  
  188. dprintf_next_s: mov    al,es:[bx]    ; pick up a byte.
  189.  
  190.         or    al,al        ; is it the end of the string?
  191.         jz    dprintf_loop    ; yes, go do next raw string byte.
  192.  
  193.         call    put_char    ; no, display the character.
  194.  
  195.         inc    bx        ; move down to the next character
  196.         jmp    dprintf_next_s    ; and go round again.
  197.  
  198. dprintf_try_u:    cmp    al,'u'          ; is it an unsigned short display?
  199.         jne    dprintf_try_x    ; no, go see if it is a "X".
  200.  
  201.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  202.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  203.         les    bx,ss:[bx]           ; pointer.
  204.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  205.  
  206.         mov    ax,es:[bx]    ; pick up the word to display.
  207.  
  208.         xor    dx,dx        ; convert the
  209.         mov    cx, 10000
  210.         div    cx        ; ten thousands
  211. ;        div    word_10000    ; ten thousands
  212.         or    al,'0'          ; digit and
  213.         call    put_char    ; display it.
  214.  
  215.         mov    ax,dx        ; convert the
  216.         xor    dx,dx        ; thousands
  217.         mov    cx, 1000
  218.         div    cx        ; digit
  219. ;        div    word_1000    ; digit
  220.         or    al,'0'          ; and
  221.         call    put_char    ; display it.
  222.  
  223.         mov    ax,dx        ; convert the
  224.         xor    dx,dx        ; hundreds
  225.         mov    cx, 100
  226.         div    cx        ; digit
  227. ;        div    word_100    ; digit
  228.         or    al,'0'          ; and
  229.         call    put_char    ; display it.
  230.  
  231.         mov    ax,dx        ; convert the
  232.         xor    dx,dx        ; tens
  233.         mov    cx, 10
  234.         div    cx        ; digit
  235. ;        div    word_10     ; digit
  236.         or    al,'0'          ; and
  237.         call    put_char    ; display it.
  238.  
  239.         mov    al,dl        ; convert the units digit
  240.         or    al,'0'          ; and go display it
  241.         jmp    dprintf_put_ch    ; and return.
  242.  
  243. dprintf_try_x:    cmp    al,'x'          ; is it an unsigned short hex display?
  244.         jne    dprintf_try_lx    ; no, go see if it is a "lX".
  245.  
  246.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  247.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  248.         les    bx,ss:[bx]           ; pointer.
  249.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  250.  
  251.         call    put_hex_word    ; convert and display the word.
  252.  
  253.         jmp    dprintf_loop    ; go do next raw string byte.
  254.  
  255. dprintf_try_lx: cmp    al,'l'          ; is it an unsigned long hex display?
  256.         jne    dprintf_try_p    ; no, go see if it is a "p".
  257.         lodsb            ; maybe, pick up a byte of the string.
  258.         cmp    al,'x'          ; is the second byte correct?
  259.         je    dprintf_do_lx    ; no, go report
  260.         jmp    dprintf_error    ; the error.
  261.  
  262. dprintf_do_lx:    lea    bx,[bp]+s_ptrs           ; yes, pick up the
  263.         add    bx,ss:[bp+s_ptr_delta] ; corresponding
  264.         les    bx,ss:[bx]           ; pointer.
  265.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  266.  
  267.         add    bx,2        ; move down to the second word.
  268.         call    put_hex_word    ; convert and display the second word.
  269.         sub    bx,2        ; move back to the first word.
  270.         call    put_hex_word    ; convert and display the first word.
  271.  
  272.         jmp    dprintf_loop    ; go do next raw string byte.
  273.  
  274. dprintf_try_p:    cmp    al,'p'          ; is it a far pointer display?
  275.         jne    dprintf_try_w    ; no, go see if it is a "w".
  276.  
  277.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  278.         add    bx,ss:[bp+s_ptr_delta] ; corresponding pointer.
  279.         add    ss:[bp+s_ptr_delta],4  ; move down to next pointer.
  280.  
  281.         push    es        ; save the callers data selector.
  282.  
  283.         push    ss        ; set up the proper
  284.         pop    es        ; selector.
  285.  
  286.         add    bx,2        ; move down to the second word.
  287.         call    put_hex_word    ; convert and display the selector.
  288.         mov    al,':'          ; display
  289.         call    put_char    ; the ":".
  290.         sub    bx,2        ; move back to the first word.
  291.         call    put_hex_word    ; convert and display the offset.
  292.  
  293.         mov    al,' '          ; display
  294.         call    put_char    ; a couple
  295.         mov    al,' '          ; of
  296.         call    put_char    ; spaces.
  297.  
  298.         pop    es        ; recover the callers data selector.
  299.  
  300.         jmp    dprintf_loop    ; go do next raw string byte.
  301.  
  302. dprintf_try_w:    cmp    al,'w'          ; is it an immediate word display?
  303.         jne    dprintf_try_z    ; no, go see if it is a "z".
  304.  
  305.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  306.         add    bx,ss:[bp+s_ptr_delta] ; corresponding pointer.
  307.         add    ss:[bp+s_ptr_delta],2  ; move down to next pointer.
  308.  
  309.         push    es        ; save the callers data selector.
  310.  
  311.         push    ss        ; set up the proper
  312.         pop    es        ; selector.
  313.  
  314.         call    put_hex_word    ; convert and display the word.
  315.  
  316.         pop    es        ; recover the callers data selector.
  317.  
  318.         jmp    dprintf_loop    ; go do next raw string byte.
  319.  
  320. dprintf_try_z:    cmp    al,'z'          ; is it a memory dump display?
  321.         je    dprintf_do_z    ; no, go report
  322.         jmp    dprintf_error    ; the error.
  323.  
  324. dprintf_do_z:
  325.         lea    bx,[bp]+s_ptrs           ; yes, pick up the
  326.         add    bx,ss:[bp+s_ptr_delta] ; corresponding pointer.
  327.         add    ss:[bp+s_ptr_delta],6  ; move down to next pointer.
  328.  
  329.         mov    cx,ss:[bx+4]    ; pick up the repeat count.
  330.  
  331.         push    es        ; save the callers data selector.
  332.  
  333.         les    bx,ss:[bx]    ; point to the area to display.
  334.  
  335. dprintf_z_a:    mov    ax,es        ; pick up the selector to display.
  336.         xchg    ah,al        ; set up to process the first byte.
  337.         call    put_left_nib    ; display the first byte
  338.         call    put_right_nib    ; of the selector.
  339.         xchg    ah,al        ; set up to process the second byte.
  340.         call    put_left_nib    ; display the second byte
  341.         call    put_right_nib    ; of the selector.
  342.  
  343.         mov    al,':'          ; display a
  344.         call    put_char    ; colon.
  345.  
  346.         mov    ax,bx        ; pick up the offset to display.
  347.         xchg    ah,al        ; set up to process the first byte.
  348.         call    put_left_nib    ; display the first byte
  349.         call    put_right_nib    ; of the offset.
  350.         xchg    ah,al        ; set up to process the second byte.
  351.         call    put_left_nib    ; display the second byte
  352.         call    put_right_nib    ; of the offset.
  353.  
  354.         mov    al,' '          ; display
  355.         call    put_char    ; two
  356.         mov    al,' '          ; seperating
  357.         call    put_char    ; spaces.
  358.  
  359.         push    cx        ; save the repeat count for later.
  360.  
  361.         mov    dx,16*3+1    ; initialize the fill count.
  362.  
  363.         cmp    cx,16        ; are there more than 16 bytes left?
  364.         jbe    dprintf_z_b    ; yes, limit it to 16 bytes
  365.         mov    cx,16        ; for this line.
  366.  
  367. dprintf_z_b:    push    bx        ; save offset and display count
  368.         push    cx        ; for the character display.
  369.  
  370. dprintf_z_c:    mov    al,es:[bx]    ; pick up a byte to display.
  371.         call    put_hex_byte    ; display it in hex.
  372.  
  373.         mov    al,' '          ; set up to display a space.
  374.         cmp    dx,9*3+1    ; should it be a dash?
  375.         jne    dprintf_z_e    ; no, bypass changing it.
  376.         mov    al,'-'          ; yes, set up to display a dash.
  377. dprintf_z_e:    call    put_char    ; display the dash or space.
  378.  
  379.         sub    dx,3        ; down the fill count by one position.
  380.  
  381.         inc    bx        ; move down to the next byte.
  382.  
  383.         loop    dprintf_z_c    ; more to do? yes, go round again?
  384.  
  385.         mov    cx,dx        ; no, pick up remaining fill count.
  386.  
  387. dprintf_z_g:    mov    al,' '          ; display a
  388.         call    put_char    ; space.
  389.  
  390.         loop    dprintf_z_g    ; more to do? yes, go round again.
  391.  
  392.         pop    cx        ; recover the offset and
  393.         pop    bx        ; display count.
  394.  
  395. dprintf_z_i:    mov    al,'.'          ; set up to display a dot.
  396.  
  397.         mov    ah,es:[bx]    ; does the byte
  398.         cmp    ah,20h        ; contain a
  399.         jb    dprintf_z_k    ; valid ascii
  400.         cmp    ah,7fh        ; code?
  401.         ja    dprintf_z_k    ; no, go display the dot.
  402.  
  403.         xchg    al,ah        ; yes, set up to do byte's contents.
  404.  
  405. dprintf_z_k:    call    put_char    ; display a dot or the byte contents.
  406.  
  407.         inc    bx        ; move down to the next byte.
  408.  
  409.         loop    dprintf_z_i    ; more to do on this line?
  410.                     ; yes, go round again.
  411.  
  412.         pop    cx        ; no, recover the repeat count.
  413.  
  414.         sub    cx,16        ; down the repeat count by one line.
  415.  
  416.         jle    dprintf_z_z    ; more to do? no, go exit.
  417.  
  418.         mov    al,CAR_RET    ; perform
  419.         call    put_char    ; a
  420.         mov    al,LINE_FEED    ; new line
  421.         call    put_char    ; operation.
  422.  
  423.         jmp    dprintf_z_a    ; go round and display another line.
  424.  
  425. dprintf_z_z:    pop    es        ; recover the callers data selector.
  426.  
  427.         jmp    dprintf_loop    ; go do next raw string byte.
  428.  
  429. dprintf_error:    mov    ah,al        ; display
  430.         mov    al,'?'          ; an
  431.         call    put_char    ; eye
  432.         mov    al,'\'          ; catching
  433.         call    put_char    ; "invalid
  434.         mov    al,ah        ; format
  435.         call    put_char    ; control"
  436.         mov    al,'\'          ; message
  437.         call    put_char    ; and
  438.         mov    al,BELL     ; beep.
  439.  
  440. dprintf_put_ch: call    put_char    ; display the character.
  441.         jmp    dprintf_loop    ; go process next raw string byte.
  442.  
  443. _dprintf    endp
  444.  
  445. put_left_nib    proc    near
  446.  
  447.         push    ax        ; save the callers ax register.
  448.  
  449.         shr    al,4        ; convert the
  450.         add    al,'0'          ; left nibble
  451.         cmp    al,'9'          ; to an ascii
  452.         jbe    put_left_nib_a    ; hex
  453.         add    al,'A'-'9'-1    ; representation.
  454. put_left_nib_a: call    put_char    ; display the character.
  455.  
  456.         pop    ax        ; restore the callers ax register.
  457.  
  458.         ret            ; return to our caller.
  459.  
  460. put_left_nib    endp
  461.  
  462. put_right_nib    proc    near
  463.  
  464.         push    ax        ; save the callers ax register.
  465.  
  466.         and    al,0fh        ; convert the
  467.         add    al,'0'          ; right nibble
  468.         cmp    al,'9'          ; to an
  469.         jbe    put_rght_nib_a    ; ascii hex
  470.         add    al,'A'-'9'-1    ; representation.
  471. put_rght_nib_a: call    put_char    ; display the character.
  472.  
  473.         pop    ax        ; restore the callers ax register.
  474.  
  475.         ret            ; return to our caller
  476.  
  477. put_right_nib    endp
  478.  
  479. put_hex_byte    proc    near
  480.  
  481.         mov    al,es:[bx]    ; display the left nibble
  482.         call    put_left_nib    ; in ascii hex.
  483.  
  484.         mov    al,es:[bx]    ; display the right nibble
  485.         call    put_right_nib    ; in ascii hex.
  486.  
  487.         ret            ; return to our caller.
  488.  
  489. put_hex_byte    endp
  490.  
  491.  
  492. put_hex_word    proc    near
  493.  
  494.         inc    bx        ; set up to process second byte first.
  495.  
  496.         call    put_hex_byte    ; display the byte in hex.
  497.  
  498.         dec    bx        ; move back to the first byte.
  499.  
  500.         call    put_hex_byte    ; display the byte in hex.
  501.  
  502.         ret            ; return to our caller.
  503.  
  504. put_hex_word    endp
  505.  
  506.  
  507. ;         public  portadr
  508. ;portadr     dw     DEFAULT_PORT     ; change config.h to change this.
  509.                     ; use: com2=02f8H, com1=03f8H
  510.  
  511. IODelay Macro
  512.     local a
  513.     jmp a
  514. a:
  515. endm
  516.  
  517. PollC    PROC    NEAR
  518.     public    PollC
  519.  
  520. ;    mov    dx, cs:PortAdr
  521.     mov    dx, DEFAULT_PORT
  522.     add    dx, COM_LSR
  523.  
  524.     in    al,dx            ; get input status
  525. ;    IODelay
  526.  
  527.     and    al,1            ; is there a char in RECV buffer?
  528.     jz    plc1            ; no, go return empty
  529.  
  530. ;    mov    dx, cs:PortAdr
  531.     mov    dx, DEFAULT_PORT
  532.     add    dx, COM_DAT
  533.  
  534.     in    al,dx            ;      char out of buffer
  535. ;    IODelay
  536.  
  537.     and    al,07fh         ; strip off        parity crap
  538. plc1:    ret
  539. PollC    ENDP
  540.  
  541.  
  542. ;**    PUTC - output a single char to COM2 handling ^S
  543.  
  544.  
  545. put_char    proc    near
  546.         public    put_char
  547.  
  548.     push    dx
  549.     push    ax
  550.  
  551. ;    See if ^S
  552.  
  553.     call    PollC            ; is there a char at input
  554.     jz    pc2            ; no, go output our char
  555.     cmp    al,'S' - 'A' + 1    ; is it ^S?
  556.     jnz    pc2            ; no, go output our char
  557.  
  558. ;    Saw ^S.  Wait for and eat next char.
  559.  
  560. pc1:    call    PollC            ; look for next char
  561.     jz    pc1            ; no char, go look again
  562.     cmp    al,'S' - 'A' + 1    ; is it ^S again?
  563.     jz    pc1            ; yes, go look for something else
  564.  
  565. ;pc2:     mov     dx, cs:PortAdr
  566. pc2:    mov    dx, DEFAULT_PORT
  567.     add    dx, COM_LSR
  568.     in    al,dx
  569. ;    IODelay
  570.     test    al,020h
  571.     jz    pc2
  572.  
  573. ;    ready.    crank it out!
  574.  
  575. ;    mov    dx, cs:PortAdr
  576.     mov    dx, DEFAULT_PORT
  577.     add    dx, COM_DAT
  578.     pop    ax
  579.     out    dx,al
  580.  
  581.         pop    dx        ; restore the callers dx register.
  582.  
  583.     ret
  584.  
  585. put_char    endp
  586.  
  587. _TEXT    ends
  588.     end
  589.