WebSVN – tendra.SVN – Diff – /branches/tendra5/src/producers/common/parse/predict.c

+/*
+ * Copyright (c) 2002-2005 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.
 */
 #define TOK_ASM				TOK_DECLARATION
 #else
 #define TOK_ASM				TOK_STATEMENT
 #endif
-#define lookup_token( T )		( ( int ) tokens [ ( T ) ] )
+#define lookup_token(T)			((int)tokens[(T)])
-static unsigned char tokens [] = {
+static unsigned char tokens[] = {
-#define LEX_TOKEN( A, B, C )		( C ),
+#define LEX_TOKEN(A, B, C)		(C),
 #include "symbols.h"
 #undef LEX_TOKEN
-    TOK_NONE
+	TOK_NONE
-} ;
+};
 /*
     PARSER STATE FLAGS
     than a cv-qualifier) has been read.  Similarly have_type_declaration
     is set to indicate an elaborated-type-specifier.  in_function_defn
     is used to count nested function definitions.
 */
-int have_type_specifier = 0 ;
+int have_type_specifier = 0;
-int have_type_declaration = TYPE_DECL_NONE ;
+int have_type_declaration = TYPE_DECL_NONE;
-int have_func_declarator = 0 ;
+int have_func_declarator = 0;
-int in_function_defn = 0 ;
+int in_function_defn = 0;
-int in_class_defn = 0 ;
+int in_class_defn = 0;
-int in_declaration = 0 ;
+int in_declaration = 0;
-int in_default_arg = 0 ;
+int in_default_arg = 0;
-int in_weak_param = 0 ;
+int in_weak_param = 0;
-int in_ptr_mem_selector = 0 ;
+int in_ptr_mem_selector = 0;
-int in_token_decl = 0 ;
+int in_token_decl = 0;
-int in_template_decl = 0 ;
+int in_template_decl = 0;
-int really_in_function_defn = 0 ;
+int really_in_function_defn = 0;
-int really_in_class_defn = 0 ;
+int really_in_class_defn = 0;
-int is_function_next = 0 ;
+int is_function_next = 0;
-int is_constructor_next = 0 ;
+int is_constructor_next = 0;
 /*
     PARSER STATE COUNTERS
     These variables are used to keep count of various items of interest
     in the parser, such as the number of expressions which have side
     effects and the number of type definitions.
 */
-int no_side_effects = 0 ;
+int no_side_effects = 0;
-int no_type_defns = 0 ;
+int no_type_defns = 0;
-int have_destructor = 0 ;
+int have_destructor = 0;
-unsigned long no_declarations = 0 ;
+unsigned long no_declarations = 0;
-unsigned long no_token_defns = 0 ;
+unsigned long no_token_defns = 0;
 /*
     FEATURE USE FLAGS
     These flags are set to indicate that certain features, which require
     the program to perform extra checks, have been used.
 */
-int used_extern_volatile = 0 ;
+int used_extern_volatile = 0;
-int used_register = 0 ;
+int used_register = 0;
 /*
     FORWARD DECLARATIONS
     The following look-ahead functions need to be declared in advance.
 */
 #if LANGUAGE_CPP
-static int predict_declarator PROTO_S ( ( int, int, int ) ) ;
+static int predict_declarator(int, int, int);
 #endif
 /*
     SKIP OVER A BRACKETED SEQUENCE
     This routine is called after reading an open bracket to skip to the
     corresponding close bracket.  It returns the number of tokens skipped.
 */
 #if LANGUAGE_CPP
-static int skip_brackets
+static int
-    PROTO_Z ()
+skip_brackets(void)
 {
-    int n = 0 ;
+	int n = 0;
-    int brackets = 1 ;
+	int brackets = 1;
-    for ( ; ; ) {
+	for (;;) {
-	int t = next_token () ;
+		int t = next_token();
-	n++ ;
+		n++;
-	switch ( t ) {
+		switch (t) {
-	    case lex_open_Hround :
+		case lex_open_Hround:
-	    case lex_open_Hsquare_H1 :
+		case lex_open_Hsquare_H1:
-	    case lex_open_Hbrace_H1 : {
+		case lex_open_Hbrace_H1:
-		/* Open bracket */
+			/* Open bracket */
-		brackets++ ;
+			brackets++;
-		break ;
+			break;
-	    }
-	    case lex_close_Hround :
+		case lex_close_Hround:
-	    case lex_close_Hsquare_H1 :
+		case lex_close_Hsquare_H1:
-	    case lex_close_Hbrace_H1 : {
+		case lex_close_Hbrace_H1:
-		/* Close bracket */
+			/* Close bracket */
-		if ( --brackets == 0 ) return ( n ) ;
+			if (--brackets == 0) {
-		break ;
+				return(n);
-	    }
+			}
+			break;
-	    case lex_eof : {
+		case lex_eof:
-		/* Premature end of file */
+			/* Premature end of file */
-		return ( n ) ;
+			return(n);
-	    }
+		}
 	}
-    }
-    /* NOTREACHED */
+	/* NOTREACHED */
 }
 #endif
 /*
     SKIP OVER AN OPERATOR NAME
     This routine is called after 'operator' has been read to return the
     token immediately following.  It has to deal with both overloaded
     operator function names and conversion function names.  Note that
     class and enumeration definitions are allowed in a conversion function
     name by the syntax, but are weeded out later.  Skipping over them
     here would therefore seem to be a lot of effort for something which
     is going to prove illegal however it is interpreted.
+		}
-	    }
-	    break ;
+		break;
+	}
-    }
-    return ( t ) ;
+	return(t);
+}
 #endif
     lists of expressions (such as function arguments or function style
     initialisers.  It is called after an initial open bracket has been
     read.  It returns 1 if the following list definitely consists of
     function parameters, 0 if it definitely consists of expressions,
     and 2 if it could be either.
 */
 #if LANGUAGE_CPP
-static int predict_func_params
+static int
-    PROTO_N ( ( t, empty, depth ) )
-    PROTO_T ( int t X int empty X int depth )
+predict_func_params(int t, int empty, int depth)
+{
-    int c = lookup_token ( t ) ;
+	int c = lookup_token(t);
-    switch ( c ) {
+	switch (c) {
-	case TOK_DECLARATION :
+	case TOK_DECLARATION:
-	case TOK_DECL_SPEC :
+	case TOK_DECL_SPEC:
-	case TOK_EXTERN :
+	case TOK_EXTERN:
-	case TOK_TYPE_KEY :
+	case TOK_TYPE_KEY:
-	case TOK_TYPE_SPEC : {
+	case TOK_TYPE_SPEC:
-	    /* These are all obviously parameter declarations */
+		/* These are all obviously parameter declarations */
-	    return ( 1 ) ;
+		return(1);
+	case TOK_SIMPLE_TYPE:
+	case TOK_TYPE:
+		/* These are simple-type-specifiers */
+		t = next_token();
+		if (t == lex_open_Hround) {
+			t = next_token();
+			return(predict_func_params(t, 1, 1));
-	}
+		}
+		return(1);
-	case TOK_SIMPLE_TYPE :
+	case TOK_NESTED_NAME:
-	case TOK_TYPE : {
+	case TOK_FULL_NAME:
-	    /* These are simple-type-specifiers */
+		/* Look for nested type-names */
+		t = next_token();
+		c = lookup_token(t);
+		if (c == TOK_TYPE) {
-	    t = next_token () ;
+			t = next_token();
-	    if ( t == lex_open_Hround ) {
+			if (t == lex_open_Hround) {
-		t = next_token () ;
+				t = next_token();
-		return ( predict_func_params ( t, 1, 1 ) ) ;
+				return(predict_func_params(t, 1, 1));
-	    }
+			}
-	    return ( 1 ) ;
+			return(1);
+		}
+		return(0);
+	}
+	if (t == lex_ellipsis) {
+		return(1);
+	}
+	if (t == lex_ellipsis_Hexp) {
+		return(1);
+	}
+	if (t == lex_close_Hround) {
+		/* Empty pair of brackets */
+		return(empty);
+	}
-	case TOK_NESTED_NAME :
-	case TOK_FULL_NAME : {
-	    /* Look for nested type-names */
-	    t = next_token () ;
+	if (depth) {
-	    c = lookup_token ( t ) ;
+		int d = predict_declarator(t, 2, 1);
-	    if ( c == TOK_TYPE ) {
+		if (d == 0) {
-		t = next_token () ;
+			return(0);
-		if ( t == lex_open_Hround ) {
-		    t = next_token () ;
-		    return ( predict_func_params ( t, 1, 1 ) ) ;
+		}
+		if (d == 2) {
+			/* Comma - check next parameter */
+			t = next_token();
+			return(predict_func_params(t, 1, 0));
+		}
+		if (d == 3) {
-		return ( 1 ) ;
+			return(2);
-	    }
+		}
-	    return ( 0 ) ;
+		return(1);
+	}
-    }
-    if ( t == lex_ellipsis ) return ( 1 ) ;
-    if ( t == lex_ellipsis_Hexp ) return ( 1 ) ;
-    if ( t == lex_close_Hround ) {
-	/* Empty pair of brackets */
-	return ( empty ) ;
-    }
-    if ( depth ) {
-	int d = predict_declarator ( t, 2, 1 ) ;
-	if ( d == 0 ) return ( 0 ) ;
-	if ( d == 2 ) {
-	    /* Comma - check next parameter */
-	    t = next_token () ;
-	    return ( predict_func_params ( t, 1, 0 ) ) ;
-	}
-	if ( d == 3 ) return ( 2 ) ;
-	return ( 1 ) ;
+	return(0);
-    }
-    return ( 0 ) ;
+}
 #endif
 /*
     LOOK-AHEAD FOR DECLARATORS
     abstract declarators and 2 to indicate parameter declarators.  The
     return value is 0 if this is definitely not a declarator, and 1 if it
     definitely is.  The return values 2 and 3 are used to indicate possible
     declarators in the parameter case, with 2 indicating a following comma
     and 3 a close bracket.
+				}
-			    }
-			    break ;
+				t = next_token();
+			}
-			case lex_ellipsis :
-			case lex_ellipsis_Hexp : {
-			    /* Ellipsis */
-			    if ( loc == 2 && brackets <= 0 ) res = 1 ;
-			    break ;
+			break;
-			}
-			case lex_eof : {
-			    /* Premature end of file */
-			    res = 1 ;
-			    break ;
-			}
-		    }
-		    if ( res != -1 ) break ;
-		    t = next_token () ;
+		}
-		break ;
-	    }
-	    case lex_semicolon :
-	    case lex_close_Htemplate : {
-		/* End of declaration (don't worry about depth) */
-		res = 3 ;
-		break ;
-	    }
+		case lex_semicolon:
+		case lex_close_Htemplate:
+			/* End of declaration (don't worry about depth) */
+			res = 3;
+			break;
-	    case lex_comma : {
+		case lex_comma:
-		/* Comma */
+			/* Comma */
-		if ( depth <= 0 ) {
+			if (depth <= 0) {
-		    /* Check rest of declaration */
+				/* Check rest of declaration */
-		    if ( loc == 1 ) {
+				if (loc == 1) {
-			res = 1 ;
+					res = 1;
-		    } else if ( loc == 2 ) {
+				} else if (loc == 2) {
-			res = 2 ;
+					res = 2;
-		    } else {
+				} else {
-			t = next_token () ;
+					t = next_token();
-			res = predict_declarator ( t, 0, 0 ) ;
+					res = predict_declarator(t, 0, 0);
-		    }
+				}
+			} else {
+				res = 0;
+			}
+			break;
+		case lex_ellipsis:
+		case lex_ellipsis_Hexp:
+			/* Ellipsis */
+			if (depth <= 0 && loc == 2) {
+				res = 1;
-		} else {
+			} else {
-		    res = 0 ;
+				res = 0;
-		}
+			}
-		break ;
+			break;
+		case lex_close_Hround: {
+			/* Declarator close bracket */
+			depth--;
+			if (depth < 0) {
+				if (loc == 1) {
+					res = 1;
+				} else if (loc == 2) {
+					res = 3;
-	    }
+				}
+			}
+			break;
+		}
-	    case lex_ellipsis :
-	    case lex_ellipsis_Hexp : {
-		/* Ellipsis */
+		default:
-		if ( depth <= 0 && loc == 2 ) {
+			/* Nothing else can appear in a declaration */
-		    res = 1 ;
+			res = 0;
-		} else {
+			break;
-		    res = 0 ;
+		}
-		break ;
-	    }
-	    case lex_close_Hround : {
-		/* Declarator close bracket */
-		depth-- ;
-		if ( depth < 0 ) {
+		if (res != -1) {
-		    if ( loc == 1 ) {
-			res = 1 ;
-		    } else if ( loc == 2 ) {
-			res = 3 ;
-		    }
-		}
-		break ;
-	    }
-	    default : {
-		/* Nothing else can appear in a declaration */
-		res = 0 ;
-		break ;
+			break;
-	    }
-	}
+		}
-	if ( res != -1 ) break ;
-	t = next_token () ;
+		t = next_token();
-    }
+	}
-    if ( !IS_NULL_nspace ( ns ) ) {
+	if (!IS_NULL_nspace(ns)) {
-	IGNORE remove_nested_nspace ( ns ) ;
+		IGNORE remove_nested_nspace(ns);
-    }
+	}
-    return ( res ) ;
+	return(res);
+}
 #endif
     classified as an expression-statement.  Actually the real answer to
     questions like is 'int ( a ) ;' a declaration or an expression is,
     are flying pigs kosher?
 */
-int predict_decl
+int
-    PROTO_Z ()
+predict_decl(void)
+{
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    int c = lookup_token ( t ) ;
+	int c = lookup_token(t);
-    switch ( c ) {
+	switch (c) {
-	case TOK_DECLARATION :
+	case TOK_DECLARATION:
-	case TOK_DECL_SPEC :
+	case TOK_DECL_SPEC:
-	case TOK_EXTERN :
+	case TOK_EXTERN:
-	case TOK_TYPE_KEY :
+	case TOK_TYPE_KEY:
-	case TOK_TYPE_SPEC : {
+	case TOK_TYPE_SPEC:
-	    /* These are all obviously declarations */
+		/* These are all obviously declarations */
-	    return ( 1 ) ;
+		return(1);
-	}
-	case TOK_SIMPLE_TYPE :
+	case TOK_SIMPLE_TYPE:
-	case TOK_TYPE : {
+	case TOK_TYPE: {
-	    /* These are simple-type-specifiers */
+		/* These are simple-type-specifiers */
-	    int d = 1 ;
+		int d = 1;
-	    PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	    t = next_token () ;
+		t = next_token();
 #if LANGUAGE_CPP
-	    if ( t == lex_open_Hround ) {
+		if (t == lex_open_Hround) {
-		/* This is the tricky case, 'T ( ...' */
+			/* This is the tricky case, 'T ( ...' */
-		t = next_token () ;
+			t = next_token();
-		d = predict_declarator ( t, 0, 1 ) ;
+			d = predict_declarator(t, 0, 1);
-	    } else /* continued ... */
+		} else /* continued ... */
 #endif
-	    if ( t == lex_colon ) {
+			if (t == lex_colon) {
-		/* Check for labels */
+				/* Check for labels */
-		if ( c == TOK_TYPE ) d = 0 ;
+				if (c == TOK_TYPE) {
+					d = 0;
-	    }
+				}
+			}
-	    crt_lookup = np ;
+		crt_lookup = np;
-	    crt_token = p ;
+		crt_token = p;
-	    return ( d ) ;
+		return(d);
 	}
 #if LANGUAGE_CPP
-	case TOK_NESTED_NAME :
+	case TOK_NESTED_NAME:
-	case TOK_FULL_NAME : {
+	case TOK_FULL_NAME: {
-	    /* Look for nested type-names */
+		/* Look for nested type-names */
-	    int d = 0 ;
+		int d = 0;
-	    PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	    t = next_token () ;
+		t = next_token();
-	    c = lookup_token ( t ) ;
+		c = lookup_token(t);
-	    if ( c == TOK_TYPE ) {
+		if (c == TOK_TYPE) {
-		d = 1 ;
+			d = 1;
-		t = next_token () ;
+			t = next_token();
-		if ( t == lex_open_Hround ) {
+			if (t == lex_open_Hround) {
-		    /* This is the tricky case, 'N::T ( ...' */
+				/* This is the tricky case, 'N::T ( ...' */
-		    t = next_token () ;
+				t = next_token();
-		    d = predict_declarator ( t, 0, 1 ) ;
+				d = predict_declarator(t, 0, 1);
+			}
+		}
-	    }
-	    crt_lookup = np ;
+		crt_lookup = np;
-	    crt_token = p ;
+		crt_token = p;
-	    return ( d ) ;
+		return(d);
 	}
 #endif
-    }
+	}
-    /* Nothing else is a declaration */
+	/* Nothing else is a declaration */
-    return ( 0 ) ;
+	return(0);
+}
 /*
     LOOK-AHEAD FOR UNDECLARED TYPES
     This look-ahead is used to handle syntax errors following undeclared
     types.  The context is in a sequence of declaration specifiers in
     which no type specifier has been encountered.  t gives the token read.
 */
-static int predict_undecl_type
+static int
-    PROTO_N ( ( t, force ) )
-    PROTO_T ( int t X int force )
+predict_undecl_type(int t, int force)
 {
-    switch ( t ) {
+	switch (t) {
-	case lex_identifier :
+	case lex_identifier:
-	case lex_type_Hname :
+	case lex_type_Hname:
-	case lex_namespace_Hname :
+	case lex_namespace_Hname:
-	case lex_statement_Hname : {
+	case lex_statement_Hname: {
-	    int d = force ;
+		int d = force;
-	    PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	    if ( !d ) {
+		if (!d) {
-		t = next_token () ;
+			t = next_token();
-		switch ( t ) {
+			switch (t) {
 #if LANGUAGE_CPP
-		    case lex_and_H1 :
+			case lex_and_H1:
-		    case lex_full_Hname_Hstar :
+			case lex_full_Hname_Hstar:
-		    case lex_nested_Hname_Hstar :
+			case lex_nested_Hname_Hstar:
 #endif
-		    case lex_star : {
+			case lex_star:
-			/* These are ptr-operators */
+				/* These are ptr-operators */
-			d = 1 ;
+				d = 1;
-			break ;
+				break;
-		    }
-		    case lex_open_Hround : {
+			case lex_open_Hround:
-			/* This is stretching the bounds of possibility */
+				/* This is stretching the bounds of
-			break ;
+				 * possibility */
-		    }
+				break;
-		    case lex_identifier :
+			case lex_identifier:
-		    case lex_type_Hname :
+			case lex_type_Hname:
-		    case lex_namespace_Hname :
+			case lex_namespace_Hname:
-		    case lex_statement_Hname :
+			case lex_statement_Hname:
-		    case lex_template_Htype :
+			case lex_template_Htype:
-		    case lex_template_Hid :
+			case lex_template_Hid:
-		    case lex_full_Hname :
+			case lex_full_Hname:
-		    case lex_nested_Hname : {
+			case lex_nested_Hname:
-			/* The identifier can't be a declarator */
+				/* The identifier can't be a declarator */
-			d = 1 ;
+				d = 1;
-			break ;
+				break;
-		    }
-		    default : {
+			default: {
-			/* Check for further declaration specifiers */
+				/* Check for further declaration specifiers */
-			int c = lookup_token ( t ) ;
+				int c = lookup_token(t);
-			switch ( c ) {
+				switch (c) {
-			    case TOK_DECL_SPEC :
+				case TOK_DECL_SPEC:
-			    case TOK_SIMPLE_TYPE :
+				case TOK_SIMPLE_TYPE:
-			    case TOK_TYPE_KEY :
+				case TOK_TYPE_KEY:
-			    case TOK_TYPE_SPEC :
+				case TOK_TYPE_SPEC:
-			    case TOK_EXTERN :
+				case TOK_EXTERN:
-			    case TOK_TYPE : {
+				case TOK_TYPE: {
-				d = 1 ;
+					d = 1;
-				break ;
+					break;
-			    }
+				}
-			}
+				}
-			break ;
+				break;
+			}
-		    }
+			}
+		}
-	    }
+		if (d) {
-	    if ( d ) p->tok = lex_type_Hname ;
+			p->tok = lex_type_Hname;
+		}
-	    crt_lookup = np ;
+		crt_lookup = np;
-	    crt_token = p ;
+		crt_token = p;
-	    return ( d ) ;
+		return(d);
+	}
+	}
-    }
-    return ( 0 ) ;
+	return(0);
+}
 /*
     LOOK-AHEAD FOR DECLARATION SPECIFIERS
     declarators or other constructs.  Note that linkage-specifications are
     spotted at this stage.  In addition type names are not always what
     they seem.  For example in:
 		typedef int t ;
 		typedef int t ;
     the second t is a type-name, but needs to be recognised as a declarator-id
     rather than a decl-specifier.  Similarly in:
 		class c {
 		    c () ;
 		} ;
     the second c is a class-name, but is actually a constructor name rather
     than a decl-specifier.
 */
-int predict_dspec
+int
-    PROTO_N ( ( force ) )
-    PROTO_T ( int force )
+predict_dspec(int force)
 {
-    int d = 0 ;
+	int d = 0;
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    int c = lookup_token ( t ) ;
+	int c = lookup_token(t);
 #if LANGUAGE_CPP
-    is_constructor_next = 0 ;
+	is_constructor_next = 0;
 #endif
-    switch ( c ) {
+	switch (c) {
-	case TOK_DECL_SPEC :
+	case TOK_DECL_SPEC:
-	case TOK_SIMPLE_TYPE :
+	case TOK_SIMPLE_TYPE:
-	case TOK_TYPE_KEY :
+	case TOK_TYPE_KEY:
-	case TOK_TYPE_SPEC : {
+	case TOK_TYPE_SPEC:
-	    /* These are declaration-specifiers */
+		/* These are declaration-specifiers */
-	    d = 1 ;
+		d = 1;
-	    break ;
+		break;
-	}
-	case TOK_EXTERN : {
+	case TOK_EXTERN: {
 #if LANGUAGE_CPP
-	    /* Explicitly check for linkage-specifications */
+		/* Explicitly check for linkage-specifications */
-	    PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	    t = next_token () ;
+		t = next_token();
-	    if ( t != lex_string_Hexp && t != lex_wstring_Hexp ) d = 1 ;
+		if (t != lex_string_Hexp && t != lex_wstring_Hexp)d = 1;
-	    crt_lookup = np ;
+		crt_lookup = np;
-	    crt_token = p ;
+		crt_token = p;
 #else
-	    d = 1 ;
+		d = 1;
 #endif
-	    break ;
+		break;
 	}
-	case TOK_TYPE : {
+	case TOK_TYPE:
-	    /* Only the first type name is counted */
+		/* Only the first type name is counted */
-	    if ( t == lex_type_Hname || t == lex_template_Htype ) {
+		if (t == lex_type_Hname || t == lex_template_Htype) {
-		if ( !have_type_specifier ) {
+			if (!have_type_specifier) {
 #if LANGUAGE_CPP
-		    PPTOKEN *p = crt_token ;
+				PPTOKEN *p = crt_token;
-		    NAMESPACE np = crt_lookup ;
+				NAMESPACE np = crt_lookup;
-		    d = 1 ;
+				d = 1;
-		    t = next_token () ;
+				t = next_token();
-		    if ( t == lex_open_Hround ) {
+				if (t == lex_open_Hround) {
-			/* Allow for constructors */
+					/* Allow for constructors */
-			t = next_token () ;
+					t = next_token();
-			if ( predict_func_params ( t, 1, 0 ) ) {
+					if (predict_func_params(t, 1, 0)) {
-			    is_constructor_next = 1 ;
+						is_constructor_next = 1;
-			    d = 0 ;
+						d = 0;
-			}
+					}
-		    }
+				}
-		    crt_lookup = np ;
+				crt_lookup = np;
-		    crt_token = p ;
+				crt_token = p;
 #else
-		    d = 1 ;
+				d = 1;
 #endif
-		}
-	    } else {
-		d = 1 ;
-	    }
-	    break ;
-	}
-#if LANGUAGE_CPP
-	case TOK_NESTED_NAME :
-	case TOK_FULL_NAME : {
-	    /* Look for nested type names */
-	    if ( !have_type_specifier ) {
-		PPTOKEN *p = crt_token ;
-		NAMESPACE np = crt_lookup ;
-		t = next_token () ;
-		c = lookup_token ( t ) ;
-		if ( c == TOK_TYPE ) {
-		    /* These are simple-type-specifiers */
-		    d = 1 ;
-		    t = next_token () ;
-		    if ( t == lex_open_Hround ) {
-			/* Allow for constructors */
-			IGNORE add_nested_nspace ( np ) ;
-			t = next_token () ;
-			if ( predict_func_params ( t, 1, 0 ) ) {
-			    is_constructor_next = 1 ;
-			    d = 0 ;
+			}
-			IGNORE remove_nested_nspace ( np ) ;
-		    }
 		} else {
-		    d = predict_undecl_type ( t, force ) ;
-		}
-		crt_lookup = np ;
-		crt_token = p ;
-	    }
+			d = 1;
-	    break ;
-	}
+		}
-#endif
-	default : {
-	    /* Check for undefined types */
-	    if ( !have_type_specifier ) {
-		d = predict_undecl_type ( t, force ) ;
-		if ( d ) crt_lex_token = lex_type_Hname ;
-	    }
-	    break ;
-	}
-    }
-    return ( d ) ;
-}
-/*
-    LOOK-AHEAD FOR TYPE SPECIFIERS
-    A look-ahead is needed to distinguish type-specifiers from following
-    declarators or other constructs.
-*/
-int predict_tspec
-    PROTO_N ( ( force ) )
-    PROTO_T ( int force )
-{
-    int d = 0 ;
-    int t = crt_lex_token ;
-    int c = lookup_token ( t ) ;
-    switch ( c ) {
-	case TOK_SIMPLE_TYPE :
-	case TOK_TYPE_KEY :
-	case TOK_TYPE_SPEC :
-	case TOK_TYPE : {
-	    /* These are type-specifiers */
-	    d = 1 ;
-	    break ;
+		break;
-	}
 #if LANGUAGE_CPP
-	case TOK_NESTED_NAME :
+	case TOK_NESTED_NAME:
-	case TOK_FULL_NAME : {
+	case TOK_FULL_NAME:
-	    /* Look for nested type names */
+		/* Look for nested type names */
+		if (!have_type_specifier) {
-	    PPTOKEN *p = crt_token ;
+			PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+			NAMESPACE np = crt_lookup;
-	    t = next_token () ;
+			t = next_token();
-	    c = lookup_token ( t ) ;
+			c = lookup_token(t);
-	    if ( c == TOK_TYPE ) {
+			if (c == TOK_TYPE) {
+				/* These are simple-type-specifiers */
-		d = 1 ;
+				d = 1;
-	    } else {
+				t = next_token();
-		if ( !have_type_specifier ) {
+				if (t == lex_open_Hround) {
+					/* Allow for constructors */
+					IGNORE add_nested_nspace(np);
+					t = next_token();
+					if (predict_func_params(t, 1, 0)) {
+						is_constructor_next = 1;
+						d = 0;
+					}
+					IGNORE remove_nested_nspace(np);
+				}
+			} else {
-		    d = predict_undecl_type ( t, force ) ;
+				d = predict_undecl_type(t, force);
+			}
+			crt_lookup = np;
+			crt_token = p;
+		}
-	    }
-	    crt_lookup = np ;
-	    crt_token = p ;
-	    break ;
+		break;
-	}
 #endif
-	default : {
+	default:
-	    /* Check for undefined types */
+		/* Check for undefined types */
-	    if ( !have_type_specifier ) {
+		if (!have_type_specifier) {
-		d = predict_undecl_type ( t, force ) ;
+			d = predict_undecl_type(t, force);
-		if ( d ) crt_lex_token = lex_type_Hname ;
+			if (d)crt_lex_token = lex_type_Hname;
-	    }
+		}
-	    break ;
+		break;
+	}
-    }
-    return ( d ) ;
+	return(d);
+}
 /*
+    LOOK-AHEAD FOR TYPE SPECIFIERS
+    A look-ahead is needed to distinguish type-specifiers from following
+    declarators or other constructs.
+*/
+int
+predict_tspec(int force)
+{
+	int d = 0;
+	int t = crt_lex_token;
+	int c = lookup_token(t);
+	switch (c) {
+	case TOK_SIMPLE_TYPE:
+	case TOK_TYPE_KEY:
+	case TOK_TYPE_SPEC:
+	case TOK_TYPE:
+		/* These are type-specifiers */
+		d = 1;
+		break;
+#if LANGUAGE_CPP
+	case TOK_NESTED_NAME:
+	case TOK_FULL_NAME: {
+		/* Look for nested type names */
+		PPTOKEN *p = crt_token;
+		NAMESPACE np = crt_lookup;
+		t = next_token();
+		c = lookup_token(t);
+		if (c == TOK_TYPE) {
+			d = 1;
+		} else {
+			if (!have_type_specifier) {
+				d = predict_undecl_type(t, force);
+			}
+		}
+		crt_lookup = np;
+		crt_token = p;
+		break;
+	}
+#endif
+	default:
+		/* Check for undefined types */
+		if (!have_type_specifier) {
+			d = predict_undecl_type(t, force);
+			if (d)crt_lex_token = lex_type_Hname;
+		}
+		break;
+	}
+	return(d);
+}
+/*
     LOOK-AHEAD FOR FUNCTION QUALIFIERS
     A further look-ahead is required when distinguishing type-ids from
     expressions after 'T ()' has been read for some type.  If the next
     token is '+' for example it is an expression, if it is 'const' it
     is a declaration.  t gives the next token and e gives the default
     value.
 */
 #if LANGUAGE_CPP
-static int predict_qual
+static int
-    PROTO_N ( ( t, e ) )
-    PROTO_T ( int t X int e )
+predict_qual(int t, int e)
 {
-    switch ( t ) {
+	switch (t) {
-	case lex_const :
+	case lex_const:
-	case lex_volatile :
+	case lex_volatile:
-	case lex_throw : {
+	case lex_throw:
-	    /* Function qualifiers */
+		/* Function qualifiers */
-	    e = 1 ;
+		e = 1;
-	    break ;
+		break;
-	}
-	case lex_and_H1 :
+	case lex_and_H1:
-	case lex_and_Heq_H1 :
+	case lex_and_Heq_H1:
-	case lex_arrow :
+	case lex_arrow:
-	case lex_arrow_Hstar :
+	case lex_arrow_Hstar:
-	case lex_assign :
+	case lex_assign:
-	case lex_div :
+	case lex_div:
-	case lex_div_Heq :
+	case lex_div_Heq:
-	case lex_dot :
+	case lex_dot:
-	case lex_dot_Hstar :
+	case lex_dot_Hstar:
-	case lex_eq :
+	case lex_eq:
-	case lex_greater :
+	case lex_greater:
-	case lex_greater_Heq :
+	case lex_greater_Heq:
-	case lex_less :
+	case lex_less:
-	case lex_less_Heq :
+	case lex_less_Heq:
-	case lex_logical_Hand_H1 :
+	case lex_logical_Hand_H1:
-	case lex_logical_Hor_H1 :
+	case lex_logical_Hor_H1:
-	case lex_lshift :
+	case lex_lshift:
-	case lex_lshift_Heq :
+	case lex_lshift_Heq:
-	case lex_minus :
+	case lex_minus:
-	case lex_minus_Heq :
+	case lex_minus_Heq:
-	case lex_minus_Hminus :
+	case lex_minus_Hminus:
-	case lex_not_Heq_H1 :
+	case lex_not_Heq_H1:
-	case lex_or_H1 :
+	case lex_or_H1:
-	case lex_or_Heq_H1 :
+	case lex_or_Heq_H1:
-	case lex_plus :
+	case lex_plus:
-	case lex_plus_Heq :
+	case lex_plus_Heq:
-	case lex_plus_Hplus :
+	case lex_plus_Hplus:
-	case lex_question :
+	case lex_question:
-	case lex_rem :
+	case lex_rem:
-	case lex_rem_Heq :
+	case lex_rem_Heq:
-	case lex_rshift :
+	case lex_rshift:
-	case lex_rshift_Heq :
+	case lex_rshift_Heq:
-	case lex_star :
+	case lex_star:
-	case lex_star_Heq :
+	case lex_star_Heq:
-	case lex_xor_H1 :
+	case lex_xor_H1:
-	case lex_xor_Heq_H1 :
+	case lex_xor_Heq_H1:
-	case lex_abs :
+	case lex_abs:
-	case lex_max :
+	case lex_max:
-	case lex_min : {
+	case lex_min:
-	    /* Binary expression operators */
+		/* Binary expression operators */
-	    e = 0 ;
+		e = 0;
-	    break ;
+		break;
-	}
-	case lex_comma : {
+	case lex_comma:
-	    /* Comma operators */
+		/* Comma operators */
-	    if ( e == 1 ) e = 0 ;
+		if (e == 1) {
-	    break ;
+			e = 0;
-	}
+		}
+		break;
-    }
+	}
-    return ( e ) ;
+	return(e);
 }
 #endif
 /*
     LOOK-AHEAD FOR TYPE IDENTIFIERS
     A look-ahead is needed to distinguish type-ids from expressions in,
     for example, sizeof expressions.  A type-id consists of a sequence
     of type-specifiers followed by an optional abstract-declarator,
     whereas the only tricky expressions are those consisting of a
     simple-type-specifier followed by a bracketed list of expressions.
     e gives the value to be returned if the result could be either.
 */
-int predict_typeid
+int
-    PROTO_N ( ( e ) )
-    PROTO_T ( int e )
+predict_typeid(int e)
+{
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    int c = lookup_token ( t ) ;
+	int c = lookup_token(t);
-    switch ( c ) {
+	switch (c) {
-	case TOK_TYPE_KEY :
+	case TOK_TYPE_KEY:
-	case TOK_TYPE_SPEC : {
+	case TOK_TYPE_SPEC:
-	    /* These are type-specifiers */
+		/* These are type-specifiers */
-	    return ( 1 ) ;
+		return(1);
-	}
-	case TOK_SIMPLE_TYPE :
+	case TOK_SIMPLE_TYPE:
-	case TOK_TYPE : {
+	case TOK_TYPE: {
-	    /* These are simple-type-specifiers */
+		/* These are simple-type-specifiers */
-	    int d = 1 ;
+		int d = 1;
 #if LANGUAGE_CPP
-	    PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	    t = next_token () ;
+		t = next_token();
-	    if ( t == lex_open_Hround ) {
+		if (t == lex_open_Hround) {
-		/* This is the tricky case 'T ( ...' */
+			/* This is the tricky case 'T ( ...' */
-		PPTOKEN *q ;
+			PPTOKEN *q;
-		NAMESPACE nq ;
+			NAMESPACE nq;
-		t = next_token () ;
+			t = next_token();
-		q = crt_token ;
+			q = crt_token;
-		nq = crt_lookup ;
+			nq = crt_lookup;
-		d = predict_func_params ( t, 2, 0 ) ;
+			d = predict_func_params(t, 2, 0);
-		if ( d != 1 ) {
+			if (d != 1) {
-		    if ( t == lex_close_Hround ) {
+				if (t == lex_close_Hround) {
-			t = next_token () ;
+					t = next_token();
-			d = predict_qual ( t, e ) ;
+					d = predict_qual(t, e);
-		    } else {
+				} else {
-			crt_lookup = nq ;
+					crt_lookup = nq;
-			crt_token = q ;
+					crt_token = q;
-			d = predict_declarator ( t, 1, 1 ) ;
+					d = predict_declarator(t, 1, 1);
-		    }
+				}
+			}
+		}
-	    }
-	    crt_lookup = np ;
+		crt_lookup = np;
-	    crt_token = p ;
+		crt_token = p;
 #else
-	    UNUSED ( e ) ;
+		UNUSED(e);
 #endif
-	    return ( d ) ;
+		return(d);
+	}
 #if LANGUAGE_CPP
-	case TOK_NESTED_NAME :
+	case TOK_NESTED_NAME:
-	case TOK_FULL_NAME : {
+	case TOK_FULL_NAME: {
-	    /* Look for nested type-names */
+		/* Look for nested type-names */
-	    int d = 0 ;
+		int d = 0;
-	    PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	    t = next_token () ;
+		t = next_token();
-	    c = lookup_token ( t ) ;
+		c = lookup_token(t);
-	    if ( c == TOK_TYPE ) {
+		if (c == TOK_TYPE) {
-		d = 1 ;
+			d = 1;
-		t = next_token () ;
+			t = next_token();
-		if ( t == lex_open_Hround ) {
+			if (t == lex_open_Hround) {
-		    /* This is the tricky case 'N::T ( ...' */
+				/* This is the tricky case 'N::T ( ...' */
-		    PPTOKEN *q ;
+				PPTOKEN *q;
-		    NAMESPACE nq ;
+				NAMESPACE nq;
-		    t = next_token () ;
+				t = next_token();
-		    q = crt_token ;
+				q = crt_token;
-		    nq = crt_lookup ;
+				nq = crt_lookup;
-		    d = predict_func_params ( t, 2, 0 ) ;
+				d = predict_func_params(t, 2, 0);
-		    if ( d != 1 ) {
+				if (d != 1) {
-			if ( t == lex_close_Hround ) {
+					if (t == lex_close_Hround) {
-			    t = next_token () ;
+						t = next_token();
-			    d = predict_qual ( t, e ) ;
+						d = predict_qual(t, e);
-			} else {
+					} else {
-			    crt_lookup = nq ;
+						crt_lookup = nq;
-			    crt_token = q ;
+						crt_token = q;
-			    d = predict_declarator ( t, 1, 1 ) ;
+						d = predict_declarator(t, 1, 1);
+					}
+				}
+			}
-		    }
+		}
-	    }
-	    crt_lookup = np ;
+		crt_lookup = np;
-	    crt_token = p ;
+		crt_token = p;
-	    return ( d ) ;
+		return(d);
 	}
 #endif
-    }
+	}
-    return ( 0 ) ;
+	return(0);
+}
 /*
     LOOK-AHEAD FOR TEMPLATE TYPE NAMES
     A look-ahead is needed to distinguish template type names from other
     types when parsing template arguments.
 */
+int
-int predict_typename
+predict_typename(void)
-    PROTO_Z ()
+{
-    int d = 0 ;
+	int d = 0;
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    if ( t == lex_type_Hname ) {
+	if (t == lex_type_Hname) {
-	/* Unqualified type names */
+		/* Unqualified type names */
-	IDENTIFIER id = crt_token->pp_data.id.use ;
+		IDENTIFIER id = crt_token->pp_data.id.use;
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	if ( ds & dspec_template ) d = 1 ;
+		if (ds & dspec_template) {
+			d = 1;
-    }
+		}
+	}
 #if LANGUAGE_CPP
-    if ( t == lex_full_Hname || t == lex_nested_Hname || t == lex_colon_Hcolon ) {
+	if (t == lex_full_Hname || t == lex_nested_Hname ||
+	    t == lex_colon_Hcolon) {
-	PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	t = next_token () ;
+		t = next_token();
-	if ( t == lex_type_Hname ) {
+		if (t == lex_type_Hname) {
-	    /* Qualified type names */
+			/* Qualified type names */
-	    IDENTIFIER id = crt_token->pp_data.id.use ;
+			IDENTIFIER id = crt_token->pp_data.id.use;
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	    if ( ds & dspec_template ) d = 1 ;
+			if (ds & dspec_template) {
+				d = 1;
+			}
+		}
+		crt_lookup = np;
+		crt_token = p;
+	}
-	crt_lookup = np ;
-	crt_token = p ;
-    }
 #endif
-    return ( d ) ;
+	return(d);
+}
 /*
     LOOK-AHEAD FOR INITIALISERS
     init-declarator from function declarators.  This predicate is called
     immediately after an open bracket.  Note that anything which could
     possibly be a function declarator is.  If the result is an initialiser
     beginning with '(' then this first token is replaced by a dummy to
     prevent further calls to predict_init.
 */
-int predict_init
+int
-    PROTO_Z ()
+predict_init(void)
 {
 #if LANGUAGE_CPP
-    PPTOKEN *p = crt_token ;
+	PPTOKEN *p = crt_token;
-    NAMESPACE np = crt_lookup ;
+	NAMESPACE np = crt_lookup;
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    int d = predict_func_params ( t, 1, 0 ) ;
+	int d = predict_func_params(t, 1, 0);
-    crt_lookup = np ;
+	crt_lookup = np;
-    crt_token = p ;
+	crt_token = p;
-    if ( d == 0 ) {
+	if (d == 0) {
-	/* Definitely doesn't look like a function declarator */
+		/* Definitely doesn't look like a function declarator */
-	if ( t == lex_open_Hround ) {
+		if (t == lex_open_Hround) {
-	    t = lex_open_Hinit ;
+			t = lex_open_Hinit;
-	    crt_lex_token = t ;
+			crt_lex_token = t;
-	    p->tok = t ;
+			p->tok = t;
-	}
+		}
-	return ( 1 ) ;
+		return(1);
-    }
+	}
-    if ( t == lex_ellipsis_Hexp ) {
+	if (t == lex_ellipsis_Hexp) {
-	t = lex_ellipsis ;
+		t = lex_ellipsis;
-	crt_lex_token = t ;
+		crt_lex_token = t;
-	p->tok = t ;
+		p->tok = t;
-    }
+	}
 #endif
-    return ( 0 ) ;
+	return(0);
 }
 /*
     LOOK-AHEAD FOR DESTRUCTORS
     complement operator followed by a class-name.  The latter is only the
     case if it is followed by a bracketed list of expressions.  The
     really difficult case is when this list is empty.  The return value
     is 2 following '::', 3 following '->' or '.', and 1 for other
     destructors.
 */
-int predict_destr
+int
-    PROTO_N ( ( ns ) )
-    PROTO_T ( NAMESPACE ns )
+predict_destr(NAMESPACE ns)
 {
 #if LANGUAGE_CPP
-    int d = 1 ;
+	int d = 1;
-    int t = last_lex_token ;
+	int t = last_lex_token;
-    if ( !IS_NULL_nspace ( ns ) ) {
+	if (!IS_NULL_nspace(ns)) {
-	if ( EQ_nspace ( ns, global_namespace ) ) {
+		if (EQ_nspace(ns, global_namespace)) {
-	    t = lex_colon_Hcolon ;
+			t = lex_colon_Hcolon;
-	} else {
+		} else {
-	    t = lex_nested_Hname ;
+			t = lex_nested_Hname;
-	}
+		}
-    }
+	}
-    switch ( t ) {
+	switch (t) {
-	case lex_nested_Hname :
+	case lex_nested_Hname:
-	case lex_full_Hname : {
+	case lex_full_Hname:
-	    /* Always have destructor names after these */
+		/* Always have destructor names after these */
-	    if ( cache_lookup ) {
+		if (cache_lookup) {
-		d = 2 ;
+			d = 2;
-	    } else {
-		/* Can only happen after '.' or '->' */
-		d = 3 ;
-	    }
-	    break ;
-	}
-	case lex_colon_Hcolon : {
-	    /* Never have destructor name after this */
-	    d = 0 ;
-	    break ;
-	}
-	case lex_arrow :
-	case lex_dot : {
-	    /* Always have destructor names after these */
-	    d = 3 ;
-	    break ;
-	}
-	default : {
-	    PPTOKEN *p = crt_token ;
-	    NAMESPACE np = crt_lookup ;
-	    t = next_token () ;
-	    if ( t == lex_open_Hround ) {
-		t = next_token () ;
-		if ( t == lex_close_Hround ) {
-		    /* This is the commonest case */
-		    if ( in_function_defn ) d = 0 ;
 		} else {
-		    d = predict_func_params ( t, 1, 0 ) ;
+			/* Can only happen after '.' or '->' */
-		    if ( d ) d = 1 ;
+			d = 3;
+		}
+		break;
+	case lex_colon_Hcolon:
+		/* Never have destructor name after this */
-	    }
+		d = 0;
+		break;
+	case lex_arrow:
+	case lex_dot:
+		/* Always have destructor names after these */
+		d = 3;
+		break;
+	default: {
+		PPTOKEN *p = crt_token;
+		NAMESPACE np = crt_lookup;
+		t = next_token();
+		if (t == lex_open_Hround) {
+			t = next_token();
+			if (t == lex_close_Hround) {
+				/* This is the commonest case */
+				if (in_function_defn)d = 0;
+			} else {
+				d = predict_func_params(t, 1, 0);
+				if (d)d = 1;
+			}
+		}
-	    crt_lookup = np ;
+		crt_lookup = np;
-	    crt_token = p ;
+		crt_token = p;
-	    break ;
+		break;
+	}
-    }
+	}
-    return ( d ) ;
+	return(d);
 #else
-    UNUSED ( ns ) ;
+	UNUSED(ns);
-    return ( 0 ) ;
+	return(0);
 #endif
+}
 /*
     LOOK-AHEAD FOR FUNCTION PARAMETERS
     A look-ahead is needed to distinguish a declarator-id representing a
     function parameter from a type-specifier.  The only difficult case is
     a type-name immediately after an open bracket.
 */
-int predict_param
+int
-    PROTO_Z ()
+predict_param(void)
 {
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    switch ( t ) {
+	switch (t) {
-	case lex_identifier :
+	case lex_identifier:
-	case lex_namespace_Hname :
+	case lex_namespace_Hname:
-	case lex_statement_Hname :
+	case lex_statement_Hname:
-	case lex_destructor_Hname :
+	case lex_destructor_Hname:
-	case lex_template_Hid :
+	case lex_template_Hid:
-	case lex_operator : {
+	case lex_operator:
-	    /* These are all unqualified-ids */
+		/* These are all unqualified-ids */
-	    return ( 1 ) ;
+		return(1);
-	}
-	case lex_type_Hname :
+	case lex_type_Hname:
-	case lex_template_Htype : {
+	case lex_template_Htype:
-	    /* Check for type names */
+		/* Check for type names */
-	    if ( last_lex_token != lex_open_Hround ) return ( 1 ) ;
+		if (last_lex_token != lex_open_Hround) {
-	    break ;
+			return(1);
-	}
+		}
+		break;
 #if LANGUAGE_CPP
-	case lex_full_Hname :
+	case lex_full_Hname:
-	case lex_nested_Hname :
+	case lex_nested_Hname:
-	case lex_colon_Hcolon : {
+	case lex_colon_Hcolon: {
-	    /* Check token after a nested name */
+		/* Check token after a nested name */
-	    int d ;
+		int d;
-	    PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	    crt_lex_token = next_token () ;
+		crt_lex_token = next_token();
-	    d = predict_param () ;
+		d = predict_param();
-	    crt_lex_token = t ;
+		crt_lex_token = t;
-	    crt_lookup = np ;
+		crt_lookup = np;
-	    crt_token = p ;
+		crt_token = p;
-	    return ( d ) ;
+		return(d);
 	}
 #endif
-    }
+	}
-    return ( 0 ) ;
+	return(0);
+}
 /*
     LOOK-AHEAD FOR CLASS SPECIFICATIONS
     or an enum-specifier.  This is recognised by an optional qualified
     identifier followed by an open brace (for the class body) or a colon
     (for a base-clause, if col is true).
 */
-int predict_class
+int
-    PROTO_N ( ( col ) )
-    PROTO_T ( int col )
+predict_class(int col)
+{
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    /* Examine the name */
+	/* Examine the name */
-    switch ( t ) {
+	switch (t) {
-	case lex_identifier :
+	case lex_identifier:
-	case lex_type_Hname :
+	case lex_type_Hname:
-	case lex_namespace_Hname :
+	case lex_namespace_Hname:
-	case lex_statement_Hname :
+	case lex_statement_Hname:
-	case lex_template_Htype : {
+	case lex_template_Htype: {
-	    /* Name present */
+		/* Name present */
-	    PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	    t = next_token () ;
+		t = next_token();
-	    crt_lookup = np ;
+		crt_lookup = np;
-	    crt_token = p ;
+		crt_token = p;
-	    break ;
+		break;
+	}
 #if LANGUAGE_CPP
-	case lex_full_Hname :
+	case lex_full_Hname:
-	case lex_nested_Hname :
+	case lex_nested_Hname:
-	case lex_colon_Hcolon : {
+	case lex_colon_Hcolon: {
-	    /* Allow for nested names */
+		/* Allow for nested names */
-	    PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	    NAMESPACE np = crt_lookup ;
+		NAMESPACE np = crt_lookup;
-	    t = next_token () ;
+		t = next_token();
-	    switch ( t ) {
+		switch (t) {
-		case lex_identifier :
+		case lex_identifier:
-		case lex_type_Hname :
+		case lex_type_Hname:
-		case lex_namespace_Hname :
+		case lex_namespace_Hname:
-		case lex_statement_Hname :
+		case lex_statement_Hname:
-		case lex_template_Htype : {
+		case lex_template_Htype:
-		    /* Nested name present */
+			/* Nested name present */
-		    t = next_token () ;
+			t = next_token();
-		    crt_lookup = np ;
+			crt_lookup = np;
-		    crt_token = p ;
+			crt_token = p;
-		    break ;
+			break;
+		default:
+			/* Invalid name */
+			crt_lookup = np;
+			crt_token = p;
+			return(0);
+		}
-		default : {
-		    /* Invalid name */
-		    crt_lookup = np ;
-		    crt_token = p ;
-		    return ( 0 ) ;
-		}
-	    }
-	    break ;
+		break;
 	}
 #endif
-    }
+	}
-    /* Examine the token following the name */
+	/* Examine the token following the name */
-    if ( t == lex_open_Hbrace_H1 ) return ( 1 ) ;
+	if (t == lex_open_Hbrace_H1) {
+		return(1);
+	}
-    if ( t == lex_colon && !in_token_decl ) return ( col ) ;
+	if (t == lex_colon && !in_token_decl) {
+		return(col);
+	}
-    return ( 0 ) ;
+	return(0);
+}
 /*
     LOOK-AHEAD FOR FUNCTION DEFINITIONS
     (starting a function-body), a ':' (starting a ctor-initialiser), or
     a 'try' (starting a function-try-block).  It has already been checked
     whether the type of the current declarator is a function.
 */
+int
-int predict_func_defn
+predict_func_defn(void)
-    PROTO_Z ()
+{
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    if ( t == lex_open_Hbrace_H1 ) return ( 1 ) ;
+	if (t == lex_open_Hbrace_H1) {
+		return(1);
+	}
 #if LANGUAGE_CPP
-    if ( t == lex_try ) return ( 1 ) ;
+	if (t == lex_try) {
+		return(1);
+	}
-    if ( t == lex_colon && !in_token_decl ) return ( 1 ) ;
+	if (t == lex_colon && !in_token_decl) {
+		return(1);
+	}
 #endif
-    return ( 0 ) ;
+	return(0);
+}
 /*
     LOOK-AHEAD FOR OBJECT INITIALISERS
     A predicate is needed to determine whether an object declaration
     is followed by an initialising expression.  Note this is not the
     same as the object being defined.
 */
+int
-int predict_obj_defn
+predict_obj_defn(void)
-    PROTO_Z ()
 {
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    if ( t == lex_assign ) return ( 1 ) ;
+	if (t == lex_assign) {
+		return(1);
+	}
 #if LANGUAGE_CPP
-    if ( t == lex_open_Hround ) return ( 1 ) ;
+	if (t == lex_open_Hround) {
+		return(1);
+	}
 #endif
-    return ( 0 ) ;
+	return(0);
 }
 /*
     LOOK-AHEAD FOR POINTER OPERATORS
     A look-ahead is needed following a conversion-function-id for possible
     to be resolved as the conversion function for 'int *' rather than as
     the conversion function for 'int' times something.  The argument ref
     indicates whether '&' is a valid pointer operator.
 */
-int predict_ptr
+int
-    PROTO_N ( ( ref ) )
-    PROTO_T ( int ref )
+predict_ptr(int ref)
+{
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    if ( t == lex_star ) return ( 1 ) ;
+	if (t == lex_star) {
+		return(1);
+	}
 #if LANGUAGE_CPP
-    if ( t == lex_full_Hname_Hstar || t == lex_nested_Hname_Hstar ) return ( 1 ) ;
+	if (t == lex_full_Hname_Hstar || t == lex_nested_Hname_Hstar) {
+		return(1);
+	}
-    if ( t == lex_and_H1 ) return ( ref ) ;
+	if (t == lex_and_H1) {
+		return(ref);
+	}
 #else
-    UNUSED ( ref ) ;
+	UNUSED(ref);
 #endif
-    return ( 0 ) ;
+	return(0);
 }
 /*
     LOOK-AHEAD FOR OPERATOR NAMES
     A look-ahead is needed in the token syntax for overloaded operator
     and conversion function names.
 */
+int
-int predict_operator
+predict_operator(void)
-    PROTO_Z ()
+{
 #if LANGUAGE_CPP
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    if ( t == lex_operator ) return ( 1 ) ;
+	if (t == lex_operator) {
+		return(1);
+	}
 #endif
-    return ( 0 ) ;
+	return(0);
+}
 /*
     LOOK-AHEAD FOR ARRAY OPERATORS
     'operator delete'.  A following '[' might be the start of an array index,
     or it may introduce 'operator new []' or 'operator delete []'.  This
     routine returns true in the latter case.
 */
-int predict_array
+int
-    PROTO_Z ()
+predict_array(void)
+{
-    PPTOKEN *p ;
+	PPTOKEN *p;
-    NAMESPACE np ;
+	NAMESPACE np;
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    if ( t != lex_open_Hsquare_H1 ) return ( 0 ) ;
+	if (t != lex_open_Hsquare_H1) {
+		return(0);
+	}
-    p = crt_token ;
+	p = crt_token;
-    np = crt_lookup ;
+	np = crt_lookup;
-    t = next_token () ;
+	t = next_token();
-    crt_lookup = np ;
+	crt_lookup = np;
-    crt_token = p ;
+	crt_token = p;
-    if ( t != lex_close_Hsquare_H1 ) return ( 0 ) ;
+	if (t != lex_close_Hsquare_H1) {
+		return(0);
+	}
-    return ( 1 ) ;
+	return(1);
+}
 /*
     LOOK-AHEAD FOR TEMPLATE PARAMETERS
     A look-ahead is required to distinguish type template parameters from
     non-type template parameters.
 */
+int
-int predict_template
+predict_template(void)
-    PROTO_Z ()
+{
-    int d = 0 ;
+	int d = 0;
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    if ( t == lex_class || t == lex_typename ) {
+	if (t == lex_class || t == lex_typename) {
-	int have_id = 0 ;
+		int have_id = 0;
-	PPTOKEN *p = crt_token ;
+		PPTOKEN *p = crt_token;
-	int s = next_token () ;
+		int s = next_token();
-	switch ( s ) {
+		switch (s) {
-	    case lex_identifier :
+		case lex_identifier:
-	    case lex_type_Hname :
+		case lex_type_Hname:
-	    case lex_namespace_Hname :
+		case lex_namespace_Hname:
-	    case lex_statement_Hname : {
+		case lex_statement_Hname:
-		s = next_token () ;
+			s = next_token();
-		have_id = 1 ;
+			have_id = 1;
-		break ;
+			break;
-	    }
-	}
+		}
-	if ( s == lex_comma || s == lex_close_Htemplate ) {
+		if (s == lex_comma || s == lex_close_Htemplate) {
-	    d = 1 ;
+			d = 1;
-	} else if ( s == lex_assign ) {
+		} else if (s == lex_assign) {
-	    if ( have_id ) {
+			if (have_id) {
-		s = next_token () ;
+				s = next_token();
-		crt_lex_token = s ;
+				crt_lex_token = s;
-		d = predict_typeid ( 2 ) ;
+				d = predict_typeid(2);
-	    } else {
+			} else {
-		d = 1 ;
+				d = 1;
+			}
+		}
+		crt_lex_token = t;
+		crt_token = p;
+	} else if (t == lex_template) {
-	    }
+		d = 1;
+	}
-	crt_lex_token = t ;
-	crt_token = p ;
-    } else if ( t == lex_template ) {
-	d = 1 ;
-    }
-    return ( d ) ;
+	return(d);
+}

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/producers/common/parse/predict.c – Rev 5 → 6