Rename branch.

--HG--
branch : unlabeled-2.2.1-branch

first/local.h.src

@@ -1,7 +0,0 @@
-/* collection of options, selected by including or excluding 'defines' */
-
-/* Version number of the EM object code */
-#	define	VERSION		3	/* 16 bits number */
-
-/* The default machine used by ack, acc, apc */
-#	define	ACKM		"pdp"

lang/pc/pem/Makefile

@@ -0,0 +1,47 @@
+# $Header$
+d=../../..
+h=$d/h
+PEM=$d/lib/pc_pem
+PEM_OUT=$d/lib/pc_pem.out
+
+HEAD=$h/em_spec.h $h/em_pseu.h $h/em_mnem.h $h/em_mes.h $h/pc_size.h
+LDFLAG=-i
+
+all:            pem pem.out
+
+pem.out:        pem.m
+		apc -mint --t -o pem.out pem.m
+
+pem:            pem.m
+		apc $(LDFLAG) -o pem pem.m
+
+# pem.m is system dependent and may NOT be distributed
+pem.m:          pem.p $(HEAD)
+		-rm -f pem.m
+		-if apc -I$h -O -c.m pem.p ; then :; else \
+			acc -o move move.c ; move ; rm -f move move.[oskm] ; \
+		fi
+
+cmp:		pem
+		cmp pem $(PEM)
+
+install:	pem
+		cp pem $(PEM)
+
+distr:
+		rm -f pem2[24].p
+		co -rdistr2 -p pem.p >pem22.p
+		apc -mpdp -c.m -I$h pem22.p ; rm -f pem22.p
+		co -rdistr2 -p pem.p >pem24.p
+		apc -mvax2 -c.m -I$h pem24.p ; rm -f pem24.p
+clean:
+		-rm -f pem pem.out *.[os] *.old
+
+pr:
+		@pr pem.p
+
+xref:
+		xref pem.p^pr -h "XREF PEM.P"
+
+opr:
+		make pr ^ opr

mach/m68k2/cg/mach.c

@@ -1,274 +0,0 @@
-#ifndef NORCSID
-static char rcsid[] = "$Header$";
-#endif
-
-/*
- * (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
- *
- *          This product is part of the Amsterdam Compiler Kit.
- *
- * Permission to use, sell, duplicate or disclose this software must be
- * obtained in writing. Requests for such permissions may be sent to
- *
- *      Dr. Andrew S. Tanenbaum
- *      Wiskundig Seminarium
- *      Vrije Universiteit
- *      Postbox 7161
- *      1007 MC Amsterdam
- *      The Netherlands
- *
- */
-
-/*
- * machine dependent back end routines for the Motorola 68000
- */
-
-con_part(sz,w) register sz; word w; {
-
-	while (part_size % sz)
-		part_size++;
-	if (part_size == TEM_WSIZE)
-		part_flush();
-	if (sz == 1) {
-		w &= 0xFF;
-		if (part_size == 0)
-			w <<= 8;
-		part_word |= w;
-	} else {
-		assert(sz == 2);
-		part_word = w;
-	}
-	part_size += sz;
-}
-
-con_mult(sz) word sz; {
-
-	if (sz != 4)
-		fatal("bad icon/ucon size");
-	fprintf(codefile,".long %s\n",str);
-}
-
-con_float() {
-
-static int been_here;
-	if (argval != 4 && argval != 8)
-		fatal("bad fcon size");
-	fprintf(codefile,".long\t");
-	if (argval == 8)
-		fprintf(codefile,"F_DUM,");
-	fprintf(codefile,"F_DUM\n");
-	if ( !been_here++)
-	{
-	fprintf(stderr,"Warning : dummy float-constant(s)\n");
-	}
-}
-
-#ifdef REGVARS
-
-
-regscore(off,size,typ,score,totyp)
-	long off;
-{
-	if (score == 0) return -1;
-	switch(typ) {
-		case reg_float:
-			return -1;
-		case reg_pointer:
-			if (size != 4 || totyp != reg_pointer) return -1;
-			score *= 2;
-			break;
-		case reg_loop:
-			score += 5;
-			/* fall through .. */
-		case reg_any:
-			if (size != 2 || totyp == reg_pointer) return -1;
-			break;
-	}
-	if (off >= 0) {
-		/* parameters must be initialised with an instruction
-		 * like "move.w 4(a6),d0", which costs 2 words.
-		 */
-		score -= 2;
-	}
-	score -= 1; /* take save/restore into account */
-	return score;
-}
-
-
-struct regsav_t {
-	char	*rs_reg;	/* e.g. "a3" or "d5" */
-	long	rs_off;		/* offset of variable */
-	int	rs_size;	/* 2 or 4 bytes */
-} regsav[9];
-
-
-int regnr;
-int nr_a_regs,nr_d_regs;
-int TEM_BSIZE;
-static long nlocals;
-
-prolog(n)
-{	nlocals = n; }
-
-
-i_regsave()
-{
-	regnr = 0;
-	nr_a_regs = 0;
-	nr_d_regs = 0;
-	TEM_BSIZE = 0;
-}
-
-#define MOVEM_LIMIT	2
-/* If #registers to be saved exceeds MOVEM_LIMIT, we
-* use the movem instruction to save registers; else
-* we simply use several move.l's.
-*/
-
-
-save()
-{
-	register struct regsav_t *p;
-	int i;
-
-	if (regnr > MOVEM_LIMIT) {
-		fprintf(codefile,"movem.l ");
-		for (p = regsav; ;) {
-			fprintf(codefile,"%s",p->rs_reg);
-			if (++p == &regsav[regnr]) break;
-			putc('/',codefile);
-		}
-		fprintf(codefile,",-(sp)\n");
-	} else {
-		/* Note that the order in which the registers are saved
-		 * is important; it is used by gto.s.
-		 */
-		for (i = 0; i < nr_a_regs; i++) {
-			fprintf(codefile,"move.l a%d,-(sp)\n",5-i);
-		}
-		for (i = 0; i < nr_d_regs; i++) {
-			fprintf(codefile,"move.l d%d,-(sp)\n",7-i);
-		}
-	}
-	/* Push a mask that indicates which registers were saved */
-	assert(nr_d_regs < 8 && nr_a_regs < 8);
-	if (nr_d_regs == 0 && nr_a_regs == 0) {
-		fprintf(codefile,"clr.w -(sp)\n");
-	} else {
-		fprintf(codefile,"move.w #%d,-(sp)\n",
-			nr_d_regs + (nr_a_regs<<3));
-	}
-
-	/* Compute AB - LB */
-	TEM_BSIZE = 4 * (nr_d_regs + nr_a_regs) + 10;
-
-	/* allocate space for local variables */
-	fprintf(codefile,"tst.b -%D(sp)\nlink\ta6,#-%D\n",nlocals+40,nlocals);
-
-	/* initialise register-parameters */
-	for (p = regsav; p < &regsav[regnr]; p++) {
-		if (p->rs_off >= 0) {
-			fprintf(codefile,"move.%c %ld(a6),%s\n",
-				(p->rs_size == 4 ? 'l' : 'w'),
-				p->rs_off + TEM_BSIZE,
-				p->rs_reg);
-		}
-	}
-}
-
-restr()
-{
-	register struct regsav_t *p;
-	int i;
-
-	fprintf(codefile,"unlk a6\n");
-	fprintf(codefile,"add.l #2,sp\n"); /* pop mask */
-	if (regnr > MOVEM_LIMIT)  {
-		fprintf(codefile,"movem.l (sp)+,");
-		for (p = regsav; ;) {
-			fprintf(codefile,"%s",p->rs_reg);
-			if (++p == &regsav[regnr]) break;
-			putc('/',codefile);
-		}
-		putc('\n',codefile);
-	} else {
-		for (i = nr_d_regs - 1; i >= 0; i--) {
-			fprintf(codefile,"move.l (sp)+,d%d\n",7-i);
-		}
-		for (i = nr_a_regs - 1; i >= 0; i--) {
-			fprintf(codefile,"move.l (sp)+,a%d\n",5-i);
-		}
-	}
-	fprintf(codefile,"rts\n");
-}
-
-
-f_regsave()
-{
-	save();
-}
-
-regsave(str,off,size)
-	char *str;
-	long off;
-{
-	assert (regnr < 9);
-	regsav[regnr].rs_reg = str;
-	if (str[0] == 'a') {
-		nr_a_regs++;
-	} else {
-		assert(str[0] == 'd');
-		nr_d_regs++;
-	}
-	regsav[regnr].rs_off = off;
-	regsav[regnr++].rs_size = size;
-	fprintf(codefile, "!Local %ld into %s\n",off,str);
-}
-
-regreturn()
-{
-	restr();
-}
-
-#endif
-
-#ifndef REGVARS
-
-prolog(nlocals) full nlocals; {
-
-	fprintf(codefile,"tst.b -%D(sp)\nlink\ta6,#-%D\n",nlocals+40,nlocals);
-}
-
-#endif
-
-
-
-mes(type) word type ; {
-	int argt ;
-
-	switch ( (int)type ) {
-	case ms_ext :
-		for (;;) {
-			switch ( argt=getarg(
-			    ptyp(sp_cend)|ptyp(sp_pnam)|sym_ptyp) ) {
-			case sp_cend :
-				return ;
-			default:
-				strarg(argt) ;
-				fprintf(codefile,".define %s\n",argstr) ;
-				break ;
-			}
-		}
-	default :
-		while ( getarg(any_ptyp) != sp_cend ) ;
-		break ;
-	}
-}
-
-
-char    *segname[] = {
-	".text",        /* SEGTXT */
-	".data",        /* SEGCON */
-	".data",        /* SEGROM */
-	".bss"          /* SEGBSS */
-};

mach/m68k4/libem/dvi.s

@@ -1,42 +0,0 @@
-.define .dvi
-
- ! signed long divide
-	.text
-.dvi:
-	movem.l	d0/d2,.savdvi
-	move.l	(sp)+,.retdvi
-	move.l	(sp)+,d0
-	move.l	(sp)+,d1
-	clr.l	d4
-	tst.l	d0	! divisor
-	bpl	1f
-	neg.l	d0
-	not	d4
-1:
-	tst.l	d1	! dividend
-	bpl	2f
-	neg.l	d1
-	not	d4
-	swap	d4
-	not	d4
-	swap	d4
-2:
-	move.l	d1,-(sp)
-	move.l	d0,-(sp)
-	jsr	.dvu
-	tst	d4
-	beq	5f
-	neg.l	d1	! quotient
-5:
-	tst.l	d4
-	bpl	6f
-	neg.l	d3	! remainder
-6:
-	movem.l .savdvi,d0/d2
-	move.l	.retdvi,-(sp)
-	rts
-.data
-.savdvi:	.space 8
-.retdvi:	.long 0
-.text
-.align 2

mach/proto/as/comm6.c

@@ -0,0 +1,363 @@
+/* @(#)comm6.c	1.7 */
+/*
+ * implement pseudo instructions
+ */
+
+#include	"comm0.h"
+#include	"comm1.h"
+#include	"y.tab.h"
+
+newequate(ip, typ)
+register item_t *ip;
+register short typ;
+{
+	typ &= ~S_EXT;
+	if (typ & S_COM)
+		typ = S_UND;
+	else if ((typ & S_VAR) && (typ & S_TYP) != S_ABS)
+		typ = S_UND;
+#ifdef THREE_PASS
+	else if (pass == PASS_1 && typ == S_UND)
+		typ = S_VAR;
+	else if (pass == PASS_2 && (ip->i_type & S_TYP) == S_UND)
+		ip->i_type |= typ;
+#endif THREE_PASS
+	if (typ == S_UND)
+		serror("illegal equate");
+	if (pass == PASS_3)
+		assert((ip->i_type & S_TYP) == (typ & S_TYP));
+	newident(ip, typ);
+}
+
+newident(ip, typ)
+register item_t *ip;
+{
+	register flag;
+#ifdef GENLAB
+	static char genlab[] = GENLAB;
+#endif GENLAB
+
+	if (pass == PASS_1) {
+		/* printf("declare %s: %o\n", ip->i_name, typ); */
+		if (ip->i_type & ~S_EXT)
+			serror("multiple declared");
+		else
+			--unresolved;
+		ip->i_type |= typ;
+	}
+	if (PASS_SYMB == 0)
+		return;
+#ifdef THREE_PASS
+	if (ip->i_type & S_EXT)
+		flag = SYM_EXT;
+	else
+		flag = SYM_LOC;
+#else
+	flag = SYM_EXT|SYM_LOC;	/* S_EXT not stable in PASS_1 */
+#endif THREE_PASS
+#ifdef GENLAB
+	if (strncmp(ip->i_name, genlab, sizeof(genlab)-1) == 0)
+		flag = SYM_LAB;
+#endif GENLAB
+	if (sflag & flag)
+		newsymb(
+			ip->i_name,
+			ip->i_type & (S_EXT|S_TYP),
+			(short)0,
+			load(ip)
+		);
+}
+
+newlabel(ip)
+register item_t *ip;
+{
+#ifdef THREE_PASS
+	register addr_t oldval = ip->i_valu;
+#endif
+
+	if (DOTSCT == NULL)
+		nosect();
+	ip->i_type &= ~S_TYP;
+	ip->i_type |= DOTTYP;
+	if (store(ip, (valu_t) DOTVAL) == 0)
+		return;
+#ifdef THREE_PASS
+	assert(pass != PASS_2 || oldval - ip->i_valu == DOTGAIN);
+#endif
+}
+
+newsect(ip)
+register item_t *ip;
+{
+	register ushort typ;
+	register sect_t *sp = NULL;
+
+	typ = ip->i_type & S_TYP;
+	if (typ == S_UND) {
+		/*
+		 * new section
+		 */
+		assert(pass == PASS_1);
+		--unresolved;
+		typ = outhead.oh_nsect + S_MIN;
+		outhead.oh_nsect++;
+		if (outhead.oh_nsect > SECTMAX || typ > S_MAX)
+			fatal("too many sections");
+		sp = &sect[typ - S_MIN];
+		sp->s_item = ip;
+		sp->s_lign = ALIGNSECT;
+#ifdef DUK
+		ip->i_type = typ;
+#else DUK
+		ip->i_type = typ | S_EXT;
+#endif DUK
+		ip->i_valu = 0;
+	} else if (typ >= S_MIN) {
+		sp = &sect[typ - S_MIN];
+		if (sp->s_item != ip)
+			sp = NULL;
+	}
+	if (sp == NULL)
+		serror("multiple declared");
+	else
+		switchsect(typ);
+}
+
+newbase(base)
+valu_t base;
+{
+#ifdef ASLD
+	register sect_t *sp;
+	
+	if ((sp = DOTSCT) == NULL)
+		nosect();
+	if (sp->s_flag & BASED)
+		serror("already based");
+	sp->s_base = base;
+	sp->s_flag |= BASED;
+	DOTVAL += base;
+#else
+	warning(".base ignored");
+#endif
+}
+
+/*
+ * NOTE: A rather different solution is used for ASLD and NOLD:
+ * ASLD:
+ *   -	maximum length of .comm is recorded in i_valu during PASS_1
+ *   -	address of .comm is recorded in i_valu in later passes:
+ *	assigned at end of PASS_1, corrected for s_gain at end of PASS_2
+ *   -	symbol table entries are produced in commfinish()
+ * NOLD:
+ *   -	i_valu cannot be used since it is needed for relocation info
+ *   -	only one .comm with a particular symbol is allowed per module
+ *   -	symbol table entries are produced in newcomm()
+ */
+newcomm(ip, val)
+register item_t *ip;
+valu_t val;
+{
+	if (pass == PASS_1) {
+		if (DOTSCT == NULL)
+			nosect();
+		if (val == 0)
+			serror("bad size");
+		/* printf("declare %s: %o\n", ip->i_name, DOTTYP); */
+		if ((ip->i_type & ~S_EXT) == S_UND) {
+			--unresolved;
+			ip->i_type = S_COM|DOTTYP|(ip->i_type&S_EXT);
+#ifdef ASLD
+			ip->i_valu = val;
+		} else if (ip->i_type == (S_COM|S_EXT|DOTTYP)) {
+			if (ip->i_valu < val)
+				ip->i_valu = val;
+#endif
+		} else
+			serror("multiple declared");
+	}
+#ifndef ASLD
+	if (PASS_SYMB == 0)
+		return;
+	if (pass != PASS_3)
+		/*
+		 * save symbol table index
+		 * for possible relocation
+		 */
+		ip->i_valu = outhead.oh_nname;
+#ifdef DUK
+	newsymb(ip->i_name, S_COM|DOTTYP|(ip->i_type&S_EXT), (short)0, val);
+#else DUK
+	newsymb(ip->i_name, S_EXT|DOTTYP, (short)0, val);
+#endif DUK
+#endif
+}
+
+switchsect(newtyp)
+short newtyp;
+{
+	register sect_t *sp;
+	
+	if (sp = DOTSCT)
+		sp->s_size = DOTVAL - sp->s_base;
+	if (newtyp == S_UND) {
+		DOTSCT = NULL;
+		DOTTYP = newtyp;
+		return;
+	}
+	assert(newtyp >= S_MIN);
+	sp = &sect[newtyp - S_MIN];
+	if (pass == PASS_3) {
+#ifdef AOUTSEEK
+		aoutpart = -1;
+		aoutseek[PARTEMIT] = sp->s_foff + sp->s_size - sp->s_zero;
+#else
+		fseek(aoutfile[PARTEMIT], sp->s_foff + sp->s_size - sp->s_zero, 0);
+#endif
+	}
+	DOTVAL = sp->s_size + sp->s_base;
+	DOTSCT = sp;
+	DOTTYP = newtyp;
+}
+
+align(bytes)
+valu_t bytes;
+{
+	register valu_t gap;
+	register sect_t *sp;
+
+	if ((sp = DOTSCT) == NULL)
+		nosect();
+	if (bytes == 0)
+		bytes = ALIGNWORD;
+	if (sp->s_lign % bytes)
+		if (bytes % sp->s_lign)
+			serror("illegal alignment");
+		else
+			sp->s_lign = bytes;
+	if (pass == PASS_1)
+		/*
+		 * be pessimistic: biggest gap possible
+		 */
+		gap = bytes - 1;
+	else {
+		/*
+		 * calculate gap correctly;
+		 * will be the same in PASS_2 and PASS_3
+		 */
+		if ((gap = DOTVAL % bytes) != 0)
+			gap = bytes - gap;
+#ifdef THREE_PASS
+		if (pass == PASS_2)
+			/*
+			 * keep track of gain with respect to PASS_1
+			 */
+			DOTGAIN += (bytes - 1) - gap;
+#endif
+	}
+	/* I don't play the os_zero game here, but plainly write out zero's */
+	/* Led abuses trailing zero parts */
+	while (gap--) emit1(0) ;
+}
+
+#ifdef RELOCATION
+newrelo(s, n)
+short s;
+{
+	struct outrelo outrelo;
+#ifdef DUK
+	int	iscomm;
+#endif DUK
+
+	if (rflag == 0)
+		return;
+	if (PASS_RELO == 0)
+		return;
+	s &= ~S_DOT;
+	assert((s & ~(S_COM|S_VAR|S_TYP)) == 0);
+#ifndef THREE_PASS
+	if (s == S_UND)
+		serror("bad relocation");
+#endif
+	/*
+	 * always relocation info if S_VAR to solve problems with:
+	 *	move	b,d0
+	 *	b=a
+	 *  a:	.data2	0
+	 */
+#ifdef DUK
+	iscomm = s & S_COM;
+#endif DUK
+	s &= ~S_COM;
+	if ((n & RELPC) == 0 && s == S_ABS)
+		return;
+	if ((n & RELPC) != 0 && s == DOTTYP)
+		return;
+	if (pass != PASS_3) {
+		outhead.oh_nrelo++;
+		return;
+	}
+	s &= ~S_VAR;
+	outrelo.or_type = (char)n;
+	outrelo.or_sect = (char)DOTTYP;
+#ifndef ASLD
+#ifdef DUK
+	if (s == S_UND || iscomm) {
+#else DUK
+	if (s == S_UND) {
+#endif DUK
+		assert(relonami != 0);
+		outrelo.or_nami = relonami-1;
+		relonami = 0;
+	} else
+#endif
+	if (s < S_MIN) {
+		assert(s == S_ABS);
+		/*
+		 * use first non existing entry (argh)
+		 */
+		outrelo.or_nami = outhead.oh_nname;
+	} else {
+		/*
+		 * section symbols are at the end
+		 */
+		outrelo.or_nami = outhead.oh_nname
+				- outhead.oh_nsect
+				+ (s - S_MIN)
+				;
+	}
+	outrelo.or_addr = (long)DOTVAL;
+	putofmt((char *)&outrelo, SF_RELO, PARTRELO);
+}
+#endif
+
+newsymb(name, type, desc, valu)
+register char *name;
+short type;
+short desc;
+valu_t valu;
+{
+	struct outname outname;
+
+	if (name && *name == 0)
+		name = 0;
+	assert(PASS_SYMB);
+	if (pass != PASS_3) {
+		if (name)
+			outhead.oh_nchar += strlen(name)+1;
+		outhead.oh_nname++;
+		return;
+	}
+	if (name) {
+		AOUTPART(PARTCHAR);
+		outname.on_foff = outhead.oh_nchar;
+		do {
+			AOUTPUTC(*name, PARTCHAR);
+			outhead.oh_nchar++;
+		} while (*name++);
+	} else
+		outname.on_foff = 0;
+	outname.on_type = type;
+	outname.on_desc = desc;
+	outname.on_valu = valu & ~((0xFFFFFFFF)<<(8*sizeof(valu_t)));
+	putofmt((char *)&outname, SF_NAME, PARTNAME);
+}

util/ass/Makefile

@@ -1,78 +0,0 @@
-d=../..
-l=$d/mach/m68k2/lib
-h=$d/h
-ASS_PATH=$l/em_ass
-CC=pmds
-
-SEP_OPT=-n
-
-CFLAGS=-O -.c
-
-all:            ass$(SEP_OPT)
-
-clean:
-		-rm -f ass-i ass-n *.o maktab *.old asstb.c
-
-install :       all
-		cp ass$(SEP_OPT) $(ASS_PATH)
-
-cmp :           all
-		cmp ass$(SEP_OPT) $(ASS_PATH)
-
-lint:           ass00.c ass30.c ass40.c ass50.c ass60.c ass70.c \
-			ass80.c assci.c assda.c assrl.c asstb.c asscm.c
-		lint -hpvbx \
-			ass00.c ass30.c ass40.c ass50.c ass60.c ass70.c \
-			ass80.c assci.c assda.c assrl.c asstb.c asscm.c
-
-
-ass-n:       ass00.o ass30.o ass40.o ass50.o ass60.o ass70.o \
-			ass80.o assci.o assda.o assrl.o asstb.o asscm.o \
-			$l/em_data.a
-		$(CC) $(CFLAGS) -s -o ass-n \
-			ass00.o ass30.o ass40.o ass50.o ass60.o ass70.o \
-			ass80.o assci.o assda.o assrl.o asstb.o asscm.o \
-			$l/em_data.a >ass.symb
-
-ass-i:       ass00.o ass30.o ass40.o ass50.o ass60.o ass70.o \
-			ass80.o assci.o assda.o assrl.o asstb.o asscm.o \
-			$l/em_data.a
-		$(CC) -i $(CFLAGS) -o ass-i \
-			ass00.o ass30.o ass40.o ass50.o ass60.o ass70.o \
-			ass80.o assci.o assda.o assrl.o asstb.o asscm.o \
-			$l/em_data.a
-
-ass00.o ass40.o ass60.o ass70.o ass80.o assrl.o: \
-		$h/local.h $h/em_spec.h $h/as_spec.h \
-		$h/em_flag.h $h/arch.h ass00.h assex.h
-
-assci.o:        $h/local.h $h/em_spec.h $h/as_spec.h \
-		$h/em_flag.h $h/em_mes.h $h/em_pseu.h \
-		$h/em_ptyp.h $h/arch.h ass00.h assex.h
-
-ass30.o ass50.o : \
-		$h/local.h $h/em_spec.h $h/as_spec.h \
-		$h/em_flag.h ip_spec.h ass00.h assex.h
-
-ass80.o:        $h/em_path.h
-
-assda.o:        $h/local.h $h/em_spec.h $h/as_spec.h \
-		$h/em_flag.h $h/arch.h ass00.h
-
-asscm.o:        ass00.h
-
-asstb.o:        asstb.c
-
-asstb.c:        maktab ip_spec.t
-		maktab ip_spec.t asstb.c
-
-maktab:         maktab.c $h/em_spec.h ip_spec.h $h/em_flag.h \
-		$l/em_data.a
-		$(CC) -O -o maktab maktab.c $l/em_data.a
-
-opr:
-		make pr ^ opr
-
-pr:
-		@(pr ass00.h assex.h ip_spec.h ass?0.c ass[rcd]?.c \
-		maktab.c ; pr -3 ip_spec.t)

util/led/Makefile

@@ -0,0 +1,161 @@
+#
+#	Author: L.J. Bekema @ VU Informatica, Amsterdam
+#
+
+.SUFFIXES:	.c,v .h .h,v
+
+.c,v.o:
+	co -q $*.c
+	$(CC) $(CFLAGS) -c $*.c
+	rm -f $*.c
+
+.h,v.h:
+	co -q $*.h
+
+#	Definitions for the making programs.
+
+M	= /user1/sjoerd/amoeba/libmonix
+X	= /usr/em/lib/l68k2
+CC	= l68k2
+LIBDIR	= ../../lib
+PREFLAGS= -DNDEBUG # -DNASSERT
+CFLAGS	= -L $(PREFLAGS)
+LDFLAGS	= -b0:0x20000 -a0:2 -a1:2 -a2:2 -a3:2 -a4:2 -c.out $M/head.o
+LDLIBS	= $X/tail_cc.1s $X/tail_cc.2g $M/libmonix.a $X/tail_em.rt $X/end_em
+LINTFLAGS=-phbxac $(PREFLAGS)
+PR	= pr
+PRFLAGS	=
+
+#	Some convenient macro definitions.
+
+CFILES	= archive.c byte_order.c error.c extract.c finish.c main.c memory.c\
+	  output.c read.c relocate.c save.c scan.c sym.c write.c
+CVFILES	= archive.c,v byte_order.c,v error.c,v extract.c,v finish.c,v main.c,v\
+	  memory.c,v output.c,v read.c,v relocate.c,v save.c,v scan.c,v\
+	  sym.c,v write.c,v
+HFILES	= assert.h const.h debug.h defs.h memory.h orig.h scan.h
+HVFILES	= assert.h,v const.h,v debug.h,v defs.h,v memory.h,v orig.h,v scan.h,v
+OFILES	= archive.o byte_order.o error.o extract.o finish.o main.o memory.o\
+	  output.o read.o relocate.o save.o scan.o sym.o write.o
+
+#	Things that can be made.
+
+led:	$(OFILES)
+	$(CC) $(LDFLAGS) $(OFILES) $(LDLIBS) -o led.led
+	/user1/sjoerd/amoeba/util/convert led.led led
+	/user1/sjoerd/amoeba/test/load led >/user1/sjoerd/amoeba/test/led.load
+
+mach.c:	mach.c,v
+	co -q mach.c
+
+install:led
+	cp led $(LIBDIR)/em_led
+
+cmp:	led
+	cmp led $(LIBDIR)/em_led
+
+lint:
+	-for i in $(CFILES) $(HFILES) mach.c; do\
+		if test ! -f $$i; then\
+			echo $$i >> checked.out;\
+			co -q $$i;\
+		fi;\
+	done
+	lint $(LINTFLAGS) $(CFILES)
+	rm -f `cat checked.out` checked.out
+
+pr:	$(CVFILES) $(HVFILES) mach.c
+	@-for i in $?; do\
+		co -q -p $$i | $(PR) $(PRFLAGS) -h `basename $$i ,v`;\
+	done
+	@touch pr
+opr:	
+	make pr | opr
+
+clean:
+	rm *.o led
+
+depend:
+	-for i in $(CFILES); do\
+		if test ! -f $$i; then\
+			echo $$i >> checked.out;\
+			co -q $$i;\
+		fi;\
+	done
+	makedepend $(CFILES)
+	rm -f `cat checked.out` checked.out
+
+procentry.o:
+	$(CC) -c -L procentry.c
+
+#	The next lines are generated automatically.
+# AUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTOAUTO
+archive.o:	../../h/arch.h
+archive.o:	../../h/out.h
+archive.o:	../../h/ranlib.h
+archive.o:	const.h
+archive.o:	debug.h
+archive.o:	defs.h
+archive.o:	memory.h
+byte_order.o:	assert.h
+byte_order.o:	const.h
+error.o:	../../h/out.h
+error.o:	const.h
+extract.o:	../../h/out.h
+extract.o:	const.h
+extract.o:	debug.h
+extract.o:	defs.h
+extract.o:	memory.h
+extract.o:	orig.h
+extract.o:	scan.h
+finish.o:	../../h/out.h
+finish.o:	const.h
+finish.o:	defs.h
+finish.o:	memory.h
+finish.o:	orig.h
+finish.o:	scan.h
+main.o:	../../h/out.h
+main.o:	const.h
+main.o:	debug.h
+main.o:	defs.h
+main.o:	memory.h
+main.o:	orig.h
+memory.o:	../../h/out.h
+memory.o:	assert.h
+memory.o:	const.h
+memory.o:	debug.h
+memory.o:	mach.c
+memory.o:	memory.h
+output.o:	../../h/out.h
+output.o:	const.h
+output.o:	memory.h
+read.o:	../../h/arch.h
+read.o:	../../h/out.h
+read.o:	../../h/ranlib.h
+read.o:	assert.h
+read.o:	const.h
+relocate.o:	../../h/out.h
+relocate.o:	const.h
+relocate.o:	debug.h
+relocate.o:	defs.h
+relocate.o:	orig.h
+save.o:	../../h/arch.h
+save.o:	../../h/out.h
+save.o:	assert.h
+save.o:	const.h
+save.o:	memory.h
+scan.o:	../../h/arch.h
+scan.o:	../../h/out.h
+scan.o:	../../h/ranlib.h
+scan.o:	assert.h
+scan.o:	const.h
+scan.o:	memory.h
+scan.o:	scan.h
+sym.o:	../../h/out.h
+sym.o:	const.h
+sym.o:	memory.h
+write.o:	../../h/out.h
+write.o:	assert.h
+write.o:	const.h
+write.o:	memory.h
+write.o:	orig.h