* app.c: MRI compatibility - allow single quote to start a string.

	* as.c: fix typo recently introduced.
	* as.h : Don't include aout/reloc.h - it's not right for COFF!
	* expr.c: Much rewriting, to accomodate MRI syntax for
	expressions. Also easier to read now.
	* listing.c: Put back defuns
	* read.c: modified to accept MRI syntax, put back listing pseudo
	ops so that an assembler built with NO_LISTING ignores list ops
	rather than pukes.
	* write.c, write.h: fixs - only keep a reloc type in a fix if the target
	machine is a SPARC or a 29K.
	* config/obj-aout.c: added s_sect pseudo op
	* config/obj-coffbfd.c: lints, set the filehdr flags right and
	fill in the timestamp.
	* config/obj-coffbfd.h: Since we don't include aout/reloc.h
	anymore, define all the relocs which the tc-<x> bit will use so we
	can translate from them to the coff types.
	* config/tc-a29k.c: reloc_type isn't ane enum any more
	* config/tc-m68k.c: Added NO_RELOC definition.

Now compiles for sparc aout, 68k aout (MRI and MIT syntax),
29k coff.

So far works as replacement for sparc and 68k /bin/as.

1 files changed, 696 insertions, 555 deletions

diff --git a/gas/expr.c b/gas/expr.c
index 601feaf..c3bd0b7 100644
--- a/gas/expr.c
+++ b/gas/expr.c
@@ -1,5 +1,5 @@
 /* expr.c -operands, expressions-
-   Copyright (C) 1987, 1990, 1991 Free Software Foundation, Inc.
+   Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.
    
    This file is part of GAS, the GNU Assembler.
    
@@ -31,11 +31,11 @@
 
 #include "obstack.h"
 
-#ifdef __STDC__
+#if __STDC__ == 1
 static void clean_up_expression(expressionS *expressionP);
 #else /* __STDC__ */
 static void clean_up_expression();	/* Internal. */
-#endif /* __STDC__ */
+#endif /* not __STDC__ */
 extern const char EXP_CHARS[];	/* JF hide MD floating pt stuff all the same place */
 extern const char FLT_CHARS[];
 
@@ -67,6 +67,257 @@ FLONUM_TYPE	generic_floating_point_number =
 /* If nonzero, we've been asked to assemble nan, +inf or -inf */
 int generic_floating_point_magic;
 
+floating_constant(expressionP)
+expressionS *expressionP;
+{
+  /* input_line_pointer->*/
+  /* floating-point constant. */
+  int error_code;
+
+  error_code = atof_generic
+   (& input_line_pointer, ".", EXP_CHARS,
+    & generic_floating_point_number);
+
+  if (error_code)
+  {
+    if (error_code == ERROR_EXPONENT_OVERFLOW)
+    {
+      as_bad("bad floating-point constant: exponent overflow, probably assembling junk");
+    }
+    else
+    {
+      as_bad("bad floating-point constant: unknown error code=%d.", error_code);
+    }
+  }
+  expressionP->X_seg = SEG_BIG;
+  /* input_line_pointer->just after constant, */
+  /* which may point to whitespace. */
+  expressionP->X_add_number =-1;
+
+}
+
+
+
+integer_constant(radix, expressionP)
+int radix;
+expressionS *expressionP;
+
+
+{
+  register char *	digit_2; /*->2nd digit of number. */  
+  char c;
+
+  register valueT	number;	/* offset or (absolute) value */
+  register short int digit; /* value of next digit in current radix */
+  register short int maxdig = 0; /* highest permitted digit value. */
+  register int too_many_digits = 0; /* if we see >= this number of */
+  register char *name; /* points to name of symbol */
+  register symbolS *	symbolP; /* points to symbol */
+
+  int small; /* true if fits in 32 bits. */
+  extern  char hex_value[]; /* in hex_value.c */
+
+  /* may be bignum, or may fit in 32 bits. */
+  /*
+   * most numbers fit into 32 bits, and we want this case to be fast.
+   * so we pretend it will fit into 32 bits. if, after making up a 32
+   * bit number, we realise that we have scanned more digits than
+   * comfortably fit into 32 bits, we re-scan the digits coding
+   * them into a bignum. for decimal and octal numbers we are conservative: some
+   * numbers may be assumed bignums when in fact they do fit into 32 bits.
+   * numbers of any radix can have excess leading zeros: we strive
+   * to recognise this and cast them back into 32 bits.
+   * we must check that the bignum really is more than 32
+   * bits, and change it back to a 32-bit number if it fits.
+   * the number we are looking for is expected to be positive, but
+   * if it fits into 32 bits as an unsigned number, we let it be a 32-bit
+   * number. the cavalier approach is for speed in ordinary cases.
+   */
+
+  switch (radix) 
+  {
+    
+  case 2:
+    maxdig = 2;
+    too_many_digits = 33;
+    break;
+  case 8:
+     maxdig = radix = 8;
+    too_many_digits = 11;
+    break;
+  case 16:
+    
+
+    maxdig = radix = 16;
+    too_many_digits = 9;
+    break;
+  case 10:
+    maxdig = radix = 10;
+    too_many_digits = 11;
+  }
+  c = *input_line_pointer;
+  input_line_pointer++;
+  digit_2 = input_line_pointer;
+  for (number=0;  (digit=hex_value[c])<maxdig;  c = * input_line_pointer ++)
+  {
+    number = number * radix + digit;
+  }
+  /* c contains character after number. */
+  /* input_line_pointer->char after c. */
+  small = input_line_pointer - digit_2 < too_many_digits;
+  if (! small)
+  {
+    /*
+     * we saw a lot of digits. manufacture a bignum the hard way.
+     */
+    LITTLENUM_TYPE *	leader;	/*->high order littlenum of the bignum. */
+    LITTLENUM_TYPE *	pointer; /*->littlenum we are frobbing now. */
+    long carry;
+
+    leader = generic_bignum;
+    generic_bignum [0] = 0;
+    generic_bignum [1] = 0;
+    /* we could just use digit_2, but lets be mnemonic. */
+    input_line_pointer = -- digit_2; /*->1st digit. */
+    c = *input_line_pointer ++;
+    for (;   (carry = hex_value [c]) < maxdig;   c = * input_line_pointer ++)
+    {
+      for (pointer = generic_bignum;
+	   pointer <= leader;
+	   pointer ++)
+      {
+	long work;
+
+	work = carry + radix * * pointer;
+	* pointer = work & LITTLENUM_MASK;
+	carry = work >> LITTLENUM_NUMBER_OF_BITS;
+      }
+      if (carry)
+      {
+	if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
+	{ /* room to grow a longer bignum. */
+	  * ++ leader = carry;
+	}
+      }
+    }
+    /* again, c is char after number, */
+    /* input_line_pointer->after c. */
+    know(sizeof (int) * 8 == 32);
+    know(LITTLENUM_NUMBER_OF_BITS == 16);
+    /* hence the constant "2" in the next line. */
+    if (leader < generic_bignum + 2)
+    { /* will fit into 32 bits. */
+      number =
+       ((generic_bignum [1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
+	| (generic_bignum [0] & LITTLENUM_MASK);
+      small = 1;
+    }
+    else
+    {
+      number = leader - generic_bignum + 1; /* number of littlenums in the bignum. */
+    }
+  }
+  if (small)
+  {
+    /*
+     * here with number, in correct radix. c is the next char.
+     * note that unlike un*x, we allow "011f" "0x9f" to
+     * both mean the same as the (conventional) "9f". this is simply easier
+     * than checking for strict canonical form. syntax sux!
+     */
+    if (number<10)
+    {
+      if (0
+#ifdef local_labels_fb
+	  || c=='b'
+#endif
+#ifdef local_labels_dollar
+	  || (c=='$' && local_label_defined[number])
+#endif
+	  )
+      {
+	/*
+	 * backward ref to local label.
+	 * because it is backward, expect it to be defined.
+	 */
+	/*
+	 * construct a local label.
+	 */
+	name = local_label_name ((int)number, 0);
+	if (((symbolP = symbol_find(name)) != NULL) /* seen before */
+	    && (S_IS_DEFINED(symbolP))) /* symbol is defined: ok */
+	{ /* expected path: symbol defined. */
+	  /* local labels are never absolute. don't waste time checking absoluteness. */
+	  know(SEG_NORMAL(S_GET_SEGMENT(symbolP)));
+
+	  expressionP->X_add_symbol = symbolP;
+	  expressionP->X_add_number = 0;
+	  expressionP->X_seg = S_GET_SEGMENT(symbolP);
+	}
+	else
+	{ /* either not seen or not defined. */
+	  as_bad("backw. ref to unknown label \"%d:\", 0 assumed.",
+		 number);
+	  expressionP->X_add_number = 0;
+	  expressionP->X_seg        = SEG_ABSOLUTE;
+	}
+      }
+      else
+      {
+	if (0
+#ifdef local_labels_fb
+	    || c == 'f'
+#endif
+#ifdef local_labels_dollar
+	    || (c=='$' && !local_label_defined[number])
+#endif
+	    )
+	{
+	  /*
+	   * forward reference. expect symbol to be undefined or
+	   * unknown. undefined: seen it before. unknown: never seen
+	   * it in this pass.
+	   * construct a local label name, then an undefined symbol.
+	   * don't create a xseg frag for it: caller may do that.
+	   * just return it as never seen before.
+	   */
+	  name = local_label_name((int)number, 1);
+	  symbolP = symbol_find_or_make(name);
+	  /* we have no need to check symbol properties. */
+#ifndef many_segments
+	  /* since "know" puts its arg into a "string", we
+	     can't have newlines in the argument.  */
+	  know(S_GET_SEGMENT(symbolP) == SEG_UNKNOWN || S_GET_SEGMENT(symbolP) == SEG_TEXT || S_GET_SEGMENT(symbolP) == SEG_DATA);
+#endif
+	  expressionP->X_add_symbol      = symbolP;
+	  expressionP->X_seg             = SEG_UNKNOWN;
+	  expressionP->X_subtract_symbol = NULL;
+	  expressionP->X_add_number      = 0;
+	}
+	else
+	{ /* really a number, not a local label. */
+	  expressionP->X_add_number = number;
+	  expressionP->X_seg        = SEG_ABSOLUTE;
+	  input_line_pointer --; /* restore following character. */
+	} /* if (c=='f') */
+      } /* if (c=='b') */
+    }
+    else
+    { /* really a number. */
+      expressionP->X_add_number = number;
+      expressionP->X_seg        = SEG_ABSOLUTE;
+      input_line_pointer --; /* restore following character. */
+    } /* if (number<10) */
+  }
+  else
+  {
+    expressionP->X_add_number = number;
+    expressionP->X_seg = SEG_BIG;
+    input_line_pointer --; /*->char following number. */
+  } /* if (small) */
+} 
+
+
 /*
  * Summary of operand().
  *
@@ -80,390 +331,280 @@ int generic_floating_point_magic;
  *
  */
 
+
+
 static segT
-    operand (expressionP)
-register expressionS *	expressionP;
+operand (expressionP)
+     register expressionS *	expressionP;
 {
-    register char c;
-    register char *name;	/* points to name of symbol */
-    register symbolS *	symbolP; /* Points to symbol */
-    
-    extern  char hex_value[];	/* In hex_value.c */
+  register char c;
+  register symbolS *	symbolP; /* points to symbol */
+  register char *name; /* points to name of symbol */
+  /* invented for humans only, hope */
+  /* optimising compiler flushes it! */
+  register short int radix; /* 2, 8, 10 or 16, 0 when floating */
+  /* 0 means we saw start of a floating- */
+  /* point constant. */
+
+  /* digits, assume it is a bignum. */
+
+
+
+
+  SKIP_WHITESPACE(); /* leading whitespace is part of operand. */
+  c = * input_line_pointer ++; /* input_line_pointer->past char in c. */
+
+  switch (c)
+  {
+#ifdef MRI
+  case '%':
+    integer_constant(2, expressionP);
+    break;
+  case '@':
+    integer_constant(8, expressionP);
+    break;
+  case '$':
+    integer_constant(16, expressionP);
+    break;	
+#endif
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+    input_line_pointer--;
     
-    SKIP_WHITESPACE();		/* Leading whitespace is part of operand. */
-    c = * input_line_pointer ++;	/* Input_line_pointer->past char in c. */
-    if (isdigit(c) || (c == 'H' && input_line_pointer[0] == '\''))
+    integer_constant(10, expressionP);
+    break;
+
+  case '0':
+    /* non-decimal radix */
+
+      
+    c = *input_line_pointer;
+    switch (c) 
     {
-	register valueT	number;	/* offset or (absolute) value */
-	register short int digit;	/* value of next digit in current radix */
-	/* invented for humans only, hope */
-	/* optimising compiler flushes it! */
-	register short int radix;	/* 2, 8, 10 or 16 */
-	/* 0 means we saw start of a floating- */
-	/* point constant. */
-	register short int maxdig = 0;/* Highest permitted digit value. */
-	register int too_many_digits = 0; /* If we see >= this number of */
-	/* digits, assume it is a bignum. */
-	register char *	digit_2; /*->2nd digit of number. */
-	int small;	/* TRUE if fits in 32 bits. */
-	
-	
-	if (c == 'H' || c == '0') {			/* non-decimal radix */
-	    if ((c = *input_line_pointer ++)=='x' || c=='X' || c=='\'') {
-		c = *input_line_pointer ++; /* read past "0x" or "0X" or H' */
-		maxdig = radix = 16;
-		too_many_digits = 9;
-	    } else {
-		/* If it says '0f' and the line ends or it DOESN'T look like
-		   a floating point #, its a local label ref.  DTRT */
-		/* likewise for the b's.  xoxorich. */
-		if ((c == 'f' || c == 'b' || c == 'B')
-		    && (!*input_line_pointer ||
-			(!strchr("+-.0123456789",*input_line_pointer) &&
-			 !strchr(EXP_CHARS,*input_line_pointer)))) {
-		    maxdig = radix = 10;
-		    too_many_digits = 11;
-		    c = '0';
-		    input_line_pointer -= 2;
-		    
-		} else if (c == 'b' || c == 'B') {
-		    c = *input_line_pointer++;
-		    maxdig = radix = 2;
-		    too_many_digits = 33;
-		    
-		} else if (c && strchr(FLT_CHARS,c)) {
-		    radix = 0;	/* Start of floating-point constant. */
-		    /* input_line_pointer->1st char of number. */
-		    expressionP->X_add_number =  -(isupper(c) ? tolower(c) : c);
-		    
-		} else {		/* By elimination, assume octal radix. */
-		    radix = maxdig = 8;
-		    too_many_digits = 11;
-		}
-	    } /* c == char after "0" or "0x" or "0X" or "0e" etc. */
-	} else {
-	    maxdig = radix = 10;
-	    too_many_digits = 11;
-	} /* if operand starts with a zero */
-	
-	if (radix) {			/* Fixed-point integer constant. */
-	    /* May be bignum, or may fit in 32 bits. */
-	    /*
-	     * Most numbers fit into 32 bits, and we want this case to be fast.
-	     * So we pretend it will fit into 32 bits. If, after making up a 32
-	     * bit number, we realise that we have scanned more digits than
-	     * comfortably fit into 32 bits, we re-scan the digits coding
-	     * them into a bignum. For decimal and octal numbers we are conservative: some
-	     * numbers may be assumed bignums when in fact they do fit into 32 bits.
-	     * Numbers of any radix can have excess leading zeros: we strive
-	     * to recognise this and cast them back into 32 bits.
-	     * We must check that the bignum really is more than 32
-	     * bits, and change it back to a 32-bit number if it fits.
-	     * The number we are looking for is expected to be positive, but
-	     * if it fits into 32 bits as an unsigned number, we let it be a 32-bit
-	     * number. The cavalier approach is for speed in ordinary cases.
-	     */
-	    digit_2 = input_line_pointer;
-	    for (number=0;  (digit=hex_value[c])<maxdig;  c = * input_line_pointer ++)
-	    {
-		number = number * radix + digit;
-	    }
-	    /* C contains character after number. */
-	    /* Input_line_pointer->char after C. */
-	    small = input_line_pointer - digit_2 < too_many_digits;
-	    if (! small)
-	    {
-		/*
-		 * We saw a lot of digits. Manufacture a bignum the hard way.
-		 */
-		LITTLENUM_TYPE *	leader;	/*->high order littlenum of the bignum. */
-		LITTLENUM_TYPE *	pointer; /*->littlenum we are frobbing now. */
-		long carry;
-		
-		leader = generic_bignum;
-		generic_bignum [0] = 0;
-		generic_bignum [1] = 0;
-		/* We could just use digit_2, but lets be mnemonic. */
-		input_line_pointer = -- digit_2; /*->1st digit. */
-		c = *input_line_pointer ++;
-		for (;   (carry = hex_value [c]) < maxdig;   c = * input_line_pointer ++)
-		{
-		    for (pointer = generic_bignum;
-			 pointer <= leader;
-			 pointer ++)
-		    {
-			long work;
-			
-			work = carry + radix * * pointer;
-			* pointer = work & LITTLENUM_MASK;
-			carry = work >> LITTLENUM_NUMBER_OF_BITS;
-		    }
-		    if (carry)
-		    {
-			if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
-			{	/* Room to grow a longer bignum. */
-			    * ++ leader = carry;
-			}
-		    }
-		}
-		/* Again, C is char after number, */
-		/* input_line_pointer->after C. */
-		know(sizeof (int) * 8 == 32);
-		know(LITTLENUM_NUMBER_OF_BITS == 16);
-		/* Hence the constant "2" in the next line. */
-		if (leader < generic_bignum + 2)
-		{		/* Will fit into 32 bits. */
-		    number =
-			((generic_bignum [1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
-			    | (generic_bignum [0] & LITTLENUM_MASK);
-		    small = 1;
-		}
-		else
-		{
-		    number = leader - generic_bignum + 1;	/* Number of littlenums in the bignum. */
-		}
-	    }
-	    if (small)
-	    {
-		/*
-		 * Here with number, in correct radix. c is the next char.
-		 * Note that unlike Un*x, we allow "011f" "0x9f" to
-		 * both mean the same as the (conventional) "9f". This is simply easier
-		 * than checking for strict canonical form. Syntax sux!
-		 */
-		if (number<10)
-		{
-		    if (0
-#ifdef LOCAL_LABELS_FB
-			|| c=='b'
-#endif
-#ifdef LOCAL_LABELS_DOLLAR
-			|| (c=='$' && local_label_defined[number])
-#endif
-			)
-		    {
-			/*
-			 * Backward ref to local label.
-			 * Because it is backward, expect it to be DEFINED.
-			 */
-			/*
-			 * Construct a local label.
-			 */
-			name = local_label_name ((int)number, 0);
-			if (((symbolP = symbol_find(name)) != NULL) /* seen before */
-			    && (S_IS_DEFINED(symbolP))) /* symbol is defined: OK */
-			{		/* Expected path: symbol defined. */
-			    /* Local labels are never absolute. Don't waste time checking absoluteness. */
-			    know(SEG_NORMAL(S_GET_SEGMENT(symbolP)));
-			    
-			    expressionP->X_add_symbol = symbolP;
-			    expressionP->X_add_number = 0;
-			    expressionP->X_seg = S_GET_SEGMENT(symbolP);
-			}
-			else
-			{		/* Either not seen or not defined. */
-			    as_bad("Backw. ref to unknown label \"%d:\", 0 assumed.",
-				   number);
-			    expressionP->X_add_number = 0;
-			    expressionP->X_seg        = SEG_ABSOLUTE;
-			}
-		    }
-		    else
-		    {
-			if (0
-#ifdef LOCAL_LABELS_FB
-			    || c == 'f'
-#endif
-#ifdef LOCAL_LABELS_DOLLAR
-			    || (c=='$' && !local_label_defined[number])
-#endif
-			    )
-			{
-			    /*
-			     * Forward reference. Expect symbol to be undefined or
-			     * unknown. Undefined: seen it before. Unknown: never seen
-			     * it in this pass.
-			     * Construct a local label name, then an undefined symbol.
-			     * Don't create a XSEG frag for it: caller may do that.
-			     * Just return it as never seen before.
-			     */
-			    name = local_label_name((int)number, 1);
-			    symbolP = symbol_find_or_make(name);
-			    /* We have no need to check symbol properties. */
-#ifndef MANY_SEGMENTS
-			    /* Since "know" puts its arg into a "string", we
-			       can't have newlines in the argument.  */
-			    know(S_GET_SEGMENT(symbolP) == SEG_UNKNOWN || S_GET_SEGMENT(symbolP) == SEG_TEXT || S_GET_SEGMENT(symbolP) == SEG_DATA);
-#endif
-			    expressionP->X_add_symbol      = symbolP;
-			    expressionP->X_seg             = SEG_UNKNOWN;
-			    expressionP->X_subtract_symbol = NULL;
-			    expressionP->X_add_number      = 0;
-			}
-			else
-			{		/* Really a number, not a local label. */
-			    expressionP->X_add_number = number;
-			    expressionP->X_seg        = SEG_ABSOLUTE;
-			    input_line_pointer --; /* Restore following character. */
-			}		/* if (c=='f') */
-		    }			/* if (c=='b') */
-		}
-		else
-		{			/* Really a number. */
-		    expressionP->X_add_number = number;
-		    expressionP->X_seg        = SEG_ABSOLUTE;
-		    input_line_pointer --; /* Restore following character. */
-		}			/* if (number<10) */
-	    }
-	    else
-	    {
-		expressionP->X_add_number = number;
-		expressionP->X_seg = SEG_BIG;
-		input_line_pointer --; /*->char following number. */
-	    }			/* if (small) */
-	}			/* (If integer constant) */
-	else
-	{			/* input_line_pointer->*/
-	    /* floating-point constant. */
-	    int error_code;
-	    
-	    error_code = atof_generic
-		(& input_line_pointer, ".", EXP_CHARS,
-		 & generic_floating_point_number);
-	    
-	    if (error_code)
-	    {
-		if (error_code == ERROR_EXPONENT_OVERFLOW)
-		{
-		    as_bad("Bad floating-point constant: exponent overflow, probably assembling junk");
-		}
-		else
-		{
-		    as_bad("Bad floating-point constant: unknown error code=%d.", error_code);
-		}
-	    }
-	    expressionP->X_seg = SEG_BIG;
-	    /* input_line_pointer->just after constant, */
-	    /* which may point to whitespace. */
-	    know(expressionP->X_add_number < 0); /* < 0 means "floating point". */
-	}			/* if (not floating-point constant) */
+
+    default:
+      /* The string was only zero */
+      expressionP->X_add_symbol = 0;
+      expressionP->X_add_number = 0;
+      expressionP->X_seg = SEG_ABSOLUTE;
+      break;
+      
+    case 'x':
+    case 'X':
+      input_line_pointer++;
+      integer_constant(16, expressionP);
+      break;
+    case 'B':
+    case 'b':
+      input_line_pointer++;
+      integer_constant(2, expressionP);
+      break;
+
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+      integer_constant(8, expressionP);
+      break;
+
+    case 'f':      
+      /* if it says '0f' and the line ends or it doesn't look like
+	 a floating point #, its a local label ref.  dtrt */
+      /* likewise for the b's.  xoxorich. */
+      if ((c == 'f' || c == 'b' || c == 'b')
+	  && (!*input_line_pointer ||
+	      (!strchr("+-.0123456789",*input_line_pointer) &&
+	       !strchr(EXP_CHARS,*input_line_pointer)))) 
+      {
+	input_line_pointer -= 2;
+	integer_constant(10, expressionP);
+	break;
+      } 
+
+    case 'd':
+    case 'D':
+    case 'F':
+      
+    case 'e':
+    case 'E':
+    case 'g':
+    case 'G':
+      
+      input_line_pointer++;  
+      floating_constant(expressionP);
+      break;
     }
-    else if(c=='.' && !is_part_of_name(*input_line_pointer)) {
-	extern struct obstack frags;
-	
-	/*
-	  JF:  '.' is pseudo symbol with value of current location in current
-	  segment. . .
-	  */
-	symbolP = symbol_new("L0\001",
-			     now_seg,
-			     (valueT)(obstack_next_free(&frags)-frag_now->fr_literal),
-			     frag_now);
-	
-	expressionP->X_add_number=0;
-	expressionP->X_add_symbol=symbolP;
-	expressionP->X_seg = now_seg;
-	
-    } else if (is_name_beginner(c)) /* here if did not begin with a digit */
+  
+    break;
+  case  '(':
+    /* didn't begin with digit & not a name */
+  {
+    (void)expression(expressionP);
+    /* Expression() will pass trailing whitespace */
+    if (* input_line_pointer ++ != ')')
     {
-	/*
-	 * Identifier begins here.
-	 * This is kludged for speed, so code is repeated.
-	 */
-	name =  -- input_line_pointer;
-	c = get_symbol_end();
-	symbolP = symbol_find_or_make(name);
-	/*
-	 * If we have an absolute symbol or a reg, then we know its value now.
-	 */
-	expressionP->X_seg = S_GET_SEGMENT(symbolP);
-	switch (expressionP->X_seg)
+      as_bad("Missing ')' assumed");
+      input_line_pointer --;
+    }
+    /* here with input_line_pointer->char after "(...)" */
+  }
+    return;
+
+
+  case '\'':
+    /*
+     * Warning: to conform to other people's assemblers NO ESCAPEMENT is permitted
+     * for a single quote. The next character, parity errors and all, is taken
+     * as the value of the operand. VERY KINKY.
+     */
+    expressionP->X_add_number = * input_line_pointer ++;
+    expressionP->X_seg        = SEG_ABSOLUTE;
+    break;
+
+  case  '~':
+  case  '-':
+  case  '+':
+
+  {
+    /* unary operator: hope for SEG_ABSOLUTE */
+    switch(operand (expressionP)) {
+      case SEG_ABSOLUTE:
+	/* input_line_pointer -> char after operand */
+	if ( c=='-' )
 	{
-	case SEG_ABSOLUTE:
-	case SEG_REGISTER:
-	    expressionP->X_add_number = S_GET_VALUE(symbolP);
-	    break;
-	    
-	default:
-	    expressionP->X_add_number  = 0;
-	    expressionP->X_add_symbol  = symbolP;
+	  expressionP -> X_add_number = - expressionP -> X_add_number;
+	  /*
+	   * Notice: '-' may  overflow: no warning is given. This is compatible
+	   * with other people's assemblers. Sigh.
+	   */
 	}
-	* input_line_pointer = c;
-	expressionP->X_subtract_symbol = NULL;
-    }
-    else if (c=='(')/* didn't begin with digit & not a name */
-    {
-	(void)expression(expressionP);
-	/* Expression() will pass trailing whitespace */
-	if (* input_line_pointer ++ != ')')
+	else
 	{
-	    as_bad("Missing ')' assumed");
-	    input_line_pointer --;
+	  expressionP -> X_add_number = ~ expressionP -> X_add_number;
 	}
-	/* here with input_line_pointer->char after "(...)" */
-    }
-    else if (c == '~' || c == '-' || c == '+') {
-	/* unary operator: hope for SEG_ABSOLUTE */
-	switch (operand (expressionP)) {
-	case SEG_ABSOLUTE:
-	    /* input_line_pointer->char after operand */
-	    if (c=='-') {
-		expressionP->X_add_number = - expressionP->X_add_number;
-		/*
-		 * Notice: '-' may  overflow: no warning is given. This is compatible
-		 * with other people's assemblers. Sigh.
-		 */
-	    } else if (c == '~') {
-		expressionP->X_add_number = ~ expressionP->X_add_number;
-	    } else if (c != '+') {
-		know(0);
-	    } /* switch on unary operator */
+	break;
+
+      case SEG_TEXT:
+      case SEG_DATA:
+      case SEG_BSS:
+      case SEG_PASS1:
+      case SEG_UNKNOWN:
+	if(c=='-') { /* JF I hope this hack works */
+	    expressionP->X_subtract_symbol=expressionP->X_add_symbol;
+	    expressionP->X_add_symbol=0;
+	    expressionP->X_seg=SEG_DIFFERENCE;
 	    break;
-	    
-	default:		/* unary on non-absolute is unsuported */
-	    if (!SEG_NORMAL(operand(expressionP))) 
-	    {
-		as_bad("Unary operator %c ignored because bad operand follows", c);
-		break;
-	    }
-	    /* Fall through for normal segments ****/
-	case SEG_PASS1:
-	case SEG_UNKNOWN:
-	    if(c=='-') {		/* JF I hope this hack works */
-		expressionP->X_subtract_symbol=expressionP->X_add_symbol;
-		expressionP->X_add_symbol=0;
-		expressionP->X_seg=SEG_DIFFERENCE;
-		break;
-	    }
-	    /* Expression undisturbed from operand(). */
-	}
-    }
-    else if (c=='\'')
+	  }
+      default: /* unary on non-absolute is unsuported */
+	as_warn("Unary operator %c ignored because bad operand follows", c);
+	break;
+	/* Expression undisturbed from operand(). */
+      }
+  }
+    
+
+  
+    break;  
+
+  case '.':
+    if( !is_part_of_name(*input_line_pointer)) 
     {
-	/*
-	 * Warning: to conform to other people's assemblers NO ESCAPEMENT is permitted
-	 * for a single quote. The next character, parity errors and all, is taken
-	 * as the value of the operand. VERY KINKY.
-	 */
-	expressionP->X_add_number = * input_line_pointer ++;
-	expressionP->X_seg        = SEG_ABSOLUTE;
+      extern struct obstack frags;
+      
+      /*
+	JF:  '.' is pseudo symbol with value of current location in current
+	segment. . .
+	*/
+      symbolP = symbol_new("L0\001",
+			   now_seg,
+			   (valueT)(obstack_next_free(&frags)-frag_now->fr_literal),
+			   frag_now);
+
+      expressionP->X_add_number=0;
+      expressionP->X_add_symbol=symbolP;
+      expressionP->X_seg = now_seg;
+      break;
+      
     }
-    else
+    else 
     {
+      goto isname;
+      
+
+    }
+    
+  case '\n':
 	/* can't imagine any other kind of operand */
 	expressionP->X_seg = SEG_ABSENT;
 	input_line_pointer --;
 	md_operand (expressionP);
+    break;    
+    /* Fall through */
+  default:
+    if (is_name_beginner(c)) /* here if did not begin with a digit */
+    {
+      /*
+       * Identifier begins here.
+       * This is kludged for speed, so code is repeated.
+       */
+isname:
+      name =  -- input_line_pointer;
+      c = get_symbol_end();
+      symbolP = symbol_find_or_make(name);
+      /*
+       * If we have an absolute symbol or a reg, then we know its value now.
+       */
+      expressionP->X_seg = S_GET_SEGMENT(symbolP);
+      switch (expressionP->X_seg)
+      {
+      case SEG_ABSOLUTE:
+      case SEG_REGISTER:
+	expressionP->X_add_number = S_GET_VALUE(symbolP);
+	break;
+
+      default:
+	expressionP->X_add_number  = 0;
+	expressionP->X_add_symbol  = symbolP;
+      }
+      * input_line_pointer = c;
+      expressionP->X_subtract_symbol = NULL;
     }
-    /*
-     * It is more 'efficient' to clean up the expressions when they are created.
-     * Doing it here saves lines of code.
-     */
-    clean_up_expression (expressionP);
-    SKIP_WHITESPACE();		/*->1st char after operand. */
-    know(* input_line_pointer != ' ');
-    return (expressionP->X_seg);
+    else 
+    {
+      as_bad("Bad expression");
+      expressionP->X_add_number = 0;
+      expressionP->X_seg = SEG_ABSOLUTE;
+
+    }
+    
+  }
+  
+  
+  
+
+
+  
+
+  /*
+   * It is more 'efficient' to clean up the expressionS when they are created.
+   * Doing it here saves lines of code.
+   */
+  clean_up_expression (expressionP);
+  SKIP_WHITESPACE(); /*->1st char after operand. */
+  know(* input_line_pointer != ' ');
+  return (expressionP->X_seg);
 } /* operand() */
+
 
 /* Internal. Simplify a struct expression for use by expr() */
 
@@ -479,29 +620,29 @@ register expressionS *	expressionP;
  */
 
 static void
-    clean_up_expression (expressionP)
-register expressionS * expressionP;
+clean_up_expression (expressionP)
+     register expressionS * expressionP;
 {
-    switch (expressionP->X_seg)
-    {
-    case SEG_ABSENT:
-    case SEG_PASS1:
+  switch (expressionP->X_seg)
+      {
+      case SEG_ABSENT:
+      case SEG_PASS1:
 	expressionP->X_add_symbol	= NULL;
 	expressionP->X_subtract_symbol	= NULL;
 	expressionP->X_add_number	= 0;
 	break;
-	
-    case SEG_BIG:
-    case SEG_ABSOLUTE:
+
+      case SEG_BIG:
+      case SEG_ABSOLUTE:
 	expressionP->X_subtract_symbol	= NULL;
 	expressionP->X_add_symbol	= NULL;
 	break;
-	
-    case SEG_UNKNOWN:
+
+      case SEG_UNKNOWN:
 	expressionP->X_subtract_symbol	= NULL;
 	break;
-	
-    case SEG_DIFFERENCE:
+
+      case SEG_DIFFERENCE:
 	/*
 	 * It does not hurt to 'cancel' NULL==NULL
 	 * when comparing symbols for 'eq'ness.
@@ -518,21 +659,21 @@ register expressionS * expressionP;
 	    expressionP->X_seg			= SEG_ABSOLUTE;
 	}
 	break;
-	
-    case SEG_REGISTER:
+
+      case SEG_REGISTER:
 	expressionP->X_add_symbol	= NULL;
 	expressionP->X_subtract_symbol	= NULL;
 	break;
-	
-    default:
+
+      default:
 	if (SEG_NORMAL(expressionP->X_seg)) {
-	    expressionP->X_subtract_symbol	= NULL;
+	  expressionP->X_subtract_symbol	= NULL;
 	}
 	else {
 	    BAD_CASE (expressionP->X_seg);
 	}
 	break;
-    }
+      }
 } /* clean_up_expression() */
 
 /*
@@ -547,72 +688,72 @@ register expressionS * expressionP;
  */
 
 static segT
-    expr_part (symbol_1_PP, symbol_2_P)
-symbolS **	symbol_1_PP;
-symbolS *	symbol_2_P;
+expr_part (symbol_1_PP, symbol_2_P)
+     symbolS **	symbol_1_PP;
+     symbolS *	symbol_2_P;
 {
     segT			return_value;
 #ifndef MANY_SEGMENTS
     know((* symbol_1_PP) == NULL || (S_GET_SEGMENT(*symbol_1_PP) == SEG_TEXT) || (S_GET_SEGMENT(*symbol_1_PP) == SEG_DATA) || (S_GET_SEGMENT(*symbol_1_PP) == SEG_BSS) || (!S_IS_DEFINED(* symbol_1_PP)));
     know(symbol_2_P == NULL || (S_GET_SEGMENT(symbol_2_P) == SEG_TEXT) || (S_GET_SEGMENT(symbol_2_P) == SEG_DATA) || (S_GET_SEGMENT(symbol_2_P) == SEG_BSS) || (!S_IS_DEFINED(symbol_2_P)));
 #endif
-    if (* symbol_1_PP)
+  if (* symbol_1_PP)
     {
-	if (!S_IS_DEFINED(* symbol_1_PP))
+      if (!S_IS_DEFINED(* symbol_1_PP))
 	{
-	    if (symbol_2_P)
+	  if (symbol_2_P)
 	    {
 		return_value = SEG_PASS1;
 		* symbol_1_PP = NULL;
 	    }
-	    else
+	  else
 	    {
 		know(!S_IS_DEFINED(* symbol_1_PP));
 		return_value = SEG_UNKNOWN;
 	    }
 	}
-	else
+      else
 	{
-	    if (symbol_2_P)
+	  if (symbol_2_P)
 	    {
-		if (!S_IS_DEFINED(symbol_2_P))
+	      if (!S_IS_DEFINED(symbol_2_P))
 		{
-		    * symbol_1_PP = NULL;
-		    return_value = SEG_PASS1;
+		  * symbol_1_PP = NULL;
+		  return_value = SEG_PASS1;
 		}
-		else
+	      else
 		{
-		    /* {seg1} - {seg2} */
-		    as_bad("Expression too complex, 2 symbols forgotten: \"%s\" \"%s\"",
-			   S_GET_NAME(* symbol_1_PP), S_GET_NAME(symbol_2_P));
-		    * symbol_1_PP = NULL;
-		    return_value = SEG_ABSOLUTE;
+		  /* {seg1} - {seg2} */
+		  as_bad("Expression too complex, 2 symbolS forgotten: \"%s\" \"%s\"",
+			  S_GET_NAME(* symbol_1_PP), S_GET_NAME(symbol_2_P));
+		  * symbol_1_PP = NULL;
+		  return_value = SEG_ABSOLUTE;
 		}
 	    }
-	    else
+	  else
 	    {
-		return_value = S_GET_SEGMENT(* symbol_1_PP);
+	      return_value = S_GET_SEGMENT(* symbol_1_PP);
 	    }
 	}
     }
-    else
+  else
     {				/* (* symbol_1_PP) == NULL */
-	if (symbol_2_P)
+      if (symbol_2_P)
 	{
-	    * symbol_1_PP = symbol_2_P;
-	    return_value = S_GET_SEGMENT(symbol_2_P);
+	  * symbol_1_PP = symbol_2_P;
+	  return_value = S_GET_SEGMENT(symbol_2_P);
 	}
-	else
+      else
 	{
-	    * symbol_1_PP = NULL;
-	    return_value = SEG_ABSOLUTE;
+	  * symbol_1_PP = NULL;
+	  return_value = SEG_ABSOLUTE;
 	}
     }
 #ifndef MANY_SEGMENTS
-    know(return_value == SEG_ABSOLUTE || return_value == SEG_TEXT || return_value == SEG_DATA || return_value == SEG_BSS || return_value == SEG_UNKNOWN || return_value == SEG_PASS1);
+  know(return_value == SEG_ABSOLUTE || return_value == SEG_TEXT || return_value == SEG_DATA || return_value == SEG_BSS || return_value == SEG_UNKNOWN || return_value == SEG_PASS1);
 #endif
-    know((*symbol_1_PP) == NULL || (S_GET_SEGMENT(*symbol_1_PP) == return_value));
-    return (return_value);
+  know((*symbol_1_PP) == NULL || (S_GET_SEGMENT(*symbol_1_PP) == return_value));
+  return (return_value);
 }				/* expr_part() */
 
 /* Expression parser. */
@@ -692,191 +833,191 @@ static const operatorT op_encoding [256] = {	/* maps ASCII->operators */
  *	3	* / % << >>
  */
 static const operator_rankT
-    op_rank [] = { 0, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1 };
+op_rank [] = { 0, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1 };
 
 /* Return resultP->X_seg. */
 segT expr(rank, resultP)
-    register operator_rankT	rank; /* Larger # is higher rank. */
-    register expressionS *resultP; /* Deliver result here. */
+register operator_rankT	rank; /* Larger # is higher rank. */
+register expressionS *resultP; /* Deliver result here. */
 {
-    expressionS		right;
-    register operatorT	op_left;
-    register char c_left;	/* 1st operator character. */
-    register operatorT	op_right;
-    register char c_right;
-    
-    know(rank >= 0);
-    (void)operand (resultP);
-    know(* input_line_pointer != ' '); /* Operand() gobbles spaces. */
-    c_left = * input_line_pointer; /* Potential operator character. */
-    op_left = op_encoding [c_left];
-    while (op_left != O_illegal && op_rank [(int) op_left] > rank)
+  expressionS		right;
+  register operatorT	op_left;
+  register char c_left;	/* 1st operator character. */
+  register operatorT	op_right;
+  register char c_right;
+
+  know(rank >= 0);
+  (void)operand (resultP);
+  know(* input_line_pointer != ' '); /* Operand() gobbles spaces. */
+  c_left = * input_line_pointer; /* Potential operator character. */
+  op_left = op_encoding [c_left];
+  while (op_left != O_illegal && op_rank [(int) op_left] > rank)
     {
-	input_line_pointer ++;	/*->after 1st character of operator. */
-	/* Operators "<<" and ">>" have 2 characters. */
-	if (* input_line_pointer == c_left && (c_left == '<' || c_left == '>'))
+      input_line_pointer ++;	/*->after 1st character of operator. */
+				/* Operators "<<" and ">>" have 2 characters. */
+      if (* input_line_pointer == c_left && (c_left == '<' || c_left == '>'))
 	{
-	    input_line_pointer ++;
+	  input_line_pointer ++;
 	}			/*->after operator. */
-	if (SEG_ABSENT == expr (op_rank[(int) op_left], &right))
+      if (SEG_ABSENT == expr (op_rank[(int) op_left], &right))
 	{
-	    as_warn("Missing operand value assumed absolute 0.");
-	    resultP->X_add_number	= 0;
-	    resultP->X_subtract_symbol	= NULL;
-	    resultP->X_add_symbol	= NULL;
-	    resultP->X_seg = SEG_ABSOLUTE;
+	  as_warn("Missing operand value assumed absolute 0.");
+	  resultP->X_add_number	= 0;
+	  resultP->X_subtract_symbol	= NULL;
+	  resultP->X_add_symbol	= NULL;
+	  resultP->X_seg = SEG_ABSOLUTE;
 	}
-	know(* input_line_pointer != ' ');
-	c_right = * input_line_pointer;
-	op_right = op_encoding [c_right];
-	if (* input_line_pointer == c_right && (c_right == '<' || c_right == '>'))
+      know(* input_line_pointer != ' ');
+      c_right = * input_line_pointer;
+      op_right = op_encoding [c_right];
+      if (* input_line_pointer == c_right && (c_right == '<' || c_right == '>'))
 	{
-	    input_line_pointer ++;
+	  input_line_pointer ++;
 	}			/*->after operator. */
-	know((int) op_right == 0 || op_rank [(int) op_right] <= op_rank[(int) op_left]);
-	/* input_line_pointer->after right-hand quantity. */
-	/* left-hand quantity in resultP */
-	/* right-hand quantity in right. */
-	/* operator in op_left. */
-	if (resultP->X_seg == SEG_PASS1 || right . X_seg == SEG_PASS1)
+      know((int) op_right == 0 || op_rank [(int) op_right] <= op_rank[(int) op_left]);
+      /* input_line_pointer->after right-hand quantity. */
+      /* left-hand quantity in resultP */
+      /* right-hand quantity in right. */
+      /* operator in op_left. */
+      if (resultP->X_seg == SEG_PASS1 || right . X_seg == SEG_PASS1)
 	{
-	    resultP->X_seg = SEG_PASS1;
+	  resultP->X_seg = SEG_PASS1;
 	}
-	else
+      else
 	{
-	    if (resultP->X_seg == SEG_BIG)
+	  if (resultP->X_seg == SEG_BIG)
 	    {
-		as_warn("Left operand of %c is a %s.  Integer 0 assumed.",
-			c_left, resultP->X_add_number > 0 ? "bignum" : "float");
-		resultP->X_seg = SEG_ABSOLUTE;
-		resultP->X_add_symbol = 0;
-		resultP->X_subtract_symbol = 0;
-		resultP->X_add_number = 0;
+	      as_warn("Left operand of %c is a %s.  Integer 0 assumed.",
+		      c_left, resultP->X_add_number > 0 ? "bignum" : "float");
+	      resultP->X_seg = SEG_ABSOLUTE;
+	      resultP->X_add_symbol = 0;
+	      resultP->X_subtract_symbol = 0;
+	      resultP->X_add_number = 0;
 	    }
-	    if (right . X_seg == SEG_BIG)
+	  if (right . X_seg == SEG_BIG)
 	    {
-		as_warn("Right operand of %c is a %s.  Integer 0 assumed.",
-			c_left, right . X_add_number > 0 ? "bignum" : "float");
-		right . X_seg = SEG_ABSOLUTE;
-		right . X_add_symbol = 0;
-		right . X_subtract_symbol = 0;
-		right . X_add_number = 0;
+	      as_warn("Right operand of %c is a %s.  Integer 0 assumed.",
+		      c_left, right . X_add_number > 0 ? "bignum" : "float");
+	      right . X_seg = SEG_ABSOLUTE;
+	      right . X_add_symbol = 0;
+	      right . X_subtract_symbol = 0;
+	      right . X_add_number = 0;
 	    }
-	    if (op_left == O_subtract)
+	  if (op_left == O_subtract)
 	    {
-		/*
-		 * Convert - into + by exchanging symbols and negating number.
-		 * I know -infinity can't be negated in 2's complement:
-		 * but then it can't be subtracted either. This trick
-		 * does not cause any further inaccuracy.
-		 */
-		
-		register symbolS *	symbolP;
-		
-		right . X_add_number      = - right . X_add_number;
-		symbolP                   = right . X_add_symbol;
-		right . X_add_symbol	= right . X_subtract_symbol;
-		right . X_subtract_symbol = symbolP;
-		if (symbolP)
+	      /*
+	       * Convert - into + by exchanging symbolS and negating number.
+	       * I know -infinity can't be negated in 2's complement:
+	       * but then it can't be subtracted either. This trick
+	       * does not cause any further inaccuracy.
+	       */
+
+	      register symbolS *	symbolP;
+
+	      right . X_add_number      = - right . X_add_number;
+	      symbolP                   = right . X_add_symbol;
+	      right . X_add_symbol	= right . X_subtract_symbol;
+	      right . X_subtract_symbol = symbolP;
+	      if (symbolP)
 		{
-		    right . X_seg		= SEG_DIFFERENCE;
+		  right . X_seg		= SEG_DIFFERENCE;
 		}
-		op_left = O_add;
+	      op_left = O_add;
 	    }
-	    
-	    if (op_left == O_add)
+
+	  if (op_left == O_add)
 	    {
-		segT	seg1;
-		segT	seg2;
+	      segT	seg1;
+	      segT	seg2;
 #ifndef MANY_SEGMENTS
-		know(resultP->X_seg == SEG_DATA || resultP->X_seg == SEG_TEXT || resultP->X_seg == SEG_BSS || resultP->X_seg == SEG_UNKNOWN || resultP->X_seg == SEG_DIFFERENCE || resultP->X_seg == SEG_ABSOLUTE || resultP->X_seg == SEG_PASS1);
-		know(right.X_seg == SEG_DATA || right.X_seg == SEG_TEXT || right.X_seg == SEG_BSS || right.X_seg == SEG_UNKNOWN || right.X_seg == SEG_DIFFERENCE || right.X_seg == SEG_ABSOLUTE || right.X_seg == SEG_PASS1);
+	      know(resultP->X_seg == SEG_DATA || resultP->X_seg == SEG_TEXT || resultP->X_seg == SEG_BSS || resultP->X_seg == SEG_UNKNOWN || resultP->X_seg == SEG_DIFFERENCE || resultP->X_seg == SEG_ABSOLUTE || resultP->X_seg == SEG_PASS1);
+	      know(right.X_seg == SEG_DATA || right.X_seg == SEG_TEXT || right.X_seg == SEG_BSS || right.X_seg == SEG_UNKNOWN || right.X_seg == SEG_DIFFERENCE || right.X_seg == SEG_ABSOLUTE || right.X_seg == SEG_PASS1);
 #endif
-		clean_up_expression (& right);
-		clean_up_expression (resultP);
-		
-		seg1 = expr_part (& resultP->X_add_symbol, right . X_add_symbol);
-		seg2 = expr_part (& resultP->X_subtract_symbol, right . X_subtract_symbol);
-		if (seg1 == SEG_PASS1 || seg2 == SEG_PASS1) {
-		    need_pass_2 = 1;
-		    resultP->X_seg = SEG_PASS1;
-		} else if (seg2 == SEG_ABSOLUTE)
-		    resultP->X_seg = seg1;
-		else if (seg1 != SEG_UNKNOWN
-			 && seg1 != SEG_ABSOLUTE
-			 && seg2 != SEG_UNKNOWN
-			 && seg1 != seg2) {
-		    know(seg2 != SEG_ABSOLUTE);
-		    know(resultP->X_subtract_symbol);
+	      clean_up_expression (& right);
+	      clean_up_expression (resultP);
+
+	      seg1 = expr_part (& resultP->X_add_symbol, right . X_add_symbol);
+	      seg2 = expr_part (& resultP->X_subtract_symbol, right . X_subtract_symbol);
+	      if (seg1 == SEG_PASS1 || seg2 == SEG_PASS1) {
+		      need_pass_2 = 1;
+		      resultP->X_seg = SEG_PASS1;
+	      } else if (seg2 == SEG_ABSOLUTE)
+		  resultP->X_seg = seg1;
+	      else if (seg1 != SEG_UNKNOWN
+		       && seg1 != SEG_ABSOLUTE
+		       && seg2 != SEG_UNKNOWN
+		       && seg1 != seg2) {
+		      know(seg2 != SEG_ABSOLUTE);
+		      know(resultP->X_subtract_symbol);
 #ifndef MANY_SEGMENTS
-		    know(seg1 == SEG_TEXT || seg1 == SEG_DATA || seg1== SEG_BSS);
-		    know(seg2 == SEG_TEXT || seg2 == SEG_DATA || seg2== SEG_BSS);
+		      know(seg1 == SEG_TEXT || seg1 == SEG_DATA || seg1== SEG_BSS);
+		      know(seg2 == SEG_TEXT || seg2 == SEG_DATA || seg2== SEG_BSS);
 #endif
-		    know(resultP->X_add_symbol);
-		    know(resultP->X_subtract_symbol);
-		    as_bad("Expression too complex: forgetting %s - %s",
-			   S_GET_NAME(resultP->X_add_symbol),
-			   S_GET_NAME(resultP->X_subtract_symbol));
-		    resultP->X_seg = SEG_ABSOLUTE;
-		    /* Clean_up_expression() will do the rest. */
-		} else
-		    resultP->X_seg = SEG_DIFFERENCE;
-		
-		resultP->X_add_number += right . X_add_number;
-		clean_up_expression (resultP);
-	    }
-	    else
+		      know(resultP->X_add_symbol);
+		      know(resultP->X_subtract_symbol);
+		      as_bad("Expression too complex: forgetting %s - %s",
+			      S_GET_NAME(resultP->X_add_symbol),
+			      S_GET_NAME(resultP->X_subtract_symbol));
+		      resultP->X_seg = SEG_ABSOLUTE;
+		      /* Clean_up_expression() will do the rest. */
+	      } else
+		  resultP->X_seg = SEG_DIFFERENCE;
+
+	      resultP->X_add_number += right . X_add_number;
+	      clean_up_expression (resultP);
+      }
+	  else
 	    {			/* Not +. */
-		if (resultP->X_seg == SEG_UNKNOWN || right . X_seg == SEG_UNKNOWN)
+	      if (resultP->X_seg == SEG_UNKNOWN || right . X_seg == SEG_UNKNOWN)
 		{
-		    resultP->X_seg = SEG_PASS1;
-		    need_pass_2 = 1;
+		  resultP->X_seg = SEG_PASS1;
+		  need_pass_2 = 1;
 		}
-		else
+	      else
 		{
-		    resultP->X_subtract_symbol = NULL;
-		    resultP->X_add_symbol = NULL;
-		    /* Will be SEG_ABSOLUTE. */
-		    if (resultP->X_seg != SEG_ABSOLUTE || right . X_seg != SEG_ABSOLUTE)
+		  resultP->X_subtract_symbol = NULL;
+		  resultP->X_add_symbol = NULL;
+		  /* Will be SEG_ABSOLUTE. */
+		  if (resultP->X_seg != SEG_ABSOLUTE || right . X_seg != SEG_ABSOLUTE)
 		    {
-			as_bad("Relocation error. Absolute 0 assumed.");
-			resultP->X_seg        = SEG_ABSOLUTE;
-			resultP->X_add_number = 0;
+		      as_bad("Relocation error. Absolute 0 assumed.");
+		      resultP->X_seg        = SEG_ABSOLUTE;
+		      resultP->X_add_number = 0;
 		    }
-		    else
+		  else
 		    {
-			switch (op_left)
+		      switch (op_left)
 			{
 			case O_bit_inclusive_or:
-			    resultP->X_add_number |= right . X_add_number;
-			    break;
-			    
+			  resultP->X_add_number |= right . X_add_number;
+			  break;
+
 			case O_modulus:
-			    if (right . X_add_number)
+			  if (right . X_add_number)
 			    {
-				resultP->X_add_number %= right . X_add_number;
+			      resultP->X_add_number %= right . X_add_number;
 			    }
-			    else
+			  else
 			    {
-				as_warn("Division by 0. 0 assumed.");
-				resultP->X_add_number = 0;
+			      as_warn("Division by 0. 0 assumed.");
+			      resultP->X_add_number = 0;
 			    }
-			    break;
-			    
+			  break;
+
 			case O_bit_and:
-			    resultP->X_add_number &= right . X_add_number;
-			    break;
-			    
+			  resultP->X_add_number &= right . X_add_number;
+			  break;
+
 			case O_multiply:
-			    resultP->X_add_number *= right . X_add_number;
-			    break;
-			    
+			  resultP->X_add_number *= right . X_add_number;
+			  break;
+
 			case O_divide:
-			    if (right . X_add_number)
+			  if (right . X_add_number)
 			    {
-				resultP->X_add_number /= right . X_add_number;
+			      resultP->X_add_number /= right . X_add_number;
 			    }
-			    else
+			  else
 			    {
 				as_warn("Division by 0. 0 assumed.");
 				resultP->X_add_number = 0;