Frostbyte's 1980s DOS Shareware Collection/floppyshareware.zip/floppyshareware/USCX/SETPGMS.ZIP/ENV_SET.ASM

Assembly Source File | 1987-01-15 | 27KB | 702 lines

                 PAGE   60,132

                 ;Usage is: call envsub  ds:si -> length,string

                 ;      length is 1 byte long, <128
                 ;         if high bit on, primary environment is set.
                 ;      string is of form: name=value

                 ;   Copyright 1987, A. B. Krueger GPW MI 48236
                 ;   All rights reserved. Contact "ARNY KRUEGER"
                 ;   at the EXEC-PC BBS (414-964-5160) for permission
                 ;   to use commercially.
                 ;

                 ;Clone of SET command that demonstrates updating
                 ;      the environment string.
                 ;If there is no secondary command processor, the
                 ;      global environment is updated
                 ;If there is a secondary command processor, then
                 ;      its enviroment is updated

sb               segment at 0      ;equates storage blocks and psp's

sb_kind          db     ' '        ;type of storage block: 'M' or 'Z'
sb_psp           dw     ?          ;psp segment address
sb_length        dw     ?          ;sb length in paragraphs
sb_head_length   equ    10h        ;length of sb header

                 org    0h         ;program segement prefix equates
psp_ret_int      dw     ?          ;int 20h
                 org    2Ch
psp_env          dw     ?          ;segment address of environment
                 org    50h
psp_dos_function dw     ?          ;address of function dispatcher
                 org    80h
psp_parm_string  db     ?          ;1 byte length plus parm string

psp_length       equ    100h

sb               ends

code_seg         segment para public
                 assume cs:code_seg,ds:code_seg,es:sb
                 public env_set

                 ;local  data

cr               equ    13
lf               equ    10

sb_count         dw    0            ;count of sb's encountered
sb_shell         dw    0            ;segment address of shell  sb
sb_shell_env     dw    0            ;segment address of global env sb
sb_secondary     dw    0            ;segment address of secondary command.com
sb_secondary_env dw    0            ;segment address of secondary command env

fatal_msg       equ    80h
error_msg       equ    40h
info_msg        equ    20h
msg_flag        db     fatal_msg+error_msg
                db     'Copyright 1987, A. B. Krueger GPW MI 48236'
secondary_msg   db     info_msg,'Secondary '
command_found   db     info_msg,'COMMAND.COM found',cr,lf,'$'
bad_dos_msg     db     fatal_msg,'Must be running under DOS 2.0 or above',cr,lf,'$'
bad_sb_msg      db     fatal_msg,'Bad storage block',cr,lf,'$'
bad_env_msg     db     error_msg,'Bad environment block',cr,lf,'$'
command_lost    db     error_msg,'Shell never found',cr,lf,'$'
addbadmsg       db     error_msg,'Environment corrupt',cr,lf,'$'
addmsg          db     info_msg,'Addition requested',cr,lf,'$'
removemsg       db     info_msg,'Removal requested',cr,lf,'$'
env_set_nospace db     error_msg,'No space in environment string',cr,lf,'$'
env_set_syntax  db     error_msg,'Set string syntax error',cr,lf,'$'

type_string     proc   near          ;type message at offset in dx
                push   ax            ;save registers
                push   cx
                push   dx
                push   si

                mov    si,dx         ;get message level
                lodsb
                and    al,msg_flag   ;compare to what sells
                jz     type_ret      ;if not on list, send to bit bucket

                mov    dx,si
                mov    ax,0900h
                int    21h
type_ret:
                pop    si
                pop    dx
                pop    cx
                pop    ax
                ret
type_string     endp

get_first_sb    proc   near       ;get first storage block, point es at it
                push   ax
                push   bx
                mov    ax,5200h
                int    21h        ;es:bx points to memory block anchor+2
                dec    bx
                dec    bx
                mov    es,es:[bx] ;get first memory block address into es
                pop    bx
                pop    ax
                ret
get_first_sb    endp

get_next_sb     proc   near
                push   ax
                mov    ax,es             ;get current paragraph
                add    ax,sb_length      ;add in number of paragraphs
                inc    ax                ;add 1 for header
                mov    es,ax             ;set new extra segment address
                pop    ax
                ret
get_next_sb     endp


find_secondary_env proc  near       ;find env sb's for current program sb
                push   ax           ;pointed to by es
                push   es
                mov    ax,es        ;get address of secondary cp's sb
                inc    ax           ;get its psp address
find_secondary_env_loop:
                call   get_next_sb  ;get next sb
                cmp    ax,sb_psp    ;match secondary's psp?
                jne    find_secondary_env_next    ;if not, skip

                mov    sb_secondary_env,es        ;otherwise, save
                jmp    find_secondary_env_exit    ;and check no further
                                                  ;lest we trash a .BAT block
find_secondary_env_next:
                cmp    sb_kind,'Z'                ;last block?
                jne    find_secondary_env_loop

find_secondary_env_exit:
                pop    es
                pop    ax
                ret
find_secondary_env endp

command_test    proc   near         ;test program storage block at es:0
                push   ax
                push   bx
                push   cx
                push   dx
                push   ds
                push   es
                push   si

                cmp    sb_count,2
                ja     command_second

                mov    dx,offset command_found
                call   type_string
                mov    sb_shell,es
                jmp    command_test_good

command_second:
                cmp    sb_shell,0                       ;did we find shell?
                je     command_first_bad                ;if not, error

                cmp    word ptr es:psp_env+sb_head_length,0  ;check environment of program
                je     command_test_good                 ;if no environment, quit

                push   sb_shell
                pop    ds                               ;ds points to shell
                mov    al,byte ptr es:sb_head_length+psp_length
                cmp    al,0E9h                          ;a JMP?
                jne    command_test_good                ;if not, no harm done

                cmp    al,byte ptr ds:sb_head_length+psp_length   ;check 1st instruction
                jne    command_first_bad

                mov    si,sb_head_length+psp_length
                mov    di,sb_head_length+psp_length
                mov    cx,10      ;look at 10 words of code
                repz   cmpsw
                clc
                jcxz   command_test_found   ;if they all match, fine

                jmp    command_test_good    ;if not, no harm done

command_test_found:
                push   cs
                pop    ds
                mov    sb_secondary,es

                mov    ax,es:psp_env+sb_head_length     ;get env address
                dec    ax                               ;back up over sb header
                mov    sb_secondary_env,ax              ;and save it

                call   find_secondary_env               ;look for other env's

                mov    dx,offset secondary_msg
                call   type_string
                jmp    command_test_good

command_first_bad:
                mov    dx,offset command_lost
                call   type_string
                stc
                jmp    command_test_end

command_test_good:
                clc
command_test_end:
                pop    si
                pop    es
                pop    ds
                pop    dx
                pop    cx
                pop    bx
                pop    ax

                ret
command_test    endp



prog_test       proc   near         ;test block for program
                push   ax           ;save registers
                push   cx
                push   dx
                push   es

                mov    ax,sb_psp             ;get PSP of owner
                cmp    ax,0                  ;if zero, it is free
                je     prog_exit

                cmp    ax,8                  ;if PSP of owner is at 8
                je     prog_exit             ;block owned by config.sys

                sub    ax,sb_head_length     ;get address of sb containg program
                cmp    ax,sb_shell           ;is owner the primary shell?
                je     prog_exit
                push   es
                pop    ax
                cmp    ax,sb_psp             ;compare to address of owner
                ja     prog_exit             ;if owner below SB, system-owned

                add    ax,sb_length          ;add in length
                cmp    ax,sb_psp             ;compare to owner's PSP
                JB     prog_exit             ;if end below owner PSP, no program
                cmp    sb_length,10          ;is block long enough to have a psp?
                jbe    prog_exit             ;if not, no program

                mov    ax,word ptr es:psp_dos_function+sb_head_length
                cmp    ax,word ptr cs:psp_dos_function   ;check PSP validity
                jne    prog_exit

                mov    ax,word ptr es:psp_ret_int+sb_head_length
                cmp    ax,word ptr cs:psp_ret_int     ;check PSP validity
                jne    prog_exit                ;if invalid, skip looking for env

                call   command_test
                clc
prog_exit:

                pop    es                       ;restore registers
                pop    dx
                pop    cx
                pop    ax
                ret

prog_test       endp

sb_scan         proc   near           ;loop cx storage blocks

                mov    al,sb_kind     ;get storage block type byte
                cmp    al,04dh        ;ordinary storage block
                je     sb_scan_got
                cmp    al,05ah
                jne    sb_scan_bad
                mov    cx,1           ;last block

sb_scan_got:
                inc    sb_count              ;count storage blocks

                cmp    sb_count,3
                jne    sb_scan_not_global

                mov    sb_shell_env,es
                jmp    sb_scan_get

sb_scan_not_global:
                call   prog_test             ;look for program

                loop   sb_scan_get
                jmp    sb_scan_end

sb_scan_get:
                call   get_next_sb
                jmp    sb_scan

sb_scan_end:
                clc
                jmp    sb_scan_exit

sb_scan_bad:
                mov    al,2
                mov    dx,offset bad_sb_msg
                stc

sb_scan_exit:
                ret
sb_scan         endp


sb_anal         proc   near           ;proc to analyze storage blocks
                                      ; to find environment(s)
                push   ax
                push   cx
                push   dx             ;carry flag = error
                push   es             ;error level in al
                mov    ah,30h         ;get release number
                int    21h
                cmp    al,01h         ;above dos 1.x?
                jna    sb_bad_dos

                cld                  ;clear direction flag
                call   get_first_sb
                mov    cx,9999        ;scan all blocks
                call   sb_scan
                jc     sb_send_msg    ;if any errors, exit

                jmp    sb_exit

sb_bad_dos:
                mov    al,1
                mov    dx,offset bad_dos_msg
                stc
                jmp    sb_send_msg

sb_bad_env:
                mov    al,3
                mov    dx,offset bad_env_msg
                stc
sb_send_msg:
                pushf
                call   type_string
                popf
sb_exit:
                pop    es
                pop    dx
                pop    cx
                pop    ax

                ret
sb_anal         endp

make_upper     proc    near          ;make cx bytes at es:di upper case

               push    ax            ;save registers modified
               push    cx
               push    di
               push    ds
               push    si

               push    es
               pop     ds
               mov     si,di
make_upper_loop:
               lodsb                  ;get a byte
               cmp     al,'a'           ;if lower case:
               jb      make_upper_next
               cmp     al,'z'
               ja      make_upper_next
               and     al,255-'a'+'A'   ;make upper case
make_upper_next:
               stosb                  ;store out results
               loop    make_upper_loop

               pop     si            ;restore registers
               pop     ds
               pop     di
               pop     cx
               pop     ax
               ret
make_upper     endp



env_var_name  proc     near               ;find environment variable name at
              push     ax                 ;  ds:si, length in cx
              push     bx                 ;at exit, ds:di points to name
              push     di                 ;         name length in cx
              push     es                 ;variable contents length to dx

              push     cx                 ;save length and pointer
              push     si                 ;for error exits

              jcxz     env_var_name_bad   ;if length is 0, exit


              push     cs                 ;scan works at es:di
              pop      es
              mov      di,si
              mov      al,' '             ;scan for non-blank

env_var_strip:
              repz     scasb              ;look for non-blank
              jcxz     env_var_name_bad   ;if all blank, error!

              inc      cx                 ;back up over non-blank character
              dec      di
              mov      si,di              ;save start of non-blank string
              mov      bx,cx              ;save length

              repnz    scasb              ;look for a blank
              mov      dx,di              ;save location of ' ' or end

              mov      cx,bx              ;reset search length
              mov      di,si              ;reset search pointer
              mov      al,'='             ;search for equals sign
              repnz    scasb
              jne      env_var_name_bad   ;if not found, error

              cmp      di,dx              ;compare location of '=' and ' '
              ja       env_var_name_bad   ;found ' ' first? then exit

              mov      dx,bx              ;restore search length
              add      dx,si              ;add start
              sub      dx,di              ;subtract where '=' was

              pop      ax                 ;pop old si from stack
              pop      ax                 ;pop old cx from stack

              mov      cx,di              ;where we found '='
              sub      cx,si              ;subtract string start
              dec      cx                 ;minus 1 for '='
              clc                         ;all is well
              jmp      env_var_name_exit

env_var_name_bad:
              pop      si                 ;restore pointer and length
              pop      cx
              xor      dx,dx              ;contents length assumed zero
              stc                         ;problems  - set carry

env_var_name_exit:
              pop      es
              pop      di
              pop      bx                 ;restore registers
              pop      ax
              ret

env_var_name  endp

get_sb_size   proc     near              ;get byte size of sb at es:0 in cx
              push     ax
              mov      ax,sb_length      ;get length of env in paragraphs
              mov      cl,4              ;times 16
              shl      ax,cl
              mov      cx,ax
              pop      ax
              ret
get_sb_size   endp

env_var_find  proc     near              ;find environment variable
                                         ;named in ds:si,name length in cx
                                         ;return string start in es:di
                                         ;length of entire string in cx
              push     ax                ;save registers
              push     bx
              push     dx

              mov      bx,cx             ;save length of name
              push     es                ;save env block address
              push     ds                ;set  es:di to source string
              pop      es                ;     "
              mov      di,si             ;make name upper case
              call     make_upper        ;altering input string
              pop      es                ;restore es to environment block

              call     get_sb_size       ;get size of sb in bytes

              mov      di,sb_head_length ;start at data portion of block
              mov      dx,cx             ;save block length

env_var_find_loop:
              push     si                ;save string pointers
              push     di

              mov      cx,bx             ;compare for length of name
              mov      ah,1              ;say not compare
              repz     cmpsb             ;compare item to name for name length
              jne      env_var_find_next ;if not found, scan on

              cmp      byte ptr es:[di],'='   ;check next byte for '='
              jne      env_var_find_next ;if found, go calc length

              mov      ah,0              ;say compare ok
env_var_find_next:
              pop      di                ;restore string pointers
              pop      si

              xor      al,al             ;look for end of current substring
              mov      cx,dx             ;search remainder of string
              mov      dx,di             ;save search start
              repnz    scasb             ;search for a zero
              jne      env_var_find_end  ;none found, error

              cmp      ah,0              ;did original compare fly?
              je       env_var_find_found;if so, then pass length, etc

              cmp      byte ptr es:[di],0  ;check next byte for zero
              je       env_var_find_end  ;if found, name not found

              mov      dx,cx             ;save length of string remaining
              jmp      env_var_find_loop ;and loop on

env_var_find_end:
              xor      cx,cx             ;length = 0, none found
              stc                        ;set error flag
              jmp      env_var_find_exit

env_var_find_found:
              mov      cx,di             ;save count of end of string
              mov      di,dx             ;restore search start
              sub      cx,di             ;calc length of search
              dec      cx                ;less length of zero
              clc                        ;no errors

env_var_find_exit:
              pop      dx
              pop      bx                ;restore registers
              pop      ax
              ret
env_var_find  endp


null_var      dw       -1

env_var_add   proc near                     ;add  environment variable
                                            ;expression ->ds:si, length in cx
              push    ax                    ;save registers
              push    bx
              push    dx

              mov     dx,offset addmsg
              call    type_string
              mov     bx,cx
              push    si
              mov     si,offset null_var  ;send on wild goose chase
              mov     cx,2                ;looking for  x'ffff'
              call    env_var_find        ;es:di points to end of env
              pop     si
              jnc     env_var_add_env_bad
                                          ;es:di now points to end of env
              call    get_sb_size         ;get length of env area in cx
              add     cx,sb_head_length   ;add head length for offsets
              sub     cx,bx               ;deduct length of string
              sub     cx,2                ;deduct length of flag
              cmp     di,cx               ;compare to where we add
              ja      env_var_add_bad     ;if no space, too bad

              mov     cx,bx               ;length of string to add
              rep     movsb               ;do the deed
              xor     ax,ax               ;make flag of two zeros
              stosw                       ;add is on

              jmp     env_var_add_good

env_var_add_env_bad:
              mov     dx,offset addbadmsg
              call    type_string

env_var_add_bad:
              stc
              jmp     env_var_add_exit

env_var_add_good:
              clc
env_var_add_exit:
              pop     dx                  ;restore registers
              pop     bx
              pop     ax
              ret

env_var_add   endp


env_var_remove proc near                ;remove environment variable
                                        ;at es:di, length in cx
              push    cx
              push    dx
              push    ds
              push    di
              push    si

              cld                      ;move left to right

              mov     dx,offset removemsg
              call    type_string

              inc     cx                  ;add 1 for zero byte
              mov     dx,cx               ;save length of var
              call    get_sb_size         ;cx gets length of env area
              add     cx,sb_head_length   ;add header length for offsets
              sub     cx,di               ;deduct where we start
              sub     cx,dx               ;deduct length of removed variable

              mov     si,di               ;move from next variable
              add     si,dx               ;add my length

              push    es                  ;do all the work in es:
              pop     ds

              rep     movsb               ;do the move

              pop     si
              pop     di
              pop     ds
              pop     dx
              pop     cx
              ret
env_var_remove  endp


env_set       proc    near                ;change environment per ds:si
              push    ax
              push    bx                  ;ds:si points to:
              push    cx                  ; length  db  ?
              push    di
              push    ds                  ; data    db  'name=value'
              push    es
              push    si

              xor     ax,ax               ;set length of local set string
              lodsb                       ;get length, push di forward
              mov     cx,ax               ;length of set string in cx
              and     cl,0ffh-80h         ;length < 128
              call    sb_anal             ;analyze the storage block chain
                                          ;to find command processor(s)

              and     al,80h              ;was use primary switch on?
              jnz     env_set_shell       ;if so, skip secondaries

              cmp     sb_secondary_env,0  ;is there a secondary command proc?
              je      env_set_shell       ;if not, use primary

              mov     es,sb_secondary_env ;command processor is secondary
              jmp     env_set_command

env_set_shell:                            ;command processor is shell
              mov     es,sb_shell_env
env_set_command:
              call    env_var_name        ;find what we want set at call
                                          ;ds:si -> expression, cx has length
                                          ;at return ds:si -> name
                                          ;cx is length of name
              jc      env_set_syntax_err  ;if not found, error

              mov     bx,cx               ;calculate new length of set string
              inc     bx                  ;add 1 for '='
              add     bx,dx               ;add length of set string

              call    env_var_find        ;find variable in environment block
                                          ;at return, es:di -> start of env str
                                          ;cx is length of env str
              jc      env_set_add         ;if not found, just add

              call    env_var_remove      ;remove variable at es:di from env
              cmp     dx,0                ;check out length of data to add
              je      env_set_exit        ;if zero, just exit

env_set_add:
              mov     cx,bx               ;restore length of variable
              call    env_var_add         ;add new variable to set string
              jc      env_set_no_space
              jmp     env_set_exit

env_set_no_space:
              mov     dx,offset env_set_nospace
              jmp     env_set_type

env_set_syntax_err:
              mov     dx,offset env_set_syntax
env_set_type:
              push    cs
              pop     ds
              call    type_string
env_set_error:
              stc
env_set_exit:
              pop     si
              pop     es
              pop     ds
              pop     di
              pop     cx
              pop     bx
              pop     ax
              ret
env_set       endp

code_seg      ends
              end