OS_Develop/dos_compilers
OS_Develop/dos_compilers
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

microsoft c v2.03

Browse Source
This commit is contained in:
davidly 2024-06-30 13:40:22 -07:00
parent c4ecbf7d91
commit 57bc7d132d
35 changed files with 1982 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
Microsoft C v203/CAT.C Normal file
View File

@ -0,0 +1,33 @@
/* (This program is from p. 154 of the Kernighan and Ritchie text */
#include <stdio.h>
main(argc, argv) /* cat: concatenate files */
int argc;
char *argv[];
{
FILE *fp, *fopen();
if (argc == 1) /* no args; copy standard input */
filecopy(stdin);
else
while (--argc > 0)
if ((fp = fopen(*++argv, "r")) == NULL) {
fprintf(stderr,
"cat: can't open %s\n", *argv);
exit(1);
} else {
filecopy(fp);
fclose(fp);
}
exit(0);
}
filecopy(fp) /* copy file fp to standard output */
FILE *fp;
{
int c;
while ((c = getc(fp)) != EOF)
putc(c, stdout);
}
p) /* cop

9
Microsoft C v203/CC.BAT Normal file
View File

@ -0,0 +1,9 @@
mc1 %1%
if errorlevel 1 goto skip
mc2 %1%
if errorlevel 1 goto skip
link %1% + cs,, nul.map, mcs
if errorlevel 1 goto skip
del %1%.obj
:skip


121
Microsoft C v203/CONIO.C Normal file
View File

@ -0,0 +1,121 @@
/**
*
* This module defines the various console I/O functions. They may
* be called directly, using the names included here, or the header
* file CONIO.H may be included so that more standard names may be
* used. This source module is provided so that users may customize
* the console I/O functions, if desired. Note that "cprintf" and
* "cscanf" (included in LC.LIB) call the functions "putch", "getch",
* and "ungetch".
*
**/
#define BDOS_IN 8 /* input function for "getch" */
#define BDOS_INE 1 /* input function for "getche" */
#define BDOS_OUT 6 /* output function for "putch" */
#define BDOS_CKS 11 /* check keyboard status for "kbhit" */
static char pushback = 0; /* character save for "ungetch" */
/**/
/**
*
* name getch -- get character from console
* getche - get character from console and echo it
*
* synopsis c = getch();
* char c; input character
*
* description These functions obtain the next character typed at
* the console or, if one was pushed back via "ungetch",
* returns the previously pushed back character.
*
**/
getch()
{
char c;
if(pushback)
{
c = pushback;
pushback = 0;
return(c);
}
return(bdos(BDOS_IN));
}
getche()
{
char c;
if(pushback)
{
c = pushback;
pushback = 0;
return(c);
}
return(bdos(BDOS_INE));
}
/**/
/**
*
* name putch -- send character directly to console
*
* synopsis putch(c);
* char c; character to be sent
*
* description This function sends the specified character directly
* to the user's console.
*
**/
putch(c)
char c;
{
bdos(BDOS_OUT, c&127);
return(c);
}
/**/
/**
*
* name ungetch -- push character back to console
*
* synopsis r = ungetch(c);
* int r; return code
* char c; character to be pushed back
*
* description This function pushes the indicated character back
* on the console. Only a single level of pushback is
* allowed. The effect is to cause "getch" to return
* the pushed-back character the next time it is called.
*
* returns r = -1 if character already pushed back
* = c otherwise
*
**/
ungetch(c)
char c;
{
if (pushback != '\0') return(-1);
pushback = c;
return(c);
}
/**/
/**
*
* name kbhit -- check if character has been typed at console
*
* synopsis status = kbhit();
* int status; 1 if character typed, else 0
*
* description This function checks to see if a character has been
* typed at the user's console since the completion of
* the last read operation. The character typed can
* be obtained by a "getch" call.
*
* returns 0 if no character has been typed
* 1 if a character is waiting to be read
*
**/
kbhit()
{
return(bdos(BDOS_CKS) != 0);
}

BIN
Microsoft C v203/CS.OBJ Normal file
View File

Binary file not shown.

53
Microsoft C v203/CTYPE.H Normal file
View File

@ -0,0 +1,53 @@
/**
*
* This header file defines various ASCII character manipulation macros,
* as follows:
*
* isalpha(c) non-zero if c is alpha
* isupper(c) non-zero if c is upper case
* islower(c) non-zero if c is lower case
* isdigit(c) non-zero if c is a digit (0 to 9)
* isxdigit(c) non-zero if c is a hexadecimal digit (0 to 9, A to F,
* a to f)
* isspace(c) non-zero if c is white space
* ispunct(c) non-zero if c is punctuation
* isalnum(c) non-zero if c is alpha or digit
* isprint(c) non-zero if c is printable (including blank)
* isgraph(c) non-zero if c is graphic (excluding blank)
* iscntrl(c) non-zero if c is control character
* isascii(c) non-zero if c is ASCII
* iscsym(c) non-zero if valid character for C symbols
* iscsymf(c) non-zero if valid first character for C symbols
*
**/
#define _U 1 /* upper case flag */
#define _L 2 /* lower case flag */
#define _N 4 /* number flag */
#define _S 8 /* space flag */
#define _P 16 /* punctuation flag */
#define _C 32 /* control character flag */
#define _B 64 /* blank flag */
#define _X 128 /* hexadecimal flag */
extern char _ctype[]; /* character type table */
#define isalpha(c) (_ctype[(c)+1]&(_U|_L))
#define isupper(c) (_ctype[(c)+1]&_U)
#define islower(c) (_ctype[(c)+1]&_L)
#define isdigit(c) (_ctype[(c)+1]&_N)
#define isxdigit(c) (_ctype[(c)+1]&_X)
#define isspace(c) (_ctype[(c)+1]&_S)
#define ispunct(c) (_ctype[(c)+1]&_P)
#define isalnum(c) (_ctype[(c)+1]&(_U|_L|_N))
#define isprint(c) (_ctype[(c)+1]&(_P|_U|_L|_N|_B))
#define isgraph(c) (_ctype[(c)+1]&(_P|_U|_L|_N))
#define iscntrl(c) (_ctype[(c)+1]&_C)
#define isascii(c) ((unsigned)(c)<=127)
#define iscsym(c) (isalnum(c)||(((c)&127)==0x5f))
#define iscsymf(c) (isalpha(c)||(((c)&127)==0x5f))
#define toupper(c) (islower(c)?((c)-('a'-'A')):(c))
#define tolower(c) (isupper(c)?((c)+('a'-'A')):(c))
#define toascii(c) ((c)&127)


24
Microsoft C v203/DM8086.H Normal file
View File

@ -0,0 +1,24 @@
/**
*
* The following definitions specify which memory addressing model is in use
* for wacky chips of the Intel 8086 variety.
*
* I8086S 64K program, 64K data
* I8086D 64K program, 1M data
* I8086P 1M program, 64K data
* I8086L 1M program, 1M data
*
*/
#define I8086D 1
/**
*
* The following definitions indicate which type of integer has the same size
* as a pointer.
*
* SPTR defined if sizeof(pointer) == sizeof(short int)
* LPTR defined if sizeof(pointer) == sizeof(long int)
*
*/
#define LPTR 1


258
Microsoft C v203/DOS.H Normal file
View File

@ -0,0 +1,258 @@
/**
*
* This header file supplies information needed to interface with the
* particular operating system and C compiler being used.
*
**/
/**
*
* The following symbols define which processor is being used.
*
* I8080 Intel 8080
* I8085 Intel 8085
* Z80 Zilog Z80
* I8086 Intel 8086 or 8088
* M68000 Motorola 68000
* GA16 General Automation 16-bit mini
* IBMPC IBM Personal Computer (also sets I8086)
*/
#define IBMPC 1
#ifdef IBMPC
#define I8086 1
#endif
#ifdef I8086
#include "m8086.h"
#endif
/**
*
* The following symbols specify which operating system is being used.
*
* CPM Any CP/M OS
* CPM80 CP/M for Intel 8080 or Zilog Z80
* CPM86 CP/M for Intel 8086
* CPM68 CP/M for Motorola 68000
* MSDOS Microsoft's MSDOS
* MSDOS1 MSDOS Version 1 (also sets MSDOS)
* MSDOS2 MSDOS Version 2 (also sets MSDOS)
*
* Note: CPM will be set to 1 for any of the above.
*
* UNIX "Standard" UNIX
* QUNIX Quantum's QUNIX OS
* MIBS General Automation's MIBS OS
* OASIS OASIS OS
* PICK PICK OS
*
*/
#define MSDOS 1
#ifdef MSDOS
#include "msdos.h"
#endif
#ifdef CPM80
#define CPM 1
#endif
#ifdef CPM86
#define CPM 1
#endif
#ifdef CPM68
#define CPM 1
#endif
#ifdef MSDOS
#define CPM 1
#endif
/**
*
* The following definitions specify the particular C compiler being used.
*
* LATTICE Lattice C compiler
* BDS BDS C compiler
* BTL Bell Labs C compiler or equivalent
* MANX MANX Aztec C compiler
*
*/
#define LATTICE 1
/**
*
* The following type definitions take care of the particularly nasty
* machine dependency caused by the unspecified handling of sign extension
* in the C language. When converting "char" to "int" some compilers
* will extend the sign, while others will not. Both are correct, and
* the unsuspecting programmer is the loser. For situations where it
* matters, the new type "byte" is equivalent to "unsigned char".
*
*/
#ifdef LATTICE
typedef char byte;
#endif
#ifdef BDS
#define byte char
#endif
#ifdef BTL
typedef unsigned char byte;
#endif
#ifdef MANX
#define byte char
#endif
/**
*
* Miscellaneous definitions
*
*/
#define SECSIZ 128 /* disk sector size */
#ifdef CPM
#define DMA (char *)0x80 /* disk buffer address */
#endif
/**
*
* The following structure is a File Control Block. Operating systems
* with CPM-like characteristics use the FCB to store information about
* a file while it is open.
*
*/
struct FCB
{
char fcbdrv; /* drive code */
char fcbnam[8]; /* file name */
char fcbext[3]; /* file name extension */
#ifdef MSDOS
short fcbcb; /* current block number */
short fcblrs; /* logical record size */
long fcblfs; /* logical file size */
short fcbdat; /* create/change date */
char fcbsys[10]; /* reserved */
char fcbcr; /* current record number */
long fcbrec; /* random record number */
#else
char fcbexn; /* extent number */
char fcbs1; /* reserved */
char fcbs2; /* reserved */
char fcbrc; /* record count */
char fcbsys[16]; /* reserved */
char fcbcr; /* current record number */
short fcbrec; /* random record number */
char fcbovf; /* random record overflow */
#endif
};
#define FCBSIZ sizeof(struct FCB)
/**
*
* The following symbols define the sizes of file names and node names.
*
*/
#ifdef CPM
#define FNSIZE 16 /* maximum file node name size */
#define FMSIZE 16 /* maximum file name size */
#endif
#ifdef MSDOS2
#define FNSIZE 16
#define FMSIZE 64
#endif
#ifdef UNIX
#define FNSIZE 16
#define FMSIZE 64
#endif
/**
*
* The following structures define the 8086 registers that are passed to
* various low-level operating system service functions.
*
*/
#ifdef I8086
struct XREG
{
short ax,bx,cx,dx,si,di;
};
struct HREG
{
byte al,ah,bl,bh,cl,ch,dl,dh;
};
union REGS
{
struct XREG x;
struct HREG h;
};
struct SREGS
{
short es,cs,ss,ds;
};
#endif
/**
*
* The following symbols define the code numbers for the various service
* functions.
*
*/
#ifdef MSDOS
#define SVC_DATE 0x2a /* get date */
#define SVC_TIME 0x2c /* get time */
#endif
/**
*
* The following codes are used to open files in various modes.
*
*/
#ifdef LATTICE
#define OPENR 0x8000 /* open for reading */
#define OPENW 0x8001 /* open for writing */
#define OPENU 0x8002 /* open for read/write */
#define OPENC 0x8001 /* create and open for writing */
#else
#define OPENR 0
#define OPENW 1
#define OPENU 2
#endif
/**
*
* The following codes are returned by the low-level operating system service
* calls. They are usually placed into _oserr by the OS interface functions.
*
*/
#if MSDOS2
#define E_FUNC 1 /* invalid function code */
#define E_FNF 2 /* file not found */
#define E_PNF 3 /* path not found */
#define E_NMH 4 /* no more file handles */
#define E_ACC 5 /* access denied */
#define E_IFH 6 /* invalid file handle */
#define E_MCB 7 /* memory control block problem */
#define E_MEM 8 /* insufficient memory */
#define E_MBA 9 /* invalid memory block address */
#define E_ENV 10 /* invalid environment */
#define E_FMT 11 /* invalid format */
#define E_IAC 12 /* invalid access code */
#define E_DATA 13 /* invalid data */
#define E_DRV 15 /* invalid drive code */
#define E_RMV 16 /* remove denied */
#define E_DEV 17 /* invalid device */
#define E_NMF 18 /* no more files */
#endif


BIN
Microsoft C v203/ERROR.H Normal file
View File

Binary file not shown.

28
Microsoft C v203/FCNTL.H Normal file
View File

@ -0,0 +1,28 @@
/**
*
* The following symbols are used for the "open" and "creat" functions.
*
**/
#define O_RDONLY 0 /* Read-only value (right byte of mode word) */
#define O_WRONLY 1 /* Write-only value */
#define O_RDWR 2 /* Read-write value */
#define O_NDELAY 4 /* Non-blocking I/O flag */
#define O_APPEND 8 /* Append mode flag */
#define O_CREAT 0x0100 /* File creation flag */
#define O_TRUNC 0x200 /* File truncation flag */
#define O_EXCL 0x400 /* Exclusive access flag */
#define O_RAW 0x8000 /* Raw I/O flag (Lattice feature) */
/**
*
* The following symbols are used for the "fcntl" function.
*
*/
#define F_DUPFD 0 /* Duplicate file descriptor */
#define F_GETFD 1 /* Get file descriptor flags */
#define F_SETFD 2 /* Set file descriptor flags */
#define F_GETFL 3 /* Get file flags */
#define F_SETFL 4 /* Set file flags */


23
Microsoft C v203/FTOC.C Normal file
View File

@ -0,0 +1,23 @@
/* print Fahrenheit-Celsius table
for f = 0, 20, ..., 300
(This program is from p. 8 of the Kernighan and Ritchie text)
*/
main()
{
int lower, upper, step;
float fahr, celsius;
lower = 0; /* lower limit of temperature table */
upper = 300; /* upper limit */
step = 20; /* step size */
fahr = lower;
while (fahr <= upper) {
celsius = (5.0/9.0) * (fahr-32.0);
printf("%4.0f %6.1f\n", fahr, celsius);
fahr = fahr + step;
}
}
 celsius = (5.0/9.0) * (fahr-32.0);
printf("%4.0f %6.1f\n", fahr, celsius);
fahr = fahr +

149
Microsoft C v203/FXU.C Normal file
View File

@ -0,0 +1,149 @@
/**
* name fxu -- function extract utility
*
* usage fxu filename function
*
* where "filename" is the name of a file containing
* several C functions, and "function" is the name of
* the particular function to be extracted. If the
* named function is found, then (1) standard input is
* copied to the standard output until EOF, and (2) the
* text of the named function is written to the standard
* output. The first option allows header information
* to be prepended to the output file.
*
**/
#include "stdio.h"
#include "ctype.h"
#define MAX 16 /* maximum characters in function name */
#define MAXBUF 2000 /* maximum characters buffered between functions */
main(argc, argv)
int argc;
char *argv[];
{
int c, brace, cnest, nc;
int i, ns, copy, inlit, delim, pc;
FILE *sfp;
char symbol[MAX+1];
char text[MAXBUF];
if (argc != 3)
{
fputs("Usage: fxu filename function\n", stderr);
exit(1);
}
if ((sfp = fopen(argv[1], "r")) == NULL)
{
fputs("Can't open source file\n", stderr);
exit(1);
}
brace = cnest = nc = ns = copy = inlit = pc = 0;
c = getc(sfp); /* get first char */
while (c != EOF)
{ /* scan through source file */
if (ns == MAXBUF)
{
fputs("Maximum buffer size exceeded\n", stderr);
exit(1);
}
if (copy == 0)
{
if (brace == 0) text[ns++] = c; /* save chars between functions */
}
else
if (putchar(c) == EOF)
{
fputs("Copy error\n", stderr);
exit(1);
}
if (c == '/')
{ /* possible comment */
nc = 0;
if ((c = getc(sfp)) == '*')
{
++cnest; /* bump nesting level */
if (copy) putchar(c);
else if (brace == 0) text[ns++] = c;
c = getc(sfp);
}
continue;
}
if (cnest != 0)
{ /* inside comment */
if (c == '*')
{
if ((c = getc(sfp)) == '/')
{
--cnest; /* reduce nesting level */
if (copy) putchar(c);
else if (brace == 0) text[ns++] = c;
c = getc(sfp);
}
continue;
}
nc = 0;
}
else if (inlit)
{ /* inside literal string */
if (c == '\\' && pc == '\\') c = 0;
if (c == delim && pc != '\\') inlit = 0;
pc = c; /* save previous character */
}
else if (c == '\'' || c == '\"')
{ /* enter literal string */
inlit = 1;
pc = 0;
delim = c;
}
else if (c == '{') ++brace;
else if (c == '}')
{ /* right brace */
nc = 0;
if (--brace == 0)
if (copy == 0) ns = 0; /* reset save index if not found */
else
{ /* copy complete */
putchar('\n');
exit(0);
}
}
else if (brace == 0)
{
if (nc == 0)
{ /* symbol not started yet */
if (iscsymf(c))
symbol[nc++] = c; /* start new symbol */
}
else if (iscsym(c) || c == '$')
/* continue symbol */
if (nc < MAX) symbol[nc++] = c;
else symbol[0] = '\0';
else if (nc != 0)
{ /* end of current symbol */
symbol[nc++] = '\0';
if (strcmp(symbol,argv[2]) == 0)
{ /* named function has been found */
while ((c = getchar()) != EOF)
putchar(c); /* copy standard input to output */
for (i = 0; i < ns; i++)
putchar(text[i]); /* copy saved characters */
copy = 1; /* turn on copy flag */
}
nc = 0;
}
}
c = getc(sfp); /* get next char */
}
fputs("Named function not found\n", stderr);
exit(1);
}
 }
}
c = getc(sfp); /* get next char */
}
fputs("Name

BIN
Microsoft C v203/FXU.EXE Normal file
View File

Binary file not shown.

53
Microsoft C v203/IOS1.H Normal file
View File

@ -0,0 +1,53 @@
/**
*
* The following structure is a UNIX file block that retains information about
* a file being accessed via the level 1 I/O functions.
*/
struct UFB
{
char ufbflg; /* flags */
char ufbtyp; /* device type */
#if MSDOS
#if MSDOS2
int ufbfh; /* file handle */
#else
struct FCB ufbfcb; /* file control block */
#endif
#else
struct FAB
{
struct FCB fcb; /* file control block */
char wf; /* buffer write flag */
long fpos; /* file position */
long eof; /* end of file */
long peof; /* previous end of file */
int bn; /* block number */
char b[128]; /* block buffer */
}
ufbfcb;
#endif
};
#define NUFBS 20 /* number of UFBs defined */
/*
*
* UFB.ufbflg definitions
*
*/
#define UFB_OP 0x80 /* file is open */
#define UFB_RA 0x40 /* reading is allowed */
#define UFB_WA 0x20 /* writing is allowed */
#define UFB_NT 0x10 /* access file with no translation */
#define UFB_AP 8 /* append mode flag */
/*
*
* UFB.ufbtyp definitions
*
*/
#define D_DISK 0
#define D_CON 1
#define D_PRN 2
#define D_AUX 3
#define D_NULL 4


BIN
Microsoft C v203/LIB.EXE Normal file
View File

Binary file not shown.

BIN
Microsoft C v203/LINK.EXE Normal file
View File

Binary file not shown.

24
Microsoft C v203/LM8086.H Normal file
View File

@ -0,0 +1,24 @@
/**
*
* The following definitions specify which memory addressing model is in use
* for wacky chips of the Intel 8086 variety.
*
* I8086S 64K program, 64K data
* I8086D 64K program, 1M data
* I8086P 1M program, 64K data
* I8086L 1M program, 1M data
*
*/
#define I8086L 1
/**
*
* The following definitions indicate which type of integer has the same size
* as a pointer.
*
* SPTR defined if sizeof(pointer) == sizeof(short int)
* LPTR defined if sizeof(pointer) == sizeof(long int)
*
*/
#define LPTR 1


BIN
Microsoft C v203/M8086.H Normal file
View File

Binary file not shown.

109
Microsoft C v203/MAIN.C Normal file
View File

@ -0,0 +1,109 @@
#include "dos.h"
#include "stdio.h"
#include "ctype.h"
#include "ios1.h"
#define MAXARG 32 /* maximum command line arguments */
extern int _stack;
extern char _iname[],_oname[];
extern struct UFB _ufbs[];
int argc; /* arg count */
char *argv[MAXARG]; /* arg pointers */
/**
*
* name _main - process command line, open files, and call "main"
*
* synopsis _main(line);
* char *line; ptr to command line that caused execution
*
* description This function performs the standard pre-processing for
* the main module of a C program. It accepts a command
* line of the form
*
* pgmname arg1 arg2 ...
*
* and builds a list of pointers to each argument. The first
* pointer is to the program name. For some environments, the
* standard I/O files are also opened, using file names that
* were set up by the OS interface module XCMAIN.
*
**/
_main(line)
char *line;
{
char c;
#if (UNIX | MSDOS2) == 0
FILE *fp0, *fp1, *fp2;
extern int _bufsiz;
char *getmem();
#endif
/*
*
* Build argument pointer list
*
*/
for(argc = 0; argc < MAXARG; )
{
while(isspace(*line)) line++;
if(*line == '\0') break;
argv[argc++] = line;
while((*line != '\0') && (isspace(*line) == 0)) line++;
c = *line;
*line++ = '\0';
if(c == '\0') break;
}
/*
*
* Open standard files
*
*/
#if (UNIX | MSDOS2) == 0
fp0 = freopen(_iname,"r",stdin);
if(_oname[0] != '>') fp1 = freopen(_oname,"w",stdout);
else fp1 = freopen(&_oname[1],"a",stdout);
fp2 = freopen("","a",stderr);
if (fp2 == NULL) _exit(1);
if (fp0 == NULL)
{
fputs("Can't open stdin file\n", fp2);
exit(1);
}
setbuf(fp0, getmem(_bufsiz)); /* set stdin buffered */
fp0->_flag &= ~_IOMYBUF; /* allow rlsmem if later set unbuff'd */
if (fp1 == NULL)
{
fputs("Can't open stdout file\n", fp2);
exit(1);
}
#endif
#ifdef MSDOS2
stdin->_file = 0;
stdin->_flag = _IOREAD;
stdout->_file = 1;
stdout->_flag = _IOWRT;
stderr->_file = 2;
stderr->_flag = _IOWRT | _IONBF;
_ufbs[0].ufbflg = UFB_OP | UFB_RA;
_ufbs[1].ufbfh = 1;
_ufbs[1].ufbflg = UFB_OP | UFB_WA;
_ufbs[2].ufbfh = 2;
_ufbs[2].ufbflg = UFB_OP | UFB_WA;
if (_fgdi(1) & 0x80) stdout->_flag |= _IONBF;
#endif
/*
*
* Call user's main program
*
*/
main(argc,argv); /* call main function */
exit(0);
}


BIN
Microsoft C v203/MC1.EXE Normal file
View File

Binary file not shown.

BIN
Microsoft C v203/MC2.EXE Normal file
View File

Binary file not shown.

BIN
Microsoft C v203/MCS.LIB Normal file
View File

Binary file not shown.

82
Microsoft C v203/MM.C Normal file
View File

@ -0,0 +1,82 @@
/* BYTE magazine October 1982. Jerry Pournelle. */
/* ported to C by David Lee */
/* various bugs not found because dimensions are square fixed by David Lee */
/* expected result: 4.65880E+05 */
#define LINT_ARGS
#include <stdio.h>
#define l 20 /* rows in A and resulting matrix C */
#define m 20 /* columns in A and rows in B (must be identical) */
#define n 20 /* columns in B and resulting matrix C */
#define ftype float
ftype Summ;
ftype A[ l + 1 ] [ m + 1 ];
ftype B[ m + 1 ] [ n + 1 ];
ftype C[ l + 1 ] [ n + 1 ];
int filla()
{
int i, j;
for ( i = 1; i <= l; i++ )
for ( j = 1; j <= m; j++ )
A[ i ] [ j ] = i + j;
return 0;
}
int fillb()
{
int i, j;
for ( i = 1; i <= m; i++ )
for ( j = 1; j <= n; j++ )
B[ i ] [ j ] = (ftype) (int) ( ( i + j ) / j );
return 0;
}
int fillc()
{
int i, j;
for ( i = 1; i <= l; i++ )
for ( j = 1; j <= n; j++ )
C[ i ] [ j ] = 0;
return 0;
}
int matmult()
{
int i, j, k;
for ( i = 1; i <= l; i++ )
for ( j = 1; j <= n; j++ )
for ( k = 1; k <= m; k++ )
C[ i ] [ j ] += A[ i ] [ k ] * B[ k ] [ j ];
return 0;
}
int summit()
{
int i, j;
for ( i = 1; i <= l; i++ )
for ( j = 1; j <= n; j++ )
Summ += C[ i ] [ j ];
return 0;
}
int main( argc, argv ) int argc; char * argv[];
{
Summ = 0;
filla();
fillb();
fillc();
matmult();
summit();
printf( "summ is : %lf\n", Summ );
return 0;
}

8
Microsoft C v203/MSDOS.H Normal file
View File

@ -0,0 +1,8 @@
/**
*
* This module contains definitions for MSDOS Version 2
*
*/
#define MSDOS2 1


BIN
Microsoft C v203/OMD.EXE Normal file
View File

Binary file not shown.

24
Microsoft C v203/PM8086.H Normal file
View File

@ -0,0 +1,24 @@
/**
*
* The following definitions specify which memory addressing model is in use
* for wacky chips of the Intel 8086 variety.
*
* I8086S 64K program, 64K data
* I8086D 64K program, 1M data
* I8086P 1M program, 64K data
* I8086L 1M program, 1M data
*
*/
#define I8086P 1
/**
*
* The following definitions indicate which type of integer has the same size
* as a pointer.
*
* SPTR defined if sizeof(pointer) == sizeof(short int)
* LPTR defined if sizeof(pointer) == sizeof(long int)
*
*/
#define SPTR 1


29
Microsoft C v203/SIEVE.C Normal file
View File

@ -0,0 +1,29 @@
#define true 1
#define false 0
#define size 8190
#define sizepl 8191
main() {
int i,prime,k,count,iter;
char flags[sizepl];
printf("10 iterations\n");
for(iter=1;iter<= 10;iter++){
count=0;
for(i = 0; i<=size;i++)
flags[i]=true;
for(i=0;i <= size; i++){
if(flags[i]){
prime = i+i+3;
k=i+prime;
while(k<=size){
flags[k] = false;
k += prime;
}
count = count+1;
}
}
}
printf("\n%d primes\n",count);
}


24
Microsoft C v203/SM8086.H Normal file
View File

@ -0,0 +1,24 @@
/**
*
* The following definitions specify which memory addressing model is in use
* for wacky chips of the Intel 8086 variety.
*
* I8086S 64K program, 64K data
* I8086D 64K program, 1M data
* I8086P 1M program, 64K data
* I8086L 1M program, 1M data
*
*/
#define I8086S 1
/**
*
* The following definitions indicate which type of integer has the same size
* as a pointer.
*
* SPTR defined if sizeof(pointer) == sizeof(short int)
* LPTR defined if sizeof(pointer) == sizeof(long int)
*
*/
#define SPTR 1


61
Microsoft C v203/STDIO.H Normal file
View File

@ -0,0 +1,61 @@
/**
*
* This header file defines the information used by the standard I/O
* package.
*
**/
#define _BUFSIZ 512 /* standard buffer size */
#define BUFSIZ 512 /* standard buffer size */
#define _NFILE 20 /* maximum number of files */
struct _iobuf
{
char *_ptr; /* current buffer pointer */
int _rcnt; /* current byte count for reading */
int _wcnt; /* current byte count for writing */
char *_base; /* base address of I/O buffer */
char _flag; /* control flags */
char _file; /* file number */
int _size; /* size of buffer */
char _cbuff; /* single char buffer */
char _pad; /* (pad to even number of bytes) */
};
extern struct _iobuf _iob[_NFILE];
#define _IOREAD 1 /* read flag */
#define _IOWRT 2 /* write flag */
#define _IONBF 4 /* non-buffered flag */
#define _IOMYBUF 8 /* private buffer flag */
#define _IOEOF 16 /* end-of-file flag */
#define _IOERR 32 /* error flag */
#define _IOSTRG 64
#define _IORW 128 /* read-write (update) flag */
#define NULL 0 /* null pointer value */
#define FILE struct _iobuf /* shorthand */
#define EOF (-1) /* end-of-file code */
#define stdin (&_iob[0]) /* standard input file pointer */
#define stdout (&_iob[1]) /* standard output file pointer */
#define stderr (&_iob[2]) /* standard error file pointer */
#define getc(p) (--(p)->_rcnt>=0? *(p)->_ptr++:_filbf(p))
#define getchar() getc(stdin)
#define putc(c,p) (--(p)->_wcnt>=0? ((int)(*(p)->_ptr++=(c))):_flsbf((c),p))
#define putchar(c) putc(c,stdout)
#define feof(p) (((p)->_flag&_IOEOF)!=0)
#define ferror(p) (((p)->_flag&_IOERR)!=0)
#define fileno(p) (p)->_file
#define rewind(fp) fseek(fp,0L,0)
#define fflush(fp) _flsbf(-1,fp)
FILE *fopen();
FILE *freopen();
long ftell(); Šchar *fgets();
#define abs(x) ((x)<0?-(x):(x))
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<=(b)?(a):(b))


33
Microsoft C v203/TINYMAIN.C Normal file
View File

@ -0,0 +1,33 @@
/**
*
* This module defines a version of _main which processes the
* command line for arguments but does not open "stdin", "stdout",
* and "stderr". Since these files are not opened, the library
* functions "printf" and "scanf" will not work; however, the
* console functions "cprintf" and "cscanf" can be used instead.
*
**/
#include "CTYPE.H"
#define MAXARG 32 /* maximum command line arguments */
_main(line)
char *line;
{
static int argc = 0;
static char *argv[MAXARG];
while (isspace(*line)) line++; /* find program name */
while (*line != '\0' && argc < MAXARG)
{ /* get command line parameters */
argv[argc++] = line;
while (*line != '\0' && isspace(*line) == 0) line++;
if (*line == '\0') break;
*line++ = '\0';
while (isspace(*line)) line++;
}
main(argc, argv); /* call main function */
_exit(0);
}
break;
*line++ = '\0';

33
Microsoft C v203/e.c Normal file
View File

@ -0,0 +1,33 @@
/*#include <string.h>*/
#include <stdio.h>
/*#include <stdlib.h> */
#define DIGITS_TO_FIND 200 /*9009*/
int main() {
int N = DIGITS_TO_FIND;
char buf[ 128 ];
int x = 0;
int a[ DIGITS_TO_FIND ];
int n;
for (n = N - 1; n > 0; --n) {
a[n] = 1;
}
a[1] = 2, a[0] = 0;
while (N > 9) {
n = N--;
while (--n) {
a[n] = x % n;
x = 10 * a[n-1] + x/n;
}
printf("%d", x);
}
printf( "\ndone\n" );
return 0;
}

11
Microsoft C v203/m.bat Normal file
View File

@ -0,0 +1,11 @@
rem errorlevel can't be used because all 3 apps use the value-less cp/m exit function
del %1.exe 1>nul 2>nul
ntvdm mc1 %1
ntvdm mc2 %1
ntvdm link %1 + cs + gettm,, %1.map, mcs

171
Microsoft C v203/tm.c Normal file
View File

@ -0,0 +1,171 @@
#include <stdio.h>
#ifdef AZTEC86
#include <stdlib.h>
#endif
#ifdef HISOFTC
#include <stdlib.h>
#endif
#define OLDMSC
#ifdef OLDMSC
#define unsigned
#define void int
#endif
#ifdef WATCOM
#include <malloc.h>
#include <process.h>
#endif
#ifdef powerc
#define allocs 50
#else
#ifdef HISOFTC
#define allocs 66 /* not enough RAM with hisoft to go higher */
#else
/* most c runtimes work up to 69, but use 66 to have a consistent benchmark */
#define allocs 66
#endif
#endif
int logging = 1;
char * memset_x( p, v, c ) char * p; int v; int c;
{
unsigned char * pc = (unsigned char *) p;
unsigned char val = (unsigned char) ( v & 0xff );
int i;
if ( 0 == p )
{
printf( "request to memset a null pointer\n" );
exit( 1 );
}
if ( logging )
#ifdef CPMTIME
printf( " memset p %u, v %d, val %x, c %d\n", p, v, val, c );
#else
#ifdef HISOFTC
printf( " memset p %u, v %d, val %x, c %d\n", p, v, val, c );
#else
printf( " memset p %p, v %d, val %x, c %d\n", p, v, val, c );
#endif
#endif
for ( i = 0; i < c; i++ )
*pc++ = val;
return p;
}
void chkmem( p, v, c ) char * p; int v; int c;
{
unsigned char * pc = (unsigned char *) p;
unsigned char val = (unsigned char) ( v & 0xff );
int i;
if ( 0 == p )
{
printf( "request to chkmem a null pointer\n" );
exit( 1 );
}
for ( i = 0; i < c; i++ )
{
if ( *pc != val )
{
#ifdef CPMTIME
printf( "memory isn't as expected! p %u, v %d, c %d, *pc %d\n",p, v, c, *pc );
#else
printf( "memory isn't as expected! p %p, v %d, c %d, *pc %d\n",p, v, c, *pc );
#endif
exit( 1 );
}
pc++;
}
}
int main( argc, argv ) int argc; char * argv[];
{
int i, cb, c_cb, j;
char * pc;
char * ap[ allocs ];
logging = ( argc > 1 );
pc = argv[ 0 ]; /* evade compiler warning */
for ( j = 0; j < 10; j++ )
{
if ( logging )
printf( "in alloc mode\n" );
for ( i = 0; i < allocs; i++ )
{
cb = 8 + ( i * 10 );
c_cb = cb + 5;
if ( logging )
printf( " i, cb: %d %d\n", i, cb );
pc = (char *) calloc( c_cb, 1 );
chkmem( pc, 0, c_cb );
memset_x( pc, 0xcc, c_cb );
ap[ i ] = (char *) malloc( cb );
memset_x( ap[ i ], 0xaa, cb );
chkmem( pc, 0xcc, c_cb );
free( pc );
}
if ( logging )
printf( "in free mode, even first\n" );
for ( i = 0; i < allocs; i += 2 )
{
cb = 8 + ( i * 10 );
c_cb = cb + 3;
if ( logging )
printf( " i, cb: %d %d\n", i, cb );
pc = (char *) calloc( c_cb, 1 );
chkmem( pc, 0, c_cb );
memset_x( pc, 0xcc, c_cb );
chkmem( ap[ i ], 0xaa, cb );
memset_x( ap[ i ], 0xff, cb );
free( ap[ i ] );
chkmem( pc, 0xcc, c_cb );
free( pc );
}
if ( logging )
printf( "in free mode, now odd\n" );
for ( i = 1; i < allocs; i += 2 )
{
cb = 8 + ( i * 10 );
c_cb = cb + 7;
if ( logging )
printf( " i, cb: %d %d\n", i, cb );
pc = (char *) calloc( c_cb, 1 );
chkmem( pc, 0, c_cb );
memset_x( pc, 0xcc, c_cb );
chkmem( ap[ i ], 0xaa, cb );
memset_x( ap[ i ], 0xff, cb );
free( ap[ i ] );
chkmem( pc, 0xcc, c_cb );
free( pc );
}
}
printf( "success\n" );
return 0;
}

31
Microsoft C v203/tphi.c Normal file
View File

@ -0,0 +1,31 @@
#include <stdio.h>
#define unsigned
typedef unsigned long uint32_t;
int main()
{
uint32_t limit = 40;
uint32_t prev2 = 1;
uint32_t prev1 = 1;
uint32_t next, i, last_shown = 0;
printf( "should tend towards 1.61803398874989484820458683436563811772030\n" );
for ( i = 1; i <= limit; i++ )
{
next = prev1 + prev2;
prev2 = prev1;
prev1 = next;
if ( i == ( last_shown + 5 ) )
{
last_shown = i;
printf( " at %2lu iterations: %lf\n", i, (double) prev1 / (double) prev2 );
}
}
printf( "done\n" );
return 0;
}

46
Microsoft C v203/tpi.c Normal file
View File

@ -0,0 +1,46 @@
#include <stdio.h>
#define HIGH_MARK 500 /* 2800 */
static long r[HIGH_MARK + 1];
int main() {
long i, k, c;
long b, d;
long iter;
int iterations = 1;
for ( iter = 0; iter < iterations; iter++ ) {
c = 0;
for (i = 0; i < HIGH_MARK; i++) {
r[i] = 2000;
}
for (k = HIGH_MARK; k > 0; k -= 14) {
d = 0;
i = k;
for (;;) {
d += r[i] * 10000;
b = 2 * i - 1;
r[i] = d % b;
d /= b;
i--;
if (i == 0) break;
d *= i;
}
if ( iter == ( iterations - 1 ) )
{
printf( "%.4d", c + d / 10000 );
fflush( stdout );
}
c = d % 10000;
}
}
printf( "\n" );
return 0;
}

545
Microsoft C v203/ttt.c Normal file
View File

@ -0,0 +1,545 @@
/*
This version builds with old compilers including:
Aztec C 1.06 for 8080 & Z80 on CP/M.
Microsoft C Compiler V1.04 for 8086 on DOS. (This is Lattice C)
Microsoft C Compiler V2.03 for 8086 on DOS. (Still Lattice C)
Microsoft C Compiler V3.00 for 8086 on DOS.
QuickC 1.0
Turbo C 2.0
The syntax is old and reminds me of 7th grade summer vacation.
Much of this code is awkward to satisfy the lowest common denominator of many compilers.
unsigned long isn't supported in many older compilers, so long is used instead.
Early DOS and CP/M require register variabes to be int, not char or other types.
The perf improvement of using register-int instead of stack-char is worth it.
*/
#define LINT_ARGS
#include <stdio.h>
#ifdef DOSTIME
#include <time.h>
#include <dos.h>
#endif
#define true 1
#define false 0
/* Function Pointers are the fastest implementation for almost every compiler */
#define UseFunPointers 1
#define UseWinner2 2
#define UseLookForWinner 3
#define WinMethod UseFunPointers
#define ABPrune true /* alpha beta pruning */
#define WinLosePrune true /* stop early on win/lose */
#define ScoreWin 6
#define ScoreTie 5
#define ScoreLose 4
#define ScoreMax 9
#define ScoreMin 2
#define DefaultIterations 100
#define PieceX 1
#define PieceO 2
#define PieceBlank 0
typedef char ttype; /* 8-bit and 16-bit cpus do best with char aside from register in locals */
int g_Iterations = DefaultIterations;
ttype g_board[ 9 ];
#if WinMethod == UseFunPointers
ttype pos0func()
{
/* using "register int" instead of "ttype" for x is faster on 8086 and Z80 */
register int x = g_board[0];
if ( ( x == g_board[1] && x == g_board[2] ) ||
( x == g_board[3] && x == g_board[6] ) ||
( x == g_board[4] && x == g_board[8] ) )
return x;
return PieceBlank;
}
ttype pos1func()
{
register int x = g_board[1];
if ( ( x == g_board[0] && x == g_board[2] ) ||
( x == g_board[4] && x == g_board[7] ) )
return x;
return PieceBlank;
}
ttype pos2func()
{
register int x = g_board[2];
if ( ( x == g_board[0] && x == g_board[1] ) ||
( x == g_board[5] && x == g_board[8] ) ||
( x == g_board[4] && x == g_board[6] ) )
return x;
return PieceBlank;
}
ttype pos3func()
{
register int x = g_board[3];
if ( ( x == g_board[4] && x == g_board[5] ) ||
( x == g_board[0] && x == g_board[6] ) )
return x;
return PieceBlank;
}
ttype pos4func()
{
register int x = g_board[4];
if ( ( x == g_board[0] && x == g_board[8] ) ||
( x == g_board[2] && x == g_board[6] ) ||
( x == g_board[1] && x == g_board[7] ) ||
( x == g_board[3] && x == g_board[5] ) )
return x;
return PieceBlank;
}
ttype pos5func()
{
register int x = g_board[5];
if ( ( x == g_board[3] && x == g_board[4] ) ||
( x == g_board[2] && x == g_board[8] ) )
return x;
return PieceBlank;
}
ttype pos6func()
{
register int x = g_board[6];
if ( ( x == g_board[7] && x == g_board[8] ) ||
( x == g_board[0] && x == g_board[3] ) ||
( x == g_board[4] && x == g_board[2] ) )
return x;
return PieceBlank;
}
ttype pos7func()
{
register int x = g_board[7];
if ( ( x == g_board[6] && x == g_board[8] ) ||
( x == g_board[1] && x == g_board[4] ) )
return x;
return PieceBlank;
}
ttype pos8func()
{
register int x = g_board[8];
if ( ( x == g_board[6] && x == g_board[7] ) ||
( x == g_board[2] && x == g_board[5] ) ||
( x == g_board[0] && x == g_board[4] ) )
return x;
return PieceBlank;
}
typedef ttype pfunc_t();
pfunc_t * winner_functions[9] =
{
pos0func,
pos1func,
pos2func,
pos3func,
pos4func,
pos5func,
pos6func,
pos7func,
pos8func,
};
#endif
#if WinMethod == UseWinner2
ttype winner2( move ) ttype move;
{
register int x; /* faster than ttype x on the stack */
switch( move ) /* msc v3 from 1985 generates a jump table! */
{
case 0:
{
x = g_board[ 0 ];
if ( ( ( x == g_board[1] ) && ( x == g_board[2] ) ) ||
( ( x == g_board[3] ) && ( x == g_board[6] ) ) ||
( ( x == g_board[4] ) && ( x == g_board[8] ) ) )
return x;
break;
}
case 1:
{
x = g_board[ 1 ];
if ( ( ( x == g_board[0] ) && ( x == g_board[2] ) ) ||
( ( x == g_board[4] ) && ( x == g_board[7] ) ) )
return x;
break;
}
case 2:
{
x = g_board[ 2 ];
if ( ( ( x == g_board[0] ) && ( x == g_board[1] ) ) ||
( ( x == g_board[5] ) && ( x == g_board[8] ) ) ||
( ( x == g_board[4] ) && ( x == g_board[6] ) ) )
return x;
break;
}
case 3:
{
x = g_board[ 3 ];
if ( ( ( x == g_board[4] ) && ( x == g_board[5] ) ) ||
( ( x == g_board[0] ) && ( x == g_board[6] ) ) )
return x;
break;
}
case 4:
{
x = g_board[ 4 ];
if ( ( ( x == g_board[0] ) && ( x == g_board[8] ) ) ||
( ( x == g_board[2] ) && ( x == g_board[6] ) ) ||
( ( x == g_board[1] ) && ( x == g_board[7] ) ) ||
( ( x == g_board[3] ) && ( x == g_board[5] ) ) )
return x;
break;
}
case 5:
{
x = g_board[ 5 ];
if ( ( ( x == g_board[3] ) && ( x == g_board[4] ) ) ||
( ( x == g_board[2] ) && ( x == g_board[8] ) ) )
return x;
break;
}
case 6:
{
x = g_board[ 6 ];
if ( ( ( x == g_board[7] ) && ( x == g_board[8] ) ) ||
( ( x == g_board[0] ) && ( x == g_board[3] ) ) ||
( ( x == g_board[4] ) && ( x == g_board[2] ) ) )
return x;
break;
}
case 7:
{
x = g_board[ 7 ];
if ( ( ( x == g_board[6] ) && ( x == g_board[8] ) ) ||
( ( x == g_board[1] ) && ( x == g_board[4] ) ) )
return x;
break;
}
case 8:
{
x = g_board[ 8 ];
if ( ( ( x == g_board[6] ) && ( x == g_board[7] ) ) ||
( ( x == g_board[2] ) && ( x == g_board[5] ) ) ||
( ( x == g_board[0] ) && ( x == g_board[4] ) ) )
return x;
break;
}
}
return PieceBlank;
} /*winner2*/
#endif
#if WinMethod == UseLookForWinner
ttype LookForWinner()
{
register int p = g_board[0]; /* faster as register int than ttype on 8086 and Z80 */
if ( PieceBlank != p )
{
if ( p == g_board[1] && p == g_board[2] )
return p;
if ( p == g_board[3] && p == g_board[6] )
return p;
}
p = g_board[3];
if ( PieceBlank != p && p == g_board[4] && p == g_board[5] )
return p;
p = g_board[6];
if ( PieceBlank != p && p == g_board[7] && p == g_board[8] )
return p;
p = g_board[1];
if ( PieceBlank != p && p == g_board[4] && p == g_board[7] )
return p;
p = g_board[2];
if ( PieceBlank != p && p == g_board[5] && p == g_board[8] )
return p;
p = g_board[4];
if ( PieceBlank != p )
{
if ( ( p == g_board[0] ) && ( p == g_board[8] ) )
return p;
if ( ( p == g_board[2] ) && ( p == g_board[6] ) )
return p;
}
return PieceBlank;
} /*LookForWinner*/
#endif
int g_IMoves = 0;
ttype MinMax( alpha, beta, depth, move ) ttype alpha; ttype beta; ttype depth; ttype move;
{
ttype pieceMove, score; /* better perf with char than int. out of registers so use stack */
register int p, value; /* better perf with these as an int on Z80, 8080, and 8086 */
g_IMoves++;
if ( depth >= 4 )
{
#if WinMethod == UseFunPointers
p = ( * winner_functions[ move ] )();
#endif
#if WinMethod == UseWinner2
p = winner2( move );
#endif
#if WinMethod == UseLookForWinner
p = LookForWinner();
#endif
if ( PieceBlank != p )
{
if ( PieceX == p )
return ScoreWin;
return ScoreLose;
}
if ( 8 == depth )
return ScoreTie;
}
if ( depth & 1 )
{
value = ScoreMin;
pieceMove = PieceX;
}
else
{
value = ScoreMax;
pieceMove = PieceO;
}
for ( p = 0; p < 9; p++ )
{
if ( PieceBlank == g_board[ p ] )
{
g_board[p] = pieceMove;
score = MinMax( alpha, beta, depth + 1, p );
g_board[p] = PieceBlank;
if ( depth & 1 )
{
#if WinLosePrune /* #if statements must be in first column for MS C 1.0 */
if ( ScoreWin == score )
return ScoreWin;
#endif
if ( score > value )
{
value = score;
#if ABPrune
if ( value >= beta )
return value;
if ( value > alpha )
alpha = value;
#endif
}
}
else
{
#if WinLosePrune
if ( ScoreLose == score )
return ScoreLose;
#endif
if ( score < value )
{
value = score;
#if ABPrune
if ( value <= alpha )
return value;
if ( value < beta )
beta = value;
#endif
}
}
}
}
return value;
} /*MinMax*/
long g_Moves = 0;
int FindSolution( position ) ttype position;
{
register int i;
for ( i = 0; i < 9; i++ )
g_board[ i ] = PieceBlank;
g_board[ position ] = PieceX;
for ( i = 0; i < g_Iterations; i++ )
{
g_IMoves = 0;
MinMax( ScoreMin, ScoreMax, 0, position );
g_Moves += g_IMoves; /* do the 4-byte long addition once per loop to save work */
}
return 0;
} /*FindSolution*/
#ifdef CPMTIME
struct CPMTimeValue
{
int h, m, s, l;
};
void print_time_now()
{
/* This CP/M BDOS call of 105 is only implemented in NTVCM -- it's not a standard CP/M 2.2 call */
struct CPMTimeValue t;
t.h = t.m = t.s = t.l = 0;
bdos( 105, &t );
printf( "current time: %02d:%02d:%02d.%02d\n", t.h, t.m, t.s, t.l );
} /*print_time_now*/
long get_ms()
{
/* This CP/M BDOS call of 105 is only implemented in NTVCM -- it's not a standard CP/M 2.2 call */
long h, m, s, l;
struct CPMTimeValue t;
t.h = t.m = t.s = t.l = 0;
bdos( 105, &t );
h = t.h;
m = t.m;
s = t.s;
l = t.l;
return h * 3600000 + m * 60000 + s * 1000 + l * 10;
} /*get_ms*/
#else /* no elif with old compilers */
#ifdef DOSTIME
void print_time_now()
{
/* Make a DOS interrupt call to get the time */
union REGS wrIn, wrOut;
wrIn.h.ah = 0x2c;
intdos( &wrIn, &wrOut );
printf( "current time: %02d:%02d:%02d.%02d\n", wrOut.h.ch, wrOut.h.cl, wrOut.h.dh, wrOut.h.dl );
fflush( stdout );
} /*print_time_now*/
long get_ms()
{
/* this function takes about 3 milliseconds on the original IBM PC */
long h, m, s, l;
union REGS wrIn, wrOut;
wrIn.h.ah = 0x2c;
intdos( &wrIn, &wrOut );
h = wrOut.h.ch;
m = wrOut.h.cl;
s = wrOut.h.dh;
l = wrOut.h.dl;
return h * 3600000 + m * 60000 + s * 1000 + l * 10;
} /*get_ms*/
#else
/* must do this on actual CP/M machines */
int print_time_now() { return 0; }
long get_ms() { return 0; }
#endif
#endif
/* see gettm.asm in masm folder for function to get current time */
extern long gettm();
long getms()
{
long r, h, m, s, l;
r = gettm();
h = ( r >> 24 ) & 0xff;
m = ( r >> 16 ) & 0xff;
s = ( r >> 8 ) & 0xff;
l = ( r >> 0 ) & 0xff;
return h * 3600000 + m * 60000 + s * 1000 + l * 10;
} /*getms*/
int main( argc, argv ) int argc; char * argv[];
{
long start_time, end_time;
if ( 2 == argc )
sscanf( argv[ 1 ], "%d", &g_Iterations ); /* no atoi in MS C 1.0 */
start_time = getms();
FindSolution( 0 );
FindSolution( 1 );
FindSolution( 4 );
end_time = getms();
printf( "runtime in ms: %ld\n", end_time - start_time );
printf( "move count: %ld\n", g_Moves ); /* 6493 * g_Iterations */
printf( "iteration count: %d\n", g_Iterations );
printf( "method: %s\n",
( WinMethod == UseFunPointers ) ? "function pointers" :
( WinMethod == UseWinner2 ) ? "winner2" :
( WinMethod == UseLookForWinner ) ? "look for winner" :
"invalid method" );
return 0;
} /*main*/