CP/M/CPM_CDROM.iso/zsys/simtel20/zcpr3/alias1.mac

Text File | 1994-07-13 | 9.4 KB | 514 lines

;
; Program: ALIAS1
; Author: Richard Conn
; Version: 1.1
; Date: 10 June 84
; Previous Versions:  1.0 (5 Mar 84)
;
version    equ    11

;
;    The purpose of ALIAS1 is to load the Command Line Buffer with
; a command line stored within ALIAS1, extracting parameters using the
; SUBMIT file convention ($n) as they are referenced in the new command
; line.  Upon successful build, ALIAS1 runs the new command line by simply
; returning to ZCPR3.
;

;
; Macros
;
    MACLIB    Z3BASE.LIB

;
; Basic Equates
;
tbuff    equ    80h

;
; External References
;
    ext    z3init,getefcb,getcl1,getenv,getfn2
    ext    eprint,codend,sksp,retud,caps

;
; Environment Definition
;
    if    z3env ne 0
;
; External ZCPR3 Environment Descriptor
;
    jmp    start
    db    'Z3ENV'    ;This is a ZCPR3 Utility
    db    1    ;External Environment Descriptor
z3eadr:
    dw    z3env
start:
    lhld    z3eadr    ;pt to ZCPR3 environment
;
    else
;
; Internal ZCPR3 Environment Descriptor
;
    MACLIB    SYSENV.LIB
z3eadr:
    jmp    start
    SYSENV
start:
    lxi    h,z3eadr    ;pt to ZCPR3 environment
    endif

;
; Start of Program -- Initialize ZCPR3 Environment
;
    call    z3init    ;initialize the ZCPR3 Env and the VLIB Env
    jmp    start1    ;skip command line buffer
;
; ALIAS ID at START+9
;
    db    'Z3 ALIAS'
;
; Internal Command Line Buffer
;    This buffer address can be determined from START+17, where the
; value of START is obtained from the 2nd and 3rd bytes of ALIAS1.
;
clbuf:
    db    0    ;set to empty
    ds    255    ;allow 256 bytes
;
; Resume ALIAS1
;
start1:
    call    codend    ;pt to free space in which to build new line
    lxi    d,clbuf    ;pt to buffer
    xchg        ;HL pts to target line, DE pts to buffer
;
; Process Next Char from Target Command Line
;
nxtchar:
    mov    a,m    ;get next char
    ora    a    ;end of line?
    jz    done
    cpi    '$'    ;possible passed parameter?
    jz    param
    stax    d    ;store next char
    inx    h    ;pt to next
    inx    d
    jmp    nxtchar
;
; Process Possible Parameter
;
param:
    lxi    b,nxtchar    ;establish return address
    push    b    ;... on stack
    inx    h    ;get parameter char
    mov    a,m
    call    caps    ;capitalize
    cpi    '*'    ;entire tail?
    jz    paraml
    cpi    'D'    ;current disk?
    jz    paramd
    cpi    'U'    ;current user?
    jz    paramu
    cpi    'F'    ;System Filename.Typ?
    jz    paramf
    cpi    'N'    ;System Filename?
    jz    paramn
;    cpi    'T'    ;System Typ?
;    jz    paramt
    sui    '0'    ;convert
    jc    noparam
    cpi    10    ;range?
    jnc    noparam
    ora    a    ;parameter 0 = original name
    jz    oname
    mov    b,a    ;count in B (1 or more)
    inx    h    ;pt to next char
    push    h    ;save ptr
    lxi    h,tbuff+1    ;pt to input line
;
; Advance to Desired Parameter
;
param1:
    call    sksp    ;skip to non-blank
    mov    a,m    ;check for done
    ora    a
    jz    paramx
    dcr    b    ;count down
    jz    param3    ;got it
;
; Skip Over This Parameter
;
param2:
    mov    a,m    ;skip to space or EOL
    inx    h    ;pt to next
    cpi    ' '    ;space
    jz    param1
    ora    a    ;EOL
    jz    paramx
    jmp    param2    ;continue
;
; Extract Parameter Into Target Buffer
;
param3:
    mov    a,m    ;get char
    cpi    ' '+1    ;done?
    jc    paramx
    stax    d    ;store char
    inx    h    ;advance
    inx    d
    jmp    param3
;
; Resume Processing of Target Command
;
paramx:
    pop    h    ;restore ptr to next char
    ret        ;resume at next char
;
; Parameter is for System Filename.typ
;
paramf:
    call    getfnum    ;get file number
    rz        ;resume if error
    push    h    ;save ptr to next char
    call    ptfn    ;set ptr to file name
    call    putn    ;put file name
    mvi    a,'.'    ;dot
    stax    d
    inx    d
    call    putt    ;put file type
    pop    h    ;restore ptr
    ret
;
; Parameter is for System Filename
;
paramn:
    call    getfnum    ;get file number
    rz        ;resume if error
    push    h    ;save ptr to next char
    call    ptfn    ;set ptr to file name
    call    putn    ;put file name
    pop    h    ;restore ptr
    ret
;
; Parameter is for System Typ
;
;paramt:
;    call    getfnum    ;get file number
;    jz    nxtchar    ;resume if error
;    push    h    ;save ptr to next char
;    call    ptfn    ;set ptr to file name
;    mvi    a,8    ;add 8 to get to file type
;    add    l
;    mov    l,a
;    mov    a,h
;    aci    0
;    mov    h,a
;    call    putt    ;put file type
;    pop    h    ;restore ptr
;    jmp    nxtchar

;
; Get File Number (1 to 4)
;    If valid number, return with value in A and HL pting to next char
;    If not valid, return with Z and HL pting to next char (the number)
;
getfnum:
    inx    h    ;pt to number
    mov    a,m    ;get char
    sui    '1'    ;convert
    jc    getfne    ;error if less
    cpi    4    ;range?
    jnc    getfne    ;error if more
    inx    h    ;pt to next char
    ret        ;NZ from CPI 4
getfne:
    xra    a    ;return Z
    ret
;
; Pt to File Name whose Number (1-4) is in A
;
ptfn:
    mov    b,a    ;number in B
    call    getfn2    ;pt to file name 2
    push    d    ;save DE
    mov    a,b    ;file 0?
    ora    a
    jz    ptfnx
    lxi    d,11    ;size of file name and type
ptfn1:
    dad    d    ;pt to next
    dcr    b    ;count down
    jnz    ptfn1
ptfnx:
    pop    d    ;restore DE
    ret
;
; Put File Name pted to by HL
;
putn:
    mvi    b,8    ;8 chars
    jmp    putc
;
; Put File Type pted to by HL
;
putt:
    mvi    b,3    ;3 chars
;
; Copy chars from HL to DE for up to 8 bytes - flush if space
;
putc:
    mov    a,m    ;get next char
    cpi    ' '    ;skip spaces
    jz    putc1
    stax    d    ;put next char
    inx    d    ;pt to next
putc1:
    inx    h    ;pt to next
    dcr    b    ;count down
    jnz    putc
    ret
;
; Parameter is for Disk Letter
;
paramd:
    call    retud    ;get DU in BC
    mov    a,b    ;get disk letter
    adi    'A'    ;convert to ASCII
    stax    d    ;store char
    inx    d    ;pt to next
    inx    h    ;pt to next char
    ret
;
; Parameter is for User Number
;
paramu:
    call    retud    ;get DU in BC
    mov    a,c    ;get user number
    mvi    b,10    ;compute 10's
    mvi    c,'0'
pmu1:
    sub    b    ;subtract 10's
    jc    pmu2
    inr    c    ;increment 10's
    jmp    pmu1
pmu2:
    add    b    ;add B back in
    adi    '0'    ;convert to ASCII
    mov    b,a    ;10's in C, 1's in B
    mov    a,c
    cpi    '0'    ;no leading 0's
    jz    pmu3
    stax    d    ;store char
    inx    d    ;pt to next
pmu3:
    mov    a,b    ;get 1's
    stax    d    ;store char
    inx    d    ;pt to next
    inx    h    ;pt to next char
    ret
;
; Parameter is command line tail
;
paraml:
    inx    h    ;pt to char after parameter letter
    push    h    ;save ptr to parameter
    lxi    h,tbuff+1    ;pt to tail
paramt1:
    mov    a,m    ;copy tail into line
    ora    a    ;end of tail?
    jz    paramt2
    stax    d    ;store char
    inx    h    ;pt to next
    inx    d
    jmp    paramt1
paramt2:
    pop    h    ;pt to next char in script
    ret        ;continue processing
;
; Form assumed to be $$
;
noparam:
    mvi    a,'$'    ;store '$'
    stax    d
    inx    d    ;pt to next chars
    inx    h
    ret
;
; $0 - ALIAS Command Name
;
oname:
    inx    h    ;pt to next char
    push    h    ;save ptr
    call    getefcb    ;pt to FCB
    jz    paramx    ;skip if no external FCB
    inx    h    ;pt to first char
    mvi    b,8    ;at most 8 chars
on1:
    mov    a,m    ;copy into output line
    cpi    ' '    ;done if space
    jz    paramx
    stax    d    ;store char
    inx    h    ;pt to next
    inx    d
    dcr    b    ;count down
    jnz    on1
    jmp    paramx

;
; Done -- Buffer is Loaded
;
done:
    xra    a    ;store ending 0
    stax    d
    call    codend    ;pt to buffer
    mov    a,m    ;skip if empty line
    ora    a
    rz
;
; Determine if ZCPR3 Environment Support is Available for Command Line
;
    push    h    ;save ptr to line
    call    getenv    ;get environment
    mov    a,h
    ora    l
    jz    done0
;
; Get environment from descriptor
;
    call    getcl1    ;get command line data
    mov    b,a    ;save char count
    mov    a,h    ;check for no command line
    ora    l
    jz    done0
    mov    a,b    ;restore char count
    ora    a    ;check for no chars
    jnz    done1
;
; Get environment from MACRO File
;
done0:
    lxi    h,z3cl    ;pt to command line from macro expansion
    mvi    a,z3cls    ;get size of command line
;
; Store Command Line
;
done1:
    pop    d    ;DE pts to line
    call    putcl    ;store in command line
    rnz        ;return to ZCPR3 for processing if OK
    call    eprint
    db    'Ovfl',0
    ret
;
;    PUTCL stores a command line in the ZCPR3 command line buffer.
; This command line is pted to by DE.  CL Buffer is pted to by HL.
; Size in A. On return, A=0 and Zero
; Flag Set if command line overflow is possible (no change to command line).
;
putcl:
    shld    clbfr    ;save ptr to command line buffer
    ora    a    ;any command line?
    jz    nocl
    mov    b,a    ;char count in B
    xchg        ;HL pts to new line
    push    h    ;save ptr to new line
pcl2:
    mov    a,m    ;go to end of line
    ora    a    ;at end?
    jz    pcl3
    inx    h    ;pt to next
    dcr    b    ;count down
    jnz    pcl2
    pop    h    ;clear stack
;
; Command Line Buffer Overflow
;
nocl:
    xra    a    ;error return
    ret
;
; At End of New Command Line (ptr on stack)
;    Ptr to first char of new command line on stack
;    HL pts to ending 0 of new command line
;    B = number of chars remaining before overflow of Z3 command line
;
pcl3:
    push    h    ;save ptr to last byte in case of error
    lhld    clbfr    ;pt to tail of command line
    mov    e,m
    inx    h
    mov    d,m
    xchg        ;HL pts to command line tail
    pop    d    ;restore ptr to last byte of command line
    push    d
    mov    a,m    ;get first char of tail
    cpi    ';'    ;continuation?
    jz    pcl4
    ora    a    ;done?
    jz    pcl4
    mvi    a,';'    ;set continuation char
    stax    d
    inx    d
    dcr    b    ;count down
    jz    pcl5    ;overflow
;
; Copy tail onto end of new command line
;
pcl4:
    mov    a,m    ;get next char
    stax    d    ;store it
    inx    h    ;pt to next
    inx    d
    ora    a    ;done?
    jz    pcl6
    dcr    b    ;count down
    jnz    pcl4
;
; Command Line too Long
;
pcl5:
    pop    h    ;get ptr to end of old line
    mvi    m,0    ;store ending 0
    pop    psw    ;clear stack
    jmp    nocl
;
; New Command Line OK
;
pcl6:
    pop    psw    ;clear stack
    lhld    clbfr    ;pt to command line buffer
    lxi    d,4    ;pt to first char in buffer
    xchg
    dad    d
    xchg
    mov    m,e    ;store address
    inx    h
    mov    m,d    ;DE pts to first char of buffer
    pop    h    ;HL pts to first char of new line
;
; Copy New Command Line into Buffer
;
pcl7:
    mov    a,m    ;copy
    stax    d
    inx    h
    inx    d
    ora    a    ;EOL?
    jnz    pcl7
;
; Exit with OK Code
;
    xra    a    ;set NZ
    dcr    a
    ret

;
; Buffers
;
clbfr:
    ds    2    ;ptr to command line

    end