FreeCalypso > hg > freecalypso-tools
view rvinterf/ctracedec/doprnt.c @ 407:19e5a3e2f9c0
fcup-settime: moved time() retrieval a little closer to the output
A fundamental problem with all simple time transfer tools is that there is
always some delay between the time retrieval on the source system and that
transmitted time being set on the destination, and the resulting time
on the destination system is off by that delay amount. This delay cannot
be fully eliminated when working in a simple environment like ours,
but we should make our best effort to minimize it. In the present case,
moving the atinterf_init() call before the time() retrieval should make
a teensy-tiny improvement.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sat, 11 Aug 2018 21:52:17 +0000 |
parents | e7502631a0f9 |
children |
line wrap: on
line source
/* * We need our own implementation of an sprintf-like function in order * to expand compressed traces with format strings from str2ind.tab * and parameters decoded from the serial byte stream. This module is * a hacked-up version of the guts of the printf family of functions * from 4.3BSD-Tahoe. */ #include <sys/types.h> #include <ctype.h> #include <string.h> #include <strings.h> static void safe_out_char(c, pp) int c; char **pp; { char *dp; c &= 0xFF; dp = *pp; if (c & 0x80) { *dp++ = 'M'; *dp++ = '-'; c &= 0x7F; } if (c < 0x20) { *dp++ = '^'; *dp++ = c + '@'; } else if (c == 0x7F) { *dp++ = '^'; *dp++ = '?'; } else *dp++ = c; *pp = dp; } #define PUTC(ch) safe_out_char((ch), &outp) #define ARG() \ _ulong = *argp++; #define BUF 12 #define todigit(c) ((c) - '0') #define tochar(n) ((n) + '0') #define LONGINT 0x01 /* long integer */ #define LONGDBL 0x02 /* long double; unimplemented */ #define SHORTINT 0x04 /* short integer */ #define ALT 0x08 /* alternate form */ #define LADJUST 0x10 /* left adjustment */ #define ZEROPAD 0x20 /* zero (as opposed to blank) pad */ #define HEXPREFIX 0x40 /* add 0x or 0X prefix */ ind2str_doprnt(fmt0, argp, outp) u_char *fmt0, *outp; u_long *argp; { register u_char *fmt; /* format string */ register int ch; /* character from fmt */ register int cnt; /* return value accumulator */ register int n; /* random handy integer */ register char *t; /* buffer pointer */ u_long _ulong; /* integer arguments %[diouxX] */ int base; /* base for [diouxX] conversion */ int dprec; /* decimal precision in [diouxX] */ int fieldsz; /* field size expanded by sign, etc */ int flags; /* flags as above */ int prec; /* precision from format (%.3d), or -1 */ int realsz; /* field size expanded by decimal precision */ int size; /* size of converted field or string */ int width; /* width from format (%8d), or 0 */ char sign; /* sign prefix (' ', '+', '-', or \0) */ char softsign; /* temporary negative sign for floats */ char *digs; /* digits for [diouxX] conversion */ char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */ fmt = fmt0; digs = "0123456789abcdef"; for (cnt = 0;; ++fmt) { for (; (ch = *fmt) && ch != '%'; ++cnt, ++fmt) PUTC(ch); if (!ch) { *outp = '\0'; return (cnt); } flags = 0; dprec = 0; width = 0; prec = -1; sign = '\0'; rflag: switch (*++fmt) { case ' ': /* * ``If the space and + flags both appear, the space * flag will be ignored.'' * -- ANSI X3J11 */ if (!sign) sign = ' '; goto rflag; case '#': flags |= ALT; goto rflag; case '*': /* * ``A negative field width argument is taken as a * - flag followed by a positive field width.'' * -- ANSI X3J11 * They don't exclude field widths read from args. */ if ((width = *argp++) >= 0) goto rflag; width = -width; /* FALLTHROUGH */ case '-': flags |= LADJUST; goto rflag; case '+': sign = '+'; goto rflag; case '.': if (*++fmt == '*') n = *argp++; else { n = 0; while (isascii(*fmt) && isdigit(*fmt)) n = 10 * n + todigit(*fmt++); --fmt; } prec = n < 0 ? -1 : n; goto rflag; case '0': /* * ``Note that 0 is taken as a flag, not as the * beginning of a field width.'' * -- ANSI X3J11 */ flags |= ZEROPAD; goto rflag; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': n = 0; do { n = 10 * n + todigit(*fmt); } while (isascii(*++fmt) && isdigit(*fmt)); width = n; --fmt; goto rflag; case 'L': flags |= LONGDBL; goto rflag; case 'h': flags |= SHORTINT; goto rflag; case 'l': flags |= LONGINT; goto rflag; case 'c': *(t = buf) = *argp++; size = 1; sign = '\0'; goto pforw; case 'D': flags |= LONGINT; /*FALLTHROUGH*/ case 'd': case 'i': ARG(); if ((long)_ulong < 0) { _ulong = -_ulong; sign = '-'; } base = 10; goto number; case 'O': flags |= LONGINT; /*FALLTHROUGH*/ case 'o': ARG(); base = 8; goto nosign; case 'p': /* * ``The argument shall be a pointer to void. The * value of the pointer is converted to a sequence * of printable characters, in an implementation- * defined manner.'' * -- ANSI X3J11 */ /* NOSTRICT */ _ulong = *argp++; base = 16; goto nosign; case 's': if (!(t = (char *)*argp++)) t = "(null)"; if (prec >= 0) { /* * can't use strlen; can only look for the * NUL in the first `prec' characters, and * strlen() will go further. */ char *p; for (p = t, size = 0; size < prec; p++, size++) if (*p == '\0') break; } else size = strlen(t); sign = '\0'; goto pforw; case 'U': flags |= LONGINT; /*FALLTHROUGH*/ case 'u': ARG(); base = 10; goto nosign; case 'X': digs = "0123456789ABCDEF"; /* FALLTHROUGH */ case 'x': ARG(); base = 16; /* leading 0x/X only if non-zero */ if (flags & ALT && _ulong != 0) flags |= HEXPREFIX; /* unsigned conversions */ nosign: sign = '\0'; /* * ``... diouXx conversions ... if a precision is * specified, the 0 flag will be ignored.'' * -- ANSI X3J11 */ number: if ((dprec = prec) >= 0) flags &= ~ZEROPAD; /* * ``The result of converting a zero value with an * explicit precision of zero is no characters.'' * -- ANSI X3J11 */ t = buf + BUF; if (_ulong != 0 || prec != 0) { do { *--t = digs[_ulong % base]; _ulong /= base; } while (_ulong); digs = "0123456789abcdef"; if (flags & ALT && base == 8 && *t != '0') *--t = '0'; /* octal leading 0 */ } size = buf + BUF - t; pforw: /* * All reasonable formats wind up here. At this point, * `t' points to a string which (if not flags&LADJUST) * should be padded out to `width' places. If * flags&ZEROPAD, it should first be prefixed by any * sign or other prefix; otherwise, it should be blank * padded before the prefix is emitted. After any * left-hand padding and prefixing, emit zeroes * required by a decimal [diouxX] precision, then print * the string proper, then emit zeroes required by any * leftover floating precision; finally, if LADJUST, * pad with blanks. */ /* * compute actual size, so we know how much to pad * fieldsz excludes decimal prec; realsz includes it */ fieldsz = size; if (sign) fieldsz++; if (flags & HEXPREFIX) fieldsz += 2; realsz = dprec > fieldsz ? dprec : fieldsz; /* right-adjusting blank padding */ if ((flags & (LADJUST|ZEROPAD)) == 0 && width) for (n = realsz; n < width; n++) PUTC(' '); /* prefix */ if (sign) PUTC(sign); if (flags & HEXPREFIX) { PUTC('0'); PUTC((char)*fmt); } /* right-adjusting zero padding */ if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) for (n = realsz; n < width; n++) PUTC('0'); /* leading zeroes from decimal precision */ for (n = fieldsz; n < dprec; n++) PUTC('0'); for (n = size; --n >= 0; ) PUTC(*t++); /* left-adjusting padding (always blank) */ if (flags & LADJUST) for (n = realsz; n < width; n++) PUTC(' '); /* finally, adjust cnt */ cnt += width > realsz ? width : realsz; break; case '\0': /* "%?" prints ?, unless ? is NULL */ *outp = '\0'; return (cnt); default: PUTC((char)*fmt); cnt++; } } /* NOTREACHED */ }