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

/* input_scrub.c - Break up input buffers into whole numbers of lines.
   Copyright (C) 1987, 1990, 1991 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, 675 Mass Ave, Cambridge, MA 02139, USA. */

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

/*
 * O/S independent module to supply buffers of sanitised source code
 * to rest of assembler. We get sanitized 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 preceeded 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")	/* bcopy 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. */
static char save_source [AFTER_SIZE];
/* 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 int buffer_length;	/* What is the largest size buffer that */
/* input_file_give_next_buffer() could */
/* return to us? */

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

static char *next_saved_file;

/* 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. */

char *physical_input_file;
char *logical_input_file;

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

line_numberT physical_input_line;
line_numberT 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];
	int buffer_length;
	char *physical_input_file;
	char *logical_input_file;
	line_numberT	physical_input_line;
	line_numberT	logical_input_line;
	char *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 */
};

#ifdef __STDC__
static void as_1_char(unsigned int c, FILE *stream);
#else /* __STDC__ */
static void as_1_char();
#endif /* __STDC__ */

/* 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(). */
char *input_scrub_push(saved_position)
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;
	bcopy(saved->save_source, save_source, sizeof(save_source));
	saved->next_saved_file		= next_saved_file;
	saved->input_file_save		= input_file_push();
	
	input_scrub_begin();		/* Reinitialize! */
	
	return((char *) saved);
} /* input_scrub_push() */

char *
    input_scrub_pop (arg)
char *arg;
{
	register struct input_save *saved;
	char *saved_position;
	
	input_scrub_end ();	/* Finish off old buffer */
	
	saved = (struct input_save *)arg;
	
	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;
	partial_where		= saved->partial_where;
	partial_size		= saved->partial_size;
	next_saved_file		= saved->next_saved_file;
	bcopy (save_source,	  saved->save_source, sizeof (save_source));
	
	free(arg);
	return saved_position;
}

\f
void
    input_scrub_begin ()
{
	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((long)(BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE));
	bcopy (BEFORE_STRING, buffer_start, (int)BEFORE_SIZE);
	
	/* Line number things. */
	logical_input_line = 0;
	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();
}

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

/* Start reading input from a new file. */

char *				/* Return start of caller's part of buffer. */
    input_scrub_new_file (filename)
char *	filename;
{
	input_file_open (filename, !flagseen['f']);
	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 (filename, position)
char *filename;
char *position;
{
	next_saved_file = input_scrub_push(position);
	return input_scrub_new_file (filename);
}

void
    input_scrub_close ()
{
	input_file_close ();
}
char *
    input_scrub_next_buffer (bufp)
char **bufp;
{
	register char *	limit;	/*->just after last char of buffer. */
	
	*bufp = buffer_start + BEFORE_SIZE;
	
#ifdef DONTDEF
	if(preprocess) {
		if(save_buffer) {
			*bufp = save_buffer;
			save_buffer = 0;
		}
		limit = input_file_give_next_buffer(buffer_start+BEFORE_SIZE);
		if (!limit) {
			partial_where = 0;
			if(partial_size)
			    as_warn("Partial line at end of file ignored");
			return partial_where;
		}
		
		if(partial_size)
		    bcopy(save_source, partial_where,(int)AFTER_SIZE);
		do_scrub(partial_where,partial_size,buffer_start+BEFORE_SIZE,limit-(buffer_start+BEFORE_SIZE),&out_string,&out_length);
		limit=out_string + out_length;
		for(p=limit;*--p!='\n';)
		    ;
		p++;
		if(p<=buffer_start+BEFORE_SIZE)
		    as_fatal("Source line too long.  Please change file '%s' and re-make the assembler.", __FILE__);
		
		partial_where = p;
		partial_size = limit-p;
		bcopy(partial_where, save_source,(int)AFTER_SIZE);
		bcopy(AFTER_STRING, partial_where, (int)AFTER_SIZE);
		
		save_buffer = *bufp;
		*bufp = out_string;
		
		return partial_where;
	}
	
	/* We're not preprocessing.  Do the right thing */
#endif
	if (partial_size)
	    {
		    bcopy (partial_where, buffer_start + BEFORE_SIZE, (int)partial_size);
		    bcopy (save_source, buffer_start + BEFORE_SIZE, (int)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;   * -- p != '\n';)
			{
			}
		    ++ p;
		    if (p <= buffer_start + BEFORE_SIZE)
			{
				as_fatal("Source line too long. Please change file %s then rebuild assembler.", __FILE__);
			}
		    partial_where = p;
		    partial_size = limit - p;
		    bcopy (partial_where, save_source,  (int)AFTER_SIZE);
		    bcopy (AFTER_STRING, partial_where, (int)AFTER_SIZE);
	    }
	else
	    {
		    partial_where = 0;
		    if (partial_size > 0)
			{
				as_warn("Partial line at end of file ignored");
			}
		    /* 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.
 */


int
    seen_at_least_1_file ()		/* TRUE if we opened any file. */
{
	return (physical_input_file != NULL);
}

void
    bump_line_counters ()
{
	++ physical_input_line;
	/*  ++ logical_input_line; FIXME-now remove this. */
}
\f
/*
 *			new_logical_line()
 *
 * Tells us what the new logical line number and file are.
 * If the line_number is <0, we don't change the current logical line number.
 * If the fname is NULL, we don't change the current logical file name.
 */
void new_logical_line(fname, line_number)
char *fname;		/* DON'T destroy it! We point to it! */
int line_number;
{
	if (fname) {
		logical_input_file = fname;
	} /* if we have a file name */
	
	if (line_number >= 0) {
		logical_input_line = line_number;
	} /* if we have a line number */
} /* new_logical_line() */
\f
/*
 *			a s _ w h e r e ()
 *
 * Write a line to stderr locating where we are in reading
 * input source files.
 * As a sop to the debugger of AS, pretty-print the offending line.
 */
void as_where() {
	char *p;
	line_numberT line;
	
	if (logical_input_file && (logical_input_line > 0)) {
		p = logical_input_file;
		line = logical_input_line;
	} else {
		p = physical_input_file;
		line = physical_input_line;
	} /* line number should match file name */
	
	fprintf(stderr, "%s:%u: ", p, line);
	
#ifdef DONTDEF
	if (physical_input_file) {
		if (input_file_is_open()) { /* we can still read lines from source */
			fprintf (stderr," @ physical line %ld., file \"%s\"",
				 (long) physical_input_line, physical_input_file);
			fprintf (stderr," @ logical line %ld., file \"%s\"\n",
				 (long) logical_input_line, logical_input_file);
			(void)putc(' ', stderr);
			as_howmuch (stderr);
			(void)putc('\n', stderr);
		} else {
			fprintf(stderr, " After reading source.\n");
		} /* input file is still open */
	} else {
		fprintf(stderr, " Before reading source.\n");
	} /* we tried to read SOME source */
#endif /* DONTDEF */
	
	return;
} /* as_where() */


\f
/*
 *			a s _ h o w m u c h ()
 *
 * Output to given stream how much of line we have scanned so far.
 * Assumes we have scanned up to and including input_line_pointer.
 * No free '\n' at end of line.
 */
void
    as_howmuch (stream)
FILE * stream;		/* Opened for write please. */
{
	register char *	p;	/* Scan input line. */
	/* register char c; JF unused */
	
	for (p = input_line_pointer - 1;   * p != '\n';   --p)
	    {
	    }
	++ p;				/* p->1st char of line. */
	for (;  p <= input_line_pointer;  p++)
	    {
		    /* Assume ASCII. EBCDIC & other micro-computer char sets ignored. */
		    /* c = *p & 0xFF; JF unused */
		    as_1_char(*p, stream);
	    }
}

static void as_1_char (c,stream)
unsigned int c;
FILE *stream;
{
	if (c > 127)
	    {
		    (void)putc('%', stream);
		    c -= 128;
	    }
	if (c < 32)
	    {
		    (void)putc('^', stream);
		    c += '@';
	    }
	(void)putc(c, stream);
}

/*
 * Local Variables:
 * comment-column: 0
 * fill-column: 131
 * End:
 */

/* end of input_scrub.c */
Commit	Line	Data
fecd2382 RP	1	/* input_scrub.c - Break up input buffers into whole numbers of lines.
fecd2382 RP	2	Copyright (C) 1987, 1990, 1991 Free Software Foundation, Inc.
a39116f1 RP	3
	4	This file is part of GAS, the GNU Assembler.
	5
	6	GAS is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	GAS is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GAS; see the file COPYING. If not, write to
	18	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
fecd2382 RP	19
	20	#include <errno.h> /* Need this to make errno declaration right */
	21	#include "as.h"
	22	#include "input-file.h"
	23
	24	/*
	25	* O/S independent module to supply buffers of sanitised source code
	26	* to rest of assembler. We get sanitized input data of arbitrary length.
	27	* We break these buffers on line boundaries, recombine pieces that
	28	* were broken across buffers, and return a buffer of full lines to
	29	* the caller.
	30	* The last partial line begins the next buffer we build and return to caller.
	31	* The buffer returned to caller is preceeded by BEFORE_STRING and followed
	32	* by AFTER_STRING, as sentinels. The last character before AFTER_STRING
	33	* is a newline.
	34	* Also looks after line numbers, for e.g. error messages.
	35	*/
	36
	37	/*
	38	* We don't care how filthy our buffers are, but our callers assume
	39	* that the following sanitation has already been done.
	40	*
	41	* No comments, reduce a comment to a space.
	42	* Reduce a tab to a space unless it is 1st char of line.
	43	* All multiple tabs and spaces collapsed into 1 char. Tab only
	44	* legal if 1st char of line.
	45	* # line file statements converted to .line x;.file y; statements.
	46	* Escaped newlines at end of line: remove them but add as many newlines
	47	* to end of statement as you removed in the middle, to synch line numbers.
	48	*/
	49	\f
	50	#define BEFORE_STRING ("\n")
	51	#define AFTER_STRING ("\0") /* bcopy of 0 chars might choke. */
	52	#define BEFORE_SIZE (1)
	53	#define AFTER_SIZE (1)
	54
	55	static char * buffer_start; /->1st char of full buffer area. /
	56	static char * partial_where; /->after last full line in buffer. /
	57	static int partial_size; /* >=0. Number of chars in partial line in buffer. */
	58	static char save_source [AFTER_SIZE];
a39116f1 RP	59	/* Because we need AFTER_STRING just after last */
	60	/* full line, it clobbers 1st part of partial */
	61	/* line. So we preserve 1st part of partial */
	62	/* line here. */
fecd2382	63	static int buffer_length; /* What is the largest size buffer that */
a39116f1 RP	64	/* input_file_give_next_buffer() could */
a39116f1 RP	65	/* return to us? */
fecd2382	66
a39116f1 RP	67	/* Saved information about the file that .include'd this one. When we hit EOF,
a39116f1 RP	68	we automatically pop to that file. */
fecd2382 RP	69
	70	static char *next_saved_file;
	71
a39116f1 RP	72	/* We can have more than one source file open at once, though the info for all
	73	but the latest one are saved off in a struct input_save. These files remain
	74	open, so we are limited by the number of open files allowed by the
	75	underlying OS. We may also sequentially read more than one source file in an
	76	assembly. */
fecd2382	77
a39116f1 RP	78	/* We must track the physical file and line number for error messages. We also
	79	track a "logical" file and line number corresponding to (C?) compiler
	80	source line numbers. Whenever we open a file we must fill in
	81	physical_input_file. So if it is NULL we have not opened any files yet. */
fecd2382	82
a39116f1 RP	83	char *physical_input_file;
a39116f1 RP	84	char *logical_input_file;
fecd2382	85
a39116f1 RP	86	typedef unsigned int line_numberT; /* 1-origin line number in a source file. */
a39116f1 RP	87	/* A line ends in '\n' or eof. */
fecd2382	88
a39116f1 RP	89	line_numberT physical_input_line;
a39116f1 RP	90	line_numberT logical_input_line;
fecd2382 RP	91
	92	/* Struct used to save the state of the input handler during include files */
	93	struct input_save {
	94	char *buffer_start;
	95	char *partial_where;
	96	int partial_size;
	97	char save_source [AFTER_SIZE];
	98	int buffer_length;
	99	char *physical_input_file;
	100	char *logical_input_file;
	101	line_numberT physical_input_line;
	102	line_numberT logical_input_line;
	103	char next_saved_file; / Chain of input_saves */
	104	char input_file_save; / Saved state of input routines */
	105	char saved_position; / Caller's saved position in buf */
	106	};
	107
	108	#ifdef __STDC__
	109	static void as_1_char(unsigned int c, FILE *stream);
	110	#else /* __STDC__ */
	111	static void as_1_char();
	112	#endif /* __STDC__ */
	113
	114	/* Push the state of input reading and scrubbing so that we can #include.
	115	The return value is a 'void *' (fudged for old compilers) to a save
	116	area, which can be restored by passing it to input_scrub_pop(). */
a39116f1 RP	117	char *input_scrub_push(saved_position)
a39116f1 RP	118	char *saved_position;
fecd2382 RP	119	{
fecd2382 RP	120	register struct input_save *saved;
a39116f1	121
fecd2382	122	saved = (struct input_save ) xmalloc(sizeof saved);
a39116f1	123
fecd2382 RP	124	saved->saved_position = saved_position;
	125	saved->buffer_start = buffer_start;
	126	saved->partial_where = partial_where;
	127	saved->partial_size = partial_size;
	128	saved->buffer_length = buffer_length;
	129	saved->physical_input_file = physical_input_file;
	130	saved->logical_input_file = logical_input_file;
	131	saved->physical_input_line = physical_input_line;
	132	saved->logical_input_line = logical_input_line;
a39116f1	133	bcopy(saved->save_source, save_source, sizeof(save_source));
fecd2382	134	saved->next_saved_file = next_saved_file;
a39116f1 RP	135	saved->input_file_save = input_file_push();
	136
	137	input_scrub_begin(); /* Reinitialize! */
	138
	139	return((char *) saved);
	140	} /* input_scrub_push() */
fecd2382 RP	141
fecd2382 RP	142	char *
a39116f1 RP	143	input_scrub_pop (arg)
a39116f1 RP	144	char *arg;
fecd2382 RP	145	{
	146	register struct input_save *saved;
	147	char *saved_position;
a39116f1	148
fecd2382	149	input_scrub_end (); /* Finish off old buffer */
a39116f1	150
fecd2382	151	saved = (struct input_save *)arg;
a39116f1	152
fecd2382 RP	153	input_file_pop (saved->input_file_save);
	154	saved_position = saved->saved_position;
	155	buffer_start = saved->buffer_start;
	156	buffer_length = saved->buffer_length;
	157	physical_input_file = saved->physical_input_file;
	158	logical_input_file = saved->logical_input_file;
	159	physical_input_line = saved->physical_input_line;
	160	logical_input_line = saved->logical_input_line;
	161	partial_where = saved->partial_where;
	162	partial_size = saved->partial_size;
	163	next_saved_file = saved->next_saved_file;
	164	bcopy (save_source, saved->save_source, sizeof (save_source));
a39116f1	165
fecd2382 RP	166	free(arg);
	167	return saved_position;
	168	}
	169
	170	\f
	171	void
a39116f1	172	input_scrub_begin ()
fecd2382	173	{
a39116f1 RP	174	know(strlen(BEFORE_STRING) == BEFORE_SIZE);
	175	know(strlen(AFTER_STRING) == AFTER_SIZE \|\| (AFTER_STRING[0] == '\0' && AFTER_SIZE == 1));
	176
	177	input_file_begin ();
	178
	179	buffer_length = input_file_buffer_size ();
	180
	181	buffer_start = xmalloc((long)(BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE));
	182	bcopy (BEFORE_STRING, buffer_start, (int)BEFORE_SIZE);
	183
	184	/* Line number things. */
	185	logical_input_line = 0;
	186	logical_input_file = (char *)NULL;
	187	physical_input_file = NULL; /* No file read yet. */
	188	next_saved_file = NULL; /* At EOF, don't pop to any other file */
	189	do_scrub_begin();
fecd2382 RP	190	}
	191
	192	void
a39116f1	193	input_scrub_end ()
fecd2382	194	{
a39116f1 RP	195	if (buffer_start)
	196	{
	197	free (buffer_start);
	198	buffer_start = 0;
	199	input_file_end ();
	200	}
fecd2382 RP	201	}
	202
	203	/* Start reading input from a new file. */
	204
	205	char * /* Return start of caller's part of buffer. */
a39116f1 RP	206	input_scrub_new_file (filename)
a39116f1 RP	207	char * filename;
fecd2382	208	{
a39116f1 RP	209	input_file_open (filename, !flagseen['f']);
	210	physical_input_file = filename[0] ? filename : "{standard input}";
	211	physical_input_line = 0;
	212
	213	partial_size = 0;
	214	return (buffer_start + BEFORE_SIZE);
fecd2382 RP	215	}
	216
	217
	218	/* Include a file from the current file. Save our state, cause it to
	219	be restored on EOF, and begin handling a new file. Same result as
	220	input_scrub_new_file. */
	221
	222	char *
a39116f1 RP	223	input_scrub_include_file (filename, position)
	224	char *filename;
	225	char *position;
fecd2382	226	{
a39116f1 RP	227	next_saved_file = input_scrub_push(position);
a39116f1 RP	228	return input_scrub_new_file (filename);
fecd2382 RP	229	}
	230
	231	void
a39116f1	232	input_scrub_close ()
fecd2382	233	{
a39116f1	234	input_file_close ();
fecd2382 RP	235	}
fecd2382 RP	236	char *
a39116f1	237	input_scrub_next_buffer (bufp)
fecd2382 RP	238	char **bufp;
fecd2382 RP	239	{
a39116f1 RP	240	register char * limit; /->just after last char of buffer. /
	241
	242	*bufp = buffer_start + BEFORE_SIZE;
	243
fecd2382	244	#ifdef DONTDEF
a39116f1 RP	245	if(preprocess) {
	246	if(save_buffer) {
	247	*bufp = save_buffer;
	248	save_buffer = 0;
	249	}
	250	limit = input_file_give_next_buffer(buffer_start+BEFORE_SIZE);
	251	if (!limit) {
	252	partial_where = 0;
	253	if(partial_size)
	254	as_warn("Partial line at end of file ignored");
	255	return partial_where;
	256	}
	257
	258	if(partial_size)
	259	bcopy(save_source, partial_where,(int)AFTER_SIZE);
	260	do_scrub(partial_where,partial_size,buffer_start+BEFORE_SIZE,limit-(buffer_start+BEFORE_SIZE),&out_string,&out_length);
	261	limit=out_string + out_length;
	262	for(p=limit;*--p!='\n';)
	263	;
	264	p++;
	265	if(p<=buffer_start+BEFORE_SIZE)
	266	as_fatal("Source line too long. Please change file '%s' and re-make the assembler.", __FILE__);
	267
	268	partial_where = p;
	269	partial_size = limit-p;
	270	bcopy(partial_where, save_source,(int)AFTER_SIZE);
	271	bcopy(AFTER_STRING, partial_where, (int)AFTER_SIZE);
	272
	273	save_buffer = *bufp;
	274	*bufp = out_string;
	275
	276	return partial_where;
fecd2382	277	}
a39116f1 RP	278
	279	/* We're not preprocessing. Do the right thing */
	280	#endif
	281	if (partial_size)
	282	{
	283	bcopy (partial_where, buffer_start + BEFORE_SIZE, (int)partial_size);
	284	bcopy (save_source, buffer_start + BEFORE_SIZE, (int)AFTER_SIZE);
	285	}
	286	limit = input_file_give_next_buffer (buffer_start + BEFORE_SIZE + partial_size);
	287	if (limit)
	288	{
	289	register char * p; /* Find last newline. */
	290
	291	for (p = limit; * -- p != '\n';)
	292	{
	293	}
	294	++ p;
	295	if (p <= buffer_start + BEFORE_SIZE)
	296	{
	297	as_fatal("Source line too long. Please change file %s then rebuild assembler.", __FILE__);
	298	}
	299	partial_where = p;
	300	partial_size = limit - p;
	301	bcopy (partial_where, save_source, (int)AFTER_SIZE);
	302	bcopy (AFTER_STRING, partial_where, (int)AFTER_SIZE);
	303	}
	304	else
	305	{
	306	partial_where = 0;
	307	if (partial_size > 0)
	308	{
	309	as_warn("Partial line at end of file ignored");
	310	}
	311	/* If we should pop to another file at EOF, do it. */
	312	if (next_saved_file)
	313	{
	314	bufp = input_scrub_pop (next_saved_file); / Pop state */
	315	/* partial_where is now correct to return, since we popped it. */
	316	}
	317	}
	318	return (partial_where);
fecd2382 RP	319	}
	320	\f
	321	/*
	322	* The remaining part of this file deals with line numbers, error
	323	* messages and so on.
	324	*/
	325
	326
	327	int
a39116f1	328	seen_at_least_1_file () /* TRUE if we opened any file. */
fecd2382	329	{
a39116f1	330	return (physical_input_file != NULL);
fecd2382 RP	331	}
	332
	333	void
a39116f1	334	bump_line_counters ()
fecd2382	335	{
a39116f1 RP	336	++ physical_input_line;
a39116f1 RP	337	/* ++ logical_input_line; FIXME-now remove this. */
fecd2382 RP	338	}
	339	\f
	340	/*
	341	* new_logical_line()
	342	*
	343	* Tells us what the new logical line number and file are.
	344	* If the line_number is <0, we don't change the current logical line number.
	345	* If the fname is NULL, we don't change the current logical file name.
	346	*/
	347	void new_logical_line(fname, line_number)
a39116f1 RP	348	char fname; / DON'T destroy it! We point to it! */
a39116f1 RP	349	int line_number;
fecd2382 RP	350	{
	351	if (fname) {
	352	logical_input_file = fname;
	353	} /* if we have a file name */
	354
	355	if (line_number >= 0) {
	356	logical_input_line = line_number;
	357	} /* if we have a line number */
	358	} /* new_logical_line() */
	359	\f
	360	/*
	361	* a s _ w h e r e ()
	362	*
	363	* Write a line to stderr locating where we are in reading
	364	* input source files.
	365	* As a sop to the debugger of AS, pretty-print the offending line.
	366	*/
a39116f1 RP	367	void as_where() {
	368	char *p;
	369	line_numberT line;
	370
	371	if (logical_input_file && (logical_input_line > 0)) {
	372	p = logical_input_file;
	373	line = logical_input_line;
	374	} else {
	375	p = physical_input_file;
	376	line = physical_input_line;
	377	} /* line number should match file name */
	378
	379	fprintf(stderr, "%s:%u: ", p, line);
	380
fecd2382	381	#ifdef DONTDEF
a39116f1 RP	382	if (physical_input_file) {
	383	if (input_file_is_open()) { /* we can still read lines from source */
	384	fprintf (stderr," @ physical line %ld., file \"%s\"",
	385	(long) physical_input_line, physical_input_file);
	386	fprintf (stderr," @ logical line %ld., file \"%s\"\n",
	387	(long) logical_input_line, logical_input_file);
	388	(void)putc(' ', stderr);
	389	as_howmuch (stderr);
	390	(void)putc('\n', stderr);
	391	} else {
	392	fprintf(stderr, " After reading source.\n");
	393	} /* input file is still open */
	394	} else {
	395	fprintf(stderr, " Before reading source.\n");
	396	} /* we tried to read SOME source */
	397	#endif /* DONTDEF */
	398
	399	return;
	400	} /* as_where() */
fecd2382 RP	401
	402
	403
	404	\f
	405	/*
	406	* a s _ h o w m u c h ()
	407	*
	408	* Output to given stream how much of line we have scanned so far.
	409	* Assumes we have scanned up to and including input_line_pointer.
	410	* No free '\n' at end of line.
	411	*/
	412	void
a39116f1 RP	413	as_howmuch (stream)
a39116f1 RP	414	FILE * stream; /* Opened for write please. */
fecd2382	415	{
a39116f1 RP	416	register char * p; /* Scan input line. */
	417	/* register char c; JF unused */
	418
	419	for (p = input_line_pointer - 1; * p != '\n'; --p)
	420	{
	421	}
	422	++ p; /* p->1st char of line. */
	423	for (; p <= input_line_pointer; p++)
	424	{
	425	/* Assume ASCII. EBCDIC & other micro-computer char sets ignored. */
	426	/* c = p & 0xFF; JF unused /
	427	as_1_char(*p, stream);
	428	}
fecd2382 RP	429	}
	430
	431	static void as_1_char (c,stream)
	432	unsigned int c;
	433	FILE *stream;
	434	{
a39116f1 RP	435	if (c > 127)
	436	{
	437	(void)putc('%', stream);
	438	c -= 128;
	439	}
	440	if (c < 32)
	441	{
	442	(void)putc('^', stream);
	443	c += '@';
	444	}
	445	(void)putc(c, stream);
fecd2382 RP	446	}
	447
	448	/*
	449	* Local Variables:
	450	* comment-column: 0
	451	* fill-column: 131
	452	* End:
	453	*/
	454
8b228fe9	455	/* end of input_scrub.c */