1 files changed, 530 insertions, 0 deletions

diff --git a/v4.0/src/DEV/XMA2EMS/PARMPARS.INC b/v4.0/src/DEV/XMA2EMS/PARMPARS.INC
new file mode 100644
index 0000000..42ea6e8
--- /dev/null
+++ b/v4.0/src/DEV/XMA2EMS/PARMPARS.INC
@@ -0,0 +1,530 @@
+        PAGE
+;-----------------------------------------------------------------------;
+;       GET_PARMS extracts parameters from the command line buffer      ;
+;                                                                       ;
+;       On entry:   all letters after 'Device=' have been changed       ;
+;                   to upper case                                       ;
+;                                                                       ;
+;       On exit:    (zf)=0 if syntax error                              ;
+;                   if (zf)=1 then...                                   ;
+;                                                                       ;
+;                   EMM_START_BLOCK has been updated                    ;
+;                                                                       ;
+;                   AX,BX,CX,DX,DI,SI,DS are destroyed                  ;
+;-----------------------------------------------------------------------;
+
+include xma2emsp.inc                    ; include parser things
+include parse.asm
+
+GET_PARMS PROC
+        LDS     BX,CS:RH_PTRA           ;make ds:bx point to request header
+
+        LDS     SI,RH.RH0_BPBA          ;make ds:si point to bios paramter buffer
+        CLD
+        mov     cs:EMS_Pgs_Parm,E_Parm_Def ;default to all of memory            ;an000; dms;
+
+;-------------------------------------------------------------------
+;       parser support added by GGA
+;-------------------------------------------------------------------
+        push    cs                      ; make ES:DI point to parm block
+        pop     es
+        lea     di,p_block
+
+        xor     cx,cx                   ; cx = 0, ordinal
+        xor     dx,dx                   ; dx = 0, reserved
+
+        push    ds                      ; save ds
+
+get_args:
+        pop     ds                      ; restore ds
+        call    SysParse                ; call the parser
+        cmp     ax,0                    ; end of line?
+        je      check_frame             ; no, find out what we got this time
+        cmp     ax,-1                   ; end of parse?
+        je      end_of_input_line1      ; yes
+                cmp     ax,-1           ; flag an error
+                ret                     ; return to caller
+
+end_of_input_line1:
+
+        jmp     end_of_input_line       ;
+
+;       find out which arg was processed this time
+
+check_frame:
+
+;       make ds point to data area for these comparisons, must restore before
+;       calling parser again
+
+        push    ds                      ; save ds
+        push    es                      ; make ds point to save areas
+        pop     ds
+
+        cmp     frame_result.$P_Type,2  ; was there a FRAME= in this pass?
+        jne     check_p0                ; no, look for a P0
+
+        mov     parse_flag,1            ; set parse flag
+
+        mov     byte ptr frame_ctl+9,0  ; turn this off so we don't allow another
+        mov     frame_result.$P_Type,0  ; clear this so we don't get fooled later
+
+        mov     byte ptr p0_ctl+9,0     ; turn these off so we don't allow any
+        mov     byte ptr p1_ctl+9,0     ; others that would conflict
+        mov     byte ptr p2_ctl+9,0
+        mov     byte ptr p3_ctl+9,0
+
+        push    si                                              ;save regs
+
+        mov     si,word ptr frame_result.$P_Picked_Val[+0]
+
+        mov     word ptr ds:[si+0],0                            ;clear the
+        mov     word ptr ds:[si+4],0                            ;  pages
+        mov     word ptr ds:[si+8],0
+        mov     word ptr ds:[si+12],0
+
+        pop     si                                              ;restore regs
+
+
+;       set flags for later code to fill in map_table
+
+        or      page_flags,frame_flag   ; set frame flag
+
+        jmp     get_args                ; go get another argument
+
+check_p0:
+        cmp     p0_result.$P_Type,2     ; was there a P0= in this pass?
+        jne     check_p1                ; no, look for a P0
+
+        mov     parse_flag,1            ; set parse flag
+
+        mov     byte ptr p0_ctl+9,0     ; turn this off so we don't allow another
+        mov     p0_result.$P_Type,0     ; clear this so we don't get fooled later
+
+        mov     byte ptr frame_ctl+9,0  ; turn this off so we don't allow another
+
+        push    si                                              ;save regs
+
+        mov     si,word ptr p0_result.$P_Picked_Val[+0]
+
+        mov     word ptr ds:[si+0],0
+
+        pop     si                                              ;restore regs
+;       set flags for later code to fill in map_table
+
+        or      page_flags,p0_flag      ; set p0 flag
+
+        jmp     get_args                ; go get another argument
+
+check_p1:
+        cmp     p1_result.$P_Type,2     ; was there a p1= in this pass?
+        jne     check_p2                ; no, look for a P2
+
+        mov     parse_flag,1            ; set parse flag
+
+        mov     byte ptr p1_ctl+9,0     ; turn this off so we don't allow another
+        mov     p1_result.$P_Type,0     ; clear this so we don't get fooled later
+
+        mov     byte ptr frame_ctl+9,0  ; turn this off so we don't allow another
+
+        push    si                                              ;save regs
+
+        mov     si,word ptr p1_result.$P_Picked_Val[+0]
+
+        mov     word ptr ds:[si+0],0
+
+        pop     si                                              ;restore regs
+;       set flags for later code to fill in map_table
+
+        or      page_flags,p1_flag      ; set p1 flag
+
+        jmp     get_args                ; go get another argument
+
+check_p2:
+        cmp     p2_result.$P_Type,2     ; was there a p2= in this pass?
+        jne     check_p3                ; no, look for a p3
+
+        mov     parse_flag,1            ; set parse flag
+
+        mov     byte ptr p2_ctl+9,0     ; turn this off so we don't allow another
+        mov     p2_result.$P_Type,0     ; clear this so we don't get fooled later
+
+        mov     byte ptr frame_ctl+9,0  ; turn this off so we don't allow another
+
+        push    si                                              ;save regs
+
+        mov     si,word ptr p2_result.$P_Picked_Val[+0]
+
+        mov     word ptr ds:[si+0],0
+
+        pop     si                                              ;restore regs
+;       set flags for later code to fill in map_table
+
+        or      page_flags,p2_flag      ; set p2 flag
+
+        jmp     get_args                ; go get another argument
+
+check_p3:
+        cmp     p3_result.$P_Type,2     ; was there a p3= in this pass?
+        jne     check_p254              ; no, look for a P254
+
+        mov     parse_flag,1            ; set parse flag
+
+        mov     byte ptr p3_ctl+9,0     ; turn this off so we don't allow another
+        mov     p3_result.$P_Type,0     ; clear this so we don't get fooled later
+
+        mov     byte ptr frame_ctl+9,0  ; turn this off so we don't allow another
+
+        push    si                                              ;save regs
+
+        mov     si,word ptr p3_result.$P_Picked_Val[+0]
+
+        mov     word ptr ds:[si+0],0
+
+        pop     si                                              ;restore regs
+;       set flags for later code to fill in map_table
+
+        or      page_flags,p3_flag      ; set p3 flag
+
+        jmp     get_args                ; go get another argument
+
+check_p254:
+        cmp     p254_result.$P_Type,2   ; was there a p254= in this pass?
+        jne     check_p255              ; no, look for a P255
+
+        mov     parse_flag,1            ; set parse flag
+
+        mov     byte ptr p254_ctl+9,0   ; turn this off so we don't allow another
+        mov     p254_result.$P_Type,0   ; clear this so we don't get fooled later
+
+        push    si                                              ;save regs
+
+        mov     si,word ptr p254_result.$P_Picked_Val[+0]
+
+        mov     word ptr ds:[si+0],0
+
+        pop     si                                              ;restore regs
+;       set flags for later code to fill in map_table
+
+        or      page_flags,p254_flag      ; set p254 flag
+
+        jmp     get_args                ; go get another argument
+
+check_p255:
+        cmp     p255_result.$P_Type,2   ; was there a P255= in this pass?
+        je      do_p255                 ; yes, process it
+        jmp     Check_X                 ; no, find out if /X was included
+
+do_p255:
+        mov     parse_flag,1            ; set parse flag
+
+        mov     byte ptr p255_ctl+9,0   ; turn this off so we don't allow another
+        mov     p255_result.$P_Type,0   ; clear this so we don't get fooled later
+
+        push    si                                              ;save regs
+
+        mov     si,word ptr p255_result.$P_Picked_Val[+0]
+
+        mov     word ptr ds:[si+0],0
+
+        pop     si                                              ;restore regs
+;       set flags for later code to fill in map_table
+
+        or      page_flags,p255_flag    ; set p255 flag
+
+        jmp     get_args                ; go get another argument
+
+Check_X:
+        cmp     es:X_Result.$P_SYNONYM_Ptr,offset es:X_Switch.$P_KeyorSW ; switch Ptr      ;an000; dms;
+        je      Do_X                    ; yes, process it
+        jmp     get_args                ; no, must have been the positional, ignore it and go on
+
+Do_X:
+
+        push    ax                      ; save regs
+        mov     ax,es:word ptr X_Result.$P_Picked_Val ;get low word of result    ;an000; dms;
+        mov     cs:EMS_Pgs_Parm,ax      ; pass to program                       ;an000; dms;
+        pop     ax                      ; restore regs
+
+        jmp     get_args                ; go get another argument
+
+
+
+
+;       getting here means invalid argument, figure out what to do later
+
+end_of_input_line:
+
+        cmp     parse_flag,null         ; were there command line args?
+        jne     cmd_line_args           ; yes, process them
+        jmp     null_cmd_line           ; no, skip processing
+
+cmd_line_args:
+
+;       put the stuff into map_table, this is done by looking at flags set
+;       by the above code and putting the addresses into map_table
+
+        push    ax                      ; save some regs
+        push    bx
+        push    cx
+        push    dx
+        push    di
+
+        xor     di,di                   ; clear index pointer
+
+        mov     map_count,null          ; clear map count default
+
+        test    page_flags,frame_flag   ; was FRAME= included?
+        jz      chk_p0                  ; no, try p0
+
+;       yes, fix up page count and fill in map_table
+
+        mov     map_count,4             ; FRAME= takes up 4 map entries
+
+;       convert the item tag into a segment address
+
+        xor     ah,ah                   ; make 0
+        mov     al,frame_result.$P_Item_Tag     ; get item tag
+        mov     cx,8                    ; need to shift left eight bits
+        shl     ax,cl                   ; to convert to a segment address
+
+;       do some math with di
+
+        xor     di,di                   ; clear index pointer
+
+;       save the segment addresses in map_table
+
+        mov     map_table.phys_page_segment[di],ax      ; store p0 segment
+        mov     map_table.phys_page_number[di],0            ; p0 page number
+        mov     cs:Page_Frame_Sta,ax                    ;save our page for XMA1 ;an000; dms;
+                                                        ;  diags.
+
+        add     ax,400h                 ; increase segment ID by 16K
+        add     di,type mappable_phys_page_struct
+
+        mov     map_table.phys_page_segment[di],ax      ; store p1 segment
+        mov     map_table.phys_page_number[di],1            ; p1 page number
+
+        add     ax,400h                 ; increase segment ID by 16K
+        add     di,type mappable_phys_page_struct
+
+        mov     map_table.phys_page_segment[di],ax      ; store p2 segment
+        mov     map_table.phys_page_number[di],2            ; p2 page number
+
+        add     ax,400h                 ; increase segment ID by 16K
+        add     di,type mappable_phys_page_struct
+
+        mov     map_table.phys_page_segment[di],ax      ; store p3 segment
+        mov     map_table.phys_page_number[di],3            ; p3 page number
+
+;       do some math with di, this will be used as a pointer into map_table
+
+        add     di,type mappable_phys_page_struct
+
+        jmp     chk_p254                ; FRAME= implies that p0 - p3 were not present,
+                                        ; skip ahead and look for p254 and p255
+
+;       check for p0
+
+chk_p0:
+
+        test    page_flags,p0_flag      ; was p0= included?
+        jz      chk_p1                  ; no, try p1
+
+;       yes, fix up page count and fill in map_table
+
+        add     map_count,1             ; one extra map entry
+
+;       convert the item tag into a segment address
+
+        xor     ah,ah                   ; make 0
+        mov     al,p0_result.$P_Item_Tag; get item tag
+        mov     cx,8                    ; need to shift left eight bits
+        shl     ax,cl                   ; to convert to a segment address
+
+
+;       save the segment addresses in map_table
+
+        mov     map_table.phys_page_segment[di],ax      ; store p0 segment
+        mov     map_table.phys_page_number[di],0            ; p0 page number
+        mov     cs:Page_Frame_Sta,ax                    ;save our page for XMA1 ;an000; dms;
+                                                        ;  diags.
+
+;       do some math with di, this will be used as a pointer into map_table
+
+        add     di,type mappable_phys_page_struct
+
+;------------------------
+;       check for p1
+;------------------------
+
+chk_p1:
+
+        test    page_flags,p1_flag      ; was p1= included?
+        jz      chk_p2                  ; no, try p2
+
+;       yes, fix up page count and fill in map_table
+
+        add     map_count,1             ; one extra map entry
+
+;       convert the item tag into a segment address
+
+        xor     ah,ah                   ; make 0
+        mov     al,p1_result.$P_Item_Tag; get item tag
+        mov     cx,8                    ; need to shift left eight bits
+        shl     ax,cl                   ; to convert to a segment address
+
+
+;       save the segment addresses in map_table
+
+        mov     map_table.phys_page_segment[di],ax      ; store p1 segment
+        mov     map_table.phys_page_number[di],1            ; p0 page number
+        mov     cs:Page_Frame_Sta,ax                    ;save our page for XMA1 ;an000; dms;
+                                                        ;  diags.
+
+;       do some math with di, this will be used as a pointer into map_table
+
+        add     di,type mappable_phys_page_struct
+
+;------------------------
+;       check for p2
+;------------------------
+
+chk_p2:
+
+        test    page_flags,p2_flag      ; was p2= included?
+        jz      chk_p3                  ; no, try p3
+
+;       yes, fix up page count and fill in map_table
+
+        add     map_count,1             ; one extra map entry
+
+;       convert the item tag into a segment address
+
+        xor     ah,ah                   ; make 0
+        mov     al,p2_result.$P_Item_Tag; get item tag
+        mov     cx,8                    ; need to shift left eight bits
+        shl     ax,cl                   ; to convert to a segment address
+
+
+;       save the segment addresses in map_table
+
+        mov     map_table.phys_page_segment[di],ax      ; store p2 segment
+        mov     map_table.phys_page_number[di],2            ; p2 page number
+        mov     cs:Page_Frame_Sta,ax                    ;save our page for XMA1 ;an000; dms;
+                                                        ;  diags.
+
+;       do some math with di, this will be used as a pointer into map_table
+
+        add     di,type mappable_phys_page_struct
+
+;------------------------
+;       check for p3
+;------------------------
+
+chk_p3:
+
+        test    page_flags,p3_flag      ; was p3= included?
+        jz      chk_p254                ; no, try p254
+
+;       yes, fix up page count and fill in map_table
+
+        add     map_count,1             ; one extra map entry
+
+;       convert the item tag into a segment address
+
+        xor     ah,ah                   ; make 0
+        mov     al,p3_result.$P_Item_Tag; get item tag
+        mov     cx,8                    ; need to shift left eight bits
+        shl     ax,cl                   ; to convert to a segment address
+
+
+;       save the segment addresses in map_table
+
+        mov     map_table.phys_page_segment[di],ax      ; store p3 segment
+        mov     map_table.phys_page_number[di],3            ; p3 page number
+        mov     cs:Page_Frame_Sta,ax                    ;save our page for XMA1 ;an000; dms;
+                                                        ;  diags.
+
+;       do some math with di, this will be used as a pointer into map_table
+
+        add     di,type mappable_phys_page_struct
+
+;------------------------
+;       check for p254
+;------------------------
+
+chk_p254:
+
+        test    page_flags,p254_flag      ; was p254= included?
+        jz      chk_p255                ; no, try p255
+
+;       yes, fix up page count and fill in map_table
+
+        add     map_count,1             ; one extra map entry
+
+;       convert the item tag into a segment address
+
+        xor     ah,ah                   ; make 0
+        mov     al,p254_result.$P_Item_Tag; get item tag
+        mov     cx,8                    ; need to shift left eight bits
+        shl     ax,cl                   ; to convert to a segment address
+
+
+;       save the segment addresses in map_table
+
+        mov     map_table.phys_page_segment[di],ax      ; store p254 segment
+        mov     map_table.phys_page_number[di],0feh         ; p254 page number
+        mov     cs:Page_Frame_Sta,ax                    ;save our page for XMA1 ;an000; dms;
+                                                        ;  diags.
+
+;       do some math with di, this will be used as a pointer into map_table
+
+        add     di,type mappable_phys_page_struct
+
+;------------------------
+;       check for p255
+;------------------------
+
+chk_p255:
+
+        test    page_flags,p255_flag      ; was p255= included?
+        jz      Chk_X                   ; no, /X switch
+
+;       yes, fix up page count and fill in map_table
+
+        add     map_count,1             ; one extra map entry
+
+;       convert the item tag into a segment address
+
+        xor     ah,ah                   ; make 0
+        mov     al,p255_result.$P_Item_Tag; get item tag
+        mov     cx,8                    ; need to shift left eight bits
+        shl     ax,cl                   ; to convert to a segment address
+
+
+;       save the segment addresses in map_table
+
+        mov     map_table.phys_page_segment[di],ax      ; store p255 segment
+        mov     map_table.phys_page_number[di],0ffh         ; p255 page number
+        mov     cs:Page_Frame_Sta,ax                    ;save our page for XMA1 ;an000; dms;
+                                                        ;  diags.
+
+;       do some math with di, this will be used as a pointer into map_table
+
+        add     di,type mappable_phys_page_struct
+
+Chk_X:
+
+        pop     di                      ; restore some regs
+        pop     dx
+        pop     cx
+        pop     bx
+        pop     ax
+
+
+null_cmd_line:
+        CMP     AL,AL                   ; else set zf to indicate no error
+        ret                             ; return to calling routine
+
+
+GET_PARMS ENDP