ihost/libukcprog/formf.c

/*  formf.c -- formatted strings and 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_formf_sccsid[] = "$Id: formf.c,v 1.1 2002/03/08 14:37:29 tdb Exp $ UKC";

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

#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#ifndef __STDC__
#include <memory.h>
#endif

#include "ukcprog.h"

#ifndef MSDOS
#ifndef __FreeBSD__
#ifndef linux
extern int sys_nerr, errno;
extern char *sys_errlist[];
#endif /* !linux */
#endif /* !__FreeBSD__ */
#endif /* !MSDOS */


/* forward declarations */
static void new_buffer PROTO((char ** p_buf, int *p_lim, bool *p_from_malloc));
static void concat PROTO((char **p_buf, int *p_pos, int* p_lim,
                                bool *p_from_malloc, const char *str, int len));
static char *long_to_ascii PROTO((unsigned long unum, int base,
                                                bool want_uppercase));
static char *float_to_ascii PROTO((double d, int precision));
static char *efloat_to_ascii PROTO((double d, int precision,
                                                bool want_uppercase));
static char *gfloat_to_ascii PROTO((double d, int precision,
                                                bool want_uppercase));

#define MAX_NUM_LEN     40      /* buffer sizes used in numeric conversions */
#define MAX_FLOAT_LEN   128


/*
 *  new_buffer()
 *  Reallocate the given buffer to twice its current size.  *p_lim is the
 *  last usable character in the buffer.  The buffer passed in might
 *  not have been allocated by malloc(); this is indicated by *p_from_malloc.
 */
static void
new_buffer(p_buf, p_lim, p_from_malloc)
char **p_buf;
int *p_lim;
bool *p_from_malloc;
{
        char *new;
        size_t size;

        size = *p_lim + 1;

        if (*p_from_malloc)
                new = realloc(*p_buf, size * 2);

        else {
                if ((new = malloc(size * 2)) != NULL)
                        memcpy(new, *p_buf, size);
                *p_from_malloc = TRUE;
        }

        if (new == NULL)
                panic("malloc returned NULL in new_buffer");

        *p_buf = new;
        *p_lim = (size * 2) - 1;
}


/*
 *  concat()
 *  Add exactly len bytes of str to the buffer, expanding it with
 *  new_buffer() if we need extra space.  Str must be at least len
 *  bytes long.
 */
static void
concat(p_buf, p_pos, p_lim, p_from_malloc, str, len)
char **p_buf;
int *p_pos, *p_lim;
bool *p_from_malloc;
const char *str;
int len;
{
        while (*p_lim - *p_pos < len)
                new_buffer(p_buf, p_lim, p_from_malloc);

        memcpy(&(*p_buf)[*p_pos], str, (size_t)len);
        *p_pos += len;
}


static char *
long_to_ascii(unum, base, want_uppercase)
unsigned long unum;
int base;
bool want_uppercase;
{
        static char nbuf[MAX_NUM_LEN + 1];
        char *s;
        const char *digs;

        s = nbuf + MAX_NUM_LEN;

        digs = want_uppercase ? "0123456789ABCDEF" : "0123456789abcdef";
        do {
                *--s = digs[unum % base];
                unum /= base;
        } while (unum != 0);


        return s;
}


static char *
float_to_ascii(d, precision)
double d;
int precision;
{
        static char buf[MAX_FLOAT_LEN];

        sprintf(buf, "%.*f", precision, d);
        return buf;
}


static char *
efloat_to_ascii(d, precision, want_uppercase)
double d;
int precision;
bool want_uppercase;
{
        static char buf[MAX_FLOAT_LEN];
        const char *format;

        if (want_uppercase)
                format = "%.*E";
        else
                format = "%.*e";

        sprintf(buf, format, precision, d);
        return buf;
}


static char *
gfloat_to_ascii(d, precision, want_uppercase)
double d;
int precision;
bool want_uppercase;
{
        static char buf[MAX_FLOAT_LEN];
        const char *format;

        if (want_uppercase)
                format = "%.*G";
        else
                format = "%.*g";

        sprintf(buf, format, precision, d);
        return buf;
}

#ifdef VMS
static const char *
vms_error_text(unsigned long msgid)
{
        unsigned long status;
        unsigned short msglen;
        static char buf[256 + 1];
        static struct dsc$descriptor_s msg = {
                sizeof buf - 1,         /* length */
                DSC$K_DTYPE_T,          /* data type (8 bit chars) */
                DSC$K_CLASS_S,          /* class (fixed length) */
                buf
        };

        status = SYS$GETMSG(msgid, &msglen, &msg, 0, 0);
        if (status != SS$_NORMAL && status != SS$_MSGNOTFND)
                sprintf(buf, "Unknown VMS message ID 0x%x", msgid);
        else
                buf[msglen] = '\0';

        return buf;
}
#endif /* VMS */

/*
 *  formf()
 *  Returns a pointer to a string formatted from the arguments given.
 *  If the string has been obtained from malloc(), the return value will
 *  be different to the buffer pased in; it is the caller's responsibility
 *  to free() this when no longer required.
 */
char *
formf(buffer_space, buffer_size, format, args)
char *buffer_space;
int buffer_size;
const char *format;
va_list args;
{
        bool left_justify, print_sign, zero_pad, alternate_form;
        bool is_negative, precision_given, want_uppercase, from_malloc;
        int min_field_width, precision, modifier, base, pos, lim, len;
        const char *fmt, *alternate_prefix, *s;
        char *buf, str[2], errno_buffer[42];
        int alternate_size, saved_errno;
        unsigned long u;
        long i;
        int *ip;
        double d;

        saved_errno = errno;    /* for use later in %m format */

        /*
         *  The formatted string is prepared in a buffer pointed to by buf.
         *  This starts out pointing to a buffer passed in as an argument,
         *  but if this fills, a new one is obtained from malloc().
         *  Pos is the index of the position for the *next* character
         *  in the output string, and lim is the index of the last
         *  usable character.
         */
        from_malloc = FALSE;
        buf = buffer_space;
        lim = buffer_size - 1;
        pos = 0;
        fmt = format;

        for (;;) {
                min_field_width = 0;
                precision_given = FALSE;
                precision = 0;
                modifier = 0;
                left_justify = FALSE;
                print_sign = FALSE;
                zero_pad = FALSE;
                alternate_form = FALSE;

                /*  Find next argument for conversion */
                while (*fmt != '\0' && *fmt != '%') {
                        if (pos == lim)
                                new_buffer(&buf, &lim, &from_malloc);

                        buf[pos++] = *fmt++;
                }

                if (*fmt == '\0') {
                        buf[pos] = '\0';
                        return buf;     /* end of format string */
                }

                /* flags, in any order */
                for (;;) {
                        if (*++fmt == '\0')
                                panic("confused format flags in formf");

                        if (*fmt == '-')
                                left_justify = TRUE;

                        else if (*fmt == '+')
                                print_sign = TRUE;

                        else if (*fmt == '0')
                                zero_pad = TRUE;

                        else if (*fmt == '#')
                                alternate_form = TRUE;
                        
                        else
                                break;  /* end of flags */

                }

                /* minimum field width */
                if (*fmt == '*') {
                        min_field_width = va_arg(args, int);
                        ++fmt;
                } else
                        while (isdigit(*fmt)) {
                                min_field_width *= 10;
                                min_field_width += *fmt - '0';
                                ++fmt;
                        }
                
                if (*fmt == '.') {

                        /* precision */
                        if (*++fmt == '*') {
                                precision_given = TRUE;
                                precision = va_arg(args, int);
                                ++fmt;
                        } else if (isdigit(*fmt)) {
                                precision_given = TRUE;
                                precision = 0;
                                do {
                                        precision *= 10;
                                        precision += *fmt - '0';
                                        ++fmt;
                                } while (isdigit(*fmt));
                        }
                }

                if (strchr("hlL", *fmt) != NULL)
                        modifier = *fmt++;

                want_uppercase = TRUE;
                alternate_prefix = "0X";
                alternate_size = 2;
                is_negative = FALSE;

                switch (*fmt) {
                        case 'd':
                        case 'i':
                                if (modifier == 'h')
                                        i = va_arg(args, short);
                                else if (modifier == 'l')
                                        i = va_arg(args, long);
                                else
                                        i = va_arg(args, int);
                                is_negative = i < 0;
                                u = is_negative ? -i : i;
                                s = long_to_ascii(u, 10, want_uppercase);
                                break;

                        case 'o':
                                base = 8;
                                alternate_prefix = "0";
                                alternate_size = 1;
                                goto gencase;
                        case 'p':
                                alternate_prefix = "0x";
                                alternate_size = 2;
                                want_uppercase = FALSE;
                                base = 16;
                                print_sign = FALSE;
                                u = (unsigned long)va_arg(args, char *);
                                s = long_to_ascii(u, base, want_uppercase);
#ifdef MSDOS
                                /*  The traditional format for pointers on
                                 *  MSDOS is segment:offset.  NOTE: we depend
                                 *  on long_to_ascii() returning a buffer with
                                 *  space before the beginning.
                                 */
                                if ((len = strlen(s)) <= 8) {
                                        s -= 8 - len;
                                        memset(s, '0', 8 - len);

                                        --s;
                                        memmove(s, s + 1, 4);
                                        s[4] = ':';
                                }
#endif
                                break;
                        case 'x':
                                alternate_prefix = "0x";
                                alternate_size = 2;
                                want_uppercase = FALSE;
                                /* fall through */;
                        case 'X':
                                base = 16;
                                goto gencase;
                        case 'u':
                                base = 10;
gencase:                        if (modifier == 'h')
                                        u = va_arg(args, short);
                                else if (modifier == 'l')
                                        u = va_arg(args, long);
                                else
                                        u = va_arg(args, int);
                                s = long_to_ascii(u, base, want_uppercase);
                                break;

                        case 'c':
                                str[0] = (char)va_arg(args, int);  /* promoted char */
                                str[1] = '\0';
                                s = str;
                                print_sign = FALSE;
                                break;

                        case '%':
                                str[0] = '%';
                                str[1] = '\0';
                                s = str;
                                print_sign = FALSE;
                                break;

                        case 's':
                                s = va_arg(args, char *);
                                if (s == NULL)
                                        panic("null pointer for %s in formf");
                                print_sign = FALSE;
                                break;
                        case 'm':
                                if (saved_errno < 0 || saved_errno > sys_nerr ||
                                            *sys_errlist[saved_errno] == '\0') {
                                        sprintf(errno_buffer,
                                                "errno %d out of range",
                                                                saved_errno);
                                        s = errno_buffer;
                                } else
                                        s = sys_errlist[saved_errno];
                                print_sign = FALSE;
                                break;
#ifdef VMS
                        case 'M':
                                s = vms_error_text(va_arg(args, unsigned));
                                print_sign = FALSE;
                                break;
#endif /* VMS */
                        case 'f':
                                d = va_arg(args, double);
                                is_negative = d < 0.0;
                                if (is_negative)
                                        d = -d;
                                if (!precision_given)
                                        precision = 6;  /* from K&R */
                                s = float_to_ascii(d, precision);
                                break;
                        case 'e':
                                want_uppercase = FALSE; /* fall through */
                        case 'E':
                                d = va_arg(args, double);
                                is_negative = d < 0.0;
                                if (is_negative)
                                        d = -d;
                                if (!precision_given)
                                        precision = 6;  /* from K&R */
                                s = efloat_to_ascii(d, precision,
                                                        want_uppercase);
                                break;
                        case 'g':
                                want_uppercase = FALSE; /* fall through */
                        case 'G':
                                d = va_arg(args, double);
                                is_negative = d < 0.0;
                                if (is_negative)
                                        d = -d;
                                if (!precision_given)
                                        precision = 6;  /* from K&R */
                                s = gfloat_to_ascii(d, precision,
                                                        want_uppercase);
                                break;
                        case 'n':
                                ip = va_arg(args, int *);
                                *ip = pos;

                                ++fmt;  /* step over format character */
                                continue;
                        
                        default:
                                panic("illegal format in formf");
                                s = NULL;       /* to satisfy gcc */
                                break;
                }

                len = strlen(s);

                /* truncate strings if requested */
                if ((*fmt == 's' || *fmt == 'm')
                                && precision_given && precision < len)
                        len = precision;

                if (!left_justify) {
                        const char *fillch_str = zero_pad ? "0" : " ";

                        if ((is_negative || print_sign) && zero_pad) {
                                concat(&buf, &pos, &lim, &from_malloc,
                                       is_negative ? "-" : "+", 1);
                                is_negative = print_sign = FALSE;
                                --min_field_width;
                        }

                        if (alternate_form && alternate_prefix != NULL) {
                                concat(&buf, &pos, &lim, &from_malloc,
                                        alternate_prefix, alternate_size);
                                min_field_width -= alternate_size;
                                alternate_form = FALSE;
                        }

                        while (len < min_field_width) {
                                concat(&buf, &pos, &lim, &from_malloc,
                                                                fillch_str, 1);
                                --min_field_width;
                        }
                }

                if (is_negative || print_sign) {
                        concat(&buf, &pos, &lim, &from_malloc,
                               is_negative ? "-" : "+", 1);
                        --min_field_width;
                }

                if (alternate_form && alternate_prefix != NULL) {
                        concat(&buf, &pos, &lim, &from_malloc,
                                        alternate_prefix, alternate_size);
                        min_field_width -= alternate_size;
                }

                
                concat(&buf, &pos, &lim, &from_malloc, s, len);
                min_field_width -= len;

                if (left_justify) {
                        while (min_field_width > 0) {
                                concat(&buf, &pos, &lim, &from_malloc, " ", 1);
                                --min_field_width;
                        }
                }

                ++fmt;  /* step over format character */
        }
}
Revision:	1.2
Committed:	Sat Mar 29 18:05:09 2003 UTC (21 years, 8 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+1 -1 lines
State:	*FILE REMOVED*
Log Message:	ihost now makes use of an external copy of libukcprog. This is available as a seperate download. All files updated accordingly to make this version 1.5.4.
#	User	Rev	Content
1	tdb	1.1	/* formf.c -- formatted strings and 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	tdb	1.2	char ukcprog_formf_sccsid[] = "$Id: formf.c,v 1.1 2002/03/08 14:37:29 tdb Exp $ UKC";
11	tdb	1.1
12			#ifdef __STDC__
13			#include <stdarg.h>
14			#else
15			#include <varargs.h>
16			#endif
17
18			#include <stdio.h>
19			#include <ctype.h>
20			#include <errno.h>
21			#include <stdlib.h>
22			#include <string.h>
23			#ifndef __STDC__
24			#include <memory.h>
25			#endif
26
27			#include "ukcprog.h"
28
29			#ifndef MSDOS
30			#ifndef __FreeBSD__
31			#ifndef linux
32			extern int sys_nerr, errno;
33			extern char *sys_errlist[];
34			#endif /* !linux */
35			#endif /* !__FreeBSD__ */
36			#endif /* !MSDOS */
37
38
39			/* forward declarations */
40			static void new_buffer PROTO((char ** p_buf, int p_lim, bool p_from_malloc));
41			static void concat PROTO((char *p_buf, int p_pos, int* p_lim,
42			bool p_from_malloc, const char str, int len));
43			static char *long_to_ascii PROTO((unsigned long unum, int base,
44			bool want_uppercase));
45			static char *float_to_ascii PROTO((double d, int precision));
46			static char *efloat_to_ascii PROTO((double d, int precision,
47			bool want_uppercase));
48			static char *gfloat_to_ascii PROTO((double d, int precision,
49			bool want_uppercase));
50
51			#define MAX_NUM_LEN 40 /* buffer sizes used in numeric conversions */
52			#define MAX_FLOAT_LEN 128
53
54
55			/*
56			* new_buffer()
57			* Reallocate the given buffer to twice its current size. *p_lim is the
58			* last usable character in the buffer. The buffer passed in might
59			* not have been allocated by malloc(); this is indicated by *p_from_malloc.
60			*/
61			static void
62			new_buffer(p_buf, p_lim, p_from_malloc)
63			char **p_buf;
64			int *p_lim;
65			bool *p_from_malloc;
66			{
67			char *new;
68			size_t size;
69
70			size = *p_lim + 1;
71
72			if (*p_from_malloc)
73			new = realloc(p_buf, size 2);
74
75			else {
76			if ((new = malloc(size * 2)) != NULL)
77			memcpy(new, *p_buf, size);
78			*p_from_malloc = TRUE;
79			}
80
81			if (new == NULL)
82			panic("malloc returned NULL in new_buffer");
83
84			*p_buf = new;
85			p_lim = (size 2) - 1;
86			}
87
88
89			/*
90			* concat()
91			* Add exactly len bytes of str to the buffer, expanding it with
92			* new_buffer() if we need extra space. Str must be at least len
93			* bytes long.
94			*/
95			static void
96			concat(p_buf, p_pos, p_lim, p_from_malloc, str, len)
97			char **p_buf;
98			int p_pos, p_lim;
99			bool *p_from_malloc;
100			const char *str;
101			int len;
102			{
103			while (p_lim - p_pos < len)
104			new_buffer(p_buf, p_lim, p_from_malloc);
105
106			memcpy(&(p_buf)[p_pos], str, (size_t)len);
107			*p_pos += len;
108			}
109
110
111			static char *
112			long_to_ascii(unum, base, want_uppercase)
113			unsigned long unum;
114			int base;
115			bool want_uppercase;
116			{
117			static char nbuf[MAX_NUM_LEN + 1];
118			char *s;
119			const char *digs;
120
121			s = nbuf + MAX_NUM_LEN;
122
123			digs = want_uppercase ? "0123456789ABCDEF" : "0123456789abcdef";
124			do {
125			*--s = digs[unum % base];
126			unum /= base;
127			} while (unum != 0);
128
129
130			return s;
131			}
132
133
134			static char *
135			float_to_ascii(d, precision)
136			double d;
137			int precision;
138			{
139			static char buf[MAX_FLOAT_LEN];
140
141			sprintf(buf, "%.*f", precision, d);
142			return buf;
143			}
144
145
146			static char *
147			efloat_to_ascii(d, precision, want_uppercase)
148			double d;
149			int precision;
150			bool want_uppercase;
151			{
152			static char buf[MAX_FLOAT_LEN];
153			const char *format;
154
155			if (want_uppercase)
156			format = "%.*E";
157			else
158			format = "%.*e";
159
160			sprintf(buf, format, precision, d);
161			return buf;
162			}
163
164
165
166			static char *
167			gfloat_to_ascii(d, precision, want_uppercase)
168			double d;
169			int precision;
170			bool want_uppercase;
171			{
172			static char buf[MAX_FLOAT_LEN];
173			const char *format;
174
175			if (want_uppercase)
176			format = "%.*G";
177			else
178			format = "%.*g";
179
180			sprintf(buf, format, precision, d);
181			return buf;
182			}
183
184			#ifdef VMS
185			static const char *
186			vms_error_text(unsigned long msgid)
187			{
188			unsigned long status;
189			unsigned short msglen;
190			static char buf[256 + 1];
191			static struct dsc$descriptor_s msg = {
192			sizeof buf - 1, /* length */
193			DSC$K_DTYPE_T, /* data type (8 bit chars) */
194			DSC$K_CLASS_S, /* class (fixed length) */
195			buf
196			};
197
198			status = SYS$GETMSG(msgid, &msglen, &msg, 0, 0);
199			if (status != SS$_NORMAL && status != SS$_MSGNOTFND)
200			sprintf(buf, "Unknown VMS message ID 0x%x", msgid);
201			else
202			buf[msglen] = '\0';
203
204			return buf;
205			}
206			#endif /* VMS */
207
208			/*
209			* formf()
210			* Returns a pointer to a string formatted from the arguments given.
211			* If the string has been obtained from malloc(), the return value will
212			* be different to the buffer pased in; it is the caller's responsibility
213			* to free() this when no longer required.
214			*/
215			char *
216			formf(buffer_space, buffer_size, format, args)
217			char *buffer_space;
218			int buffer_size;
219			const char *format;
220			va_list args;
221			{
222			bool left_justify, print_sign, zero_pad, alternate_form;
223			bool is_negative, precision_given, want_uppercase, from_malloc;
224			int min_field_width, precision, modifier, base, pos, lim, len;
225			const char fmt, alternate_prefix, *s;
226			char *buf, str[2], errno_buffer[42];
227			int alternate_size, saved_errno;
228			unsigned long u;
229			long i;
230			int *ip;
231			double d;
232
233			saved_errno = errno; /* for use later in %m format */
234
235			/*
236			* The formatted string is prepared in a buffer pointed to by buf.
237			* This starts out pointing to a buffer passed in as an argument,
238			* but if this fills, a new one is obtained from malloc().
239			* Pos is the index of the position for the next character
240			* in the output string, and lim is the index of the last
241			* usable character.
242			*/
243			from_malloc = FALSE;
244			buf = buffer_space;
245			lim = buffer_size - 1;
246			pos = 0;
247			fmt = format;
248
249			for (;;) {
250			min_field_width = 0;
251			precision_given = FALSE;
252			precision = 0;
253			modifier = 0;
254			left_justify = FALSE;
255			print_sign = FALSE;
256			zero_pad = FALSE;
257			alternate_form = FALSE;
258
259			/* Find next argument for conversion */
260			while (fmt != '\0' && fmt != '%') {
261			if (pos == lim)
262			new_buffer(&buf, &lim, &from_malloc);
263
264			buf[pos++] = *fmt++;
265			}
266
267			if (*fmt == '\0') {
268			buf[pos] = '\0';
269			return buf; /* end of format string */
270			}
271
272			/* flags, in any order */
273			for (;;) {
274			if (*++fmt == '\0')
275			panic("confused format flags in formf");
276
277			if (*fmt == '-')
278			left_justify = TRUE;
279
280			else if (*fmt == '+')
281			print_sign = TRUE;
282
283			else if (*fmt == '0')
284			zero_pad = TRUE;
285
286			else if (*fmt == '#')
287			alternate_form = TRUE;
288
289			else
290			break; /* end of flags */
291
292			}
293
294			/* minimum field width */
295			if (fmt == '') {
296			min_field_width = va_arg(args, int);
297			++fmt;
298			} else
299			while (isdigit(*fmt)) {
300			min_field_width *= 10;
301			min_field_width += *fmt - '0';
302			++fmt;
303			}
304
305			if (*fmt == '.') {
306
307			/* precision */
308			if (++fmt == '') {
309			precision_given = TRUE;
310			precision = va_arg(args, int);
311			++fmt;
312			} else if (isdigit(*fmt)) {
313			precision_given = TRUE;
314			precision = 0;
315			do {
316			precision *= 10;
317			precision += *fmt - '0';
318			++fmt;
319			} while (isdigit(*fmt));
320			}
321			}
322
323			if (strchr("hlL", *fmt) != NULL)
324			modifier = *fmt++;
325
326			want_uppercase = TRUE;
327			alternate_prefix = "0X";
328			alternate_size = 2;
329			is_negative = FALSE;
330
331			switch (*fmt) {
332			case 'd':
333			case 'i':
334			if (modifier == 'h')
335			i = va_arg(args, short);
336			else if (modifier == 'l')
337			i = va_arg(args, long);
338			else
339			i = va_arg(args, int);
340			is_negative = i < 0;
341			u = is_negative ? -i : i;
342			s = long_to_ascii(u, 10, want_uppercase);
343			break;
344
345			case 'o':
346			base = 8;
347			alternate_prefix = "0";
348			alternate_size = 1;
349			goto gencase;
350			case 'p':
351			alternate_prefix = "0x";
352			alternate_size = 2;
353			want_uppercase = FALSE;
354			base = 16;
355			print_sign = FALSE;
356			u = (unsigned long)va_arg(args, char *);
357			s = long_to_ascii(u, base, want_uppercase);
358			#ifdef MSDOS
359			/* The traditional format for pointers on
360			* MSDOS is segment:offset. NOTE: we depend
361			* on long_to_ascii() returning a buffer with
362			* space before the beginning.
363			*/
364			if ((len = strlen(s)) <= 8) {
365			s -= 8 - len;
366			memset(s, '0', 8 - len);
367
368			--s;
369			memmove(s, s + 1, 4);
370			s[4] = ':';
371			}
372			#endif
373			break;
374			case 'x':
375			alternate_prefix = "0x";
376			alternate_size = 2;
377			want_uppercase = FALSE;
378			/* fall through */;
379			case 'X':
380			base = 16;
381			goto gencase;
382			case 'u':
383			base = 10;
384			gencase: if (modifier == 'h')
385			u = va_arg(args, short);
386			else if (modifier == 'l')
387			u = va_arg(args, long);
388			else
389			u = va_arg(args, int);
390			s = long_to_ascii(u, base, want_uppercase);
391			break;
392
393			case 'c':
394			str[0] = (char)va_arg(args, int); /* promoted char */
395			str[1] = '\0';
396			s = str;
397			print_sign = FALSE;
398			break;
399
400			case '%':
401			str[0] = '%';
402			str[1] = '\0';
403			s = str;
404			print_sign = FALSE;
405			break;
406
407			case 's':
408			s = va_arg(args, char *);
409			if (s == NULL)
410			panic("null pointer for %s in formf");
411			print_sign = FALSE;
412			break;
413			case 'm':
414			if (saved_errno < 0 \|\| saved_errno > sys_nerr \|\|
415			*sys_errlist[saved_errno] == '\0') {
416			sprintf(errno_buffer,
417			"errno %d out of range",
418			saved_errno);
419			s = errno_buffer;
420			} else
421			s = sys_errlist[saved_errno];
422			print_sign = FALSE;
423			break;
424			#ifdef VMS
425			case 'M':
426			s = vms_error_text(va_arg(args, unsigned));
427			print_sign = FALSE;
428			break;
429			#endif /* VMS */
430			case 'f':
431			d = va_arg(args, double);
432			is_negative = d < 0.0;
433			if (is_negative)
434			d = -d;
435			if (!precision_given)
436			precision = 6; /* from K&R */
437			s = float_to_ascii(d, precision);
438			break;
439			case 'e':
440			want_uppercase = FALSE; /* fall through */
441			case 'E':
442			d = va_arg(args, double);
443			is_negative = d < 0.0;
444			if (is_negative)
445			d = -d;
446			if (!precision_given)
447			precision = 6; /* from K&R */
448			s = efloat_to_ascii(d, precision,
449			want_uppercase);
450			break;
451			case 'g':
452			want_uppercase = FALSE; /* fall through */
453			case 'G':
454			d = va_arg(args, double);
455			is_negative = d < 0.0;
456			if (is_negative)
457			d = -d;
458			if (!precision_given)
459			precision = 6; /* from K&R */
460			s = gfloat_to_ascii(d, precision,
461			want_uppercase);
462			break;
463			case 'n':
464			ip = va_arg(args, int *);
465			*ip = pos;
466
467			++fmt; /* step over format character */
468			continue;
469
470			default:
471			panic("illegal format in formf");
472			s = NULL; /* to satisfy gcc */
473			break;
474			}
475
476			len = strlen(s);
477
478			/* truncate strings if requested */
479			if ((fmt == 's' \|\| fmt == 'm')
480			&& precision_given && precision < len)
481			len = precision;
482
483			if (!left_justify) {
484			const char *fillch_str = zero_pad ? "0" : " ";
485
486			if ((is_negative \|\| print_sign) && zero_pad) {
487			concat(&buf, &pos, &lim, &from_malloc,
488			is_negative ? "-" : "+", 1);
489			is_negative = print_sign = FALSE;
490			--min_field_width;
491			}
492
493			if (alternate_form && alternate_prefix != NULL) {
494			concat(&buf, &pos, &lim, &from_malloc,
495			alternate_prefix, alternate_size);
496			min_field_width -= alternate_size;
497			alternate_form = FALSE;
498			}
499
500			while (len < min_field_width) {
501			concat(&buf, &pos, &lim, &from_malloc,
502			fillch_str, 1);
503			--min_field_width;
504			}
505			}
506
507			if (is_negative \|\| print_sign) {
508			concat(&buf, &pos, &lim, &from_malloc,
509			is_negative ? "-" : "+", 1);
510			--min_field_width;
511			}
512
513			if (alternate_form && alternate_prefix != NULL) {
514			concat(&buf, &pos, &lim, &from_malloc,
515			alternate_prefix, alternate_size);
516			min_field_width -= alternate_size;
517			}
518
519
520			concat(&buf, &pos, &lim, &from_malloc, s, len);
521			min_field_width -= len;
522
523			if (left_justify) {
524			while (min_field_width > 0) {
525			concat(&buf, &pos, &lim, &from_malloc, " ", 1);
526			--min_field_width;
527			}
528			}
529
530			++fmt; /* step over format character */
531			}
532			}