if (flag_mri && *input_line_pointer == '\'')
if (flag_m68k_mri && *input_line_pointer == '\'')
read_a_source_file (name)     char *name;{  register char c;  register char *s;		/* string of symbol, '\0' appended */  register int temp;  pseudo_typeS *pop;  buffer = input_scrub_new_file (name);  listing_file (name);  listing_newline ("");  while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)    {				/* We have another line to parse. */      know (buffer_limit[-1] == '\n');	/* Must have a sentinel. */    contin:			/* JF this goto is my fault I admit it.				   Someone brave please re-write the whole				   input section here?  Pleeze???  */      while (input_line_pointer < buffer_limit)	{	  /* We have more of this buffer to parse. */	  /*	   * We now have input_line_pointer->1st char of next line.	   * If input_line_pointer [-1] == '\n' then we just	   * scanned another line: so bump line counters.	   */	  if (is_end_of_line[(unsigned char) input_line_pointer[-1]])	    {#ifdef md_start_line_hook	      md_start_line_hook ();#endif	      if (input_line_pointer[-1] == '\n')		bump_line_counters ();	      line_label = NULL;	      if (flag_mri#ifdef LABELS_WITHOUT_COLONS		  || 1#endif		  )		{		  /* Text at the start of a line must be a label, we		     run down and stick a colon in.  */		  if (is_name_beginner (*input_line_pointer))		    {		      char *line_start = input_line_pointer;		      char c;		      HANDLE_CONDITIONAL_ASSEMBLY ();		      c = get_symbol_end ();		      /* In MRI mode, the EQU pseudoop must be			 handled specially.  */		      if (flag_mri)			{			  char *rest = input_line_pointer + 1;			  if (*rest == ':')			    ++rest;			  if (*rest == ' ' || *rest == '\t')			    ++rest;			  if ((strncasecmp (rest, "EQU", 3) == 0			       || strncasecmp (rest, "SET", 3) == 0)			      && (rest[3] == ' ' || rest[3] == '\t'))			    {			      input_line_pointer = rest + 3;			      equals (line_start);			      continue;			    }			}		      line_label = colon (line_start);		      *input_line_pointer = c;		      if (c == ':')			input_line_pointer++;		    }		}	    }	  /*	   * We are at the begining of a line, or similar place.	   * We expect a well-formed assembler statement.	   * A "symbol-name:" is a statement.	   *	   * Depending on what compiler is used, the order of these tests	   * may vary to catch most common case 1st.	   * Each test is independent of all other tests at the (top) level.	   * PLEASE make a compiler that doesn't use this assembler.	   * It is crufty to waste a compiler's time encoding things for this	   * assembler, which then wastes more time decoding it.	   * (And communicating via (linear) files is silly!	   * If you must pass stuff, please pass a tree!)	   */	  if ((c = *input_line_pointer++) == '\t'	      || c == ' '	      || c == '\f'	      || c == 0)	    {	      c = *input_line_pointer++;	    }	  know (c != ' ');	/* No further leading whitespace. */	  LISTING_NEWLINE ();	  /*	   * C is the 1st significant character.	   * Input_line_pointer points after that character.	   */	  if (is_name_beginner (c))	    {	      /* want user-defined label or pseudo/opcode */	      HANDLE_CONDITIONAL_ASSEMBLY ();	      s = --input_line_pointer;	      c = get_symbol_end ();	/* name's delimiter */	      /*	       * C is character after symbol.	       * That character's place in the input line is now '\0'.	       * S points to the beginning of the symbol.	       *   [In case of pseudo-op, s->'.'.]	       * Input_line_pointer->'\0' where c was.	       */	      if (TC_START_LABEL(c, input_line_pointer))		{		  if (flag_mri)		    {		      char *rest = input_line_pointer + 1;		      /* In MRI mode, \tsym: set 0 is permitted.  */		      if (*rest == ':')			++rest;		      if (*rest == ' ' || *rest == '\t')			++rest;		      if ((strncasecmp (rest, "EQU", 3) == 0			   || strncasecmp (rest, "SET", 3) == 0)			  && (rest[3] == ' ' || rest[3] == '\t'))			{			  input_line_pointer = rest + 3;			  equals (s);			  continue;			}		    }		  line_label = colon (s);	/* user-defined label */		  *input_line_pointer++ = ':';	/* Put ':' back for error messages' sake. */		  /* Input_line_pointer->after ':'. */		  SKIP_WHITESPACE ();		}	      else if (c == '='		       || (input_line_pointer[1] == '='#ifdef TC_EQUAL_IN_INSN			   && ! TC_EQUAL_IN_INSN (c, input_line_pointer)#endif			   ))		{		  equals (s);		  demand_empty_rest_of_line ();		}	      else		{		/* expect pseudo-op or machine instruction */		  pop = NULL;#define IGNORE_OPCODE_CASE#ifdef IGNORE_OPCODE_CASE		  {		    char *s2 = s;		    while (*s2)		      {			if (isupper (*s2))			  *s2 = tolower (*s2);			s2++;		      }		  }#endif#ifndef MRI_MODE_NEEDS_PSEUDO_DOT#define MRI_MODE_NEEDS_PSEUDO_DOT 0#endif		  if ((flag_mri && ! MRI_MODE_NEEDS_PSEUDO_DOT)#ifdef NO_PSEUDO_DOT		      || 1#endif		      )		    {		      /* The MRI assembler and the m88k use pseudo-ops                         without a period.  */		      pop = (pseudo_typeS *) hash_find (po_hash, s);		      if (pop != NULL && pop->poc_handler == NULL)			pop = NULL;		    }		  if (pop != NULL		      || ((! flag_mri || MRI_MODE_NEEDS_PSEUDO_DOT)			  && *s == '.'))		    {		      /*		       * PSEUDO - OP.		       *		       * WARNING: c has next char, which may be end-of-line.		       * We lookup the pseudo-op table with s+1 because we		       * already know that the pseudo-op begins with a '.'.		       */		      if (pop == NULL)			pop = (pseudo_typeS *) hash_find (po_hash, s + 1);		      /* In MRI mode, we may need to insert an                         automatic alignment directive.  What a hack                         this is.  */		      if (mri_pending_align			  && (pop == NULL			      || ! ((pop->poc_handler == cons				     && pop->poc_val == 1)				    || (pop->poc_handler == s_space					&& pop->poc_val == 1))))			{			  do_align (1, (char *) NULL);			  mri_pending_align = 0;			}		      /* Print the error msg now, while we still can */		      if (pop == NULL)			{			  as_bad ("Unknown pseudo-op:  `%s'", s);			  *input_line_pointer = c;			  s_ignore (0);			  continue;			}		      /* Put it back for error messages etc. */		      *input_line_pointer = c;		      /* The following skip of whitespace is compulsory.			 A well shaped space is sometimes all that separates			 keyword from operands. */		      if (c == ' ' || c == '\t')			input_line_pointer++;		      /*		       * Input_line is restored.		       * Input_line_pointer->1st non-blank char		       * after pseudo-operation.		       */		      (*pop->poc_handler) (pop->poc_val);		      /* If that was .end, just get out now.  */		      if (pop->poc_handler == s_end)			goto quit;		    }		  else		    {		/* machine instruction */		      int inquote = 0;		      if (mri_pending_align)			{			  do_align (1, (char *) NULL);			  mri_pending_align = 0;			}		      /* WARNING: c has char, which may be end-of-line. */		      /* Also: input_line_pointer->`\0` where c was. */		      *input_line_pointer = c;		      while (!is_end_of_line[(unsigned char) *input_line_pointer]			     || inquote#ifdef TC_EOL_IN_INSN			     || TC_EOL_IN_INSN (input_line_pointer)#endif			     )			{			  if (flag_mri && *input_line_pointer == '\'')			    inquote = ! inquote;			  input_line_pointer++;			}		      c = *input_line_pointer;		      *input_line_pointer = '\0';#ifdef OBJ_GENERATE_ASM_LINENO		      if (generate_asm_lineno == 0)			{		          if (ecoff_no_current_file ())			    generate_asm_lineno = 1;			}		      if (generate_asm_lineno == 1)		        {			  unsigned int lineno;			  char *s;			  as_where (&s, &lineno);			  OBJ_GENERATE_ASM_LINENO (s, lineno);		        }#endif		      if (macro_defined)			{			  sb out;			  const char *err;			  if (check_macro (s, &out, '\0', &err))			    {			      if (err != NULL)				as_bad (err);			      *input_line_pointer++ = c;			      input_scrub_include_sb (&out,						      input_line_pointer);			      sb_kill (&out);			      buffer_limit =				input_scrub_next_buffer (&input_line_pointer);			      continue;			    }			}		      md_assemble (s);	/* Assemble 1 instruction. */		      *input_line_pointer++ = c;		      /* We resume loop AFTER the end-of-line from			 this instruction. */		    }		/* if (*s=='.') */		}		/* if c==':' */	      continue;	    }			/* if (is_name_beginner(c) */	  /* Empty statement?  */	  if (is_end_of_line[(unsigned char) c])	    continue;	  if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB)	      && isdigit (c))	    {	      /* local label  ("4:") */	      char *backup = input_line_pointer;	      HANDLE_CONDITIONAL_ASSEMBLY ();	      temp = c - '0';	      while (isdigit (*input_line_pointer))		{		  temp = (temp * 10) + *input_line_pointer - '0';		  ++input_line_pointer;		}		/* read the whole number */	      if (LOCAL_LABELS_DOLLAR		  && *input_line_pointer == '$'		  && *(input_line_pointer + 1) == ':')		{		  input_line_pointer += 2;		  if (dollar_label_defined (temp))		    {		      as_fatal ("label \"%d$\" redefined", temp);		    }		  define_dollar_label (temp);		  colon (dollar_label_name (temp, 0));		  continue;		}	      if (LOCAL_LABELS_FB		  && *input_line_pointer++ == ':')		{		  fb_label_instance_inc (temp);		  colon (fb_label_name (temp, 0));		  continue;		}	      input_line_pointer = backup;	    }			/* local label  ("4:") */	  if (c && strchr (line_comment_chars, c))	    {			/* Its a comment.  Better say APP or NO_APP */	      char *ends;	      char *new_buf;	      char *new_tmp;	      unsigned int new_length;	      char *tmp_buf = 0;	      bump_line_counters ();	      s = input_line_pointer;	      if (strncmp (s, "APP\n", 4))		continue;	/* We ignore it */	      s += 4;	      ends = strstr (s, "#NO_APP\n");	      if (!ends)		{		  unsigned int tmp_len;		  unsigned int num;		  /* The end of the #APP wasn't in this buffer.  We		     keep reading in buffers until we find the #NO_APP		     that goes with this #APP  There is one.  The specs		     guarentee it. . . */		  tmp_len = buffer_limit - s;		  tmp_buf = xmalloc (tmp_len + 1);		  memcpy (tmp_buf, s, tmp_len);		  do		    {		      new_tmp = input_scrub_next_buffer (&buffer);		      if (!new_tmp)			break;		      else			buffer_limit = new_tmp;		      input_line_pointer = buffer;		      ends = strstr (buffer, "#NO_APP\n");		      if (ends)			num = ends - buffer;		      else			num = buffer_limit - buffer;		      tmp_buf = xrealloc (tmp_buf, tmp_len + num);		      memcpy (tmp_buf + tmp_len, buffer, num);		      tmp_len += num;		    }		  while (!ends);		  input_line_pointer = ends ? ends + 8 : NULL;		  s = tmp_buf;		  ends = s + tmp_len;		}	      else		{		  input_line_pointer = ends + 8;		}	      scrub_string = s;	      scrub_string_end = ends;	      new_length = ends - s;	      new_buf = (char *) xmalloc (new_length);	      new_tmp = new_buf;	      for (;;)		{		  int space;		  int size;		  space = (new_buf + new_length) - new_tmp;		  size = do_scrub_chars (scrub_from_string, new_tmp, space);		  if (size < space)		    {		      new_tmp += size;		      break;		    }		  new_buf = xrealloc (new_buf, new_length + 100);		  new_tmp = new_buf + new_length;		  new_length += 100;		}	      if (tmp_buf)		free (tmp_buf);	      old_buffer = buffer;	      old_input = input_line_pointer;	      old_limit = buffer_limit;	      buffer = new_buf;	      input_line_pointer = new_buf;	      buffer_limit = new_tmp;	      continue;	    }	  HANDLE_CONDITIONAL_ASSEMBLY ();	  /* as_warn("Junk character %d.",c);  Now done by ignore_rest */	  input_line_pointer--;	/* Report unknown char as ignored. */	  ignore_rest_of_line ();	}			/* while (input_line_pointer<buffer_limit) */#ifdef md_after_pass_hook      md_after_pass_hook ();#endif      if (old_buffer)	{	  free (buffer);	  bump_line_counters ();	  if (old_input != 0)	    {	      buffer = old_buffer;	      input_line_pointer = old_input;	      buffer_limit = old_limit;	      old_buffer = 0;	      goto contin;	    }	}    }				/* while (more buffers to scan) */ quit:  input_scrub_close ();		/* Close the input file */}