From: Peter Johnson <peter@tortall.net>
Date: Sun, 19 Aug 2001 03:52:58 +0000 (-0000)
Subject: Run through GNU indent using indent profile.  Manually fix some changes
X-Git-Tag: v0.1.0~370
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=edf74fe9ea33f459c5d2178522e762b742b2c75c;p=yasm

Run through GNU indent using indent profile.  Manually fix some changes
(particularly functions such as BuildBC_Insn() which have large numbers
of arguments).

svn path=/trunk/yasm/; revision=141
---

diff --git a/frontends/yasm/yasm.c b/frontends/yasm/yasm.c
index 35f30bdd..f1075991 100644
--- a/frontends/yasm/yasm.c
+++ b/frontends/yasm/yasm.c
@@ -1,4 +1,4 @@
-/* $Id: yasm.c,v 1.6 2001/08/19 02:15:18 peter Exp $
+/* $Id: yasm.c,v 1.7 2001/08/19 03:52:58 peter Exp $
  * Program entry point, command line parsing
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -33,13 +33,13 @@ unsigned int line_number = 1;
 unsigned int mode_bits = 32;
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
     FILE *in;
 
-    if(argc==2) {
+    if (argc == 2) {
 	in = fopen(argv[1], "rt");
-	if(!in) {
+	if (!in) {
 	    fprintf(stderr, "could not open file `%s'\n", argv[1]);
 	    return EXIT_FAILURE;
 	}
@@ -51,8 +51,7 @@ main (int argc, char *argv[])
 
     nasm_parser.doparse(&raw_preproc, &dbg_outfmt, in);
 
-    if(filename)
+    if (filename)
 	free(filename);
     return EXIT_SUCCESS;
 }
-
diff --git a/libyasm/bytecode.c b/libyasm/bytecode.c
index 54c7c8e4..b86e86e7 100644
--- a/libyasm/bytecode.c
+++ b/libyasm/bytecode.c
@@ -1,4 +1,4 @@
-/* $Id: bytecode.c,v 1.15 2001/08/18 22:15:12 peter Exp $
+/* $Id: bytecode.c,v 1.16 2001/08/19 03:52:58 peter Exp $
  * Bytecode utility functions
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -30,22 +30,24 @@
 /* Static structures for when NULL is passed to conversion functions. */
 /*  for Convert*ToEA() */
 static effaddr eff_static;
+
 /*  for Convert*ToImm() */
 static immval im_static;
+
 /*  for Convert*ToBytes() */
 unsigned char bytes_static[16];
 
 static void BuildBC_Common(bytecode *bc);
 
 effaddr *
-ConvertRegToEA (effaddr *ptr, unsigned long reg)
+ConvertRegToEA(effaddr *ptr, unsigned long reg)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &eff_static;
 
     ptr->len = 0;
     ptr->segment = 0;
-    ptr->modrm = 0xC0 | (reg & 0x07);	    /* Mod=11, R/M=Reg, Reg=0 */
+    ptr->modrm = 0xC0 | (reg & 0x07);	/* Mod=11, R/M=Reg, Reg=0 */
     ptr->valid_modrm = 1;
     ptr->need_modrm = 1;
     ptr->valid_sib = 0;
@@ -55,9 +57,9 @@ ConvertRegToEA (effaddr *ptr, unsigned long reg)
 }
 
 effaddr *
-ConvertExprToEA (effaddr *ptr, expr *expr_ptr)
+ConvertExprToEA(effaddr *ptr, expr *expr_ptr)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &eff_static;
 
     ptr->segment = 0;
@@ -73,13 +75,13 @@ ConvertExprToEA (effaddr *ptr, expr *expr_ptr)
 }
 
 effaddr *
-ConvertImmToEA (effaddr *ptr, immval *im_ptr, unsigned char im_len)
+ConvertImmToEA(effaddr *ptr, immval *im_ptr, unsigned char im_len)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &eff_static;
 
     ptr->disp = im_ptr->val;
-    if(im_ptr->len > im_len)
+    if (im_ptr->len > im_len)
 	Warning(WARN_VALUE_EXCEEDS_BOUNDS, (char *)NULL, "word");
     ptr->len = im_len;
     ptr->segment = 0;
@@ -92,17 +94,17 @@ ConvertImmToEA (effaddr *ptr, immval *im_ptr, unsigned char im_len)
 }
 
 immval *
-ConvertIntToImm (immval *ptr, unsigned long int_val)
+ConvertIntToImm(immval *ptr, unsigned long int_val)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &im_static;
 
     /* FIXME: this will leak expr's if static is used */
     ptr->val = expr_new_ident(EXPR_NUM, ExprNum(int_val));
 
-    if((int_val & 0xFF) == int_val)
+    if ((int_val & 0xFF) == int_val)
 	ptr->len = 1;
-    else if((int_val & 0xFFFF) == int_val)
+    else if ((int_val & 0xFFFF) == int_val)
 	ptr->len = 2;
     else
 	ptr->len = 4;
@@ -113,9 +115,9 @@ ConvertIntToImm (immval *ptr, unsigned long int_val)
 }
 
 immval *
-ConvertExprToImm (immval *ptr, expr *expr_ptr)
+ConvertExprToImm(immval *ptr, expr *expr_ptr)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &im_static;
 
     ptr->val = expr_ptr;
@@ -126,21 +128,21 @@ ConvertExprToImm (immval *ptr, expr *expr_ptr)
 }
 
 void
-SetEASegment (effaddr *ptr, unsigned char segment)
+SetEASegment(effaddr *ptr, unsigned char segment)
 {
-    if(!ptr)
+    if (!ptr)
 	return;
 
-    if(ptr->segment != 0)
+    if (ptr->segment != 0)
 	Warning(WARN_MULT_SEG_OVERRIDE, (char *)NULL);
 
     ptr->segment = segment;
 }
 
 void
-SetEALen (effaddr *ptr, unsigned char len)
+SetEALen(effaddr *ptr, unsigned char len)
 {
-    if(!ptr)
+    if (!ptr)
 	return;
 
     /* Currently don't warn if length truncated, as this is called only from
@@ -151,12 +153,12 @@ SetEALen (effaddr *ptr, unsigned char len)
 }
 
 void
-SetInsnOperSizeOverride (bytecode *bc, unsigned char opersize)
+SetInsnOperSizeOverride(bytecode *bc, unsigned char opersize)
 {
-    if(!bc)
+    if (!bc)
 	return;
 
-    switch(bc->type) {
+    switch (bc->type) {
 	case BC_INSN:
 	    bc->data.insn.opersize = opersize;
 	    break;
@@ -165,18 +167,18 @@ SetInsnOperSizeOverride (bytecode *bc, unsigned char opersize)
 	    break;
 	default:
 	    InternalError(__LINE__, __FILE__,
-		"OperSize override applied to non-instruction");
+			  "OperSize override applied to non-instruction");
 	    return;
     }
 }
 
 void
-SetInsnAddrSizeOverride (bytecode *bc, unsigned char addrsize)
+SetInsnAddrSizeOverride(bytecode *bc, unsigned char addrsize)
 {
-    if(!bc)
+    if (!bc)
 	return;
 
-    switch(bc->type) {
+    switch (bc->type) {
 	case BC_INSN:
 	    bc->data.insn.addrsize = addrsize;
 	    break;
@@ -185,20 +187,20 @@ SetInsnAddrSizeOverride (bytecode *bc, unsigned char addrsize)
 	    break;
 	default:
 	    InternalError(__LINE__, __FILE__,
-		"AddrSize override applied to non-instruction");
+			  "AddrSize override applied to non-instruction");
 	    return;
     }
 }
 
 void
-SetInsnLockRepPrefix (bytecode *bc, unsigned char prefix)
+SetInsnLockRepPrefix(bytecode *bc, unsigned char prefix)
 {
     unsigned char *lockrep_pre = (unsigned char *)NULL;
 
-    if(!bc)
+    if (!bc)
 	return;
 
-    switch(bc->type) {
+    switch (bc->type) {
 	case BC_INSN:
 	    lockrep_pre = &bc->data.insn.lockrep_pre;
 	    break;
@@ -207,29 +209,29 @@ SetInsnLockRepPrefix (bytecode *bc, unsigned char prefix)
 	    break;
 	default:
 	    InternalError(__LINE__, __FILE__,
-		"LockRep prefix applied to non-instruction");
+			  "LockRep prefix applied to non-instruction");
 	    return;
     }
 
-    if(*lockrep_pre != 0)
+    if (*lockrep_pre != 0)
 	Warning(WARN_MULT_LOCKREP_PREFIX, (char *)NULL);
 
     *lockrep_pre = prefix;
 }
 
 void
-SetOpcodeSel (jmprel_opcode_sel *old_sel, jmprel_opcode_sel new_sel)
+SetOpcodeSel(jmprel_opcode_sel *old_sel, jmprel_opcode_sel new_sel)
 {
-    if(!old_sel)
+    if (!old_sel)
 	return;
 
-    if((*old_sel == JR_SHORT_FORCED) || (*old_sel == JR_NEAR_FORCED))
+    if ((*old_sel == JR_SHORT_FORCED) || (*old_sel == JR_NEAR_FORCED))
 	Warning(WARN_MULT_SHORTNEAR, (char *)NULL);
     *old_sel = new_sel;
 }
 
 static void
-BuildBC_Common (bytecode *bc)
+BuildBC_Common(bytecode *bc)
 {
     bc->len = 0;
 
@@ -241,24 +243,24 @@ BuildBC_Common (bytecode *bc)
 }
 
 void
-BuildBC_Insn (bytecode      *bc,
-	      unsigned char  opersize,
-	      unsigned char  opcode_len,
-	      unsigned char  op0,
-	      unsigned char  op1,
-	      unsigned char  op2,
-	      effaddr       *ea_ptr,
-	      unsigned char  spare,
-	      immval        *im_ptr,
-	      unsigned char  im_len,
-	      unsigned char  im_sign)
+BuildBC_Insn(bytecode      *bc,
+	     unsigned char  opersize,
+	     unsigned char  opcode_len,
+	     unsigned char  op0,
+	     unsigned char  op1,
+	     unsigned char  op2,
+	     effaddr       *ea_ptr,
+	     unsigned char  spare,
+	     immval        *im_ptr,
+	     unsigned char  im_len,
+	     unsigned char  im_sign)
 {
     bc->next = (bytecode *)NULL;
     bc->type = BC_INSN;
 
-    if(ea_ptr) {
+    if (ea_ptr) {
 	bc->data.insn.ea = *ea_ptr;
-	bc->data.insn.ea.modrm &= 0xC7;		/* zero spare/reg bits */
+	bc->data.insn.ea.modrm &= 0xC7;	/* zero spare/reg bits */
 	bc->data.insn.ea.modrm |= (spare << 3) & 0x38;	/* plug in provided bits */
     } else {
 	bc->data.insn.ea.len = 0;
@@ -267,7 +269,7 @@ BuildBC_Insn (bytecode      *bc,
 	bc->data.insn.ea.need_sib = 0;
     }
 
-    if(im_ptr) {
+    if (im_ptr) {
 	bc->data.insn.imm = *im_ptr;
 	bc->data.insn.imm.f_sign = im_sign;
 	bc->data.insn.imm.f_len = im_len;
@@ -290,19 +292,19 @@ BuildBC_Insn (bytecode      *bc,
 }
 
 void
-BuildBC_JmpRel (bytecode      *bc,
-	        targetval     *target,
-	        unsigned char  short_valid,
-	        unsigned char  short_opcode_len,
-	        unsigned char  short_op0,
-	        unsigned char  short_op1,
-	        unsigned char  short_op2,
-	        unsigned char  near_valid,
-	        unsigned char  near_opcode_len,
-	        unsigned char  near_op0,
-	        unsigned char  near_op1,
-	        unsigned char  near_op2,
-	        unsigned char  addrsize)
+BuildBC_JmpRel(bytecode      *bc,
+	       targetval     *target,
+	       unsigned char  short_valid,
+	       unsigned char  short_opcode_len,
+	       unsigned char  short_op0,
+	       unsigned char  short_op1,
+	       unsigned char  short_op2,
+	       unsigned char  near_valid,
+	       unsigned char  near_opcode_len,
+	       unsigned char  near_op0,
+	       unsigned char  near_op1,
+	       unsigned char  near_op2,
+	       unsigned char  addrsize)
 {
     bc->next = (bytecode *)NULL;
     bc->type = BC_JMPREL;
@@ -310,13 +312,13 @@ BuildBC_JmpRel (bytecode      *bc,
     bc->data.jmprel.target = target->val;
     bc->data.jmprel.op_sel = target->op_sel;
 
-    if((target->op_sel == JR_SHORT_FORCED) && (!short_valid))
+    if ((target->op_sel == JR_SHORT_FORCED) && (!short_valid))
 	Error(ERR_NO_JMPREL_FORM, (char *)NULL, "SHORT");
-    if((target->op_sel == JR_NEAR_FORCED) && (!near_valid))
+    if ((target->op_sel == JR_NEAR_FORCED) && (!near_valid))
 	Error(ERR_NO_JMPREL_FORM, (char *)NULL, "NEAR");
 
     bc->data.jmprel.shortop.valid = short_valid;
-    if(short_valid) {
+    if (short_valid) {
 	bc->data.jmprel.shortop.opcode[0] = short_op0;
 	bc->data.jmprel.shortop.opcode[1] = short_op1;
 	bc->data.jmprel.shortop.opcode[2] = short_op2;
@@ -324,7 +326,7 @@ BuildBC_JmpRel (bytecode      *bc,
     }
 
     bc->data.jmprel.nearop.valid = near_valid;
-    if(near_valid) {
+    if (near_valid) {
 	bc->data.jmprel.nearop.opcode[0] = near_op0;
 	bc->data.jmprel.nearop.opcode[1] = near_op1;
 	bc->data.jmprel.nearop.opcode[2] = near_op2;
@@ -339,9 +341,7 @@ BuildBC_JmpRel (bytecode      *bc,
 }
 
 void
-BuildBC_Data (bytecode      *bc,
-	      dataval       *data,
-	      unsigned long  size)
+BuildBC_Data(bytecode *bc, dataval *data, unsigned long size)
 {
     dataval *cur = data;
 
@@ -359,20 +359,20 @@ BuildBC_Data (bytecode      *bc,
      * constants (equ's) should always be legal, but labels should raise
      * warnings when used in db or dq context at the minimum).
      */
-    while(cur) {
-	switch(cur->type) {
+    while (cur) {
+	switch (cur->type) {
 	    case DV_EMPTY:
 	    case DV_STRING:
 		/* string is valid in every size */
 		break;
 	    case DV_FLOAT:
-		if(size == 1)
+		if (size == 1)
 		    Error(ERR_DECLDATA_FLOAT, (char *)NULL, "DB");
-		else if(size == 2)
+		else if (size == 2)
 		    Error(ERR_DECLDATA_FLOAT, (char *)NULL, "DW");
 		break;
 	    case DV_EXPR:
-		if(size == 10)
+		if (size == 10)
 		    Error(ERR_DECLDATA_EXPR, (char *)NULL, "DT");
 		break;
 	}
@@ -389,9 +389,7 @@ BuildBC_Data (bytecode      *bc,
 }
 
 void
-BuildBC_Reserve (bytecode      *bc,
-		 expr          *numitems,
-		 unsigned long  itemsize)
+BuildBC_Reserve(bytecode *bc, expr *numitems, unsigned long itemsize)
 {
     bc->next = (bytecode *)NULL;
     bc->type = BC_RESERVE;
@@ -403,9 +401,9 @@ BuildBC_Reserve (bytecode      *bc,
 }
 
 void
-DebugPrintBC (bytecode *bc)
+DebugPrintBC(bytecode *bc)
 {
-    switch(bc->type) {
+    switch (bc->type) {
 	case BC_EMPTY:
 	    printf("_Empty_\n");
 	    break;
@@ -418,17 +416,17 @@ DebugPrintBC (bytecode *bc)
 	    else
 		expr_print(bc->data.insn.ea.disp);
 	    printf("\n");
-	    printf (" Len=%u SegmentOv=%2x\n",
-		(unsigned int)bc->data.insn.ea.len,
-		(unsigned int)bc->data.insn.ea.segment);
+	    printf(" Len=%u SegmentOv=%2x\n",
+		   (unsigned int)bc->data.insn.ea.len,
+		   (unsigned int)bc->data.insn.ea.segment);
 	    printf(" ModRM=%2x ValidRM=%u NeedRM=%u\n",
-		(unsigned int)bc->data.insn.ea.modrm,
-		(unsigned int)bc->data.insn.ea.valid_modrm,
-		(unsigned int)bc->data.insn.ea.need_modrm);
+		   (unsigned int)bc->data.insn.ea.modrm,
+		   (unsigned int)bc->data.insn.ea.valid_modrm,
+		   (unsigned int)bc->data.insn.ea.need_modrm);
 	    printf(" SIB=%2x ValidSIB=%u NeedSIB=%u\n",
-		(unsigned int)bc->data.insn.ea.sib,
-		(unsigned int)bc->data.insn.ea.valid_sib,
-		(unsigned int)bc->data.insn.ea.need_sib);
+		   (unsigned int)bc->data.insn.ea.sib,
+		   (unsigned int)bc->data.insn.ea.valid_sib,
+		   (unsigned int)bc->data.insn.ea.need_sib);
 	    printf("Immediate Value:\n");
 	    printf(" Val=");
 	    if (!bc->data.insn.imm.val)
@@ -437,60 +435,72 @@ DebugPrintBC (bytecode *bc)
 		expr_print(bc->data.insn.imm.val);
 	    printf("\n");
 	    printf(" Len=%u, IsNeg=%u\n",
-		(unsigned int)bc->data.insn.imm.len,
-		(unsigned int)bc->data.insn.imm.isneg);
+		   (unsigned int)bc->data.insn.imm.len,
+		   (unsigned int)bc->data.insn.imm.isneg);
 	    printf(" FLen=%u, FSign=%u\n",
-		(unsigned int)bc->data.insn.imm.f_len,
-		(unsigned int)bc->data.insn.imm.f_sign);
+		   (unsigned int)bc->data.insn.imm.f_len,
+		   (unsigned int)bc->data.insn.imm.f_sign);
 	    printf("Opcode: %2x %2x %2x OpLen=%u\n",
-		(unsigned int)bc->data.insn.opcode[0],
-		(unsigned int)bc->data.insn.opcode[1],
-		(unsigned int)bc->data.insn.opcode[2],
-		(unsigned int)bc->data.insn.opcode_len);
+		   (unsigned int)bc->data.insn.opcode[0],
+		   (unsigned int)bc->data.insn.opcode[1],
+		   (unsigned int)bc->data.insn.opcode[2],
+		   (unsigned int)bc->data.insn.opcode_len);
 	    printf("AddrSize=%u OperSize=%u LockRepPre=%2x\n",
-		(unsigned int)bc->data.insn.addrsize,
-		(unsigned int)bc->data.insn.opersize,
-		(unsigned int)bc->data.insn.lockrep_pre);
+		   (unsigned int)bc->data.insn.addrsize,
+		   (unsigned int)bc->data.insn.opersize,
+		   (unsigned int)bc->data.insn.lockrep_pre);
 	    break;
 	case BC_JMPREL:
 	    printf("_Relative Jump_\n");
 	    printf("Target=");
 	    expr_print(bc->data.jmprel.target);
 	    printf("\nShort Form:\n");
-	    if(!bc->data.jmprel.shortop.valid)
+	    if (!bc->data.jmprel.shortop.valid)
 		printf(" None\n");
 	    else
 		printf(" Opcode: %2x %2x %2x OpLen=%u\n",
-		    (unsigned int)bc->data.jmprel.shortop.opcode[0],
-		    (unsigned int)bc->data.jmprel.shortop.opcode[1],
-		    (unsigned int)bc->data.jmprel.shortop.opcode[2],
-		    (unsigned int)bc->data.jmprel.shortop.opcode_len);
-	    if(!bc->data.jmprel.nearop.valid)
+		       (unsigned int)bc->data.jmprel.shortop.opcode[0],
+		       (unsigned int)bc->data.jmprel.shortop.opcode[1],
+		       (unsigned int)bc->data.jmprel.shortop.opcode[2],
+		       (unsigned int)bc->data.jmprel.shortop.opcode_len);
+	    if (!bc->data.jmprel.nearop.valid)
 		printf(" None\n");
 	    else
 		printf(" Opcode: %2x %2x %2x OpLen=%u\n",
-		    (unsigned int)bc->data.jmprel.nearop.opcode[0],
-		    (unsigned int)bc->data.jmprel.nearop.opcode[1],
-		    (unsigned int)bc->data.jmprel.nearop.opcode[2],
-		    (unsigned int)bc->data.jmprel.nearop.opcode_len);
+		       (unsigned int)bc->data.jmprel.nearop.opcode[0],
+		       (unsigned int)bc->data.jmprel.nearop.opcode[1],
+		       (unsigned int)bc->data.jmprel.nearop.opcode[2],
+		       (unsigned int)bc->data.jmprel.nearop.opcode_len);
 	    printf("OpSel=");
-	    switch(bc->data.jmprel.op_sel) {
-		case JR_NONE:		printf("None"); break;
-		case JR_SHORT:		printf("Short"); break;
-		case JR_NEAR:		printf("Near"); break;
-		case JR_SHORT_FORCED:	printf("Forced Short"); break;
-		case JR_NEAR_FORCED:	printf("Forced Near"); break;
-		default:		printf("UNKNOWN!!"); break;
+	    switch (bc->data.jmprel.op_sel) {
+		case JR_NONE:
+		    printf("None");
+		    break;
+		case JR_SHORT:
+		    printf("Short");
+		    break;
+		case JR_NEAR:
+		    printf("Near");
+		    break;
+		case JR_SHORT_FORCED:
+		    printf("Forced Short");
+		    break;
+		case JR_NEAR_FORCED:
+		    printf("Forced Near");
+		    break;
+		default:
+		    printf("UNKNOWN!!");
+		    break;
 	    }
 	    printf("\nAddrSize=%u OperSize=%u LockRepPre=%2x\n",
-		(unsigned int)bc->data.jmprel.addrsize,
-		(unsigned int)bc->data.jmprel.opersize,
-		(unsigned int)bc->data.jmprel.lockrep_pre);
+		   (unsigned int)bc->data.jmprel.addrsize,
+		   (unsigned int)bc->data.jmprel.opersize,
+		   (unsigned int)bc->data.jmprel.lockrep_pre);
 	    break;
 	case BC_DATA:
 	    printf("_Data_\n");
 	    printf("Final Element Size=%u\n",
-		(unsigned int)bc->data.data.size);
+		   (unsigned int)bc->data.data.size);
 	    printf("Elements:\n");
 	    dataval_print(bc->data.data.data);
 	    break;
@@ -499,23 +509,23 @@ DebugPrintBC (bytecode *bc)
 	    printf("Num Items=");
 	    expr_print(bc->data.reserve.numitems);
 	    printf("\nItem Size=%u\n",
-		(unsigned int)bc->data.reserve.itemsize);
+		   (unsigned int)bc->data.reserve.itemsize);
 	    break;
 	default:
 	    printf("_Unknown_\n");
     }
     printf("Length=%lu\n", bc->len);
     printf("Filename=\"%s\" Line Number=%u\n",
-	bc->filename ? bc->filename : "<UNKNOWN>", bc->lineno);
+	   bc->filename ? bc->filename : "<UNKNOWN>", bc->lineno);
     printf("Offset=%lx BITS=%u\n", bc->offset, bc->mode_bits);
 }
 
 dataval *
-dataval_new_expr (expr *exp)
+dataval_new_expr(expr *exp)
 {
     dataval *retval = malloc(sizeof(dataval));
 
-    if(!retval)
+    if (!retval)
 	Fatal(FATAL_NOMEM);
 
     retval->next = (dataval *)NULL;
@@ -527,11 +537,11 @@ dataval_new_expr (expr *exp)
 }
 
 dataval *
-dataval_new_float (double float_val)
+dataval_new_float(double float_val)
 {
     dataval *retval = malloc(sizeof(dataval));
 
-    if(!retval)
+    if (!retval)
 	Fatal(FATAL_NOMEM);
 
     retval->next = (dataval *)NULL;
@@ -543,11 +553,11 @@ dataval_new_float (double float_val)
 }
 
 dataval *
-dataval_new_string (char *str_val)
+dataval_new_string(char *str_val)
 {
     dataval *retval = malloc(sizeof(dataval));
 
-    if(!retval)
+    if (!retval)
 	Fatal(FATAL_NOMEM);
 
     retval->next = (dataval *)NULL;
@@ -559,16 +569,16 @@ dataval_new_string (char *str_val)
 }
 
 dataval *
-dataval_append (dataval *list, dataval *item)
+dataval_append(dataval *list, dataval *item)
 {
-    if(item)
+    if (item)
 	item->next = (dataval *)NULL;
 
-    if(!list) {
+    if (!list) {
 	item->last = item;
 	return item;
     } else {
-	if(item) {
+	if (item) {
 	    list->last->next = item;
 	    list->last = item;
 	    item->last = (dataval *)NULL;
@@ -578,12 +588,12 @@ dataval_append (dataval *list, dataval *item)
 }
 
 void
-dataval_print (dataval *start)
+dataval_print(dataval *start)
 {
     dataval *cur = start;
 
-    while(cur) {
-	switch(cur->type) {
+    while (cur) {
+	switch (cur->type) {
 	    case DV_EMPTY:
 		printf(" Empty\n");
 		break;
@@ -603,4 +613,3 @@ dataval_print (dataval *start)
 	cur = cur->next;
     }
 }
-
diff --git a/libyasm/bytecode.h b/libyasm/bytecode.h
index fafb3b44..f6874c01 100644
--- a/libyasm/bytecode.h
+++ b/libyasm/bytecode.h
@@ -1,4 +1,4 @@
-/* $Id: bytecode.h,v 1.15 2001/07/25 00:33:10 peter Exp $
+/* $Id: bytecode.h,v 1.16 2001/08/19 03:52:58 peter Exp $
  * Bytecode utility functions header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -80,9 +80,9 @@ typedef struct bytecode_s {
 
     union {
 	struct {
-	    effaddr ea;			/* effective address */
+	    effaddr ea;		/* effective address */
 
-	    immval imm;			/* immediate or relative value */
+	    immval imm;		/* immediate or relative value */
 
 	    unsigned char opcode[3];	/* opcode */
 	    unsigned char opcode_len;
@@ -109,7 +109,7 @@ typedef struct bytecode_s {
 	    unsigned char lockrep_pre;	/* 0 indicates no prefix */
 	} jmprel;
 	struct {
-	    dataval *data;		/* non-converted data (linked list) */
+	    dataval *data;	/* non-converted data (linked list) */
 
 	    /* final (converted) size of each element (in bytes) */
 	    unsigned char size;
@@ -120,7 +120,7 @@ typedef struct bytecode_s {
 	} reserve;
     } data;
 
-    unsigned long len;	/* total length of entire bytecode */
+    unsigned long len;		/* total length of entire bytecode */
 
     /* where it came from */
     char *filename;
@@ -173,9 +173,7 @@ void BuildBC_JmpRel(bytecode      *bc,
 		    unsigned char  near_op2,
 		    unsigned char  addrsize);
 
-void BuildBC_Data(bytecode      *bc,
-		  dataval       *data,
-		  unsigned long  size);
+void BuildBC_Data(bytecode *bc, dataval *data, unsigned long size);
 
 void BuildBC_Reserve(bytecode      *bc,
 		     struct expr_s *numitems,
diff --git a/libyasm/errwarn.c b/libyasm/errwarn.c
index 1b2e818b..30cddbd2 100644
--- a/libyasm/errwarn.c
+++ b/libyasm/errwarn.c
@@ -1,4 +1,4 @@
-/* $Id: errwarn.c,v 1.19 2001/08/18 23:05:37 peter Exp $
+/* $Id: errwarn.c,v 1.20 2001/08/19 03:52:58 peter Exp $
  * Error and warning reporting and related functions.
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -112,16 +112,16 @@ static char unprint[5];
 /* Convert a possibly unprintable character into a printable string, using
  * standard cat(1) convention for unprintable characters. */
 char *
-conv_unprint (char ch)
+conv_unprint(char ch)
 {
-    int pos=0;
+    int pos = 0;
 
-    if(((ch & ~0x7F) != 0)/*!isascii(ch)*/ && !isprint(ch)) {
+    if (((ch & ~0x7F) != 0) /*!isascii(ch)*/ && !isprint(ch)) {
 	unprint[pos++] = 'M';
 	unprint[pos++] = '-';
 	ch &= toascii(ch);
     }
-    if(iscntrl(ch)) {
+    if (iscntrl(ch)) {
 	unprint[pos++] = '^';
 	unprint[pos++] = (ch == '\177') ? '?' : ch | 0100;
     } else
@@ -133,7 +133,7 @@ conv_unprint (char ch)
 
 /* Parser error handler.  Moves error into our error handling system. */
 void
-yyerror (char *s)
+yyerror(char *s)
 {
     Error(ERR_PARSER, (char *)NULL, s);
 }
@@ -141,17 +141,17 @@ yyerror (char *s)
 /* Report an internal error.  Essentially a fatal error with trace info.
  * Exit immediately because it's essentially an assert() trap. */
 void
-InternalError (unsigned int line, char *file, char *message)
+InternalError(unsigned int line, char *file, char *message)
 {
     fprintf(stderr, "INTERNAL ERROR at %s, line %d: %s\n", file, line,
-	message);
+	    message);
     exit(EXIT_FAILURE);
 }
 
 /* Report a fatal error.  These are unrecoverable (such as running out of
  * memory), so just exit immediately. */
 void
-Fatal (fatal_num num)
+Fatal(fatal_num num)
 {
     fprintf(stderr, "FATAL: %s\n", fatal_msgs[num]);
     exit(EXIT_FAILURE);
@@ -183,31 +183,31 @@ Fatal (fatal_num num)
  * specified and NULL passed for the argtypes parameter when Error() is
  * called. */
 static char *
-process_argtypes (char *src, char *argtypes)
+process_argtypes(char *src, char *argtypes)
 {
     char *dest;
     char *argtype[9];
     int at_num;
     char *destp, *srcp, *argtypep;
 
-    if(argtypes) {
+    if (argtypes) {
 	dest = malloc(strlen(src) + strlen(argtypes));
-	if(!dest)
+	if (!dest)
 	    Fatal(FATAL_NOMEM);
 	/* split argtypes by % */
 	at_num = 0;
-	while((argtypes = strchr(argtypes, '%')) && at_num < 9)
+	while ((argtypes = strchr(argtypes, '%')) && at_num < 9)
 	    argtype[at_num++] = ++argtypes;
 	/* search through src for %, copying as we go */
 	destp = dest;
 	srcp = src;
-	while(*srcp != '\0') {
+	while (*srcp != '\0') {
 	    *(destp++) = *srcp;
-	    if(*(srcp++) == '%') {
-		if(isdigit(*srcp)) {
+	    if (*(srcp++) == '%') {
+		if (isdigit(*srcp)) {
 		    /* %1, %2, etc */
-		    argtypep = argtype[*srcp-'1'];
-		    while((*argtypep != '%') && (*argtypep != '\0'))
+		    argtypep = argtype[*srcp - '1'];
+		    while ((*argtypep != '%') && (*argtypep != '\0'))
 			*(destp++) = *(argtypep++);
 		} else
 		    *(destp++) = *srcp;
@@ -216,7 +216,7 @@ process_argtypes (char *src, char *argtypes)
 	}
     } else {
 	dest = strdup(src);
-	if(!dest)
+	if (!dest)
 	    Fatal(FATAL_NOMEM);
     }
     return dest;
@@ -226,12 +226,12 @@ process_argtypes (char *src, char *argtypes)
  * argument types.  Does not print the error, only stores it for
  * OutputError() to print. */
 void
-Error (err_num num, char *argtypes, ...)
+Error(err_num num, char *argtypes, ...)
 {
     va_list ap;
     char *printf_str;
 
-    if((last_err_num != ERR_NONE) && (last_err_num != ERR_PARSER))
+    if ((last_err_num != ERR_NONE) && (last_err_num != ERR_PARSER))
 	return;
 
     last_err_num = num;
@@ -251,12 +251,12 @@ Error (err_num num, char *argtypes, ...)
  * argument types.  Does not print the warning, only stores it for
  * OutputWarning() to print. */
 void
-Warning (warn_num num, char *argtypes, ...)
+Warning(warn_num num, char *argtypes, ...)
 {
     va_list ap;
     char *printf_str;
 
-    if(last_warn_num != WARN_NONE)
+    if (last_warn_num != WARN_NONE)
 	return;
 
     last_warn_num = num;
@@ -274,20 +274,19 @@ Warning (warn_num num, char *argtypes, ...)
 
 /* Output a previously stored error (if any) to stderr. */
 void
-OutputError (void)
+OutputError(void)
 {
-    if(last_err_num != ERR_NONE)
+    if (last_err_num != ERR_NONE)
 	fprintf(stderr, "%s:%u: %s\n", filename, line_number, last_err);
     last_err_num = ERR_NONE;
 }
 
 /* Output a previously stored warning (if any) to stderr. */
 void
-OutputWarning (void)
+OutputWarning(void)
 {
-    if(last_warn_num != WARN_NONE)
+    if (last_warn_num != WARN_NONE)
 	fprintf(stderr, "%s:%u: warning: %s\n", filename, line_number,
-	    last_warn);
+		last_warn);
     last_warn_num = WARN_NONE;
 }
-
diff --git a/libyasm/expr.c b/libyasm/expr.c
index 627b2a4e..1b0248f7 100644
--- a/libyasm/expr.c
+++ b/libyasm/expr.c
@@ -1,4 +1,4 @@
-/* $Id: expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Expression handling
  *
  *  Copyright (C) 2001  Michael Urman
@@ -30,36 +30,36 @@
 /* allocate a new expression node, with children as defined.
  * If it's a unary operator, put the element on the right */
 expr *
-expr_new (ExprType ltype,
-	  ExprItem left,
-	  ExprOp   op,
-	  ExprType rtype,
-	  ExprItem right)
+expr_new(ExprType ltype,
+	 ExprItem left,
+	 ExprOp   op,
+	 ExprType rtype,
+	 ExprItem right)
 {
     expr *ptr;
-    ptr = malloc (sizeof (expr));
-    if (ptr == NULL) Fatal (FATAL_NOMEM);
+    ptr = malloc(sizeof(expr));
+    if (ptr == NULL)
+	Fatal(FATAL_NOMEM);
     ptr->ltype = ltype;
     ptr->op = op;
     ptr->rtype = rtype;
-    switch (ltype)
-    {
+    switch (ltype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->left, &left, sizeof (ExprItem));
+	    memcpy(&ptr->left, &left, sizeof(ExprItem));
+	    break;
+	case EXPR_NONE:
 	    break;
-	case EXPR_NONE: break;
     }
-    switch (rtype)
-    {
+    switch (rtype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->right, &right, sizeof (ExprItem));
+	    memcpy(&ptr->right, &right, sizeof(ExprItem));
 	    break;
 	case EXPR_NONE:
-	    Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+	    Fatal(FATAL_UNKNOWN);	/* TODO: better error? */
 	    break;
     }
     return ptr;
@@ -67,68 +67,67 @@ expr_new (ExprType ltype,
 
 /* helpers */
 ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
 {
     ExprItem e;
+
     e.sym = s;
     return e;
 }
 
 ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
 {
     ExprItem e;
     e.expr = x;
+
     return e;
 }
 
 ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
 {
     ExprItem e;
+
     e.num = n;
     return e;
 }
 
 ExprItem
-ExprNone (void)
+ExprNone(void)
 {
     ExprItem e;
+
     e.num = 0;
     return e;
 }
 
 /* get rid of unnecessary branches if possible.  report. */
 int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
 {
     int simplified = 0;
 
     /* try to simplify the left side */
-    if (e->ltype == EXPR_EXPR)
-    {
+    if (e->ltype == EXPR_EXPR) {
 	/* if the left subexpr isn't an IDENT, recurse simplification */
 	if (e->left.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->left.expr);
+	    simplified |= expr_simplify(e->left.expr);
 
 	/* if the left subexpr is just an IDENT (or string thereof),
 	 * pull it up into the current node */
-	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
-	{
+	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->ltype = e->left.expr->rtype;
-	    memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
-	    free (e->left.expr);
-	    memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+	    free(e->left.expr);
+	    memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->ltype == EXPR_SYM)
-    {
+    } else if (e->ltype == EXPR_SYM) {
 	/* if it's a symbol that has a defined value, turn it into a
 	 * number */
-	if (e->left.sym->status & SYM_VALUED)
-	{
+	if (e->left.sym->status & SYM_VALUED) {
 	    e->ltype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->left.num = e->left.sym->value;
@@ -137,25 +136,20 @@ expr_simplify (expr *e)
     }
 
     /* ditto on the right */
-    if (e->rtype == EXPR_EXPR)
-    {
+    if (e->rtype == EXPR_EXPR) {
 	if (e->right.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->right.expr);
+	    simplified |= expr_simplify(e->right.expr);
 
-	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
-	{
+	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->rtype = e->right.expr->rtype;
-	    memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
-	    free (e->right.expr);
-	    memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+	    free(e->right.expr);
+	    memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->rtype == EXPR_SYM)
-    {
-	if (e->right.sym->status & SYM_VALUED)
-	{
+    } else if (e->rtype == EXPR_SYM) {
+	if (e->right.sym->status & SYM_VALUED) {
 	    e->rtype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->right.num = e->right.sym->value;
@@ -164,62 +158,108 @@ expr_simplify (expr *e)
     }
 
     if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
-	&& e->rtype == EXPR_NUM
-	&& e->op != EXPR_IDENT)
-    {
-	switch (e->op)
-	{
-	    case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
-	    case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
-	    case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
-	    case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
-	    case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
-	    case EXPR_NEG: e->right.num = -(e->right.num); break;
-	    case EXPR_NOT: e->right.num = ~(e->right.num); break;
-	    case EXPR_OR:  e->right.num = e->left.num | e->right.num; break;
-	    case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
-	    case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
-	    case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
-	    case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
-	    case EXPR_LNOT: e->right.num = !e->right.num; break;
-	    case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
-	    case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
-	    case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
-	    case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
-	    case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
-	    case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
-	    case EXPR_IDENT: break;
+	&& e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+	switch (e->op) {
+	    case EXPR_ADD:
+		e->right.num = e->left.num + e->right.num;
+		break;
+	    case EXPR_SUB:
+		e->right.num = e->left.num - e->right.num;
+		break;
+	    case EXPR_MUL:
+		e->right.num = e->left.num * e->right.num;
+		break;
+	    case EXPR_DIV:
+		e->right.num = e->left.num / e->right.num;
+		break;
+	    case EXPR_MOD:
+		e->right.num = e->left.num % e->right.num;
+		break;
+	    case EXPR_NEG:
+		e->right.num = -(e->right.num);
+		break;
+	    case EXPR_NOT:
+		e->right.num = ~(e->right.num);
+		break;
+	    case EXPR_OR:
+		e->right.num = e->left.num | e->right.num;
+		break;
+	    case EXPR_AND:
+		e->right.num = e->left.num & e->right.num;
+		break;
+	    case EXPR_XOR:
+		e->right.num = e->left.num ^ e->right.num;
+		break;
+	    case EXPR_SHL:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_SHR:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_LOR:
+		e->right.num = e->left.num || e->right.num;
+		break;
+	    case EXPR_LAND:
+		e->right.num = e->left.num && e->right.num;
+		break;
+	    case EXPR_LNOT:
+		e->right.num = !e->right.num;
+		break;
+	    case EXPR_EQ:
+		e->right.num = e->right.num == e->left.num;
+		break;
+	    case EXPR_LT:
+		e->right.num = e->right.num < e->left.num;
+		break;
+	    case EXPR_GT:
+		e->right.num = e->right.num > e->left.num;
+		break;
+	    case EXPR_LE:
+		e->right.num = e->right.num <= e->left.num;
+		break;
+	    case EXPR_GE:
+		e->right.num = e->right.num >= e->left.num;
+		break;
+	    case EXPR_NE:
+		e->right.num = e->right.num != e->left.num;
+		break;
+	    case EXPR_IDENT:
+		break;
 	}
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
 
     /* catch simple identities like 0+x, 1*x, etc., for x not a num */
-    else if (e->ltype == EXPR_NUM
-	     && ((e->left.num == 1 && e->op == EXPR_MUL)
-		 ||(e->left.num == 0 && e->op == EXPR_ADD)
-		 ||(e->left.num == -1 && e->op == EXPR_AND)
-		 ||(e->left.num == 0 && e->op == EXPR_OR)))
-    {
+    else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->left.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_OR))) {
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
     /* and the corresponding x+|-0, x*&/1 */
-    else if (e->rtype == EXPR_NUM
-	     && ((e->right.num == 1 && e->op == EXPR_MUL)
-		 ||(e->right.num == 1 && e->op == EXPR_DIV)
-		 ||(e->right.num == 0 && e->op == EXPR_ADD)
-		 ||(e->right.num == 0 && e->op == EXPR_SUB)
-		 ||(e->right.num == -1 && e->op == EXPR_AND)
-		 ||(e->right.num == 0 && e->op == EXPR_OR)
-		 ||(e->right.num == 0 && e->op == EXPR_SHL)
-		 ||(e->right.num == 0 && e->op == EXPR_SHR)))
-    {
+    else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+				      || (e->right.num == 1 &&
+					  e->op == EXPR_DIV)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SUB)
+				      || (e->right.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_OR)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHL)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHR))) {
 	e->op = EXPR_IDENT;
 	e->rtype = e->ltype;
-	memcpy (&e->right, &e->left, sizeof (ExprItem));
+	memcpy(&e->right, &e->left, sizeof(ExprItem));
 	simplified = 1;
     }
 
@@ -227,59 +267,118 @@ expr_simplify (expr *e)
 }
 
 int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
 {
     while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-	   && expr_simplify (e));
+	   && expr_simplify(e)) ;
 
-    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-    {
+    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
 	*retval = e->right.num;
 	return 1;
-    }
-    else
+    } else
 	return 0;
 }
 
 void
-expr_print (expr *e)
+expr_print(expr *e)
 {
     if (e->op != EXPR_IDENT) {
 	switch (e->ltype) {
-	    case EXPR_NUM: printf ("%lu", e->left.num); break;
-	    case EXPR_SYM: printf ("%s", e->left.sym->name); break;
-	    case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
-	    case EXPR_NONE: break;
+	    case EXPR_NUM:
+		printf("%lu", e->left.num);
+		break;
+	    case EXPR_SYM:
+		printf("%s", e->left.sym->name);
+		break;
+	    case EXPR_EXPR:
+		printf("(");
+		expr_print(e->left.expr);
+
+		printf(")");
+	    case EXPR_NONE:
+		break;
 	}
     }
     switch (e->op) {
-	case EXPR_ADD: printf ("+"); break;
-	case EXPR_SUB: printf ("-"); break;
-	case EXPR_MUL: printf ("*"); break;
-	case EXPR_DIV: printf ("/"); break;
-	case EXPR_MOD: printf ("%%"); break;
-	case EXPR_NEG: printf ("-"); break;
-	case EXPR_NOT: printf ("~"); break;
-	case EXPR_OR: printf ("|"); break;
-	case EXPR_AND: printf ("&"); break;
-	case EXPR_XOR: printf ("^"); break;
-	case EXPR_SHL: printf ("<<"); break;
-	case EXPR_SHR: printf (">>"); break;
-	case EXPR_LOR: printf ("||"); break;
-	case EXPR_LAND: printf ("&&"); break;
-	case EXPR_LNOT: printf ("!"); break;
-	case EXPR_LT: printf ("<"); break;
-	case EXPR_GT: printf (">"); break;
-	case EXPR_LE: printf ("<="); break;
-	case EXPR_GE: printf (">="); break;
-	case EXPR_NE: printf ("!="); break;
-	case EXPR_EQ: printf ("=="); break;
-	case EXPR_IDENT: break;
+	case EXPR_ADD:
+	    printf("+");
+	    break;
+	case EXPR_SUB:
+	    printf("-");
+	    break;
+	case EXPR_MUL:
+	    printf("*");
+	    break;
+	case EXPR_DIV:
+	    printf("/");
+	    break;
+	case EXPR_MOD:
+	    printf("%%");
+	    break;
+	case EXPR_NEG:
+	    printf("-");
+	    break;
+	case EXPR_NOT:
+	    printf("~");
+	    break;
+	case EXPR_OR:
+	    printf("|");
+	    break;
+	case EXPR_AND:
+	    printf("&");
+	    break;
+	case EXPR_XOR:
+	    printf("^");
+	    break;
+	case EXPR_SHL:
+	    printf("<<");
+	    break;
+	case EXPR_SHR:
+	    printf(">>");
+	    break;
+	case EXPR_LOR:
+	    printf("||");
+	    break;
+	case EXPR_LAND:
+	    printf("&&");
+	    break;
+	case EXPR_LNOT:
+	    printf("!");
+	    break;
+	case EXPR_LT:
+	    printf("<");
+	    break;
+	case EXPR_GT:
+	    printf(">");
+	    break;
+	case EXPR_LE:
+	    printf("<=");
+	    break;
+	case EXPR_GE:
+	    printf(">=");
+	    break;
+	case EXPR_NE:
+	    printf("!=");
+	    break;
+	case EXPR_EQ:
+	    printf("==");
+	    break;
+	case EXPR_IDENT:
+	    break;
     }
     switch (e->rtype) {
-	case EXPR_NUM: printf ("%lu", e->right.num); break;
-	case EXPR_SYM: printf ("%s", e->right.sym->name); break;
-	case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
-	case EXPR_NONE: break;
+	case EXPR_NUM:
+	    printf("%lu", e->right.num);
+	    break;
+	case EXPR_SYM:
+	    printf("%s", e->right.sym->name);
+	    break;
+	case EXPR_EXPR:
+	    printf("(");
+	    expr_print(e->right.expr);
+
+	    printf(")");
+	case EXPR_NONE:
+	    break;
     }
 }
diff --git a/libyasm/expr.h b/libyasm/expr.h
index 2f0188b2..943ad514 100644
--- a/libyasm/expr.h
+++ b/libyasm/expr.h
@@ -1,4 +1,4 @@
-/* $Id: expr.h,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.h,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Expression handling header file
  *
  *  Copyright (C) 2001  Michael Urman
@@ -44,11 +44,11 @@ typedef enum {
     EXPR_LE,
     EXPR_GE,
     EXPR_NE,
-    EXPR_IDENT	    /* if right is IDENT, then the entire expr is just a num */
+    EXPR_IDENT			/* if right is IDENT, then the entire expr is just a num */
 } ExprOp;
 
 typedef enum {
-    EXPR_NONE,	    /* for left side of a NOT, NEG, etc. */
+    EXPR_NONE,			/* for left side of a NOT, NEG, etc. */
     EXPR_NUM,
     EXPR_EXPR,
     EXPR_SYM
@@ -66,12 +66,12 @@ typedef struct expr_s {
     ExprOp op;
 } expr;
 
-expr *expr_new (ExprType, ExprItem, ExprOp, ExprType, ExprItem);
+expr *expr_new(ExprType, ExprItem, ExprOp, ExprType, ExprItem);
 
-ExprItem ExprSym (struct symrec_s *);
-ExprItem ExprExpr (expr *);
-ExprItem ExprNum (unsigned long);
-ExprItem ExprNone (void);
+ExprItem ExprSym(struct symrec_s *);
+ExprItem ExprExpr(expr *);
+ExprItem ExprNum(unsigned long);
+ExprItem ExprNone(void);
 
 #define expr_new_tree(l,o,r) \
     expr_new (EXPR_EXPR, ExprExpr(l), (o), EXPR_EXPR, ExprExpr(r))
@@ -80,10 +80,10 @@ ExprItem ExprNone (void);
 #define expr_new_ident(t,r) \
     expr_new (EXPR_NONE, ExprNone(), EXPR_IDENT, (ExprType)(t), (r))
 
-int expr_simplify (expr *);
-void expr_print (expr *);
+int expr_simplify(expr *);
+void expr_print(expr *);
 
 /* get the value if possible.  return value is IF POSSIBLE, not the val */
-int expr_get_value (expr *, unsigned long *);
+int expr_get_value(expr *, unsigned long *);
 
 #endif
diff --git a/libyasm/objfmt.h b/libyasm/objfmt.h
index ab73f0ca..652276f3 100644
--- a/libyasm/objfmt.h
+++ b/libyasm/objfmt.h
@@ -1,4 +1,4 @@
-/* $Id: objfmt.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: objfmt.h,v 1.2 2001/08/19 03:52:58 peter Exp $
  * Output format module interface header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -24,8 +24,11 @@
 
 /* Interface to the output format module(s) */
 typedef struct outfmt_s {
-    char *name;		/* one-line description of the format */
-    char *keyword;	/* keyword used to select format on the command line */
+    /* one-line description of the format */
+    char *name;
+
+    /* keyword used to select format on the command line */
+    char *keyword;
 
     /* NULL-terminated list of debugging formats that are valid to use with
      * this output format.
diff --git a/libyasm/parser.h b/libyasm/parser.h
index 3416173c..f844643e 100644
--- a/libyasm/parser.h
+++ b/libyasm/parser.h
@@ -1,4 +1,4 @@
-/* $Id: parser.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: parser.h,v 1.2 2001/08/19 03:52:58 peter Exp $
  * Parser module interface header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -24,8 +24,11 @@
 
 /* Interface to the parser module(s) -- the "front end" of the assembler */
 typedef struct parser_s {
-    char *name;		/* one-line description of the parser */
-    char *keyword;	/* keyword used to select parser on the command line */
+    /* one-line description of the parser */
+    char *name;
+
+    /* keyword used to select parser on the command line */
+    char *keyword;
 
     /* NULL-terminated list of preprocessors that are valid to use with this
      * parser.  The raw preprocessor (raw_preproc) should always be in this
@@ -52,7 +55,7 @@ typedef struct parser_s {
      * Note that calling this has many side effects in the output format
      * module: sections and variables are declared, etc.
      */
-    section * (*doparse) (preproc *pp, outfmt *of, FILE *f);
+    section *(*doparse) (preproc *pp, outfmt *of, FILE *f);
 } parser;
 
 /* Available parsers */
diff --git a/libyasm/preproc.h b/libyasm/preproc.h
index a239dcf6..2e884fbd 100644
--- a/libyasm/preproc.h
+++ b/libyasm/preproc.h
@@ -1,4 +1,4 @@
-/* $Id: preproc.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: preproc.h,v 1.2 2001/08/19 03:52:58 peter Exp $
  * Preprocessor module interface header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -24,10 +24,11 @@
 
 /* Interface to the preprocesor module(s) */
 typedef struct preproc_s {
-    char *name;		/* one-line description of the preprocessor */
+    /* one-line description of the preprocessor */
+    char *name;
 
     /* keyword used to select preprocessor on the command line */
-    char *keyword;	
+    char *keyword;
 
     /* Initializes preprocessor.
      *
diff --git a/libyasm/section.h b/libyasm/section.h
index 83615e9f..fcfb1f13 100644
--- a/libyasm/section.h
+++ b/libyasm/section.h
@@ -1,4 +1,4 @@
-/* $Id: section.h,v 1.4 2001/08/19 02:54:20 peter Exp $
+/* $Id: section.h,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Section header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -36,7 +36,7 @@ typedef struct section_s {
 	unsigned long start;
     } data;
 
-    bytecode *bc;	/* the bytecodes for the section's contents */
+    bytecode *bc;		/* the bytecodes for the section's contents */
 } section;
 
 #endif
diff --git a/libyasm/symrec.c b/libyasm/symrec.c
index a7114323..445fc19d 100644
--- a/libyasm/symrec.c
+++ b/libyasm/symrec.c
@@ -1,4 +1,4 @@
-/* $Id: symrec.c,v 1.5 2001/07/11 23:16:50 peter Exp $
+/* $Id: symrec.c,v 1.6 2001/08/19 03:52:58 peter Exp $
  * Symbol table handling
  *
  *  Copyright (C) 2001  Michael Urman
@@ -26,17 +26,17 @@
 #include "errwarn.h"
 
 /* private functions */
-static symtab *symtab_get (char *);
-static symtab *symtab_new (char *, SymType);
-static symtab *symtab_get_or_new (char *, SymType);
-static void symtab_insert (symtab *);
+static symtab *symtab_get(char *);
+static symtab *symtab_new(char *, SymType);
+static symtab *symtab_get_or_new(char *, SymType);
+static void symtab_insert(symtab *);
 
 /* The symbol table: a chain of `symtab'. */
 symtab *sym_table = (symtab *)NULL;
 
 /* insert a symtab into the global sym_table */
 void
-symtab_insert (symtab *tab)
+symtab_insert(symtab *tab)
 {
     tab->next = (symtab *)sym_table;
     sym_table = tab;
@@ -44,13 +44,12 @@ symtab_insert (symtab *tab)
 
 /* find a symtab in the global sym_table */
 symtab *
-symtab_get (char *name)
+symtab_get(char *name)
 {
     symtab *tab;
-    for (tab = sym_table; tab != NULL; tab = tab->next)
-    {
-	if (strcmp (tab->rec.name, name) == 0)
-	{
+
+    for (tab = sym_table; tab != NULL; tab = tab->next) {
+	if (strcmp(tab->rec.name, name) == 0) {
 	    return tab;
 	}
     }
@@ -59,13 +58,12 @@ symtab_get (char *name)
 
 /* call a function with each symrec.  stop early if 0 returned */
 void
-sym_foreach (int(*mapfunc)(symrec *))
+sym_foreach(int (*mapfunc) (symrec *))
 {
     symtab *tab;
-    for (tab = sym_table; tab != NULL; tab = tab->next)
-    {
-	if (mapfunc(&(tab->rec)) == 0)
-	{
+
+    for (tab = sym_table; tab != NULL; tab = tab->next) {
+	if (mapfunc(&(tab->rec)) == 0) {
 	    return;
 	}
     }
@@ -73,15 +71,15 @@ sym_foreach (int(*mapfunc)(symrec *))
 
 /* create a new symtab */
 symtab *
-symtab_new (char *name, SymType type)
+symtab_new(char *name, SymType type)
 {
     symtab *tab;
     tab = malloc(sizeof(symtab));
-    if (tab == NULL) return NULL;
-    tab->rec.name = malloc(strlen(name)+1);
-    if (tab->rec.name == NULL)
-    {
-	free (tab);
+    if (tab == NULL)
+	return NULL;
+    tab->rec.name = malloc(strlen(name) + 1);
+    if (tab->rec.name == NULL) {
+	free(tab);
 	return NULL;
     }
     strcpy(tab->rec.name, name);
@@ -89,68 +87,70 @@ symtab_new (char *name, SymType type)
     tab->rec.value = 0;
     tab->rec.line = line_number;
     tab->rec.status = SYM_NOSTATUS;
-    symtab_insert (tab);
+    symtab_insert(tab);
     return tab;
 }
 
 symtab *
-symtab_get_or_new (char *name, SymType type)
+symtab_get_or_new(char *name, SymType type)
 {
     symtab *tab;
-    tab = symtab_get (name);
-    if (tab == NULL)
-    {
-	tab = symtab_new (name, type);
-	if (tab == NULL)
-	{
-	    Fatal (FATAL_NOMEM);
+
+    tab = symtab_get(name);
+    if (tab == NULL) {
+	tab = symtab_new(name, type);
+	if (tab == NULL) {
+	    Fatal(FATAL_NOMEM);
 	}
     }
     return tab;
 }
 
 symrec *
-sym_use_get (char *name, SymType type)
+sym_use_get(char *name, SymType type)
 {
     symtab *tab;
-    tab = symtab_get_or_new (name, type);
+
+    tab = symtab_get_or_new(name, type);
     tab->rec.status |= SYM_USED;
     return &(tab->rec);
 }
 
 symrec *
-sym_def_get (char *name, SymType type)
+sym_def_get(char *name, SymType type)
 {
     symtab *tab;
-    tab = symtab_get_or_new (name, type);
+
+    tab = symtab_get_or_new(name, type);
     if (tab->rec.status & SYM_DECLARED)
-	Error (ERR_DUPLICATE_DEF, "%s%d", tab->rec.name, tab->rec.line);
+	Error(ERR_DUPLICATE_DEF, "%s%d", tab->rec.name, tab->rec.line);
     tab->rec.status |= SYM_DECLARED;
     return &(tab->rec);
 }
 
 #if 0
 symrec *
-putsym (char *sym_name, int sym_type)
+putsym(char *sym_name, int sym_type)
 {
     symrec *ptr;
     ptr = malloc(sizeof(symrec));
-    ptr->name = malloc(strlen(sym_name)+1);
+    ptr->name = malloc(strlen(sym_name) + 1);
     strcpy(ptr->name, sym_name);
     ptr->type = sym_type;
-    ptr->value.var = 0; /* set value to 0 even if fctn.  */
+    ptr->value.var = 0;		/* set value to 0 even if fctn.  */
     ptr->next = (symrec *)sym_table;
     sym_table = ptr;
     return ptr;
 }
 
 symrec *
-getsym (char *sym_name)
+getsym(char *sym_name)
 {
     symrec *ptr;
-    for(ptr=sym_table; ptr != (symrec *)NULL; ptr=(symrec *)ptr->next)
-	if(strcmp(ptr->name, sym_name) == 0)
+
+    for (ptr = sym_table; ptr != (symrec *)NULL; ptr = (symrec *)ptr->next)
+	if (strcmp(ptr->name, sym_name) == 0)
 	    return ptr;
     return 0;
 }
-#endif /* 0 */
+#endif				/* 0 */
diff --git a/libyasm/symrec.h b/libyasm/symrec.h
index 4ef9bc1e..a672b6db 100644
--- a/libyasm/symrec.h
+++ b/libyasm/symrec.h
@@ -1,4 +1,4 @@
-/* $Id: symrec.h,v 1.5 2001/07/11 21:16:22 peter Exp $
+/* $Id: symrec.h,v 1.6 2001/08/19 03:52:58 peter Exp $
  * Symbol table handling header file
  *
  *  Copyright (C) 2001  Michael Urman
@@ -24,14 +24,14 @@
 
 typedef enum {
     SYM_NOSTATUS = 0,
-    SYM_USED	 = 1 << 0,  /* for using variables before declared */
-    SYM_DECLARED = 1 << 1,  /* once it's been declared */
-    SYM_VALUED	 = 1 << 2   /* once its value has been determined */
+    SYM_USED = 1 << 0,		/* for using variables before declared */
+    SYM_DECLARED = 1 << 1,	/* once it's been declared */
+    SYM_VALUED = 1 << 2		/* once its value has been determined */
 } SymStatus;
 
 typedef enum {
-    SYM_CONSTANT,	    /* for EQU defined symbols */
-    SYM_LABEL		    /* for labels */
+    SYM_CONSTANT,		/* for EQU defined symbols */
+    SYM_LABEL			/* for labels */
 } SymType;
 
 typedef struct symrec_s {
@@ -52,8 +52,8 @@ extern symtab *sym_table;
 /*symrec *putsym(char *, SymType);*/
 /*symrec *getsym(char *);*/
 
-symrec *sym_use_get (char *, SymType);
-symrec *sym_def_get (char *, SymType);
-void sym_foreach (int(*)(symrec *));
+symrec *sym_use_get(char *, SymType);
+symrec *sym_def_get(char *, SymType);
+void sym_foreach(int (*)(symrec *));
 
 #endif
diff --git a/modules/arch/x86/expr.c b/modules/arch/x86/expr.c
index 627b2a4e..1b0248f7 100644
--- a/modules/arch/x86/expr.c
+++ b/modules/arch/x86/expr.c
@@ -1,4 +1,4 @@
-/* $Id: expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Expression handling
  *
  *  Copyright (C) 2001  Michael Urman
@@ -30,36 +30,36 @@
 /* allocate a new expression node, with children as defined.
  * If it's a unary operator, put the element on the right */
 expr *
-expr_new (ExprType ltype,
-	  ExprItem left,
-	  ExprOp   op,
-	  ExprType rtype,
-	  ExprItem right)
+expr_new(ExprType ltype,
+	 ExprItem left,
+	 ExprOp   op,
+	 ExprType rtype,
+	 ExprItem right)
 {
     expr *ptr;
-    ptr = malloc (sizeof (expr));
-    if (ptr == NULL) Fatal (FATAL_NOMEM);
+    ptr = malloc(sizeof(expr));
+    if (ptr == NULL)
+	Fatal(FATAL_NOMEM);
     ptr->ltype = ltype;
     ptr->op = op;
     ptr->rtype = rtype;
-    switch (ltype)
-    {
+    switch (ltype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->left, &left, sizeof (ExprItem));
+	    memcpy(&ptr->left, &left, sizeof(ExprItem));
+	    break;
+	case EXPR_NONE:
 	    break;
-	case EXPR_NONE: break;
     }
-    switch (rtype)
-    {
+    switch (rtype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->right, &right, sizeof (ExprItem));
+	    memcpy(&ptr->right, &right, sizeof(ExprItem));
 	    break;
 	case EXPR_NONE:
-	    Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+	    Fatal(FATAL_UNKNOWN);	/* TODO: better error? */
 	    break;
     }
     return ptr;
@@ -67,68 +67,67 @@ expr_new (ExprType ltype,
 
 /* helpers */
 ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
 {
     ExprItem e;
+
     e.sym = s;
     return e;
 }
 
 ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
 {
     ExprItem e;
     e.expr = x;
+
     return e;
 }
 
 ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
 {
     ExprItem e;
+
     e.num = n;
     return e;
 }
 
 ExprItem
-ExprNone (void)
+ExprNone(void)
 {
     ExprItem e;
+
     e.num = 0;
     return e;
 }
 
 /* get rid of unnecessary branches if possible.  report. */
 int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
 {
     int simplified = 0;
 
     /* try to simplify the left side */
-    if (e->ltype == EXPR_EXPR)
-    {
+    if (e->ltype == EXPR_EXPR) {
 	/* if the left subexpr isn't an IDENT, recurse simplification */
 	if (e->left.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->left.expr);
+	    simplified |= expr_simplify(e->left.expr);
 
 	/* if the left subexpr is just an IDENT (or string thereof),
 	 * pull it up into the current node */
-	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
-	{
+	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->ltype = e->left.expr->rtype;
-	    memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
-	    free (e->left.expr);
-	    memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+	    free(e->left.expr);
+	    memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->ltype == EXPR_SYM)
-    {
+    } else if (e->ltype == EXPR_SYM) {
 	/* if it's a symbol that has a defined value, turn it into a
 	 * number */
-	if (e->left.sym->status & SYM_VALUED)
-	{
+	if (e->left.sym->status & SYM_VALUED) {
 	    e->ltype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->left.num = e->left.sym->value;
@@ -137,25 +136,20 @@ expr_simplify (expr *e)
     }
 
     /* ditto on the right */
-    if (e->rtype == EXPR_EXPR)
-    {
+    if (e->rtype == EXPR_EXPR) {
 	if (e->right.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->right.expr);
+	    simplified |= expr_simplify(e->right.expr);
 
-	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
-	{
+	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->rtype = e->right.expr->rtype;
-	    memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
-	    free (e->right.expr);
-	    memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+	    free(e->right.expr);
+	    memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->rtype == EXPR_SYM)
-    {
-	if (e->right.sym->status & SYM_VALUED)
-	{
+    } else if (e->rtype == EXPR_SYM) {
+	if (e->right.sym->status & SYM_VALUED) {
 	    e->rtype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->right.num = e->right.sym->value;
@@ -164,62 +158,108 @@ expr_simplify (expr *e)
     }
 
     if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
-	&& e->rtype == EXPR_NUM
-	&& e->op != EXPR_IDENT)
-    {
-	switch (e->op)
-	{
-	    case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
-	    case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
-	    case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
-	    case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
-	    case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
-	    case EXPR_NEG: e->right.num = -(e->right.num); break;
-	    case EXPR_NOT: e->right.num = ~(e->right.num); break;
-	    case EXPR_OR:  e->right.num = e->left.num | e->right.num; break;
-	    case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
-	    case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
-	    case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
-	    case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
-	    case EXPR_LNOT: e->right.num = !e->right.num; break;
-	    case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
-	    case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
-	    case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
-	    case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
-	    case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
-	    case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
-	    case EXPR_IDENT: break;
+	&& e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+	switch (e->op) {
+	    case EXPR_ADD:
+		e->right.num = e->left.num + e->right.num;
+		break;
+	    case EXPR_SUB:
+		e->right.num = e->left.num - e->right.num;
+		break;
+	    case EXPR_MUL:
+		e->right.num = e->left.num * e->right.num;
+		break;
+	    case EXPR_DIV:
+		e->right.num = e->left.num / e->right.num;
+		break;
+	    case EXPR_MOD:
+		e->right.num = e->left.num % e->right.num;
+		break;
+	    case EXPR_NEG:
+		e->right.num = -(e->right.num);
+		break;
+	    case EXPR_NOT:
+		e->right.num = ~(e->right.num);
+		break;
+	    case EXPR_OR:
+		e->right.num = e->left.num | e->right.num;
+		break;
+	    case EXPR_AND:
+		e->right.num = e->left.num & e->right.num;
+		break;
+	    case EXPR_XOR:
+		e->right.num = e->left.num ^ e->right.num;
+		break;
+	    case EXPR_SHL:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_SHR:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_LOR:
+		e->right.num = e->left.num || e->right.num;
+		break;
+	    case EXPR_LAND:
+		e->right.num = e->left.num && e->right.num;
+		break;
+	    case EXPR_LNOT:
+		e->right.num = !e->right.num;
+		break;
+	    case EXPR_EQ:
+		e->right.num = e->right.num == e->left.num;
+		break;
+	    case EXPR_LT:
+		e->right.num = e->right.num < e->left.num;
+		break;
+	    case EXPR_GT:
+		e->right.num = e->right.num > e->left.num;
+		break;
+	    case EXPR_LE:
+		e->right.num = e->right.num <= e->left.num;
+		break;
+	    case EXPR_GE:
+		e->right.num = e->right.num >= e->left.num;
+		break;
+	    case EXPR_NE:
+		e->right.num = e->right.num != e->left.num;
+		break;
+	    case EXPR_IDENT:
+		break;
 	}
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
 
     /* catch simple identities like 0+x, 1*x, etc., for x not a num */
-    else if (e->ltype == EXPR_NUM
-	     && ((e->left.num == 1 && e->op == EXPR_MUL)
-		 ||(e->left.num == 0 && e->op == EXPR_ADD)
-		 ||(e->left.num == -1 && e->op == EXPR_AND)
-		 ||(e->left.num == 0 && e->op == EXPR_OR)))
-    {
+    else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->left.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_OR))) {
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
     /* and the corresponding x+|-0, x*&/1 */
-    else if (e->rtype == EXPR_NUM
-	     && ((e->right.num == 1 && e->op == EXPR_MUL)
-		 ||(e->right.num == 1 && e->op == EXPR_DIV)
-		 ||(e->right.num == 0 && e->op == EXPR_ADD)
-		 ||(e->right.num == 0 && e->op == EXPR_SUB)
-		 ||(e->right.num == -1 && e->op == EXPR_AND)
-		 ||(e->right.num == 0 && e->op == EXPR_OR)
-		 ||(e->right.num == 0 && e->op == EXPR_SHL)
-		 ||(e->right.num == 0 && e->op == EXPR_SHR)))
-    {
+    else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+				      || (e->right.num == 1 &&
+					  e->op == EXPR_DIV)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SUB)
+				      || (e->right.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_OR)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHL)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHR))) {
 	e->op = EXPR_IDENT;
 	e->rtype = e->ltype;
-	memcpy (&e->right, &e->left, sizeof (ExprItem));
+	memcpy(&e->right, &e->left, sizeof(ExprItem));
 	simplified = 1;
     }
 
@@ -227,59 +267,118 @@ expr_simplify (expr *e)
 }
 
 int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
 {
     while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-	   && expr_simplify (e));
+	   && expr_simplify(e)) ;
 
-    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-    {
+    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
 	*retval = e->right.num;
 	return 1;
-    }
-    else
+    } else
 	return 0;
 }
 
 void
-expr_print (expr *e)
+expr_print(expr *e)
 {
     if (e->op != EXPR_IDENT) {
 	switch (e->ltype) {
-	    case EXPR_NUM: printf ("%lu", e->left.num); break;
-	    case EXPR_SYM: printf ("%s", e->left.sym->name); break;
-	    case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
-	    case EXPR_NONE: break;
+	    case EXPR_NUM:
+		printf("%lu", e->left.num);
+		break;
+	    case EXPR_SYM:
+		printf("%s", e->left.sym->name);
+		break;
+	    case EXPR_EXPR:
+		printf("(");
+		expr_print(e->left.expr);
+
+		printf(")");
+	    case EXPR_NONE:
+		break;
 	}
     }
     switch (e->op) {
-	case EXPR_ADD: printf ("+"); break;
-	case EXPR_SUB: printf ("-"); break;
-	case EXPR_MUL: printf ("*"); break;
-	case EXPR_DIV: printf ("/"); break;
-	case EXPR_MOD: printf ("%%"); break;
-	case EXPR_NEG: printf ("-"); break;
-	case EXPR_NOT: printf ("~"); break;
-	case EXPR_OR: printf ("|"); break;
-	case EXPR_AND: printf ("&"); break;
-	case EXPR_XOR: printf ("^"); break;
-	case EXPR_SHL: printf ("<<"); break;
-	case EXPR_SHR: printf (">>"); break;
-	case EXPR_LOR: printf ("||"); break;
-	case EXPR_LAND: printf ("&&"); break;
-	case EXPR_LNOT: printf ("!"); break;
-	case EXPR_LT: printf ("<"); break;
-	case EXPR_GT: printf (">"); break;
-	case EXPR_LE: printf ("<="); break;
-	case EXPR_GE: printf (">="); break;
-	case EXPR_NE: printf ("!="); break;
-	case EXPR_EQ: printf ("=="); break;
-	case EXPR_IDENT: break;
+	case EXPR_ADD:
+	    printf("+");
+	    break;
+	case EXPR_SUB:
+	    printf("-");
+	    break;
+	case EXPR_MUL:
+	    printf("*");
+	    break;
+	case EXPR_DIV:
+	    printf("/");
+	    break;
+	case EXPR_MOD:
+	    printf("%%");
+	    break;
+	case EXPR_NEG:
+	    printf("-");
+	    break;
+	case EXPR_NOT:
+	    printf("~");
+	    break;
+	case EXPR_OR:
+	    printf("|");
+	    break;
+	case EXPR_AND:
+	    printf("&");
+	    break;
+	case EXPR_XOR:
+	    printf("^");
+	    break;
+	case EXPR_SHL:
+	    printf("<<");
+	    break;
+	case EXPR_SHR:
+	    printf(">>");
+	    break;
+	case EXPR_LOR:
+	    printf("||");
+	    break;
+	case EXPR_LAND:
+	    printf("&&");
+	    break;
+	case EXPR_LNOT:
+	    printf("!");
+	    break;
+	case EXPR_LT:
+	    printf("<");
+	    break;
+	case EXPR_GT:
+	    printf(">");
+	    break;
+	case EXPR_LE:
+	    printf("<=");
+	    break;
+	case EXPR_GE:
+	    printf(">=");
+	    break;
+	case EXPR_NE:
+	    printf("!=");
+	    break;
+	case EXPR_EQ:
+	    printf("==");
+	    break;
+	case EXPR_IDENT:
+	    break;
     }
     switch (e->rtype) {
-	case EXPR_NUM: printf ("%lu", e->right.num); break;
-	case EXPR_SYM: printf ("%s", e->right.sym->name); break;
-	case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
-	case EXPR_NONE: break;
+	case EXPR_NUM:
+	    printf("%lu", e->right.num);
+	    break;
+	case EXPR_SYM:
+	    printf("%s", e->right.sym->name);
+	    break;
+	case EXPR_EXPR:
+	    printf("(");
+	    expr_print(e->right.expr);
+
+	    printf(")");
+	case EXPR_NONE:
+	    break;
     }
 }
diff --git a/modules/arch/x86/x86expr.c b/modules/arch/x86/x86expr.c
index 2d891512..69213d1f 100644
--- a/modules/arch/x86/x86expr.c
+++ b/modules/arch/x86/x86expr.c
@@ -1,4 +1,4 @@
-/* $Id: x86expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: x86expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Expression handling
  *
  *  Copyright (C) 2001  Michael Urman
@@ -30,36 +30,36 @@
 /* allocate a new expression node, with children as defined.
  * If it's a unary operator, put the element on the right */
 expr *
-expr_new (ExprType ltype,
-	  ExprItem left,
-	  ExprOp   op,
-	  ExprType rtype,
-	  ExprItem right)
+expr_new(ExprType ltype,
+	 ExprItem left,
+	 ExprOp   op,
+	 ExprType rtype,
+	 ExprItem right)
 {
     expr *ptr;
-    ptr = malloc (sizeof (expr));
-    if (ptr == NULL) Fatal (FATAL_NOMEM);
+    ptr = malloc(sizeof(expr));
+    if (ptr == NULL)
+	Fatal(FATAL_NOMEM);
     ptr->ltype = ltype;
     ptr->op = op;
     ptr->rtype = rtype;
-    switch (ltype)
-    {
+    switch (ltype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->left, &left, sizeof (ExprItem));
+	    memcpy(&ptr->left, &left, sizeof(ExprItem));
+	    break;
+	case EXPR_NONE:
 	    break;
-	case EXPR_NONE: break;
     }
-    switch (rtype)
-    {
+    switch (rtype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->right, &right, sizeof (ExprItem));
+	    memcpy(&ptr->right, &right, sizeof(ExprItem));
 	    break;
 	case EXPR_NONE:
-	    Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+	    Fatal(FATAL_UNKNOWN);	/* TODO: better error? */
 	    break;
     }
     return ptr;
@@ -67,68 +67,67 @@ expr_new (ExprType ltype,
 
 /* helpers */
 ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
 {
     ExprItem e;
+
     e.sym = s;
     return e;
 }
 
 ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
 {
     ExprItem e;
     e.expr = x;
+
     return e;
 }
 
 ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
 {
     ExprItem e;
+
     e.num = n;
     return e;
 }
 
 ExprItem
-ExprNone (void)
+ExprNone(void)
 {
     ExprItem e;
+
     e.num = 0;
     return e;
 }
 
 /* get rid of unnecessary branches if possible.  report. */
 int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
 {
     int simplified = 0;
 
     /* try to simplify the left side */
-    if (e->ltype == EXPR_EXPR)
-    {
+    if (e->ltype == EXPR_EXPR) {
 	/* if the left subexpr isn't an IDENT, recurse simplification */
 	if (e->left.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->left.expr);
+	    simplified |= expr_simplify(e->left.expr);
 
 	/* if the left subexpr is just an IDENT (or string thereof),
 	 * pull it up into the current node */
-	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
-	{
+	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->ltype = e->left.expr->rtype;
-	    memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
-	    free (e->left.expr);
-	    memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+	    free(e->left.expr);
+	    memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->ltype == EXPR_SYM)
-    {
+    } else if (e->ltype == EXPR_SYM) {
 	/* if it's a symbol that has a defined value, turn it into a
 	 * number */
-	if (e->left.sym->status & SYM_VALUED)
-	{
+	if (e->left.sym->status & SYM_VALUED) {
 	    e->ltype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->left.num = e->left.sym->value;
@@ -137,25 +136,20 @@ expr_simplify (expr *e)
     }
 
     /* ditto on the right */
-    if (e->rtype == EXPR_EXPR)
-    {
+    if (e->rtype == EXPR_EXPR) {
 	if (e->right.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->right.expr);
+	    simplified |= expr_simplify(e->right.expr);
 
-	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
-	{
+	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->rtype = e->right.expr->rtype;
-	    memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
-	    free (e->right.expr);
-	    memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+	    free(e->right.expr);
+	    memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->rtype == EXPR_SYM)
-    {
-	if (e->right.sym->status & SYM_VALUED)
-	{
+    } else if (e->rtype == EXPR_SYM) {
+	if (e->right.sym->status & SYM_VALUED) {
 	    e->rtype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->right.num = e->right.sym->value;
@@ -164,62 +158,108 @@ expr_simplify (expr *e)
     }
 
     if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
-	&& e->rtype == EXPR_NUM
-	&& e->op != EXPR_IDENT)
-    {
-	switch (e->op)
-	{
-	    case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
-	    case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
-	    case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
-	    case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
-	    case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
-	    case EXPR_NEG: e->right.num = -(e->right.num); break;
-	    case EXPR_NOT: e->right.num = ~(e->right.num); break;
-	    case EXPR_OR:  e->right.num = e->left.num | e->right.num; break;
-	    case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
-	    case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
-	    case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
-	    case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
-	    case EXPR_LNOT: e->right.num = !e->right.num; break;
-	    case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
-	    case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
-	    case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
-	    case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
-	    case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
-	    case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
-	    case EXPR_IDENT: break;
+	&& e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+	switch (e->op) {
+	    case EXPR_ADD:
+		e->right.num = e->left.num + e->right.num;
+		break;
+	    case EXPR_SUB:
+		e->right.num = e->left.num - e->right.num;
+		break;
+	    case EXPR_MUL:
+		e->right.num = e->left.num * e->right.num;
+		break;
+	    case EXPR_DIV:
+		e->right.num = e->left.num / e->right.num;
+		break;
+	    case EXPR_MOD:
+		e->right.num = e->left.num % e->right.num;
+		break;
+	    case EXPR_NEG:
+		e->right.num = -(e->right.num);
+		break;
+	    case EXPR_NOT:
+		e->right.num = ~(e->right.num);
+		break;
+	    case EXPR_OR:
+		e->right.num = e->left.num | e->right.num;
+		break;
+	    case EXPR_AND:
+		e->right.num = e->left.num & e->right.num;
+		break;
+	    case EXPR_XOR:
+		e->right.num = e->left.num ^ e->right.num;
+		break;
+	    case EXPR_SHL:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_SHR:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_LOR:
+		e->right.num = e->left.num || e->right.num;
+		break;
+	    case EXPR_LAND:
+		e->right.num = e->left.num && e->right.num;
+		break;
+	    case EXPR_LNOT:
+		e->right.num = !e->right.num;
+		break;
+	    case EXPR_EQ:
+		e->right.num = e->right.num == e->left.num;
+		break;
+	    case EXPR_LT:
+		e->right.num = e->right.num < e->left.num;
+		break;
+	    case EXPR_GT:
+		e->right.num = e->right.num > e->left.num;
+		break;
+	    case EXPR_LE:
+		e->right.num = e->right.num <= e->left.num;
+		break;
+	    case EXPR_GE:
+		e->right.num = e->right.num >= e->left.num;
+		break;
+	    case EXPR_NE:
+		e->right.num = e->right.num != e->left.num;
+		break;
+	    case EXPR_IDENT:
+		break;
 	}
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
 
     /* catch simple identities like 0+x, 1*x, etc., for x not a num */
-    else if (e->ltype == EXPR_NUM
-	     && ((e->left.num == 1 && e->op == EXPR_MUL)
-		 ||(e->left.num == 0 && e->op == EXPR_ADD)
-		 ||(e->left.num == -1 && e->op == EXPR_AND)
-		 ||(e->left.num == 0 && e->op == EXPR_OR)))
-    {
+    else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->left.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_OR))) {
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
     /* and the corresponding x+|-0, x*&/1 */
-    else if (e->rtype == EXPR_NUM
-	     && ((e->right.num == 1 && e->op == EXPR_MUL)
-		 ||(e->right.num == 1 && e->op == EXPR_DIV)
-		 ||(e->right.num == 0 && e->op == EXPR_ADD)
-		 ||(e->right.num == 0 && e->op == EXPR_SUB)
-		 ||(e->right.num == -1 && e->op == EXPR_AND)
-		 ||(e->right.num == 0 && e->op == EXPR_OR)
-		 ||(e->right.num == 0 && e->op == EXPR_SHL)
-		 ||(e->right.num == 0 && e->op == EXPR_SHR)))
-    {
+    else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+				      || (e->right.num == 1 &&
+					  e->op == EXPR_DIV)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SUB)
+				      || (e->right.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_OR)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHL)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHR))) {
 	e->op = EXPR_IDENT;
 	e->rtype = e->ltype;
-	memcpy (&e->right, &e->left, sizeof (ExprItem));
+	memcpy(&e->right, &e->left, sizeof(ExprItem));
 	simplified = 1;
     }
 
@@ -227,59 +267,118 @@ expr_simplify (expr *e)
 }
 
 int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
 {
     while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-	   && expr_simplify (e));
+	   && expr_simplify(e)) ;
 
-    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-    {
+    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
 	*retval = e->right.num;
 	return 1;
-    }
-    else
+    } else
 	return 0;
 }
 
 void
-expr_print (expr *e)
+expr_print(expr *e)
 {
     if (e->op != EXPR_IDENT) {
 	switch (e->ltype) {
-	    case EXPR_NUM: printf ("%lu", e->left.num); break;
-	    case EXPR_SYM: printf ("%s", e->left.sym->name); break;
-	    case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
-	    case EXPR_NONE: break;
+	    case EXPR_NUM:
+		printf("%lu", e->left.num);
+		break;
+	    case EXPR_SYM:
+		printf("%s", e->left.sym->name);
+		break;
+	    case EXPR_EXPR:
+		printf("(");
+		expr_print(e->left.expr);
+
+		printf(")");
+	    case EXPR_NONE:
+		break;
 	}
     }
     switch (e->op) {
-	case EXPR_ADD: printf ("+"); break;
-	case EXPR_SUB: printf ("-"); break;
-	case EXPR_MUL: printf ("*"); break;
-	case EXPR_DIV: printf ("/"); break;
-	case EXPR_MOD: printf ("%%"); break;
-	case EXPR_NEG: printf ("-"); break;
-	case EXPR_NOT: printf ("~"); break;
-	case EXPR_OR: printf ("|"); break;
-	case EXPR_AND: printf ("&"); break;
-	case EXPR_XOR: printf ("^"); break;
-	case EXPR_SHL: printf ("<<"); break;
-	case EXPR_SHR: printf (">>"); break;
-	case EXPR_LOR: printf ("||"); break;
-	case EXPR_LAND: printf ("&&"); break;
-	case EXPR_LNOT: printf ("!"); break;
-	case EXPR_LT: printf ("<"); break;
-	case EXPR_GT: printf (">"); break;
-	case EXPR_LE: printf ("<="); break;
-	case EXPR_GE: printf (">="); break;
-	case EXPR_NE: printf ("!="); break;
-	case EXPR_EQ: printf ("=="); break;
-	case EXPR_IDENT: break;
+	case EXPR_ADD:
+	    printf("+");
+	    break;
+	case EXPR_SUB:
+	    printf("-");
+	    break;
+	case EXPR_MUL:
+	    printf("*");
+	    break;
+	case EXPR_DIV:
+	    printf("/");
+	    break;
+	case EXPR_MOD:
+	    printf("%%");
+	    break;
+	case EXPR_NEG:
+	    printf("-");
+	    break;
+	case EXPR_NOT:
+	    printf("~");
+	    break;
+	case EXPR_OR:
+	    printf("|");
+	    break;
+	case EXPR_AND:
+	    printf("&");
+	    break;
+	case EXPR_XOR:
+	    printf("^");
+	    break;
+	case EXPR_SHL:
+	    printf("<<");
+	    break;
+	case EXPR_SHR:
+	    printf(">>");
+	    break;
+	case EXPR_LOR:
+	    printf("||");
+	    break;
+	case EXPR_LAND:
+	    printf("&&");
+	    break;
+	case EXPR_LNOT:
+	    printf("!");
+	    break;
+	case EXPR_LT:
+	    printf("<");
+	    break;
+	case EXPR_GT:
+	    printf(">");
+	    break;
+	case EXPR_LE:
+	    printf("<=");
+	    break;
+	case EXPR_GE:
+	    printf(">=");
+	    break;
+	case EXPR_NE:
+	    printf("!=");
+	    break;
+	case EXPR_EQ:
+	    printf("==");
+	    break;
+	case EXPR_IDENT:
+	    break;
     }
     switch (e->rtype) {
-	case EXPR_NUM: printf ("%lu", e->right.num); break;
-	case EXPR_SYM: printf ("%s", e->right.sym->name); break;
-	case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
-	case EXPR_NONE: break;
+	case EXPR_NUM:
+	    printf("%lu", e->right.num);
+	    break;
+	case EXPR_SYM:
+	    printf("%s", e->right.sym->name);
+	    break;
+	case EXPR_EXPR:
+	    printf("(");
+	    expr_print(e->right.expr);
+
+	    printf(")");
+	case EXPR_NONE:
+	    break;
     }
 }
diff --git a/modules/preprocs/raw/preproc.c b/modules/preprocs/raw/preproc.c
index d04baf8c..5f163894 100644
--- a/modules/preprocs/raw/preproc.c
+++ b/modules/preprocs/raw/preproc.c
@@ -1,4 +1,4 @@
-/* $Id: preproc.c,v 1.2 2001/08/19 02:50:14 peter Exp $
+/* $Id: preproc.c,v 1.3 2001/08/19 03:52:58 peter Exp $
  * Raw preprocessor (preforms NO preprocessing)
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -41,14 +41,14 @@ input(char *buf, int max_size)
 {
     int c = '*', n;
 
-    if(is_interactive) {
-	for(n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
-	    buf[n] = (char) c;
-	if(c == '\n')
-	    buf[n++] = (char) c;
-	if(c == EOF && ferror(in))
+    if (is_interactive) {
+	for (n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
+	    buf[n] = (char)c;
+	if (c == '\n')
+	    buf[n++] = (char)c;
+	if (c == EOF && ferror(in))
 	    Error(ERR_FILE_READ, (char *)NULL);
-    } else if(((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
+    } else if (((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
 	Error(ERR_FILE_READ, (char *)NULL);
 
     return n;
diff --git a/modules/preprocs/raw/raw-preproc.c b/modules/preprocs/raw/raw-preproc.c
index 92a47648..ce70e2b4 100644
--- a/modules/preprocs/raw/raw-preproc.c
+++ b/modules/preprocs/raw/raw-preproc.c
@@ -1,4 +1,4 @@
-/* $Id: raw-preproc.c,v 1.2 2001/08/19 02:50:14 peter Exp $
+/* $Id: raw-preproc.c,v 1.3 2001/08/19 03:52:58 peter Exp $
  * Raw preprocessor (preforms NO preprocessing)
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -41,14 +41,14 @@ input(char *buf, int max_size)
 {
     int c = '*', n;
 
-    if(is_interactive) {
-	for(n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
-	    buf[n] = (char) c;
-	if(c == '\n')
-	    buf[n++] = (char) c;
-	if(c == EOF && ferror(in))
+    if (is_interactive) {
+	for (n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
+	    buf[n] = (char)c;
+	if (c == '\n')
+	    buf[n++] = (char)c;
+	if (c == EOF && ferror(in))
 	    Error(ERR_FILE_READ, (char *)NULL);
-    } else if(((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
+    } else if (((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
 	Error(ERR_FILE_READ, (char *)NULL);
 
     return n;
diff --git a/src/arch/x86/expr.c b/src/arch/x86/expr.c
index 627b2a4e..1b0248f7 100644
--- a/src/arch/x86/expr.c
+++ b/src/arch/x86/expr.c
@@ -1,4 +1,4 @@
-/* $Id: expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Expression handling
  *
  *  Copyright (C) 2001  Michael Urman
@@ -30,36 +30,36 @@
 /* allocate a new expression node, with children as defined.
  * If it's a unary operator, put the element on the right */
 expr *
-expr_new (ExprType ltype,
-	  ExprItem left,
-	  ExprOp   op,
-	  ExprType rtype,
-	  ExprItem right)
+expr_new(ExprType ltype,
+	 ExprItem left,
+	 ExprOp   op,
+	 ExprType rtype,
+	 ExprItem right)
 {
     expr *ptr;
-    ptr = malloc (sizeof (expr));
-    if (ptr == NULL) Fatal (FATAL_NOMEM);
+    ptr = malloc(sizeof(expr));
+    if (ptr == NULL)
+	Fatal(FATAL_NOMEM);
     ptr->ltype = ltype;
     ptr->op = op;
     ptr->rtype = rtype;
-    switch (ltype)
-    {
+    switch (ltype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->left, &left, sizeof (ExprItem));
+	    memcpy(&ptr->left, &left, sizeof(ExprItem));
+	    break;
+	case EXPR_NONE:
 	    break;
-	case EXPR_NONE: break;
     }
-    switch (rtype)
-    {
+    switch (rtype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->right, &right, sizeof (ExprItem));
+	    memcpy(&ptr->right, &right, sizeof(ExprItem));
 	    break;
 	case EXPR_NONE:
-	    Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+	    Fatal(FATAL_UNKNOWN);	/* TODO: better error? */
 	    break;
     }
     return ptr;
@@ -67,68 +67,67 @@ expr_new (ExprType ltype,
 
 /* helpers */
 ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
 {
     ExprItem e;
+
     e.sym = s;
     return e;
 }
 
 ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
 {
     ExprItem e;
     e.expr = x;
+
     return e;
 }
 
 ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
 {
     ExprItem e;
+
     e.num = n;
     return e;
 }
 
 ExprItem
-ExprNone (void)
+ExprNone(void)
 {
     ExprItem e;
+
     e.num = 0;
     return e;
 }
 
 /* get rid of unnecessary branches if possible.  report. */
 int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
 {
     int simplified = 0;
 
     /* try to simplify the left side */
-    if (e->ltype == EXPR_EXPR)
-    {
+    if (e->ltype == EXPR_EXPR) {
 	/* if the left subexpr isn't an IDENT, recurse simplification */
 	if (e->left.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->left.expr);
+	    simplified |= expr_simplify(e->left.expr);
 
 	/* if the left subexpr is just an IDENT (or string thereof),
 	 * pull it up into the current node */
-	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
-	{
+	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->ltype = e->left.expr->rtype;
-	    memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
-	    free (e->left.expr);
-	    memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+	    free(e->left.expr);
+	    memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->ltype == EXPR_SYM)
-    {
+    } else if (e->ltype == EXPR_SYM) {
 	/* if it's a symbol that has a defined value, turn it into a
 	 * number */
-	if (e->left.sym->status & SYM_VALUED)
-	{
+	if (e->left.sym->status & SYM_VALUED) {
 	    e->ltype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->left.num = e->left.sym->value;
@@ -137,25 +136,20 @@ expr_simplify (expr *e)
     }
 
     /* ditto on the right */
-    if (e->rtype == EXPR_EXPR)
-    {
+    if (e->rtype == EXPR_EXPR) {
 	if (e->right.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->right.expr);
+	    simplified |= expr_simplify(e->right.expr);
 
-	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
-	{
+	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->rtype = e->right.expr->rtype;
-	    memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
-	    free (e->right.expr);
-	    memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+	    free(e->right.expr);
+	    memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->rtype == EXPR_SYM)
-    {
-	if (e->right.sym->status & SYM_VALUED)
-	{
+    } else if (e->rtype == EXPR_SYM) {
+	if (e->right.sym->status & SYM_VALUED) {
 	    e->rtype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->right.num = e->right.sym->value;
@@ -164,62 +158,108 @@ expr_simplify (expr *e)
     }
 
     if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
-	&& e->rtype == EXPR_NUM
-	&& e->op != EXPR_IDENT)
-    {
-	switch (e->op)
-	{
-	    case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
-	    case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
-	    case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
-	    case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
-	    case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
-	    case EXPR_NEG: e->right.num = -(e->right.num); break;
-	    case EXPR_NOT: e->right.num = ~(e->right.num); break;
-	    case EXPR_OR:  e->right.num = e->left.num | e->right.num; break;
-	    case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
-	    case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
-	    case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
-	    case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
-	    case EXPR_LNOT: e->right.num = !e->right.num; break;
-	    case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
-	    case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
-	    case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
-	    case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
-	    case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
-	    case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
-	    case EXPR_IDENT: break;
+	&& e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+	switch (e->op) {
+	    case EXPR_ADD:
+		e->right.num = e->left.num + e->right.num;
+		break;
+	    case EXPR_SUB:
+		e->right.num = e->left.num - e->right.num;
+		break;
+	    case EXPR_MUL:
+		e->right.num = e->left.num * e->right.num;
+		break;
+	    case EXPR_DIV:
+		e->right.num = e->left.num / e->right.num;
+		break;
+	    case EXPR_MOD:
+		e->right.num = e->left.num % e->right.num;
+		break;
+	    case EXPR_NEG:
+		e->right.num = -(e->right.num);
+		break;
+	    case EXPR_NOT:
+		e->right.num = ~(e->right.num);
+		break;
+	    case EXPR_OR:
+		e->right.num = e->left.num | e->right.num;
+		break;
+	    case EXPR_AND:
+		e->right.num = e->left.num & e->right.num;
+		break;
+	    case EXPR_XOR:
+		e->right.num = e->left.num ^ e->right.num;
+		break;
+	    case EXPR_SHL:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_SHR:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_LOR:
+		e->right.num = e->left.num || e->right.num;
+		break;
+	    case EXPR_LAND:
+		e->right.num = e->left.num && e->right.num;
+		break;
+	    case EXPR_LNOT:
+		e->right.num = !e->right.num;
+		break;
+	    case EXPR_EQ:
+		e->right.num = e->right.num == e->left.num;
+		break;
+	    case EXPR_LT:
+		e->right.num = e->right.num < e->left.num;
+		break;
+	    case EXPR_GT:
+		e->right.num = e->right.num > e->left.num;
+		break;
+	    case EXPR_LE:
+		e->right.num = e->right.num <= e->left.num;
+		break;
+	    case EXPR_GE:
+		e->right.num = e->right.num >= e->left.num;
+		break;
+	    case EXPR_NE:
+		e->right.num = e->right.num != e->left.num;
+		break;
+	    case EXPR_IDENT:
+		break;
 	}
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
 
     /* catch simple identities like 0+x, 1*x, etc., for x not a num */
-    else if (e->ltype == EXPR_NUM
-	     && ((e->left.num == 1 && e->op == EXPR_MUL)
-		 ||(e->left.num == 0 && e->op == EXPR_ADD)
-		 ||(e->left.num == -1 && e->op == EXPR_AND)
-		 ||(e->left.num == 0 && e->op == EXPR_OR)))
-    {
+    else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->left.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_OR))) {
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
     /* and the corresponding x+|-0, x*&/1 */
-    else if (e->rtype == EXPR_NUM
-	     && ((e->right.num == 1 && e->op == EXPR_MUL)
-		 ||(e->right.num == 1 && e->op == EXPR_DIV)
-		 ||(e->right.num == 0 && e->op == EXPR_ADD)
-		 ||(e->right.num == 0 && e->op == EXPR_SUB)
-		 ||(e->right.num == -1 && e->op == EXPR_AND)
-		 ||(e->right.num == 0 && e->op == EXPR_OR)
-		 ||(e->right.num == 0 && e->op == EXPR_SHL)
-		 ||(e->right.num == 0 && e->op == EXPR_SHR)))
-    {
+    else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+				      || (e->right.num == 1 &&
+					  e->op == EXPR_DIV)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SUB)
+				      || (e->right.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_OR)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHL)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHR))) {
 	e->op = EXPR_IDENT;
 	e->rtype = e->ltype;
-	memcpy (&e->right, &e->left, sizeof (ExprItem));
+	memcpy(&e->right, &e->left, sizeof(ExprItem));
 	simplified = 1;
     }
 
@@ -227,59 +267,118 @@ expr_simplify (expr *e)
 }
 
 int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
 {
     while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-	   && expr_simplify (e));
+	   && expr_simplify(e)) ;
 
-    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-    {
+    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
 	*retval = e->right.num;
 	return 1;
-    }
-    else
+    } else
 	return 0;
 }
 
 void
-expr_print (expr *e)
+expr_print(expr *e)
 {
     if (e->op != EXPR_IDENT) {
 	switch (e->ltype) {
-	    case EXPR_NUM: printf ("%lu", e->left.num); break;
-	    case EXPR_SYM: printf ("%s", e->left.sym->name); break;
-	    case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
-	    case EXPR_NONE: break;
+	    case EXPR_NUM:
+		printf("%lu", e->left.num);
+		break;
+	    case EXPR_SYM:
+		printf("%s", e->left.sym->name);
+		break;
+	    case EXPR_EXPR:
+		printf("(");
+		expr_print(e->left.expr);
+
+		printf(")");
+	    case EXPR_NONE:
+		break;
 	}
     }
     switch (e->op) {
-	case EXPR_ADD: printf ("+"); break;
-	case EXPR_SUB: printf ("-"); break;
-	case EXPR_MUL: printf ("*"); break;
-	case EXPR_DIV: printf ("/"); break;
-	case EXPR_MOD: printf ("%%"); break;
-	case EXPR_NEG: printf ("-"); break;
-	case EXPR_NOT: printf ("~"); break;
-	case EXPR_OR: printf ("|"); break;
-	case EXPR_AND: printf ("&"); break;
-	case EXPR_XOR: printf ("^"); break;
-	case EXPR_SHL: printf ("<<"); break;
-	case EXPR_SHR: printf (">>"); break;
-	case EXPR_LOR: printf ("||"); break;
-	case EXPR_LAND: printf ("&&"); break;
-	case EXPR_LNOT: printf ("!"); break;
-	case EXPR_LT: printf ("<"); break;
-	case EXPR_GT: printf (">"); break;
-	case EXPR_LE: printf ("<="); break;
-	case EXPR_GE: printf (">="); break;
-	case EXPR_NE: printf ("!="); break;
-	case EXPR_EQ: printf ("=="); break;
-	case EXPR_IDENT: break;
+	case EXPR_ADD:
+	    printf("+");
+	    break;
+	case EXPR_SUB:
+	    printf("-");
+	    break;
+	case EXPR_MUL:
+	    printf("*");
+	    break;
+	case EXPR_DIV:
+	    printf("/");
+	    break;
+	case EXPR_MOD:
+	    printf("%%");
+	    break;
+	case EXPR_NEG:
+	    printf("-");
+	    break;
+	case EXPR_NOT:
+	    printf("~");
+	    break;
+	case EXPR_OR:
+	    printf("|");
+	    break;
+	case EXPR_AND:
+	    printf("&");
+	    break;
+	case EXPR_XOR:
+	    printf("^");
+	    break;
+	case EXPR_SHL:
+	    printf("<<");
+	    break;
+	case EXPR_SHR:
+	    printf(">>");
+	    break;
+	case EXPR_LOR:
+	    printf("||");
+	    break;
+	case EXPR_LAND:
+	    printf("&&");
+	    break;
+	case EXPR_LNOT:
+	    printf("!");
+	    break;
+	case EXPR_LT:
+	    printf("<");
+	    break;
+	case EXPR_GT:
+	    printf(">");
+	    break;
+	case EXPR_LE:
+	    printf("<=");
+	    break;
+	case EXPR_GE:
+	    printf(">=");
+	    break;
+	case EXPR_NE:
+	    printf("!=");
+	    break;
+	case EXPR_EQ:
+	    printf("==");
+	    break;
+	case EXPR_IDENT:
+	    break;
     }
     switch (e->rtype) {
-	case EXPR_NUM: printf ("%lu", e->right.num); break;
-	case EXPR_SYM: printf ("%s", e->right.sym->name); break;
-	case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
-	case EXPR_NONE: break;
+	case EXPR_NUM:
+	    printf("%lu", e->right.num);
+	    break;
+	case EXPR_SYM:
+	    printf("%s", e->right.sym->name);
+	    break;
+	case EXPR_EXPR:
+	    printf("(");
+	    expr_print(e->right.expr);
+
+	    printf(")");
+	case EXPR_NONE:
+	    break;
     }
 }
diff --git a/src/arch/x86/x86expr.c b/src/arch/x86/x86expr.c
index 2d891512..69213d1f 100644
--- a/src/arch/x86/x86expr.c
+++ b/src/arch/x86/x86expr.c
@@ -1,4 +1,4 @@
-/* $Id: x86expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: x86expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Expression handling
  *
  *  Copyright (C) 2001  Michael Urman
@@ -30,36 +30,36 @@
 /* allocate a new expression node, with children as defined.
  * If it's a unary operator, put the element on the right */
 expr *
-expr_new (ExprType ltype,
-	  ExprItem left,
-	  ExprOp   op,
-	  ExprType rtype,
-	  ExprItem right)
+expr_new(ExprType ltype,
+	 ExprItem left,
+	 ExprOp   op,
+	 ExprType rtype,
+	 ExprItem right)
 {
     expr *ptr;
-    ptr = malloc (sizeof (expr));
-    if (ptr == NULL) Fatal (FATAL_NOMEM);
+    ptr = malloc(sizeof(expr));
+    if (ptr == NULL)
+	Fatal(FATAL_NOMEM);
     ptr->ltype = ltype;
     ptr->op = op;
     ptr->rtype = rtype;
-    switch (ltype)
-    {
+    switch (ltype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->left, &left, sizeof (ExprItem));
+	    memcpy(&ptr->left, &left, sizeof(ExprItem));
+	    break;
+	case EXPR_NONE:
 	    break;
-	case EXPR_NONE: break;
     }
-    switch (rtype)
-    {
+    switch (rtype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->right, &right, sizeof (ExprItem));
+	    memcpy(&ptr->right, &right, sizeof(ExprItem));
 	    break;
 	case EXPR_NONE:
-	    Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+	    Fatal(FATAL_UNKNOWN);	/* TODO: better error? */
 	    break;
     }
     return ptr;
@@ -67,68 +67,67 @@ expr_new (ExprType ltype,
 
 /* helpers */
 ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
 {
     ExprItem e;
+
     e.sym = s;
     return e;
 }
 
 ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
 {
     ExprItem e;
     e.expr = x;
+
     return e;
 }
 
 ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
 {
     ExprItem e;
+
     e.num = n;
     return e;
 }
 
 ExprItem
-ExprNone (void)
+ExprNone(void)
 {
     ExprItem e;
+
     e.num = 0;
     return e;
 }
 
 /* get rid of unnecessary branches if possible.  report. */
 int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
 {
     int simplified = 0;
 
     /* try to simplify the left side */
-    if (e->ltype == EXPR_EXPR)
-    {
+    if (e->ltype == EXPR_EXPR) {
 	/* if the left subexpr isn't an IDENT, recurse simplification */
 	if (e->left.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->left.expr);
+	    simplified |= expr_simplify(e->left.expr);
 
 	/* if the left subexpr is just an IDENT (or string thereof),
 	 * pull it up into the current node */
-	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
-	{
+	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->ltype = e->left.expr->rtype;
-	    memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
-	    free (e->left.expr);
-	    memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+	    free(e->left.expr);
+	    memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->ltype == EXPR_SYM)
-    {
+    } else if (e->ltype == EXPR_SYM) {
 	/* if it's a symbol that has a defined value, turn it into a
 	 * number */
-	if (e->left.sym->status & SYM_VALUED)
-	{
+	if (e->left.sym->status & SYM_VALUED) {
 	    e->ltype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->left.num = e->left.sym->value;
@@ -137,25 +136,20 @@ expr_simplify (expr *e)
     }
 
     /* ditto on the right */
-    if (e->rtype == EXPR_EXPR)
-    {
+    if (e->rtype == EXPR_EXPR) {
 	if (e->right.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->right.expr);
+	    simplified |= expr_simplify(e->right.expr);
 
-	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
-	{
+	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->rtype = e->right.expr->rtype;
-	    memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
-	    free (e->right.expr);
-	    memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+	    free(e->right.expr);
+	    memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->rtype == EXPR_SYM)
-    {
-	if (e->right.sym->status & SYM_VALUED)
-	{
+    } else if (e->rtype == EXPR_SYM) {
+	if (e->right.sym->status & SYM_VALUED) {
 	    e->rtype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->right.num = e->right.sym->value;
@@ -164,62 +158,108 @@ expr_simplify (expr *e)
     }
 
     if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
-	&& e->rtype == EXPR_NUM
-	&& e->op != EXPR_IDENT)
-    {
-	switch (e->op)
-	{
-	    case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
-	    case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
-	    case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
-	    case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
-	    case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
-	    case EXPR_NEG: e->right.num = -(e->right.num); break;
-	    case EXPR_NOT: e->right.num = ~(e->right.num); break;
-	    case EXPR_OR:  e->right.num = e->left.num | e->right.num; break;
-	    case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
-	    case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
-	    case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
-	    case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
-	    case EXPR_LNOT: e->right.num = !e->right.num; break;
-	    case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
-	    case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
-	    case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
-	    case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
-	    case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
-	    case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
-	    case EXPR_IDENT: break;
+	&& e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+	switch (e->op) {
+	    case EXPR_ADD:
+		e->right.num = e->left.num + e->right.num;
+		break;
+	    case EXPR_SUB:
+		e->right.num = e->left.num - e->right.num;
+		break;
+	    case EXPR_MUL:
+		e->right.num = e->left.num * e->right.num;
+		break;
+	    case EXPR_DIV:
+		e->right.num = e->left.num / e->right.num;
+		break;
+	    case EXPR_MOD:
+		e->right.num = e->left.num % e->right.num;
+		break;
+	    case EXPR_NEG:
+		e->right.num = -(e->right.num);
+		break;
+	    case EXPR_NOT:
+		e->right.num = ~(e->right.num);
+		break;
+	    case EXPR_OR:
+		e->right.num = e->left.num | e->right.num;
+		break;
+	    case EXPR_AND:
+		e->right.num = e->left.num & e->right.num;
+		break;
+	    case EXPR_XOR:
+		e->right.num = e->left.num ^ e->right.num;
+		break;
+	    case EXPR_SHL:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_SHR:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_LOR:
+		e->right.num = e->left.num || e->right.num;
+		break;
+	    case EXPR_LAND:
+		e->right.num = e->left.num && e->right.num;
+		break;
+	    case EXPR_LNOT:
+		e->right.num = !e->right.num;
+		break;
+	    case EXPR_EQ:
+		e->right.num = e->right.num == e->left.num;
+		break;
+	    case EXPR_LT:
+		e->right.num = e->right.num < e->left.num;
+		break;
+	    case EXPR_GT:
+		e->right.num = e->right.num > e->left.num;
+		break;
+	    case EXPR_LE:
+		e->right.num = e->right.num <= e->left.num;
+		break;
+	    case EXPR_GE:
+		e->right.num = e->right.num >= e->left.num;
+		break;
+	    case EXPR_NE:
+		e->right.num = e->right.num != e->left.num;
+		break;
+	    case EXPR_IDENT:
+		break;
 	}
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
 
     /* catch simple identities like 0+x, 1*x, etc., for x not a num */
-    else if (e->ltype == EXPR_NUM
-	     && ((e->left.num == 1 && e->op == EXPR_MUL)
-		 ||(e->left.num == 0 && e->op == EXPR_ADD)
-		 ||(e->left.num == -1 && e->op == EXPR_AND)
-		 ||(e->left.num == 0 && e->op == EXPR_OR)))
-    {
+    else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->left.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_OR))) {
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
     /* and the corresponding x+|-0, x*&/1 */
-    else if (e->rtype == EXPR_NUM
-	     && ((e->right.num == 1 && e->op == EXPR_MUL)
-		 ||(e->right.num == 1 && e->op == EXPR_DIV)
-		 ||(e->right.num == 0 && e->op == EXPR_ADD)
-		 ||(e->right.num == 0 && e->op == EXPR_SUB)
-		 ||(e->right.num == -1 && e->op == EXPR_AND)
-		 ||(e->right.num == 0 && e->op == EXPR_OR)
-		 ||(e->right.num == 0 && e->op == EXPR_SHL)
-		 ||(e->right.num == 0 && e->op == EXPR_SHR)))
-    {
+    else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+				      || (e->right.num == 1 &&
+					  e->op == EXPR_DIV)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SUB)
+				      || (e->right.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_OR)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHL)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHR))) {
 	e->op = EXPR_IDENT;
 	e->rtype = e->ltype;
-	memcpy (&e->right, &e->left, sizeof (ExprItem));
+	memcpy(&e->right, &e->left, sizeof(ExprItem));
 	simplified = 1;
     }
 
@@ -227,59 +267,118 @@ expr_simplify (expr *e)
 }
 
 int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
 {
     while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-	   && expr_simplify (e));
+	   && expr_simplify(e)) ;
 
-    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-    {
+    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
 	*retval = e->right.num;
 	return 1;
-    }
-    else
+    } else
 	return 0;
 }
 
 void
-expr_print (expr *e)
+expr_print(expr *e)
 {
     if (e->op != EXPR_IDENT) {
 	switch (e->ltype) {
-	    case EXPR_NUM: printf ("%lu", e->left.num); break;
-	    case EXPR_SYM: printf ("%s", e->left.sym->name); break;
-	    case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
-	    case EXPR_NONE: break;
+	    case EXPR_NUM:
+		printf("%lu", e->left.num);
+		break;
+	    case EXPR_SYM:
+		printf("%s", e->left.sym->name);
+		break;
+	    case EXPR_EXPR:
+		printf("(");
+		expr_print(e->left.expr);
+
+		printf(")");
+	    case EXPR_NONE:
+		break;
 	}
     }
     switch (e->op) {
-	case EXPR_ADD: printf ("+"); break;
-	case EXPR_SUB: printf ("-"); break;
-	case EXPR_MUL: printf ("*"); break;
-	case EXPR_DIV: printf ("/"); break;
-	case EXPR_MOD: printf ("%%"); break;
-	case EXPR_NEG: printf ("-"); break;
-	case EXPR_NOT: printf ("~"); break;
-	case EXPR_OR: printf ("|"); break;
-	case EXPR_AND: printf ("&"); break;
-	case EXPR_XOR: printf ("^"); break;
-	case EXPR_SHL: printf ("<<"); break;
-	case EXPR_SHR: printf (">>"); break;
-	case EXPR_LOR: printf ("||"); break;
-	case EXPR_LAND: printf ("&&"); break;
-	case EXPR_LNOT: printf ("!"); break;
-	case EXPR_LT: printf ("<"); break;
-	case EXPR_GT: printf (">"); break;
-	case EXPR_LE: printf ("<="); break;
-	case EXPR_GE: printf (">="); break;
-	case EXPR_NE: printf ("!="); break;
-	case EXPR_EQ: printf ("=="); break;
-	case EXPR_IDENT: break;
+	case EXPR_ADD:
+	    printf("+");
+	    break;
+	case EXPR_SUB:
+	    printf("-");
+	    break;
+	case EXPR_MUL:
+	    printf("*");
+	    break;
+	case EXPR_DIV:
+	    printf("/");
+	    break;
+	case EXPR_MOD:
+	    printf("%%");
+	    break;
+	case EXPR_NEG:
+	    printf("-");
+	    break;
+	case EXPR_NOT:
+	    printf("~");
+	    break;
+	case EXPR_OR:
+	    printf("|");
+	    break;
+	case EXPR_AND:
+	    printf("&");
+	    break;
+	case EXPR_XOR:
+	    printf("^");
+	    break;
+	case EXPR_SHL:
+	    printf("<<");
+	    break;
+	case EXPR_SHR:
+	    printf(">>");
+	    break;
+	case EXPR_LOR:
+	    printf("||");
+	    break;
+	case EXPR_LAND:
+	    printf("&&");
+	    break;
+	case EXPR_LNOT:
+	    printf("!");
+	    break;
+	case EXPR_LT:
+	    printf("<");
+	    break;
+	case EXPR_GT:
+	    printf(">");
+	    break;
+	case EXPR_LE:
+	    printf("<=");
+	    break;
+	case EXPR_GE:
+	    printf(">=");
+	    break;
+	case EXPR_NE:
+	    printf("!=");
+	    break;
+	case EXPR_EQ:
+	    printf("==");
+	    break;
+	case EXPR_IDENT:
+	    break;
     }
     switch (e->rtype) {
-	case EXPR_NUM: printf ("%lu", e->right.num); break;
-	case EXPR_SYM: printf ("%s", e->right.sym->name); break;
-	case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
-	case EXPR_NONE: break;
+	case EXPR_NUM:
+	    printf("%lu", e->right.num);
+	    break;
+	case EXPR_SYM:
+	    printf("%s", e->right.sym->name);
+	    break;
+	case EXPR_EXPR:
+	    printf("(");
+	    expr_print(e->right.expr);
+
+	    printf(")");
+	case EXPR_NONE:
+	    break;
     }
 }
diff --git a/src/bytecode.c b/src/bytecode.c
index 54c7c8e4..b86e86e7 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1,4 +1,4 @@
-/* $Id: bytecode.c,v 1.15 2001/08/18 22:15:12 peter Exp $
+/* $Id: bytecode.c,v 1.16 2001/08/19 03:52:58 peter Exp $
  * Bytecode utility functions
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -30,22 +30,24 @@
 /* Static structures for when NULL is passed to conversion functions. */
 /*  for Convert*ToEA() */
 static effaddr eff_static;
+
 /*  for Convert*ToImm() */
 static immval im_static;
+
 /*  for Convert*ToBytes() */
 unsigned char bytes_static[16];
 
 static void BuildBC_Common(bytecode *bc);
 
 effaddr *
-ConvertRegToEA (effaddr *ptr, unsigned long reg)
+ConvertRegToEA(effaddr *ptr, unsigned long reg)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &eff_static;
 
     ptr->len = 0;
     ptr->segment = 0;
-    ptr->modrm = 0xC0 | (reg & 0x07);	    /* Mod=11, R/M=Reg, Reg=0 */
+    ptr->modrm = 0xC0 | (reg & 0x07);	/* Mod=11, R/M=Reg, Reg=0 */
     ptr->valid_modrm = 1;
     ptr->need_modrm = 1;
     ptr->valid_sib = 0;
@@ -55,9 +57,9 @@ ConvertRegToEA (effaddr *ptr, unsigned long reg)
 }
 
 effaddr *
-ConvertExprToEA (effaddr *ptr, expr *expr_ptr)
+ConvertExprToEA(effaddr *ptr, expr *expr_ptr)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &eff_static;
 
     ptr->segment = 0;
@@ -73,13 +75,13 @@ ConvertExprToEA (effaddr *ptr, expr *expr_ptr)
 }
 
 effaddr *
-ConvertImmToEA (effaddr *ptr, immval *im_ptr, unsigned char im_len)
+ConvertImmToEA(effaddr *ptr, immval *im_ptr, unsigned char im_len)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &eff_static;
 
     ptr->disp = im_ptr->val;
-    if(im_ptr->len > im_len)
+    if (im_ptr->len > im_len)
 	Warning(WARN_VALUE_EXCEEDS_BOUNDS, (char *)NULL, "word");
     ptr->len = im_len;
     ptr->segment = 0;
@@ -92,17 +94,17 @@ ConvertImmToEA (effaddr *ptr, immval *im_ptr, unsigned char im_len)
 }
 
 immval *
-ConvertIntToImm (immval *ptr, unsigned long int_val)
+ConvertIntToImm(immval *ptr, unsigned long int_val)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &im_static;
 
     /* FIXME: this will leak expr's if static is used */
     ptr->val = expr_new_ident(EXPR_NUM, ExprNum(int_val));
 
-    if((int_val & 0xFF) == int_val)
+    if ((int_val & 0xFF) == int_val)
 	ptr->len = 1;
-    else if((int_val & 0xFFFF) == int_val)
+    else if ((int_val & 0xFFFF) == int_val)
 	ptr->len = 2;
     else
 	ptr->len = 4;
@@ -113,9 +115,9 @@ ConvertIntToImm (immval *ptr, unsigned long int_val)
 }
 
 immval *
-ConvertExprToImm (immval *ptr, expr *expr_ptr)
+ConvertExprToImm(immval *ptr, expr *expr_ptr)
 {
-    if(!ptr)
+    if (!ptr)
 	ptr = &im_static;
 
     ptr->val = expr_ptr;
@@ -126,21 +128,21 @@ ConvertExprToImm (immval *ptr, expr *expr_ptr)
 }
 
 void
-SetEASegment (effaddr *ptr, unsigned char segment)
+SetEASegment(effaddr *ptr, unsigned char segment)
 {
-    if(!ptr)
+    if (!ptr)
 	return;
 
-    if(ptr->segment != 0)
+    if (ptr->segment != 0)
 	Warning(WARN_MULT_SEG_OVERRIDE, (char *)NULL);
 
     ptr->segment = segment;
 }
 
 void
-SetEALen (effaddr *ptr, unsigned char len)
+SetEALen(effaddr *ptr, unsigned char len)
 {
-    if(!ptr)
+    if (!ptr)
 	return;
 
     /* Currently don't warn if length truncated, as this is called only from
@@ -151,12 +153,12 @@ SetEALen (effaddr *ptr, unsigned char len)
 }
 
 void
-SetInsnOperSizeOverride (bytecode *bc, unsigned char opersize)
+SetInsnOperSizeOverride(bytecode *bc, unsigned char opersize)
 {
-    if(!bc)
+    if (!bc)
 	return;
 
-    switch(bc->type) {
+    switch (bc->type) {
 	case BC_INSN:
 	    bc->data.insn.opersize = opersize;
 	    break;
@@ -165,18 +167,18 @@ SetInsnOperSizeOverride (bytecode *bc, unsigned char opersize)
 	    break;
 	default:
 	    InternalError(__LINE__, __FILE__,
-		"OperSize override applied to non-instruction");
+			  "OperSize override applied to non-instruction");
 	    return;
     }
 }
 
 void
-SetInsnAddrSizeOverride (bytecode *bc, unsigned char addrsize)
+SetInsnAddrSizeOverride(bytecode *bc, unsigned char addrsize)
 {
-    if(!bc)
+    if (!bc)
 	return;
 
-    switch(bc->type) {
+    switch (bc->type) {
 	case BC_INSN:
 	    bc->data.insn.addrsize = addrsize;
 	    break;
@@ -185,20 +187,20 @@ SetInsnAddrSizeOverride (bytecode *bc, unsigned char addrsize)
 	    break;
 	default:
 	    InternalError(__LINE__, __FILE__,
-		"AddrSize override applied to non-instruction");
+			  "AddrSize override applied to non-instruction");
 	    return;
     }
 }
 
 void
-SetInsnLockRepPrefix (bytecode *bc, unsigned char prefix)
+SetInsnLockRepPrefix(bytecode *bc, unsigned char prefix)
 {
     unsigned char *lockrep_pre = (unsigned char *)NULL;
 
-    if(!bc)
+    if (!bc)
 	return;
 
-    switch(bc->type) {
+    switch (bc->type) {
 	case BC_INSN:
 	    lockrep_pre = &bc->data.insn.lockrep_pre;
 	    break;
@@ -207,29 +209,29 @@ SetInsnLockRepPrefix (bytecode *bc, unsigned char prefix)
 	    break;
 	default:
 	    InternalError(__LINE__, __FILE__,
-		"LockRep prefix applied to non-instruction");
+			  "LockRep prefix applied to non-instruction");
 	    return;
     }
 
-    if(*lockrep_pre != 0)
+    if (*lockrep_pre != 0)
 	Warning(WARN_MULT_LOCKREP_PREFIX, (char *)NULL);
 
     *lockrep_pre = prefix;
 }
 
 void
-SetOpcodeSel (jmprel_opcode_sel *old_sel, jmprel_opcode_sel new_sel)
+SetOpcodeSel(jmprel_opcode_sel *old_sel, jmprel_opcode_sel new_sel)
 {
-    if(!old_sel)
+    if (!old_sel)
 	return;
 
-    if((*old_sel == JR_SHORT_FORCED) || (*old_sel == JR_NEAR_FORCED))
+    if ((*old_sel == JR_SHORT_FORCED) || (*old_sel == JR_NEAR_FORCED))
 	Warning(WARN_MULT_SHORTNEAR, (char *)NULL);
     *old_sel = new_sel;
 }
 
 static void
-BuildBC_Common (bytecode *bc)
+BuildBC_Common(bytecode *bc)
 {
     bc->len = 0;
 
@@ -241,24 +243,24 @@ BuildBC_Common (bytecode *bc)
 }
 
 void
-BuildBC_Insn (bytecode      *bc,
-	      unsigned char  opersize,
-	      unsigned char  opcode_len,
-	      unsigned char  op0,
-	      unsigned char  op1,
-	      unsigned char  op2,
-	      effaddr       *ea_ptr,
-	      unsigned char  spare,
-	      immval        *im_ptr,
-	      unsigned char  im_len,
-	      unsigned char  im_sign)
+BuildBC_Insn(bytecode      *bc,
+	     unsigned char  opersize,
+	     unsigned char  opcode_len,
+	     unsigned char  op0,
+	     unsigned char  op1,
+	     unsigned char  op2,
+	     effaddr       *ea_ptr,
+	     unsigned char  spare,
+	     immval        *im_ptr,
+	     unsigned char  im_len,
+	     unsigned char  im_sign)
 {
     bc->next = (bytecode *)NULL;
     bc->type = BC_INSN;
 
-    if(ea_ptr) {
+    if (ea_ptr) {
 	bc->data.insn.ea = *ea_ptr;
-	bc->data.insn.ea.modrm &= 0xC7;		/* zero spare/reg bits */
+	bc->data.insn.ea.modrm &= 0xC7;	/* zero spare/reg bits */
 	bc->data.insn.ea.modrm |= (spare << 3) & 0x38;	/* plug in provided bits */
     } else {
 	bc->data.insn.ea.len = 0;
@@ -267,7 +269,7 @@ BuildBC_Insn (bytecode      *bc,
 	bc->data.insn.ea.need_sib = 0;
     }
 
-    if(im_ptr) {
+    if (im_ptr) {
 	bc->data.insn.imm = *im_ptr;
 	bc->data.insn.imm.f_sign = im_sign;
 	bc->data.insn.imm.f_len = im_len;
@@ -290,19 +292,19 @@ BuildBC_Insn (bytecode      *bc,
 }
 
 void
-BuildBC_JmpRel (bytecode      *bc,
-	        targetval     *target,
-	        unsigned char  short_valid,
-	        unsigned char  short_opcode_len,
-	        unsigned char  short_op0,
-	        unsigned char  short_op1,
-	        unsigned char  short_op2,
-	        unsigned char  near_valid,
-	        unsigned char  near_opcode_len,
-	        unsigned char  near_op0,
-	        unsigned char  near_op1,
-	        unsigned char  near_op2,
-	        unsigned char  addrsize)
+BuildBC_JmpRel(bytecode      *bc,
+	       targetval     *target,
+	       unsigned char  short_valid,
+	       unsigned char  short_opcode_len,
+	       unsigned char  short_op0,
+	       unsigned char  short_op1,
+	       unsigned char  short_op2,
+	       unsigned char  near_valid,
+	       unsigned char  near_opcode_len,
+	       unsigned char  near_op0,
+	       unsigned char  near_op1,
+	       unsigned char  near_op2,
+	       unsigned char  addrsize)
 {
     bc->next = (bytecode *)NULL;
     bc->type = BC_JMPREL;
@@ -310,13 +312,13 @@ BuildBC_JmpRel (bytecode      *bc,
     bc->data.jmprel.target = target->val;
     bc->data.jmprel.op_sel = target->op_sel;
 
-    if((target->op_sel == JR_SHORT_FORCED) && (!short_valid))
+    if ((target->op_sel == JR_SHORT_FORCED) && (!short_valid))
 	Error(ERR_NO_JMPREL_FORM, (char *)NULL, "SHORT");
-    if((target->op_sel == JR_NEAR_FORCED) && (!near_valid))
+    if ((target->op_sel == JR_NEAR_FORCED) && (!near_valid))
 	Error(ERR_NO_JMPREL_FORM, (char *)NULL, "NEAR");
 
     bc->data.jmprel.shortop.valid = short_valid;
-    if(short_valid) {
+    if (short_valid) {
 	bc->data.jmprel.shortop.opcode[0] = short_op0;
 	bc->data.jmprel.shortop.opcode[1] = short_op1;
 	bc->data.jmprel.shortop.opcode[2] = short_op2;
@@ -324,7 +326,7 @@ BuildBC_JmpRel (bytecode      *bc,
     }
 
     bc->data.jmprel.nearop.valid = near_valid;
-    if(near_valid) {
+    if (near_valid) {
 	bc->data.jmprel.nearop.opcode[0] = near_op0;
 	bc->data.jmprel.nearop.opcode[1] = near_op1;
 	bc->data.jmprel.nearop.opcode[2] = near_op2;
@@ -339,9 +341,7 @@ BuildBC_JmpRel (bytecode      *bc,
 }
 
 void
-BuildBC_Data (bytecode      *bc,
-	      dataval       *data,
-	      unsigned long  size)
+BuildBC_Data(bytecode *bc, dataval *data, unsigned long size)
 {
     dataval *cur = data;
 
@@ -359,20 +359,20 @@ BuildBC_Data (bytecode      *bc,
      * constants (equ's) should always be legal, but labels should raise
      * warnings when used in db or dq context at the minimum).
      */
-    while(cur) {
-	switch(cur->type) {
+    while (cur) {
+	switch (cur->type) {
 	    case DV_EMPTY:
 	    case DV_STRING:
 		/* string is valid in every size */
 		break;
 	    case DV_FLOAT:
-		if(size == 1)
+		if (size == 1)
 		    Error(ERR_DECLDATA_FLOAT, (char *)NULL, "DB");
-		else if(size == 2)
+		else if (size == 2)
 		    Error(ERR_DECLDATA_FLOAT, (char *)NULL, "DW");
 		break;
 	    case DV_EXPR:
-		if(size == 10)
+		if (size == 10)
 		    Error(ERR_DECLDATA_EXPR, (char *)NULL, "DT");
 		break;
 	}
@@ -389,9 +389,7 @@ BuildBC_Data (bytecode      *bc,
 }
 
 void
-BuildBC_Reserve (bytecode      *bc,
-		 expr          *numitems,
-		 unsigned long  itemsize)
+BuildBC_Reserve(bytecode *bc, expr *numitems, unsigned long itemsize)
 {
     bc->next = (bytecode *)NULL;
     bc->type = BC_RESERVE;
@@ -403,9 +401,9 @@ BuildBC_Reserve (bytecode      *bc,
 }
 
 void
-DebugPrintBC (bytecode *bc)
+DebugPrintBC(bytecode *bc)
 {
-    switch(bc->type) {
+    switch (bc->type) {
 	case BC_EMPTY:
 	    printf("_Empty_\n");
 	    break;
@@ -418,17 +416,17 @@ DebugPrintBC (bytecode *bc)
 	    else
 		expr_print(bc->data.insn.ea.disp);
 	    printf("\n");
-	    printf (" Len=%u SegmentOv=%2x\n",
-		(unsigned int)bc->data.insn.ea.len,
-		(unsigned int)bc->data.insn.ea.segment);
+	    printf(" Len=%u SegmentOv=%2x\n",
+		   (unsigned int)bc->data.insn.ea.len,
+		   (unsigned int)bc->data.insn.ea.segment);
 	    printf(" ModRM=%2x ValidRM=%u NeedRM=%u\n",
-		(unsigned int)bc->data.insn.ea.modrm,
-		(unsigned int)bc->data.insn.ea.valid_modrm,
-		(unsigned int)bc->data.insn.ea.need_modrm);
+		   (unsigned int)bc->data.insn.ea.modrm,
+		   (unsigned int)bc->data.insn.ea.valid_modrm,
+		   (unsigned int)bc->data.insn.ea.need_modrm);
 	    printf(" SIB=%2x ValidSIB=%u NeedSIB=%u\n",
-		(unsigned int)bc->data.insn.ea.sib,
-		(unsigned int)bc->data.insn.ea.valid_sib,
-		(unsigned int)bc->data.insn.ea.need_sib);
+		   (unsigned int)bc->data.insn.ea.sib,
+		   (unsigned int)bc->data.insn.ea.valid_sib,
+		   (unsigned int)bc->data.insn.ea.need_sib);
 	    printf("Immediate Value:\n");
 	    printf(" Val=");
 	    if (!bc->data.insn.imm.val)
@@ -437,60 +435,72 @@ DebugPrintBC (bytecode *bc)
 		expr_print(bc->data.insn.imm.val);
 	    printf("\n");
 	    printf(" Len=%u, IsNeg=%u\n",
-		(unsigned int)bc->data.insn.imm.len,
-		(unsigned int)bc->data.insn.imm.isneg);
+		   (unsigned int)bc->data.insn.imm.len,
+		   (unsigned int)bc->data.insn.imm.isneg);
 	    printf(" FLen=%u, FSign=%u\n",
-		(unsigned int)bc->data.insn.imm.f_len,
-		(unsigned int)bc->data.insn.imm.f_sign);
+		   (unsigned int)bc->data.insn.imm.f_len,
+		   (unsigned int)bc->data.insn.imm.f_sign);
 	    printf("Opcode: %2x %2x %2x OpLen=%u\n",
-		(unsigned int)bc->data.insn.opcode[0],
-		(unsigned int)bc->data.insn.opcode[1],
-		(unsigned int)bc->data.insn.opcode[2],
-		(unsigned int)bc->data.insn.opcode_len);
+		   (unsigned int)bc->data.insn.opcode[0],
+		   (unsigned int)bc->data.insn.opcode[1],
+		   (unsigned int)bc->data.insn.opcode[2],
+		   (unsigned int)bc->data.insn.opcode_len);
 	    printf("AddrSize=%u OperSize=%u LockRepPre=%2x\n",
-		(unsigned int)bc->data.insn.addrsize,
-		(unsigned int)bc->data.insn.opersize,
-		(unsigned int)bc->data.insn.lockrep_pre);
+		   (unsigned int)bc->data.insn.addrsize,
+		   (unsigned int)bc->data.insn.opersize,
+		   (unsigned int)bc->data.insn.lockrep_pre);
 	    break;
 	case BC_JMPREL:
 	    printf("_Relative Jump_\n");
 	    printf("Target=");
 	    expr_print(bc->data.jmprel.target);
 	    printf("\nShort Form:\n");
-	    if(!bc->data.jmprel.shortop.valid)
+	    if (!bc->data.jmprel.shortop.valid)
 		printf(" None\n");
 	    else
 		printf(" Opcode: %2x %2x %2x OpLen=%u\n",
-		    (unsigned int)bc->data.jmprel.shortop.opcode[0],
-		    (unsigned int)bc->data.jmprel.shortop.opcode[1],
-		    (unsigned int)bc->data.jmprel.shortop.opcode[2],
-		    (unsigned int)bc->data.jmprel.shortop.opcode_len);
-	    if(!bc->data.jmprel.nearop.valid)
+		       (unsigned int)bc->data.jmprel.shortop.opcode[0],
+		       (unsigned int)bc->data.jmprel.shortop.opcode[1],
+		       (unsigned int)bc->data.jmprel.shortop.opcode[2],
+		       (unsigned int)bc->data.jmprel.shortop.opcode_len);
+	    if (!bc->data.jmprel.nearop.valid)
 		printf(" None\n");
 	    else
 		printf(" Opcode: %2x %2x %2x OpLen=%u\n",
-		    (unsigned int)bc->data.jmprel.nearop.opcode[0],
-		    (unsigned int)bc->data.jmprel.nearop.opcode[1],
-		    (unsigned int)bc->data.jmprel.nearop.opcode[2],
-		    (unsigned int)bc->data.jmprel.nearop.opcode_len);
+		       (unsigned int)bc->data.jmprel.nearop.opcode[0],
+		       (unsigned int)bc->data.jmprel.nearop.opcode[1],
+		       (unsigned int)bc->data.jmprel.nearop.opcode[2],
+		       (unsigned int)bc->data.jmprel.nearop.opcode_len);
 	    printf("OpSel=");
-	    switch(bc->data.jmprel.op_sel) {
-		case JR_NONE:		printf("None"); break;
-		case JR_SHORT:		printf("Short"); break;
-		case JR_NEAR:		printf("Near"); break;
-		case JR_SHORT_FORCED:	printf("Forced Short"); break;
-		case JR_NEAR_FORCED:	printf("Forced Near"); break;
-		default:		printf("UNKNOWN!!"); break;
+	    switch (bc->data.jmprel.op_sel) {
+		case JR_NONE:
+		    printf("None");
+		    break;
+		case JR_SHORT:
+		    printf("Short");
+		    break;
+		case JR_NEAR:
+		    printf("Near");
+		    break;
+		case JR_SHORT_FORCED:
+		    printf("Forced Short");
+		    break;
+		case JR_NEAR_FORCED:
+		    printf("Forced Near");
+		    break;
+		default:
+		    printf("UNKNOWN!!");
+		    break;
 	    }
 	    printf("\nAddrSize=%u OperSize=%u LockRepPre=%2x\n",
-		(unsigned int)bc->data.jmprel.addrsize,
-		(unsigned int)bc->data.jmprel.opersize,
-		(unsigned int)bc->data.jmprel.lockrep_pre);
+		   (unsigned int)bc->data.jmprel.addrsize,
+		   (unsigned int)bc->data.jmprel.opersize,
+		   (unsigned int)bc->data.jmprel.lockrep_pre);
 	    break;
 	case BC_DATA:
 	    printf("_Data_\n");
 	    printf("Final Element Size=%u\n",
-		(unsigned int)bc->data.data.size);
+		   (unsigned int)bc->data.data.size);
 	    printf("Elements:\n");
 	    dataval_print(bc->data.data.data);
 	    break;
@@ -499,23 +509,23 @@ DebugPrintBC (bytecode *bc)
 	    printf("Num Items=");
 	    expr_print(bc->data.reserve.numitems);
 	    printf("\nItem Size=%u\n",
-		(unsigned int)bc->data.reserve.itemsize);
+		   (unsigned int)bc->data.reserve.itemsize);
 	    break;
 	default:
 	    printf("_Unknown_\n");
     }
     printf("Length=%lu\n", bc->len);
     printf("Filename=\"%s\" Line Number=%u\n",
-	bc->filename ? bc->filename : "<UNKNOWN>", bc->lineno);
+	   bc->filename ? bc->filename : "<UNKNOWN>", bc->lineno);
     printf("Offset=%lx BITS=%u\n", bc->offset, bc->mode_bits);
 }
 
 dataval *
-dataval_new_expr (expr *exp)
+dataval_new_expr(expr *exp)
 {
     dataval *retval = malloc(sizeof(dataval));
 
-    if(!retval)
+    if (!retval)
 	Fatal(FATAL_NOMEM);
 
     retval->next = (dataval *)NULL;
@@ -527,11 +537,11 @@ dataval_new_expr (expr *exp)
 }
 
 dataval *
-dataval_new_float (double float_val)
+dataval_new_float(double float_val)
 {
     dataval *retval = malloc(sizeof(dataval));
 
-    if(!retval)
+    if (!retval)
 	Fatal(FATAL_NOMEM);
 
     retval->next = (dataval *)NULL;
@@ -543,11 +553,11 @@ dataval_new_float (double float_val)
 }
 
 dataval *
-dataval_new_string (char *str_val)
+dataval_new_string(char *str_val)
 {
     dataval *retval = malloc(sizeof(dataval));
 
-    if(!retval)
+    if (!retval)
 	Fatal(FATAL_NOMEM);
 
     retval->next = (dataval *)NULL;
@@ -559,16 +569,16 @@ dataval_new_string (char *str_val)
 }
 
 dataval *
-dataval_append (dataval *list, dataval *item)
+dataval_append(dataval *list, dataval *item)
 {
-    if(item)
+    if (item)
 	item->next = (dataval *)NULL;
 
-    if(!list) {
+    if (!list) {
 	item->last = item;
 	return item;
     } else {
-	if(item) {
+	if (item) {
 	    list->last->next = item;
 	    list->last = item;
 	    item->last = (dataval *)NULL;
@@ -578,12 +588,12 @@ dataval_append (dataval *list, dataval *item)
 }
 
 void
-dataval_print (dataval *start)
+dataval_print(dataval *start)
 {
     dataval *cur = start;
 
-    while(cur) {
-	switch(cur->type) {
+    while (cur) {
+	switch (cur->type) {
 	    case DV_EMPTY:
 		printf(" Empty\n");
 		break;
@@ -603,4 +613,3 @@ dataval_print (dataval *start)
 	cur = cur->next;
     }
 }
-
diff --git a/src/bytecode.h b/src/bytecode.h
index fafb3b44..f6874c01 100644
--- a/src/bytecode.h
+++ b/src/bytecode.h
@@ -1,4 +1,4 @@
-/* $Id: bytecode.h,v 1.15 2001/07/25 00:33:10 peter Exp $
+/* $Id: bytecode.h,v 1.16 2001/08/19 03:52:58 peter Exp $
  * Bytecode utility functions header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -80,9 +80,9 @@ typedef struct bytecode_s {
 
     union {
 	struct {
-	    effaddr ea;			/* effective address */
+	    effaddr ea;		/* effective address */
 
-	    immval imm;			/* immediate or relative value */
+	    immval imm;		/* immediate or relative value */
 
 	    unsigned char opcode[3];	/* opcode */
 	    unsigned char opcode_len;
@@ -109,7 +109,7 @@ typedef struct bytecode_s {
 	    unsigned char lockrep_pre;	/* 0 indicates no prefix */
 	} jmprel;
 	struct {
-	    dataval *data;		/* non-converted data (linked list) */
+	    dataval *data;	/* non-converted data (linked list) */
 
 	    /* final (converted) size of each element (in bytes) */
 	    unsigned char size;
@@ -120,7 +120,7 @@ typedef struct bytecode_s {
 	} reserve;
     } data;
 
-    unsigned long len;	/* total length of entire bytecode */
+    unsigned long len;		/* total length of entire bytecode */
 
     /* where it came from */
     char *filename;
@@ -173,9 +173,7 @@ void BuildBC_JmpRel(bytecode      *bc,
 		    unsigned char  near_op2,
 		    unsigned char  addrsize);
 
-void BuildBC_Data(bytecode      *bc,
-		  dataval       *data,
-		  unsigned long  size);
+void BuildBC_Data(bytecode *bc, dataval *data, unsigned long size);
 
 void BuildBC_Reserve(bytecode      *bc,
 		     struct expr_s *numitems,
diff --git a/src/errwarn.c b/src/errwarn.c
index 1b2e818b..30cddbd2 100644
--- a/src/errwarn.c
+++ b/src/errwarn.c
@@ -1,4 +1,4 @@
-/* $Id: errwarn.c,v 1.19 2001/08/18 23:05:37 peter Exp $
+/* $Id: errwarn.c,v 1.20 2001/08/19 03:52:58 peter Exp $
  * Error and warning reporting and related functions.
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -112,16 +112,16 @@ static char unprint[5];
 /* Convert a possibly unprintable character into a printable string, using
  * standard cat(1) convention for unprintable characters. */
 char *
-conv_unprint (char ch)
+conv_unprint(char ch)
 {
-    int pos=0;
+    int pos = 0;
 
-    if(((ch & ~0x7F) != 0)/*!isascii(ch)*/ && !isprint(ch)) {
+    if (((ch & ~0x7F) != 0) /*!isascii(ch)*/ && !isprint(ch)) {
 	unprint[pos++] = 'M';
 	unprint[pos++] = '-';
 	ch &= toascii(ch);
     }
-    if(iscntrl(ch)) {
+    if (iscntrl(ch)) {
 	unprint[pos++] = '^';
 	unprint[pos++] = (ch == '\177') ? '?' : ch | 0100;
     } else
@@ -133,7 +133,7 @@ conv_unprint (char ch)
 
 /* Parser error handler.  Moves error into our error handling system. */
 void
-yyerror (char *s)
+yyerror(char *s)
 {
     Error(ERR_PARSER, (char *)NULL, s);
 }
@@ -141,17 +141,17 @@ yyerror (char *s)
 /* Report an internal error.  Essentially a fatal error with trace info.
  * Exit immediately because it's essentially an assert() trap. */
 void
-InternalError (unsigned int line, char *file, char *message)
+InternalError(unsigned int line, char *file, char *message)
 {
     fprintf(stderr, "INTERNAL ERROR at %s, line %d: %s\n", file, line,
-	message);
+	    message);
     exit(EXIT_FAILURE);
 }
 
 /* Report a fatal error.  These are unrecoverable (such as running out of
  * memory), so just exit immediately. */
 void
-Fatal (fatal_num num)
+Fatal(fatal_num num)
 {
     fprintf(stderr, "FATAL: %s\n", fatal_msgs[num]);
     exit(EXIT_FAILURE);
@@ -183,31 +183,31 @@ Fatal (fatal_num num)
  * specified and NULL passed for the argtypes parameter when Error() is
  * called. */
 static char *
-process_argtypes (char *src, char *argtypes)
+process_argtypes(char *src, char *argtypes)
 {
     char *dest;
     char *argtype[9];
     int at_num;
     char *destp, *srcp, *argtypep;
 
-    if(argtypes) {
+    if (argtypes) {
 	dest = malloc(strlen(src) + strlen(argtypes));
-	if(!dest)
+	if (!dest)
 	    Fatal(FATAL_NOMEM);
 	/* split argtypes by % */
 	at_num = 0;
-	while((argtypes = strchr(argtypes, '%')) && at_num < 9)
+	while ((argtypes = strchr(argtypes, '%')) && at_num < 9)
 	    argtype[at_num++] = ++argtypes;
 	/* search through src for %, copying as we go */
 	destp = dest;
 	srcp = src;
-	while(*srcp != '\0') {
+	while (*srcp != '\0') {
 	    *(destp++) = *srcp;
-	    if(*(srcp++) == '%') {
-		if(isdigit(*srcp)) {
+	    if (*(srcp++) == '%') {
+		if (isdigit(*srcp)) {
 		    /* %1, %2, etc */
-		    argtypep = argtype[*srcp-'1'];
-		    while((*argtypep != '%') && (*argtypep != '\0'))
+		    argtypep = argtype[*srcp - '1'];
+		    while ((*argtypep != '%') && (*argtypep != '\0'))
 			*(destp++) = *(argtypep++);
 		} else
 		    *(destp++) = *srcp;
@@ -216,7 +216,7 @@ process_argtypes (char *src, char *argtypes)
 	}
     } else {
 	dest = strdup(src);
-	if(!dest)
+	if (!dest)
 	    Fatal(FATAL_NOMEM);
     }
     return dest;
@@ -226,12 +226,12 @@ process_argtypes (char *src, char *argtypes)
  * argument types.  Does not print the error, only stores it for
  * OutputError() to print. */
 void
-Error (err_num num, char *argtypes, ...)
+Error(err_num num, char *argtypes, ...)
 {
     va_list ap;
     char *printf_str;
 
-    if((last_err_num != ERR_NONE) && (last_err_num != ERR_PARSER))
+    if ((last_err_num != ERR_NONE) && (last_err_num != ERR_PARSER))
 	return;
 
     last_err_num = num;
@@ -251,12 +251,12 @@ Error (err_num num, char *argtypes, ...)
  * argument types.  Does not print the warning, only stores it for
  * OutputWarning() to print. */
 void
-Warning (warn_num num, char *argtypes, ...)
+Warning(warn_num num, char *argtypes, ...)
 {
     va_list ap;
     char *printf_str;
 
-    if(last_warn_num != WARN_NONE)
+    if (last_warn_num != WARN_NONE)
 	return;
 
     last_warn_num = num;
@@ -274,20 +274,19 @@ Warning (warn_num num, char *argtypes, ...)
 
 /* Output a previously stored error (if any) to stderr. */
 void
-OutputError (void)
+OutputError(void)
 {
-    if(last_err_num != ERR_NONE)
+    if (last_err_num != ERR_NONE)
 	fprintf(stderr, "%s:%u: %s\n", filename, line_number, last_err);
     last_err_num = ERR_NONE;
 }
 
 /* Output a previously stored warning (if any) to stderr. */
 void
-OutputWarning (void)
+OutputWarning(void)
 {
-    if(last_warn_num != WARN_NONE)
+    if (last_warn_num != WARN_NONE)
 	fprintf(stderr, "%s:%u: warning: %s\n", filename, line_number,
-	    last_warn);
+		last_warn);
     last_warn_num = WARN_NONE;
 }
-
diff --git a/src/expr.c b/src/expr.c
index 627b2a4e..1b0248f7 100644
--- a/src/expr.c
+++ b/src/expr.c
@@ -1,4 +1,4 @@
-/* $Id: expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Expression handling
  *
  *  Copyright (C) 2001  Michael Urman
@@ -30,36 +30,36 @@
 /* allocate a new expression node, with children as defined.
  * If it's a unary operator, put the element on the right */
 expr *
-expr_new (ExprType ltype,
-	  ExprItem left,
-	  ExprOp   op,
-	  ExprType rtype,
-	  ExprItem right)
+expr_new(ExprType ltype,
+	 ExprItem left,
+	 ExprOp   op,
+	 ExprType rtype,
+	 ExprItem right)
 {
     expr *ptr;
-    ptr = malloc (sizeof (expr));
-    if (ptr == NULL) Fatal (FATAL_NOMEM);
+    ptr = malloc(sizeof(expr));
+    if (ptr == NULL)
+	Fatal(FATAL_NOMEM);
     ptr->ltype = ltype;
     ptr->op = op;
     ptr->rtype = rtype;
-    switch (ltype)
-    {
+    switch (ltype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->left, &left, sizeof (ExprItem));
+	    memcpy(&ptr->left, &left, sizeof(ExprItem));
+	    break;
+	case EXPR_NONE:
 	    break;
-	case EXPR_NONE: break;
     }
-    switch (rtype)
-    {
+    switch (rtype) {
 	case EXPR_NUM:
 	case EXPR_SYM:
 	case EXPR_EXPR:
-	    memcpy (&ptr->right, &right, sizeof (ExprItem));
+	    memcpy(&ptr->right, &right, sizeof(ExprItem));
 	    break;
 	case EXPR_NONE:
-	    Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+	    Fatal(FATAL_UNKNOWN);	/* TODO: better error? */
 	    break;
     }
     return ptr;
@@ -67,68 +67,67 @@ expr_new (ExprType ltype,
 
 /* helpers */
 ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
 {
     ExprItem e;
+
     e.sym = s;
     return e;
 }
 
 ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
 {
     ExprItem e;
     e.expr = x;
+
     return e;
 }
 
 ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
 {
     ExprItem e;
+
     e.num = n;
     return e;
 }
 
 ExprItem
-ExprNone (void)
+ExprNone(void)
 {
     ExprItem e;
+
     e.num = 0;
     return e;
 }
 
 /* get rid of unnecessary branches if possible.  report. */
 int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
 {
     int simplified = 0;
 
     /* try to simplify the left side */
-    if (e->ltype == EXPR_EXPR)
-    {
+    if (e->ltype == EXPR_EXPR) {
 	/* if the left subexpr isn't an IDENT, recurse simplification */
 	if (e->left.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->left.expr);
+	    simplified |= expr_simplify(e->left.expr);
 
 	/* if the left subexpr is just an IDENT (or string thereof),
 	 * pull it up into the current node */
-	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
-	{
+	while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->ltype = e->left.expr->rtype;
-	    memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
-	    free (e->left.expr);
-	    memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+	    free(e->left.expr);
+	    memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->ltype == EXPR_SYM)
-    {
+    } else if (e->ltype == EXPR_SYM) {
 	/* if it's a symbol that has a defined value, turn it into a
 	 * number */
-	if (e->left.sym->status & SYM_VALUED)
-	{
+	if (e->left.sym->status & SYM_VALUED) {
 	    e->ltype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->left.num = e->left.sym->value;
@@ -137,25 +136,20 @@ expr_simplify (expr *e)
     }
 
     /* ditto on the right */
-    if (e->rtype == EXPR_EXPR)
-    {
+    if (e->rtype == EXPR_EXPR) {
 	if (e->right.expr->op != EXPR_IDENT)
-	    simplified |= expr_simplify (e->right.expr);
+	    simplified |= expr_simplify(e->right.expr);
 
-	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
-	{
+	while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
 	    ExprItem tmp;
 	    e->rtype = e->right.expr->rtype;
-	    memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
-	    free (e->right.expr);
-	    memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+	    memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+	    free(e->right.expr);
+	    memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
 	    simplified = 1;
 	}
-    }
-    else if (e->rtype == EXPR_SYM)
-    {
-	if (e->right.sym->status & SYM_VALUED)
-	{
+    } else if (e->rtype == EXPR_SYM) {
+	if (e->right.sym->status & SYM_VALUED) {
 	    e->rtype = EXPR_NUM;
 	    /* don't try to free the symrec here. */
 	    e->right.num = e->right.sym->value;
@@ -164,62 +158,108 @@ expr_simplify (expr *e)
     }
 
     if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
-	&& e->rtype == EXPR_NUM
-	&& e->op != EXPR_IDENT)
-    {
-	switch (e->op)
-	{
-	    case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
-	    case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
-	    case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
-	    case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
-	    case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
-	    case EXPR_NEG: e->right.num = -(e->right.num); break;
-	    case EXPR_NOT: e->right.num = ~(e->right.num); break;
-	    case EXPR_OR:  e->right.num = e->left.num | e->right.num; break;
-	    case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
-	    case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
-	    case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
-	    case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
-	    case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
-	    case EXPR_LNOT: e->right.num = !e->right.num; break;
-	    case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
-	    case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
-	    case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
-	    case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
-	    case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
-	    case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
-	    case EXPR_IDENT: break;
+	&& e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+	switch (e->op) {
+	    case EXPR_ADD:
+		e->right.num = e->left.num + e->right.num;
+		break;
+	    case EXPR_SUB:
+		e->right.num = e->left.num - e->right.num;
+		break;
+	    case EXPR_MUL:
+		e->right.num = e->left.num * e->right.num;
+		break;
+	    case EXPR_DIV:
+		e->right.num = e->left.num / e->right.num;
+		break;
+	    case EXPR_MOD:
+		e->right.num = e->left.num % e->right.num;
+		break;
+	    case EXPR_NEG:
+		e->right.num = -(e->right.num);
+		break;
+	    case EXPR_NOT:
+		e->right.num = ~(e->right.num);
+		break;
+	    case EXPR_OR:
+		e->right.num = e->left.num | e->right.num;
+		break;
+	    case EXPR_AND:
+		e->right.num = e->left.num & e->right.num;
+		break;
+	    case EXPR_XOR:
+		e->right.num = e->left.num ^ e->right.num;
+		break;
+	    case EXPR_SHL:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_SHR:
+		e->right.num = e->right.num << e->left.num;
+		break;
+	    case EXPR_LOR:
+		e->right.num = e->left.num || e->right.num;
+		break;
+	    case EXPR_LAND:
+		e->right.num = e->left.num && e->right.num;
+		break;
+	    case EXPR_LNOT:
+		e->right.num = !e->right.num;
+		break;
+	    case EXPR_EQ:
+		e->right.num = e->right.num == e->left.num;
+		break;
+	    case EXPR_LT:
+		e->right.num = e->right.num < e->left.num;
+		break;
+	    case EXPR_GT:
+		e->right.num = e->right.num > e->left.num;
+		break;
+	    case EXPR_LE:
+		e->right.num = e->right.num <= e->left.num;
+		break;
+	    case EXPR_GE:
+		e->right.num = e->right.num >= e->left.num;
+		break;
+	    case EXPR_NE:
+		e->right.num = e->right.num != e->left.num;
+		break;
+	    case EXPR_IDENT:
+		break;
 	}
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
 
     /* catch simple identities like 0+x, 1*x, etc., for x not a num */
-    else if (e->ltype == EXPR_NUM
-	     && ((e->left.num == 1 && e->op == EXPR_MUL)
-		 ||(e->left.num == 0 && e->op == EXPR_ADD)
-		 ||(e->left.num == -1 && e->op == EXPR_AND)
-		 ||(e->left.num == 0 && e->op == EXPR_OR)))
-    {
+    else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->left.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->left.num == 0 &&
+					  e->op == EXPR_OR))) {
 	e->op = EXPR_IDENT;
 	simplified = 1;
     }
     /* and the corresponding x+|-0, x*&/1 */
-    else if (e->rtype == EXPR_NUM
-	     && ((e->right.num == 1 && e->op == EXPR_MUL)
-		 ||(e->right.num == 1 && e->op == EXPR_DIV)
-		 ||(e->right.num == 0 && e->op == EXPR_ADD)
-		 ||(e->right.num == 0 && e->op == EXPR_SUB)
-		 ||(e->right.num == -1 && e->op == EXPR_AND)
-		 ||(e->right.num == 0 && e->op == EXPR_OR)
-		 ||(e->right.num == 0 && e->op == EXPR_SHL)
-		 ||(e->right.num == 0 && e->op == EXPR_SHR)))
-    {
+    else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+				      || (e->right.num == 1 &&
+					  e->op == EXPR_DIV)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_ADD)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SUB)
+				      || (e->right.num == -1 &&
+					  e->op == EXPR_AND)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_OR)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHL)
+				      || (e->right.num == 0 &&
+					  e->op == EXPR_SHR))) {
 	e->op = EXPR_IDENT;
 	e->rtype = e->ltype;
-	memcpy (&e->right, &e->left, sizeof (ExprItem));
+	memcpy(&e->right, &e->left, sizeof(ExprItem));
 	simplified = 1;
     }
 
@@ -227,59 +267,118 @@ expr_simplify (expr *e)
 }
 
 int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
 {
     while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-	   && expr_simplify (e));
+	   && expr_simplify(e)) ;
 
-    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
-    {
+    if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
 	*retval = e->right.num;
 	return 1;
-    }
-    else
+    } else
 	return 0;
 }
 
 void
-expr_print (expr *e)
+expr_print(expr *e)
 {
     if (e->op != EXPR_IDENT) {
 	switch (e->ltype) {
-	    case EXPR_NUM: printf ("%lu", e->left.num); break;
-	    case EXPR_SYM: printf ("%s", e->left.sym->name); break;
-	    case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
-	    case EXPR_NONE: break;
+	    case EXPR_NUM:
+		printf("%lu", e->left.num);
+		break;
+	    case EXPR_SYM:
+		printf("%s", e->left.sym->name);
+		break;
+	    case EXPR_EXPR:
+		printf("(");
+		expr_print(e->left.expr);
+
+		printf(")");
+	    case EXPR_NONE:
+		break;
 	}
     }
     switch (e->op) {
-	case EXPR_ADD: printf ("+"); break;
-	case EXPR_SUB: printf ("-"); break;
-	case EXPR_MUL: printf ("*"); break;
-	case EXPR_DIV: printf ("/"); break;
-	case EXPR_MOD: printf ("%%"); break;
-	case EXPR_NEG: printf ("-"); break;
-	case EXPR_NOT: printf ("~"); break;
-	case EXPR_OR: printf ("|"); break;
-	case EXPR_AND: printf ("&"); break;
-	case EXPR_XOR: printf ("^"); break;
-	case EXPR_SHL: printf ("<<"); break;
-	case EXPR_SHR: printf (">>"); break;
-	case EXPR_LOR: printf ("||"); break;
-	case EXPR_LAND: printf ("&&"); break;
-	case EXPR_LNOT: printf ("!"); break;
-	case EXPR_LT: printf ("<"); break;
-	case EXPR_GT: printf (">"); break;
-	case EXPR_LE: printf ("<="); break;
-	case EXPR_GE: printf (">="); break;
-	case EXPR_NE: printf ("!="); break;
-	case EXPR_EQ: printf ("=="); break;
-	case EXPR_IDENT: break;
+	case EXPR_ADD:
+	    printf("+");
+	    break;
+	case EXPR_SUB:
+	    printf("-");
+	    break;
+	case EXPR_MUL:
+	    printf("*");
+	    break;
+	case EXPR_DIV:
+	    printf("/");
+	    break;
+	case EXPR_MOD:
+	    printf("%%");
+	    break;
+	case EXPR_NEG:
+	    printf("-");
+	    break;
+	case EXPR_NOT:
+	    printf("~");
+	    break;
+	case EXPR_OR:
+	    printf("|");
+	    break;
+	case EXPR_AND:
+	    printf("&");
+	    break;
+	case EXPR_XOR:
+	    printf("^");
+	    break;
+	case EXPR_SHL:
+	    printf("<<");
+	    break;
+	case EXPR_SHR:
+	    printf(">>");
+	    break;
+	case EXPR_LOR:
+	    printf("||");
+	    break;
+	case EXPR_LAND:
+	    printf("&&");
+	    break;
+	case EXPR_LNOT:
+	    printf("!");
+	    break;
+	case EXPR_LT:
+	    printf("<");
+	    break;
+	case EXPR_GT:
+	    printf(">");
+	    break;
+	case EXPR_LE:
+	    printf("<=");
+	    break;
+	case EXPR_GE:
+	    printf(">=");
+	    break;
+	case EXPR_NE:
+	    printf("!=");
+	    break;
+	case EXPR_EQ:
+	    printf("==");
+	    break;
+	case EXPR_IDENT:
+	    break;
     }
     switch (e->rtype) {
-	case EXPR_NUM: printf ("%lu", e->right.num); break;
-	case EXPR_SYM: printf ("%s", e->right.sym->name); break;
-	case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
-	case EXPR_NONE: break;
+	case EXPR_NUM:
+	    printf("%lu", e->right.num);
+	    break;
+	case EXPR_SYM:
+	    printf("%s", e->right.sym->name);
+	    break;
+	case EXPR_EXPR:
+	    printf("(");
+	    expr_print(e->right.expr);
+
+	    printf(")");
+	case EXPR_NONE:
+	    break;
     }
 }
diff --git a/src/expr.h b/src/expr.h
index 2f0188b2..943ad514 100644
--- a/src/expr.h
+++ b/src/expr.h
@@ -1,4 +1,4 @@
-/* $Id: expr.h,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.h,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Expression handling header file
  *
  *  Copyright (C) 2001  Michael Urman
@@ -44,11 +44,11 @@ typedef enum {
     EXPR_LE,
     EXPR_GE,
     EXPR_NE,
-    EXPR_IDENT	    /* if right is IDENT, then the entire expr is just a num */
+    EXPR_IDENT			/* if right is IDENT, then the entire expr is just a num */
 } ExprOp;
 
 typedef enum {
-    EXPR_NONE,	    /* for left side of a NOT, NEG, etc. */
+    EXPR_NONE,			/* for left side of a NOT, NEG, etc. */
     EXPR_NUM,
     EXPR_EXPR,
     EXPR_SYM
@@ -66,12 +66,12 @@ typedef struct expr_s {
     ExprOp op;
 } expr;
 
-expr *expr_new (ExprType, ExprItem, ExprOp, ExprType, ExprItem);
+expr *expr_new(ExprType, ExprItem, ExprOp, ExprType, ExprItem);
 
-ExprItem ExprSym (struct symrec_s *);
-ExprItem ExprExpr (expr *);
-ExprItem ExprNum (unsigned long);
-ExprItem ExprNone (void);
+ExprItem ExprSym(struct symrec_s *);
+ExprItem ExprExpr(expr *);
+ExprItem ExprNum(unsigned long);
+ExprItem ExprNone(void);
 
 #define expr_new_tree(l,o,r) \
     expr_new (EXPR_EXPR, ExprExpr(l), (o), EXPR_EXPR, ExprExpr(r))
@@ -80,10 +80,10 @@ ExprItem ExprNone (void);
 #define expr_new_ident(t,r) \
     expr_new (EXPR_NONE, ExprNone(), EXPR_IDENT, (ExprType)(t), (r))
 
-int expr_simplify (expr *);
-void expr_print (expr *);
+int expr_simplify(expr *);
+void expr_print(expr *);
 
 /* get the value if possible.  return value is IF POSSIBLE, not the val */
-int expr_get_value (expr *, unsigned long *);
+int expr_get_value(expr *, unsigned long *);
 
 #endif
diff --git a/src/main.c b/src/main.c
index 20cd55e3..e5c9b535 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,4 +1,4 @@
-/* $Id: main.c,v 1.6 2001/08/19 02:15:18 peter Exp $
+/* $Id: main.c,v 1.7 2001/08/19 03:52:58 peter Exp $
  * Program entry point, command line parsing
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -33,13 +33,13 @@ unsigned int line_number = 1;
 unsigned int mode_bits = 32;
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
     FILE *in;
 
-    if(argc==2) {
+    if (argc == 2) {
 	in = fopen(argv[1], "rt");
-	if(!in) {
+	if (!in) {
 	    fprintf(stderr, "could not open file `%s'\n", argv[1]);
 	    return EXIT_FAILURE;
 	}
@@ -51,8 +51,7 @@ main (int argc, char *argv[])
 
     nasm_parser.doparse(&raw_preproc, &dbg_outfmt, in);
 
-    if(filename)
+    if (filename)
 	free(filename);
     return EXIT_SUCCESS;
 }
-
diff --git a/src/objfmt.h b/src/objfmt.h
index ab73f0ca..652276f3 100644
--- a/src/objfmt.h
+++ b/src/objfmt.h
@@ -1,4 +1,4 @@
-/* $Id: objfmt.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: objfmt.h,v 1.2 2001/08/19 03:52:58 peter Exp $
  * Output format module interface header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -24,8 +24,11 @@
 
 /* Interface to the output format module(s) */
 typedef struct outfmt_s {
-    char *name;		/* one-line description of the format */
-    char *keyword;	/* keyword used to select format on the command line */
+    /* one-line description of the format */
+    char *name;
+
+    /* keyword used to select format on the command line */
+    char *keyword;
 
     /* NULL-terminated list of debugging formats that are valid to use with
      * this output format.
diff --git a/src/outfmt.h b/src/outfmt.h
index eab7f6bd..bd090e75 100644
--- a/src/outfmt.h
+++ b/src/outfmt.h
@@ -1,4 +1,4 @@
-/* $Id: outfmt.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: outfmt.h,v 1.2 2001/08/19 03:52:58 peter Exp $
  * Output format module interface header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -24,8 +24,11 @@
 
 /* Interface to the output format module(s) */
 typedef struct outfmt_s {
-    char *name;		/* one-line description of the format */
-    char *keyword;	/* keyword used to select format on the command line */
+    /* one-line description of the format */
+    char *name;
+
+    /* keyword used to select format on the command line */
+    char *keyword;
 
     /* NULL-terminated list of debugging formats that are valid to use with
      * this output format.
diff --git a/src/parser.h b/src/parser.h
index 3416173c..f844643e 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -1,4 +1,4 @@
-/* $Id: parser.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: parser.h,v 1.2 2001/08/19 03:52:58 peter Exp $
  * Parser module interface header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -24,8 +24,11 @@
 
 /* Interface to the parser module(s) -- the "front end" of the assembler */
 typedef struct parser_s {
-    char *name;		/* one-line description of the parser */
-    char *keyword;	/* keyword used to select parser on the command line */
+    /* one-line description of the parser */
+    char *name;
+
+    /* keyword used to select parser on the command line */
+    char *keyword;
 
     /* NULL-terminated list of preprocessors that are valid to use with this
      * parser.  The raw preprocessor (raw_preproc) should always be in this
@@ -52,7 +55,7 @@ typedef struct parser_s {
      * Note that calling this has many side effects in the output format
      * module: sections and variables are declared, etc.
      */
-    section * (*doparse) (preproc *pp, outfmt *of, FILE *f);
+    section *(*doparse) (preproc *pp, outfmt *of, FILE *f);
 } parser;
 
 /* Available parsers */
diff --git a/src/preproc.h b/src/preproc.h
index a239dcf6..2e884fbd 100644
--- a/src/preproc.h
+++ b/src/preproc.h
@@ -1,4 +1,4 @@
-/* $Id: preproc.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: preproc.h,v 1.2 2001/08/19 03:52:58 peter Exp $
  * Preprocessor module interface header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -24,10 +24,11 @@
 
 /* Interface to the preprocesor module(s) */
 typedef struct preproc_s {
-    char *name;		/* one-line description of the preprocessor */
+    /* one-line description of the preprocessor */
+    char *name;
 
     /* keyword used to select preprocessor on the command line */
-    char *keyword;	
+    char *keyword;
 
     /* Initializes preprocessor.
      *
diff --git a/src/preprocs/raw/preproc.c b/src/preprocs/raw/preproc.c
index d04baf8c..5f163894 100644
--- a/src/preprocs/raw/preproc.c
+++ b/src/preprocs/raw/preproc.c
@@ -1,4 +1,4 @@
-/* $Id: preproc.c,v 1.2 2001/08/19 02:50:14 peter Exp $
+/* $Id: preproc.c,v 1.3 2001/08/19 03:52:58 peter Exp $
  * Raw preprocessor (preforms NO preprocessing)
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -41,14 +41,14 @@ input(char *buf, int max_size)
 {
     int c = '*', n;
 
-    if(is_interactive) {
-	for(n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
-	    buf[n] = (char) c;
-	if(c == '\n')
-	    buf[n++] = (char) c;
-	if(c == EOF && ferror(in))
+    if (is_interactive) {
+	for (n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
+	    buf[n] = (char)c;
+	if (c == '\n')
+	    buf[n++] = (char)c;
+	if (c == EOF && ferror(in))
 	    Error(ERR_FILE_READ, (char *)NULL);
-    } else if(((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
+    } else if (((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
 	Error(ERR_FILE_READ, (char *)NULL);
 
     return n;
diff --git a/src/preprocs/raw/raw-preproc.c b/src/preprocs/raw/raw-preproc.c
index 92a47648..ce70e2b4 100644
--- a/src/preprocs/raw/raw-preproc.c
+++ b/src/preprocs/raw/raw-preproc.c
@@ -1,4 +1,4 @@
-/* $Id: raw-preproc.c,v 1.2 2001/08/19 02:50:14 peter Exp $
+/* $Id: raw-preproc.c,v 1.3 2001/08/19 03:52:58 peter Exp $
  * Raw preprocessor (preforms NO preprocessing)
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -41,14 +41,14 @@ input(char *buf, int max_size)
 {
     int c = '*', n;
 
-    if(is_interactive) {
-	for(n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
-	    buf[n] = (char) c;
-	if(c == '\n')
-	    buf[n++] = (char) c;
-	if(c == EOF && ferror(in))
+    if (is_interactive) {
+	for (n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
+	    buf[n] = (char)c;
+	if (c == '\n')
+	    buf[n++] = (char)c;
+	if (c == EOF && ferror(in))
 	    Error(ERR_FILE_READ, (char *)NULL);
-    } else if(((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
+    } else if (((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
 	Error(ERR_FILE_READ, (char *)NULL);
 
     return n;
diff --git a/src/section.h b/src/section.h
index 83615e9f..fcfb1f13 100644
--- a/src/section.h
+++ b/src/section.h
@@ -1,4 +1,4 @@
-/* $Id: section.h,v 1.4 2001/08/19 02:54:20 peter Exp $
+/* $Id: section.h,v 1.5 2001/08/19 03:52:58 peter Exp $
  * Section header file
  *
  *  Copyright (C) 2001  Peter Johnson
@@ -36,7 +36,7 @@ typedef struct section_s {
 	unsigned long start;
     } data;
 
-    bytecode *bc;	/* the bytecodes for the section's contents */
+    bytecode *bc;		/* the bytecodes for the section's contents */
 } section;
 
 #endif
diff --git a/src/symrec.c b/src/symrec.c
index a7114323..445fc19d 100644
--- a/src/symrec.c
+++ b/src/symrec.c
@@ -1,4 +1,4 @@
-/* $Id: symrec.c,v 1.5 2001/07/11 23:16:50 peter Exp $
+/* $Id: symrec.c,v 1.6 2001/08/19 03:52:58 peter Exp $
  * Symbol table handling
  *
  *  Copyright (C) 2001  Michael Urman
@@ -26,17 +26,17 @@
 #include "errwarn.h"
 
 /* private functions */
-static symtab *symtab_get (char *);
-static symtab *symtab_new (char *, SymType);
-static symtab *symtab_get_or_new (char *, SymType);
-static void symtab_insert (symtab *);
+static symtab *symtab_get(char *);
+static symtab *symtab_new(char *, SymType);
+static symtab *symtab_get_or_new(char *, SymType);
+static void symtab_insert(symtab *);
 
 /* The symbol table: a chain of `symtab'. */
 symtab *sym_table = (symtab *)NULL;
 
 /* insert a symtab into the global sym_table */
 void
-symtab_insert (symtab *tab)
+symtab_insert(symtab *tab)
 {
     tab->next = (symtab *)sym_table;
     sym_table = tab;
@@ -44,13 +44,12 @@ symtab_insert (symtab *tab)
 
 /* find a symtab in the global sym_table */
 symtab *
-symtab_get (char *name)
+symtab_get(char *name)
 {
     symtab *tab;
-    for (tab = sym_table; tab != NULL; tab = tab->next)
-    {
-	if (strcmp (tab->rec.name, name) == 0)
-	{
+
+    for (tab = sym_table; tab != NULL; tab = tab->next) {
+	if (strcmp(tab->rec.name, name) == 0) {
 	    return tab;
 	}
     }
@@ -59,13 +58,12 @@ symtab_get (char *name)
 
 /* call a function with each symrec.  stop early if 0 returned */
 void
-sym_foreach (int(*mapfunc)(symrec *))
+sym_foreach(int (*mapfunc) (symrec *))
 {
     symtab *tab;
-    for (tab = sym_table; tab != NULL; tab = tab->next)
-    {
-	if (mapfunc(&(tab->rec)) == 0)
-	{
+
+    for (tab = sym_table; tab != NULL; tab = tab->next) {
+	if (mapfunc(&(tab->rec)) == 0) {
 	    return;
 	}
     }
@@ -73,15 +71,15 @@ sym_foreach (int(*mapfunc)(symrec *))
 
 /* create a new symtab */
 symtab *
-symtab_new (char *name, SymType type)
+symtab_new(char *name, SymType type)
 {
     symtab *tab;
     tab = malloc(sizeof(symtab));
-    if (tab == NULL) return NULL;
-    tab->rec.name = malloc(strlen(name)+1);
-    if (tab->rec.name == NULL)
-    {
-	free (tab);
+    if (tab == NULL)
+	return NULL;
+    tab->rec.name = malloc(strlen(name) + 1);
+    if (tab->rec.name == NULL) {
+	free(tab);
 	return NULL;
     }
     strcpy(tab->rec.name, name);
@@ -89,68 +87,70 @@ symtab_new (char *name, SymType type)
     tab->rec.value = 0;
     tab->rec.line = line_number;
     tab->rec.status = SYM_NOSTATUS;
-    symtab_insert (tab);
+    symtab_insert(tab);
     return tab;
 }
 
 symtab *
-symtab_get_or_new (char *name, SymType type)
+symtab_get_or_new(char *name, SymType type)
 {
     symtab *tab;
-    tab = symtab_get (name);
-    if (tab == NULL)
-    {
-	tab = symtab_new (name, type);
-	if (tab == NULL)
-	{
-	    Fatal (FATAL_NOMEM);
+
+    tab = symtab_get(name);
+    if (tab == NULL) {
+	tab = symtab_new(name, type);
+	if (tab == NULL) {
+	    Fatal(FATAL_NOMEM);
 	}
     }
     return tab;
 }
 
 symrec *
-sym_use_get (char *name, SymType type)
+sym_use_get(char *name, SymType type)
 {
     symtab *tab;
-    tab = symtab_get_or_new (name, type);
+
+    tab = symtab_get_or_new(name, type);
     tab->rec.status |= SYM_USED;
     return &(tab->rec);
 }
 
 symrec *
-sym_def_get (char *name, SymType type)
+sym_def_get(char *name, SymType type)
 {
     symtab *tab;
-    tab = symtab_get_or_new (name, type);
+
+    tab = symtab_get_or_new(name, type);
     if (tab->rec.status & SYM_DECLARED)
-	Error (ERR_DUPLICATE_DEF, "%s%d", tab->rec.name, tab->rec.line);
+	Error(ERR_DUPLICATE_DEF, "%s%d", tab->rec.name, tab->rec.line);
     tab->rec.status |= SYM_DECLARED;
     return &(tab->rec);
 }
 
 #if 0
 symrec *
-putsym (char *sym_name, int sym_type)
+putsym(char *sym_name, int sym_type)
 {
     symrec *ptr;
     ptr = malloc(sizeof(symrec));
-    ptr->name = malloc(strlen(sym_name)+1);
+    ptr->name = malloc(strlen(sym_name) + 1);
     strcpy(ptr->name, sym_name);
     ptr->type = sym_type;
-    ptr->value.var = 0; /* set value to 0 even if fctn.  */
+    ptr->value.var = 0;		/* set value to 0 even if fctn.  */
     ptr->next = (symrec *)sym_table;
     sym_table = ptr;
     return ptr;
 }
 
 symrec *
-getsym (char *sym_name)
+getsym(char *sym_name)
 {
     symrec *ptr;
-    for(ptr=sym_table; ptr != (symrec *)NULL; ptr=(symrec *)ptr->next)
-	if(strcmp(ptr->name, sym_name) == 0)
+
+    for (ptr = sym_table; ptr != (symrec *)NULL; ptr = (symrec *)ptr->next)
+	if (strcmp(ptr->name, sym_name) == 0)
 	    return ptr;
     return 0;
 }
-#endif /* 0 */
+#endif				/* 0 */
diff --git a/src/symrec.h b/src/symrec.h
index 4ef9bc1e..a672b6db 100644
--- a/src/symrec.h
+++ b/src/symrec.h
@@ -1,4 +1,4 @@
-/* $Id: symrec.h,v 1.5 2001/07/11 21:16:22 peter Exp $
+/* $Id: symrec.h,v 1.6 2001/08/19 03:52:58 peter Exp $
  * Symbol table handling header file
  *
  *  Copyright (C) 2001  Michael Urman
@@ -24,14 +24,14 @@
 
 typedef enum {
     SYM_NOSTATUS = 0,
-    SYM_USED	 = 1 << 0,  /* for using variables before declared */
-    SYM_DECLARED = 1 << 1,  /* once it's been declared */
-    SYM_VALUED	 = 1 << 2   /* once its value has been determined */
+    SYM_USED = 1 << 0,		/* for using variables before declared */
+    SYM_DECLARED = 1 << 1,	/* once it's been declared */
+    SYM_VALUED = 1 << 2		/* once its value has been determined */
 } SymStatus;
 
 typedef enum {
-    SYM_CONSTANT,	    /* for EQU defined symbols */
-    SYM_LABEL		    /* for labels */
+    SYM_CONSTANT,		/* for EQU defined symbols */
+    SYM_LABEL			/* for labels */
 } SymType;
 
 typedef struct symrec_s {
@@ -52,8 +52,8 @@ extern symtab *sym_table;
 /*symrec *putsym(char *, SymType);*/
 /*symrec *getsym(char *);*/
 
-symrec *sym_use_get (char *, SymType);
-symrec *sym_def_get (char *, SymType);
-void sym_foreach (int(*)(symrec *));
+symrec *sym_use_get(char *, SymType);
+symrec *sym_def_get(char *, SymType);
+void sym_foreach(int (*)(symrec *));
 
 #endif