home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / assemblr / mslang / as / cleanf.asm < prev    next >
Assembly Source File  |  1985-08-28  |  4KB  |  147 lines
  1.     name    cleanf
  2.     page    55,132
  3.     title    'CLEANF - Filter text file'
  4. ;
  5. ; CLEANF - a DOS 2.0 filter for word processing document files.
  6. ; 
  7. ; CLEAN.ASM Originally written by Ray Duncan
  8. ; Converted to DOS 2.0 filter CLEANF.ASM by Bob Taylor.
  9. ;
  10. ; This program reads text from the standard input device and writes
  11. ; filtered and transformed text to the standard output device.
  12. ; 
  13. ;    1.  High bit of all characters is stripped off.
  14. ;     2.  Tabs are expanded.
  15. ;       3.  Removes all control codes except for line
  16. ;           feeds, carriage returns, and form feeds.
  17. ;       4.  Appends an end-of-file mark to the text, if
  18. ;           none was present in the input stream.
  19. ;
  20. ; Can be used to make a WordStar file acceptable for 
  21. ; other screen or line editors, and vice versa.
  22. ;
  23. ;
  24. cr    equ    0dh        ; ASCII carriage return
  25. lf    equ    0ah        ; ASCII line feed
  26. ff    equ    0ch        ; ASCII form feed
  27. eof    equ    01ah        ; End-of-file marker
  28. tab    equ    09h        ; ASCII tab code
  29.  
  30. command    equ    80h        ; buffer for command tail
  31.  
  32. ; DOS 2.0 Pre-Defined Handles
  33.  
  34. stdin    equ    0000        ; standard input file
  35. stdout    equ    0001        ; standard output file
  36. stderr    equ    0002        ; standard error file
  37. stdaux    equ    0003        ; standard auxilliary file
  38. stdprn    equ    0004        ; standard printer file
  39.  
  40. cseg    segment para public 'CODE'
  41.  
  42.     assume    cs:cseg,ds:cseg
  43.  
  44.     org    100H        ; start .COM at 100H
  45.  
  46. clean    proc    far        ; entry point from PC-DOS.
  47.     push    ds        ; push a long return back
  48.     xor    ax,ax        ; to DOS onto the stack.
  49.     push    ax
  50.  
  51. clean3:    call    get_char    ; get a character from input.
  52.     and    al,7fh        ; turn off the high bit.
  53.     cmp    al,20h        ; is it a control char?
  54.     jae    clean4        ; no.  write it to output.
  55.     cmp    al,eof        ; is it end of file?
  56.     je    clean6        ; yes, go write EOF mark and exit.
  57.     cmp    al,tab        ; is it a tab?
  58.     je    clean5        ; yes, go expand it to spaces.
  59.     cmp    al,cr        ; is it a carriage return?
  60.     je    clean35        ; yes, go process it.
  61.     cmp    al,lf        ; is it a line feed?
  62.     je    clean35        ; yes, go process it.
  63.     cmp    al,ff        ; is it a form feed?
  64.     jne    clean3        ; no. discard it.  
  65. clean35:
  66.     mov    column,0    ; if it's a legit ctrl char,
  67.     jmp    clean45        ;  we should be back at column 0.
  68.  
  69. clean4:    inc    column        ; if it's a non-ctrl char, 
  70. clean45:            ;  col = col + 1.
  71.     call    put_char    ; write the char to output.
  72.     jnc    clean3        ; if OK, go back for another char.
  73.  
  74.     mov    bx,stderr    ; not OK.  Set up to show error.
  75.     mov    dx,offset err_msg
  76.     mov    cx,err_msg_len    ; error = Disk full.
  77.     mov    ah,40h        ; write the error message
  78.     int    21h        ; to the standard error device. (CON:)
  79.     ret            ; back to DOS.
  80.  
  81. clean5:    mov    ax,column    ; tab code detected, must expand 
  82.     cwd            ; expand tabs to spaces.
  83.     mov    cx,8        ; divide the current column counter
  84.     idiv    cx        ; by eight...
  85.     sub    cx,dx        ; eight minus the remainder is the 
  86.     add    column,cx    ; number of spaces to send out to
  87. clean55:            ; move to the next tab position.
  88.     push    cx
  89.     mov    al,20h
  90.     call    put_char    ; send an ASCII blank
  91.     pop    cx
  92.     loop    clean55
  93.     jmp    clean3
  94.  
  95. clean6:    call    put_char    ; write out the EOF mark,
  96.     ret            ; and return to DOS.
  97.  
  98. clean    endp
  99.  
  100.  
  101. get_char proc near
  102.     mov    bx,stdin        ; get chars from std. input
  103.     mov    cx,1            ; # of chars to get = 1
  104.     mov    dx,offset input_buffer    ; location = input_buffer
  105.     mov    ah,3fh
  106.     int    21h            ; do the function call
  107.     or    ax,ax            ; test # of chars returned
  108.     jz    get_char1        ; if none, return EOF
  109.     mov    al,input_buffer        ; else, return the char in AL
  110.     ret
  111. get_char1:
  112.     mov    al,eof            ; no chars read, return 
  113.     ret                ; an End-of-File (EOF) mark.
  114. get_char endp
  115.  
  116. put_char proc near
  117.     mov    output_buffer,al    ; put char to write in buffer.
  118.     mov    bx,stdout        ; write to std. output
  119.     mov    cx,1            ; # of chars = 1
  120.     mov    dx,offset output_buffer    ; location = output_buffer
  121.     mov    ah,40h
  122.     int    21h            ; do the function call
  123.     cmp    ax,1            ; check to see it was really done.
  124.     jne    put_char1
  125.     clc                ; really done. return carry = 0
  126.     ret                ; as success signal.
  127. put_char1:
  128.     stc                ; not really done. return carry = 1
  129.     ret                ; as error signal (device is full).
  130. put_char endp
  131.  
  132. input_buffer    db    0        
  133. output_buffer    db    0
  134.  
  135. column        dw    0
  136.  
  137. err_msg        db    cr,lf
  138.         db    'clean: Disk is full.'
  139.         db    cr,lf
  140. err_msg_len    equ    (this byte)-(offset err_msg)
  141.  
  142. cseg    ends
  143.  
  144.     end    clean
  145.  
  146.  
  147.