libukcprog/src/errf.c

/* errf.c -- formatted error messages */

/*  Copyright 1992  Godfrey Paul, University of Kent at Canterbury.
 *
 *  You can do what you like with this source code as long as
 *  you don't try to make money out of it and you include an
 *  unaltered copy of this message (including the copyright).
 */

char ukcprog_errf_sccsid[] = "$Id: errf.c,v 1.16 1995/11/26 16:05:56 mtr Exp $ UKC";

#ifdef __STDC__
#include <stdarg.h>
#else
#include <varargs.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "ukcprog.h"

static const char *munge_progname PROTO((const char *));
static void default_ofunc PROTO((const char *str));

static errf_ofunc_t User_errf_ofunc = default_ofunc;
static const char *Output_prefix = "";
static char *Progname = NULL;

static void
default_ofunc(str)
const char *str;
{
        fprintf(stderr, "%s%s\n", Output_prefix, str);
        fflush(stderr);
}

errf_ofunc_t
errf_set_ofunc(func)
errf_ofunc_t func;
{
        errf_ofunc_t old;

        if (func == NULL)
                func = default_ofunc;

        old = User_errf_ofunc;
        User_errf_ofunc = func;

        return old;
}


/*  errf_set_prefix()
 *  Sets the string that errf() prefixes to messages.
 *  Returns the old one.
 */
const char *
errf_set_prefix(prefix)
const char *prefix;
{
        const char *old;

        old = Output_prefix;
        Output_prefix = prefix;

        return old;
}


/*  errf_get_prefix()
 *  Return the current prefix.
 */
const char *
errf_get_prefix()
{
        return Output_prefix;
}


static const char *
munge_progname(progname)
const char *progname;
{
#ifdef VMS
        const char *name, *dot;
        char  *s;
        int i;

        if ((name = strrchr(progname, ']')) == NULL)
                name = progname;
        else
                ++name;

        if ((dot = strchr(name, '.')) == NULL)
                dot = name + strlen(name);

        s = strf("%.*s", dot - name, name);

        for (i = 0; i < dot - name; ++i)
                s[i] = toupper(s[i]);

        if (Progname != NULL)
                free(Progname);

        Progname = s;

        return "%%%s, ";
#else
#ifdef MSDOS
        const char *name;
        
        if ((name = strrchr(progname, '\\')) == NULL)
                name = progname;

        else
                ++name;

        if (Progname != NULL)
                free(Progname);

        Progname = strsave(name);

        return "%s: ";
#else
        /*  Everything is assumed to be some variant of Unix.
         */
        const char *name;
        
        if ((name = strrchr(progname, '/')) == NULL)
                name = progname;

        else
                ++name;

        if (Progname != NULL)
                free(Progname);

        Progname = strsave(name);

        return "%s: ";
#endif /* !MSDOS */
#endif /* !VMS */
}


/*  errf_set_progname()
 *  Convenience routine to set the errf prefix to include the progname.
 */
void
errf_set_progname(name)
const char *name;
{
        const char *fmt;

        fmt = munge_progname(name);
        errf_set_prefix(strf(fmt, Progname));
}


/*  errf_get_progname()
 */
const char *
errf_get_progname()
{
        return Progname;
}


#ifdef __STDC__
void
errf(const char *fmt, ...)
{

#else /* !__STDC__ */
void
errf(va_alist)
va_dcl
{
        char *fmt;
#endif /* !__STDC__ */
        va_list args;
        char buffer[100];
        char *s;

#ifdef __STDC__
        va_start(args, fmt);
#else
        va_start(args);
        fmt = va_arg(args, char *);
#endif

        s = formf(buffer, sizeof(buffer), fmt, args);

        va_end(args);

        (*User_errf_ofunc)(s);

        if (s != buffer)        /* must have been obtained from malloc */
                free(s);
}


/*  errf_usage()
 *  Output a usage string prefixed by the program name and exit(1).
 */
void
errf_usage(usage)
const char *usage;
{
        if (User_errf_ofunc != default_ofunc)
                (*User_errf_ofunc)(strf("Usage: %s %s", Progname, usage));
        else
                fprintf(stderr, "Usage: %s %s\n", Progname, usage);
        exit(1);
}
Revision:	1.1
Committed:	Sat Mar 29 16:30:33 2003 UTC (21 years, 8 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	LIBUKCPROG_1_0_2, LIBUKCPROG_1_0_1, LIBUKCPROG_1_0, HEAD
Log Message:	libukcprog is now a seperate package. I doubt this will be much use to anyone other than us, but I see no reason why we can't package it up and distribute it. Obviously we can't attach the GPL to this, as we don't own it.
#	User	Rev	Content
1	tdb	1.1	/* errf.c -- formatted error messages */
2
3			/* Copyright 1992 Godfrey Paul, University of Kent at Canterbury.
4			*
5			* You can do what you like with this source code as long as
6			* you don't try to make money out of it and you include an
7			* unaltered copy of this message (including the copyright).
8			*/
9
10			char ukcprog_errf_sccsid[] = "$Id: errf.c,v 1.16 1995/11/26 16:05:56 mtr Exp $ UKC";
11
12			#ifdef __STDC__
13			#include <stdarg.h>
14			#else
15			#include <varargs.h>
16			#endif
17
18			#include <stdio.h>
19			#include <stdlib.h>
20			#include <string.h>
21
22			#include "ukcprog.h"
23
24			static const char munge_progname PROTO((const char ));
25			static void default_ofunc PROTO((const char *str));
26
27			static errf_ofunc_t User_errf_ofunc = default_ofunc;
28			static const char *Output_prefix = "";
29			static char *Progname = NULL;
30
31			static void
32			default_ofunc(str)
33			const char *str;
34			{
35			fprintf(stderr, "%s%s\n", Output_prefix, str);
36			fflush(stderr);
37			}
38
39			errf_ofunc_t
40			errf_set_ofunc(func)
41			errf_ofunc_t func;
42			{
43			errf_ofunc_t old;
44
45			if (func == NULL)
46			func = default_ofunc;
47
48			old = User_errf_ofunc;
49			User_errf_ofunc = func;
50
51			return old;
52			}
53
54
55			/* errf_set_prefix()
56			* Sets the string that errf() prefixes to messages.
57			* Returns the old one.
58			*/
59			const char *
60			errf_set_prefix(prefix)
61			const char *prefix;
62			{
63			const char *old;
64
65			old = Output_prefix;
66			Output_prefix = prefix;
67
68			return old;
69			}
70
71
72			/* errf_get_prefix()
73			* Return the current prefix.
74			*/
75			const char *
76			errf_get_prefix()
77			{
78			return Output_prefix;
79			}
80
81
82			static const char *
83			munge_progname(progname)
84			const char *progname;
85			{
86			#ifdef VMS
87			const char name, dot;
88			char *s;
89			int i;
90
91			if ((name = strrchr(progname, ']')) == NULL)
92			name = progname;
93			else
94			++name;
95
96			if ((dot = strchr(name, '.')) == NULL)
97			dot = name + strlen(name);
98
99			s = strf("%.*s", dot - name, name);
100
101			for (i = 0; i < dot - name; ++i)
102			s[i] = toupper(s[i]);
103
104			if (Progname != NULL)
105			free(Progname);
106
107			Progname = s;
108
109			return "%%%s, ";
110			#else
111			#ifdef MSDOS
112			const char *name;
113
114			if ((name = strrchr(progname, '\\')) == NULL)
115			name = progname;
116
117			else
118			++name;
119
120			if (Progname != NULL)
121			free(Progname);
122
123			Progname = strsave(name);
124
125			return "%s: ";
126			#else
127			/* Everything is assumed to be some variant of Unix.
128			*/
129			const char *name;
130
131			if ((name = strrchr(progname, '/')) == NULL)
132			name = progname;
133
134			else
135			++name;
136
137			if (Progname != NULL)
138			free(Progname);
139
140			Progname = strsave(name);
141
142			return "%s: ";
143			#endif /* !MSDOS */
144			#endif /* !VMS */
145			}
146
147
148			/* errf_set_progname()
149			* Convenience routine to set the errf prefix to include the progname.
150			*/
151			void
152			errf_set_progname(name)
153			const char *name;
154			{
155			const char *fmt;
156
157			fmt = munge_progname(name);
158			errf_set_prefix(strf(fmt, Progname));
159			}
160
161
162			/* errf_get_progname()
163			*/
164			const char *
165			errf_get_progname()
166			{
167			return Progname;
168			}
169
170
171			#ifdef __STDC__
172			void
173			errf(const char *fmt, ...)
174			{
175
176			#else /* !__STDC__ */
177			void
178			errf(va_alist)
179			va_dcl
180			{
181			char *fmt;
182			#endif /* !__STDC__ */
183			va_list args;
184			char buffer[100];
185			char *s;
186
187			#ifdef __STDC__
188			va_start(args, fmt);
189			#else
190			va_start(args);
191			fmt = va_arg(args, char *);
192			#endif
193
194			s = formf(buffer, sizeof(buffer), fmt, args);
195
196			va_end(args);
197
198			(*User_errf_ofunc)(s);
199
200			if (s != buffer) /* must have been obtained from malloc */
201			free(s);
202			}
203
204
205			/* errf_usage()
206			* Output a usage string prefixed by the program name and exit(1).
207			*/
208			void
209			errf_usage(usage)
210			const char *usage;
211			{
212			if (User_errf_ofunc != default_ofunc)
213			(*User_errf_ofunc)(strf("Usage: %s %s", Progname, usage));
214			else
215			fprintf(stderr, "Usage: %s %s\n", Progname, usage);
216			exit(1);
217			}