home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / assemblr / mslang / params / params.asm next >
Encoding:
Assembly Source File  |  1993-09-30  |  7.8 KB  |  204 lines
  1. .model small
  2.  
  3. .data
  4.    PUBLIC PSPSeg
  5.    firstScan db 1
  6.    PSPSeg    dw 0
  7.    QUOTE EQU '"'   ; if this is EQU 0, quoted strings will not be 
  8.                    ; recognized as one paramter, if they contain
  9.                    ; whitespace (blanks)
  10. .stack 100h
  11.  
  12. .code
  13.  
  14. ;*******************************************************************
  15. ;  void ScanCommands( void );
  16. ; 
  17. ;  Parses the command line into parameters, terminating each with
  18. ;  a zero byte and the whole line with another zero byte.
  19. ;  Separators for parameters are all characters <= ' '. If the QUOTE 
  20. ;  symbol is <> 0, a string enclosed in QUOTEs will be treated as one 
  21. ;  parameter, even if it contains whitespace. There may be other non-
  22. ;  blank characters before and after the quote, which will be counted
  23. ;  as belonging to the same parameter.
  24. ;  Will set the firstScan variable to 0. Assumes ds=@data, preserves
  25. ;  all registers.
  26. ;*******************************************************************
  27. ScanCommands PROC USES ax bx cx dx ds
  28.      mov firstScan, 0      ; set flag to false 
  29.      ; set up ds:bx to point to the command line, cl with the length
  30.      mov  ds, PSPSeg
  31. ASSUME ds:nothing
  32.      mov  bx, 80h
  33.      mov  cl, byte ptr [bx]
  34.      inc  bx
  35.      or   cl, cl
  36.      jz   end_of_line
  37.  
  38.      ; The following scanning loop has two parts. First we look for
  39.      ; a non-whitespace char as start of a parameter, then for its end.
  40.      ; cl is tested for end of commandline conditions
  41.      ; Throughout this loop, ch holds the QUOTE character, al the
  42.      ; current character and ah the terminator to skip or find.
  43.  
  44.      mov  ch, QUOTE        ; load working registers
  45.      mov  ah, ' '          ; terminator is whitespace first
  46.      ; find start of next param
  47. find_new_param:
  48.      mov  al, [bx]         ; get next character
  49.      cmp  al, ah           ; compare to current terminator (' ' here)
  50.      ja   param_start      ; if it is a whitespace
  51. find_1:
  52.      inc  bx               ; point to next character
  53.      dec  cl               ; dec character counter
  54.      jz   end_of_line      ; if it is zero, end of line reached
  55.      jmp  short find_new_param ; else test next char
  56.      ; found param, seek for its end
  57. param_start:
  58.      cmp  al, ch           ; is char the quote char?
  59.      jne  no_quote         ; if yes, 
  60.      cmp  al, ah           ; are we currently looking for one as terminator?
  61.      jne  starting_quote   ; if yes
  62.      mov  ah, ' '          ; reset terminator to blank, we found the end
  63.                            ; of a quoted string
  64.      jmp  short next_char
  65. starting_quote:            ; else make the quote the terminator IF it is
  66.                            ; not zero!
  67.      or   ch, ch
  68.      jz   find_1           ; hey! we have a zero-terminated string here,
  69.                            ; a ready-made parameter, so seek the next
  70.      mov  ah, ch           ; else look for the quote next
  71.      jmp  short next_char
  72. no_quote:
  73.      cmp  al, ah           ; is this character a whitespace?
  74.      ja   next_char        ; if yes
  75.      cmp  ah, ch           ; are we looking for a quote as terminator?
  76.      je   next_char        ; if not
  77.      mov  byte ptr [bx],0  ; make current character a zero char
  78.      jmp  find_1           ; and go looking for the next parameters start
  79.  
  80. next_char:
  81.      inc  bx               ; point to next character
  82.      dec  cl               ; dec character counter
  83.      jz   end_of_line      ; if it is zero, end of line reached
  84.      mov  al, [bx]         ; else load the next character
  85.      jmp  short param_start; and go test it
  86.  
  87. end_of_line:
  88.      cmp  bx, 100h         ; are we still inside the PSP?
  89.      jnb  scan_done        ; if yes
  90.      mov  byte ptr [bx], 0 ; add an additional zero byte
  91.  
  92. scan_done:
  93.      ret
  94. ASSUME ds:@data
  95.  
  96. ScanCommands ENDP
  97.  
  98. ;*******************************************************************
  99. ;   int ParamCount( void );
  100. ;
  101. ;   ParamCount returns the number of parameters on the command line
  102. ;   in AX. Keeps all other registers unchanged.
  103. ;   On the first run, ParamCount will parse the command line and 
  104. ;   convert each parameter to a zero-terminated string.
  105. ;
  106. ;   Assumes ds is pointing to @data
  107. ;*******************************************************************
  108. ParamCount PROC PUBLIC USES si cx ds
  109.      test firstScan, 0FFh  ; flag <> 0?
  110.      jz   @F
  111.      call ScanCommands     ; if not, parse the commandline
  112. @@:
  113.      ; count the zero bytes in the command tail, this now gives
  114.      ; the number of parameters
  115.      mov  ds, PSPSeg ; point ds:si at length byte of command tail
  116. ASSUME ds:nothing
  117.      mov  si, 80h
  118.      mov  cl, [si]
  119.      sub  ch, ch     ; cx has length of command tail
  120.      inc  si         ; ds:si points to start of command tail
  121.      sub  ax, ax     ; use ax to hold count
  122.      jcxz count_done
  123. count_loop:
  124.      cmp  byte ptr [si], 0 ; is current char a zero byte?
  125.      jne  @F               ; if yes
  126.      inc  ax               ; count it
  127. @@:
  128.      inc  si               ; next char
  129.      dec  cx
  130.      jnz  count_loop       ; loop if not done
  131.      ; slight problem here, we will not get to the zero terminating
  132.      ; the last parameter 'cause its not included in the character count
  133.      ; just test if the last character tested was a zero, if not, assume
  134.      ; an additonal parameter
  135.      dec  si
  136.      cmp  byte ptr [si], 0
  137.      je   count_done
  138.      inc  ax
  139. count_done:
  140.      ret 
  141. ASSUME ds:@data
  142. ParamCount ENDP
  143.  
  144. ;*******************************************************************
  145. ;   char far *ParamStr( int n );
  146. ;
  147. ;   ParamStr returns a far pointer to the n-th parameter on the
  148. ;   command line in dx:ax. Count starts at 1!
  149. ;   Uses register calling convention! n is expected in AX on entry.
  150. ;
  151. ;   Assumes ds is pointing to @data. Leaves all registers except
  152. ;   dx and ax intact.
  153. ;*******************************************************************
  154. ParamStr PROC PUBLIC USES bx cx ds
  155.      test firstScan, 0FFh  ; has command line be parsed yet?
  156.      jz   @F
  157.      call ScanCommands     ; if not, parse it now
  158. @@:
  159.      mov  cx, ax     ; cx has index (offset from 1)
  160.      mov  ds, PSPSeg ; point ds:bx at length byte of command tail
  161. ASSUME ds:nothing
  162.      mov  bx, 80h
  163.      mov  al, [bx]   ; use length value in al as a guard for overruns
  164.                      ; (index given > ParamCount)
  165.      inc  bx         ; point ds:bx at first char
  166.      jcxz @F         ; index 0 is an error but is treated as 1 here
  167.      dec  cx         ; convert index to number of zero-bytes to count
  168. @@:
  169.      jcxz found_param; if cx=0, index was 1, needs no search
  170.  
  171.      ; now search thru the command line, counting zero bytes as proxy
  172.      ; for a parameter
  173. find_loop:
  174.      cmp  byte ptr [bx], 0  ; is this the end of a param?
  175.      jne  @F                ; if yes
  176.      dec  cx                ; reduce count
  177. @@:     
  178.      inc  bx                ; next character
  179.      dec  al                ; dec guard value
  180.      jz   overrun           ; if it is now zero, we have reached the end
  181.                             ;   of the command line
  182.      jcxz found_param       ; else if cx is zero, we are at the start
  183.                             ;   of the requested parameter
  184.      jmp short find_loop    ; else continue search
  185.  
  186. found_param:
  187.      ; ds:bx now points at the start of a parameter. It may contain
  188.      ; blanks at the start due to the parsing method. Skip over these.
  189.      ; A non-blank character is guaranteed in the parameter.
  190. skip_blanks:
  191.      cmp byte ptr [bx], ' ' ; is this a whitespace character?
  192.      ja  @F                 ; if not, done
  193.      inc bx                 ; else skip it
  194.      jmp short skip_blanks  ; and test again
  195. @@:
  196. overrun:                    ; if overrun, bx will point to a zero-byte
  197.      mov dx, ds             ; set up result in dx:ax
  198.      mov ax, bx
  199.      ret
  200. ASSUME ds:@data
  201. ParamStr ENDP
  202.  
  203. END
  204.