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

#include "exp_ops.h"

#include "hashid_ops.h"

#include "id_ops.h"

#include "tok_ops.h"

#include "type_ops.h"

#include "error.h"

#include "catalog.h"

#include "option.h"

#include "allocate.h"

#include "basetype.h"

#include "cast.h"

#include "chktype.h"

#include "class.h"

#include "construct.h"

#include "convert.h"

#include "declare.h"

#include "derive.h"

#include "destroy.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 "namespace.h"

#include "predict.h"

#include "redeclare.h"

#include "statement.h"

#include "syntax.h"

#include "template.h"

#include "tokdef.h"

#include "typeid.h"

/*

    THE SET OF ALL TYPES

    The dummy list univ_type_set is used to represent the set of all

    types.  These sets of types are used to represent exception

    specifications for functions.  The list empty_type_set is used to

    give the exception specification for a function when none is given,

    by default it equals univ_type_set.

*/

LIST ( TYPE ) univ_type_set = NULL_list ( TYPE ) ;

LIST ( TYPE ) empty_type_set = NULL_list ( TYPE ) ;

/*

    INITIALISE THE SET OF ALL TYPES

    This routine initialises the set of all types to a dummy unique list.

*/

void init_exception

    PROTO_Z ()

{

    LIST ( TYPE ) p ;

    CONS_type ( type_any, NULL_list ( TYPE ), p ) ;

    p = uniq_type_set ( p ) ;

    COPY_list ( type_func_except ( type_func_void ), p ) ;

    COPY_list ( type_func_except ( type_temp_func ), p ) ;

    empty_type_set = p ;

    univ_type_set = p ;

    return ;

}

/*

    IS A TYPE IN A SET OF TYPES?

    This routine checks whether the type t is an element of the set of

    types listed as p.

*/

int in_type_set

    PROTO_N ( ( p, t ) )

    PROTO_T ( LIST ( TYPE ) p X TYPE t )

{

    if ( EQ_list ( p, univ_type_set ) ) return ( 1 ) ;

    expand_tokdef++ ;

    while ( !IS_NULL_list ( p ) ) {

	TYPE s = DEREF_type ( HEAD_list ( p ) ) ;

	if ( EQ_type ( t, s ) || eq_type_unqual ( t, s ) ) {

	    expand_tokdef-- ;

	    return ( 1 ) ;

	}

	p = TAIL_list ( p ) ;

    }

    expand_tokdef-- ;

    return ( 0 ) ;

}

/*

    IS A TYPE DERIVABLE FROM A SET OF TYPES?

    This routine checks whether an exception of type t will be caught by

    an element of the set of types listed as p.  It returns the catching

    type, or the null type if no match is found.

*/

static TYPE from_type_set

    PROTO_N ( ( p, t ) )

    PROTO_T ( LIST ( TYPE ) p X TYPE t )

{

    if ( EQ_list ( p, univ_type_set ) ) {

	/* The universal set catches everything */

	return ( t ) ;

    }

    expand_tokdef++ ;

    if ( IS_type_ref ( t ) ) t = DEREF_type ( type_ref_sub ( t ) ) ;

    while ( !IS_NULL_list ( p ) ) {

	TYPE r = DEREF_type ( HEAD_list ( p ) ) ;

	if ( !IS_NULL_type ( r ) ) {

	    TYPE s = r ;

	    unsigned rank ;

	    CONVERSION conv ;

	    if ( IS_type_ref ( s ) ) s = DEREF_type ( type_ref_sub ( s ) ) ;

	    if ( eq_type_unqual ( t, s ) ) {

		/* Exact match is allowed */

		expand_tokdef-- ;

		return ( r ) ;

	    }

	    conv.from = t ;

	    conv.to = s ;

	    rank = std_convert_seq ( &conv, NULL_exp, 0, 0 ) ;

	    switch ( rank ) {

		case CONV_EXACT :

		case CONV_QUAL :

		case CONV_BASE :

		case CONV_PTR_BASE :

		case CONV_PTR_VOID :

		case CONV_PTR_BOTTOM : {

		    /* These conversions are allowed */

		    expand_tokdef-- ;

		    return ( r ) ;

		}

	    }

	}

	p = TAIL_list ( p ) ;

    }

    expand_tokdef-- ;

    return ( NULL_type ) ;

}

/*

    ARE TWO TYPE SETS EQUAL?

    This routine checks whether the sets of types listed as p and q are

    equal.  It returns 2 if they are equal, 1 if p is a subset of q, and

    duplicate elements a fair amount can be deduced from the cardinalities

    of the sets, also the search is optimised if the types are given in

    the same order in each set.  If eq is true then only equality is

    checked for.

*/

int eq_type_set

    PROTO_N ( ( p, q, eq ) )

    PROTO_T ( LIST ( TYPE ) p X LIST ( TYPE ) q X int eq )

{

    unsigned n, m ;

    LIST ( TYPE ) r ;

    /* Deal with the set of all types */

    if ( EQ_list ( p, q ) ) return ( 2 ) ;

    if ( EQ_list ( q, univ_type_set ) && !eq ) return ( 1 ) ;

    if ( EQ_list ( p, univ_type_set ) ) return ( 0 ) ;

    /* Check whether p is larger than q */

    n = LENGTH_list ( p ) ;

    m = LENGTH_list ( q ) ;

    if ( n > m ) return ( 0 ) ;

    if ( n < m && eq ) return ( 0 ) ;

    /* Check whether p is a subset of q */

    r = q ;

    while ( !IS_NULL_list ( p ) ) {

	TYPE t = DEREF_type ( HEAD_list ( p ) ) ;

	TYPE s = DEREF_type ( HEAD_list ( r ) ) ;

	if ( !EQ_type ( t, s ) && !eq_type_unqual ( t, s ) ) {

	    if ( !in_type_set ( q, t ) ) return ( 0 ) ;

	}

	r = TAIL_list ( r ) ;

	p = TAIL_list ( p ) ;

    }

    /* Check for equality using set sizes */

    if ( n < m ) return ( 1 ) ;

    return ( 2 ) ;

}

/*

    ADD AN ELEMENT TO A TYPE SET

    This routine adds the type t to the type set p if it is not already

    a member.

*/

LIST ( TYPE ) cons_type_set

    PROTO_N ( ( p, t ) )

    PROTO_T ( LIST ( TYPE ) p X TYPE t )

{

    if ( !IS_NULL_type ( t ) && !in_type_set ( p, t ) ) {

	CONS_type ( t, p, p ) ;

    }

    return ( p ) ;

}

/*

    FIND THE UNION OF TWO TYPE SETS

    This routine adds the elements of the type set q to the type set p.

*/

LIST ( TYPE ) union_type_set

    PROTO_N ( ( p, q ) )

    PROTO_T ( LIST ( TYPE ) p X LIST ( TYPE ) q )

{

    if ( !EQ_list ( p, univ_type_set ) ) {

	if ( EQ_list ( q, univ_type_set ) ) {

	    DESTROY_list ( p, SIZE_type ) ;

	    p = q ;

	} else {

	    while ( !IS_NULL_list ( q ) ) {

		TYPE t = DEREF_type ( HEAD_list ( q ) ) ;

		if ( !IS_NULL_type ( t ) ) {

		    if ( !in_type_set ( p, t ) ) CONS_type ( t, p, p ) ;

		}

		q = TAIL_list ( q ) ;

	    }

	}

    }

    return ( p ) ;

}

/*

    MAKE A UNIQUE COPY OF A TYPE SET

    This routine maintains a list of type sets.  If p equals an element of

    this list then the copy is returned and p is destroyed.  Otherwise p

    is added to the list.

*/

LIST ( TYPE ) uniq_type_set

    PROTO_N ( ( p ) )

    PROTO_T ( LIST ( TYPE ) p )

{

    static LIST ( LIST ( TYPE ) ) sets = NULL_list ( LIST ( TYPE ) ) ;

    LIST ( LIST ( TYPE ) ) s = sets ;

    while ( !IS_NULL_list ( s ) ) {

	LIST ( TYPE ) q = DEREF_list ( HEAD_list ( s ) ) ;

	if ( eq_type_set ( p, q, 1 ) == 2 ) {

	    DESTROY_list ( p, SIZE_type ) ;

	    return ( q ) ;

	}

	s = TAIL_list ( s ) ;

    }

    CONS_list ( p, sets, sets ) ;

    return ( p ) ;

}

/*

    COMPARE THE EXCEPTION SPECIFIERS OF TWO TYPES

    This routine compares the exception specifiers of the similar types

    s and t.  It returns 2 if they are equal, 1 if s is more constrained

    than t, and 0 otherwise.

*/

int eq_except

    PROTO_N ( ( s, t ) )

    PROTO_T ( TYPE s X TYPE t )

{

    unsigned ns, nt ;

    if ( EQ_type ( s, t ) ) return ( 2 ) ;

    if ( IS_NULL_type ( s ) ) return ( 0 ) ;

    if ( IS_NULL_type ( t ) ) return ( 0 ) ;

    ns = TAG_type ( s ) ;

    nt = TAG_type ( t ) ;

    if ( ns != nt ) return ( 2 ) ;

    ASSERT ( ORDER_type == 18 ) ;

    switch ( ns ) {

	case type_func_tag : {

	    /* Function types */

	    LIST ( TYPE ) es = DEREF_list ( type_func_except ( s ) ) ;

	    LIST ( TYPE ) et = DEREF_list ( type_func_except ( t ) ) ;

	    int eq = eq_type_set ( es, et, 0 ) ;

	    if ( eq ) {

		TYPE rs, rt ;

		LIST ( TYPE ) ps = DEREF_list ( type_func_ptypes ( s ) ) ;

		LIST ( TYPE ) pt = DEREF_list ( type_func_ptypes ( t ) ) ;

		while ( !IS_NULL_list ( ps ) && !IS_NULL_list ( pt ) ) {

		    rs = DEREF_type ( HEAD_list ( ps ) ) ;

		    rt = DEREF_type ( HEAD_list ( pt ) ) ;

		    if ( eq_except ( rs, rt ) != 2 ) return ( 0 ) ;

		    pt = TAIL_list ( pt ) ;

		    ps = TAIL_list ( ps ) ;

		}

		rs = DEREF_type ( type_func_ret ( s ) ) ;

		rt = DEREF_type ( type_func_ret ( t ) ) ;

		if ( eq_except ( rs, rt ) != 2 ) return ( 0 ) ;

	    }

	    return ( eq ) ;

	}

	case type_ptr_tag :

	case type_ref_tag : {

	    /* Pointer and reference types */

	    TYPE ps = DEREF_type ( type_ptr_etc_sub ( s ) ) ;

	    TYPE pt = DEREF_type ( type_ptr_etc_sub ( t ) ) ;

	    return ( eq_except ( ps, pt ) ) ;

	}

	case type_ptr_mem_tag : {

	    /* Pointer to member types */

	    TYPE ps = DEREF_type ( type_ptr_mem_sub ( s ) ) ;

	    TYPE pt = DEREF_type ( type_ptr_mem_sub ( t ) ) ;

	    return ( eq_except ( ps, pt ) ) ;

	}

	case type_array_tag : {

	    /* Array types */

	    TYPE ps = DEREF_type ( type_array_sub ( s ) ) ;

	    TYPE pt = DEREF_type ( type_array_sub ( t ) ) ;

	    return ( eq_except ( ps, pt ) ) ;

	}

	case type_templ_tag : {

	    /* Template types */

	    TOKEN as = DEREF_tok ( type_templ_sort ( s ) ) ;

	    TOKEN at = DEREF_tok ( type_templ_sort ( t ) ) ;

	    LIST ( IDENTIFIER ) qs = DEREF_list ( tok_templ_pids ( as ) ) ;

	    LIST ( IDENTIFIER ) qt = DEREF_list ( tok_templ_pids ( at ) ) ;

	    int eq = eq_templ_params ( qs, qt ) ;

	    if ( eq ) {

		TYPE ps = DEREF_type ( type_templ_defn ( s ) ) ;

		TYPE pt = DEREF_type ( type_templ_defn ( t ) ) ;

		eq = eq_except ( ps, pt ) ;

	    }

	    restore_templ_params ( qs ) ;

	    return ( eq ) ;

	}

    }

    return ( 2 ) ;

}

/*

    CREATE AN EXCEPTION TYPE

    This routine converts the exception type t to its primary form.

    Reference types are replaced by the referenced type and any top level

    type qualifiers are removed.  chk gives the context for the conversion,

    1 for a throw expression, 2 for a catch statement, 3 for an exception

    specifier and 0 otherwise.

*/

TYPE exception_type

    PROTO_N ( ( t, chk ) )

    PROTO_T ( TYPE t X int chk )

{

    if ( !IS_NULL_type ( t ) ) {

	unsigned tag = TAG_type ( t ) ;

	if ( tag == type_ref_tag ) {

	    t = DEREF_type ( type_ref_sub ( t ) ) ;

	    tag = TAG_type ( t ) ;

	}

	t = qualify_type ( t, cv_none, 0 ) ;

	if ( chk ) {

	    /* Check exception type */

	    TYPE s = t ;

	    if ( tag == type_ptr_tag ) {

		s = DEREF_type ( type_ptr_sub ( s ) ) ;

		tag = TAG_type ( s ) ;

	    }

	    if ( tag == type_compound_tag ) {

		ERROR err = check_incomplete ( s ) ;

		if ( !IS_NULL_err ( err ) ) {

		    /* Can't have an incomplete class */

		    ERROR err2 = NULL_err ;

		    switch ( chk ) {

			case 1 : err2 = ERR_except_throw_incompl () ; break ;

			case 2 : err2 = ERR_except_handle_incompl () ; break ;

			case 3 : err2 = ERR_except_spec_incompl () ; break ;

		    }

		    err = concat_error ( err, err2 ) ;

		    report ( crt_loc, err ) ;

		}

		if ( chk == 1 ) {

		    /* Can't throw a type with an ambiguous base */

		    CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( s ) ) ;

		    err = class_info ( cs, cinfo_ambiguous, 1 ) ;

		    if ( !IS_NULL_err ( err ) ) {

			ERROR err2 = ERR_except_throw_ambig () ;

			err = concat_error ( err, err2 ) ;

			report ( crt_loc, err ) ;

		    }

		}

	    }

	}

    }

    return ( t ) ;

}

/*

    CHECK AN EXCEPTION SPECIFIER TYPE

    This routine checks the type t, which forms part of an exception

    specification for a function.  The argument n gives the number of types

    defined in t.

*/

TYPE check_except_type

    PROTO_N ( ( t, n ) )

    PROTO_T ( TYPE t X int n )

{

    if ( n ) report ( crt_loc, ERR_except_spec_typedef () ) ;

    IGNORE exception_type ( t, 3 ) ;

    return ( t ) ;

}

/*

    STACK OF CURRENTLY ACTIVE TRY BLOCKS

    The stack crt_try_block is used to hold all the currently active try

    blocks and exception handlers.  The flag in_func_handler is set to

    1 (or 2 for constructors and destructors) in the handler of a function

    try block.

*/

STACK ( EXP ) crt_try_blocks = NULL_stack ( EXP ) ;

static STACK ( STACK ( EXP ) ) past_try_blocks = NULL_stack ( STACK ( EXP ) ) ;

int in_func_handler = 0 ;

/*

    CHECK A THROWN TYPE

    This routine checks the type t thrown from an explicit throw expression

    (if expl is true) or a function call.  The null type is used to

    indicate an unknown type.  The routine returns true if the exception

    is caught by an enclosing handler.

*/

int check_throw

    PROTO_N ( ( t, expl ) )

    PROTO_T ( TYPE t X int expl )

{

    IDENTIFIER fn ;

    LIST ( EXP ) p = LIST_stack ( crt_try_blocks ) ;

    while ( !IS_NULL_list ( p ) ) {

	EXP e = DEREF_exp ( HEAD_list ( p ) ) ;

	if ( IS_exp_try_block ( e ) ) {

	    /* Add to list of thrown types */

	    LIST ( TYPE ) q ;

	    q = DEREF_list ( exp_try_block_ttypes ( e ) ) ;

	    if ( !EQ_list ( q, univ_type_set ) ) {

		LIST ( LOCATION ) ql ;

		ql = DEREF_list ( exp_try_block_tlocs ( e ) ) ;

		if ( IS_NULL_type ( t ) ) {

		    DESTROY_list ( q, SIZE_type ) ;

		    DESTROY_list ( ql, SIZE_loc ) ;

		    q = univ_type_set ;

		    ql = NULL_list ( LOCATION ) ;

		    CONS_loc ( crt_loc, ql, ql ) ;

		} else {

		    if ( !in_type_set ( q, t ) ) {

			CONS_type ( t, q, q ) ;

			CONS_loc ( crt_loc, ql, ql ) ;

		    }

		}

		COPY_list ( exp_try_block_ttypes ( e ), q ) ;

		COPY_list ( exp_try_block_tlocs ( e ), ql ) ;

	    }

	    return ( 1 ) ;

	}

	if ( IS_NULL_type ( t ) && expl && IS_exp_handler ( e ) ) {

	    /* Can deduce type of 'throw' inside a handler */

	    IDENTIFIER ex = DEREF_id ( exp_handler_except ( e ) ) ;

	    if ( !IS_NULL_id ( ex ) ) {

		t = DEREF_type ( id_variable_etc_type ( ex ) ) ;

		t = exception_type ( t, 0 ) ;

	    }

	}

	p = TAIL_list ( p ) ;

    }

    /* Exception not caught by any try block */

    fn = crt_func_id ;

    if ( IS_NULL_type ( t ) ) t = type_any ;

    if ( IS_NULL_id ( fn ) ) {

	report ( crt_loc, ERR_except_spec_throw ( t ) ) ;

    } else {

	report ( crt_loc, ERR_except_spec_call ( fn, t ) ) ;

    }

    return ( 0 ) ;

}

/*

    CHECK THE EXCEPTIONS THROWN IN A TRY BLOCK

    This routine checks the exceptions thrown in the try block e.  Any

    which are not caught by the handlers of e are passed to the enclosing

    block or reported if this is the outermost block.  The routine

    returns true if all the exceptions are handled by an enclosing block.

*/

int check_try_block

    PROTO_N ( ( e ) )

    PROTO_T ( EXP e )

{

    int res = 1 ;

    if ( IS_exp_try_block ( e ) ) {

	LOCATION loc ;

	LIST ( LOCATION ) ql ;

	LIST ( TYPE ) p = DEREF_list ( exp_try_block_htypes ( e ) ) ;

	LIST ( TYPE ) q = DEREF_list ( exp_try_block_ttypes ( e ) ) ;

	EXP a = DEREF_exp ( exp_try_block_ellipsis ( e ) ) ;

	if ( EQ_list ( p, univ_type_set ) ) {

	    /* Have handlers for any type */

	    return ( 1 ) ;

	}

	if ( !IS_NULL_exp ( a ) && IS_exp_handler ( a ) ) {

	    /* Have a ... handler */

	    return ( 1 ) ;

	}

	bad_crt_loc++ ;

	loc = crt_loc ;

	ql = DEREF_list ( exp_try_block_tlocs ( e ) ) ;

	if ( EQ_list ( q, univ_type_set ) ) {

	    /* Can throw any type */

	    DEREF_loc ( HEAD_list ( ql ), crt_loc ) ;

	    res = check_throw ( NULL_type, 0 ) ;

	} else {

	    /* Can throw a finite set of types */

	    q = REVERSE_list ( q ) ;

	    ql = REVERSE_list ( ql ) ;

	    COPY_list ( exp_try_block_ttypes ( e ), q ) ;

	    COPY_list ( exp_try_block_tlocs ( e ), ql ) ;

	    while ( !IS_NULL_list ( q ) ) {

		TYPE t = DEREF_type ( HEAD_list ( q ) ) ;

		TYPE u = from_type_set ( p, t ) ;

		if ( IS_NULL_type ( u ) ) {

		    /* Throw uncaught type to enclosing block */

		    DEREF_loc ( HEAD_list ( ql ), crt_loc ) ;

		    if ( !check_throw ( t, 0 ) ) res = 0 ;

		}

		ql = TAIL_list ( ql ) ;

		q = TAIL_list ( q ) ;

	    }

	}

	crt_loc = loc ;

	bad_crt_loc-- ;

    }

    return ( res ) ;

}

/*

    CHECK THE EXCEPTIONS THROWN BY A FUNCTION CALL

    This routine checks the possible exceptions thrown by a call to a

    function of type fn.  When known the function name is given by fid.

    The routine returns true if the exception is handled by an enclosing

    try-block.

*/

int check_func_throw

    PROTO_N ( ( fn, fid ) )

    PROTO_T ( TYPE fn X IDENTIFIER fid )

{

    int res = 1 ;

    if ( IS_type_func ( fn ) ) {

	LIST ( TYPE ) p = DEREF_list ( type_func_except ( fn ) ) ;

	if ( IS_NULL_list ( p ) ) return ( 1 ) ;

	if ( EQ_list ( p, univ_type_set ) ) {

	    /* Can throw any type */

	    res = check_throw ( NULL_type, 0 ) ;

	} else {

	    /* Can throw a finite set of types */

	    while ( !IS_NULL_list ( p ) ) {

		TYPE t = DEREF_type ( HEAD_list ( p ) ) ;

		if ( !IS_NULL_type ( t ) ) {

		    if ( !check_throw ( t, 0 ) ) res = 0 ;

		}

		p = TAIL_list ( p ) ;

	    }

	}

    } else {

	res = check_throw ( NULL_type, 0 ) ;

    }

    UNUSED ( fid ) ;

    return ( res ) ;

}

/*

    START THE EXCEPTION CHECKS FOR A FUNCTION DEFINITION

    This routine starts the exception specification checks for a function

    which throws the types p.

*/

void start_try_check

    PROTO_N ( ( p ) )

    PROTO_T ( LIST ( TYPE ) p )

{

    EXP e ;

    MAKE_exp_try_block ( type_void, NULL_exp, 0, e ) ;

    COPY_list ( exp_try_block_htypes ( e ), p ) ;

    PUSH_stack ( crt_try_blocks, past_try_blocks ) ;

    crt_try_blocks = NULL_stack ( EXP ) ;

    PUSH_exp ( e, crt_try_blocks ) ;

    return ;

}

/*

    END THE EXCEPTION CHECKS FOR A FUNCTION DEFINITION

    This routine ends the exception specification checks for the function

    id with definition a.

*/

EXP end_try_check

    PROTO_N ( ( id, a ) )

    PROTO_T ( IDENTIFIER id X EXP a )

{

    EXP e ;

    POP_exp ( e, crt_try_blocks ) ;

    POP_stack ( crt_try_blocks, past_try_blocks ) ;

    if ( !IS_NULL_exp ( e ) && IS_exp_try_block ( e ) ) {

	IDENTIFIER fid = crt_func_id ;

	crt_func_id = id ;

	IGNORE check_try_block ( e ) ;

	if ( EQ_id ( fid, id ) ) {

	    LIST ( TYPE ) p = DEREF_list ( exp_try_block_ttypes ( e ) ) ;

	    if ( IS_NULL_list ( p ) && !in_template_decl ) {

		/* Function can't throw an exception */

		DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;

		ds |= dspec_friend ;

		COPY_dspec ( id_storage ( id ), ds ) ;

	    }

	}

	COPY_list ( exp_try_block_htypes ( e ), NULL_list ( TYPE ) ) ;

	free_exp ( e, 1 ) ;

	crt_func_id = fid ;

    }

    return ( a ) ;

}

/*

    EXCEPTION HANDLING ROUTINES

    The exception handling routines are only included in the C++ producer.

*/

#if LANGUAGE_CPP

/*

    BEGIN THE CONSTRUCTION OF A TRY STATEMENT

    This routine begins the construction of the statement 'try { body }

    handlers'.  It is called immediately after the 'try'.  func is true

    for a function-try-block.

*/

EXP begin_try_stmt

    PROTO_N ( ( func ) )

    PROTO_T ( int func )

{

    EXP e ;

    if ( func ) {

	/* Check function try blocks */

	IDENTIFIER fn = crt_func_id ;

	if ( !IS_NULL_id ( fn ) ) {

	    HASHID nm = DEREF_hashid ( id_name ( fn ) ) ;

	    unsigned tag = TAG_hashid ( nm ) ;

	    if ( tag == hashid_constr_tag || tag == hashid_destr_tag ) {

		/* Constructors and destructors are marked */

		func = 2 ;

	    }

	} else {

	    func = 0 ;

	}

    }

    MAKE_exp_try_block ( type_void, NULL_exp, func, e ) ;

    CONS_exp ( e, all_try_blocks, all_try_blocks ) ;

    PUSH_exp ( e, crt_try_blocks ) ;

    return ( e ) ;

}

/*

    INJECT FUNCTION PARAMETERS INTO A HANDLER

    It is not allowed to redeclare a function parameter in the body or

    the handler of a function-try-block.  This routine ensures this by

    injecting the function parameters into the current scope when prev

    is a function-try-block.

*/

void inject_try_stmt

    PROTO_N ( ( prev ) )

    PROTO_T ( EXP prev )

{

    int func = DEREF_int ( exp_try_block_func ( prev ) ) ;

    if ( func ) {

	IDENTIFIER id = crt_func_id ;

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

	    LIST ( IDENTIFIER ) pids ;

	    NAMESPACE ns = crt_namespace ;

	    TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;

	    while ( IS_type_templ ( t ) ) {

		t = DEREF_type ( type_templ_defn ( t ) ) ;

	    }

	    pids = DEREF_list ( type_func_pids ( t ) ) ;

	    while ( !IS_NULL_list ( pids ) ) {

		IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;

		IGNORE redeclare_id ( ns, pid ) ;

		pids = TAIL_list ( pids ) ;

	    }

	}

    }

    return ;

}

/*

    CONTINUE THE CONSTRUCTION OF A TRY STATEMENT

    This routine continues the contruction of the try statement prev by

    filling in the given body statement.

*/

EXP cont_try_stmt

    PROTO_N ( ( prev, body ) )

    PROTO_T ( EXP prev X EXP body )

{

    EXP e ;

    int func = DEREF_int ( exp_try_block_func ( prev ) ) ;

    if ( func ) in_func_handler = func ;

    COPY_exp ( exp_try_block_body ( prev ), body ) ;

    set_parent_stmt ( body, prev ) ;

    POP_exp ( e, crt_try_blocks ) ;

    UNUSED ( e ) ;

    return ( prev ) ;

}

/*

    COMPLETE THE CONSTRUCTION OF A TRY STATEMENT

    This routine completes the contruction of the try statement prev.  It

    checks whether it contains at least one handler and determines the

    reachability of the following statement.

*/

EXP end_try_stmt

    PROTO_N ( ( prev, empty ) )

    PROTO_T ( EXP prev X int empty )

{

    EXP e ;

    TYPE t ;

    int all_bottom = 1 ;

    int func = DEREF_int ( exp_try_block_func ( prev ) ) ;

    /* Check handler list */

    EXP ell = DEREF_exp ( exp_try_block_ellipsis ( prev ) ) ;

    LIST ( EXP ) hs = DEREF_list ( exp_try_block_handlers ( prev ) ) ;

    LIST ( TYPE ) ps = DEREF_list ( exp_try_block_ttypes ( prev ) ) ;

    unsigned nh = LENGTH_list ( hs ) ;

    if ( IS_NULL_exp ( ell ) ) {

	/* Create default handler if necessary */

	if ( IS_NULL_list ( hs ) && !empty ) {

	    /* Check that there is at least one handler */

	    report ( crt_loc, ERR_except_handlers () ) ;

	}

	MAKE_exp_exception ( type_bottom, ell, NULL_exp, NULL_exp, 0, ell ) ;

	COPY_exp ( exp_try_block_ellipsis ( prev ), ell ) ;

    } else {

	nh++ ;

    }

    IGNORE check_value ( OPT_VAL_exception_handlers, ( ulong ) nh ) ;

    /* Do unreached code analysis */

    e = DEREF_exp ( exp_try_block_body ( prev ) ) ;

    t = DEREF_type ( exp_type ( e ) ) ;

    if ( IS_type_bottom ( t ) ) {

	/* Don't reach end of try block */

	t = DEREF_type ( exp_type ( ell ) ) ;

	if ( !IS_type_bottom ( t ) ) all_bottom = 0 ;

	while ( !IS_NULL_list ( hs ) && all_bottom ) {

	    /* Check the other handlers */

	    e = DEREF_exp ( HEAD_list ( hs ) ) ;

	    t = DEREF_type ( exp_type ( e ) ) ;

	    if ( !IS_type_bottom ( t ) ) all_bottom = 0 ;

	    hs = TAIL_list ( hs ) ;

	}

    } else {

	/* Reach end of try block */

	all_bottom = 0 ;

    }

    if ( all_bottom ) {

	COPY_type ( exp_type ( prev ), type_bottom ) ;

	unreached_code = 1 ;

	unreached_last = 0 ;

    } else {

	unreached_code = unreached_prev ;

    }

    if ( IS_NULL_list ( ps ) && !empty && !in_template_decl ) {

	report ( crt_loc, ERR_except_not () ) ;

    }

    if ( func ) in_func_handler = 0 ;

    IGNORE check_try_block ( prev ) ;

    return ( prev ) ;

}

/*

    MARK ALL VARIABLES ENCLOSING A TRY BLOCK

    This routine marks all the local variables of the function id which

    contain a try block within their scope.

*/

void end_try_blocks

    PROTO_N ( ( id ) )

    PROTO_T ( IDENTIFIER id )

{

    LIST ( EXP ) p = all_try_blocks ;

    if ( !IS_NULL_list ( p ) ) {