/* LIBNAME(MSC) */
/* GLOBAL (int errno) */
/* GLOBAL (int _doserrno) */

extern int errno;
int _doserrno;

/* UCOVER */
#include <stdio.h>
#include <sys/stat.h>
#include <errno.h>
#include <graph.h>
#include <bios.h>
#include <dos.h>
/* ENDCOVER */

/* ACOVER */
#define far
#define near
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
#include <sys/types.h>
#include <sys/stat.h>
/* ENDCOVER */

/* From DOS stdlib.h */
#define _MAX_PATH   80      /* max length of full pathname */
#define _MAX_DRIVE   3      /* max length of drive component */
#define _MAX_DIR    66      /* max length of path component */
#define _MAX_FNAME   9      /* max length of file name component */
#define _MAX_EXT     5      /* max length of extension component */

#define MAXLINE 1024		/* size of a logical line */
#ifndef NULL
#define NULL 0L
#endif

/*
 * Buffer Manipulation - handled locally by Wizard
 *
memccpy()
memchr()
memcmp()
memicmp()
memmove()
memcpy()
memset()
movedata()
*/

/*
 * Character Classification & Conversion - handled locally by Wizard
 *
isalnum()
isalpha()
isascii()
iscntrl()
isdigit()
isgraph()
islower()
isprint()
ispunct()
isspace()
isupper()
isxdigit()
toascii()
tolower()
_tolower()
toupper()
_toupper()
*/

/*
 * Data Conversion - handled locally by Wizard
 *
atof()
atoi()
atol()
ecvt()
fcvt()
gcvt()
itoa()
strtol()
strtoul()
ultoa()
*/

/* UCOVER */
long
strtoul(str, ptr, base)
char *str;
char **ptr;
int base;
{
	long strtol();

	return(strtol(str, ptr, base));
}
/* ENDCOVER */

/* UCOVER */
/* Reasons for cover:
 *	1) Returns pointer to string.
 *	2) May alter minimum number of chars in string.
 */
char *
ltoa(value, string, radix)
long value;
char *string;
int radix;
{
	char sbuf[33];
	void Xltoa();
	char *strcpy();
	int len;

	Xltoa(value, sbuf, radix);
	sbuf[32] = '\0';
	strcpy(string, sbuf);
	return(string);
}
/* ENDCOVER */

void
Xltoa(value, string, radix)
long value;
char *string;			/* BUFIN[33] */
int radix;
{
}

/* ACOVER */
void
Xltoa(value, string, radix)
long value;
char *string;
int radix;
{
	(void)ltoa(value, string, radix);
}
/* ENDCOVER */

/*
 * Directory Control - passed to DOS
 */
int
chdir(path)
char *path;	/* BUFOUT[STRING] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* UCOVER */
/* Reasons for cover:
 *	1) Returns pointer to string.
 *	2) Avoid the case where the DOS library mallocs a buffer.
 *	3) Do a local malloc() if NULL path.
 */
char *
getcwd(path, n)
char *path;
int n;
{
	char tmpbuf[_MAX_PATH];
	long rtnval;
	long Xgetcwd();
	int len;
	char *strcpy(), *strdup();
	char *malloc();

	rtnval = Xgetcwd(tmpbuf, n);
	if (rtnval) {
		if (!path) {
			if ((len = strlen(tmpbuf)+1) > n)
				n = len;
			path = malloc(n);
			if (!path) {
				errno = ENOMEM;
				return(NULL);
			}
		}
		tmpbuf[n-1] = '\0';
		strcpy(path, tmpbuf);
		return(path);
	}
	return(NULL);
}
/* ENDCOVER */

long
Xgetcwd(path, n)
char *path;		/* BUFIN[n] */
int n;
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* ACOVER */
long
Xgetcwd(path, n)
char *path;
int n;
{
	char *getcwd();

	return((long)getcwd(path, n));
}
/* ENDCOVER */

int
mkdir(path)
char *path;	/* BUFOUT[STRING] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
rmdir(path)
char *path;	/* BUFOUT[STRING] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/*
 * File Handling - passed to DOS
 */
int
access(path, mode)
char *path;	/* BUFOUT[STRING] */
int mode;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
chmod(path, pmode)
char *path;	/* BUFOUT[STRING] */
int pmode;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
chsize(handle, size)
int handle;
long size;
/* GLOBAL int errno;	BUFIN[1] */
{
}

long
filelength(handle)
int handle;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
fstat(handle, buffer)			/* NAME(Xfstat) */
int handle;
struct stat *buffer;	/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* ACOVER */
/* Reasons for cover:
 *	1) Must align structure members do to different 80286 
 *	   and Opus alignment.
 */
int
Xfstat(handle, buffer)
int handle;
struct ustat {
	unsigned short s[8];
	long l[4];
} *buffer;
{
	struct stat dbuffer;	/* dos stat buffer */
	int rv;

	rv = fstat(handle, &dbuffer);
	buffer->s[0] = (unsigned short)dbuffer.st_dev;	/* adjust alignment */
	buffer->s[1] = (unsigned short)dbuffer.st_ino;
	buffer->s[2] = (unsigned short)dbuffer.st_mode;
	buffer->s[3] = (unsigned short)dbuffer.st_nlink;
	buffer->s[4] = (unsigned short)dbuffer.st_uid;
	buffer->s[5] = (unsigned short)dbuffer.st_gid;
	buffer->s[6] = (unsigned short)dbuffer.st_rdev;
	buffer->s[7] = 0;
	buffer->l[0] = (long)dbuffer.st_size;
	buffer->l[1] = (long)dbuffer.st_atime;
	buffer->l[2] = (long)dbuffer.st_mtime;
	buffer->l[3] = (long)dbuffer.st_ctime;
	return(rv);
}
/* ENDCOVER */

int
isatty(handle)
int handle;
{
}

int
locking(handle, mode, nbyte)
int handle;
int mode;
long nbyte;
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* Reasons for additional Opus code:
 *	1) Returns pointer to char or NULL.
 */
char *	
mktemp(template)
char *template;		/* BUFIO[STRING] */
{
	if (rtnval)		/* RETURN */
		return(template);
	else
		return(NULL);
}

int
remove(path)
char *path;		/* BUFOUT[STRING] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
rename(oldname, newname)
char *oldname;		/* BUFOUT[STRING] */
char *newname;		/* BUFOUT[STRING] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
setmode(handle, mode)
int handle;
int mode;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
stat(path, buffer)				/* NAME(Xstat) */
char *path;		/* BUFOUT[STRING] */
struct stat *buffer;	/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* ACOVER */
/* Reasons for cover:
 *	1) Must align structure members do to different 80286 
 *	   and Opus alignment.
 */
int
Xstat(path, buffer)
char *path;
struct ustat {
	unsigned short s[8];
	long l[4];
} *buffer;
{
	struct stat dbuffer;	/* dos stat buffer */
	int rv;

	rv = stat(path, &dbuffer);
	buffer->s[0] = (unsigned short)dbuffer.st_dev;	/* adjust alignment */
	buffer->s[1] = (unsigned short)dbuffer.st_ino;
	buffer->s[2] = (unsigned short)dbuffer.st_mode;
	buffer->s[3] = (unsigned short)dbuffer.st_nlink;
	buffer->s[4] = (unsigned short)dbuffer.st_uid;
	buffer->s[5] = (unsigned short)dbuffer.st_gid;
	buffer->s[6] = (unsigned short)dbuffer.st_rdev;
	buffer->s[7] = 0;
	buffer->l[0] = (long)dbuffer.st_size;
	buffer->l[1] = (long)dbuffer.st_atime;
	buffer->l[2] = (long)dbuffer.st_mtime;
	buffer->l[3] = (long)dbuffer.st_ctime;
	return(rv);
}
/* ENDCOVER */

int
umask(pmode)
int pmode;
{
}

int
unlink(path)
char *path;	/* BUFOUT[STRING] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/*
 * Graphics Functions - passed to DOS
 */

/* Graphics - Configure */
short
_displaycursor(toggle)
short toggle;
{
}

/* Reasons for additional code:
 *	1) Returns a pointer to a local structure.
 */
struct videoconfig *
_getvideoconfig(config)
struct videoconfig *config;	/* BUFIN[1] */
{
	return(config);	/* RETURN */
}

short
_setactivepage(page)
short page;
{
}

short
_setvideomode(mode)
short mode;
{
}

short
_setvisualpage(page)
short page;
{
}

/* Graphics - Set Coordinates */
/* UCOVER */
/* Reasons for cover:
 *	1) Returns a structure.
 */
struct xycoord
_getlogcoord(x,y)
short x;
short y;
{
	struct xycoord xy;

	(void)Xgetlogcoord(x,y,&xy);
	return(xy);
}
/* ENDCOVER */

Xgetlogcoord(x,y,xy)
short x;
short y;
struct xycoord *xy;	/* BUFIN[1] */
{
}

/* ACOVER */
Xgetlogcoord(x,y,xy)
short x;
short y;
struct xycoord *xy;
{
	*xy = _getlogcoord(x,y);
}
/* ENDCOVER */

/* UCOVER */
/* Reasons for cover:
 *	1) Returns a structure.
 */
struct xycoord
_getphyscoord(x,y)
short x;
short y;
{
	struct xycoord xy;

	(void)Xgetphyscoord(x,y,&xy);
	return(xy);
}
/* ENDCOVER */

Xgetphyscoord(x,y,xy)
short x;
short y;
struct xycoord *xy;	/* BUFIN[1] */
{
}

/* ACOVER */
Xgetphyscoord(x,y,xy)
short x;
short y;
struct xycoord *xy;
{
	*xy = _getphyscoord(x,y);
}
/* ENDCOVER */

void
_setcliprgn(x1,y1,x2,y2)
short x1;
short y1;
short x2;
short y2;
{
}

/* UCOVER */
/* Reasons for cover:
 *	1) Returns a structure.
 */
struct xycoord
_setlogorg(x,y)
short x;
short y;
{
	struct xycoord xy;

	(void)Xsetlogorg(x,y,&xy);
	return(xy);
}
/* ENDCOVER */

Xsetlogorg(x,y,xy)
short x;
short y;
struct xycoord *xy;	/* BUFIN[1] */
{
}

/* ACOVER */
Xsetlogorg(x,y,xy)
short x;
short y;
struct xycoord *xy;
{
	*xy = _setlogorg(x,y);
}
/* ENDCOVER */

void
_setviewport(x1,y1,x2,y2)
short x1;
short y1;
short x2;
short y2;
{
}


/* Graphics - Set Palette */
short
_remapallpalette(colors)
long *colors; 		/* BUFOUT[16] */
{
}

long
_remappalette(pixel, color)
short pixel;
long color;
{
}

short
_selectpalette(number)
short number;
{
}

/* Graphics - Set Attributes */
long
_getbkcolor()
{
}

short
_getcolor()
{
}

unsigned short
_getlinestyle()
{
}

unsigned char *
_getfillmask(mask)
unsigned char *mask;	/* BUFIN[8] */
{
	return(mask); 	/* RETURN */
}

long
_setbkcolor(color)
long color;
{
}

short
_setcolor(color)
short color;
{
}

/* Reasons for cover:				NEED TO COVER !!!!
 *	1) To allow for a NULL mask.
 */
void
_setfillmask(mask)
unsigned char *mask;	/* BUFOUT[8] */
{
}

void
_setlinestyle(mask)
unsigned short mask;
{
}


/* Graphics - Output Images */
short
_arc(x1,y1,x2,y2,x3,y3,x4,y4)
short x1;
short y1;
short x2;
short y2;
short x3;
short y3;
short x4;
short y4;
{
}

void
_clearscreen(area)
short area;
{
}

short
_ellipse(control,x1,y1,x2,y2)
short control;
short x1;
short y1;
short x2;
short y2;
{
}

short
_floodfill(x,y,boundary)
short x;
short y;
short boundary;
{
}

/* UCOVER */
/* Reasons for cover:
 *	1) Returns a structure.
 */
struct xycoord
_getcurrentposition()
{
	struct xycoord xy;

	(void)Xgetcurrentposition(&xy);
	return(xy);
}
/* ENDCOVER */

Xgetcurrentposition(xy)
struct xycoord *xy;		/* BUFIN[1] */
{
}

/* ACOVER */
Xgetcurrentposition(xy)
struct xycoord *xy;
{
	*xy = _getcurrentposition();
}
/* ENDCOVER */

short
_getpixel(x,y)
short x;
short y;
{
}

short
_lineto(x,y)
short x;
short y;
{
}

/* UCOVER */
/* Reasons for cover:
 *	1) Returns a structure.
 */
struct xycoord
_moveto(x,y)
short x;
short y;
{
	struct xycoord xy;

	(void)Xmoveto(x,y,&xy);
	return(xy);
}
/* ENDCOVER */

Xmoveto(x,y,xy)
short x;
short y;
struct xycoord *xy;	/* BUFIN[1] */
{
}

/* ACOVER */
Xmoveto(x,y,xy)
short x;
short y;
struct xycoord *xy;
{
	*xy = _moveto(x,y);
}
/* ENDCOVER */

short
_pie(control,x1,y1,x2,y2,x3,y3,x4,y4)
short control;
short x1;
short y1;
short x2;
short y2;
short x3;
short y3;
short x4;
short y4;
{
}

short
_rectangle(control,x1,y1,x2,y2)
short control;
short x1;
short y1;
short x2;
short y2;
{
}

short
_setpixel(x,y)
short x;
short y;
{
}

/* Graphics - Output Text */
short
_gettextcolor()
{
}

/* UCOVER */
/* Reasons for cover:
 *	1) Returns a structure.
 */
struct rccoord
_gettextposition()
{
	struct rccoord xy;

	(void)Xgettextposition(&xy);
	return(xy);
}
/* ENDCOVER */

Xgettextposition(xy)
struct rccoord *xy;		/* BUFIN[1] */
{
}

/* ACOVER */
Xgettextposition(xy)
struct rccoord *xy;
{
	*xy = _gettextposition();
}
/* ENDCOVER */

void
_outtext(text)
char *text;		/* BUFOUT[STRING] */
{
}

/* UCOVER */
/* Reasons for cover:
 *	1) Returns a structure.
 */
struct rccoord
_settextposition(x,y)
short x;
short y;
{
	struct rccoord xy;

	(void)Xsettextposition(x,y,&xy);
	return(xy);
}
/* ENDCOVER */

Xsettextposition(x,y,xy)
short x;
short y;
struct rccoord *xy;	/* BUFIN[1] */
{
}

/* ACOVER */
Xsettextposition(x,y,xy)
short x;
short y;
struct rccoord *xy;
{
	*xy = _settextposition(x,y);
}
/* ENDCOVER */

short
_settextcolor(pixel)
short pixel;
{
}

void
_settextwindow(r1,c1,r2,c2)
short r1;
short c1;
short r2;
short c2;
{
}

short
_wrapon(option)
short option;
{
}

/* Graphics - Transfer Images */

/* Reasons for additional code:
 *	1) To determine image buffer size at runtime.
 */
void
_getimage(x1,y1,x2,y2,image)
short x1;
short y1;
short x2;
short y2;
char *image; /* BUFIN[_imagesize(x1,y1,x2,y2)] */
{
}

long
_imagesize(x1,y1,x2,y2)
short x1;
short y1;
short x2;
short y2;
{
}

#define IMAGBUFCNT 4096
/* Reasons for additional code:
 *	1) To determine image buffer size at runtime.
 */
void
_putimage(x,y,image,action)
short x;
short y;
char *image;	/* BUFOUT[IMAGBUFCNT] */
short action;
{
}

/*
 * Stream Routines - handled locally by Wizard for efficiency.
 */

#ifdef STREAMS
/* UCOVER */
void
clearerr(stream)
FILE *stream;
{
}

int
fclose(stream)
FILE *stream;
{
}

int
fcloseall(stream)
FILE *stream;
{
}

FILE *
fdopen(handle, type)
int handle;
char *type;
{
}

int
feof(stream)
FILE *stream;
{
}

int
ferror(stream)
FILE *stream;
{
}

int
fflush(stream)
FILE *stream;
{
}

int
fgetc(stream)
FILE *stream;
{
}

int
fgetchar()
{
}

int
fgetpos(stream,pos)
FILE *stream;
long *pos;
{
}

char *
fgets(string, n, stream)
char *string;
int n;
FILE *stream;
{
}

int
fileno(stream)
FILE *stream;
{
}

int
flushall()
{
}

FILE *
fopen(path, type)
char *path;
char *type;
{
}

fprintf()

int
fputc(c, stream)
int c;
FILE *stream;
{
}

int
fputchar(c)
int c;
{
}

int
fputs(string, stream)
char *string;
FILE *stream;
{
}

unsigned int
fread(buffer, size, count, stream)
char *buffer;
unsigned int size;
unsigned int count;
FILE *stream;
{
}

FILE *
freopen(path, type, stream)
char *path;
char *type;
FILE *stream;
{
}

fscanf()

int
fseek(stream, offset, origin)
FILE *stream;
long offset;
int origin;
{
}

int
fsetpos(stream, pos)
FILE *stream;
long *pos;
{
}

long
ftell(stream)
FILE *stream;
{
}

unsigned int
fwrite(buffer, size, count, stream)
char *buffer;
unsigned int size;
unsigned int count;
FILE *stream;
{
}

int
getc(stream)
FILE *stream;
{
}

int
getchar()
{
}

char *
gets(buffer)
char *buffer;
{
}

int
getw(stream)
FILE *stream;
{
}

printf()

int
putc(c, stream)
int c;
FILE *stream;
{
}

int
putchar(c)
int c;
{
}

int
puts(string)
char *string;
{
}

int
putw(binint, stream)
int binint;
FILE *stream;
{
}

void
rewind(stream)
FILE *stream;
{
}

int
rmtmp()
{
}

int
ungetc(c, stream)
int c;
FILE *stream;
{
}

scanf()

setbuf()

setvbuf()

sprintf()

sscanf()

vfprintf()

vprintf()

vsprintf()

tmpfile()

#endif		/* end of streams routines */
/* ENDCOVER */

/* UCOVER */
/* Reasons for cover:
 *	1) Returns a pointer to a string.
 *	2) DOS will malloc() a buffer if NULL arg, so create
 *	   a buffer locally to transfer result back to.
 *	3) Free() previously malloc()'d buffer on subsequent calls.
 */
char *
tempnam(dir, prefix)
char *dir;
char *prefix;
{
	char buffer[_MAX_PATH];
	char *string;
	long rtnval;
	long Utempnam();
	char *strdup();

	rtnval = Xtempnam(dir, prefix, buffer, sizeof(buffer));
	if (rtnval) {
		string = strdup(buffer);
		return(string);
	}
	return(NULL);
}
/* ENDCOVER */

long
Xtempnam(dir, prefix, buffer, max)
char *dir;		/* BUFOUT[STRING] */
char *prefix;		/* BUFOUT[STRING] */
char *buffer;		/* BUFIN[max] */
int max;
{
}

/* ACOVER */
long
Xtempnam(dir, prefix, buffer, max)
char *dir;
char *prefix;
char *buffer;
int max;
{
	char *tempnam();
	char *strcpy();
	static char *name = NULL;

	if (name)
		free(name);
	name = tempnam(dir, prefix);
	if (name) {
		name[max-1] = '\0';
		strcpy(buffer, name);
	}
	return((long)name);
}
/* ENDCOVER */

/* UCOVER */
/* Reasons for cover:
 *	1) Returns a pointer to a string.
 *	2) Uses an internal static buffer if string is NULL.
 *	   This is allocated locally.
 */
char *
tmpnam(string)
char *string;
{
	static char tmpstr[L_tmpnam];
	void Xtmpnam();

	if (!string)
		string = tmpstr;
	Xtmpnam(string);
	return(string);
}
/* ENDCOVER */

void
Xtmpnam(string)
char *string;		/* BUFIO[L_tmpnam] */
{
}

/* ACOVER */
void
Xtmpnam(string)
char *string;
{
	(void)tmpnam(string);
}
/* ENDCOVER */

/*
 * Low-Level Routines - passed to DOS
 */
int
close(handle)
int handle;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
creat(path, pmode)
char *path;		/* BUFOUT[STRING] */
int pmode;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
dup(handle)
int handle;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
dup2(handle1, handle2)
int handle1;
int handle2;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
eof(handle)
int handle;
/* GLOBAL int errno;	BUFIN[1] */
{
}

long
lseek(handle, offset, origin)
int handle;
long offset;
int origin;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
open(path, oflag, pmode)
char *path;		/* BUFOUT[STRING] */
int oflag;
int pmode;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
read(handle,buffer, count)
int handle;
char *buffer;		/* BUFIN[count] */
int count;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
sopen(path, oflag, shflag, pmode)
char *path;		/* BUFOUT[STRING] */
int oflag;
int shflag;
int pmode;
/* GLOBAL int errno;	BUFIN[1] */
{
}

long
tell(handle)
int handle;
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
write(handle, buffer, count)
int handle;
char *buffer;		/* BUFOUT[count] */
unsigned int count;
/* GLOBAL int errno;	BUFIN[1] */
{
}

/*
 * Console & Port I/O - passed to DOS
 */
/* Reason for additional code:
 *	1) Returns a pointer to a char.
 */
char *
cgets(str)
char *str;	/* BUFIO[MAXLINE] */
{
	if (rtnval)		/* RETURN */
		return(str);
	else
		return(NULL);
}

/* Not implemented due to variable number of arguments. */
/* cprintf() */

int
cputs(string)
char *string;	/* BUFOUT[STRING] */
{
}

/* Not implemented due to variable number of arguments. */
/* cscanf() */

int
getch()
{
}

int
getche()
{
}

int
inp(port)
unsigned int port;
{
}

unsigned int
inpw(port)
unsigned int port;
{
}

int
kbhit()
{
}

int
outp(port, byte)
unsigned int port;
int byte;
{
}

unsigned int
outpw(port, word)
unsigned port;
unsigned int word;
{
}

int
putch(c)
int c;
{
}

/* Do not do any streams stuff now
int
ungetch(c, stream)
int c;
FILE *stream;
{
}
*/

/*
 * Math Routines - use unix math lib for now
 */

/*
 * Memory Allocation - handled locally by Wizard
 *
alloca()
calloc()
_expand()
_ffree()
_fheapchk()
_fheapset()
_fheapwalk()
_fmalloc()
free()
_freect()
_fmsize()
halloc()
_heapchk()
_heapset()
_heapwalk()
hfree()
malloc()
_memavl()
_memmax()
_msize()
_nfree()
_nheapchk()
_nheapset()
_nheapwalk()
_nmalloc()
_nmsize()
realloc()
sbrk()
stackavail()
*/

/*
 * Process Control - handled locally in Wizard
 *
abort()
atexit()
execl()
execle()
execlp()
execlpe()
execv()
execve()
execvp()
execvpe()
exit()
_exit()
getpid()
onexit()
raise()
signal()
spawnl()
spawnle()
spawnlp()
spawnlpe()
spawnv()
spawnve()
spawnvp()
spawnvpe()
*/
int
system(string)
char *string;		/* BUFOUT[STRING] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/*
 * Searching and Sorting - handled locally by Wizard
 *
bsearch()
lfind()
lsearch()
qsort()
*/

/*
 * String Manipulation - handled locally by Wizard
 *
strcat()
strchr()
strcmp()
strcmpi()
strcpy()
strcspn()
strdup()
strerror()
stricmp()
strlen()
strlwr()
strncat()
strncmp()
strncpy()
strnicmp()
strnset()
strpbrk()
strrev()
strset()
strspn()
strstr()
strtok()
strupr()
*/

/* UCOVER */
/* Reasons for cover:
 *	1) Returns a pointer to a char.
 *	2) The returned pointer points into the original string
 *	   argument. Since this is a DOS pointer it has no meaning
 *	   as a return value. Therefore, the DOS cover takes the 
 *	   pointer and computes an offset from the start of the string.
 *	   This offset is then returned so the Opus cover can compute
 *	   the offset into the original string in its address space.
 */
char *
strrchr(string, c)	
char *string;
int c;
{
	long index;
	long Xstrrchr();

	index = Xstrrchr(string, c);
	if (index == -1L)
		return(NULL);
	return(string + index);
}
/* ENDCOVER */

long
Xstrrchr(string, c)
char *string;			/* BUFOUT[STRING] */
int c;
{
}

/* ACOVER */
long
Xstrrchr(string, c)
char *string;
int c;
{
	char *ptr;
	char *strrchr();

	ptr = strrchr(string, c);
	if (ptr == NULL)
		return(-1L);
	return(ptr - string);
}
/* ENDCOVER */

/*
 * DOS Sytem Calls - passed to DOS
 */
/* DOS System Calls - BIOS Interface */
#ifdef DISKINFO_T_DEF
/* due to the structure of the header file, "bios.h", the
   structure "diskinfo" is not defined and so this routine
   fails to compile. To use this routine, delete the "NO_EXT_KEYS"
   ifdef around the diskinfo structure definition in that file.
*/
unsigned int
_bios_disk(service, diskinfo)
unsigned int service;
struct diskinfo_t *diskinfo;		/* BUFIO[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}
#endif

unsigned int
_bios_equiplist()
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_bios_keybrd(service)
unsigned int service;
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_bios_memsize()
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_bios_printer(service, printer, data)
unsigned int service;
unsigned int printer;
unsigned int data;
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_bios_serialcom(service, serial_port, data)
unsigned int service;
unsigned int serial_port;
unsigned int data;
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_bios_timeofday(service, timeval)
int service;
long timeval;
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* DOS System Calls - MS-DOS Interface */
int
bdos(dosfn, dosdx, dosal)
int dosfn;
unsigned int dosdx;
unsigned int dosal;
{
}

/* _chain_intr() _disable() _dos_allocmem() */

unsigned int
_dos_close(handle)
int handle;
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_dos_creat(path, attribute, handle)
char *path;		/* BUFOUT[STRING] */
unsigned int attribute;
int *handle;		/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_dos_creatnew(path, attribute, handle)
char *path;		/* BUFOUT[STRING] */
unsigned int attribute;
int *handle;		/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_dos_findfirst(path, attributes, buffer)	/* NAME(Xdos_findfirst) */
char *path;		/* BUFOUT[STRING] */
unsigned int attributes;
struct find_t *buffer;	/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* ACOVER */
/* Reasons for cover:
 *	1) Must align structure members do to different 80286 
 *	   and Opus alignment.
 */
unsigned int
Xdos_findfirst(path, attributes, buffer)
char *path;
unsigned int attributes;
struct ufind_t {
	char c1[22];
	short s1;
	unsigned long ul[2];	/* DOS uint -> ulong for WS uint */
	long l1;
	char c2[13];
   } *buffer;
{
	struct find_t dbuffer;	/* dos find_t buffer */
	unsigned int rv;
	int i;

	rv = _dos_findfirst(path, attributes, &dbuffer);
	/* adjust alignment */
	for ( i=0; i < 22; i++ )
		buffer->c1[i] = (char)dbuffer.reserved[i];
	buffer->s1 = 0;
	buffer->ul[0] = (unsigned long)dbuffer.wr_time;
	buffer->ul[1] = (unsigned long)dbuffer.wr_date;
	buffer->l1 = dbuffer.size;
	for ( i=0; i < 13; i++ )
		buffer->c2[i] = (char)dbuffer.name[i];
	return(rv);
}
/* ENDCOVER */

unsigned int
_dos_findnext(buffer)			/* NAME(Xdos_findnext) */
struct find_t *buffer;	/* BUFIO[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* ACOVER */
/* Reasons for cover:
 *	1) Must align structure members do to different 80286 
 *	   and Opus alignment.
 */
unsigned int
Xdos_findnext(buffer)
struct ufind_t {
	char c1[22];
	short s1;
	unsigned long ul[2];	/* DOS uint -> ulong for WS uint */
	long l1;
	char c2[13];
   } *buffer;
{
	struct find_t dbuffer;	/* dos find_t buffer */
	unsigned int rv;
	int i;

	/* Align WS -> DOS struct */
	for ( i=0; i < 22; i++ )
		dbuffer.reserved[i] = (char)buffer->c1[i];
	dbuffer.wr_time = (unsigned int)buffer->ul[0];
	dbuffer.wr_date = (unsigned int)buffer->ul[1];
	dbuffer.size = buffer->l1;
	for ( i=0; i < 13; i++ )
	dbuffer.name[i] = (char)buffer->c2[i];

	rv = _dos_findnext(&dbuffer);

	/* Align WS -> DOS struct */
	for ( i=0; i < 22; i++ )
		buffer->c1[i] = (char)dbuffer.reserved[i];
	buffer->s1 = 0;
	buffer->ul[0] = (unsigned long)dbuffer.wr_time;
	buffer->ul[2] = (unsigned long)dbuffer.wr_date;
	buffer->l1 = dbuffer.size;
	for ( i=0; i < 13; i++ )
		buffer->c2[i] = (char)dbuffer.name[i];
	return(rv);
}
/* ENDCOVER */

/* _dos_freemem() */

void
_dos_getdate(date)		/* NAME(Xdos_getdate) */
struct dosdate_t *date;		/* BUFIN[1] */
{
}

/* ACOVER */
/* Reasons for cover:
 *	1) Must align structure members do to different 80286 
 *	   and Opus alignment.
 */
void
Xdos_getdate(date)
struct udosdate_t {
    unsigned char day;
    unsigned char month;
    short pad;
    unsigned long year;		/* DOS uint -> ulong for WS uint */
    unsigned char dayofweek;
    } *date;
{
	struct dosdate_t dbuffer;	/* dos dosdate_t buffer */

	_dos_getdate(&dbuffer);

	/* Align DOS struct to WS struct */
	date->day = (unsigned char)dbuffer.day;
	date->month = (unsigned char)dbuffer.month;
	date->pad = 0;
	date->year = (unsigned long)dbuffer.year;
	date->dayofweek = (unsigned char)dbuffer.dayofweek;
}
/* ENDCOVER */

unsigned int
_dos_getdiskfree(drive, diskspace)	/* NAME(Xdos_getdiskfree) */
unsigned int drive;
struct diskfree_t *diskspace;		/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* ACOVER */
/* Reasons for cover:
 *	1) Must align structure members do to different 80286 
 *	   and Opus alignment.
 */
unsigned int
Xdos_getdiskfree(drive, diskspace)
unsigned int drive;
struct udiskfree_t {
	unsigned long ul[4];	/* DOS uint -> ulong for WS uint */
   } *diskspace;
{
	struct diskfree_t dbuffer;	/* dos diskfree_t buffer */
	unsigned int rv;

	rv = _dos_getdiskfree(drive, &dbuffer);

	/* Align DOS struct to WS struct */

	diskspace->ul[0] = (unsigned long)dbuffer.total_clusters;
	diskspace->ul[1] = (unsigned long)dbuffer.avail_clusters;
	diskspace->ul[2] = (unsigned long)dbuffer.sectors_per_cluster;
	diskspace->ul[3] = (unsigned long)dbuffer.bytes_per_sector;

	return(rv);
}
/* ENDCOVER */

void
_dos_getdrive(drive)
unsigned int *drive; 	/* BUFIN[1] */
{
}

unsigned int
_dos_getfileattr(path, attributes)
char *path;		/* BUFOUT[STRING] */
unsigned *attributes;	/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_dos_getftime(handle, date, time)
int handle;
unsigned int *date;	/* BUFIN[1] */
unsigned int *time;	/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

void
_dos_gettime(time)
struct dostime_t *time;	/* BUFIN[1] */
{
}

/* _dos_getvect() */

/* _dos_keep() */

unsigned int
_dos_open(path, mode, handle)
char *path;		/* BUFOUT[STRING] */
unsigned int mode;
int *handle;		/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned
_dos_read(handle, buffer, count, bytes)
int handle;
char *buffer;		/* BUFIN[count] */
unsigned int count;
unsigned int *bytes;	/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* _dos_setblock() */

unsigned int
_dos_setdate(date)		/* NAME(Xdos_setdate) */
struct dosdate_t *date;		/* BUFOUT[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* ACOVER */
unsigned int
Xdos_setdate(date)
struct udosdate_t {
    unsigned char day;
    unsigned char month;
    short pad;
    unsigned long year;		/* DOS uint -> ulong for WS uint */
    unsigned char dayofweek;
    } *date;
{
	struct dosdate_t dbuffer;	/* dos dosdate_t buffer */
	unsigned int rv;

	/* Align WS struct to DOS struct */
	dbuffer.day = (unsigned char)date->day;
	dbuffer.month = (unsigned char)date->month;
	dbuffer.year = (unsigned int)date->year;
	dbuffer.dayofweek = (unsigned char)date->dayofweek;

	rv = _dos_setdate(&dbuffer);

	return(rv);
}
/* ENDCOVER */

void
_dos_setdrive(drivenum, drives)
unsigned int drivenum;
unsigned int *drives;	/* BUFIN[1] */
{
}

unsigned int
_dos_setfileattr(path, attributes)
char *path;		/* BUFOUT[STRING] */
unsigned int attributes;
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_dos_setftime(handle, date, time)
int handle;
unsigned int date;
unsigned int time;
/* GLOBAL int errno;	BUFIN[1] */
{
}

unsigned int
_dos_settime(time)
struct dostime_t *time;		/* BUFOUT[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

/* _dos_setvect() */

unsigned int
_dos_write(handle, buffer, count, bytes)
int handle;
char *buffer;		/* BUFOUT[count] */
unsigned int count;
unsigned int *bytes;	/* BUFIN[1] */
/* GLOBAL int errno;	BUFIN[1] */
{
}

int
dosexterr(buffer)
struct DOSERROR *buffer;	/* BUFIN[1] */
{
}


/* PROBLEM8 */
/* _enable() FP_OFF() FP_SEG() */
/* _harderr() _hardresume() _hardretn() */

int
int86(intno, inregs, outregs)
int intno;
union REGS *inregs;	/* BUFOUT[1] */
union REGS *outregs;	/* BUFIN[1] */
/* GLOBAL int _doserrno;	BUFIN[1] */
{
}

int
int86x(intno, inregs, outregs, segregs)
int intno;
union REGS *inregs;	/* BUFOUT[1] */
union REGS *outregs;	/* BUFIN[1] */
struct SREGS *segregs;	/* BUFOUT[1] */
/* GLOBAL int _doserrno;	BUFIN[1] */
{
}

int
intdos(inregs, outregs)
union REGS *inregs;	/* BUFOUT[1] */
union REGS *outregs;	/* BUFIN[1] */
/* GLOBAL int _doserrno;	BUFIN[1] */
{
}

int
intdosx(inregs, outregs, segregs)
union REGS *inregs;	/* BUFOUT[1] */
union REGS *outregs;	/* BUFIN[1] */
struct SREGS *segregs;	/* BUFOUT[1] */
/* GLOBAL int _doserrno;	BUFIN[1] */
{
}

/* segread() */

/*
 * Time Routines - handled locally by Wizard
 *
asctime()
clock()
ctime()
difftime()
ftime()
gmtime()
localtime()
mktime()
_strdate()
_strtime()
time()
tzset()
utime()
*/

/*
 * Miscellaneous Routines - most handled locally by Wizard
 *
abs()
assert()
div()
getenv()
labs()
ldiv()
longjmp()
_lrotl()
_lrotr()
putenv()
rand()
_rotl()
_rotr()
setjmp()
srand()
swab()
*/

void
perror(string)
char *string;	/* BUFOUT[STRING] */
/* GLOBAL int errno;	BUFOUT[1] */
{
}

/* UCOVER */
/* Reasons for cover:
 *	1) Need to create local buffer for return string since
 *	   we don't know how large the user's buffer is. We use
 *	   strcpy() to copy the returned string into the user's
 *	   buffer, since this will only copy up to the null. We
 *	   have to assume that the user's buffer is large enough
 *	   to hold that much.
 */
void
_makepath(path, drive, dir, fname, ext)
char *path;
char *drive;
char *dir;
char *fname;
char *ext;
{
	char sbuf[_MAX_PATH];
	void Xmakepath();
	char *strcpy();

	Xmakepath(sbuf, drive, dir, fname, ext);
	strcpy(path, sbuf);
}
/* ENDCOVER */

void
Xmakepath(path, drive, dir, fname, ext)
char *path;		/* BUFIN[_MAX_PATH] */
char *drive;		/* BUFOUT[STRING] */
char *dir;		/* BUFOUT[STRING] */
char *fname;		/* BUFOUT[STRING] */
char *ext;		/* BUFOUT[STRING] */
{
}

/* ACOVER */
void
Xmakepath(path, drive, dir, fname, ext)
char *path;
char *drive;
char *dir;
char *fname;
char *ext;
{
	(void)_makepath(path, drive, dir, fname, ext);
}
/* ENDCOVER */


/* UCOVER */
/* Reasons for cover:
 *	1) Need to create local buffer for return string since
 *	   we don't know how large the user's buffer is. We use
 *	   strcpy() to copy the returned string into the user's
 *	   buffer, since this will only copy up to the null. We
 *	   have to assume that the user's buffer is large enough
 *	   to hold that much.
 */
void
_searchenv(name, env_var, path)
char *name;
char *env_var;
char *path;
{
	char sbuf[_MAX_PATH];
	void Xsearchenv();
	char *strcpy();

	Xsearchenv(name, env_var, sbuf);
	sbuf[_MAX_PATH] = '\0';
	strcpy(path, sbuf);
}
/* ENDCOVER */

void
Xsearchenv(name, env_var, path)
char *name;		/* BUFOUT[STRING] */
char *env_var;		/* BUFOUT[STRING] */
char *path;		/* BUFIN[_MAX_PATH] */
{
}

/* ACOVER */
void
Xsearchenv(name, env_var, path)
char *name;
char *env_var;
char *path;
{
	(void)_searchenv(name, env_var, path);
}
/* ENDCOVER */


/* UCOVER */
/* Reasons for cover:
 *	1) Need to create local buffers for return strings since
 *	   we don't know how large the user's buffers are. We use
 *	   strcpy() to copy the returned strings into the user's
 *	   buffers, since this will only copy up to the null. We
 *	   have to assume that the user's buffers are large enough
 *	   to hold that much.
 */
void
_splitpath(path, drive, dir, fname, ext)
char *path;
char *drive;
char *dir;
char *fname;
char *ext;
{
	char drvbuf[_MAX_DRIVE];
	char dirbuf[_MAX_DIR];
	char filbuf[_MAX_FNAME];
	char extbuf[_MAX_EXT];
	void Xsplitpath();
	char *strcpy();

	Xsplitpath(path, drvbuf, dirbuf, filbuf, extbuf);
printf("%s %s %s %s\n",drvbuf,dirbuf,filbuf,extbuf);
	strcpy(drive, drvbuf);
	strcpy(dir, dirbuf);
	strcpy(fname, filbuf);
	strcpy(ext, extbuf);
}
/* ENDCOVER */

void
Xsplitpath(path, drive, dir, fname, ext)
char *path;	/* BUFOUT[STRING] */
char *drive;	/* BUFIN[_MAX_DRIVE] */
char *dir;	/* BUFIN[_MAX_DIR] */
char *fname;	/* BUFIN[_MAX_FNAME] */
char *ext;	/* BUFIN[_MAX_EXT] */
{
}

/* ACOVER */
void
Xsplitpath(path, drive, dir, fname, ext)
char *path;
char *drive;
char *dir;
char *fname;
char *ext;
{
	(void)_splitpath(path, drive, dir, fname, ext);
}
/* ENDCOVER */
