Subversion Repositories tendra.SVN

/*

    		 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.

*/

#include "config.h"

#include <limits.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 "char.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

    PROTO_N ( ( str, c, pc, pn ) )

    PROTO_T ( STRING str X unsigned long c X int *pc X 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

    PROTO_N ( ( str, margs ) )

    PROTO_T ( STRING str X 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

    PROTO_N ( ( s, n, m, flags ) )

    PROTO_T ( string s X BUILTIN_TYPE n X BUILTIN_TYPE m X 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

    PROTO_N ( ( p, n, t, state ) )

    PROTO_T ( LIST ( TYPE ) p X unsigned n X TYPE t X 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

    PROTO_N ( ( str, p, margs, state ) )

    PROTO_T ( STRING str X LIST ( TYPE ) p X unsigned margs X 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

    PROTO_N ( ( str, p, margs, state ) )

    PROTO_T ( STRING str X LIST ( TYPE ) p X unsigned margs X 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

    PROTO_N ( ( str, margs, pf ) )

    PROTO_T ( STRING str X unsigned margs X 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

    PROTO_N ( ( t ) )

    PROTO_T ( 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

    PROTO_Z ()

{

    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 ;

}