[thirdparty/binutils-gdb.git] / gas / input-scrub.c

/* input_scrub.c - Break up input buffers into whole numbers of lines.
   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   2000, 2001, 2003
   Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to the Free
   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
   02110-1301, USA.  */

#include <errno.h>		/* Need this to make errno declaration right */
#include "as.h"
#include "input-file.h"
#include "sb.h"
#include "listing.h"

/*
 * O/S independent module to supply buffers of sanitised source code
 * to rest of assembler.  We get sanitised input data of arbitrary length.
 * We break these buffers on line boundaries, recombine pieces that
 * were broken across buffers, and return a buffer of full lines to
 * the caller.
 * The last partial line begins the next buffer we build and return to caller.
 * The buffer returned to caller is preceded by BEFORE_STRING and followed
 * by AFTER_STRING, as sentinels. The last character before AFTER_STRING
 * is a newline.
 * Also looks after line numbers, for e.g. error messages.
 */

/*
 * We don't care how filthy our buffers are, but our callers assume
 * that the following sanitation has already been done.
 *
 * No comments, reduce a comment to a space.
 * Reduce a tab to a space unless it is 1st char of line.
 * All multiple tabs and spaces collapsed into 1 char. Tab only
 *   legal if 1st char of line.
 * # line file statements converted to .line x;.file y; statements.
 * Escaped newlines at end of line: remove them but add as many newlines
 *   to end of statement as you removed in the middle, to synch line numbers.
 */
\f
#define BEFORE_STRING ("\n")
#define AFTER_STRING ("\0")	/* memcpy of 0 chars might choke.  */
#define BEFORE_SIZE (1)
#define AFTER_SIZE  (1)

static char *buffer_start;	/*->1st char of full buffer area.  */
static char *partial_where;	/*->after last full line in buffer.  */
static int partial_size;	/* >=0. Number of chars in partial line in buffer.  */

/* Because we need AFTER_STRING just after last full line, it clobbers
   1st part of partial line. So we preserve 1st part of partial line
   here.  */
static char save_source[AFTER_SIZE];

/* What is the largest size buffer that input_file_give_next_buffer()
   could return to us?  */
static unsigned int buffer_length;

/* The index into an sb structure we are reading from.  -1 if none.  */
static int sb_index = -1;

/* If we are reading from an sb structure, this is it.  */
static sb from_sb;

/* Should we do a conditional check on from_sb? */
static int from_sb_is_expansion = 1;

/* The number of nested sb structures we have included.  */
int macro_nest;

/* We can have more than one source file open at once, though the info for all
   but the latest one are saved off in a struct input_save.  These files remain
   open, so we are limited by the number of open files allowed by the
   underlying OS. We may also sequentially read more than one source file in an
   assembly.  */

/* We must track the physical file and line number for error messages. We also
   track a "logical" file and line number corresponding to (C?)  compiler
   source line numbers.  Whenever we open a file we must fill in
   physical_input_file. So if it is NULL we have not opened any files yet.  */

static char *physical_input_file;
static char *logical_input_file;

typedef unsigned int line_numberT;	/* 1-origin line number in a source file.  */
/* A line ends in '\n' or eof.  */

static line_numberT physical_input_line;
static int logical_input_line;

/* Struct used to save the state of the input handler during include files */
struct input_save {
  char *              buffer_start;
  char *              partial_where;
  int                 partial_size;
  char                save_source[AFTER_SIZE];
  unsigned int        buffer_length;
  char *              physical_input_file;
  char *              logical_input_file;
  line_numberT        physical_input_line;
  int                 logical_input_line;
  int                 sb_index;
  sb                  from_sb;
  int                 from_sb_is_expansion; /* Should we do a conditional check?  */
  struct input_save * next_saved_file;	/* Chain of input_saves.  */
  char *              input_file_save;	/* Saved state of input routines.  */
  char *              saved_position;	/* Caller's saved position in buf.  */
};

static struct input_save *input_scrub_push (char *saved_position);
static char *input_scrub_pop (struct input_save *arg);

/* Saved information about the file that .include'd this one.  When we hit EOF,
   we automatically pop to that file.  */

static struct input_save *next_saved_file;

/* Push the state of input reading and scrubbing so that we can #include.
   The return value is a 'void *' (fudged for old compilers) to a save
   area, which can be restored by passing it to input_scrub_pop().  */

static struct input_save *
input_scrub_push (char *saved_position)
{
  register struct input_save *saved;

  saved = (struct input_save *) xmalloc (sizeof *saved);

  saved->saved_position = saved_position;
  saved->buffer_start = buffer_start;
  saved->partial_where = partial_where;
  saved->partial_size = partial_size;
  saved->buffer_length = buffer_length;
  saved->physical_input_file = physical_input_file;
  saved->logical_input_file = logical_input_file;
  saved->physical_input_line = physical_input_line;
  saved->logical_input_line = logical_input_line;
  saved->sb_index = sb_index;
  saved->from_sb = from_sb;
  saved->from_sb_is_expansion = from_sb_is_expansion;
  memcpy (saved->save_source, save_source, sizeof (save_source));
  saved->next_saved_file = next_saved_file;
  saved->input_file_save = input_file_push ();

  input_file_begin ();		/* Reinitialize! */
  logical_input_line = -1;
  logical_input_file = (char *) NULL;
  buffer_length = input_file_buffer_size ();
  sb_index = -1;

  buffer_start = xmalloc ((BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE));
  memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE);

  return saved;
}

static char *
input_scrub_pop (struct input_save *saved)
{
  char *saved_position;

  input_scrub_end ();		/* Finish off old buffer */

  input_file_pop (saved->input_file_save);
  saved_position = saved->saved_position;
  buffer_start = saved->buffer_start;
  buffer_length = saved->buffer_length;
  physical_input_file = saved->physical_input_file;
  logical_input_file = saved->logical_input_file;
  physical_input_line = saved->physical_input_line;
  logical_input_line = saved->logical_input_line;
  sb_index = saved->sb_index;
  from_sb = saved->from_sb;
  from_sb_is_expansion = saved->from_sb_is_expansion;
  partial_where = saved->partial_where;
  partial_size = saved->partial_size;
  next_saved_file = saved->next_saved_file;
  memcpy (save_source, saved->save_source, sizeof (save_source));

  free (saved);
  return saved_position;
}
\f
void
input_scrub_begin (void)
{
  know (strlen (BEFORE_STRING) == BEFORE_SIZE);
  know (strlen (AFTER_STRING) == AFTER_SIZE
	|| (AFTER_STRING[0] == '\0' && AFTER_SIZE == 1));

  input_file_begin ();

  buffer_length = input_file_buffer_size ();

  buffer_start = xmalloc ((BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE));
  memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE);

  /* Line number things.  */
  logical_input_line = -1;
  logical_input_file = (char *) NULL;
  physical_input_file = NULL;	/* No file read yet.  */
  next_saved_file = NULL;	/* At EOF, don't pop to any other file */
  do_scrub_begin (flag_m68k_mri);
}

void
input_scrub_end (void)
{
  if (buffer_start)
    {
      free (buffer_start);
      buffer_start = 0;
      input_file_end ();
    }
}

/* Start reading input from a new file.
   Return start of caller's part of buffer.  */

char *
input_scrub_new_file (char *filename)
{
  input_file_open (filename, !flag_no_comments);
  physical_input_file = filename[0] ? filename : _("{standard input}");
  physical_input_line = 0;

  partial_size = 0;
  return (buffer_start + BEFORE_SIZE);
}

/* Include a file from the current file.  Save our state, cause it to
   be restored on EOF, and begin handling a new file.  Same result as
   input_scrub_new_file.  */

char *
input_scrub_include_file (char *filename, char *position)
{
  next_saved_file = input_scrub_push (position);
  return input_scrub_new_file (filename);
}

/* Start getting input from an sb structure.  This is used when
   expanding a macro.  */

void
input_scrub_include_sb (sb *from, char *position, int is_expansion)
{
  if (macro_nest > max_macro_nest)
    as_fatal (_("macros nested too deeply"));
  ++macro_nest;

#ifdef md_macro_start
  if (is_expansion)
    {
      md_macro_start ();
    }
#endif

  next_saved_file = input_scrub_push (position);

  sb_new (&from_sb);
  from_sb_is_expansion = is_expansion;
  if (from->len >= 1 && from->ptr[0] != '\n')
    {
      /* Add the sentinel required by read.c.  */
      sb_add_char (&from_sb, '\n');
    }
  sb_add_sb (&from_sb, from);
  sb_index = 1;

  /* These variables are reset by input_scrub_push.  Restore them
     since we are, after all, still at the same point in the file.  */
  logical_input_line = next_saved_file->logical_input_line;
  logical_input_file = next_saved_file->logical_input_file;
}

void
input_scrub_close (void)
{
  input_file_close ();
}

char *
input_scrub_next_buffer (char **bufp)
{
  register char *limit;		/*->just after last char of buffer.  */

  if (sb_index >= 0)
    {
      if (sb_index >= from_sb.len)
	{
	  sb_kill (&from_sb);
	  if (from_sb_is_expansion
	      )
	    {
	      cond_finish_check (macro_nest);
#ifdef md_macro_end
	      /* Allow the target to clean up per-macro expansion
	         data.  */
	      md_macro_end ();
#endif
	    }
	  --macro_nest;
	  partial_where = NULL;
	  if (next_saved_file != NULL)
	    *bufp = input_scrub_pop (next_saved_file);
	  return partial_where;
	}

      partial_where = from_sb.ptr + from_sb.len;
      partial_size = 0;
      *bufp = from_sb.ptr + sb_index;
      sb_index = from_sb.len;
      return partial_where;
    }

  *bufp = buffer_start + BEFORE_SIZE;

  if (partial_size)
    {
      memcpy (buffer_start + BEFORE_SIZE, partial_where,
	      (unsigned int) partial_size);
      memcpy (buffer_start + BEFORE_SIZE, save_source, AFTER_SIZE);
    }
  limit = input_file_give_next_buffer (buffer_start
				       + BEFORE_SIZE
				       + partial_size);
  if (limit)
    {
      register char *p;		/* Find last newline.  */

      for (p = limit - 1; *p != '\n'; --p)
	;
      ++p;

      while (p <= buffer_start + BEFORE_SIZE)
	{
	  int limoff;

	  limoff = limit - buffer_start;
	  buffer_length += input_file_buffer_size ();
	  buffer_start = xrealloc (buffer_start,
				   (BEFORE_SIZE
				    + 2 * buffer_length
				    + AFTER_SIZE));
	  *bufp = buffer_start + BEFORE_SIZE;
	  limit = input_file_give_next_buffer (buffer_start + limoff);

	  if (limit == NULL)
	    {
	      as_warn (_("partial line at end of file ignored"));
	      partial_where = NULL;
	      if (next_saved_file)
		*bufp = input_scrub_pop (next_saved_file);
	      return NULL;
	    }

	  for (p = limit - 1; *p != '\n'; --p)
	    ;
	  ++p;
	}

      partial_where = p;
      partial_size = limit - p;
      memcpy (save_source, partial_where, (int) AFTER_SIZE);
      memcpy (partial_where, AFTER_STRING, (int) AFTER_SIZE);
    }
  else
    {
      partial_where = 0;
      if (partial_size > 0)
	{
	  as_warn (_("partial line at end of file ignored"));
	}

      /* Tell the listing we've finished the file.  */
      LISTING_EOF ();

      /* If we should pop to another file at EOF, do it.  */
      if (next_saved_file)
	{
	  *bufp = input_scrub_pop (next_saved_file);	/* Pop state */
	  /* partial_where is now correct to return, since we popped it.  */
	}
    }
  return (partial_where);
}
\f
/* The remaining part of this file deals with line numbers, error
   messages and so on.  Return TRUE if we opened any file.  */

int
seen_at_least_1_file (void)
{
  return (physical_input_file != NULL);
}

void
bump_line_counters (void)
{
  if (sb_index < 0)
    {
      ++physical_input_line;
      if (logical_input_line >= 0)
	++logical_input_line;
    }
}
\f
/* Tells us what the new logical line number and file are.
   If the line_number is -1, we don't change the current logical line
   number.  If it is -2, we decrement the logical line number (this is
   to support the .appfile pseudo-op inserted into the stream by
   do_scrub_chars).
   If the fname is NULL, we don't change the current logical file name.
   Returns nonzero if the filename actually changes.  */

int
new_logical_line (char *fname, /* DON'T destroy it!  We point to it!  */
		  int line_number)
{
  if (line_number >= 0)
    logical_input_line = line_number;
  else if (line_number == -2 && logical_input_line > 0)
    --logical_input_line;

  if (fname
      && (logical_input_file == NULL
	  || strcmp (logical_input_file, fname)))
    {
      logical_input_file = fname;
      return 1;
    }
  else
    return 0;
}
\f
/* Return the current file name and line number.
   namep should be char * const *, but there are compilers which screw
   up declarations like that, and it's easier to avoid it.  */

void
as_where (char **namep, unsigned int *linep)
{
  if (logical_input_file != NULL
      && (linep == NULL || logical_input_line >= 0))
    {
      *namep = logical_input_file;
      if (linep != NULL)
	*linep = logical_input_line;
    }
  else if (physical_input_file != NULL)
    {
      *namep = physical_input_file;
      if (linep != NULL)
	*linep = physical_input_line;
    }
  else
    {
      *namep = 0;
      if (linep != NULL)
	*linep = 0;
    }
}
Commit	Line	Data
252b5132	1	/* input_scrub.c - Break up input buffers into whole numbers of lines.
f7e42eb4	2	Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
2da5c037	3	2000, 2001, 2003
252b5132 RH	4	Free Software Foundation, Inc.
	5
	6	This file is part of GAS, the GNU Assembler.
	7
	8	GAS is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2, or (at your option)
	11	any later version.
	12
	13	GAS is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with GAS; see the file COPYING. If not, write to the Free
4b4da160 NC	20	Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
4b4da160 NC	21	02110-1301, USA. */
252b5132 RH	22
	23	#include <errno.h> /* Need this to make errno declaration right */
	24	#include "as.h"
	25	#include "input-file.h"
	26	#include "sb.h"
	27	#include "listing.h"
	28
	29	/*
	30	* O/S independent module to supply buffers of sanitised source code
	31	* to rest of assembler. We get sanitised input data of arbitrary length.
	32	* We break these buffers on line boundaries, recombine pieces that
	33	* were broken across buffers, and return a buffer of full lines to
	34	* the caller.
	35	* The last partial line begins the next buffer we build and return to caller.
47eebc20	36	* The buffer returned to caller is preceded by BEFORE_STRING and followed
252b5132 RH	37	* by AFTER_STRING, as sentinels. The last character before AFTER_STRING
	38	* is a newline.
	39	* Also looks after line numbers, for e.g. error messages.
	40	*/
	41
	42	/*
	43	* We don't care how filthy our buffers are, but our callers assume
	44	* that the following sanitation has already been done.
	45	*
	46	* No comments, reduce a comment to a space.
	47	* Reduce a tab to a space unless it is 1st char of line.
	48	* All multiple tabs and spaces collapsed into 1 char. Tab only
	49	* legal if 1st char of line.
	50	* # line file statements converted to .line x;.file y; statements.
	51	* Escaped newlines at end of line: remove them but add as many newlines
	52	* to end of statement as you removed in the middle, to synch line numbers.
	53	*/
	54	\f
	55	#define BEFORE_STRING ("\n")
e13b337a	56	#define AFTER_STRING ("\0") /* memcpy of 0 chars might choke. */
252b5132 RH	57	#define BEFORE_SIZE (1)
	58	#define AFTER_SIZE (1)
	59
e13b337a KH	60	static char buffer_start; /->1st char of full buffer area. */
	61	static char partial_where; /->after last full line in buffer. */
	62	static int partial_size; /* >=0. Number of chars in partial line in buffer. */
7152f1dc KH	63
	64	/* Because we need AFTER_STRING just after last full line, it clobbers
	65	1st part of partial line. So we preserve 1st part of partial line
	66	here. */
252b5132	67	static char save_source[AFTER_SIZE];
7152f1dc KH	68
	69	/* What is the largest size buffer that input_file_give_next_buffer()
	70	could return to us? */
	71	static unsigned int buffer_length;
252b5132 RH	72
	73	/* The index into an sb structure we are reading from. -1 if none. */
	74	static int sb_index = -1;
	75
	76	/* If we are reading from an sb structure, this is it. */
	77	static sb from_sb;
	78
9f10757c TW	79	/* Should we do a conditional check on from_sb? */
	80	static int from_sb_is_expansion = 1;
	81
252b5132 RH	82	/* The number of nested sb structures we have included. */
	83	int macro_nest;
	84
	85	/* We can have more than one source file open at once, though the info for all
	86	but the latest one are saved off in a struct input_save. These files remain
	87	open, so we are limited by the number of open files allowed by the
	88	underlying OS. We may also sequentially read more than one source file in an
e13b337a	89	assembly. */
252b5132 RH	90
	91	/* We must track the physical file and line number for error messages. We also
	92	track a "logical" file and line number corresponding to (C?) compiler
	93	source line numbers. Whenever we open a file we must fill in
e13b337a	94	physical_input_file. So if it is NULL we have not opened any files yet. */
252b5132 RH	95
	96	static char *physical_input_file;
	97	static char *logical_input_file;
	98
e13b337a KH	99	typedef unsigned int line_numberT; /* 1-origin line number in a source file. */
e13b337a KH	100	/* A line ends in '\n' or eof. */
252b5132 RH	101
	102	static line_numberT physical_input_line;
	103	static int logical_input_line;
	104
	105	/* Struct used to save the state of the input handler during include files */
ee515fb7	106	struct input_save {
e972090a NC	107	char * buffer_start;
	108	char * partial_where;
	109	int partial_size;
	110	char save_source[AFTER_SIZE];
	111	unsigned int buffer_length;
	112	char * physical_input_file;
	113	char * logical_input_file;
	114	line_numberT physical_input_line;
	115	int logical_input_line;
	116	int sb_index;
	117	sb from_sb;
	118	int from_sb_is_expansion; /* Should we do a conditional check? */
	119	struct input_save * next_saved_file; /* Chain of input_saves. */
	120	char * input_file_save; /* Saved state of input routines. */
	121	char * saved_position; /* Caller's saved position in buf. */
7152f1dc	122	};
252b5132	123
b1f1fa96 KH	124	static struct input_save input_scrub_push (char saved_position);
b1f1fa96 KH	125	static char input_scrub_pop (struct input_save arg);
252b5132 RH	126
252b5132 RH	127	/* Saved information about the file that .include'd this one. When we hit EOF,
e13b337a	128	we automatically pop to that file. */
252b5132 RH	129
	130	static struct input_save *next_saved_file;
	131
	132	/* Push the state of input reading and scrubbing so that we can #include.
	133	The return value is a 'void *' (fudged for old compilers) to a save
e13b337a	134	area, which can be restored by passing it to input_scrub_pop(). */
7152f1dc	135
252b5132	136	static struct input_save *
b1f1fa96	137	input_scrub_push (char *saved_position)
252b5132 RH	138	{
	139	register struct input_save *saved;
	140
	141	saved = (struct input_save ) xmalloc (sizeof saved);
	142
	143	saved->saved_position = saved_position;
	144	saved->buffer_start = buffer_start;
	145	saved->partial_where = partial_where;
	146	saved->partial_size = partial_size;
	147	saved->buffer_length = buffer_length;
	148	saved->physical_input_file = physical_input_file;
	149	saved->logical_input_file = logical_input_file;
	150	saved->physical_input_line = physical_input_line;
	151	saved->logical_input_line = logical_input_line;
	152	saved->sb_index = sb_index;
	153	saved->from_sb = from_sb;
9f10757c	154	saved->from_sb_is_expansion = from_sb_is_expansion;
252b5132 RH	155	memcpy (saved->save_source, save_source, sizeof (save_source));
	156	saved->next_saved_file = next_saved_file;
	157	saved->input_file_save = input_file_push ();
	158
	159	input_file_begin (); /* Reinitialize! */
	160	logical_input_line = -1;
	161	logical_input_file = (char *) NULL;
	162	buffer_length = input_file_buffer_size ();
	163	sb_index = -1;
	164
	165	buffer_start = xmalloc ((BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE));
	166	memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE);
	167
	168	return saved;
7152f1dc	169	}
252b5132 RH	170
252b5132 RH	171	static char *
b1f1fa96	172	input_scrub_pop (struct input_save *saved)
252b5132 RH	173	{
	174	char *saved_position;
	175
	176	input_scrub_end (); /* Finish off old buffer */
	177
	178	input_file_pop (saved->input_file_save);
	179	saved_position = saved->saved_position;
	180	buffer_start = saved->buffer_start;
	181	buffer_length = saved->buffer_length;
	182	physical_input_file = saved->physical_input_file;
	183	logical_input_file = saved->logical_input_file;
	184	physical_input_line = saved->physical_input_line;
	185	logical_input_line = saved->logical_input_line;
	186	sb_index = saved->sb_index;
	187	from_sb = saved->from_sb;
9f10757c	188	from_sb_is_expansion = saved->from_sb_is_expansion;
252b5132 RH	189	partial_where = saved->partial_where;
	190	partial_size = saved->partial_size;
	191	next_saved_file = saved->next_saved_file;
	192	memcpy (save_source, saved->save_source, sizeof (save_source));
	193
	194	free (saved);
	195	return saved_position;
	196	}
	197	\f
252b5132	198	void
b1f1fa96	199	input_scrub_begin (void)
252b5132 RH	200	{
252b5132 RH	201	know (strlen (BEFORE_STRING) == BEFORE_SIZE);
7152f1dc KH	202	know (strlen (AFTER_STRING) == AFTER_SIZE
7152f1dc KH	203	\|\| (AFTER_STRING[0] == '\0' && AFTER_SIZE == 1));
252b5132 RH	204
	205	input_file_begin ();
	206
	207	buffer_length = input_file_buffer_size ();
	208
	209	buffer_start = xmalloc ((BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE));
	210	memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE);
	211
e13b337a	212	/* Line number things. */
252b5132 RH	213	logical_input_line = -1;
252b5132 RH	214	logical_input_file = (char *) NULL;
e13b337a	215	physical_input_file = NULL; /* No file read yet. */
252b5132 RH	216	next_saved_file = NULL; /* At EOF, don't pop to any other file */
	217	do_scrub_begin (flag_m68k_mri);
	218	}
	219
	220	void
b1f1fa96	221	input_scrub_end (void)
252b5132 RH	222	{
	223	if (buffer_start)
	224	{
	225	free (buffer_start);
	226	buffer_start = 0;
	227	input_file_end ();
	228	}
	229	}
	230
7152f1dc KH	231	/* Start reading input from a new file.
7152f1dc KH	232	Return start of caller's part of buffer. */
252b5132	233
7152f1dc	234	char *
b1f1fa96	235	input_scrub_new_file (char *filename)
252b5132 RH	236	{
	237	input_file_open (filename, !flag_no_comments);
	238	physical_input_file = filename[0] ? filename : _("{standard input}");
	239	physical_input_line = 0;
	240
	241	partial_size = 0;
	242	return (buffer_start + BEFORE_SIZE);
	243	}
	244
252b5132 RH	245	/* Include a file from the current file. Save our state, cause it to
252b5132 RH	246	be restored on EOF, and begin handling a new file. Same result as
e13b337a	247	input_scrub_new_file. */
252b5132 RH	248
252b5132 RH	249	char *
b1f1fa96	250	input_scrub_include_file (char filename, char position)
252b5132 RH	251	{
	252	next_saved_file = input_scrub_push (position);
	253	return input_scrub_new_file (filename);
	254	}
	255
	256	/* Start getting input from an sb structure. This is used when
	257	expanding a macro. */
	258
	259	void
b1f1fa96	260	input_scrub_include_sb (sb from, char position, int is_expansion)
252b5132 RH	261	{
252b5132 RH	262	if (macro_nest > max_macro_nest)
dcb87e5c	263	as_fatal (_("macros nested too deeply"));
252b5132 RH	264	++macro_nest;
252b5132 RH	265
9f10757c TW	266	#ifdef md_macro_start
	267	if (is_expansion)
	268	{
	269	md_macro_start ();
	270	}
	271	#endif
	272
252b5132 RH	273	next_saved_file = input_scrub_push (position);
	274
	275	sb_new (&from_sb);
9f10757c	276	from_sb_is_expansion = is_expansion;
252b5132 RH	277	if (from->len >= 1 && from->ptr[0] != '\n')
	278	{
	279	/* Add the sentinel required by read.c. */
	280	sb_add_char (&from_sb, '\n');
	281	}
	282	sb_add_sb (&from_sb, from);
	283	sb_index = 1;
	284
	285	/* These variables are reset by input_scrub_push. Restore them
	286	since we are, after all, still at the same point in the file. */
	287	logical_input_line = next_saved_file->logical_input_line;
	288	logical_input_file = next_saved_file->logical_input_file;
	289	}
	290
	291	void
b1f1fa96	292	input_scrub_close (void)
252b5132 RH	293	{
	294	input_file_close ();
	295	}
	296
	297	char *
b1f1fa96	298	input_scrub_next_buffer (char **bufp)
252b5132	299	{
e13b337a	300	register char limit; /->just after last char of buffer. */
252b5132 RH	301
	302	if (sb_index >= 0)
	303	{
	304	if (sb_index >= from_sb.len)
	305	{
	306	sb_kill (&from_sb);
7152f1dc	307	if (from_sb_is_expansion
dcb87e5c	308	)
7152f1dc KH	309	{
7152f1dc KH	310	cond_finish_check (macro_nest);
9f10757c	311	#ifdef md_macro_end
7152f1dc KH	312	/* Allow the target to clean up per-macro expansion
	313	data. */
	314	md_macro_end ();
9f10757c	315	#endif
7152f1dc KH	316	}
7152f1dc KH	317	--macro_nest;
252b5132 RH	318	partial_where = NULL;
	319	if (next_saved_file != NULL)
	320	*bufp = input_scrub_pop (next_saved_file);
	321	return partial_where;
	322	}
	323
	324	partial_where = from_sb.ptr + from_sb.len;
	325	partial_size = 0;
	326	*bufp = from_sb.ptr + sb_index;
	327	sb_index = from_sb.len;
	328	return partial_where;
	329	}
	330
	331	*bufp = buffer_start + BEFORE_SIZE;
	332
	333	if (partial_size)
	334	{
	335	memcpy (buffer_start + BEFORE_SIZE, partial_where,
	336	(unsigned int) partial_size);
	337	memcpy (buffer_start + BEFORE_SIZE, save_source, AFTER_SIZE);
	338	}
	339	limit = input_file_give_next_buffer (buffer_start
	340	+ BEFORE_SIZE
	341	+ partial_size);
	342	if (limit)
	343	{
e13b337a	344	register char p; / Find last newline. */
252b5132 RH	345
	346	for (p = limit - 1; *p != '\n'; --p)
	347	;
	348	++p;
	349
	350	while (p <= buffer_start + BEFORE_SIZE)
	351	{
	352	int limoff;
	353
	354	limoff = limit - buffer_start;
	355	buffer_length += input_file_buffer_size ();
	356	buffer_start = xrealloc (buffer_start,
	357	(BEFORE_SIZE
	358	+ 2 * buffer_length
	359	+ AFTER_SIZE));
	360	*bufp = buffer_start + BEFORE_SIZE;
	361	limit = input_file_give_next_buffer (buffer_start + limoff);
	362
	363	if (limit == NULL)
	364	{
	365	as_warn (_("partial line at end of file ignored"));
	366	partial_where = NULL;
	367	if (next_saved_file)
	368	*bufp = input_scrub_pop (next_saved_file);
	369	return NULL;
	370	}
	371
	372	for (p = limit - 1; *p != '\n'; --p)
	373	;
	374	++p;
	375	}
	376
	377	partial_where = p;
	378	partial_size = limit - p;
	379	memcpy (save_source, partial_where, (int) AFTER_SIZE);
	380	memcpy (partial_where, AFTER_STRING, (int) AFTER_SIZE);
	381	}
	382	else
	383	{
	384	partial_where = 0;
	385	if (partial_size > 0)
	386	{
0e389e77	387	as_warn (_("partial line at end of file ignored"));
252b5132 RH	388	}
	389
	390	/* Tell the listing we've finished the file. */
	391	LISTING_EOF ();
	392
e13b337a	393	/* If we should pop to another file at EOF, do it. */
252b5132 RH	394	if (next_saved_file)
	395	{
	396	bufp = input_scrub_pop (next_saved_file); / Pop state */
e13b337a	397	/* partial_where is now correct to return, since we popped it. */
252b5132 RH	398	}
	399	}
	400	return (partial_where);
7152f1dc	401	}
252b5132	402	\f
7152f1dc KH	403	/* The remaining part of this file deals with line numbers, error
7152f1dc KH	404	messages and so on. Return TRUE if we opened any file. */
252b5132	405
252b5132	406	int
b1f1fa96	407	seen_at_least_1_file (void)
252b5132 RH	408	{
	409	return (physical_input_file != NULL);
	410	}
	411
	412	void
b1f1fa96	413	bump_line_counters (void)
252b5132 RH	414	{
	415	if (sb_index < 0)
	416	{
	417	++physical_input_line;
	418	if (logical_input_line >= 0)
	419	++logical_input_line;
	420	}
	421	}
	422	\f
7152f1dc KH	423	/* Tells us what the new logical line number and file are.
	424	If the line_number is -1, we don't change the current logical line
	425	number. If it is -2, we decrement the logical line number (this is
	426	to support the .appfile pseudo-op inserted into the stream by
	427	do_scrub_chars).
	428	If the fname is NULL, we don't change the current logical file name.
	429	Returns nonzero if the filename actually changes. */
	430
252b5132	431	int
b1f1fa96 KH	432	new_logical_line (char fname, / DON'T destroy it! We point to it! */
b1f1fa96 KH	433	int line_number)
252b5132 RH	434	{
	435	if (line_number >= 0)
	436	logical_input_line = line_number;
	437	else if (line_number == -2 && logical_input_line > 0)
	438	--logical_input_line;
	439
	440	if (fname
	441	&& (logical_input_file == NULL
	442	\|\| strcmp (logical_input_file, fname)))
	443	{
	444	logical_input_file = fname;
	445	return 1;
	446	}
	447	else
	448	return 0;
7152f1dc	449	}
252b5132	450	\f
7152f1dc KH	451	/* Return the current file name and line number.
	452	namep should be char * const *, but there are compilers which screw
	453	up declarations like that, and it's easier to avoid it. */
	454
e13b337a	455	void
b1f1fa96	456	as_where (char *namep, unsigned int linep)
252b5132 RH	457	{
	458	if (logical_input_file != NULL
	459	&& (linep == NULL \|\| logical_input_line >= 0))
	460	{
	461	*namep = logical_input_file;
	462	if (linep != NULL)
	463	*linep = logical_input_line;
	464	}
	465	else if (physical_input_file != NULL)
	466	{
	467	*namep = physical_input_file;
	468	if (linep != NULL)
	469	*linep = physical_input_line;
	470	}
	471	else
	472	{
	473	*namep = 0;
	474	if (linep != NULL)
	475	*linep = 0;
	476	}
7152f1dc	477	}