diff -r -u bcc/Makefile new/Makefile
--- bcc/Makefile	Tue Jul 25 14:27:02 1995
+++ new/Makefile	Sat Dec 30 04:07:02 1995
@@ -1,27 +1,38 @@
 #
-#	Build bcc
+# bcc Makefile
+# $Id$
 #
+CFLAGS		=-g -Wall -fno-strength-reduce -O2 -DLOCALPREFIX="\"/usr\""
+# Uncomment below for Electric Fence malloc debugger.
+#LDFLAGS 	= -L/usr/local/lib -lefence
+CC		= gcc
+OBJS = bcc-cc1.o codefrag.o debug.o declare.o express.o exptree.o floatop.o \
+	function.o gencode.o genloads.o glogcode.o hardop.o input.o label.o \
+	loadexp.o longop.o output.o preproc.o preserve.o scan.o softop.o \
+	state.o table.o type.o assign.o	
+
+
+all:	bcc bcc-cc1
+
+bcc: bcc.o
+	$(CC) $(CFLAGS) bcc.o  $(LDFLAGS) -o $@
+
+bcc09: bcc.o
+	$(CC) -DMC6809 $(CFLAGS) bcc.o $(LDFLAGS) -o $@
+
+ccc: bcc.o
+	$(CC) -DCCC $(CFLAGS bcc.o ) $(LDFLAGS) -o $@
+
+bcc-cc1: $(OBJS)
+	$(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) -o bcc-cc1
+
+clean:
+	rm -f bcc bcc-cc1 bcc09 ccc bcc.o $(OBJS)
 
-all:		bcc bcc-cc1
 
-CFLAGS = -DLOCALPREFIX="\"/usr/local\"" -O2
 
-SRCS		=assign.c declare.c gencode.c label.c preserve.c type.c \
-		 bcc-cc1.c express.c genloads.c loadexp.c scan.c \
-		 exptree.c glogcode.c longop.c softop.c codefrag.c \
-		 floatop.c hardop.c output.c state.c debug.c function.c \
-		 input.c preproc.c table.c
 
-OBJS		=assign.o declare.o gencode.o label.o preserve.o type.o \
-		 bcc-cc1.o express.o genloads.o loadexp.o scan.o \
-		 exptree.o glogcode.o longop.o softop.o codefrag.o \
-		 floatop.o hardop.o output.o state.o debug.o function.o \
-		 input.o preproc.o table.o
 
 
-bcc:		bcc.c
-		$(CC) $(CFLAGS) -o bcc bcc.c
 
-bcc-cc1:	$(OBJS)
-		$(CC) $(CFLAGS) -o bcc-cc1 $(OBJS)
 
Only in new: Makefile~
diff -r -u bcc/assign.c new/assign.c
--- bcc/assign.c	Mon Jun 21 18:51:29 1993
+++ new/assign.c	Sat Dec 30 03:55:29 1995
@@ -26,23 +26,23 @@
 
     if (target->type->constructor & (ARRAY | FUNCTION) ||
 	target->flags == TEMP || target->flags == (LABELLED | STRING) ||
-	target->indcount == 0 && target->flags != REGVAR)
+	(target->indcount == 0 && target->flags != REGVAR))
     {
 	bugerror("botched lvalue");
 	return;
     }
     if (source->storage != target->storage
-	|| source->indcount != target->indcount
-	|| source->level != target->level
-	|| source->offset.offi != target->offset.offi	/* kludge union cmp */
-	|| source->type != target->type
-	|| (source->storage & (LOCAL | GLOBAL)
-	    || source->level == OFFKLUDGELEVEL)
-	   && ((source->flags ^ target->flags) & LABELLED
-	       || source->flags & LABELLED
-		  && source->name.label != target->name.label
-	       || !(source->flags & LABELLED)
-		  && strcmp(source->name.namep, target->name.namep) != 0))
+        || source->indcount != target->indcount
+        || source->level != target->level
+        || source->offset.offi != target->offset.offi   /* kludge union cmp */
+        || source->type != target->type
+        || ((source->storage & (LOCAL | GLOBAL)
+            || source->level == OFFKLUDGELEVEL)
+           && ((source->flags ^ target->flags) & LABELLED
+               || (source->flags & LABELLED
+                  && source->name.label != target->name.label)
+               || (!(source->flags & LABELLED)
+                  && strcmp(source->name.namep, target->name.namep) != 0))))
     {
 	tscalar = target->type->scalar;
 	if (tscalar & CHAR && source->storage == CONSTANT)
@@ -210,7 +210,7 @@
     store_pt targreg;
 
     if (type->constructor & (ARRAY | FUNCTION)
-	|| type->constructor & STRUCTU && target->type != type)
+	|| (type->constructor & STRUCTU && target->type != type))
     {
 	bugerror("botched implicit cast");
 	return;
@@ -262,7 +262,7 @@
 	    target->storage = BREG;
 	}
     }
-    else if (newscalar & (SHORT | INT | LONG) && !(newscalar & DLONG)
+    else if ((newscalar & (SHORT | INT | LONG) && !(newscalar & DLONG))
 	     || type->constructor & POINTER)
     {
 	if (oldscalar & RSCALAR)
Only in new: assign.c~
Only in bcc: bcc
Only in bcc: bcc-cc1
diff -r -u bcc/bcc.c new/bcc.c
--- bcc/bcc.c	Tue Jul 25 14:18:16 1995
+++ new/bcc.c	Sat Dec 30 02:50:08 1995
@@ -553,7 +553,7 @@
 	    {
 		arg = ldargs.argv[argc];
 		if (arg[0] == '-' && arg[1] == 'i'
-		    && (arg[2] == 0 || arg[2] == '-' && arg[3] == 0))
+		    && (arg[2] == 0 || (arg[2] == '-' && arg[3] == 0)))
 		{
 		    --ldargs.argc;
 		    memmove(ldargs.argv + argc, ldargs.argv + argc + 1,
Only in new: bcc.c~
Only in bcc: ccc
diff -r -u bcc/codefrag.c new/codefrag.c
--- bcc/codefrag.c	Sat Nov 14 10:12:35 1992
+++ new/codefrag.c	Sat Dec 30 02:51:41 1995
@@ -616,8 +616,8 @@
 store_pt reg;
 {
 #ifdef I8088
-    if (i386_32 && (uoffset_t) offset + 1 <= 2	/* do -1 to 1 by dec/inc */
-	|| !i386_32 && (uoffset_t) offset + 2 <= 4)	/* do -2 to 2  */
+    if ((i386_32 && (uoffset_t) offset + 1 <= 2)  /* do -1 to 1 by dec/inc */
+	|| (!i386_32 && (uoffset_t) offset + 2 <= 4))	/* do -2 to 2  */
     {
 	if (reg == ALREG)
 	    reg = AXREG;	/* shorter and faster */
@@ -1325,7 +1325,7 @@
     {
 	for (lastcount = single1skip; (factor & 1) == 0; factor >>= 1)
 	    ++lastcount;
-	mulstack[++mulsp] = lastcount;
+	mulstack[(int)++mulsp] = lastcount;
 	/* first time bumps mulsp to 0 even if an unsigned char */
 	for (count = 0; (factor & 1) != 0; factor >>= 1)
 	    ++count;
@@ -1333,14 +1333,14 @@
 	if (count == 2 && factor == 0)
 	    /* 3 = 2 + 1  better than  3 = 4 - 1 */
 	    /* but rest of algorithm messed up unless factor now 0 */
-	    mulstack[++mulsp] = 1;
+	    mulstack[(int)++mulsp] = 1;
 	else if (count > 1)
 	{
 	    single1skip = 0;
 	    if (lastcount == 1 && mulsp != 0)
-		mulstack[mulsp] = -1 - count;
+		mulstack[(int)mulsp] = -1 - count;
 	    else
-		mulstack[++mulsp] = -count;
+		mulstack[(int)++mulsp] = -count;
 	}
     }
     if (mulsp > 3)
@@ -1351,7 +1351,7 @@
 	do
 	{
 	    finishfactor();	/* finish save/add/subfactor() if nec */
-	    stackentry = mulstack[mulsp--];
+	    stackentry = mulstack[(int)mulsp--];
 	    if (stackentry < 0)
 	    {
 #ifdef I8088
Only in new: codefrag.c~
diff -r -u bcc/declare.c new/declare.c
--- bcc/declare.c	Sat Jul 10 05:34:17 1993
+++ new/declare.c	Sat Dec 30 02:53:40 1995
@@ -322,7 +322,7 @@
     value_t fieldwidth;
     value_t fwidth;
     offset_t offset;
-    scalar_t scalar;
+    scalar_t scalar=0;
 
     offset = *psoffset;
     declspec();
@@ -713,8 +713,8 @@
 	}
 	else if (gvarsymptr != NULL && (gvarsymptr->level == level ||
 					gvartype->constructor == FUNCTION ||
-					gvarsc == EXTERNDECL &&
-					gvarsymptr->level == GLBLEVEL))
+					(gvarsc == EXTERNDECL &&
+					gvarsymptr->level == GLBLEVEL)))
 	{
 	    if (gvarsymptr->level != GLBLEVEL || gvarsymptr->flags == KEYWORD)
 		multidecl(gvarname);
@@ -723,8 +723,8 @@
 		if (gvartype->constructor != ARRAY ||
 		    gvarsymptr->type->constructor != ARRAY ||
 		    gvartype->nexttype != gvarsymptr->type->nexttype ||
-		    gvartype->typesize != 0 &&
-		    gvarsymptr->type->typesize != 0)
+		    (gvartype->typesize != 0 &&
+		    gvarsymptr->type->typesize != 0))
 		    multidecl(gvarname);
 		else if (gvartype->typesize != 0)
 		    gvarsymptr->type = gvartype;
Only in new: declare.c~
diff -r -u bcc/exptree.c new/exptree.c
--- bcc/exptree.c	Sat Nov 14 10:12:36 1992
+++ new/exptree.c	Sat Dec 30 03:09:51 1995
@@ -62,15 +62,15 @@
 	if (!(rscalar & DOUBLE))
 	    nodeptr->right = castnode(dtype, right);
     }
-    else if (!(bothscalar & DLONG) && (nodeptr->tag == ANDOP &&
-	     (redscalar(nodeptr->left.nodeptr) | redscalar(right)) & CHAR ||
-	     (nodeptr->tag == EOROP || nodeptr->tag == OROP) &&
-	     redscalar(nodeptr->left.nodeptr) & redscalar(right) & CHAR ||
-	     nodeptr->tag == MODOP && right->tag == LEAF &&
+    else if (!(bothscalar & DLONG) && ((nodeptr->tag == ANDOP &&
+	     (redscalar(nodeptr->left.nodeptr) | redscalar(right)) & CHAR) ||
+	     ((nodeptr->tag == EOROP || nodeptr->tag == OROP) &&
+	     redscalar(nodeptr->left.nodeptr) & redscalar(right) & CHAR) ||
+	     (nodeptr->tag == MODOP && right->tag == LEAF &&
 	     right->left.symptr->storage == CONSTANT &&
 	     (divisor = right->left.symptr->offset.offv,
 	      (uvalue_t) divisor <= MAXUCHTO + 1) &&
-	     bitcount((uvalue_t) divisor) <= 1))
+	     bitcount((uvalue_t) divisor) <= 1)))
     {
 	/* result fits in char and extends correctly */
 	if (bothscalar & UNSIGNED)
@@ -237,17 +237,17 @@
 #if MAXREGS != 1
     weight_t rightweight;
 #endif
-    double dsourceval;
-    double dtargval;
+    double dsourceval = 0; /* for -Wall */
+    double dtargval = 0 ; /* for -Wall */
     bool_t lflag;
     scalar_t lscalar;
     struct nodestruct *pswap;
-    struct symstruct *source;
-    value_t sourceval;
+    struct symstruct *source = NULL; /* for -Wall */
+    value_t sourceval = 0 ;  /* for -Wall */
     struct symstruct *target;
     offset_t targszdelta;
-    value_t targval;
-    scalar_t rscalar;
+    value_t targval = 0; /* for -Wall */
+    scalar_t rscalar = 0; /* for -Wall */
     bool_t uflag;
 
     switch ((op_t) t)
@@ -479,8 +479,8 @@
 	case COMMAOP:
 	    return p2;
 	case CONDOP:
-	    if (lscalar & RSCALAR && dtargval != FALSE
-		|| !(lscalar & RSCALAR) && targval != FALSE)
+	    if ((lscalar & RSCALAR && dtargval != FALSE)
+		|| (!(lscalar & RSCALAR) && targval != FALSE))
 	    {
 		p2->left.nodeptr->nodetype = p2->nodetype;
 		return p2->left.nodeptr;
@@ -488,14 +488,14 @@
 	    p2->right->nodetype = p2->nodetype;
 	    return p2->right;
 	case LOGANDOP:
-	    if (lscalar & RSCALAR && dtargval != FALSE
-		|| !(lscalar & RSCALAR) && targval != FALSE)
+	    if ((lscalar & RSCALAR && dtargval != FALSE)
+		|| (!(lscalar & RSCALAR) && targval != FALSE))
 		break;
 	    p1->nodetype = target->type = itype;
 	    return p1;
 	case LOGOROP:
-	    if (lscalar & RSCALAR && dtargval == FALSE
-		|| !(lscalar & RSCALAR) && targval == FALSE)
+	    if ((lscalar & RSCALAR && dtargval == FALSE)
+		|| (!(lscalar & RSCALAR) && targval == FALSE))
 		break;
 	    target->offset.offv = TRUE;
 	    p1->nodetype = target->type = itype;
@@ -521,11 +521,11 @@
 	}
     }
     if (target->storage != CONSTANT ||
-	!(lscalar & (ISCALAR | RSCALAR)) && (op_t) t != PTRSUBOP ||
-	p2 != NULL &&
+	!((lscalar & (ISCALAR | RSCALAR)) && (op_t) t != PTRSUBOP) ||
+	(p2 != NULL &&
 	(p2->tag != LEAF || (source = p2->left.symptr)->storage != CONSTANT ||
-	 !((rscalar = source->type->scalar) & (ISCALAR | RSCALAR))
-	 && (op_t) t != PTRSUBOP))
+	 (!((rscalar = source->type->scalar) & (ISCALAR | RSCALAR))
+	 && (op_t) t != PTRSUBOP))))
 	goto node1;
     lflag = lscalar & LONG;
     uflag = lscalar & UNSIGNED;
@@ -540,7 +540,7 @@
 	    uflag |= rscalar & UNSIGNED;
 	}
     }
-    if (lscalar & RSCALAR || p2 != NULL && rscalar & RSCALAR)
+    if (lscalar & RSCALAR || (p2 != NULL && rscalar & RSCALAR))
     {
     if (!(lscalar & RSCALAR))
     {
@@ -950,8 +950,8 @@
 		targtype = ctype;
 	    if (bothscalar & UNSIGNED)
 		targtype = tounsigned(targtype);
-	    if (!(bothscalar & INT) || left->tag == LEAF && lscalar & INT ||
-		right->tag == LEAF && rscalar & INT)
+	    if ((!(bothscalar & INT) || (left->tag == LEAF && lscalar & INT)) ||
+		(right->tag == LEAF && rscalar & INT))
 	    {
 		/* this is correct even when the if fails (the casts have to */
 		/* be considered at a lower level) but gives worse code */
@@ -963,12 +963,12 @@
 	    return targtype;	/* XXX - reduced from promote(targtype) */
 	}
 	if (targtype->constructor & POINTER &&
-	    (isconst0(right) || right->nodetype->constructor & POINTER &&
-	     right->nodetype->nexttype->constructor & VOID))
+	    (isconst0(right) || (right->nodetype->constructor & POINTER &&
+	     right->nodetype->nexttype->constructor & VOID)))
 	    return targtype;
 	if (right->nodetype->constructor & POINTER &&
-	    (isconst0(left) || targtype->constructor & POINTER &&
-	     targtype->nexttype->constructor & VOID))
+	    (isconst0(left) || (targtype->constructor & POINTER &&
+	     targtype->nexttype->constructor & VOID)))
 	    return right->nodetype;
 	error("mismatched types");
 	fixnode(left);		/* XXX - better to fix the CONDOP */
Only in new: exptree.c~
diff -r -u bcc/gencode.c new/gencode.c
--- bcc/gencode.c	Sat Nov 14 10:51:21 1992
+++ new/gencode.c	Sat Dec 30 03:13:26 1995
@@ -3,7 +3,7 @@
 /* Copyright (C) 1992 Bruce Evans */
 
 #define islvalop(op) \
-	((op) >= ASSIGNOP && (op) <= SUBABOP || (op) == PTRADDABOP)
+	(((op) >= ASSIGNOP && (op) <= SUBABOP) || (op) == PTRADDABOP)
 
 #include "const.h"
 #include "types.h"
@@ -291,7 +291,7 @@
 	    }
 	    if (source->storage & allindregs && source->indcount == 0 &&
 		(source->type->scalar & (DLONG | RSCALAR) ||
-		 left->tag == FUNCOP && source->flags != REGVAR))
+		 (left->tag == FUNCOP && source->flags != REGVAR)))
 		push(source);	/* XXX - perhaps not float */
 	    else
 		preserve(source);
@@ -351,11 +351,11 @@
     debug(exp);
 #endif
     if (commutop
-	&& (target->storage == CONSTANT
-	    && !(target->type->scalar & (DLONG | RSCALAR))
+	&& ((target->storage == CONSTANT
+	    && !(target->type->scalar & (DLONG | RSCALAR)))
 	    || source->storage & ALLDATREGS
-	    || source->type->scalar & (DLONG | RSCALAR)
-	       && source->indcount == 0 && target->indcount != 0))
+	    || (source->type->scalar & (DLONG | RSCALAR)
+	       && source->indcount == 0 && target->indcount != 0)))
     {
 	exp->left.nodeptr = right;
 	exp->right = left;
@@ -471,12 +471,12 @@
     ccode_t condtrue;
     op_pt op;
     store_t regmark;
-    offset_t saveargsp;
-    store_t savelist;
-    offset_t saveoffset;
+    offset_t saveargsp = 0; /* for -Wall */
+    store_t savelist = 0; /* for -Wall */
+    offset_t saveoffset = 0; /* for -Wall */
     struct symstruct *source;
     offset_t spmark;
-    struct symstruct *structarg;
+    struct symstruct *structarg = 0; /* for -Wall */
     struct symstruct *target;
 
     if ((op_t) (op = exp->tag) == LEAF)
Only in new: gencode.c~
diff -r -u bcc/genloads.c new/genloads.c
--- bcc/genloads.c	Sat Nov 14 10:48:50 1992
+++ new/genloads.c	Sat Dec 30 03:18:09 1995
@@ -434,15 +434,16 @@
     {
 	if (source->type->scalar & RSCALAR)
 	    load(source, doubleregs & ~DREG);
-	else if (source->storage == CONSTANT && !(source->type->scalar & DLONG)
+	else if ((source->storage == CONSTANT &&
+		  !(source->type->scalar & DLONG))
 		 || source->type->scalar & CHAR)
 	    load(source, DREG);
 	else if (source->storage & ~reguse & allregs)
 	    load(source, source->storage);
 	else if (((reguse & allindregs) == allindregs ||
-		  !(source->type->constructor & (ARRAY | POINTER)) &&
+		  ((!(source->type->constructor & (ARRAY | POINTER)) &&
 		  source->indcount != 0) &&
-		 !(source->type->scalar & DLONG))
+		 !(source->type->scalar & DLONG))))
 	    load(source, DREG);
 	else
 	    load(source, getindexreg());
@@ -1011,10 +1012,10 @@
 	}
     }
 #ifdef I8088
-    else if (source->indcount == 1 &&
+    else if ((source->indcount == 1 &&
 	     (sscalar & (SHORT | INT | LONG | FLOAT) ||
-	      source->type->constructor & POINTER) ||
-	     source->storage == CONSTANT && i386_32)
+	      source->type->constructor & POINTER)) ||
+	     (source->storage == CONSTANT && i386_32))
     {
 	size = source->type->typesize;
 	if (size == 1)
Only in new: genloads.c~
diff -r -u bcc/glogcode.c new/glogcode.c
--- bcc/glogcode.c	Sat Nov 14 10:48:57 1992
+++ new/glogcode.c	Sat Dec 30 03:25:43 1995
@@ -90,7 +90,7 @@
     }
 #endif
 #endif
-    sbranch(oppcc[*pcondtrue], falselab = getlabel());
+    sbranch(oppcc[(int)*pcondtrue], falselab = getlabel());
     loadlogical(target, falselab);
 }
 
@@ -107,25 +107,25 @@
     reduceconst(target);
     sscalar = source->type->scalar;
     tscalar = target->type->scalar;
-    if (source->storage != CONSTANT &&
+    if ((source->storage != CONSTANT &&
 	(target->storage == CONSTANT ||
-	 sscalar & CHAR && !(tscalar & CHAR) ||
-	 (sscalar & CHAR || !(tscalar & CHAR)) &&
-	 source->indcount == 0 && target->indcount != 0) ||
-	tscalar & DLONG && target->indcount != 0)
+	 (sscalar & CHAR && !(tscalar & CHAR)) ||
+	 ((sscalar & CHAR || !(tscalar & CHAR)) &&
+	 source->indcount == 0 && target->indcount != 0))) ||
+	(tscalar & DLONG && target->indcount != 0))
     {
 	swapsym(target, source);
-	*pcondtrue = reverscc[*pcondtrue];
+	*pcondtrue = reverscc[(int)*pcondtrue];
 	tempscalar = sscalar;
 	sscalar = tscalar;
 	tscalar = tempscalar;
     }
-    if (sscalar & CHAR && tscalar & CHAR &&
-	(source->type != sctype || target->type != sctype) ||
+    if ((sscalar & CHAR && tscalar & CHAR &&
+	(source->type != sctype || target->type != sctype)) ||
 	(sscalar | tscalar) & UNSIGNED ||
 	(source->type->constructor | target->type->constructor) &
 	(ARRAY | POINTER))
-	*pcondtrue = unsigncc[*pcondtrue];
+	*pcondtrue = unsigncc[(int)*pcondtrue];
     if (source->type->scalar & DLONG)
     {
 	longop(EQOP, source, target);
@@ -141,7 +141,7 @@
 	if (sscalar & CHAR)
 	{
 	    if (tscalar & CHAR)
-		*pcondtrue = unsigncc[*pcondtrue];
+		*pcondtrue = unsigncc[(int)*pcondtrue];
 	    else
 	    {
 		source->type = iscalartotype(sscalar);
@@ -271,7 +271,7 @@
     changesp(spmark, FALSE);
     reguse = regmark;
     if ((bool_t) nojump)
-	lbranch(oppcc[condtrue], falselab);
+	lbranch(oppcc[(int)condtrue], falselab);
     else
 	lbranch(condtrue, truelab);
 }
@@ -452,7 +452,7 @@
     store_t targreg;
 #endif
 
-    *pcondtrue = testcc[*pcondtrue];
+    *pcondtrue = testcc[(int)*pcondtrue];
     if (target->type->scalar & DLONG)
     {
 	long1op(EQOP, target);
@@ -465,7 +465,7 @@
     }
 #ifdef I8088
     if (target->indcount != 0 ||
-	target->storage == LOCAL && target->offset.offi != sp)
+	(target->storage == LOCAL && target->offset.offi != sp))
 	load(target, DREG);
     if (target->storage == GLOBAL)
 	load(target, getindexreg());
@@ -546,7 +546,7 @@
 	condtrue = NE;
 	test(source, &condtrue);
 	if ((bool_t) nojump)
-	    lbranch(oppcc[condtrue], falselab);
+	    lbranch(oppcc[(int)condtrue], falselab);
 	else
 	    lbranch(condtrue, truelab);
     }
Only in new: glogcode.c~
diff -r -u bcc/hardop.c new/hardop.c
--- bcc/hardop.c	Sat Nov 14 10:49:13 1992
+++ new/hardop.c	Sat Dec 30 03:27:09 1995
@@ -286,8 +286,8 @@
 	sscalar = source->type->scalar;
     }
     if (target->indcount != 0 &&
-	(tscalar & CHAR && !(sscalar & CHAR) &&
-       op != ANDOP || source->indcount == 0 && source->storage != CONSTANT))
+	((tscalar & CHAR && !(sscalar & CHAR) &&
+       op != ANDOP) || (source->indcount == 0 && source->storage != CONSTANT)))
     {
 	swapsym(target, source);
 	sscalar = tscalar;
Only in new: hardop.c~
diff -r -u bcc/input.c new/input.c
--- bcc/input.c	Sat Nov 14 10:12:36 1992
+++ new/input.c	Sat Dec 30 03:28:58 1995
@@ -462,9 +462,9 @@
 	    case 't':		/* print source code in asm output */
 	    case 'w':		/* watch location counter */
 		if (arg[2] == 0)
-		    flag[arg[1]] = TRUE;
+		    flag[(int)arg[1]] = TRUE;
 		else if (arg[2] == '-' && arg[3] == 0)
-		    flag[arg[1]] = FALSE;
+		    flag[(int)arg[1]] = FALSE;
 		else
 		    usage();
 		if (arg[1] == '0')	/* flag 0 is negative logic flag 3 */
Only in new: input.c~
Only in new: install
Only in new: install~
diff -r -u bcc/label.c new/label.c
--- bcc/label.c	Sat Nov 14 10:49:22 1992
+++ new/label.c	Sat Dec 30 03:30:30 1995
@@ -78,7 +78,7 @@
 {
     register struct labdatstruct *labptr;
 
-    labptr = &vislab[nextvislab];
+    labptr = &vislab[(int)nextvislab];
     labptr->labcond = cond;
     labptr->labnum = label;
     labptr->lablc = lc;
@@ -184,7 +184,7 @@
 
 	labmin = &vislab[0];
 	labmax = &vislab[MAXVISLAB];
-	labptr = labmid = &vislab[nextvislab];
+	labptr = labmid = &vislab[(int)nextvislab];
 	if (!watchlc)
 	    do
 	    {
@@ -199,7 +199,7 @@
 #ifdef I8088 /* patch "bcc(c) to j(c)(c)( ) */
 			*labpatch = 'j';
 			*(labpatch + 1) =
-			    *(cnameptr = scondnames[labptr->labcond]);
+			    *(cnameptr = scondnames[(int)labptr->labcond]);
 #endif
 #ifdef MC6809
 # ifdef NEW_MC6809 /* patch JMP\t> or LBCC\t to BCC \t */
@@ -308,7 +308,7 @@
     {
 	outlbranch();
 #ifdef I8088
-	outbyte(*(cnameptr = lcondnames[(ccode_t) cond]));
+	outbyte(*(cnameptr = lcondnames[(int) cond]));
 	outbyte(*(cnameptr + 1));
 	if ((ccode_t) cond == LS || (ccode_t) cond == HS)
 	    outbyte('s');	/* "blos" or "bhis" */
@@ -406,7 +406,7 @@
     if ((ccode_t) cond != RN)
     {
 	outsbranch();
-	outbyte(*(cnameptr = scondnames[(ccode_t) cond]));
+	outbyte(*(cnameptr = scondnames[(int) cond]));
 	outbyte(*(cnameptr + 1));
 	outtab();
 	outlabel(label);
Only in new: label.c~
diff -r -u bcc/loadexp.c new/loadexp.c
--- bcc/loadexp.c	Sat Nov 14 10:49:28 1992
+++ new/loadexp.c	Sat Dec 30 03:32:17 1995
@@ -56,9 +56,9 @@
 	makeleaf(node(ASSIGNOP, lhs, exp));
     }
     else if (exp->tag != LEAF ||
-	     (symptr = exp->left.symptr)->storage != CONSTANT &&
+	     ((symptr = exp->left.symptr)->storage != CONSTANT &&
 	     (symptr->storage != GLOBAL || symptr->indcount != 0 ||
-	      type->scalar & DLONG) ||
+	      type->scalar & DLONG)) ||
 	     (type->constructor | (symptr->type->constructor & ~FUNCTION)) &
 	     ~(ARRAY | POINTER))
 	error("initializer too complicated");
Only in new: loadexp.c~
diff -r -u bcc/longop.c new/longop.c
--- bcc/longop.c	Sat Nov 14 10:49:35 1992
+++ new/longop.c	Sat Dec 30 03:33:11 1995
@@ -39,7 +39,7 @@
 	shiftflag = TRUE;
     else
 	scalar |= source->type->scalar;
-    if (source->indcount == 0 && !shiftflag ||
+    if ((source->indcount == 0 && !shiftflag) ||
 	source->storage & (DREG | OPREG | OPWORKREG))
     {
 	pres2(source, target);
Only in new: longop.c~
Only in new: make.log
diff -r -u bcc/output.c new/output.c
--- bcc/output.c	Sat Nov 14 10:12:37 1992
+++ new/output.c	Sat Dec 30 03:33:23 1995
@@ -378,7 +378,7 @@
 	outhexdigs(num / 0x10);
 	num %= 0x10;
     }
-    outbyte(hexdigits[(fastin_t) num]);
+    outbyte(hexdigits[(int) num]);
 }
 
 /* print string terminated by EOL */
Only in new: output.c~
diff -r -u bcc/preproc.c new/preproc.c
--- bcc/preproc.c	Fri Dec  4 16:45:03 1992
+++ new/preproc.c	Sat Dec 30 03:36:47 1995
@@ -230,7 +230,7 @@
     char sname[NAMESIZE];
     char quote;
     struct symstruct **hashptr;
-    struct symstruct *locmark;
+    struct symstruct *locmark = NULL; /* for -Wall */
     char *macstring;
     fastin_t nparnames;
     char *oldstring;
@@ -492,7 +492,7 @@
     {
 	register struct ifstruct *ifptr;
 
-	ifptr = &ifstack[--iflevel];
+	ifptr = &ifstack[(int)--iflevel];
 	ifstate.elseflag = ifptr->elseflag;
 	ifstate.ifflag = ifptr->ifflag;
     }
@@ -586,8 +586,8 @@
 		    }
 		    else if (ch == '(')
 			++lpcount;
-		    else if (ch == ')' && --lpcount == 0 ||
-			     ch == ',' && lpcount == 1)
+		    else if ((ch == ')' && --lpcount == 0) ||
+			     (ch == ',' && lpcount == 1))
 			break;
 		    if (ch == EOL)
 			ch = ' ';
@@ -757,7 +757,7 @@
     {
 	register struct ifstruct *ifptr;
 
-	ifptr = &ifstack[iflevel++];
+	ifptr = &ifstack[(int)iflevel++];
 	ifptr->elseflag = ifstate.elseflag;
 	ifptr->ifflag = ifstate.ifflag;
 	ifstate.elseflag = FALSE;	/* prepare for !(if now)||(if future)*/
@@ -778,8 +778,8 @@
 	    iftrue = constexpression() != 0;
 	    incppexpr = FALSE;
 	}
-	if (!iftrue && (sym_t) ifcase != IFNDEFCNTL ||
-	    iftrue && (sym_t) ifcase == IFNDEFCNTL)
+	if ((!iftrue && (sym_t) ifcase != IFNDEFCNTL) ||
+	    (iftrue && (sym_t) ifcase == IFNDEFCNTL))
 	{
 	    ifstate.elseflag = TRUE;
 	    ifstate.ifflag = FALSE;
Only in new: preproc.c~
diff -r -u bcc/preserve.c new/preserve.c
--- bcc/preserve.c	Sat Nov 14 10:49:55 1992
+++ new/preserve.c	Sat Dec 30 03:38:46 1995
@@ -14,10 +14,10 @@
 offset_t newsp;
 bool_pt absflag;
 {
-    if (newsp != sp || (bool_t) absflag && switchnow != NULL)
+    if (newsp != sp || ((bool_t) absflag && switchnow != NULL))
     {
 #ifdef FRAMEPOINTER
-	if (newsp != framep || !(bool_t) absflag && switchnow != NULL)
+	if (newsp != framep || (!(bool_t) absflag && switchnow != NULL))
 	{
 	    outleasp();
 	    if (!(bool_t) absflag && switchnow != NULL)
@@ -106,7 +106,8 @@
     if (target->storage & allregs)
     {
 	if (target->storage & (allregs - allindregs) /* XXX */ ||
-	    target->indcount == 0 && target->type->scalar & (DLONG | RSCALAR))
+	    (target->indcount == 0 &&
+	     target->type->scalar & (DLONG | RSCALAR)))
 	    push(target);	/* XXX - perhaps not float */
 	else if (((target->storage | reguse) & allindregs) == allindregs)
 	{
Only in new: preserve.c~
diff -r -u bcc/softop.c new/softop.c
--- bcc/softop.c	Sat Nov 14 10:50:02 1992
+++ new/softop.c	Sat Dec 30 03:40:14 1995
@@ -124,14 +124,17 @@
 
     regpushed = (regmark = reguse) & OPREG;
     workreg = OPREG;
-    if (sscalar & CHAR && target->storage & WORKDATREGS &&
-	source->storage == OPREG && source->indcount != 0 ||
-	(sscalar & CHAR || source->storage & WORKDATREGS) &&
-	target->storage == OPREG && target->indcount != 0 ||
-	source->storage == OPREG &&
-	target->storage == GLOBAL && target->indcount == 0
+    if ((sscalar & CHAR && target->storage & WORKDATREGS &&
+	source->storage == OPREG && source->indcount != 0) ||
+	((sscalar & CHAR || source->storage & WORKDATREGS) &&
+	target->storage == OPREG && target->indcount != 0) ||
+#ifdef MC6809 /* for -Wall */
+	(
+#endif
+	(source->storage == OPREG &&
+	target->storage == GLOBAL && target->indcount == 0)
 #ifdef MC6809
-	&& posindependent
+	&& posindependent)
 #endif
 	)
     {
Only in new: softop.c~
diff -r -u bcc/state.c new/state.c
--- bcc/state.c	Sat Nov 14 10:50:07 1992
+++ new/state.c	Sat Dec 30 03:42:29 1995
@@ -128,8 +128,8 @@
 register struct nodestruct *exp;
 {
     return exp == NULL ||
-	exp->tag == LEAF && exp->left.symptr->storage == CONSTANT &&
-	exp->left.symptr->offset.offv != 0;
+	(exp->tag == LEAF && exp->left.symptr->storage == CONSTANT &&
+	exp->left.symptr->offset.offv != 0);
 }
 
 PRIVATE void sort(caselist, count)	/* shell sort */
@@ -370,7 +370,7 @@
 {
     struct loopstruct forloop;
     label_t forstatlab;
-    label_t fortestlab;
+    label_t fortestlab = 0; /* for -Wall */
     struct nodestruct *testexp;
     struct nodestruct *loopexp;
 
@@ -469,7 +469,7 @@
 {
     struct switchstruct *sw;
     struct loopstruct switchloop;
-    offset_t spmark;
+    offset_t spmark = 0; /* for -Wall */
     label_t sdecidelab;
 
     sw = (struct switchstruct *) ourmalloc(sizeof *sw);
Only in new: state.c~
diff -r -u bcc/table.c new/table.c
--- bcc/table.c	Sat Nov 14 10:12:38 1992
+++ new/table.c	Sat Dec 30 03:42:46 1995
@@ -145,7 +145,7 @@
 struct typestruct *type;
 {
     struct symstruct **hashptr;
-    struct symstruct *oldsymptr;
+    struct symstruct *oldsymptr = NULL; /* for -Wall */
     register struct symstruct *symptr;
 
     hashptr = gethashptr(name);
Only in new: table.c~