; [ This translation created 10-Feb-83 by Version 4.3 ]

.RADIX 8 ; To be safe

CSEG SEGMENT PUBLIC 'CODESG'

ASSUME CS:CSEG

INCLUDE OEM.H

TITLE ITSA86 - Resident Initialization for I8086

COMMENT *

--------- --- ---- -- --------- -----------

COPYRIGHT (C) 1982 BY MICROSOFT CORPORATION

--------- --- ---- -- --------- -----------

by Len Oorthuys Microsoft Corp.

*

;************************************************************************

;* *

;* NOTE: Any code linked after this module is discarded after *

;* Initialization of BASIC. *

;* *

;************************************************************************

INCLUDE GIO86U

.SALL

CPM86=0

TETRA=0 ;Save DS in DATSEG(defined in CS and

; used by interrupt routine).

INCLUDE MSDOSU

DSEG SEGMENT PUBLIC 'DATASG'

ASSUME DS:DSEG

EXTRN TEMP8:WORD,TXTTAB:WORD

DSEG ENDS

EXTRN NODSKS:NEAR,LRUN:NEAR,READY:NEAR

PUBLIC WORDS

WORDS: DB " Bytes free" ;WORDS

DB 0

PAGE

SUBTTL INITSA

PUBLIC INITSA

INITSA:

CALL NODSKS

CALL MAPINI ;Init the new memory map

MOV BX,WORD PTR TXTTAB

DEC BX

MOV WORD PTR 0[BX],0D

MOV BX,WORD PTR TEMP8 ;POINT TO START OF COMMAND LINE

MOV AL,BYTE PTR 0[BX] ;GET BYTE POINTED TO

OR AL,AL ;IF ZERO, NO FILE SEEN

JZ GREADY

JMP LRUN ;TRY TO RUN FILE

GREADY: JMP READY

PAGE

;BASVAR - Retrieve or Modify BASIC Internal Data Locations

;This routine provides a method to retrieve or modify certain BASIC internal

;data locations. This routine is provided as support for PEEK and

;POKE filsters. These data items have been documented to IBM GW BASIC users

;in the IBM Technical Reference Manual.

;

;Entry - AX = Value to set (if PSW.C set)

; BX = 0 for current program line number

; 1 for last program line containing an error

; 2 for address of user program text

; 3 for address of user variable table

; PSW.C set indicates to write the variable

; PSW.C reset indicates to read the variable

;Exit - AX = value of appropriate variable

; BX modified

;

DSEG SEGMENT PUBLIC 'DATASG'

EXTRN CURLIN:WORD,ERRLIN:WORD,TXTTAB:WORD,VARTAB:WORD

DSEG ENDS

PUBLIC BASVAR

BVTAB: DW OFFSET CURLIN

DW OFFSET ERRLIN

DW OFFSET TXTTAB

DW OFFSET VARTAB

BASVAR:

PUSHF

SHL BX,1 ;make word offset

POPF ;preserve PSW.C (input parameter)

MOV BX,WORD PTR BVTAB[BX] ;Get address of appropriate variable

JNB BASVRD ;Performing read function

MOV WORD PTR 0[BX],AX ;Perform write function

BASVRD: MOV AX,WORD PTR 0[BX] ;Perform read function

RET

PAGE

SUBTTL Initialization Support Routines

DSEG SEGMENT PUBLIC 'DATASG'

EXTRN CSWFLG:WORD,CSWSIZ:WORD,MSWFLG:WORD,MSWSIZ:WORD,NEWDS:WORD

EXTRN STKLOW:WORD,MEMSIZ:WORD,TOPMEM:WORD,SAVSEG:WORD,MAXMEM:WORD

EXTRN FILTAB:WORD

EXTRN FREFLG:WORD ;BYTES FREE message flag

DSEG ENDS

EXTRN CLEARC:NEAR,OMERR:NEAR

EXTRN SETCBF:NEAR ;OEM Set COM Buf (size & location)

EXTRN LINPRT:NEAR,STROUT:NEAR,CRDO:NEAR ;COM

EXTRN CPMMEM:NEAR

PUBLIC MAPCLC,MAPINI

;MAPINI - Set up the final memory map.

;Entry - NEWDS = final DS:

; MSWSIZ = final MAXMEM

;Exit - DS: and stack moved.

;

MAPINI:

;Move the stack to the end of the new memory map

POP BX ;Return address

CLI ;disable external interrupts

; while changing memory map

MOV AX,WORD PTR NEWDS

MOV SS,AX

MOV SP,WORD PTR MSWSIZ ;

PUSH BX ;Return address

;Move the data segment

MOV ES,AX ;NEWDS

XOR SI,SI

MOV CX,WORD PTR TXTTAB ;Amount of memory to move

SHR CX,1 ;In words

CLD

MOV BX,DS

CMP AX,BX ;Test for direction of copy

JB BLKCPY ;brif destination is below source

STD ;Copy up

MOV SI,WORD PTR TXTTAB ;starting from top

BLKCPY:

MOV DI,SI

REP MOVSW

;Set new data segment

MOV DS,AX ;NEWDS

EXTRN SEGINI:NEAR

CALL SEGINI

MOV AX,DS

MOV WORD PTR SAVSEG,AX ;For PEEK/POKE

STI ;enable external interrupts

;Insure zeros at TXTTAB

MOV BX,WORD PTR TXTTAB

MOV WORD PTR 0[BX],0D

MOV BYTE PTR 2[BX],LOW 0D ;Three zeros necessary

;Call CLEARC to set up stack and finalize the memory map

MOV AX,WORD PTR MSWSIZ

;Make sure that [TXTTAB]+<stack size>+32 does not overflow memory

MOV BX,WORD PTR TOPMEM

SUB BX,WORD PTR STKLOW ;BX=stack size

JBE GOMERR ;BRIF illegal stack(0 or less bytes)

NEG BX

ADD BX,AX ;BX=new stack bottom

JNB GOMERR ;BRIF MSWSIZ is less than stack size

SUB BX,32D ;Leave a little room for a program

JB GOMERR ;BRIF no room left

CMP BX,WORD PTR TXTTAB ;Is new MAXMEM big enough?

JBE GOMERR ;BRIF new MAXMEM smaller than data area

MAXRQ1: MOV BX,AX

SUB BX,WORD PTR MAXMEM ;Calc. seg. size difference

MOV WORD PTR MAXMEM,AX ;Memory request

ADD WORD PTR TOPMEM,BX

ADD WORD PTR STKLOW,BX

ADD WORD PTR FILTAB,BX

ADD WORD PTR MEMSIZ,BX

POP BX ;Return address (BX saved by CLEARC)

CALL CLEARC

PUSH BX ;Return address (BX saved by CLEARC)

;Set up program segment prefix

MOV DX,DS

MOV AH,LOW 38D ;Function ^H26

INT 33D ;MSDOS function request

;Print free bytes message

TEST BYTE PTR FREFLG,LOW 255D ;BYTES FREE message flag

JNZ MAPINX ;Exit - message not to be printed

MOV BX,WORD PTR MEMSIZ

SUB BX,WORD PTR TXTTAB

DEC BX

DEC BX

CALL LINPRT ;PRINT # OF BYTES FREE

MOV BX,OFFSET WORDS ;TYPE THE HEADING

CALL STROUT ;"BYTES FREE"

CALL CRDO ;PRINT CARRIAGE RETURN

MAPINX: RET

GOMERR: JMP OMERR

PAGE

SUBTTL End of the New CS:

;All code loaded after this label is resident only until routine MAPINI

;initializes the new memory map.

CSEND:

;MAPCLC - Calculate the final memory map limits.

;Entry - CSWFLG = Flag nonzero when /C: option exists

; CSWSIZ = /C: option size

; MSWFLG = Flag nonzero when /M: option exists

; MSWSIZ = /C: option size

;Exit - NEWDS = Final DS: address

; MSWSIZ = Highest memory address (future MAXMEM)

;

MAPCLC:

;Validate/get COM buffer size

MOV DX,OFFSET CSEND ;Location of COM buffer (New end of CS:)

ADD DX,15D ;Round to next higher paragraph

MOV CL,LOW 4D

SHR DX,CL

MOV CX,CS

ADD CX,DX ;Segment offset of COM buffer

MOV DX,WORD PTR CSWSIZ ;Segment size request

TEST BYTE PTR CSWFLG,LOW 255D ;Was there a /C: opt - PSW.Z for SETCBF

CALL SETCBF ;Report buffer size/loc

JB GOMERR ; & validate size

MOV WORD PTR CSWSIZ,DX ;COM buffer size

;Calculate NEWDS (New DS:)

; DX - COM buffer size

; NEWDS = (D+15/16) + DS:

ADD DX,15D ;Round off to paragraph

SHR DX,1

SHR DX,1

SHR DX,1

SHR DX,1

ADD DX,CX ;Skip COM buffer

JO GOMERR

MOV WORD PTR NEWDS,DX

;Validate the /M option or calculate the maximum possible MAXMEM

;1. Calcualte maximum MAXMEM based on the NEWDS

;2. If there was no /M option then goto 4

;3. Compare /M to the maximum and declare an error if /M is larger

;4. Save the new memory size as MSWSIZ

PUSH BX ;Save text pointer

MOV BX,WORD PTR CPMMEM

SUB BX,DX ;Avail paragraphs

JB GOMERR

MOV DX,OFFSET 65535D/16D ;Max usable paragraphs

CMP BX,DX

JB MAXREQ ;More than enough

MOV BX,DX

MAXREQ: MOV CL,LOW 4D

SHL BX,CL ;DX has valid maximum bytes

TEST BYTE PTR MSWFLG,LOW 255D

JZ NOMOPT ;No memory option

MOV DX,WORD PTR MSWSIZ ;Get /M: size

CMP BX,DX

JB GOMERR ;Not enough for request

MOV BX,DX

NOMOPT: MOV WORD PTR MSWSIZ,BX ;New MAXMEM

; ADDI BX,^D256

; JB MAXRQ1 ;BRIF very large MAXMEM, value OK

; CMP BX,TXTTAB ;Is new MAXMEM big enough?

; JBE GOMERR ;BRIF new MAXMEM smaller than data area

POP BX

RET

;SEGOFF Convert end of memory segment to offset from current DS

;

; On entry: BX=last segment in memory

; DS=current data segment

;

; On exit: BX=offset from current segment to paragraph specified by BX

; Other registers unchanged, flags modified

;

PUBLIC SEGOFF

EXTRN OMERR:NEAR

SEGOFF: PUSH CX

MOV CX,DS

SUB BX,CX ;[BX]=number of paragraphs free for DSEG

JBE SGOFER ;BRIF last segment is less than current

MOV CX,7777O ;[CX]=max num of paragraphs BASIC could use

CMP BX,CX

JBE LESS64 ;Brif less than 64k bytes available

MOV BX,CX ;don't need more than 64k bytes

LESS64:

MOV CL,LOW 4

SHL BX,CL ;convert paragraphs to bytes

POP CX ;restore caller's CX

RET

SGOFER: JMP OMERR

CSEG ENDS

END