/*
 * Automatically generated from the files:
 *	/mnt/gmirror/ports/lang/TenDRA/work/tendra/src/producers/cpp/syntax/syntax.sid
 * and
 *	/mnt/gmirror/ports/lang/TenDRA/work/tendra/src/producers/cpp/syntax/syntax.act
 * by:
 *	/mnt/gmirror/ports/lang/TenDRA/work/tendra/obj/utilities/sid/sid
 */

/* BEGINNING OF HEADER */

#define __SID_SPLIT

/*
 *    		 Crown Copyright (c) 1997, 1998
 *
 *    This TenDRA(r) Computer Program is subject to Copyright
 *    owned by the United Kingdom Secretary of State for Defence
 *    acting through the Defence Evaluation and Research Agency
 *    (DERA).  It is made available to Recipients with a
 *    royalty-free licence for its use, reproduction, transfer
 *    to other parties and amendment for any purpose not excluding
 *    product development provided that any such use et cetera
 *    shall be deemed to be acceptance of the following conditions:-
 *
 *        (1) Its Recipients shall ensure that this Notice is
 *        reproduced upon any copies or amended versions of it;
 *
 *        (2) Any amended version of it shall be clearly marked to
 *        show both the nature of and the organisation responsible
 *        for the relevant amendment or amendments;
 *
 *        (3) Its onward transfer from a recipient to another
 *        party shall be deemed to be that party's acceptance of
 *        these conditions;
 *
 *        (4) DERA gives no warranty or assurance as to its
 *        quality or suitability for any purpose and DERA accepts
 *        no liability whatsoever in relation to any use to which
 *        it may be put.
 */


#include "config.h"
#include "producer.h"
#include "c_types.h"
#include "ctype_ops.h"
#include "exp_ops.h"
#include "hashid_ops.h"
#include "id_ops.h"
#include "nspace_ops.h"
#include "type_ops.h"
#include "error.h"
#include "catalog.h"
#include "option.h"
#include "access.h"
#include "allocate.h"
#include "assign.h"
#include "basetype.h"
#include "cast.h"
#include "chktype.h"
#include "class.h"
#include "constant.h"
#include "construct.h"
#include "convert.h"
#include "declare.h"
#include "derive.h"
#include "dump.h"
#include "exception.h"
#include "expression.h"
#include "function.h"
#include "hash.h"
#include "identifier.h"
#include "initialise.h"
#include "inttype.h"
#include "label.h"
#include "lex.h"
#include "literal.h"
#include "member.h"
#include "namespace.h"
#include "parse.h"
#include "pragma.h"
#include "predict.h"
#include "preproc.h"
#include "redeclare.h"
#include "rewrite.h"
#include "statement.h"
#include "symbols.h"
#include "template.h"
#include "tokdef.h"
#include "token.h"
#include "typeid.h"
#include "variable.h"


/*
 *    COMPOUND TYPE ALIASES
 *
 *    These are the aliases for the compound types used in the parser.
 */

typedef LIST (EXP) SID_LIST_EXP;
typedef LIST (TYPE) SID_LIST_TYPE;


/*
 *    FUNCTION DECLARATIONS
 *
 *    The function declarations are included at this point so that the
 *    type definitions are in scope.
 */

#include "syntax.h"


/*
 *    COMPILATION MODE
 *
 *    The output of sid is automatically generated.  Hence it is not
 *    necessarily appropriate to apply the same level of checking to this
 *    as to the rest of the program.  These pragmas describe the relaxations
 *    allowed for the sid output.
 */

#if FS_TENDRA
#pragma TenDRA begin
#pragma TenDRA const conditional allow
#pragma TenDRA unreachable code allow
#pragma TenDRA variable analysis off
#endif



void
ZR847 (void)
{
    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	DECL_SPEC ZI497;
	int ZI849;
	NAMESPACE ZI429;
	IDENTIFIER ZI825;
	IDENTIFIER ZI423;

	{
	    switch (CURRENT_TERMINAL) {
	      case lex_virtual:
		{
		    ADVANCE_LEXER;
		    {
 (ZI849) = 1; 
		    }
		    ZR1333 (&ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		}
		break;
	      case lex_private: case lex_protected: case lex_public:
		{
		    ZR832 (&ZI497);
		    ZR1332 (&ZI849);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		}
		break;
	      default:
		{
		    {
 (ZI497) = dspec_none; 
		    }
		    {
 (ZI849) = 0; 
		    }
		}
		break;
	    }
	}
	ZR432 (&ZI429);
	ZR512 (&ZI825);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI423) = check_id ((ZI429), (ZI825), 0);
    last_namespace = (ZI429);
	}
	{

    add_base_class ((ZI423), (ZI497), (ZI849));
	}
    }
    return;
  ZL1:;
    SAVE_LEXER (358);
    return;
}

void
ZR1013 (DECL_SPEC ZI693, BASE_TYPE ZI515, TYPE ZI501, ACCESS_LIST ZI674)
{
    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	TYPE ZI418;
	IDENTIFIER ZI423;
	int ZI562;
	IDENTIFIER ZI463;
	EXP ZI435;

	ZR955 (ZI501, &ZI418, &ZI423, &ZI562);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    if (type_tag ((ZI418)) == type_func_tag) {
	/* Look ahead for function definitions */
	int def = predict_func_defn ();
	if (def & !have_func_declarator) adjust_param ((ZI418));
	(ZI463) = make_func_decl ((ZI693), (ZI418), (ZI423), def);
	is_function_next = def;
    } else {
	int def = predict_obj_defn ();
	(ZI463) = make_object_decl ((ZI693), (ZI418), (ZI423), def);
	is_function_next = 0;
    }
    if (IS_id_type_alias ((ZI463))) {
	BASE_TYPE bs = DEREF_btype (id_type_alias_rep ((ZI463)));
	bs |= (ZI515);
	COPY_btype (id_type_alias_rep ((ZI463)), bs);
    }
    have_type_declaration = TYPE_DECL_NONE;
    have_func_declarator = 0;
	}
	{

    IGNORE clear_access ((ZI463), &(ZI674));
	}
	{

    if (crt_access_list.pending) {
	IGNORE report_access ((ZI463));
    }
	}
	ZR1009 (ZI562, ZI463, &ZI435);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    int def = init_object ((ZI463), (ZI435));
    if (do_dump) dump_declare ((ZI463), &decl_loc, def);
	}
	{

    if (crt_access_list.pending) {
	IGNORE report_access ((ZI463));
    }
	}
	{

    end_declarator ((ZI463), 1);
	}
    }
    return;
  ZL1:;
    SAVE_LEXER (358);
    return;
}

void
ZR1038 (TYPE ZI418, DECL_SPEC ZI693, EXP *ZO435)
{
    EXP ZI435;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	BASE_TYPE ZI1253;
	TYPE ZI1254;
	CV_SPEC ZI1255;
	DECL_SPEC ZI1256;
	BASE_TYPE ZI515;
	TYPE ZI880;
	CV_SPEC ZI881;
	DECL_SPEC ZI914;
	DECL_SPEC ZI916;

	{

    /* Resolve declaration-specifiers from other declarators */
    (ZI0) = predict_dspec (0);
	}
	if (!ZI0)
	    goto ZL2;
	ZR911 (ZI418, &ZI1253, &ZI1254, &ZI1255, &ZI1256);
	ZR922 (&ZI418, &ZI1253, &ZI1254, &ZI1255, &ZI1256, &ZI515, &ZI880, &ZI881, &ZI914);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    /* Combine two declaration specifiers */
    DECL_SPEC d = (((ZI693) & (ZI914)) & dspec_duplicate);
    if (d) report (crt_loc, ERR_dcl_spec_dup (d));
    (ZI916) = ((ZI693) | (ZI914));
	}
	ZR1257 (&ZI418, &ZI515, &ZI880, &ZI881, &ZI916);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI435) = NULL_exp;
	}
	goto ZL0;
    }
    /*UNREACHED*/
  ZL2:;
    switch (CURRENT_TERMINAL) {
      case lex_extern:
	{
	    ZR1067 (ZI418, ZI693, &ZI435);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_export: case lex_template:
	{
	    ZR1077 (ZI418, ZI693, &ZI435);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
      case lex_statement_Hname: case lex_destructor_Hname: case lex_template_Hid:
      case lex_template_Htype: case lex_nested_Hname: case lex_full_Hname:
      case lex_nested_Hname_Hstar: case lex_full_Hname_Hstar: case lex_and_H1:
      case lex_open_Hround: case lex_semicolon: case lex_star:
      case lex_colon_Hcolon: case lex_operator:
	{
	    BASE_TYPE ZI515;
	    TYPE ZI880;
	    CV_SPEC ZI1258;

	    {
 (ZI515) = btype_none; 
	    }
	    {

    (ZI880) = NULL_type;
	    }
	    {
 (ZI1258) = cv_none; 
	    }
	    ZR1259 (&ZI418, &ZI693, &ZI515, &ZI880, &ZI1258, &ZI435);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_asm: case lex_namespace: case lex_using:
	{
	    {

    if (!IS_NULL_type ((ZI418))) report (crt_loc, ERR_temp_decl_bad ());
    UNUSED ((ZI693));
	    }
	    ZR1082 (&ZI435);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR1007 (IDENTIFIER ZI463, SID_LIST_EXP *ZO501)
{
    SID_LIST_EXP ZI501;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	EXP ZI435;
	SID_LIST_EXP ZI484;

	ZR653 (&ZI435);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    if (crt_access_list.pending) {
	IGNORE report_access ((ZI463));
    }
	}
	{
	    switch (CURRENT_TERMINAL) {
	      case lex_comma:
		{
		    ADVANCE_LEXER;
		    ZR1007 (ZI463, &ZI484);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		}
		break;
	      default:
		{
		    {

    (ZI484) = NULL_list (EXP);
		    }
		}
		break;
	    }
	}
	{

    CONS_exp ((ZI435), (ZI484), (ZI501));
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO501 = ZI501;
}

void
ZR780 (EXP *ZO435)
{
    EXP ZI435;

    switch (CURRENT_TERMINAL) {
      case lex_reachable:
	{
	    EXP ZI497;

	    ADVANCE_LEXER;
	    {
 unreached_code = 0; 
	    }
	    ZR665 (&ZI497);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI435) = make_reach_stmt ((ZI497), 1);
	    }
	}
	break;
      case lex_unreachable:
	{
	    EXP ZI497;

	    ADVANCE_LEXER;
	    {
 unreached_code = 1; 
	    }
	    ZR665 (&ZI497);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI435) = make_reach_stmt ((ZI497), 0);
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR507 (IDENTIFIER *ZO423)
{
    IDENTIFIER ZI423;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	NAMESPACE ZI429;
	IDENTIFIER ZI464;

	switch (CURRENT_TERMINAL) {
	  case lex_full_Hname:
	    {

    ZI429 = crt_token->pp_data.ns;
	    }
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	{
	    switch (CURRENT_TERMINAL) {
	      case lex_template_Htype:
		{
		    {

    IDENTIFIER id = crt_token->pp_data.tok.id;
    PPTOKEN *args = crt_token->pp_data.tok.args;
    ZI464 = parse_type_template (id, args, 0);
    crt_templ_qualifier = 1;
    RESCAN_LEXER;
		    }
		    ADVANCE_LEXER;
		}
		break;
	      case lex_type_Hname:
		{
		    {

    ZI464 = crt_token->pp_data.id.use;
		    }
		    ADVANCE_LEXER;
		}
		break;
	      default:
		goto ZL1;
	    }
	}
	{

    crt_id_qualifier = qual_full;
    qual_namespace = (ZI429);
	}
	{

    (ZI423) = check_id ((ZI429), (ZI464), 0);
    last_namespace = (ZI429);
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO423 = ZI423;
}

void
ZR1024 (EXP ZI562, EXP *ZO435, EXP *ZO463)
{
    EXP ZI435;
    EXP ZI463;

    switch (CURRENT_TERMINAL) {
      case lex_colon:
	{
	    NAMESPACE ZI516;
	    int ZI460;

	    ADVANCE_LEXER;
	    {

    (ZI516) = ctor_begin ();
	    }
	    {
		switch (CURRENT_TERMINAL) {
		  case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
		  case lex_statement_Hname: case lex_template_Htype: case lex_nested_Hname:
		  case lex_full_Hname: case lex_open_Hround: case lex_colon_Hcolon:
		    {
			ZR1022 (ZI516);
			if ((CURRENT_TERMINAL) == 358) {
			    RESTORE_LEXER;
			    goto ZL1;
			}
			{
 (ZI460) = 1; 
			}
		    }
		    break;
		  default:
		    {
			{
 (ZI460) = 0; 
			}
		    }
		    break;
		}
	    }
	    {

    (ZI435) = ctor_end ((ZI516), (ZI562), (ZI460));
	    }
	    {

    (ZI463) = NULL_exp;
	    }
	}
	break;
      default:
	{
	    {

    (ZI463) = NULL_exp;
    (ZI435) = ctor_none ((ZI562), &(ZI463));
	    }
	}
	break;
      case 358:
	return;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
    *ZO463 = ZI463;
}

void
ZR1289 (EXP *ZO435)
{
    EXP ZI435;

    switch (CURRENT_TERMINAL) {
      case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
      case lex_destructor_Hname: case lex_template_Hid: case lex_template_Htype:
      case lex_operator: case lex_template:
	{
	    ZR1273 (&ZI435);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_delete: case lex_new:
	{
	    int ZI460;

	    {
 (ZI460) = 1; 
	    }
	    ZR1435 (&ZI460, &ZI435);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR476 (IDENTIFIER *ZO423)
{
    IDENTIFIER ZI423;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	IDENTIFIER ZI464;

	{
	    switch (CURRENT_TERMINAL) {
	      case lex_template_Htype:
		{
		    {

    IDENTIFIER id = crt_token->pp_data.tok.id;
    PPTOKEN *args = crt_token->pp_data.tok.args;
    ZI464 = parse_type_template (id, args, 0);
    crt_templ_qualifier = 1;
    RESCAN_LEXER;
		    }
		    ADVANCE_LEXER;
		}
		break;
	      case lex_type_Hname:
		{
		    {

    ZI464 = crt_token->pp_data.id.use;
		    }
		    ADVANCE_LEXER;
		}
		break;
	      default:
		goto ZL1;
	    }
	}
	{

    (ZI423) = (ZI464);
    crt_id_qualifier = qual_none;
    last_namespace = crt_namespace;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO423 = ZI423;
}

void
ZR765 (int ZI558, IDENTIFIER *ZO463)
{
    IDENTIFIER ZI463;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	TYPE ZI578;
	BASE_TYPE ZI879;
	TYPE ZI1602;
	CV_SPEC ZI1603;
	BASE_TYPE ZI515;
	TYPE ZI880;
	CV_SPEC ZI881;
	DECL_SPEC ZI914;
	TYPE ZI884;
	DECL_SPEC ZI916;
	TYPE ZI418;
	IDENTIFIER ZI423;
	int ZI561;

	{

    /* Resolve type-specifiers from other declarators */
    (ZI0) = predict_tspec (0);
	}
	if (!ZI0)
	    goto ZL2;
	{

    (ZI578) = NULL_type;
	}
	ZR877 (ZI578, &ZI879, &ZI1602, &ZI1603);
	ZR890 (&ZI879, &ZI1602, &ZI1603, &ZI515, &ZI880, &ZI881);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{
 (ZI914) = dspec_none; 
	}
	{

    /* Complete a declaration specifier and a type */
    (ZI916) = complete_dspec ((ZI914), (ZI515), (ZI880), (ZI881));
    (ZI884) = complete_pre_type ((ZI515), (ZI880), (ZI881), 0);
    have_type_specifier = 0;
	}
	{

    crt_templ_qualifier = 0;
	}
	ZR966 (ZI884, &ZI418, &ZI423);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI561) = no_type_defns - (ZI558);
	}
	{

    (ZI463) = make_except_decl ((ZI916), (ZI418), (ZI423), (ZI561));
    have_type_declaration = TYPE_DECL_NONE;
    have_func_declarator = 0;
	}
	goto ZL0;
    }
    /*UNREACHED*/
  ZL2:;
    switch (CURRENT_TERMINAL) {
      case lex_ellipsis: case lex_ellipsis_Hexp:
	{
	    {
		switch (CURRENT_TERMINAL) {
		  case lex_ellipsis:
		    {
			ADVANCE_LEXER;
		    }
		    break;
		  case lex_ellipsis_Hexp:
		    {
			ADVANCE_LEXER;
		    }
		    break;
		  default:
		    goto ZL1;
		}
	    }
	    {

    (ZI463) = NULL_id;
	    }
	}
	break;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO463 = ZI463;
}

void
ZR822 (BASE_TYPE *ZO821)
{
    BASE_TYPE ZI821;

    switch (CURRENT_TERMINAL) {
      case lex_class:
	{
	    ADVANCE_LEXER;
	    {
 (ZI821) = btype_class; 
	    }
	}
	break;
      case lex_struct:
	{
	    ADVANCE_LEXER;
	    {
 (ZI821) = btype_struct; 
	    }
	}
	break;
      case lex_union:
	{
	    ADVANCE_LEXER;
	    {
 (ZI821) = btype_union; 
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO821 = ZI821;
}

void
ZR1004 (IDENTIFIER ZI463, SID_LIST_EXP *ZO501)
{
    SID_LIST_EXP ZI501;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	EXP ZI460;
	EXP ZI497;
	SID_LIST_EXP ZI484;

	ZR1003 (ZI463, &ZI460);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    MAKE_exp_location (type_void, crt_loc, (ZI460), (ZI497));
	}
	{
	    switch (CURRENT_TERMINAL) {
	      case lex_comma:
		{
		    ADVANCE_LEXER;
		    ZR1006 (&ZI463, &ZI484);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		}
		break;
	      default:
		{
		    {

    (ZI484) = NULL_list (EXP);
		    }
		}
		break;
	    }
	}
	{

    CONS_exp ((ZI497), (ZI484), (ZI501));
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO501 = ZI501;
}

void
ZR839 (EXP *ZO1171)
{
    EXP ZI1171;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	EXP ZI562;
	EXP ZI501;

	switch (CURRENT_TERMINAL) {
	  case lex_hash_Hif:
	    {

    ZI562 = crt_token->pp_data.exp;
	    }
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	{

    EXP c = crt_hash_cond;
    crt_hash_cond = make_if_cond ((ZI562), c);
    (ZI501) = c;
	}
	{

    target_decl (lex_if, (ZI562));
	}
	ZR838 ();
	ZR1172 (ZI501, &ZI1171);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO1171 = ZI1171;
}

void
parse_tok_type (TYPE *ZO418)
{
    TYPE ZI418;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	BASE_TYPE ZI515;
	TYPE ZI501;
	CV_SPEC ZI788;
	TYPE ZI484;

	ZR878 (&ZI515, &ZI501, &ZI788);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI484) = complete_pre_type ((ZI515), (ZI501), (ZI788), 1);
    have_type_specifier = 0;
	}
	ZR960 (ZI484, &ZI418);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO418 = ZI418;
}

void
ZR1291 (EXP *ZO435)
{
    EXP ZI435;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	TYPE ZI418;
	int ZI555;
	EXP ZI497;

	{

    /* Resolve type-ids from expressions */
    (ZI0) = predict_typeid (0);
	}
	if (!ZI0)
	    goto ZL2;
	ZR552 (&ZI418, &ZI555);
	switch (CURRENT_TERMINAL) {
	  case lex_close_Hround:
	    break;
	  case 358:
	    RESTORE_LEXER;
	    goto ZL1;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	ZR585 (&ZI497);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    /* n is the number of type definitions in t */
    (ZI435) = make_cast_exp ((ZI418), (ZI497), (ZI555));
	}
	goto ZL0;
    }
    /*UNREACHED*/
  ZL2:;
    switch (CURRENT_TERMINAL) {
      case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
      case lex_destructor_Hname: case lex_template_Hid: case lex_template_Htype:
      case lex_nested_Hname: case lex_full_Hname: case lex_char_Hexp:
      case lex_wchar_Hexp: case lex_string_Hexp: case lex_wstring_Hexp:
      case lex_integer_Hexp: case lex_floating_Hexp: case lex_complex_Hexp:
      case lex_complex_Htype: case lex_and_H1: case lex_compl_H1:
      case lex_minus: case lex_minus_Hminus: case lex_not_H1:
      case lex_open_Hround: case lex_plus: case lex_plus_Hplus:
      case lex_star: case lex_colon_Hcolon: case lex_abs:
      case lex_char: case lex_double: case lex_float:
      case lex_int: case lex_long: case lex_short:
      case lex_signed: case lex_sizeof: case lex_unsigned:
      case lex_void: case lex_bool: case lex_const_Hcast:
      case lex_delete: case lex_dynamic_Hcast: case lex_false:
      case lex_new: case lex_operator: case lex_reinterpret_Hcast:
      case lex_static_Hcast: case lex_this: case lex_throw:
      case lex_true: case lex_typeid: case lex_wchar_Ht:
      case lex_alignof: case lex_bottom: case lex_discard:
      case lex_ellipsis_Hexp: case lex_ptrdiff_Ht: case lex_set:
      case lex_size_Ht: case lex_unused: case lex_vtable:
      case lex_inset_Hstart:
	{
	    EXP ZI497;
	    EXP ZI1283;

	    {

    IGNORE incr_value (OPT_VAL_paren_depth);
	    }
	    ZR495 (&ZI497);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI1283) = make_paren_exp ((ZI497));
    decr_value (OPT_VAL_paren_depth);
	    }
	    switch (CURRENT_TERMINAL) {
	      case lex_close_Hround:
		break;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    ZR1245 (ZI1283, &ZI435);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR620 (void)
{
    switch (CURRENT_TERMINAL) {
      case lex_eq:
	{
	    ADVANCE_LEXER;
	}
	break;
      case lex_not_Heq_H1:
	{
	    {
		{
		    switch (CURRENT_TERMINAL) {
		      case lex_not_Heq_H1:
			break;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		}
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    return;
  ZL1:;
    SAVE_LEXER (358);
    return;
}

void
ZR624 (EXP *ZO1216)
{
    EXP ZI1216;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	EXP ZI435;

	ZR621 (&ZI435);
	ZR1217 (ZI435, &ZI1216);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO1216 = ZI1216;
}

void
ZR1021 (NAMESPACE ZI516)
{
    switch (CURRENT_TERMINAL) {
      case lex_open_Hround:
	{
	    SID_LIST_EXP ZI501;
	    EXP ZI435;
	    IDENTIFIER ZI423;

	    ADVANCE_LEXER;
	    ZR504 (&ZI501);
	    switch (CURRENT_TERMINAL) {
	      case lex_close_Hround:
		break;
	      case 358:
		RESTORE_LEXER;
		goto ZL1;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    {

    MAKE_exp_initialiser (type_void, (ZI501), NULL_list (OFFSET), 0, 0, 0, (ZI435));
	    }
	    {

    (ZI423) = NULL_id;
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
	    }
	    {

    ctor_initialise ((ZI516), (ZI423), (ZI435));
	    }
	}
	break;
      case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
      case lex_statement_Hname: case lex_template_Htype: case lex_nested_Hname:
      case lex_full_Hname: case lex_colon_Hcolon:
	{
	    NAMESPACE ZI429;
	    IDENTIFIER ZI825;
	    IDENTIFIER ZI423;
	    QUALIFIER ZI459;
	    int ZI460;
	    SID_LIST_EXP ZI501;
	    EXP ZI435;

	    ZR432 (&ZI429);
	    ZR512 (&ZI825);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI423) = check_id ((ZI429), (ZI825), 0);
    last_namespace = (ZI429);
	    }
	    {

    (ZI459) = crt_id_qualifier;
    (ZI460) = crt_templ_qualifier;
	    }
	    switch (CURRENT_TERMINAL) {
	      case lex_open_Hround:
		break;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    ZR504 (&ZI501);
	    switch (CURRENT_TERMINAL) {
	      case lex_close_Hround:
		break;
	      case 358:
		RESTORE_LEXER;
		goto ZL1;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    {

    crt_id_qualifier = (ZI459);
    crt_templ_qualifier = (ZI460);
	    }
	    {

    MAKE_exp_initialiser (type_void, (ZI501), NULL_list (OFFSET), 0, 0, 0, (ZI435));
	    }
	    {

    ctor_initialise ((ZI516), (ZI423), (ZI435));
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    return;
  ZL1:;
    SAVE_LEXER (358);
    return;
}

void
ZR648 (EXP *ZO435)
{
    EXP ZI435;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	switch (CURRENT_TERMINAL) {
	  case lex_inset_Hstart:
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	ZR1296 (&ZI435);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR1166 (TYPE ZI1162, IDENTIFIER ZI1163, TYPE *ZO1164, IDENTIFIER *ZO1165)
{
    TYPE ZI1164;
    IDENTIFIER ZI1165;

  ZL2_1166:;
    switch (CURRENT_TERMINAL) {
      case lex_open_Hround: case lex_open_Hsquare_H1: case lex_weak:
	{
	    IDENTIFIER ZI423;
	    QUALIFIER ZI459;
	    int ZI460;
	    TYPE ZI484;
	    TYPE ZI418;

	    ZI423 = ZI1163;
	    {

    (ZI459) = crt_id_qualifier;
    (ZI460) = crt_templ_qualifier;
	    }
	    ZR957 (&ZI484);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    crt_id_qualifier = (ZI459);
    crt_templ_qualifier = (ZI460);
	    }
	    {

    (ZI418) = (IS_NULL_type ((ZI1162)) ? (ZI484): inject_pre_type ((ZI1162), (ZI484), 0));
	    }
	    ZI1162 = ZI418;
	    ZI1163 = ZI423;
	    goto ZL2_1166;
	}
	/*UNREACHED*/
      default:
	{
	    ZI1164 = ZI1162;
	    ZI1165 = ZI1163;
	}
	break;
      case 358:
	return;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO1164 = ZI1164;
    *ZO1165 = ZI1165;
}

void
ZR1294 (EXP *ZI1292, EXP *ZO435)
{
    EXP ZI435;

    switch (CURRENT_TERMINAL) {
      case lex_comma:
	{
	    SID_LIST_EXP ZI484;
	    SID_LIST_EXP ZI501;

	    ADVANCE_LEXER;
	    ZR652 (&ZI484);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    CONS_exp ((*ZI1292), (ZI484), (ZI501));
	    }
	    {

    (ZI435) = make_comma_exp ((ZI501));
	    }
	}
	break;
      default:
	{
	    ZI435 = *ZI1292;
	}
	break;
      case 358:
	return;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR587 (int *ZO454)
{
    int ZI454;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	switch (CURRENT_TERMINAL) {
	  case lex_delete:
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	ZR1436 (&ZI454);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO454 = ZI454;
}

void
parse_type_param (IDENTIFIER *ZO463)
{
    IDENTIFIER ZI463;

    switch (CURRENT_TERMINAL) {
      case lex_template:
	{
	    int ZI435;
	    TOKEN ZI501;
	    TYPE ZI418;
	    DECL_SPEC ZI693;
	    TYPE ZI880;
	    IDENTIFIER ZI423;
	    IDENTIFIER ZI464;

	    ADVANCE_LEXER;
	    {
 (ZI435) = 0; 
	    }
	    {

    (ZI501) = template_params ((ZI435));
    RESCAN_LEXER;
	    }
	    {

    (ZI418) = NULL_type;
	    }
	    {
 (ZI693) = dspec_none; 
	    }
	    {

    (ZI880) = make_template_type ((ZI501), (ZI418));
	    }
	    switch (CURRENT_TERMINAL) {
	      case lex_class:
		break;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    ZR1120 (&ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI463) = make_template_param ((ZI880), (ZI423));
    UNUSED ((ZI693));
	    }
	    {
		switch (CURRENT_TERMINAL) {
		  case lex_assign:
		    {
			IDENTIFIER ZI825;

			ADVANCE_LEXER;
			{

    in_default_arg++;
			}
			ZR488 (&ZI825);
			if ((CURRENT_TERMINAL) == 358) {
			    RESTORE_LEXER;
			    goto ZL1;
			}
			{

    (ZI464) = (ZI825);
    crt_id_qualifier = qual_none;
    last_namespace = crt_namespace;
			}
			{

    in_default_arg--;
			}
		    }
		    break;
		  default:
		    {
			{

    (ZI464) = NULL_id;
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
			}
		    }
		    break;
		}
	    }
	    {

    init_template_param ((ZI463), (ZI464));
	    }
	    {

    end_template ((ZI501));
	    }
	    {

    RESCAN_LEXER;
	    }
	}
	break;
      case lex_class: case lex_typename:
	{
	    IDENTIFIER ZI423;
	    TYPE ZI418;

	    {
		switch (CURRENT_TERMINAL) {
		  case lex_class:
		    {
			ADVANCE_LEXER;
		    }
		    break;
		  case lex_typename:
		    {
			ADVANCE_LEXER;
		    }
		    break;
		  default:
		    goto ZL1;
		}
	    }
	    ZR1120 (&ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI463) = make_type_param ((ZI423));
	    }
	    {
		switch (CURRENT_TERMINAL) {
		  case lex_assign:
		    {
			ADVANCE_LEXER;
			{

    in_default_arg++;
			}
			parse_tok_type (&ZI418);
			if ((CURRENT_TERMINAL) == 358) {
			    RESTORE_LEXER;
			    goto ZL1;
			}
			{

    in_default_arg--;
			}
			{

    object_type ((ZI418), null_tag);
			}
		    }
		    break;
		  default:
		    {
			{

    (ZI418) = NULL_type;
			}
		    }
		    break;
		}
	    }
	    {

    init_type_param ((ZI463), (ZI418));
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    {
	{

    /* Syntax errors */
    ERROR err = ERR_lex_parse (crt_token);
    report (crt_loc, err);
    have_syntax_error = 1;
	}
	{

    (ZI463) = NULL_id;
	}
    }
  ZL0:;
    *ZO463 = ZI463;
}

void
ZR1295 (EXP *ZI497, SID_LIST_EXP *ZO501)
{
    SID_LIST_EXP ZI501;

    switch (CURRENT_TERMINAL) {
      case lex_comma:
	{
	    SID_LIST_EXP ZI484;

	    ADVANCE_LEXER;
	    ZR652 (&ZI484);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    CONS_exp ((*ZI497), (ZI484), (ZI501));
	    }
	}
	break;
      default:
	{
	    SID_LIST_EXP ZI484;

	    {

    (ZI484) = NULL_list (EXP);
	    }
	    {

    CONS_exp ((*ZI497), (ZI484), (ZI501));
	    }
	}
	break;
      case 358:
	return;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO501 = ZI501;
}

void
ZR837 (TYPE ZI418, DECL_SPEC ZI693)
{
    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
  ZL2_837:;
    {
	BASE_TYPE ZI1340;
	TYPE ZI1341;
	CV_SPEC ZI1342;
	DECL_SPEC ZI1343;
	BASE_TYPE ZI515;
	TYPE ZI880;
	CV_SPEC ZI881;
	DECL_SPEC ZI914;
	DECL_SPEC ZI916;

	{

    /* Resolve declaration-specifiers from other declarators */
    (ZI0) = predict_dspec (0);
	}
	if (!ZI0)
	    goto ZL3;
	ZR911 (ZI418, &ZI1340, &ZI1341, &ZI1342, &ZI1343);
	ZR922 (&ZI418, &ZI1340, &ZI1341, &ZI1342, &ZI1343, &ZI515, &ZI880, &ZI881, &ZI914);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    /* Combine two declaration specifiers */
    DECL_SPEC d = (((ZI693) & (ZI914)) & dspec_duplicate);
    if (d) report (crt_loc, ERR_dcl_spec_dup (d));
    (ZI916) = ((ZI693) | (ZI914));
	}
	ZR1344 (&ZI418, &ZI515, &ZI880, &ZI881, &ZI916);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	} else {
	    goto ZL2_837;
	}
    }
    /*UNREACHED*/
  ZL3:;
    switch (CURRENT_TERMINAL) {
      case lex_private: case lex_protected: case lex_public:
	{
	    DECL_SPEC ZI460;

	    ZR832 (&ZI460);
	    switch (CURRENT_TERMINAL) {
	      case lex_colon:
		break;
	      case 358:
		RESTORE_LEXER;
		goto ZL1;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    {
 crt_access = (ZI460); 
	    }
	    goto ZL2_837;
	}
	/*UNREACHED*/
      case lex_export: case lex_template:
	{
	    ZR1094 (ZI418, ZI693);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    } else {
		goto ZL2_837;
	    }
	}
	/*UNREACHED*/
      case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
      case lex_statement_Hname: case lex_destructor_Hname: case lex_template_Hid:
      case lex_template_Htype: case lex_nested_Hname: case lex_full_Hname:
      case lex_nested_Hname_Hstar: case lex_full_Hname_Hstar: case lex_and_H1:
      case lex_colon: case lex_open_Hround: case lex_star:
      case lex_colon_Hcolon: case lex_operator:
	{
	    BASE_TYPE ZI515;
	    TYPE ZI880;
	    CV_SPEC ZI881;
	    DECL_SPEC ZI914;
	    DECL_SPEC ZI916;
	    TYPE ZI884;
	    DECL_SPEC ZI1078;
	    TYPE ZI1079;
	    ACCESS_LIST ZI674;
	    int ZI724;
	    IDENTIFIER ZI463;

	    {
 (ZI515) = btype_none; 
	    }
	    {

    (ZI880) = NULL_type;
	    }
	    {
 (ZI881) = cv_none; 
	    }
	    {
 (ZI914) = dspec_none; 
	    }
	    {

    /* Combine two declaration specifiers */
    DECL_SPEC d = (((ZI693) & (ZI914)) & dspec_duplicate);
    if (d) report (crt_loc, ERR_dcl_spec_dup (d));
    (ZI916) = ((ZI693) | (ZI914));
	    }
	    {

    /* Complete a declaration specifier and a type */
    (ZI1078) = complete_dspec ((ZI916), (ZI515), (ZI880), (ZI881));
    (ZI884) = complete_pre_type ((ZI515), (ZI880), (ZI881), 0);
    have_type_specifier = 0;
	    }
	    {

    (ZI1079) = (IS_NULL_type ((ZI418)) ? (ZI884): inject_pre_type ((ZI418), (ZI884), 1));
	    }
	    {

    save_access (&(ZI674));
	    }
	    {
 (ZI724) = 1; 
	    }
	    {

    crt_templ_qualifier = 0;
	    }
	    ZR1089 (ZI1078, ZI1079, ZI515, ZI674, ZI724, &ZI463);
	    ZR1097 (&ZI515, &ZI1078, &ZI1079, &ZI674, &ZI463);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    } else {
		goto ZL2_837;
	    }
	}
	/*UNREACHED*/
      case lex_hash_Hif: case lex_using:
	{
	    {

    if (!IS_NULL_type ((ZI418))) report (crt_loc, ERR_temp_decl_bad ());
    UNUSED ((ZI693));
	    }
	    ZR1345 ();
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    } else {
		goto ZL2_837;
	    }
	}
	/*UNREACHED*/
      case lex_semicolon:
	{
	    TYPE ZI880;
	    BASE_TYPE ZI515;
	    CV_SPEC ZI881;

	    {

    (ZI880) = NULL_type;
	    }
	    {
 (ZI515) = btype_none; 
	    }
	    {
 (ZI881) = cv_none; 
	    }
	    {

    IGNORE empty_decl ((ZI693), (ZI418), (ZI515), (ZI880), (ZI881), last_lex_token, 1);
    have_type_declaration = TYPE_DECL_NONE;
    have_func_declarator = 0;
    have_type_specifier = 0;
	    }
	    ADVANCE_LEXER;
	    goto ZL2_837;
	}
	/*UNREACHED*/
      default:
	break;
    }
    return;
  ZL1:;
    SAVE_LEXER (358);
    return;
}

void
ZR1296 (EXP *ZO435)
{
    EXP ZI435;

    switch (CURRENT_TERMINAL) {
      case lex_set:
	{
	    EXP ZI497;

	    ADVANCE_LEXER;
	    ZR495 (&ZI497);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI435) = make_set_exp ((ZI497));
	    }
	    switch (CURRENT_TERMINAL) {
	      case lex_inset_Hend:
		break;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	}
	break;
      case lex_unused:
	{
	    EXP ZI497;

	    ADVANCE_LEXER;
	    ZR495 (&ZI497);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI435) = make_unused_exp ((ZI497));
	    }
	    switch (CURRENT_TERMINAL) {
	      case lex_inset_Hend:
		break;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR417 (void)
{
    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	switch (CURRENT_TERMINAL) {
	  case lex_close_Hround:
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
    }
    return;
  ZL1:;
    {
	int ZI418;

	{
 (ZI418) = lex_close_Hround; 
	}
	{

    /* Expected symbol */
    int p = primary_form (crt_lex_token);
    if (p != (ZI418)) report (crt_loc, ERR_lex_expect ((ZI418)));
	}
    }
}

void
ZR557 (int ZI454, EXP *ZO435)
{
    EXP ZI435;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	int ZI558;
	int ZI559;
	EXP ZI562;

	{

    suppress_usage++;
	}
	{

    (ZI558) = no_side_effects;
	}
	{

    (ZI559) = no_type_defns;
	}
	switch (CURRENT_TERMINAL) {
	  case lex_open_Hround:
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	{
	    {
		TYPE ZI418;
		int ZI563;

		{

    /* Resolve type-ids from expressions */
    (ZI0) = predict_typeid (1);
		}
		if (!ZI0)
		    goto ZL3;
		ZR552 (&ZI418, &ZI563);
		switch (CURRENT_TERMINAL) {
		  case lex_close_Hround:
		    break;
		  case 358:
		    RESTORE_LEXER;
		    goto ZL1;
		  default:
		    goto ZL1;
		}
		ADVANCE_LEXER;
		{

    (ZI562) = make_typeid_type ((ZI454), (ZI418), (ZI563));
		}
		goto ZL2;
	    }
	    /*UNREACHED*/
	  ZL3:;
	    switch (CURRENT_TERMINAL) {
	      case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
	      case lex_destructor_Hname: case lex_template_Hid: case lex_template_Htype:
	      case lex_nested_Hname: case lex_full_Hname: case lex_char_Hexp:
	      case lex_wchar_Hexp: case lex_string_Hexp: case lex_wstring_Hexp:
	      case lex_integer_Hexp: case lex_floating_Hexp: case lex_complex_Hexp:
	      case lex_complex_Htype: case lex_and_H1: case lex_compl_H1:
	      case lex_minus: case lex_minus_Hminus: case lex_not_H1:
	      case lex_open_Hround: case lex_plus: case lex_plus_Hplus:
	      case lex_star: case lex_colon_Hcolon: case lex_abs:
	      case lex_char: case lex_double: case lex_float:
	      case lex_int: case lex_long: case lex_short:
	      case lex_signed: case lex_sizeof: case lex_unsigned:
	      case lex_void: case lex_bool: case lex_const_Hcast:
	      case lex_delete: case lex_dynamic_Hcast: case lex_false:
	      case lex_new: case lex_operator: case lex_reinterpret_Hcast:
	      case lex_static_Hcast: case lex_this: case lex_throw:
	      case lex_true: case lex_typeid: case lex_wchar_Ht:
	      case lex_alignof: case lex_bottom: case lex_discard:
	      case lex_ellipsis_Hexp: case lex_ptrdiff_Ht: case lex_set:
	      case lex_size_Ht: case lex_unused: case lex_vtable:
	      case lex_inset_Hstart:
		{
		    EXP ZI497;
		    int ZI561;

		    ZR495 (&ZI497);
		    switch (CURRENT_TERMINAL) {
		      case lex_close_Hround:
			break;
		      case 358:
			RESTORE_LEXER;
			goto ZL1;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI562) = make_typeid_exp ((ZI454), (ZI497), (ZI561));
		    }
		}
		break;
	      default:
		goto ZL1;
	    }
	  ZL2:;
	}
	{

    suppress_usage--;
	}
	ZI435 = ZI562;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR597 (int ZI454, EXP *ZO435)
{
    EXP ZI435;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	int ZI558;
	int ZI559;
	EXP ZI562;

	{

    suppress_usage++;
	}
	{

    (ZI558) = no_side_effects;
	}
	{

    (ZI559) = no_type_defns;
	}
	{
	    switch (CURRENT_TERMINAL) {
	      case lex_alignof:
		{
		    int ZI1419;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    {
 (ZI1419) = lex_alignof; 
		    }
		    ZR597 (ZI1419, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_colon_Hcolon:
		{
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    ZR1289 (&ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_complex_Hexp:
		{
		    EXP ZI1284;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    {

    IDENTIFIER id = crt_token->pp_data.tok.id;
    PPTOKEN *args = crt_token->pp_data.tok.args;
    ZI1284 = parse_exp_token (id, args);
    RESCAN_LEXER;
		    }
		    ADVANCE_LEXER;
		    ZR1245 (ZI1284, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_complex_Htype:
		{
		    TYPE ZI1270;
		    BASE_TYPE ZI515;
		    CV_SPEC ZI788;
		    TYPE ZI1433;
		    SID_LIST_EXP ZI501;
		    EXP ZI1287;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    {

    IDENTIFIER id = crt_token->pp_data.tok.id;
    PPTOKEN *args = crt_token->pp_data.tok.args;
    ZI1270 = parse_type_token (id, args);
    have_type_declaration = TYPE_DECL_NONE;
    have_type_specifier = 1;
    RESCAN_LEXER;
		    }
		    ADVANCE_LEXER;
		    {
 (ZI515) = btype_none; 
		    }
		    {
 (ZI788) = cv_none; 
		    }
		    {

    (ZI1433) = complete_pre_type ((ZI515), (ZI1270), (ZI788), 1);
    have_type_specifier = 0;
		    }
		    switch (CURRENT_TERMINAL) {
		      case lex_open_Hround:
			break;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		    ZR504 (&ZI501);
		    switch (CURRENT_TERMINAL) {
		      case lex_close_Hround:
			break;
		      case 358:
			RESTORE_LEXER;
			goto ZL1;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		    {

    (ZI1287) = make_func_cast_exp ((ZI1433), (ZI501));
		    }
		    ZR1245 (ZI1287, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_const_Hcast:
		{
		    TYPE ZI1422;
		    EXP ZI1423;
		    int ZI555;
		    EXP ZI1276;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    ZR556 (&ZI1422, &ZI1423, &ZI555);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    /* n is the number of type definitions in t */
    (ZI1276) = make_const_cast_exp ((ZI1422), (ZI1423), (ZI555));
		    }
		    ZR1245 (ZI1276, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_dynamic_Hcast:
		{
		    TYPE ZI1428;
		    EXP ZI1429;
		    int ZI555;
		    EXP ZI1279;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    ZR556 (&ZI1428, &ZI1429, &ZI555);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    /* n is the number of type definitions in t */
    (ZI1279) = make_dynamic_cast_exp ((ZI1428), (ZI1429), (ZI555));
		    }
		    ZR1245 (ZI1279, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_ellipsis_Hexp:
		{
		    EXP ZI1282;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    {

    (ZI1282) = make_ellipsis_exp ();
		    }
		    ZR1245 (ZI1282, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_full_Hname:
		{
		    NAMESPACE ZI429;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    {

    ZI429 = crt_token->pp_data.ns;
		    }
		    ADVANCE_LEXER;
		    ZR1272 (&ZI429, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_minus_Hminus:
		{
		    EXP ZI1412;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    ZR585 (&ZI1412);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI497) = make_prefix_exp (lex_minus_Hminus, (ZI1412));
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_nested_Hname:
		{
		    NAMESPACE ZI429;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    {

    ZI429 = crt_token->pp_data.ns;
		    }
		    ADVANCE_LEXER;
		    ZR1271 (&ZI429, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_open_Hround:
		{
		    ADVANCE_LEXER;
		    ZR1434 (&ZI454, &ZI558, &ZI559, &ZI562);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		}
		break;
	      case lex_plus_Hplus:
		{
		    EXP ZI1411;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    ZR585 (&ZI1411);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI497) = make_prefix_exp (lex_plus_Hplus, (ZI1411));
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_reinterpret_Hcast:
		{
		    TYPE ZI1424;
		    EXP ZI1425;
		    int ZI555;
		    EXP ZI1277;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    ZR556 (&ZI1424, &ZI1425, &ZI555);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    /* n is the number of type definitions in t */
    (ZI1277) = make_reinterp_cast_exp ((ZI1424), (ZI1425), (ZI555));
		    }
		    ZR1245 (ZI1277, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_sizeof:
		{
		    int ZI1418;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    {
 (ZI1418) = lex_sizeof; 
		    }
		    ZR597 (ZI1418, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_star:
		{
		    EXP ZI1413;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    ZR585 (&ZI1413);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI497) = make_indir_exp ((ZI1413));
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_static_Hcast:
		{
		    TYPE ZI1426;
		    EXP ZI1427;
		    int ZI555;
		    EXP ZI1278;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    ZR556 (&ZI1426, &ZI1427, &ZI555);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI1278) = make_static_cast_exp ((ZI1426), (ZI1427), (ZI555));
		    }
		    ZR1245 (ZI1278, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_this:
		{
		    EXP ZI1281;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    {

    (ZI1281) = make_this_exp ();
		    }
		    ZR1245 (ZI1281, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_typeid:
		{
		    int ZI1421;
		    EXP ZI1275;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    {
 (ZI1421) = lex_typeid; 
		    }
		    ZR557 (ZI1421, &ZI1275);
		    ZR1245 (ZI1275, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_vtable:
		{
		    int ZI1420;
		    EXP ZI1274;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ADVANCE_LEXER;
		    {
 (ZI1420) = lex_vtable; 
		    }
		    ZR557 (ZI1420, &ZI1274);
		    ZR1245 (ZI1274, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_and_H1:
		{
		    EXP ZI1414;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    {
			{
			    switch (CURRENT_TERMINAL) {
			      case lex_and_H1:
				break;
			      default:
				goto ZL1;
			    }
			    ADVANCE_LEXER;
			}
		    }
		    ZR585 (&ZI1414);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI497) = make_ref_exp ((ZI1414), 0);
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_char: case lex_double: case lex_float:
	      case lex_int: case lex_long: case lex_short:
	      case lex_signed: case lex_unsigned: case lex_void:
	      case lex_bool: case lex_wchar_Ht: case lex_bottom:
	      case lex_ptrdiff_Ht: case lex_size_Ht:
		{
		    BASE_TYPE ZI515;
		    TYPE ZI1270;
		    CV_SPEC ZI788;
		    TYPE ZI1431;
		    SID_LIST_EXP ZI501;
		    EXP ZI1285;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ZR513 (&ZI515);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI1270) = NULL_type;
    have_type_specifier = 1;
		    }
		    {
 (ZI788) = cv_none; 
		    }
		    {

    (ZI1431) = complete_pre_type ((ZI515), (ZI1270), (ZI788), 1);
    have_type_specifier = 0;
		    }
		    switch (CURRENT_TERMINAL) {
		      case lex_open_Hround:
			break;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		    ZR504 (&ZI501);
		    switch (CURRENT_TERMINAL) {
		      case lex_close_Hround:
			break;
		      case 358:
			RESTORE_LEXER;
			goto ZL1;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		    {

    (ZI1285) = make_func_cast_exp ((ZI1431), (ZI501));
		    }
		    ZR1245 (ZI1285, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_char_Hexp: case lex_wchar_Hexp: case lex_string_Hexp:
	      case lex_wstring_Hexp: case lex_integer_Hexp: case lex_floating_Hexp:
	      case lex_false: case lex_true:
		{
		    EXP ZI1280;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ZR441 (&ZI1280);
		    ZR1245 (ZI1280, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_not_H1:
		{
		    EXP ZI1415;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    {
			{
			    switch (CURRENT_TERMINAL) {
			      case lex_not_H1:
				break;
			      default:
				goto ZL1;
			    }
			    ADVANCE_LEXER;
			}
		    }
		    ZR585 (&ZI1415);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI497) = make_not_exp ((ZI1415));
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_identifier: case lex_namespace_Hname: case lex_destructor_Hname:
	      case lex_template_Hid: case lex_operator:
		{
		    IDENTIFIER ZI423;
		    EXP ZI1288;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ZR481 (&ZI423);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI1288) = make_id_exp ((ZI423));
		    }
		    ZR1245 (ZI1288, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_type_Hname: case lex_template_Htype:
		{
		    IDENTIFIER ZI423;
		    TYPE ZI1270;
		    BASE_TYPE ZI515;
		    CV_SPEC ZI788;
		    TYPE ZI1432;
		    SID_LIST_EXP ZI501;
		    EXP ZI1286;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    ZR476 (&ZI423);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    MAKE_type_pre (cv_none, btype_alias, crt_id_qualifier, (ZI1270));
    COPY_id (type_name ((ZI1270)), (ZI423));
    have_type_specifier = 1;
		    }
		    {
 (ZI515) = btype_none; 
		    }
		    {
 (ZI788) = cv_none; 
		    }
		    {

    (ZI1432) = complete_pre_type ((ZI515), (ZI1270), (ZI788), 1);
    have_type_specifier = 0;
		    }
		    switch (CURRENT_TERMINAL) {
		      case lex_open_Hround:
			break;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		    ZR504 (&ZI501);
		    switch (CURRENT_TERMINAL) {
		      case lex_close_Hround:
			break;
		      case 358:
			RESTORE_LEXER;
			goto ZL1;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		    {

    (ZI1286) = make_func_cast_exp ((ZI1432), (ZI501));
		    }
		    ZR1245 (ZI1286, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_delete: case lex_new:
		{
		    int ZI460;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    {
 (ZI460) = 0; 
		    }
		    ZR1435 (&ZI460, &ZI497);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      case lex_compl_H1: case lex_minus: case lex_plus:
	      case lex_abs:
		{
		    int ZI1416;
		    EXP ZI1417;
		    EXP ZI497;
		    int ZI561;
		    int ZI563;
		    TYPE ZI418;

		    {
 (ZI1416) = crt_lex_token; 
		    }
		    ZR600 ();
		    ZR585 (&ZI1417);
		    if ((CURRENT_TERMINAL) == 358) {
			RESTORE_LEXER;
			goto ZL1;
		    }
		    {

    (ZI497) = make_uminus_exp ((ZI1416), (ZI1417));
		    }
		    {

    (ZI561) = no_side_effects - (ZI558);
		    }
		    {

    (ZI563) = no_type_defns - (ZI559);
		    }
		    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (ZI454));
		    }
		    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (ZI454));
		    }
		}
		break;
	      default:
		goto ZL1;
	    }
	}
	{

    suppress_usage--;
	}
	ZI435 = ZI562;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR481 (IDENTIFIER *ZO423)
{
    IDENTIFIER ZI423;

    switch (CURRENT_TERMINAL) {
      case lex_destructor_Hname:
	{
	    IDENTIFIER ZI482;

	    {

    ZI482 = crt_token->pp_data.id.use;
	    }
	    ADVANCE_LEXER;
	    {

    (ZI423) = check_id (NULL_nspace, (ZI482), 0);
    crt_id_qualifier = qual_none;
    last_namespace = crt_namespace;
	    }
	}
	break;
      case lex_identifier:
	{
	    IDENTIFIER ZI482;

	    {

    ZI482 = crt_token->pp_data.id.use;
	    }
	    ADVANCE_LEXER;
	    {

    (ZI423) = (ZI482);
    crt_id_qualifier = qual_none;
    last_namespace = crt_namespace;
	    }
	}
	break;
      case lex_namespace_Hname:
	{
	    IDENTIFIER ZI482;

	    {

    ZI482 = crt_token->pp_data.id.use;
	    }
	    ADVANCE_LEXER;
	    {

    (ZI423) = (ZI482);
    crt_id_qualifier = qual_none;
    last_namespace = crt_namespace;
	    }
	}
	break;
      case lex_template_Hid:
	{
	    IDENTIFIER ZI482;

	    {

    IDENTIFIER id = crt_token->pp_data.tok.id;
    PPTOKEN *args = crt_token->pp_data.tok.args;
    ZI482 = parse_id_template (id, args, 0);
    crt_templ_qualifier = 1;
    RESCAN_LEXER;
	    }
	    ADVANCE_LEXER;
	    {

    (ZI423) = check_id (NULL_nspace, (ZI482), 0);
    crt_id_qualifier = qual_none;
    last_namespace = crt_namespace;
	    }
	}
	break;
      case lex_operator:
	{
	    IDENTIFIER ZI482;

	    parse_operator (&ZI482);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI423) = check_id (NULL_nspace, (ZI482), 0);
    crt_id_qualifier = qual_none;
    last_namespace = crt_namespace;
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO423 = ZI423;
}

void
ZR1172 (EXP ZI1170, EXP *ZO1171)
{
    EXP ZI1171;

  ZL2_1172:;
    switch (CURRENT_TERMINAL) {
      case lex_hash_Helif:
	{
	    EXP ZI501;
	    EXP ZI562;

	    ZI501 = ZI1170;
	    {

    ZI562 = crt_token->pp_data.exp;
	    }
	    ADVANCE_LEXER;
	    {

    EXP c = make_else_cond (crt_hash_cond);
    crt_hash_cond = make_if_cond ((ZI562), c);
	    }
	    {

    target_decl (lex_elif, (ZI562));
	    }
	    ZR838 ();
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    } else {
		ZI1170 = ZI501;
		goto ZL2_1172;
	    }
	}
	/*UNREACHED*/
      default:
	{
	    ZI1171 = ZI1170;
	}
	break;
      case 358:
	return;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO1171 = ZI1171;
}

void
ZR775 (EXP *ZO435)
{
    EXP ZI435;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	int ZI674;
	EXP ZI497;
	EXP ZI460;
	EXP ZI562;

	switch (CURRENT_TERMINAL) {
	  case lex_try:
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	{

    (ZI674) = unreached_code;
    if ((ZI674)) {
	if (!unreached_last) {
	    report (crt_loc, ERR_stmt_stmt_unreach ());
	    unreached_last = 1;
	}
    } else {
	unreached_last = 0;
    }
	}
	{

    (ZI497) = begin_try_stmt (0);
	}
	ZR682 (&ZI460);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI562) = cont_try_stmt ((ZI497), (ZI460));
	}
	ZR774 (ZI562);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{
 unreached_prev = (ZI674); 
	}
	{

    (ZI435) = end_try_stmt ((ZI562), 0);
	}
	{

    unreached_fall = 1;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR1077 (TYPE ZI418, DECL_SPEC ZI693, EXP *ZO435)
{
    EXP ZI435;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	int ZI718;
	TOKEN ZI501;
	TYPE ZI880;

	ZR1115 (&ZI718);
	switch (CURRENT_TERMINAL) {
	  case lex_template:
	    break;
	  case 358:
	    RESTORE_LEXER;
	    goto ZL1;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	{

    (ZI501) = template_params ((ZI718));
    RESCAN_LEXER;
	}
	{

    (ZI880) = make_template_type ((ZI501), (ZI418));
	}
	ZR1038 (ZI880, ZI693, &ZI435);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    end_template ((ZI501));
	}
	{

    RESCAN_LEXER;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR964 (TYPE *ZO418, IDENTIFIER *ZO423)
{
    TYPE ZI418;
    IDENTIFIER ZI423;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	IDENTIFIER ZI1377;
	TYPE ZI1378;

	{

    /* Resolve parameter declarators from type names */
    (ZI0) = predict_param ();
	}
	if (!ZI0)
	    goto ZL2;
	ZR947 (&ZI1377);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI1378) = NULL_type;
	}
	{

    IDENTIFIER pid = underlying_id ((ZI1377));
    DEREF_loc (id_loc (pid), decl_loc);
	}
	ZR1166 (ZI1378, ZI1377, &ZI418, &ZI423);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	goto ZL0;
    }
    /*UNREACHED*/
  ZL2:;
    switch (CURRENT_TERMINAL) {
      case lex_open_Hround:
	{
	    ADVANCE_LEXER;
	    ZR1376 (&ZI418, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_weak:
	{
	    IDENTIFIER ZI1375;
	    int ZI948;
	    TYPE ZI1381;
	    IDENTIFIER ZI1382;

	    ADVANCE_LEXER;
	    switch (CURRENT_TERMINAL) {
	      case lex_open_Hround:
		break;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    {

    (ZI1375) = NULL_id;
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
	    }
	    {
 (ZI948) = 1; 
	    }
	    {

    func_type_defn (0);
    begin_param ((ZI1375));
    have_type_declaration = TYPE_DECL_NONE;
    have_func_declarator = 0;
	    }
	    ZR949 (ZI948, &ZI1381);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    end_param ();
    have_type_declaration = TYPE_DECL_NONE;
    have_func_declarator = 1;
	    }
	    {

    HASHID nm = lookup_anon ();
    (ZI1382) = DEREF_id (hashid_id (nm));
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
	    }
	    {

    IDENTIFIER pid = underlying_id ((ZI1382));
    DEREF_loc (id_loc (pid), decl_loc);
	    }
	    ZR1166 (ZI1381, ZI1382, &ZI418, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_open_Hsquare_H1:
	{
	    EXP ZI435;
	    TYPE ZI1379;
	    IDENTIFIER ZI1380;

	    {
		{
		    switch (CURRENT_TERMINAL) {
		      case lex_open_Hsquare_H1:
			break;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		}
	    }
	    ZR958 (&ZI435);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    NAT n = make_array_dim ((ZI435));
    MAKE_type_array (cv_none, NULL_type, n, (ZI1379));
	    }
	    {
		{
		    switch (CURRENT_TERMINAL) {
		      case lex_close_Hsquare_H1:
			break;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		}
	    }
	    {

    HASHID nm = lookup_anon ();
    (ZI1380) = DEREF_id (hashid_id (nm));
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
	    }
	    {

    IDENTIFIER pid = underlying_id ((ZI1380));
    DEREF_loc (id_loc (pid), decl_loc);
	    }
	    ZR1166 (ZI1379, ZI1380, &ZI418, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_nested_Hname_Hstar: case lex_full_Hname_Hstar: case lex_and_H1:
      case lex_star:
	{
	    TYPE ZI501;
	    TYPE ZI484;

	    ZR931 (&ZI501);
	    ZR964 (&ZI484, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 0));
	    }
	}
	break;
      default:
	{
	    {

    (ZI418) = NULL_type;
	    }
	    {

    HASHID nm = lookup_anon ();
    (ZI423) = DEREF_id (hashid_id (nm));
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
	    }
	    {

    IDENTIFIER pid = underlying_id ((ZI423));
    DEREF_loc (id_loc (pid), decl_loc);
	    }
	}
	break;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO418 = ZI418;
    *ZO423 = ZI423;
}

void
ZR922 (TYPE *ZI578, BASE_TYPE *ZI879, TYPE *ZI880, CV_SPEC *ZI881, DECL_SPEC *ZI914, BASE_TYPE *ZO515, TYPE *ZO418, CV_SPEC *ZO788, DECL_SPEC *ZO693)
{
    BASE_TYPE ZI515;
    TYPE ZI418;
    CV_SPEC ZI788;
    DECL_SPEC ZI693;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	BASE_TYPE ZI1390;
	TYPE ZI1391;
	CV_SPEC ZI1392;
	DECL_SPEC ZI1393;
	BASE_TYPE ZI883;
	TYPE ZI884;
	CV_SPEC ZI885;
	DECL_SPEC ZI916;

	{

    /* Resolve declaration-specifiers from other declarators */
    (ZI0) = predict_dspec (0);
	}
	if (!ZI0)
	    goto ZL2;
	ZR911 (*ZI578, &ZI1390, &ZI1391, &ZI1392, &ZI1393);
	ZR922 (ZI578, &ZI1390, &ZI1391, &ZI1392, &ZI1393, &ZI883, &ZI884, &ZI885, &ZI916);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    if ((*ZI879) & (ZI883)) {
	(ZI515) = join_pre_types ((*ZI879), (ZI883));
    } else {
	(ZI515) = ((*ZI879) | (ZI883));
    }
	}
	{

    /* Join two partial types */
    if (IS_NULL_type ((*ZI880))) {
	(ZI418) = (ZI884);
    } else if (IS_NULL_type ((ZI884))) {
	(ZI418) = (*ZI880);
    } else {
	report (crt_loc, ERR_dcl_type_simple_many ((*ZI880), (ZI884)));
	(ZI418) = (ZI884);
    }
	}
	{

    CV_SPEC c = ((*ZI881) & (ZI885));
    if (c) report (crt_loc, ERR_dcl_type_cv_dup (c));
    (ZI788) = ((*ZI881) | (ZI885));
	}
	{

    /* Combine two declaration specifiers */
    DECL_SPEC d = (((*ZI914) & (ZI916)) & dspec_duplicate);
    if (d) report (crt_loc, ERR_dcl_spec_dup (d));
    (ZI693) = ((*ZI914) | (ZI916));
	}
	goto ZL0;
    }
    /*UNREACHED*/
  ZL2:;
    switch (CURRENT_TERMINAL) {
      default:
	{
	    ZI515 = *ZI879;
	    ZI418 = *ZI880;
	    ZI788 = *ZI881;
	    ZI693 = *ZI914;
	}
	break;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO515 = ZI515;
    *ZO418 = ZI418;
    *ZO788 = ZI788;
    *ZO693 = ZI693;
}

void
ZR966 (TYPE ZI501, TYPE *ZO418, IDENTIFIER *ZO423)
{
    TYPE ZI418;
    IDENTIFIER ZI423;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	IDENTIFIER ZI1377;
	TYPE ZI1378;
	TYPE ZI484;

	{

    /* Resolve parameter declarators from type names */
    (ZI0) = predict_param ();
	}
	if (!ZI0)
	    goto ZL2;
	ZR947 (&ZI1377);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI1378) = NULL_type;
	}
	{

    IDENTIFIER pid = underlying_id ((ZI1377));
    DEREF_loc (id_loc (pid), decl_loc);
	}
	ZR1166 (ZI1378, ZI1377, &ZI484, &ZI423);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 1));
	}
	goto ZL0;
    }
    /*UNREACHED*/
  ZL2:;
    switch (CURRENT_TERMINAL) {
      case lex_open_Hround:
	{
	    TYPE ZI484;

	    ADVANCE_LEXER;
	    ZR1376 (&ZI484, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 1));
	    }
	}
	break;
      case lex_weak:
	{
	    IDENTIFIER ZI1375;
	    int ZI948;
	    TYPE ZI1381;
	    IDENTIFIER ZI1382;
	    TYPE ZI484;

	    ADVANCE_LEXER;
	    switch (CURRENT_TERMINAL) {
	      case lex_open_Hround:
		break;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    {

    (ZI1375) = NULL_id;
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
	    }
	    {
 (ZI948) = 1; 
	    }
	    {

    func_type_defn (0);
    begin_param ((ZI1375));
    have_type_declaration = TYPE_DECL_NONE;
    have_func_declarator = 0;
	    }
	    ZR949 (ZI948, &ZI1381);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    end_param ();
    have_type_declaration = TYPE_DECL_NONE;
    have_func_declarator = 1;
	    }
	    {

    HASHID nm = lookup_anon ();
    (ZI1382) = DEREF_id (hashid_id (nm));
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
	    }
	    {

    IDENTIFIER pid = underlying_id ((ZI1382));
    DEREF_loc (id_loc (pid), decl_loc);
	    }
	    ZR1166 (ZI1381, ZI1382, &ZI484, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 1));
	    }
	}
	break;
      case lex_open_Hsquare_H1:
	{
	    EXP ZI435;
	    TYPE ZI1379;
	    IDENTIFIER ZI1380;
	    TYPE ZI484;

	    {
		{
		    switch (CURRENT_TERMINAL) {
		      case lex_open_Hsquare_H1:
			break;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		}
	    }
	    ZR958 (&ZI435);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    NAT n = make_array_dim ((ZI435));
    MAKE_type_array (cv_none, NULL_type, n, (ZI1379));
	    }
	    {
		{
		    switch (CURRENT_TERMINAL) {
		      case lex_close_Hsquare_H1:
			break;
		      default:
			goto ZL1;
		    }
		    ADVANCE_LEXER;
		}
	    }
	    {

    HASHID nm = lookup_anon ();
    (ZI1380) = DEREF_id (hashid_id (nm));
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
	    }
	    {

    IDENTIFIER pid = underlying_id ((ZI1380));
    DEREF_loc (id_loc (pid), decl_loc);
	    }
	    ZR1166 (ZI1379, ZI1380, &ZI484, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 1));
	    }
	}
	break;
      case lex_nested_Hname_Hstar: case lex_full_Hname_Hstar: case lex_and_H1:
      case lex_star:
	{
	    TYPE ZI1383;
	    TYPE ZI1384;
	    TYPE ZI484;

	    ZR931 (&ZI1383);
	    ZR964 (&ZI1384, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI484) = (IS_NULL_type ((ZI1384)) ? (ZI1383): inject_pre_type ((ZI1384), (ZI1383), 0));
	    }
	    {

    (ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 1));
	    }
	}
	break;
      default:
	{
	    TYPE ZI484;

	    {

    (ZI484) = NULL_type;
	    }
	    {

    HASHID nm = lookup_anon ();
    (ZI423) = DEREF_id (hashid_id (nm));
    crt_id_qualifier = qual_none;
    qual_namespace = NULL_nspace;
	    }
	    {

    IDENTIFIER pid = underlying_id ((ZI423));
    DEREF_loc (id_loc (pid), decl_loc);
	    }
	    {

    (ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 1));
	    }
	}
	break;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO418 = ZI418;
    *ZO423 = ZI423;
}

void
ZR1061 (EXP *ZO435)
{
    EXP ZI435;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	EXP ZI497;
	SID_LIST_EXP ZI501;

	switch (CURRENT_TERMINAL) {
	  case lex_asm:
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	switch (CURRENT_TERMINAL) {
	  case lex_open_Hround:
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	{
	    switch (CURRENT_TERMINAL) {
	      case lex_string_Hexp:
		{
		    {

    ZI497 = crt_token->pp_data.exp;
		    }
		    ADVANCE_LEXER;
		}
		break;
	      case lex_wstring_Hexp:
		{
		    {

    ZI497 = crt_token->pp_data.exp;
		    }
		    ADVANCE_LEXER;
		}
		break;
	      default:
		goto ZL1;
	    }
	}
	ZR503 (&ZI501);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI435) = make_asm ((ZI497), (ZI501));
	}
	switch (CURRENT_TERMINAL) {
	  case lex_close_Hround:
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	ZR422 ();
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR573 (TYPE ZI418, EXP *ZO435)
{
    EXP ZI435;

    switch (CURRENT_TERMINAL) {
      case lex_open_Hround:
	{
	    SID_LIST_EXP ZI501;

	    ADVANCE_LEXER;
	    ZR504 (&ZI501);
	    switch (CURRENT_TERMINAL) {
	      case lex_close_Hround:
		break;
	      case 358:
		RESTORE_LEXER;
		goto ZL1;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    {

    (ZI435) = make_new_init ((ZI418), (ZI501), 1);
	    }
	}
	break;
      default:
	{
	    {

    (ZI435) = make_new_init ((ZI418), NULL_list (EXP), 0);
	    }
	}
	break;
      case 358:
	return;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR636 (EXP *ZO435)
{
    EXP ZI435;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	EXP ZI1265;

	ZR634 (&ZI1265);
	ZR1267 (&ZI1265, &ZI435);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR949 (int ZI948, TYPE *ZO418)
{
    TYPE ZI418;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	int ZI950;
	CV_SPEC ZI788;
	SID_LIST_TYPE ZI726;

	ZR946 (&ZI950);
	switch (CURRENT_TERMINAL) {
	  case lex_close_Hround:
	    break;
	  case 358:
	    RESTORE_LEXER;
	    goto ZL1;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	ZR793 (&ZI788);
	ZR944 (&ZI726);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    CV_SPEC cv = func_linkage ((ZI788));
    if ((ZI948)) (ZI950) |= FUNC_WEAK;
    (ZI418) = make_func_type (NULL_type, (ZI950), cv, (ZI726));
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO418 = ZI418;
}

void
ZR1434 (int *ZI454, int *ZI558, int *ZI559, EXP *ZO562)
{
    EXP ZI562;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	TYPE ZI418;
	int ZI563;
	EXP ZI497;

	{

    /* Resolve type-ids from expressions */
    (ZI0) = predict_typeid (1);
	}
	if (!ZI0)
	    goto ZL2;
	ZR552 (&ZI418, &ZI563);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI497) = NULL_exp;
	}
	{

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (*ZI454));
	}
	switch (CURRENT_TERMINAL) {
	  case lex_close_Hround:
	    break;
	  default:
	    goto ZL1;
	}
	ADVANCE_LEXER;
	goto ZL0;
    }
    /*UNREACHED*/
  ZL2:;
    switch (CURRENT_TERMINAL) {
      case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
      case lex_destructor_Hname: case lex_template_Hid: case lex_template_Htype:
      case lex_nested_Hname: case lex_full_Hname: case lex_char_Hexp:
      case lex_wchar_Hexp: case lex_string_Hexp: case lex_wstring_Hexp:
      case lex_integer_Hexp: case lex_floating_Hexp: case lex_complex_Hexp:
      case lex_complex_Htype: case lex_and_H1: case lex_compl_H1:
      case lex_minus: case lex_minus_Hminus: case lex_not_H1:
      case lex_open_Hround: case lex_plus: case lex_plus_Hplus:
      case lex_star: case lex_colon_Hcolon: case lex_abs:
      case lex_char: case lex_double: case lex_float:
      case lex_int: case lex_long: case lex_short:
      case lex_signed: case lex_sizeof: case lex_unsigned:
      case lex_void: case lex_bool: case lex_const_Hcast:
      case lex_delete: case lex_dynamic_Hcast: case lex_false:
      case lex_new: case lex_operator: case lex_reinterpret_Hcast:
      case lex_static_Hcast: case lex_this: case lex_throw:
      case lex_true: case lex_typeid: case lex_wchar_Ht:
      case lex_alignof: case lex_bottom: case lex_discard:
      case lex_ellipsis_Hexp: case lex_ptrdiff_Ht: case lex_set:
      case lex_size_Ht: case lex_unused: case lex_vtable:
      case lex_inset_Hstart:
	{
	    EXP ZI1430;
	    EXP ZI1283;
	    EXP ZI497;
	    int ZI561;
	    int ZI563;
	    TYPE ZI418;

	    {

    IGNORE incr_value (OPT_VAL_paren_depth);
	    }
	    ZR495 (&ZI1430);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI1283) = make_paren_exp ((ZI1430));
    decr_value (OPT_VAL_paren_depth);
	    }
	    switch (CURRENT_TERMINAL) {
	      case lex_close_Hround:
		break;
	      default:
		goto ZL1;
	    }
	    ADVANCE_LEXER;
	    ZR1245 (ZI1283, &ZI497);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI561) = no_side_effects - (*ZI558);
	    }
	    {

    (ZI563) = no_type_defns - (*ZI559);
	    }
	    {

    (ZI418) = typeof_exp (&(ZI497), (ZI561), (*ZI454));
	    }
	    {

    (ZI562) = make_sizeof_exp ((ZI418), (ZI497), (ZI563), (*ZI454));
	    }
	}
	break;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO562 = ZI562;
}

void
ZR947 (IDENTIFIER *ZO423)
{
    IDENTIFIER ZI423;

    switch (CURRENT_TERMINAL) {
      case lex_colon_Hcolon:
	{
	    ADVANCE_LEXER;
	    ZR1351 (&ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_full_Hname:
	{
	    NAMESPACE ZI429;

	    {

    ZI429 = crt_token->pp_data.ns;
	    }
	    ADVANCE_LEXER;
	    ZR1350 (&ZI429, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_nested_Hname:
	{
	    NAMESPACE ZI429;

	    {

    ZI429 = crt_token->pp_data.ns;
	    }
	    ADVANCE_LEXER;
	    ZR1349 (&ZI429, &ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_statement_Hname:
	{
	    IDENTIFIER ZI482;

	    {

    ZI482 = crt_token->pp_data.id.use;
	    }
	    ADVANCE_LEXER;
	    {

    (ZI423) = (ZI482);
    crt_id_qualifier = qual_none;
    last_namespace = crt_namespace;
	    }
	}
	break;
      case lex_identifier: case lex_namespace_Hname: case lex_destructor_Hname:
      case lex_template_Hid: case lex_operator:
	{
	    ZR481 (&ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_type_Hname: case lex_template_Htype:
	{
	    IDENTIFIER ZI464;

	    ZR476 (&ZI464);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI423) = constr_name (last_namespace, (ZI464));
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO423 = ZI423;
}

void
parse_type (TYPE *ZO418)
{
    TYPE ZI418;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	parse_tok_type (&ZI418);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    object_type ((ZI418), null_tag);
	}
    }
    goto ZL0;
  ZL1:;
    {
	{

    /* Syntax errors */
    ERROR err = ERR_lex_parse (crt_token);
    report (crt_loc, err);
    have_syntax_error = 1;
	}
	{

    (ZI418) = NULL_type;
	}
    }
  ZL0:;
    *ZO418 = ZI418;
}

void
ZR1101 (IDENTIFIER *ZO463)
{
    IDENTIFIER ZI463;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	TYPE ZI578;
	BASE_TYPE ZI879;
	TYPE ZI1512;
	CV_SPEC ZI1513;
	BASE_TYPE ZI515;
	TYPE ZI880;
	CV_SPEC ZI881;
	DECL_SPEC ZI914;
	TYPE ZI884;
	DECL_SPEC ZI693;
	TYPE ZI1079;
	IDENTIFIER ZI423;
	int ZI562;
	TYPE ZI418;

	{

    /* Resolve type-specifiers from other declarators */
    (ZI0) = predict_tspec (0);
	}
	if (!ZI0)
	    goto ZL1;
	{

    (ZI578) = NULL_type;
	}
	ZR877 (ZI578, &ZI879, &ZI1512, &ZI1513);
	ZR890 (&ZI879, &ZI1512, &ZI1513, &ZI515, &ZI880, &ZI881);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{
 (ZI914) = dspec_none; 
	}
	{

    /* Complete a declaration specifier and a type */
    (ZI693) = complete_dspec ((ZI914), (ZI515), (ZI880), (ZI881));
    (ZI884) = complete_pre_type ((ZI515), (ZI880), (ZI881), 0);
    have_type_specifier = 0;
	}
	{

    crt_templ_qualifier = 0;
	}
	ZR955 (ZI884, &ZI1079, &ZI423, &ZI562);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    if ((ZI562)) report (crt_loc, ERR_dcl_init_bad ());
	}
	{

    (ZI418) = make_cond_type ((ZI1079));
	}
	{

    if (type_tag ((ZI418)) == type_func_tag) {
	/* Look ahead for function definitions */
	int def = predict_func_defn ();
	if (def & !have_func_declarator) adjust_param ((ZI418));
	(ZI463) = make_func_decl ((ZI693), (ZI418), (ZI423), def);
	is_function_next = def;
    } else {
	int def = predict_obj_defn ();
	(ZI463) = make_object_decl ((ZI693), (ZI418), (ZI423), def);
	is_function_next = 0;
    }
    if (IS_id_type_alias ((ZI463))) {
	BASE_TYPE bs = DEREF_btype (id_type_alias_rep ((ZI463)));
	bs |= (ZI515);
	COPY_btype (id_type_alias_rep ((ZI463)), bs);
    }
    have_type_declaration = TYPE_DECL_NONE;
    have_func_declarator = 0;
	}
	{

    if (crt_access_list.pending) {
	IGNORE report_access ((ZI463));
    }
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO463 = ZI463;
}

void
ZR1132 (OFFSET ZI460, TYPE ZI578, OFFSET *ZO1157, TYPE *ZO1158)
{
    OFFSET ZI1157;
    TYPE ZI1158;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
  ZL2_1132:;
    {
	OFFSET ZI497;
	TYPE ZI418;

	ZR1131 (ZI460, ZI578, &ZI497, &ZI418);
	{
	    switch (CURRENT_TERMINAL) {
	      case lex_dot: case lex_open_Hsquare_H1:
		{
		    ZI460 = ZI497;
		    ZI578 = ZI418;
		    goto ZL2_1132;
		}
		/*UNREACHED*/
	      default:
		{
		    ZI1157 = ZI497;
		    ZI1158 = ZI418;
		}
		break;
	      case 358:
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO1157 = ZI1157;
    *ZO1158 = ZI1158;
}

void
ZR1435 (int *ZI460, EXP *ZO435)
{
    EXP ZI435;

    switch (CURRENT_TERMINAL) {
      case lex_new:
	{
	    int ZI461;
	    SID_LIST_EXP ZI501;
	    TYPE ZI418;
	    int ZI555;
	    int ZI463;
	    EXP ZI578;
	    EXP ZI459;
	    EXP ZI497;

	    ADVANCE_LEXER;
	    {

    (ZI461) = have_type_declaration;
    have_type_declaration = TYPE_DECL_NONE;
	    }
	    ZR575 (&ZI501, &ZI418, &ZI555);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    int td = have_type_declaration;
    (ZI463) = 0;
    if (td != TYPE_DECL_NONE) {
	if (td == TYPE_DECL_ELABORATE && found_elaborate_type) {
	    /* This is allowed */
	    /* EMPTY */
	} else {
	    (ZI463) = 1;
	}
    }
    have_type_declaration = (ZI461);
	    }
	    {

    (ZI578) = begin_new_try ();
	    }
	    ZR573 (ZI418, &ZI459);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI497) = end_new_try ((ZI578), (ZI459));
	    }
	    {

    (ZI435) = make_new_exp ((ZI418), (ZI555) + (ZI463), (*ZI460), (ZI501), (ZI497));
	    }
	}
	break;
      case lex_delete:
	{
	    int ZI454;
	    EXP ZI497;

	    ZR587 (&ZI454);
	    ZR585 (&ZI497);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	    {

    (ZI435) = make_delete_exp ((ZI454), (*ZI460), (ZI497));
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO435 = ZI435;
}

void
ZR477 (IDENTIFIER *ZO423)
{
    IDENTIFIER ZI423;

    switch (CURRENT_TERMINAL) {
      case lex_full_Hname:
	{
	    ZR507 (&ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_nested_Hname:
	{
	    ZR506 (&ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case lex_colon_Hcolon:
	{
	    ZR508 (&ZI423);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      case 358:
	return;
      default:
	goto ZL1;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO423 = ZI423;
}

void
ZR996 (TYPE *ZO418)
{
    TYPE ZI418;

    if ((CURRENT_TERMINAL) == 358) {
	return;
    }
    {
	TYPE ZI501;
	TYPE ZI484;

	{

    /* Resolve pointer declarators from expressions */
    (ZI0) = predict_ptr (0);
	}
	if (!ZI0)
	    goto ZL2;
	ZR931 (&ZI501);
	ZR996 (&ZI484);
	if ((CURRENT_TERMINAL) == 358) {
	    RESTORE_LEXER;
	    goto ZL1;
	}
	{

    (ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 0));
	}
	goto ZL0;
    }
    /*UNREACHED*/
  ZL2:;
    switch (CURRENT_TERMINAL) {
      case lex_open_Hsquare_H1:
	{
	    ZR995 (&ZI418);
	    if ((CURRENT_TERMINAL) == 358) {
		RESTORE_LEXER;
		goto ZL1;
	    }
	}
	break;
      default:
	{
	    {

    (ZI418) = NULL_type;
	    }
	}
	break;
    }
    goto ZL0;
  ZL1:;
    SAVE_LEXER (358);
    return;
  ZL0:;
    *ZO418 = ZI418;
}

/* END OF FILE */