; ; CMDEDIT.ASM ;(c) 1989, 1990 PC Magazine and Ashok P. Nadkarni ; SIGNATURE1 equ <"CMDEDIT 2.0 (c) 1990 Ziff Communications Co."> SIGNATURE2 equ <"PC Magazine"> SIGNATURE3 equ <"Ashok P. Nadkarni"> ; Main module for command line editor. INCLUDE common.inc INCLUDE general.inc INCLUDE ascii.inc INCLUDE buffers.inc INCLUDE dos.inc INCLUDE bios.inc PUBLIC dos_version_major PUBLIC dos_version_minor PUBLIC resident PUBLIC macro_level PUBLIC cur_macro PUBLIC cur_macro_len PUBLIC linebuf PUBLIC linelimit PUBLIC dot PUBLIC lastchar PUBLIC LINEBUF_END PUBLIC edit_mode PUBLIC default_imode PUBLIC caller_cursor PUBLIC omode_cursor PUBLIC pgm_name PUBLIC macrosize PUBLIC symsize PUBLIC dossize PUBLIC dirsize PUBLIC mfilename PUBLIC mfile_seen PUBLIC macro_ignore_char PUBLIC cmdlen PUBLIC silent PUBLIC endm_cmd PUBLIC defs PUBLIC defm PUBLIC tsr_install_end PUBLIC source PUBLIC abort_processing PUBLIC disp_line PUBLIC set_disp_marks PUBLIC insert_at_dot PUBLIC insert_chars PUBLIC remove_chars PUBLIC erase_to_dot PUBLIC init_over PUBLIC line_to_scr PUBLIC get_next_line PUBLIC reset_line PUBLIC in_appl PUBLIC user_command PUBLIC our_break_handler PUBLIC prev_isr1b PUBLIC old_int21vec PUBLIC cmdedit_isr PUBLIC makeroom PUBLIC locate_dosenv PUBLIC cmdedit IFE TSR PUBLIC cmdedit_cmd PUBLIC debug_loop PUBLIC freadline PUBLIC get_file_line PUBLIC read_cmdfile PUBLIC disp_prompt PUBLIC prompt PUBLIC init_screen ENDIF DGROUP GROUP CSEG CSEG SEGMENT PARA PUBLIC 'CODE' EXTRN install_begin:BYTE EXTRN install:PROC EXTRN execute_defs:PROC EXTRN execute_defm:PROC EXTRN execute_dels:PROC EXTRN execute_delm:PROC EXTRN execute_cmdstat:PROC EXTRN execute_pushd:PROC EXTRN execute_popd:PROC EXTRN execute_chd:PROC EXTRN hist_init:PROC EXTRN hist_type:PROC EXTRN hist_top:PROC EXTRN dirs_init:PROC EXTRN macro_init:PROC EXTRN symbol_init:PROC EXTRN expand_macro:PROC EXTRN expand_symbol:PROC EXTRN get_macro_line:PROC EXTRN skip_whitespace:PROC EXTRN skip_nonwhite:PROC EXTRN stre_cmp:PROC EXTRN get_kbd_line:PROC EXTRN getargs:PROC EXTRN file_error:BYTE EXTRN abort_install:PROC EXTRN expand_var:PROC EXTRN execute_rsthist:PROC EXTRN execute_rstmac:PROC EXTRN execute_rstsym:PROC EXTRN execute_rstdir:PROC ; Define important fields in the PSP. ASSUME CS:DGROUP ORG 2Ch env dw ? ;Segment of environment block ORG 80h PROMPT_BUF_SIZE EQU 80 prompt LABEL BYTE ;buffer used for prompt after TSRing cmdlen DB ? ;Offset 80h in the PSP contains length of command ; line when program is invoked ORG 80h+PROMPT_BUF_SIZE prompt_length dw ? cur_macro LABEL BYTE ;Start of area used after TSRing to ; store the current macro expansion. ASSUME CS:DGROUP,DS:DGROUP,ES:DGROUP,SS:DGROUP ORG 100h entry: jmp install ; The following variables are LOST after TSRing since the space is ; reused for other purposes. mfilename db 64 DUP (0) ;Storage for ASCIIZ filename mfile_seen db 0 ;Indicate if command line ; specified an init file mfile_handle dw ? ;Handle for open file ; Entry init_over is jumped to from the installation code after all the ; command line parsing has been done. This part of the installation ; remains resident. It is not kept with the install code because that ; code sections gets overwritten with various buffers. init_over proc near ; The command parameters have been parsed. Now get ready to terminate. mov si,offset DGROUP:install_begin ;First location in installation code mov bx,si ; is where the buffers start. mov ax,dossize ;Size of DOS history buffer add si,ax ;SI <- end of DOS buffer xor cx,cx ;Indicate DOS mode call near ptr hist_init ;Initialize DOS history buffer mov bx,si ;Repeat for directory stack mov ax,dirsize add si,ax call near ptr dirs_init mov bx,si ;And finally for the macros mov ax,macrosize add si,ax call near ptr macro_init mov bx,si ;And finally for the macros mov ax,symsize add si,ax call near ptr symbol_init ; SI->end of buffer area ; Read in the command file call near ptr init_screen ;Need to do this because ; reset_line (called by ; execute_defm) restores cursor shape. call near ptr read_cmdfile ; Initialize var source to get the next line from the keyboard. mov source,offset DGROUP:get_kbd_line ; All data structures initalized. Now setup stack pointer, release ; unneeded memory back to DOS, set up interrupt handler and TSR. push es ;save ES mov es,env ;Don't need environment block ASSUME ES:NOTHING mov ah,49h int 21h ;Release the block IF TSR mov ax,3521h ;Get old interrupt vector int 21h mov old_int21vec,bx ;Remember offset mov old_int21vec+2,es ;Remember segment mov dx,offset DGROUP:cmdedit_isr ;Our handler ;DS = CS already mov ax,2521h ;Set intr vector int 21h ENDIF pop es ;Restore ES ASSUME ES:DGROUP lea dx,STACK_SIZE+15[si] ;Calculate end of TSR portion ; DX<-num bytes to keep resident and dl,0f0h ; rounded to para ; Note DX->BEYOND last byte of program mov new_sp,dx ;Remember it mov resident,1 ;Indicate we're TSR IFE TSR ; Don't actually TSR debug_loop: @init_over_10: @DispCh CR @DispCh LF lea dx,dummy_prompt @DispStr dx mov dx,offset DGROUP:debug_buf ;Offset mov debug_buf,DEBUG_BUFSIZE-2 mov ah,0Ah ;Function code pushf ;Simulate interrupt push cs ;Simulate interrupt call near ptr cmdedit_isr ;Simulate interrupt jmp short @init_over_10 ;Keep looping debug_buf db 256 DUP (?) DEBUG_BUFSIZE equ $-debug_buf dummy_prompt db "dummy>",DOLLAR ENDIF int 27h ;TSR init_over endp ;+ ; FUNCTION : read_cmdfile ; ; Reads commands from a file. The filename is in the variable ; mfilename. The space occupied this function is overwritten ; after TSRing so it must NOT be called once the program is resident. ; ; Parameters: ; None. ; ; Returns: ; AX = 0 on success, any other value if failure ; ; Register(s) destroyed: ; AX,BX,CX,DX ;- read_cmdfile proc near @save si,di cmp mfile_seen,0 je @read_cmdfile_100 ;No file specified @OpenFil mfilename,0 jc @read_cmdfile_92 ;CF=1 for errors @read_cmdfile_30: mov source,offset DGROUP:get_file_line ; We want get_next_line to read ; from the file. mov mfile_handle,ax ;Save file handle @read_cmdfile_50: mov dx,offset DGROUP:linebuf ;Destination for file line mov ax,LINEBUF_SIZE call near ptr freadline ;Get next line into buffer ;AX contains line length jnc @read_cmdfile_80 ;no error or EOF or ax,ax ;No more bytes ? jz @read_cmdfile_99 ;EOF is not error jmp short @read_cmdfile_90 ;Error, abort install @read_cmdfile_80: mov dx,offset DGROUP:linebuf add dx,ax mov lastchar,dx ;Update end of line call near ptr cmdedit_cmd ;Execute as a command jnc @read_cmdfile_50 ;If not a command, better be a ; blank line call near ptr blankline jnc @read_cmdfile_50 ;Ignore blank lines ; If not blank line and not CMDEDIT command, then error error handler @read_cmdfile_90: ; Come here for error @ClosFil mfile_handle ;Close the file @read_cmdfile_92: @DispStr file_error mov ax,-1 ;Indicate exit code jmp abort_install ;Exit program @read_cmdfile_99: @ClosFil mfile_handle ;Close the file jc @read_cmdfile_92 ;Abort if error closnig file @read_cmdfile_100: @restore ret read_cmdfile endp ;+ ; FUNCTION : get_file_line ; ; Called indirectly through the global variable 'source'. ; Currently this routine exists only during installation and must ; NOT be called once the program is a TSR. The next line from the ; file is copied to linebuf. If there is no next line, the ; installation is aborted. ; ; Parameters: ; None. ; ; Returns: ; Nothing. ; Register(s) destroyed: ; AX,BX,CX,DX ;- get_file_line proc near mov dx,offset DGROUP:linebuf mov ax,LINEBUF_SIZE call near ptr freadline jnc @get_file_line_99 ;Error reading file or EOF @DispStr file_error jmp abort_install @get_file_line_99: mov dx,offset DGROUP:linebuf add dx,ax mov lastchar,dx ;Update end of line ret get_file_line endp ;+ ; FUNCTION : freadline ; ; Reads a line at a time from the file whose handle is in ; mfile_handle into the buffer pointed to by AX. If the buffer is ; too small or if there are any errors, the routine returns with CF set. ; If EOF, then AX = 0 and CF is set. ; ; Parameters: ; DX = address of buffer ; AX = size of buffer ; ; Returns: ; CF = 0 if no errors (and not EOF), else 1. ; AX = num chars in line if CF = 0. ; 0 if EOF, ffff for other errors if CF = 1 ; ; Register(s) destroyed: ;- freadline proc near @save si,di mov di,dx ;DI->buffer mov bx,mfile_handle mov si,ax ;SI<-num bytes to read xchg cx,ax ;CX<-num bytes to read mov ah,3Fh ;File read function int 21h jc @freadline_99 ;Error! mov cx,ax ;CX<-num bytes read jcxz @freadline_99_a ;EOF (note AX is 0 indicating EOF) xchg dx,ax ;DX<-num bytes read mov bx,di ;BX->start of buffer mov al,CR repne scasb ;Hunt for CR je @freadline_50 ;Found ; No CR found, this better be the last line in file. cmp dx,si ;Were fewer bytes read than requested? cmc jc @freadline_99 ;Error push dx ;Save length of line xor ax,ax ;AX<-num extra bytes read jmp short @freadline_60 @freadline_50: stc ;Assume line too long jcxz @freadline_99 ;error if match in last char ; (line too long) cmp BYTE PTR [di],LF ;Next char must be linefeed stc ;Assume error jne @freadline_99 ;Indeed an error if not LF mov ax,di sub ax,bx ;AX<-num chars including CR sub dx,ax xchg ax,dx dec dx ;DX<-num chars in line dec ax ;AX<-num extra chars read push dx ;Save num chars in line @freadline_60: ; Top of stack contains num bytes in line. ; Now position file pointer to 'unread' characters. ; AX contains the num of extra characters read. neg ax cwd mov cx,ax xchg cx,dx ;CX:DX<-num bytes to 'unread' mov bx,mfile_handle mov ax,4201h ;Move file ptr relative int 21h ;Seek file relative ; CF set/reset by error status pop ax ;AX<-num bytes in line clc ;No errors jmp short @freadline_100 @freadline_99: mov ax,0ffffh ;Non-EOF error @freadline_99_a: stc ;Indicate error or EOF @freadline_100: @restore ret freadline endp ;+ ; FUNCTION : blankline ; ; Checks whether the line in linebuf is blank or not. Also treats it ; as blank line if it begins with a `-'. ; ; Parameters: ; None. ; ; Returns: ; CF = 0 if blank line, else 1. ; Register(s) destroyed: ; AX,BX,CX,DX ;- blankline proc near @save si mov si,offset DGROUP:linebuf cmp byte ptr [si],'-' ;Comment char ? jne @blankline_20 clc jmp short @blankline_99 @blankline_20: mov cx,lastchar sub cx,si ;CX<-num chars in line call near ptr skip_whitespace ;CF=1 if end of string cmc @blankline_99: @restore ret blankline endp ; Extend the resident part of the installation code to form a buffer to ; hold the prompt and one to hold the current macro line arguments. ; - 128 bytes from PSP + initial portion of CSEG. tsr_install_end LABEL BYTE IF ($-entry) LT (2+PROMPT_BUF_SIZE+LINEBUF_SIZE - 128) DB (2+PROMPT_BUF_SIZE+LINEBUF_SIZE - 128 - ($-entry)) DUP (?) ENDIF pgm_name db SIGNATURE1,CR,LF copyrite db SIGNATURE2,32,254,32,SIGNATURE3,CR,LF,LF,DOLLAR,26 ; Major and minor DOS versions. dos_version_major db ? dos_version_minor db ? ;dos_envseg dw 0 ;Segment for DOS ; environment. 0 indicates ; we don't know it. resident db 0 ;1 after becoming resident abort_entry_stack dw ? ;Storage for stack state to be ; restored when processing is aborted abort_msg_hd db '*** CMDEDIT : ' ;Header for abort message ABORT_HDR_LEN equ $-abort_msg_hd abort_msg_tl db ' Any ongoing macro aborted! ***' ;Tail for abort message ABORT_TAIL_LEN equ $-abort_msg_tl ; The following are error messages displayed by routine abort_processing. ; ALL MESSAGES MUST BE SHORT ENOUGH TO FIT INTO LINEBUF TOGETHER WITH ; abort_msg_hd and abort_msg_tl. The order of messages must be same as ; the order of Error code definitions in file common.inc abort_msg_table LABEL BYTE line_trunc_msg db 'Line too long.' saw_sig_msg db 'Command aborted by user.' dirstk_empty_msg db 'Directory stack empty.' dirstk_msg db 'Invalid dir or stack full.' dirstk_only_dos db 'Command is DOS only.' nested_macro_msg db 'Nested macro definition.' nested_delm_msg db 'DELM used inside macro.' ctrl_brk_msg db 'Control-Break.' abort_msg_end LABEL BYTE ; The following table holds pointers to each entry in the message table ; above. The length of each message is also stored here. abort_msg_ptrs LABEL WORD dw line_trunc_msg dw saw_sig_msg-line_trunc_msg dw saw_sig_msg dw dirstk_empty_msg-saw_sig_msg dw dirstk_empty_msg dw dirstk_msg-dirstk_empty_msg dw dirstk_msg dw dirstk_only_dos-dirstk_msg dw dirstk_only_dos dw nested_macro_msg-dirstk_only_dos dw nested_macro_msg dw nested_delm_msg-nested_macro_msg dw nested_delm_msg dw ctrl_brk_msg-nested_delm_msg dw ctrl_brk_msg dw abort_msg_end-ctrl_brk_msg macrosize dw 512 ;Default size of macro buffer symsize dw 512 ;Default size of symbol buffer dossize dw 512 ;Default size of DOS history buffer dirsize dw 128 ;Default size of directory stack buffer ;+-------------------------+ ;| CMDEDIT state variables | ;+-------------------------+ ; The variables source and macro_level together indicate the source of ; the next line. If macro_level is non-zero, the next line is obtained ; from an ongoing macro expansion. If macro_level is 0, then the ; variable source contains the address of the function to call to ; return the next line. This will be either get_kbd_line or ; get_file_line. macro_level dw 0 source dw ? ;filled in during initialization ;+----------------------------------------------------------+ ;| CMDEDIT commands. All commands preceded by a length byte.| ;| For each command that is added, make sure you update the | ;| table cmd_func_table below. | ;+----------------------------------------------------------+ cmd_table LABEL BYTE defs db 4,'defs' ;Define a single line macro defm db 4,'defm' ;Start multiline macro definition pushd db 5,'pushd' ;Push on directory stack popd db 4,'popd' ;Pop from directory stack chd db 3,'chd' ;Change disk and directory dels db 4,'dels' ;Delete a symbol delm db 4,'delm' ;Delete a macro rsthist db 7,'rsthist' ;Reset history stack rstmac db 6,'rstmac' ;Reset macro buffer rstsym db 6,'rstsym' ;Reset symbol buffer rstdir db 6,'rstdir' ;Reset directory stack cmdstat db 7,'cmdstat' ;Show macro and symbol status cmd_table_end db 0 ;Terminate with a 0 MAX_CMD_LEN equ 7 ;Length of longest command ; Note endm is not a command except during a macro definition. endm_cmd db 4,'endm' ;End multiline macro definition ;+--------------------------------------------------------------+ ;| CMDEDIT command functions. Must be in same order as commands.| ;+--------------------------------------------------------------+ cmd_func_table label WORD dw execute_defs dw execute_defm dw execute_pushd dw execute_popd dw execute_chd dw execute_dels dw execute_delm dw execute_rsthist dw execute_rstmac dw execute_rstsym dw execute_rstdir dw execute_cmdstat linebuf_prefix db 0 ;Fill byte/Sentinel before linebuf. ; Used in code to allow uniform ; checking of first linebuf character. linebuf db LINEBUF_SIZE DUP (?) ;Temporary line buffer. LINEBUF_END equ $ linebuf_suffix db ? ;Need a byte at end of ; linebuf in various places macro_ignore_char db ';' ;Character used to prevent macro ; and symbol expansion. lastchar dw ? ;Points beyond last char in the line cur_macro_len dw ? ;Length of data in cur_macro dot dw ? ;Current position in line disp_begin dw ? ;disp_begin and disp_end are disp_end dw ? ; markers into the line buffer ; that are used to keep track ; of the range that has been ; changed. This is used to ; selectively update the display. edit_mode db ? ;1 if insert mode, else 0 default_imode db 0 ;By default overtype mode linelimit dw ? ;Upper limit for linebuf based ; on user's buffer length noted_dos_seg db 0 ;1 after we have noted DOS segment dos_seg dw ? ;Stores DOS segment in_appl db 0 ;0 if dos, 1 if application user_command db 0 ;This is set to 1 by certain ; CMDEDIT commands to return a ; string to the caller. ; (Basically put in as a kluge ; to get the prompt right after ; a pushd/popd/chd) ;+------------+ ;| Video data | ;+------------+ video_page db ? ;Current video page screen_width db ? ;width of screen initial_curcol label byte ;initial cursor column initial_curpos dw ? ;Initial cursor position ;Next two words must be contiguos omode_cursor dw ? ;Cursor for overtype mode imode_cursor dw ? ;Cursor for insert mode caller_cursor dw ? ;Cursor shape of caller silent db 0 ;non-0 if bell should not be rung ;+-------------------------------------------------------------------------+ ;|Storage areas for various registers when called through INT 21 interface.| ;+-------------------------------------------------------------------------+ ssreg dw ? spreg dw ? old_int21h LABEL DWORD ;Storage for previous int 21h vector old_int21vec DW 2 DUP (?) new_sp dw ? ;Store our stack ptr (bottom of stack). ;This is first para BEYOND cmdedit's memory. prev_isr1b dd ? ;Previous control break handler ; check_break is set to 1 on entry to cmdedit, and restored to 0 on exit. If ; 1 on entry, then calling program must have been aborted with a break or ; critical error. The CMDEDIT Ctrl-Break ISR increments this flag every ; time it is called. If it is > 1, inside CMDEDIT, it indicates that a ; ctrl-break was entered. This allows runaway macros and symbols to be ; aborted. check_break dw 0 trap_break db 0 ;If 1, does not allow original ; Ctrl-Break handler to see the ; Ctrl_break ;+ ; FUNCTION : cmdedit_isr ; ; This is our replacement for the DOS INT 21h handler. ; ; Parameters: ; AH = function code ; ; Register(s) destroyed: ;- cmdedit_isr proc far ASSUME CS:DGROUP,DS:NOTHING,ES:NOTHING,SS:NOTHING pushf ;Save flags cmp ah,0Ah ;Is it the buffered input function ? je @cmdedit_isr_10 ;If so go on carry out our duty popf ;else restore flags jmp cs:old_int21h ;and execute the original ISR @cmdedit_isr_10: ;Save registers mov cs:ssreg,ss ;Stack segment mov cs:spreg,sp ; and pointer cli ;Wanna change stack push cs pop ss mov sp,cs:new_sp ;Bottom of stack ASSUME SS:DGROUP sti ;OK to interrupt now @save ax,bx,cx,dx,si,di,bp,ds,es xchg bx,dx mov al,byte ptr ds:[bx] ;Length of caller buffer xchg dx,bx xor ah,ah ;AX<-length of caller's buffer push ds ;Save user segment mov cx,cs mov ds,cx ;Init DS, ES to point to DGROUP mov es,cx ASSUME DS:DGROUP,ES:DGROUP add ax,offset dgroup:linebuf ;AX->last allowable linebuf ; location + 1 dec ax ;Need room for CR at end of line mov linelimit,ax ;Store it pop ax ;AX <- User's buffer segment ;DX already contains offset of ; user buffer call near ptr cmdedit ;Main routine @restore cli mov ss,cs:ssreg mov sp,cs:spreg sti popf iret cmdedit_isr endp ;+ ; FUNCTION : cmdedit ; ; Main routine called by the INT 21h ISR to get next line. ; General Algorithm: ; (1) Get the next line from the keyboard/macro expansion/file. ; (2) Check for line begins with a macro. If so, expand it and ; repeat step (2). Else go onto step (3). ; (3) Check if the line is an internal CMDEDIT command. If so, execute ; it and return to step (1). ; (4) Copy line to caller's buffer and return. ; ; Parameters: ; AX = segment of user's buffer ; DX = offset of user's buffer ; ; Returns: ; The next input line is copied into the user's buffer. ; Register(s) destroyed: ; All except segment registers. ;- cmdedit proc near push es ;Save ES push ax ;Caller's buffer segment push dx ;Caller's buffer offset mov trap_break,1 ;Trap Ctrl-Break handler mov cx,1 xchg cx,CS:check_break ;Check if last call did not ; exit normally. Also set flag ; for this call. jcxz @cmdedit_0 ;Last exit was OK mov macro_level,0 ;No it was not, so reset input mov source,offset DGROUP:get_kbd_line @cmdedit_0: call near ptr init_screen ;Get screen/cursor data cmp noted_dos_seg,0 ;Have we noted the DOS segment ? jne @cmdedit_1 ;Jump if we know it already mov noted_dos_seg,1 ;Remember that we now know it mov dos_seg,ax ;Else remember it ;No point jumping over next ;couple of statements. @cmdedit_1: mov cx,1 ;Assume caller is not DOS cmp ax,dos_seg ;Is the caller DOS ? jne @cmdedit_2 dec cx ;Yes, CX<-0 @cmdedit_2: mov in_appl,cl ;Rememeber whether caller is dos call near ptr hist_type ;Set the history type (DOS/appl) ; cmdedit_abort_entry is the entry point when command proessing is ; aborted for any reason. It is jumped to from abort_processing mov abort_entry_stack,sp ;Remember stack state cmdedit_abort_entry LABEL PROC @cmdedit_3: call near ptr reset_line ;Reset cursor, line etc. call near ptr get_next_line ;Get the next line from appropriate ; source (stored in linebuf) @cmdedit_10: cmp check_break,2 ;Check for any control breaks jb @cmdedit_11 ;No ctrl-breaks mov check_break,1 mov ax,E_CTRL_BREAK ;Message number jmp abort_processing @cmdedit_11: ;If the first character is a ignore character, do not do a macro or symbol ;expansion. mov cx,lastchar ;End of line mov si,offset DGROUP:linebuf ;SI->line buffer sub cx,si ;CX<-length of line jcxz @cmdedit_15 ;Empty line, keep going since it ; can still be a macro or symbol mov al,[si] ;AL<-first char of line cmp al,macro_ignore_char jne @cmdedit_15 ; First is an ignore character so move up all characters and return mov di,si ;DI->start of line inc si ;SI->first char to copy dec cx ;1 less character dec lastchar ; Assume ES==DS, direction flag clear rep movsb ;Move the bytes jmp @cmdedit_25 ;Yes, exit with carry flag set @cmdedit_15: call near ptr expand_symbol ;Check if symbol and expand jnc @cmdedit_10 ;If expanded, recurse call near ptr expand_macro ;Check if line is a macro ; and expand if possible. jnc @cmdedit_10 ;If expanded, do recursively. ; (note that currently recursion ; will take place only on the ; last line of a macro definition) @cmdedit_25: mov user_command,0 ;Init flag call near ptr cmdedit_cmd ;Check if CMDEDIT command jc @cmdedit_30 ;No ; CMDEDIT command, but might want to return to caller anyway. cmp user_command,1 ;If 1, then return string to caller je @cmdedit_30 ; klugery here for PUSHD/POPD/CHD ; to intentionally return a ; blank line to DOS in order to ; get prompt right. jmp short @cmdedit_3 @cmdedit_30: ; Expand variables if any. call near ptr replace_vars ; Check if line too long for user buffer. mov ax,lastchar ;AX->last character in buffer cmp ax,linelimit jbe @cmdedit_80 ;We're OK mov ax,E_TRUNCATE ;error - line too long jmp near ptr abort_processing @cmdedit_80: sub ax,offset DGROUP:linebuf ;AX<-length of line ; OK now we have a line to give to the caller. Copy it into caller's ; buffer and return. pop di ;Caller's buffer offset pop es ;Caller's buffer segment inc di ;ES:DI->second byte of user buffer stosb ;Store line length mov si,offset DGROUP:linebuf ;SI->Source string xchg cx,ax ;CX<-length of string rep movsb ;Copy bytes mov al,CR stosb ;Store terminating carraige-return ; Set cursor shape to caller's shape call near ptr restore_cursor ;Restore user's cursor shape mov check_break,0 ;Reset flag mov trap_break,0 ; Ctrl-Break handler pop es ;Restore ES ret cmdedit endp ;+ ; FUNCTION : get_next_line ; ; Gets the next line from the appropriate source and stores it in ; the line buffer. THe source of the line may be either a macro ; expansion or a file or the keyboard. ; ; Parameters: ; None. ; ; Returns: ; Nothing ; Register(s) destroyed: ;- get_next_line proc near mov lastchar,offset DGROUP:linebuf ;Empty line (in case not ; already done) call near ptr get_macro_line ;Get next line in expansion jnc @get_next_line_99 ;Jump if there is a next line ;No next line in expansion, so ;get line from keyboard/file @get_next_line_10: call [source] ;get_kbd_line / get_file_line @get_next_line_99: ret get_next_line endp ;+ ; FUNCTION : replace_vars ; ; Replaces all the variables in the current line with their ; expansions. If the line is too long, aborts with a truncation ; error. ; ; Parameters: ; None. ; ; Returns: ; Nothing. ; Register(s) destroyed: ; AX,BX,CX,DX ;- replace_vars proc near call near ptr expand_var ;CF set if error. AX ; contains error code jnc @replace_vars_99 jmp near ptr abort_processing ;Abort processing @replace_vars_99: ret replace_vars endp ;+ ; FUNCTION : get_curpos ; ; Returns the current cursor position. ; ; Parameters: ; Global video_page indicates the page. ; ; Returns: ; DX = Current cursor position. ; CX = Current cursor scan lines. ; Register(s) destroyed: AX,BX ;- get_curpos proc near @GetCur video_page ret get_curpos endp ;+ ; FUNCTION : set_disp_marks ; ; Sets the marks disp_begin and disp_end to indicate the start ; and end positions in the line that have been changed. The ; routine is passed two parameters which indicate ; the potentially new values for disp_begin and disp_end ; respectively. However the global disp_begin is changed only if ; the new value is less than the current value. Similarly ; disp_end is changed only if the new value is greater than the ; current value. ; ; Parameters: ; AX = potential disp_end ; DX = potential disp_begin ; ; Returns: ; Nothing. ; May set globals disp_begin and disp_end. ; ; Register(s) destroyed: None. ;- set_disp_marks proc near cmp ax,disp_end ;New value greater ? jb @set_disp_marks_10 ;No mov disp_end,ax ;New disp_end @set_disp_marks_10: cmp dx,disp_begin ;New value smaller jnb @set_disp_marks_20 ;No mov disp_begin,dx ;New disp_begin @set_disp_marks_20: ret set_disp_marks endp ;+ ; FUNCTION : disp_line ; ; Displays the current contents of the line buffer. Since the ; entire line is not redisplayed everytime, all procedures that ; change the contents of the line buffer have to follow certain ; rules in order to make sure the display correctly shows the ; line. The variable disp_begin must be set to the earliest ; position in the line that has been changed and disp_end to beyond ; last position in the line that has been changed.; ; Parameters: ; None. ; ; Returns: ; Nothing ; Register(s) destroyed: ;- disp_line proc near @save si,di mov ax,disp_begin ;Lower limit of changed chars mov si,ax mov cx,disp_end ;CX->byte after last char that ; has changed sub cx,si ;CX<-num chars to be output jcxz @disp_line_90 ;Nothing to be updated push cx ;Save CX across calls call near ptr line_to_scr ;Move cursor to corresponding ; position on the screen. ; OK, now we are ready to begin updating the screen. call near ptr get_curpos ;DX<-current cursor position pop cx ;Restore CX mov di,lastchar ;DI->beyond last char cmp si,di ;Beyond last char? je @disp_line_25 ;Go display blanks @disp_line_10: ;Loop to output chars lodsb ;AL<-next char @DispCh al ;Display it push cx ;Save CX push dx ;Save old cursor position call near ptr get_curpos ;DX<-new cursor position ; BX destroyed pop bx ;BX<-old cursor position pop cx ;Restore CX or dl,dl ;Column 0 ? jne @disp_line_20 ;Nope ;Col 0 cmp bh,dh ;Is the row the same jne @disp_line_20 ;yes, screen scrolled dec initial_curpos+1 ;Decrement the row for initial ; cursor position @disp_line_20: mov bx,dx ;New cursor position cmp si,di ;Beyond last char? loopne @disp_line_10 ;Keep looping until count exhausted or ; beyond last char @disp_line_25: ; Now all changed positions have been displayed. If CX is not 0, ; then the remaining char positions have to be ; replaced with blanks. Note that since we are now overwriting ; previously displayed positions, no need to check for line ; wraparound or scroll. jcxz @disp_line_90 ;No more chars mov al,' ' ;Overwrite with blanks @disp_line_30: @DispCh al loop @disp_line_30 @disp_line_90: mov ax,dot mov disp_begin,ax ;Initialize for next call mov disp_end,ax call near ptr line_to_scr ;Set cursor at dot @restore ret disp_line endp ;+ ; FUNCTION : line_to_scr ; ; Places the cursor at the screen position corresponding to a ; specific position in the line buffer. The entire line buffer ; upto that position must have been displayed before. ; ; Parameters: ; AX = Pointer into the line buffer ; ; Returns: ; Nothing. ; Register(s) destroyed: AX, BX, DX ;- line_to_scr proc near sub ax,offset dgroup:linebuf ;ax<-num chars mov dx,initial_curpos ;Initial cursor position ; dh<-row, dl<-column xor bh,bh mov bl,dl ;BX<-original column add ax,bx ;Compensate for initial position. ; AX is now the 'virtual column' mov bl,screen_width ;BX<-width of screen @line_to_scr_10: ;Loop to skip over chars that ; do not need to be updated cmp ax,bx ;Num of chars fit on a line? jb @line_to_scr_20 ;Yes, exit loop sub ax,bx ;Go to next line inc dh ;Increment the row jmp short @line_to_scr_10 @line_to_scr_20: ; al now contains the column and dh the row where the cursor should ; be placed mov dl,al ;dx<-screen position @SetCurPos ,,video_page ;Set the cursor position ret line_to_scr endp ;+ ; FUNCTION : insert_chars ; ; Inserts a string of chars at the specified position in the ; linebuffer. If the length would exceed the size of the line buffer, ; chars are only store until the buffer is full and the carry flag is ; set. Dot is updated appropriately. ; ; Parameters : ; ; SI - ptr to source string ; DI - ptr to insert position. This must lie in the line buffer. ; AX - length of source string ; ; Returns: ; CF = 1 if could not be fitted into linebuf ; 0 otherwise ; ; Registers destroyed: ; AX,CX,DX insert_chars proc near @save si,di mov dx,di ;Save insert position in DX mov di,lastchar ;First empty position mov cx,offset DGROUP:linebuf_suffix sub cx,di ;Subtract current last position ; CX<-max chars that will fit cmp cx,ax ;Will all chars fit ? jb @insert_chars_5 ;Not all chars will fit xchg ax,cx ;All chars will fit @insert_chars_5: ; CX is number of chars to insert pushf ;Remember CF ; Make place for the characters to be inserted by moving current ; characters up by CX. mov ax,di sub ax,dx ;AX<-num chars to move push si ;Remember source address mov si,di ;SI->first char to be moved add di,cx ;DI -> new value of lastchar mov lastchar,di ;Store it xchg ax,cx ;AX<-num chars to insert ; CX<-num chars to move std ;Direction is downward cmpsb ;Decrement SI,DI rep movsb ;Make place cld pop si ;Restore string source ; Before inserting the chars, update the dot if it is affected. cmp dx,dot ;Is the dot at or after the insert ; position ? jb @insert_chars_50 ;No, jump add dot,ax ;Else update the dot @insert_chars_50: mov di,dx ;DI->insert position xchg cx,ax ;CX<-num chars to insert rep movsb ;Copy string into linebuffer mov ax,lastchar call near ptr set_disp_marks ;AX,DX are parameters popf ;Restore CF @restore ret insert_chars endp ;+ ; FUNCTION : insert_at_dot ; ; Inserts a string of characters into the line buffer in the ; position pointed to by dot. If the length specified in global ; caller_buflen will be exceeded,chars are only stored until the ; buffer is full and CF is set. ; ; Parameters: ; SI = ptr to source string ; AL = length of string ; ; Returns: ; CF = 1 if could not be fitted into linebuf ; 0 otherwise ; Register(s) destroyed: ; ;- insert_at_dot proc near @save si,di,dx xor ah,ah ;AX<-length of source string mov di,dot ;DI-> insert position call near ptr insert_chars ;Params SI,DI,AX, returns status in CF @restore ret insert_at_dot endp ;+ ; FUNCTION : remove_chars ; ; Removes a string of chars at the specified position in the ; linebuffer. The display markers and the lastchar global are updated ; accordingly. ; ; Parameters : ; ; SI - ptr to position in linebuf from which to delete ; AX - number of chars to delete. ; ; Returns: ; Nothing. ; ; Registers destroyed: ; AX,CX,DX remove_chars proc near @save si,di mov di,ax ;Save delete count ; First update the display markers mov ax,lastchar mov dx,si call near ptr set_disp_marks ;AX,DX params mov ax,lastchar sub ax,si ;Num chars after delete position cmp ax,di ;More than the specified number ? jb @remove_chars_10 ;No, so just delete that many bytes mov ax,di @remove_chars_10: ; AX is number of bytes to delete. See if the dot needs to be updated. mov di,si ;DI->delete position add si,ax ;SI->first char after delete string cmp di,dot jnb @remove_chars_40 ;dot before delete pos, so ; unaffected cmp si,dot ;Is dot beyond it delete range jb @remove_chars_30 ;Yes ; dot is in delete region. Update it to point to first delete position mov dot,di jmp short @remove_chars_40 @remove_chars_30: ; dot is beyond delete position. So subtract delete bytes from it. sub dot,ax @remove_chars_40: ; Now that the screen markers and dot have been updated, get down to the ; real business at hand. SI points to first char after delete string, DI is ; the delete position. AX is number of bytes to be deleted. mov cx,lastchar sub lastchar,ax ;Update lastchar sub cx,si ;CX<-num bytes to move rep movsb ;Move 'em ; All done @restore ret remove_chars endp ;+ ; FUNCTION : erase_to_dot ; ; Deletes all characters from the line buffer between the ; positions AX and dot. (Either AX or dot may be specify the ; beginning of range to be deleted). The markers disp_begin and ; disp_end are set to reflect the changed positions in the line. ; Global lastchar is also updated. ; Parameters: ; AX = One endpoint of the range to be deleted. ; Global dot is the other. ; Returns: ; Nothing. ; Register(s) destroyed: ;- erase_to_dot proc near @save si mov si,dot cmp ax,si ;Make sure AX is after dot jnb @erase_to_dot_10 ;Yes it is xchg si,ax ;Else exchange @erase_to_dot_10: ;AX is low end, SI high end sub ax,si ;AX is num bytes to delete call near ptr remove_chars ;Delete AX chars starting at [SI] @restore ret erase_to_dot endp ;+ ; FUNCTION : cmdedit_cmd ; ; Checks if the line buffer contains a CMDEDIT command and if so ; executes it. ; ; Parameters: ; None. ; ; Returns: ; CF = 0 if the line was a command ; 1 otherwise. ; Register(s) destroyed: ; AX,BX,CX,DX ;- cmdedit_cmd proc near @save si,di mov si,offset DGROUP:linebuf ;SI->linebuf mov di,lastchar ;DI->end of line in linebuf ; Skip leading whitespace mov cx,di sub cx,si ;CX<-num chars in linebuf call near ptr skip_whitespace ;SI->first non-whitespace char ; CX<-num remaining chars jcxz @cmdedit_cmd_99 ;No command on line mov di,si ;DI->first char of word ; Skip first word (name of this command) call near ptr skip_nonwhite ;SI->first whitespace after ; command name ; CX<-num remaining chars mov ax,si sub ax,di ;AX<-num chars in word cmp ax,MAX_CMD_LEN ;Word too long to be command? ja @cmdedit_cmd_98 ;Yes, exit ; Now search thru the command table to see if the first word in the line is a ; CMDEDIT command. Currently, DI->start of word, AX = num chars in word xor dx,dx ;DX<-Command number mov si,offset dgroup:cmd_table ;SI->Start of commands @cmdedit_cmd_10: xor ch,ch ;Clear high bits mov cl,[si] ;CX<-Length of command jcxz @cmdedit_cmd_98 ;End of table, exit inc si ;SI->command cmp cx,ax ;Lengths match jne @cmdedit_cmd_30 ;No, go try next command xchg bx,ax ;BX<-num chars in word call near ptr stre_cmp ;Compare strings xchg ax,bx ;AX<-num chars in word je @cmdedit_cmd_50 ;Command matched @cmdedit_cmd_30: xor ch,ch mov cl,-1[si] ;AX<-length of command add si,cx ;SI->length of next command inc dx ;Increment the command number jmp short @cmdedit_cmd_10 ;Try next command @cmdedit_cmd_50: ;Found command mov si,di ;SI->first char of command add si,ax ;SI->first char after command mov cx,lastchar sub cx,si ;CX<-num chars after command mov di,dx ;BX<-command number shl di,1 ;BX<-offset into table call cmd_func_table[di] ;Execute it ; Params: ; SI->first char after command ; CX = remaining length of line ; (after command) cmp source,offset DGROUP:get_kbd_line jne @cmdedit_cmd_60 call near ptr disp_prompt ;Display user prompt @cmdedit_cmd_60: clc ;CF = 0 jmp short @cmdedit_cmd_99 @cmdedit_cmd_98: ;No command found stc ;CF = 1 @cmdedit_cmd_99: @restore ret cmdedit_cmd endp ;+ ; FUNCTION : abort_processing ; ; Called by various routines in case of any errors that require ; aborting of any ongoing processing. An error message is ; displayed and CMDEDIT state is reset to accept input from the ; keyboard. The routine adjusts the stack pointer to a previously ; stored state. Execution then continues at a `abort entry' ; point. The routine does NOT return to the caller. ; ; Parameters: ; AX = Error message number. ; ; Returns: ; Does NOT return to caller. ; ; Register(s) destroyed: ; Potentially all but irrelevant since routine does not return to ; caller. ;- abort_processing proc near mov macro_level,0 ;Reset macro level mov source,offset DGROUP:get_kbd_line ;Set input to keyboard ; Display a message mov si,offset DGROUP:abort_msg_hd mov di,offset DGROUP:linebuf mov dot,di ;dot MUST be at ; beginning of line ; since this position is ; stored in the main routine mov cx,ABORT_HDR_LEN rep movsb ;Copy message header sal ax,1 sal ax,1 ;AX is now index into msg table xchg ax,bx mov si,abort_msg_ptrs[bx] ;SI->message mov cx,abort_msg_ptrs[bx+2] ;CX<-length of message rep movsb ;Copy msg into linebuf mov si,offset DGROUP:abort_msg_tl mov cx,ABORT_TAIL_LEN rep movsb ;Copy tail of message mov lastchar,di mov ax,di ;Set display marks mov dx,offset DGROUP:linebuf call near ptr set_disp_marks call disp_line ;Display message call near ptr restore_cursor ;Restore cursor to user shape @DispCh CR @DispCh LF call near ptr disp_prompt mov sp,abort_entry_stack jmp near ptr cmdedit_abort_entry abort_processing endp ;+ ; FUNCTION : restore_cursor ; ; Restores the cursor to the user's shape. ; ; Parameters: ; Global caller_cursor contains original shape ; ; Returns: ; ; Register(s) destroyed: ; None. ;- restore_cursor proc near @save ax,cx mov cx,caller_cursor IF TOGGLE_CURSOR @SetCurSz ch,cl ENDIF @restore ret restore_cursor endp ;+ ; FUNCTION : reset_line ; ; Called to init various things like cursor shape, history buffer ; character positions etc. ; ; Parameters: ; None. ; ; Returns: ; Nothing. ; ; Register(s) destroyed: ; AX,BX,CX,DX ;- reset_line proc near call near ptr hist_top ;Reset history stack ptr to top call near ptr restore_cursor ;Reset cursor shape mov ax,offset dgroup:linebuf mov lastchar,ax ;End of line mov dot,ax ;current pos in line mov disp_begin,ax ;first pos that changed mov disp_end,ax ;last pos that changed ; Init overstrike/insert mode mov bl,default_imode ;Default edit mode ; (insert/overstrike) mov edit_mode,bl ;Init insert/overtype mode ; Initialize the cursor shapes for insert and overstrike mode mov ax,caller_cursor ;Caller's cursor shape IF TOGGLE_CURSOR mov ah,al sub ah,3 mov imode_cursor,ax ;Insert mode cursor mov ah,al sub ah,1 mov omode_cursor,ax ;Overtype mode cursor ; Init cursor shape xor bh,bh add bx,bx mov cx,omode_cursor[bx] mov ah,01h int 10h ELSE mov omode_cursor,ax mov imode_cursor,ax ENDIF mov bh,video_page @GetCur bh mov initial_curpos,dx ;Initial cursor position ret reset_line endp ;+ ; FUNCTION : init_screen ; ; Inits various screen parameters. Reads the current prompt from ; the screen and store in the prompt buffer. prompt buffer is ; assumed to be at most the width of the screen. ; ; Parameters: ; None. ; ; Returns: ; Nothing. ; Register(s) destroyed: ; AX,BX,CX,DX ;- init_screen proc near @save si,di @GetMode ;Get the video mode mov video_page,bh ;Store page mov screen_width,ah ; and width of display @GetCur bh ;Get the cursor shape and position mov initial_curpos,dx ;Initial cursor position mov caller_cursor,cx ;Caller's cursor shape mov di,offset DGROUP:prompt mov cx,PROMPT_BUF_SIZE ;CX<-size of prompt buffer ; (assumed not 0) mov si,dx ;DX<-cursor pos xor dl,dl ;DX<-position at start of row @init_screen_5: ; BH holds video page, DX is cursor position, SI is ending cursor ; position, CX is remaining space in prompt buffer @SetCurPos ,,bh ;Set cursor position cmp dx,si ;Reached original position ? je @init_screen_10 ;Yes, all done @GetChAtr bh ;Get char at cursor stosb ;Store in prompt buffer inc dl ;Increment cursor position loop @init_screen_5 ;loop unless prompt buffer full @init_screen_10: sub di,offset DGROUP:prompt mov prompt_length,di ;Store length of prompt @restore ret init_screen endp ;+ ; FUNCTION : disp_prompt ; ; Called to display the user's prompt. The prompt is taken from ; the buffer 'prompt'. ; ; Parameters: ; None. ; ; Returns: ; Nothing. ; Register(s) destroyed: ; ;- disp_prompt proc near @save si @DispCh CR @DispCh LF mov cx,prompt_length jcxz @disp_prompt_99 mov si,offset DGROUP:prompt @disp_prompt_10: lodsb @DispCh al loop @disp_prompt_10 @disp_prompt_99: @restore ret disp_prompt endp ;+ ; FUNCTION : makeroom ; ; Called to push a specified number of characters from the end of a ; line to the back of the line buffer. ; ; Parameters: ; CX - number of chars to push back ; ; Returns: ; DI - points to the first char of the string pushed back. ; Register(s) destroyed: ; CX ;- makeroom proc near @save si mov si,lastchar ;end of line dec si mov di,offset DGROUP:linebuf_suffix ;Di->end of linebuf (we ; want to move chars in ; reverse order) std rep movsb ;Move up characters cld inc di ;DI->start of string @restore ret makeroom endp ;+ ; FUNCTION : getpsp ; ; Returns the PSP of the current process ; ; Returns: ; BX - segment of current PSP ; ; Registers destroyed : ; AX,BX ;- getpsp proc near ; Get the PSP of the current process cmp dos_version_major,2 jbe @getpsp_10 ; DOS 3.x or above - use documented call mov ah,62h jmp short @getpsp_90 @getpsp_10: ; DOS version 2.x - use undocumented call mov ah,51h @getpsp_90: int 21h ;BX->PSP segment ret getpsp endp ;+ ; Function : locate_dosenv ; ; Locates the segment in which the current environment is located. ; This environment is the 'current' environment which may not ; necessarily be the root environment. ; ; Parameters: ; None. ; ; Returns: ; AX - segment of environment ; ; Register(s) destroyed: ; AX ;- locate_dosenv proc near @save bx,si,es call near ptr getpsp ;BX->segment of psp mov es,bx ;ES->segment of psp ; Loop to find the current command.com psp mov si,16h ;ES:SI->parent psp xor ax,ax ;Init for loop jmp short @locate_dosenv_20 ;'while' loop @locate_dosenv_10: mov ax,es:[si] ;AX<-psp seg mov es,ax ;ES->psp of parent @locate_dosenv_20: cmp ax,es:[si] ;Is psp == parent psp ? jne @locate_dosenv_10 ; ES contains DOS PSP. mov ax,es:[2ch] ;Offset 2c is env address ; AX->DOS environment ; mov dos_envseg,ax cmp dos_version_major,2 ;DOS 2.x ? je @locate_dosenv_50 ; Versions 3.x or higher cmp dos_version_minor,10 ;3.1 or below ? jle @locate_dosenv_50 ;If so handle like 2.x cmp dos_version_minor,30 ;3,3 or above ? jge @locate_dosenv_99 ;Then all done ; DOS version higher than 3.1 but below 3.3. jmp short @locate_dosenv_60 @locate_dosenv_50: ; DOS version 2.x-3.1. If the environement is non-0, all done. Else the ; environment is the memory block below the command.com. or ax,ax ;0 ? jne @locate_dosenv_99 ;No, all done @locate_dosenv_60: mov si,es dec si ;SI is segment of memory ; control block of command.com mov es,si mov ax,es:[3] ;AX->size of command.com in ; paragraphs inc ax ;Add size of MCB to AX (in ; paras) add ax,si ;AX->MCB of environment inc ax ;AX->environment ; mov dos_envseg,ax ;Store it. @locate_dosenv_99: ; OK, now dos_envseg supposedly contains the environment segment. DO some ; heuristics to make sure it is really what we think it is. @restore ret locate_dosenv endp ;+ ; FUNCTION : our_break_handler ; ; This takes over the Ctrl-Break interrupt and sets a flag when ; Ctrl-Break is hit. It then jumps to the original Ctrl-Break handler. ; ; Parameters: ; ; ; Returns: ; ; Register(s) destroyed: ;- our_break_handler proc near inc CS:check_break cmp CS:trap_break,1 jne @our_break_handler_10 iret @our_break_handler_10: jmp CS:prev_isr1b our_break_handler endp CSEG ENDS END entry