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

#include "c_types.h"

#include "ctype_ops.h"

#include "etype_ops.h"

#include "exp_ops.h"

#include "flt_ops.h"

#include "ftype_ops.h"

#include "graph_ops.h"

#include "id_ops.h"

#include "itype_ops.h"

#include "nat_ops.h"

#include "off_ops.h"

#include "str_ops.h"

#include "type_ops.h"

#include "error.h"

#include "tdf.h"

#include "basetype.h"

#include "capsule.h"

#include "char.h"

#include "check.h"

#include "chktype.h"

#include "compile.h"

#include "constant.h"

#include "convert.h"

#include "copy.h"

#include "derive.h"

#include "encode.h"

#include "exp.h"

#include "init.h"

#include "interface.h"

#include "inttype.h"

#include "literal.h"

#include "mangle.h"

#include "shape.h"

#include "struct.h"

#include "tok.h"

#include "ustring.h"

#if TDF_OUTPUT

/*

    ENCODE A TDF INT

    This routine adds the simple integer constant n to the bitstream bs

    as a TDF INT.  The argument e is true if this is the last sequence of

    digits in a value.

*/

static BITSTREAM *

enc_tdfint(BITSTREAM *bs, NAT n, int e)

{

	unsigned np;

	LIST(unsigned)p;

	if (IS_nat_small(n)) {

		p = NULL_list(unsigned);

		np = 1;

	} else {

		p = DEREF_list(nat_large_values(n));

		np = LENGTH_list(p);

	}

	if (np <= 2) {

		/* Small values */

		unsigned long v = get_nat_value(n);

		if (e) {

			bs = enc_int(bs, v);

		} else {

			bs = enc_int_aux(bs, v);

		}

	} else {

		/* Really large values */

		unsigned u = DEREF_unsigned(HEAD_list(p));

		n = binary_nat_op(exp_rshift_tag, n, small_nat[3]);

		bs = enc_tdfint(bs, n, 0);

		u &= 0x7;

		if (e) {

			u |= 0x8;

		}

		bs = enc_bits(bs,(unsigned)4, u);

	}

	return (bs);

}

/*

    ENCODE A TDF BOOL

    This routine adds the value n to the bitstream bs as a TDF BOOL,

    nonzero values map to true, zero to false.

*/

BITSTREAM *

enc_bool(BITSTREAM *bs, int n)

{

	if (n) {

		ENC_true(bs);

	} else {

		ENC_false(bs);

	}

	return (bs);

}

/*

    ENCODE A CALCULATED INTEGRAL EXPRESSION

    This routine adds the calculated integral expression n to the

    bitstream bs.  The value is negated if sgn is true and a token is

    introduced to represent the value if intro is true.  The value is

    encoded as a NAT if sort is 0, a SIGNED NAT if sort is 1, an

    EXP if sort is 2 and a constant EXP if sort is 3.

*/

static BITSTREAM *

enc_calc(BITSTREAM *bs, NAT n, int sgn, int intro, int sort)

{

	static int suppress_calc = 0;

	NAT n1 = n;

	ulong m = DEREF_ulong(nat_calc_tok(n));

	EXP e = DEREF_exp(nat_calc_value(n));

	TYPE t = DEREF_type(exp_type(e));

	if (m == LINK_NONE && !suppress_calc) {

		EXP f = eval_exp(e, 1);

		if (!EQ_exp(f, e) && IS_exp_int_lit(f)) {

			e = f;

			t = DEREF_type(exp_type(e));

			n = DEREF_nat(exp_int_lit_nat(e));

			if (!IS_nat_calc(n)) {

				/* Value evaluates to a literal constant */

				if (sort == 0) {

					bs = enc_nat(bs, n, 0);

				} else {

					if (sort >= 2) {

						ENC_make_int(bs);

						bs = enc_variety(bs, t);

					}

					bs = enc_snat(bs, n, sgn, 0);

				}

				return (bs);

			}

		}

	}

	/* Encode calculated value */

	suppress_calc++;

	if (sort == 0) {

		ENC_computed_nat(bs);

		sort = 2;

	} else if (sort == 1) {

		ENC_computed_signed_nat(bs);

		sort = 2;

	}

	if (sgn) {

		/* Negated value */

		ENC_negate(bs);

		bs = enc_error_treatment(bs, t);

		bs = enc_calc(bs, n, 0, intro, sort);

	} else {

		if (intro && m == LINK_NONE) {

			/* Introduce token for value */

			while (!IS_NULL_exp(e) && IS_exp_int_lit(e)) {

				NAT n2 = DEREF_nat(exp_int_lit_nat(e));

				if (!IS_nat_calc(n2)) {

					break;

				}

				m = DEREF_ulong(nat_calc_tok(n2));

				if (m != LINK_NONE) {

					break;

				}

				e = DEREF_exp(nat_calc_value(n2));

			}

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

				LIST(TOKEN)args;

				args = DEREF_list(exp_token_args(e));

				if (IS_NULL_list(args)) {

					/* Use existing token */

					IDENTIFIER tok =

					    DEREF_id(exp_token_tok(e));

					IGNORE capsule_id(tok, VAR_token);

					m = DEREF_ulong(id_no(tok));

				}

			}

			if (m == LINK_NONE) {

				/* Introduce token for value */

				BITSTREAM *ts;

				m = capsule_no(NULL_string, VAR_token);

				ts = enc_tokdef_start(m, "E", NIL(ulong), 1);

				if (sort == 3) {

					/* Force constant evaluation */

					ENC_make_int(ts);

					ts = enc_variety(ts, t);

					ENC_computed_signed_nat(ts);

				}

				ts = enc_exp(ts, e);

				enc_tokdef_end(m, ts);

			}

			COPY_ulong(nat_calc_tok(n1), m);

			COPY_ulong(nat_calc_tok(n), m);

		}

		if (m == LINK_NONE) {

			/* Calculated value */

			if (sort == 3) {

				/* Force constant evaluation */

				ENC_make_int(bs);

				bs = enc_variety(bs, t);

				ENC_computed_signed_nat(bs);

			}

			bs = enc_exp(bs, e);

		} else {

			/* Tokenised value */

			m = link_no(bs, m, VAR_token);

			ENC_exp_apply_token(bs);

			ENC_make_tok(bs, m);

			ENC_LEN_SMALL(bs, 0);

		}

	}

	suppress_calc--;

	return (bs);

}

/*

    ENCODE A TDF NAT

    This routine adds the integer constant n to the bitstream bs as a

    TDF NAT.

*/

BITSTREAM *

enc_nat(BITSTREAM *bs, NAT n, int intro)

{

	if (IS_NULL_nat(n)) {

		/* Null constant maps to zero */

		ENC_make_nat(bs);

		ENC_INT_SMALL(bs, 0);

	} else {

		ASSERT(ORDER_nat == 5);

		switch (TAG_nat(n)) {

		case nat_small_tag: {

			unsigned v = DEREF_unsigned(nat_small_value(n));

			ENC_make_nat(bs);

			ENC_INT(bs, v);

			break;

		}

		case nat_large_tag: {

			ENC_make_nat(bs);

			bs = enc_tdfint(bs, n, 1);

			break;

		}

		case nat_calc_tag: {

			bs = enc_calc(bs, n, 0, intro, 0);

			break;

		}

		case nat_neg_tag: {

			/* This case shouldn't occur */

			ENC_make_nat(bs);

			ENC_INT_SMALL(bs, 0);

			break;

		}

		case nat_token_tag: {

			/* Token applications */

			IDENTIFIER tok = DEREF_id(nat_token_tok(n));

			LIST(TOKEN)args = DEREF_list(nat_token_args(n));

			TOKEN sort = DEREF_tok(id_token_sort(tok));

			int s = token_code(sort);

			if (s == 'Z') {

				/* Signed nat token */

				TYPE t = type_sint;

				ENC_computed_nat(bs);

				ENC_make_int(bs);

				bs = enc_variety(bs, t);

			}

			bs = enc_token(bs, tok, args);

			break;

		}

		}

	}

	return (bs);

}

/*

    ENCODE A TDF SIGNED NAT

    This routine adds the integer constant n to the bitstream bs as a

    TDF SIGNED NAT.  sgn is true if the value is to be negated and intro

    is true if a token is to be introduced for a calculated value.

*/

BITSTREAM *

enc_snat(BITSTREAM *bs, NAT n, int sgn, int intro)

{

	if (IS_NULL_nat(n)) {

		/* Null constant maps to zero */

		ENC_make_signed_nat(bs);

		ENC_OFF(bs);

		ENC_INT_SMALL(bs, 0);

	} else {

		ASSERT(ORDER_nat == 5);

		switch (TAG_nat(n)) {

		case nat_small_tag: {

			unsigned v = DEREF_unsigned(nat_small_value(n));

			if (v == 0) {

				sgn = 0;

			}

			ENC_make_signed_nat(bs);

			ENC_BOOL(bs, sgn);

			ENC_INT(bs, v);

			break;

		}

		case nat_large_tag: {

			ENC_make_signed_nat(bs);

			ENC_BOOL(bs, sgn);

			bs = enc_tdfint(bs, n, 1);

			break;

		}

		case nat_calc_tag: {

			bs = enc_calc(bs, n, sgn, intro, 1);

			break;

		}

		case nat_neg_tag: {

			NAT m = DEREF_nat(nat_neg_arg(n));

			bs = enc_snat(bs, m, !sgn, intro);

			break;

		}

		case nat_token_tag: {

			/* Token applications */

			IDENTIFIER tok = DEREF_id(nat_token_tok(n));

			LIST(TOKEN)args = DEREF_list(nat_token_args(n));

			TOKEN sort = DEREF_tok(id_token_sort(tok));

			int s = token_code(sort);

			if (s == 'Z') {

				/* Signed nat token */

				if (sgn) {

					/* Negate signed nat */

					TYPE t = type_sint;

					ENC_computed_signed_nat(bs);

					ENC_negate(bs);

					bs = enc_error_treatment(bs, t);

					ENC_make_int(bs);

					bs = enc_variety(bs, t);

				}

			} else {

				/* Nat token */

				ENC_snat_from_nat(bs);

				bs = enc_bool(bs, sgn);

			}

			bs = enc_token(bs, tok, args);

			break;

		}

		}

	}

	return (bs);

}

/*

    ENCODE AN INTEGER LITERAL EXPRESSION

    This routine adds the integer constant expression n of type t to the

    bitstream bs.  etag gives the expression tag which is used to

    determine whether a token should be introduced for the value.

*/

BITSTREAM *

enc_int_lit(BITSTREAM *bs, NAT n, TYPE t, unsigned etag)

{

	if (IS_nat_calc(n)) {

		if (etag == exp_identifier_tag) {

			/* Enumerator value */

			bs = enc_calc(bs, n, 0, 1, 3);

		} else {

			/* Other calculated value */

			bs = enc_calc(bs, n, 0, 0, 2);

		}

	} else {

		/* Simple value */

		ENC_make_int(bs);

		bs = enc_variety(bs, t);

		bs = enc_snat(bs, n, 0, 0);

	}

	return (bs);

}

/*

    ENCODE A TDF FLOATING LITERAL

    This routine adds the floating literal flt of type t to the bitstream

    bs as a TDF EXP.

*/

BITSTREAM *

enc_float(BITSTREAM *bs, FLOAT flt, TYPE t)

{

	ulong n = DEREF_ulong(flt_tok(flt));

	if (n == LINK_NONE) {

		/* Decompose literal */

		BITSTREAM *ts;

		string i = DEREF_string(flt_simple_int_part(flt));

		string f = DEREF_string(flt_simple_frac_part(flt));

		unsigned long ni = (unsigned long)ustrlen(i);

		unsigned long nf = (unsigned long)ustrlen(f);

		unsigned long nt = ni + nf + 1;

		NAT e = DEREF_nat(flt_simple_exponent(flt));

		/* Map to canonical form */

		if (ni == 0) {

			/* Introduce leading zero */

			i = small_number[0];

			ni = 1;

			nt = nf + 2;

		}

		if (nf == 0) {

			/* No decimal part */

			nt = ni;

		}

		if (nf == 1 && f[0] == '0') {

			/* Ignore trivial decimal part */

			nf = 0;

			nt = ni;

		}

		/* Encode expression */

		n = capsule_no(NULL_string, VAR_token);

		ts = enc_tokdef_start(n, "E", NIL(ulong), 1);

		ENC_make_floating(ts);

		ts = enc_flvar(ts, t);

		ENC_to_nearest(ts);

		ENC_false(ts);

		ENC_make_string(ts);

		ENC_INT(ts, BYTE_SIZE);

		ENC_INT(ts, nt);

		ts = enc_ascii(ts, ni, i);

		if (nf) {

			ENC_BITS(ts, BYTE_SIZE, '.');

			ts = enc_ascii(ts, nf, f);

		}

		ENC_make_nat(ts);

		ENC_INT(ts, 10);

		ts = enc_snat(ts, e, 0, 0);

		enc_tokdef_end(n, ts);

		COPY_ulong(flt_tok(flt), n);

	}

	n = link_no(bs, n, VAR_token);

	ENC_exp_apply_token(bs);

	ENC_make_tok(bs, n);

	ENC_LEN_SMALL(bs, 0);

	return (bs);

}

/*

    ENCODE A SMALL TDF FLOATING LITERAL

    This routine adds the small floating literal given by the value v of

    type t to the bitstream bs as a TDF EXP.

*/

BITSTREAM *

enc_float_int(BITSTREAM *bs, int v, TYPE t)

{

	FLOAT flt = get_float(t, v);

	if (!IS_NULL_flt(flt)) {

		bs = enc_float(bs, flt, t);

	} else {

		char s[20];

		sprintf_v(s, "%d", v);

		ENC_make_floating(bs);

		bs = enc_flvar(bs, t);

		ENC_to_nearest(bs);

		ENC_false(bs);

		ENC_make_string(bs);

		bs = enc_ustring(bs, ustrlit(s));

		ENC_make_nat(bs);

		ENC_INT(bs, 10);

		bs = enc_snat(bs, NULL_nat, 0, 0);

	}

	return (bs);

}

/*

    ENCODE A STRING LITERAL EXPRESSION

    This routine adds the string literal str of type t to the bitstream

    bs.  Note that the type determines the string length - the string

    is truncated or padded with zeros as necessary (this includes the

    normal terminal zero for a string).

*/

BITSTREAM *

enc_string(BITSTREAM *bs, STRING str, TYPE t)

{

	unsigned long i, m;

	unsigned long d = 0;

	string s = DEREF_string(str_simple_text(str));

	unsigned long n = DEREF_ulong(str_simple_len(str));

	unsigned kind = DEREF_unsigned(str_simple_kind(str));

	if (n == 0) {

		/* Allow for empty strings */

		bs = enc_null_exp(bs, t);

		return (bs);

	}

	if (IS_type_array(t)) {

		/* Find array size */

		NAT sz = DEREF_nat(type_array_size(t));

		m = get_nat_value(sz);

		if (m < n) {

			/* String truncation */

			n = m;

		} else {

			d = m - n;

			if (d <= STRING_PADDING) {

				/* Small padding */

				d = 0;

			} else {

				/* Large padding */

				ENC_concat_nof(bs);

				m = n;

			}

		}

		t = DEREF_type(type_array_sub(t));

	} else {

		m = n + 1;

	}

	if (kind & STRING_FAT) {

		/* Fat character strings */

		unsigned mbits = 0;

		unsigned long maxc = 1;

		BASE_TYPE sign = btype_none;

		unsigned bits = find_type_size(t, &mbits, &sign);

		if (sign != btype_unsigned) {

			bits--;

		}

		maxc <<= bits;

		ENC_make_nof(bs);

		ENC_LIST(bs, m);

		for (i = 0; i < n; i++) {

			TYPE u = t;

			int ch = CHAR_SIMPLE;

			unsigned long c = get_multi_char(s, &ch);

			if (ch == CHAR_SIMPLE) {

				c = to_ascii(c, &ch);

			}

			if (maxc && c >= maxc) {

				/* Character doesn't fit into type */

				ENC_change_variety(bs);

				bs = enc_error_treatment(bs, u);

				bs = enc_variety(bs, u);

				u = type_ulong;

			}

			ENC_make_int(bs);

			bs = enc_variety(bs, u);

			ENC_make_signed_nat(bs);

			ENC_OFF(bs);

			ENC_INT(bs, c);

			s += MULTI_WIDTH;

		}

		for (; i < m; i++) {

			/* Terminal zeros */

			bs = enc_make_int(bs, t, 0);

		}

	} else {

		ENC_make_nof_int(bs);

		bs = enc_variety(bs, t);

		ENC_make_string(bs);

		ENC_INT(bs, BYTE_SIZE);

		ENC_INT(bs, m);

		if (kind & STRING_MULTI) {

			for (i = 0; i < n; i++) {

				int ch = CHAR_SIMPLE;

				unsigned long c = get_multi_char(s, &ch);

				if (ch == CHAR_SIMPLE) {

					c = to_ascii(c, &ch);

				}

				ENC_BITS(bs, BYTE_SIZE, c);

				s += MULTI_WIDTH;

			}

		} else {

			/* Simple string */

			bs = enc_ascii(bs, n, s);

		}

		for (i = n; i < m; i++) {

			/* Terminal zeros */

			ENC_BITS(bs, BYTE_SIZE, 0);

		}

	}

	if (d) {

		/* Large padding */

		ENC_n_copies(bs);

		ENC_make_nat(bs);

		ENC_INT(bs, d);

		bs = enc_make_int(bs, t, 0);

	}

	return (bs);

}

/*

    ENCODE A STRING LITERAL

    This routine adds the string literal str to the bitstream bs.

*/

BITSTREAM *

enc_strlit(BITSTREAM *bs, STRING str)

{

	string s = DEREF_string(str_simple_text(str));

	unsigned long n = DEREF_ulong(str_simple_len(str));

	unsigned kind = DEREF_unsigned(str_simple_kind(str));

	ENC_make_string(bs);

	ENC_INT(bs, BYTE_SIZE);

	ENC_INT(bs, n);

	if (kind & STRING_MULTI) {

		unsigned long i;

		for (i = 0; i < n; i++) {

			int ch = CHAR_SIMPLE;

			unsigned long c = get_multi_char(s, &ch);

			if (ch == CHAR_SIMPLE) {

				c = to_ascii(c, &ch);

			}

			ENC_BITS(bs, BYTE_SIZE, c);

			s += MULTI_WIDTH;

		}

	} else {

		bs = enc_ascii(bs, n, s);

	}

	return (bs);

}

/*

    ENCODE A CHARACTER LITERAL EXPRESSION

    This routine adds the character literal str of type t to the bitstream

    bs.  u gives the actual literal type, from which it is cast to t.  Note

    that it is possible that str does not fit into u.

*/

BITSTREAM *

enc_char(BITSTREAM *bs, STRING str, TYPE t, TYPE u)

{

	NAT n;

	TYPE w;

	int convert_to_t;

	int convert_to_u;

	unsigned long v = DEREF_ulong(str_simple_tok(str));

	if (v == LINK_NONE) {

		/* Evaluate literal */

		n = eval_char_lit(str);

		v = DEREF_ulong(str_simple_tok(str));

		if (v < 128) {

			/* Small values are easy */

			bs = enc_make_int(bs, t,(int)v);

			return (bs);

		}

	} else {

		if (v < 128) {

			/* Small values are easy */

			bs = enc_make_int(bs, t,(int)v);

			return (bs);

		}

		n = make_nat_value(v);

	}

	if (check_nat_range(u, n) == 0) {

		if (EQ_type(t, u) || check_nat_range(t, n) == 0) {

			/* Fits into both t and u */

			w = t;

			convert_to_t = 0;

			convert_to_u = 0;

		} else {

			/* Fits into u but not t */

			w = u;

			convert_to_t = 1;

			convert_to_u = 0;

		}

	} else {

		/* Doesn't fit into u */

		w = find_char_type(n);

		convert_to_t = 1;

		convert_to_u = 1;

	}

	if (convert_to_t) {

		ENC_change_variety(bs);

		bs = enc_error_treatment(bs, t);

		bs = enc_variety(bs, t);

	}

	if (convert_to_u && !EQ_type(u, t)) {

		ENC_change_variety(bs);

		bs = enc_error_treatment(bs, u);

		bs = enc_variety(bs, u);

	}

	ENC_make_int(bs);

	bs = enc_variety(bs, w);

	ENC_make_signed_nat(bs);

	ENC_OFF(bs);

	bs = enc_tdfint(bs, n, 1);

	return (bs);

}

/*

    FIND AN INTEGRAL TYPE

    This routine returns the integral type corresponding to the type t.

*/

static INT_TYPE

find_itype(TYPE t)

{

	INT_TYPE it;

	unsigned tag = TAG_type(t);

	if (tag == type_bitfield_tag) {

		it = DEREF_itype(type_bitfield_defn(t));

	} else {

		if (tag == type_enumerate_tag) {

			/* Allow for enumeration types */

			ENUM_TYPE et = DEREF_etype(type_enumerate_defn(t));

			t = DEREF_type(etype_rep(et));

			tag = TAG_type(t);

		}

		if (tag != type_integer_tag) {

			t = type_sint;

		}

		it = DEREF_itype(type_integer_rep(t));

	}

	return (it);

}

/*

    ENCODE A TDF VARIETY NUMBER

    This routine adds the code number of the integral type it to the

    bitstream bs as a TDF SIGNED NAT.

*/

static BITSTREAM *

enc_var_no(BITSTREAM *bs, INT_TYPE it, int alt)

{

	ulong tok;

	unsigned tag = TAG_itype(it);

	ASSERT(ORDER_itype == 6);

	switch (tag) {

	case itype_basic_tag: {

		/* Built-in integral types */

		BUILTIN_TYPE n = DEREF_ntype(itype_basic_no(it));

		unsigned m = base_token[n].no;

		if (alt) {

			m = base_token[n].alt;

		}

		if (m != ARITH_none) {

			/* Basic types are easy */

			bs = enc_make_snat(bs,(int)m);

			return (bs);

		}

		break;

	}

	case itype_bitfield_tag: {

		/* Bitfield types */

		TYPE s = DEREF_type(itype_bitfield_sub(it));

		INT_TYPE is = find_itype(s);

		bs = enc_var_no(bs, is, alt);

		return (bs);

	}

	case itype_token_tag: {

		/* Tokenised types */

		IDENTIFIER tk = DEREF_id(itype_token_tok(it));

		LIST(TOKEN)args = DEREF_list(itype_token_args(it));

		bs = enc_token(bs, tk, args);

		return (bs);

	}

	}

	/* Find the token number */

	tok = DEREF_ulong(itype_ntok(it));

	if (tok == LINK_NONE) {

		if (tag == itype_basic_tag) {

			/* Look up special token number */

			BUILTIN_TYPE n = DEREF_ntype(itype_basic_no(it));

			int tn = base_token[n].tok;

			tok = special_no(tn);

			COPY_ulong(itype_ntok(it), tok);

		} else {

			/* Compound integral types */

			string s = NULL;

			BITSTREAM *ts, *us;

			if (output_all) {

				TYPE t = make_itype(it, it);

				s = mangle_tname("~cpp.itype_no.", t);

			}

			tok = capsule_no(s, VAR_token);