Print this page
4854 printf(1) doesn't support %b and \c properly
4818 printf(1) should support n$ width and precision specifiers
@@ -1,6 +1,7 @@
/*
+ * Copyright 2014 Garrett D'Amore <garrett@damore.org>
* Copyright 2010 Nexenta Systems, Inc. All rights reserved.
* Copyright (c) 1989, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -36,10 +37,12 @@
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#include <alloca.h>
+#include <ctype.h>
#include <locale.h>
#include <note.h>
#define warnx1(a, b, c) warnx(a)
#define warnx2(a, b, c) warnx(a, b)
@@ -49,15 +52,10 @@
#define _(x) gettext(x)
#define PF(f, func) do { \
char *b = NULL; \
- int dollar = 0; \
- if (*f == '$') { \
- dollar++; \
- *f = '%'; \
- } \
if (havewidth) \
if (haveprec) \
(void) asprintf(&b, f, fieldwidth, precision, func); \
else \
(void) asprintf(&b, f, fieldwidth, func); \
@@ -67,12 +65,10 @@
(void) asprintf(&b, f, func); \
if (b) { \
(void) fputs(b, stdout); \
free(b); \
} \
- if (dollar) \
- *f = '$'; \
_NOTE(CONSTCOND) } while (0)
static int asciicode(void);
static char *doformat(char *, int *);
static int escape(char *, int, size_t *);
@@ -83,19 +79,22 @@
static const char
*getstr(void);
static char *mknum(char *, char);
static void usage(void);
+static const char digits[] = "0123456789";
+
static int myargc;
static char **myargv;
static char **gargv;
+static char **maxargv;
int
main(int argc, char *argv[])
{
size_t len;
- int chopped, end, rval;
+ int end, rval;
char *format, *fmt, *start;
(void) setlocale(LC_ALL, "");
argv++;
@@ -123,16 +122,16 @@
* format strings are reused as necessary to use up the provided
* arguments, arguments of zero/null string are provided to use
* up the format string.
*/
fmt = format = *argv;
- chopped = escape(fmt, 1, &len); /* backslash interpretation */
+ (void) escape(fmt, 1, &len); /* backslash interpretation */
rval = end = 0;
gargv = ++argv;
for (;;) {
- char **maxargv = gargv;
+ maxargv = gargv;
myargv = gargv;
for (myargc = 0; gargv[myargc]; myargc++)
/* nop */;
start = fmt;
@@ -161,11 +160,11 @@
if (end == 1) {
warnx1(_("missing format character"), NULL, NULL);
return (1);
}
(void) fwrite(start, 1, PTRDIFF(fmt, start), stdout);
- if (chopped || !*gargv)
+ if (!*gargv)
return (rval);
/* Restart at the beginning of the format string. */
fmt = format;
end = 1;
}
@@ -172,68 +171,132 @@
/* NOTREACHED */
}
static char *
-doformat(char *start, int *rval)
+doformat(char *fmt, int *rval)
{
static const char skip1[] = "#'-+ 0";
- static const char skip2[] = "0123456789";
- char *fmt;
int fieldwidth, haveprec, havewidth, mod_ldbl, precision;
char convch, nextch;
+ char *start;
+ char **fargv;
+ char *dptr;
+ int l;
- fmt = start + 1;
+ start = alloca(strlen(fmt) + 1);
+ dptr = start;
+ *dptr++ = '%';
+ *dptr = 0;
+
+ fmt++;
+
/* look for "n$" field index specifier */
- fmt += strspn(fmt, skip2);
- if ((*fmt == '$') && (fmt != (start + 1))) {
- int idx = atoi(start + 1);
+ l = strspn(fmt, digits);
+ if ((l > 0) && (fmt[l] == '$')) {
+ int idx = atoi(fmt);
if (idx <= myargc) {
gargv = &myargv[idx - 1];
} else {
gargv = &myargv[myargc];
}
- start = fmt;
- fmt++;
+ if (gargv > maxargv) {
+ maxargv = gargv;
+ }
+ fmt += l + 1;
+
+ /* save format argument */
+ fargv = gargv;
} else {
- fmt = start + 1;
+ fargv = NULL;
}
/* skip to field width */
- fmt += strspn(fmt, skip1);
+ while (strchr(skip1, *fmt) != NULL) {
+ *dptr++ = *fmt++;
+ *dptr = 0;
+ }
+
+
if (*fmt == '*') {
+
+ fmt++;
+ l = strspn(fmt, digits);
+ if ((l > 0) && (fmt[l] == '$')) {
+ int idx = atoi(fmt);
+ if (idx <= myargc) {
+ gargv = &myargv[idx - 1];
+ } else {
+ gargv = &myargv[myargc];
+ }
+ fmt += l + 1;
+ }
+
if (getint(&fieldwidth))
return (NULL);
+ if (gargv > maxargv) {
+ maxargv = gargv;
+ }
havewidth = 1;
- ++fmt;
+
+ *dptr++ = '*';
+ *dptr = 0;
} else {
havewidth = 0;
/* skip to possible '.', get following precision */
- fmt += strspn(fmt, skip2);
+ while (isdigit(*fmt)) {
+ *dptr++ = *fmt++;
+ *dptr = 0;
}
+ }
+
if (*fmt == '.') {
/* precision present? */
- ++fmt;
+ fmt++;
+ *dptr++ = '.';
+
if (*fmt == '*') {
+
+ fmt++;
+ l = strspn(fmt, digits);
+ if ((l > 0) && (fmt[l] == '$')) {
+ int idx = atoi(fmt);
+ if (idx <= myargc) {
+ gargv = &myargv[idx - 1];
+ } else {
+ gargv = &myargv[myargc];
+ }
+ fmt += l + 1;
+ }
+
if (getint(&precision))
return (NULL);
+ if (gargv > maxargv) {
+ maxargv = gargv;
+ }
haveprec = 1;
- ++fmt;
+ *dptr++ = '*';
+ *dptr = 0;
} else {
haveprec = 0;
/* skip to conversion char */
- fmt += strspn(fmt, skip2);
+ while (isdigit(*fmt)) {
+ *dptr++ = *fmt++;
+ *dptr = 0;
}
+ }
} else
haveprec = 0;
if (!*fmt) {
warnx1(_("missing format character"), NULL, NULL);
return (NULL);
}
+ *dptr++ = *fmt;
+ *dptr = 0;
/*
* Look for a length modifier. POSIX doesn't have these, so
* we only support them for floating-point conversions, which
* are extensions. This is useful because the L modifier can
@@ -252,12 +315,18 @@
}
} else {
mod_ldbl = 0;
}
+ /* save the current arg offset, and set to the format arg */
+ if (fargv != NULL) {
+ gargv = fargv;
+ }
+
convch = *fmt;
nextch = *++fmt;
+
*fmt = '\0';
switch (convch) {
case 'b': {
size_t len;
char *p;
@@ -267,17 +336,15 @@
if (p == NULL) {
warnx2("%s", strerror(ENOMEM), NULL);
return (NULL);
}
getout = escape(p, 0, &len);
- *(fmt - 1) = 's';
- PF(start, p);
- *(fmt - 1) = 'b';
+ (void) fputs(p, stdout);
free(p);
if (getout)
- return (fmt);
+ exit(*rval);
break;
}
case 'c': {
char p;
@@ -326,10 +393,12 @@
default:
warnx2(_("illegal format character %c"), convch, NULL);
return (NULL);
}
*fmt = nextch;
+
+ /* return the gargv to the next element */
return (fmt);
}
static char *
mknum(char *str, char ch)
@@ -383,13 +452,17 @@
break;
case 'b': /* backspace */
*store = '\b';
break;
case 'c':
+ if (!percent) {
*store = '\0';
*len = PTRDIFF(store, save);
return (1);
+ }
+ *store = 'c';
+ break;
case 'f': /* form-feed */
*store = '\f';
break;
case 'n': /* newline */
*store = '\n';