Subversion Repositories tendra.SVN

/*

 * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.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,

 *    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.

 * 3. Neither the name of The TenDRA Project nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific, prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``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 COPYRIGHT HOLDERS OR

 * CONTRIBUTORS 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.

 *

 * $Id$

 */

/*

    		 Crown Copyright (c) 1997, 1998

    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 "c_types.h"

#include "ctype_ops.h"

#include "exp_ops.h"

#include "id_ops.h"

#include "nat_ops.h"

#include "off_ops.h"

#include "type_ops.h"

#include "error.h"

#include "catalog.h"

#include "option.h"

#include "basetype.h"

#include "cast.h"

#include "check.h"

#include "chktype.h"

#include "class.h"

#include "compile.h"

#include "constant.h"

#include "construct.h"

#include "convert.h"

#include "derive.h"

#include "expression.h"

#include "identifier.h"

#include "initialise.h"

#include "literal.h"

#include "member.h"

#include "operator.h"

#include "overload.h"

#include "predict.h"

#include "quality.h"

#include "statement.h"

#include "syntax.h"

#include "template.h"

/*

    CONSTRUCT AN ERROR EXPRESSION

    This routine creates an error expression.  The result is an lvalue

    if lv is true.

*/

EXP

make_error_exp(int lv)

{

	EXP a;

	TYPE t = type_error;

	if (lv) {

		t = lvalue_type(t);

	}

	MAKE_exp_value(t, a);

	return (a);

}

/*

    CONSTRUCT A NULL POINTER CONSTANT

    This routine checks converts the integral expression a into a null

    pointer (or pointer to member) constant of type t.  Basically this

    consists of testing whether a evaluates to zero, however writing

    anything other than a plain literal '0' for the null pointer (for

    example '1 - 1') is considered bad practice, so there is a test

    for this.  The null expression is returns if a is non-zero.

*/

EXP

make_null_ptr(EXP a, TYPE t)

{

	EXP e = NULL_exp;

	if (IS_NULL_exp(a)) {

		/* Allow null expressions */

		MAKE_exp_null(t, e);

	} else {

		if (is_zero_exp(a)) {

			if (!is_literal(a)) {

				/* Report complex literals */

				report(crt_loc, ERR_conv_ptr_null_complex());

			}

			MAKE_exp_null(t, e);

		} else {

			if (in_template_decl && IS_exp_int_lit(a)) {

				if (depends_on_exp(a, any_templ_param, 0)) {

					/* Check for template parameters */

					report(crt_loc,

					       ERR_conv_ptr_null_complex());

					MAKE_exp_op(t, lex_pointer, a,

						    NULL_exp, e);

				}

			}

		}

	}

	return (e);

}

/*

    CONSTRUCT A PARENTHESISED EXPRESSION

    This routine constructs the expression '( a )'.  Note that parentheses

    are only needed in order to perform analysis for odd precedence in

    expressions.  It is otherwise just an identity operation.

*/

EXP

make_paren_exp(EXP a)

{

	EXP e;

	TYPE ta = DEREF_type(exp_type(a));

	if (IS_exp_int_lit(a)) {

		/* Deal with integer constant expressions */

		unsigned etag = DEREF_unsigned(exp_int_lit_etag(a));

		switch (etag) {

		case exp_int_lit_tag:

		case exp_null_tag:

		case exp_identifier_tag: {

			/* Don't bother with literals and enumerators */

			e = a;

			break;

		}

		default: {

			/* Mark other values as parenthesised */

			NAT n = DEREF_nat(exp_int_lit_nat(a));

			MAKE_exp_int_lit(ta, n, exp_paren_tag, e);

			break;

		}

		}

	} else {

		MAKE_exp_paren(ta, a, e);

	}

	return (e);

}

/*

    CONSTRUCT A TYPE OFFSET

    This routine constructs an offset of a times the offset of the type t.

    This is negated if neg is true.

*/

OFFSET

make_off_mult(TYPE t, EXP a, int neg)

{

	OFFSET off;

	if (IS_type_top_etc(t)) {

		/* Map 'void *' to 'char *' */

		t = type_char;

	}

	if (IS_exp_int_lit(a)) {

		/* Constant offsets */

		int neg1 = neg;

		NAT n = DEREF_nat(exp_int_lit_nat(a));

		if (IS_nat_neg(n)) {

			n = DEREF_nat(nat_neg_arg(n));

			neg1 = !neg1;

		}

		if (IS_nat_small(n)) {

			unsigned v = DEREF_unsigned(nat_small_value(n));

			if (v < 100) {

				if (v == 0) {

					MAKE_off_zero(t, off);

				} else if (v == 1) {

					MAKE_off_type(t, off);

				} else {

					MAKE_type_array(cv_none, t, n, t);

					MAKE_off_type(t, off);

				}

				if (neg1) {

					MAKE_off_negate(off, off);

				}

				return (off);

			}

		}

	}

	MAKE_off_type(t, off);

	MAKE_off_mult(off, a, off);

	if (neg) {

		MAKE_off_negate(off, off);

	}

	return (off);

}

/*

    CREATE AN ADD-TO-POINTER EXPRESSION

    This routine creates a pointer of type t by adding the offset off to

    the pointer expression a.  For pointers of type 'void *' conversions

    are performed to and from 'char *'.

*/

EXP

make_add_ptr(TYPE t, EXP a, OFFSET off)

{

	EXP e;

	if (IS_type_ptr(t)) {

		TYPE s = DEREF_type(type_ptr_sub(t));

		if (IS_type_top_etc(s)) {

			TYPE p = type_char_star;

			MAKE_exp_cast(p,(CONV_PTR_VOID | CONV_REVERSE), a, e);

			e = make_add_ptr(p, e, off);

			MAKE_exp_cast(t, CONV_PTR_VOID, e, e);

			return (e);

		}

	}

	MAKE_exp_add_ptr(t, a, off, 0, e);

	return (e);

}

/*

    CONSTRUCT AN INDEX EXPRESSION

    This routine constructs the expression 'a [b]'.  The result is an

    lvalue.  Note that if a is immediately derived from an array and b is

    an integer constant then bounds checks are applied to the operation.

    However once an array has been converted into a pointer any associated

    bounds information is lost.

*/

EXP

make_index_exp(EXP a, EXP b)

{

	TYPE t;

	EXP e, p;

	int z = 0;

	OFFSET off;

	TYPE ta, tb;

	unsigned ca, cb;

	ERROR err = NULL_err;

	TYPE sa = DEREF_type(exp_type(a));

	TYPE sb = DEREF_type(exp_type(b));

	/* Do reference conversions */

	a = convert_reference(a, REF_NORMAL);

	b = convert_reference(b, REF_NORMAL);

	/* Find the operand types */

	ta = DEREF_type(exp_type(a));

	ca = type_category(&ta);

	tb = DEREF_type(exp_type(b));

	cb = type_category(&tb);

	/* Check for overloading */

#if LANGUAGE_CPP

	if (IS_TYPE_OVERLOAD(ca) || IS_TYPE_OVERLOAD(cb)) {

		if (overload_depth == 0) {

			e = binary_overload(lex_array_Hop, a, b);

			return (e);

		}

	}

#endif

	/* Do lvalue conversions */

	if (IS_TYPE_ADDRESS(ca)) {

		a = convert_lvalue(a);

		ta = DEREF_type(exp_type(a));

		ca = type_category(&ta);

	}

	if (IS_TYPE_ADDRESS(cb)) {

		b = convert_lvalue(b);

		tb = DEREF_type(exp_type(b));

		cb = type_category(&tb);

	}

	/* Swap operands if the second is a pointer */

	if (IS_TYPE_PTR(cb)) {

		/* Alright because order of evaluation is undefined */

		EXP c = a;

		TYPE tc = ta;

		unsigned cc = ca;

		a = b;

		b = c;

		ta = tb;

		tb = tc;

		ca = cb;

		cb = cc;

		sa = sb;

	}

	/* The first operand should now be a pointer */

	if (!IS_TYPE_PTR(ca)) {

		if (!IS_TYPE_ERROR(ca) && !IS_TYPE_ERROR(cb)) {

			report(crt_loc, ERR_expr_sub_ptr_op(ta, tb));

		}

		return (make_error_exp(0));

	}

	/* The second operand should be integral */

	if (!IS_TYPE_INT(cb)) {

		if (!IS_TYPE_ERROR(cb)) {

			report(crt_loc, ERR_expr_sub_int_op(tb));

		}

		/* Continue with zero index */

		z = 1;

	}

	/* Check index value */

	if (IS_exp_int_lit(b)) {

		if (IS_type_array(sa)) {

			check_bounds(lex_array_Hop, sa, b);

		}

		z = is_zero_exp(b);

	} else {

		if (eq_type_unqual(tb, type_char)) {

			report(crt_loc, ERR_expr_sub_char_op(tb));

		}

	}

	/* The pointer must be to a complete object type */

	t = check_pointer(ta, &err);

	if (!IS_NULL_err(err)) {

		err = concat_error(err, ERR_expr_sub_incompl());

		report(crt_loc, err);

	}

	/* Construct pointer to the result */

	if (z) {

		/* Zero offset */

		p = a;

	} else {

		/* Non-zero offset */

		if (IS_TYPE_BITF(cb)) {

			b = convert_bitfield(b);

		}

		off = make_off_mult(t, b, 0);

		p = make_add_ptr(ta, a, off);

	}

	/* The result is an lvalue */

	t = lvalue_type(t);

	/* Construct the result */

	MAKE_exp_indir(t, p, e);

	COPY_int(exp_indir_index(e), 1);

	return (e);

}

/*

    CONSTRUCT A INDIRECTION EXPRESSION

    This routine constructs the indirection expression '*a'.  The result

    is an lvalue.

*/

EXP

make_indir_exp(EXP a)

{

	EXP e;

	TYPE ta;

	unsigned ca;

	/* Do reference conversion */

	a = convert_reference(a, REF_NORMAL);

	/* Find operand type */

	ta = DEREF_type(exp_type(a));

	ca = type_category(&ta);

	/* Check for overloading */

#if LANGUAGE_CPP

	if (IS_TYPE_OVERLOAD(ca)) {

		if (overload_depth == 0) {

			e = unary_overload(lex_star, a);

			return (e);

		}

	}

#endif

	/* Do lvalue conversion */

	if (IS_TYPE_ADDRESS(ca)) {

		a = convert_lvalue(a);

		ta = DEREF_type(exp_type(a));

		ca = type_category(&ta);

	}

	/* Operand can be pointer ... */

	if (IS_TYPE_PTR(ca)) {

		TYPE t = check_pointer(ta, KILL_err);

		if (IS_type_top_etc(t)) {

			/* The pointer cannot be 'void *' */

			report(crt_loc, ERR_expr_unary_op_indir_void(ta));

		}

		if (IS_exp_null(a)) {

			/* Check for obvious null pointers */

			report(crt_loc, ERR_expr_unary_op_indir_null(lex_star));

		}

		/* The result is an lvalue */

		t = lvalue_type(t);

		/* Construct the result */

		MAKE_exp_indir(t, a, e);

		return (e);

	}

	/* ... and nothing else */

	if (!IS_TYPE_ERROR(ca)) {

		report(crt_loc, ERR_expr_unary_op_indir_op(ta));

	}

	return (make_error_exp(1));

}

/*

    CONSTRUCT A REFERENCE TO AN OBJECT

    This routine constructs a pointer to the expression a which designates

    an object.  Any errors arising are added to err.

*/

EXP

make_ref_object(EXP a, ERROR *err)

{

	EXP e;

	TYPE p;

	TYPE ta = DEREF_type(exp_type(a));

	unsigned ca = type_category(&ta);

	if (IS_TYPE_ERROR(ca)) {

		/* Error progagation */

		e = make_error_exp(0);

		return (e);

	}

	if (!IS_TYPE_LVALUE(ca)) {

		/* Operand should be an lvalue */

		add_error(err, ERR_expr_unary_op_ref_lvalue());

	}

	if (IS_TYPE_BITF(ca)) {

		/* Can't apply to a bitfield */

		add_error(err, ERR_expr_unary_op_ref_bitf());

		ta = find_bitfield_type(ta);

	}

	if (option(OPT_addr_register) && used_register) {

		/* Can't apply to a register variable in C */

		EXP b = NULL_exp;

		DECL_SPEC ds = find_exp_linkage(a, &b, 1);

		if ((ds & dspec_register) && !(ds & dspec_temp)) {

			if (IS_exp_identifier(b)) {

				IDENTIFIER id = DEREF_id(exp_identifier_id(b));

				add_error(err,

					  ERR_expr_unary_op_ref_register(id));

			}

		}

	}

	if (IS_type_top_etc(ta)) {

		/* Can't apply to void */

		add_error(err, ERR_expr_unary_op_ref_void(ta));

	} else {

		/* Check for incomplete types */

		ERROR err2 = check_incomplete(ta);

		if (!IS_NULL_err(err2)) {

			add_error(err, err2);

			add_error(err, ERR_expr_unary_op_ref_incompl());

		}

	}

	/* Construct the result */

	ta = rvalue_type(ta);

	MAKE_type_ptr(cv_none, ta, p);

	MAKE_exp_address(p, a, e);

	return (e);

}

/*

    CONSTRUCT A REFERENCE TO A MEMBER

    This routine constructs a pointer to the expression a which designates

    a class member.  Note that a can represent an overloaded member function

    in which case the actual result type can only be determined after

    overload resolution.  Also the type of an inherited member is that

    of its base class rather than its derived class.

*/

#if LANGUAGE_CPP

static EXP

make_ref_member(EXP a, int paren, int res)

{

	EXP e;

	TYPE p;

	DECL_SPEC ds;

	/* Find the base class */

	IDENTIFIER id = DEREF_id(exp_member_id(a));

	IDENTIFIER uid = DEREF_id(id_alias(id));

	CLASS_TYPE tc = parent_class(uid);

	/* Find the result type */

	TYPE ta = DEREF_type(exp_type(a));

	ta = rvalue_type(ta);

	if (IS_type_bitfield(ta)) {

		/* Can't apply to a bitfield */

		report(crt_loc, ERR_expr_unary_op_ref_bitf());

		ta = find_bitfield_type(ta);

	}

	MAKE_type_ptr_mem(cv_none, tc, ta, p);

	/* Construct the result */

	if (!EQ_id(id, uid)) {

		QUALIFIER qual = DEREF_qual(exp_member_qual(a));

		MAKE_exp_member(ta, uid, qual, a);

	}

	MAKE_exp_address_mem(p, a, paren, e);

	if (res) {

		/* Mark identifier as used */

		if (res == 2) {

			use_id(id, suppress_usage);

		} else {

			reuse_id(id, suppress_usage);

		}

		ds = DEREF_dspec(id_storage(id));

		if (ds & dspec_trivial) {

			/* Can take the address of a trivial function */

			CONS_id(id, pending_funcs, pending_funcs);

		}

	}

	return (e);

}

#endif

/*

    CONSTRUCT A REFERENCE EXPRESSION

    This routine constructs the expression '&a' for constructing a pointer

    to a or a pointer member to a.  The res argument is true to indicate

    that any overloaded functions in a have been resolved.

*/

EXP

make_ref_exp(EXP a, int res)

{

	EXP e;

	ERROR err = NULL_err;

#if LANGUAGE_CPP

	TYPE ta;

	unsigned ca;

	int paren = IS_exp_paren(a);

	/* Perform reference conversions */

	a = convert_reference(a, REF_ADDRESS);

	/* Check for members */

	if (IS_exp_member(a)) {

		int is_mem = 1;

		IDENTIFIER id = DEREF_id(exp_member_id(a));

		QUALIFIER idtype = DEREF_qual(exp_member_qual(a));

		idtype &= ~qual_mark;

		if (!(idtype & qual_explicit)) {

			EXP b = make_this_field(id);

			if (!IS_NULL_exp(b)) {

				a = convert_reference(b, REF_ADDRESS);

				is_mem = 0;

			}

		}

		if (is_mem) {

			if (IS_id_member(id))res = 2;

			if (res) {

				if (idtype == qual_none) {

					/* Identifiers must be qualified */

					report(crt_loc,

					       ERR_expr_unary_op_ref_unqual());

				} else {

					if (idtype != qual_nested) {

						/* Shouldn't have fully

						 * qualified identifier */

						report(crt_loc, ERR_expr_unary_op_ref_full());

					}

					if (paren) {

						/* Identifier can't be

						 * parenthesised */

						report(crt_loc, ERR_expr_unary_op_ref_paren());

						paren = 0;

					}

				}

			}

			e = make_ref_member(a, paren, res);

			return (e);

		}

	}

	/* Get operand type */

	ta = DEREF_type(exp_type(a));

	ca = type_category(&ta);

	if (IS_TYPE_OVERLOAD(ca)) {

		/* Check for overloading */

		if (overload_depth == 0) {

			e = unary_overload(lex_and_H1, a);

			return (e);

		}

		if (IS_type_compound(ta)) {

			/* Mark class types */

			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(ta));

			CLASS_USAGE cu = DEREF_cusage(ctype_usage(ct));

			cu |= cusage_address;

			COPY_cusage(ctype_usage(ct), cu);

		}

	}

#else

	/* Perform reference conversions */

	a = convert_reference(a, REF_ADDRESS);

	UNUSED(res);

#endif

	/* Construct the result */

	e = make_ref_object(a, &err);

	if (!IS_NULL_err(err)) {

		report(crt_loc, err);

	}

	return (e);

}

/*

    CONSTRUCT A UNARY ARITHMETIC EXPRESSION

    This routine constructs the unary arithmetic expression 'op a'.  For

    '+a' the expression constructed is '( a )' rather than 'a'.  This is

    to prevent expressions like 'a << +( b + c )' confusing the dubious

    parenthesis checks.

*/

EXP

make_uminus_exp(int op, EXP a)

{

	TYPE ta;

	unsigned ca;

	/* Find operation information */

	unsigned cb = CTYPE_ARITH;

	unsigned tag = exp_negate_tag;

	switch (op) {

	case lex_plus: {

		tag = exp_paren_tag;

#if LANGUAGE_CPP

		cb = CTYPE_SCALAR;

#endif

		break;

	}

	case lex_compl_H1: {

		tag = exp_compl_tag;

		cb = CTYPE_INT;

		break;

	}

	case lex_abs: {

		tag = exp_abs_tag;

		break;

	}

	}

	/* Do reference conversion */

	a = convert_reference(a, REF_NORMAL);

	/* Find the operand type */

	ta = DEREF_type(exp_type(a));

	ca = type_category(&ta);

	/* Check for overloading */

#if LANGUAGE_CPP

	if (IS_TYPE_OVERLOAD(ca)) {

		if (overload_depth == 0) {

			EXP e = unary_overload(op, a);

			return (e);

		}

	}

#endif

	/* Do lvalue conversion */

	if (IS_TYPE_ADDRESS(ca)) {

		a = convert_lvalue(a);

		ta = DEREF_type(exp_type(a));

		ca = type_category(&ta);

	}

	/* Check operand type ... */

	if (ca & cb) {

		EXP e;

		TYPE pta = promote_type(ta);

		a = convert_promote(pta, a);

		if (tag == exp_paren_tag) {

			e = make_paren_exp(a);

		} else {

			if (IS_exp_int_lit(a)) {

				e = make_unary_nat(tag, a);

			} else {

				MAKE_exp_negate_etc(tag, pta, a, e);

			}

		}

		return (e);

	}

	/* ... and report error otherwise */

	if (!IS_TYPE_ERROR(ca)) {

		ERROR err;

		if (cb == CTYPE_SCALAR) {

			err = ERR_expr_unary_op_uplus_op(op, ta);

		} else if (cb == CTYPE_ARITH) {

			err = ERR_expr_unary_op_uminus_op(op, ta);

		} else {

			err = ERR_expr_unary_op_compl_op(op, ta);

		}

		report(crt_loc, err);

	}

	return (make_error_exp(0));

}

/*

    CONSTRUCT A LOGICAL NEGATION EXPRESSION

    This routine constructs the expression '!a'.

*/

EXP

make_not_exp(EXP a)

{

	TYPE ta;

	EXP e, b;

	unsigned ca;

	ERROR err = NULL_err;

	unsigned tag = TAG_exp(a);

	/* Do reference conversion */

	a = convert_reference(a, REF_NORMAL);

	/* Find the operand type */

	ta = DEREF_type(exp_type(a));

	ca = type_category(&ta);

	/* Check for overloading */

#if LANGUAGE_CPP

	if (IS_TYPE_OVERLOAD(ca)) {

		if (overload_depth == 0) {

			e = unary_overload(lex_not_H1, a);

			return (e);

		}

	}

#endif

	/* Do lvalue conversion */

	if (IS_TYPE_ADDRESS(ca)) {

		a = convert_lvalue(a);

	}

	/* Convert the operand to a boolean */

	b = convert_boolean(a, tag, &err);

	if (!IS_NULL_err(err)) {

		err = concat_error(err, ERR_expr_unary_op_not_op());

		report(crt_loc, err);

	}

	/* Construct the result */

	if (IS_exp_int_lit(b)) {

		e = make_unary_nat(exp_not_tag, b);

	} else {

		MAKE_exp_not(type_bool, b, e);

	}

	return (e);

}

/*

    DIVISION MODE

    This flag gives the mode to be used in integer division and remainder

    operations.  The values 0, 1 and 2 correspond to the TDF operations

    div0, div1 and div2 and rem0, rem1 and rem2 respectively.  The value 3

    indicates that the decision should be postponed to the installers.

*/

int division_mode = 3;

/*

    CHECK FOR DUBIOUS DIVISION EXPRESSIONS

    This routine checks the division operation 'a / b' or 'a % b' for

    dubious constant operands.  All the necessary operand and arithmetic

    type conversions have already been performed on a and b.  The routine

    returns 1 if both operands are integer constants and b is not zero.

*/

int

check_div_exp(int op, EXP a, EXP b)

{

	int eval = 1;

	int div_mode = division_mode;

	if (IS_exp_int_lit(b)) {

		/* Check the second operand */