WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/output/unmangle.c

+/*
+ * 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.
 */
     The following forward declarations are required in the name unmangling
     routines.
 */
-static NAT unmangle_nat PROTO_S ( ( string * ) ) ;
+static NAT unmangle_nat(string *);
-static TYPE unmangle_type PROTO_S ( ( string *, CV_SPEC, BASE_TYPE, int ) ) ;
+static TYPE unmangle_type(string *, CV_SPEC, BASE_TYPE, int);
-static IDENTIFIER unmangle_nspace PROTO_S ( ( string *, NAMESPACE, int ) ) ;
+static IDENTIFIER unmangle_nspace(string *, NAMESPACE, int);
-static LIST ( TOKEN ) unmangle_token_args PROTO_S ( ( string * ) ) ;
+static LIST(TOKEN)unmangle_token_args(string *);
-static TOKEN find_token_arg PROTO_S ( ( string * ) ) ;
+static TOKEN find_token_arg(string *);
 /*
     DUMMY RETURN TYPE
     This variable is a dummy used as a return type when none is given in
     a mangled form.  Its printed form is empty.
 */
-static TYPE dummy_ret_type = NULL_type ;
+static TYPE dummy_ret_type = NULL_type;
 /*
     CURRENT UNMANGLING INFORMATION
     The following variables are used to hold certain information about the
     identifier being unmangled.
 */
-static IDENTIFIER crt_unmangle_class = NULL_id ;
+static IDENTIFIER crt_unmangle_class = NULL_id;
-static LIST ( TOKEN ) crt_unmangle_args = NULL_list ( TOKEN ) ;
+static LIST(TOKEN)crt_unmangle_args = NULL_list(TOKEN);
 /*
     UNMANGLE AN OPERATOR NAME
     This routine unmangles an operator name from the string pointed to
     by ps.
+	}
-	case 'd' : {
+	case 's': {
-	    c = *( s++ ) ;
+		c = *(s++);
-	    switch ( c ) {
+		if (c == 'z') {
-		case 'f' : t = lex_dot ; break ;
-		case 'l' : t = lex_delete ; break ;
-		case 'm' : t = lex_dot_Hstar ; break ;
-		case 't' : t = lex_destructor_Hname ; break ;
-		case 'v' : t = lex_div ; break ;
+			t = lex_sizeof;
-	    }
+		}
-	    break ;
+		break;
+	}
-	case 'e' : {
+	case 't': {
-	    c = *( s++ ) ;
+		c = *(s++);
-	    switch ( c ) {
+		switch (c) {
-		case 'q' : t = lex_eq ; break ;
-		case 'r' : t = lex_xor_H1 ; break ;
-	    }
-	    break ;
-	}
-	case 'f' : {
+		case 'b':
-	    t = lex_float ;
+			t = lex_vtable;
-	    break ;
+			break;
-	}
-	case 'g' : {
+		case 'd':
-	    c = *( s++ ) ;
+			t = lex_typeid;
-	    switch ( c ) {
-		case 'e' : t = lex_greater_Heq ; break ;
-		case 't' : t = lex_greater ; break ;
-	    }
-	    break ;
+			break;
-	}
-	case 'l' : {
+		case 'i': {
-	    c = *( s++ ) ;
-	    switch ( c ) {
-		case 'e' : t = lex_less_Heq ; break ;
-		case 's' : t = lex_lshift ; break ;
+			if (s[0] == '_' && s[1] == '_') {
-		case 't' : t = lex_less ; break ;
-	    }
-	    break ;
-	}
-	case 'm' : {
-	    c = *( s++ ) ;
+				t = lex_typeof;
-	    switch ( c ) {
-		case 'd' : t = lex_rem ; break ;
-		case 'i' : t = lex_minus ; break ;
-		case 'l' : t = lex_star ; break ;
-		case 'm' : t = lex_minus_Hminus ; break ;
-		case 'n' : t = lex_min ; break ;
-		case 'x' : t = lex_max ; break ;
-	    }
-	    break ;
-	}
-	case 'n' : {
+				s += 2;
-	    c = *( s++ ) ;
-	    switch ( c ) {
-		case 'e' : t = lex_not_Heq_H1 ; break ;
-		case 't' : t = lex_not_H1 ; break ;
-		case 'w' : t = lex_new ; break ;
-	    }
-	    break ;
-	}
+			}
-	case 'o' : {
-	    c = *( s++ ) ;
-	    switch ( c ) {
-		case 'o' : t = lex_logical_Hor_H1 ; break ;
-		case 'p' : t = lex_operator ; break ;
-		case 'r' : t = lex_or_H1 ; break ;
-	    }
-	    break ;
+			break;
-	}
+		}
-	case 'p' : {
-	    c = *( s++ ) ;
-	    switch ( c ) {
-		case 'l' : t = lex_plus ; break ;
-		case 'p' : t = lex_plus_Hplus ; break ;
-	    }
-	    break ;
-	}
+		}
-	case 'r' : {
-	    c = *( s++ ) ;
-	    switch ( c ) {
-		case 'f' : t = lex_arrow ; break ;
-		case 'm' : t = lex_arrow_Hstar ; break ;
-		case 's' : t = lex_rshift ; break ;
-	    }
-	    break ;
+		break;
+	}
-	case 's' : {
+	case 'v': {
-	    c = *( s++ ) ;
+		c = *(s++);
+		switch (c) {
+		case 'c':
-	    if ( c == 'z' ) t = lex_sizeof ;
+			t = lex_array_Hop;
-	    break ;
+			break;
+		case 'd':
+			t = lex_delete_Harray;
-	}
+			break;
-	case 't' : {
+		case 'n':
-	    c = *( s++ ) ;
+			t = lex_new_Harray;
+			break;
-	    switch ( c ) {
+		case '_':
-		case 'b' : t = lex_vtable ; break ;
+			t = lex_static;
-		case 'd' : t = lex_typeid ; break ;
+			break;
-		case 'i' : {
+		case 't': {
-		    if ( s [0] == '_' && s [1] == '_' ) {
+			if (s[0] == '_' && s[1] == '_') {
-			t = lex_typeof ;
+				t = lex_virtual;
-			s += 2 ;
+				s += 2;
-		    }
+			}
-		    break ;
+			break;
+		}
+		}
-	    }
-	    break ;
-	}
-	case 'v' : {
-	    c = *( s++ ) ;
-	    switch ( c ) {
-		case 'c' : t = lex_array_Hop ; break ;
-		case 'd' : t = lex_delete_Harray ; break ;
-		case 'n' : t = lex_new_Harray ; break ;
-		case '_' : t = lex_static ; break ;
-		case 't' : {
-		    if ( s [0] == '_' && s [1] == '_' ) {
-			t = lex_virtual ;
-			s += 2 ;
-		    }
-		    break ;
+		break;
-		}
-	    }
-	    break ;
-	}
-	case '0' : case '1' : case '2' : case '3' : case '4' :
-	case '5' : case '6' : case '7' : case '8' : case '9' : {
-	    t = lex_auto ;
-	    break ;
+	}
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9': {
+		t = lex_auto;
+		break;
+	}
-    }
+	}
-    if ( t != lex_unknown ) *ps = s ;
+	if (t != lex_unknown) {
+		*ps = s;
+	}
-    return ( t ) ;
+	return (t);
+}
 /*
     UNMANGLE A NUMBER
     This routine unmangles a series of digits from the string pointed
     to by ps.  If e is true then the digits should be terminated by an
     underscore.
 */
-static unsigned unmangle_no
+static unsigned
-    PROTO_N ( ( ps, e ) )
-    PROTO_T ( string *ps X int e )
+unmangle_no(string *ps, int e)
+{
-    character c ;
+	character c;
-    unsigned n = 0 ;
+	unsigned n = 0;
-    string s = *ps ;
+	string s = *ps;
-    while ( c = *( s++ ), ( c >= char_zero && c <= char_nine ) ) {
+	while (c = *(s++), (c >= char_zero && c <= char_nine)) {
-	unsigned d = ( unsigned ) ( c - char_zero ) ;
+		unsigned d = (unsigned)(c - char_zero);
-	n = 10 * n + d ;
+		n = 10 * n + d;
-    }
+	}
-    if ( c != MANGLE_sep || e == 0 ) s-- ;
+	if (c != MANGLE_sep || e == 0) {
+		s--;
+	}
-    *ps = s ;
+	*ps = s;
-    return ( n ) ;
+	return (n);
+}
 /*
     UNMANGLE A SMALL NUMBER
     This routine unmangles a small number from the string pointed to
     by ps.  This consists either of a single digit or a series of digits
     delimited by underscores.
 */
-static unsigned unmangle_digit
+static unsigned
-    PROTO_N ( ( ps ) )
-    PROTO_T ( string *ps )
+unmangle_digit(string *ps)
 {
-    unsigned n ;
+	unsigned n;
-    string s = *ps ;
+	string s = *ps;
-    character c = *( s++ ) ;
+	character c = *(s++);
-    if ( c >= char_zero && c <= char_nine ) {
+	if (c >= char_zero && c <= char_nine) {
-	n = ( unsigned ) ( c - char_zero ) ;
+		n = (unsigned)(c - char_zero);
-    } else if ( c == MANGLE_sep ) {
+	} else if (c == MANGLE_sep) {
-	n = unmangle_no ( &s, 1 ) ;
+		n = unmangle_no(&s, 1);
-    } else {
+	} else {
-	n = 0 ;
+		n = 0;
-	s-- ;
+		s--;
-    }
+	}
-    *ps = s ;
+	*ps = s;
-    return ( n ) ;
+	return (n);
 }
 /*
     UNMANGLE AN EXPRESSION
     This routine unmangles an expression of type t from the string pointed
     to by ps.
 */
-static EXP unmangle_exp
+static EXP
-    PROTO_N ( ( ps, t ) )
-    PROTO_T ( string *ps X TYPE t )
+unmangle_exp(string *ps, TYPE t)
 {
-    EXP e = NULL_exp ;
+	EXP e = NULL_exp;
-    string s = *ps ;
+	string s = *ps;
-    character c = *s ;
+	character c = *s;
-    if ( ( c >= char_zero && c <= char_nine ) || c == MANGLE_neg ) {
+	if ((c >= char_zero && c <= char_nine) || c == MANGLE_neg) {
-	/* Read an integer constant */
+		/* Read an integer constant */
-	NAT n = unmangle_nat ( &s ) ;
+		NAT n = unmangle_nat(&s);
-	if ( !IS_NULL_nat ( n ) ) {
+		if (!IS_NULL_nat(n)) {
-	    MAKE_exp_int_lit ( t, n, exp_int_lit_tag, e ) ;
+			MAKE_exp_int_lit(t, n, exp_int_lit_tag, e);
-	}
+		}
-    } else if ( c == MANGLE_op ) {
+	} else if (c == MANGLE_op) {
-	int op ;
+		int op;
-	s++ ;
+		s++;
-	op = unmangle_op ( &s ) ;
+		op = unmangle_op(&s);
-	if ( op == lex_float ) {
+		if (op == lex_float) {
-	    /* Floating point literals */
+			/* Floating point literals */
-	    string u = xustrcpy ( s ) ;
+			string u = xustrcpy(s);
-	    string v = u ;
+			string v = u;
-	    while ( c = *( s++ ), c != 0 ) {
+			while (c = *(s++), c != 0) {
-		if ( c == MANGLE_sep ) {
+				if (c == MANGLE_sep) {
-		    *v = 0 ;
+					*v = 0;
-		    s++ ;
+					s++;
-		    break ;
+					break;
-		}
+				}
-		if ( ( c >= char_zero && c <= char_nine ) || c == 'e' ) {
+				if ((c >= char_zero && c <= char_nine) ||
+				    c == 'e') {
-		    /* EMPTY */
+					/* EMPTY */
-		} else if ( c == 'd' ) {
+				} else if (c == 'd') {
-		    *v = '.' ;
+					*v = '.';
-		} else if ( c == MANGLE_neg ) {
+				} else if (c == MANGLE_neg) {
-		    *v = '-' ;
+					*v = '-';
-		} else {
+				} else {
-		    *v = 0 ;
+					*v = 0;
-		    break ;
+					break;
-		}
+				}
-		v++ ;
+				v++;
-	    }
+			}
-	    s-- ;
+			s--;
-	    e = make_literal_exp ( u, &op, 0 ) ;
+			e = make_literal_exp(u, &op, 0);
-	} else {
+		} else {
-	    int n = 0 ;
+			int n = 0;
-	    c = *s ;
+			c = *s;
-	    if ( c >= char_zero && c <= char_nine ) {
+			if (c >= char_zero && c <= char_nine) {
-		n = ( int ) ( c - char_zero ) ;
+				n = (int)(c - char_zero);
-		s++ ;
+				s++;
-	    }
+			}
-	    if ( op == lex_sizeof ) {
+			if (op == lex_sizeof) {
-		TYPE r = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
+				TYPE r = unmangle_type(&s, cv_none, btype_none,
+);
-		e = make_sizeof_exp ( r, NULL_exp, 0, op ) ;
+				e = make_sizeof_exp(r, NULL_exp, 0, op);
-	    } else {
+			} else {
-		LIST ( EXP ) p = NULL_list ( EXP ) ;
+				LIST(EXP)p = NULL_list(EXP);
-		while ( n ) {
+				while (n) {
-		    EXP a = unmangle_exp ( &s, t ) ;
+					EXP a = unmangle_exp(&s, t);
-		    CONS_exp ( a, p, p ) ;
+					CONS_exp(a, p, p);
-		    n-- ;
+					n--;
-		}
+				}
-		p = REVERSE_list ( p ) ;
+				p = REVERSE_list(p);
-		MAKE_exp_opn ( t, op, p, e ) ;
+				MAKE_exp_opn(t, op, p, e);
-	    }
+			}
-	}
+		}
-    } else if ( c == MANGLE_sep ) {
+	} else if (c == MANGLE_sep) {
-	IDENTIFIER id ;
+		IDENTIFIER id;
-	s++ ;
+		s++;
-	id = unmangle_nspace ( &s, global_namespace, 1 ) ;
+		id = unmangle_nspace(&s, global_namespace, 1);
-	if ( !IS_NULL_id ( id ) ) {
+		if (!IS_NULL_id(id)) {
-	    MAKE_exp_identifier ( t, id, qual_nested, e ) ;
+			MAKE_exp_identifier(t, id, qual_nested, e);
-	}
+		}
-    } else if ( c == MANGLE_templ_param ) {
+	} else if (c == MANGLE_templ_param) {
-	/* Template parameter expressions */
+		/* Template parameter expressions */
-	TOKEN tok ;
+		TOKEN tok;
-	s++ ;
+		s++;
-	tok = find_token_arg ( &s ) ;
+		tok = find_token_arg(&s);
-	if ( !IS_NULL_tok ( tok ) && IS_tok_exp ( tok ) ) {
+		if (!IS_NULL_tok(tok) && IS_tok_exp(tok)) {
-	    e = DEREF_exp ( tok_exp_value ( tok ) ) ;
+			e = DEREF_exp(tok_exp_value(tok));
-	}
+		}
-    }
+	}
-    *ps = s ;
+	*ps = s;
-    return ( e ) ;
+	return (e);
 }
 /*
     UNMANGLE AN INTEGER CONSTANT
     This routine unmangles an integer constant from the string pointed to
     by ps.
 */
-static NAT unmangle_nat
+static NAT
-    PROTO_N ( ( ps ) )
-    PROTO_T ( string *ps )
+unmangle_nat(string *ps)
+{
-    NAT n = NULL_nat ;
+	NAT n = NULL_nat;
-    string s = *ps ;
+	string s = *ps;
-    character c = *s ;
+	character c = *s;
-    if ( c >= char_zero && c <= char_nine ) {
+	if (c >= char_zero && c <= char_nine) {
-	/* Read a sequence of digits */
+		/* Read a sequence of digits */
-	s++ ;
+		s++;
-	do {
+		do {
-	    unsigned d = ( unsigned ) ( c - char_zero ) ;
+			unsigned d = (unsigned)(c - char_zero);
-	    n = make_nat_literal ( n, ( unsigned ) 10, d ) ;
+			n = make_nat_literal(n,(unsigned)10, d);
-	} while ( c = *( s++ ), ( c >= char_zero && c <= char_nine ) ) ;
+		} while (c = *(s++), (c >= char_zero && c <= char_nine));
-	if ( c != MANGLE_sep ) s-- ;
+		if (c != MANGLE_sep) {
+			s--;
+		}
-    } else if ( c == MANGLE_sep ) {
+	} else if (c == MANGLE_sep) {
-	/* Empty sequence of digits */
+		/* Empty sequence of digits */
-	s++ ;
+		s++;
-    } else if ( c == MANGLE_neg ) {
+	} else if (c == MANGLE_neg) {
-	/* Negate an integer */
+		/* Negate an integer */
-	s++ ;
+		s++;
-	n = unmangle_nat ( &s ) ;
+		n = unmangle_nat(&s);
-	n = negate_nat ( n ) ;
+		n = negate_nat(n);
-    } else {
+	} else {
-	/* Read an expression */
+		/* Read an expression */
-	EXP e = unmangle_exp ( &s, type_sint ) ;
+		EXP e = unmangle_exp(&s, type_sint);
-	if ( !IS_NULL_exp ( e ) ) {
+		if (!IS_NULL_exp(e)) {
-	    MAKE_nat_calc ( e, n ) ;
+			MAKE_nat_calc(e, n);
+		}
+	}
-    }
-    *ps = s ;
+	*ps = s;
-    return ( n ) ;
+	return (n);
+}
 /*
     UNMANGLE A NAMESPACE QUALIFIER
     This routine unmangles a namespace qualifier from the string pointed
     to by ps.  Note that all such namespaces are declared as classes even
     if they are not in reality.
 */
-static IDENTIFIER unmangle_nspace
+static IDENTIFIER
-    PROTO_N ( ( ps, ns, var ) )
-    PROTO_T ( string *ps X NAMESPACE ns X int var )
+unmangle_nspace(string *ps, NAMESPACE ns, int var)
+{
-    string s = *ps ;
+	string s = *ps;
-    character c = *s ;
+	character c = *s;
-    IDENTIFIER id = NULL_id ;
+	IDENTIFIER id = NULL_id;
-    if ( c >= char_zero && c <= char_nine ) {
+	if (c >= char_zero && c <= char_nine) {
-	unsigned n = unmangle_no ( &s, 0 ) ;
+		unsigned n = unmangle_no(&s, 0);
-	if ( n ) {
+		if (n) {
-	    HASHID nm ;
+			HASHID nm;
-	    int ext = 0 ;
+			int ext = 0;
-	    TYPE t = NULL_type ;
+			TYPE t = NULL_type;
-	    string p = xustr ( ( gen_size ) ( n + 1 ) ) ;
+			string p = xustr((gen_size)(n + 1));
-	    string q = p ;
+			string q = p;
-	    while ( n ) {
+			while (n) {
-		c = *s ;
+				c = *s;
-		if ( c ) {
+				if (c) {
-		    if ( c == MANGLE_sep && s [1] == MANGLE_sep ) {
+					if (c == MANGLE_sep && s[1] ==
+					    MANGLE_sep) {
-			/* Allow for unicode characters */
+						/* Allow for unicode
+						 * characters */
-			if ( s [2] == MANGLE_unicode4 ) {
+						if (s[2] == MANGLE_unicode4) {
-			    *( q++ ) = char_backslash ;
+							*(q++) = char_backslash;
-			    c = char_u ;
+							c = char_u;
-			    ext = 1 ;
+							ext = 1;
-			    s += 2 ;
+							s += 2;
+						} else if (s[2] ==
-			} else if ( s [2] == MANGLE_unicode8 ) {
+							   MANGLE_unicode8) {
-			    *( q++ ) = char_backslash ;
+							*(q++) = char_backslash;
-			    c = char_U ;
+							c = char_U;
-			    ext = 1 ;
+							ext = 1;
-			    s += 2 ;
+							s += 2;
-			}
+						}
-		    }
+					}
-		    *( q++ ) = c ;
+					*(q++) = c;
-		    s++ ;
+					s++;
-		} else {
+				} else {
-		    *( q++ ) = char_question ;
+					*(q++) = char_question;
+				}
+				n--;
+			}
+			*q = 0;
+			nm = lookup_name(p, hash(p), ext, lex_identifier);
+			if (var) {
+				t = type_sint;
+				MAKE_id_variable(nm, dspec_extern, ns, crt_loc,
+						 t, id);
+			} else {
+				id = make_class(ns, nm, btype_lang,
+						dspec_extern, t, t);
+			}
+		}
+	} else if (c == MANGLE_qual) {
+		unsigned n;
+		s++;
+		n = unmangle_digit(&s);
+		while (n) {
+			NAMESPACE pns;
+			id = unmangle_nspace(&s, ns, 0);
+			pns = find_namespace(id);
+			if (!IS_NULL_nspace(pns)) {
+				ns = pns;
+			}
+			n--;
+		}
+	} else if (c == MANGLE_template) {
+		s++;
+		id = unmangle_nspace(&s, ns, 0);
+		if (!IS_NULL_id(id)) {
+			LIST(TOKEN)args = unmangle_token_args(&s);
+			TYPE t = make_dummy_class(id, args, btype_lang);
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
+			id = DEREF_id(ctype_name(ct));
+		}
-		n-- ;
-	    }
-	    *q = 0 ;
-	    nm = lookup_name ( p, hash ( p ), ext, lex_identifier ) ;
-	    if ( var ) {
-		t = type_sint ;
-		MAKE_id_variable ( nm, dspec_extern, ns, crt_loc, t, id ) ;
-	    } else {
-		id = make_class ( ns, nm, btype_lang, dspec_extern, t, t ) ;
-	    }
-	}
-    } else if ( c == MANGLE_qual ) {
-	unsigned n ;
-	s++ ;
-	n = unmangle_digit ( &s ) ;
-	while ( n ) {
-	    NAMESPACE pns ;
-	    id = unmangle_nspace ( &s, ns, 0 ) ;
-	    pns = find_namespace ( id ) ;
-	    if ( !IS_NULL_nspace ( pns ) ) ns = pns ;
-	    n-- ;
-	}
-    } else if ( c == MANGLE_template ) {
-	s++ ;
-	id = unmangle_nspace ( &s, ns, 0 ) ;
-	if ( !IS_NULL_id ( id ) ) {
-	    LIST ( TOKEN ) args = unmangle_token_args ( &s ) ;
-	    TYPE t = make_dummy_class ( id, args, btype_lang ) ;
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
-	    id = DEREF_id ( ctype_name ( ct ) ) ;
-	}
-    } else if ( c == MANGLE_templ_param ) {
+	} else if (c == MANGLE_templ_param) {
-	TOKEN tok ;
+		TOKEN tok;
-	s++ ;
+		s++;
-	tok = find_token_arg ( &s ) ;
+		tok = find_token_arg(&s);
-	if ( !IS_NULL_tok ( tok ) && IS_tok_type ( tok ) ) {
+		if (!IS_NULL_tok(tok) && IS_tok_type(tok)) {
-	    TYPE t = DEREF_type ( tok_type_value ( tok ) ) ;
+			TYPE t = DEREF_type(tok_type_value(tok));
-	    if ( !IS_NULL_type ( t ) && IS_type_compound ( t ) ) {
+			if (!IS_NULL_type(t) && IS_type_compound(t)) {
+				CLASS_TYPE ct =
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+				    DEREF_ctype(type_compound_defn(t));
-		id = DEREF_id ( ctype_name ( ct ) ) ;
+				id = DEREF_id(ctype_name(ct));
-	    }
+			}
-	}
+		}
-    }
+	}
-    *ps = s ;
+	*ps = s;
-    return ( id ) ;
+	return (id);
 }
 /*
     UNMANGLE A TOKEN ARGUMENT
     This routine unmangles a token or template argument from the string
     pointed to by ps.
 */
-static TOKEN unmangle_token_arg
+static TOKEN
-    PROTO_N ( ( ps ) )
-    PROTO_T ( string *ps )
+unmangle_token_arg(string *ps)
+{
-    TOKEN tok = NULL_tok ;
+	TOKEN tok = NULL_tok;
-    string s = *ps ;
+	string s = *ps;
-    character c = *s ;
+	character c = *s;
-    switch ( c ) {
+	switch (c) {
-	case MANGLE_nat : {
+	case MANGLE_nat: {
-	    /* Integer constant tokens */
+		/* Integer constant tokens */
-	    NAT n ;
+		NAT n;
-	    s++ ;
+		s++;
-	    n = unmangle_nat ( &s ) ;
+		n = unmangle_nat(&s);
-	    if ( !IS_NULL_nat ( n ) ) {
+		if (!IS_NULL_nat(n)) {
-		MAKE_tok_nat ( n, tok ) ;
+			MAKE_tok_nat(n, tok);
+		}
+		break;
+	}
+	case MANGLE_stmt: {
+		/* Statement tokens */
+		EXP e;
+		s++;
+		e = unmangle_exp(&s, type_void);
+		if (!IS_NULL_exp(e)) {
+			MAKE_tok_stmt(e, tok);
-	    }
+		}
+		break;
+	}
+	case MANGLE_type: {
+		/* Type tokens */
+		TYPE t;
+		s++;
+		t = unmangle_type(&s, cv_none, btype_none, 1);
+		MAKE_tok_type(btype_none, t, tok);
-	    break ;
+		break;
+	}
-	case MANGLE_stmt : {
+	default: {
-	    /* Statement tokens */
+		/* Expression tokens */
-	    EXP e ;
+		TYPE t = unmangle_type(&s, cv_none, btype_none, 1);
-	    s++ ;
-	    e = unmangle_exp ( &s, type_void ) ;
+		EXP e = unmangle_exp(&s, t);
-	    if ( !IS_NULL_exp ( e ) ) {
+		if (!IS_NULL_exp(e)) {
-		MAKE_tok_stmt ( e, tok ) ;
+			MAKE_tok_exp(t, 0, e, tok);
-	    }
+		}
-	    break ;
+		break;
+	}
-	case MANGLE_type : {
-	    /* Type tokens */
-	    TYPE t ;
-	    s++ ;
-	    t = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    MAKE_tok_type ( btype_none, t, tok ) ;
-	    break ;
+	}
-	default : {
-	    /* Expression tokens */
-	    TYPE t = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    EXP e = unmangle_exp ( &s, t ) ;
-	    if ( !IS_NULL_exp ( e ) ) {
-		MAKE_tok_exp ( t, 0, e, tok ) ;
-	    }
-	    break ;
-	}
-    }
-    *ps = s ;
+	*ps = s;
-    return ( tok ) ;
+	return (tok);
+}
 /*
     UNMANGLE A LIST OF TOKEN ARGUMENTS
     This routine unmangles a list of token or template arguments from the
     string pointed to by ps.
 */
-static LIST ( TOKEN ) unmangle_token_args
+static LIST(TOKEN)
-    PROTO_N ( ( ps ) )
-    PROTO_T ( string *ps )
+unmangle_token_args(string *ps)
+{
-    string s = *ps ;
+	string s = *ps;
-    unsigned n = unmangle_digit ( &s ) ;
+	unsigned n = unmangle_digit(&s);
-    LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
+	LIST(TOKEN)args = NULL_list(TOKEN);
-    while ( n ) {
+	while (n) {
-	TOKEN tok = unmangle_token_arg ( &s ) ;
+		TOKEN tok = unmangle_token_arg(&s);
-	if ( !IS_NULL_tok ( tok ) ) {
+		if (!IS_NULL_tok(tok)) {
-	    CONS_tok ( tok, args, args ) ;
+			CONS_tok(tok, args, args);
+		}
+		if (*s == 0) {
+			break;
+		}
+		n--;
+	}
-	if ( *s == 0 ) break ;
-	n-- ;
-    }
-    args = REVERSE_list ( args ) ;
+	args = REVERSE_list(args);
-    *ps = s ;
+	*ps = s;
-    return ( args ) ;
+	return (args);
+}
 /*
     FIND A TOKEN ARGUMENT VALUE
     This routine returns the an argument from the current argument list.
     The arguments are numbered from zero.
 */
-static TOKEN find_token_arg
+static TOKEN
-    PROTO_N ( ( ps ) )
-    PROTO_T ( string *ps )
+find_token_arg(string *ps)
 {
-    unsigned n = unmangle_digit ( ps ) ;
+	unsigned n = unmangle_digit(ps);
-    LIST ( TOKEN ) args = crt_unmangle_args ;
+	LIST(TOKEN)args = crt_unmangle_args;
-    while ( !IS_NULL_list ( args ) ) {
+	while (!IS_NULL_list(args)) {
-	if ( n == 0 ) {
+		if (n == 0) {
-	    /* Token argument found */
+			/* Token argument found */
-	    TOKEN arg = DEREF_tok ( HEAD_list ( args ) ) ;
+			TOKEN arg = DEREF_tok(HEAD_list(args));
-	    return ( arg ) ;
+			return (arg);
-	}
+		}
-	n-- ;
+		n--;
-	args = TAIL_list ( args ) ;
+		args = TAIL_list(args);
-    }
+	}
-    return ( NULL_tok ) ;
+	return (NULL_tok);
 }
 /*
     FIND A FUNCTION PARAMETER TYPE
     This routine returns the mth parameter type from the members mem.
     The parameters are numbered from one, with n giving the total number
     of parameters.
 */
-static TYPE unmangle_param
+static TYPE
-    PROTO_N ( ( m, n, mem ) )
-    PROTO_T ( unsigned m X unsigned n X MEMBER mem )
+unmangle_param(unsigned m, unsigned n, MEMBER mem)
 {
-    while ( !IS_NULL_member ( mem ) ) {
+	while (!IS_NULL_member(mem)) {
-	IDENTIFIER id = DEREF_id ( member_id ( mem ) ) ;
+		IDENTIFIER id = DEREF_id(member_id(mem));
-	if ( !IS_NULL_id ( id ) && IS_id_parameter ( id ) ) {
+		if (!IS_NULL_id(id) && IS_id_parameter(id)) {
-	    if ( m == n ) {
+			if (m == n) {
-		/* Parameter type found */
+				/* Parameter type found */
-		TYPE t = DEREF_type ( id_parameter_type ( id ) ) ;
+				TYPE t = DEREF_type(id_parameter_type(id));
-		return ( t ) ;
+				return (t);
-	    }
+			}
-	    m++ ;
+			m++;
-	}
+		}
-	mem = DEREF_member ( member_next ( mem ) ) ;
+		mem = DEREF_member(member_next(mem));
-    }
+	}
-    return ( type_error ) ;
+	return (type_error);
 }
 /*
     UNMANGLE A FUNCTION TYPE
     This routine unmangles a function type from the string pointed to
     by ps.
 */
-static TYPE unmangle_func
+static TYPE
-    PROTO_N ( ( ps, cv, ret ) )
-    PROTO_T ( string *ps X CV_SPEC cv X int ret )
+unmangle_func(string *ps, CV_SPEC cv, int ret)
-{
-    TYPE t ;
-    string s = *ps ;
-    character c = *s ;
-    if ( c == MANGLE_const ) {
-	/* Const member function type */
-	s++ ;
-	cv |= cv_const ;
-	t = unmangle_func ( &s, cv, ret ) ;
-    } else if ( c == MANGLE_volatile ) {
-	/* Volatile member function type */
-	s++ ;
-	cv |= cv_volatile ;
-	t = unmangle_func ( &s, cv, ret ) ;
-    } else if ( c == MANGLE_c_lang ) {
-	/* C linkage function type */
-	s++ ;
-	cv |= cv_c ;
-	t = unmangle_func ( &s, cv, ret ) ;
-    } else {
-	/* Read list of parameter types */
-	TYPE t1 ;
-	MEMBER mem ;
-	NAMESPACE ns ;
-	unsigned npars = 0 ;
-	int ell = FUNC_NONE ;
-	begin_param ( NULL_id ) ;
-	ns = crt_namespace ;
-	for ( ; ; ) {
-	    /* Read parameter types */
-	    unsigned m ;
-	    unsigned n = 1 ;
-	    c = *s ;
-	    if ( c == 0 ) {
-		break ;
-	    } else if ( c == MANGLE_ellipsis ) {
-		/* Ellipsis */
-		s++ ;
-		ell = FUNC_ELLIPSIS ;
-		break ;
-	    } else if ( c == MANGLE_repeat ) {
-		/* Repeated parameter */
-		s++ ;
-		m = unmangle_digit ( &s ) ;
-		mem = DEREF_member ( nspace_last ( ns ) ) ;
-		t1 = unmangle_param ( m, npars, mem ) ;
-	    } else if ( c == MANGLE_multi ) {
-		/* Multiply repeated parameter */
-		s++ ;
-		n = unmangle_digit ( &s ) ;
-		m = unmangle_no ( &s, 1 ) ;
-		mem = DEREF_member ( nspace_last ( ns ) ) ;
-		t1 = unmangle_param ( m, npars, mem ) ;
-	    } else {
-		/* Simple parameter type */
-		t1 = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-		if ( IS_type_error ( t1 ) ) break ;
-	    }
-	    while ( n ) {
-		/* Declare parameters */
-		DECL_SPEC ds = dspec_none ;
-		HASHID nm = lookup_anon () ;
-		IDENTIFIER pid = DEREF_id ( hashid_id ( nm ) ) ;
-		pid = make_param_decl ( ds, t1, pid, CONTEXT_PARAMETER ) ;
-		init_param ( pid, NULL_exp ) ;
-		npars++ ;
-		n-- ;
-	    }
-	}
-	t = make_func_type ( dummy_ret_type, ell, cv, empty_type_set ) ;
-	end_param () ;
-	if ( ret ) {
-	    /* Read return type */
-	    c = *( s++ ) ;
-	    if ( c == MANGLE_sep ) {
-		t1 = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    } else {
-		t1 = type_error ;
-		s-- ;
-	    }
-	    COPY_type ( type_func_ret ( t ), NULL_type ) ;
-	    t = inject_pre_type ( t, t1, 0 ) ;
-	}
-    }
-    *ps = s ;
-    return ( t ) ;
-}
-/*
-    UNMANGLE A TYPE
-    This routine unmangles a type from the string pointed to by ps.
-*/
-static TYPE unmangle_type
-    PROTO_N ( ( ps, cv, bt, ret ) )
-    PROTO_T ( string *ps X CV_SPEC cv X BASE_TYPE bt X int ret )
+{
-    TYPE t ;
+	TYPE t;
-    string s = *ps ;
+	string s = *ps;
-    character c = *( s++ ) ;
+	character c = *s;
-    switch ( c ) {
+	if (c == MANGLE_const) {
-	case MANGLE_char : t = make_base_type ( bt | btype_char ) ; break ;
+		/* Const member function type */
+		s++;
-	case MANGLE_short : t = make_base_type ( bt | btype_short ) ; break ;
+		cv |= cv_const;
-	case MANGLE_int : t = make_base_type ( bt | btype_int ) ; break ;
+		t = unmangle_func(&s, cv, ret);
-	case MANGLE_long : t = make_base_type ( bt | btype_long ) ; break ;
+	} else if (c == MANGLE_volatile) {
-	case MANGLE_llong : t = make_base_type ( bt | btype_llong ) ; break ;
+		/* Volatile member function type */
+		s++;
-	case MANGLE_float : t = type_float ; break ;
+		cv |= cv_volatile;
-	case MANGLE_double : t = type_double ; break ;
+		t = unmangle_func(&s, cv, ret);
-	case MANGLE_ldouble : t = type_ldouble ; break ;
+	} else if (c == MANGLE_c_lang) {
-	case MANGLE_void : t = type_void ; break ;
+		/* C linkage function type */
+		s++;
+		cv |= cv_c;
-	case MANGLE_bottom : t = type_bottom ; break ;
+		t = unmangle_func(&s, cv, ret);
+	} else {
-	case MANGLE_bool : t = type_bool ; break ;
+		/* Read list of parameter types */
+		TYPE t1;
+		MEMBER mem;
+		NAMESPACE ns;
-	case MANGLE_ptrdiff_t : t = type_ptrdiff_t ; break ;
+		unsigned npars = 0;
-	case MANGLE_size_t : t = type_size_t ; break ;
+		int ell = FUNC_NONE;
-	case MANGLE_wchar_t : t = type_wchar_t ; break ;
+		begin_param(NULL_id);
-	case MANGLE_signed : {
+		ns = crt_namespace;
+		for (;;) {
-	    /* Signed types */
+			/* Read parameter types */
-	    bt |= btype_signed ;
+			unsigned m;
-	    t = unmangle_type ( &s, cv_none, bt, ret ) ;
+			unsigned n = 1;
+			c = *s;
+			if (c == 0) {
-	    break ;
+				break;
+			} else if (c == MANGLE_ellipsis) {
+				/* Ellipsis */
-	}
+				s++;
+				ell = FUNC_ELLIPSIS;
+				break;
-	case MANGLE_unsigned : {
+			} else if (c == MANGLE_repeat) {
-	    /* Unsigned types */
+				/* Repeated parameter */
+				s++;
-	    bt |= btype_unsigned ;
+				m = unmangle_digit(&s);
+				mem = DEREF_member(nspace_last(ns));
-	    t = unmangle_type ( &s, cv_none, bt, ret ) ;
+				t1 = unmangle_param(m, npars, mem);
-	    break ;
+			} else if (c == MANGLE_multi) {
+				/* Multiply repeated parameter */
-	}
+				s++;
-	case MANGLE_const : {
+				n = unmangle_digit(&s);
-	    /* Const types */
+				m = unmangle_no(&s, 1);
-	    cv |= cv_const ;
+				mem = DEREF_member(nspace_last(ns));
-	    t = unmangle_type ( &s, cv, bt, ret ) ;
+				t1 = unmangle_param(m, npars, mem);
-	    cv = cv_none ;
+			} else {
+				/* Simple parameter type */
+				t1 = unmangle_type(&s, cv_none, btype_none, 1);
-	    break ;
+				if (IS_type_error(t1))break;
-	}
+			}
-	case MANGLE_volatile : {
+			while (n) {
-	    /* Volatile types */
+				/* Declare parameters */
+				DECL_SPEC ds = dspec_none;
-	    cv |= cv_volatile ;
+				HASHID nm = lookup_anon();
+				IDENTIFIER pid = DEREF_id(hashid_id(nm));
-	    t = unmangle_type ( &s, cv, bt, ret ) ;
+				pid = make_param_decl(ds, t1, pid,
-	    cv = cv_none ;
+						      CONTEXT_PARAMETER);
+				init_param(pid, NULL_exp);
-	    break ;
+				npars++;
+				n--;
-	}
+			}
+		}
+		t = make_func_type(dummy_ret_type, ell, cv, empty_type_set);
+		end_param();
-	case MANGLE_ptr : {
+		if (ret) {
-	    /* Pointer types */
+			/* Read return type */
+			c = *(s++);
+			if (c == MANGLE_sep) {
-	    TYPE t1 = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
+				t1 = unmangle_type(&s, cv_none, btype_none, 1);
+			} else {
+				t1 = type_error;
+				s--;
+			}
-	    MAKE_type_ptr ( cv, NULL_type, t ) ;
+			COPY_type(type_func_ret(t), NULL_type);
-	    t = inject_pre_type ( t, t1, 0 ) ;
+			t = inject_pre_type(t, t1, 0);
-	    cv = cv_none ;
-	    break ;
+		}
+	}
+	*ps = s;
+	return (t);
+}
-	case MANGLE_ref : {
-	    /* Reference types */
-	    TYPE t1 = unmangle_type ( &s, cv, btype_none, 1 ) ;
-	    MAKE_type_ref ( cv_none, NULL_type, t ) ;
-	    t = inject_pre_type ( t, t1, 0 ) ;
-	    cv = cv_none ;
-	    break ;
-	}
-	case MANGLE_ptr_mem : {
-	    /* Pointer to member types */
-	    TYPE t1 = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    TYPE t2 = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    if ( IS_type_compound ( t1 ) ) {
-		CLASS_TYPE c1 = DEREF_ctype ( type_compound_defn ( t1 ) ) ;
-		MAKE_type_ptr_mem ( cv, c1, NULL_type, t ) ;
-	    } else {
-		report ( crt_loc, ERR_dcl_mptr_class ( t1 ) ) ;
-		MAKE_type_ptr ( cv, NULL_type, t ) ;
-	    }
-	    t = inject_pre_type ( t, t2, 0 ) ;
-	    cv = cv_none ;
-	    break ;
-	}
-	case MANGLE_func : {
-	    /* Function types */
-	    t = unmangle_func ( &s, cv, ret ) ;
-	    cv = cv_none ;
-	    break ;
-	}
-	case MANGLE_array : {
-	    /* Array types */
-	    NAT n = unmangle_nat ( &s ) ;
-	    TYPE t1 = unmangle_type ( &s, cv, btype_none, 1 ) ;
-	    n = check_array_dim ( n ) ;
-	    MAKE_type_array ( cv_none, NULL_type, n, t ) ;
-	    t = inject_pre_type ( t, t1, 0 ) ;
-	    cv = cv_none ;
-	    break ;
-	}
-	case MANGLE_bitfield : {
-	    /* Bitfield types */
-	    TYPE t1 ;
-	    NAT n = unmangle_nat ( &s ) ;
-	    BASE_TYPE b1 = btype_named ;
-	    if ( *s == MANGLE_signed ) b1 |= btype_signed ;
-	    t1 = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    b1 = get_bitfield_rep ( t1, b1 ) ;
-	    t = check_bitfield_type ( cv, t1, b1, n, 0 ) ;
-	    cv = cv_none ;
-	    break ;
-	}
-	case MANGLE_template : {
-	    /* Template class types */
-	    IDENTIFIER id = unmangle_nspace ( &s, global_namespace, 0 ) ;
-	    if ( IS_NULL_id ( id ) ) {
-		t = type_error ;
-	    } else {
-		LIST ( TOKEN ) args = unmangle_token_args ( &s ) ;
-		MAKE_type_token ( cv, id, args, t ) ;
-		cv = cv_none ;
-	    }
-	    break ;
-	}
-	case MANGLE_templ_param : {
-	    /* Template parameter types */
-	    TOKEN tok = find_token_arg ( &s ) ;
-	    if ( !IS_NULL_tok ( tok ) && IS_tok_type ( tok ) ) {
-		t = DEREF_type ( tok_type_value ( tok ) ) ;
-	    } else {
-		t = type_error ;
-	    }
-	    break ;
-	}
-	case MANGLE_promote : {
-	    /* Promotion types */
-	    TYPE t1 = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    t = promote_type ( t1 ) ;
-	    break ;
-	}
-	case MANGLE_arith : {
-	    /* Arithmetic types */
-	    TYPE t1 = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    TYPE t2 = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    t = arith_type ( t1, t2, NULL_exp, NULL_exp ) ;
-	    break ;
-	}
-	case MANGLE_literal : {
-	    /* Literal types */
-	    NAT n ;
-	    int fit = 0 ;
-	    int form = BASE_DECIMAL ;
-	    int suff = SUFFIX_NONE ;
-	    c = *s ;
-	    if ( c == MANGLE_octal ) {
-		form = BASE_OCTAL ;
-		c = *( ++s ) ;
-	    } else if ( c == MANGLE_hex ) {
-		form = BASE_HEXADECIMAL ;
-		c = *( ++s ) ;
-	    }
-	    if ( c == MANGLE_unsigned ) {
-		suff |= SUFFIX_U ;
-		c = *( ++s ) ;
-	    }
-	    if ( c == MANGLE_long ) {
-		suff |= SUFFIX_L ;
-		c = *( ++s ) ;
-	    }
-	    if ( c == MANGLE_llong ) {
-		suff |= SUFFIX_LL ;
-		s++ ;
-	    }
-	    n = unmangle_nat ( &s ) ;
-	    if ( IS_NULL_nat ( n ) ) n = small_nat [0] ;
-	    t = find_literal_type ( n, form, suff, NULL_string, &fit ) ;
-	    break ;
-	}
-	case MANGLE_self : {
-	    /* Parent class type */
-	    IDENTIFIER self = crt_unmangle_class ;
-	    if ( IS_NULL_id ( self ) ) {
-		t = type_error ;
-	    } else {
-		t = DEREF_type ( id_class_name_etc_defn ( self ) ) ;
-	    }
-	    break ;
-	}
-	case char_zero : case char_one : case char_two :
-	case char_three : case char_four : case char_five :
-	case char_six : case char_seven : case char_eight :
-	case char_nine : case MANGLE_qual : {
-	    /* Named types */
-	    IDENTIFIER id ;
-	    s-- ;
-	    id = unmangle_nspace ( &s, global_namespace, 0 ) ;
-	    if ( IS_NULL_id ( id ) ) {
-		t = type_error ;
-	    } else {
-		t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
-	    }
-	    break ;
-	}
-	default : {
-	    /* Invalid mangled types */
-	    if ( bt == btype_none && cv == cv_none ) {
-		t = type_error ;
-	    } else {
-		t = make_base_type ( bt | btype_int ) ;
-	    }
-	    s-- ;
-	    break ;
-	}
-    }
-    if ( cv ) t = qualify_type ( t, cv, 0 ) ;
-    *ps = s ;
-    return ( t ) ;
-}
 /*
-    UNMANGLE AN IDENTIFIER NAME
+    UNMANGLE A TYPE
-    This routine unmangles the identifier s into the buffer bf.
+    This routine unmangles a type from the string pointed to by ps.
 */
-static string unmangle_name
+static TYPE
-    PROTO_N ( ( s, bf ) )
-    PROTO_T ( string s X BUFFER *bf )
+unmangle_type(string *ps, CV_SPEC cv, BASE_TYPE bt, int ret)
+{
+	TYPE t;
-    int func = 0 ;
+	string s = *ps;
+	character c = *(s++);
+	switch (c) {
+	case MANGLE_char:
-    int op = lex_identifier ;
+		t = make_base_type(bt | btype_char);
+		break;
+	case MANGLE_short:
+		t = make_base_type(bt | btype_short);
+		break;
+	case MANGLE_int:
-    IDENTIFIER id = NULL_id ;
+		t = make_base_type(bt | btype_int);
+		break;
+	case MANGLE_long:
+		t = make_base_type(bt | btype_long);
+		break;
+	case MANGLE_llong:
+		t = make_base_type(bt | btype_llong);
+		break;
+	case MANGLE_float:
+		t = type_float;
+		break;
+	case MANGLE_double:
+		t = type_double;
+		break;
+	case MANGLE_ldouble:
+		t = type_ldouble;
+		break;
+	case MANGLE_void:
+		t = type_void;
+		break;
+	case MANGLE_bottom:
+		t = type_bottom;
+		break;
+	case MANGLE_bool:
+		t = type_bool;
+		break;
+	case MANGLE_ptrdiff_t:
+		t = type_ptrdiff_t;
+		break;
+	case MANGLE_size_t:
+		t = type_size_t;
+		break;
+	case MANGLE_wchar_t:
+		t = type_wchar_t;
+		break;
-    HASHID nm = NULL_hashid ;
+	case MANGLE_signed: {
+		/* Signed types */
+		bt |= btype_signed;
+		t = unmangle_type(&s, cv_none, bt, ret);
+		break;
+	}
+	case MANGLE_unsigned: {
-    /* Check names beginning with '__' */
+		/* Unsigned types */
+		bt |= btype_unsigned;
-    if ( s [0] == '_' && s [1] == '_' ) {
+		t = unmangle_type(&s, cv_none, bt, ret);
+		break;
+	}
+	case MANGLE_const: {
-	string s0 = s + 2 ;
+		/* Const types */
+		cv |= cv_const;
-	op = unmangle_op ( &s0 ) ;
+		t = unmangle_type(&s, cv, bt, ret);
+		cv = cv_none;
+		break;
+	}
-	if ( op == lex_unknown ) {
+	case MANGLE_volatile: {
+		/* Volatile types */
-#if ( TDF_major < 4 )
+		cv |= cv_volatile;
+		t = unmangle_type(&s, cv, bt, ret);
+		cv = cv_none;
+		break;
+	}
+	case MANGLE_ptr: {
+		/* Pointer types */
-	    if ( ustrseq ( s, "__MAIN__" ) s = ustrlit ( "main" ) ;
+		TYPE t1 = unmangle_type(&s, cv_none, btype_none, 1);
+		MAKE_type_ptr(cv, NULL_type, t);
+		t = inject_pre_type(t, t1, 0);
+		cv = cv_none;
-#endif
+		break;
+	}
+	case MANGLE_ref: {
-	    bfputs ( bf, s ) ;
+		/* Reference types */
+		TYPE t1 = unmangle_type(&s, cv, btype_none, 1);
+		MAKE_type_ref(cv_none, NULL_type, t);
+		t = inject_pre_type(t, t1, 0);
+		cv = cv_none;
+		break;
+	}
+	case MANGLE_ptr_mem: {
+		/* Pointer to member types */
+		TYPE t1 = unmangle_type(&s, cv_none, btype_none, 1);
+		TYPE t2 = unmangle_type(&s, cv_none, btype_none, 1);
+		if (IS_type_compound(t1)) {
+			CLASS_TYPE c1 = DEREF_ctype(type_compound_defn(t1));
+			MAKE_type_ptr_mem(cv, c1, NULL_type, t);
+		} else {
+			report(crt_loc, ERR_dcl_mptr_class(t1));
+			MAKE_type_ptr(cv, NULL_type, t);
+		}
+		t = inject_pre_type(t, t2, 0);
+		cv = cv_none;
+		break;
+	}
+	case MANGLE_func: {
-	    return ( NULL ) ;
+		/* Function types */
+		t = unmangle_func(&s, cv, ret);
+		cv = cv_none;
+		break;
+	}
-	s = s0 ;
+	case MANGLE_array: {
-    }
+		/* Array types */
+		NAT n = unmangle_nat(&s);
+		TYPE t1 = unmangle_type(&s, cv, btype_none, 1);
+		n = check_array_dim(n);
+		MAKE_type_array(cv_none, NULL_type, n, t);
-    /* Read identifier name */
+		t = inject_pre_type(t, t1, 0);
-    switch ( op ) {
+		cv = cv_none;
+		break;
+	}
-	case lex_identifier : {
+	case MANGLE_bitfield: {
-	    /* Identifier name */
+		/* Bitfield types */
-	    character c ;
-	    int ext = 0 ;
+		TYPE t1;
-	    unsigned long h ;
+		NAT n = unmangle_nat(&s);
-	    BUFFER *tf = clear_buffer ( &token_buff, NIL ( FILE ) ) ;
-	    while ( c = *s, c != 0 ) {
+		BASE_TYPE b1 = btype_named;
-		if ( c == MANGLE_sep && s [1] == MANGLE_sep ) {
+		if (*s == MANGLE_signed) {
-		    c = s [2] ;
+			b1 |= btype_signed;
+		}
-		    if ( c == MANGLE_unicode4 ) {
+		t1 = unmangle_type(&s, cv_none, btype_none, 1);
-			bfputc ( tf, char_backslash ) ;
+		b1 = get_bitfield_rep(t1, b1);
+		t = check_bitfield_type(cv, t1, b1, n, 0);
-			c = char_u ;
+		cv = cv_none;
-			ext = 1 ;
+		break;
-			s += 2 ;
+	}
-		    } else if ( c == MANGLE_unicode8 ) {
+	case MANGLE_template: {
-			bfputc ( tf, char_backslash ) ;
+		/* Template class types */
-			c = char_U ;
+		IDENTIFIER id = unmangle_nspace(&s, global_namespace, 0);
-			ext = 1 ;
+		if (IS_NULL_id(id)) {
-			s += 2 ;
+			t = type_error;
-		    } else {
+		} else {
+			LIST(TOKEN)args = unmangle_token_args(&s);
-			break ;
+			MAKE_type_token(cv, id, args, t);
-		    }
+			cv = cv_none;
+		}
+		break;
+	}
+	case MANGLE_templ_param: {
+		/* Template parameter types */
+		TOKEN tok = find_token_arg(&s);
+		if (!IS_NULL_tok(tok) && IS_tok_type(tok)) {
+			t = DEREF_type(tok_type_value(tok));
+		} else {
+			t = type_error;
+		}
+		break;
+	}
+	case MANGLE_promote: {
+		/* Promotion types */
+		TYPE t1 = unmangle_type(&s, cv_none, btype_none, 1);
+		t = promote_type(t1);
+		break;
+	}
+	case MANGLE_arith: {
+		/* Arithmetic types */
+		TYPE t1 = unmangle_type(&s, cv_none, btype_none, 1);
+		TYPE t2 = unmangle_type(&s, cv_none, btype_none, 1);
+		t = arith_type(t1, t2, NULL_exp, NULL_exp);
+		break;
+	}
+	case MANGLE_literal: {
+		/* Literal types */
+		NAT n;
+		int fit = 0;
+		int form = BASE_DECIMAL;
+		int suff = SUFFIX_NONE;
+		c = *s;
+		if (c == MANGLE_octal) {
+			form = BASE_OCTAL;
+			c = *(++s);
+		} else if (c == MANGLE_hex) {
+			form = BASE_HEXADECIMAL;
+			c = *(++s);
+		}
-		bfputc ( tf, ( int ) c ) ;
+		if (c == MANGLE_unsigned) {
+			suff |= SUFFIX_U;
+			c = *(++s);
+		}
+		if (c == MANGLE_long) {
+			suff |= SUFFIX_L;
+			c = *(++s);
+		}
+		if (c == MANGLE_llong) {
+			suff |= SUFFIX_LL;
-		s++ ;
+			s++;
-	    }
+		}
+		n = unmangle_nat(&s);
-	    bfputc ( tf, 0 ) ;
+		if (IS_NULL_nat(n)) {
-	    h = hash ( tf->start ) ;
+			n = small_nat[0];
+		}
-	    nm = lookup_name ( tf->start, h, ext, lex_unknown ) ;
+		t = find_literal_type(n, form, suff, NULL_string, &fit);
+		break;
+	}
+	case MANGLE_self: {
+		/* Parent class type */
+		IDENTIFIER self = crt_unmangle_class;
+		if (IS_NULL_id(self)) {
+			t = type_error;
+		} else {
+			t = DEREF_type(id_class_name_etc_defn(self));
+		}
+		break;
+	}
+	case char_zero:
+	case char_one:
+	case char_two:
+	case char_three:
+	case char_four:
+	case char_five:
+	case char_six:
+	case char_seven:
+	case char_eight:
+	case char_nine:
+	case MANGLE_qual: {
+		/* Named types */
+		IDENTIFIER id;
+		s--;
+		id = unmangle_nspace(&s, global_namespace, 0);
+		if (IS_NULL_id(id)) {
+			t = type_error;
+		} else {
-	    id = DEREF_id ( hashid_id ( nm ) ) ;
+			t = DEREF_type(id_class_name_etc_defn(id));
+		}
-	    break ;
+		break;
+	}
-	case lex_type_Hname :
+	default: {
-	case lex_destructor_Hname : {
+		/* Invalid mangled types */
-	    /* Constructor and destructor names */
+		if (bt == btype_none && cv == cv_none) {
-	    func = 1 ;
+			t = type_error;
-	    break ;
+		} else {
-	}
-	case lex_operator : {
-	    /* Conversion function name */
-	    TYPE t = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
+			t = make_base_type(bt | btype_int);
-	    nm = lookup_conv ( t ) ;
-	    id = DEREF_id ( hashid_id ( nm ) ) ;
-	    func = 1 ;
-	    break ;
-	}
+		}
+		s--;
-	case lex_auto : {
+		break;
-	    /* Anonymous identifier */
-	    bfprintf ( bf, "<anon>" ) ;
-	    return ( NULL ) ;
 	}
-	case lex_static : {
-	    /* Local static variable */
-	    bfprintf ( bf, "<static>" ) ;
-	    return ( NULL ) ;
+	}
+	if (cv) {
+		t = qualify_type(t, cv, 0);
+	}
+	*ps = s;
+	return (t);
+}
-	case lex_typeof : {
-	    /* Run-time type information */
-	    TYPE t = unmangle_type ( &s, cv_none, btype_none, 1 ) ;
-	    bfprintf ( bf, "typeid ( " ) ;
-	    IGNORE print_type ( t, bf, 0 ) ;
-	    bfprintf ( bf, " )" ) ;
-	    return ( s ) ;
-	}
-	case lex_virtual : {
-	    /* Virtual function table */
-	    int sep = 0 ;
-	    bfprintf ( bf, "vtable ( " ) ;
-	    for ( ; ; ) {
-		id = unmangle_nspace ( &s, global_namespace, 0 ) ;
-		if ( IS_NULL_id ( id ) ) break ;
-		if ( sep ) bfprintf ( bf, "::" ) ;
-		IGNORE print_id_long ( id, qual_none, bf, 0 ) ;
-		sep = 1 ;
-	    }
-	    if ( !sep ) bfprintf ( bf, "<error>" ) ;
-	    bfprintf ( bf, " )" ) ;
-	    return ( s ) ;
-	}
-	default : {
-	    /* Operator name */
-	    nm = lookup_op ( op ) ;
-	    if ( !IS_NULL_hashid ( nm ) ) {
-		id = DEREF_id ( hashid_id ( nm ) ) ;
-		func = 1 ;
-	    }
-	    break ;
-	}
-    }
-    /* Unmangle identifier namespace and type */
-    if ( s [0] == MANGLE_sep && s [1] == MANGLE_sep ) {
-	TYPE t ;
-	string s0 = s + 2 ;
-	NAMESPACE pns = global_namespace ;
-	IDENTIFIER pid = unmangle_nspace ( &s0, pns, 0 ) ;
-	character c = *s0 ;
-	if ( c == MANGLE_func_templ ) {
-	    /* Allow for template functions */
-	    s0++ ;
-	    crt_unmangle_args = unmangle_token_args ( &s0 ) ;
-	    if ( *s0 == MANGLE_sep ) s0++ ;
-	}
+/*
+    UNMANGLE AN IDENTIFIER NAME
+    This routine unmangles the identifier s into the buffer bf.
+*/
+static string
+unmangle_name(string s, BUFFER *bf)
+{
+	int func = 0;
+	int op = lex_identifier;
+	IDENTIFIER id = NULL_id;
+	HASHID nm = NULL_hashid;
+	/* Check names beginning with '__' */
+	if (s[0] == '_' && s[1] == '_') {
+		string s0 = s + 2;
+		op = unmangle_op(&s0);
+		if (op == lex_unknown) {
+#if (TDF_major < 4)
+			if (ustrseq(s, "__MAIN__")) {
+				s = ustrlit("main");
+			}
+#endif
+			bfputs(bf, s);
+			return (NULL);
+		}
+		s = s0;
+	}
+	/* Read identifier name */
+	switch (op) {
+	case lex_identifier: {
+		/* Identifier name */
+		character c;
+		int ext = 0;
+		unsigned long h;
+		BUFFER *tf = clear_buffer(&token_buff, NIL(FILE));
+		while (c = *s, c != 0) {
+			if (c == MANGLE_sep && s[1] == MANGLE_sep) {
+				c = s[2];
+				if (c == MANGLE_unicode4) {
+					bfputc(tf, char_backslash);
+					c = char_u;
+					ext = 1;
+					s += 2;
+				} else if (c == MANGLE_unicode8) {
+					bfputc(tf, char_backslash);
+					c = char_U;
+					ext = 1;
+					s += 2;
+				} else {
+					break;
+				}
+			}
+			bfputc(tf,(int)c);
+			s++;
+		}
+		bfputc(tf, 0);
+		h = hash(tf->start);
+		nm = lookup_name(tf->start, h, ext, lex_unknown);
+		id = DEREF_id(hashid_id(nm));
+		break;
+	}
+	case lex_type_Hname:
+	case lex_destructor_Hname: {
+		/* Constructor and destructor names */
+		func = 1;
+		break;
+	}
+	case lex_operator: {
+		/* Conversion function name */
+		TYPE t = unmangle_type(&s, cv_none, btype_none, 1);
+		nm = lookup_conv(t);
+		id = DEREF_id(hashid_id(nm));
+		func = 1;
+		break;
+	}
+	case lex_auto: {
+		/* Anonymous identifier */
+		bfprintf(bf, "<anon>");
+		return (NULL);
+	}
+	case lex_static: {
+		/* Local static variable */
+		bfprintf(bf, "<static>");
+		return (NULL);
+	}
+	case lex_typeof: {
+		/* Run-time type information */
+		TYPE t = unmangle_type(&s, cv_none, btype_none, 1);
+		bfprintf(bf, "typeid ( ");
+		IGNORE print_type(t, bf, 0);
+		bfprintf(bf, " )");
+		return (s);
+	}
+	case lex_virtual: {
+		/* Virtual function table */
+		int sep = 0;
+		bfprintf(bf, "vtable ( ");
+		for (;;) {
+			id = unmangle_nspace(&s, global_namespace, 0);
+			if (IS_NULL_id(id)) {
+				break;
+			}
+			if (sep) {
+				bfprintf(bf, "::");
+			}
+			IGNORE print_id_long(id, qual_none, bf, 0);
+			sep = 1;
+		}
+		if (!sep) {
+			bfprintf(bf, "<error>");
+		}
+		bfprintf(bf, " )");
+		return (s);
+	}
+	default: {
+		/* Operator name */
+		nm = lookup_op(op);
+		if (!IS_NULL_hashid(nm)) {
+			id = DEREF_id(hashid_id(nm));
+			func = 1;
+		}
+		break;
+	}
+	}
+	/* Unmangle identifier namespace and type */
+	if (s[0] == MANGLE_sep && s[1] == MANGLE_sep) {
+		TYPE t;
+		string s0 = s + 2;
+		NAMESPACE pns = global_namespace;
+		IDENTIFIER pid = unmangle_nspace(&s0, pns, 0);
+		character c = *s0;
+		if (c == MANGLE_func_templ) {
+			/* Allow for template functions */
+			s0++;
+			crt_unmangle_args = unmangle_token_args(&s0);
+			if (*s0 == MANGLE_sep) {
+				s0++;
+			}
+		}
-	/* Unmangle identifier type */
+		/* Unmangle identifier type */
-	if ( func ) {
+		if (func) {
-	    crt_unmangle_class = pid ;
+			crt_unmangle_class = pid;
-	    t = unmangle_func ( &s0, cv_none, 0 ) ;
+			t = unmangle_func(&s0, cv_none, 0);
+		} else {
+			if (c == 0 && !IS_NULL_id(pid)) {
+				t = DEREF_type(id_class_name_etc_defn(pid));
+				pid = NULL_id;
+			} else {
+				crt_unmangle_class = pid;
+				t = unmangle_type(&s0, cv_none, btype_none, 0);
+			}
+		}
+		if (IS_NULL_id(pid)) {
+			member_func_type(NULL_ctype, id_function_tag, t);
+		}
+		/* Look up constructor and destructor names */
+		if (!IS_NULL_id(pid)) {
+			TYPE p = DEREF_type(id_class_name_etc_defn(pid));
+			if (IS_type_compound(p)) {
+				CLASS_TYPE ct =
+				    DEREF_ctype(type_compound_defn(p));
+				pns = DEREF_nspace(ctype_member(ct));
+				if (op == lex_type_Hname) {
+					id = DEREF_id(ctype_constr(ct));
+					nm = DEREF_hashid(id_name(id));
+				} else if (op == lex_destructor_Hname) {
+					id = DEREF_id(ctype_destr(ct));
+					nm = DEREF_hashid(id_name(id));
+				}
+			}
+		}
+		if (IS_NULL_hashid(nm)) {
+			nm = KEYWORD(lex_zzzz);
+		}
+		/* Create result identifier */
+		MAKE_id_function(nm, dspec_extern, pns, crt_loc, t, NULL_id,
+				 id);
+		if (c == MANGLE_func_templ) {
+			/* Set up template function arguments */
+			TYPE form;
+			DECL_SPEC ds = (dspec_extern | dspec_instance);
+			MAKE_type_token(cv_none, id, crt_unmangle_args, form);
+			MAKE_id_function(nm, ds, pns, crt_loc, t, NULL_id, id);
+			COPY_type(id_function_form(id), form);
+		}
+		crt_unmangle_args = NULL_list(TOKEN);
+		crt_unmangle_class = NULL_id;
+		s = s0;
+	}
+	/* Print identifier to buffer */
+	if (IS_NULL_id(id)) {
+		bfprintf(bf, "<error>");
+		s = NULL;
 	} else {
-	    if ( c == 0 && !IS_NULL_id ( pid ) ) {
+		print_id_desc++;
-		t = DEREF_type ( id_class_name_etc_defn ( pid ) ) ;
+		IGNORE print_id_long(id, qual_none, bf, 0);
-		pid = NULL_id ;
+		print_id_desc--;
-	    } else {
-		crt_unmangle_class = pid ;
-		t = unmangle_type ( &s0, cv_none, btype_none, 0 ) ;
-	    }
+	}
-	if ( IS_NULL_id ( pid ) ) {
-	    member_func_type ( NULL_ctype, id_function_tag, t ) ;
-	}
-	/* Look up constructor and destructor names */
-	if ( !IS_NULL_id ( pid ) ) {
-	    TYPE p = DEREF_type ( id_class_name_etc_defn ( pid ) ) ;
-	    if ( IS_type_compound ( p ) ) {
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( p ) ) ;
-		pns = DEREF_nspace ( ctype_member ( ct ) ) ;
-		if ( op == lex_type_Hname ) {
-		    id = DEREF_id ( ctype_constr ( ct ) ) ;
-		    nm = DEREF_hashid ( id_name ( id ) ) ;
-		} else if ( op == lex_destructor_Hname ) {
-		    id = DEREF_id ( ctype_destr ( ct ) ) ;
-		    nm = DEREF_hashid ( id_name ( id ) ) ;
-		}
-	    }
-	}
-	if ( IS_NULL_hashid ( nm ) ) nm = KEYWORD ( lex_zzzz ) ;
-	/* Create result identifier */
-	MAKE_id_function ( nm, dspec_extern, pns, crt_loc, t, NULL_id, id ) ;
-	if ( c == MANGLE_func_templ ) {
-	    /* Set up template function arguments */
-	    TYPE form ;
-	    DECL_SPEC ds = ( dspec_extern | dspec_instance ) ;
-	    MAKE_type_token ( cv_none, id, crt_unmangle_args, form ) ;
-	    MAKE_id_function ( nm, ds, pns, crt_loc, t, NULL_id, id ) ;
-	    COPY_type ( id_function_form ( id ), form ) ;
-	}
-	crt_unmangle_args = NULL_list ( TOKEN ) ;
-	crt_unmangle_class = NULL_id ;
-	s = s0 ;
-    }
-    /* Print identifier to buffer */
-    if ( IS_NULL_id ( id ) ) {
-	bfprintf ( bf, "<error>" ) ;
-	s = NULL ;
-    } else {
-	print_id_desc++ ;
-	IGNORE print_id_long ( id, qual_none, bf, 0 ) ;
-	print_id_desc-- ;
-    }
-    return ( s ) ;
+	return (s);
 }
 /*
     INITIALISE UNMANGLING ROUTINES
     This routine initialises the unmangling routines.
 */
-static void init_unmangle
+static void
-    PROTO_Z ()
+init_unmangle(void)
 {
-    static int done = 0 ;
+	static int done = 0;
-    if ( !done ) {
+	if (!done) {
-	MAKE_type_pre ( cv_none, btype_none, qual_none, dummy_ret_type ) ;
+		MAKE_type_pre(cv_none, btype_none, qual_none, dummy_ret_type);
-	done = 1 ;
+		done = 1;
-    }
+	}
-    return ;
+	return;
 }
 /*
     END OF LANGUAGE DEPENDENT ROUTINES
     The remaining routine is the only one included in the C producer.
 */
 #endif
 /*
     UNMANGLE A LIST OF IDENTIFIER NAMES
     This routine unmangles the list of identifier names p to the file f.
 */
-void unmangle_list
+void
-    PROTO_N ( ( p, f, pre ) )
-    PROTO_T ( LIST ( string ) p X FILE *f X int pre )
+unmangle_list(LIST(string)p, FILE *f, int pre)
+{
 #if LANGUAGE_CPP
-    init_unmangle () ;
+	init_unmangle();
 #endif
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	string s = DEREF_string ( HEAD_list ( p ) ) ;
+		string s = DEREF_string(HEAD_list(p));
-	if ( s ) {
+		if (s) {
-	    BUFFER *bf = clear_buffer ( &mangle_buff, f ) ;
+			BUFFER *bf = clear_buffer(&mangle_buff, f);
-	    if ( pre ) {
+			if (pre) {
-		/* Print mapping information */
+				/* Print mapping information */
-		bfprintf ( bf, "%s -> ", s ) ;
+				bfprintf(bf, "%s -> ", s);
-	    }
+			}
 #if LANGUAGE_CPP
-	    s = unmangle_name ( s, bf ) ;
+			s = unmangle_name(s, bf);
+			if (s && *s) {
-	    if ( s && *s ) bfprintf ( bf, " ?" ) ;
+				bfprintf(bf, " ?");
+			}
 #else
-	    bfputs ( bf, s ) ;
+			bfputs(bf, s);
 #endif
-	    bfputc ( bf, '\n' ) ;
+			bfputc(bf, '\n');
-	    output_buffer ( bf, 1 ) ;
+			output_buffer(bf, 1);
+		}
+		p = TAIL_list(p);
+	}
-	p = TAIL_list ( p ) ;
-    }
-    fflush_v ( f ) ;
+	fflush_v(f);
-    return ;
+	return;
+}

Subversion Repositories tendra.SVN

(root)/trunk/src/producers/common/output/unmangle.c – Rev 2 → 7