[deliverable/binutils-gdb.git] / gas / messages.c

/* messages.c - error reporter -
   Copyright (C) 1987, 1991, 1992 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 <stdio.h> /* define stderr */
#include <errno.h>

#include "as.h"

#ifndef __STDC__
#ifndef NO_STDARG
#define NO_STDARG
#endif
#endif

#ifndef NO_STDARG
#include <stdarg.h>
#else
#ifndef NO_VARARGS
#include <varargs.h>
#endif /* NO_VARARGS */
#endif /* NO_STDARG */

/*
 * Despite the rest of the comments in this file, (FIXME-SOON),
 * here is the current scheme for error messages etc:
 *
 * as_fatal() is used when gas is quite confused and
 * continuing the assembly is pointless.  In this case we
 * exit immediately with error status.
 *
 * as_bad() is used to mark errors that result in what we
 * presume to be a useless object file.  Say, we ignored
 * something that might have been vital.  If we see any of
 * these, assembly will continue to the end of the source,
 * no object file will be produced, and we will terminate
 * with error status.  The new option, -Z, tells us to
 * produce an object file anyway but we still exit with
 * error status.  The assumption here is that you don't want
 * this object file but we could be wrong.
 *
 * as_warn() is used when we have an error from which we
 * have a plausible error recovery.  eg, masking the top
 * bits of a constant that is longer than will fit in the
 * destination.  In this case we will continue to assemble
 * the source, although we may have made a bad assumption,
 * and we will produce an object file and return normal exit
 * status (ie, no error).  The new option -X tells us to
 * treat all as_warn() errors as as_bad() errors.  That is,
 * no object file will be produced and we will exit with
 * error status.  The idea here is that we don't kill an
 * entire make because of an error that we knew how to
 * correct.  On the other hand, sometimes you might want to
 * stop the make at these points.
 *
 * as_tsktsk() is used when we see a minor error for which
 * our error recovery action is almost certainly correct.
 * In this case, we print a message and then assembly
 * continues as though no error occurred.
 */

/*
  ERRORS
  
  JF: this is now bogus.  We now print more standard error messages
  that try to look like everyone else's.
  
  We print the error message 1st, beginning in column 1.
  All ancillary info starts in column 2 on lines after the
  key error text.
  We try to print a location in logical and physical file
  just after the main error text.
  Caller then prints any appendices after that, begining all
  lines with at least 1 space.
  
  Optionally, we may die.
  There is no need for a trailing '\n' in your error text format
  because we supply one.
  
  as_warn(fmt,args)  Like fprintf(stderr,fmt,args) but also call errwhere().
  
  as_fatal(fmt,args) Like as_warn() but exit with a fatal status.
  
  */

static int warning_count; /* Count of number of warnings issued */

int had_warnings() {
	return(warning_count);
} /* had_err() */

/* Nonzero if we've hit a 'bad error', and should not write an obj file,
   and exit with a nonzero error code */

static int error_count;

int had_errors() {
	return(error_count);
} /* had_errors() */


/*
 *			a s _ p e r r o r
 *
 * Like perror(3), but with more info.
 */
void as_perror(gripe, filename)
char *gripe;		/* Unpunctuated error theme. */
char *filename;
{
#ifndef HAVE_STRERROR
	extern char *strerror();
#endif /* HAVE_STRERROR */

	as_where();
	fprintf(stderr, gripe, filename);
	fprintf(stderr, ": %s\n", strerror(errno));
	errno = 0; /* After reporting, clear it. */
} /* as_perror() */

/*
 *			a s _ t s k t s k ()
 *
 * Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a warning, and locate warning
 * in input file(s).
 * Please only use this for when we have some recovery action.
 * Please explain in string (which may have '\n's) what recovery was done.
 */

#ifndef NO_STDARG
void as_tsktsk(const char *Format, ...)
{
	va_list args;
	
	as_where();
	va_start(args, Format);
	vfprintf(stderr, Format, args);
	va_end(args);
	(void) putc('\n', stderr);
} /* as_tsktsk() */
#else
#ifndef NO_VARARGS
void as_tsktsk(Format,va_alist)
char *Format;
va_dcl
{
	va_list args;
	
	as_where();
	va_start(args);
	vfprintf(stderr, Format, args);
	va_end(args);
	(void) putc('\n', stderr);
} /* as_tsktsk() */
#else
/*VARARGS1 */
as_tsktsk(Format,args)
char *Format;
{
	as_where();
	_doprnt (Format, &args, stderr);
	(void)putc ('\n', stderr);
	/* as_where(); */
} /* as_tsktsk */
#endif /* not NO_VARARGS */
#endif /* not NO_STDARG */

/*
 *			a s _ w a r n ()
 *
 * Send to stderr a string as a warning, and locate warning
 * in input file(s).
 * Please only use this for when we have some recovery action.
 * Please explain in string (which may have '\n's) what recovery was done.
 */

#ifndef NO_STDARG
void as_warn(const char *Format, ...)
{
	va_list args;
	char buffer[200];
	
	if(!flagseen['W']) {
		++warning_count;
		as_where();
		va_start(args, Format);
		fprintf(stderr,"Warning: ");
		vsprintf(buffer, Format, args);
		fputs (buffer, stderr);
#ifndef NO_LISTING
		listing_warning(buffer);
#endif
		va_end(args);
		(void) putc('\n', stderr);
	}
} /* as_warn() */
#else
#ifndef NO_VARARGS
void as_warn(Format,va_alist)
char *Format;
va_dcl
{
	va_list args;
	char buffer[200];
	
	if(!flagseen['W']) {
		++warning_count;
		as_where();
		va_start(args);
		fprintf(stderr,"Warning: ");
		vsprintf(buffer, Format, args);
		fputs (buffer, stderr);
#ifndef NO_LISTING
		listing_warning(buffer);
#endif		
		va_end(args);
		(void) putc('\n', stderr);
	}
} /* as_warn() */
#else
/*VARARGS1 */
as_warn(Format,args)
char *Format;
{
	/* -W supresses warning messages. */
	if (! flagseen ['W']) {
		++warning_count;
		as_where();
		_doprnt (Format, &args, stderr);
		(void)putc ('\n', stderr);
		/* as_where(); */
	}
} /* as_warn() */
#endif /* not NO_VARARGS */
#endif /* not NO_STDARG */

/*
 *			a s _ b a d ()
 *
 * Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a warning,
 * and locate warning in input file(s).
 * Please us when there is no recovery, but we want to continue processing
 * but not produce an object file.
 * Please explain in string (which may have '\n's) what recovery was done.
 */

#ifndef NO_STDARG
void as_bad(const char *Format, ...)
{
	va_list args;
	char buffer[200];
	
	++error_count;
	as_where();
	va_start(args, Format);
	fprintf(stderr,"Error: ");
	
	vsprintf(buffer, Format, args);
	fputs (buffer,stderr);
#ifndef NO_LISTING
	listing_error(buffer);
#endif
	va_end(args);
	(void) putc('\n', stderr);
} /* as_bad() */
#else
#ifndef NO_VARARGS
void as_bad(Format,va_alist)
char *Format;
va_dcl
{
	va_list args;
	char buffer[200];
	
	++error_count;
	as_where();
	va_start(args);
	vsprintf(buffer, Format, args);
	fputs (buffer, stderr);
#ifndef NO_LISTING
	listing_error(buffer);
#endif
	
	va_end(args);
	(void) putc('\n', stderr);
}				/* as_bad() */
#else
/*VARARGS1 */
as_bad(Format,args)
char *Format;
{
	++error_count;
	
	as_where();
	fprintf(stderr,"Error: ");
	_doprnt (Format, &args, stderr);
	(void)putc ('\n', stderr);
	/* as_where(); */
} /* as_bad() */
#endif /* not NO_VARARGS */
#endif /* not NO_STDARG */

/*
 *			a s _ f a t a l ()
 *
 * Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a fatal
 * message, and locate stdsource in input file(s).
 * Please only use this for when we DON'T have some recovery action.
 * It exit()s with a warning status.
 */

#ifndef NO_STDARG
void as_fatal(const char *Format, ...)
{
	va_list args;
	
	as_where();
	va_start(args, Format);
	fprintf (stderr, "FATAL:");
	vfprintf(stderr, Format, args);
	(void) putc('\n', stderr);
	va_end(args);
	exit(33);
} /* as_fatal() */
#else
#ifndef NO_VARARGS
void as_fatal(Format,va_alist)
char *Format;
va_dcl
{
	va_list args;
	
	as_where();
	va_start(args);
	fprintf (stderr, "FATAL:");
	vfprintf(stderr, Format, args);
	(void) putc('\n', stderr);
	va_end(args);
	exit(33);
} /* as_fatal() */
#else
/*VARARGS1 */
as_fatal(Format, args)
char *Format;
{
	as_where();
	fprintf(stderr,"FATAL:");
	_doprnt (Format, &args, stderr);
	(void)putc ('\n', stderr);
	/* as_where(); */
	exit(33);		/* What is a good exit status? */
} /* as_fatal() */
#endif /* not NO_VARARGS */
#endif /* not NO_STDARG */

/* end of messages.c */
Commit	Line	Data
fecd2382	1	/* messages.c - error reporter -
c1c28543	2	Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
a39116f1	3
fecd2382	4	This file is part of GAS, the GNU Assembler.
a39116f1	5
fecd2382 RP	6	GAS is free software; you can redistribute it and/or modify
fecd2382 RP	7	it under the terms of the GNU General Public License as published by
a39116f1	8	the Free Software Foundation; either version 2, or (at your option)
fecd2382	9	any later version.
a39116f1	10
fecd2382 RP	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.
a39116f1	15
fecd2382 RP	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. */
	19
fecd2382 RP	20	#include <stdio.h> /* define stderr */
	21	#include <errno.h>
	22
	23	#include "as.h"
	24
4959cb7b KR	25	#ifndef __STDC__
	26	#ifndef NO_STDARG
	27	#define NO_STDARG
	28	#endif
	29	#endif
	30
fecd2382 RP	31	#ifndef NO_STDARG
	32	#include <stdarg.h>
	33	#else
	34	#ifndef NO_VARARGS
	35	#include <varargs.h>
	36	#endif /* NO_VARARGS */
	37	#endif /* NO_STDARG */
	38
	39	/*
	40	* Despite the rest of the comments in this file, (FIXME-SOON),
	41	* here is the current scheme for error messages etc:
	42	*
	43	* as_fatal() is used when gas is quite confused and
	44	* continuing the assembly is pointless. In this case we
	45	* exit immediately with error status.
	46	*
	47	* as_bad() is used to mark errors that result in what we
	48	* presume to be a useless object file. Say, we ignored
	49	* something that might have been vital. If we see any of
	50	* these, assembly will continue to the end of the source,
	51	* no object file will be produced, and we will terminate
	52	* with error status. The new option, -Z, tells us to
	53	* produce an object file anyway but we still exit with
	54	* error status. The assumption here is that you don't want
	55	* this object file but we could be wrong.
	56	*
	57	* as_warn() is used when we have an error from which we
	58	* have a plausible error recovery. eg, masking the top
	59	* bits of a constant that is longer than will fit in the
	60	* destination. In this case we will continue to assemble
	61	* the source, although we may have made a bad assumption,
	62	* and we will produce an object file and return normal exit
	63	* status (ie, no error). The new option -X tells us to
	64	* treat all as_warn() errors as as_bad() errors. That is,
	65	* no object file will be produced and we will exit with
	66	* error status. The idea here is that we don't kill an
	67	* entire make because of an error that we knew how to
	68	* correct. On the other hand, sometimes you might want to
	69	* stop the make at these points.
	70	*
	71	* as_tsktsk() is used when we see a minor error for which
	72	* our error recovery action is almost certainly correct.
	73	* In this case, we print a message and then assembly
	74	* continues as though no error occurred.
	75	*/
	76
	77	/*
	78	ERRORS
a39116f1	79
fecd2382 RP	80	JF: this is now bogus. We now print more standard error messages
fecd2382 RP	81	that try to look like everyone else's.
a39116f1	82
fecd2382 RP	83	We print the error message 1st, beginning in column 1.
	84	All ancillary info starts in column 2 on lines after the
	85	key error text.
	86	We try to print a location in logical and physical file
	87	just after the main error text.
	88	Caller then prints any appendices after that, begining all
	89	lines with at least 1 space.
a39116f1	90
fecd2382 RP	91	Optionally, we may die.
	92	There is no need for a trailing '\n' in your error text format
	93	because we supply one.
a39116f1	94
fecd2382	95	as_warn(fmt,args) Like fprintf(stderr,fmt,args) but also call errwhere().
a39116f1	96
fecd2382	97	as_fatal(fmt,args) Like as_warn() but exit with a fatal status.
a39116f1 RP	98
a39116f1 RP	99	*/
fecd2382	100
09952cd9	101	static int warning_count; /* Count of number of warnings issued */
fecd2382 RP	102
	103	int had_warnings() {
	104	return(warning_count);
	105	} /* had_err() */
	106
	107	/* Nonzero if we've hit a 'bad error', and should not write an obj file,
	108	and exit with a nonzero error code */
	109
09952cd9	110	static int error_count;
fecd2382 RP	111
	112	int had_errors() {
	113	return(error_count);
	114	} /* had_errors() */
	115
	116
	117	/*
	118	* a s _ p e r r o r
	119	*
	120	* Like perror(3), but with more info.
	121	*/
	122	void as_perror(gripe, filename)
	123	char gripe; / Unpunctuated error theme. */
	124	char *filename;
	125	{
c1c28543 KR	126	#ifndef HAVE_STRERROR
	127	extern char *strerror();
	128	#endif /* HAVE_STRERROR */
	129
fecd2382	130	as_where();
c1c28543	131	fprintf(stderr, gripe, filename);
b1520b1f	132	fprintf(stderr, ": %s\n", strerror(errno));
fecd2382 RP	133	errno = 0; /* After reporting, clear it. */
	134	} /* as_perror() */
	135
	136	/*
	137	* a s _ t s k t s k ()
	138	*
	139	* Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a warning, and locate warning
	140	* in input file(s).
	141	* Please only use this for when we have some recovery action.
	142	* Please explain in string (which may have '\n's) what recovery was done.
	143	*/
	144
	145	#ifndef NO_STDARG
c1c28543	146	void as_tsktsk(const char *Format, ...)
fecd2382 RP	147	{
	148	va_list args;
	149
	150	as_where();
	151	va_start(args, Format);
	152	vfprintf(stderr, Format, args);
	153	va_end(args);
	154	(void) putc('\n', stderr);
	155	} /* as_tsktsk() */
	156	#else
	157	#ifndef NO_VARARGS
	158	void as_tsktsk(Format,va_alist)
	159	char *Format;
	160	va_dcl
	161	{
	162	va_list args;
	163
	164	as_where();
	165	va_start(args);
	166	vfprintf(stderr, Format, args);
	167	va_end(args);
	168	(void) putc('\n', stderr);
	169	} /* as_tsktsk() */
	170	#else
	171	/VARARGS1 /
	172	as_tsktsk(Format,args)
	173	char *Format;
	174	{
	175	as_where();
	176	_doprnt (Format, &args, stderr);
	177	(void)putc ('\n', stderr);
	178	/* as_where(); */
	179	} /* as_tsktsk */
	180	#endif /* not NO_VARARGS */
	181	#endif /* not NO_STDARG */
	182
fecd2382 RP	183	/*
	184	* a s _ w a r n ()
	185	*
09952cd9	186	* Send to stderr a string as a warning, and locate warning
fecd2382 RP	187	* in input file(s).
	188	* Please only use this for when we have some recovery action.
	189	* Please explain in string (which may have '\n's) what recovery was done.
	190	*/
	191
	192	#ifndef NO_STDARG
c1c28543	193	void as_warn(const char *Format, ...)
fecd2382 RP	194	{
fecd2382 RP	195	va_list args;
a39116f1	196	char buffer[200];
fecd2382 RP	197
	198	if(!flagseen['W']) {
	199	++warning_count;
	200	as_where();
	201	va_start(args, Format);
a39116f1 RP	202	fprintf(stderr,"Warning: ");
a39116f1 RP	203	vsprintf(buffer, Format, args);
4772861e	204	fputs (buffer, stderr);
a39116f1 RP	205	#ifndef NO_LISTING
	206	listing_warning(buffer);
	207	#endif
fecd2382 RP	208	va_end(args);
	209	(void) putc('\n', stderr);
	210	}
	211	} /* as_warn() */
	212	#else
	213	#ifndef NO_VARARGS
	214	void as_warn(Format,va_alist)
	215	char *Format;
	216	va_dcl
	217	{
	218	va_list args;
a39116f1	219	char buffer[200];
fecd2382 RP	220
	221	if(!flagseen['W']) {
	222	++warning_count;
	223	as_where();
	224	va_start(args);
a39116f1 RP	225	fprintf(stderr,"Warning: ");
a39116f1 RP	226	vsprintf(buffer, Format, args);
4772861e	227	fputs (buffer, stderr);
a39116f1 RP	228	#ifndef NO_LISTING
	229	listing_warning(buffer);
	230	#endif
fecd2382 RP	231	va_end(args);
	232	(void) putc('\n', stderr);
	233	}
	234	} /* as_warn() */
	235	#else
	236	/VARARGS1 /
	237	as_warn(Format,args)
	238	char *Format;
	239	{
	240	/* -W supresses warning messages. */
	241	if (! flagseen ['W']) {
	242	++warning_count;
	243	as_where();
	244	_doprnt (Format, &args, stderr);
	245	(void)putc ('\n', stderr);
	246	/* as_where(); */
	247	}
	248	} /* as_warn() */
	249	#endif /* not NO_VARARGS */
	250	#endif /* not NO_STDARG */
	251
fecd2382 RP	252	/*
	253	* a s _ b a d ()
	254	*
	255	* Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a warning,
	256	* and locate warning in input file(s).
	257	* Please us when there is no recovery, but we want to continue processing
	258	* but not produce an object file.
	259	* Please explain in string (which may have '\n's) what recovery was done.
	260	*/
	261
	262	#ifndef NO_STDARG
c1c28543	263	void as_bad(const char *Format, ...)
fecd2382 RP	264	{
fecd2382 RP	265	va_list args;
a39116f1 RP	266	char buffer[200];
a39116f1 RP	267
fecd2382 RP	268	++error_count;
	269	as_where();
	270	va_start(args, Format);
a39116f1 RP	271	fprintf(stderr,"Error: ");
	272
	273	vsprintf(buffer, Format, args);
4772861e	274	fputs (buffer,stderr);
a39116f1 RP	275	#ifndef NO_LISTING
	276	listing_error(buffer);
	277	#endif
fecd2382 RP	278	va_end(args);
	279	(void) putc('\n', stderr);
	280	} /* as_bad() */
	281	#else
	282	#ifndef NO_VARARGS
	283	void as_bad(Format,va_alist)
	284	char *Format;
	285	va_dcl
	286	{
	287	va_list args;
a39116f1 RP	288	char buffer[200];
a39116f1 RP	289
fecd2382 RP	290	++error_count;
	291	as_where();
	292	va_start(args);
a39116f1	293	vsprintf(buffer, Format, args);
4772861e	294	fputs (buffer, stderr);
a39116f1 RP	295	#ifndef NO_LISTING
	296	listing_error(buffer);
	297	#endif
	298
fecd2382 RP	299	va_end(args);
fecd2382 RP	300	(void) putc('\n', stderr);
a39116f1	301	} /* as_bad() */
fecd2382 RP	302	#else
	303	/VARARGS1 /
	304	as_bad(Format,args)
	305	char *Format;
	306	{
	307	++error_count;
a39116f1	308
fecd2382	309	as_where();
a39116f1	310	fprintf(stderr,"Error: ");
fecd2382 RP	311	_doprnt (Format, &args, stderr);
	312	(void)putc ('\n', stderr);
	313	/* as_where(); */
	314	} /* as_bad() */
	315	#endif /* not NO_VARARGS */
	316	#endif /* not NO_STDARG */
	317
fecd2382 RP	318	/*
	319	* a s _ f a t a l ()
	320	*
	321	* Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a fatal
	322	* message, and locate stdsource in input file(s).
	323	* Please only use this for when we DON'T have some recovery action.
	324	* It exit()s with a warning status.
	325	*/
	326
	327	#ifndef NO_STDARG
c1c28543	328	void as_fatal(const char *Format, ...)
fecd2382 RP	329	{
fecd2382 RP	330	va_list args;
a39116f1	331
fecd2382 RP	332	as_where();
	333	va_start(args, Format);
	334	fprintf (stderr, "FATAL:");
	335	vfprintf(stderr, Format, args);
	336	(void) putc('\n', stderr);
	337	va_end(args);
a39116f1	338	exit(33);
fecd2382 RP	339	} /* as_fatal() */
	340	#else
	341	#ifndef NO_VARARGS
	342	void as_fatal(Format,va_alist)
	343	char *Format;
	344	va_dcl
	345	{
	346	va_list args;
a39116f1	347
fecd2382 RP	348	as_where();
	349	va_start(args);
	350	fprintf (stderr, "FATAL:");
	351	vfprintf(stderr, Format, args);
	352	(void) putc('\n', stderr);
	353	va_end(args);
a39116f1	354	exit(33);
fecd2382 RP	355	} /* as_fatal() */
	356	#else
	357	/VARARGS1 /
	358	as_fatal(Format, args)
	359	char *Format;
	360	{
	361	as_where();
	362	fprintf(stderr,"FATAL:");
	363	_doprnt (Format, &args, stderr);
	364	(void)putc ('\n', stderr);
	365	/* as_where(); */
a39116f1	366	exit(33); /* What is a good exit status? */
fecd2382 RP	367	} /* as_fatal() */
	368	#endif /* not NO_VARARGS */
	369	#endif /* not NO_STDARG */
	370
8b228fe9	371	/* end of messages.c */