Subversion Repositories SvarDOS

; WMINICRT - minimal runtime for (Open) Watcom C to generate DOS .COM files
;
; The default behaviour of the runtime is:
;   - sets up a stack of 400H bytes
;   - releases additional memory beyond stack to DOS
;   - panics on initialization, if not enough memory for stack size
;   - panics if running out of stack during execution
;
; WASM definitions:
;   STACKSIZE=<value>     define stack size other than 400h
;   NOSTACKCHECK          do not assemble __STK function
;   STACKSTAT             remember the minimum SP, maintained by __STK__
;                         and exported via _stack_low_.
;
; To build an executable without build- and linker scripts run:
;   wasm startup.asm
;   wcc -0 -bt=dos -ms -os -zl your_c_file.c
;   wlink system dos com file startup,your_c_file
; To change the stack size, add -DSTACKSIZE=<value> to the wasm call
;
; To compile without stack checking:
;   a) compile this startup file with wasm -DNOSTACKCHECK startup.asm
;   b) call the C compiler with -s flag
;
; To build a debug version of your program:
;   wasm -d1 startup.asm
;   wcc -bt=dos -ms -d2 -zl your_c_file.c
;   wlink system dos com debug all option map file startup,your_c_file
;
; TODO:
;   - display stack statistics on program termination if STACKSTAT is enabled
;   - proper Makefiles
;   - many more (optional) things while keeping it small :-)

.8086

IFNDEF STACKSIZE
STACKSIZE = 400h
ENDIF

      DGROUP group _TEXT,_DATA,CONST,CONST2,_BSS,_STACK

      extrn   "C",main : near

      public _cstart_, _small_code_

_TEXT segment word public 'CODE'
      org   100h

_small_code_ label near

_cstart_ proc
      ; DOS puts the COM program in the largest memory block it can find
      ; and sets SP to the end of this block. On top of that, it reserves
      ; the entire memory (not only the process' block) to the program, which
      ; makes it impossible to allocate memory or run child processes.
      ; for this reasons it is beneficial to resize the memory block we occupy
      ; into a more reasonable value

    @verify_stack_size:
      cmp sp,offset DGROUP:_stack_end_
      ja @resize_mem
      mov dx,offset @memerr
      jmp _panic_
      @memerr db 'MEMERR$'

      ; step 2: resize our memory block to sp bytes (ie. sp/16 paragraphs)
    @resize_mem:
      mov sp,offset DGROUP:_stack_end_
      IFDEF STACKSTAT
        mov [_stack_low_],sp
      ENDIF STACKSTAT
      mov ah,4ah
      mov bx,sp
      add bx,0fh
      shr bx,1
      shr bx,1
      shr bx,1
      shr bx,1
      int 21h

      ; clear _BSS to be ANSI C conformant
      mov di,offset DGROUP:_BSS
      mov cx,offset DGROUP:_STACK
      sub cx,di
      shr cx,1
      xor ax,ax
      cld
      rep stosw

      call main
      mov ah,4ch
      int 21h
_cstart_ endp

_panic_ proc
      ; output error message in DX, then terminate with FF
      mov ah,9
      int 21h
      mov ax,4cffh      ; terminate if not enough stack space
      int 21h
_panic_ endp

      IFNDEF NOSTACKCHECK

public __STK
__STK proc
      ; ensures that we have enough stack space left. the needed bytes are
      ; given in AX. panics if stack low.
      sub ax,sp         ; subtract needed bytes from SP
      neg ax            ; SP-AX = -(AX-SP)
      cmp ax,offset DGROUP:_STACK - 2 ; -2 is to compensate for __STK ret addr
      jae @l1           ; enough stack => return, else panic
      int 3             ; trap into debugger
      mov dx,offset @stkerr
      add sp,200h       ; make sure we have enough stack to call DOS
      jmp _panic_
      @stkerr db 'STKERR$'
@l1:
      IFDEF STACKSTAT   ; update lowest stack pointer if statistics enabled
        cmp [_stack_low_],ax
        jbe @r
        mov [_stack_low_],ax
      ENDIF STACKSTAT
@r:
      ret
__STK endp

      ENDIF

_DATA segment word public 'DATA'
_DATA ends

CONST segment word public 'DATA'
CONST ends

CONST2 segment word public 'DATA'
CONST2 ends

_BSS  segment word public 'BSS'
      IFDEF STACKSTAT
        public _stack_low_
        _stack_low_:  dw 1 dup(?)
      ENDIF STACKSTAT
_BSS  ends

; stack definition, available memory is checked at runtime
; defined as segment so that linker may detect .COM size overflow
_STACK segment para public 'TINY_STACK'
public _stack_end_
      db STACKSIZE dup(?)
_stack_end_:
_STACK ends

_TEXT ends

      end _cstart_