/*
* Copyright (c) 2002, The Tendra Project <http://www.ten15.org/>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice unmodified, this list of conditions, and the following
* disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*
* Crown Copyright (c) 1997
*
* This TenDRA(r) Computer Program is subject to Copyright
* owned by the United Kingdom Secretary of State for Defence
* acting through the Defence Evaluation and Research Agency
* (DERA). It is made available to Recipients with a
* royalty-free licence for its use, reproduction, transfer
* to other parties and amendment for any purpose not excluding
* product development provided that any such use et cetera
* shall be deemed to be acceptance of the following conditions:-
*
* (1) Its Recipients shall ensure that this Notice is
* reproduced upon any copies or amended versions of it;
*
* (2) Any amended version of it shall be clearly marked to
* show both the nature of and the organisation responsible
* for the relevant amendment or amendments;
*
* (3) Its onward transfer from a recipient to another
* party shall be deemed to be that party's acceptance of
* these conditions;
*
* (4) DERA gives no warranty or assurance as to its
* quality or suitability for any purpose and DERA accepts
* no liability whatsoever in relation to any use to which
* it may be put.
*
* $TenDRA: tendra/src/producers/common/construct/printf.c,v 1.8 2004/09/05 03:54:06 bp Exp $
*/
#include "config.h"
#include "producer.h"
#include <limits.h>
#include "char.h"
#include "c_types.h"
#include "id_ops.h"
#include "str_ops.h"
#include "type_ops.h"
#include "error.h"
#include "catalog.h"
#include "option.h"
#include "basetype.h"
#include "chktype.h"
#include "convert.h"
#include "literal.h"
#include "printf.h"
#include "typeid.h"
#include "ustring.h"
/*
* PRINTF AND SCANF FLAGS
*
* These values are used to indicate the various flags, field widths and
* precision used to modify printf and scanf format strings.
*/
#define PRINTF_NONE ((unsigned) 0x0000)
#define PRINTF_THOUSAND ((unsigned) 0x0001)
#define PRINTF_LEFT ((unsigned) 0x0002)
#define PRINTF_SIGN ((unsigned) 0x0004)
#define PRINTF_SPACE ((unsigned) 0x0008)
#define PRINTF_ALT ((unsigned) 0x0010)
#define PRINTF_ZERO ((unsigned) 0x0020)
#define PRINTF_WIDTH ((unsigned) 0x0040)
#define PRINTF_PREC ((unsigned) 0x0080)
#define PRINTF_ERROR ((unsigned) 0x0100)
#define PRINTF_FLAGS ((unsigned) 0x003f)
#define PRINTF_ARITH ((unsigned) 0x003d)
/*
* SKIP A NUMBER OF DIGITS FROM A STRING
*
* This routine skips a number of decimal digits from the string str.
* The first character and its character type are given by c and pc.
* The routine returns the first non-digit character, assigning the
* value read (or UINT_MAX if an overflow occurs) into pn.
*/
static unsigned long
read_width(STRING str, unsigned long c, int *pc, unsigned *pn)
{
unsigned n = 0;
unsigned m = 0;
int overflow = 0;
while (*pc == CHAR_SIMPLE && (c >= char_zero && c <= char_nine)) {
n = 10 * n + (unsigned) (c - char_zero);
if (n < m) overflow = 1;
m = n;
c = get_string_char (str, pc);
}
if (overflow) n = UINT_MAX;
*pn = n;
return (c);
}
/*
* READ A PRINTF ARGUMENT NUMBER
*
* In several places in a printf or scanf format string, a sequence of
* characters of the form 'n$' for a sequence of decimal digits n is
* used to indicate the nth, as opposed to the next, argument. This
* routine checks for such sequences in the string str, returning n.
* margs gives the maximum value allowed for n, if n exceeds this value
* then it UINT_MAX is returned. A value of 0 is returned if str does
* not have this form (note that the arguments are numbered from 1).
*/
static unsigned
read_arg_no(STRING str, unsigned margs)
{
unsigned long tok = DEREF_ulong (str_simple_tok (str));
int ch = CHAR_SIMPLE;
unsigned long c = get_string_char (str, &ch);
if (ch == CHAR_SIMPLE && (c >= char_zero && c <= char_nine)) {
unsigned n = 0;
c = read_width (str, c, &ch, &n);
if (ch == CHAR_SIMPLE && c == char_dollar) {
if (n > margs) {
/* Argument number out of range */
report (crt_loc, ERR_printf_arg_large (n));
n = UINT_MAX;
}
if (n == 0) {
/* Can't have argument zero */
report (crt_loc, ERR_printf_arg_zero ());
n = 1;
}
return (n);
}
}
COPY_ulong (str_simple_tok (str), tok);
return (0);
}
/*
* CHECK A PRINTF OR SCANF FORMAT STRING
*
* This routine combines a printf or scanf format string corresponding to
* the type n, modified by the type modifier m. flags gives any invalid
* format flags.
*/
static BUILTIN_TYPE
check_format(string s, BUILTIN_TYPE n, BUILTIN_TYPE m, unsigned flags)
{
switch (m) {
case ntype_sshort : {
/* 'h' modifier */
switch (n) {
case ntype_sint : n = ntype_sshort ; break;
case ntype_uint : n = ntype_ushort ; break;
default : flags |= PRINTF_ERROR ; break;
}
break;
}
case ntype_slong : {
/* 'l' modifier */
switch (n) {
case ntype_char : n = ntype_wchar_t ; break;
case ntype_uchar : n = ntype_none ; break;
case ntype_sint : n = ntype_slong ; break;
case ntype_uint : n = ntype_ulong ; break;
case ntype_float : n = ntype_double ; break;
default : flags |= PRINTF_ERROR ; break;
}
break;
}
case ntype_ldouble : {
/* 'L' modifier */
switch (n) {
case ntype_float : n = ntype_ldouble ; break;
case ntype_double : n = ntype_ldouble ; break;
default : flags |= PRINTF_ERROR ; break;
}
break;
}
}
if (flags) {
if (flags & PRINTF_ERROR) {
report (crt_loc, ERR_printf_invalid (s));
s [1] = s [2];
s [2] = 0;
}
if (flags & PRINTF_FLAGS) {
character t [8];
string r = t;
if (flags & PRINTF_THOUSAND) *(r++) = char_single_quote;
if (flags & PRINTF_LEFT) *(r++) = char_minus;
if (flags & PRINTF_SIGN) *(r++) = char_plus;
if (flags & PRINTF_SPACE) *(r++) = char_space;
if (flags & PRINTF_ALT) *(r++) = char_hash;
if (flags & PRINTF_ZERO) *(r++) = char_zero;
*r = 0;
report (crt_loc, ERR_printf_flags (t, s));
}
if (flags & PRINTF_WIDTH) {
report (crt_loc, ERR_printf_width (s));
}
if (flags & PRINTF_PREC) {
report (crt_loc, ERR_printf_precision (s));
}
}
return (n);
}
/*
* SET AN ARGUMENT TYPE
*
* This routine sets the nth argument of the list p to be t. The elements
* of p are in reverse order and numbered from 1. A zero value for n is
* equivalent to 'LENGTH_list (p) + 1'. The state flag is used to keep
* track of whether numbered and unnumbered arguments are mixed.
*/
static LIST (TYPE)
set_printf_arg(LIST (TYPE) p, unsigned n, TYPE t, int *state)
{
if (n == 0) {
/* Simple case */
if (*state == 2) {
report (crt_loc, ERR_printf_arg_mix ());
*state = 3;
} else {
*state = 1;
}
CONS_type (t, p, p);
} else {
unsigned m = UINT_MAX;
if (*state == 1) {
report (crt_loc, ERR_printf_arg_mix ());
*state = 3;
} else {
*state = 2;
}
if (n != m) {
/* Valid argument number */
TYPE s;
LIST (TYPE) q;
m = LENGTH_list (p);
while (m < n) {
/* Add extra arguments if necessary */
CONS_type (NULL_type, p, p);
m++;
}
q = p;
while (m > n) {
/* Scan to nth argument */
q = TAIL_list (q);
m--;
}
s = DEREF_type (HEAD_list (q));
if (!IS_NULL_type (s) && !EQ_type (s, t)) {
/* Check for compatibility with previous type */
ERROR err = NULL_err;
t = check_compatible (s, t, 1, &err, 1);
if (!IS_NULL_err (err)) {
err = set_severity (err, OPT_whatever, 0);
err = concat_error (err, ERR_printf_arg_compat (n));
report (crt_loc, err);
}
}
COPY_type (HEAD_list (q), t);
}
}
return (p);
}
/*
* PRINTF AND SCANF ARGUMENT TYPES
*
* These variables give those printf and scanf argument types which are
* not built-in types or pointers to built-in types.
*/
static TYPE ptr_const_char = NULL_type;
static TYPE ptr_const_wchar_t = NULL_type;
static TYPE ptr_ptr_void = NULL_type;
static TYPE type_wint_t = NULL_type;
/*
* FIND A PRINTF ARGUMENT TYPE
*
* This routine reads a single printf argument type from the string
* str, adding it to the list p. It is entered immediately after the
* '%' in the format string has been read.
*/
static LIST (TYPE)
add_printf_arg(STRING str, LIST (TYPE) p, unsigned margs, int *state)
{
unsigned flag;
character s [8];
string r = s;
unsigned long c;
TYPE t = NULL_type;
int ch = CHAR_SIMPLE;
BUILTIN_TYPE n = ntype_none;
unsigned flags = PRINTF_NONE;
/* Read argument number */
unsigned arg = read_arg_no (str, margs);
/* Read flags */
do {
c = get_string_char (str, &ch);
if (ch == CHAR_SIMPLE) {
if (c == char_percent && flags == PRINTF_NONE && arg == 0) {
/* Have precisely '%%' */
return (p);
}
switch (c) {
case char_single_quote : flag = PRINTF_THOUSAND ; break;
case char_minus : flag = PRINTF_LEFT ; break;
case char_plus : flag = PRINTF_SIGN ; break;
case char_space : flag = PRINTF_SPACE ; break;
case char_hash : flag = PRINTF_ALT ; break;
case char_zero : flag = PRINTF_ZERO ; break;
default : flag = PRINTF_NONE ; break;
}
flags |= flag;
} else {
flag = PRINTF_NONE;
}
} while (flag != PRINTF_NONE);
/* Read field width */
if (ch == CHAR_SIMPLE) {
if (c == char_asterix) {
unsigned arg2 = read_arg_no (str, margs);
p = set_printf_arg (p, arg2, type_sint, state);
c = get_string_char (str, &ch);
flags |= PRINTF_WIDTH;
} else if (c >= char_zero && c <= char_nine) {
unsigned v = 0;
c = read_width (str, c, &ch, &v);
flags |= PRINTF_WIDTH;
}
}
/* Read precision */
if (ch == CHAR_SIMPLE && c == char_dot) {
c = get_string_char (str, &ch);
if (ch == CHAR_SIMPLE) {
if (c == char_asterix) {
unsigned arg2 = read_arg_no (str, margs);
p = set_printf_arg (p, arg2, type_sint, state);
c = get_string_char (str, &ch);
} else if (c >= char_zero && c <= char_nine) {
unsigned v = 0;
c = read_width (str, c, &ch, &v);
}
}
flags |= PRINTF_PREC;
}
/* Read type modifier */
*(r++) = char_percent;
if (ch == CHAR_SIMPLE) {
switch (c) {
case char_h : n = ntype_sshort ; break;
case char_l : n = ntype_slong ; break;
case char_L : n = ntype_ldouble ; break;
}
if (n != ntype_none) {
*(r++) = (character) c;
c = get_string_char (str, &ch);
}
}
/* Read type specifier */
r [0] = (character) c;
r [1] = 0;
if (ch == CHAR_SIMPLE) {
switch (c) {
case char_c : {
flags &= (PRINTF_ARITH | PRINTF_PREC);
n = check_format (s, ntype_uchar, n, flags);
if (n == ntype_none) goto wint_lab;
break;
}
case char_C : {
flags &= PRINTF_ARITH;
n = check_format (s, ntype_none, n, flags);
wint_lab : {
t = type_wint_t;
if (IS_NULL_type (t)) {
t = find_std_type ("wint_t", 0, 0);
if (!IS_NULL_type (t)) {
type_wint_t = t;
} else {
t = type_error;
}
}
}
break;
}
case char_d :
case char_i : {
flags &= PRINTF_ALT;
n = check_format (s, ntype_sint, n, flags);
break;
}
case char_o : {
flags &= (PRINTF_ALT | PRINTF_THOUSAND);
n = check_format (s, ntype_uint, n, flags);
break;
}
case char_u : {
flags &= PRINTF_ALT;
n = check_format (s, ntype_uint, n, flags);
break;
}
case char_x :
case char_X : {
flags &= PRINTF_THOUSAND;
n = check_format (s, ntype_uint, n, flags);
break;
}
case char_e :
case char_E : {
flags &= PRINTF_THOUSAND;
n = check_format (s, ntype_double, n, flags);
break;
}
case char_f :
case char_g :
case char_G : {
n = check_format (s, ntype_double, n, PRINTF_NONE);
break;
}
case char_s : {
flags &= PRINTF_ARITH;
n = check_format (s, ntype_char, n, flags);
if (n == ntype_char) {
t = ptr_const_char;
} else {
t = ptr_const_wchar_t;
}
n = ntype_none;
break;
}
case char_S : {
flags &= PRINTF_ARITH;
n = check_format (s, ntype_none, n, flags);
t = ptr_const_wchar_t;
break;
}
case char_p : {
flags &= (PRINTF_ARITH | PRINTF_PREC);
n = check_format (s, ntype_none, n, flags);
t = type_void_star;
break;
}
case char_n : {
n = check_format (s, ntype_sint, n, flags);
t = ptr_type_builtin [n];
n = ntype_none;
break;
}
default : {
report (crt_loc, ERR_printf_unknown (s));
t = type_error;
n = ntype_none;
break;
}
}
if (n != ntype_none) t = type_builtin [n];
} else {
report (crt_loc, ERR_printf_unknown (s));
t = type_error;
}
if (!IS_NULL_type (t)) {
t = arg_promote_type (t, KILL_err);
p = set_printf_arg (p, arg, t, state);
}
return (p);
}
/*
* FIND A SCANF ARGUMENT TYPE
*
* This routine reads a single scanf argument type from the string
* str, adding it to the list p. It is entered immediately after the
* '%' in the format string has been read.
*/
static LIST (TYPE)
add_scanf_arg(STRING str, LIST (TYPE) p, unsigned margs, int *state)
{
character s [8];
string r = s;
int ignore = 0;
unsigned long c;
TYPE t = NULL_type;
int ch = CHAR_SIMPLE;
BUILTIN_TYPE n = ntype_none;
unsigned flags = PRINTF_NONE;
/* Read argument number */
unsigned arg = read_arg_no (str, margs);
/* Check for initial '*' */
c = get_string_char (str, &ch);
if (ch == CHAR_SIMPLE) {
if (c == char_percent && arg == 0) {
/* Have precisely '%%' */
return (p);
}
if (c == char_asterix) {
c = get_string_char (str, &ch);
ignore = 1;
}
}
/* Read field width */
if (ch == CHAR_SIMPLE && (c >= char_zero && c <= char_nine)) {
unsigned v = 0;
c = read_width (str, c, &ch, &v);
flags |= PRINTF_WIDTH;
}
/* Read type modifier */
*(r++) = char_percent;
if (ch == CHAR_SIMPLE) {
switch (c) {
case char_h : n = ntype_sshort ; break;
case char_l : n = ntype_slong ; break;
case char_L : n = ntype_ldouble ; break;
}
if (n != ntype_none) {
*(r++) = (character) c;
c = get_string_char (str, &ch);
}
}
/* Read type specifier */
r [0] = (character) c;
r [1] = 0;
if (ch == CHAR_SIMPLE) {
switch (c) {
case char_c : {
n = check_format (s, ntype_char, n, PRINTF_NONE);
break;
}
case char_C : {
n = check_format (s, ntype_wchar_t, n, PRINTF_NONE);
break;
}
case char_d :
case char_i : {
n = check_format (s, ntype_sint, n, PRINTF_NONE);
break;
}
case char_o :
case char_u :
case char_x :
case char_X : {
n = check_format (s, ntype_uint, n, PRINTF_NONE);
break;
}
case char_e :
case char_E :
case char_f :
case char_g :
case char_G : {
n = check_format (s, ntype_float, n, PRINTF_NONE);
break;
}
case char_s : {
n = check_format (s, ntype_char, n, PRINTF_NONE);
break;
}
case char_open_square : {
c = get_string_char (str, &ch);
if (ch == CHAR_SIMPLE && c == char_circum) {
IGNORE get_string_char (str, &ch);
}
do {
c = get_string_char (str, &ch);
if (ch == CHAR_NONE) {
report (crt_loc, ERR_printf_unterm (s));
break;
}
} while (ch != CHAR_SIMPLE || c != char_close_square);
r = ustrlit ("%[...]");
n = check_format (r, ntype_char, n, PRINTF_NONE);
break;
}
case char_S : {
n = check_format (s, ntype_wchar_t, n, PRINTF_NONE);
break;
}
case char_p : {
n = check_format (s, ntype_none, n, PRINTF_NONE);
t = ptr_ptr_void;
break;
}
case char_n : {
if (ignore) {
r = ustrlit ("*");
report (crt_loc, ERR_printf_flags (r, s));
}
n = check_format (s, ntype_sint, n, flags);
break;
}
default : {
report (crt_loc, ERR_printf_unknown (s));
t = type_error;
n = ntype_none;
break;
}
}
if (n != ntype_none) t = ptr_type_builtin [n];
} else {
report (crt_loc, ERR_printf_unknown (s));
t = type_error;
}
if (!IS_NULL_type (t) && !ignore) {
p = set_printf_arg (p, arg, t, state);
}
return (p);
}
/*
* FIND PRINTF OR SCANF ARGUMENT TYPES
*
* This routine finds the list of arguments expected by a printf-like
* or scanf-like function with format string fmt. margs gives the
* number argument number which may be specified using '%n$', and pf is
* the value returned by is_printf_type.
*/
LIST (TYPE)
find_printf_args(STRING str, unsigned margs, int pf)
{
int state = 0;
unsigned long c;
int ch = CHAR_SIMPLE;
LIST (TYPE) p = NULL_list (TYPE);
ulong tok = DEREF_ulong (str_simple_tok (str));
COPY_ulong (str_simple_tok (str), 0);
while (c = get_string_char (str, &ch), ch != CHAR_NONE) {
if (c == char_percent && ch == CHAR_SIMPLE) {
if (pf & 1) {
p = add_printf_arg (str, p, margs, &state);
} else {
p = add_scanf_arg (str, p, margs, &state);
}
}
}
if (state >= 2) {
int reported = 0;
LIST (TYPE) q = p;
while (!IS_NULL_list (q)) {
TYPE t = DEREF_type (HEAD_list (q));
if (IS_NULL_type (t)) {
/* No format string for given argument */
if (!reported) {
unsigned n = LENGTH_list (q);
report (crt_loc, ERR_printf_arg_none (n));
reported = 1;
}
COPY_type (HEAD_list (q), type_error);
} else {
reported = 0;
}
q = TAIL_list (q);
}
}
COPY_ulong (str_simple_tok (str), tok);
p = REVERSE_list (p);
return (p);
}
/*
* PRINTF AND SCANF STRING TYPES
*
* Functions like printf and scanf are indicated by an argument with one
* of the following types, which equal 'const char *' or 'const wchar_t *'.
*/
TYPE type_printf = NULL_type;
TYPE type_scanf = NULL_type;
TYPE type_wprintf = NULL_type;
TYPE type_wscanf = NULL_type;
/*
* IS A TYPE A PRINTF OR SCANF STRING TYPE?
*
* This routine checks whether the type t is derived from one of the
* printf or scanf string types above. It returns 1 for type_printf,
* 2 for type_scanf, 3 for type_wprintf and 4 for type_wscanf.
*/
int
is_printf_type(TYPE t)
{
IDENTIFIER tid = DEREF_id (type_name (t));
if (!IS_NULL_id (tid)) {
TYPE s = DEREF_type (id_class_name_etc_defn (tid));
if (IS_type_ptr (s)) {
if (EQ_type (s, type_printf)) return (1);
if (EQ_type (s, type_scanf)) return (2);
if (EQ_type (s, type_wprintf)) return (3);
if (EQ_type (s, type_wscanf)) return (4);
}
}
return (0);
}
/*
* INITIALISE PRINTF AND SCANF TYPES
*
* This routine initialises the printf and scanf strings.
*/
void
init_printf()
{
TYPE c = qualify_type (type_char, cv_const, 0);
TYPE w = qualify_type (type_wchar_t, cv_const, 0);
MAKE_type_ptr (cv_none, c, type_printf);
MAKE_type_ptr (cv_none, c, type_scanf);
MAKE_type_ptr (cv_none, w, type_wprintf);
MAKE_type_ptr (cv_none, w, type_wscanf);
MAKE_type_ptr (cv_none, c, ptr_const_char);
MAKE_type_ptr (cv_none, w, ptr_const_wchar_t);
MAKE_type_ptr (cv_none, type_void_star, ptr_ptr_void);
return;
}
syntax highlighted by Code2HTML, v. 0.9.1