/*
 * UNIX/v7m make configuration program (mkconf.c).
 * Creates the files l.s, locore vectors and c.c, 
 * configuration table.
 * Vector addreses are assigned according to the fixed
 * and floating vector rules, if non standard
 * vectors exist the l.s file must be edited after the
 * mkconf program has been run.
 *
 * Added rk06 & rk07 support.
 * Added rm02/3 & ts11 support.
 * Added A. P. Stettner's rl11 modificatons.
 * Added dz11 support.
 * Added improved core dump code,
 * uses unibus map (if requried) to
 * insure that all of memory is dumpped.
 * Added "ov" declaration for overlay kernel.
 * Added "nsid" declaration for no separate I/D space CPU.
 * Added "nfp" declaration for excluding floating point support code.
 * Added "|" for rx|rx2 and hs|ml.
 * Added automatic configuration of the text
 * overlay segments for the overlay kernel.
 * Added "dump" declaration to select core dump tape
 * and optionally specify dump tape CSR address.
 *
 * Fred Canter 8/20/81
 *
 ********************************************************
 *							*
 * The TS11 vector is assigned to location 050, in      *
 * order that the TS11 can function on a system which   *
 * also has a TM11, see comments at the head of the     *
 * TS11 driver "/sys/dev/ts.c" for an explaination.     *
 *							*
 * The startup code copies the TS11 vector from 050 to  *
 * 0224 or 0260 depending on the configuration.         *
 *							*
 ********************************************************
 */

#include <stdio.h>

#define	HT	01
#define	TM	02
#define	TS	03
#define CHAR	01
#define BLOCK	02
#define INTR	04
#define EVEN	010
#define KL	020
#define ROOT	040
#define	SWAP	0100
#define	PIPE	0200

char	*btab[] =
{
	"rk",
	"rp",
	"rf",
	"tm",
	"tc",
	"hs|ml",
	"hp",
	"ht",
	"rl",
	"hk",
	"ts",
	"rx|rx2",
	"hm",
	0
};
char	*ctab[] =
{
	"console",
	"pc",
	"lp",
	"dc",
	"dh",
	"dp",
	"dj",
	"dn",
	"mem",
	"rk",
	"rf",
	"rp",
	"tm",
	"hs|ml",
	"hp",
	"ht",
	"du",
	"tty",
	"rl",
	"hk",
	"ts",
	"dz",
	"rx2",
	"hm",
	0
};
struct tab
{
	char	*name;
	int	count;
	int	address;
	int	key;
	char	*codea;
	char	*codeb;
	char	*codec;
	char	*coded;
	char	*codee;
	char	*codef;
	char	*codeg;
} table[] =
{
	"ts",
	0, 50, BLOCK+CHAR+INTR,
	"	tsio; br5\n",
	".globl	_tsintr\n",
	"tsio:	jsr	r0,call; jmp _tsintr\n",
	"	tsopen, tsclose, tsstrategy, &tstab,",
	"	tsopen, tsclose, tsread, tswrite, nodev, nulldev, 0,",
	"int	tsopen(), tsclose(), tsstrategy();\nstruct	buf	tstab;",
	"int	tsread(), tswrite();",

	"console",
	-1, 60, CHAR+INTR+KL,
	"	klin; br4\n	klou; br4\n",
	".globl	_klrint\nklin:	jsr	r0,call; jmp _klrint\n",
	".globl	_klxint\nklou:	jsr	r0,call; jmp _klxint\n",
	"",
	"	klopen, klclose, klread, klwrite, klioctl, nulldev, 0,",
	"",
	"int	klopen(), klclose(), klread(), klwrite(), klioctl();",

	"mem",
	-1, 300, CHAR,
	"",
	"",
	"",
	"",
	"	nulldev, nulldev, mmread, mmwrite, nodev, nulldev, 0, ",
	"",
	"int	mmread(), mmwrite();",

	"pc",
	0, 70, CHAR+INTR,
	"	pcin; br4\n	pcou; br4\n",
	".globl	_pcrint\npcin:	jsr	r0,call; jmp _pcrint\n",
	".globl	_pcpint\npcou:	jsr	r0,call; jmp _pcpint\n",
	"",
	"	pcopen, pcclose, pcread, pcwrite, nodev, nulldev, 0, ",
	"",
	"int	pcopen(), pcclose(), pcread(), pcwrite();",

	"clock",
	-2, 100, INTR,
	"	kwlp; br6\n",
	".globl	_clock\n",
	"kwlp:	jsr	r0,call; jmp _clock\n",
	"",
	"",
	"",
	"",

	"parity",
	-1, 114, INTR,
	"	trap; br7+10.		/ 11/70 parity\n",
	"",
	"",
	"",
	"",
	"",
	"",

/*
 * 110 unused
 * 114 memory parity
 * 120 XY plotter
 * 124 DR11-B
 * 130 AD01
 * 134 AFC11
 * 140 AA11
 * 144 AA11
 */

	"hm",
	0, 150, BLOCK+CHAR+INTR,
	"	hmio; br5\n",
	".globl	_hmintr\n",
	"hmio:	jsr	r0,call; jmp _hmintr\n",
	"	nulldev, nulldev, hmstrategy, &hmtab,",
	"	nulldev, nulldev, hmread, hmwrite, nodev, nulldev, 0,",
	"int	hmstrategy();\nstruct	buf	hmtab;",
	"int	hmread(), hmwrite();",

/*
 * 154 unused
 */

	"rl",
	0, 160, BLOCK+CHAR+INTR,
	"	rlio; br5\n",
	".globl	_rlintr\n",
	"rlio:	jsr	r0,call; jmp _rlintr\n",
	"	nulldev, nulldev, rlstrategy, &rltab,",
	"	nulldev, nulldev, rlread, rlwrite, nodev, nulldev, 0,",
	"int	rlstrategy();\nstruct	buf	rltab;",
	"int	rlread(), rlwrite();",

/*
 * 164-174 unused
 */

	"lp",
	0, 200, CHAR+INTR,
	"	lpou; br4\n",
	"",
	".globl	_lpintr\nlpou:	jsr	r0,call; jmp _lpintr\n",
	"",
	"	lpopen, lpclose, nodev, lpwrite, nodev, nulldev, 0,",
	"",
	"int	lpopen(), lpclose(), lpwrite();",

	"rf",
	0, 204, BLOCK+CHAR+INTR,
	"	rfio; br5\n",
	".globl	_rfintr\n",
	"rfio:	jsr	r0,call; jmp _rfintr\n",
	"	nulldev, nulldev, rfstrategy, &rftab, ",
	"	nulldev, nulldev, rfread, rfwrite, nodev, nulldev, 0,",
	"int	rfstrategy();\nstruct	buf	rftab;",
	"int	rfread(), rfwrite();",

	"hs",
	0, 204, BLOCK+CHAR+INTR,
	"	hsio; br5\n",
	".globl	_hsintr\n",
	"hsio:	jsr	r0,call; jmp _hsintr\n",
	"	nulldev, nulldev, hsstrategy, &hstab, ",
	"	nulldev, nulldev, hsread, hswrite, nodev, nulldev, 0,",
	"int	hsstrategy();\nstruct	buf	hstab;",
	"int	hsread(), hswrite();",

	"ml",
	0, 204, BLOCK+CHAR+INTR,
	"	mlio; br5\n",
	".globl	_mlintr\n",
	"mlio:	jsr	r0,call; jmp _mlintr\n",
	"	nulldev, nulldev, mlstrategy, &mltab, ",
	"	nulldev, nulldev, mlread, mlwrite, nodev, nulldev, 0,",
	"int	mlstrategy();\nstruct	buf	mltab;",
	"int	mlread(), mlwrite();",

/*
 * 210 RC
 */

	"hk",
	0, 210, BLOCK+CHAR+INTR,
	"	hkio; br5\n",
	".globl	_hkintr\n",
	"hkio:	jsr	r0,call; jmp _hkintr\n",
	"	nulldev, nulldev, hkstrategy, &hktab,",
	"	nulldev, nulldev, hkread, hkwrite, nodev, nulldev, 0,",
	"int	hkstrategy();\nstruct	buf	hktab;",
	"int	hkread(), hkwrite();",

	"tc",
	0, 214, BLOCK+INTR,
	"	tcio; br6\n",
	".globl	_tcintr\n",
	"tcio:	jsr	r0,call; jmp _tcintr\n",
	"	nulldev, tcclose, tcstrategy, &tctab,",
	"",
	"int	tcstrategy(), tcclose();\nstruct	buf	tctab;",
	"",

	"rk",
	0, 220, BLOCK+CHAR+INTR,
	"	rkio; br5\n",
	".globl	_rkintr\n",
	"rkio:	jsr	r0,call; jmp _rkintr\n",
	"	nulldev, nulldev, rkstrategy, &rktab,",
	"	nulldev, nulldev, rkread, rkwrite, nodev, nulldev, 0,",
	"int	rkstrategy();\nstruct	buf	rktab;",
	"int	rkread(), rkwrite();",

	"tm",
	0, 224, BLOCK+CHAR+INTR,
	"	tmio; br5\n",
	".globl	_tmintr\n",
	"tmio:	jsr	r0,call; jmp _tmintr\n",
	"	tmopen, tmclose, tmstrategy, &tmtab, ",
	"	tmopen, tmclose, tmread, tmwrite, nodev, nulldev, 0,",
	"int	tmopen(), tmclose(), tmstrategy();\nstruct	buf	tmtab;",
	"int	tmread(), tmwrite();",

	"ht",
	0, 224, BLOCK+CHAR+INTR,
	"	htio; br5\n",
	".globl	_htintr\n",
	"htio:	jsr	r0,call; jmp _htintr\n",
	"	htopen, htclose, htstrategy, &httab,",
	"	htopen, htclose, htread, htwrite, nodev, nulldev, 0,",
	"int	htopen(), htclose(), htstrategy();\nstruct	buf	httab;",
	"int	htread(), htwrite();",

	"cr",
	0, 230, CHAR+INTR,
	"	crin; br6\n",
	"",
	".globl	_crint\ncrin:	jsr	r0,call; jmp _crint\n",
	"",
	"	cropen, crclose, crread, nodev, nodev, nulldev, 0,",
	"",
	"int	cropen(), crclose(), crread();",

/*
 * 234 UDC11
 */

	"rp",
	0, 254, BLOCK+CHAR+INTR,
	"	rpio; br5\n",
	".globl	_rpintr\n",
	"rpio:	jsr	r0,call; jmp _rpintr\n",
	"	nulldev, nulldev, rpstrategy, &rptab,",
	"	nulldev, nulldev, rpread, rpwrite, nodev, nulldev, 0,",
	"int	rpstrategy();\nstruct	buf	rptab;",
	"int	rpread(), rpwrite();",

	"hp",
	0, 254, BLOCK+CHAR+INTR,
	"	hpio; br5\n",
	".globl	_hpintr\n",
	"hpio:	jsr	r0,call; jmp _hpintr\n",
	"	nulldev, nulldev, hpstrategy, &hptab,",
	"	nulldev, nulldev, hpread, hpwrite, nodev, nulldev, 0,",
	"int	hpstrategy();\nstruct	buf	hptab;",
	"int	hpread(), hpwrite();",

/*
 * 260 TA11 (alt TS11)
 */

	"rx",
	0, 264, BLOCK+INTR,
	"	rxio; br5\n",
	".globl	_rxintr\n",
	"rxio:	jsr	r0,call; jmp _rxintr\n",
	"	rxopen, nulldev, rxstrategy, &rxtab,",
	"",
	"int	rxopen(), rxstrategy();\nstruct buf	rxtab;",
	"",

	"rx2",
	0, 264, BLOCK+CHAR+INTR,
	"	rx2io; br5\n",
	".globl	_rx2intr\n",
	"rx2io:	jsr	r0,call; jmp _rx2intr\n",
	"	rx2open, nulldev, rx2strategy, &rx2tab,",
	"	rx2open, nulldev, rx2read, rx2write, nodev, nulldev, 0,",
	"int	rx2open(), rx2strategy();\nstruct	buf	rx2tab;",
	"int	rx2read(), rx2write();",

	"dc",
	0, 308, CHAR+INTR,
	"	dcin; br5+%d.\n	dcou; br5+%d.\n",
	".globl	_dcrint\ndcin:	jsr	r0,call; jmp _dcrint\n",
	".globl	_dcxint\ndcou:	jsr	r0,call; jmp _dcxint\n",
	"",
	"	dcopen, dcclose, dcread, dcwrite, dcioctl, nulldev, dc11,",
	"",
	"int	dcopen(), dcclose(), dcread(), dcwrite(), dcioctl();\nstruct	tty	dc11[];",

	"kl",
	0, 308, INTR+KL,
	"	klin; br4+%d.\n	klou; br4+%d.\n",
	"",
	"",
	"",
	"",
	"",
	"",

	"dp",
	0, 308, CHAR+INTR,
	"	dpin; br6+%d.\n	dpou; br6+%d.\n",
	".globl	_dprint\ndpin:	jsr	r0,call; jmp _dprint\n",
	".globl	_dpxint\ndpou:	jsr	r0,call; jmp _dpxint\n",
	"",
	"	dpopen, dpclose, dpread, dpwrite, nodev, nulldev, 0,",
	"",
	"int	dpopen(), dpclose(), dpread(), dpwrite();",

/*
 * DM11-A
 */

	"dn",
	0, 304, CHAR+INTR,
	"	dnou; br5+%d.\n",
	"",
	".globl	_dnint\ndnou:	jsr	r0,call; jmp _dnint\n",
	"",
	"	dnopen, dnclose, nodev, dnwrite, nodev, nulldev, 0,",
	"",
	"int	dnopen(), dnclose(), dnwrite();",

	"dhdm",
	0, 304, INTR,
	"	dmin; br4+%d.\n",
	"",
	".globl	_dmint\ndmin:	jsr	r0,call; jmp _dmint\n",
	"",
	"",
	"",
	"",

/*
 * DR11-A+
 * DR11-C+
 * PA611+
 * PA611+
 * DT11+
 * DX11+
 */

	"dl",
	0, 308, INTR+KL,
	"	klin; br4+%d.\n	klou; br4+%d.\n",
	"",
	"",
	"",
	"",
	"",
	"",

/*
 * DJ11
 */

	"dh",
	0, 308, CHAR+INTR+EVEN,
	"	dhin; br5+%d.\n	dhou; br5+%d.\n",
	".globl	_dhrint\ndhin:	jsr	r0,call; jmp _dhrint\n",
	".globl	_dhxint\ndhou:	jsr	r0,call; jmp _dhxint\n",
	"",
	"	dhopen, dhclose, dhread, dhwrite, dhioctl, dhstop, dh11,",
	"",
	"int	dhopen(), dhclose(), dhread(), dhwrite(), dhioctl(), dhstop();\nstruct	tty	dh11[];",

/*
 * GT40
 * LPS+
 * DQ11
 * KW11-W
 */

	"du",
	0, 308, CHAR+INTR,
	"	duin; br6+%d.\n	duou; br6+%d.\n",
	".globl	_durint\nduin:	jsr	r0,call; jmp _durint\n",
	".globl	_duxint\nduou:	jsr	r0,call; jmp _duxint\n",
	"",
	"	duopen, duclose, duread, duwrite, nodev, nulldev, 0,",
	"",
	"int	duopen(), duclose(), duread(), duwrite();",

/*
 * DUP11
 * DV11
 * LK11-A
 * DMC11
 */

	"dz",
	0, 308, CHAR+INTR+EVEN,
	"	dzin; br5+%d.\n	dzou; br5+%d.\n",
	".globl _dzrint\ndzin:	jsr	r0,call; jmp _dzrint\n",
	".globl _dzxint\ndzou:	jsr	r0,call; jmp _dzxint\n",
	"",
	"	dzopen, dzclose, dzread, dzwrite, dzioctl, nulldev, dz_tty,",
	"",
	"int	dzopen(), dzclose(), dzread(), dzwrite(), dzioctl();\nstruct	tty	dz_tty[];",

	"tty",
	1, 0, CHAR,
	"",
	"",
	"",
	"",
	"	syopen, nulldev, syread, sywrite, sysioctl, nulldev, 0,",
	"",
	"int	syopen(), syread(), sywrite(), sysioctl();",

	0
};

/*
 * The ovtab structure describes each of the modules
 * used to make the overlay text segments of the
 * overlay kernel.
 * The order of appearance of the modules in this
 * structure is critical and must not be changed.
 */

struct	ovtab
{
	char	*mn;		/* object module name */
	int	mc;		/* non-zero if module is configured */
				/* some modules are always configured, */
				/* others are keyed from COUNT */
				/* field of structure "table" above */
	int	ovno;		/* initial overlay number, */
				/* may be changed later */
	int	mts;		/* module text size in bytes */
	char	*mpn;		/* module full path name */
} ovt [] =
{
/*
 *	overlay 1
 * Mostly system calls, will be added to later.
 * Mem driver is about the only thing that
 * will fit.
 * This overlay should be as full as possible,
 * so as not to waste memory space.
 */
	"pipe",
	1, 1, -1,
	"\t../ovsys/pipe.o \\",
	"sys1",
	1, 1, -1,
	"\t../ovsys/sys1.o \\",
	"sys2",
	1, 1, -1,
	"\t../ovsys/sys2.o \\",
	"sys3",
	1, 1, -1,
	"\t../ovsys/sys3.o \\",
	"sys4",
	1, 1, -1,
	"\t../ovsys/sys4.o \\",
	"text",
	1, 1, -1,
	"\t../ovsys/text.o \\",
/*
 *	overlay 2
 * This overlay contains some system stuff
 * plus bio, will be filled in with tape drivers
 * and what ever else will fit.
 */
	"acct",
	1, 2, -1,
	"\t../ovsys/acct.o \\",
	"main",
	1, 2, -1,
	"\t../ovsys/main.o \\",
	"machdep",
	1, 2, -1,
	"\t../ovsys/machdep.o \\",
	"sig",
	1, 2, -1,
	"\t../ovsys/sig.o \\",
	"bio",
	1, 2, -1,
	"\t../ovdev/bio.o \\",
/*
 *	overlay 3
 * This overlay has the big disk drivers and the
 * disk sort routines. These drivers may not be
 * configured, but in any case this overlay will
 * get as much as possible of the overflow from
 * overlays 1 & 2.
 *
 * If all three disk drivers are configured (hp, hk, & hm)
 * this overlay would overflow, in that case "hm" is
 * changed to overlay 8 on the fly and loaded where ever it
 * will fit on the next pass.
 */
	"hp",
	0, 3, -1,
	"\t../ovdev/hp.o \\",
	"hk",
	0, 3, -1,
	"\t../ovdev/hk.o \\",
	"hm",
	0, 3, -1,
	"\t../ovdev/hm.o \\",
	"dsort",
	0, 3, -1,
	"\t../ovdev/dsort.o \\",
	"dkleave",
	0, 3, -1,
	"\t../ovdev/dkleave.o \\",

/*
 *	overlay 4
 * Initially empty, will be filled in with
 * overflow from previous overlays.
 */

/*
 *	overlay 5
 * The overlay holds most of the tty drivers and
 * associated routines, not much room for fill.
 */
	"tty",
	1, 5, -1,
	"\t../ovdev/tty.o \\",
	"sys",
	1, 5, -1,
	"\t../ovdev/sys.o \\",
	"kl",
	1, 5, -1,
	"\t../ovdev/kl.o \\",
	"dz",
	0, 5, -1,
	"\t../ovdev/dz.o \\",
	"dhdm",
	0, 5, -1,
	"\t../ovdev/dhdm.o \\",
	"dh",
	0, 5, -1,
	"\t../ovdev/dh.o \\",
	"dhfdm",
	0, 5, -1,
	"\t../ovdev/dhfdm.o \\",
	"partab",
	1, 5, -1,
	"\t../ovdev/partab.o \\",
	"prim",
	1, 5, -1,
	"\t../ovsys/prim.o \\",
/*
 *	overlay 6
 * Contains the packet driver stuff.
 * It could hold overflow from previous
 * overlays if necessary.
 */
	"pk0",
	0, 6, -1,
	"\t../ovdev/pk0.o \\",
	"pk1",
	0, 6, -1,
	"\t../ovdev/pk1.o \\",
	"pk2",
	0, 6, -1,
	"\t../ovdev/pk2.o \\",
	"pk3",
	0, 6, -1,
	"\t../ovdev/pk3.o \\",
/*
 *	overlay 7
 * Contains the multiplexed files stuff.
 * could also hold overflow.
 */
	"mx1",
	0, 7, -1,
	"\t../ovdev/mx1.o \\",
	"mx2",
	0, 7, -1,
	"\t../ovdev/mx2.o \\",
/*
 *	overlay 8
 * This is not a real overlay, all of the
 * modules here will be used to fill out
 * overlays 1 thru 7.
 * Contains the mem driver, the HM disk driver,
 * and the magtape drivers.
 */
	"mem",
	1, 8, -1,
	"\t../ovdev/mem.o \\",
	"ts",
	0, 8, -1,
	"\t../ovdev/ts.o \\",
	"ht",
	0, 8, -1,
	"\t../ovdev/ht.o \\",
	"tm",
	0, 8, -1,
	"\t../ovdev/tm.o \\",
	"tc",
	0, 8, -1,
	"\t../ovdev/tc.o \\",
/*
 *	overlay 9
 * Again not a real overlay, used to fill others.
 * Contains all smaller disk drivers.
 */
	"ml",
	0, 9, -1,
	"\t../ovdev/ml.o \\",
	"hs",
	0, 9, -1,
	"\t../ovdev/hs.o \\",
	"rp",
	0, 9, -1,
	"\t../ovdev/rp.o \\",
	"rx2",
	0, 9, -1,
	"\t../ovdev/rx2.o \\",
	"rl",
	0, 9, -1,
	"\t../ovdev/rl.o \\",
	"rk",
	0, 9, -1,
	"\t../ovdev/rk.o \\",
	"rf",
	0, 9, -1,
	"\t../ovdev/rf.o \\",
/*
 *	overlay 10
 * Also not a real overlay, used to fill others.
 * Contains LP driver and misc. comm. device drivers.
 */
	"lp",
	0, 10, -1,
	"\t../ovdev/lp.o \\",
	"du",
	0, 10, -1,
	"\t../ovdev/du.o \\",
	"dn",
	0, 10, -1,
	"\t../ovdev/dn.o \\",
	"dc",
	0, 10, -1,
	"\t../ovdev/dc.o \\",
	"cat",
	0, 10, -1,
	"\t../ovdev/cat.o \\",
	"vp",
	0, 10, -1,
	"\t../ovdev/vp.o \\",
	"vs",
	0, 10, -1,
	"\t../ovdev/vs.o \\",
	0
};

/*
 * The ovdtab is an array of structures which
 * describe the actual overlays as they will
 * appear in the "ovload" overlay load file.
 * The first structure (overlay 0) is never used.
 */

struct	ovdes
{
	int	nentry;		/* number of modules in this overlay */
	int	size;		/* total size of this overlay in bytes */
	char	*omns[12];	/* pointers to module pathname strings */
} ovdtab [8];

char	*stra40[] =
{
	"/ low core",
	"",
	0
};

char	*stra70[] =
{
	"/ low core",
	"",
	".data",
	0
};

char	*stra[] =
{
	"ZERO:",
	"",
	"br4 = 200",
	"br5 = 240",
	"br6 = 300",
	"br7 = 340",
	"",
	". = ZERO+0",
	"	br	1f",
	"	4",
	"",
	"/ trap vectors",
	"	trap; br7+0.		/ bus error",
	"	trap; br7+1.		/ illegal instruction",
	"	trap; br7+2.		/ bpt-trace trap",
	"	trap; br7+3.		/ iot trap",
	"	trap; br7+4.		/ power fail",
	"	trap; br7+5.		/ emulator trap",
	"	start;br7+6.		/ system  (overlaid by 'trap')",
	"",
	". = ZERO+40",
	".globl	start, dump",
	"1:	jmp	start",
	"",
	0,
};

char	*strb[] =
{
	"",
	". = ZERO+240",
	"	trap; br7+7.		/ programmed interrupt",
	"	trap; br7+8.		/ floating point",
	"	trap; br7+9.		/ segmentation violation",
	0
};

char	*strc[] =
{
	"",
	"/ floating vectors",
	". = ZERO+300",
	0,
};

char	*strov[] =
{
	"",
	"/ overlay descriptor tables",
	"",
	".globl ova, ovd, ovend",
	"ova:\t.=.+16.\t/ overlay addresses",
	"ovd:\t.=.+16.\t/ overlay sizes",
	"ovend:\t.=.+2\t/ end of overlays",
	0
};

char	*sizcmd = {"size ../ovsys/*.o ../ovdev/*.o > text.sizes"};
char	*cmcmd = {"chmod 744 ovload"};

char	*strovh[] =
{
	"covld -X -n -o unix_ov l.o mch_ov.o c_ov.o \\",
	0,
};

char	*strovl[] =
{
	"-L \\",
	"\t../ovsys/LIB1_ov",
	0,
};

char	*strovz[] =
{
	"-Z \\",
	0,
};

char	*strd[] =
{
	"",
	"//////////////////////////////////////////////////////",
	"/		interface code to C",
	"//////////////////////////////////////////////////////",
	"",
	".text",
	".globl	call, trap",
	0
};

char	*stre[] =
{
	"#include \"../h/param.h\"",
	"#include \"../h/systm.h\"",
	"#include \"../h/buf.h\"",
	"#include \"../h/tty.h\"",
	"#include \"../h/conf.h\"",
	"#include \"../h/proc.h\"",
	"#include \"../h/text.h\"",
	"#include \"../h/dir.h\"",
	"#include \"../h/user.h\"",
	"#include \"../h/file.h\"",
	"#include \"../h/inode.h\"",
	"#include \"../h/acct.h\"",
	"",
	"int	nulldev();",
	"int	nodev();",
	0
};

char	*stre1[] =
{
	"struct	bdevsw	bdevsw[] =",
	"{",
	0,
};

char	*strf[] =
{
	"	0",
	"};",
	"",
	0,
};

char	*strf1[] =
{
	"",
	"struct	cdevsw	cdevsw[] =",
	"{",
	0,
};

char	strg[] =
{
"	0\n\
};\n\
int	rootdev	= makedev(%d, %d);\n\
int	swapdev	= makedev(%d, %d);\n\
int	pipedev = makedev(%d, %d);\n\
int	nldisp = %d;\n\
daddr_t	swplo	= %ld;\n\
int	nswap	= %l;\n\
"};

char	strg1[] =
{
"	\n\
struct	buf	buf[NBUF];\n\
struct	file	file[NFILE];\n\
struct	inode	inode[NINODE];\n"
};

char	*strg1a[] =
{
	"#ifdef\tMX",
	"int	mpxchan();",
	"int	(*ldmpx)() = mpxchan;",
	"#endif\tMX",
	0
};

char	strg2[] =
{
"struct	proc	proc[NPROC];\n\
struct	text	text[NTEXT];\n\
struct	buf	bfreelist;\n\
struct	acct	acctbuf;\n\
struct	inode	*acctp;\n"
};

char	*strg3[] =
{
	"",
	"/*",
	" * The following locations are used by commands",
	" * like ps & pstat to free them from param.h",
	" */",
	"",
	"int	nproc	NPROC;",
	"int	ninode	NINODE;",
	"int	ntext	NTEXT;",
	"int	nofile	NOFILE;",
	"int	nsig	NSIG;",
	"int	nfile	NFILE;",
	0
};

char	*strh[] =
{
	"	0",
	"};",
	"",
	"int	ttyopen(), ttyclose(), ttread(), ttwrite(), ttyinput(), ttstart();",
	0
};

char	*stri[] =
{
	"int	pkopen(), pkclose(), pkread(), pkwrite(), pkioctl(), pkrint(), pkxint();",
	0
};

char	*strj[] =
{
	"struct	linesw	linesw[] =",
	"{",
	"	ttyopen, nulldev, ttread, ttwrite, nodev, ttyinput, ttstart, /* 0 */",
	0
};

char	*strk[] =
{
	"	pkopen, pkclose, pkread, pkwrite, pkioctl, pkrint, pkxint, /* 1 */",
	0
};

int	mpx;
int	ov;
int	nsid;
int	nfp;
int	dump;
int	cdcsr;
int	rootmaj = -1;
int	rootmin;
int	swapmaj = -1;
int	swapmin;
int	pipemaj = -1;
int	pipemin;
long	swplo	= 4000;
int	nswap = 872;
int	pack;
int	nldisp = 1;

char	trash[100];
char	omn[20];
char	mtsize[20];

main()
{
	register struct tab *p;
	struct	ovtab	*otp;
	struct	ovdes	*ovdp;
	register char *q;
	char	*c;
	int i, n, ev, nkl;
	int flagf, flagb;
	int dumpht, dumptm, dumpts;
	int fi, ovcnt;

	while(input());

/*
 * pass1 -- create interrupt vectors
 */
	fprintf(stderr, "\n");
	if(ov)
		fprintf(stderr, "(overlay kernel specified)\n");
	if(ov && nsid)
		fprintf(stderr, "(ov & nsid specified, nsid ignored)\n");
	else if(nsid)
		fprintf(stderr, "(non-separate I/D space CPU specified)\n");
	if(nfp)
		fprintf(stderr, "(floating point support excluded)\n");
	nkl = 0;
	flagf = flagb = 1;
	freopen("l.s", "w", stdout);
	if(!ov && !nsid)
		puke(stra70);
	else
		puke(stra40);
	puke(stra);
	ev = 0;
	for(p=table; p->name; p++)
	if(p->count != 0 && p->key & INTR) {
		if(p->address>240 && flagb) {
			flagb = 0;
			puke(strb);
		}
		if(p->address >= 300) {
			if(flagf) {
				ev = 0;
				flagf = 0;
				puke(strc);
			}
			if(p->key & EVEN && ev & 07) {
				printf("	.=.+4\n");
				ev += 4;
			}
			printf("/%s %o\n", p->name, 0300+ev);
		} else
			printf("\n. = ZERO+%d\n", p->address);
		n = p->count;
		if(n < 0)
			n = -n;
		for(i=0; i<n; i++) {
			if(p->key & KL) {
				printf(p->codea, nkl, nkl);
				nkl++;
			} else
				printf(p->codea, i, i);
			if (p->address<300) {
				fprintf(stderr, "%s at %d", p->name, p->address+4*i);
				if (equal(p->name, "ts"))
					fprintf(stderr, "   (TS auto-config)");
				fprintf(stderr, "\n");
			} else
				fprintf(stderr, "%s at %o\n", p->name, 0300+ev);
			ev += p->address - 300;
		}
	}
	if(flagb)
		puke(strb);
/*
 * TS11 auto vector select
 *
 * Text must not be allowed to start at
 * an address that is less than 0300.
 * The vector at 0260 must be initialized to
 * zero for the TS11 auto vector
 * select to function.
 * With the advent of v7m 2.0, text does not
 * ever start before 1000.
 */

	printf("\n. = ZERO+1000\n");
	printf("\n\tjmp\tdump\t/ jump to core dump code\n");
	if(ov)
		puke(strov);
	puke(strd);
	for(p=table; p->name; p++)
	if(p->count != 0 && p->key & INTR)
		printf("\n%s%s", p->codeb, p->codec);

/*
 * pass 2 -- create configuration table
 */

	freopen("c.c", "w", stdout);
	/*
	 * declarations
	 */
	puke(stre);
	for (i=0; q=btab[i]; i++) {
		for (p=table; p->name; p++)
		if (match(q, p->name) &&
		   (p->key&BLOCK) && p->count && *p->codef)
			printf("%s\n", p->codef);
	}
	puke(stre1);
	for(i=0; q=btab[i]; i++) {
		for(p=table; p->name; p++)
		if(match(q, p->name) &&
		   (p->key&BLOCK) && p->count) {
			printf("%s	/* %s = %d */\n", p->coded, p->name, i);
			if(p->key & ROOT)
				rootmaj = i;
			if (p->key & SWAP)
				swapmaj = i;
			if (p->key & PIPE)
				pipemaj = i;
			goto newb;
		}
		printf("	nodev, nodev, nodev, 0, /* %s = %d */\n", q, i);
	newb:;
	}
	if (swapmaj == -1) {
		swapmaj = rootmaj;
		swapmin = rootmin;
	}
	if (pipemaj == -1) {
		pipemaj = rootmaj;
		pipemin = rootmin;
	}
	puke(strf);
	for (i=0; q=ctab[i]; i++) {
		for (p=table; p->name; p++)
		if (match(q, p->name) &&
		   (p->key&CHAR) && p->count && *p->codeg)
			printf("%s\n", p->codeg);
	}
	puke(strf1);
	for(i=0; q=ctab[i]; i++) {
		for(p=table; p->name; p++)
		if(match(q, p->name) &&
		   (p->key&CHAR) && p->count) {
			printf("%s	/* %s = %d */\n", p->codee, p->name, i);
			goto newc;
		}
		printf("	nodev, nodev, nodev, nodev, nodev, nulldev, 0, /* %s = %d */\n", q, i);
	newc:;
	}
	puke(strh);
	if (pack) {
		nldisp++;
		puke(stri);
	}
	puke(strj);
	if (pack)
		puke(strk);
	printf(strg, rootmaj, rootmin,
		swapmaj, swapmin,
		pipemaj, pipemin,
		nldisp,
		swplo, nswap);
	printf(strg1);
	if (!mpx)
		puke(strg1a);
	printf(strg2);
	puke(strg3);
	if(rootmaj < 0)
		fprintf(stderr, "No root device given\n");
	freopen("mch0.s", "w", stdout);
	dumpht = 0;
	dumptm = 0;
	dumpts = 0;
	for (i=0; table[i].name; i++) {
		if (equal(table[i].name, "ht") && table[i].count)
			dumpht = 1;
		if (equal(table[i].name, "tm") && table[i].count)
			dumptm = 1;
		if (equal(table[i].name, "ts") && table[i].count)
			dumpts = 1;
	}
	if((dump == HT) && dumpht) {
		dumptm = 0;
		dumpts = 0;
		}
	if((dump == TM) && dumptm) {
		dumpht = 0;
		dumpts = 0;
		}
	if((dump == TS) && dumpts) {
		dumpht = 0;
		dumptm = 0;
		}
	if (dumpht) {
		printf("HTDUMP = 1\n");
		printf("TUDUMP = 0\n");
		printf("TSDUMP = 0\n");
		if(cdcsr)
			printf("\nHTCS1	= %o\n", cdcsr);
		else
			printf("\nHTCS1	= 172440\n");
	} else if (dumptm) {
		printf("HTDUMP = 0\n");
		printf("TUDUMP = 1\n");
		printf("TSDUMP = 0\n");
		if(cdcsr)
			printf("\nMTS	= %o\n", cdcsr);
		else
			printf("\nMTS	= 172520\n");
		printf("MTC	= MTS+2\n");
	} else if (dumpts) {
		printf("HTDUMP = 0\n");
		printf("TUDUMP = 0\n");
		printf("TSDUMP = 1\n");
		if(cdcsr)
			printf("\nTSDB	= %o\n", cdcsr);
		else
			printf("\nTSDB	= 172520\n");
		printf("TSSR	= TSDB+2\n");
	} else {
		fprintf(stderr, "\n(No tape, so no core dump included)\n");
		printf("HTDUMP = 0\n");
		printf("TUDUMP = 0\n");
		printf("TSDUMP = 0\n");
		}
	if(nfp)
		printf("\n.fpp\t= 0\n");
	else
		printf("\n.fpp\t= 1\n");
/*
 * pass3 - create "ovload" file
 *
 * "ovload" is a shell file used by /sys/conf/makefile
 * to invoke the covld command to link the overlay
 * kernel and produce the executable file unix_ov.
 *
 * The method to this madness is as follows:
 *
 * 1.	If the "ov" specification was not present in
 *	the conf file, then skip this pass !
 *
 * 2.	Use the size command to create the file text.sizes
 *	containing the text sizes of each object module.
 *	../ovdev/bio.o 2086+30+0 = 2116b = 04104b, etc.
 *
 * 3.	Transfer the text size of each object module from the
 *	text.sizes file to that module's slot in the ovtab structure.
 *
 * 4.	Check each module in the ovtab structure to insure that it's
 *	size was found and initialize the ovdes (overlay descriptor)
 *	array to all zeroes (all overlays empty).
 *
 * 5.	Scan the ovtab structure and load all of the modules that
 *	are always configured into their designated overlays.
 *
 * 6.	Search the mkconf "table" to find all configured devices
 *	(count > 0) and mark them as optional configured devices in
 *	the ovtab structure, one exception is "tty" which always included.
 *	If the "hp", "hk", or "hm" disks are configured,
 *	then the "dsort" and "dkleave" modules must be included
 *	in overlay 3.
 *	If the "dh" driver is configured and the "dhdm" module
 *	is not included, then the "dhfdm" module must be included
 *	in overlay 5.
 *	If the "rx" specification is included, it's name is changed
 *	to "rx2" because the rx2.o module supports both rx01 & rx02.
 *
 * 7.	Check for "mpx" and "pack", if specified mark their object
 *	modules as optional configured devices in the ovtab structure.
 *
 * 8.	Scan the ovtab and load all optionaly configured modules
 *	that have fixed overlay assignments into their designated overlays.
 *	Except for the following special case any module with a
 *	fixed overlay assignment, which causes that overlay to
 *	overflow will cause a fatal error, i.e., overlay
 *	3 could overflow if all three big disk drivers (hp, hm, & hk)
 *	are configured. If this occurs the "hm" driver will be
 *	loaded into the first overlay with sufficient free space.
 *
 * 9.	Scan the ovtab and transfer any configured modules from
 *	pseudo overlays 8 thru 10 to real overlays 1 thru 7.
 *	The modules are placed into the overlays starting at one
 *	on a first fit basis. Actually this is done in two passes,
 *	first the existing overlays are scanned to locate a
 *	slot for the module, if the module will not fit into
 *	any existing overlay, then a new overlay is created and
 *	the module is loaded into it.
 *
 * 10.	Create the "ovload" shell file by scanning the overlay
 *	descriptor array and writing the pathnames of the
 *	modules to be loaded into the file.
 */

/* 1. */
	if(!ov)
		exit(0);
/* 2. */
	system(sizcmd);
	if((fi = fopen("text.sizes", "r")) == 0) {
		fprintf(stderr, "\nCan't open text.sizes file\n");
		exit();
		}
/* 3. */
scanlp:
    ovcnt = fscanf(fi, "%9s%[^\.]%s%[^+]%[^\n]",trash,omn,trash,mtsize,trash);
	if(ovcnt == EOF)
		goto endovs;
	if(ovcnt != 5) {
		fprintf(stderr, "\ntext.sizes file format error\n");
		exit();
		}
	for(otp = ovt; otp->mn; otp++) {
		q = &omn;
		if(equal(otp->mn, q)) {
			otp->mts = atoi(mtsize);
			break;
			}
		}
	goto scanlp;
endovs:
	fclose(fi);
/* 4. */
	for(otp = ovt; otp->mn; otp++)
		if(otp->mts < 0)
		fprintf(stderr, "\n%s.o object file size not found\n", otp->mn);
	for(i=0; i<8; i++) {
		ovdtab[i].nentry = 0;
		ovdtab[i].size = 0;
		}
/* 5. */
	for(otp = ovt; otp->mn; otp++)
		if((otp->mc == 1) && (otp->ovno < 6)) {
			if(ovload(otp, otp->ovno) < 0)
				goto ovlerr;
			}
/* 6. */
	for(p=table; p->name; p++)
		if(p->count > 0) {
			if(equal(p->name, "rx"))
				c = ctab[22];	/* rx2 */
			else
				c = p->name;
			n = 0;
			for(otp=ovt; otp->mn; otp++)
				if(equal(c, q=otp->mn)) {
					if(otp->mc == 0)
						otp->mc = 2;
					n++;
					break;
					}
				if(!n) {
			fprintf(stderr, "\n%s not in overlay table\n", c);
					exit();
					}
			}

	/* if hp, hm or hk configured, must include dsort and dkleave */

	n = 0;
	for(otp=ovt; otp->mn; otp++) {
		if((equal(otp->mn, "hp") ||
		equal(otp->mn, "hm") ||
		equal(otp->mn, "hk")) &&
		(otp->mc == 2))
			n++;
		if(equal(otp->mn, "dsort") && n)
			otp->mc = 2;
		if(equal(otp->mn, "dkleave") && n) {
			otp->mc = 2;
			break;
			}
		}

	/* if dh configured without dhdm, must include dhfdm */

	n = 0;
	for(otp=ovt; otp->mn; otp++)
		if(equal(otp->mn, "dhdm"))
			break;
	if(otp->mc == 0)
		n++;
	otp++;
	if((otp->mc == 2) && n) {
		otp++;
		otp->mc = 2;
		}
/* 7. */
	for(otp=ovt; otp->mn; otp++) {
		if((otp->ovno == 6) && pack)
			otp->mc = 2;
		if((otp->ovno == 7) && mpx)
			otp->mc = 2;
		}
/* 8. */
	for(otp=ovt; otp->mn; otp++)
		if((otp->mc == 2) && (otp->ovno < 8))
			if(ovload(otp, otp->ovno) < 0) {
				if(otp->ovno == 3)
					otp->ovno = 8;
				else
					goto ovlerr;
				}
/* 9. */
	for(otp=ovt; otp->mn; otp++) {
		if(otp->ovno < 8)
ovldok:
		continue;
		if(otp->mc) {
			for(i=1; i<8; i++) {
				if(ovdtab[i].size)
					if(ovload(otp, i) >= 0)
						goto ovldok;
				}
			for(i=1; i<8; i++) {
				if(ovload(otp, i) >= 0)
					goto ovldok;
				}
		fprintf(stderr,"%s will not fit in overlay %d\n",otp->mn,i);
			exit();
			}
		}
/* 10. */
	freopen("ovload", "w", stdout);
	puke(strovh);
	for(i=1; i<8; i++) {
		ovdp = &ovdtab[i];
		if(ovdp->nentry) {
			puke(strovz);
			for(n=0; n < ovdp->nentry; n++) {
				printf("%s", ovdp->omns[n]);
				printf("\n");
				}
			}
		}
	puke(strovl);
	printf("\n");
	fclose(stdout);
	system(cmcmd);
	exit();
ovlerr:
	fprintf(stderr, "\noverlay %d size overflow\n",otp->ovno);
	exit();
}

/*
 * ovload checks to see if the module will fit
 * into the overlay and then loads it if possible
 * or returns -1 if it can't be loaded.
 */

ovload(tp, ovn)
struct ovtab *tp;
{
	register struct ovdes *dp;

	dp = &ovdtab[ovn];
	if((dp->nentry >= 12) ||
	(dp->size >= 8192) ||
	((dp->size + tp->mts) > 8192))
		return(-1);
	dp->omns[dp->nentry] = tp->mpn;
	dp->size += tp->mts;
	dp->nentry++;
	return(1);
}

puke(s)
char **s;
{
	char *c;

	while(c = *s++) {
		printf(c);
		printf("\n");
	}
}

input()
{
	char line[100];
	register struct tab *q;
	int count, n;
	long num;
	unsigned int onum;
	char keyw[32], dev[32];

	if (fgets(line, 100, stdin) == NULL)
		return(0);
	count = -1;
	 sscanf(line, "%d%s%s%o", &count, keyw, dev, &onum);
	n = sscanf(line, "%d%s%s%ld", &count, keyw, dev, &num);
	if (count == -1 && n>0) {
		count = 1;
		n++;
	}
	if (n<2)
		goto badl;
	for(q=table; q->name; q++)
	if(equal(q->name, keyw)) {
		if(q->count < 0) {
			fprintf(stderr, "%s: no more, no less\n", keyw);
			return(1);
		}
		q->count += count;
		if(q->address < 300 && q->count > 1) {
			q->count = 1;
			fprintf(stderr, "%s: only one\n", keyw);
		}
		return(1);
	}
	if (equal(keyw, "nswap")) {
		if (n<3)
			goto badl;
		if (sscanf(dev, "%ld", &num) <= 0)
			goto badl;
		nswap = num;
		return(1);
	}
	if (equal(keyw, "swplo")) {
		if (n<3)
			goto badl;
		if (sscanf(dev, "%ld", &num) <= 0)
			goto badl;
		swplo = num;
		return(1);
	}
	if (equal(keyw, "pack")) {
		pack++;
		return(1);
	}
	if (equal(keyw, "mpx")) {
		mpx++;
		return(1);
	}
	if (equal(keyw, "ov")) {
		ov++;
		return;
	}
	if (equal(keyw, "nsid")) {
		nsid++;
		return(1);
	}
	if (equal(keyw, "nfp")) {
		nfp++;
		return(1);
	}
	dump = 0;
	if (equal(keyw, "dump")) {
		if (n<3)
			goto badl;
		if (equal(dev, "ht"))
			dump = HT;
		else if(equal(dev, "tm"))
			dump = TM;
		else if(equal(dev, "ts"))
			dump = TS;
		else
			goto badl;
		cdcsr = 0;
		if (n == 4) {
			if ((onum > 0160006) && (onum < 0177514))
				cdcsr = onum & 0177776;
			else
				goto badl;
			}
		return(1);
		}
	if (equal(keyw, "done"))
		return(0);
	if (equal(keyw, "root")) {
		if (n<4)
			goto badl;
		for (q=table; q->name; q++) {
			if (equal(q->name, dev)) {
				q->key |= ROOT;
				rootmin = num;
				return(1);
			}
		}
		fprintf(stderr, "Can't find root\n");
		return(1);
	}
	if (equal(keyw, "swap")) {
		if (n<4)
			goto badl;
		for (q=table; q->name; q++) {
			if (equal(q->name, dev)) {
				q->key |= SWAP;
				swapmin = num;
				return(1);
			}
		}
		fprintf(stderr, "Can't find swap\n");
		return(1);
	}
	if (equal(keyw, "pipe")) {
		if (n<4)
			goto badl;
		for (q=table; q->name; q++) {
			if (equal(q->name, dev)) {
				q->key |= PIPE;
				pipemin = num;
				return(1);
			}
		}
		fprintf(stderr, "Can't find pipe\n");
		return(1);
	}
	fprintf(stderr, "%s: cannot find\n", keyw);
	return(1);
badl:
	fprintf(stderr, "Bad line: %s", line);
	return(1);
}

equal(a, b)
char *a, *b;
{
	return(!strcmp(a, b));
}

match(a, b)
register char *a, *b;
{
	register char *t;

	for (t = b; *a && *t; a++) {
		if (*a != *t) {
			while (*a && *a != '|')
				a++;
			if (*a == '\0')
				return(0);
			t = b;
		} else
			t++;
	}
	if (*a == '\0' || *a == '|')
		return(1);
	return(0);
}