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

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

#include "c_types.h"

#include "exp_ops.h"

#include "hashid_ops.h"

#include "id_ops.h"

#include "error.h"

#include "tdf.h"

#include "basetype.h"

#include "capsule.h"

#include "check.h"

#include "compile.h"

#include "destroy.h"

#include "diag.h"

#include "encode.h"

#include "exp.h"

#include "init.h"

#include "redeclare.h"

#include "shape.h"

#include "statement.h"

#include "struct.h"

#include "stmt.h"

#include "syntax.h"

#include "throw.h"

#include "tok.h"

/*

    NUMBER OF PENDING DESTRUCTORS

    This variable keeps track of the number of destructors for local

    variables which are pending at any moment during the TDF generation.

    This includes such pseudo-destructors as for jump locations in

    try blocks.

*/

unsigned long no_destructors = 0;

/*

    TDF STATEMENT ENCODING ROUTINES

    The remaining routines are only included if TDF output is enabled.

*/

#if TDF_OUTPUT

/*

    FIND THE NUMBER OF COMPONENTS IN A STATEMENT

    This routine finds the number of components in the statement e,

    ignoring trivial statements and expanding compound statements

    recursively.  The result equals the number of statements added to

    the bitstream by enc_compound_stmt.

*/

unsigned

stmt_length(EXP e)

{

	if (!IS_NULL_exp(e)) {

		switch (TAG_exp(e)) {

		case exp_sequence_tag: {

			/* Compound statements */

			unsigned n = 0;

			LIST(EXP)p = DEREF_list(exp_sequence_first(e));

			while (!IS_NULL_list(p)) {

				EXP a = DEREF_exp(HEAD_list(p));

				if (!IS_NULL_exp(a)) {

					n += stmt_length(a);

				}

				p = TAIL_list(p);

			}

			return (n);

		}

		case exp_location_tag: {

			/* Location statements */

			EXP a = DEREF_exp(exp_location_arg(e));

			if (!IS_NULL_exp(a)) {

				if (is_diag_stmt(a)) {

					return (1);

				}

				return (stmt_length(a));

			}

			break;

		}

		case exp_reach_tag:

		case exp_unreach_tag: {

			/* Flow control statement */

			EXP a = DEREF_exp(exp_reach_etc_body(e));

			return (stmt_length(a));

		}

		case exp_set_tag:

		case exp_unused_tag: {

			/* Variable flow statements */

			break;

		}

		default : {

			/* Other statements */

			return (1);

		}

		}

	}

	return (0);

}

/*

    ENCODE A COMPOUND STATEMENT

    This routine adds the statement e to the bitstream bs, ignoring

    trivial statements and expanding compound statements recursively.

*/

BITSTREAM *

enc_compound_stmt(BITSTREAM *bs, EXP e)

{

	if (!IS_NULL_exp(e)) {

		switch (TAG_exp(e)) {

		case exp_sequence_tag: {

			/* Compound statements */

			LIST(EXP)p = DEREF_list(exp_sequence_first(e));

			while (!IS_NULL_list(p)) {

				EXP a = DEREF_exp(HEAD_list(p));

				if (!IS_NULL_exp(a)) {

					bs = enc_compound_stmt(bs, a);

				}

				p = TAIL_list(p);

			}

			break;

		}

		case exp_location_tag: {

			/* Location statements */

			EXP a = DEREF_exp(exp_location_arg(e));

			if (!IS_NULL_exp(a)) {

				if (is_diag_stmt(a)) {

					BITSTREAM *ts = enc_diag_begin(&bs);

					ts = enc_stmt(ts, a);

					bs = enc_diag_end(bs, ts, a, 1);

				} else {

					bs = enc_compound_stmt(bs, a);

				}

			}

			crt_enc_loc = exp_location_end(e);

			break;

		}

		case exp_reach_tag:

		case exp_unreach_tag: {

			/* Flow control statement */

			EXP a = DEREF_exp(exp_reach_etc_body(e));

			bs = enc_compound_stmt(bs, a);

			break;

		}

		case exp_set_tag:

		case exp_unused_tag: {

			/* Variable flow statements */

			break;

		}

		default: {

			/* Other statements */

			bs = enc_stmt(bs, e);

			break;

		}

		}

	}

	return (bs);

}

/*

    ENCODE A LIST OF DESTRUCTORS

    This routine adds all the destructors and pseudo-destructors called

    by a jump from e to d to the bitstream bs.

*/

static BITSTREAM *

enc_destructors(BITSTREAM *bs, EXP e, EXP d)

{

	unsigned long m = no_destructors;

	if (m && !unreached_code) {

		unsigned long n = 0;

		unsigned long extra = 0;

#if LANGUAGE_CPP

		unsigned ptag = null_tag;

#endif

		BITSTREAM *ts = start_bitstream(NIL(FILE), bs->link);

		while (!EQ_exp(e, d) && !IS_NULL_exp(e) && n < m) {

			unsigned tag = TAG_exp(e);

			if (tag == exp_decl_stmt_tag) {

				/* Jump out of variable scope */

				IDENTIFIER id = DEREF_id(exp_decl_stmt_id(e));

				DECL_SPEC ds = DEREF_dspec(id_storage(id));

				if (ds & dspec_auto) {

					EXP a = DEREF_exp(id_variable_term(id));

					if (!IS_NULL_exp(a)) {

						/* Destructor found */

						ulong v;

						int var = 1;

						TYPE t = DEREF_type(id_variable_type(id));

						if (ds & dspec_explicit) {

							if (ds & dspec_temp) {

								var = 4;

							}

						}

						v = unit_no(ts, id, VAR_tag, 0);

						ts = enc_term_local(ts, v,

								    NULL_off,

								    0, t, a,

								    var);

						extra++;

						n++;

					}

				}

			}

#if LANGUAGE_CPP

			/* ... continued */

			else if (tag == exp_try_block_tag) {

				/* Jump out of try block */

				if (ptag != exp_handler_tag) {

					ulong ex =

					    DEREF_ulong(exp_try_block_no(e));

					ts = enc_try_end(ts, ex);

					n++;

				}

			} else if (tag == exp_handler_tag) {

				/* Jump out of exception handler */

				ts = enc_special(ts, TOK_except_end);

				n++;

			}

			ptag = tag;

#endif

			e = get_parent_stmt(e);

		}

		/* Check for exception specifications */

#if LANGUAGE_CPP

		if (IS_NULL_exp(e) && n < m && in_exception_spec) {

			ts = enc_try_end(ts, last_params[DUMMY_catch]);

			n++;

		}

#endif

		/* Add destructors to main list */

		if (n) {

			ENC_SEQUENCE(bs, n + extra);

		}

		bs = join_bitstreams(bs, ts);

	}

	return (bs);

}

/*

    ENCODE THE DESTRUCTOR FOR A CONDITION DECLARATION

    If a condition-declaration in a while or for loop has a destructor

    then this destructor needs to be called at the completion of the

    loop (this is the normal end-of-scope destructor) and just before

    the second and subsequent evaluations of the condition.  This

    routine adds the latter such destructors for the variable ids to

    the bitstream bs

*/

static BITSTREAM *

enc_while_destr(BITSTREAM *bs, LIST(IDENTIFIER)ids)

{

	while (!IS_NULL_list(ids)) {

		IDENTIFIER id = DEREF_id(HEAD_list(ids));

		EXP d = DEREF_exp(id_variable_term(id));

		if (!IS_NULL_exp(d)) {

			int var = 1;

			DECL_SPEC ds = DEREF_dspec(id_storage(id));

			TYPE t = DEREF_type(id_variable_type(id));

			ulong n = unit_no(bs, id, VAR_tag, 0);

			ENC_SEQ_SMALL(bs, 2);

			if ((ds & dspec_explicit) && (ds & dspec_temp)) {

				var = 4;

			}

			bs = enc_term_local(bs, n, NULL_off, 0, t, d, var);

		}

		ids = TAIL_list(ids);

	}

	return (bs);

}

/*

    ENCODE A LABELLED STATEMENT

    This routine adds the labelled statement 'e' to the bitstream bs.

*/

static BITSTREAM *

enc_label_stmt(BITSTREAM *bs, EXP e)

{

	EXP a = DEREF_exp(exp_label_stmt_body(e));

	IDENTIFIER lab = DEREF_id(exp_label_stmt_label(e));

	IDENTIFIER flab = DEREF_id(id_alias(lab));

	if (EQ_id(lab, flab)) {

		/* Simple label */

		ulong n = DEREF_ulong(id_no(flab));

		if (n == LINK_NONE) {

			/* Label not previously output */

			DECL_SPEC info = DEREF_dspec(id_storage(flab));

			if (info & dspec_used) {

				n = unit_no(bs, flab, VAR_label, 1);

				ENC_repeat(bs);

				ENC_make_label(bs, n);

				ENC_make_top(bs);

				unreached_code = 0;

				bs = enc_stmt(bs, a);

				clear_no(flab);

			} else {

				bs = enc_stmt(bs, a);

			}

		} else {

			/* Label body output separately */

			ENC_goto(bs);

			ENC_make_label(bs, n);

			unreached_code = 1;

		}

	} else {

		/* Label alias */

		bs = enc_stmt(bs, a);

	}

	return (bs);

}

/*

    ADD A LABEL TO A LIST

    This routine adds the label lab to the list q if it has not been

    output in bitstream bs and is not already a member of the list.

*/

static LIST(IDENTIFIER)

add_label(BITSTREAM *bs, IDENTIFIER lab, LIST(IDENTIFIER)q)

{

	if (!IS_NULL_id(lab)) {

		IDENTIFIER flab = DEREF_id(id_alias(lab));

		ulong n = DEREF_ulong(id_no(flab));

		if (n == LINK_NONE) {

			/* Not previously output */

			IGNORE unit_no(bs, flab, VAR_label, 1);

			CONS_id(flab, q, q);

		}

	}

	return (q);

}

/*

    ADD A NUMBER OF LABELS TO A LIST

    This routine adds the those labels in the list p which have not been

    output in bitstream bs to the list q.

*/

static LIST(IDENTIFIER)

add_labels(BITSTREAM *bs, LIST(IDENTIFIER)p, LIST(IDENTIFIER)q)

{

	while (!IS_NULL_list(p)) {

		IDENTIFIER lab = DEREF_id(HEAD_list(p));

		q = add_label(bs, lab, q);

		p = TAIL_list(p);

	}

	return (q);

}

/*

    ENCODE THE START OF A LABELLED STATEMENT

    This routine adds the start of a labelled statement for the labels

    lbs to the bitstream bs.  This comprises outputting the list of

    labels.  vars gives a list of variable declarations which need to

    be moved outside the labelled statement.

*/

static BITSTREAM *

enc_labelled_start(BITSTREAM *bs, LIST(IDENTIFIER)lbs,

		   LIST(IDENTIFIER)vars)

{

	unsigned nl = LENGTH_list(lbs);

	while (!IS_NULL_list(vars)) {

		/* Declare variables */

		IDENTIFIER id = DEREF_id(HEAD_list(vars));

		DECL_SPEC ds = DEREF_dspec(id_storage(id));

		if (!(ds & dspec_reserve) || !is_anon_member(id)) {

			int var = 2;

			EXP d = NULL_exp;

			if ((ds & dspec_explicit) && (ds & dspec_temp)) {

				var = 4;

			}

			bs = enc_variable(bs, id, var, &d, NULL_exp);

			if (!IS_NULL_exp(d)) {

				no_destructors++;

			}

		}

		vars = TAIL_list(vars);

	}

	if (nl == 0) {

		/* No labels */

		/* EMPTY */

	} else if (nl == 1) {

		/* Single label can be mapped to conditional */

		IDENTIFIER lab = DEREF_id(HEAD_list(lbs));

		ulong n = unit_no(bs, lab, VAR_label, 1);

		ENC_conditional(bs);

		ENC_make_label(bs, n);

	} else {

		/* Multiple labels require labelled */

		ENC_labelled(bs);

		ENC_LIST(bs, nl);

		while (!IS_NULL_list(lbs)) {

			IDENTIFIER lab = DEREF_id(HEAD_list(lbs));

			ulong n = unit_no(bs, lab, VAR_label, 1);

			ENC_make_label(bs, n);

			lbs = TAIL_list(lbs);

		}

	}

	return (bs);

}

/*

    ENCODE A BRANCH OF A LABELLED STATEMENT

    This routine adds the branch of the labelled statement d corresponding

    to the label lab to the bitstream bs.  Note that each such branch is

    terminated by a jump to an immediately following label, a jump to an

    enclosing break or continue label, or by falling through to the end

    of the labelled statement (see end_solve_branch).

*/

static BITSTREAM *

enc_labelled_branch(BITSTREAM *bs, IDENTIFIER lab, EXP d)

{

	ulong n;

	IDENTIFIER nlab;

	EXP e = DEREF_exp(id_label_stmt(lab));

	EXP f = e;

	EXP g = NULL_exp;

	/* Examine label type */

	int op = DEREF_int(id_label_op(lab));

	switch (op) {

	case lex_while:

	case lex_for: {

		/* While or for label */

		e = DEREF_exp(exp_label_stmt_parent(e));

		nlab = DEREF_id(exp_while_stmt_cont_lab(e));

		e = DEREF_exp(exp_while_stmt_body(e));

		if (is_diag_stmt(e)) {

			g = e;

		}

		break;

	}

	case lex_do: {

		/* Do label */

		e = DEREF_exp(exp_label_stmt_parent(e));

		nlab = DEREF_id(exp_do_stmt_cont_lab(e));

		e = DEREF_exp(exp_do_stmt_body(e));

		if (is_diag_stmt(e)) {

			g = e;

		}

		break;

	}

	case lex_if: {

		/* Conditional label */

		EXP c;

		int sw = 0;

		nlab = DEREF_id(exp_label_stmt_next(e));

		e = DEREF_exp(exp_label_stmt_parent(e));

		c = DEREF_exp(exp_if_stmt_cond(e));

		IGNORE simplify_cond(c, &sw);

		if (sw) {

			e = DEREF_exp(exp_if_stmt_true_code(e));

		} else {

			e = DEREF_exp(exp_if_stmt_false_code(e));

		}

		if (is_diag_stmt(e)) {

			g = e;

		}

		break;

	}

	case lex_continue: {

		/* Continue label */

		EXP c;

		unsigned m;

		IDENTIFIER rlab;

		LIST(IDENTIFIER)cids;

		EXP b = DEREF_exp(exp_label_stmt_body(e));

		e = DEREF_exp(exp_label_stmt_parent(e));

		if (IS_exp_while_stmt(e)) {

			c = DEREF_exp(exp_while_stmt_cond(e));

			rlab = DEREF_id(exp_while_stmt_loop_lab(e));

			nlab = DEREF_id(exp_while_stmt_break_lab(e));

			cids = DEREF_list(exp_while_stmt_cond_id(e));

		} else {

			c = DEREF_exp(exp_do_stmt_cond(e));

			rlab = DEREF_id(exp_do_stmt_loop_lab(e));

			nlab = DEREF_id(exp_do_stmt_break_lab(e));

			cids = NULL_list(IDENTIFIER);

		}

		m = stmt_length(b);

		ENC_SEQUENCE(bs, m + 1);

		if (m) {

			bs = enc_compound_stmt(bs, b);

		}

		/* Output conditional jump */

		n = unit_no(bs, rlab, VAR_label, 0);

		if (!IS_NULL_list(cids)) {

			bs = enc_while_destr(bs, cids);

		}

		bs = enc_condition(bs, c, LINK_NONE, n);

		n = unit_no(bs, nlab, VAR_label, 0);

		ENC_goto(bs);

		ENC_make_label(bs, n);

		unreached_code = 1;

		return (bs);

	}

	default : {

		/* Other labels */

		if (!IS_NULL_exp(e)) {

			if (is_diag_stmt(e)) {

				g = e;

			}

			nlab = DEREF_id(exp_label_stmt_next(e));

			e = DEREF_exp(exp_label_stmt_body(e));

		} else {

			nlab = NULL_id;

		}

		break;

	}

	}

	/* Output label body */

	if (IS_NULL_id(nlab)) {

		/* Fall through to end of labelled statement */

		if (no_destructors) {

			if (!IS_NULL_exp(e)) {

				ENC_SEQ_SMALL(bs, 1);

				if (!IS_NULL_exp(g)) {

					BITSTREAM *ts = enc_diag_begin(&bs);

					ts = enc_stmt(ts, e);

					bs = enc_diag_end(bs, ts, g, 1);

				} else {

					bs = enc_stmt(bs, e);

				}

			}

			bs = enc_destructors(bs, f, d);

			ENC_make_top(bs);

		} else {

			if (!IS_NULL_exp(g)) {

				BITSTREAM *ts = enc_diag_begin(&bs);

				ts = enc_stmt(ts, e);

				bs = enc_diag_end(bs, ts, g, 1);

			} else {

				bs = enc_stmt(bs, e);

			}

		}

	} else {

		/* Jump to following label */

		if (!IS_NULL_exp(e)) {

			ENC_SEQ_SMALL(bs, 1);

			if (!IS_NULL_exp(g)) {

				BITSTREAM *ts = enc_diag_begin(&bs);

				ts = enc_stmt(ts, e);

				bs = enc_diag_end(bs, ts, g, 1);

			} else {

				bs = enc_stmt(bs, e);

			}

		}

		op = DEREF_int(id_label_op(nlab));

		if (op == lex_break || op == lex_continue) {

			/* Need to call destructors for jump */

			EXP b = DEREF_exp(id_label_stmt(nlab));

			b = DEREF_exp(exp_label_stmt_parent(b));

			bs = enc_destructors(bs, f, b);

		}

		n = unit_no(bs, nlab, VAR_label, 0);

		ENC_goto(bs);

		ENC_make_label(bs, n);

		unreached_code = 1;

	}

	return (bs);

}

/*

    ENCODE THE END OF A LABELLED STATEMENT

    This routine adds the end of the labelled statement e to the bitstream

    bs.  This comprises outputting the list of label bodies for the labels

    lbs and then taking the labels and the variables vars out of scope.

*/

static BITSTREAM *

enc_labelled_end(BITSTREAM *bs, LIST(IDENTIFIER)lbs, LIST(IDENTIFIER)vars,

		 EXP e)

{

	int uc = unreached_code;

	unsigned nl = LENGTH_list(lbs);

	if (nl == 0) {

		/* No labels */

		/* EMPTY */

	} else if (nl == 1) {

		/* Single label */

		IDENTIFIER lab = DEREF_id(HEAD_list(lbs));

		unreached_code = 0;

		bs = enc_labelled_branch(bs, lab, e);

		if (!unreached_code) {

			uc = 0;

		}

		clear_no(lab);

	} else {

		/* Multiple labels */

		LIST(IDENTIFIER)p = lbs;

		ENC_LIST(bs, nl);

		while (!IS_NULL_list(p)) {

			IDENTIFIER lab = DEREF_id(HEAD_list(p));

			unreached_code = 0;

			bs = enc_labelled_branch(bs, lab, e);

			if (!unreached_code) {

				uc = 0;

			}

			p = TAIL_list(p);

		}

		p = lbs;

		while (!IS_NULL_list(p)) {

			IDENTIFIER lab = DEREF_id(HEAD_list(p));

			clear_no(lab);

			p = TAIL_list(p);

		}

	}

	while (!IS_NULL_list(vars)) {

		/* Take variables out of scope */

		IDENTIFIER id = DEREF_id(HEAD_list(vars));

		DECL_SPEC ds = DEREF_dspec(id_storage(id));

		if (ds & dspec_auto) {

			clear_no(id);

		}

		vars = TAIL_list(vars);

	}

	unreached_code = uc;

	return (bs);

}

/*

    CURRENT ENCODING LOCATION

    This location is used to store the current location during the

    encoding of statements.

*/

PTR(LOCATION)crt_enc_loc = NULL_ptr(LOCATION);

/*

    ENCODE A DECLARATION STATEMENT

    This routine adds the declaration statement e to the bitstream bs.

*/

static BITSTREAM *

enc_decl_stmt(BITSTREAM *bs, EXP e)

{

	int var = 1;

	int scope = 0;

	BITSTREAM *ts;

	ulong nlabs = 0;

	EXP d = NULL_exp;

	int diag = output_diag;

	EXP a = DEREF_exp(exp_decl_stmt_body(e));

	IDENTIFIER id = DEREF_id(exp_decl_stmt_id(e));

	TYPE t = DEREF_type(id_variable_type(id));

	DECL_SPEC ds = DEREF_dspec(id_storage(id));

	if (!(ds & dspec_reserve) || !is_anon_member(id)) {

		EXP b = DEREF_exp(id_variable_init(id));

		if (IS_NULL_exp(b) || !output_diag) {

			/* Don't output diagnostics */

			e = NULL_exp;

		}

		if (ds & dspec_explicit) {

			/* Only declare explicitly initialised variables */

			if (ds & dspec_temp) {

				nlabs = no_labels(bs);

				e = NULL_exp;

				var = 4;

			} else {

				var = 3;

			}

		}

		if (ds & dspec_done) {

			/* Variable previously declared */

			int dummy = 0;

			EXP d1 = DEREF_exp(id_variable_term(id));

			if (!IS_NULL_exp(d1)) {

				/* Allow for terminator expressions */

				if (output_except) {

					while (IS_exp_nof(d1)) {

						d1 = DEREF_exp(exp_nof_pad(d1));

					}

					if (IS_NULL_exp(b) && var == 1) {

						/* Force initialisation */

						b = make_dummy_init(t);

						dummy = 1;

					}

				} else {

					d1 = NULL_exp;

				}

			}

			if (!IS_NULL_exp(b)) {

				ulong n = unit_no(bs, id, VAR_tag, 0);

				bs = enc_assign_local(bs, b, d1, n, t, e);

				if (IS_exp_thrown(b) && output_new_diag) {

					diag = 0;

				}

				if (dummy)free_exp(b, 1);

			}

		} else {

			/* Variable not previously declared */

			bs = enc_variable(bs, id, var, &d, e);

			if (ds & dspec_auto) {

				scope = 1;

			}

		}

	}

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

		HASHID nm = DEREF_hashid(id_name(id));

		if (!IS_hashid_anon(nm)) {

			ts = start_bitstream(NIL(FILE), bs->link);

		} else {

			ts = bs;

			diag = 0;

		}

	} else {

		ts = bs;

		diag = 0;

	}

	if (IS_NULL_exp(d)) {

		ts = enc_stmt(ts, a);

	} else {

		unsigned seq = stmt_length(a) + 1;

		no_destructors++;

		ENC_SEQUENCE(ts, seq);

		ts = enc_compound_stmt(ts, a);

		if (unreached_code) {

			ENC_make_top(ts);

			ENC_make_top(ts);

		} else {

			ulong n = unit_no(ts, id, VAR_tag, 0);

			if (var == 4 && nlabs == no_labels(bs)) {

				var = 3;

			}

			ts = enc_term_local(ts, n, NULL_off, 0, t, d, var);

		}

		no_destructors--;

	}

	if (diag) {

		bs = enc_diag_local(bs, id, ts);

	} else {

		bs = ts;

	}

	if (scope) {

		/* Take variable out of scope */

		clear_no(id);

	}

	return (bs);

}

/*

    ENCODE A TDF BODY STATEMENT

    This routine is identical to enc_stmt except that it makes explicit

    provision for diagnostic information.

*/

static BITSTREAM *

enc_body_stmt(BITSTREAM *bs, EXP e)

{

	if (output_diag && is_diag_stmt(e)) {

		BITSTREAM *ts = enc_diag_begin(&bs);

		ts = enc_stmt(ts, e);

		bs = enc_diag_end(bs, ts, e, 1);

	} else {

		bs = enc_stmt(bs, e);

	}

	return (bs);