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 <ctype.h>

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

#include "id_ops.h"

#include "itype_ops.h"

#include "member_ops.h"

#include "nat_ops.h"

#include "nspace_ops.h"

#include "off_ops.h"

#include "str_ops.h"

#include "tok_ops.h"

#include "type_ops.h"

#include "error.h"

#include "basetype.h"

#include "buffer.h"

#include "char.h"

#include "class.h"

#include "constant.h"

#include "convert.h"

#include "debug.h"

#include "exception.h"

#include "file.h"

#include "function.h"

#include "hash.h"

#include "label.h"

#include "lex.h"

#include "literal.h"

#include "print.h"

#include "redeclare.h"

#include "symbols.h"

#include "syntax.h"

#include "tok.h"

#include "token.h"

#include "ustring.h"

/*

    PRINT BUFFER

    This buffer is used for the error output.

*/

BUFFER print_buff = NULL_buff;

/*

    FUNCTION DECLARATIONS

    A couple of forward function declarations are necessary.

*/

static int print_head(TYPE, int, BUFFER *, int);

static int print_tail(TYPE, BUFFER *, int);

/*

    PRINT FLAGS

    These flags are used to control the form of the output.

*/

static int print_default_args = 0;

static int print_member_type = 0;

static int print_return_type = 1;

static int print_func_params = 0;

static int print_except = 0;

static int print_func_linkage = 0;

static int print_parent_namespace = 1;

static int print_bitfield_sep = ':';

int print_c_style = LANGUAGE_C;

int print_type_alias = 0;

int print_uniq_anon = 0;

int print_id_desc = 0;

/*

    PRINT A LEXICAL TOKEN NAME

    This routine prints the name of the lexical token t to the buffer bf.

    With all the routines in this file the sp argument is true if a space

    should be printed before the actual text, and the return value is true

    if a space should be printed after it.

*/

int

print_lex(int t, BUFFER *bf, int sp)

{

	string s = token_name(t);

	if (s == NULL) {

		return (sp);

	}

	if (sp) {

		bfputc(bf, ' ');

	}

	bfputs(bf, s);

	return (1);

}

/*

    PRINT AN ACCESS SPECIFIER

    This routine prints the access specifier n to the buffer bf.

*/

int

print_access(DECL_SPEC n, BUFFER *bf, int sp)

{

	int t;

	DECL_SPEC a = (n & dspec_access);

	if (a == dspec_private) {

		t = lex_private;

	} else if (a == dspec_protected) {

		t = lex_protected;

	} else {

		t = lex_public;

	}

	sp = print_lex(t, bf, sp);

	return (sp);

}

/*

    BUILT-IN TYPE NAMES

    This table gives the names of the built-in types.

*/

CONST char *ntype_name[ORDER_ntype] = {

	"<error>",		/* ntype_none */

	"char",			/* ntype_char */

	"signed char",		/* ntype_schar */

	"unsigned char",	/* ntype_uchar */

	"short",		/* ntype_sshort */

	"unsigned short",	/* ntype_ushort */

	"int",			/* ntype_sint */

	"unsigned int",		/* ntype_uint */

	"long",			/* ntype_slong */

	"unsigned long",	/* ntype_ulong */

	"long long",		/* ntype_sllong */

	"unsigned long long",	/* ntype_ullong */

	"float",		/* ntype_float */

	"double",		/* ntype_double */

	"long double",		/* ntype_ldouble */

	"void",			/* ntype_void */

	"<bottom>",		/* ntype_bottom */

	"bool",			/* ntype_bool */

	"ptrdiff_t",		/* ntype_ptrdiff_t */

	"size_t",		/* ntype_size_t */

	"wchar_t",		/* ntype_wchar_t */

	"..."			/* ntype_ellipsis */

};

/*

    PRINT A BUILT-IN TYPE

    This routine prints the built-in type n to the buffer bf.

*/

int

print_ntype(BUILTIN_TYPE n, BUFFER *bf, int sp)

{

	if (sp) {

		bfputc(bf, ' ');

	}

	bfputs(bf, ustrlit(ntype_name[n]));

	return (1);

}

/*

    PRINT A BASE TYPE

    This routine prints the base type n to the buffer bf.

*/

int

print_btype(BASE_TYPE n, BUFFER *bf, int sp)

{

	BASE_TYPE key = (n & btype_named);

	if (key) {

		switch (key) {

		case btype_class:

			sp = print_lex(lex_class, bf, sp);

			break;

		case btype_struct:

			sp = print_lex(lex_struct, bf, sp);

			break;

		case btype_union:

			sp = print_lex(lex_union, bf, sp);

			break;

		case btype_enum:

			sp = print_lex(lex_enum, bf, sp);

			break;

		case btype_any:

			sp = print_lex(lex_tag_Hcap, bf, sp);

			break;

		}

	} else {

		if (n & btype_signed) {

			sp = print_lex(lex_signed, bf, sp);

		}

		if (n & btype_unsigned) {

			sp = print_lex(lex_unsigned, bf, sp);

		}

		if (n & btype_short) {

			sp = print_lex(lex_short, bf, sp);

		}

		if (n & btype_long) {

			sp = print_lex(lex_long, bf, sp);

		}

		if (n & btype_long2) {

			sp = print_lex(lex_long, bf, sp);

		}

		if (n & btype_char) {

			sp = print_lex(lex_char, bf, sp);

		}

		if (n & btype_int) {

			sp = print_lex(lex_int, bf, sp);

		}

		if (n & btype_float) {

			sp = print_lex(lex_float, bf, sp);

		}

		if (n & btype_double) {

			sp = print_lex(lex_double, bf, sp);

		}

		if (n & btype_void) {

			sp = print_lex(lex_void, bf, sp);

		}

		if (n & btype_bottom) {

			sp = print_lex(lex_bottom, bf, sp);

		}

		if (n & btype_bool) {

			sp = print_lex(lex_bool, bf, sp);

		}

		if (n & btype_ptrdiff_t) {

			sp = print_lex(lex_ptrdiff_Ht, bf, sp);

		}

		if (n & btype_size_t) {

			sp = print_lex(lex_size_Ht, bf, sp);

		}

		if (n & btype_wchar_t) {

			sp = print_lex(lex_wchar_Ht, bf, sp);

		}

		if (n & btype_ellipsis) {

			sp = print_lex(lex_ellipsis, bf, sp);

		}

		if (n & btype_star) {

			sp = print_lex(lex_star, bf, sp);

		}

	}

	return (sp);

}

/*

    PRINT A CONST-VOLATILE QUALIFIER

    This routine prints the const-volatile qualifier n to the buffer bf.

*/

int

print_cv(CV_SPEC n, BUFFER *bf, int sp)

{

	if (n) {

		if (n & cv_const) {

			sp = print_lex(lex_const, bf, sp);

		}

		if (n & cv_volatile) {

			sp = print_lex(lex_volatile, bf, sp);

		}

	}

	return (sp);

}

/*

    PRINT A DECLARATION SPECIFIER

    This routine prints the declaration specifier n to the buffer bf.  The

    C and C++ linkage specifiers are not included.

*/

int

print_dspec(DECL_SPEC n, BUFFER *bf, int sp)

{

	if (n & dspec_typedef) {

		sp = print_lex(lex_typedef, bf, sp);

	}

	if (n & dspec_storage) {

		if (n & dspec_extern) {

			sp = print_lex(lex_extern, bf, sp);

		}

		if (n & dspec_static) {

			sp = print_lex(lex_static, bf, sp);

		}

		if (n & dspec_register) {

			sp = print_lex(lex_register, bf, sp);

		}

		if (n & dspec_auto) {

			sp = print_lex(lex_auto, bf, sp);

		}

		if (n & dspec_mutable) {

			sp = print_lex(lex_mutable, bf, sp);

		}

	}

	if (n & dspec_function) {

		if (n & dspec_explicit) {

			sp = print_lex(lex_explicit, bf, sp);

		}

		if (n & dspec_friend) {

			sp = print_lex(lex_friend, bf, sp);

		}

		if (n & dspec_inline) {

			sp = print_lex(lex_inline, bf, sp);

		}

		if (n & dspec_virtual) {

			sp = print_lex(lex_virtual, bf, sp);

		}

	}

	return (sp);

}

/*

    PRINT A LINKAGE SPECIFIER

    This routine prints the linkage specifier n to the buffer bf.

*/

static int

print_linkage(CV_SPEC n, BUFFER *bf, int sp)

{

	CV_SPEC m = (n & cv_language);

	if (m) {

		if (m != cv_cpp && !print_c_style) {

			string s = linkage_string(dspec_none, m);

			if (sp) {

				bfputc(bf, ' ');

			}

			bfprintf(bf, "extern \"%s\"", s);

			sp = 1;

		}

	}

	return (sp);

}

/*

    PRINT A BUFFER LOCATION

    This routine prints the file location p to the buffer bf.  q gives

    the main location.  If the file names from p and q match then only

    the line number is printed.

*/

int

print_loc(LOCATION *p, LOCATION *q, BUFFER *bf, int sp)

{

	string fn;

	unsigned long ln;

	if (sp) {

		bfputc(bf, ' ');

	}

	if (p == NULL) {

		fn = ustrlit("<unknown>");

		ln = 0;

	} else {

		PTR(POSITION)pa = p->posn;

		if (IS_NULL_ptr(pa)) {

			fn = ustrlit("<unknown>");

		} else {

			fn = DEREF_string(posn_file(pa));

			if (q) {

				/* Check previous location */

				PTR(POSITION)qa = q->posn;

				if (EQ_ptr(qa, pa)) {

					fn = NULL;

				} else if (!IS_NULL_ptr(qa)) {

					string gn = DEREF_string(posn_file(qa));

					if (ustreq(gn, fn)) {

						fn = NULL;

					}

				}

			}

		}

		ln = p->line;

	}

	if (fn) {

		bfprintf(bf, "\"%s\"", fn);

		if (ln) {

			bfprintf(bf, ", line %lu", ln);

		}

	} else {

		bfprintf(bf, "line %lu", ln);

	}

	return (1);

}

/*

    PRINT A HASH TABLE ENTRY

    This routine prints the identifier name corresponding to the hash

    table entry p to the buffer bf.

*/

int

print_hashid(HASHID p, int sep, int anon, BUFFER *bf, int sp)

{

	unsigned tag;

	if (IS_NULL_hashid(p)) {

		return (sp);

	}

	tag = TAG_hashid(p);

	ASSERT(ORDER_hashid == 7);

	switch (tag) {

	case hashid_name_tag:

	case hashid_ename_tag: {

		/* Simple name */

		string s = DEREF_string(hashid_name_etc_text(p));

		if (sp) {

			bfputc(bf, ' ');

		}

		bfputs(bf, s);

		sp = 1;

		break;

	}

	case hashid_constr_tag:

	case hashid_destr_tag: {

		/* Class destructor name */

		IDENTIFIER tid = DEREF_id(hashid_constr_etc_tid(p));

		if (IS_NULL_id(tid)) {

			/* Unnamed constructor or destructor */

			TYPE t = DEREF_type(hashid_constr_etc_type(p));

			if (sep) {

				IGNORE print_type(t, bf, sp);

				bfprintf(bf, "::");

			} else {

				if (sp)bfputc(bf, ' ');

			}

			if (tag == hashid_destr_tag) {

				bfputc(bf, '~');

			}

			sp = print_type(t, bf, 0);

		} else {

			/* Named constructor or destructor */

			static HASHID lastp = NULL_hashid;

			if (sep && !EQ_hashid(p, lastp)) {

				lastp = p;

				tid = DEREF_id(hashid_id(p));

				sp = print_id_short(tid, qual_none, bf, sp);

				lastp = NULL_hashid;

				break;

			}

			p = DEREF_hashid(id_name(tid));

			if (sp) {

				bfputc(bf, ' ');

			}

			if (sep) {

				IGNORE print_hashid(p, 0, 1, bf, 0);

				bfprintf(bf, "::");

			}

			if (tag == hashid_destr_tag) {

				bfputc(bf, '~');

			}

			sp = print_hashid(p, 0, 1, bf, 0);

		}

		break;

	}

	case hashid_conv_tag: {

		/* Overloaded conversion name */

		int prt = print_return_type;

		TYPE t = DEREF_type(hashid_conv_type(p));

		sp = print_lex(lex_operator, bf, sp);

		print_return_type = 1;

		sp = print_type(t, bf, sp);

		print_return_type = prt;

		break;

	}

	case hashid_op_tag: {

		/* Overloaded operator name */

		int op = DEREF_int(hashid_op_lex(p));

		string s = token_name(op);

		sp = print_lex(lex_operator, bf, sp);

		if (s) {

			int c = (int)*s;

			if (isalpha(c)) {

				bfputc(bf, ' ');

			}

			bfputs(bf, s);

		}

		break;

	}

	case hashid_anon_tag: {

		/* Anonymous identifier */

		if (anon) {

			unsigned long u = DEREF_ulong(hashid_anon_uniq(p));

			if (sp) {

				bfputc(bf, ' ');

			}

			if (print_uniq_anon) {

				bfprintf(bf, "<anon%x.%lu>", uniq_string, u);

			} else {

				bfprintf(bf, "<anon%lu>", u);

			}

			sp = 1;

		}

		break;

	}

	}

	return (sp);

}

/*

    PRINT AN IDENTIFIER (SHORT FORM)

    This routines prints the short form of the identifier id to the buffer bf.

*/

int

print_id_short(IDENTIFIER id, QUALIFIER qual, BUFFER *bf, int sp)

{

	if (!IS_NULL_id(id)) {

		int sep = 0;

		HASHID p = DEREF_hashid(id_name(id));

		/* Print enclosing namespace name */

		NAMESPACE ns = DEREF_nspace(id_parent(id));

		if (sp) {

			bfputc(bf, ' ');

		}

		if (print_parent_namespace && !print_c_style) {

			if (IS_NULL_nspace(ns)) {

				if (qual == qual_full || qual == qual_top) {

					bfprintf(bf, "::");

				}

				sep = 1;

			} else {

				IGNORE print_nspace(ns, qual, 1, bf, 0);

			}

		}

		/* Print identifier name */

		if (IS_hashid_anon(p)) {

			/* Print anonymous identifier names */

			IDENTIFIER alt = id;

			unsigned tag = TAG_id(id);

			if (tag == id_token_tag) {

				DECL_SPEC ds = DEREF_dspec(id_storage(id));

				if (ds & dspec_auto) {

					alt = DEREF_id(id_token_alt(id));

					tag = id_parameter_tag;

				}

			}

			if (tag == id_parameter_tag) {

				/* Parameter names */

				unsigned long n = 0;

				MEMBER mem = DEREF_member(nspace_last(ns));

				id = DEREF_id(id_alias(id));

				alt = DEREF_id(id_alias(alt));

				while (!IS_NULL_member(mem)) {

					IDENTIFIER mid =

					    DEREF_id(member_id(mem));

					if (!IS_NULL_id(mid)) {

						if (EQ_id(mid, id)) {

							n = 0;

						}

						if (EQ_id(mid, alt)) {

							n = 0;

						}

						n++;

					}

					mem = DEREF_member(member_next(mem));

				}

				bfprintf(bf, "<param%lu>", n);

			} else {

				/* Other identifiers */

				LOCATION loc;

				string fn, fs;

				DEREF_loc(id_loc(id), loc);

				fs = DEREF_string(posn_file(loc.posn));

				fn = ustrrchr(fs, '/');

				fn = (fn ? fn + 1 : fs);

				bfprintf(bf, "(\"%s\":%lu)", fn, loc.line );

			}

		} else {

			/* Print other identifier names */

			IGNORE print_hashid(p, sep, 0, bf, 0);

		}

		sp = 1;

	}

	return (sp);

}

/*

    PRINT AN IDENTIFIER (LONG FORM)

    This routines prints the long form of the identifier id to the buffer bf.

*/

int

print_id_long(IDENTIFIER id, QUALIFIER qual, BUFFER *bf, int sp)

{

	if (!IS_NULL_id(id)) {

		int prt = 1;

		int key = 0;

		TYPE t = NULL_type;

		TYPE f = NULL_type;

		TOKEN tok = NULL_tok;

		GRAPH gr = NULL_graph;

		CONST char *desc = NULL;

		int full = print_id_desc;

		NAMESPACE pns = NULL_nspace;

		LIST(TYPE)p = NULL_list(TYPE);

		switch (TAG_id(id)) {

		case id_keyword_tag:

		case id_iso_keyword_tag: {

			/* Keywords */

			if (full) {

				desc = "keyword";

			}

			break;

		}

		case id_builtin_tag: {

			/* Built-in operators */

			t = DEREF_type(id_builtin_ret(id));

			p = DEREF_list(id_builtin_ptypes(id));

			if (full) {

				desc = "built-in";

			}

			break;

		}

		case id_obj_macro_tag:

		case id_func_macro_tag: {

			/* Macros */

			if (full) {

				desc = "macro";

			}

			break;

		}

		case id_predicate_tag: {

			/* Predicates */

			if (full) {

				desc = "predicate";

			}

			break;

		}

		case id_class_name_tag:

		case id_enum_name_tag: {

			/* Class and enumeration names */

			f = DEREF_type(id_class_name_etc_defn(id));

			key = (full || print_c_style);

			break;

		}

		case id_class_alias_tag:

		case id_enum_alias_tag:

		case id_type_alias_tag: {

			/* Typedef names */

			if (full) {

				t = DEREF_type(id_class_name_etc_defn(id));

				desc = "typedef";

			}

			break;

		}

		case id_nspace_name_tag: {

			/* Namespace names */

			if (full) {

				desc = "namespace";

			}

			break;

		}

		case id_nspace_alias_tag: {

			/* Namespace aliases */

			if (full) {

				desc = "namespace";

				pns = DEREF_nspace(id_nspace_alias_defn(id));

			}

			break;

		}

		case id_variable_tag:

		case id_parameter_tag: {

			/* Object names */

			if (full) {

				DECL_SPEC ds = DEREF_dspec(id_storage(id));

				if (ds & dspec_auto) {

					desc = "auto";

				}

				t = DEREF_type(id_variable_etc_type(id));

			}

			break;

		}

		case id_stat_member_tag: {

			/* Static members */

			if (full) {

				t = DEREF_type(id_stat_member_type(id));

				desc = "static";

			}

			break;

		}

		case id_weak_param_tag: {

			if (full) {

				desc = "auto";

				t = type_sint;

			}

			break;

		}

		case id_function_tag:

		case id_mem_func_tag: {

			/* Function names */

			HASHID nm = DEREF_hashid(id_name(id));

			switch (TAG_hashid(nm)) {

			case hashid_constr_tag:

			case hashid_destr_tag:

			case hashid_conv_tag: {

				/* Inhibit return type */

				prt = 0;

				break;

			}

			}

			t = DEREF_type(id_function_etc_type(id));

			f = DEREF_type(id_function_etc_form(id));

			if (!IS_NULL_type(f) && !IS_type_token(f)) {

				f = NULL_type;

			}

			if (full) {

				DECL_SPEC ds = DEREF_dspec(id_storage(id));

				if (ds & dspec_implicit) {

					desc = "implicit";

				}

			} else {

				if (print_c_style) {

					t = NULL_type;

				}

			}

			break;

		}

		case id_stat_mem_func_tag: {

			/* Static function member names */

			t = DEREF_type(id_stat_mem_func_type(id));

			f = DEREF_type(id_stat_mem_func_form(id));

			if (!IS_NULL_type(f) && !IS_type_token(f)) {

				f = NULL_type;

			}

			if (full) {

				desc = "static";

			} else {

				if (print_c_style) {

					t = NULL_type;

				}

			}

			break;

		}

		case id_member_tag: {