Convert to ISO C90 format. Fix formatting and white space usage as well.

1 files changed, 1826 insertions, 2036 deletions

diff --git a/gas/config/tc-vax.c b/gas/config/tc-vax.c
index bd09752..299746b 100644
--- a/gas/config/tc-vax.c
+++ b/gas/config/tc-vax.c
@@ -25,6 +25,7 @@
 #include "vax-inst.h"
 #include "obstack.h"		/* For FRAG_APPEND_1_CHAR macro in "frags.h" */
 #include "subsegs.h"
+#include "safe-ctype.h"
 
 #ifdef OBJ_ELF
 #include "elf/vax.h"
@@ -40,19 +41,19 @@ const char line_comment_chars[] = "#";
 
 const char line_separator_chars[] = ";";
 
-/* Chars that can be used to separate mant from exp in floating point nums */
+/* Chars that can be used to separate mant from exp in floating point nums.  */
 const char EXP_CHARS[] = "eE";
 
-/* Chars that mean this number is a floating point constant */
-/* as in 0f123.456 */
-/* or    0H1.234E-12 (see exp chars above) */
+/* Chars that mean this number is a floating point constant
+   as in 0f123.456
+   or    0H1.234E-12 (see exp chars above).  */
 const char FLT_CHARS[] = "dDfFgGhH";
 
 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
    changed in read.c .  Ideally it shouldn't have to know about it at all,
    but nothing is ideal around here.  */
 
-/* Hold details of an operand expression */
+/* Hold details of an operand expression.  */
 static expressionS exp_of_operand[VIT_MAX_OPERANDS];
 static segT seg_of_operand[VIT_MAX_OPERANDS];
 
@@ -67,8 +68,8 @@ FLONUM_TYPE float_operand[VIT_MAX_OPERANDS];
 #ifdef OBJ_ELF
 #define GLOBAL_OFFSET_TABLE_NAME	"_GLOBAL_OFFSET_TABLE_"
 #define PROCEDURE_LINKAGE_TABLE_NAME	"_PROCEDURE_LINKAGE_TABLE_"
-symbolS *GOT_symbol;		/* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
-symbolS *PLT_symbol;		/* Pre-defined "_PROCEDURE_LINKAGE_TABLE_" */
+symbolS *GOT_symbol;		/* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
+symbolS *PLT_symbol;		/* Pre-defined "_PROCEDURE_LINKAGE_TABLE_".  */
 #endif
 
 int flag_hash_long_names;	/* -+ */
@@ -79,23 +80,21 @@ int flag_no_hash_mixed_case;	/* -h NUM */
 int flag_want_pic;		/* -k */
 #endif
 
-/*
- * For VAX, relative addresses of "just the right length" are easy.
- * The branch displacement is always the last operand, even in
- * synthetic instructions.
- * For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
- *
- *		    4       3       2       1       0	     bit number
- *	---/ /--+-------+-------+-------+-------+-------+
- *		|     what state ?	|  how long ?	|
- *	---/ /--+-------+-------+-------+-------+-------+
- *
- * The "how long" bits are 00=byte, 01=word, 10=long.
- * This is a Un*x convention.
- * Not all lengths are legit for a given value of (what state).
- * The "how long" refers merely to the displacement length.
- * The address usually has some constant bytes in it as well.
- *
+/* For VAX, relative addresses of "just the right length" are easy.
+   The branch displacement is always the last operand, even in
+   synthetic instructions.
+   For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
+
+  		    4       3       2       1       0	     bit number
+  	---/ /--+-------+-------+-------+-------+-------+
+  		|     what state ?	|  how long ?	|
+  	---/ /--+-------+-------+-------+-------+-------+
+
+   The "how long" bits are 00=byte, 01=word, 10=long.
+   This is a Un*x convention.
+   Not all lengths are legit for a given value of (what state).
+   The "how long" refers merely to the displacement length.
+   The address usually has some constant bytes in it as well.
 
  groups for VAX address relaxing.
 
@@ -182,8 +181,7 @@ int flag_want_pic;		/* -k */
  We can change an opcode's lowest order bit without breaking anything else.
 
  We sometimes store context in the operand literal. This way we can figure out
- after relax() what the original addressing mode was.
- */
+ after relax() what the original addressing mode was.  */
 
 /* These displacements are relative to the start address of the
    displacement.  The first letter is Byte, Word.  2nd letter is
@@ -192,7 +190,7 @@ int flag_want_pic;		/* -k */
 #define BB (1+-128)
 #define WF (2+ 32767)
 #define WB (2+-32768)
-/* Dont need LF, LB because they always reach. [They are coded as 0.] */
+/* Dont need LF, LB because they always reach. [They are coded as 0.]  */
 
 #define C(a,b) ENCODE_RELAX(a,b)
 /* This macro has no side-effects.  */
@@ -239,7 +237,8 @@ const relax_typeS md_relax_table[] =
 #undef WF
 #undef WB
 
-void float_cons PARAMS ((int));
+void float_cons (int);
+int flonum_gen2vax (char, FLONUM_TYPE *, LITTLENUM_TYPE *);
 
 const pseudo_typeS md_pseudo_table[] =
 {
@@ -263,47 +262,12 @@ const pseudo_typeS md_pseudo_table[] =
 #define STATE_BYTE			(0)
 #define STATE_WORD			(1)
 #define STATE_LONG			(2)
-#define STATE_UNDF			(3)	/* Symbol undefined in pass1 */
+#define STATE_UNDF			(3)	/* Symbol undefined in pass1.  */
 
 #define min(a, b)	((a) < (b) ? (a) : (b))
-
-int flonum_gen2vax PARAMS ((char format_letter, FLONUM_TYPE * f,
-			    LITTLENUM_TYPE * words));
-static const char *vip_begin PARAMS ((int, const char *, const char *,
-				      const char *));
-static void vip_op_1 PARAMS ((int, const char *));
-static void vip_op_defaults PARAMS ((const char *, const char *, const char *));
-static void vip_op PARAMS ((char *, struct vop *));
-static void vip PARAMS ((struct vit *, char *));
-
-static int vax_reg_parse PARAMS ((char, char, char, char));
-
-void
-md_begin ()
-{
-  const char *errtxt;
-  FLONUM_TYPE *fP;
-  int i;
-
-  if ((errtxt = vip_begin (1, "$", "*", "`")) != 0)
-    {
-      as_fatal (_("VIP_BEGIN error:%s"), errtxt);
-    }
-
-  for (i = 0, fP = float_operand;
-       fP < float_operand + VIT_MAX_OPERANDS;
-       i++, fP++)
-    {
-      fP->low = &big_operand_bits[i][0];
-      fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
-    }
-}
 
 void
-md_number_to_chars (con, value, nbytes)
-     char con[];
-     valueT value;
-     int nbytes;
+md_number_to_chars (char con[], valueT value, int nbytes)
 {
   number_to_chars_littleendian (con, value, nbytes);
 }
@@ -312,10 +276,7 @@ md_number_to_chars (con, value, nbytes)
    that they reference.  */
 
 void				/* Knows about order of bytes in address.  */
-md_apply_fix (fixP, valueP, seg)
-     fixS *fixP;
-     valueT *valueP;
-     segT seg ATTRIBUTE_UNUSED;
+md_apply_fix (fixS *fixP, valueT *valueP, segT seg ATTRIBUTE_UNUSED)
 {
   valueT value = * valueP;
 
@@ -331,11 +292,11 @@ md_apply_fix (fixP, valueP, seg)
 }
 
 long
-md_chars_to_number (con, nbytes)
-     unsigned char con[];	/* Low order byte 1st.  */
-     int nbytes;		/* Number of bytes in the input.  */
+md_chars_to_number (unsigned char con[],	/* Low order byte 1st.  */
+		    int nbytes)		/* Number of bytes in the input.  */
 {
   long retval;
+
   for (retval = 0, con += nbytes - 1; nbytes--; con--)
     {
       retval <<= BITS_PER_CHAR;
@@ -344,20 +305,18 @@ md_chars_to_number (con, nbytes)
   return retval;
 }
 
-/*
- * Copy a bignum from in to out.
- * If the output is shorter than the input, copy lower-order
- * littlenums.  Return 0 or the number of significant littlenums
- * dropped.  Assumes littlenum arrays are densely packed: no unused
- * chars between the littlenums. Uses memcpy() to move littlenums, and
- * wants to know length (in chars) of the input bignum.
- */
+/* Copy a bignum from in to out.
+   If the output is shorter than the input, copy lower-order
+   littlenums.  Return 0 or the number of significant littlenums
+   dropped.  Assumes littlenum arrays are densely packed: no unused
+   chars between the littlenums. Uses memcpy() to move littlenums, and
+   wants to know length (in chars) of the input bignum.  */
 
 static int
-bignum_copy (register LITTLENUM_TYPE *in,
-	     register int in_length,	/* in sizeof(littlenum)s */
-	     register LITTLENUM_TYPE *out,
-	     register int out_length	/* in sizeof(littlenum)s */)
+bignum_copy (LITTLENUM_TYPE *in,
+	     int in_length,	/* in sizeof(littlenum)s */
+	     LITTLENUM_TYPE *out,
+	     int out_length	/* in sizeof(littlenum)s */)
 {
   int significant_littlenums_dropped;
 
@@ -376,9 +335,7 @@ bignum_copy (register LITTLENUM_TYPE *in,
       significant_littlenums_dropped = p - in - in_length + 1;
 
       if (significant_littlenums_dropped < 0)
-	{
-	  significant_littlenums_dropped = 0;
-	}
+	significant_littlenums_dropped = 0;
     }
   else
     {
@@ -386,891 +343,21 @@ bignum_copy (register LITTLENUM_TYPE *in,
 	      (unsigned int) in_length << LITTLENUM_SHIFT);
 
       if (out_length > in_length)
-	{
-	  memset ((char *) (out + in_length),
-		  '\0',
-		  (unsigned int) (out_length - in_length) << LITTLENUM_SHIFT);
-	}
+	memset ((char *) (out + in_length), '\0',
+		(unsigned int) (out_length - in_length) << LITTLENUM_SHIFT);
 
       significant_littlenums_dropped = 0;
     }
 
-  return (significant_littlenums_dropped);
+  return significant_littlenums_dropped;
 }
 
-/* vax:md_assemble() emit frags for 1 instruction */
-
-void
-md_assemble (instruction_string)
-     char *instruction_string;	/* A string: assemble 1 instruction.  */
-{
-  /* Non-zero if operand expression's segment is not known yet.  */
-  int is_undefined;
-  /* Non-zero if operand expression's segment is absolute.  */
-  int is_absolute;
-
-  int length_code;
-  char *p;
-  /* An operand. Scans all operands.  */
-  struct vop *operandP;
-  char *save_input_line_pointer;
-			/* What used to live after an expression.  */
-  char c_save;
-  /* 1: instruction_string bad for all passes.  */
-  int goofed;
-  /* Points to slot just after last operand.  */
-  struct vop *end_operandP;
-  /* Points to expression values for this operand.  */
-  expressionS *expP;
-  segT *segP;
-
-  /* These refer to an instruction operand expression.  */
-  /* Target segment of the address.	 */
-  segT to_seg;
-  valueT this_add_number;
-  /* Positive (minuend) symbol.  */
-  symbolS *this_add_symbol;
-  /* As a number.  */
-  long opcode_as_number;
-  /* Least significant byte 1st.  */
-  char *opcode_as_chars;
-  /* As an array of characters.  */
-  /* Least significant byte 1st */
-  char *opcode_low_byteP;
-  /* length (bytes) meant by vop_short.  */
-  int length;
-  /* 0, or 1 if '@' is in addressing mode.  */
-  int at;
-  /* From vop_nbytes: vax_operand_width (in bytes) */
-  int nbytes;
-  FLONUM_TYPE *floatP;
-  LITTLENUM_TYPE literal_float[8];
-  /* Big enough for any floating point literal.  */
-
-  vip (&v, instruction_string);
-
-  /*
-   * Now we try to find as many as_warn()s as we can. If we do any as_warn()s
-   * then goofed=1. Notice that we don't make any frags yet.
-   * Should goofed be 1, then this instruction will wedge in any pass,
-   * and we can safely flush it, without causing interpass symbol phase
-   * errors. That is, without changing label values in different passes.
-   */
-  if ((goofed = (*v.vit_error)) != 0)
-    {
-      as_fatal (_("Ignoring statement due to \"%s\""), v.vit_error);
-    }
-  /*
-   * We need to use expression() and friends, which require us to diddle
-   * input_line_pointer. So we save it and restore it later.
-   */
-  save_input_line_pointer = input_line_pointer;
-  for (operandP = v.vit_operand,
-       expP = exp_of_operand,
-       segP = seg_of_operand,
-       floatP = float_operand,
-       end_operandP = v.vit_operand + v.vit_operands;
-
-       operandP < end_operandP;
-
-       operandP++, expP++, segP++, floatP++)
-    {				/* for each operand */
-      if (operandP->vop_error)
-	{
-	  as_fatal (_("Aborting because statement has \"%s\""), operandP->vop_error);
-	  goofed = 1;
-	}
-      else
-	{
-	  /* Statement has no syntax goofs: let's sniff the expression.  */
-	  int can_be_short = 0;	/* 1 if a bignum can be reduced to a short literal.  */
-
-	  input_line_pointer = operandP->vop_expr_begin;
-	  c_save = operandP->vop_expr_end[1];
-	  operandP->vop_expr_end[1] = '\0';
-	  /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1.  */
-	  *segP = expression (expP);
-	  switch (expP->X_op)
-	    {
-	    case O_absent:
-	      /* for BSD4.2 compatibility, missing expression is absolute 0 */
-	      expP->X_op = O_constant;
-	      expP->X_add_number = 0;
-	      /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
-		 X_add_symbol to any particular value.  But, we will program
-		 defensively. Since this situation occurs rarely so it costs
-		 us little to do, and stops Dean worrying about the origin of
-		 random bits in expressionS's.  */
-	      expP->X_add_symbol = NULL;
-	      expP->X_op_symbol = NULL;
-	      break;
-
-	    case O_symbol:
-	    case O_constant:
-	      break;
-
-	    default:
-	      /*
-	       * Major bug. We can't handle the case of a
-	       * SEG_OP expression in a VIT_OPCODE_SYNTHETIC
-	       * variable-length instruction.
-	       * We don't have a frag type that is smart enough to
-	       * relax a SEG_OP, and so we just force all
-	       * SEG_OPs to behave like SEG_PASS1s.
-	       * Clearly, if there is a demand we can invent a new or
-	       * modified frag type and then coding up a frag for this
-	       * case will be easy. SEG_OP was invented for the
-	       * .words after a CASE opcode, and was never intended for
-	       * instruction operands.
-	       */
-	      need_pass_2 = 1;
-	      as_fatal (_("Can't relocate expression"));
-	      break;
-
-	    case O_big:
-	      /* Preserve the bits.  */
-	      if (expP->X_add_number > 0)
-		{
-		  bignum_copy (generic_bignum, expP->X_add_number,
-			       floatP->low, SIZE_OF_LARGE_NUMBER);
-		}
-	      else
-		{
-		  know (expP->X_add_number < 0);
-		  flonum_copy (&generic_floating_point_number,
-			       floatP);
-		  if (strchr ("s i", operandP->vop_short))
-		    {
-		      /* Could possibly become S^# */
-		      flonum_gen2vax (-expP->X_add_number, floatP, literal_float);
-		      switch (-expP->X_add_number)
-			{
-			case 'f':
-			  can_be_short =
-			    (literal_float[0] & 0xFC0F) == 0x4000
-			    && literal_float[1] == 0;
-			  break;
-
-			case 'd':
-			  can_be_short =
-			    (literal_float[0] & 0xFC0F) == 0x4000
-			    && literal_float[1] == 0
-			    && literal_float[2] == 0
-			    && literal_float[3] == 0;
-			  break;
-
-			case 'g':
-			  can_be_short =
-			    (literal_float[0] & 0xFF81) == 0x4000
-			    && literal_float[1] == 0
-			    && literal_float[2] == 0
-			    && literal_float[3] == 0;
-			  break;
-
-			case 'h':
-			  can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
-					  && (literal_float[1] & 0xE000) == 0
-					  && literal_float[2] == 0
-					  && literal_float[3] == 0
-					  && literal_float[4] == 0
-					  && literal_float[5] == 0
-					  && literal_float[6] == 0
-					  && literal_float[7] == 0);
-			  break;
-
-			default:
-			  BAD_CASE (-expP->X_add_number);
-			  break;
-			}	/* switch (float type) */
-		    }		/* if (could want to become S^#...) */
-		}		/* bignum or flonum ? */
-
-	      if (operandP->vop_short == 's'
-		  || operandP->vop_short == 'i'
-		  || (operandP->vop_short == ' '
-		      && operandP->vop_reg == 0xF
-		      && (operandP->vop_mode & 0xE) == 0x8))
-		{
-		  /* Saw a '#'.  */
-		  if (operandP->vop_short == ' ')
-		    {
-		      /* We must chose S^ or I^.  */
-		      if (expP->X_add_number > 0)
-			{
-			  /* Bignum: Short literal impossible.  */
-			  operandP->vop_short = 'i';
-			  operandP->vop_mode = 8;
-			  operandP->vop_reg = 0xF;	/* VAX PC.  */
-			}
-		      else
-			{
-			  /* Flonum: Try to do it.  */
-			  if (can_be_short)
-			    {
-			      operandP->vop_short = 's';
-			      operandP->vop_mode = 0;
-			      operandP->vop_ndx = -1;
-			      operandP->vop_reg = -1;
-			      expP->X_op = O_constant;
-			    }
-			  else
-			    {
-			      operandP->vop_short = 'i';
-			      operandP->vop_mode = 8;
-			      operandP->vop_reg = 0xF;	/* VAX PC */
-			    }
-			}	/* bignum or flonum ? */
-		    }		/*  if #, but no S^ or I^ seen.  */
-		  /* No more ' ' case: either 's' or 'i'.  */
-		  if (operandP->vop_short == 's')
-		    {
-		      /* Wants to be a short literal.  */
-		      if (expP->X_add_number > 0)
-			{
-			  as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
-			  operandP->vop_short = 'i';
-			  operandP->vop_mode = 8;
-			  operandP->vop_reg = 0xF;	/* VAX PC.  */
-			}
-		      else
-			{
-			  if (!can_be_short)
-			    {
-			      as_warn (_("Can't do flonum short literal: immediate mode used."));
-			      operandP->vop_short = 'i';
-			      operandP->vop_mode = 8;
-			      operandP->vop_reg = 0xF;	/* VAX PC.  */
-			    }
-			  else
-			    {	/* Encode short literal now.  */
-			      int temp = 0;
-
-			      switch (-expP->X_add_number)
-				{
-				case 'f':
-				case 'd':
-				  temp = literal_float[0] >> 4;
-				  break;
-
-				case 'g':
-				  temp = literal_float[0] >> 1;
-				  break;
-
-				case 'h':
-				  temp = ((literal_float[0] << 3) & 070)
-				    | ((literal_float[1] >> 13) & 07);
-				  break;
-
-				default:
-				  BAD_CASE (-expP->X_add_number);
-				  break;
-				}
-
-			      floatP->low[0] = temp & 077;
-			      floatP->low[1] = 0;
-			    }	/* if can be short literal float */
-			}	/* flonum or bignum ? */
-		    }
-		  else
-		    {		/* I^# seen: set it up if float.  */
-		      if (expP->X_add_number < 0)
-			{
-			  memcpy (floatP->low, literal_float, sizeof (literal_float));
-			}
-		    }		/* if S^# seen.  */
-		}
-	      else
-		{
-		  as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
-			   (expP->X_add_number = 0x80000000L));
-		  /* Chosen so luser gets the most offset bits to patch later.  */
-		}
-	      expP->X_add_number = floatP->low[0]
-		| ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
-	      /*
-	       * For the O_big case we have:
-	       * If vop_short == 's' then a short floating literal is in the
-	       *	lowest 6 bits of floatP -> low [0], which is
-	       *	big_operand_bits [---] [0].
-	       * If vop_short == 'i' then the appropriate number of elements
-	       *	of big_operand_bits [---] [...] are set up with the correct
-	       *	bits.
-	       * Also, just in case width is byte word or long, we copy the lowest
-	       * 32 bits of the number to X_add_number.
-	       */
-	      break;
-	    }
-	  if (input_line_pointer != operandP->vop_expr_end + 1)
-	    {
-	      as_fatal ("Junk at end of expression \"%s\"", input_line_pointer);
-	      goofed = 1;
-	    }
-	  operandP->vop_expr_end[1] = c_save;
-	}
-    }				/* for(each operand) */
-
-  input_line_pointer = save_input_line_pointer;
-
-  if (need_pass_2 || goofed)
-    {
-      return;
-    }
-
-  /* Emit op-code.  */
-  /* Remember where it is, in case we want to modify the op-code later.  */
-  opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
-  memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
-  opcode_as_chars = v.vit_opcode;
-  opcode_as_number = md_chars_to_number ((unsigned char *) opcode_as_chars, 4);
-  for (operandP = v.vit_operand,
-       expP = exp_of_operand,
-       segP = seg_of_operand,
-       floatP = float_operand,
-       end_operandP = v.vit_operand + v.vit_operands;
-
-       operandP < end_operandP;
-
-       operandP++,
-       floatP++,
-       segP++,
-       expP++)
-    {
-      if (operandP->vop_ndx >= 0)
-	{
-	  /* indexed addressing byte */
-	  /* Legality of indexed mode already checked: it is OK */
-	  FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
-	}			/* if(vop_ndx>=0) */
-
-      /* Here to make main operand frag(s).  */
-      this_add_number = expP->X_add_number;
-      this_add_symbol = expP->X_add_symbol;
-      to_seg = *segP;
-      is_undefined = (to_seg == undefined_section);
-      is_absolute = (to_seg == absolute_section);
-      at = operandP->vop_mode & 1;
-      length = (operandP->vop_short == 'b'
-		? 1 : (operandP->vop_short == 'w'
-		       ? 2 : (operandP->vop_short == 'l'
-			      ? 4 : 0)));
-      nbytes = operandP->vop_nbytes;
-      if (operandP->vop_access == 'b')
-	{
-	  if (to_seg == now_seg || is_undefined)
-	    {
-	      /* If is_undefined, then it might BECOME now_seg.  */
-	      if (nbytes)
-		{
-		  p = frag_more (nbytes);
-		  fix_new (frag_now, p - frag_now->fr_literal, nbytes,
-			   this_add_symbol, this_add_number, 1, NO_RELOC);
-		}
-	      else
-		{		/* to_seg==now_seg || to_seg == SEG_UNKNOWN */
-		  /* nbytes==0 */
-		  length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
-		  if (opcode_as_number & VIT_OPCODE_SPECIAL)
-		    {
-		      if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
-			{
-			  /* br or jsb */
-			  frag_var (rs_machine_dependent, 5, 1,
-			    ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
-				    this_add_symbol, this_add_number,
-				    opcode_low_byteP);
-			}
-		      else
-			{
-			  if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
-			    {
-			      length_code = STATE_WORD;
-			      /* JF: There is no state_byte for this one! */
-			      frag_var (rs_machine_dependent, 10, 2,
-					ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
-					this_add_symbol, this_add_number,
-					opcode_low_byteP);
-			    }
-			  else
-			    {
-			      know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
-			      frag_var (rs_machine_dependent, 9, 1,
-			      ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
-					this_add_symbol, this_add_number,
-					opcode_low_byteP);
-			    }
-			}
-		    }
-		  else
-		    {
-		      know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
-		      frag_var (rs_machine_dependent, 7, 1,
-		       ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
-				this_add_symbol, this_add_number,
-				opcode_low_byteP);
-		    }
-		}
-	    }
-	  else
-	    {
-	      /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
-	      /*
-	       * --- SEG FLOAT MAY APPEAR HERE ----
-	       */
-	      if (is_absolute)
-		{
-		  if (nbytes)
-		    {
-		      know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
-		      p = frag_more (nbytes);
-		      /* Conventional relocation.  */
-		      fix_new (frag_now, p - frag_now->fr_literal, nbytes,
-			       section_symbol (absolute_section),
-			       this_add_number, 1, NO_RELOC);
-		    }
-		  else
-		    {
-		      know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
-		      if (opcode_as_number & VIT_OPCODE_SPECIAL)
-			{
-			  if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
-			    {
-			      /* br or jsb */
-			      *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
-			      know (opcode_as_chars[1] == 0);
-			      p = frag_more (5);
-			      p[0] = VAX_ABSOLUTE_MODE;	/* @#...  */
-			      md_number_to_chars (p + 1, this_add_number, 4);
-			      /* Now (eg) JMP @#foo or JSB @#foo.  */
-			    }
-			  else
-			    {
-			      if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
-				{
-				  p = frag_more (10);
-				  p[0] = 2;
-				  p[1] = 0;
-				  p[2] = VAX_BRB;
-				  p[3] = 6;
-				  p[4] = VAX_JMP;
-				  p[5] = VAX_ABSOLUTE_MODE;	/* @#...  */
-				  md_number_to_chars (p + 6, this_add_number, 4);
-				  /*
-				   * Now (eg)	ACBx	1f
-				   *		BRB	2f
-				   *	1:	JMP	@#foo
-				   *	2:
-				   */
-				}
-			      else
-				{
-				  know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
-				  p = frag_more (9);
-				  p[0] = 2;
-				  p[1] = VAX_BRB;
-				  p[2] = 6;
-				  p[3] = VAX_JMP;
-                                  p[4] = VAX_ABSOLUTE_MODE;     /* @#...  */
-				  md_number_to_chars (p + 5, this_add_number, 4);
-				  /*
-				   * Now (eg)	xOBxxx	1f
-				   *		BRB	2f
-				   *	1:	JMP	@#foo
-				   *	2:
-				   */
-				}
-			    }
-			}
-		      else
-			{
-			  /* b<cond> */
-			  *opcode_low_byteP ^= 1;
-			  /* To reverse the condition in a VAX branch,
-			     complement the lowest order bit.  */
-			  p = frag_more (7);
-			  p[0] = 6;
-			  p[1] = VAX_JMP;
-			  p[2] = VAX_ABSOLUTE_MODE;	/* @#...  */
-			  md_number_to_chars (p + 3, this_add_number, 4);
-			  /*
-			   * Now (eg)	BLEQ	1f
-			   *		JMP	@#foo
-			   *	1:
-			   */
-			}
-		    }
-		}
-	      else
-		{
-		  /* to_seg != now_seg && !is_undefinfed && !is_absolute */
-		  if (nbytes > 0)
-		    {
-		      /* Pc-relative. Conventional relocation.  */
-		      know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
-		      p = frag_more (nbytes);
-		      fix_new (frag_now, p - frag_now->fr_literal, nbytes,
-			       section_symbol (absolute_section),
-			       this_add_number, 1, NO_RELOC);
-		    }
-		  else
-		    {
-		      know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
-		      if (opcode_as_number & VIT_OPCODE_SPECIAL)
-			{
-			  if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
-			    {
-			      /* br or jsb */
-			      know (opcode_as_chars[1] == 0);
-			      *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
-			      p = frag_more (5);
-			      p[0] = VAX_PC_RELATIVE_MODE;
-			      fix_new (frag_now,
-				       p + 1 - frag_now->fr_literal, 4,
-				       this_add_symbol,
-				       this_add_number, 1, NO_RELOC);
-			      /* Now eg JMP foo or JSB foo.  */
-			    }
-			  else
-			    {
-			      if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
-				{
-				  p = frag_more (10);
-				  p[0] = 0;
-				  p[1] = 2;
-				  p[2] = VAX_BRB;
-				  p[3] = 6;
-				  p[4] = VAX_JMP;
-				  p[5] = VAX_PC_RELATIVE_MODE;
-				  fix_new (frag_now,
-					   p + 6 - frag_now->fr_literal, 4,
-					   this_add_symbol,
-					   this_add_number, 1, NO_RELOC);
-				  /*
-				   * Now (eg)	ACBx	1f
-				   *		BRB	2f
-				   *	1:	JMP	foo
-				   *	2:
-				   */
-				}
-			      else
-				{
-				  know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
-				  p = frag_more (10);
-				  p[0] = 2;
-				  p[1] = VAX_BRB;
-				  p[2] = 6;
-				  p[3] = VAX_JMP;
-				  p[4] = VAX_PC_RELATIVE_MODE;
-				  fix_new (frag_now,
-					   p + 5 - frag_now->fr_literal,
-					   4, this_add_symbol,
-					   this_add_number, 1, NO_RELOC);
-				  /*
-				   * Now (eg)	xOBxxx	1f
-				   *		BRB	2f
-				   *	1:	JMP	foo
-				   *	2:
-				   */
-				}
-			    }
-			}
-		      else
-			{
-			  know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
-			  *opcode_low_byteP ^= 1;	/* Reverse branch condition.  */
-			  p = frag_more (7);
-			  p[0] = 6;
-			  p[1] = VAX_JMP;
-			  p[2] = VAX_PC_RELATIVE_MODE;
-			  fix_new (frag_now, p + 3 - frag_now->fr_literal,
-				   4, this_add_symbol,
-				   this_add_number, 1, NO_RELOC);
-			}
-		    }
-		}
-	    }
-	}
-      else
-	{
-	  know (operandP->vop_access != 'b');	/* So it is ordinary operand.  */
-	  know (operandP->vop_access != ' ');	/* ' ' target-independent: elsewhere.  */
-	  know (operandP->vop_access == 'a'
-		|| operandP->vop_access == 'm'
-		|| operandP->vop_access == 'r'
-		|| operandP->vop_access == 'v'
-		|| operandP->vop_access == 'w');
-	  if (operandP->vop_short == 's')
-	    {
-	      if (is_absolute)
-		{
-		  if (this_add_number >= 64)
-		    {
-		      as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
-			       (long) this_add_number);
-		      operandP->vop_short = 'i';
-		      operandP->vop_mode = 8;
-		      operandP->vop_reg = 0xF;
-		    }
-		}
-	      else
-		{
-		  as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
-			   segment_name (now_seg), segment_name (to_seg));
-		  operandP->vop_short = 'i';
-		  operandP->vop_mode = 8;
-		  operandP->vop_reg = 0xF;
-		}
-	    }
-	  if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
-		  || (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
-	    {
-	      /* One byte operand.  */
-	      know (operandP->vop_mode > 3);
-	      FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
-	      /* All 1-bytes except S^# happen here.  */
-	    }
-	  else
-	    {
-	      /* {@}{q^}foo{(Rn)} or S^#foo */
-	      if (operandP->vop_reg == -1 && operandP->vop_short != 's')
-		{
-		  /* "{@}{q^}foo" */
-		  if (to_seg == now_seg)
-		    {
-		      if (length == 0)
-			{
-			  know (operandP->vop_short == ' ');
-			  length_code = STATE_BYTE;
-#ifdef OBJ_ELF
-			  if (S_IS_EXTERNAL (this_add_symbol)
-			      || S_IS_WEAK (this_add_symbol))
-			    length_code = STATE_UNDF;
-#endif
-			  p = frag_var (rs_machine_dependent, 10, 2,
-			       ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
-					this_add_symbol, this_add_number,
-					opcode_low_byteP);
-			  know (operandP->vop_mode == 10 + at);
-			  *p = at << 4;
-			  /* At is the only context we need to carry
-			     to other side of relax() process.  Must
-			     be in the correct bit position of VAX
-			     operand spec. byte.  */
-			}
-		      else
-			{
-			  know (length);
-			  know (operandP->vop_short != ' ');
-			  p = frag_more (length + 1);
-			  p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
-			  fix_new (frag_now, p + 1 - frag_now->fr_literal,
-				   length, this_add_symbol,
-				   this_add_number, 1, NO_RELOC);
-			}
-		    }
-		  else
-		    {		/* to_seg != now_seg */
-		      if (this_add_symbol == NULL)
-			{
-			  know (is_absolute);
-			  /* Do @#foo: simpler relocation than foo-.(pc) anyway.  */
-			  p = frag_more (5);
-			  p[0] = VAX_ABSOLUTE_MODE;	/* @#...  */
-			  md_number_to_chars (p + 1, this_add_number, 4);
-			  if (length && length != 4)
-			    {
-			      as_warn (_("Length specification ignored. Address mode 9F used"));
-			    }
-			}
-		      else
-			{
-			  /* {@}{q^}other_seg */
-			  know ((length == 0 && operandP->vop_short == ' ')
-			     || (length > 0 && operandP->vop_short != ' '));
-			  if (is_undefined
-#ifdef OBJ_ELF
-			      || S_IS_WEAK(this_add_symbol)
-			      || S_IS_EXTERNAL(this_add_symbol)
-#endif
-			      )
-			    {
-			      switch (length)
-				{
-				default: length_code = STATE_UNDF; break;
-				case 1: length_code = STATE_BYTE; break;
-				case 2: length_code = STATE_WORD; break;
-				case 4: length_code = STATE_LONG; break;
-				}
-			      /*
-			       * We have a SEG_UNKNOWN symbol. It might
-			       * turn out to be in the same segment as
-			       * the instruction, permitting relaxation.
-			       */
-			      p = frag_var (rs_machine_dependent, 5, 2,
-			       ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
-					    this_add_symbol, this_add_number,
-					    opcode_low_byteP);
-			      p[0] = at << 4;
-			    }
-			  else
-			    {
-			      if (length == 0)
-				{
-				  know (operandP->vop_short == ' ');
-				  length = 4;	/* Longest possible.  */
-				}
-			      p = frag_more (length + 1);
-			      p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
-			      md_number_to_chars (p + 1, this_add_number, length);
-			      fix_new (frag_now,
-				       p + 1 - frag_now->fr_literal,
-				       length, this_add_symbol,
-				       this_add_number, 1, NO_RELOC);
-			    }
-			}
-		    }
-		}
-	      else
-		{
-		  /* {@}{q^}foo(Rn) or S^# or I^# or # */
-		  if (operandP->vop_mode < 0xA)
-		    {
-		      /* # or S^# or I^# */
-		      if (operandP->vop_access == 'v'
-			  || operandP->vop_access == 'a')
-			{
-			  if (operandP->vop_access == 'v')
-			    as_warn (_("Invalid operand:  immediate value used as base address."));
-			  else
-			    as_warn (_("Invalid operand:  immediate value used as address."));
-			  /* gcc 2.6.3 is known to generate these in at least
-			     one case.  */
-			}
-		      if (length == 0
-			  && is_absolute && (expP->X_op != O_big)
-			  && operandP->vop_mode == 8	/* No '@'.  */
-			  && this_add_number < 64)
-			{
-			  operandP->vop_short = 's';
-			}
-		      if (operandP->vop_short == 's')
-			{
-			  FRAG_APPEND_1_CHAR (this_add_number);
-			}
-		      else
-			{
-			  /* I^#...  */
-			  know (nbytes);
-			  p = frag_more (nbytes + 1);
-			  know (operandP->vop_reg == 0xF);
-#ifdef OBJ_ELF
-			  if (flag_want_pic && operandP->vop_mode == 8
-				&& this_add_symbol != NULL)
-			    {
-			      as_warn (_("Symbol used as immediate operand in PIC mode."));
-			    }
-#endif
-			  p[0] = (operandP->vop_mode << 4) | 0xF;
-			  if ((is_absolute) && (expP->X_op != O_big))
-			    {
-			      /* If nbytes > 4, then we are scrod. We
-			         don't know if the high order bytes
-			         are to be 0xFF or 0x00.  BSD4.2 & RMS
-			         say use 0x00. OK --- but this
-			         assembler needs ANOTHER rewrite to
-			         cope properly with this bug.  */
-			      md_number_to_chars (p + 1, this_add_number,
-						  min (sizeof (valueT),
-						       (size_t) nbytes));
-			      if ((size_t) nbytes > sizeof (valueT))
-				memset (p + 5, '\0', nbytes - sizeof (valueT));
-			    }
-			  else
-			    {
-			      if (expP->X_op == O_big)
-				{
-				  /*
-				   * Problem here is to get the bytes
-				   * in the right order.  We stored
-				   * our constant as LITTLENUMs, not
-				   * bytes.  */
-				  LITTLENUM_TYPE *lP;
-
-				  lP = floatP->low;
-				  if (nbytes & 1)
-				    {
-				      know (nbytes == 1);
-				      p[1] = *lP;
-				    }
-				  else
-				    {
-				      for (p++; nbytes; nbytes -= 2, p += 2, lP++)
-					{
-					  md_number_to_chars (p, *lP, 2);
-					}
-				    }
-				}
-			      else
-				{
-				  fix_new (frag_now, p + 1 - frag_now->fr_literal,
-					   nbytes, this_add_symbol,
-					   this_add_number, 0, NO_RELOC);
-				}
-			    }
-			}
-		    }
-		  else
-		    {		/* {@}{q^}foo(Rn) */
-		      know ((length == 0 && operandP->vop_short == ' ')
-			    || (length > 0 && operandP->vop_short != ' '));
-		      if (length == 0)
-			{
-			  if (is_absolute)
-			    {
-			      long test;
-
-			      test = this_add_number;
-
-			      if (test < 0)
-				test = ~test;
-
-			      length = test & 0xffff8000 ? 4
-				: test & 0xffffff80 ? 2
-				: 1;
-			    }
-			  else
-			    {
-			      length = 4;
-			    }
-			}
-		      p = frag_more (1 + length);
-		      know (operandP->vop_reg >= 0);
-		      p[0] = operandP->vop_reg
-			| ((at | "?\12\14?\16"[length]) << 4);
-		      if (is_absolute)
-			{
-			  md_number_to_chars (p + 1, this_add_number, length);
-			}
-		      else
-			{
-			  fix_new (frag_now, p + 1 - frag_now->fr_literal,
-				   length, this_add_symbol,
-				   this_add_number, 0, NO_RELOC);
-			}
-		    }
-		}
-	    }			/* if(single-byte-operand) */
-	}
-    }				/* for(operandP) */
-}				/* vax_assemble() */
-
 /* md_estimate_size_before_relax(), called just before relax().
    Any symbol that is now undefined will not become defined.
    Return the correct fr_subtype in the frag and the growth beyond
    fr_fix.  */
 int
-md_estimate_size_before_relax (fragP, segment)
-     fragS *fragP;
-     segT segment;
+md_estimate_size_before_relax (fragS *fragP, segT segment)
 {
   if (RELAX_LENGTH (fragP->fr_subtype) == STATE_UNDF)
     {
@@ -1413,22 +500,17 @@ md_estimate_size_before_relax (fragP, segment)
   return md_relax_table[fragP->fr_subtype].rlx_length;
 }
 
-/*
- *			md_convert_frag();
- *
- * Called after relax() is finished.
- * In:	Address of frag.
- *	fr_type == rs_machine_dependent.
- *	fr_subtype is what the address relaxed to.
- *
- * Out:	Any fixSs and constants are set up.
- *	Caller will turn frag into a ".space 0".
- */
+/* Called after relax() is finished.
+   In:	Address of frag.
+  	fr_type == rs_machine_dependent.
+  	fr_subtype is what the address relaxed to.
+
+   Out:	Any fixSs and constants are set up.
+  	Caller will turn frag into a ".space 0".  */
 void
-md_convert_frag (headers, seg, fragP)
-     bfd *headers ATTRIBUTE_UNUSED;
-     segT seg ATTRIBUTE_UNUSED;
-     fragS *fragP;
+md_convert_frag (bfd *headers ATTRIBUTE_UNUSED,
+		 segT seg ATTRIBUTE_UNUSED,
+		 fragS *fragP)
 {
   char *addressP;		/* -> _var to change.  */
   char *opcodeP;		/* -> opcode char(s) to change.  */
@@ -1446,7 +528,6 @@ md_convert_frag (headers, seg, fragP)
 
   switch (fragP->fr_subtype)
     {
-
     case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE):
       know (*addressP == 0 || *addressP == 0x10);	/* '@' bit.  */
       addressP[0] |= 0xAF;	/* Byte displacement. */
@@ -1567,7 +648,7 @@ md_convert_frag (headers, seg, fragP)
       break;
     }
   fragP->fr_fix += extension;
-}				/* md_convert_frag() */
+}
 
 /* Translate internal format of relocation info into target format.
 
@@ -1577,97 +658,87 @@ md_convert_frag (headers, seg, fragP)
    bit 0 as pcrel.  */
 #ifdef comment
 void
-md_ri_to_chars (the_bytes, ri)
-     char *the_bytes;
-     struct reloc_info_generic ri;
+md_ri_to_chars (char *the_bytes, struct reloc_info_generic ri)
 {
-  /* this is easy */
+  /* This is easy.  */
   md_number_to_chars (the_bytes, ri.r_address, sizeof (ri.r_address));
-  /* now the fun stuff */
+  /* Now the fun stuff.  */
   the_bytes[6] = (ri.r_symbolnum >> 16) & 0x0ff;
   the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff;
   the_bytes[4] = ri.r_symbolnum & 0x0ff;
-  the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06) |
-		  ((ri.r_pcrel << 0) & 0x01)) & 0x0F;
+  the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06)
+		  | ((ri.r_pcrel << 0) & 0x01)) & 0x0F;
 }
 
 #endif /* comment */
 
-/*
- *       BUGS, GRIPES,  APOLOGIA, etc.
- *
- * The opcode table 'votstrs' needs to be sorted on opcode frequency.
- * That is, AFTER we hash it with hash_...(), we want most-used opcodes
- * to come out of the hash table faster.
- *
- * I am sorry to inflict yet another VAX assembler on the world, but
- * RMS says we must do everything from scratch, to prevent pin-heads
- * restricting this software.
- */
-
-/*
- * This is a vaguely modular set of routines in C to parse VAX
- * assembly code using DEC mnemonics. It is NOT un*x specific.
- *
- * The idea here is that the assembler has taken care of all:
- *   labels
- *   macros
- *   listing
- *   pseudo-ops
- *   line continuation
- *   comments
- *   condensing any whitespace down to exactly one space
- * and all we have to do is parse 1 line into a vax instruction
- * partially formed. We will accept a line, and deliver:
- *   an error message (hopefully empty)
- *   a skeleton VAX instruction (tree structure)
- *   textual pointers to all the operand expressions
- *   a warning message that notes a silly operand (hopefully empty)
- */
-
-/*
- *		E D I T   H I S T O R Y
- *
- * 17may86 Dean Elsner. Bug if line ends immediately after opcode.
- * 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
- *  6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
- *  2jan86 Dean Elsner. Invent synthetic opcodes.
- *	Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
- *	which means this is not a real opcode, it is like a macro; it will
- *	be relax()ed into 1 or more instructions.
- *	Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
- *	like a regular branch instruction. Option added to vip_begin():
- *	exclude	synthetic opcodes. Invent synthetic_votstrs[].
- * 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
- *	Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
- *	so caller's don't have to know the difference between a 1-byte & a
- *	2-byte op-code. Still need vax_opcodeT concept, so we know how
- *	big an object must be to hold an op.code.
- * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
- *	because vax opcodes may be 16 bits. Our crufty C compiler was
- *	happily initialising 8-bit vot_codes with 16-bit numbers!
- *	(Wouldn't the 'phone company like to compress data so easily!)
- * 29dec85 Dean Elsner. New static table vax_operand_width_size[].
- *	Invented so we know hw many bytes a "I^#42" needs in its immediate
- *	operand. Revised struct vop in "vax-inst.h": explicitly include
- *	byte length of each operand, and it's letter-code datum type.
- * 17nov85 Dean Elsner. Name Change.
- *	Due to ar(1) truncating names, we learned the hard way that
- *	"vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
- *	the archived object name. SO... we shortened the name of this
- *	source file, and changed the makefile.
- */
-
-/* handle of the OPCODE hash table */
+/*       BUGS, GRIPES,  APOLOGIA, etc.
+
+   The opcode table 'votstrs' needs to be sorted on opcode frequency.
+   That is, AFTER we hash it with hash_...(), we want most-used opcodes
+   to come out of the hash table faster.
+
+   I am sorry to inflict yet another VAX assembler on the world, but
+   RMS says we must do everything from scratch, to prevent pin-heads
+   restricting this software.
+
+   This is a vaguely modular set of routines in C to parse VAX
+   assembly code using DEC mnemonics. It is NOT un*x specific.
+
+   The idea here is that the assembler has taken care of all:
+     labels
+     macros
+     listing
+     pseudo-ops
+     line continuation
+     comments
+     condensing any whitespace down to exactly one space
+   and all we have to do is parse 1 line into a vax instruction
+   partially formed. We will accept a line, and deliver:
+     an error message (hopefully empty)
+     a skeleton VAX instruction (tree structure)
+     textual pointers to all the operand expressions
+     a warning message that notes a silly operand (hopefully empty)
+
+  		E D I T   H I S T O R Y
+
+   17may86 Dean Elsner. Bug if line ends immediately after opcode.
+   30apr86 Dean Elsner. New vip_op() uses arg block so change call.
+    6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
+    2jan86 Dean Elsner. Invent synthetic opcodes.
+  	Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
+  	which means this is not a real opcode, it is like a macro; it will
+  	be relax()ed into 1 or more instructions.
+  	Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
+  	like a regular branch instruction. Option added to vip_begin():
+  	exclude	synthetic opcodes. Invent synthetic_votstrs[].
+   31dec85 Dean Elsner. Invent vit_opcode_nbytes.
+  	Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
+  	so caller's don't have to know the difference between a 1-byte & a
+  	2-byte op-code. Still need vax_opcodeT concept, so we know how
+  	big an object must be to hold an op.code.
+   30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
+  	because vax opcodes may be 16 bits. Our crufty C compiler was
+  	happily initialising 8-bit vot_codes with 16-bit numbers!
+  	(Wouldn't the 'phone company like to compress data so easily!)
+   29dec85 Dean Elsner. New static table vax_operand_width_size[].
+  	Invented so we know hw many bytes a "I^#42" needs in its immediate
+  	operand. Revised struct vop in "vax-inst.h": explicitly include
+  	byte length of each operand, and it's letter-code datum type.
+   17nov85 Dean Elsner. Name Change.
+  	Due to ar(1) truncating names, we learned the hard way that
+  	"vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
+  	the archived object name. SO... we shortened the name of this
+  	source file, and changed the makefile.  */
+
+/* Handle of the OPCODE hash table.  */
 static struct hash_control *op_hash;
 
-/*
- * In:	1 character, from "bdfghloqpw" being the data-type of an operand
- *	of a vax instruction.
- *
- * Out:	the length of an operand of that type, in bytes.
- *	Special branch operands types "-?!" have length 0.
- */
+/* In:	1 character, from "bdfghloqpw" being the data-type of an operand
+  	of a vax instruction.
+
+   Out:	the length of an operand of that type, in bytes.
+  	Special branch operands types "-?!" have length 0.  */
 
 static const short int vax_operand_width_size[256] =
 {
@@ -1689,53 +760,48 @@ static const short int vax_operand_width_size[256] =
   0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
 };
 
-/*
- * This perversion encodes all the vax opcodes as a bunch of strings.
- * RMS says we should build our hash-table at run-time. Hmm.
- * Please would someone arrange these in decreasing frequency of opcode?
- * Because of the way hash_...() works, the most frequently used opcode
- * should be textually first and so on.
- *
- * Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
- * So change 'vax.opcodes', then re-generate this table.
- */
+/* This perversion encodes all the vax opcodes as a bunch of strings.
+   RMS says we should build our hash-table at run-time. Hmm.
+   Please would someone arrange these in decreasing frequency of opcode?
+   Because of the way hash_...() works, the most frequently used opcode
+   should be textually first and so on.
+
+   Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
+   So change 'vax.opcodes', then re-generate this table.  */
 
 #include "opcode/vax.h"
 
-/*
- * This is a table of optional op-codes. All of them represent
- * 'synthetic' instructions that seem popular.
- *
- * Here we make some pseudo op-codes. Every code has a bit set to say
- * it is synthetic. This lets you catch them if you want to
- * ban these opcodes. They are mnemonics for "elastic" instructions
- * that are supposed to assemble into the fewest bytes needed to do a
- * branch, or to do a conditional branch, or whatever.
- *
- * The opcode is in the usual place [low-order n*8 bits]. This means
- * that if you mask off the bucky bits, the usual rules apply about
- * how long the opcode is.
- *
- * All VAX branch displacements come at the end of the instruction.
- * For simple branches (1-byte opcode + 1-byte displacement) the last
- * operand is coded 'b?' where the "data type" '?' is a clue that we
- * may reverse the sense of the branch (complement lowest order bit)
- * and branch around a jump. This is by far the most common case.
- * That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
- * a 0-byte op-code followed by 2 or more bytes of operand address.
- *
- * If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
- * case.
- *
- * For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
- * option before (2) we can directly JSB/JMP because there is no condition.
- * These operands have 'b-' as their access/data type.
- *
- * That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
- * cases, we do the same idea. JACBxxx are all marked with a 'b!'
- * JAOBxxx & JSOBxxx are marked with a 'b:'.
- *
- */
+/* This is a table of optional op-codes. All of them represent
+   'synthetic' instructions that seem popular.
+
+   Here we make some pseudo op-codes. Every code has a bit set to say
+   it is synthetic. This lets you catch them if you want to
+   ban these opcodes. They are mnemonics for "elastic" instructions
+   that are supposed to assemble into the fewest bytes needed to do a
+   branch, or to do a conditional branch, or whatever.
+  
+   The opcode is in the usual place [low-order n*8 bits]. This means
+   that if you mask off the bucky bits, the usual rules apply about
+   how long the opcode is.
+  
+   All VAX branch displacements come at the end of the instruction.
+   For simple branches (1-byte opcode + 1-byte displacement) the last
+   operand is coded 'b?' where the "data type" '?' is a clue that we
+   may reverse the sense of the branch (complement lowest order bit)
+   and branch around a jump. This is by far the most common case.
+   That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
+   a 0-byte op-code followed by 2 or more bytes of operand address.
+  
+   If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
+   case.
+  
+   For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
+   option before (2) we can directly JSB/JMP because there is no condition.
+   These operands have 'b-' as their access/data type.
+  
+   That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
+   cases, we do the same idea. JACBxxx are all marked with a 'b!'
+   JAOBxxx & JSOBxxx are marked with a 'b:'.  */
 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
 You have just broken the encoding below, which assumes the sign bit
   means 'I am an imaginary instruction'.
@@ -1796,25 +862,95 @@ static const struct vot
 /* CASEx has no branch addresses in our conception of it.  */
 /* You should use ".word ..." statements after the "case ...".  */
 
-  {"",	{"", 0}}			/* empty is end sentinel */
-
-};				/* synthetic_votstrs */
+  {"",		{"", 0}}	/* Empty is end sentinel.  */
+};
 
-/*
- *                  v i p _ b e g i n ( )
- *
- * Call me once before you decode any lines.
- * I decode votstrs into a hash table at op_hash (which I create).
- * I return an error text or null.
- * If you want, I will include the 'synthetic' jXXX instructions in the
- * instruction table.
- * You must nominate metacharacters for eg DEC's "#", "@", "^".
- */
+/* Because this module is useful for both VMS and UN*X style assemblers
+   and because of the variety of UN*X assemblers we must recognise
+   the different conventions for assembler operand notation. For example
+   VMS says "#42" for immediate mode, while most UN*X say "$42".
+   We permit arbitrary sets of (single) characters to represent the
+   3 concepts that DEC writes '#', '@', '^'.  */
+
+/* Character tests.  */
+#define VIP_IMMEDIATE 01	/* Character is like DEC # */
+#define VIP_INDIRECT  02	/* Char is like DEC @ */
+#define VIP_DISPLEN   04	/* Char is like DEC ^ */
+
+#define IMMEDIATEP(c)	(vip_metacharacters [(c) & 0xff] & VIP_IMMEDIATE)
+#define INDIRECTP(c)	(vip_metacharacters [(c) & 0xff] & VIP_INDIRECT)
+#define DISPLENP(c)	(vip_metacharacters [(c) & 0xff] & VIP_DISPLEN)
+
+/* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
+   are ever called.  */
+
+#if defined(CONST_TABLE)
+#define _ 0,
+#define I VIP_IMMEDIATE,
+#define S VIP_INDIRECT,
+#define D VIP_DISPLEN,
+static const char
+vip_metacharacters[256] =
+{
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
+  _ _ _ _ I _ _ _ _ _ S _ _ _ _ _	/* sp !  "  #  $  %  & '  (  )  *  +  ,  -  .  / */
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?*/
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*@  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O*/
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _*/
+  D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*`  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o*/
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~  ^?*/
+
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+};
+#undef _
+#undef I
+#undef S
+#undef D
+
+#else
+
+static char vip_metacharacters[256];
+
+static void
+vip_op_1 (int bit, const char *syms)
+{
+  unsigned char t;
+
+  while ((t = *syms++) != 0)
+    vip_metacharacters[t] |= bit;
+}
+
+/* Can be called any time.  More arguments may appear in future.  */
+static void
+vip_op_defaults (const char *immediate, const char *indirect, const char *displen)
+{
+  vip_op_1 (VIP_IMMEDIATE, immediate);
+  vip_op_1 (VIP_INDIRECT, indirect);
+  vip_op_1 (VIP_DISPLEN, displen);
+}
+
+#endif
+
+/* Call me once before you decode any lines.
+   I decode votstrs into a hash table at op_hash (which I create).
+   I return an error text or null.
+   If you want, I will include the 'synthetic' jXXX instructions in the
+   instruction table.
+   You must nominate metacharacters for eg DEC's "#", "@", "^".  */
 
 static const char *
-vip_begin (synthetic_too, immediate, indirect, displen)
-     int synthetic_too;		/* 1 means include jXXX op-codes.  */
-     const char *immediate, *indirect, *displen;
+vip_begin (int synthetic_too,		/* 1 means include jXXX op-codes.  */
+	   const char *immediate,
+	   const char *indirect,
+	   const char *displen)
 {
   const struct vot *vP;		/* scan votstrs */
   const char *retval = 0;	/* error text */
@@ -1835,303 +971,65 @@ vip_begin (synthetic_too, immediate, indirect, displen)
   return retval;
 }
 
-/*
- *                  v i p ( )
- *
- * This converts a string into a vax instruction.
- * The string must be a bare single instruction in dec-vax (with BSD4 frobs)
- * format.
- * It provides some error messages: at most one fatal error message (which
- * stops the scan) and at most one warning message for each operand.
- * The vax instruction is returned in exploded form, since we have no
- * knowledge of how you parse (or evaluate) your expressions.
- * We do however strip off and decode addressing modes and operation
- * mnemonic.
- *
- * The exploded instruction is returned to a struct vit of your choice.
- * #include "vax-inst.h" to know what a struct vit is.
- *
- * This function's value is a string. If it is not "" then an internal
- * logic error was found: read this code to assign meaning to the string.
- * No argument string should generate such an error string:
- * it means a bug in our code, not in the user's text.
- *
- * You MUST have called vip_begin() once before using this function.
- */
-
-static void
-vip (vitP, instring)
-     struct vit *vitP;		/* We build an exploded instruction here.  */
-     char *instring;		/* Text of a vax instruction: we modify.  */
-{
-  /* How to bit-encode this opcode.  */
-  struct vot_wot *vwP;
-  /* 1/skip whitespace.2/scan vot_how */
-  char *p;
-  char *q;
-  /* counts number of operands seen */
-  unsigned char count;
-  /* scan operands in struct vit */
-  struct vop *operandp;
-  /* error over all operands */
-  const char *alloperr;
-  /* Remember char, (we clobber it with '\0' temporarily).  */
-  char c;
-  /* Op-code of this instruction.  */
-  vax_opcodeT oc;
-
-  if (*instring == ' ')
-    ++instring;			/* Skip leading whitespace.  */
-  for (p = instring; *p && *p != ' '; p++);;	/* MUST end in end-of-string or exactly 1 space.  */
-  /* Scanned up to end of operation-code.  */
-  /* Operation-code is ended with whitespace.  */
-  if (p - instring == 0)
-    {
-      vitP->vit_error = _("No operator");
-      count = 0;
-      memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
-    }
-  else
-    {
-      c = *p;
-      *p = '\0';
-      /*
-       * Here with instring pointing to what better be an op-name, and p
-       * pointing to character just past that.
-       * We trust instring points to an op-name, with no whitespace.
-       */
-      vwP = (struct vot_wot *) hash_find (op_hash, instring);
-      *p = c;			/* Restore char after op-code.  */
-      if (vwP == 0)
-	{
-	  vitP->vit_error = _("Unknown operator");
-	  count = 0;
-	  memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
-	}
-      else
-	{
-	  /*
-	   * We found a match! So let's pick up as many operands as the
-	   * instruction wants, and even gripe if there are too many.
-	   * We expect comma to separate each operand.
-	   * We let instring track the text, while p tracks a part of the
-	   * struct vot.
-	   */
-	  const char *howp;
-	  /*
-	   * The lines below know about 2-byte opcodes starting FD,FE or FF.
-	   * They also understand synthetic opcodes. Note:
-	   * we return 32 bits of opcode, including bucky bits, BUT
-	   * an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
-	   */
-	  oc = vwP->vot_code;	/* The op-code.  */
-	  vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
-	  md_number_to_chars (vitP->vit_opcode, oc, 4);
-	  count = 0;		/* no operands seen yet */
-	  instring = p;		/* point just past operation code */
-	  alloperr = "";
-	  for (howp = vwP->vot_how, operandp = vitP->vit_operand;
-	       !(alloperr && *alloperr) && *howp;
-	       operandp++, howp += 2)
-	    {
-	      /*
-	       * Here to parse one operand. Leave instring pointing just
-	       * past any one ',' that marks the end of this operand.
-	       */
-	      if (!howp[1])
-		as_fatal (_("odd number of bytes in operand description"));
-	      else if (*instring)
-		{
-		  for (q = instring; (c = *q) && c != ','; q++)
-		    ;
-		  /*
-		   * Q points to ',' or '\0' that ends argument. C is that
-		   * character.
-		   */
-		  *q = 0;
-		  operandp->vop_width = howp[1];
-		  operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]];
-		  operandp->vop_access = howp[0];
-		  vip_op (instring, operandp);
-		  *q = c;	/* Restore input text.  */
-		  if (operandp->vop_error)
-		    alloperr = _("Bad operand");
-		  instring = q + (c ? 1 : 0);	/* next operand (if any) */
-		  count++;	/*  won another argument, may have an operr */
-		}
-	      else
-		alloperr = _("Not enough operands");
-	    }
-	  if (!*alloperr)
-	    {
-	      if (*instring == ' ')
-		instring++;	/* Skip whitespace.  */
-	      if (*instring)
-		alloperr = _("Too many operands");
-	    }
-	  vitP->vit_error = alloperr;
-	}
-    }
-  vitP->vit_operands = count;
-}
-
-#ifdef test
-
-/*
- * Test program for above.
- */
-
-struct vit myvit;		/* build an exploded vax instruction here */
-char answer[100];		/* human types a line of vax assembler here */
-char *mybug;			/* "" or an internal logic diagnostic */
-int mycount;			/* number of operands */
-struct vop *myvop;		/* scan operands from myvit */
-int mysynth;			/* 1 means want synthetic opcodes.  */
-char my_immediate[200];
-char my_indirect[200];
-char my_displen[200];
+/* Take 3 char.s, the last of which may be `\0` (non-existent)
+   and return the VAX register number that they represent.
+  
+   Return -1 if they don't form a register name. Good names return
+   a number from 0:15 inclusive.
+  
+   Case is not important in a name.
+  
+   Register names understood are:
+  
+  	R0
+  	R1
+  	R2
+  	R3
+  	R4
+  	R5
+  	R6
+   	R7
+  	R8
+  	R9
+  	R10
+  	R11
+  	R12	AP
+  	R13	FP
+  	R14	SP
+  	R15	PC  */
 
-main ()
-{
-  char *p;
-
-  printf ("0 means no synthetic instructions.   ");
-  printf ("Value for vip_begin?  ");
-  gets (answer);
-  sscanf (answer, "%d", &mysynth);
-  printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
-  printf ("enter immediate symbols eg enter #   ");
-  gets (my_immediate);
-  printf ("enter indirect symbols  eg enter @   ");
-  gets (my_indirect);
-  printf ("enter displen symbols   eg enter ^   ");
-  gets (my_displen);
-  if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))
-    {
-      error ("vip_begin=%s", p);
-    }
-  printf ("An empty input line will quit you from the vax instruction parser\n");
-  for (;;)
-    {
-      printf ("vax instruction: ");
-      fflush (stdout);
-      gets (answer);
-      if (!*answer)
-	{
-	  break;		/* out of for each input text loop */
-	}
-      vip (&myvit, answer);
-      if (*myvit.vit_error)
-	{
-	  printf ("ERR:\"%s\"\n", myvit.vit_error);
-	}
-      printf ("opcode=");
-      for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
-	   mycount;
-	   mycount--, p++
-	)
-	{
-	  printf ("%02x ", *p & 0xFF);
-	}
-      printf ("   operand count=%d.\n", mycount = myvit.vit_operands);
-      for (myvop = myvit.vit_operand; mycount; mycount--, myvop++)
-	{
-	  printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
-		  myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
-		  myvop->vop_short, myvop->vop_access, myvop->vop_width,
-		  myvop->vop_nbytes);
-	  for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++)
-	    {
-	      putchar (*p);
-	    }
-	  printf ("\"\n");
-	  if (myvop->vop_error)
-	    {
-	      printf ("  err:\"%s\"\n", myvop->vop_error);
-	    }
-	  if (myvop->vop_warn)
-	    {
-	      printf ("  wrn:\"%s\"\n", myvop->vop_warn);
-	    }
-	}
-    }
-  vip_end ();
-  exit (EXIT_SUCCESS);
-}
-
-#endif /* #ifdef test */
-
-/* end of vax_ins_parse.c */
-
-/* vax_reg_parse.c - convert a VAX register name to a number */
-
-/* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU.  */
-
-/*
- *          v a x _ r e g _ p a r s e ( )
- *
- * Take 3 char.s, the last of which may be `\0` (non-existent)
- * and return the VAX register number that they represent.
- *
- * Return -1 if they don't form a register name. Good names return
- * a number from 0:15 inclusive.
- *
- * Case is not important in a name.
- *
- * Register names understood are:
- *
- *	R0
- *	R1
- *	R2
- *	R3
- *	R4
- *	R5
- *	R6
- * 	R7
- *	R8
- *	R9
- *	R10
- *	R11
- *	R12	AP
- *	R13	FP
- *	R14	SP
- *	R15	PC
- *
- */
-
-#include "safe-ctype.h"
 #define AP (12)
 #define FP (13)
 #define SP (14)
 #define PC (15)
-
-int				/* return -1 or 0:15 */
-vax_reg_parse (c1, c2, c3, c4)	/* 3 chars of register name */
-     char c1, c2, c3, c4;	/* c3 == 0 if 2-character reg name */
+
+static int				/* Return -1 or 0:15.  */
+vax_reg_parse (char c1, char c2,	/* 3 chars of register name.  */
+	       char c3, char c4)	/* c3 == 0 if 2-character reg name.  */
 {
-  int retval;		/* return -1:15 */
+  int retval;
 
   retval = -1;
 
 #ifdef OBJ_ELF
-  if (c1 != '%')	/* register prefixes are mandatory for ELF */
+  if (c1 != '%')	/* Register prefixes are mandatory for ELF.  */
     return retval;
   c1 = c2;
   c2 = c3;
   c3 = c4;
 #endif
 #ifdef OBJ_VMS
-  if (c4 != 0)		/* register prefixes are not allowed under VMS */
+  if (c4 != 0)		/* Register prefixes are not allowed under VMS.  */
     return retval;
 #endif
 #ifdef OBJ_AOUT
-  if (c1 == '%')	/* register prefixes are optional under a.out */
+  if (c1 == '%')	/* Register prefixes are optional under a.out.  */
     {
       c1 = c2;
       c2 = c3;
       c3 = c4;
     }
-  else if (c3 && c4)	/* can't be 4 characters long.  */
+  else if (c3 && c4)	/* Can't be 4 characters long.  */
     return retval;
 #endif
 
@@ -2147,9 +1045,9 @@ vax_reg_parse (c1, c2, c3, c4)	/* 3 chars of register name */
 	  /* clamp the register value to 1 hex digit */
 	}
       else if (c3)
-	retval = -1;		/* c3 must be '\0' or a digit */
+	retval = -1;		/* c3 must be '\0' or a digit.  */
     }
-  else if (c3)			/* There are no three letter regs */
+  else if (c3)			/* There are no three letter regs.  */
     retval = -1;
   else if (c2 == 'p')
     {
@@ -2172,290 +1070,206 @@ vax_reg_parse (c1, c2, c3, c4)	/* 3 chars of register name */
     retval = PC;
   else
     retval = -1;
-  return (retval);
-}
-
-/*
- *               v i p _ o p ( )
- *
- * Parse a vax operand in DEC assembler notation.
- * For speed, expect a string of whitespace to be reduced to a single ' '.
- * This is the case for GNU AS, and is easy for other DEC-compatible
- * assemblers.
- *
- * Knowledge about DEC VAX assembler operand notation lives here.
- * This doesn't even know what a register name is, except it believes
- * all register names are 2 or 3 characters, and lets vax_reg_parse() say
- * what number each name represents.
- * It does, however, know that PC, SP etc are special registers so it can
- * detect addressing modes that are silly for those registers.
- *
- * Where possible, it delivers 1 fatal or 1 warning message if the operand
- * is suspect. Exactly what we test for is still evolving.
- */
-
-/*
- *		   	B u g s
- *
- *	Arg block.
- *
- * There were a number of 'mismatched argument type' bugs to vip_op.
- * The most general solution is to typedef each (of many) arguments.
- * We used instead a typedef'd argument block. This is less modular
- * than using separate return pointers for each result, but runs faster
- * on most engines, and seems to keep programmers happy. It will have
- * to be done properly if we ever want to use vip_op as a general-purpose
- * module (it was designed to be).
- *
- *	G^
- *
- * Doesn't support DEC "G^" format operands. These always take 5 bytes
- * to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
- * optimising to (say) a "B^" if you are lucky in the way you link.
- * When someone builds a linker smart enough to convert "G^" to "B^", "W^"
- * whenever possible, then we should implement it.
- * If there is some other use for "G^", feel free to code it in!
- *
- *
- *	speed
- *
- * If I nested if()s more, I could avoid testing (*err) which would save
- * time, space and page faults. I didn't nest all those if()s for clarity
- * and because I think the mode testing can be re-arranged 1st to test the
- * commoner constructs 1st. Does anybody have statistics on this?
- *
- *
- *
- *	error messages
- *
- * In future, we should be able to 'compose' error messages in a scratch area
- * and give the user MUCH more informative error messages. Although this takes
- * a little more code at run-time, it will make this module much more self-
- * documenting. As an example of what sucks now: most error messages have
- * hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
- * the Un*x characters "$`*", that most users will expect from this AS.
- */
-
-/*
- * The input is a string, ending with '\0'.
- *
- * We also require a 'hint' of what kind of operand is expected: so
- * we can remind caller not to write into literals for instance.
- *
- * The output is a skeletal instruction.
- *
- * The algorithm has two parts.
- * 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
- * 2. express the @^#-()+[] as some parameters suited to further analysis.
- *
- * 2nd step is where we detect the googles of possible invalid combinations
- * a human (or compiler) might write. Note that if we do a half-way
- * decent assembler, we don't know how long to make (eg) displacement
- * fields when we first meet them (because they may not have defined values).
- * So we must wait until we know how many bits are needed for each address,
- * then we can know both length and opcodes of instructions.
- * For reason(s) above, we will pass to our caller a 'broken' instruction
- * of these major components, from which our caller can generate instructions:
- *  -  displacement length      I^ S^ L^ B^ W^ unspecified
- *  -  mode                     (many)
- *  -  register                 R0-R15 or absent
- *  -  index register           R0-R15 or absent
- *  -  expression text          what we don't parse
- *  -  error text(s)            why we couldn't understand the operand
- */
-
-/*
- * To decode output of this, test errtxt. If errtxt[0] == '\0', then
- * we had no errors that prevented parsing. Also, if we ever report
- * an internal bug, errtxt[0] is set non-zero. So one test tells you
- * if the other outputs are to be taken seriously.
- */
-
-/*
- * Because this module is useful for both VMS and UN*X style assemblers
- * and because of the variety of UN*X assemblers we must recognise
- * the different conventions for assembler operand notation. For example
- * VMS says "#42" for immediate mode, while most UN*X say "$42".
- * We permit arbitrary sets of (single) characters to represent the
- * 3 concepts that DEC writes '#', '@', '^'.
- */
-
-/* character tests */
-#define VIP_IMMEDIATE 01	/* Character is like DEC # */
-#define VIP_INDIRECT  02	/* Char is like DEC @ */
-#define VIP_DISPLEN   04	/* Char is like DEC ^ */
-
-#define IMMEDIATEP(c)	(vip_metacharacters [(c)&0xff]&VIP_IMMEDIATE)
-#define INDIRECTP(c)	(vip_metacharacters [(c)&0xff]&VIP_INDIRECT)
-#define DISPLENP(c)	(vip_metacharacters [(c)&0xff]&VIP_DISPLEN)
-
-/* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
- * are ever called.
- */
-
-#if defined(CONST_TABLE)
-#define _ 0,
-#define I VIP_IMMEDIATE,
-#define S VIP_INDIRECT,
-#define D VIP_DISPLEN,
-static const char
-vip_metacharacters[256] =
-{
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
-  _ _ _ _ I _ _ _ _ _ S _ _ _ _ _	/* sp !  "  #  $  %  & '  (  )  *  +  ,  -  .  / */
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?*/
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*@  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O*/
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _*/
-  D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*`  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o*/
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _	/*p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~  ^?*/
-
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-};
-#undef _
-#undef I
-#undef S
-#undef D
-#else
-static char vip_metacharacters[256];
-
-static void
-vip_op_1 (bit, syms)
-     int bit;
-     const char *syms;
-{
-  unsigned char t;
-
-  while ((t = *syms++) != 0)
-    vip_metacharacters[t] |= bit;
+  return retval;
 }
 
-/* Can be called any time.  More arguments may appear in future.  */
-static void
-vip_op_defaults (immediate, indirect, displen)
-     const char *immediate;
-     const char *indirect;
-     const char *displen;
-{
-  vip_op_1 (VIP_IMMEDIATE, immediate);
-  vip_op_1 (VIP_INDIRECT, indirect);
-  vip_op_1 (VIP_DISPLEN, displen);
-}
+/* Parse a vax operand in DEC assembler notation.
+   For speed, expect a string of whitespace to be reduced to a single ' '.
+   This is the case for GNU AS, and is easy for other DEC-compatible
+   assemblers.
+  
+   Knowledge about DEC VAX assembler operand notation lives here.
+   This doesn't even know what a register name is, except it believes
+   all register names are 2 or 3 characters, and lets vax_reg_parse() say
+   what number each name represents.
+   It does, however, know that PC, SP etc are special registers so it can
+   detect addressing modes that are silly for those registers.
+  
+   Where possible, it delivers 1 fatal or 1 warning message if the operand
+   is suspect. Exactly what we test for is still evolving.
+
+   ---
+  	Arg block.
+  
+   There were a number of 'mismatched argument type' bugs to vip_op.
+   The most general solution is to typedef each (of many) arguments.
+   We used instead a typedef'd argument block. This is less modular
+   than using separate return pointers for each result, but runs faster
+   on most engines, and seems to keep programmers happy. It will have
+   to be done properly if we ever want to use vip_op as a general-purpose
+   module (it was designed to be).
+  
+ 	G^
+
+   Doesn't support DEC "G^" format operands. These always take 5 bytes
+   to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
+   optimising to (say) a "B^" if you are lucky in the way you link.
+   When someone builds a linker smart enough to convert "G^" to "B^", "W^"
+   whenever possible, then we should implement it.
+   If there is some other use for "G^", feel free to code it in!
+
+  	speed
+  
+   If I nested if()s more, I could avoid testing (*err) which would save
+   time, space and page faults. I didn't nest all those if()s for clarity
+   and because I think the mode testing can be re-arranged 1st to test the
+   commoner constructs 1st. Does anybody have statistics on this?  
+  
+  	error messages
+  
+   In future, we should be able to 'compose' error messages in a scratch area
+   and give the user MUCH more informative error messages. Although this takes
+   a little more code at run-time, it will make this module much more self-
+   documenting. As an example of what sucks now: most error messages have
+   hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
+   the Un*x characters "$`*", that most users will expect from this AS.
+
+   ----
+   
+   The input is a string, ending with '\0'.
+  
+   We also require a 'hint' of what kind of operand is expected: so
+   we can remind caller not to write into literals for instance.
+  
+   The output is a skeletal instruction.
+  
+   The algorithm has two parts.
+   1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
+   2. express the @^#-()+[] as some parameters suited to further analysis.
+  
+   2nd step is where we detect the googles of possible invalid combinations
+   a human (or compiler) might write. Note that if we do a half-way
+   decent assembler, we don't know how long to make (eg) displacement
+   fields when we first meet them (because they may not have defined values).
+   So we must wait until we know how many bits are needed for each address,
+   then we can know both length and opcodes of instructions.
+   For reason(s) above, we will pass to our caller a 'broken' instruction
+   of these major components, from which our caller can generate instructions:
+    -  displacement length      I^ S^ L^ B^ W^ unspecified
+    -  mode                     (many)
+    -  register                 R0-R15 or absent
+    -  index register           R0-R15 or absent
+    -  expression text          what we don't parse
+    -  error text(s)            why we couldn't understand the operand
+
+   ----
+    
+   To decode output of this, test errtxt. If errtxt[0] == '\0', then
+   we had no errors that prevented parsing. Also, if we ever report
+   an internal bug, errtxt[0] is set non-zero. So one test tells you
+   if the other outputs are to be taken seriously.
+
+   ----
+   
+   Dec defines the semantics of address modes (and values)
+   by a two-letter code, explained here.
+  
+     letter 1:   access type
+  
+       a         address calculation - no data access, registers forbidden
+       b         branch displacement
+       m         read - let go of bus - write back    "modify"
+       r         read
+       v         bit field address: like 'a' but registers are OK
+       w         write
+       space	 no operator (eg ".long foo") [our convention]
+  
+     letter 2:   data type (i.e. width, alignment)
+  
+       b         byte
+       d         double precision floating point (D format)
+       f         single precision floating point (F format)
+       g         G format floating
+       h         H format floating
+       l         longword
+       o         octaword
+       q         quadword
+       w         word
+       ?	 simple synthetic branch operand
+       -	 unconditional synthetic JSB/JSR operand
+       !	 complex synthetic branch operand
+  
+   The '-?!' letter 2's are not for external consumption. They are used
+   for various assemblers. Generally, all unknown widths are assumed 0.
+   We don't limit your choice of width character.
+  
+   DEC operands are hard work to parse. For example, '@' as the first
+   character means indirect (deferred) mode but elsewhere it is a shift
+   operator.
+   The long-winded explanation of how this is supposed to work is
+   cancelled. Read a DEC vax manual.
+   We try hard not to parse anything that MIGHT be part of the expression
+   buried in that syntax. For example if we see @...(Rn) we don't check
+   for '-' before the '(' because mode @-(Rn) does not exist.
+  
+   After parsing we have:
+  
+   at                     1 if leading '@' (or Un*x '*')
+   len                    takes one value from " bilsw". eg B^ -> 'b'.
+   hash                   1 if leading '#' (or Un*x '$')
+   expr_begin, expr_end   the expression we did not parse
+                          even though we don't interpret it, we make use
+                          of its presence or absence.
+   sign                   -1: -(Rn)    0: absent    +1: (Rn)+
+   paren                  1 if () are around register
+   reg                    major register number 0:15    -1 means absent
+   ndx                    index register number 0:15    -1 means absent
+  
+   Again, I dare not explain it: just trace ALL the code!
+
+   Summary of vip_op outputs.
 
-#endif
-
+  mode	reg	len	ndx
+  (Rn) => @Rn
+  {@}Rn			5+@	n	' '	optional
+  branch operand		0	-1	' '	-1
+  S^#foo			0	-1	's'	-1
+  -(Rn)			7	n	' '	optional
+  {@}(Rn)+		8+@	n	' '	optional
+  {@}#foo, no S^		8+@	PC	" i"	optional
+  {@}{q^}{(Rn)}		10+@+q	option	" bwl"	optional  */
 
-/*
- * Dec defines the semantics of address modes (and values)
- * by a two-letter code, explained here.
- *
- *   letter 1:   access type
- *
- *     a         address calculation - no data access, registers forbidden
- *     b         branch displacement
- *     m         read - let go of bus - write back    "modify"
- *     r         read
- *     v         bit field address: like 'a' but registers are OK
- *     w         write
- *     space	 no operator (eg ".long foo") [our convention]
- *
- *   letter 2:   data type (i.e. width, alignment)
- *
- *     b         byte
- *     d         double precision floating point (D format)
- *     f         single precision floating point (F format)
- *     g         G format floating
- *     h         H format floating
- *     l         longword
- *     o         octaword
- *     q         quadword
- *     w         word
- *     ?	 simple synthetic branch operand
- *     -	 unconditional synthetic JSB/JSR operand
- *     !	 complex synthetic branch operand
- *
- * The '-?!' letter 2's are not for external consumption. They are used
- * for various assemblers. Generally, all unknown widths are assumed 0.
- * We don't limit your choice of width character.
- *
- * DEC operands are hard work to parse. For example, '@' as the first
- * character means indirect (deferred) mode but elsewhere it is a shift
- * operator.
- * The long-winded explanation of how this is supposed to work is
- * cancelled. Read a DEC vax manual.
- * We try hard not to parse anything that MIGHT be part of the expression
- * buried in that syntax. For example if we see @...(Rn) we don't check
- * for '-' before the '(' because mode @-(Rn) does not exist.
- *
- * After parsing we have:
- *
- * at                     1 if leading '@' (or Un*x '*')
- * len                    takes one value from " bilsw". eg B^ -> 'b'.
- * hash                   1 if leading '#' (or Un*x '$')
- * expr_begin, expr_end   the expression we did not parse
- *                        even though we don't interpret it, we make use
- *                        of its presence or absence.
- * sign                   -1: -(Rn)    0: absent    +1: (Rn)+
- * paren                  1 if () are around register
- * reg                    major register number 0:15    -1 means absent
- * ndx                    index register number 0:15    -1 means absent
- *
- * Again, I dare not explain it: just trace ALL the code!
- */
-
 static void
-vip_op (optext, vopP)
-     /* user's input string e.g.: "@B^foo@bar(AP)[FP]:" */
-     char *optext;
-     /* Input fields: vop_access, vop_width.
-	Output fields: _ndx, _reg, _mode, _short, _warn,
-	_error _expr_begin, _expr_end, _nbytes.
-	vop_nbytes : number of bytes in a datum.  */
-     struct vop *vopP;
+vip_op (char *optext, /* user's input string e.g.: "@B^foo@bar(AP)[FP]:" */
+	struct vop *vopP) /* Input fields: vop_access, vop_width.
+			     Output fields: _ndx, _reg, _mode, _short, _warn,
+			     _error _expr_begin, _expr_end, _nbytes.
+			     vop_nbytes : number of bytes in a datum.  */
 {
-  /* track operand text forward */
+  /* Track operand text forward.  */
   char *p;
-  /* track operand text backward */
+  /* Track operand text backward.  */
   char *q;
-  /* 1 if leading '@' ('*') seen */
+  /* 1 if leading '@' ('*') seen.  */
   int at;
   /* one of " bilsw" */
   char len;
-  /* 1 if leading '#' ('$') seen */
+  /* 1 if leading '#' ('$') seen.  */
   int hash;
-  /* -1, 0 or +1 */
+  /* -1, 0 or +1.  */
   int sign = 0;
-  /* 1 if () surround register */
+  /* 1 if () surround register.  */
   int paren = 0;
-  /* register number, -1:absent */
+  /* Register number, -1:absent.  */
   int reg = 0;
-  /* index register number -1:absent */
+  /* Index register number -1:absent.  */
   int ndx = 0;
-  /* report illegal operand, ""==OK */
-  /* " " is a FAKE error: means we won */
+  /* Report illegal operand, ""==OK.  */
+  /* " " is a FAKE error: means we won.  */
   /* ANY err that begins with ' ' is a fake.  */
-  /* " " is converted to "" before return */
+  /* " " is converted to "" before return.  */
   const char *err;
-  /* warn about weird modes pf address */
+  /* Warn about weird modes pf address.  */
   const char *wrn;
-  /* preserve q in case we backup */
+  /* Preserve q in case we backup.  */
   char *oldq = NULL;
-  /* build up 4-bit operand mode here */
-  /* note: index mode is in ndx, this is */
-  /* the major mode of operand address */
+  /* Build up 4-bit operand mode here.  */
+  /* Note: index mode is in ndx, this is.  */
+  /* The major mode of operand address.  */
   int mode = 0;
-  /*
-   * Notice how we move wrong-arg-type bugs INSIDE this module: if we
-   * get the types wrong below, we lose at compile time rather than at
-   * lint or run time.
-   */
+  /* Notice how we move wrong-arg-type bugs INSIDE this module: if we
+     get the types wrong below, we lose at compile time rather than at
+     lint or run time.  */
   char access_mode;		/* vop_access.  */
   char width;			/* vop_width.  */
 
@@ -2477,66 +1291,59 @@ vip_op (optext, vopP)
 	p++;			/* skip over whitespace */
     }
 
-  /*
-   * This code is subtle. It tries to detect all legal (letter)'^'
-   * but it doesn't waste time explicitly testing for premature '\0' because
-   * this case is rejected as a mismatch against either (letter) or '^'.
-   */
+  /* This code is subtle. It tries to detect all legal (letter)'^'
+     but it doesn't waste time explicitly testing for premature '\0' because
+     this case is rejected as a mismatch against either (letter) or '^'.  */
   {
     char c;
 
     c = *p;
     c = TOLOWER (c);
     if (DISPLENP (p[1]) && strchr ("bilws", len = c))
-      p += 2;			/* skip (letter) '^' */
-    else			/* no (letter) '^' seen */
-      len = ' ';		/* len is determined */
+      p += 2;			/* Skip (letter) '^'.  */
+    else			/* No (letter) '^' seen.  */
+      len = ' ';		/* Len is determined.  */
   }
 
   if (*p == ' ')		/* Expect all whitespace reduced to ' '.  */
-    p++;			/* skip over whitespace */
+    p++;
 
   if ((hash = IMMEDIATEP (*p)) != 0)	/* 1 if *p=='#' ('$' for Un*x) */
-    p++;			/* hash is determined */
+    p++;			/* Hash is determined.  */
 
-  /*
-   * p points to what may be the beginning of an expression.
-   * We have peeled off the front all that is peelable.
-   * We know at, len, hash.
-   *
-   * Lets point q at the end of the text and parse that (backwards).
-   */
+  /* p points to what may be the beginning of an expression.
+     We have peeled off the front all that is peelable.
+     We know at, len, hash.
+    
+     Lets point q at the end of the text and parse that (backwards).  */
 
   for (q = p; *q; q++)
     ;
-  q--;				/* now q points at last char of text */
-
+  q--;				/* Now q points at last char of text.  */
+
   if (*q == ' ' && q >= p)	/* Expect all whitespace reduced to ' '.  */
     q--;
-  /* reverse over whitespace, but don't */
-  /* run back over *p */
-
-  /*
-   * As a matter of policy here, we look for [Rn], although both Rn and S^#
-   * forbid [Rn]. This is because it is easy, and because only a sick
-   * cyborg would have [...] trailing an expression in a VAX-like assembler.
-   * A meticulous parser would first check for Rn followed by '(' or '['
-   * and not parse a trailing ']' if it found another. We just ban expressions
-   * ending in ']'.
-   */
+
+  /* Reverse over whitespace, but don't.  */
+  /* Run back over *p.  */
+
+  /* As a matter of policy here, we look for [Rn], although both Rn and S^#
+     forbid [Rn]. This is because it is easy, and because only a sick
+     cyborg would have [...] trailing an expression in a VAX-like assembler.
+     A meticulous parser would first check for Rn followed by '(' or '['
+     and not parse a trailing ']' if it found another. We just ban expressions
+     ending in ']'.  */
   if (*q == ']')
     {
       while (q >= p && *q != '[')
 	q--;
-      /* either q<p or we got matching '[' */
+      /* Either q<p or we got matching '['.  */
       if (q < p)
 	err = _("no '[' to match ']'");
       else
 	{
-	  /*
-	   * Confusers like "[]" will eventually lose with a bad register
-	   * name error. So again we don't need to check for early '\0'.
-	   */
+	  /* Confusers like "[]" will eventually lose with a bad register
+	   * name error. So again we don't need to check for early '\0'.  */
 	  if (q[3] == ']')
 	    ndx = vax_reg_parse (q[1], q[2], 0, 0);
 	  else if (q[4] == ']')
@@ -2545,34 +1352,33 @@ vip_op (optext, vopP)
 	    ndx = vax_reg_parse (q[1], q[2], q[3], q[4]);
 	  else
 	    ndx = -1;
-	  /*
-	   * Since we saw a ']' we will demand a register name in the [].
-	   * If luser hasn't given us one: be rude.
-	   */
+	  /* Since we saw a ']' we will demand a register name in the [].
+	   * If luser hasn't given us one: be rude.  */
 	  if (ndx < 0)
 	    err = _("bad register in []");
 	  else if (ndx == PC)
 	    err = _("[PC] index banned");
 	  else
-	    q--;		/* point q just before "[...]" */
+	    /* Point q just before "[...]".  */
+	    q--;
 	}
     }
   else
-    ndx = -1;			/* no ']', so no iNDeX register */
+    /* No ']', so no iNDeX register.  */
+    ndx = -1;
+
+  /* If err = "..." then we lost: run away.
+     Otherwise ndx == -1 if there was no "[...]".
+     Otherwise, ndx is index register number, and q points before "[...]".  */
 
-  /*
-   * If err = "..." then we lost: run away.
-   * Otherwise ndx == -1 if there was no "[...]".
-   * Otherwise, ndx is index register number, and q points before "[...]".
-   */
-
   if (*q == ' ' && q >= p)	/* Expect all whitespace reduced to ' '.  */
     q--;
-  /* reverse over whitespace, but don't */
-  /* run back over *p */
+  /* Reverse over whitespace, but don't.  */
+  /* Run back over *p.  */
   if (!err || !*err)
     {
-      sign = 0;			/* no ()+ or -() seen yet */
+      /* no ()+ or -() seen yet */
+      sign = 0;
 
       if (q > p + 3 && *q == '+' && q[-1] == ')')
 	{
@@ -2590,10 +1396,8 @@ vip_op (optext, vopP)
 	    err = _("no '(' to match ')'");
 	  else
 	    {
-	      /*
-	       * Confusers like "()" will eventually lose with a bad register
-	       * name error. So again we don't need to check for early '\0'.
-	       */
+	      /* Confusers like "()" will eventually lose with a bad register
+	         name error. So again we don't need to check for early '\0'.  */
 	      if (q[3] == ')')
 		reg = vax_reg_parse (q[1], q[2], 0, 0);
 	      else if (q[4] == ')')
@@ -2602,15 +1406,13 @@ vip_op (optext, vopP)
 		reg = vax_reg_parse (q[1], q[2], q[3], q[4]);
 	      else
 		reg = -1;
-	      /*
-	       * Since we saw a ')' we will demand a register name in the ')'.
-	       * This is nasty: why can't our hypothetical assembler permit
-	       * parenthesised expressions? BECAUSE I AM LAZY! That is why.
-	       * Abuse luser if we didn't spy a register name.
-	       */
+	      /* Since we saw a ')' we will demand a register name in the ')'.
+	         This is nasty: why can't our hypothetical assembler permit
+	         parenthesised expressions? BECAUSE I AM LAZY! That is why.
+	         Abuse luser if we didn't spy a register name.  */
 	      if (reg < 0)
 		{
-		  /* JF allow parenthesized expressions.  I hope this works */
+		  /* JF allow parenthesized expressions.  I hope this works.  */
 		  paren = 0;
 		  while (*q != ')')
 		    q++;
@@ -2618,32 +1420,24 @@ vip_op (optext, vopP)
 		}
 	      else
 		q--;		/* point just before '(' of "(...)" */
-	      /*
-	       * If err == "..." then we lost. Run away.
-	       * Otherwise if reg >= 0 then we saw (Rn).
-	       */
+	      /* If err == "..." then we lost. Run away.
+	         Otherwise if reg >= 0 then we saw (Rn).  */
 	    }
-	  /*
-	   * If err == "..." then we lost.
-	   * Otherwise paren==1 and reg = register in "()".
-	   */
+	  /* If err == "..." then we lost.
+	     Otherwise paren==1 and reg = register in "()".  */
 	}
       else
 	paren = 0;
-      /*
-       * If err == "..." then we lost.
-       * Otherwise, q points just before "(Rn)", if any.
-       * If there was a "(...)" then paren==1, and reg is the register.
-       */
-
-      /*
-       * We should only seek '-' of "-(...)" if:
-       *   we saw "(...)"                    paren == 1
-       *   we have no errors so far          ! *err
-       *   we did not see '+' of "(...)+"    sign < 1
-       * We don't check len. We want a specific error message later if
-       * user tries "x^...-(Rn)". This is a feature not a bug.
-       */
+      /* If err == "..." then we lost.
+         Otherwise, q points just before "(Rn)", if any.
+         If there was a "(...)" then paren==1, and reg is the register.  */
+
+      /* We should only seek '-' of "-(...)" if:
+           we saw "(...)"                    paren == 1
+           we have no errors so far          ! *err
+           we did not see '+' of "(...)+"    sign < 1
+         We don't check len. We want a specific error message later if
+         user tries "x^...-(Rn)". This is a feature not a bug.  */
       if (!err || !*err)
 	{
 	  if (paren && sign < 1)/* !sign is adequate test */
@@ -2654,31 +1448,27 @@ vip_op (optext, vopP)
 		  q--;
 		}
 	    }
-	  /*
-	   * We have back-tracked over most
-	   * of the crud at the end of an operand.
-	   * Unless err, we know: sign, paren. If paren, we know reg.
-	   * The last case is of an expression "Rn".
-	   * This is worth hunting for if !err, !paren.
-	   * We wouldn't be here if err.
-	   * We remember to save q, in case we didn't want "Rn" anyway.
-	   */
+	  /* We have back-tracked over most
+	     of the crud at the end of an operand.
+	     Unless err, we know: sign, paren. If paren, we know reg.
+	     The last case is of an expression "Rn".
+	     This is worth hunting for if !err, !paren.
+	     We wouldn't be here if err.
+	     We remember to save q, in case we didn't want "Rn" anyway.  */
 	  if (!paren)
 	    {
 	      if (*q == ' ' && q >= p)	/* Expect all whitespace reduced to ' '.  */
 		q--;
-	      /* reverse over whitespace, but don't */
-	      /* run back over *p */
-	      /* room for Rn or Rnn (include prefix) exactly? */
+	      /* Reverse over whitespace, but don't.  */
+	      /* Run back over *p.  */
+	      /* Room for Rn or Rnn (include prefix) exactly?  */
 	      if (q > p && q < p + 4)
 		reg = vax_reg_parse (p[0], p[1],
 		  q < p + 2 ? 0 : p[2],
 		  q < p + 3 ? 0 : p[3]);
 	      else
-		reg = -1;	/* always comes here if no register at all */
-	      /*
-	       * Here with a definitive reg value.
-	       */
+		reg = -1;	/* Always comes here if no register at all.  */
+	      /* Here with a definitive reg value.  */
 	      if (reg >= 0)
 		{
 		  oldq = q;
@@ -2687,43 +1477,35 @@ vip_op (optext, vopP)
 	    }
 	}
     }
-  /*
-   * have reg. -1:absent; else 0:15
-   */
-
-  /*
-   * We have:  err, at, len, hash, ndx, sign, paren, reg.
-   * Also, any remaining expression is from *p through *q inclusive.
-   * Should there be no expression, q==p-1. So expression length = q-p+1.
-   * This completes the first part: parsing the operand text.
-   */
+  /* have reg. -1:absent; else 0:15.  */
+
+  /* We have:  err, at, len, hash, ndx, sign, paren, reg.
+     Also, any remaining expression is from *p through *q inclusive.
+     Should there be no expression, q==p-1. So expression length = q-p+1.
+     This completes the first part: parsing the operand text.  */
 
-  /*
-   * We now want to boil the data down, checking consistency on the way.
-   * We want:  len, mode, reg, ndx, err, p, q, wrn, bug.
-   * We will deliver a 4-bit reg, and a 4-bit mode.
-   */
-
-  /*
-   * Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
-   *
-   * in:  at	?
-   *      len	?
-   *      hash	?
-   *      p:q	?
-   *      sign  ?
-   *      paren	?
-   *      reg   ?
-   *      ndx   ?
-   *
-   * out: mode  0
-   *      reg   -1
-   *      len	' '
-   *      p:q	whatever was input
-   *      ndx	-1
-   *      err	" "		 or error message, and other outputs trashed
-   */
-  /* branch operands have restricted forms */
+  /* We now want to boil the data down, checking consistency on the way.
+     We want:  len, mode, reg, ndx, err, p, q, wrn, bug.
+     We will deliver a 4-bit reg, and a 4-bit mode.  */
+
+  /* Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
+    
+     in:  at	?
+          len	?
+          hash	?
+          p:q	?
+          sign  ?
+          paren	?
+          reg   ?
+          ndx   ?
+    
+     out: mode  0
+          reg   -1
+          len	' '
+          p:q	whatever was input
+          ndx	-1
+          err	" "		 or error message, and other outputs trashed.  */
+  /* Branch operands have restricted forms.  */
   if ((!err || !*err) && access_mode == 'b')
     {
       if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
@@ -2731,28 +1513,26 @@ vip_op (optext, vopP)
       else
 	err = " ";
     }
-
+
   /* Since nobody seems to use it: comment this 'feature'(?) out for now.  */
 #ifdef NEVER
-  /*
-   * Case of stand-alone operand. e.g. ".long foo"
-   *
-   * in:  at	?
-   *      len	?
-   *      hash	?
-   *      p:q	?
-   *      sign  ?
-   *      paren	?
-   *      reg   ?
-   *      ndx   ?
-   *
-   * out: mode  0
-   *      reg   -1
-   *      len	' '
-   *      p:q	whatever was input
-   *      ndx	-1
-   *      err	" "		 or error message, and other outputs trashed
-   */
+  /* Case of stand-alone operand. e.g. ".long foo"
+    
+     in:  at	?
+          len	?
+          hash	?
+          p:q	?
+          sign  ?
+          paren	?
+          reg   ?
+          ndx   ?
+    
+     out: mode  0
+          reg   -1
+          len	' '
+          p:q	whatever was input
+          ndx	-1
+          err	" "		 or error message, and other outputs trashed.  */
   if ((!err || !*err) && access_mode == ' ')
     {
       if (at)
@@ -2780,26 +1560,24 @@ vip_op (optext, vopP)
 	  mode = 0;
 	}
     }
-#endif /*#Ifdef NEVER*/
-
-  /*
-   * Case of S^#.
-   *
-   * in:  at       0
-   *      len      's'               definition
-   *      hash     1              demand
-   *      p:q                        demand not empty
-   *      sign     0                 by paren==0
-   *      paren    0             by "()" scan logic because "S^" seen
-   *      reg      -1                or nn by mistake
-   *      ndx      -1
-   *
-   * out: mode     0
-   *      reg      -1
-   *      len      's'
-   *      exp
-   *      ndx      -1
-   */
+#endif
+
+  /* Case of S^#.
+    
+     in:  at       0
+          len      's'               definition
+          hash     1              demand
+          p:q                        demand not empty
+          sign     0                 by paren==0
+          paren    0             by "()" scan logic because "S^" seen
+          reg      -1                or nn by mistake
+          ndx      -1
+    
+     out: mode     0
+          reg      -1
+          len      's'
+          exp
+          ndx      -1  */
   if ((!err || !*err) && len == 's')
     {
       if (!hash || paren || at || ndx >= 0)
@@ -2808,17 +1586,13 @@ vip_op (optext, vopP)
 	{
 	  if (reg >= 0)
 	    {
-	      /*
-	       * SHIT! we saw S^#Rnn ! put the Rnn back in
-	       * expression. KLUDGE! Use oldq so we don't
-	       * need to know exact length of reg name.
-	       */
+	      /* Darn! we saw S^#Rnn ! put the Rnn back in
+	         expression. KLUDGE! Use oldq so we don't
+	         need to know exact length of reg name.  */
 	      q = oldq;
 	      reg = 0;
 	    }
-	  /*
-	   * We have all the expression we will ever get.
-	   */
+	  /* We have all the expression we will ever get.  */
 	  if (p > q)
 	    err = _("S^# needs expression");
 	  else if (access_mode == 'r')
@@ -2830,25 +1604,23 @@ vip_op (optext, vopP)
 	    err = _("S^# may only read-access");
 	}
     }
-
-  /*
-   * Case of -(Rn), which is weird case.
-   *
-   * in:  at       0
-   *      len      '
-   *      hash     0
-   *      p:q      q<p
-   *      sign     -1                by definition
-   *      paren    1              by definition
-   *      reg      present           by definition
-   *      ndx      optional
-   *
-   * out: mode     7
-   *      reg      present
-   *      len      ' '
-   *      exp      ""                enforce empty expression
-   *      ndx      optional          warn if same as reg
-   */
+  
+  /* Case of -(Rn), which is weird case.
+    
+     in:  at       0
+          len      '
+          hash     0
+          p:q      q<p
+          sign     -1                by definition
+          paren    1              by definition
+          reg      present           by definition
+          ndx      optional
+    
+     out: mode     7
+          reg      present
+          len      ' '
+          exp      ""                enforce empty expression
+          ndx      optional          warn if same as reg.  */
   if ((!err || !*err) && sign < 0)
     {
       if (len != ' ' || hash || at || p <= q)
@@ -2863,36 +1635,32 @@ vip_op (optext, vopP)
 	    wrn = _("[]index same as -()register: unpredictable");
 	}
     }
-
-  /*
-   * We convert "(Rn)" to "@Rn" for our convenience.
-   * (I hope this is convenient: has someone got a better way to parse this?)
-   * A side-effect of this is that "@Rn" is a valid operand.
-   */
+
+  /* We convert "(Rn)" to "@Rn" for our convenience.
+     (I hope this is convenient: has someone got a better way to parse this?)
+     A side-effect of this is that "@Rn" is a valid operand.  */
   if (paren && !sign && !hash && !at && len == ' ' && p > q)
     {
       at = 1;
       paren = 0;
     }
 
-  /*
-   * Case of (Rn)+, which is slightly different.
-   *
-   * in:  at
-   *      len      ' '
-   *      hash     0
-   *      p:q      q<p
-   *      sign     +1                by definition
-   *      paren    1              by definition
-   *      reg      present           by definition
-   *      ndx      optional
-   *
-   * out: mode     8+@
-   *      reg      present
-   *      len      ' '
-   *      exp      ""                enforce empty expression
-   *      ndx      optional          warn if same as reg
-   */
+  /* Case of (Rn)+, which is slightly different.
+    
+     in:  at
+          len      ' '
+          hash     0
+          p:q      q<p
+          sign     +1                by definition
+          paren    1              by definition
+          reg      present           by definition
+          ndx      optional
+    
+     out: mode     8+@
+          reg      present
+          len      ' '
+          exp      ""                enforce empty expression
+          ndx      optional          warn if same as reg.  */
   if ((!err || !*err) && sign > 0)
     {
       if (len != ' ' || hash || p <= q)
@@ -2907,25 +1675,23 @@ vip_op (optext, vopP)
 	    wrn = _("[]index same as ()+register: unpredictable");
 	}
     }
-
-  /*
-   * Case of #, without S^.
-   *
-   * in:  at
-   *      len      ' ' or 'i'
-   *      hash     1              by definition
-   *      p:q
-   *      sign     0
-   *      paren    0
-   *      reg      absent
-   *      ndx      optional
-   *
-   * out: mode     8+@
-   *      reg      PC
-   *      len      ' ' or 'i'
-   *      exp
-   *      ndx      optional
-   */
+
+  /* Case of #, without S^.
+    
+     in:  at
+          len      ' ' or 'i'
+          hash     1              by definition
+          p:q
+          sign     0
+          paren    0
+          reg      absent
+          ndx      optional
+    
+     out: mode     8+@
+          reg      PC
+          len      ' ' or 'i'
+          exp
+          ndx      optional.  */
   if ((!err || !*err) && hash)
     {
       if (len != 'i' && len != ' ')
@@ -2936,17 +1702,15 @@ vip_op (optext, vopP)
 	{
 	  if (reg >= 0)
 	    {
-	      /*
-	       * SHIT! we saw #Rnn! Put the Rnn back into the expression.
-	       * By using oldq, we don't need to know how long Rnn was.
-	       * KLUDGE!
-	       */
+	      /* Darn! we saw #Rnn! Put the Rnn back into the expression.
+	         By using oldq, we don't need to know how long Rnn was.
+	         KLUDGE!  */
 	      q = oldq;
-	      reg = -1;		/* no register any more */
+	      reg = -1;		/* No register any more.  */
 	    }
-	  err = " ";		/* win */
+	  err = " ";		/* Win.  */
 
-	  /* JF a bugfix, I think! */
+	  /* JF a bugfix, I think!  */
 	  if (at && access_mode == 'a')
 	    vopP->vop_nbytes = 4;
 
@@ -2956,30 +1720,26 @@ vip_op (optext, vopP)
 	    wrn = _("writing or modifying # is unpredictable");
 	}
     }
-  /*
-   * If !*err, then        sign == 0
-   *                       hash == 0
-   */
-
-  /*
-   * Case of Rn. We separate this one because it has a few special
-   * errors the remaining modes lack.
-   *
-   * in:  at       optional
-   *      len      ' '
-   *      hash     0             by program logic
-   *      p:q      empty
-   *      sign     0                 by program logic
-   *      paren    0             by definition
-   *      reg      present           by definition
-   *      ndx      optional
-   *
-   * out: mode     5+@
-   *      reg      present
-   *      len      ' '               enforce no length
-   *      exp      ""                enforce empty expression
-   *      ndx      optional          warn if same as reg
-   */
+  /* If !*err, then       sign == 0
+                          hash == 0 */
+
+  /* Case of Rn. We separate this one because it has a few special
+     errors the remaining modes lack.
+    
+     in:  at       optional
+          len      ' '
+          hash     0             by program logic
+          p:q      empty
+          sign     0                 by program logic
+          paren    0             by definition
+          reg      present           by definition
+          ndx      optional
+    
+     out: mode     5+@
+          reg      present
+          len      ' '               enforce no length
+          exp      ""                enforce empty expression
+          ndx      optional          warn if same as reg.  */
   if ((!err || !*err) && !paren && reg >= 0)
     {
       if (len != ' ')
@@ -2995,43 +1755,37 @@ vip_op (optext, vopP)
 	err = _("a register has no address");
       else
 	{
-	  /*
-	   * Idea here is to detect from length of datum
-	   * and from register number if we will touch PC.
-	   * Warn if we do.
-	   * vop_nbytes is number of bytes in operand.
-	   * Compute highest byte affected, compare to PC0.
-	   */
+	  /* Idea here is to detect from length of datum
+	     and from register number if we will touch PC.
+	     Warn if we do.
+	     vop_nbytes is number of bytes in operand.
+	     Compute highest byte affected, compare to PC0.  */
 	  if ((vopP->vop_nbytes + reg * 4) > 60)
 	    wrn = _("PC part of operand unpredictable");
 	  err = " ";		/* win */
 	  mode = 5;		/* Rn */
 	}
     }
-  /*
-   * If !*err,        sign  == 0
-   *                  hash  == 0
-   *                  paren == 1  OR reg==-1
-   */
-
-  /*
-   * Rest of cases fit into one bunch.
-   *
-   * in:  at       optional
-   *      len      ' ' or 'b' or 'w' or 'l'
-   *      hash     0             by program logic
-   *      p:q      expected          (empty is not an error)
-   *      sign     0                 by program logic
-   *      paren    optional
-   *      reg      optional
-   *      ndx      optional
-   *
-   * out: mode     10 + @ + len
-   *      reg      optional
-   *      len      ' ' or 'b' or 'w' or 'l'
-   *      exp                        maybe empty
-   *      ndx      optional          warn if same as reg
-   */
+  /* If !*err,        sign  == 0
+                      hash  == 0
+                      paren == 1  OR reg==-1  */
+
+  /* Rest of cases fit into one bunch.
+    
+     in:  at       optional
+          len      ' ' or 'b' or 'w' or 'l'
+          hash     0             by program logic
+          p:q      expected          (empty is not an error)
+          sign     0                 by program logic
+          paren    optional
+          reg      optional
+          ndx      optional
+    
+     out: mode     10 + @ + len
+          reg      optional
+          len      ' ' or 'b' or 'w' or 'l'
+          exp                        maybe empty
+          ndx      optional          warn if same as reg.  */
   if (!err || !*err)
     {
       err = " ";		/* win (always) */
@@ -3042,22 +1796,20 @@ vip_op (optext, vopP)
 	  mode += 2;
 	case 'w':
 	  mode += 2;
-	case ' ':		/* assumed B^ until our caller changes it */
+	case ' ':	/* Assumed B^ until our caller changes it.  */
 	case 'b':
 	  break;
 	}
     }
 
-  /*
-   * here with completely specified     mode
-   *					len
-   *					reg
-   *					expression   p,q
-   *					ndx
-   */
+  /* here with completely specified     mode
+    					len
+    					reg
+    					expression   p,q
+    					ndx.  */
 
   if (*err == ' ')
-    err = 0;			/* " " is no longer an error */
+    err = 0;			/* " " is no longer an error.  */
 
   vopP->vop_mode = mode;
   vopP->vop_reg = reg;
@@ -3068,34 +1820,223 @@ vip_op (optext, vopP)
   vopP->vop_error = err;
   vopP->vop_warn = wrn;
 }
+
+/* This converts a string into a vax instruction.
+   The string must be a bare single instruction in dec-vax (with BSD4 frobs)
+   format.
+   It provides some error messages: at most one fatal error message (which
+   stops the scan) and at most one warning message for each operand.
+   The vax instruction is returned in exploded form, since we have no
+   knowledge of how you parse (or evaluate) your expressions.
+   We do however strip off and decode addressing modes and operation
+   mnemonic.
+  
+   The exploded instruction is returned to a struct vit of your choice.
+   #include "vax-inst.h" to know what a struct vit is.
+  
+   This function's value is a string. If it is not "" then an internal
+   logic error was found: read this code to assign meaning to the string.
+   No argument string should generate such an error string:
+   it means a bug in our code, not in the user's text.
+  
+   You MUST have called vip_begin() once before using this function.  */
+
+static void
+vip (struct vit *vitP,		/* We build an exploded instruction here.  */
+     char *instring)		/* Text of a vax instruction: we modify.  */
+{
+  /* How to bit-encode this opcode.  */
+  struct vot_wot *vwP;
+  /* 1/skip whitespace.2/scan vot_how */
+  char *p;
+  char *q;
+  /* counts number of operands seen */
+  unsigned char count;
+  /* scan operands in struct vit */
+  struct vop *operandp;
+  /* error over all operands */
+  const char *alloperr;
+  /* Remember char, (we clobber it with '\0' temporarily).  */
+  char c;
+  /* Op-code of this instruction.  */
+  vax_opcodeT oc;
+
+  if (*instring == ' ')
+    ++instring;
+  
+  /* MUST end in end-of-string or exactly 1 space.  */
+  for (p = instring; *p && *p != ' '; p++)
+    ;
+
+  /* Scanned up to end of operation-code.  */
+  /* Operation-code is ended with whitespace.  */
+  if (p - instring == 0)
+    {
+      vitP->vit_error = _("No operator");
+      count = 0;
+      memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
+    }
+  else
+    {
+      c = *p;
+      *p = '\0';
+      /* Here with instring pointing to what better be an op-name, and p
+         pointing to character just past that.
+         We trust instring points to an op-name, with no whitespace.  */
+      vwP = (struct vot_wot *) hash_find (op_hash, instring);
+      /* Restore char after op-code.  */
+      *p = c;
+      if (vwP == 0)
+	{
+	  vitP->vit_error = _("Unknown operator");
+	  count = 0;
+	  memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
+	}
+      else
+	{
+	  /* We found a match! So let's pick up as many operands as the
+	     instruction wants, and even gripe if there are too many.
+	     We expect comma to separate each operand.
+	     We let instring track the text, while p tracks a part of the
+	     struct vot.  */
+	  const char *howp;
+	  /* The lines below know about 2-byte opcodes starting FD,FE or FF.
+	     They also understand synthetic opcodes. Note:
+	     we return 32 bits of opcode, including bucky bits, BUT
+	     an opcode length is either 8 or 16 bits for vit_opcode_nbytes.  */
+	  oc = vwP->vot_code;	/* The op-code.  */
+	  vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
+	  md_number_to_chars (vitP->vit_opcode, oc, 4);
+	  count = 0;		/* No operands seen yet.  */
+	  instring = p;		/* Point just past operation code.  */
+	  alloperr = "";
+	  for (howp = vwP->vot_how, operandp = vitP->vit_operand;
+	       !(alloperr && *alloperr) && *howp;
+	       operandp++, howp += 2)
+	    {
+	      /* Here to parse one operand. Leave instring pointing just
+	         past any one ',' that marks the end of this operand.  */
+	      if (!howp[1])
+		as_fatal (_("odd number of bytes in operand description"));
+	      else if (*instring)
+		{
+		  for (q = instring; (c = *q) && c != ','; q++)
+		    ;
+		  /* Q points to ',' or '\0' that ends argument. C is that
+		     character.  */
+		  *q = 0;
+		  operandp->vop_width = howp[1];
+		  operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]];
+		  operandp->vop_access = howp[0];
+		  vip_op (instring, operandp);
+		  *q = c;	/* Restore input text.  */
+		  if (operandp->vop_error)
+		    alloperr = _("Bad operand");
+		  instring = q + (c ? 1 : 0);	/* Next operand (if any).  */
+		  count++;	/*  Won another argument, may have an operr.  */
+		}
+	      else
+		alloperr = _("Not enough operands");
+	    }
+	  if (!*alloperr)
+	    {
+	      if (*instring == ' ')
+		instring++;
+	      if (*instring)
+		alloperr = _("Too many operands");
+	    }
+	  vitP->vit_error = alloperr;
+	}
+    }
+  vitP->vit_operands = count;
+}
 
-/*
+#ifdef test
 
-  Summary of vip_op outputs.
+/* Test program for above.  */
 
-  mode	reg	len	ndx
-  (Rn) => @Rn
-  {@}Rn			5+@	n	' '	optional
-  branch operand		0	-1	' '	-1
-  S^#foo			0	-1	's'	-1
-  -(Rn)			7	n	' '	optional
-  {@}(Rn)+		8+@	n	' '	optional
-  {@}#foo, no S^		8+@	PC	" i"	optional
-  {@}{q^}{(Rn)}		10+@+q	option	" bwl"	optional
+struct vit myvit;		/* Build an exploded vax instruction here.  */
+char answer[100];		/* Human types a line of vax assembler here.  */
+char *mybug;			/* "" or an internal logic diagnostic.  */
+int mycount;			/* Number of operands.  */
+struct vop *myvop;		/* Scan operands from myvit.  */
+int mysynth;			/* 1 means want synthetic opcodes.  */
+char my_immediate[200];
+char my_indirect[200];
+char my_displen[200];
+
+int
+main (void)
+{
+  char *p;
 
-  */
+  printf ("0 means no synthetic instructions.   ");
+  printf ("Value for vip_begin?  ");
+  gets (answer);
+  sscanf (answer, "%d", &mysynth);
+  printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
+  printf ("enter immediate symbols eg enter #   ");
+  gets (my_immediate);
+  printf ("enter indirect symbols  eg enter @   ");
+  gets (my_indirect);
+  printf ("enter displen symbols   eg enter ^   ");
+  gets (my_displen);
+
+  if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))
+    error ("vip_begin=%s", p);
+
+  printf ("An empty input line will quit you from the vax instruction parser\n");
+  for (;;)
+    {
+      printf ("vax instruction: ");
+      fflush (stdout);
+      gets (answer);
+      if (!*answer)
+	break;		/* Out of for each input text loop.  */
+
+      vip (& myvit, answer);
+      if (*myvit.vit_error)
+	printf ("ERR:\"%s\"\n", myvit.vit_error);
+
+      printf ("opcode=");
+      for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
+	   mycount;
+	   mycount--, p++)
+	printf ("%02x ", *p & 0xFF);
+
+      printf ("   operand count=%d.\n", mycount = myvit.vit_operands);
+      for (myvop = myvit.vit_operand; mycount; mycount--, myvop++)
+	{
+	  printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
+		  myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
+		  myvop->vop_short, myvop->vop_access, myvop->vop_width,
+		  myvop->vop_nbytes);
+	  for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++)
+	    putchar (*p);
+
+	  printf ("\"\n");
+	  if (myvop->vop_error)
+	    printf ("  err:\"%s\"\n", myvop->vop_error);
+
+	  if (myvop->vop_warn)
+	    printf ("  wrn:\"%s\"\n", myvop->vop_warn);
+	}
+    }
+  vip_end ();
+  exit (EXIT_SUCCESS);
+}
+
+#endif
 
 #ifdef TEST			/* #Define to use this testbed.  */
 
-/*
- * Follows a test program for this function.
- * We declare arrays non-local in case some of our tiny-minded machines
- * default to small stacks. Also, helps with some debuggers.
- */
+/* Follows a test program for this function.
+   We declare arrays non-local in case some of our tiny-minded machines
+   default to small stacks. Also, helps with some debuggers.  */
 
 #include <stdio.h>
 
-char answer[100];		/* human types into here */
+char answer[100];		/* Human types into here.  */
 char *p;			/*  */
 char *myerr;
 char *mywrn;
@@ -3113,7 +2054,8 @@ char my_immediate[200];
 char my_indirect[200];
 char my_displen[200];
 
-main ()
+int
+main (void)
 {
   printf ("enter immediate symbols eg enter #   ");
   gets (my_immediate);
@@ -3122,6 +2064,7 @@ main ()
   printf ("enter displen symbols   eg enter ^   ");
   gets (my_displen);
   vip_op_defaults (my_immediate, my_indirect, my_displen);
+
   for (;;)
     {
       printf ("access,width (eg 'ab' or 'wh') [empty line to quit] :  ");
@@ -3211,20 +2154,17 @@ mumble (text, value)
   printf ("  ");
 }
 
-#endif /* ifdef TEST */
-
-/* end: vip_op.c */
+#endif
 
 int md_short_jump_size = 3;
 int md_long_jump_size = 6;
 
 void
-md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
-     char *ptr;
-     addressT from_addr;
-     addressT to_addr ATTRIBUTE_UNUSED;
-     fragS *frag ATTRIBUTE_UNUSED;
-     symbolS *to_symbol ATTRIBUTE_UNUSED;
+md_create_short_jump (char *ptr,
+		      addressT from_addr,
+		      addressT to_addr ATTRIBUTE_UNUSED,
+		      fragS *frag ATTRIBUTE_UNUSED,
+		      symbolS *to_symbol ATTRIBUTE_UNUSED)
 {
   valueT offset;
 
@@ -3233,22 +2173,21 @@ md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
      We need to account for the one byte instruction and also its
      two byte operand.  */
   offset = to_addr - (from_addr + 1 + 2);
-  *ptr++ = VAX_BRW;		/* branch with word (16 bit) offset */
+  *ptr++ = VAX_BRW;		/* Branch with word (16 bit) offset.  */
   md_number_to_chars (ptr, offset, 2);
 }
 
 void
-md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
-     char *ptr;
-     addressT from_addr ATTRIBUTE_UNUSED;
-     addressT to_addr;
-     fragS *frag;
-     symbolS *to_symbol;
+md_create_long_jump (char *ptr,
+		     addressT from_addr ATTRIBUTE_UNUSED,
+		     addressT to_addr,
+		     fragS *frag,
+		     symbolS *to_symbol)
 {
   valueT offset;
 
   offset = to_addr - S_GET_VALUE (to_symbol);
-  *ptr++ = VAX_JMP;		/* arbitrary jump */
+  *ptr++ = VAX_JMP;		/* Arbitrary jump.  */
   *ptr++ = VAX_ABSOLUTE_MODE;
   md_number_to_chars (ptr, offset, 4);
   fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (long) 0, 0, NO_RELOC);
@@ -3261,7 +2200,8 @@ const char *md_shortopts = "d:STt:VkKQ:";
 #else
 const char *md_shortopts = "d:STt:V";
 #endif
-struct option md_longopts[] = {
+struct option md_longopts[] =
+{
 #ifdef OBJ_ELF
 #define OPTION_PIC (OPTION_MD_BASE)
   {"pic", no_argument, NULL, OPTION_PIC},
@@ -3271,9 +2211,7 @@ struct option md_longopts[] = {
 size_t md_longopts_size = sizeof (md_longopts);
 
 int
-md_parse_option (c, arg)
-     int c;
-     char *arg;
+md_parse_option (int c, char *arg)
 {
   switch (c)
     {
@@ -3302,15 +2240,15 @@ md_parse_option (c, arg)
       flag_hash_long_names = 1;
       break;
 
-    case '1':			/* For backward compatibility */
+    case '1':			/* For backward compatibility.  */
       flag_one = 1;
       break;
 
-    case 'H':			/* Show new symbol after hash truncation */
+    case 'H':			/* Show new symbol after hash truncation.  */
       flag_show_after_trunc = 1;
       break;
 
-    case 'h':			/* No hashing of mixed-case names */
+    case 'h':			/* No hashing of mixed-case names.  */
       {
 	extern char vms_name_mapping;
 	vms_name_mapping = atoi (arg);
@@ -3321,8 +2259,9 @@ md_parse_option (c, arg)
     case 'v':
       {
 	extern char *compiler_version_string;
+
 	if (!arg || !*arg || access (arg, 0) == 0)
-	  return 0;		/* have caller show the assembler version */
+	  return 0;		/* Have caller show the assembler version.  */
 	compiler_version_string = arg;
       }
       break;
@@ -3332,7 +2271,7 @@ md_parse_option (c, arg)
     case OPTION_PIC:
     case 'k':
       flag_want_pic = 1;
-      break;			/* -pic, Position Independent Code */
+      break;			/* -pic, Position Independent Code.  */
 
      /* -Qy, -Qn: SVR4 arguments controlling whether a .comment
 	section should be emitted or not.  FIXME: Not implemented.  */
@@ -3348,8 +2287,7 @@ md_parse_option (c, arg)
 }
 
 void
-md_show_usage (stream)
-     FILE *stream;
+md_show_usage (FILE *stream)
 {
   fprintf (stream, _("\
 VAX options:\n\
@@ -3374,41 +2312,36 @@ VMS options:\n\
 /* We have no need to default values of symbols.  */
 
 symbolS *
-md_undefined_symbol (name)
-     char *name ATTRIBUTE_UNUSED;
+md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
 {
-  return 0;
+  return NULL;
 }
 
 /* Round up a section size to the appropriate boundary.  */
 valueT
-md_section_align (segment, size)
-     segT segment ATTRIBUTE_UNUSED;
-     valueT size;
+md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
 {
-  return size;			/* Byte alignment is fine */
+  /* Byte alignment is fine */
+  return size;
 }
 
 /* Exactly what point is a PC-relative offset relative TO?
    On the vax, they're relative to the address of the offset, plus
    its size. */
 long
-md_pcrel_from (fixP)
-     fixS *fixP;
+md_pcrel_from (fixS *fixP)
 {
   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
 }
 
 arelent *
-tc_gen_reloc (section, fixp)
-     asection *section ATTRIBUTE_UNUSED;
-     fixS *fixp;
+tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
 {
   arelent *reloc;
   bfd_reloc_code_real_type code;
 
   if (fixp->fx_tcbit)
-    abort();
+    abort ();
 
   if (fixp->fx_r_type != BFD_RELOC_NONE)
     {
@@ -3456,8 +2389,8 @@ tc_gen_reloc (section, fixp)
 #undef F
 #undef MAP
 
-  reloc = (arelent *) xmalloc (sizeof (arelent));
-  reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
+  reloc = xmalloc (sizeof (arelent));
+  reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
 #ifndef OBJ_ELF
@@ -3475,4 +2408,861 @@ tc_gen_reloc (section, fixp)
   return reloc;
 }
 
-/* end of tc-vax.c */
+void
+md_assemble (char *instruction_string)
+{
+  /* Non-zero if operand expression's segment is not known yet.  */
+  int is_undefined;
+  /* Non-zero if operand expression's segment is absolute.  */
+  int is_absolute;
+  int length_code;
+  char *p;
+  /* An operand. Scans all operands.  */
+  struct vop *operandP;
+  char *save_input_line_pointer;
+			/* What used to live after an expression.  */
+  char c_save;
+  /* 1: instruction_string bad for all passes.  */
+  int goofed;
+  /* Points to slot just after last operand.  */
+  struct vop *end_operandP;
+  /* Points to expression values for this operand.  */
+  expressionS *expP;
+  segT *segP;
+
+  /* These refer to an instruction operand expression.  */
+  /* Target segment of the address.	 */
+  segT to_seg;
+  valueT this_add_number;
+  /* Positive (minuend) symbol.  */
+  symbolS *this_add_symbol;
+  /* As a number.  */
+  long opcode_as_number;
+  /* Least significant byte 1st.  */
+  char *opcode_as_chars;
+  /* As an array of characters.  */
+  /* Least significant byte 1st */
+  char *opcode_low_byteP;
+  /* length (bytes) meant by vop_short.  */
+  int length;
+  /* 0, or 1 if '@' is in addressing mode.  */
+  int at;
+  /* From vop_nbytes: vax_operand_width (in bytes) */
+  int nbytes;
+  FLONUM_TYPE *floatP;
+  LITTLENUM_TYPE literal_float[8];
+  /* Big enough for any floating point literal.  */
+
+  vip (&v, instruction_string);
+
+  /* Now we try to find as many as_warn()s as we can. If we do any as_warn()s
+     then goofed=1. Notice that we don't make any frags yet.
+     Should goofed be 1, then this instruction will wedge in any pass,
+     and we can safely flush it, without causing interpass symbol phase
+     errors. That is, without changing label values in different passes.  */
+  if ((goofed = (*v.vit_error)) != 0)
+    {
+      as_fatal (_("Ignoring statement due to \"%s\""), v.vit_error);
+    }
+  /* We need to use expression() and friends, which require us to diddle
+     input_line_pointer. So we save it and restore it later.  */
+  save_input_line_pointer = input_line_pointer;
+  for (operandP = v.vit_operand,
+       expP = exp_of_operand,
+       segP = seg_of_operand,
+       floatP = float_operand,
+       end_operandP = v.vit_operand + v.vit_operands;
+
+       operandP < end_operandP;
+
+       operandP++, expP++, segP++, floatP++)
+    {
+      if (operandP->vop_error)
+	{
+	  as_fatal (_("Aborting because statement has \"%s\""), operandP->vop_error);
+	  goofed = 1;
+	}
+      else
+	{
+	  /* Statement has no syntax goofs: let's sniff the expression.  */
+	  int can_be_short = 0;	/* 1 if a bignum can be reduced to a short literal.  */
+
+	  input_line_pointer = operandP->vop_expr_begin;
+	  c_save = operandP->vop_expr_end[1];
+	  operandP->vop_expr_end[1] = '\0';
+	  /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1.  */
+	  *segP = expression (expP);
+	  switch (expP->X_op)
+	    {
+	    case O_absent:
+	      /* for BSD4.2 compatibility, missing expression is absolute 0 */
+	      expP->X_op = O_constant;
+	      expP->X_add_number = 0;
+	      /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
+		 X_add_symbol to any particular value.  But, we will program
+		 defensively. Since this situation occurs rarely so it costs
+		 us little to do, and stops Dean worrying about the origin of
+		 random bits in expressionS's.  */
+	      expP->X_add_symbol = NULL;
+	      expP->X_op_symbol = NULL;
+	      break;
+
+	    case O_symbol:
+	    case O_constant:
+	      break;
+
+	    default:
+	      /* Major bug. We can't handle the case of a
+	         SEG_OP expression in a VIT_OPCODE_SYNTHETIC
+	         variable-length instruction.
+	         We don't have a frag type that is smart enough to
+	         relax a SEG_OP, and so we just force all
+	         SEG_OPs to behave like SEG_PASS1s.
+	         Clearly, if there is a demand we can invent a new or
+	         modified frag type and then coding up a frag for this
+	         case will be easy. SEG_OP was invented for the
+	         .words after a CASE opcode, and was never intended for
+	         instruction operands.  */
+	      need_pass_2 = 1;
+	      as_fatal (_("Can't relocate expression"));
+	      break;
+
+	    case O_big:
+	      /* Preserve the bits.  */
+	      if (expP->X_add_number > 0)
+		{
+		  bignum_copy (generic_bignum, expP->X_add_number,
+			       floatP->low, SIZE_OF_LARGE_NUMBER);
+		}
+	      else
+		{
+		  know (expP->X_add_number < 0);
+		  flonum_copy (&generic_floating_point_number,
+			       floatP);
+		  if (strchr ("s i", operandP->vop_short))
+		    {
+		      /* Could possibly become S^# */
+		      flonum_gen2vax (-expP->X_add_number, floatP, literal_float);
+		      switch (-expP->X_add_number)
+			{
+			case 'f':
+			  can_be_short =
+			    (literal_float[0] & 0xFC0F) == 0x4000
+			    && literal_float[1] == 0;
+			  break;
+
+			case 'd':
+			  can_be_short =
+			    (literal_float[0] & 0xFC0F) == 0x4000
+			    && literal_float[1] == 0
+			    && literal_float[2] == 0
+			    && literal_float[3] == 0;
+			  break;
+
+			case 'g':
+			  can_be_short =
+			    (literal_float[0] & 0xFF81) == 0x4000
+			    && literal_float[1] == 0
+			    && literal_float[2] == 0
+			    && literal_float[3] == 0;
+			  break;
+
+			case 'h':
+			  can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
+					  && (literal_float[1] & 0xE000) == 0
+					  && literal_float[2] == 0
+					  && literal_float[3] == 0
+					  && literal_float[4] == 0
+					  && literal_float[5] == 0
+					  && literal_float[6] == 0
+					  && literal_float[7] == 0);
+			  break;
+
+			default:
+			  BAD_CASE (-expP->X_add_number);
+			  break;
+			}
+		    }
+		}
+
+	      if (operandP->vop_short == 's'
+		  || operandP->vop_short == 'i'
+		  || (operandP->vop_short == ' '
+		      && operandP->vop_reg == 0xF
+		      && (operandP->vop_mode & 0xE) == 0x8))
+		{
+		  /* Saw a '#'.  */
+		  if (operandP->vop_short == ' ')
+		    {
+		      /* We must chose S^ or I^.  */
+		      if (expP->X_add_number > 0)
+			{
+			  /* Bignum: Short literal impossible.  */
+			  operandP->vop_short = 'i';
+			  operandP->vop_mode = 8;
+			  operandP->vop_reg = 0xF;	/* VAX PC.  */
+			}
+		      else
+			{
+			  /* Flonum: Try to do it.  */
+			  if (can_be_short)
+			    {
+			      operandP->vop_short = 's';
+			      operandP->vop_mode = 0;
+			      operandP->vop_ndx = -1;
+			      operandP->vop_reg = -1;
+			      expP->X_op = O_constant;
+			    }
+			  else
+			    {
+			      operandP->vop_short = 'i';
+			      operandP->vop_mode = 8;
+			      operandP->vop_reg = 0xF;	/* VAX PC */
+			    }
+			}	/* bignum or flonum ? */
+		    }		/*  if #, but no S^ or I^ seen.  */
+		  /* No more ' ' case: either 's' or 'i'.  */
+		  if (operandP->vop_short == 's')
+		    {
+		      /* Wants to be a short literal.  */
+		      if (expP->X_add_number > 0)
+			{
+			  as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
+			  operandP->vop_short = 'i';
+			  operandP->vop_mode = 8;
+			  operandP->vop_reg = 0xF;	/* VAX PC.  */
+			}
+		      else
+			{
+			  if (!can_be_short)
+			    {
+			      as_warn (_("Can't do flonum short literal: immediate mode used."));
+			      operandP->vop_short = 'i';
+			      operandP->vop_mode = 8;
+			      operandP->vop_reg = 0xF;	/* VAX PC.  */
+			    }
+			  else
+			    {
+			      /* Encode short literal now.  */
+			      int temp = 0;
+
+			      switch (-expP->X_add_number)
+				{
+				case 'f':
+				case 'd':
+				  temp = literal_float[0] >> 4;
+				  break;
+
+				case 'g':
+				  temp = literal_float[0] >> 1;
+				  break;
+
+				case 'h':
+				  temp = ((literal_float[0] << 3) & 070)
+				    | ((literal_float[1] >> 13) & 07);
+				  break;
+
+				default:
+				  BAD_CASE (-expP->X_add_number);
+				  break;
+				}
+
+			      floatP->low[0] = temp & 077;
+			      floatP->low[1] = 0;
+			    }
+			}
+		    }
+		  else
+		    {
+		      /* I^# seen: set it up if float.  */
+		      if (expP->X_add_number < 0)
+			{
+			  memcpy (floatP->low, literal_float, sizeof (literal_float));
+			}
+		    }		/* if S^# seen.  */
+		}
+	      else
+		{
+		  as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
+			   (expP->X_add_number = 0x80000000L));
+		  /* Chosen so luser gets the most offset bits to patch later.  */
+		}
+	      expP->X_add_number = floatP->low[0]
+		| ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
+
+	      /* For the O_big case we have:
+	         If vop_short == 's' then a short floating literal is in the
+	        	lowest 6 bits of floatP -> low [0], which is
+	        	big_operand_bits [---] [0].
+	         If vop_short == 'i' then the appropriate number of elements
+	        	of big_operand_bits [---] [...] are set up with the correct
+	        	bits.
+	         Also, just in case width is byte word or long, we copy the lowest
+	         32 bits of the number to X_add_number.  */
+	      break;
+	    }
+	  if (input_line_pointer != operandP->vop_expr_end + 1)
+	    {
+	      as_fatal ("Junk at end of expression \"%s\"", input_line_pointer);
+	      goofed = 1;
+	    }
+	  operandP->vop_expr_end[1] = c_save;
+	}
+    }
+
+  input_line_pointer = save_input_line_pointer;
+
+  if (need_pass_2 || goofed)
+    return;
+
+  /* Emit op-code.  */
+  /* Remember where it is, in case we want to modify the op-code later.  */
+  opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
+  memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
+  opcode_as_chars = v.vit_opcode;
+  opcode_as_number = md_chars_to_number ((unsigned char *) opcode_as_chars, 4);
+  for (operandP = v.vit_operand,
+       expP = exp_of_operand,
+       segP = seg_of_operand,
+       floatP = float_operand,
+       end_operandP = v.vit_operand + v.vit_operands;
+
+       operandP < end_operandP;
+
+       operandP++,
+       floatP++,
+       segP++,
+       expP++)
+    {
+      if (operandP->vop_ndx >= 0)
+	{
+	  /* Indexed addressing byte.  */
+	  /* Legality of indexed mode already checked: it is OK.  */
+	  FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
+	}			/* if(vop_ndx>=0) */
+
+      /* Here to make main operand frag(s).  */
+      this_add_number = expP->X_add_number;
+      this_add_symbol = expP->X_add_symbol;
+      to_seg = *segP;
+      is_undefined = (to_seg == undefined_section);
+      is_absolute = (to_seg == absolute_section);
+      at = operandP->vop_mode & 1;
+      length = (operandP->vop_short == 'b'
+		? 1 : (operandP->vop_short == 'w'
+		       ? 2 : (operandP->vop_short == 'l'
+			      ? 4 : 0)));
+      nbytes = operandP->vop_nbytes;
+      if (operandP->vop_access == 'b')
+	{
+	  if (to_seg == now_seg || is_undefined)
+	    {
+	      /* If is_undefined, then it might BECOME now_seg.  */
+	      if (nbytes)
+		{
+		  p = frag_more (nbytes);
+		  fix_new (frag_now, p - frag_now->fr_literal, nbytes,
+			   this_add_symbol, this_add_number, 1, NO_RELOC);
+		}
+	      else
+		{
+		  /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
+		  /* nbytes==0 */
+		  length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
+		  if (opcode_as_number & VIT_OPCODE_SPECIAL)
+		    {
+		      if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
+			{
+			  /* br or jsb */
+			  frag_var (rs_machine_dependent, 5, 1,
+			    ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
+				    this_add_symbol, this_add_number,
+				    opcode_low_byteP);
+			}
+		      else
+			{
+			  if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
+			    {
+			      length_code = STATE_WORD;
+			      /* JF: There is no state_byte for this one! */
+			      frag_var (rs_machine_dependent, 10, 2,
+					ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
+					this_add_symbol, this_add_number,
+					opcode_low_byteP);
+			    }
+			  else
+			    {
+			      know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
+			      frag_var (rs_machine_dependent, 9, 1,
+			      ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
+					this_add_symbol, this_add_number,
+					opcode_low_byteP);
+			    }
+			}
+		    }
+		  else
+		    {
+		      know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
+		      frag_var (rs_machine_dependent, 7, 1,
+		       ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
+				this_add_symbol, this_add_number,
+				opcode_low_byteP);
+		    }
+		}
+	    }
+	  else
+	    {
+	      /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
+	      /* --- SEG FLOAT MAY APPEAR HERE ---  */
+	      if (is_absolute)
+		{
+		  if (nbytes)
+		    {
+		      know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
+		      p = frag_more (nbytes);
+		      /* Conventional relocation.  */
+		      fix_new (frag_now, p - frag_now->fr_literal, nbytes,
+			       section_symbol (absolute_section),
+			       this_add_number, 1, NO_RELOC);
+		    }
+		  else
+		    {
+		      know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
+		      if (opcode_as_number & VIT_OPCODE_SPECIAL)
+			{
+			  if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
+			    {
+			      /* br or jsb */
+			      *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
+			      know (opcode_as_chars[1] == 0);
+			      p = frag_more (5);
+			      p[0] = VAX_ABSOLUTE_MODE;	/* @#...  */
+			      md_number_to_chars (p + 1, this_add_number, 4);
+			      /* Now (eg) JMP @#foo or JSB @#foo.  */
+			    }
+			  else
+			    {
+			      if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
+				{
+				  p = frag_more (10);
+				  p[0] = 2;
+				  p[1] = 0;
+				  p[2] = VAX_BRB;
+				  p[3] = 6;
+				  p[4] = VAX_JMP;
+				  p[5] = VAX_ABSOLUTE_MODE;	/* @#...  */
+				  md_number_to_chars (p + 6, this_add_number, 4);
+				  /* Now (eg)	ACBx	1f
+				    		BRB	2f
+				    	1:	JMP	@#foo
+				    	2:  */
+				}
+			      else
+				{
+				  know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
+				  p = frag_more (9);
+				  p[0] = 2;
+				  p[1] = VAX_BRB;
+				  p[2] = 6;
+				  p[3] = VAX_JMP;
+                                  p[4] = VAX_ABSOLUTE_MODE;     /* @#...  */
+				  md_number_to_chars (p + 5, this_add_number, 4);
+				  /* Now (eg)	xOBxxx	1f
+				   		BRB	2f
+				   	1:	JMP	@#foo
+				   	2:  */
+				}
+			    }
+			}
+		      else
+			{
+			  /* b<cond> */
+			  *opcode_low_byteP ^= 1;
+			  /* To reverse the condition in a VAX branch,
+			     complement the lowest order bit.  */
+			  p = frag_more (7);
+			  p[0] = 6;
+			  p[1] = VAX_JMP;
+			  p[2] = VAX_ABSOLUTE_MODE;	/* @#...  */
+			  md_number_to_chars (p + 3, this_add_number, 4);
+			  /* Now (eg)	BLEQ	1f
+			   		JMP	@#foo
+			   	1:  */
+			}
+		    }
+		}
+	      else
+		{
+		  /* to_seg != now_seg && !is_undefinfed && !is_absolute */
+		  if (nbytes > 0)
+		    {
+		      /* Pc-relative. Conventional relocation.  */
+		      know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
+		      p = frag_more (nbytes);
+		      fix_new (frag_now, p - frag_now->fr_literal, nbytes,
+			       section_symbol (absolute_section),
+			       this_add_number, 1, NO_RELOC);
+		    }
+		  else
+		    {
+		      know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
+		      if (opcode_as_number & VIT_OPCODE_SPECIAL)
+			{
+			  if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
+			    {
+			      /* br or jsb */
+			      know (opcode_as_chars[1] == 0);
+			      *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
+			      p = frag_more (5);
+			      p[0] = VAX_PC_RELATIVE_MODE;
+			      fix_new (frag_now,
+				       p + 1 - frag_now->fr_literal, 4,
+				       this_add_symbol,
+				       this_add_number, 1, NO_RELOC);
+			      /* Now eg JMP foo or JSB foo.  */
+			    }
+			  else
+			    {
+			      if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
+				{
+				  p = frag_more (10);
+				  p[0] = 0;
+				  p[1] = 2;
+				  p[2] = VAX_BRB;
+				  p[3] = 6;
+				  p[4] = VAX_JMP;
+				  p[5] = VAX_PC_RELATIVE_MODE;
+				  fix_new (frag_now,
+					   p + 6 - frag_now->fr_literal, 4,
+					   this_add_symbol,
+					   this_add_number, 1, NO_RELOC);
+				  /* Now (eg)	ACBx	1f
+				   		BRB	2f
+				   	1:	JMP	foo
+				   	2:  */
+				}
+			      else
+				{
+				  know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
+				  p = frag_more (10);
+				  p[0] = 2;
+				  p[1] = VAX_BRB;
+				  p[2] = 6;
+				  p[3] = VAX_JMP;
+				  p[4] = VAX_PC_RELATIVE_MODE;
+				  fix_new (frag_now,
+					   p + 5 - frag_now->fr_literal,
+					   4, this_add_symbol,
+					   this_add_number, 1, NO_RELOC);
+				  /* Now (eg)	xOBxxx	1f
+				   		BRB	2f
+				   	1:	JMP	foo
+				   	2:  */
+				}
+			    }
+			}
+		      else
+			{
+			  know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
+			  *opcode_low_byteP ^= 1;	/* Reverse branch condition.  */
+			  p = frag_more (7);
+			  p[0] = 6;
+			  p[1] = VAX_JMP;
+			  p[2] = VAX_PC_RELATIVE_MODE;
+			  fix_new (frag_now, p + 3 - frag_now->fr_literal,
+				   4, this_add_symbol,
+				   this_add_number, 1, NO_RELOC);
+			}
+		    }
+		}
+	    }
+	}
+      else
+	{
+	  /* So it is ordinary operand.  */
+	  know (operandP->vop_access != 'b');
+	  /* ' ' target-independent: elsewhere.  */
+	  know (operandP->vop_access != ' ');
+	  know (operandP->vop_access == 'a'
+		|| operandP->vop_access == 'm'
+		|| operandP->vop_access == 'r'
+		|| operandP->vop_access == 'v'
+		|| operandP->vop_access == 'w');
+	  if (operandP->vop_short == 's')
+	    {
+	      if (is_absolute)
+		{
+		  if (this_add_number >= 64)
+		    {
+		      as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
+			       (long) this_add_number);
+		      operandP->vop_short = 'i';
+		      operandP->vop_mode = 8;
+		      operandP->vop_reg = 0xF;
+		    }
+		}
+	      else
+		{
+		  as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
+			   segment_name (now_seg), segment_name (to_seg));
+		  operandP->vop_short = 'i';
+		  operandP->vop_mode = 8;
+		  operandP->vop_reg = 0xF;
+		}
+	    }
+	  if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
+		  || (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
+	    {
+	      /* One byte operand.  */
+	      know (operandP->vop_mode > 3);
+	      FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
+	      /* All 1-bytes except S^# happen here.  */
+	    }
+	  else
+	    {
+	      /* {@}{q^}foo{(Rn)} or S^#foo */
+	      if (operandP->vop_reg == -1 && operandP->vop_short != 's')
+		{
+		  /* "{@}{q^}foo" */
+		  if (to_seg == now_seg)
+		    {
+		      if (length == 0)
+			{
+			  know (operandP->vop_short == ' ');
+			  length_code = STATE_BYTE;
+#ifdef OBJ_ELF
+			  if (S_IS_EXTERNAL (this_add_symbol)
+			      || S_IS_WEAK (this_add_symbol))
+			    length_code = STATE_UNDF;
+#endif
+			  p = frag_var (rs_machine_dependent, 10, 2,
+			       ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
+					this_add_symbol, this_add_number,
+					opcode_low_byteP);
+			  know (operandP->vop_mode == 10 + at);
+			  *p = at << 4;
+			  /* At is the only context we need to carry
+			     to other side of relax() process.  Must
+			     be in the correct bit position of VAX
+			     operand spec. byte.  */
+			}
+		      else
+			{
+			  know (length);
+			  know (operandP->vop_short != ' ');
+			  p = frag_more (length + 1);
+			  p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
+			  fix_new (frag_now, p + 1 - frag_now->fr_literal,
+				   length, this_add_symbol,
+				   this_add_number, 1, NO_RELOC);
+			}
+		    }
+		  else
+		    {
+		      /* to_seg != now_seg */
+		      if (this_add_symbol == NULL)
+			{
+			  know (is_absolute);
+			  /* Do @#foo: simpler relocation than foo-.(pc) anyway.  */
+			  p = frag_more (5);
+			  p[0] = VAX_ABSOLUTE_MODE;	/* @#...  */
+			  md_number_to_chars (p + 1, this_add_number, 4);
+			  if (length && length != 4)
+			    as_warn (_("Length specification ignored. Address mode 9F used"));
+			}
+		      else
+			{
+			  /* {@}{q^}other_seg */
+			  know ((length == 0 && operandP->vop_short == ' ')
+			     || (length > 0 && operandP->vop_short != ' '));
+			  if (is_undefined
+#ifdef OBJ_ELF
+			      || S_IS_WEAK(this_add_symbol)
+			      || S_IS_EXTERNAL(this_add_symbol)
+#endif
+			      )
+			    {
+			      switch (length)
+				{
+				default: length_code = STATE_UNDF; break;
+				case 1: length_code = STATE_BYTE; break;
+				case 2: length_code = STATE_WORD; break;
+				case 4: length_code = STATE_LONG; break;
+				}
+			      /* We have a SEG_UNKNOWN symbol. It might
+			         turn out to be in the same segment as
+			         the instruction, permitting relaxation.  */
+			      p = frag_var (rs_machine_dependent, 5, 2,
+			       ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
+					    this_add_symbol, this_add_number,
+					    opcode_low_byteP);
+			      p[0] = at << 4;
+			    }
+			  else
+			    {
+			      if (length == 0)
+				{
+				  know (operandP->vop_short == ' ');
+				  length = 4;	/* Longest possible.  */
+				}
+			      p = frag_more (length + 1);
+			      p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
+			      md_number_to_chars (p + 1, this_add_number, length);
+			      fix_new (frag_now,
+				       p + 1 - frag_now->fr_literal,
+				       length, this_add_symbol,
+				       this_add_number, 1, NO_RELOC);
+			    }
+			}
+		    }
+		}
+	      else
+		{
+		  /* {@}{q^}foo(Rn) or S^# or I^# or # */
+		  if (operandP->vop_mode < 0xA)
+		    {
+		      /* # or S^# or I^# */
+		      if (operandP->vop_access == 'v'
+			  || operandP->vop_access == 'a')
+			{
+			  if (operandP->vop_access == 'v')
+			    as_warn (_("Invalid operand:  immediate value used as base address."));
+			  else
+			    as_warn (_("Invalid operand:  immediate value used as address."));
+			  /* gcc 2.6.3 is known to generate these in at least
+			     one case.  */
+			}
+		      if (length == 0
+			  && is_absolute && (expP->X_op != O_big)
+			  && operandP->vop_mode == 8	/* No '@'.  */
+			  && this_add_number < 64)
+			{
+			  operandP->vop_short = 's';
+			}
+		      if (operandP->vop_short == 's')
+			{
+			  FRAG_APPEND_1_CHAR (this_add_number);
+			}
+		      else
+			{
+			  /* I^#...  */
+			  know (nbytes);
+			  p = frag_more (nbytes + 1);
+			  know (operandP->vop_reg == 0xF);
+#ifdef OBJ_ELF
+			  if (flag_want_pic && operandP->vop_mode == 8
+				&& this_add_symbol != NULL)
+			    {
+			      as_warn (_("Symbol used as immediate operand in PIC mode."));
+			    }
+#endif
+			  p[0] = (operandP->vop_mode << 4) | 0xF;
+			  if ((is_absolute) && (expP->X_op != O_big))
+			    {
+			      /* If nbytes > 4, then we are scrod. We
+			         don't know if the high order bytes
+			         are to be 0xFF or 0x00.  BSD4.2 & RMS
+			         say use 0x00. OK --- but this
+			         assembler needs ANOTHER rewrite to
+			         cope properly with this bug.  */
+			      md_number_to_chars (p + 1, this_add_number,
+						  min (sizeof (valueT),
+						       (size_t) nbytes));
+			      if ((size_t) nbytes > sizeof (valueT))
+				memset (p + 5, '\0', nbytes - sizeof (valueT));
+			    }
+			  else
+			    {
+			      if (expP->X_op == O_big)
+				{
+				  /* Problem here is to get the bytes
+				     in the right order.  We stored
+				     our constant as LITTLENUMs, not
+				     bytes.  */
+				  LITTLENUM_TYPE *lP;
+
+				  lP = floatP->low;
+				  if (nbytes & 1)
+				    {
+				      know (nbytes == 1);
+				      p[1] = *lP;
+				    }
+				  else
+				    {
+				      for (p++; nbytes; nbytes -= 2, p += 2, lP++)
+					md_number_to_chars (p, *lP, 2);
+				    }
+				}
+			      else
+				{
+				  fix_new (frag_now, p + 1 - frag_now->fr_literal,
+					   nbytes, this_add_symbol,
+					   this_add_number, 0, NO_RELOC);
+				}
+			    }
+			}
+		    }
+		  else
+		    {
+		      /* {@}{q^}foo(Rn) */
+		      know ((length == 0 && operandP->vop_short == ' ')
+			    || (length > 0 && operandP->vop_short != ' '));
+		      if (length == 0)
+			{
+			  if (is_absolute)
+			    {
+			      long test;
+
+			      test = this_add_number;
+
+			      if (test < 0)
+				test = ~test;
+
+			      length = test & 0xffff8000 ? 4
+				: test & 0xffffff80 ? 2
+				: 1;
+			    }
+			  else
+			    {
+			      length = 4;
+			    }
+			}
+		      p = frag_more (1 + length);
+		      know (operandP->vop_reg >= 0);
+		      p[0] = operandP->vop_reg
+			| ((at | "?\12\14?\16"[length]) << 4);
+		      if (is_absolute)
+			{
+			  md_number_to_chars (p + 1, this_add_number, length);
+			}
+		      else
+			{
+			  fix_new (frag_now, p + 1 - frag_now->fr_literal,
+				   length, this_add_symbol,
+				   this_add_number, 0, NO_RELOC);
+			}
+		    }
+		}
+	    }
+	}
+    }
+}
+
+void
+md_begin (void)
+{
+  const char *errtxt;
+  FLONUM_TYPE *fP;
+  int i;
+
+  if ((errtxt = vip_begin (1, "$", "*", "`")) != 0)
+    as_fatal (_("VIP_BEGIN error:%s"), errtxt);
+
+  for (i = 0, fP = float_operand;
+       fP < float_operand + VIT_MAX_OPERANDS;
+       i++, fP++)
+    {
+      fP->low = &big_operand_bits[i][0];
+      fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
+    }
+}