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

#include "exp_ops.h"

#include "hashid_ops.h"

#include "id_ops.h"

#include "loc_ext.h"

#include "member_ops.h"

#include "nspace_ops.h"

#include "str_ops.h"

#include "type_ops.h"

#include "error.h"

#include "catalog.h"

#include "option.h"

#include "assign.h"

#include "basetype.h"

#include "cast.h"

#include "check.h"

#include "chktype.h"

#include "class.h"

#include "constant.h"

#include "construct.h"

#include "convert.h"

#include "declare.h"

#include "destroy.h"

#include "dump.h"

#include "exception.h"

#include "expression.h"

#include "file.h"

#include "function.h"

#include "hash.h"

#include "identifier.h"

#include "initialise.h"

#include "label.h"

#include "lex.h"

#include "literal.h"

#include "member.h"

#include "namespace.h"

#include "overload.h"

#include "parse.h"

#include "predict.h"

#include "quality.h"

#include "redeclare.h"

#include "statement.h"

#include "symbols.h"

#include "syntax.h"

#include "template.h"

#include "ustring.h"

#include "variable.h"

/*

    UNREACHED CODE ANALYSIS

    The detection of unreachable code is primarily by means of the simple

    flag, which is true for unreported statements.  The flag unreached_last

    is set to equal unreached_code whenever a reachability check is applied.

    This is to ensure that only the first statement in an unreached block

    is reported.  At the end of a conditional, or other complex statement,

    unreached_prev is set to the value of unreached_code at the start of

    that statement.  The flag unreached_fall is set to false immediately

    following a 'case' or 'default' label, but set to true after a non-

    trivial statement (this is included in the grammar).

*/

int unreached_code = 0;

int unreached_last = 0;

int unreached_prev = 0;

int unreached_fall = 0;

int suppress_fall = 0;

/*

    DOES AN EXPRESSION NOT RETURN?

    This routine tests whether the expression e has type bottom, i.e. does

    not return a value.

*/

static int

is_bottom(EXP e)

{

	TYPE t;

	if (IS_NULL_exp(e)) {

		return (0);

	}

	t = DEREF_type(exp_type(e));

	return (IS_type_bottom(t));

}

/*

    FIND THE PARENT OF A STATEMENT

    This routine returns a pointer to the parent of the statement e.  It

    returns the null pointer if e is a simple expression.

*/

static PTR(EXP)

parent_stmt(EXP e)

{

	PTR(EXP) ptr = NULL_ptr(EXP);

	if (!IS_NULL_exp(e)) {

		switch (TAG_exp(e)) {

		case exp_reach_tag:

			ptr = exp_reach_parent(e);

			break;

		case exp_unreach_tag:

			ptr = exp_unreach_parent(e);

			break;

		case exp_sequence_tag:

			ptr = exp_sequence_parent(e);

			break;

		case exp_solve_stmt_tag:

			ptr = exp_solve_stmt_parent(e);

			break;

		case exp_decl_stmt_tag:

			ptr = exp_decl_stmt_parent(e);

			break;

		case exp_if_stmt_tag:

			ptr = exp_if_stmt_parent(e);

			break;

		case exp_while_stmt_tag:

			ptr = exp_while_stmt_parent(e);

			break;

		case exp_do_stmt_tag:

			ptr = exp_do_stmt_parent(e);

			break;

		case exp_switch_stmt_tag:

			ptr = exp_switch_stmt_parent(e);

			break;

		case exp_hash_if_tag:

			ptr = exp_hash_if_parent(e);

			break;

		case exp_return_stmt_tag:

			ptr = exp_return_stmt_parent(e);

			break;

		case exp_goto_stmt_tag:

			ptr = exp_goto_stmt_parent(e);

			break;

		case exp_label_stmt_tag:

			ptr = exp_label_stmt_parent(e);

			break;

		case exp_try_block_tag:

			ptr = exp_try_block_parent(e);

			break;

		case exp_handler_tag:

			ptr = exp_handler_parent(e);

			break;

		case exp_token_tag:

			ptr = exp_token_parent(e);

			break;

		case exp_location_tag: {

			EXP a = DEREF_exp(exp_location_arg(e));

			ptr = parent_stmt(a);

			break;

		}

		case exp_paren_tag: {

			EXP a = DEREF_exp(exp_paren_arg(e));

			ptr = parent_stmt(a);

			break;

		}

		}

	}

	return (ptr);

}

/*

    GET THE PARENT OF A STATEMENT

    This routine returns the parent statement of e.

*/

EXP

get_parent_stmt(EXP e)

{

	EXP p = NULL_exp;

	if (!IS_NULL_exp(e)) {

		PTR(EXP)ptr = parent_stmt(e);

		if (!IS_NULL_ptr(ptr)) {

			p = DEREF_exp(ptr);

		}

	}

	return (p);

}

/*

    SET THE PARENT OF A STATEMENT

    This routine sets the parent of the statement e to be p.

*/

void

set_parent_stmt(EXP e, EXP p)

{

	if (!IS_NULL_exp(e)) {

		PTR(EXP)ptr = parent_stmt(e);

		if (!IS_NULL_ptr(ptr)) {

			COPY_exp(ptr, p);

		}

	}

	return;

}

/*

    STATEMENT LOCATION FLAG

    The flag record_location may be set to true to force extra expressions

    giving the location of each statement to be inserted into the output.

    The variable stmt_loc records the last such location.

*/

int record_location = 0;

LOCATION stmt_loc = NULL_loc;

static int adjusted_line = 0;

/*

    ADJUST COLUMN NUMBER

    This routine sets stmt_loc to point to the start of the preprocessing

    token p.

*/

static void

adjust_column(PPTOKEN *p)

{

	if (p) {

		int t = p->tok;

		if (t >= FIRST_SYMBOL && t <= LAST_SYMBOL) {

			/* Adjust to start of symbol */

			ulong len = (ulong)ustrlen(token_name(t));

			stmt_loc = crt_loc;

			stmt_loc.column -= (len - 1);

			return;

		}

		if (t >= FIRST_KEYWORD && t <= LAST_KEYWORD) {

			/* Map keywords to underlying identifier */

			t = lex_identifier;

		}

		if (t == lex_identifier) {

			IDENTIFIER id = p->pp_data.id.use;

			id = underlying_id(id);

			DEREF_loc(id_loc(id), stmt_loc);

			return;

		}

	}

	stmt_loc = crt_loc;

	return;

}

/*

    ADJUST LINE NUMBER

    This routine is called whenever the location of a statement is

    recorded.  It is intended to ensure that the current location points

    to the start of the next statement rather than the end of the current

    statement.

*/

static void

adjust_line(int next)

{

	if (!adjusted_line) {

		adjusted_line = 1;

		if (next) {

			switch (crt_lex_token) {

			case lex_open_Hbrace_H1:

			case lex_colon:

			case lex_semicolon:

			case lex_close_Hround:

			case lex_else:

			case lex_exhaustive: {

				/* Scan to next token */

				PPTOKEN *p = crt_token->next;

				if (p) {

					/* Set location from next token */

					p = read_loc_tokens(p);

					if (crt_state_depth == 0) {

						adjust_column(p);

						return;

					}

				} else {

					if (crt_state_depth == 0) {

						/* Skip white space from input

						 * file */

						unsigned long sp =

						    skip_white(1);

						update_column();

						stmt_loc = crt_loc;

						stmt_loc.column++;

						if (sp) {

							patch_white(sp);

						}

						return;

					}

				}

				break;

			}

			default:

				/* Use current token */

				if (crt_state_depth == 0) {

					adjust_column(crt_token);

					return;

				}

				break;

			}

		}

		stmt_loc = crt_loc;

	}

	return;

}

/*

    BLOCK NAMESPACE

    This variable can be set to make begin_compound_stmt use an existing

    namespace rather than creating a new one.

*/

NAMESPACE block_namespace = NULL_nspace;

/*

    BEGIN A COMPOUND STATEMENT

    These routine begins the construction of a compound statement.  If

    scope is true then this compound statement also establishes a scope.

    A compound statement consists of a list of statements (the first of

    which is always a dummy null expression) plus a pointer indicating

    where the next statement to be added to the compound statement is to

    go.  For simple statement lists this is the last element of the list,

    but if labels or declarations are introduced then any statements added

    subsequently will go at the end of the dummy block introduced by

    begin_label_stmt or make_decl_stmt.  The parent field of the main

    statement is used within the construction to point to the innermost

    block of this kind.  It is only set to its correct value at the end

    of the compound statement.

*/

EXP

begin_compound_stmt(int scope)

{

	TYPE t;

	NAMESPACE ns;

	EXP e = NULL_exp;

	LIST(EXP) stmts;

	NAMESPACE cns = NULL_nspace;

	/* Create block namespace */

	if (scope > 0) {

		ns = block_namespace;

		if (IS_NULL_nspace(ns)) {

			/* Create new namespace */

			unsigned tag = nspace_block_tag;

			if (scope == 2) {

				tag = nspace_dummy_tag;

			}

			cns = crt_namespace;

			ns = make_namespace(crt_func_id, tag, 0);

			push_namespace(ns);

		} else {

			/* Use existing namespace */

			MEMBER mem = DEREF_member(nspace_last(ns));

			COPY_member(nspace_prev(ns), mem);

			cns = ns;

			block_namespace = NULL_nspace;

		}

		IGNORE incr_value(OPT_VAL_statement_depth);

	} else {

		ns = NULL_nspace;

	}

	/* Create compound statement */

	t = (unreached_code ? type_bottom : type_void);

	if (record_location && scope >= 0) {

		/* Record start of block */

		adjust_line(scope);

		adjusted_line = 0;

		MAKE_exp_location(t, stmt_loc, e, e);

		if (do_scope) {

			dump_begin_scope(NULL_id, ns, cns, &crt_loc);

		}

	}

	CONS_exp(e, NULL_list(EXP), stmts);

	MAKE_exp_sequence(t, stmts, stmts, ns, 0, e);

	COPY_exp(exp_sequence_parent(e), e);

	return (e);

}

/*

    MARK THE START OF A COMPOUND STATEMENT

    On occasions a compound statement may be created before the open brace

    which marks its start.  In this case this routine is called when the

    open brace is encountered to record the actual position of the start

    of the block.

*/

void

mark_compound_stmt(EXP prev)

{

	if (record_location) {

		LIST(EXP) stmts = DEREF_list(exp_sequence_first(prev));

		EXP stmt = DEREF_exp(HEAD_list(stmts));

		if (!IS_NULL_exp(stmt) && IS_exp_location(stmt)) {

			adjust_line(1);

			adjusted_line = 0;

			COPY_loc(exp_location_end(stmt), stmt_loc);

		}

	}

	return;

}

/*

    EXTEND A COMPOUND STATEMENT

    This routine adds the statement stmt to the end of the compound

    statement prev.  Note that this routine also decides where the

    statement after this one is to go on the basis of the rules above.

*/

static EXP

extend_compound_stmt(EXP prev, EXP stmt, int loc)

{

	EXP body;

	EXP parent;

	LIST(EXP) elem;

	LIST(EXP) elem0;

	LIST(EXP) stmts;

	/* Allow for null statements */

	if (IS_NULL_exp(stmt)) {

		return (prev);

	}

	/* Add statement to list */

	stmts = DEREF_list(exp_sequence_last(prev));

	CONS_exp(stmt, NULL_list(EXP), elem);

	COPY_list(PTR_TAIL_list(stmts), elem);

	elem0 = elem;

	/* Set the parent of stmt */

	parent = DEREF_exp(exp_sequence_parent(prev));

	set_parent_stmt(stmt, parent);

	/* Find location of next statement */

	switch (TAG_exp(stmt)) {

	case exp_decl_stmt_tag: {

		/* Transfer to the body of a declaration */

		unsigned tag;

		body = stmt;

		do {

			body = DEREF_exp(exp_decl_stmt_body(body));

			tag = TAG_exp(body);

		} while (tag == exp_decl_stmt_tag);

		if (tag == exp_sequence_tag) {

			elem = DEREF_list(exp_sequence_last(body));

			COPY_exp(exp_sequence_parent(prev), body);

		}

		loc = 0;

		break;

	}

	case exp_label_stmt_tag:

		/* Transfer to the body of a labelled statement */

		body = DEREF_exp(exp_label_stmt_body(stmt));

		if (IS_exp_sequence(body)) {

			elem = DEREF_list(exp_sequence_last(body));

			COPY_exp(exp_sequence_parent(prev), body);

		}

		loc = 0;

		break;

	case exp_location_tag:

	case exp_thrown_tag:

		/* Don't record location in these cases */

		loc = 0;

		break;

	}

	COPY_list(exp_sequence_last(prev), elem);

	/* Record statement location */

	if (record_location) {

		adjust_line(1);

		if (loc) {

			TYPE t = DEREF_type(exp_type(stmt));

			MAKE_exp_location(t, stmt_loc, stmt, stmt);

			COPY_exp(HEAD_list(elem0), stmt);

		}

	}

	/* Unreached code analysis */

	if (is_bottom(stmt)) {

		COPY_type(exp_type(prev), type_bottom);

	}

	return (prev);

}

/*

    ADD A STATEMENT TO A COMPOUND STATEMENT

    This routine adds the statement stmt to the compound statement prev,

    returning the resulting compound statement.  It differs from the

    previous routine in taking any declarations in stmt into account.

    This is done using the last field of the current namespace which keeps

    track of the last variable in the block for which a declaration

    statement has been introduced.  The treatment of labelled statements

    is tricky - the declarations need to be inserted between the label

    and its body.

*/

EXP

add_compound_stmt(EXP prev, EXP stmt)

{

    EXP parent = NULL_exp;

    LIST(EXP) last = NULL_list(EXP);

    NAMESPACE ns = DEREF_nspace(exp_sequence_decl(prev));

    if (!IS_NULL_nspace(ns)) {

	MEMBER p = DEREF_member(nspace_last(ns));

	MEMBER q = DEREF_member(nspace_prev(ns));

	if (!EQ_member(p, q)) {

	    /* Create declaration statement */

	    int vars = 0;

	    EXP decl = make_decl_stmt(p, q, &vars);

	    if (!IS_NULL_exp(stmt) && IS_exp_label_stmt(stmt)) {

		/* Labels come before declarations */

		EXP body = DEREF_exp(exp_label_stmt_body(stmt));

		if (IS_exp_sequence(body)) {

		    last = DEREF_list(exp_sequence_last(body));

		    body = DEREF_exp(HEAD_list(last));

		    if (!IS_NULL_exp(body)) {

			EXP b = body;

			if (IS_exp_location(b)) {

			    b = DEREF_exp(exp_location_arg(b));

			}

			if (!IS_NULL_exp(b)) {

			    COPY_exp(HEAD_list(last), NULL_exp);

			}

		    }

		    last = NULL_list(EXP);

		    prev = extend_compound_stmt(prev, stmt, 1);

		    stmt = body;

		}

	    }

	    if (!vars) {

		last = DEREF_list(exp_sequence_last(prev));

		parent = DEREF_exp(exp_sequence_parent(prev));

	    }

	    prev = extend_compound_stmt(prev, decl, 0);

	    COPY_member(nspace_prev(ns), p);

	}

    }

    if (!IS_NULL_exp(stmt)) {

	/* Add the new statement */

	prev = extend_compound_stmt(prev, stmt, 1);

    }

    if (!IS_NULL_list(last)) {

	/* Restrict scope of temporaries to stmt */

	last = END_list(last);

	COPY_list(exp_sequence_last(prev), last);

	COPY_exp(exp_sequence_parent(prev), parent);

    }

    adjusted_line = 0;

    return (prev);

}

/*

    END A COMPOUND STATEMENT

    This routine ends the compound statement prev.

*/

EXP

end_compound_stmt(EXP prev)

{

	/* Take local declarations out of scope */

	int blk = DEREF_int(exp_sequence_block(prev));

	NAMESPACE ns = DEREF_nspace(exp_sequence_decl(prev));

	if (!IS_NULL_nspace(ns)) {

		if (check_namespace(ns, prev, ANON_NONE, 1)) {

			if (blk == 0) {

				COPY_int(exp_sequence_block(prev), 1);

			}

		}

		if (do_scope) {

			dump_end_scope(NULL_id, ns, &stmt_loc);

		}

		decr_value(OPT_VAL_statement_depth);

		IGNORE pop_namespace();

	}

	COPY_exp(exp_sequence_parent(prev), NULL_exp);

	return (prev);

}

/*

    CONSTRUCT A TEMPORARY DECLARATION STATEMENT

    This routine binds any temporary variable declarations given by the

    namespace members p to q to the expression e.  This is part of the

    action of make_decl_stmt.

*/

EXP

make_temp_decl(MEMBER p, MEMBER q, EXP e)

{

	MEMBER r = p;

	while (!EQ_member(r, q)) {

		IDENTIFIER id = DEREF_id(member_id(r));

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

			/* Construct declaration statement */

			DECL_SPEC ds = DEREF_dspec(id_storage(id));

			if (ds & dspec_temp) {

				/* Temporary variables */

				if (!(ds & dspec_ignore)) {

					EXP d;

					TYPE t =

					    DEREF_type(id_variable_type(id));

					EXP term =

					    DEREF_exp(id_variable_term(id));

					if (!IS_NULL_exp(term)) {

						have_destructor = 1;

					}

					MAKE_exp_decl_stmt(t, id, e, d);

					set_parent_stmt(e, d);

					e = d;

				}

			}

		}

		r = DEREF_member(member_next(r));

	}

	return (e);

}

/*

    CONSTRUCT A DECLARATION STATEMENT

    This routine constructs a series of nested declaration statements

    corresponding to the given list of namespace members.  p gives the

    last member of the current block namespace defined, while q gives

    the last member defined before this declaration.  The body of a

    declaration statement consists of the rest of the statements in the

    enclosing block.  That is:

			{

			    stmt1 ;

			    ....

			    decl1 ;

			    decl2 ;

			    ....

			    body1 ;

			    ....

			}

    is transformed into:

			{

			    stmt1 ;

			    ....

			    decl1 ; {

				decl2 ; {

				    .... {

					body1 ;

					....

				    }

				}

			    }

			}

    except that the introduced blocks do not establish scopes.  Any

    temporary variables introduced are declared before the normal

    variables regardless of their actual order of declaration.

*/

EXP

make_decl_stmt(MEMBER p, MEMBER q, int *vars)

{

    MEMBER r = p;

    unsigned temps = 0;

    IDENTIFIER init = NULL_id;

    LIST(IDENTIFIER) destr = NULL_list(IDENTIFIER);

    EXP e = begin_compound_stmt(-1);

    /* Scan through members */

    while (!EQ_member(r, q)) {

	IDENTIFIER id = DEREF_id(member_id(r));

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

	    /* Construct declaration statement */

	    DECL_SPEC ds = DEREF_dspec(id_storage(id));

	    if (ds & dspec_temp) {

		/* Temporary variables */

		if (!(ds & dspec_ignore)) {

		    if (ds & dspec_register) {

			EXP term = DEREF_exp(id_variable_term(id));

			if (!IS_NULL_exp(term)) {

			    CONS_id(id, destr, destr);

			}

		    }

		    temps++;

		}

	    } else if (ds & dspec_linkage) {

		/* External variables */

		/* EMPTY */

	    } else if ((ds & dspec_reserve) && !is_anon_member(id)) {

		/* Injected variables */

		/* EMPTY */

	    } else {

		EXP d;

		TYPE t = DEREF_type(id_variable_type(id));

		EXP def = DEREF_exp(id_variable_init(id));

		EXP term = DEREF_exp(id_variable_term(id));

		if (!IS_NULL_exp(term)) {

			have_destructor = 1;

		}

		if (!IS_NULL_exp(def) && !IS_exp_null(def)) {

		    /* Identifier is initialised */

		    init = id;

		}

		MAKE_exp_decl_stmt(t, id, e, d);

		set_parent_stmt(e, d);

		*vars = 1;

		e = d;

	    }

	}

	r = DEREF_member(member_next(r));

    }

    /* Scan through again for temporary variables */

    if (temps) {

	e = make_temp_decl(p, q, e);

	if (!IS_NULL_list(destr)) {

	    /* NOT YET IMPLEMENTED */

	    DESTROY_list(destr, SIZE_id);

	}

    }

    /* Only report unreached declarations if they are initialised */

    if (!IS_NULL_id(init) && unreached_code) {

	if (!unreached_last) {

	    LOCATION loc;

	    DEREF_loc(id_loc(init), loc);

	    report(loc, ERR_stmt_stmt_unreach());

	    unreached_last = 1;

	}

    }

    return (e);

}

/*

    BIND TEMPORARY VARIABLES TO AN EXPRESSION

    This routine binds any temporary variables declared in e to the

    expression.  Reference conversions are also applied, but any

    parentheses are preserved for the benefit of the assignment in

    boolean check.

*/

EXP

bind_temporary(EXP e)

{

	if (!IS_NULL_exp(e)) {

		NAMESPACE ns = crt_namespace;

		unsigned tag = TAG_exp(e);

		e = convert_reference(e, REF_NORMAL);

		if (!IS_NULL_nspace(ns) && IS_nspace_block_etc(ns)) {

			MEMBER p = DEREF_member(nspace_last(ns));