getc.inc

   1 ;; -----------------------------------------------------------------------
   2 ;;
   3 ;;   Copyright 1994-2007 H. Peter Anvin - All Rights Reserved
   4 ;;
   5 ;;   This program is free software; you can redistribute it and/or modify
   6 ;;   it under the terms of the GNU General Public License as published by
   7 ;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
   8 ;;   Boston MA 02111-1307, USA; either version 2 of the License, or
   9 ;;   (at your option) any later version; incorporated herein by reference.
  10 ;;
  11 ;; -----------------------------------------------------------------------
  12
  13 ;;
  14 ;; getc.inc
  15 ;;
  16 ;; Simple file handling library (open, getc, ungetc)
  17 ;;
  18 ;; WARNING: This interface uses the real_mode_seg/comboot_seg.
  19 ;;
  20
  21 MAX_GETC_LG2    equ 4                   ; Max number of file nesting
  22 MAX_GETC        equ (1 << MAX_GETC_LG2)
  23 bytes_per_getc_lg2      equ 16-MAX_GETC_LG2
  24 bytes_per_getc          equ (1 << bytes_per_getc_lg2)
  25 secs_per_getc   equ bytes_per_getc/SECTOR_SIZE
  26 MAX_UNGET       equ 5                   ; Max bytes that can be pushed back
  27
  28                 struc getc_file
  29 gc_file         resw 1                  ; File pointer
  30 gc_bufbytes     resw 1                  ; Bytes left in buffer
  31 gc_bytes        resd 1                  ; Bytes left in file
  32 gc_bufdata      resw 1                  ; Pointer to data in buffer
  33 gc_unget_cnt    resb 1                  ; Character pushed back count
  34 gc_unget_buf    resb MAX_UNGET          ; Character pushed back buffer
  35                 endstruc
  36 getc_file_lg2   equ 4                   ; Size of getc_file as a power of 2
  37
  38 %ifndef DEPEND
  39 %if (getc_file_size != (1 << getc_file_lg2))
  40 %error "getc_file_size != (1 << getc_file_lg2)"
  41 %endif
  42 %endif
  43
  44 ;
  45 ; open,getc:    Load a file a character at a time for parsing in a manner
  46 ;               similar to the C library getc routine.
  47 ;               Up to MAX_GETC files can be open at the same time,
  48 ;               they are accessed in a stack-like fashion.
  49 ;
  50 ;               All routines assume CS == DS.
  51 ;
  52 ;               open:   Input:  mangled filename in DS:DI
  53 ;                       Output: ZF set on file not found or zero length
  54 ;
  55 ;               openfd: Input:  file handle in SI
  56 ;                       Output: ZF set on getc stack overflow
  57 ;
  58 ;               getc:   Output: CF set on end of file
  59 ;                               Character loaded in AL
  60 ;
  61 ;               close:  Output: CF set if nothing open
  62 ;
  63 open:
  64                 call searchdir
  65                 jz openfd.ret
  66 openfd:
  67                 push bx
  68
  69                 mov bx,[CurrentGetC]
  70                 sub bx,getc_file_size
  71                 cmp bx,GetCStack
  72                 jb .stack_full          ; Excessive nesting
  73                 mov [CurrentGetC],bx
  74
  75                 mov [bx+gc_file],si     ; File pointer
  76                 mov [bx+gc_bytes],ax    ; Bytes available
  77                 mov [bx+gc_bytes+2],dx
  78                 xor ax,ax
  79                 mov [bx+gc_bufbytes],ax         ; Buffer empty
  80                 mov [bx+gc_unget_cnt],al        ; ungetc buffer empty
  81
  82                 inc ax                  ; ZF <- 0
  83                 pop bx
  84 .ret:           ret
  85
  86 .stack_full:
  87                 call close_file
  88                 xor ax,ax               ; ZF <- 1
  89                 pop bx
  90                 ret
  91
  92 getc:
  93                 push bx
  94                 push si
  95                 push di
  96                 push es
  97
  98                 mov di,[CurrentGetC]
  99                 movzx bx,byte [di+gc_unget_cnt]
 100                 and bx,bx
 101                 jnz .have_unget
 102
 103                 mov ax,real_mode_seg    ; Borrow the real_mode_seg
 104                 mov es,ax
 105 .got_data:
 106                 sub word [di+gc_bufbytes],1
 107                 jc .get_data            ; Was it zero already?
 108                 mov si,[di+gc_bufdata]
 109                 mov al,[es:si]
 110                 inc si
 111                 mov [di+gc_bufdata],si
 112 .done:
 113                 clc
 114 .ret:
 115                 pop es
 116                 pop di
 117                 pop si
 118                 pop bx
 119                 ret
 120 .have_unget:
 121                 dec bx
 122                 mov al,[di+bx+gc_unget_buf]
 123                 mov [di+gc_unget_cnt],bl
 124                 jmp .done
 125
 126 .get_data:
 127                 pushad
 128                 ; Compute start of buffer
 129                 mov bx,di
 130                 sub bx,GetCStack
 131                 shl bx,bytes_per_getc_lg2-getc_file_lg2
 132
 133                 mov [di+gc_bufdata],bx
 134                 mov si,[di+gc_file]
 135                 mov ecx,[di+gc_bytes]
 136                 jecxz .empty
 137                 cmp ecx,bytes_per_getc
 138                 jna .sizeok
 139                 mov ecx,bytes_per_getc
 140 .sizeok:
 141                 mov [di+gc_bufbytes],cx
 142                 sub [di+gc_bytes],ecx
 143                 add cx,SECTOR_SIZE-1
 144                 shr cx,SECTOR_SHIFT
 145                 call getfssec
 146                 mov [di+gc_file],si
 147                 popad
 148                 jmp .got_data
 149
 150 .empty:
 151                 ; CX == 0 at this point; gc_bufbytes was clobbered
 152                 ; by the subtract; we need to restore it to zero so
 153                 ; we will continue to get EOF on any further attempts
 154                 ; to read the file.
 155                 mov [di+gc_bufbytes],cx
 156                 popad
 157                 stc
 158                 jmp .ret
 159
 160 close:
 161                 push bx
 162                 push si
 163                 mov bx,[CurrentGetC]
 164                 mov si,[bx+gc_file]
 165                 call close_file
 166                 add bx,getc_file_size
 167                 mov [CurrentGetC],bx
 168                 pop si
 169                 pop bx
 170                 ret
 171
 172 ;
 173 ; ungetc:       Push a character (in AL) back into the getc buffer
 174 ;               Note: if more than MAX_UNGET bytes are pushed back, all
 175 ;               hell will break loose.
 176 ;
 177 ungetc:
 178                 push di
 179                 push bx
 180                 mov di,[CurrentGetC]
 181                 movzx bx,[di+gc_unget_cnt]
 182                 mov [bx+di+gc_unget_buf],al
 183                 inc bx
 184                 mov [di+gc_unget_cnt],bl
 185                 pop bx
 186                 pop di
 187                 ret
 188
 189 ;
 190 ; skipspace:    Skip leading whitespace using "getc".  If we hit end-of-line
 191 ;               or end-of-file, return with carry set; ZF = true of EOF
 192 ;               ZF = false for EOLN; otherwise CF = ZF = 0.
 193 ;
 194 ;               Otherwise AL = first character after whitespace
 195 ;
 196 skipspace:
 197 .loop:          call getc
 198                 jc .eof
 199                 cmp al,1Ah                      ; DOS EOF
 200                 je .eof
 201                 cmp al,0Ah
 202                 je .eoln
 203                 cmp al,' '
 204                 jbe .loop
 205                 ret                             ; CF = ZF = 0
 206 .eof:           cmp al,al                       ; Set ZF
 207                 stc                             ; Set CF
 208                 ret
 209 .eoln:          add al,0FFh                     ; Set CF, clear ZF
 210                 ret
 211
 212 ;
 213 ; getint:       Load an integer from the getc file.
 214 ;               Return CF if error; otherwise return integer in EBX
 215 ;
 216 getint:
 217                 mov di,NumBuf
 218 .getnum:        cmp di,NumBufEnd        ; Last byte in NumBuf
 219                 jae .loaded
 220                 push di
 221                 call getc
 222                 pop di
 223                 jc .loaded
 224                 stosb
 225                 cmp al,'-'
 226                 jnb .getnum
 227                 call ungetc             ; Unget non-numeric
 228 .loaded:        mov byte [di],0
 229                 mov si,NumBuf
 230                 ; Fall through to parseint
 231
 232 ;
 233 ; parseint:     Convert an integer to a number in EBX
 234 ;               Get characters from string in DS:SI
 235 ;               Return CF on error
 236 ;               DS:SI points to first character after number
 237 ;
 238 ;               Syntaxes accepted: [-]dec, [-]0+oct, [-]0x+hex, val+[KMG]
 239 ;
 240 parseint:
 241                 push eax
 242                 push ecx
 243                 push bp
 244                 xor eax,eax             ; Current digit (keep eax == al)
 245                 mov ebx,eax             ; Accumulator
 246                 mov ecx,ebx             ; Base
 247                 xor bp,bp               ; Used for negative flag
 248 .begin:         lodsb
 249                 cmp al,'-'
 250                 jne .not_minus
 251                 xor bp,1                ; Set unary minus flag
 252                 jmp short .begin
 253 .not_minus:
 254                 cmp al,'0'
 255                 jb .err
 256                 je .octhex
 257                 cmp al,'9'
 258                 ja .err
 259                 mov cl,10               ; Base = decimal
 260                 jmp short .foundbase
 261 .octhex:
 262                 lodsb
 263                 cmp al,'0'
 264                 jb .km          ; Value is zero
 265                 or al,20h               ; Downcase
 266                 cmp al,'x'
 267                 je .ishex
 268                 cmp al,'7'
 269                 ja .err
 270                 mov cl,8                ; Base = octal
 271                 jmp short .foundbase
 272 .ishex:
 273                 mov al,'0'              ; No numeric value accrued yet
 274                 mov cl,16               ; Base = hex
 275 .foundbase:
 276                 call unhexchar
 277                 jc .km                ; Not a (hex) digit
 278                 cmp al,cl
 279                 jae .km                 ; Invalid for base
 280                 imul ebx,ecx            ; Multiply accumulated by base
 281                 add ebx,eax             ; Add current digit
 282                 lodsb
 283                 jmp short .foundbase
 284 .km:
 285                 dec si                  ; Back up to last non-numeric
 286                 lodsb
 287                 or al,20h
 288                 cmp al,'k'
 289                 je .isk
 290                 cmp al,'m'
 291                 je .ism
 292                 cmp al,'g'
 293                 je .isg
 294                 dec si                  ; Back up
 295 .fini:          and bp,bp
 296                 jz .ret         ; CF=0!
 297                 neg ebx                 ; Value was negative
 298 .done:          clc
 299 .ret:           pop bp
 300                 pop ecx
 301                 pop eax
 302                 ret
 303 .err:           stc
 304                 jmp short .ret
 305 .isg:           shl ebx,10              ; * 2^30
 306 .ism:           shl ebx,10              ; * 2^20
 307 .isk:           shl ebx,10              ; * 2^10
 308                 jmp .fini
 309
 310                 section .bss
 311                 alignb 4
 312 NumBuf          resb 15                 ; Buffer to load number
 313 NumBufEnd       resb 1                  ; Last byte in NumBuf
 314
 315 GetCStack       resb getc_file_size*MAX_GETC
 316 .end            equ $
 317
 318                 section .data
 319 CurrentGetC     dw GetCStack.end        ; GetCStack empty
 320
 321 ;
 322 ; unhexchar:    Convert a hexadecimal digit in AL to the equivalent number;
 323 ;               return CF=1 if not a hex digit
 324 ;
 325                 section .text
 326 unhexchar:
 327                 cmp al,'0'
 328                 jb .ret                 ; If failure, CF == 1 already
 329                 cmp al,'9'
 330                 ja .notdigit
 331                 sub al,'0'              ; CF <- 0
 332                 ret
 333 .notdigit:      or al,20h               ; upper case -> lower case
 334                 cmp al,'a'
 335                 jb .ret                 ; If failure, CF == 1 already
 336                 cmp al,'f'
 337                 ja .err
 338                 sub al,'a'-10           ; CF <- 0
 339                 ret
 340 .err:           stc
 341 .ret:           ret
 342
 343 ;
 344 ;
 345 ; getline:      Get a command line, converting control characters to spaces
 346 ;               and collapsing streches to one; a space is appended to the
 347 ;               end of the string, unless the line is empty.
 348 ;               The line is terminated by ^J, ^Z or EOF and is written
 349 ;               to ES:DI.  On return, DI points to first char after string.
 350 ;               CF is set if we hit EOF.
 351 ;
 352 getline:
 353                 call skipspace
 354                 mov dl,1                ; Empty line -> empty string.
 355                 jz .eof               ; eof
 356                 jc .eoln              ; eoln
 357                 call ungetc
 358 .fillloop:      push dx
 359                 push di
 360                 call getc
 361                 pop di
 362                 pop dx
 363                 jc .ret         ; CF set!
 364                 cmp al,' '
 365                 jna .ctrl
 366                 xor dx,dx
 367 .store:         stosb
 368                 jmp short .fillloop
 369 .ctrl:          cmp al,10
 370                 je .ret         ; CF clear!
 371                 cmp al,26
 372                 je .eof
 373                 and dl,dl
 374                 jnz .fillloop           ; Ignore multiple spaces
 375                 mov al,' '              ; Ctrl -> space
 376                 inc dx
 377                 jmp short .store
 378 .eoln:          clc                     ; End of line is not end of file
 379                 jmp short .ret
 380 .eof:           stc
 381 .ret:           pushf                   ; We want the last char to be space!
 382                 and dl,dl
 383                 jnz .xret
 384                 mov al,' '
 385                 stosb
 386 .xret:          popf
 387                 ret