| /* GNU m4 -- A simple macro processor |
| Copyright (C) 1989-1994, 2001, 2006-2010, 2013-2014, 2017 Free |
| Software Foundation, Inc. |
| |
| This file is part of GNU M4. |
| |
| GNU M4 is free software: you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation, either version 3 of the License, or |
| (at your option) any later version. |
| |
| GNU M4 is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| /* printf like formatting for m4. */ |
| |
| #include "vasnprintf.h" |
| |
| /* Simple varargs substitute. We assume int and unsigned int are the |
| same size; likewise for long and unsigned long. We do not yet |
| handle long double or long long. */ |
| |
| /* Parse STR of length LEN as an integer, reporting warnings on behalf |
| of ME. */ |
| static int |
| arg_int (struct m4 *context, const m4_call_info *me, const char *str, |
| size_t len) |
| { |
| char *endp; |
| long value; |
| |
| /* TODO - also allow parsing `'a' or `"a' which results in the |
| numeric value of 'a', as in printf(1). */ |
| if (!len) |
| { |
| m4_warn (context, 0, me, _("empty string treated as 0")); |
| return 0; |
| } |
| errno = 0; |
| value = strtol (str, &endp, 10); |
| if (endp - str != len) |
| m4_warn (context, 0, me, _("non-numeric argument %s"), |
| quotearg_style_mem (locale_quoting_style, str, len)); |
| else if (isspace (to_uchar (*str))) |
| m4_warn (context, 0, me, _("leading whitespace ignored")); |
| else if (errno == ERANGE || (int) value != value) |
| m4_warn (context, 0, me, _("numeric overflow detected")); |
| return value; |
| } |
| |
| /* Parse STR of length LEN as a long, reporting warnings on behalf of |
| ME. */ |
| static long |
| arg_long (struct m4 *context, const m4_call_info *me, const char *str, |
| size_t len) |
| { |
| char *endp; |
| long value; |
| |
| /* TODO - also allow parsing `'a' or `"a' which results in the |
| numeric value of 'a', as in printf(1). */ |
| if (!len) |
| { |
| m4_warn (context, 0, me, _("empty string treated as 0")); |
| return 0L; |
| } |
| errno = 0; |
| value = strtol (str, &endp, 10); |
| if (endp - str != len) |
| m4_warn (context, 0, me, _("non-numeric argument %s"), |
| quotearg_style_mem (locale_quoting_style, str, len)); |
| else if (isspace (to_uchar (*str))) |
| m4_warn (context, 0, me, _("leading whitespace ignored")); |
| else if (errno == ERANGE) |
| m4_warn (context, 0, me, _("numeric overflow detected")); |
| return value; |
| } |
| |
| /* Check STR of length LEN for embedded NUL, reporting warnings on |
| behalf of ME. */ |
| static const char * |
| arg_string (struct m4 *context, const m4_call_info *me, const char *str, |
| size_t len) |
| { |
| if (strlen (str) < len) |
| m4_warn (context, 0, me, _("argument %s truncated"), |
| quotearg_style_mem (locale_quoting_style, str, len)); |
| return str; |
| } |
| |
| /* Parse STR of length LEN as a double, reporting warnings on behalf |
| of ME. */ |
| static double |
| arg_double (struct m4 *context, const m4_call_info *me, const char *str, |
| size_t len) |
| { |
| char *endp; |
| double value; |
| |
| if (!len) |
| { |
| m4_warn (context, 0, me, _("empty string treated as 0")); |
| return 0.0; |
| } |
| errno = 0; |
| value = strtod (str, &endp); |
| if (endp - str != len) |
| m4_warn (context, 0, me, _("non-numeric argument %s"), |
| quotearg_style_mem (locale_quoting_style, str, len)); |
| else if (isspace (to_uchar (*str))) |
| m4_warn (context, 0, me, _("leading whitespace ignored")); |
| else if (errno == ERANGE) |
| m4_warn (context, 0, me, _("numeric overflow detected")); |
| return value; |
| } |
| |
| #define ARG_INT(i, argc, argv) \ |
| ((argc <= ++i) ? 0 : arg_int (context, me, M4ARG (i), M4ARGLEN (i))) |
| |
| #define ARG_LONG(i, argc, argv) \ |
| ((argc <= ++i) ? 0L : arg_long (context, me, M4ARG (i), M4ARGLEN (i))) |
| |
| #define ARG_STR(i, argc, argv) \ |
| ((argc <= ++i) ? "" : arg_string (context, me, M4ARG (i), M4ARGLEN (i))) |
| |
| #define ARG_DOUBLE(i, argc, argv) \ |
| ((argc <= ++i) ? 0.0 : arg_double (context, me, M4ARG (i), M4ARGLEN (i))) |
| |
| |
| /* The main formatting function. Output is placed on the obstack OBS, |
| the first argument in ARGV is the formatting string, and the rest |
| is arguments for the string. Warn rather than invoke unspecified |
| behavior in the underlying printf when we do not recognize a |
| format. */ |
| |
| static void |
| format (m4 *context, m4_obstack *obs, int argc, m4_macro_args *argv) |
| { |
| const m4_call_info *me = m4_arg_info (argv); |
| const char *f; /* Format control string. */ |
| size_t f_len; /* Length of f. */ |
| const char *fmt; /* Position within f. */ |
| char fstart[] = "%'+- 0#*.*hhd"; /* Current format spec. */ |
| char *p; /* Position within fstart. */ |
| unsigned char c; /* A simple character. */ |
| int i = 1; /* Index within argc used so far. */ |
| bool valid_format = true; /* True if entire format string ok. */ |
| |
| /* Flags. */ |
| char flags; /* Flags to use in fstart. */ |
| enum { |
| THOUSANDS = 0x01, /* '\''. */ |
| PLUS = 0x02, /* '+'. */ |
| MINUS = 0x04, /* '-'. */ |
| SPACE = 0x08, /* ' '. */ |
| ZERO = 0x10, /* '0'. */ |
| ALT = 0x20, /* '#'. */ |
| DONE = 0x40 /* No more flags. */ |
| }; |
| |
| /* Precision specifiers. */ |
| int width; /* Minimum field width. */ |
| int prec; /* Precision. */ |
| char lflag; /* Long flag. */ |
| |
| /* Specifiers we are willing to accept. ok['x'] implies %x is ok. |
| Various modifiers reduce the set, in order to avoid undefined |
| behavior in printf. */ |
| char ok[128]; |
| |
| /* Check that formatted text succeeded with correct type. */ |
| int result = 0; |
| enum {CHAR, INT, LONG, DOUBLE, STR} datatype; |
| |
| f = fmt = M4ARG (1); |
| f_len = M4ARGLEN (1); |
| assert (!f[f_len]); /* Requiring a terminating NUL makes parsing simpler. */ |
| memset (ok, 0, sizeof ok); |
| while (1) |
| { |
| const char *percent = (char *) memchr (fmt, '%', f_len); |
| if (!percent) |
| { |
| obstack_grow (obs, fmt, f_len); |
| break; |
| } |
| obstack_grow (obs, fmt, percent - fmt); |
| f_len -= percent - fmt + 1; |
| fmt = percent + 1; |
| |
| if (*fmt == '%') |
| { |
| obstack_1grow (obs, '%'); |
| fmt++; |
| f_len--; |
| continue; |
| } |
| |
| p = fstart + 1; /* % */ |
| lflag = 0; |
| ok['a'] = ok['A'] = ok['c'] = ok['d'] = ok['e'] = ok['E'] |
| = ok['f'] = ok['F'] = ok['g'] = ok['G'] = ok['i'] = ok['o'] |
| = ok['s'] = ok['u'] = ok['x'] = ok['X'] = 1; |
| |
| /* Parse flags. */ |
| flags = 0; |
| do |
| { |
| switch (*fmt) |
| { |
| case '\'': /* thousands separator */ |
| ok['a'] = ok['A'] = ok['c'] = ok['e'] = ok['E'] |
| = ok['o'] = ok['s'] = ok['x'] = ok['X'] = 0; |
| flags |= THOUSANDS; |
| break; |
| |
| case '+': /* mandatory sign */ |
| ok['c'] = ok['o'] = ok['s'] = ok['u'] = ok['x'] = ok['X'] = 0; |
| flags |= PLUS; |
| break; |
| |
| case ' ': /* space instead of positive sign */ |
| ok['c'] = ok['o'] = ok['s'] = ok['u'] = ok['x'] = ok['X'] = 0; |
| flags |= SPACE; |
| break; |
| |
| case '0': /* zero padding */ |
| ok['c'] = ok['s'] = 0; |
| flags |= ZERO; |
| break; |
| |
| case '#': /* alternate output */ |
| ok['c'] = ok['d'] = ok['i'] = ok['s'] = ok['u'] = 0; |
| flags |= ALT; |
| break; |
| |
| case '-': /* left justification */ |
| flags |= MINUS; |
| break; |
| |
| default: |
| flags |= DONE; |
| break; |
| } |
| } |
| while (!(flags & DONE) && (f_len--, fmt++)); |
| if (flags & THOUSANDS) |
| *p++ = '\''; |
| if (flags & PLUS) |
| *p++ = '+'; |
| if (flags & MINUS) |
| *p++ = '-'; |
| if (flags & SPACE) |
| *p++ = ' '; |
| if (flags & ZERO) |
| *p++ = '0'; |
| if (flags & ALT) |
| *p++ = '#'; |
| |
| /* Minimum field width; an explicit 0 is the same as not giving |
| the width. */ |
| width = 0; |
| *p++ = '*'; |
| if (*fmt == '*') |
| { |
| width = ARG_INT (i, argc, argv); |
| fmt++; |
| f_len--; |
| } |
| else |
| while (isdigit ((unsigned char) *fmt)) |
| { |
| width = 10 * width + *fmt - '0'; |
| fmt++; |
| f_len--; |
| } |
| |
| /* Maximum precision; an explicit negative precision is the same |
| as not giving the precision. A lone '.' is a precision of 0. */ |
| prec = -1; |
| *p++ = '.'; |
| *p++ = '*'; |
| if (*fmt == '.') |
| { |
| ok['c'] = 0; |
| f_len--; |
| if (*(++fmt) == '*') |
| { |
| prec = ARG_INT (i, argc, argv); |
| ++fmt; |
| f_len--; |
| } |
| else |
| { |
| prec = 0; |
| while (isdigit ((unsigned char) *fmt)) |
| { |
| prec = 10 * prec + *fmt - '0'; |
| fmt++; |
| f_len--; |
| } |
| } |
| } |
| |
| /* Length modifiers. We don't yet recognize ll, j, t, or z. */ |
| if (*fmt == 'l') |
| { |
| *p++ = 'l'; |
| lflag = 1; |
| fmt++; |
| f_len--; |
| ok['c'] = ok['s'] = 0; |
| } |
| else if (*fmt == 'h') |
| { |
| *p++ = 'h'; |
| fmt++; |
| f_len--; |
| if (*fmt == 'h') |
| { |
| *p++ = 'h'; |
| fmt++; |
| f_len--; |
| } |
| ok['a'] = ok['A'] = ok['c'] = ok['e'] = ok['E'] = ok['f'] = ok['F'] |
| = ok['g'] = ok['G'] = ok['s'] = 0; |
| } |
| |
| c = *fmt; |
| if (sizeof ok <= c || !ok[c] || !f_len) |
| { |
| m4_warn (context, 0, me, _("unrecognized specifier in %s"), |
| quotearg_style_mem (locale_quoting_style, f, M4ARGLEN (1))); |
| valid_format = false; |
| if (f_len > 0) |
| { |
| fmt++; |
| f_len--; |
| } |
| continue; |
| } |
| fmt++; |
| f_len--; |
| |
| /* Specifiers. We don't yet recognize C, S, n, or p. */ |
| switch (c) |
| { |
| case 'c': |
| datatype = CHAR; |
| p -= 2; /* %.*c is undefined, so undo the '.*'. */ |
| break; |
| |
| case 's': |
| datatype = STR; |
| break; |
| |
| case 'd': |
| case 'i': |
| case 'o': |
| case 'x': |
| case 'X': |
| case 'u': |
| datatype = lflag ? LONG : INT; |
| break; |
| |
| case 'a': |
| case 'A': |
| case 'e': |
| case 'E': |
| case 'f': |
| case 'F': |
| case 'g': |
| case 'G': |
| datatype = DOUBLE; |
| break; |
| |
| default: |
| abort (); |
| } |
| *p++ = c; |
| *p = '\0'; |
| |
| switch (datatype) |
| { |
| case CHAR: |
| result = obstack_printf (obs, fstart, width, |
| ARG_INT (i, argc, argv)); |
| break; |
| |
| case INT: |
| result = obstack_printf (obs, fstart, width, prec, |
| ARG_INT (i, argc, argv)); |
| break; |
| |
| case LONG: |
| result = obstack_printf (obs, fstart, width, prec, |
| ARG_LONG (i, argc, argv)); |
| break; |
| |
| case DOUBLE: |
| result = obstack_printf (obs, fstart, width, prec, |
| ARG_DOUBLE (i, argc, argv)); |
| break; |
| |
| case STR: |
| result = obstack_printf (obs, fstart, width, prec, |
| ARG_STR (i, argc, argv)); |
| break; |
| |
| default: |
| abort (); |
| } |
| /* Since obstack_printf can only fail with EILSEQ or EINVAL, but |
| we constructed fstart, the result should not be negative. */ |
| assert (0 <= result); |
| } |
| if (valid_format) |
| m4_bad_argc (context, argc, me, i, i, true); |
| } |
