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

#include "id_ops.h"

#include "loc_ext.h"

#include "member_ops.h"

#include "nspace_ops.h"

#include "off_ops.h"

#include "type_ops.h"

#include "error.h"

#include "catalog.h"

#include "option.h"

#include "access.h"

#include "allocate.h"

#include "basetype.h"

#include "capsule.h"

#include "chktype.h"

#include "class.h"

#include "compile.h"

#include "construct.h"

#include "declare.h"

#include "derive.h"

#include "dump.h"

#include "exception.h"

#include "file.h"

#include "function.h"

#include "hash.h"

#include "identifier.h"

#include "initialise.h"

#include "instance.h"

#include "inttype.h"

#include "namespace.h"

#include "operator.h"

#include "overload.h"

#include "predict.h"

#include "preproc.h"

#include "redeclare.h"

#include "syntax.h"

#include "template.h"

#include "tokdef.h"

#include "token.h"

#include "virtual.h"

/*

    DECLARATION LOCATION

    This variable is used to record the location of the current declaration.

    This is primarily so that the location of a declaration can be set to

    the location of the declarator rather than the end of the corresponding

    initialiser.

*/

LOCATION decl_loc = NULL_loc;

int is_redeclared = 0;

/*

    DEFAULT LINKAGE FOR INLINE FUNCTIONS AND CONST OBJECTS

    These variables give the default linkages for inline functions and

    const objects and the default cv-qualifiers for external objects.

*/

DECL_SPEC inline_linkage = dspec_static;

DECL_SPEC const_linkage = dspec_static;

CV_SPEC cv_extern = cv_none;

/*

    DUMMY EMPTY DECLARATION SPECIFIER

    The value dspec_empty is used during the processing of declarations

    to mark any declaration specifier which does not contain an explicit

    specifier.  The value dspec_nonempty gives those declaration

    specifiers which constitute an explicit specifier.

*/

#define dspec_empty		dspec_pure

#define dspec_nonempty		dspec_keyword

/*

    COMPLETE A DECLARATION SPECIFIER

    This routine completes the declaration specifier given by the

    specifiers ds, the type t and the cv-qualifier cv.  If these are

    all empty then the result is marked using dspec_empty.  The special

    case 'extern "LANG" typedef' is checked.

*/

DECL_SPEC

complete_dspec(DECL_SPEC ds, BASE_TYPE bt, TYPE t, CV_SPEC cv)

{

	DECL_SPEC key = (ds & dspec_nonempty);

	if (key || bt || !IS_NULL_type(t) || cv) {

		/* Have a declaration specifier */

		if (ds & dspec_c) {

			/* Have a linkage specification */

			if (ds & dspec_typedef) {

				ds &= ~dspec_extern;

			}

			ds &= ~dspec_c;

		}

	} else {

		ds |= dspec_empty;

	}

	return (ds);

}

/*

    CHECK INFERRED OBJECT TYPES

    This routine checks the declaration specifiers ds and the type *p for

    inferred types and empty specifier lists.  It is used in object,

    parameter and class member declarations.

*/

static DECL_SPEC

check_inferred_type(DECL_SPEC ds, TYPE *p, int mem)

{

	int infer;

	TYPE t = *p;

	int empty = 0;

	ERROR err = NULL_err;

	/* Report if there are no declaration specifiers */

	if (ds & dspec_empty) {

		if (mem) {

			err = ERR_class_mem_ds_empty();

		} else {

			err = ERR_dcl_dcl_ds_empty();

		}

		ds &= ~dspec_empty;

		empty = 1;

	}

	/* Check on inferred types */

	infer = is_type_inferred(t);

	if (infer != INFERRED_NOT) {

		ERROR err2;

		t = clean_inferred_type(t);

		if (empty) {

			err2 = ERR_dcl_type_infer(t);

		} else {

			err2 = report_inferred_type(t, infer);

		}

		err = concat_error(err, err2);

		*p = t;

	}

	if (!IS_NULL_err(err)) {

		report(crt_loc, err);

	}

	return (ds);

}

/*

    CHECK INFERRED FUNCTION TYPES

    This routine checks the declaration specifiers ds and the function

    type t for inferred types and empty specifier lists.  It is used in

    function declarations and definitions (as indicated by def).

*/

static DECL_SPEC

check_func_type(DECL_SPEC ds, TYPE t, int def, int chk, int mem)

{

	int empty = 0;

	ERROR err = NULL_err;

	/* Report if there are no declaration specifiers */

	if (ds & dspec_empty) {

		if (mem) {

			err = ERR_class_mem_ds_empty();

		} else if (def) {

			err = ERR_dcl_dcl_ds_func();

		} else {

			err = ERR_dcl_dcl_ds_empty();

		}

		ds &= ~dspec_empty;

		empty = 1;

	}

	/* Check for template types */

	while (IS_type_templ(t)) {

		ds |= dspec_template;

		t = DEREF_type(type_templ_defn(t));

	}

	/* Check the return type */

	if (chk) {

		TYPE r = DEREF_type(type_func_ret(t));

		int infer = is_type_inferred(r);

		if (infer != INFERRED_NOT) {

			ERROR err2;

			r = clean_inferred_type(r);

			if (empty) {

				err2 = ERR_dcl_type_infer(r);

			} else {

				err2 = report_inferred_type(r, infer);

			}

			err = concat_error(err, err2);

			COPY_type(type_func_ret(t), r);

		}

	}

	if (!IS_NULL_err(err)) {

		report(crt_loc, err);

	}

	return (ds);

}

/*

    SHIFT A STORAGE CLASS

    This macro is used to shift a storage class specifier into a more

    sensible range.

*/

#define DSPEC_STORAGE(A)	((A) >> 6)

/*

    CHECK STORAGE CLASS SPECIFIERS

    This routine extracts the storage class specifiers from the declaration

    specifiers ds in the context given by loc.  It returns a valid storage

    class specifier.

*/

static DECL_SPEC

check_storage(DECL_SPEC ds, int loc, IDENTIFIER id)

{

	DECL_SPEC st = (ds & dspec_storage);

	/* Check on storage class */

switch_label:

	switch (DSPEC_STORAGE(st)) {

	case DSPEC_STORAGE(dspec_none): {

		/* No storage class given */

		break;

	}

	case DSPEC_STORAGE(dspec_auto):

	case DSPEC_STORAGE(dspec_register): {

		/* Deal with auto and register */

		switch (loc) {

		case CONTEXT_OBJECT: {

			/* Objects declared in a block are alright */

			if (!in_function_defn) {

				goto bad_auto_lab;

			}

			break;

		}

		case CONTEXT_FUNCTION: {

			/* Functions can't be auto */

			if (!in_function_defn) {

				goto bad_auto_lab;

			}

			report(crt_loc, ERR_dcl_stc_auto_func(st));

			st = dspec_none;

			break;

		}

		case CONTEXT_PARAMETER:

		case CONTEXT_WEAK_PARAM: {

			/* Function parameters are alright */

			if (st == dspec_auto) {

				/* Can't have auto parameters in C */

				report(crt_loc, ERR_dcl_stc_auto_par());

			}

			break;

		}

		case CONTEXT_TEMPL_PARAM: {

			/* Template parameters can't have storage class */

			report(crt_loc, ERR_temp_param_dcl_stc(st));

			st = dspec_none;

			break;

		}

		default:

bad_auto_lab:

			/* Anything outside a block can't be auto */

			report(crt_loc, ERR_dcl_stc_auto_bad(st));

			st = dspec_none;

			break;

		}

		break;

	}

	case DSPEC_STORAGE(dspec_static): {

		/* Deal with static */

		switch (loc) {

		case CONTEXT_PARAMETER:

		case CONTEXT_WEAK_PARAM: {

			/* Function parameters can't be static */

			report(crt_loc, ERR_dcl_stc_param(st));

			st = dspec_none;

			break;

		}

		case CONTEXT_TEMPL_PARAM: {

			/* Template parameters can't have storage class */

			report(crt_loc, ERR_temp_param_dcl_stc(st));

			st = dspec_none;

			break;

		}

		}

		break;

	}

	case DSPEC_STORAGE(dspec_extern): {

		/* Deal with extern */

		switch (loc) {

		case CONTEXT_OBJECT:

		case CONTEXT_FUNCTION: {

			/* Objects and functions can be extern */

			if (!IS_NULL_id(id)) {

				switch (TAG_id(id)) {

				case id_member_tag:

				case id_mem_func_tag:

				case id_stat_member_tag:

				case id_stat_mem_func_tag: {

					/* But not class members */

					ERROR err = ERR_dcl_stc_ext_mem();

					report(crt_loc, err);

					break;

				}

				}

			}

			break;

		}

		case CONTEXT_PARAMETER:

		case CONTEXT_WEAK_PARAM: {

			/* Function parameters can't be extern */

			report(crt_loc, ERR_dcl_stc_param(st));

			st = dspec_none;

			break;

		}

		case CONTEXT_TEMPL_PARAM: {

			/* Template parameters can't have storage class */

			report(crt_loc, ERR_temp_param_dcl_stc(st));

			st = dspec_none;

			break;

		}

		default:

			/* Class members can't be extern */

			report(crt_loc, ERR_dcl_stc_ext_mem());

			st = dspec_none;

			break;

		}

		break;

	}

	case DSPEC_STORAGE(dspec_mutable): {

		/* Deal with mutable */

		if (loc != CONTEXT_MEMBER) {

			/* Only data members can be mutable */

			report(crt_loc, ERR_dcl_stc_mut_bad());

			st = dspec_none;

		}

		break;

	}

	default: {

		/* More than one storage class - select one */

		DECL_SPEC nst = dspec_static;

		while (!(st & nst)) {

			ASSERT(nst != dspec_none);

			nst <<= 1;

		}

		report(crt_loc, ERR_dcl_stc_dup(st, nst));

		st = nst;

		goto switch_label;

	}

	}

	return (st);

}

/*

    CHECK STORAGE CLASS SPECIFIERS

    This routine extracts the function specifiers (plus friend specifiers)

    from the declaration specifiers ds in the context given by loc (as

    above).  It returns a valid combination of function and friend

    specifiers.

*/

static DECL_SPEC

check_func_spec(DECL_SPEC ds, int loc)

{

	DECL_SPEC fn = dspec_none;

	/* Only functions can be inline */

	if (ds & dspec_inline) {

		if (loc == CONTEXT_FUNCTION || loc == CONTEXT_FUNC_MEMBER) {

			fn |= dspec_inline;

		} else {

			report(crt_loc, ERR_dcl_fct_spec_inline_bad());

		}

	}

	/* Only function members can be virtual */

	if (ds & dspec_virtual) {

		if (loc == CONTEXT_FUNC_MEMBER) {

			fn |= dspec_virtual;

		} else {

			report(crt_loc, ERR_dcl_fct_spec_virtual());

		}

	}

	/* Only function members can be explicit */

	if (ds & dspec_explicit) {

		if (loc == CONTEXT_FUNC_MEMBER) {

			fn |= dspec_explicit;

		} else {

			report(crt_loc, ERR_dcl_fct_spec_explicit());

		}

	}

	/* Only functions declared in a class can be friends */

	if (ds & dspec_friend) {

		if (loc == CONTEXT_FUNCTION && in_class_defn) {

			/* Don't add to specifier list */

			/* EMPTY */

		} else if (in_class_defn) {

			report(crt_loc, ERR_class_friend_decl());

		} else {

			report(crt_loc, ERR_dcl_friend_class());

		}

	}

	/* Allow for function discarding */

	if (loc == CONTEXT_FUNCTION || loc == CONTEXT_FUNC_MEMBER) {

		fn |= dspec_ignore;

	}

	return (fn);

}

/*

    CONSTRUCT A TYPE DECLARATION

    This routine constructs the declaration of a type with declaration

    specifiers ds (which will include typedef), type t and name id in the

    namespace ns.  mem gives the member of ns corresponding to id or the

    null member for class member redeclarations.

*/

static IDENTIFIER

make_type_decl(NAMESPACE ns, DECL_SPEC ds, TYPE t, MEMBER mem, IDENTIFIER id)

{

	int reported = 0;

	IDENTIFIER old_id;

	unsigned tag = TAG_type(t);

	QUALIFIER cq = crt_id_qualifier;

	HASHID nm = DEREF_hashid(id_name(id));

	/* Can't have other declaration specifiers with typedef */

	DECL_SPEC st = (ds & dspec_keyword);

	if (st != dspec_typedef) {

		st &= ~dspec_typedef;

		report(crt_loc, ERR_dcl_typedef_dspec(st));

	}

	/* Check for function cv-qualifiers and exception specifiers */

	object_type(t, id_type_alias_tag);

	/* Check for previous declaration */

	if (IS_NULL_member(mem)) {

		mem = search_member(ns, nm, 1);

		old_id = DEREF_id(member_id(mem));

		old_id = redecl_inherit(old_id, cq, in_class_defn, 2);

		if (IS_NULL_id(old_id)) {

			report(crt_loc, ERR_lookup_qual_undef(nm, ns));

		}

	} else {

		old_id = DEREF_id(member_id(mem));

		old_id = redecl_inherit(old_id, cq, in_class_defn, 2);

	}

	/* Allow for type redeclarations */

#if LANGUAGE_CPP

	id = type_member(mem, 3);

	id = redecl_inherit(id, cq, in_class_defn, 2);

#else

	id = old_id;

#endif

	if (!IS_NULL_id(id) && IS_id_class_name_etc(id)) {

		/* Already declared as a type name */

		TYPE s;

		ERROR err = NULL_err;

		PTR(LOCATION)loc = id_loc(id);

		unsigned long tokdefs = no_token_defns;

		/* Check for reserved identifiers */

		DECL_SPEC ods = DEREF_dspec(id_storage(id));

		if ((ds | ods) & dspec_reserve) {

			report(crt_loc, ERR_basic_odr_decl(id, loc));

			return (id);

		}

		/* Check type compatibility */

		s = DEREF_type(id_class_name_etc_defn(id));

		s = check_compatible(s, t, 0, &err, 1);

		/* QUERY: or is type equality required? */

		/* Compatible redefinition */

		if (IS_NULL_err(err)) {

			NAMESPACE cns = crt_namespace;

			if (cq != qual_none) {

				/* Check qualified definitions */

				check_decl_nspace(id, ns, 1, cns);

			}

			if (in_class_defn && EQ_nspace(ns, cns)) {

				if (!is_tagged_type(id)) {

					/* Still not allowed in a class

					 * definition */

					report(crt_loc,

					       ERR_class_mem_redecl(id, loc));

				}

			} else if (tokdefs == no_token_defns &&

				   !in_pragma_dir) {

				/* Can't redeclare types in C */

				report(crt_loc, ERR_basic_odr_typedef(id, loc));

			}

			if (tag == type_func_tag) {

				/* Check function types */

				s = redecl_func_type(id, s, t, 0, 1);

			}

			COPY_type(id_class_name_etc_defn(id), s);

			adjust_access(id, crt_access, 0);

			return (id);

		}

		/* Incompatible redefinition */

		err = concat_error(err, ERR_basic_link_typedef(id, loc));

		report(crt_loc, err);

		reported = 1;

	}

	/* Declare the type */

	id = make_typedef(ns, nm, t, dspec_none);

	if (is_tagged_type(id)) {

		/* Class-like typedef-names */

		set_type_member(mem, id);

	} else {

		/* Object-like typedef-names */

		if (!IS_NULL_id(old_id) && !reported) {

			/* Already declared as an object */

			PTR(LOCATION)loc = id_loc(old_id);

			report(crt_loc, ERR_basic_odr_diff(old_id, loc));

		}

		set_member(mem, id);

	}

	if (tag == type_func_tag) {

		/* Check function type */

		decl_func_type(id, t, 0);

	} else if (tag == type_templ_tag) {

		IGNORE check_templ_params(t, id);

		report(crt_loc, ERR_temp_decl_bad());

	}

	return (id);

}

/*

    CREATE A SPECIAL TYPE DEFINITION

    This routine creates a typedef of the identifier id to the special

    type t.

*/

void

typedef_special(IDENTIFIER id, TYPE t)

{

	int pushed = 0;

	NAMESPACE ns = nonblock_namespace;

	if (!EQ_nspace(ns, crt_namespace)) {

		push_namespace(ns);

		pushed = 1;

	}

	decl_loc = preproc_loc;

	if (in_class_defn) {

		id = make_member_decl(dspec_typedef, t, id, 0);

	} else {

		id = make_object_decl(dspec_typedef, t, id, 0);

	}

	if (do_dump) {

		dump_declare(id, &decl_loc, 1);

	}

	if (pushed) {

		IGNORE pop_namespace();

	}

	return;

}

/*

    FIND THE LINKAGE OF AN IDENTIFIER

    This routine finds the linkage of the identifier id (including the

    language specifier), returning the default value st if id does not

    represent an object or function.

*/

static DECL_SPEC

find_storage(IDENTIFIER id, DECL_SPEC st, TYPE t)

{

	if (!IS_NULL_id(id)) {

		switch (TAG_id(id)) {

		case id_variable_tag:

		case id_parameter_tag:

		case id_stat_member_tag:

		case id_weak_param_tag: {

			/* Objects */

			DECL_SPEC ds = DEREF_dspec(id_storage(id));

			st = (ds & (dspec_storage | dspec_language));

			break;

		}

		case id_function_tag:

		case id_mem_func_tag:

		case id_stat_mem_func_tag: {

			/* Functions */

			DECL_SPEC ds;

#if LANGUAGE_CPP

			LIST(IDENTIFIER)pids = NULL_list(IDENTIFIER);

			if (!IS_NULL_type(t)) {

				int eq = 0;

				id = resolve_func(id, t, 0, 0, pids, &eq);

				if (IS_NULL_id(id) ||

				    !IS_id_function_etc(id)) {

					return (st);

				}

			}

#else

			UNUSED(t);

#endif

			ds = DEREF_dspec(id_storage(id));

			st = (ds & (dspec_storage | dspec_language));

			break;

		}

		}

	}

	return (st);

}

/*

    CHECK THE LOCATION OF A DECLARATION

    This routine checks whether the namespace cns is a suitable location

    for redeclaring the object id, which is a member of the namespace ns.

    def is true for a definition.

*/

void

check_decl_nspace(IDENTIFIER id, NAMESPACE ns, int def, NAMESPACE cns)

{

	int func = 0;

	int local_def = really_in_function_defn;

	switch (TAG_id(id)) {

	case id_class_name_tag:

	case id_enum_name_tag:

	case id_class_alias_tag:

	case id_enum_alias_tag:

	case id_type_alias_tag: {

		/* Can define local types */

		local_def = 0;

		break;

	}

	case id_mem_func_tag:

	case id_stat_mem_func_tag: {

		/* Member function */

		DECL_SPEC ds = DEREF_dspec(id_storage(id));

		if (ds & dspec_implicit) {

			/* Ignore implicit constructors etc */

			return;

		}

		if (!def && !is_templ_nspace(ns)) {

			/* Can't even redeclare in this case */

			report(crt_loc, ERR_class_mfct_redecl(id));

			return;

		}

		func = 1;

		break;

	}

	case id_undef_tag: {

		/* Report undeclared members */

		HASHID nm = DEREF_hashid(id_name(id));

		report(crt_loc, ERR_lookup_qual_undef(nm, ns));

		return;

	}

	}

	if (def) {

		/* Check for enclosing namespace scope */

		if (local_def || !is_subnspace(cns, ns)) {

			/* Report badly placed definition */

			ERROR err;

			if (IS_nspace_ctype(ns)) {

				if (func) {

					/* Member functions */

					err = ERR_class_mfct_scope(id);

				} else {

					/* Other class members */

					err = ERR_class_static_data_scope(id);

				}

			} else {

				/* Namespace members */

				err = ERR_dcl_nspace_memdef_scope(id);

			}

			report(crt_loc, err);

		}

	}

	return;

}

/*

    CHECK AN OBJECT TYPE

    This routine checks the type t for the object id with declaration

    specifiers ds.

*/

void

check_obj_decl(DECL_SPEC ds, TYPE t, IDENTIFIER id, int tentative)

{

	unsigned tag = TAG_type(t);

	if (tag == type_top_tag || tag == type_bottom_tag) {

		/* Always report void declarations */

		report(crt_loc, ERR_basic_fund_void_decl(id, t));

	} else if (tag == type_templ_tag) {

		/* Shouldn't have template type */

		report(crt_loc, ERR_temp_decl_bad());

	} else if (ds & dspec_defn) {

		/* Only check otherwise if this is a definition */

		if (tag == type_array_tag) {

			/* Arrays may be completed by the initialiser */

			/* EMPTY */

		} else if (tag == type_ref_tag) {

			/* References don't need checking */

			/* EMPTY */

		} else {

			ERROR err;

			if (!tentative) {

				err = check_complete(t);

				if (!IS_NULL_err(err)) {

					/* Other definitions should have

					 * complete type */

					ERROR err2 =

					    ERR_basic_types_def_incompl(id);

					err = concat_error(err, err2);

					report(crt_loc, err);

				}

			}

			err = check_abstract(t);

			if (!IS_NULL_err(err)) {

				/* Objects can't have abstract type */

				ERROR err2 = ERR_class_abstract_decl(id);

				err = concat_error(err, err2);

				report(crt_loc, err);

			}

		}

	}

	return;

}

/*

    DECLARE AN OBJECT

    This routine constructs the declaration of an object with declaration

    specifiers ds, type t and name id.