OS_Develop/dos_compilers
OS_Develop/dos_compilers
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
fc495a9ffd
dos_compilers/Manx Aztec C86 v340a/SRC/DOS20.ARC

3354 lines
57 KiB
Plaintext
Raw Normal View History

Manx Aztec C v3.40a
2024-07-01 15:45:15 +02:00
access.c
#include <stat.h>
#include <errno.h>
access(path, amode)
char *path;
{
struct {
char rsvd[21];
char attr;
long time;
long size;
char name[13];
} sbuf;
register char *cp;
_sys(0x1a,&sbuf);
if (_sys(0x4e,path,~ST_VLABEL) == -1) {
if (errno == ENOMORE)
errno = ENOENT;
return -1;
}
if (amode & 02 && sbuf.attr & ST_RDONLY) {
errno = EACCES;
return -1;
}
if (amode & 01) { /* execute or search */
if ((sbuf.attr & ST_DIRECT) == 0) {
for (cp = sbuf.name ; *cp ;)
if (*cp++ == '.')
break;
if (strcmp(cp,"EXE") != 0 && strcmp(cp,"COM") != 0
&& strcmp(cp,"BAT") != 0) {
errno = EACCES;
return -1;
}
}
}
return 0;
}
asctime.c
/* Copyright (C) 1984 by Manx Software Systems */
#include <time.h>
char *
asctime(tm)
struct tm *tm;
{
static char days[7][4] = {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
static char months[12][4] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
static char buffer[26];
sprintf(buffer, "%s %s %2d %02d:%02d:%02d %4d\n",
days[tm->tm_wday], months[tm->tm_mon], tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_year+1900);
return buffer;
}
bdos.asm
;Copyright (C) 1983 by Manx Software Systems
; :ts=8
include lmacros.h
procdef bdos,<<func,word>,<dxval,word>,<cxval,word>>
push es
mov ax,func
test ah,ah
jnz valok
xchg ah,al
valok:
mov dx,dxval
mov cx,cxval
int 21H
mov dx,es
pop es
and ax,0ffH
pret
pend bdos
finish
end
sbegin.asm
; Copyright (C) 1983 1984 by Manx Software Systems
; :ts=8
include lmacros.h
codeseg segment para public 'code'
public $MEMRY
public _mbot_, _sbot_, _mtop_,_lowwater_
dataseg segment para public 'data'
extrn _Uorg_:byte,_Uend_:byte
$MEMRY dw offset _Uend_
public errno_
errno_ dw 0
public _dsval_,_csval_
_dsval_ dw 0
_csval_ dw 0
_mbot_ dw 0
_sbot_ dw 0
_mtop_ dw 0
_lowwater_ dw -1
public _PSP_
_PSP_ dw 0
extrn _STKSIZ_:word,_HEAPSIZ_:word
extrn _STKLOW_:word,_STKRED_:word
dataseg ends
exitad dw 0
exitcs dw 0
assume cs:codeseg,ds:dataseg,es:dataseg,ss:dataseg
ifdef FARPROC
extrn Croot_:far
else
extrn Croot_:near
endif
public $begin
public _exit_
$begin proc far
mov bp,dataseg
test bp,bp
jnz notcom
mov bp,ds
notcom:
mov exitcs,ds
mov bx,[2] ;get top segment
sub bx,bp ;compute size of Data seg
cmp bx,4096 ;check if greater than 64K
jbe smallseg
lea bx,[bp+4096] ;end address of segment (paragraphs)
mov ax,es
sub bx,ax ;compute length of segment
mov ah,4aH ;SETBLOCK system call
int 21H
mov bx,4096
smallseg:
mov es,bp
mov es:_PSP_,ds
mov cl,4
shl bx,cl
cmp es:_STKLOW_,0
je setstk ;stack goes above heap
mov ax,es:_STKRED_ ;stack goes below heap
shl ax,1 ;allow at least twice the RED zone size
mov bx,es:_STKSIZ_
shl bx,cl ;compute requested stack size
cmp bx,ax ;but don't allow too little
ja sizeok
mov bx,ax
sizeok:
add bx, offset _Uend_
setstk:
cli
mov ss,bp
mov sp,bx
sti
;
test bx,bx
jnz oksav
mov bx,0ffffh
oksav:
mov es:_mtop_,bx
; now adjust heap size if necessary
cmp es:_STKLOW_,0 ; can't do it unless heap above stack
je heapdone
mov si,es:_HEAPSIZ_
mov ax,bx
inc ax
mov es:$MEMRY,ax ; start of heap for later
shl si,cl
add bx,si
jnc heapok
mov bx,0ffffh
heapok:
mov es:_mtop_,bx ; and save as _mtop_
add bx,15
shr bx,cl ; convert to paragraph form
mov ax,es
add bx,ax ; calculate paragraph address of last byte
mov ax,ds ; now take the paragrph form and
sub bx,ax ;compute length of segment
mov bp,es ;save ES
mov es,ax
mov ah,4aH ;SETBLOCK system call
int 21H
jnc heapdone
mov ax,254
jmp badexit
heapdone:
mov es,bp ;restore ES
cld
; clear uninitialized data
mov di,offset _Uorg_
mov cx,offset _Uend_
sub cx,di
inc cx
shr cx,1
jcxz noclear
sub ax,ax
rep stosw
noclear:
;
mov es,[2cH] ;get enviroment segment
sub di,di
mov cx,7fffH
arglook:
mov ah,es:byte ptr [di]
cmp ah,'=' ;look for null named env. string
je found_args
test ah,ah
jz no_args
repne scasb ;look for null byte
jz arglook
no_args:
mov cl,[80H]
sub ch,ch
mov si,81H
mov ax,1
jmp short mov_args
;
found_args:
sub ax,ax
stosb ;zap and skip over '='
mov si,di
mov di,es
mov ds,di
mov_args:
push ax ;first arg # for Croot
mov es,bp ;reload ES with our real dataseg
mov di,es:$MEMRY
push di ;argp for Croot
jcxz cpy_done
cpy_args: ;copy argument string to work buffer
lodsb
test al,al
jz cpy_done
stosb
loop cpy_args
cpy_done:
sub al,al
stosb ;null terminate string
mov ds,bp ;set DS, now DS, SS, ES are equal
inc di
and di,0fffeH ;adjust to word boundary
mov $MEMRY,di ;save memory allocation info for sbrk()
mov _mbot_,di
mov _sbot_,offset _Uend_
cmp _STKLOW_,0
jnz nostk
mov _sbot_,di
nostk:
mov ax,_sbot_
add ax,_STKRED_
mov _sbot_,ax
mov _dsval_,ds
mov _csval_,cs
call Croot_ ;Croot(argp, first)
jmp short exits
_exit_:
pop ax
pop ax ;fetch return code
ifdef FARPROC
pop ax
exit label far
else
exit:
endif
exits:
badexit:
mov ah,4cH
int 21H
jmp dword ptr exitad
$begin endp
retip dw 0
retcs dw 0
public $dbgentry
$dbgentry proc far
pop cs:retip
pop cs:retcs ; save return address into debugger
pop ds ;set DS
call caller
jmp dword ptr cs:retip ; return to debugger
$dbgentry endp
caller proc
push di ;CS value of local function
push si ;IP value call local function
db 0cbH ;far return instruction
caller endp
codeseg ends
end $begin
chmod.asm
; :ts=8
;Copyright (C) 1984 by Manx Software Systems
include lmacros.h
dataseg segment word public 'data'
extrn errno_:word
dataseg ends
procdef chmod, <<filnam,ptr>,<attr,word>>
pushds
mov ax,4301h
ldptr dx,filnam,ds
mov cx,attr
int 21h
popds
jnc retok
mov ds:errno_,ax
mov ax,-1
pret
retok:
sub ax,ax
pret
pend chmod
finish
end
croot.c
/* Copyright (C) 1981,1982, 1983 by Manx Software Systems */
#include "errno.h"
#include "fcntl.h"
static char **Argv;
static int Argc;
noper()
{
return 0;
}
int (*cls_)() = noper;
extern char _ioflg[];
Croot(cp, first)
register char *cp;
{
register char **cpp;
char *sbrk();
#ifdef REDIR
register int k;
register char *fname;
#endif
_ioflg[0] = isatty(0); /* set flag for i/o routines */
_ioflg[1] = isatty(1); /* set flag for i/o routines */
_ioflg[2] = isatty(2); /* set flag for i/o routines */
Argv = (char **)sbrk((first+1)*sizeof(char *));
Argv[0] = "";
cpp = &Argv[Argc = first];
for (;;) {
while (*cp == ' ' || *cp == '\t')
++cp;
if (*cp == 0)
break;
#ifdef REDIR
if (*cp == '>') { /* redirect output */
k = 1;
goto redirect;
} else if (*cp == '<') { /* redirect input */
k = 0;
redirect:
while (*++cp == ' ' || *cp == '\t')
;
fname = cp;
while (*++cp)
if (*cp == ' ' || *cp == '\t') {
*cp++ = 0;
break;
}
close(k);
if (k)
k = creat(fname, 0666);
else
k = open(fname, O_RDONLY);
if (k == -1)
redir_err(fname);
} else
#endif
{
*cpp++ = cp;
Argc++;
if (sbrk(sizeof(char *)) == (char *)-1) {
write(2, "Too many args.", 14);
_exit(200);
}
while (*++cp)
if (*cp == ' ' || *cp == '\t') {
*cp++ = 0;
break;
}
}
}
*cpp = 0;
main(Argc,Argv);
exit(0);
}
#ifdef REDIR
static redir_err(name)
char *name;
{
char buff[200];
strcpy(buff, "Can't open file for redirection: ");
strcat(buff, name);
strcat(buff, "\n");
write(2, buff, strlen(buff));
exit(10);
}
#endif
exit(code)
{
(*cls_)();
_exit(code);
}
crt0.asm
; Copyright (C) 1983 1984 by Manx Software Systems
; :ts=8
PGROUP group @CODE,PROG
@CODE segment byte public 'CODE'
@CODE ends
PROG segment byte public 'CODE'
PROG ends
DGROUP group @DATAB,DATA,@DATAC,@DATAI,@DATAT,@DATAU,@DATAV,@STACK
@DATAB segment para public 'DATAB'
@DATAB ends
DATA segment word public 'DATA'
db 'Aztec C86 version 3.40a',0
even
public _Dorg
_Dorg label byte
DATA ends
@DATAC segment word public 'DATAC'
@DATAC ends
@DATAI segment word public 'DATAI'
@DATAI ends
@DATAT segment word public 'DATAT'
public _Dend
_Dend label byte
public _Uorg
_Uorg label byte
@DATAT ends
@DATAU segment word public 'DATAU'
@DATAU ends
@DATAV segment word public 'DATAV'
public _Uend
_Uend label byte
@DATAV ends
@STACK segment para stack 'STACK'
First db 2048 dup (?)
@STACK ends
end
csread.asm
; Copyright (C) 1983, 1984 by Manx Software Systems
; :ts=8
include lmacros.h
dataseg segment word public 'data'
extrn errno_:word
dataseg ends
procdef _csread,<<fd,word>,<addr,fptr>,<len,word>>
; _csread(fd, char *addr, len)
; read data into code segment
mov bx,fd
push ds
ifdef FARPROC
lds dx,addr
else
mov dx,addr
endif
mov cx,len
ifndef FARPROC
mov ax,cs
mov ds,ax
endif
mov ah,3fH
int 21H
pop ds
jnc ret_ok
mov ds:errno_,ax
mov ax,-1
ret_ok:
pret
pend _csread
finish
end
ctime.c
/* Copyright (C) 1984 by Manx Software Systems */
#include <time.h>
char *
ctime(clock)
long *clock;
{
struct tm *tm;
tm = localtime(clock);
return asctime(tm);
}
dioctl.asm
; Copyright (C) 1983 by Manx Software Systems
; :ts=8
include lmacros.h
dataseg segment word public 'data'
extrn errno_:word
dataseg ends
procdef _ioctl, <<fd,word>,<req,byte>,<arg,ptr>,<len,word>>
; _ioctl(fd, req, arg[, len])
mov bx,fd
mov ah,44H
mov al,req
cmp al,0
je getinfo
cmp al,1
je setinfo
cmp al,6
jge getstat
pushds
ldptr dx,arg,ds
mov cx,len
int 21H
popds
jnc xret_ok
mov ds:errno_,ax
mov ax,-1
xret_ok:
pret
;
doint proc near
int 21H
jnc ret_ok
mov ds:errno_,ax
mov ax,-1
ret_ok:
ret
doint endp
;
getstat:
call doint
pret
;
getinfo:
call doint
jc err
ldptr bx,arg,es
ifdef LONGPTR
mov es:[bx],dx
else
mov ds:[bx],dx
endif
sub ax,ax
err:
pret
;
setinfo:
ldptr bx,arg,es
ifdef LONGPTR
mov dl,es:[bx]
else
mov dl,ds:[bx]
endif
sub dh,dh
mov bx,fd
call doint
jc err
sub ax,ax
pret
pend _ioctl
finish
end
dos.asm
; Copyright (C) 1983, 1984 by Manx Software Systems
; :ts=8
include lmacros.h
dataseg segment para public 'data'
extrn errno_:word
dataseg ends
assume ds:dataseg
procdef dos,<<func,word>,<bxval,word>,<cxval,word>,<dxval,word>,<dival,word>,<sival,word>>
; dos(ax,bx,cx,dx,di,si)
push di
push si
ifndef LONGPTR
mov ax,ds
mov es,ax
endif
mov ax,func
test ah,ah
jnz skip
xchg ah,al
skip:
mov bx,bxval
mov cx,cxval
mov dx,dxval
mov di,dival
mov si,sival
int 21H
jnc ret_ok
mov errno_,ax
mov ax,-1
ret_ok:
pop si
pop di
pret
pend dos
finish
end
dostime.asm
; Copyright (C) 1984 by Manx Software Systems
; :ts=8
include lmacros.h
codeseg segment byte public "code"
days dw -1, 30, 58, 89, 119, 150, 180, 211, 242, 272, 303, 333
codeseg ends
procdef dostime, <<arg,ptr>>
push es
push si
;
mov ah,2aH
int 21h
ldptr bx,arg,es
sub cx,1900
ifndef LONGPTR
mov ds:word ptr 10[bx],cx ;year - 1900
else
mov es:word ptr 10[bx],cx ;year - 1900
endif
sub ah,ah
mov al,dh
dec al
ifndef LONGPTR
mov ds:word ptr 8[bx],ax ;month
else
mov es:word ptr 8[bx],ax ;month
endif
mov al,dl
ifndef LONGPTR
mov ds:word ptr 6[bx],ax ;day of month
else
mov es:word ptr 6[bx],ax ;day of month
endif
;
mov ah,2cH
int 21H
ldptr bx,arg,es
sub ah,ah
mov al,ch
ifndef LONGPTR
mov ds:word ptr 4[bx],ax ;hour
mov al,cl
mov ds:word ptr 2[bx],ax ;minute
mov al,dh
mov ds:word ptr [bx],ax ;seconds
mov al,dl
mov ds:word ptr 18[bx],ax ;1/100 seconds
;
sub ax,ax
mov si,ds:word ptr 8[bx]
cmp si,2
jb noleap
test ds:byte ptr 10[bx],3
jnz noleap
inc ax
noleap:
shl si,1
add ax,cs:days[si]
add ax,ds:word ptr 6[bx]
mov ds:word ptr 14[bx],ax ;day of year
;
mov si,ds:word ptr 10[bx]
else
mov es:word ptr 4[bx],ax ;hour
mov al,cl
mov es:word ptr 2[bx],ax ;minute
mov al,dh
mov es:word ptr [bx],ax ;seconds
mov al,dl
mov es:word ptr 18[bx],ax ;1/100 seconds
;
sub ax,ax
mov si,es:word ptr 8[bx]
cmp si,2
jb noleap
test es:byte ptr 10[bx],3
jnz noleap
inc ax
noleap:
shl si,1
add ax,cs:days[si]
add ax,es:word ptr 6[bx]
mov es:word ptr 14[bx],ax ;day of year
;
mov si,es:word ptr 10[bx]
endif
add ax,si
dec si
shr si,1
shr si,1
add ax,si
inc ax
sub dx,dx
mov cx,7
div cx
ifndef LONGPTR
mov ds:word ptr 12[bx],dx ;day of week
;
mov ds:word ptr 16[bx],0 ;say no D.S.T. for now
else
mov es:word ptr 12[bx],dx ;day of week
;
mov es:word ptr 16[bx],0 ;say no D.S.T. for now
endif
pop si
pop es
pret
pend dostime
finish
end
dup.asm
; Copyright (C) 1984 by Manx Software Systems
; :ts=8
include lmacros.h
dataseg segment word public 'data'
extrn errno_:word
dataseg ends
assume ds:dataseg
procdef dup,<<ofd,word>>
; dup(ofd) : duplicate file descriptor
; if ok, returns new fd. if error, returns -1.
mov ah,45h
dupx:
mov bx,ofd
int 21H
jnc ret_ok
mov errno_,ax
mov ax,-1
ret_ok:
pret
pend dup
;
procdef fdup,<<oofd,word>,<nfd,word>>
; fdup(ofd, nfd): force dup of ofd into nfd
; If nfd is open it will be closed.
; if ok, returns nfd; if error, returns -1
mov cx,nfd
mov ah,46h
jmp dupx
pend fdup
finish
end
exec.asm
; Copyright (C) 1984 by Manx Software Systems
; :ts=8
include lmacros.h
ifdef FARPROC
extrn _sigfix_:far
else
extrn _sigfix_:near
endif
;
e_magic equ 0
e_used equ 2 ;number of bytes used in final sector of file
e_pages equ 4 ;size of file in 512-byte pages
e_nreloc equ 6 ;number relocation table items
e_hsize equ 8 ;size of header in 16-byte paragraphs
e_min equ 10 ;minimum # of para required above program
e_max equ 12 ;maximum # of para " " "
e_ss equ 14 ;offset of stack segment in load module
e_sp equ 16 ;initial SP value
e_csum equ 18 ;negative sum of all words in the file
e_ip equ 20 ;starting IP for program
e_cs equ 22 ; " CS "
e_freloc equ 24 ;offset of first relocation item
e_ovly equ 26 ;overlay number
;
ldrsize equ 1024
header equ ldrsize-30
reloc equ 26
startad equ 0
;
dataseg segment word public 'data'
extrn _PSP_:word
dataseg ends
;
;exec(fd,cline,fcb1,fcb2,header)
; NOTE: This function never returns, even if the exec
; fails.
;
procdef exec,<<fd,word>,<cline,ptr>,<fcb1,ptr>,<fcb2,ptr>,<head,ptr>>
;
; copy cmd line and fcb's into PSP
;
load proc far ;so returns are far
push ds
call _sigfix_ ;restore int 22,23 vectors
mov es,ds:_PSP_ ;fetch segment of PSP
ldptr si,cline,ds
mov di,80h
mov cx,64
rep movsw ;copy command line
ldptr si,fcb1,ds
mov di,5ch
mov cx,8
rep movsw ;copy fcb1
ldptr si,fcb2,ds
mov cx,8
rep movsw ;copy fcb2
;
mov bx,0ffffh ;ask for all of memory
mov ah,4ah
int 21h
mov ah,4ah ;then ask for what we can get
int 21h
;
mov dx,fd ;file handle
ldptr si,head,ds ;exe header from file
cmp ds:word ptr [si+e_magic],5a4dh ;check magic #
je exefile
mov bp,bx ;compute new SP
cmp bp,4096 ;check size of segment
jbe smallstk
mov bp,4096
smallstk:
mov cx,4
shl bp,cl ;new SP
;
mov cx,es
add bx,cx ;end of our segment
sub bx,8 ;get 128 bytes for loader and stack
mov es,bx
pop si ; get old ds value back
mov ss,bx
mov sp,128
push si ; push old ds on stack for later use
;
mov cx,cs
mov ds,cx
mov si,offset com_loader
sub di,di
mov cx,offset com_ldend
sub cx,si
rep movsb
;
mov bx,dx ;handle into bx for io calls
sub cx,cx
sub dx,dx
mov ax,4200H
int 21H ;rewind file
;
mov dx,100H ;address to read data into
lea cx,[bp-256] ;byte count to read in
pop ds
mov ax,ds:_PSP_ ;segment of PSP
mov ds,ax
mov es,ax
push ss
sub ax,ax
push ax
mov ah,3fH
ret
;
; this block of code is moved to the top of available memory
; and jumped to with the registers for a read call setup
;
com_loader:
int 21h
jnc ok
mov ax,4cfeh
int 21h
ok:
mov ah,3eH
int 21h ;close the file
mov ax,ds
mov ss,ax
mov sp,bp
push ax ;push new cs
mov ax,100h
push ax ;push new ip
ret
com_ldend:
;
;
exefile:
mov cx,es
add bx,cx ;end of our segment
sub bx,ldrsize/16 ;get mem for loader, header, and stack
mov es,bx
mov di,header
mov cx,13
rep movsw ;copy 26 byte file header
;
pop si ; get old ds value
mov ss,bx
mov sp,header
push si ; push old ds value on new stack for later use
;
mov cx,cs
mov ds,cx
mov si,offset exe_loader
sub di,di
mov cx,offset exe_ldend
sub cx,si
rep movsb
;
pop ds
mov ax,ds:_PSP_ ;segment of PSP
push ax ;ES, DS value for program
add ax,10h
mov ds,ax ;place to load program
mov bp,ax
mov bx,dx ;get handle into bx for int 21h
;
mov di,header
mov dx,ss:e_hsize[di] ;compute offset of program
sub ax,ax
mov cl,4
lshift:
shl dx,1
rcl ax,1
loop lshift
mov cx,ax
mov ax,4200H
int 21h ;lseek to load module
jc punt
;
mov si,ss:e_pages[di]
mov cl,5
shl si,cl ;# paragraphs in file
sub si,ss:e_hsize[di] ;now, # para in program
;
push ss ;CS for loader
sub ax,ax
push ax ;IP for loader
ret ;far return to code at top of mem
;
; this code is moved to the top of our segment and jumped to
; with the following registers setup:
; bx - file handle of program
; ds, bp - where to load the program
; di - points to the exe header
; si - # para to read in
; PSP address pushed onto stack
;
exe_loader:
mov ah,3fH
mov cx,1024
sub dx,dx
int 21h
jc punt
test ax,ax
jz load_done
mov ax,ds
add ax,64
mov ds,ax
sub si,64
ja exe_loader
;
load_done:
mov ax,cs
mov ds,ax
cmp word ptr e_nreloc[di],0
jz reloc_done
mov dx,e_freloc[di]
sub cx,cx
mov ax,4200H
int 21H ;lseek to relocation info
jc punt
relocate:
lea dx,reloc[di]
mov cx,4
mov ah,3fH
int 21H
jc punt
cmp ax,4
jne punt
mov si,reloc[di]
mov ax,reloc+2[di]
add ax,bp
mov es,ax
add es:[si],bp
dec word ptr e_nreloc[di]
jnz relocate
reloc_done:
mov ah,3eH
int 21h ;close file
add e_ss[di],bp ;relocate stack segment
add e_cs[di],bp ;relocate starting CS
pop ax ;get PSP address before changing stack
mov ss,e_ss[di]
mov sp,e_sp[di]
mov ds,ax
mov es,ax
jmp cs:dword ptr e_ip[di]
punt:
mov ax,4cfeh
int 21h
exe_ldend:
load endp
pend exec
finish
end
execl.c
/* Copyright (C) 1983, 1984 by Manx Software Systems */
execl(path, args)
char *path, *args;
{
return execv(path, &args);
}
execlp.c
/* Copyright (C) 1983, 1984 by Manx Software Systems */
execlp(name, args)
char *name, *args;
{
return execvp(name, &args);
}
execv.c
/* Copyright (C) 1983, 1984 by Manx Software Systems */
#define EXEMAGIC 0x5a4d
struct exehead { /* MS-dos .exe file header */
int e_magic;
int e_used; /* number of bytes used in final sector of file */
int e_pages; /* size of file in 512-byte pages */
int e_nreloc; /* number relocation table items */
int e_hsize; /* size of header in 16-byte paragraphs */
int e_min; /* minimum # of para required above program */
int e_max; /* maximum # of para " " " */
unsigned e_ss; /* offset of stack segment in load module */
unsigned e_sp; /* initial SP value */
unsigned e_csum; /* negative sum of all words in the file */
unsigned e_ip; /* starting IP for program */
unsigned e_cs; /* " CS " */
int e_freloc; /* offset of first relocation item */
int e_ovly; /* overlay number */
};
execv(path, argv)
char *path, **argv;
{
register char *cp, *xp;
int i, fd;
char buffer[130];
char fcb1[16], fcb2[16];
struct exehead header;
if ((fd = open(path,0)) == -1)
return -1;
if (read(fd, &header, sizeof header) != sizeof header)
header.e_magic = 0;
cp = buffer+1;
i = 1;
if (*argv) {
++argv; /* skip arg0, used for unix (tm) compatibility */
while (xp = *argv++) {
if (i == 1)
fcbinit(xp, fcb1);
else if (i == 2)
fcbinit(xp, fcb2);
*cp++ = ' ';
while (*xp) {
if (cp >= buffer+128)
goto done;
*cp++ = *xp++;
}
++i;
}
}
done:
buffer[0] = cp - (buffer+1);
return exec(fd, buffer, fcb1, fcb2, &header);
}
execvp.c
/* Copyright (C) 1983, 1984 by Manx Software Systems */
execvp(name, argv)
char *name, **argv;
{
register char *cp, *xp;
char *getenv(), path[64];
tryexec("", name, argv);
if ((cp = getenv("PATH")) != 0) {
while (*cp) {
xp = path;
while (*cp) {
if (*cp == ';') {
++cp;
break;
}
*xp++ = *cp++;
}
*xp = 0;
if (path[0] != 0)
tryexec(path, name, argv);
}
}
return -1;
}
static
tryexec(dir, name, argv)
char *dir, *name, **argv;
{
char newname[64];
register char *cp;
char *strchr(), *strrchr();
strcpy(newname, dir);
if (((cp = strchr(newname, '/')) || (cp = strchr(newname, '\\')))
&& *(cp+1) != 0)
strcat(newname, "/");
strcat(newname, name);
if (strchr(name, '.') == 0) {
strcat(newname, ".com");
execv(newname, argv);
strcpy(strrchr(newname,'.'), ".exe");
}
execv(newname, argv);
}
fcbinit.asm
;Copyright (C) 1983 by Manx Software Systems
; :ts=8
include lmacros.h
procdef fcbinit, <<jname,ptr>,<fcb,ptr>>
pushds
push di
push si
ifndef LONGPTR
mov di,ds
mov es,di
endif
ldptr si,jname
ldptr di,fcb
mov ax,2900H ; issue parse filename call
int 21H
and ax,0ffH
cmp es:byte ptr 1[di],' '
jne nameok
mov ax,-1
nameok:
pop si
pop di
popds
pret
pend fcbinit
finish
end
fexec.asm
; Copyright (C) 1984 by Manx Software Systems
; :ts=8
include lmacros.h
dataseg segment para public 'data'
param equ this word
env dw ?
cline dw ?,?
fcb1 dw ?,?
fcb2 dw ?,?
extrn errno_:word
dataseg ends
assume ds:dataseg
save_ss dw 0
save_sp dw 0
procdef fexec,<<filname,ptr>,<enva,word>,<clinea,ptr>,<fcb1a,ptr>,<fcb2a,ptr>>
; char *fexec(name,env,cline,fcb1,fcb2)
;
push si
push di
pushf
push [030H]
push [02EH]
push ds
push es
mov cs:save_ss,ss
mov cs:save_sp,sp
;
; set up parameter block for exec call
;
mov ax,enva
mov env,ax
ifndef LONGPTR
mov ax,ds
mov es,ax
endif
ldptr ax,clinea,es
mov cline,ax
mov cline+2,es
ldptr ax,fcb1a,es
mov fcb1,ax
mov fcb1+2,es
ldptr ax,fcb2a,es
mov fcb2,ax
mov fcb2+2,es
;
mov ax,ds
mov es,ax
mov bx,offset param
ldptr dx,filname,ds ;name of file to exec
mov ax,04b00H
int 21h
mov ss,cs:save_ss
mov sp,cs:save_sp
pop es
pop ds
jnc noerror
mov errno_,ax
mov ax,-1
jmp short done
noerror:
sub ax,ax
done:
pop [02EH]
pop [030H]
popf
pop di
pop si
pret
pend fexec
finish
end
fexecl.c
/* Copyright (C) 1983, 1984 by Manx Software Systems */
fexecl(path, args)
char *path, *args;
{
return fexecv(path, &args);
}
fexecv.c
/* Copyright (C) 1983, 1984 by Manx Software Systems */
fexecv(path, argv)
char *path, **argv;
{
register char *cp, *xp;
int i;
char buffer[130];
char fcb1[16], fcb2[16];
cp = buffer+1;
i = 1;
fcbinit(".", fcb1); /* initialize fcb's, in case no args */
fcbinit(".", fcb2);
if (*argv) {
++argv; /* skip arg0, used for unix (tm) compatibility */
while (xp = *argv++) {
if (i == 1)
fcbinit(xp, fcb1);
else if (i == 2)
fcbinit(xp, fcb2);
*cp++ = ' ';
while (*xp) {
if (cp >= buffer+127)
goto done;
*cp++ = *xp++;
}
++i;
}
}
done:
buffer[0] = cp - (buffer+1);
*cp = '\r'; /* add CR to make some dos commands happy */
return fexec(path, 0, buffer, fcb1, fcb2);
}
ftime.asm
; :ts=8
;Copyright (C) 1984 by Manx Software Systems
include lmacros.h
dataseg segment para public 'data'
extrn errno_:word
dataseg ends
assume ds:dataseg
procdef ftime,<<get,byte>,<fd,word>,<newt1,word>,<newt2,word>>
;
;long ftime(get/set, fd, [long newtime])
;
mov ah,57h
mov al,get
mov bx,fd
mov cx,newt1
mov dx,newt2
int 21h
jnc retok
mov errno_,ax
mov ax,-1
mov dx,ax
pret
retok:
test get,1
jz gettime
sub dx,dx
mov cx,dx
gettime:
mov ax,cx
pret
pend ftime
finish
end
getcwd.c
/* Copyright (C) 1984 by Manx Software Systems */
char *
getcwd(buf, size)
char *buf;
{
char *malloc();
int allflag = 0;
if (buf == 0) {
if ((buf = malloc(size)) == 0)
return 0;
allflag = 1;
}
if (_sys(0x47,buf,0) == -1) {
if (allflag)
free(buf);
return 0;
}
return buf;
}
getenv.asm
; Copyright (C) 1984 by Manx Software Systems
; :ts=8
include lmacros.h
dataseg segment para public 'data'
ifndef LONGPTR
retbuf db 256 dup (?)
endif
extrn _PSP_:word
dataseg ends
assume ds:dataseg
procdef getenv, <<jname,ptr>>
; char *getenv(name)
; char *name;
;
push ds
push si
push di
ifndef LONGPTR
mov bx,ds
mov es,bx
endif
cld
ldptr bx,jname,es
mov ds,ds:_PSP_ ;fetch segment of PSP
mov ds,ds:[2cH] ;get environment segment
sub si,si
envloop:
lodsb
test al,al
jz nostring
sub di,di
cmploop:
cmp al,'='
jne notaneq
sub al,al
notaneq:
cmp al,es:[bx][di]
jne next
test al,al
je foundit
inc di
lodsb
test al,al
jne cmploop
jmp envloop
next:
lodsb
test al,al
jne next
jmp envloop
;
foundit:
ifndef LONGPTR
;
; copy string to local buffer, so we can return a 16-bit pointer to it.
;
mov di,offset retbuf
mov cx,255
cpyloop:
lodsb
stosb
test al,al
loopnz cpyloop
sub al,al
stosb ;guarantee null termination
mov ax,offset retbuf
test ax,ax
jmp short done
;
nostring:
sub ax,ax
done:
else
mov dx,ds
mov ax,si
jmp short done
nostring:
sub ax,ax
sub dx,dx
done:
endif
pop di
pop si
pop ds
pret
pend getenv
finish
end
io.asm
; Copyright (C) 1983 1984 by Manx Software Systems
; :ts=8
include lmacros.h
ifdef FARPROC
extrn __tty_rd_:far,__tty_wr_:far
else
extrn __tty_rd_:near,__tty_wr_:near
endif
dataseg segment para public 'data'
extrn errno_:word
public _ioflg_
_ioflg_ db 20 dup (0)
public _ttrd_, _ttwr_
ifdef FARPROC
_ttrd_ dd __tty_rd_
else
_ttrd_ dw offset __tty_rd_
endif
ifdef FARPROC
_ttwr_ dd __tty_wr_
else
_ttwr_ dw offset __tty_wr_
endif
dataseg ends
assume ds:dataseg
;
procdef _read, <<rdfd,word>,<xbuff,ptr>,<xlen,word>>
mov ah,3fH
mov bx,rdfd
jmp short use_dos
pend _read
;
procdef _write, <<wrfd,word>,<ybuff,ptr>,<ylen,word>>
mov ah,40H
mov bx,wrfd
jmp short use_dos
pend _write
;
procdef read, <<ifd,word>,<ibuffer,ptr>,<ilen,word>>
;read_(fd, buffer, length)
;char *buffer; int length;
mov ah,3fH
jmp short iocommon
pend read
;
procdef write, <<fd,word>,<buffer,ptr>,<len,word>>
;write(fd, buffer, length)
;char *buffer; int length;
mov ah,40H
iocommon:
mov bx,fd
cmp _ioflg_[bx],0
jz use_dos
pop bp
cmp ah,03fH
je readit
jmp _ttwr_
readit:
jmp _ttrd_
;
use_dos:
pushds
ldptr dx,buffer,ds
mov cx,len
int 21H
popds
jnc io_ok
mov errno_,ax
mov ax,-1
io_ok:
pret
pend write
;
procdef close, <<ffd,word>>
;close(fd)
mov ah,3eH
mov bx,ffd
int 21H
jnc cls_ok
mov errno_,ax
mov ax,-1
pret
cls_ok:
sub ax,ax
pret
pend close
;
procdef lseek, <<fffd,word>,<pos1,word>,<pos2,word>,<how,byte>>
;long lseek(fd, pos, how)
;long pos;
mov ah,42H
mov al,how
mov dx,pos1
mov cx,pos2
mov bx,fffd
int 21H
jnc lsk_ok
mov errno_,ax
mov ax,-1
mov dx,ax
lsk_ok:
pret
pend lseek
;
procdef unlink,<<namea,ptr>>
;unlink(name)
pushds
mov ah,41H
ldptr dx,namea,ds
int 21H
popds
jnc unl_ok
mov errno_,ax
mov ax,-1
pret
unl_ok:
sub ax,ax
pret
pend unlink
;
procdef rename, <<old,ptr>,<new,ptr>>
;rename(old, new)
push di
pushds
mov ah,56H
ldptr dx,old,ds
ifndef LONGPTR
mov di,ds
mov es,di
endif
ldptr di,new,es
int 21H
popds
pop di
jnc rnm_ok
mov errno_,ax
mov ax,-1
pret
rnm_ok:
sub ax,ax
pret
pend rename
finish
end
ioctl.c
/* Copyright (C) 1984, 1985 by Manx Software Systems */
#include "errno.h"
#include "sgtty.h"
#define TIME 10 /* number of iterations of raw_rd loop */
#define MIN 1 /* minimum number of chars returned from read */
extern char _ioflg[];
extern int (*_ttrd)();
extern int (*_ttwr)();
extern char _Eol;
extern int _TTrem;
extern int __tty_rd(), __tty_wr(), _write();
static struct sgttyb Tty_ctl = { '\b', '\x18', CRMOD|ECHO };
static int raw_rd(), cr_wr();
static int ioflags, myflags, ttyfd;
ioctl(fd, cmd, arg)
struct sgttyb *arg;
{
int flags;
if (_ioflg[fd] == 0) {
errno = ENOTTY;
return -1;
}
switch (cmd) {
case TIOCGETP:
*arg = Tty_ctl;
break;
case TIOCSETP:
if (ttyfd == 0) {
if (_ioflg[2])
ttyfd = 2;
else if ((ttyfd = _sys(0x3d02,"/dev/con",0)) == -1)
return -1;
}
if (ioflags == 0) {
_ioctl(ttyfd, 0, &ioflags);
ioflags &= 0xff;
}
Tty_ctl = *arg;
if ((myflags = Tty_ctl.sg_flags) & RAW)
myflags = RAW;
_ttwr = _write;
_Eol = '\r';
if (myflags&CRMOD) {
_Eol = '\n';
_ttwr = __tty_wr;
}
if (myflags&(RAW|CBREAK)) {
_TTrem = 0; /* clear out input buffer */
_ttrd = raw_rd;
ioflags |= 0x20; /* turn on dos's raw flag */
_ioctl(ttyfd, 1, &ioflags);
} else {
ioflags &= ~0x20; /* turn off dos's raw flag */
_ioctl(ttyfd, 1, &ioflags);
_ttrd = __tty_rd;
}
break;
}
return 0;
}
raw_rd(fd, buff, len)
register char *buff;
{
int i;
register int count;
for (count = 0 ; count < len ; ) {
for (i = TIME ; i-- ; )
if (_ioctl(ttyfd, 6) != 0)
goto have_char;
if (count < MIN)
continue;
break;
have_char:
_read(ttyfd, buff, 1);
if (*buff == '\r')
*buff = _Eol;
if (myflags&ECHO)
(*_ttwr)(ttyfd, buff, 1);
++buff;
++count;
}
return count;
}
isatty.asm
; Copyright (C) 1983 by Manx Software Systems
; :ts=8
include lmacros.h
procdef isatty, <<fd,word>>
; isatty(fd)
mov bx,fd
mov ax,4400H
int 21H
jc not_tty ;error, then not a tty
test dl,80h ;is the channel a device?
jz not_tty ;no, ...
test dl,3 ;is it console input or output
jz not_tty ;no, ...
mov ax,1 ;yes, the channel is a tty
pret
not_tty:
sub ax,ax
pret
pend isatty
finish
end
localtim.c
/* Copyright (C) 1984 by Manx Software Systems */
#include <time.h>
struct tm *
gmtime(clock)
long *clock;
{
struct tm *localtime();
return localtime(clock);
}
struct tm *
localtime(clock)
long *clock;
{
union {
long l;
unsigned u[2];
} un;
static struct tm tm;
static int days[12] = {
-1, 30, 58, 89, 119, 150, 180, 211, 242, 272, 303, 333
};
un.l = *clock;
tm.tm_sec = (un.u[0]&31) * 2;
tm.tm_min = (un.u[0]>>5) & 63;
tm.tm_hour = (un.u[0]>>11) & 31;
tm.tm_mday = un.u[1] & 31;
tm.tm_mon = ((un.u[1]>>5) & 15) - 1;
tm.tm_year = ((un.u[1]>>9) & 127) + 80;
tm.tm_yday = days[tm.tm_mon] + tm.tm_mday +
(tm.tm_mon > 1 && (tm.tm_year&3) == 0);
tm.tm_wday = (tm.tm_yday + tm.tm_year + ((tm.tm_year-1)>>2) + 1) % 7;
return &tm;
}
mkdir.asm
; Copyright (C) 1984 by Manx Software Systems
; :ts=8
include lmacros.h
dataseg segment para public 'data'
extrn errno_:word
dataseg ends
assume ds:dataseg
procdef mkdir,<<namea,ptr>>
; char *mkdir(name)
; char *name;
;
mov ah,39h
dircommon:
pushds
ldptr dx,namea,ds
int 21h
popds
mov ax,0
jnc ok
mov errno_,ax
mov ax,-1
ok:
pret
pend mkdir
;
procdef rmdir,<<nnamea,ptr>>
mov ah,3aH
jmp dircommon
pend rmdir
;
procdef chdir,<<xnamea,ptr>>
mov ah,3bH
jmp dircommon
pend chdir
finish
end
open.c
/* Copyright (C) 1982 1983 1984 by Manx Software Systems */
#include "errno.h"
#include "fcntl.h"
extern int errno;
extern char _ioflg[];
creat(name, mode)
char *name;
{
return open(name, O_WRONLY|O_TRUNC|O_CREAT, mode);
}
open(name, flag, mode)
char *name;
{
register int fd, m;
m = 0x3d00 | (flag&0x00f3);
if ((flag&O_TRUNC) != 0)
m = 0x3c00;
if ((fd = _sys(m,name,0)) == -1) {
if ((flag&O_CREAT) != 0)
fd = _sys(0x3c,name,0);
} else if ((flag&O_EXCL) != 0) {
close(fd);
errno = EEXIST;
return -1;
}
if (fd >= 0) {
if (flag&O_APPEND)
(void)lseek(fd, 0L, 2);
_ioflg[fd] = isatty(fd); /* set flag for i/o routines */
}
return fd;
}
stat.c
#include <stat.h>
stat(path, buf)
char *path; register struct stat *buf;
{
struct {
char rsvd[21];
char attr;
long time;
long size;
char name[13];
} sbuf;
_sys(0x1a,&sbuf);
if (_sys(0x4e,path,~ST_VLABEL) == -1)
return -1;
buf->st_attr = sbuf.attr;
buf->st_mtime = sbuf.time;
buf->st_size = sbuf.size;
return 0;
}
system.c
/* Copyright (C) 1984 by Manx Software Systems */
static int swt_char;
system(cmd)
char *cmd;
{
register char *prog;
char *getenv();
char buffer[130];
#asm
mov ax,3700h ;ask dos for current switch character
int 21h
sub dh,dh
mov swt_char_,dx
#endasm
if ((prog = getenv("COMSPEC")) == 0)
prog = "/command.com";
sprintf(buffer+1, "%cC %.123s\r", swt_char, cmd);
buffer[0] = strlen(buffer+1) - 1;
if (fexec(prog,0,buffer,0,0) == -1)
return -1;
return wait();
}
time.asm
; Copyright (C) 1984 by Manx Software Systems
; :ts=8
include lmacros.h
procdef time,<<tloc,ptr>> ;time_t time(time_t *tloc)
; if tloc!=0 then time is also stored there
;
mov ah,2aH
int 21h
sub cx,1980
mov ax,cx
mov cl,9
shl ax,cl
and dh,15
and dl,31
mov cl,3
shl dl,cl
shr dx,cl
or ax,dx
push ax ;save across system call
;
mov ah,2cH
int 21H
mov ax,cx
and ah,31
and al,63
and dh,63
shr dh,1 ;divide seconds by two
shl al,1 ;move minutes over 2 bits
shl al,1
mov cl,3 ;now move minutes & hours over 3 bits
shl ax,cl
or al,dh ;or the seconds/2 into the bottom 5 bits
;
pop dx ;restore the date info as the high word
ldptr bx,tloc,es ;get tloc
ifdef LONGPTR
mov cx,es
or cx,bx
else
test bx,bx
endif
jz done
ifdef LONGPTR
mov es:[bx],ax
mov es:2[bx],dx
else
mov ds:[bx],ax
mov ds:2[bx],dx
endif
done:
pret
pend time
finish
end
ttyio.c
/* Copyright (C) 1983, 1984 by Manx Software Systems */
#include "errno.h"
extern int errno;
char _Eol = '\n';
int _TTrem; /* # of bytes remaining in tty buffer */
__tty_rd(fd,buff,len)
char *buff;
{
static char buffer[260], *bp;
register int l;
if ((l = _TTrem) == 0) {
if ((l = _read(fd, buffer, 260)) != 0 && buffer[l-1]=='\n') {
--l;
buffer[l-1] = _Eol;
}
bp = buffer;
_TTrem = l;
}
if (l > len)
l = len;
if (l)
movmem(bp, buff, l);
bp += l;
_TTrem -= l;
return l;
}
__tty_wr(fd, buff, len)
char *buff;
{
register int count;
register char *cp;
static char crbuf = '\r';
cp = buff;
for (count = len ; count-- ; ) {
if (*cp++ == '\n') {
_write(fd, buff, cp-buff);
_write(fd, &crbuf, 1);
buff = cp;
}
}
if (cp != buff)
_write(fd, buff, cp-buff);
return len;
}
utime.c
/* Copyright (C) 1984 by Manx Software Systems */
struct utimbuf {
long actime; /* access time (not used on Msdos) */
long modtime; /* modification time */
};
utime(path, times)
char *path; register struct utimbuf *times;
{
long time(), ftime();
register int fd, r;
if ((fd = open(path, 0)) == -1)
return -1;
r = ftime(1, fd, times ? times->modtime : time(0));
close(fd);
return r;
}
wait.asm
; Copyright (C) 1984 by Manx Software Systems
; :ts=8
include lmacros.h
procdef wait
mov ah,4dh
int 21h
jnc noerr
neg ax
noerr:
pret
pend wait
finish
end
syserr.c
/* Copyright (C) 1984 by Manx Software Systems */
char *sys_errlist[] = {
/* MsDos error codes */
"No error",
"Invalid function number",
"File not found",
"Path not found",
"Too many open files",
"Access denied",
"Bad file handle",
"Memory control blocks destroyed",
"Insufficient memory",
"Invalid memory block address",
"Invalid environment",
"Invalid format",
"Invalid access code",
"Invalid data",
"",
"Invalid drive",
"Attempt to remove the current directory",
"Not same device",
"No more files",
/* additional codes for Aztec C */
"File exists",
"Not a console device",
/* math library */
"Result too large",
"Argument out of domain"
};
int sys_nerr = sizeof (sys_errlist) / sizeof (char *);
lbegin.asm
; Copyright (C) 1983 1984 by Manx Software Systems
; :ts=8
include lmacros.h
codeseg segment para public 'code'
public $MEMRY
public _mbot_, _sbot_, _mtop_,_lowwater_
dataseg segment para public 'data'
$MEMRY dw -1
dw -1
public errno_
errno_ dw 0
public _dsval_,_csval_
_dsval_ dw 0
_csval_ dw 0
_mbot_ dw 0,0
_sbot_ dw 0,0
_mtop_ dw 0,0
_lowwater_ dw -1
public _PSP_
_PSP_ dw 0
extrn _HEAPSIZ_:word,_STKSIZ_:word
extrn _STKLOW_:word,_STKRED_:word
extrn _Uorg_:byte,_Uend_:byte
dataseg ends
exitad dw 0
exitcs dw 0
assume cs:codeseg,ds:dataseg,es:dataseg,ss:dataseg
ifdef FARPROC
extrn Croot_:far
else
extrn Croot_:near
endif
public $begin
public _exit_
$begin proc far
mov bp,dataseg
test bp,bp
jnz notcom
mov ax,253 ; This CAN'T be a com file
jmp badexit
notcom:
mov exitcs,ds
mov es,bp
mov es:_PSP_,ds
mov bp,offset _Uend_ ; stack starts at Uend
add bp,15 ; round up to next paragraph
rcr bp,1
mov cl,3 ; and convert to paragraph form
shr bp,cl
and bp,01fffh
mov dx,es ; add in datasegment base paragraph
add bp,dx
mov bx,es:_STKRED_
shr bx,cl ;compute (2*STKRED)/16 note: cl==3
cmp bx,es:_STKSIZ_ ;allocate either 2*STKRED or STKSIZ
jae ok1
mov bx,es:_STKSIZ_ ;whichever is bigger
ok1:
cmp bx,1000h ; stack can't be bigger than 64K
jb ok2
mov bx,1000h
ok2:
mov dx,bx
mov cl,4
shl bx,cl
cli
mov ss,bp
mov sp,bx
sti
;
add dx,bp
inc dx
mov es:$MEMRY+2,dx ; and save as bottom of heap
mov es:$MEMRY,0
mov es:_mbot_+2,dx ; and save as bottom of heap
mov es:_mbot_,0
; now adjust heap size if necessary
mov bx,es:_HEAPSIZ_
add bx,es:$MEMRY+2 ; add in base paragraph of heap
mov es:_mtop_+2,bx ; and save as top of heap
mov es:_mtop_,0
mov si,ds
sub bx,si ; get size of total program in paragraphs
mov bp,es
mov es,si ; point es at PSP
mov ah,4ah
int 21h ; SETBLOCK to raise or lower allocation
jnc didheap
mov ax,254
jmp badexit
didheap:
mov es,bp ; restore es to point at dataseg
;
cld
; clear uninitialized data
mov di,offset _Uorg_
mov cx,offset _Uend_
sub cx,di
inc cx
shr cx,1
jcxz noclear
sub ax,ax
rep stosw
noclear:
;
mov es,[2cH] ;get enviroment segment
sub di,di
mov cx,7fffH
arglook:
mov ah,es:byte ptr [di]
cmp ah,'=' ;look for null named env. string
je found_args
test ah,ah
jz no_args
repne scasb ;look for null byte
jz arglook
no_args:
mov si,ds
mov es,si
mov si,081h
mov di,080h
mov cl,[80h]
sub ch,ch
jcxz nomov
rep movsb
nomov:
sub al,al
stosb
mov ax,1
mov di,080h
jmp short mov_args
;
found_args:
sub ax,ax
stosb ;zap and skip over '='
mov_args:
push ax ; first arg # for Croot
push es
push di ; argp argument for Croot
mov es,bp
mov ds,bp ;set DS, now DS, SS, ES are equal
mov _dsval_,ds
mov _csval_,cs
mov ax,_STKRED_
mov _sbot_,ax
call Croot_ ;Croot(argp, first)
jmp short exits
_exit_:
pop ax
pop ax ;fetch return code
ifdef FARPROC
pop ax
exit label far
else
exit:
endif
exits:
badexit:
mov ah,4cH
int 21H
jmp dword ptr exitad
$begin endp
retip dw 0
retcs dw 0
public $dbgentry
$dbgentry proc far
pop cs:retip
pop cs:retcs ; save return address into debugger
pop ds ;set DS
call caller
jmp dword ptr cs:retip ; return to debugger
$dbgentry endp
caller proc
push di ;CS value of local function
push si ;IP value call local function
db 0cbH ;far return instruction
caller endp
codeseg ends
end $begin
ssbrk.asm
; :ts=8
;Copyright (C) 1983 by Manx Software Systems
include lmacros.h
dataseg segment word public 'data'
extrn $MEMRY:word
extrn _mbot_:word, _sbot_:word
extrn _mtop_:word
extrn errno_:word
extrn _STKLOW_:word
extrn _STKRED_:word
extrn _PSP_:word
dataseg ends
assume ds:dataseg
;
; sbrk(size): return address of current top & bump by size bytes
;
procdef sbrk,<<siz,word>>
push di
mov ax,siz
mov di,$MEMRY
test ax,ax
jge addok
sub di,ax
jc invalid
jmp short dobrk
addok:
add ax,di
jc invalid
dobrk:
push ax
call brk_
pop cx
test ax,ax
jnz brk_error
mov ax,di ;return original value of the break
brk_error:
pop di
test ax,ax ;set flags for C
pret
invalid:
mov errno_,-8
mov ax,-1
jmp brk_error
pend sbrk
;
; brk(addr): set current top address to addr
; returns 0 if ok, -1 if error
;
procdef brk,<<addr,word>>
mov ax,addr
inc ax
and al,-2
cmp ax,_mbot_
jb brk_ov
cmp _STKLOW_,0
jne abovestk
mov bx,sp
sub bx,_STKRED_
cmp ax,bx
jae brk_ov
mov $MEMRY,ax ;new value is good so save it away
add ax,_STKRED_
mov _sbot_,ax ;save as new value for safety check
brk_ok2:
sub ax,ax
pret
;heap is above stack
abovestk:
cmp ax,_mtop_
ja getstore
cmp ax,$MEMRY
jb getstore
mov $MEMRY,ax ;new value is good so save it away
jmp brk_ok2
; going to do a SETBLOCK call
getstore:
push ax
mov bx,ax
mov cx,4
shr bx,cl
and bx,0fffh
add bx,65 ;bump to nearest 1k increment
and bx,0ffc0h ;and round
push bx
push es
mov cx,ds
add bx,cx ;get actual paragraph address
mov es,_PSP_
sub bx,_PSP_
mov ah,04ah
int 21h ;SETBLOCK
pop es
pop bx
pop ax
jc brk_ov ; couldn't do it, so punt
mov $MEMRY,ax
test bx,0e000h
jnz brk_ov
mov cx,4
shl bx,cl
mov _mtop_,bx
sub ax,ax
pret
; invalid request
brk_ov:
mov errno_,-8
mov ax,-1
test ax,ax
pret
pend brk
;
; rsvstk(size): set safety margin for stack
; this will make sure that at least size
; bytes of stack below the current level remain.
;
procdef rsvstk,<<stksize,word>>
mov ax,sp
sub ax,stksize
mov _STKRED_,ax
pret
pend rsvstk
finish
end
lsbrk.asm
; :ts=8
;Copyright (C) 1983 by Manx Software Systems
include lmacros.h
dataseg segment word public 'data'
extrn $MEMRY:word
extrn _mbot_:word, _sbot_:word
extrn _mtop_:word
extrn errno_:word
extrn _PSP_:word
dataseg ends
assume ds:dataseg
;
; sbrk(size): return address of current top & bump by size bytes
;
procdef sbrk,<<siz,word>>
push di
push si
mov ax,$MEMRY ; convert $MEMRY to 20-bit physical address
mov dx,$MEMRY+2
mov si,ax
mov di,dx
mov cx,4
rol dx,cl
mov bx,dx
and bx,0fff0h
and dx,0fh
add ax,bx
adc dx,0
mov bx,siz ; load and check sign of size
cmp bx,0
jge notneg
sub ax,bx
sbb dx,0
js brk_error ; mustn't go negative
jmp canon
notneg:
add ax,bx
adc dx,0
test dx,0fff0h
jnz brk_error ; mustn't overflow 20-bits
canon:
ror dx,cl
mov bx,ax
and ax,0fh
shr bx,cl
and bx,0fffh
or dx,bx
push dx
push ax
call brk_
add sp,4
test ax,ax
jnz brk_error
mov ax,si ;return original value of the break
mov dx,di
pop si
pop di
pret
brk_error:
pop si
pop di
mov dx,ax
pret
pend sbrk
;
; brk(addr): set current top address to addr
; returns 0 if ok, -1 if error
;
procdef brk,<<addr,word>,<aseg,word>>
push di
push si
mov ax,addr
inc ax
and al,-2
mov dx,aseg
mov bx,ax ; convert to canonical pointer
mov cx,4
shr bx,cl
and bx,0fffh
and ax,0fh
add dx,bx
cmp dx,_mtop_+2
ja getstore
jne brk_ok2
cmp ax,_mtop_
jnb getstore
brk_ok2:
cmp dx,$MEMRY+2
ja brk_ok3
jne chkunder
cmp ax,$MEMRY
jnb brk_ok3
chkunder:
cmp dx,_mbot_+2
jb brk_ov
jne getstore
cmp ax,_mbot_
jb brk_ov
getstore:
; going to do a SETBLOCK call
push ax
mov bx,dx
test ax,ax
jz nobump
inc bx
nobump:
add bx,63 ;bump to nearest 1k increment
and bx,0ffc0h ;and round
push es
push bx
mov cx,_PSP_
mov es,cx ;set segment for SETBLOCK call
sub bx,cx ;and adjust length appropriately
mov ah,04ah
int 21h ;SETBLOCK
pop bx
pop es
pop ax
jc brk_ov ; couldn't do it, so punt
mov _mtop_+2,bx
mov _mtop_,0
brk_ok3:
mov $MEMRY,ax
mov $MEMRY+2,dx
sub ax,ax
pop si
pop di
pret
; invalid request
brk_ov:
mov errno_,-4
mov ax,-1
test ax,ax
pop si
pop di
pret
pend brk
finish
end
clock.asm
; Copyright (C) 1985, 1986 by Manx Software Systems, Inc.
; :ts=8
include lmacros.h
dataseg segment word public 'data'
last dw 0,0
dataseg ends
assume ds:dataseg
procdef clock
mov ah,2ch
int 21h ; get time
mov al,100
mul dh ;get seconds as hundredths into ax
sub dh,dh
add ax,dx ;add in hundredths
mov bx,ax ;save total hundredths
mov al,60
mul ch ; get hours as mins into ax
sub ch,ch
add ax,cx ; add minutes to converted hours
mov cx,6000
mul cx ; convert to hundredths of seconds
add ax,bx ; add in seconds+hundredths
adc dx,0 ; axdx now contains value in hunredths
cmp dx,word ptr last+2
ja valok
jne clktrn
cmp ax,word ptr last
jae valok
clktrn: ; clock turned over since last call
add ax,0d600h
adc dx,083h ; add in 24 hours
valok:
mov word ptr last+2,dx
mov word ptr last,ax
pret
pend clock
finish
end
sigfix.asm
; Copyright (C) 1985 by Manx Software Systems, Inc.
; :ts=8
include lmacros.h
dataseg segment word public 'data'
public _brkvec_
_brkvec_ dw 0,0
dataseg ends
assume ds:dataseg
;
; This routine is used by exec (used by execl, execv, etc.)
; to reset any signal handlers which have been setup.
;
procdef _sigfix
cmp _brkvec_+2,0
je brk_ok
push ds
lds dx,dword ptr _brkvec_
mov ax,2523H ;restore old cntl-break handler
int 21H
pop ds
brk_ok:
pret
pend _sigfix
finish
end
sighand.asm
; Copyright (C) 1985 by Manx Software Systems, Inc.
; :ts=8
include lmacros.h
dataseg segment word public 'data'
extrn _PSP_:word
extrn _brkvec_:word
ifdef FARPROC
bss temp:word,4 ;used for far call to handler
global _sigfuns_:word,6*4
else
global _sigfuns_:word,6*2
endif
saveds dw 0
dataseg ends
ourds dw 0
assume ds:dataseg
;
procdef _sig_setup
mov ourds,ds
cmp _brkvec_+2,0
jne have_brk
push ds
mov ax,3523H ;get cntl-break (cntl-c) handler
int 21H
mov _brkvec_,bx
mov _brkvec_+2,es
mov dx,offset brk_handler
mov ax,cs
mov ds,ax
mov ax,2523H ;set new cntl-break handler
int 21H
pop ds
have_brk:
pret
pend _sig_setup
brk_handler proc far
push ds
mov ds,ourds
ifdef FARPROC
cmp _sigfuns_+2,0
jne chk_ignore
cmp _sigfuns_,0
jne chk_ignore
else
cmp _sigfuns_,0
jne chk_ignore
endif
pop saveds ;get ds from the stack
push _brkvec_+2
push _brkvec_
mov ds,saveds
ret
chk_ignore:
ifdef FARPROC
cmp _sigfuns_,1
jne not_ignore
cmp _sigfuns_+2,0
je ignore
not_ignore:
else
cmp _sigfuns_,1
je ignore
endif
cld
push es
push ax
push bx
mov ax,sp
mov bx,ss
mov es,_PSP_
mov ss,es:[30h] ;get our last ss:sp from place
mov sp,es:[2eh] ;where DOS saves it
push ax
push bx
push cx
push dx
push si
push di
mov ax,1 ;signal #1
push ax
ifdef FARPROC
mov ax,_sigfuns_+2
mov temp+2,ax
mov ax,_sigfuns_
mov temp,ax
mov _sigfuns_,0 ;set SIG_DFL
mov _sigfuns_+2,0
sti
call dword ptr temp
else
mov ax,_sigfuns_
mov _sigfuns_,0 ;set SIG_DFL
sti
call ax
endif
pop ax ;throw away argument
pop di
pop si
pop dx
pop cx
pop bx
pop ax
mov ss,bx ;restore to system stack
mov sp,ax
pop bx
pop ax
pop es
ignore:
pop ds
iret
brk_handler endp
finish
end
signal.c
#include <signal.h>
#include <errno.h>
extern void (*_sigfuns[_NUMSIG])();
static char setup;
void (*signal(sig, func))()
register int sig; void (*func)();
{
register void (*retval)();
if (!setup) {
_sig_setup();
setup = 1;
}
if ((sig -= _FSTSIG) < 0 || sig >= _NUMSIG) {
errno = EINVAL;
return SIG_ERR;
}
retval = _sigfuns[sig];
_sigfuns[sig] = func;
return retval;
}
sys.asm
;Copyright (C) 1985 by Manx Software Systems
; :ts=8
include lmacros.h
dataseg segment para public 'data'
extrn errno_:word
dataseg ends
assume ds:dataseg
procdef _sys,<<func,word>,<arg,ptr>,<arg2,word>>
mov ax,func
test ah,ah
jnz valok
xchg ah,al
valok:
cmp ah,10
jb simple
;
push si
pushds
push es
cmp ah,47H ;check for getcwd call
jne not_cwd
mov dx,arg2 ;load drive # into DX
ldptr si,arg,ds
jmp short issue
not_cwd:
mov cx,arg2
ldptr dx,arg,ds
issue:
int 21H
mov dx,es
pop es
popds
jnc noerror
mov errno_,ax
mov ax,-1
mov dx,ax
noerror:
pop si
pret
;
simple:
mov dx,word ptr arg
int 21H
and ax,0ffH
pret
pend _sys
finish
end
monitor.c
short monitor (lowpc, highpc, buffer, pockets, nfunc)
int (*lowpc)(), (*highpc)();
unsigned int *buffer;
int pockets, nfunc;
{
return _monitor(lowpc,highpc,buffer,pockets,nfunc);
}
profil.c
void profil (buff, bufsiz, offset, scale)
char *buff;
int bufsiz;
int (*offset)();
int scale;
{
_profil(buff, bufsiz, offset, scale);
return;
}
mon.c
#include <stdio.h>
short _mon_off;
unsigned _speed = 0;
long _ticks=0;
extern int errno;
extern int _Corg(), _Cend();
#define high(x) ((unsigned long)(x))
#define low(x) ((unsigned long)(x) & 0x0000ffffl)
#define canon(x) (int (*)())(((high(x) >> 12)&0x000fffffl) + low(x))
static struct {
short pockets;
short byte_pock;
long lowpc;
long highpc;
int speed;
long time;
} mon_head;
void _profil();
short _monitor (lowpc, highpc, buffer, pockets, nfunc)
int (*lowpc)(), (*highpc)();
unsigned int *buffer;
int pockets, nfunc;
{
register int i;
static short pro_flag;
static unsigned int *buff_add, oldsig;
unsigned long tot_bytes, left_over, org;
unsigned int bytes, scale;
int exit();
FILE *fopen(), *fp;
int (*slowpc)();
/*
* offset = lowpc;
* tot_bytes = highpc - lowpc
* range mod pockets = bytes left over
* if (bytes left over)
* pockets * (bytes in range +1) > range
*/
if (pro_flag)
{
/*check to see if profiling was turned off by overflow*/
if (_mon_off) {
printf ("Bucket number %d overflowed\n", _mon_off);
_mon_off = 0;
}
else
_clkrest();
pro_flag = 0;
mon_head.time = _ticks;
if ((fp = fopen ("mon.out", "w")) == NULL)
return (errno);
if ((fwrite (&mon_head, sizeof(mon_head), 1, fp)) != 1) {
printf("\nfunction monitor: error trying to write header data\n");
fclose (fp);
return(errno);
}
for (i=0; i<mon_head.pockets; ++i) {
if ((fwrite (&buff_add[i], sizeof(short), 1, fp)) != 1) {
printf("\nfunction monitor: error trying to write data\n");
fclose (fp);
return(errno);
}
}
fclose (fp);
return(0);
} /* end if */
if (pockets == 0 || buffer == 0) /* check for valid array and pockets */
return -1;
for (i=0; i<pockets; ++i) /* clear the users array of junk */
buffer[i] = 0;
pro_flag = 1;
/* are we running in large code model ? */
slowpc = lowpc;
if (sizeof(int (*)()) == 4)
slowpc = canon(lowpc);
tot_bytes = _ptrdiff((unsigned long)highpc,(unsigned long)slowpc);
if ((bytes = tot_bytes/pockets) == 0)
bytes = 1; /* must have at least one byte per pocket */
if (tot_bytes < pockets || ((tot_bytes % pockets) == 0))
;
else {
while ( (left_over = (long)pockets * (bytes + 1)) < tot_bytes)
bytes = left_over / pockets;
}
/* mon_head.speed is set in intr_sp to the number of intrps. per sec */
mon_head.pockets = pockets;
mon_head.byte_pock = bytes;
org = 0;
if (sizeof(int (*)()) == 4)
org = canon(_Corg);
mon_head.lowpc = (unsigned long)slowpc-org;
mon_head.highpc = (unsigned long)highpc-org;
buff_add = buffer;
_profil (buffer, pockets, lowpc, bytes);
}
void _profil (buff, bufsiz, offset, scale)
char *buff;
int bufsiz;
int (*offset)();
int scale;
{
_clkinit(buff, bufsiz, offset, scale);
return;
}
/*
;divsor for 121 Hz clock is 9861 dec.
;hex value 0x4DE0 will give exactly 60 inters. per second
*/
#define DIVSOR 1193180L
_intr_sp (sp)
int sp;
{
if (sp > 121) {
_speed = 9861;
mon_head.speed = 121;
} else if (sp <= 0) {
_speed = 0;
mon_head.speed = 18;
} else {
_speed = DIVSOR / sp;
mon_head.speed = sp;
}
}
clk.asm
;:ts=8
;Copyright (C) 1985 by Manx Software Systems, Inc.
;
; IBM PC Clock Support routines
;
include lmacros.h
;
; divsor for 121 Hz clock is 9861 dec.
; hex value 0x4DE0 will give exactly 60 inters. per second
codemacro killtime
db 0EBH
db 0
endm
INTVEC equ 20h ;location of interrupt vector for clock
TIMER equ 40h
CNTRL equ 43h
EXITVEC equ 88h
TIME_LOW equ 61
TIME_HIGH equ 98
TIMES equ 6
dataseg segment para public 'data'
reset_ct db TIMES
scale dw 0
ifdef LONGPTR
buff_add dd 0
else
buff_add dw 0
endif
buf_size dw 0
ifdef FARPROC
ofset dd 0
else
ofset dw 0
endif
extrn _mon_off_:word
extrn _speed_:word
extrn _ticks_:word
extrn _PSP_:word
dataseg ends
data_add dw ? ;codesegment variable for location of dataseg in 'C'
clk_ipvec dw ? ;memory location of the stored clock int vector's ip
clk_csvec dw ? ;memory location of the stored clock int vector's cs
;memory location of all the int vectors on how to exit a program
int22_ip dw ? ;memory location of the stored int 22 vector's ip
int22_cs dw ? ;memory location of the stored int 22 vector's cs
;memory location of all the int vectors in the PSP
PSP_ip dw ? ;memory location of the stored PSP int 22 vector's ip
PSP_cs dw ? ;memory location of the stored PSP int 22 vector's cs
assume cs:codeseg, ds:dataseg
procdef _clkinit,<<ibufad,ptr>,<ibufsz,word>,<iofset,fptr>,<iscl,word>>
push es ;get args. off stack for later use
mov ax,word ptr ibufad
mov word ptr buff_add,ax
ifdef LONGPTR
mov ax,word ptr ibufad+2
mov word ptr buff_add+2,ax
endif
mov ax,ibufsz
mov buf_size,ax
ifndef FARPROC
mov ax,word ptr iofset
mov ofset,ax
else
push cx
mov cx,4
mov ax,word ptr iofset
mov dx,word ptr 2+iofset ;convert to physical address
rol dx,cl
mov bx,dx
and dx,0fh
and bx,0fff0h
add ax,bx
adc dx,0
mov word ptr ofset,ax
mov word ptr ofset+2,dx
pop cx
endif
mov ax,iscl
mov scale,ax
sub ax,ax
mov es,ax
mov ax, es:[INTVEC] ;save contents of interupt table
mov cs:clk_ipvec, ax
mov ax,es:[INTVEC+2] ;ditto
mov cs:clk_csvec,ax
mov ax, es:[EXITVEC] ;save contents of interupt table
mov cs:int22_ip, ax
mov ax,es:[EXITVEC+2] ;ditto
mov cs:int22_cs,ax
mov es,_PSP_ ;save contents of the PSP
mov ax,es:[0ah]
mov cs:PSP_ip,ax
mov ax,es:[0ch]
mov cs:PSP_cs,ax
cli
xor ax,ax
mov es,ax
mov es:[INTVEC],offset intsr ;insert the address of int. handler
mov es:[INTVEC+2],cs
mov cs:data_add,ds ;mov 'C' dataseg address to var.
mov es:[EXITVEC],offset int_22 ;insert the address of int. handler
mov es:[EXITVEC+2],cs
mov es,_PSP_
mov es:[0ah], offset int_22 ;move handler into PSP
mov es:[0ch], cs
sti
xor ax,ax
mov al,36h ;use mode 3 for timer 0
cli
out CNTRL,al
killtime
mov ax,word ptr _speed_
out TIMER,al ;
killtime
mov al,ah
out TIMER,al
killtime
sti
sub ax,ax
mov _speed_,ax
pop es
pret
pend _clkinit
procdef _clkrest
push es
sub ax,ax
cli
mov al,36h ;use mode 3 for timer 0
out CNTRL,al
killtime
mov al,0h ;load low byte
out TIMER,al ;restore to 18.2 intrs. per second
killtime
out TIMER,al
sub ax,ax
mov es,ax
mov ax, cs:clk_ipvec ;restore interupt vec. table
mov es:[INTVEC], ax
mov ax, cs:clk_csvec ;restore interupt vec. table
mov es:[INTVEC+2],ax
mov ax, cs:int22_ip ;restore interupt vec. table
mov es:[EXITVEC], ax
mov ax, cs:int22_cs ;restore interupt vec. table
mov es:[EXITVEC+2],ax
mov es,_PSP_ ;restore the PSP
mov ax,cs:PSP_ip
mov es:[0ah],ax
mov ax,cs:PSP_cs
mov es:[0ch],ax
sti
pop es
pret
pend _clkrest
int_22:
sti
push ax
push dx
push es
push ds
call _clkrest_
pop ds
pop es
pop dx
mov al,020h ;send EOI to 8259
out 020h,al
pop ax
jmp dword ptr cs:int22_ip
intsr:
sti
push bp
mov bp,sp
push ds
push si
push ax
push bx
push dx
mov ds,cs:data_add
add word ptr _ticks_,1 ;get total number of interupts
adc word ptr _ticks_+2,0
ifndef FARPROC
mov ax,word ptr 4[bp] ;get cs value in interrupted code
mov dx,cs
cmp ax,dx ;compare with current cs
jne quit ;if not = punt
mov ax,word ptr 2[bp] ;get ip value in interrupted code
sub ax,ofset ;sub ofset (lowpc) from ip
jb quit ;if negative punt
cmp scale,1
jz nodiv
xor dx,dx
div scale ;div. by scale factor done in monitor
else
mov ax,ss:word ptr 2[bp] ;get ip value in interrupted code
mov dx,ss:word ptr 4[bp] ;get cs value in interrupted code
rol dx,1
rol dx,1
rol dx,1
rol dx,1
mov bx,dx
and dx,0fh
and bx,0fff0h
add ax,bx
adc dx,0 ;convert to physical address
sub ax,word ptr ofset
sbb dx,word ptr ofset+2
jb quit ;if beyond bottom of range,punt
cmp dx,word ptr scale
jge quit ;if divide will overflow,punt
cmp word ptr scale,1
jz nodiv ;skip divide if index is good as is
div word ptr scale
endif
nodiv:
cmp ax,buf_size ;check to see if out of buff
ja quit ;if out of range punt
shl ax,1 ;shift to get on a word boundary
mov si,ax
ldptr bx,buff_add,ds
add ds:word ptr [bx][si],1 ;else increment word
jnc quit ;check to see if we overflowed a bucket
sub ds:word ptr 0[bx][si],1
ifdef LONGPTR
mov ds,cs:data_add
endif
call _clkrest_
sub ax,ax
mov ax,si
mov _mon_off_,ax
quit:
ifdef LONGPTR
mov ds,cs:data_add
endif
dec reset_ct
jz time_out
pop dx
pop bx
pop ax
pop si
pop ds
pop bp
push ax
mov al,020h ;send EOI to 8259
out 020h,al
pop ax
iret
time_out:
mov reset_ct,TIMES
pop dx
pop bx
pop ax
pop si
pop ds
pop bp
jmp dword ptr cs:clk_ipvec
finish
end
dosdir.c
#include "model.h"
#define SETDMA 26
#define SRCHFIR 0x4e
#define SRCHNXT 0x4f
char *
scdir(pat)
char *pat;
{
register char *cp, *np;
char *index();
static int code = SRCHFIR;
static char nambuf[64], *tail;
static struct {
char reserve[21];
char attr;
long mtime;
long fsize;
char name[13];
} srchbuf;
if (code == SRCHFIR) {
if (index(pat, '*') == 0 && index(pat, '?') == 0) {
code = 0;
return pat;
}
strncpy(nambuf, pat, 64);
for (cp = tail = nambuf ; cp < &nambuf[64] && *cp ; ++cp)
if ((tail == nambuf && *cp == ':') || *cp == '/' || *cp == '\\')
tail = cp+1;
}
#ifdef _LARGEDATA
bdosx(SETDMA, &srchbuf);
if (code == 0 || dosx(code, 0, -1, pat) == -1) {
#else
bdos(SETDMA, &srchbuf);
if (code == 0 || dos(code, 0, -1, pat) == -1) {
#endif
code = SRCHFIR;
return (char *)0;
}
code = SRCHNXT;
np = tail;
cp = srchbuf.name;
while (*np++ = tolower(*cp++))
;
return nambuf;
}
bdosx.asm
;Copyright (C) 1983 by Manx Software Systems
; :ts=8
include lmacros.h
procdef bdosx,<<func,word>,<dxval,word>,<dsval,word>,<cxval,word>>
push es
push ds
mov ax,func
test ah,ah
jnz valok
xchg ah,al
valok:
mov dx,dxval
mov cx,cxval
push dsval
pop ds
int 21H
mov dx,es
pop ds
pop es
and ax,0ffH
pret
pend bdosx
finish
end
dosx.asm
; Copyright (C) 1983, 1984 by Manx Software Systems
; :ts=8
include lmacros.h
dataseg segment para public 'data'
extrn errno_:word
dataseg ends
assume ds:dataseg
procdef dosx,<<func,word>,<bxval,word>,<cxval,word>,<dxval,word>,<dsval,word>,<dival,word>,<sival,word>>
; dosx(ax,bx,cx,dx,es,di,si)
push di
push si
ifndef LONGPTR
mov ax,ds
mov es,ax
endif
push ds
mov ax,func
test ah,ah
jnz skip
xchg ah,al
skip:
mov bx,bxval
mov cx,cxval
mov dx,dxval
mov di,dival
mov si,sival
push dsval
pop ds
int 21H
pop ds
jnc ret_ok
mov errno_,ax
mov ax,-1
ret_ok:
pop si
pop di
pret
pend dosx
finish
end
stkover.c
_stkover()
{
write(2, "STACK OVERFLOW, INCREASE STACK SIZE\n", 36);
_exit(100);
}
filelock.asm
; :ts=8
;Copyright (C) 1984 by Manx Software Systems
include lmacros.h
dataseg segment word public 'data'
extrn errno_:word
dataseg ends
procdef filelock, <<fd,word>,<flag,word>,<pos,dword>,<len,dword>>
push si
push di
mov ah,5ch
mov al,byte ptr flag
mov bx,fd
mov cx,word ptr pos+2
mov dx,word ptr pos
mov si,word ptr len+2
mov di,word ptr len
int 21h
pop di
pop si
jnc retok
mov ds:errno_,ax
mov ax,-1
pret
retok:
sub ax,ax
pret
pend filelock
finish
end

Reference in New Issue Copy Permalink