WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/utility/error.c

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
 #include "config.h"
 #if FS_STDARG
 #include <stdarg.h>
 #else
 #include <varargs.h>
 #include "save.h"
 #include "statement.h"
 #include "ustring.h"
 #include "xalloc.h"
 /*
     PROGRAM NAME
     These variables give the program name and version number.
 */
-CONST char *progname = NULL ;
+CONST char *progname = NULL;
-CONST char *progvers = NULL ;
+CONST char *progvers = NULL;
 /*
     SET PROGRAM NAME
     This routine sets the program name to the basename of prog and the
     program version to vers.
 */
-void set_progname
+void
-    PROTO_N ( ( prog, vers ) )
-    PROTO_T ( CONST char *prog X CONST char *vers )
+set_progname(CONST char *prog, CONST char *vers)
 {
-    error_file = stderr ;
+	error_file = stderr;
-    if ( prog ) {
+	if (prog) {
-	char *s = strrchr ( prog, '/' ) ;
+		char *s = strrchr(prog, '/');
-	if ( s ) prog = s + 1 ;
+		if (s)prog = s + 1;
-	s = strrchr ( prog, file_sep ) ;
+		s = strrchr(prog, file_sep);
-	if ( s ) prog = s + 1 ;
+		if (s)prog = s + 1;
-	progname = prog ;
+		progname = prog;
-    } else {
+	} else {
-	progname = "unknown" ;
+		progname = "unknown";
-    }
+	}
-    progvers = vers ;
+	progvers = vers;
-    return ;
+	return;
 }
 /*
     PRINT VERSION NUMBER
     This routine prints the program name and version number plus the
     versions of C++ and the TDF specification it supports to the print
     buffer, returning the result.
 */
-string report_version
+string
-    PROTO_N ( ( vers ) )
-    PROTO_T ( int vers )
+report_version(int vers)
+{
-    BUFFER *bf = clear_buffer ( &print_buff, NIL ( FILE ) ) ;
+	BUFFER *bf = clear_buffer(&print_buff, NIL(FILE));
-    bfprintf ( bf, "%x: Version %x", progname, progvers ) ;
+	bfprintf(bf, "%x: Version %x", progname, progvers);
-    if ( vers ) {
+	if (vers) {
-	char buff [20] ;
+		char buff[20];
-	char *v = LANGUAGE_VERSION ;
+		char *v = LANGUAGE_VERSION;
-	sprintf_v ( buff, "%.4s-%.2s", v, v + 4 ) ;
+		sprintf_v(buff, "%.4s-%.2s", v, v + 4);
-	bfprintf ( bf, " (%x %x", LANGUAGE_NAME, buff ) ;
+		bfprintf(bf, " (%x %x", LANGUAGE_NAME, buff);
-	bfprintf ( bf, " to TDF %d.%d", TDF_major, TDF_minor ) ;
+		bfprintf(bf, " to TDF %d.%d", TDF_major, TDF_minor);
 #ifdef RELEASE
-	bfprintf ( bf, ", Release %x", RELEASE ) ;
+		bfprintf(bf, ", Release %x", RELEASE);
 #endif
-	bfprintf ( bf, ")" ) ;
+		bfprintf(bf, ")");
-    }
+	}
-    return ( bf->start ) ;
+	return (bf->start);
 }
 /*
     CURRENT FILE POSITION
     This structure gives the current file position.  This consists of a
     string, giving the file name, an integer, giving the line number, and
     a pointer to any previous positions from which this is derived by a
     #include directive.
 */
-LOCATION crt_loc = NULL_loc ;
+LOCATION crt_loc = NULL_loc;
-LOCATION builtin_loc = NULL_loc ;
+LOCATION builtin_loc = NULL_loc;
 /*
     ERROR REPORTING VARIABLES
     These variables are used by the error reporting routines.  exit_status
     gives the overall status of the program - it is EXIT_SUCCESS if no
     serious errors have occurred, and EXIT_FAILURE otherwise.  A count of
     the number of serious errors is kept in number_errors, up to a maximum
     of max_errors.
 */
-FILE *error_file = NULL ;
+FILE *error_file = NULL;
-int exit_status = EXIT_SUCCESS ;
+int exit_status = EXIT_SUCCESS;
-unsigned long number_errors = 0 ;
+unsigned long number_errors = 0;
-unsigned long number_warnings = 0 ;
+unsigned long number_warnings = 0;
-unsigned long max_errors = 32 ;
+unsigned long max_errors = 32;
-int error_threshold = ERROR_NONE ;
+int error_threshold = ERROR_NONE;
-int no_error_args = 0 ;
+int no_error_args = 0;
-int verbose = 0 ;
+int verbose = 0;
-static int print_short = 0 ;
+static int print_short = 0;
-static int print_error_loc = 0 ;
+static int print_error_loc = 0;
-static int print_error_name = 0 ;
+static int print_error_name = 0;
-static int print_error_source = 0 ;
+static int print_error_source = 0;
-static int print_iso_ref = 1 ;
+static int print_iso_ref = 1;
-static int print_ansi_ref = 0 ;
+static int print_ansi_ref = 0;
 /*
     PROCESS AN ERROR FORMATTING OPTION
     This routine processes the error formatting options given by opt.
     This corresponds to the command-line option '-mopt'.
 */
-void error_option
+void
-    PROTO_N ( ( opt ) )
-    PROTO_T ( string opt )
+error_option(string opt)
 {
-    int out = 1 ;
+	int out = 1;
-    character c ;
+	character c;
-    while ( c = *( opt++ ), c != 0 ) {
+	while (c = *(opt++), c != 0) {
-	switch ( c ) {
+		switch (c) {
+		case 'a':
-	    case 'a' : print_ansi_ref = out ; break ;
+			print_ansi_ref = out;
+			break;
+		case 'c':
-	    case 'c' : print_error_source = out ; break ;
+			print_error_source = out;
+			break;
+		case 'e':
-	    case 'e' : print_error_name = out ; break ;
+			print_error_name = out;
+			break;
+		case 'f':
-	    case 'f' : good_fseek = out ; break ;
+			good_fseek = out;
+			break;
+		case 'g':
-	    case 'g' : record_location = out ; break ;
+			record_location = out;
+			break;
+		case 'i':
-	    case 'i' : good_stat = out ; break ;
+			good_stat = out;
+			break;
+		case 'k':
-	    case 'k' : output_spec = out ; break ;
+			output_spec = out;
+			break;
+		case 'l':
-	    case 'l' : print_error_loc = out ; break ;
+			print_error_loc = out;
+			break;
+		case 'm':
-	    case 'm' : allow_multibyte = out ; break ;
+			allow_multibyte = out;
+			break;
+		case 'p':
-	    case 'p' : preproc_space = out ; break ;
+			preproc_space = out;
+			break;
+		case 'q':
-	    case 'q' : print_short = out ; break ;
+			print_short = out;
+			break;
+		case 'r':
-	    case 'r' : allow_dos_newline = out ; break ;
+			allow_dos_newline = out;
+			break;
+		case 's':
-	    case 's' : print_iso_ref = out ; break ;
+			print_iso_ref = out;
+			break;
+		case 't':
-	    case 't' : print_type_alias = out ; break ;
+			print_type_alias = out;
+			break;
+		case 'x':
-	    case 'x' : print_c_style = out ; break ;
+			print_c_style = out;
+			break;
-	    case '+' : out = 1 ; break ;
+		case '+':
+			out = 1;
+			break;
-	    case '-' : out = 0 ; break ;
+		case '-':
+			out = 0;
+			break;
-	    case 'o' : {
+		case 'o': {
-		error_file = ( out ? stdout : stderr ) ;
+			error_file = (out ? stdout : stderr);
-		break ;
+			break;
-	    }
+		}
-	    case 'w' : {
+		case 'w': {
-		OPTION sev = OPTION_WARN ;
+			OPTION sev = OPTION_WARN;
+			if (out) {
-		if ( out ) sev = OPTION_OFF ;
+				sev = OPTION_OFF;
+			}
-		OPT_CATALOG [ OPT_warning ].def [0] = sev ;
+			OPT_CATALOG[OPT_warning].def[0] = sev;
-		OPT_CATALOG [ OPT_warning ].def [1] = sev ;
+			OPT_CATALOG[OPT_warning].def[1] = sev;
-		break ;
+			break;
-	    }
+		}
-	    case 'z' : {
+		case 'z': {
-		OPTION sev = OPTION_ON ;
+			OPTION sev = OPTION_ON;
+			if (out) {
-		if ( out ) sev = OPTION_WARN ;
+				sev = OPTION_WARN;
+			}
-		OPT_CATALOG [ OPT_error ].def [0] = sev ;
+			OPT_CATALOG[OPT_error].def[0] = sev;
-		OPT_CATALOG [ OPT_error ].def [1] = sev ;
+			OPT_CATALOG[OPT_error].def[1] = sev;
-		break ;
+			break;
-	    }
+		}
-	    default : {
+		default : {
-		/* Unknown output options */
+			/* Unknown output options */
+			CONST char *err =
-		CONST char *err = "Unknown error formatting option, '%c'" ;
+			    "Unknown error formatting option, '%c'";
-		error ( ERROR_WARNING, err, ( int ) c ) ;
+			error(ERROR_WARNING, err,(int)c);
-		break ;
+			break;
-	    }
+		}
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     ERROR MESSAGE PARAMETERS
     These macros are used to parameterise the form of the error messages.
 */
 #define HEADER_FATAL		"Fatal error"
 #define HEADER_SERIOUS		"Error"
 #define HEADER_WARNING		"Warning"
 #define HEADER_INTERNAL		"Internal error"
 #define HEADER_ASSERT		"Assertion"
-#define PRINT_HEADER( M, L, F )\
+#define PRINT_HEADER(M, L, F)\
-	print_location ( ( L ), ( F ) ) ;\
+	print_location((L), (F));\
-	fputs_v ( ": ", ( F ) ) ;\
+	fputs_v(": ",(F));\
-	fputs_v ( ( M ), ( F ) ) ;\
+	fputs_v((M), (F));\
-	fputs_v ( ":\n", ( F ) )
+	fputs_v(":\n",(F))
-#define PRINT_SOURCE( L, F )\
+#define PRINT_SOURCE(L, F)\
-	print_source ( ( L ), 1, 0, "    ", ( F ) )
+	print_source((L), 1, 0, "    ",(F))
-#define PRINT_FROM( L, F )\
+#define PRINT_FROM(L, F)\
-	fputs_v ( "    (included from ", ( F ) ) ;\
+	fputs_v("    (included from ",(F));\
-	print_location ( ( L ), ( F ) ) ;\
+	print_location((L), (F));\
-	fputs_v ( ")\n", ( F ) )
+	fputs_v(")\n",(F))
-#define PRINT_START( M, F )\
+#define PRINT_START(M, F)\
-	fputs_v ( ( M ), ( F ) ) ;\
+	fputs_v((M), (F));\
-	fputs_v ( ": ", ( F ) )
+	fputs_v(": ",(F))
 #define MESSAGE_START		"  "
 #define MESSAGE_END		".\n"
 #define MESSAGE_TERM		"\n"
 #define MESSAGE_NAME		"[%x]: "
 #define MESSAGE_ISO		"[ISO %x]: "
     FORWARD DECLARATION
     The following forward declaration is necessary.
 */
-static void print_error_msg PROTO_S ( ( ERROR, LOCATION *, FILE * ) ) ;
+static void print_error_msg(ERROR, LOCATION *, FILE *);
 /*
     TERMINATE PROGRAM
     a memory allocation error when the amount of tidying up which can
     be done is limited, although some memory is freed to give a little
     leeway.
 */
-void term_error
+void
-    PROTO_N ( ( fatal ) )
-    PROTO_T ( int fatal )
+term_error(int fatal)
+{
-    if ( fatal ) {
+	if (fatal) {
-	/* Cope with memory allocation errors */
+		/* Cope with memory allocation errors */
-	exit_status = EXIT_FAILURE ;
+		exit_status = EXIT_FAILURE;
-	output_capsule = 0 ;
+		output_capsule = 0;
-	output_spec = 0 ;
+		output_spec = 0;
-	free_buffer ( &token_buff ) ;
+		free_buffer(&token_buff);
-    }
+	}
-    if ( do_dump ) {
+	if (do_dump) {
-	/* End dump file */
+		/* End dump file */
-	term_dump () ;
+		term_dump();
-	do_dump = 0 ;
+		do_dump = 0;
-    }
+	}
-    if ( do_error ) {
+	if (do_error) {
-	/* Report errors in dump file */
+		/* Report errors in dump file */
-	unsigned long e = number_errors ;
+		unsigned long e = number_errors;
-	unsigned long w = number_warnings ;
+		unsigned long w = number_warnings;
-	int sev = ( e ? ERROR_SERIOUS : ERROR_WARNING ) ;
+		int sev = (e ? ERROR_SERIOUS : ERROR_WARNING);
-	do_error = 0 ;
+		do_error = 0;
-	error ( sev, "%lu error(s), %lu warning(s)", e, w ) ;
+		error(sev, "%lu error(s), %lu warning(s)", e, w);
-    }
+	}
-    if ( output_name [ OUTPUT_SPEC ] ) {
+	if (output_name[OUTPUT_SPEC]) {
-	/* Write spec file */
+		/* Write spec file */
-	begin_spec () ;
+		begin_spec();
-	end_spec () ;
+		end_spec();
-    }
+	}
-    if ( output_tdf ) {
+	if (output_tdf) {
-	/* Write capsule */
+		/* Write capsule */
-	write_capsule () ;
+		write_capsule();
-    }
+	}
-    exit ( exit_status ) ;
+	exit(exit_status);
+}
 /*
     ERROR BREAKPOINT ROUTINE
     This routine is intended to aid in debugging.  It is called just after
     any error message is printed.
 */
-static void error_break
+static void
-    PROTO_Z ()
+error_break(void)
 {
-    return ;
+	return;
 }
 /*
     FIND AN ERROR MESSAGE HEADER
     This routine returns the error message header for an error of severity
     sev.  It also updates the internal flags.
 */
-static CONST char *error_header
+static CONST char *
-    PROTO_N ( ( sev ) )
-    PROTO_T ( int sev )
+error_header(int sev)
+{
-    CONST char *msg ;
+	CONST char *msg;
-    switch ( sev ) {
+	switch (sev) {
-	case ERROR_FATAL : {
+	case ERROR_FATAL: {
-	    msg = HEADER_FATAL ;
+		msg = HEADER_FATAL;
-	    exit_status = EXIT_FAILURE ;
-	    output_capsule = 0 ;
-	    number_errors++ ;
-	    break ;
-	}
-	case ERROR_INTERNAL : {
-	    msg = HEADER_INTERNAL ;
-	    if ( error_severity [ OPTION_ON ] == ERROR_SERIOUS ) {
-		exit_status = EXIT_FAILURE ;
+		exit_status = EXIT_FAILURE;
-		output_capsule = 0 ;
+		output_capsule = 0;
-	    }
-	    number_errors++ ;
+		number_errors++;
-	    break ;
+		break;
+	}
-	default : {
+	case ERROR_INTERNAL: {
-	    msg = HEADER_SERIOUS ;
+		msg = HEADER_INTERNAL;
-	    if ( error_severity [ OPTION_ON ] == ERROR_SERIOUS ) {
+		if (error_severity[OPTION_ON] == ERROR_SERIOUS) {
-		exit_status = EXIT_FAILURE ;
+			exit_status = EXIT_FAILURE;
-		output_capsule = 0 ;
+			output_capsule = 0;
-	    }
+		}
-	    number_errors++ ;
+		number_errors++;
-	    break ;
+		break;
+	}
+	default : {
+		msg = HEADER_SERIOUS;
+		if (error_severity[OPTION_ON] == ERROR_SERIOUS) {
+			exit_status = EXIT_FAILURE;
+			output_capsule = 0;
+		}
+		number_errors++;
+		break;
+	}
-	case ERROR_WARNING : {
+	case ERROR_WARNING: {
-	    msg = HEADER_WARNING ;
+		msg = HEADER_WARNING;
-	    number_warnings++ ;
+		number_warnings++;
-	    break ;
+		break;
 	}
-    }
+	}
-    return ( msg ) ;
+	return (msg);
+}
 /*
     PRINT A LOCATION TO A FILE
     This routine prints the location loc to the file f.
 */
-static void print_location
+static void
-    PROTO_N ( ( loc, f ) )
-    PROTO_T ( LOCATION *loc X FILE *f )
+print_location(LOCATION *loc, FILE *f)
 {
-    BUFFER *bf = clear_buffer ( &print_buff, f ) ;
+	BUFFER *bf = clear_buffer(&print_buff, f);
-    IGNORE print_loc ( loc, NIL ( LOCATION ), bf, 0 ) ;
+	IGNORE print_loc(loc, NIL(LOCATION), bf, 0);
-    output_buffer ( bf, 0 ) ;
+	output_buffer(bf, 0);
-    return ;
+	return;
 }
 /*
     CONVERT AN ISO SECTION NUMBER TO AN ANSI SECTION NUMBER
     The ISO C standard was based on the ANSI C standard but the sections
     were renumbered.  The ISO and ANSI C++ standards are identical.  This
     routine converts the ISO section number s to the corresponding ANSI
     section number, printing it to the buffer bf.
 */
-static void iso_to_ansi
+static void
-    PROTO_N ( ( bf, s ) )
-    PROTO_T ( BUFFER *bf X CONST char *s )
+iso_to_ansi(BUFFER *bf, CONST char *s)
+{
 #if LANGUAGE_C
-    char c ;
+	char c;
-    unsigned long n = 0 ;
+	unsigned long n = 0;
-    CONST char *p = "1." ;
+	CONST char *p = "1.";
-    CONST char *q = s ;
+	CONST char *q = s;
-    while ( c = *q, ( c >= '0' && c <= '9' ) ) {
+	while (c = *q,(c >= '0' && c <= '9')) {
-	n = 10 * n + ( unsigned long ) ( c - '0' ) ;
+		n = 10 * n + (unsigned long)(c - '0');
-	q++ ;
+		q++;
-    }
+	}
-    if ( n == 0 ) {
+	if (n == 0) {
-	bfprintf ( bf, "%x", s ) ;
+		bfprintf(bf, "%x", s);
-    } else {
+	} else {
-	switch ( n ) {
+		switch (n) {
-	    case 1 : n = 2 ; break ;
+		case 1:
+			n = 2;
+			break;
-	    case 2 : n = 3 ; break ;
+		case 2:
+			n = 3;
+			break;
-	    case 3 : n = 6 ; break ;
+		case 3:
+			n = 6;
+			break;
-	    case 4 : n = 7 ; break ;
+		case 4:
+			n = 7;
+			break;
+		default:
+			p = "";
+			n -= 3;
+			break;
+		}
-	    default : p = "" ; n -= 3 ; break ;
+		bfprintf(bf, "%x%lu%x", p, n, q);
+	}
-	bfprintf ( bf, "%x%lu%x", p, n, q ) ;
-    }
 #else
-    bfprintf ( bf, "%x", s ) ;
+	bfprintf(bf, "%x", s);
 #endif
-    return ;
+	return;
+}
 /*
     PRINT THE START OF AN ERROR MESSAGE
     This routine prints the start of an error message of severity sev and
     location loc to the file f.
 */
-static void print_error_start
+static void
-    PROTO_N ( ( f, loc, sev ) )
-    PROTO_T ( FILE *f X LOCATION *loc X int sev )
+print_error_start(FILE *f, LOCATION *loc, int sev)
+{
-    CONST char *msg = error_header ( sev ) ;
+	CONST char *msg = error_header(sev);
-    if ( loc ) {
+	if (loc) {
-	PRINT_HEADER ( msg, loc, f ) ;
+		PRINT_HEADER(msg, loc, f);
-	if ( print_error_loc ) {
+		if (print_error_loc) {
-	    /* Print full error location */
+			/* Print full error location */
-	    LOCATION floc ;
+			LOCATION floc;
-	    LOCATION *ploc = loc ;
+			LOCATION *ploc = loc;
-	    for ( ; ; ) {
+			for (;;) {
-		PTR ( LOCATION ) from ;
+				PTR(LOCATION)from;
-		PTR ( POSITION ) posn = ploc->posn ;
+				PTR(POSITION)posn = ploc->posn;
-		if ( IS_NULL_ptr ( posn ) ) break ;
+				if (IS_NULL_ptr(posn)) {
+					break;
+				}
-		from = DEREF_ptr ( posn_from ( posn ) ) ;
+				from = DEREF_ptr(posn_from(posn));
-		if ( IS_NULL_ptr ( from ) ) break ;
+				if (IS_NULL_ptr(from)) {
+					break;
+				}
-		DEREF_loc ( from, floc ) ;
+				DEREF_loc(from, floc);
-		ploc = &floc ;
+				ploc = &floc;
-		PRINT_FROM ( ploc, f ) ;
+				PRINT_FROM(ploc, f);
-	    }
+			}
-	}
+		}
-	if ( print_error_source ) {
+		if (print_error_source) {
-	    /* Print source line */
+			/* Print source line */
-	    PRINT_SOURCE ( loc, f ) ;
+			PRINT_SOURCE(loc, f);
+		}
+	} else {
+		PRINT_START(msg, f);
+	}
-    } else {
-	PRINT_START ( msg, f ) ;
-    }
-    return ;
+	return;
+}
 /*
     PRINT THE END OF AN ERROR MESSAGE
     This routine prints the end of an error message of severity sev to
     the file f.
 */
-static void print_error_end
+static void
-    PROTO_N ( ( f, sev ) )
-    PROTO_T ( FILE *f X int sev )
+print_error_end(FILE *f, int sev)
+{
-    unsigned long n = number_errors ;
+	unsigned long n = number_errors;
-    if ( n >= max_errors && sev != ERROR_FATAL ) {
+	if (n >= max_errors && sev != ERROR_FATAL) {
-	ERROR err = ERR_fail_too_many ( n ) ;
+		ERROR err = ERR_fail_too_many(n);
-	print_error_msg ( err, &crt_loc, f ) ;
+		print_error_msg(err, &crt_loc, f);
-	sev = ERROR_FATAL ;
+		sev = ERROR_FATAL;
-    }
+	}
-    fputs_v ( MESSAGE_TERM, f ) ;
+	fputs_v(MESSAGE_TERM, f);
-    error_break () ;
+	error_break();
-    if ( sev == ERROR_FATAL ) term_error ( 0 ) ;
+	if (sev == ERROR_FATAL) {
+		term_error(0);
+	}
-    return ;
+	return;
+}
 /*
     OPTION SEVERITY LEVELS
     This table gives the mapping between options and error severity
     levels.
 */
-int error_severity [] = {
+int error_severity[] = {
-    ERROR_NONE,				/* OPTION_OFF */
+	ERROR_NONE,			/* OPTION_OFF */
-    ERROR_WARNING,			/* OPTION_WARN */
+	ERROR_WARNING,			/* OPTION_WARN */
-    ERROR_SERIOUS,			/* OPTION_ON */
+	ERROR_SERIOUS,			/* OPTION_ON */
-    ERROR_WHATEVER			/* OPTION_WHATEVER */
+	ERROR_WHATEVER			/* OPTION_WHATEVER */
-} ;
+};
-int default_severity [] = {
+int default_severity[] = {
-    ERROR_NONE,				/* OPTION_OFF */
+	ERROR_NONE,			/* OPTION_OFF */
-    ERROR_WARNING,			/* OPTION_WARN */
+	ERROR_WARNING,			/* OPTION_WARN */
-    ERROR_SERIOUS,			/* OPTION_ON */
+	ERROR_SERIOUS,			/* OPTION_ON */
-    ERROR_WHATEVER			/* OPTION_WHATEVER */
+	ERROR_WHATEVER			/* OPTION_WHATEVER */
-} ;
+};
 /*
     CREATE AN ERROR STRUCTURE
     This routine creates a structure for error n in the error catalogue.
     Any extra arguments needed by the error should also be given.  Because
     of restrictions imposed by the way that stdarg is implemented, any
     structure arguments need to be explicitly passed by reference.  Note
     that these arguments are stored in the result in reverse order.
 */
-ERROR make_error
+ERROR
-    PROTO_V ( ( int n, ... ) ) /* VARARGS */
+make_error(int n, ...) /* VARARGS */
+{
-    int sev ;
+	int sev;
-    ERROR e ;
+	ERROR e;
-    OPTION opt ;
+	OPTION opt;
-    va_list args ;
+	va_list args;
-    ERR_DATA *msg ;
+	ERR_DATA *msg;
-    CONST char *s ;
+	CONST char *s;
 #if FS_STDARG
-    va_start ( args, n ) ;
+	va_start(args, n);
 #else
-    int n ;
+	int n;
-    va_start ( args ) ;
+	va_start(args);
-    n = va_arg ( args, int ) ;
+	n = va_arg(args, int);
 #endif
+		}
-	    }
+	}
-    }
-    va_end ( args ) ;
+	va_end(args);
-    return ( e ) ;
+	return (e);
+}
 /*
     PRINT THE BODY OF AN ERROR STRUCTURE
     This routine prints the body of the simple error message e to the
     buffer bf.
 */
-static void print_error_body
+static void
-    PROTO_N ( ( e, loc, bf ) )
-    PROTO_T ( ERROR e X LOCATION *loc X BUFFER *bf )
+print_error_body(ERROR e, LOCATION *loc, BUFFER *bf)
+{
-    char c ;
+	char c;
-    QUALIFIER qual = qual_none ;
+	QUALIFIER qual = qual_none;
-    /* Extract error information */
+	/* Extract error information */
-    int n = DEREF_int ( err_simple_number ( e ) ) ;
+	int n = DEREF_int(err_simple_number(e));
-    unsigned sz = DEREF_unsigned ( err_simple_size ( e ) ) ;
+	unsigned sz = DEREF_unsigned(err_simple_size(e));
-    /* Look up error in catalogue */
+	/* Look up error in catalogue */
-    ERR_DATA *msg = ERR_CATALOG + n ;
+	ERR_DATA *msg = ERR_CATALOG + n;
-    CONST char *sig = msg->signature ;
+	CONST char *sig = msg->signature;
-    CONST char *s = msg->key_STD ;
+	CONST char *s = msg->key_STD;
+		}
-		case ERR_KEY_unsigned : {
-		    unsigned arg ;
-		    arg = DEREF_unsigned ( err_arg ( e, a, unsigned ) ) ;
-		    bfprintf ( bf, "%u", arg ) ;
-		    break ;
-		}
-		default : {
-		    bfprintf ( bf, "<arg%u>", a ) ;
-		    break ;
-		}
-	    }
-	} else {
-	    /* Other characters */
-	    bfputc ( bf, c ) ;
 	}
-    }
-    return ;
+	return;
+}
 /*
     PRINT AN ERROR STRUCTURE
     This routine prints the body of the error message given by e to the
     file f.
 */
-static void print_error_msg
+static void
-    PROTO_N ( ( e, loc, f ) )
-    PROTO_T ( ERROR e X LOCATION *loc X FILE *f )
+print_error_msg(ERROR e, LOCATION *loc, FILE *f)
+{
-    if ( IS_err_simple ( e ) ) {
+	if (IS_err_simple(e)) {
-	/* Print simple error message */
+		/* Print simple error message */
-	BUFFER *bf ;
+		BUFFER *bf;
-	int n = DEREF_int ( err_simple_number ( e ) ) ;
+		int n = DEREF_int(err_simple_number(e));
-	ERR_DATA *msg = ERR_CATALOG + n ;
+		ERR_DATA *msg = ERR_CATALOG + n;
-	ERR_PROPS props = msg->props ;
+		ERR_PROPS props = msg->props;
-	int sev = DEREF_int ( err_severity ( e ) ) ;
+		int sev = DEREF_int(err_severity(e));
-	if ( sev == ERROR_WHATEVER && print_short ) return ;
+		if (sev == ERROR_WHATEVER && print_short) return;
-	bf = clear_buffer ( &print_buff, f ) ;
+		bf = clear_buffer(&print_buff, f);
-	if ( loc ) bfprintf ( bf, MESSAGE_START ) ;
+		if (loc)bfprintf(bf, MESSAGE_START);
-	if ( print_error_name ) {
+		if (print_error_name) {
-	    CONST char *name = msg->name ;
+			CONST char *name = msg->name;
-	    if ( name ) bfprintf ( bf, MESSAGE_NAME, name ) ;
+			if (name)bfprintf(bf, MESSAGE_NAME, name);
-	}
-	if ( !( props & ERR_PROP_non_iso ) && print_iso_ref ) {
-	    CONST char *iso ;
-	    ERR_DATA *prev = msg ;
-	    while ( iso = prev->key_ISO, iso == NULL ) {
-		/* Scan back to current section number */
-		if ( prev == ERR_CATALOG ) break ;
-		prev-- ;
-	    }
-	    msg->key_ISO = iso ;
-	    if ( iso && iso [0] ) {
-		if ( print_ansi_ref ) {
-		    bfprintf ( bf, MESSAGE_ANSI ) ;
-		    iso_to_ansi ( bf, iso ) ;
-		    bfprintf ( bf, MESSAGE_ANSI_END ) ;
-		} else {
-		    bfprintf ( bf, MESSAGE_ISO, iso ) ;
+		}
+		if (!(props & ERR_PROP_non_iso) && print_iso_ref) {
+			CONST char *iso;
+			ERR_DATA *prev = msg;
+			while (iso = prev->key_ISO, iso == NULL) {
+				/* Scan back to current section number */
+				if (prev == ERR_CATALOG)break;
+				prev--;
+			}
+			msg->key_ISO = iso;
+			if (iso && iso[0]) {
+				if (print_ansi_ref) {
+					bfprintf(bf, MESSAGE_ANSI);
+					iso_to_ansi(bf, iso);
+					bfprintf(bf, MESSAGE_ANSI_END);
+				} else {
+					bfprintf(bf, MESSAGE_ISO, iso);
-	    }
+				}
+			}
-	}
+		}
-	if ( props ) {
+		if (props) {
+			if (props & ERR_PROP_pragma) {
+				bfprintf(bf, MESSAGE_PRAGMA);
+			}
-	    if ( props & ERR_PROP_pragma ) bfprintf ( bf, MESSAGE_PRAGMA ) ;
+			if (props & ERR_PROP_printf) {
-	    if ( props & ERR_PROP_printf ) bfprintf ( bf, MESSAGE_PRINTF ) ;
+				bfprintf(bf, MESSAGE_PRINTF);
+			}
+			if (props & ERR_PROP_token) {
-	    if ( props & ERR_PROP_token ) bfprintf ( bf, MESSAGE_TOKEN ) ;
+				bfprintf(bf, MESSAGE_TOKEN);
+			}
+			if (props & ERR_PROP_syntax) {
-	    if ( props & ERR_PROP_syntax ) bfprintf ( bf, MESSAGE_SYNTAX ) ;
+				bfprintf(bf, MESSAGE_SYNTAX);
+			}
-	}
+		}
-	print_error_body ( e, loc, bf ) ;
+		print_error_body(e, loc, bf);
-	bfprintf ( bf, MESSAGE_END ) ;
+		bfprintf(bf, MESSAGE_END);
-	output_buffer ( bf, 1 ) ;
+		output_buffer(bf, 1);
-    } else {
+	} else {
-	/* Print composite error message */
+		/* Print composite error message */
-	ERROR e1 = DEREF_err ( err_compound_head ( e ) ) ;
+		ERROR e1 = DEREF_err(err_compound_head(e));
-	ERROR e2 = DEREF_err ( err_compound_tail ( e ) ) ;
+		ERROR e2 = DEREF_err(err_compound_tail(e));
-	print_error_msg ( e1, loc, f ) ;
+		print_error_msg(e1, loc, f);
-	print_error_msg ( e2, loc, f ) ;
+		print_error_msg(e2, loc, f);
-    }
+	}
-    return ;
+	return;
+}
 /*
     DESTROY AN ERROR STRUCTURE
     This routine destroys the error structure e.  If d is false then the
     first component of a compound error is not destroyed.
 */
-void destroy_error
+void
-    PROTO_N ( ( e, d ) )
-    PROTO_T ( ERROR e X int d )
+destroy_error(ERROR e, int d)
+{
-    if ( !IS_NULL_err ( e ) ) {
+	if (!IS_NULL_err(e)) {
-	if ( IS_err_simple ( e ) ) {
+		if (IS_err_simple(e)) {
-	    if ( d ) DESTROY_err_simple_args ( e ) ;
+			if (d)DESTROY_err_simple_args(e);
-	} else {
+		} else {
-	    int sev ;
+			int sev;
-	    ERROR e1, e2 ;
+			ERROR e1, e2;
-	    DESTROY_err_compound ( destroy, sev, e1, e2, e ) ;
+			DESTROY_err_compound(destroy, sev, e1, e2, e);
-	    if ( d ) destroy_error ( e1, 1 ) ;
+			if (d)destroy_error(e1, 1);
-	    destroy_error ( e2, 1 ) ;
+			destroy_error(e2, 1);
-	    UNUSED ( sev ) ;
+			UNUSED(sev);
+		}
+	}
-    }
-    return ;
+	return;
+}
 /*
     JOIN TWO ERROR STRUCTURES
     This routine joins the error structures e1 and e2 into a single compound
     error structure.
 */
-ERROR concat_error
+ERROR
-    PROTO_N ( ( e1, e2 ) )
-    PROTO_T ( ERROR e1 X ERROR e2 )
+concat_error(ERROR e1, ERROR e2)
 {
-    ERROR e ;
+	ERROR e;
-    int s1, s2 ;
+	int s1, s2;
-    if ( IS_NULL_err ( e1 ) ) return ( e2 ) ;
+	if (IS_NULL_err(e1)) {
+		return (e2);
+	}
-    if ( IS_NULL_err ( e2 ) ) return ( e1 ) ;
+	if (IS_NULL_err(e2)) {
+		return (e1);
+	}
-    s1 = DEREF_int ( err_severity ( e1 ) ) ;
+	s1 = DEREF_int(err_severity(e1));
-    s2 = DEREF_int ( err_severity ( e2 ) ) ;
+	s2 = DEREF_int(err_severity(e2));
-    if ( s2 > s1 ) s1 = s2 ;
+	if (s2 > s1) {
+		s1 = s2;
+	}
-    MAKE_err_compound ( s1, e1, e2, e ) ;
+	MAKE_err_compound(s1, e1, e2, e);
-    return ( e ) ;
+	return (e);
 }
 /*
     OPTIONALLY JOIN TWO ERROR STRUCTURES
     This routine joins the error structures e1 and e2 into a single compound
     error structure if e1 represents a serious error.  Otherwise e2 is
     destroyed and e1 is returned.
 */
-ERROR concat_warning
+ERROR
-    PROTO_N ( ( e1, e2 ) )
-    PROTO_T ( ERROR e1 X ERROR e2 )
+concat_warning(ERROR e1, ERROR e2)
 {
-    ERROR e ;
+	ERROR e;
-    int s1, s2 ;
+	int s1, s2;
-    if ( IS_NULL_err ( e1 ) ) return ( e2 ) ;
+	if (IS_NULL_err(e1)) {
+		return (e2);
+	}
-    if ( IS_NULL_err ( e2 ) ) return ( e1 ) ;
+	if (IS_NULL_err(e2)) {
+		return (e1);
+	}
-    s1 = DEREF_int ( err_severity ( e1 ) ) ;
+	s1 = DEREF_int(err_severity(e1));
-    if ( s1 > ERROR_WARNING ) {
+	if (s1 > ERROR_WARNING) {
-	s2 = DEREF_int ( err_severity ( e2 ) ) ;
+		s2 = DEREF_int(err_severity(e2));
-	if ( s2 > s1 ) s1 = s2 ;
+		if (s2 > s1) {
+			s1 = s2;
+		}
-	MAKE_err_compound ( s1, e1, e2, e ) ;
+		MAKE_err_compound(s1, e1, e2, e);
-    } else {
+	} else {
-	destroy_error ( e2, 1 ) ;
+		destroy_error(e2, 1);
-	e = e1 ;
+		e = e1;
-    }
+	}
-    return ( e ) ;
+	return (e);
 }
 /*
     ADD AN ERROR TO A LIST
     This routine adds the error e to the end of the list indicated by err.
     If err is the null pointer then e is destroyed.
 */
-void add_error
+void
-    PROTO_N ( ( err, e ) )
-    PROTO_T ( ERROR *err X ERROR e )
+add_error(ERROR *err, ERROR e)
+{
-    if ( !IS_NULL_err ( e ) ) {
+	if (!IS_NULL_err(e)) {
-	if ( err ) {
+		if (err) {
-	    ERROR e1 = *err ;
+			ERROR e1 = *err;
-	    if ( IS_NULL_err ( e1 ) ) {
+			if (IS_NULL_err(e1)) {
-		*err = e ;
+				*err = e;
-	    } else {
+			} else {
-		int s1 = DEREF_int ( err_severity ( e1 ) ) ;
+				int s1 = DEREF_int(err_severity(e1));
-		int s2 = DEREF_int ( err_severity ( e ) ) ;
+				int s2 = DEREF_int(err_severity(e));
-		if ( s2 > s1 ) s1 = s2 ;
+				if (s2 > s1) {
+					s1 = s2;
+				}
-		MAKE_err_compound ( s1, e1, e, *err ) ;
+				MAKE_err_compound(s1, e1, e, *err);
-	    }
+			}
-	} else {
+		} else {
-	    destroy_error ( e, 1 ) ;
+			destroy_error(e, 1);
+		}
+	}
-    }
-    return ;
+	return;
+}
 /*
     STANDARD ERROR PREFIX
     These variables give an error message which is added to the start
     of any error before it is printed.  The prefix error severity is not
     taken into account in the overall error severity.
 */
-static ERROR error_prefix = NULL_err ;
+static ERROR error_prefix = NULL_err;
 /*
     SET ERROR PREFIX
     This routine sets the error prefix to be e, returning the previous
     value.
 */
-ERROR set_prefix
+ERROR
-    PROTO_N ( ( e ) )
-    PROTO_T ( ERROR e )
+set_prefix(ERROR e)
+{
-    ERROR p = error_prefix ;
+	ERROR p = error_prefix;
-    error_prefix = e ;
+	error_prefix = e;
-    return ( p ) ;
+	return (p);
+}
 /*
     RESTORE ERROR PREFIX
     This routine restores the error prefix to e, destroying the previous
     value.
 */
-void restore_prefix
+void
-    PROTO_N ( ( e ) )
-    PROTO_T ( ERROR e )
+restore_prefix(ERROR e)
 {
-    destroy_error ( error_prefix, 1 ) ;
+	destroy_error(error_prefix, 1);
-    error_prefix = e ;
+	error_prefix = e;
-    return ;
+	return;
 }
 /*
     PRINT AN ERROR MESSAGE
     This routine prints the error e at location loc.
 */
-void print_error
+void
-    PROTO_N ( ( loc, e ) )
-    PROTO_T ( LOCATION *loc X ERROR e )
+print_error(LOCATION *loc, ERROR e)
 {
-    if ( !IS_NULL_err ( e ) ) {
+	if (!IS_NULL_err(e)) {
-	int d = 1 ;
+		int d = 1;
-	int sev = DEREF_int ( err_severity ( e ) ) ;
+		int sev = DEREF_int(err_severity(e));
-	if ( sev > error_threshold ) {
+		if (sev > error_threshold) {
-	    ERROR p = error_prefix ;
+			ERROR p = error_prefix;
-	    if ( !IS_NULL_err ( p ) ) {
+			if (!IS_NULL_err(p)) {
-		/* Add error prefix */
+				/* Add error prefix */
-		MAKE_err_compound ( sev, p, e, e ) ;
+				MAKE_err_compound(sev, p, e, e);
-		d = 0 ;
+				d = 0;
-	    }
+			}
-	    if ( do_error && dump_error ( e, loc, sev, 0 ) ) {
+			if (do_error && dump_error(e, loc, sev, 0)) {
-		/* Dump error to file */
+				/* Dump error to file */
-		unsigned long n ;
+				unsigned long n;
-		IGNORE error_header ( sev ) ;
+				IGNORE error_header(sev);
-		n = number_errors ;
+				n = number_errors;
-		error_break () ;
+				error_break();
-		if ( sev == ERROR_FATAL ) term_error ( 0 ) ;
+				if (sev == ERROR_FATAL)term_error(0);
-		if ( n >= max_errors ) term_error ( 0 ) ;
+				if (n >= max_errors)term_error(0);
-	    } else {
+			} else {
-		/* Print error to standard error */
+				/* Print error to standard error */
-		FILE *f = error_file ;
+				FILE *f = error_file;
-		print_error_start ( f, loc, sev ) ;
+				print_error_start(f, loc, sev);
-		print_error_msg ( e, loc, f ) ;
+				print_error_msg(e, loc, f);
-		print_error_end ( f, sev ) ;
+				print_error_end(f, sev);
-	    }
+			}
-	}
+		}
-	destroy_error ( e, d ) ;
+		destroy_error(e, d);
-    }
+	}
-    return ;
+	return;
+}
 /*
     CREATE AN INSTALLER ERROR EXPRESSION
     This routine creates an install-time error expression for the error
     e at the location loc.
 */
-EXP install_error
+EXP
-    PROTO_N ( ( loc, e ) )
-    PROTO_T ( LOCATION *loc X ERROR e )
+install_error(LOCATION *loc, ERROR e)
 {
-    EXP a = NULL_exp ;
+	EXP a = NULL_exp;
-    if ( !IS_NULL_err ( e ) ) {
+	if (!IS_NULL_err(e)) {
-	int sev = DEREF_int ( err_severity ( e ) ) ;
+		int sev = DEREF_int(err_severity(e));
-	if ( sev > ERROR_WARNING ) {
+		if (sev > ERROR_WARNING) {
-	    string s ;
+			string s;
-	    BUFFER *bf = clear_buffer ( &print_buff, NIL ( FILE ) ) ;
+			BUFFER *bf = clear_buffer(&print_buff, NIL(FILE));
-	    if ( loc ) {
+			if (loc) {
-		IGNORE print_loc ( loc, NIL ( LOCATION ), bf, 0 ) ;
+				IGNORE print_loc(loc, NIL(LOCATION), bf, 0);
-		bfprintf ( bf, ": " ) ;
+				bfprintf(bf, ": ");
-	    }
+			}
-	    print_error_body ( e, loc, bf ) ;
+			print_error_body(e, loc, bf);
-	    bfputc ( bf, 0 ) ;
+			bfputc(bf, 0);
-	    s = xustrcpy ( bf->start ) ;
+			s = xustrcpy(bf->start);
-	    MAKE_exp_fail ( type_bottom, s, a ) ;
+			MAKE_exp_fail(type_bottom, s, a);
-	}
+		}
-	destroy_error ( e, 1 ) ;
+		destroy_error(e, 1);
-    }
+	}
-    return ( a ) ;
+	return (a);
 }
 /*
     PRINT A SIMPLE ERROR
     This routine prints a simple error message at the current location of
     severity sev given by the printf style string s.  Any extra arguments
     needed by s should also be given.
 */
-void error
+void
-    PROTO_V ( ( int sev, CONST char *s, ... ) ) /* VARARGS */
+error(int sev, CONST char *s, ...) /* VARARGS */
+{
-    va_list args ;
+	va_list args;
 #if FS_STDARG
-    va_start ( args, s ) ;
+	va_start(args, s);
 #else
-    int sev ;
+	int sev;
-    CONST char *s ;
+	CONST char *s;
-    va_start ( args ) ;
+	va_start(args);
-    sev = va_arg ( args, int ) ;
+	sev = va_arg(args, int);
-    s = va_arg ( args, CONST char * ) ;
+	s = va_arg(args, CONST char *);
 #endif
-    if ( sev > error_threshold ) {
+	if (sev > error_threshold) {
-	FILE *f = error_file ;
+		FILE *f = error_file;
-	print_error_start ( f, NIL ( LOCATION ), sev ) ;
+		print_error_start(f, NIL(LOCATION), sev);
-	vfprintf_v ( f, s, args ) ;
+		vfprintf_v(f, s, args);
-	fputs_v ( MESSAGE_END, f ) ;
+		fputs_v(MESSAGE_END, f);
-	print_error_end ( f, sev ) ;
+		print_error_end(f, sev);
-    }
+	}
-    va_end ( args ) ;
+	va_end(args);
-    return ;
+	return;
+}
 /*
     PRINT A RUNNING COMMENTARY
     This routine is used in verbose mode to print a running commentary of
     the compilation of the object id.
 */
-void commentary
+void
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+commentary(IDENTIFIER id)
+{
-    if ( verbose && !IS_NULL_id ( id ) ) {
+	if (verbose && !IS_NULL_id(id)) {
-	BUFFER *bf = clear_buffer ( &print_buff, stdout ) ;
+		BUFFER *bf = clear_buffer(&print_buff, stdout);
-	print_id_desc++ ;
+		print_id_desc++;
-	IGNORE print_id_long ( id, qual_none, bf, 0 ) ;
+		IGNORE print_id_long(id, qual_none, bf, 0);
-	print_id_desc-- ;
+		print_id_desc--;
-	bfprintf ( bf, " ;\n" ) ;
+		bfprintf(bf, " ;\n");
-	output_buffer ( bf, 1 ) ;
+		output_buffer(bf, 1);
-    }
+	}
-    return ;
+	return;
+}
 /*
     PRINT AN ASSERTION
     check whether the condition of an assertion is false.
 */
 #ifdef ASSERTS
-void assertion
+void
-    PROTO_N ( ( s, file, line ) )
-    PROTO_T ( CONST char *s X CONST char *file X int line )
+assertion(CONST char *s, CONST char *file, int line)
+{
-    FILE *f = error_file ;
+	FILE *f = error_file;
-    PRINT_HEADER ( HEADER_ASSERT, &crt_loc, f ) ;
+	PRINT_HEADER(HEADER_ASSERT, &crt_loc, f);
-    fprintf_v ( f, "  %s, %s: line %d.\n\n", s, file, line ) ;
+	fprintf_v(f, "  %s, %s: line %d.\n\n", s, file, line);
-    error_break () ;
+	error_break();
-    abort () ;
+	abort();
+}
-int is_true
+int
-    PROTO_N ( ( c ) )
-    PROTO_T ( int c )
+is_true(int c)
+{
-    return ( c ) ;
+	return (c);
+}
 #endif

Subversion Repositories tendra.SVN

(root)/trunk/src/producers/common/utility/error.c – Rev 2 → 7