WebSVN – tendra.SVN – Diff – /trunk/src/tools/tspec/syntax.c

 /*
  * Automatically generated from the files:
- *	/u/g/release/Source/src/tools/tspec/syntax.sid
+ *	syntax.sid
  * and
- *	/u/g/release/Source/src/tools/tspec/syntax.act
+ *	syntax.act
  * by:
  *	sid
  */
 /* BEGINNING OF HEADER */
 /* BEGINNING OF FUNCTION DECLARATIONS */
-static void ZRsimple_Htype PROTO_S ((SID_TYPE *));
+static void ZRsimple_Htype(SID_TYPE *);
-static void ZRparameter_Hdeclaration PROTO_S ((SID_TYPE *));
+static void ZRparameter_Hdeclaration(SID_TYPE *);
-static void ZRnat_Hdeclarator_Hlist PROTO_S ((SID_COMMAND *));
+static void ZRnat_Hdeclarator_Hlist(SID_COMMAND *);
-static void ZRtype_Hdeclarator_Hlist PROTO_S ((SID_COMMAND *));
+static void ZRtype_Hdeclarator_Hlist(SID_COMMAND *);
-static void ZRfunction_Hoperator PROTO_S ((SID_TYPE *));
+static void ZRfunction_Hoperator(SID_TYPE *);
-static void ZRexp_Hdeclarator_Hlist PROTO_S ((int, SID_TYPE, int, SID_COMMAND *));
+static void ZRexp_Hdeclarator_Hlist(int, SID_TYPE, int, SID_COMMAND *);
-static void ZRsubset_Hkey PROTO_S ((SID_STRING *));
+static void ZRsubset_Hkey(SID_STRING *);
-static void ZRmacro_Hparam_Hdeclaration PROTO_S ((SID_TYPE *));
+static void ZRmacro_Hparam_Hdeclaration(SID_TYPE *);
-static void ZRifdef_Hmacro_Hname PROTO_S ((SID_STRING *));
+static void ZRifdef_Hmacro_Hname(SID_STRING *);
-static void ZR285 PROTO_S ((SID_TYPE *));
+static void ZRdefine_Hparam_Hlist(SID_STRING *);
-static void ZRdefine_Hparam_Hlist PROTO_S ((SID_STRING *));
+static void ZR287(SID_TYPE *);
-static void ZRdeclarator PROTO_S ((SID_IDENTIFIER *, SID_TYPE *));
+static void ZRdeclarator(SID_IDENTIFIER *, SID_TYPE *);
-static void ZRidentifier PROTO_S ((SID_IDENTIFIER *));
+static void ZRidentifier(SID_IDENTIFIER *);
-static void ZRsubset_Hcommand PROTO_S ((SID_COMMAND *));
+static void ZRsubset_Hcommand(SID_COMMAND *);
-static void ZRqualified_Htype PROTO_S ((SID_TYPE *));
+static void ZRqualified_Htype(SID_TYPE *);
-static void ZRabstract_Hdeclarator PROTO_S ((SID_STRING *, SID_TYPE *));
+static void ZRabstract_Hdeclarator(SID_STRING *, SID_TYPE *);
-static void ZR306 PROTO_S ((SID_STRING, SID_TYPE, SID_STRING *, SID_TYPE *));
+static void ZRparameter_Hlist(SID_TYPE *);
-static void ZRparameter_Hlist PROTO_S ((SID_TYPE *));
+static void ZRinternal_Hname(SID_STRING *, int *);
-static void ZRinternal_Hname PROTO_S ((SID_STRING *, int *));
+static void ZR308(SID_STRING, SID_TYPE, SID_STRING *, SID_TYPE *);
-static void ZRmacro_Hoperator PROTO_S ((SID_TYPE *));
+static void ZRmacro_Hoperator(SID_TYPE *);
-static void ZRenumerator_Hlist PROTO_S ((SID_COMMAND *));
+static void ZRenumerator_Hlist(SID_COMMAND *);
-static void ZRexternal_Hname PROTO_S ((SID_STRING *, int *));
+static void ZRexternal_Hname(SID_STRING *, int *);
-static void ZRtype_Hqualifier PROTO_S ((unsigned *));
+static void ZRtype_Hqualifier(unsigned *);
-static void ZR316 PROTO_S ((SID_IDENTIFIER, SID_TYPE, SID_IDENTIFIER *, SID_TYPE *));
-static void ZRtype_Hkey PROTO_S ((int *));
+static void ZRtype_Hkey(int *);
-static void ZRtype_Hqualifier_Hopt PROTO_S ((unsigned *));
+static void ZRtype_Hqualifier_Hopt(unsigned *);
-static void ZRconstant_Hvalue PROTO_S ((SID_STRING *));
+static void ZRconstant_Hvalue(SID_STRING *);
-static void ZR318 PROTO_S ((SID_STRING *, SID_STRING *));
+static void ZR318(SID_IDENTIFIER, SID_TYPE, SID_IDENTIFIER *, SID_TYPE *);
-static void ZRspec_Hcommand PROTO_S ((SID_COMMAND *));
+static void ZRspec_Hcommand(SID_COMMAND *);
-static void ZR319 PROTO_S ((SID_STRING *, SID_STRING *, SID_STRING *));
-static void ZRfunc_Hcommand PROTO_S ((int *));
+static void ZRfunc_Hcommand(int *);
-static void ZR320 PROTO_S ((SID_COMMAND *));
+static void ZR320(SID_STRING *, SID_STRING *);
-static void ZR321 PROTO_S ((int *, SID_COMMAND *));
+static void ZR321(SID_STRING *, SID_STRING *, SID_STRING *);
-static void ZRarray_Hoperator PROTO_S ((SID_TYPE *));
+static void ZRarray_Hoperator(SID_TYPE *);
-static void ZR322 PROTO_S ((SID_STRING *, int *, SID_IDENTIFIER *));
+static void ZR322(SID_COMMAND *);
-static void ZR323 PROTO_S ((SID_STRING *));
+static void ZR323(int *, SID_COMMAND *);
-static void ZRmacro_Hparam_Hlist PROTO_S ((SID_TYPE *));
+static void ZRmacro_Hparam_Hlist(SID_TYPE *);
-static void ZR326 PROTO_S ((SID_STRING *, SID_STRING *));
+static void ZR324(SID_STRING *, int *, SID_IDENTIFIER *);
-static void ZR327 PROTO_S ((int *));
+static void ZR325(SID_STRING *);
-static void ZR328 PROTO_S ((int *));
+static void ZR328(SID_STRING *, SID_STRING *);
-static void ZRenum_Hcommand PROTO_S ((int *));
+static void ZRenum_Hcommand(int *);
-static void ZRenumerator PROTO_S ((SID_COMMAND *));
+static void ZRenumerator(SID_COMMAND *);
+static void ZR329(int *);
-static void ZRfield_Hdeclarator_Hlist PROTO_S ((SID_TYPE, SID_TYPE, SID_COMMAND *));
+static void ZRfield_Hdeclarator_Hlist(SID_TYPE, SID_TYPE, SID_COMMAND *);
-static void ZR331 PROTO_S ((SID_TYPE *, SID_TYPE *));
+static void ZR330(int *);
-static void ZRfield_Hexact PROTO_S ((int *));
+static void ZRfield_Hexact(int *);
-static void ZR333 PROTO_S ((SID_TYPE *));
+static void ZR333(SID_TYPE *, SID_TYPE *);
+static void ZR335(SID_TYPE *);
-static void ZRcommand_Hlist PROTO_S ((SID_COMMAND *));
+static void ZRcommand_Hlist(SID_COMMAND *);
-static void ZR336 PROTO_S ((SID_STRING *, SID_TYPE *, SID_STRING *, SID_TYPE *));
+static void ZR338(SID_STRING *, SID_TYPE *, SID_STRING *, SID_TYPE *);
-static void ZR337 PROTO_S ((SID_TYPE *));
+static void ZR339(SID_TYPE *);
-static void ZR338 PROTO_S ((int *));
+static void ZR340(int *);
-static void ZRdirect_Hdeclarator PROTO_S ((SID_IDENTIFIER *, SID_TYPE *));
+static void ZRdirect_Hdeclarator(SID_IDENTIFIER *, SID_TYPE *);
-static void ZRtype_Hcommand PROTO_S ((int *));
+static void ZRtype_Hcommand(int *);
-static void ZRtext_Hcommand PROTO_S ((SID_COMMAND *));
+static void ZRtext_Hcommand(SID_COMMAND *);
-static void ZR345 PROTO_S ((SID_IDENTIFIER *, SID_IDENTIFIER *, SID_TYPE *));
+static void ZR347(SID_IDENTIFIER *, SID_IDENTIFIER *, SID_TYPE *);
-static void ZR346 PROTO_S ((int *));
+static void ZRname_Hversion(int *);
-static void ZR347 PROTO_S ((int *));
+static void ZR348(int *);
-static void ZRname_Hversion PROTO_S ((int *));
-static void ZR348 PROTO_S ((SID_TYPE *));
-static void ZRdirect_Habstract_Hdeclarator PROTO_S ((SID_STRING *, SID_TYPE *));
+static void ZRdirect_Habstract_Hdeclarator(SID_STRING *, SID_TYPE *);
-static void ZRfield_Hdeclarator PROTO_S ((SID_IDENTIFIER *, SID_TYPE *));
+static void ZRfield_Hdeclarator(SID_IDENTIFIER *, SID_TYPE *);
-static void ZRvariable_Hcommand PROTO_S ((void));
+static void ZRvariable_Hcommand(void);
-static void ZR349 PROTO_S ((SID_STRING *));
+static void ZR349(int *);
-static void ZR350 PROTO_S ((SID_STRING *));
+static void ZR350(SID_TYPE *);
-static void ZR351 PROTO_S ((SID_STRING *));
+static void ZR351(SID_STRING *);
-static void ZRdefine_Hparam_Hclause PROTO_S ((SID_STRING *));
+static void ZRdefine_Hparam_Hclause(SID_STRING *);
-static void ZRexp_Hcommand PROTO_S ((int *));
+static void ZRexp_Hcommand(int *);
-static void ZR352 PROTO_S ((SID_STRING *));
+static void ZR352(SID_STRING *);
-static void ZRif_Hcommand PROTO_S ((SID_COMMAND *, SID_STRING *));
+static void ZRif_Hcommand(SID_COMMAND *, SID_STRING *);
+static void ZR353(SID_STRING *);
+static void ZR354(SID_STRING *);
-static void ZRbitfield_Hoperator PROTO_S ((SID_TYPE *));
+static void ZRbitfield_Hoperator(SID_TYPE *);
-static void ZRuse_Hsubset_Hname PROTO_S ((SID_STRING *));
+static void ZRuse_Hsubset_Hname(SID_STRING *);
-extern void read_spec PROTO_S ((SID_COMMAND *));
+extern void read_spec(SID_COMMAND *);
-static void ZRmacro_Hdeclarator PROTO_S ((SID_IDENTIFIER *, SID_TYPE *));
+static void ZRmacro_Hdeclarator(SID_IDENTIFIER *, SID_TYPE *);
-static void ZRsubset_Hname PROTO_S ((SID_STRING *));
+static void ZRsubset_Hname(SID_STRING *);
-static void ZRbuiltin_Htype PROTO_S ((unsigned *));
+static void ZRbuiltin_Htype(unsigned *);
-static void ZRobject_Hqualifier PROTO_S ((int *));
+static void ZRobject_Hqualifier(int *);
-static void ZRfield_Hlist PROTO_S ((SID_TYPE, SID_COMMAND *));
+static void ZRfield_Hlist(SID_TYPE, SID_COMMAND *);
-static void ZRptr_Hoperator PROTO_S ((SID_TYPE *));
+static void ZRptr_Hoperator(SID_TYPE *);
-static void ZRtype_Hkeyword PROTO_S ((unsigned *));
+static void ZRtype_Hkeyword(unsigned *);
 /* BEGINNING OF STATIC VARIABLES */
 /* BEGINNING OF FUNCTION DEFINITIONS */
 static void
-ZRsimple_Htype PROTO_N ((ZOt))
+ZRsimple_Htype(SID_TYPE *ZOt)
-  PROTO_T (SID_TYPE *ZOt)
+{
     SID_TYPE ZIt;
     switch (CURRENT_TERMINAL) {
-      case 31: case 33: case 36: case 37: case 38:
+      case 32: case 34: case 37: case 38: case 39:
-      case 41: case 42: case 45: case 46:
+      case 42: case 43: case 46: case 47:
+	{
 	    unsigned ZIb;
 	    ZRbuiltin_Htype (&ZIb);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     (ZIt) = basic_type ( (ZIb) ) ;
+	    }
+	}
 	break;
-      case 0: case 34: case 43: case 44:
+      case 0: case 35: case 44: case 45:
+	{
 	    int ZItag;
 	    SID_STRING ZInm;
 	    ZRtype_Hkey (&ZItag);
 	      case 0:
+		{
  ZInm = token_value ;
+		}
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
+	    }
     (ZIt) = find_type ( (ZInm), any_version, (ZItag), 1 ) ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRparameter_Hdeclaration PROTO_N ((ZOt))
+ZRparameter_Hdeclaration(SID_TYPE *ZOt)
-  PROTO_T (SID_TYPE *ZOt)
+{
     SID_TYPE ZIt;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_TYPE ZIs;
 	SID_STRING ZInm;
 	SID_TYPE ZIp;
 	ZRqualified_Htype (&ZIs);
 	ZRabstract_Hdeclarator (&ZInm, &ZIp);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+	{
     UNUSED ( (ZInm) ) ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRnat_Hdeclarator_Hlist PROTO_N ((ZOc))
+ZRnat_Hdeclarator_Hlist(SID_COMMAND *ZOc)
-  PROTO_T (SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_IDENTIFIER ZIid;
 	SID_COMMAND ZIa;
 	SID_COMMAND ZIb;
 	ZRidentifier (&ZIid);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+	{
     object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_NAT ) ;
     (ZIa) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_NAT ) ;
+	}
+	{
 	    switch (CURRENT_TERMINAL) {
-	      case 61:
+	      case 62:
+		{
 		    ADVANCE_LEXER;
 		    ZRnat_Hdeclarator_Hlist (&ZIb);
-		    if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
 			RESTORE_LEXER;
 			goto ZL1;
+		    }
+		}
 		break;
     (ZIc) = join_object ( (ZIa), (ZIb) ) ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOc = ZIc;
+}
 static void
-ZRtype_Hdeclarator_Hlist PROTO_N ((ZOc))
+ZRtype_Hdeclarator_Hlist(SID_COMMAND *ZOc)
-  PROTO_T (SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	int ZItag;
 	SID_IDENTIFIER ZIid;
 	SID_COMMAND ZIa;
 	SID_COMMAND ZIb;
 	ZRtype_Hcommand (&ZItag);
 	ZRidentifier (&ZIid);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+	{
     type *t = make_type ( (ZIid).iname, (ZIid).ivers, (ZItag) ) ;
     (ZIa) = make_token ( (ZIid).ename, (ZIid).evers, t->u.obj, OBJ_TYPE ) ;
+	}
+	{
 	    switch (CURRENT_TERMINAL) {
-	      case 61:
+	      case 62:
+		{
 		    ADVANCE_LEXER;
 		    ZRtype_Hdeclarator_Hlist (&ZIb);
-		    if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
 			RESTORE_LEXER;
 			goto ZL1;
+		    }
+		}
 		break;
     (ZIc) = join_object ( (ZIa), (ZIb) ) ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOc = ZIc;
+}
 static void
-ZRfunction_Hoperator PROTO_N ((ZOt))
+ZRfunction_Hoperator(SID_TYPE *ZOt)
-  PROTO_T (SID_TYPE *ZOt)
+{
     SID_TYPE ZIt;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	switch (CURRENT_TERMINAL) {
-	  case 55:
+	  case 56:
 	    break;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
-	ZR333 (&ZIt);
+	ZR335 (&ZIt);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRexp_Hdeclarator_Hlist PROTO_N ((ZIcmd, ZIs, ZIlv, ZOc))
-  PROTO_T (int ZIcmd X SID_TYPE ZIs X int ZIlv X SID_COMMAND *ZOc)
+ZRexp_Hdeclarator_Hlist(int ZIcmd, SID_TYPE ZIs, int ZIlv, SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_IDENTIFIER ZIid;
 	SID_TYPE ZIp;
 	SID_TYPE ZIt;
 	SID_COMMAND ZIa;
 	SID_COMMAND ZIb;
 	ZRdeclarator (&ZIid, &ZIp);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
 	}
+	{
     (ZIu) = inject_type ( (ZIp), (ZIs) ) ;
+	}
+	{
     p->u.u_type = check_type ( (ZIt), (ZIcmd) ) ;
     (ZIa) = make_token ( (ZIid).ename, (ZIid).evers, p, (ZIcmd) ) ;
+	}
+	{
 	    switch (CURRENT_TERMINAL) {
-	      case 61:
+	      case 62:
+		{
 		    ADVANCE_LEXER;
 		    ZRexp_Hdeclarator_Hlist (ZIcmd, ZIs, ZIlv, &ZIb);
-		    if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
 			RESTORE_LEXER;
 			goto ZL1;
 		    }
 		}
 		break;
 	      default:
 		{
+		    {
     (ZIb) = null ;
+		    }
+		}
 		break;
+	    }
 	}
+	{
     (ZIc) = join_object ( (ZIa), (ZIb) ) ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOc = ZIc;
+}
 static void
-ZRsubset_Hkey PROTO_N ((ZOkey))
+ZRsubset_Hkey(SID_STRING *ZOkey)
-  PROTO_T (SID_STRING *ZOkey)
+{
     SID_STRING ZIkey;
     switch (CURRENT_TERMINAL) {
-      case 55:
+      case 56:
+	{
 	    ADVANCE_LEXER;
-	    ZR349 (&ZIkey);
+	    ZR351 (&ZIkey);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
+	    {
  (ZIkey) = "11" ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOkey = ZIkey;
+}
 static void
-ZRmacro_Hparam_Hdeclaration PROTO_N ((ZOt))
+ZRmacro_Hparam_Hdeclaration(SID_TYPE *ZOt)
-  PROTO_T (SID_TYPE *ZOt)
+{
     SID_TYPE ZIt;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	int ZIlv;
 	SID_TYPE ZIs;
 	SID_TYPE ZIu;
 	ZRobject_Hqualifier (&ZIlv);
 	ZRqualified_Htype (&ZIs);
 	ZRabstract_Hdeclarator (&ZInm, &ZIp);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+	{
     UNUSED ( (ZInm) ) ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRifdef_Hmacro_Hname PROTO_N ((ZOc))
+ZRifdef_Hmacro_Hname(SID_STRING *ZOc)
-  PROTO_T (SID_STRING *ZOc)
+{
     SID_STRING ZIc;
     switch (CURRENT_TERMINAL) {
-      case 49:
+      case 50:
 	{
 	    ADVANCE_LEXER;
 	    {
     (ZIc) = BUILDING_MACRO ;
 	    }
 	}
 	break;
       case 0:
+	{
+	    {
  ZIc = token_value ;
+	    }
 	    ADVANCE_LEXER;
+	}
 	break;
-      case 51:
+      case 52:
+	{
 	    SID_STRING ZIa;
 	    SID_STRING ZIb;
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 55:
+	      case 56:
 		break;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
 	      case 2:
+		{
  ZIa = token_value ;
 		}
 		break;
 	      default:
 		goto ZL1;
 	    }
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 61:
+	      case 62:
 		break;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
 	      case 2:
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
     (ZIc) = macro_name ( PROTECT_PREFIX, (ZIa), (ZIb), null_str ) ;
+	    }
+	}
 	break;
-      case 74:
-	return;
-      default:
-	goto ZL1;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOc = ZIc;
-}
-static void
-ZR285 PROTO_N ((ZOt))
-  PROTO_T (SID_TYPE *ZOt)
-{
-    SID_TYPE ZIt;
-    switch (CURRENT_TERMINAL) {
-      case 55:
-	{
-	    ZRmacro_Hoperator (&ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
-		RESTORE_LEXER;
-		goto ZL1;
-	    }
-	}
-	break;
-      default:
-	{
-	    {
-    (ZIt) = null ;
-	    }
-	}
-	break;
-      case 74:
+      case 75:
 	return;
+      default:
+	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZOt = ZIt;
+    *ZOc = ZIc;
+}
 static void
-ZRdefine_Hparam_Hlist PROTO_N ((ZOp))
+ZRdefine_Hparam_Hlist(SID_STRING *ZOp)
-  PROTO_T (SID_STRING *ZOp)
+{
     SID_STRING ZIp;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
     }
     {
-	SID_STRING ZI324;
+	SID_STRING ZI326;
 	switch (CURRENT_TERMINAL) {
 	  case 0:
 	    {
- ZI324 = token_value ;
+ ZI326 = token_value ;
 	    }
 	    break;
 	  default:
 	    goto ZL1;
 	}
 	ADVANCE_LEXER;
-	ZR326 (&ZI324, &ZIp);
+	ZR328 (&ZI326, &ZIp);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
 	}
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOp = ZIp;
+}
+static void
+ZR287(SID_TYPE *ZOt)
+{
+    SID_TYPE ZIt;
+    switch (CURRENT_TERMINAL) {
+      case 56:
+	{
+	    ZRmacro_Hoperator (&ZIt);
+	    if ((CURRENT_TERMINAL) == 75) {
+		RESTORE_LEXER;
+		goto ZL1;
+	    }
+	}
+	break;
+      default:
+	{
+	    {
+    (ZIt) = null ;
+	    }
+	}
+	break;
+      case 75:
+	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZOp = ZIp;
+    *ZOt = ZIt;
+}
 static void
-ZRdeclarator PROTO_N ((ZOid, ZOt))
-  PROTO_T (SID_IDENTIFIER *ZOid X SID_TYPE *ZOt)
+ZRdeclarator(SID_IDENTIFIER *ZOid, SID_TYPE *ZOt)
+{
     SID_IDENTIFIER ZIid;
     SID_TYPE ZIt;
     switch (CURRENT_TERMINAL) {
-      case 0: case 55:
+      case 0: case 56:
+	{
 	    ZRdirect_Hdeclarator (&ZIid, &ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	}
 	break;
-      case 71:
+      case 72:
+	{
 	    SID_TYPE ZIp;
 	    SID_TYPE ZIs;
 	    ZRptr_Hoperator (&ZIp);
 	    ZRdeclarator (&ZIid, &ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     (ZIt) = inject_type ( (ZIs), (ZIp) ) ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOid = ZIid;
     *ZOt = ZIt;
+}
 static void
-ZRidentifier PROTO_N ((ZOid))
-  PROTO_T (SID_IDENTIFIER *ZOid)
+ZRidentifier(SID_IDENTIFIER *ZOid)
+{
     SID_IDENTIFIER ZIid;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_STRING ZInm;
 	int ZIv;
 	ZRinternal_Hname (&ZInm, &ZIv);
-	ZR322 (&ZInm, &ZIv, &ZIid);
+	ZR324 (&ZInm, &ZIv, &ZIid);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOid = ZIid;
+}
 static void
-ZRsubset_Hcommand PROTO_N ((ZOc))
+ZRsubset_Hcommand(SID_COMMAND *ZOc)
-  PROTO_T (SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_STRING ZIs;
 	SID_COMMAND ZIa;
 	SID_COMMAND ZIb;
 	switch (CURRENT_TERMINAL) {
 	  case 23:
 	    break;
 	  default:
-	    goto ZL1;
-	}
-	ADVANCE_LEXER;
-	ZRsubset_Hname (&ZIs);
-	switch (CURRENT_TERMINAL) {
-	  case 59:
-	    break;
-	  case 74:
-	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+	ADVANCE_LEXER;
+	ZRsubset_Hname (&ZIs);
+	switch (CURRENT_TERMINAL) {
+	  case 60:
+	    break;
+	  case 75:
+	    RESTORE_LEXER;
+	    goto ZL1;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
+	{
 	object *q = search_hash ( subsets, nm, no_version ) ;
 	update_time ( p, q ) ;
+    }
     (ZIa) = crt_object ;
     crt_object = p ;
 	}
 	switch (CURRENT_TERMINAL) {
-	  case 53:
+	  case 54:
 	    break;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
 	ZRcommand_Hlist (&ZIb);
 	switch (CURRENT_TERMINAL) {
-	  case 54:
+	  case 55:
 	    break;
-	  case 74:
+	  case 75:
 	    RESTORE_LEXER;
 	    goto ZL1;
 	  default:
 	    goto ZL1;
 	}
 	ADVANCE_LEXER;
+	{
     object *p = crt_object ;
     if ( p ) p->u.u_info->elements = (ZIb) ;
     crt_object = (ZIa) ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOc = ZIc;
 }
 static void
-ZRqualified_Htype PROTO_N ((ZOt))
+ZRqualified_Htype(SID_TYPE *ZOt)
-  PROTO_T (SID_TYPE *ZOt)
 {
     SID_TYPE ZIt;
     switch (CURRENT_TERMINAL) {
-      case 0: case 31: case 33: case 34: case 36:
+      case 0: case 32: case 34: case 35: case 37:
-      case 37: case 38: case 41: case 42: case 43:
+      case 38: case 39: case 42: case 43: case 44:
-      case 44: case 45: case 46:
+      case 45: case 46: case 47:
 	{
-	    SID_TYPE ZI329;
+	    SID_TYPE ZI331;
-	    ZRsimple_Htype (&ZI329);
+	    ZRsimple_Htype (&ZI331);
-	    ZR331 (&ZI329, &ZIt);
+	    ZR333 (&ZI331, &ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
-      case 32: case 47:
+      case 33: case 48:
+	{
 	    unsigned ZIcv;
 	    SID_TYPE ZIs;
 	    ZRtype_Hqualifier (&ZIcv);
 	    ZRsimple_Htype (&ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
     (ZIt) = make_subtype ( (ZIs), TYPE_QUALIFIER ) ;
     (ZIt)->v.str = cv_qualifier [ (ZIcv) ] ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRabstract_Hdeclarator PROTO_N ((ZOnm, ZOt))
+ZRabstract_Hdeclarator(SID_STRING *ZOnm, SID_TYPE *ZOt)
-  PROTO_T (SID_STRING *ZOnm X SID_TYPE *ZOt)
+{
     SID_STRING ZInm;
     SID_TYPE ZIt;
     switch (CURRENT_TERMINAL) {
       default:
+	{
 	    ZRdirect_Habstract_Hdeclarator (&ZInm, &ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	}
 	break;
-      case 71:
+      case 72:
+	{
 	    SID_TYPE ZIp;
 	    SID_TYPE ZIs;
 	    ZRptr_Hoperator (&ZIp);
 	    ZRabstract_Hdeclarator (&ZInm, &ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
-		RESTORE_LEXER;
-		goto ZL1;
-	    }
-	    {
-    (ZIt) = inject_type ( (ZIs), (ZIp) ) ;
-	    }
-	}
-	break;
-      case 74:
-	return;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOnm = ZInm;
-    *ZOt = ZIt;
-}
-static void
-ZR306 PROTO_N ((ZI302, ZI303, ZO304, ZO305))
-  PROTO_T (SID_STRING ZI302 X SID_TYPE ZI303 X SID_STRING *ZO304 X SID_TYPE *ZO305)
-{
-    SID_STRING ZI304;
-    SID_TYPE ZI305;
-  ZL2_306:;
-    switch (CURRENT_TERMINAL) {
-      case 57:
-	{
-	    SID_STRING ZInm;
-	    SID_TYPE ZIs;
-	    SID_TYPE ZIt;
-	    ZInm = ZI302;
-	    ZRarray_Hoperator (&ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
+	    {
-    (ZIt) = inject_type ( (ZI303), (ZIs) ) ;
+    (ZIt) = inject_type ( (ZIs), (ZIp) ) ;
+	    }
-	    ZI302 = ZInm;
-	    ZI303 = ZIt;
-	    goto ZL2_306;
-	}
-	/*UNREACHED*/
-      default:
-	{
-	    ZI304 = ZI302;
-	    ZI305 = ZI303;
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZO304 = ZI304;
+    *ZOnm = ZInm;
-    *ZO305 = ZI305;
+    *ZOt = ZIt;
+}
 static void
-ZRparameter_Hlist PROTO_N ((ZOp))
+ZRparameter_Hlist(SID_TYPE *ZOp)
-  PROTO_T (SID_TYPE *ZOp)
+{
     SID_TYPE ZIp;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_TYPE ZIt;
 	SID_TYPE ZIq;
 	ZRparameter_Hdeclaration (&ZIt);
+	{
 	    switch (CURRENT_TERMINAL) {
-	      case 61:
+	      case 62:
+		{
 		    ADVANCE_LEXER;
-		    ZR337 (&ZIq);
+		    ZR339 (&ZIq);
-		    if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
 			RESTORE_LEXER;
 			goto ZL1;
+		    }
+		}
 		break;
     (ZIq) = null ;
+		    }
+		}
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
+	{
     (ZIp)->v.next = (ZIq) ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOp = ZIp;
+}
 static void
-ZRinternal_Hname PROTO_N ((ZOnm, ZOv))
-  PROTO_T (SID_STRING *ZOnm X int *ZOv)
+ZRinternal_Hname(SID_STRING *ZOnm, int *ZOv)
+{
     SID_STRING ZInm;
     int ZIv;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_STRING ZIa;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
 	ZRname_Hversion (&ZIv);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+	{
     if ( crt_field_name ) {
 	(ZInm) = string_printf ( "%s.%s", crt_field_name, (ZIa) ) ;
     } else {
 	(ZInm) = (ZIa) ;
     }
 	}
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOnm = ZInm;
     *ZOv = ZIv;
+}
+static void
+ZR308(SID_STRING ZI304, SID_TYPE ZI305, SID_STRING *ZO306, SID_TYPE *ZO307)
+{
+    SID_STRING ZI306;
+    SID_TYPE ZI307;
+  ZL2_308:;
+    switch (CURRENT_TERMINAL) {
+      case 58:
+	{
+	    SID_STRING ZInm;
+	    SID_TYPE ZIs;
+	    SID_TYPE ZIt;
+	    ZInm = ZI304;
+	    ZRarray_Hoperator (&ZIs);
+	    if ((CURRENT_TERMINAL) == 75) {
+		RESTORE_LEXER;
+		goto ZL1;
+	    }
+	    {
+    (ZIt) = inject_type ( (ZI305), (ZIs) ) ;
+	    }
+	    ZI304 = ZInm;
+	    ZI305 = ZIt;
+	    goto ZL2_308;
+	}
+	/*UNREACHED*/
+      default:
+	{
+	    ZI306 = ZI304;
+	    ZI307 = ZI305;
+	}
+	break;
+      case 75:
+	return;
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZO306 = ZI306;
+    *ZO307 = ZI307;
 }
 static void
-ZRmacro_Hoperator PROTO_N ((ZOt))
+ZRmacro_Hoperator(SID_TYPE *ZOt)
-  PROTO_T (SID_TYPE *ZOt)
+{
     SID_TYPE ZIt;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	switch (CURRENT_TERMINAL) {
-	  case 55:
+	  case 56:
 	    break;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
-	ZR348 (&ZIt);
+	ZR350 (&ZIt);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRenumerator_Hlist PROTO_N ((ZOc))
+ZRenumerator_Hlist(SID_COMMAND *ZOc)
-  PROTO_T (SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_COMMAND ZIa;
 	SID_COMMAND ZIb;
 	ZRenumerator (&ZIa);
+	{
 	    switch (CURRENT_TERMINAL) {
-	      case 61:
+	      case 62:
+		{
 		    ADVANCE_LEXER;
 		    ZRenumerator_Hlist (&ZIb);
-		    if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
 			RESTORE_LEXER;
 			goto ZL1;
+		    }
+		}
 		break;
     (ZIb) = null ;
+		    }
+		}
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
+	{
     (ZIc) = join_object ( (ZIa), (ZIb) ) ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOc = ZIc;
+}
 static void
-ZRexternal_Hname PROTO_N ((ZOnm, ZOv))
-  PROTO_T (SID_STRING *ZOnm X int *ZOv)
+ZRexternal_Hname(SID_STRING *ZOnm, int *ZOv)
+{
     SID_STRING ZInm;
     int ZIv;
     switch (CURRENT_TERMINAL) {
       case 0:
+	{
 	    SID_STRING ZIa;
 	    SID_STRING ZIb;
 	    {
  ZIa = token_value ;
 	    }
 	    ADVANCE_LEXER;
 	    ZRname_Hversion (&ZIv);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     if ( crt_field_name ) {
 	(ZIb) = string_printf ( "%s.%s", crt_field_name, (ZIa) ) ;
     } else {
 	(ZIb) = (ZIa) ;
     }
 	    }
+	    {
     (ZInm) = token_name ( (ZIb) ) ;
 	    }
 	}
 	break;
       case 2:
+	{
+	    {
  ZInm = token_value ;
 	    }
 	    ADVANCE_LEXER;
 	    ZRname_Hversion (&ZIv);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOnm = ZInm;
     *ZOv = ZIv;
 }
 static void
-ZRtype_Hqualifier PROTO_N ((ZOcv))
+ZRtype_Hqualifier(unsigned *ZOcv)
-  PROTO_T (unsigned *ZOcv)
 {
     unsigned ZIcv;
     switch (CURRENT_TERMINAL) {
-      case 32:
+      case 33:
 	{
 	    unsigned ZIa;
 	    ADVANCE_LEXER;
 	    ZRtype_Hqualifier_Hopt (&ZIa);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     if ( (ZIa) & 1 ) error ( ERR_SERIOUS, "Duplicate type qualifier" ) ;
     (ZIcv) = ( (ZIa) | 1 ) ;
 	    }
 	}
 	break;
-      case 47:
+      case 48:
+	{
 	    unsigned ZIa;
 	    ADVANCE_LEXER;
 	    ZRtype_Hqualifier_Hopt (&ZIa);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     if ( (ZIa) & 2 ) error ( ERR_SERIOUS, "Duplicate type qualifier" ) ;
     (ZIcv) = ( (ZIa) | 2 ) ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOcv = ZIcv;
-}
-static void
-ZR316 PROTO_N ((ZI310, ZI311, ZO314, ZO315))
-  PROTO_T (SID_IDENTIFIER ZI310 X SID_TYPE ZI311 X SID_IDENTIFIER *ZO314 X SID_TYPE *ZO315)
-{
-    SID_IDENTIFIER ZI314;
-    SID_TYPE ZI315;
-  ZL2_316:;
-    switch (CURRENT_TERMINAL) {
-      case 55: case 57:
-	{
-	    SID_IDENTIFIER ZIid;
-	    ZIid = ZI310;
-	    {
-		switch (CURRENT_TERMINAL) {
-		  case 57:
-		    {
-			SID_TYPE ZIs;
-			SID_TYPE ZIt;
-			ZRarray_Hoperator (&ZIs);
-			if ((CURRENT_TERMINAL) == 74) {
-			    RESTORE_LEXER;
-			    goto ZL1;
-			}
-			{
-    (ZIt) = inject_type ( (ZI311), (ZIs) ) ;
-			}
-			ZI310 = ZIid;
-			ZI311 = ZIt;
-			goto ZL2_316;
-		    }
-		    /*UNREACHED*/
-		  case 55:
-		    {
-			SID_TYPE ZIs;
-			SID_TYPE ZIt;
-			ZRfunction_Hoperator (&ZIs);
-			if ((CURRENT_TERMINAL) == 74) {
-			    RESTORE_LEXER;
-			    goto ZL1;
-			}
-			{
-    (ZIt) = inject_type ( (ZI311), (ZIs) ) ;
-			}
-			ZI310 = ZIid;
-			ZI311 = ZIt;
-			goto ZL2_316;
-		    }
-		    /*UNREACHED*/
-		  default:
-		    goto ZL1;
-		}
-	    }
-	}
-	/*UNREACHED*/
-      default:
-	{
-	    ZI314 = ZI310;
-	    ZI315 = ZI311;
-	}
-	break;
-      case 74:
-	return;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZO314 = ZI314;
-    *ZO315 = ZI315;
+    *ZOcv = ZIcv;
+}
 static void
-ZRtype_Hkey PROTO_N ((ZOtag))
+ZRtype_Hkey(int *ZOtag)
-  PROTO_T (int *ZOtag)
+{
     int ZItag;
     switch (CURRENT_TERMINAL) {
-      case 34:
+      case 35:
 	{
 	    ADVANCE_LEXER;
+	    {
  (ZItag) = TYPE_ENUM_TAG ;
+	    }
+	}
 	break;
-      case 43:
+      case 44:
+	{
 	    ADVANCE_LEXER;
+	    {
  (ZItag) = TYPE_STRUCT_TAG ;
 	    }
 	}
 	break;
-      case 44:
+      case 45:
+	{
 	    ADVANCE_LEXER;
+	    {
  (ZItag) = TYPE_UNION_TAG ;
+	    }
+	    {
  (ZItag) = TYPE_GENERIC ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     *ZOtag = ZItag;
+}
 static void
-ZRtype_Hqualifier_Hopt PROTO_N ((ZOcv))
+ZRtype_Hqualifier_Hopt(unsigned *ZOcv)
-  PROTO_T (unsigned *ZOcv)
+{
     unsigned ZIcv;
     switch (CURRENT_TERMINAL) {
-      case 32: case 47:
+      case 33: case 48:
+	{
 	    ZRtype_Hqualifier (&ZIcv);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
     (ZIcv) = 0 ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOcv = ZIcv;
+}
 static void
-ZRconstant_Hvalue PROTO_N ((ZOs))
+ZRconstant_Hvalue(SID_STRING *ZOs)
-  PROTO_T (SID_STRING *ZOs)
+{
     SID_STRING ZIs;
     switch (CURRENT_TERMINAL) {
-      case 66:
+      case 67:
 	{
 	    SID_STRING ZIa;
 	    ADVANCE_LEXER;
 	    ZRconstant_Hvalue (&ZIa);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     (ZIs) = string_concat ( "!", (ZIa) ) ;
 	    }
 	}
 	break;
       case 5:
 	{
 	    {
  ZIs = token_value ;
 	    }
 	    ADVANCE_LEXER;
 	}
 	break;
-      case 67:
+      case 68:
 	{
 	    SID_STRING ZIa;
 	    ADVANCE_LEXER;
 	    ZRconstant_Hvalue (&ZIa);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
 	error ( ERR_SERIOUS, "Undefined NAT, '%s'", (ZIa) ) ;
     } else if ( p->objtype != OBJ_NAT ) {
 	error ( ERR_SERIOUS, "'%s' is not a NAT", (ZIa) ) ;
+    }
     (ZIs) = (ZIa) ;
 	    }
 	}
 	break;
       case 1:
 	{
 	    {
  ZIs = token_value ;
 	    }
 	    ADVANCE_LEXER;
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOs = ZIs;
+}
 static void
-ZR318 PROTO_N ((ZIa, ZOs))
-  PROTO_T (SID_STRING *ZIa X SID_STRING *ZOs)
+ZR318(SID_IDENTIFIER ZI312, SID_TYPE ZI313, SID_IDENTIFIER *ZO316, SID_TYPE *ZO317)
+{
+    SID_IDENTIFIER ZI316;
-    SID_STRING ZIs;
+    SID_TYPE ZI317;
+  ZL2_318:;
     switch (CURRENT_TERMINAL) {
-      case 61:
+      case 56: case 58:
 	{
-	    SID_STRING ZIb;
+	    SID_IDENTIFIER ZIid;
+	    ZIid = ZI312;
+	    {
+		switch (CURRENT_TERMINAL) {
+		  case 58:
+		    {
+			SID_TYPE ZIs;
+			SID_TYPE ZIt;
+			ZRarray_Hoperator (&ZIs);
+			if ((CURRENT_TERMINAL) == 75) {
+			    RESTORE_LEXER;
+			    goto ZL1;
+			}
+			{
+    (ZIt) = inject_type ( (ZI313), (ZIs) ) ;
+			}
+			ZI312 = ZIid;
+			ZI313 = ZIt;
+			goto ZL2_318;
+		    }
+		    /*UNREACHED*/
+		  case 56:
+		    {
+			SID_TYPE ZIs;
+			SID_TYPE ZIt;
+			ZRfunction_Hoperator (&ZIs);
+			if ((CURRENT_TERMINAL) == 75) {
+			    RESTORE_LEXER;
+			    goto ZL1;
+			}
+			{
+    (ZIt) = inject_type ( (ZI313), (ZIs) ) ;
+			}
-	    ADVANCE_LEXER;
+			ZI312 = ZIid;
-	    switch (CURRENT_TERMINAL) {
+			ZI313 = ZIt;
-	      case 2:
+			goto ZL2_318;
-		{
+		    }
+		    /*UNREACHED*/
+		  default:
- ZIb = token_value ;
+		    goto ZL1;
+		}
-		break;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    ZR319 (ZIa, &ZIb, &ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
-		RESTORE_LEXER;
-		goto ZL1;
+	    }
+	}
-	break;
+	/*UNREACHED*/
       default:
+	{
-	    {
+	    ZI316 = ZI312;
-    (ZIs) = subset_name ( (*ZIa), null_str, null_str ) ;
-	    }
+	    ZI317 = ZI313;
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
+    *ZO316 = ZI316;
-    *ZOs = ZIs;
+    *ZO317 = ZI317;
+}
 static void
-ZRspec_Hcommand PROTO_N ((ZOc))
+ZRspec_Hcommand(SID_COMMAND *ZOc)
-  PROTO_T (SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
     switch (CURRENT_TERMINAL) {
       case 7:
 	    ADVANCE_LEXER;
 	    ZRidentifier (&ZIid);
 	    ZRdefine_Hparam_Hclause (&ZIp);
 	    ZRconstant_Hvalue (&ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     char *def ;
     object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_DEFINE ) ;
+    if ( (ZIp) ) {
+	if ( *(ZIp) ) {
+	    def = string_printf ( "( %s ) %s", (ZIp), (ZIs) ) ;
+	} else {
+	    def = string_printf ( "() %s", (ZIs) ) ;
+	}
+    } else {
+	def = string_printf ( " %s", (ZIs) ) ;
+    }
+    p->u.u_str = def ;
+    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_EXTERN ) ;
+	    }
+	}
+	break;
+      case 30:
+	{
+	    SID_IDENTIFIER ZIid;
+	    SID_STRING ZIp;
+	    SID_STRING ZIs;
+	    ADVANCE_LEXER;
+	    ZRidentifier (&ZIid);
+	    ZRdefine_Hparam_Hclause (&ZIp);
+	    ZRconstant_Hvalue (&ZIs);
+	    if ((CURRENT_TERMINAL) == 75) {
+		RESTORE_LEXER;
+		goto ZL1;
+	    }
+	    {
+    char *def ;
+    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_DEFMIN ) ;
     if ( (ZIp) ) {
 	if ( *(ZIp) ) {
 	    def = string_printf ( "( %s ) %s", (ZIp), (ZIs) ) ;
 	} else {
 	    def = string_printf ( "() %s", (ZIs) ) ;
 	    SID_IDENTIFIER ZIid;
 	    SID_COMMAND ZIe;
 	    ADVANCE_LEXER;
 	    ZRenum_Hcommand (&ZItag);
 	    ZRidentifier (&ZIid);
 	    switch (CURRENT_TERMINAL) {
-	      case 59:
+	      case 60:
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
 	    }
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 53:
+	      case 54:
 		break;
 	      default:
 		goto ZL1;
 	    }
 	    ADVANCE_LEXER;
 	    ZRenumerator_Hlist (&ZIe);
 	    switch (CURRENT_TERMINAL) {
-	      case 54:
+	      case 55:
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
+	    {
 	    ADVANCE_LEXER;
 	    ZRtype_Hcommand (&ZItag);
 	    ZRidentifier (&ZIid);
 	    ZRfield_Hexact (&ZIe);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
 	    error ( ERR_SERIOUS, "Illegal field type, '%s'", (ZIid).iname ) ;
 	    break ;
+	}
+    }
     crt_field_name = (ZIt)->u.obj->name ;
 	    }
 	    switch (CURRENT_TERMINAL) {
-	      case 53:
+	      case 54:
 		break;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    ZRfield_Hlist (ZIt, &ZIb);
 	    switch (CURRENT_TERMINAL) {
-	      case 54:
+	      case 55:
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
+	    }
 	    char *nm = crt_field_name ;
 	    error ( ERR_SERIOUS, "Redefinition of type '%s'", nm ) ;
+	}
 	if ( (ZIb) == null ) {
 	    error ( ERR_SERIOUS, "Empty struct/union definition" ) ;
 	} else {
 	    (ZIt)->v.obj2 = (ZIb) ;
+	}
 	if ( (ZIa) == null ) {
 	    /* This is a hack, do properly later */
 	    (ZIc) = make_object ( null_str, OBJ_TYPE ) ;
+	    {
  (ZIcmd) = OBJ_IMPLEMENT ;
+	    }
 	    ZRsubset_Hname (&ZIs);
 	    ZRsubset_Hkey (&ZIkey);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
     object *p = make_subset ( (ZIs) ) ;
     update_time ( crt_object, p ) ;
     (ZIc) = make_object ( (ZIkey), (ZIcmd) ) ;
     (ZIc)->u.u_obj = p ;
+	    }
 	    ADVANCE_LEXER;
 	    ZRobject_Hqualifier (&ZIlv);
 	    ZRqualified_Htype (&ZIs);
 	    ZRmacro_Hdeclarator (&ZIid, &ZIp);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
     (ZIu) = inject_type ( (ZIp), (ZIs) ) ;
 	    }
 	    {
     (ZIv) = make_subtype ( (ZIu), (ZIlv) ) ;
 	    }
-	    ZR285 (&ZIq);
+	    ZR287 (&ZIq);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
 	    {
     (ZIt) = inject_type ( (ZIq), (ZIv) ) ;
 	    }
+	    {
     object *p ;
     int cmd = OBJ_MACRO ;
     if ( (ZIt)->id != TYPE_PROC ) cmd = OBJ_EXP ;
 	break;
       case 22:
+	{
 	    ADVANCE_LEXER;
 	    ZRnat_Hdeclarator_Hlist (&ZIc);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
       case 24:
 	{
 	    SID_IDENTIFIER ZIid;
 	    SID_TYPE ZIt;
 	    ADVANCE_LEXER;
 	    ZRidentifier (&ZIid);
-	    ZR285 (&ZIt);
+	    ZR287 (&ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
 	      case 5:
+		{
  ZIs = token_value ;
+		}
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
+	    }
 	break;
       case 27:
+	{
 	    ADVANCE_LEXER;
 	    ZRtype_Hdeclarator_Hlist (&ZIc);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
       case 28:
+	{
 	    ADVANCE_LEXER;
-	    ZR320 (&ZIc);
+	    ZR322 (&ZIc);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
 	    ADVANCE_LEXER;
+	    {
  (ZIcmd) = OBJ_USE ;
+	    }
-	    ZR321 (&ZIcmd, &ZIc);
+	    ZR323 (&ZIcmd, &ZIc);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
 	    int ZIlv;
 	    SID_TYPE ZIt;
 	    ZRexp_Hcommand (&ZIcmd);
 	    ZRobject_Hqualifier (&ZIlv1);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
 	(ZIlv) = (ZIlv1) ;
+    }
+	    }
 	    ZRqualified_Htype (&ZIt);
 	    ZRexp_Hdeclarator_Hlist (ZIcmd, ZIt, ZIlv, &ZIc);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
 	    SID_TYPE ZIt;
 	    ZRfunc_Hcommand (&ZIcmd);
 	    ZRqualified_Htype (&ZIs);
 	    ZRdeclarator (&ZIid, &ZIp);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
     (ZIt) = inject_type ( (ZIp), (ZIs) ) ;
 	    }
+	    {
     object *p = make_exp ( (ZIid).iname, (ZIid).ivers, (ZIcmd) ) ;
     p->u.u_type = check_type ( (ZIt), OBJ_FUNC ) ;
     (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, (ZIcmd) ) ;
 	    }
 	}
 	break;
       case 23:
 	{
 	    ZRsubset_Hcommand (&ZIc);
+	    if ((CURRENT_TERMINAL) == 75) {
+		RESTORE_LEXER;
+		goto ZL1;
+	    }
+	}
+	break;
+      case 75:
+	return;
+      default:
+	goto ZL1;
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOc = ZIc;
+}
+static void
+ZRfunc_Hcommand(int *ZOcmd)
+{
+    int ZIcmd;
+    if ((CURRENT_TERMINAL) == 75) {
+	return;
+    }
+    {
+	switch (CURRENT_TERMINAL) {
+	  case 15:
+	    break;
+	  default:
+	    goto ZL1;
+	}
+	ADVANCE_LEXER;
+	ZR348 (&ZIcmd);
+	if ((CURRENT_TERMINAL) == 75) {
+	    RESTORE_LEXER;
+	    goto ZL1;
+	}
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOcmd = ZIcmd;
+}
+static void
+ZR320(SID_STRING *ZIa, SID_STRING *ZOs)
+{
+    SID_STRING ZIs;
+    switch (CURRENT_TERMINAL) {
+      case 62:
+	{
+	    SID_STRING ZIb;
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 2:
+		{
+ ZIb = token_value ;
+		}
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    ZR321 (ZIa, &ZIb, &ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
+      default:
+	{
+	    {
+    (ZIs) = subset_name ( (*ZIa), null_str, null_str ) ;
+	    }
+	}
+	break;
-      case 74:
+      case 75:
 	return;
-      default:
-	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZOc = ZIc;
+    *ZOs = ZIs;
+}
 static void
-ZR319 PROTO_N ((ZIa, ZIb, ZOs))
-  PROTO_T (SID_STRING *ZIa X SID_STRING *ZIb X SID_STRING *ZOs)
+ZR321(SID_STRING *ZIa, SID_STRING *ZIb, SID_STRING *ZOs)
+{
     SID_STRING ZIs;
     switch (CURRENT_TERMINAL) {
-      case 61:
+      case 62:
+	{
 	    SID_STRING ZIc;
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
 	    ADVANCE_LEXER;
+	    {
     if ( (*ZIb) [0] == 0 ) (*ZIb) = null ;
     (ZIs) = subset_name ( (*ZIa), (*ZIb), (ZIc) ) ;
 	    }
 	}
 	break;
       default:
 	{
 	    {
     (ZIs) = subset_name ( (*ZIa), (*ZIb), null_str ) ;
 	    }
 	}
 	break;
-      case 74:
+      case 75:
 	return;
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOs = ZIs;
 }
 static void
-ZRfunc_Hcommand PROTO_N ((ZOcmd))
+ZRarray_Hoperator(SID_TYPE *ZOt)
-  PROTO_T (int *ZOcmd)
 {
-    int ZIcmd;
+    SID_TYPE ZIt;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
     }
     {
+	SID_STRING ZIa;
 	switch (CURRENT_TERMINAL) {
-	  case 15:
+	  case 58:
 	    break;
 	  default:
 	    goto ZL1;
 	}
 	ADVANCE_LEXER;
+	{
+	    switch (CURRENT_TERMINAL) {
+	      case 0: case 1: case 5: case 67: case 68:
+		{
-	ZR346 (&ZIcmd);
+		    ZRconstant_Hvalue (&ZIa);
-	if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
-	    RESTORE_LEXER;
+			RESTORE_LEXER;
+			goto ZL1;
+		    }
+		}
+		break;
+	      default:
+		{
+		    {
+    (ZIa) = "" ;
+		    }
+		}
+		break;
+	    }
+	}
+	switch (CURRENT_TERMINAL) {
+	  case 59:
+	    break;
+	  default:
 	    goto ZL1;
+	}
+	ADVANCE_LEXER;
+	{
+    (ZIt) = make_subtype ( ( type * ) null, TYPE_ARRAY ) ;
+    (ZIt)->v.str = (ZIa) ;
 	}
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZOcmd = ZIcmd;
+    *ZOt = ZIt;
 }
 static void
-ZR320 PROTO_N ((ZOc))
-  PROTO_T (SID_COMMAND *ZOc)
+ZR322(SID_COMMAND *ZOc)
 {
     SID_COMMAND ZIc;
     switch (CURRENT_TERMINAL) {
-      case 50:
+      case 51:
 	{
 	    SID_TYPE ZIt;
 	    SID_IDENTIFIER ZIid;
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 55:
+	      case 56:
 		break;
 	      default:
 		goto ZL1;
 	    }
 	    ADVANCE_LEXER;
 	    ZRqualified_Htype (&ZIt);
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    ZRidentifier (&ZIid);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     t->v.next = s ;
     (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, t->u.obj, OBJ_EXTERN ) ;
+	    }
+	}
 	break;
-      case 52:
+      case 53:
+	{
 	    SID_STRING ZIs;
 	    SID_TYPE ZIt;
 	    SID_IDENTIFIER ZIid;
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 55:
+	      case 56:
 		break;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    {
     (ZIt) = special_type ( (ZIs) ) ;
+	    }
 	    ZRidentifier (&ZIid);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
     type *t = make_type ( (ZIid).iname, (ZIid).ivers, TYPE_DEFINED ) ;
     t->v.next = check_type ( (ZIt), OBJ_TYPE ) ;
     (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, t->u.obj, OBJ_EXTERN ) ;
 	    }
+	}
 	break;
-      case 0: case 31: case 32: case 33: case 34:
+      case 0: case 32: case 33: case 34: case 35:
-      case 36: case 37: case 38: case 41: case 42:
+      case 37: case 38: case 39: case 42: case 43:
-      case 43: case 44: case 45: case 46: case 47:
+      case 44: case 45: case 46: case 47: case 48:
+	{
 	    SID_TYPE ZIs;
 	    SID_IDENTIFIER ZIid;
 	    SID_TYPE ZIp;
 	    SID_TYPE ZIt;
 	    ZRqualified_Htype (&ZIs);
 	    ZRdeclarator (&ZIid, &ZIp);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
     (ZIt) = inject_type ( (ZIp), (ZIs) ) ;
 	    }
 	    {
     type *t = make_type ( (ZIid).iname, (ZIid).ivers, TYPE_DEFINED ) ;
     t->v.next = check_type ( (ZIt), OBJ_TYPE ) ;
     (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, t->u.obj, OBJ_EXTERN ) ;
 	    }
 	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOc = ZIc;
+}
 static void
-ZR321 PROTO_N ((ZIcmd, ZOc))
-  PROTO_T (int *ZIcmd X SID_COMMAND *ZOc)
+ZR323(int *ZIcmd, SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
     switch (CURRENT_TERMINAL) {
       case 2:
 	{
 	    SID_STRING ZIs;
 	    SID_STRING ZIkey;
 	    ZRsubset_Hname (&ZIs);
 	    ZRsubset_Hkey (&ZIkey);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     (ZIc) = make_object ( (ZIkey), (*ZIcmd) ) ;
     (ZIc)->u.u_obj = p ;
+	    }
+	}
 	break;
-      case 55:
+      case 56:
+	{
 	    SID_STRING ZIs;
 	    SID_STRING ZIkey1;
 	    SID_STRING ZIkey;
 	    ZRuse_Hsubset_Hname (&ZIs);
 	    ZRsubset_Hkey (&ZIkey1);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
  (ZIkey) = string_concat ( (ZIkey1), "G" ) ;
+	    }
+	    {
     object *p = make_subset ( (ZIs) ) ;
     (ZIc) = make_object ( (ZIkey), (*ZIcmd) ) ;
     (ZIc)->u.u_obj = p ;
+	    }
+	}
 	break;
-      case 74:
-	return;
-      default:
-	goto ZL1;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOc = ZIc;
-}
-static void
-ZRarray_Hoperator PROTO_N ((ZOt))
-  PROTO_T (SID_TYPE *ZOt)
-{
-    SID_TYPE ZIt;
-    if ((CURRENT_TERMINAL) == 74) {
-	return;
-    }
-    {
-	SID_STRING ZIa;
-	switch (CURRENT_TERMINAL) {
-	  case 57:
-	    break;
-	  default:
-	    goto ZL1;
-	}
-	ADVANCE_LEXER;
-	{
-	    switch (CURRENT_TERMINAL) {
-	      case 0: case 1: case 5: case 66: case 67:
-		{
-		    ZRconstant_Hvalue (&ZIa);
-		    if ((CURRENT_TERMINAL) == 74) {
-			RESTORE_LEXER;
-			goto ZL1;
-		    }
-		}
-		break;
-	      default:
-		{
-		    {
-    (ZIa) = "" ;
-		    }
-		}
-		break;
-	    }
-	}
-	switch (CURRENT_TERMINAL) {
-	  case 58:
-	    break;
-	  default:
-	    goto ZL1;
-	}
-	ADVANCE_LEXER;
-	{
-    (ZIt) = make_subtype ( ( type * ) null, TYPE_ARRAY ) ;
-    (ZIt)->v.str = (ZIa) ;
-	}
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOt = ZIt;
-}
-static void
-ZR322 PROTO_N ((ZInm, ZIv, ZOid))
-  PROTO_T (SID_STRING *ZInm X int *ZIv X SID_IDENTIFIER *ZOid)
-{
-    SID_IDENTIFIER ZIid;
-    switch (CURRENT_TERMINAL) {
-      case 68:
-	{
-	    SID_STRING ZItnm;
-	    int ZItv;
-	    ADVANCE_LEXER;
-	    ZRexternal_Hname (&ZItnm, &ZItv);
-	    if ((CURRENT_TERMINAL) == 74) {
-		RESTORE_LEXER;
-		goto ZL1;
-	    }
-	    {
-    (ZIid).iname = (*ZInm) ;
-    (ZIid).ivers = (*ZIv) ;
-    (ZIid).ename = (ZItnm) ;
-    (ZIid).evers = (ZItv) ;
-	    }
-	}
-	break;
-      default:
-	{
-	    SID_STRING ZItnm;
-	    {
-    (ZItnm) = token_name ( (*ZInm) ) ;
-	    }
-	    {
-    (ZIid).iname = (*ZInm) ;
-    (ZIid).ivers = (*ZIv) ;
-    (ZIid).ename = (ZItnm) ;
-    (ZIid).evers = (*ZIv) ;
-	    }
-	}
-	break;
-      case 74:
+      case 75:
-	return;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOid = ZIid;
-}
-static void
-ZR323 PROTO_N ((ZOp))
-  PROTO_T (SID_STRING *ZOp)
-{
-    SID_STRING ZIp;
-    switch (CURRENT_TERMINAL) {
-      case 56:
-	{
-	    ADVANCE_LEXER;
-	    {
- (ZIp) = "" ;
-	    }
-	}
-	break;
-      case 0:
-	{
-	    ZRdefine_Hparam_Hlist (&ZIp);
-	    switch (CURRENT_TERMINAL) {
-	      case 56:
-		break;
-	      case 74:
-		RESTORE_LEXER;
-		goto ZL1;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	}
-	break;
-      case 74:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZOp = ZIp;
+    *ZOc = ZIc;
+}
 static void
-ZRmacro_Hparam_Hlist PROTO_N ((ZOp))
+ZRmacro_Hparam_Hlist(SID_TYPE *ZOp)
-  PROTO_T (SID_TYPE *ZOp)
+{
     SID_TYPE ZIp;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_TYPE ZIt;
 	SID_TYPE ZIq;
 	ZRmacro_Hparam_Hdeclaration (&ZIt);
+	{
 	    switch (CURRENT_TERMINAL) {
-	      case 61:
+	      case 62:
+		{
 		    ADVANCE_LEXER;
 		    ZRmacro_Hparam_Hlist (&ZIq);
-		    if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
 			RESTORE_LEXER;
 			goto ZL1;
 		    }
+		}
 		break;
 	      default:
+		{
+		    {
     (ZIq) = null ;
+		    }
+		}
 		break;
-	      case 74:
+	      case 75:
-		RESTORE_LEXER;
-		goto ZL1;
-	    }
-	}
-	{
-    (ZIp) = make_subtype ( (ZIt), TYPE_LIST ) ;
-    (ZIp)->v.next = (ZIq) ;
-	}
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOp = ZIp;
-}
-static void
-ZR326 PROTO_N ((ZI324, ZOp))
-  PROTO_T (SID_STRING *ZI324 X SID_STRING *ZOp)
-{
-    SID_STRING ZIp;
-    switch (CURRENT_TERMINAL) {
-      case 61:
-	{
-	    SID_STRING ZIq;
-	    ADVANCE_LEXER;
-	    ZRdefine_Hparam_Hlist (&ZIq);
-	    if ((CURRENT_TERMINAL) == 74) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
-	    {
+	{
-    (ZIp) = string_printf ( "%s, %s", (*ZI324), (ZIq) ) ;
+    (ZIp) = make_subtype ( (ZIt), TYPE_LIST ) ;
-	    }
-	}
-	break;
-      default:
-	{
-	    ZIp = *ZI324;
+    (ZIp)->v.next = (ZIq) ;
 	}
-	break;
-      case 74:
-	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOp = ZIp;
+}
 static void
-ZR327 PROTO_N ((ZOcmd))
-  PROTO_T (int *ZOcmd)
+ZR324(SID_STRING *ZInm, int *ZIv, SID_IDENTIFIER *ZOid)
+{
-    int ZIcmd;
+    SID_IDENTIFIER ZIid;
     switch (CURRENT_TERMINAL) {
-      case 55:
+      case 69:
+	{
+	    SID_STRING ZItnm;
+	    int ZItv;
 	    ADVANCE_LEXER;
-	    ZR328 (&ZIcmd);
+	    ZRexternal_Hname (&ZItnm, &ZItv);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
+    (ZIid).iname = (*ZInm) ;
+    (ZIid).ivers = (*ZIv) ;
+    (ZIid).ename = (ZItnm) ;
+    (ZIid).evers = (ZItv) ;
+	    }
+	}
 	break;
       default:
 	{
+	    SID_STRING ZItnm;
+	    {
+    (ZItnm) = token_name ( (*ZInm) ) ;
+	    }
 	    {
+    (ZIid).iname = (*ZInm) ;
+    (ZIid).ivers = (*ZIv) ;
- (ZIcmd) = OBJ_EXP ;
+    (ZIid).ename = (ZItnm) ;
+    (ZIid).evers = (*ZIv) ;
 	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZOcmd = ZIcmd;
+    *ZOid = ZIid;
+}
 static void
-ZR328 PROTO_N ((ZOcmd))
+ZR325(SID_STRING *ZOp)
-  PROTO_T (int *ZOcmd)
+{
-    int ZIcmd;
+    SID_STRING ZIp;
     switch (CURRENT_TERMINAL) {
-      case 32:
+      case 57:
 	{
-	    ADVANCE_LEXER;
-	    switch (CURRENT_TERMINAL) {
-	      case 56:
-		break;
-	      default:
-		goto ZL1;
-	    }
 	    ADVANCE_LEXER;
+	    {
- (ZIcmd) = OBJ_CONST ;
+ (ZIp) = "" ;
 	    }
 	}
 	break;
-      case 35:
+      case 0:
 	{
-	    ADVANCE_LEXER;
+	    ZRdefine_Hparam_Hlist (&ZIp);
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
+	      case 75:
+		RESTORE_LEXER;
+		goto ZL1;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
+	}
+	break;
+      case 75:
+	return;
+      default:
+	goto ZL1;
-	    {
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOp = ZIp;
+}
+static void
+ZR328(SID_STRING *ZI326, SID_STRING *ZOp)
+{
+    SID_STRING ZIp;
- (ZIcmd) = OBJ_EXTERN ;
+    switch (CURRENT_TERMINAL) {
+      case 62:
+	{
+	    SID_STRING ZIq;
+	    ADVANCE_LEXER;
+	    ZRdefine_Hparam_Hlist (&ZIq);
+	    if ((CURRENT_TERMINAL) == 75) {
+		RESTORE_LEXER;
+		goto ZL1;
+	    }
+	    {
+    (ZIp) = string_printf ( "%s, %s", (*ZI326), (ZIq) ) ;
+	    }
+	}
+	break;
+      default:
+	{
+	    ZIp = *ZI326;
+	}
 	break;
-      case 74:
+      case 75:
 	return;
-      default:
-	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZOcmd = ZIcmd;
+    *ZOp = ZIp;
+}
 static void
-ZRenum_Hcommand PROTO_N ((ZOtag))
+ZRenum_Hcommand(int *ZOtag)
-  PROTO_T (int *ZOtag)
+{
     int ZItag;
     switch (CURRENT_TERMINAL) {
-      case 34:
+      case 35:
+	{
 	    ADVANCE_LEXER;
 	    {
  (ZItag) = TYPE_ENUM_TAG ;
+	    }
+	}
 	break;
       default:
+	{
+	    {
  (ZItag) = TYPE_ENUM ;
 	    }
 	}
 	break;
-      case 74:
+      case 75:
 	return;
     }
     *ZOtag = ZItag;
 }
 static void
-ZRenumerator PROTO_N ((ZOc))
-  PROTO_T (SID_COMMAND *ZOc)
+ZRenumerator(SID_COMMAND *ZOc)
 {
     SID_COMMAND ZIc;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
     }
     {
 	SID_IDENTIFIER ZIid;
 	SID_STRING ZIs;
 	ZRidentifier (&ZIid);
+	{
 	    switch (CURRENT_TERMINAL) {
-	      case 65:
+	      case 66:
+		{
 		    ADVANCE_LEXER;
 		    ZRconstant_Hvalue (&ZIs);
-		    if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
 			RESTORE_LEXER;
 			goto ZL1;
+		    }
+		}
 		break;
     (ZIs) = "" ;
+		    }
+		}
 		break;
-	      case 74:
+	      case 75:
+		RESTORE_LEXER;
+		goto ZL1;
+	    }
+	}
+	{
+    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_ENUMVAL ) ;
+    p->u.u_str = (ZIs) ;
+    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_EXTERN ) ;
+	}
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOc = ZIc;
+}
+static void
+ZR329(int *ZOcmd)
+{
+    int ZIcmd;
+    switch (CURRENT_TERMINAL) {
+      case 56:
+	{
+	    ADVANCE_LEXER;
+	    ZR330 (&ZIcmd);
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
+	break;
+      default:
+	{
+	    {
-    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_ENUMVAL ) ;
+ (ZIcmd) = OBJ_EXP ;
-    p->u.u_str = (ZIs) ;
+	    }
-    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_EXTERN ) ;
 	}
+	break;
+      case 75:
+	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZOc = ZIc;
+    *ZOcmd = ZIcmd;
+}
 static void
-ZRfield_Hdeclarator_Hlist PROTO_N ((ZIm, ZIs, ZOc))
-  PROTO_T (SID_TYPE ZIm X SID_TYPE ZIs X SID_COMMAND *ZOc)
+ZRfield_Hdeclarator_Hlist(SID_TYPE ZIm, SID_TYPE ZIs, SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_IDENTIFIER ZIid;
 	SID_TYPE ZIp;
 	SID_TYPE ZIt;
 	SID_COMMAND ZIa;
 	SID_COMMAND ZIb;
 	ZRfield_Hdeclarator (&ZIid, &ZIp);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
 	}
 	{
     (ZIt) = inject_type ( (ZIp), (ZIs) ) ;
 	}
 	{
     type *t = check_type ( (ZIt), OBJ_FIELD ) ;
     field *f = make_field ( (ZIid).iname, (ZIid).ivers, (ZIm), t ) ;
     (ZIa) = make_token ( (ZIid).ename, (ZIid).evers, f->obj, OBJ_FIELD ) ;
 	}
+	{
 	    switch (CURRENT_TERMINAL) {
-	      case 61:
+	      case 62:
 		{
 		    ADVANCE_LEXER;
 		    ZRfield_Hdeclarator_Hlist (ZIm, ZIs, &ZIb);
-		    if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
 			RESTORE_LEXER;
 			goto ZL1;
 		    }
 		}
 		break;
 	      default:
+		{
+		    {
     (ZIb) = null ;
+		    }
+		}
 		break;
 	    }
 	}
 	{
     (ZIc) = join_object ( (ZIa), (ZIb) ) ;
 	}
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOc = ZIc;
 }
+static void
+ZR330(int *ZOcmd)
+{
+    int ZIcmd;
+    switch (CURRENT_TERMINAL) {
+      case 33:
+	{
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 57:
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    {
+ (ZIcmd) = OBJ_CONST ;
+	    }
+	}
+	break;
+      case 36:
+	{
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 57:
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    {
+ (ZIcmd) = OBJ_EXTERN ;
+	    }
+	}
+	break;
+      case 75:
+	return;
+      default:
+	goto ZL1;
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOcmd = ZIcmd;
+}
 static void
-ZR331 PROTO_N ((ZI329, ZOt))
+ZRfield_Hexact(int *ZOe)
+{
+    int ZIe;
+    switch (CURRENT_TERMINAL) {
+      case 60:
+	{
+	    ADVANCE_LEXER;
+	    {
+ (ZIe) = 1 ;
+	    }
+	}
+	break;
+      default:
+	{
+	    {
+ (ZIe) = 0 ;
+	    }
+	}
+	break;
+      case 75:
+	return;
+    }
+    *ZOe = ZIe;
+}
+static void
-  PROTO_T (SID_TYPE *ZI329 X SID_TYPE *ZOt)
+ZR333(SID_TYPE *ZI331, SID_TYPE *ZOt)
 {
     SID_TYPE ZIt;
     switch (CURRENT_TERMINAL) {
-      case 32: case 47:
+      case 33: case 48:
 	{
 	    unsigned ZIcv;
 	    ZRtype_Hqualifier (&ZIcv);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
-    (ZIt) = make_subtype ( (*ZI329), TYPE_QUALIFIER ) ;
+    (ZIt) = make_subtype ( (*ZI331), TYPE_QUALIFIER ) ;
     (ZIt)->v.str = cv_qualifier [ (ZIcv) ] ;
 	    }
 	}
 	break;
       default:
 	{
-	    ZIt = *ZI329;
+	    ZIt = *ZI331;
 	}
 	break;
-      case 74:
+      case 75:
 	return;
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRfield_Hexact PROTO_N ((ZOe))
-  PROTO_T (int *ZOe)
+ZR335(SID_TYPE *ZOt)
+{
-    int ZIe;
+    SID_TYPE ZIt;
     switch (CURRENT_TERMINAL) {
-      case 59:
+      case 57:
+	{
-	    ADVANCE_LEXER;
-	    {
- (ZIe) = 1 ;
-	    }
-	}
-	break;
-      default:
-	{
-	    {
- (ZIe) = 0 ;
-	    }
-	}
-	break;
-      case 74:
-	return;
-    }
-    *ZOe = ZIe;
-}
-static void
-ZR333 PROTO_N ((ZOt))
-  PROTO_T (SID_TYPE *ZOt)
-{
-    SID_TYPE ZIt;
-    switch (CURRENT_TERMINAL) {
-      case 56:
-	{
 	    SID_TYPE ZIp;
 	    ADVANCE_LEXER;
+	    {
     error ( ERR_WARNING, "Empty parameter list" ) ;
     (ZIp) = null ;
 	    }
+	    {
     (ZIt) = make_subtype ( ( type * ) null, TYPE_PROC ) ;
     (ZIt)->v.next = (ZIp) ;
+	    }
+	}
 	break;
-      case 0: case 31: case 32: case 33: case 34:
+      case 0: case 32: case 33: case 34: case 35:
-      case 36: case 37: case 38: case 41: case 42:
+      case 37: case 38: case 39: case 42: case 43:
-      case 43: case 44: case 45: case 46: case 47:
+      case 44: case 45: case 46: case 47: case 48:
+	{
 	    SID_TYPE ZIp;
 	    ZRparameter_Hlist (&ZIp);
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
 	    }
 	    ADVANCE_LEXER;
 	    {
     (ZIt) = make_subtype ( ( type * ) null, TYPE_PROC ) ;
     (ZIt)->v.next = (ZIp) ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRcommand_Hlist PROTO_N ((ZOc))
+ZRcommand_Hlist(SID_COMMAND *ZOc)
-  PROTO_T (SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
   ZL2_command_Hlist:;
     switch (CURRENT_TERMINAL) {
       case 7: case 8: case 9: case 12: case 13:
       case 14: case 15: case 19: case 21: case 22:
       case 23: case 24: case 26: case 27: case 28:
-      case 29:
+      case 29: case 30:
+	{
 	    SID_COMMAND ZIa;
 	    SID_COMMAND ZIb;
 	    ZRspec_Hcommand (&ZIa);
 	    switch (CURRENT_TERMINAL) {
-	      case 70:
+	      case 71:
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    ZRcommand_Hlist (&ZIb);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
 	break;
       case 4: case 5: case 6: case 16: case 17:
       case 18:
+	{
 	    SID_COMMAND ZIa;
 	    SID_COMMAND ZIb;
 	    ZRtext_Hcommand (&ZIa);
 	    ZRcommand_Hlist (&ZIb);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
+	    {
     (ZIc) = join_object ( (ZIa), (ZIb) ) ;
+	    }
+	}
 	break;
       case 3: case 20:
+	{
 	    ZRvariable_Hcommand ();
 	    switch (CURRENT_TERMINAL) {
-	      case 70:
+	      case 71:
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    goto ZL2_command_Hlist;
+	}
     (ZIc) = null ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOc = ZIc;
+}
 static void
-ZR336 PROTO_N ((ZI334, ZI335, ZO304, ZO305))
-  PROTO_T (SID_STRING *ZI334 X SID_TYPE *ZI335 X SID_STRING *ZO304 X SID_TYPE *ZO305)
+ZR338(SID_STRING *ZI336, SID_TYPE *ZI337, SID_STRING *ZO306, SID_TYPE *ZO307)
+{
-    SID_STRING ZI304;
+    SID_STRING ZI306;
-    SID_TYPE ZI305;
+    SID_TYPE ZI307;
     switch (CURRENT_TERMINAL) {
-      case 55:
+      case 56:
+	{
 	    SID_TYPE ZIs;
 	    SID_TYPE ZIt;
 	    ZRfunction_Hoperator (&ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
-    (ZIt) = inject_type ( (*ZI335), (ZIs) ) ;
+    (ZIt) = inject_type ( (*ZI337), (ZIs) ) ;
 	    }
-	    ZR306 (*ZI334, ZIt, &ZI304, &ZI305);
+	    ZR308 (*ZI336, ZIt, &ZI306, &ZI307);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	}
 	break;
       default:
 	{
-	    ZR306 (*ZI334, *ZI335, &ZI304, &ZI305);
+	    ZR308 (*ZI336, *ZI337, &ZI306, &ZI307);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	}
 	break;
-      case 74:
+      case 75:
 	return;
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZO304 = ZI304;
+    *ZO306 = ZI306;
-    *ZO305 = ZI305;
+    *ZO307 = ZI307;
 }
 static void
-ZR337 PROTO_N ((ZOq))
-  PROTO_T (SID_TYPE *ZOq)
+ZR339(SID_TYPE *ZOq)
+{
     SID_TYPE ZIq;
     switch (CURRENT_TERMINAL) {
-      case 64:
+      case 65:
+	{
 	    ADVANCE_LEXER;
+	    {
     (ZIq) = make_subtype ( type_ellipsis, TYPE_LIST ) ;
     (ZIq)->v.next = null ;
 	    }
 	}
 	break;
-      case 0: case 31: case 32: case 33: case 34:
+      case 0: case 32: case 33: case 34: case 35:
-      case 36: case 37: case 38: case 41: case 42:
+      case 37: case 38: case 39: case 42: case 43:
-      case 43: case 44: case 45: case 46: case 47:
+      case 44: case 45: case 46: case 47: case 48:
+	{
 	    ZRparameter_Hlist (&ZIq);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOq = ZIq;
+}
 static void
-ZR338 PROTO_N ((ZOtag))
-  PROTO_T (int *ZOtag)
+ZR340(int *ZOtag)
+{
     int ZItag;
     switch (CURRENT_TERMINAL) {
-      case 30:
+      case 31:
 	{
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
 	      default:
 		goto ZL1;
 	    }
 	    ADVANCE_LEXER;
 	    {
  (ZItag) = TYPE_ARITH ;
-	    }
-	}
-	break;
-      case 36:
-	{
-	    ADVANCE_LEXER;
-	    switch (CURRENT_TERMINAL) {
-	      case 56:
-		break;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    {
- (ZItag) = TYPE_FLOAT ;
+	    }
+	}
 	break;
       case 37:
 	{
-	    ADVANCE_LEXER;
-	    switch (CURRENT_TERMINAL) {
-	      case 56:
-		break;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    {
- (ZItag) = TYPE_INT ;
-	    }
-	}
-	break;
-      case 40:
-	{
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
+	    {
- (ZItag) = TYPE_SCALAR ;
+ (ZItag) = TYPE_FLOAT ;
+	    }
+	}
 	break;
-      case 42:
+      case 38:
+	{
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
 	    {
- (ZItag) = TYPE_SIGNED ;
+ (ZItag) = TYPE_INT ;
+	    }
+	}
+	break;
+      case 41:
+	{
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 57:
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    {
+ (ZItag) = TYPE_SCALAR ;
 	    }
 	}
 	break;
       case 43:
 	{
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 57:
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    {
+ (ZItag) = TYPE_SIGNED ;
+	    }
+	}
+	break;
+      case 44:
+	{
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
+	    {
  (ZItag) = TYPE_STRUCT ;
 	    }
+	}
+	break;
+      case 45:
+	{
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 57:
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    {
+ (ZItag) = TYPE_UNION ;
+	    }
 	}
 	break;
-      case 44:
+      case 46:
+	{
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
 	      default:
 		goto ZL1;
 	    }
 	    ADVANCE_LEXER;
+	    {
- (ZItag) = TYPE_UNION ;
+ (ZItag) = TYPE_UNSIGNED ;
+	    }
+	}
 	break;
-      case 45:
+      case 75:
+	return;
+      default:
+	goto ZL1;
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOtag = ZItag;
+}
+static void
+ZRdirect_Hdeclarator(SID_IDENTIFIER *ZO316, SID_TYPE *ZO317)
+{
+    SID_IDENTIFIER ZI316;
+    SID_TYPE ZI317;
+    switch (CURRENT_TERMINAL) {
+      case 56:
+	{
-	    ADVANCE_LEXER;
-	    switch (CURRENT_TERMINAL) {
-	      case 56:
-		break;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    {
- (ZItag) = TYPE_UNSIGNED ;
-	    }
-	}
-	break;
-      case 74:
-	return;
-      default:
-	goto ZL1;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOtag = ZItag;
-}
-static void
-ZRdirect_Hdeclarator PROTO_N ((ZO314, ZO315))
-  PROTO_T (SID_IDENTIFIER *ZO314 X SID_TYPE *ZO315)
-{
-    SID_IDENTIFIER ZI314;
-    SID_TYPE ZI315;
-    switch (CURRENT_TERMINAL) {
-      case 55:
-	{
 	    SID_IDENTIFIER ZIid;
 	    SID_TYPE ZIt;
 	    ADVANCE_LEXER;
 	    ZRdeclarator (&ZIid, &ZIt);
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
+	    }
 	    ADVANCE_LEXER;
-	    ZR316 (ZIid, ZIt, &ZI314, &ZI315);
+	    ZR318 (ZIid, ZIt, &ZI316, &ZI317);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
+	{
 	    SID_IDENTIFIER ZIid;
 	    SID_TYPE ZIt;
 	    ZRidentifier (&ZIid);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     (ZIt) = null ;
+	    }
-	    ZR316 (ZIid, ZIt, &ZI314, &ZI315);
+	    ZR318 (ZIid, ZIt, &ZI316, &ZI317);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZO314 = ZI314;
+    *ZO316 = ZI316;
-    *ZO315 = ZI315;
+    *ZO317 = ZI317;
+}
 static void
-ZRtype_Hcommand PROTO_N ((ZOtag))
+ZRtype_Hcommand(int *ZOtag)
-  PROTO_T (int *ZOtag)
+{
     int ZItag;
     switch (CURRENT_TERMINAL) {
-      case 55:
+      case 56:
+	{
 	    ADVANCE_LEXER;
-	    ZR338 (&ZItag);
+	    ZR340 (&ZItag);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
-	}
-	break;
-      case 43:
-	{
-	    ADVANCE_LEXER;
-	    {
- (ZItag) = TYPE_STRUCT_TAG ;
-	    }
 	}
 	break;
       case 44:
+	{
 	    ADVANCE_LEXER;
 	    {
+ (ZItag) = TYPE_STRUCT_TAG ;
+	    }
+	}
+	break;
+      case 45:
+	{
+	    ADVANCE_LEXER;
+	    {
  (ZItag) = TYPE_UNION_TAG ;
+	    }
+	}
 	break;
       default:
+	    {
  (ZItag) = TYPE_GENERIC ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOtag = ZItag;
 }
 static void
-ZRtext_Hcommand PROTO_N ((ZOc))
+ZRtext_Hcommand(SID_COMMAND *ZOc)
-  PROTO_T (SID_COMMAND *ZOc)
 {
     SID_COMMAND ZIc;
     switch (CURRENT_TERMINAL) {
       case 6:
+	{
 	    SID_STRING ZIs;
 		switch (CURRENT_TERMINAL) {
 		  case 10:
+		    {
 			ADVANCE_LEXER;
 			ZRcommand_Hlist (&ZIb);
-			if ((CURRENT_TERMINAL) == 74) {
+			if ((CURRENT_TERMINAL) == 75) {
 			    RESTORE_LEXER;
 			    goto ZL1;
+			}
+		    }
 		    break;
     (ZIb) = null ;
+			}
+		    }
 		    break;
-		  case 74:
+		  case 75:
 		    RESTORE_LEXER;
 		    goto ZL1;
+		}
+	    }
 	    switch (CURRENT_TERMINAL) {
     if ( (ZIb) ) {
 	q = make_object ( (ZIs), OBJ_IF ) ;
 	q->u.u_num = CMD_ELSE ;
 	p = join_object ( p, q ) ;
 	p = join_object ( p, (ZIb) ) ;
     }
     q = make_object ( (ZIs), OBJ_IF ) ;
     q->u.u_num = CMD_ENDIF ;
     (ZIc) = join_object ( p, q ) ;
-	    }
-	}
-	break;
-      case 74:
-	return;
-      default:
-	goto ZL1;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOc = ZIc;
-}
-static void
-ZR345 PROTO_N ((ZI343, ZOid, ZOt))
-  PROTO_T (SID_IDENTIFIER *ZI343 X SID_IDENTIFIER *ZOid X SID_TYPE *ZOt)
-{
-    SID_IDENTIFIER ZIid;
-    SID_TYPE ZIt;
-    switch (CURRENT_TERMINAL) {
-      case 60:
-	{
-	    ZRbitfield_Hoperator (&ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
-		RESTORE_LEXER;
-		goto ZL1;
-	    }
-	    ZIid = *ZI343;
-	}
-	break;
-      default:
-	{
-	    SID_TYPE ZI342;
-	    {
-    (ZI342) = null ;
-	    }
-	    ZR316 (*ZI343, ZI342, &ZIid, &ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
-		RESTORE_LEXER;
-		goto ZL1;
 	    }
 	}
 	break;
-      case 74:
+      case 75:
 	return;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOid = ZIid;
-    *ZOt = ZIt;
-}
-static void
-ZR346 PROTO_N ((ZOcmd))
-  PROTO_T (int *ZOcmd)
-{
-    int ZIcmd;
-    switch (CURRENT_TERMINAL) {
-      case 55:
-	{
-	    ADVANCE_LEXER;
-	    ZR347 (&ZIcmd);
-	    if ((CURRENT_TERMINAL) == 74) {
-		RESTORE_LEXER;
-		goto ZL1;
-	    }
-	}
-	break;
       default:
-	{
-	    {
- (ZIcmd) = OBJ_FUNC ;
-	    }
-	}
-	break;
-      case 74:
-	return;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOcmd = ZIcmd;
-}
-static void
-ZR347 PROTO_N ((ZOcmd))
-  PROTO_T (int *ZOcmd)
-{
-    int ZIcmd;
-    switch (CURRENT_TERMINAL) {
-      case 35:
-	{
-	    ADVANCE_LEXER;
-	    switch (CURRENT_TERMINAL) {
-	      case 56:
-		break;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    {
- (ZIcmd) = OBJ_EXTERN ;
-	    }
-	}
-	break;
-      case 48:
-	{
-	    ADVANCE_LEXER;
-	    switch (CURRENT_TERMINAL) {
-	      case 56:
-		break;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    {
- (ZIcmd) = OBJ_WEAK ;
-	    }
-	}
-	break;
-      case 74:
-	return;
-      default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOcmd = ZIcmd;
-}
-static void
-ZRname_Hversion PROTO_N ((ZOv))
-  PROTO_T (int *ZOv)
-{
-    int ZIv;
-    switch (CURRENT_TERMINAL) {
-      case 62:
-	{
-	    SID_STRING ZIn;
-	    ADVANCE_LEXER;
-	    switch (CURRENT_TERMINAL) {
-	      case 1:
-		{
- ZIn = token_value ;
-		}
-		break;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    {
-    (ZIv) = atoi ( (ZIn) ) ;
-	    }
-	}
-	break;
-      default:
-	{
-	    {
-    (ZIv) = no_version ;
-	    }
-	}
-	break;
-      case 74:
-	return;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZOv = ZIv;
+    *ZOc = ZIc;
+}
 static void
-ZR348 PROTO_N ((ZOt))
-  PROTO_T (SID_TYPE *ZOt)
+ZR347(SID_IDENTIFIER *ZI345, SID_IDENTIFIER *ZOid, SID_TYPE *ZOt)
+{
+    SID_IDENTIFIER ZIid;
     SID_TYPE ZIt;
     switch (CURRENT_TERMINAL) {
-      case 56:
+      case 61:
-	{
-	    SID_TYPE ZIp;
-	    ADVANCE_LEXER;
-	    {
-    (ZIp) = null ;
-	    }
-	    {
-    (ZIt) = make_subtype ( ( type * ) null, TYPE_PROC ) ;
-    (ZIt)->v.next = (ZIp) ;
-	    }
-	}
-	break;
-      case 0: case 31: case 32: case 33: case 34:
-      case 36: case 37: case 38: case 39: case 41:
-      case 42: case 43: case 44: case 45: case 46:
-      case 47:
+	{
-	    SID_TYPE ZIp;
-	    ZRmacro_Hparam_Hlist (&ZIp);
+	    ZRbitfield_Hoperator (&ZIt);
-	    switch (CURRENT_TERMINAL) {
+	    if ((CURRENT_TERMINAL) == 75) {
-	      case 56:
-		break;
-	      case 74:
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
-	      default:
+	    ZIid = *ZI345;
+	}
-		goto ZL1;
+	break;
+      default:
-	    }
+	{
-	    ADVANCE_LEXER;
+	    SID_TYPE ZI344;
+	    {
+    (ZI344) = null ;
+	    }
-    (ZIt) = make_subtype ( ( type * ) null, TYPE_PROC ) ;
+	    ZR318 (*ZI345, ZI344, &ZIid, &ZIt);
-    (ZIt)->v.next = (ZIp) ;
+	    if ((CURRENT_TERMINAL) == 75) {
+		RESTORE_LEXER;
+		goto ZL1;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
-      default:
-	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
+    *ZOid = ZIid;
     *ZOt = ZIt;
+}
 static void
-ZRdirect_Habstract_Hdeclarator PROTO_N ((ZO304, ZO305))
+ZRname_Hversion(int *ZOv)
-  PROTO_T (SID_STRING *ZO304 X SID_TYPE *ZO305)
+{
-    SID_STRING ZI304;
-    SID_TYPE ZI305;
+    int ZIv;
     switch (CURRENT_TERMINAL) {
-      case 0:
+      case 63:
+	{
+	    SID_STRING ZIn;
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 1:
+		{
+ ZIn = token_value ;
+		}
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    {
+    (ZIv) = atoi ( (ZIn) ) ;
+	    }
+	}
+	break;
+      default:
+	{
-	    SID_STRING ZInm;
-	    SID_TYPE ZIt;
+	    {
- ZInm = token_value ;
+    (ZIv) = no_version ;
+	    }
+	}
+	break;
+      case 75:
+	return;
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOv = ZIv;
+}
+static void
+ZR348(int *ZOcmd)
+{
+    int ZIcmd;
+    switch (CURRENT_TERMINAL) {
+      case 56:
+	{
+	    ADVANCE_LEXER;
+	    ZR349 (&ZIcmd);
+	    if ((CURRENT_TERMINAL) == 75) {
+		RESTORE_LEXER;
+		goto ZL1;
+	    }
+	}
+	break;
+      default:
+	{
+	    {
+ (ZIcmd) = OBJ_FUNC ;
+	    }
+	}
+	break;
+      case 75:
+	return;
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOcmd = ZIcmd;
+}
+static void
+ZRdirect_Habstract_Hdeclarator(SID_STRING *ZO306, SID_TYPE *ZO307)
+{
+    SID_STRING ZI306;
+    SID_TYPE ZI307;
+    switch (CURRENT_TERMINAL) {
+      case 0:
+	{
+	    SID_STRING ZInm;
+	    SID_TYPE ZIt;
+	    {
+ ZInm = token_value ;
+	    }
 	    ADVANCE_LEXER;
 	    {
     (ZIt) = null ;
 	    }
-	    ZR306 (ZInm, ZIt, &ZI304, &ZI305);
+	    ZR308 (ZInm, ZIt, &ZI306, &ZI307);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	}
 	break;
-      case 55:
+      case 56:
+	{
-	    SID_STRING ZI334;
+	    SID_STRING ZI336;
-	    SID_TYPE ZI335;
+	    SID_TYPE ZI337;
 	    ADVANCE_LEXER;
-	    ZRabstract_Hdeclarator (&ZI334, &ZI335);
+	    ZRabstract_Hdeclarator (&ZI336, &ZI337);
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
-	      case 74:
+	      case 75:
-		RESTORE_LEXER;
-		goto ZL1;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    ZR336 (&ZI334, &ZI335, &ZI304, &ZI305);
-	    if ((CURRENT_TERMINAL) == 74) {
 		RESTORE_LEXER;
+		goto ZL1;
+	      default:
 		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    ZR338 (&ZI336, &ZI337, &ZI306, &ZI307);
+	    if ((CURRENT_TERMINAL) == 75) {
+		RESTORE_LEXER;
+		goto ZL1;
+	    }
 	}
 	break;
       default:
+	{
 	    SID_STRING ZInm;
 	    SID_TYPE ZIt;
 	    {
     (ZInm) = null ;
+	    }
+	    {
     (ZIt) = null ;
+	    }
-	    ZR306 (ZInm, ZIt, &ZI304, &ZI305);
+	    ZR308 (ZInm, ZIt, &ZI306, &ZI307);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
-    *ZO304 = ZI304;
+    *ZO306 = ZI306;
-    *ZO305 = ZI305;
+    *ZO307 = ZI307;
+}
 static void
-ZRfield_Hdeclarator PROTO_N ((ZOid, ZOt))
-  PROTO_T (SID_IDENTIFIER *ZOid X SID_TYPE *ZOt)
+ZRfield_Hdeclarator(SID_IDENTIFIER *ZOid, SID_TYPE *ZOt)
+{
     SID_IDENTIFIER ZIid;
     SID_TYPE ZIt;
     switch (CURRENT_TERMINAL) {
-      case 55:
+      case 56:
 	{
-	    SID_IDENTIFIER ZI339;
+	    SID_IDENTIFIER ZI341;
-	    SID_TYPE ZI340;
+	    SID_TYPE ZI342;
 	    ADVANCE_LEXER;
-	    ZRdeclarator (&ZI339, &ZI340);
+	    ZRdeclarator (&ZI341, &ZI342);
 	    switch (CURRENT_TERMINAL) {
-	      case 56:
+	      case 57:
 		break;
-	      case 74:
+	      case 75:
+		RESTORE_LEXER;
+		goto ZL1;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    ZR318 (ZI341, ZI342, &ZIid, &ZIt);
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
-		goto ZL1;
-	      default:
 		goto ZL1;
+	    }
-	    ADVANCE_LEXER;
-	    ZR316 (ZI339, ZI340, &ZIid, &ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
-		RESTORE_LEXER;
-		goto ZL1;
-	    }
 	}
 	break;
-      case 60:
+      case 61:
 	{
 	    ZRbitfield_Hoperator (&ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
+    }
     (ZIid).iname = nm ;
     (ZIid).ivers = no_version ;
     (ZIid).ename = token_name ( nm ) ;
     (ZIid).evers = no_version ;
 	    }
+	}
 	break;
       case 0:
 	{
-	    SID_IDENTIFIER ZI343;
+	    SID_IDENTIFIER ZI345;
-	    ZRidentifier (&ZI343);
+	    ZRidentifier (&ZI345);
-	    ZR345 (&ZI343, &ZIid, &ZIt);
+	    ZR347 (&ZI345, &ZIid, &ZIt);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
-      case 71:
+      case 72:
+	{
 	    SID_TYPE ZIp;
 	    SID_TYPE ZIs;
 	    ZRptr_Hoperator (&ZIp);
 	    ZRdeclarator (&ZIid, &ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     (ZIt) = inject_type ( (ZIs), (ZIp) ) ;
+	    }
+	}
 	break;
-      case 74:
-	return;
-      default:
-	goto ZL1;
-    }
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
-    return;
-  ZL0:;
-    *ZOid = ZIid;
-    *ZOt = ZIt;
-}
-static void
-ZRvariable_Hcommand PROTO_Z ()
-{
-    switch (CURRENT_TERMINAL) {
-      case 20:
-	{
-	    SID_STRING ZIs;
-	    ADVANCE_LEXER;
-	    switch (CURRENT_TERMINAL) {
-	      case 2:
-		{
- ZIs = token_value ;
-		}
-		break;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	}
-	break;
-      case 3:
-	{
-	    SID_STRING ZInm;
-	    {
- ZInm = token_value ;
-	    }
-	    ADVANCE_LEXER;
-	    switch (CURRENT_TERMINAL) {
-	      case 65:
-		break;
-	      default:
-		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    ZR352 (&ZInm);
-	    if ((CURRENT_TERMINAL) == 74) {
-		RESTORE_LEXER;
-		goto ZL1;
-	    }
-	}
-	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
-    return;
+    goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
+  ZL0:;
+    *ZOid = ZIid;
+    *ZOt = ZIt;
+}
 static void
-ZR349 PROTO_N ((ZOkey))
+ZRvariable_Hcommand(void)
-  PROTO_T (SID_STRING *ZOkey)
+{
-    SID_STRING ZIkey;
     switch (CURRENT_TERMINAL) {
-      case 66:
+      case 20:
+	{
+	    SID_STRING ZIs;
 	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
-	    ZR350 (&ZIkey);
+	      case 2:
+		{
-	    if ((CURRENT_TERMINAL) == 74) {
+ ZIs = token_value ;
+		}
+		break;
-		RESTORE_LEXER;
+	      default:
 		goto ZL1;
+	}
 	break;
       default:
+	{
+	    {
  (ZIp) = null ;
 	    }
 	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOp = ZIp;
+}
 static void
-ZRexp_Hcommand PROTO_N ((ZOcmd))
+ZRexp_Hcommand(int *ZOcmd)
-  PROTO_T (int *ZOcmd)
+{
     int ZIcmd;
     switch (CURRENT_TERMINAL) {
       case 8:
+	{
 	    ADVANCE_LEXER;
+	    {
  (ZIcmd) = OBJ_CONST ;
 	    }
 	}
 	break;
       case 13:
+	{
 	    ADVANCE_LEXER;
-	    ZR327 (&ZIcmd);
+	    ZR329 (&ZIcmd);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOcmd = ZIcmd;
+}
 static void
-ZR352 PROTO_N ((ZInm))
-  PROTO_T (SID_STRING *ZInm)
+ZR352(SID_STRING *ZOkey)
+{
+    SID_STRING ZIkey;
     switch (CURRENT_TERMINAL) {
       case 67:
+	{
-	    SID_STRING ZIs;
 	    ADVANCE_LEXER;
 	    switch (CURRENT_TERMINAL) {
-	      case 1:
+	      case 57:
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
-		{
+	    {
- ZIs = token_value ;
+ (ZIkey) = "11" ;
+	    }
-		}
+	}
+	break;
+      case 70:
+	{
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 57:
 		break;
 	      default:
 		goto ZL1;
-	    }
-	    ADVANCE_LEXER;
-	    {
-    set_integer ( (*ZInm), -atoi ( (ZIs) ) ) ;
-	    }
-	}
-	break;
-      case 1:
-	{
-	    SID_STRING ZIs;
-	    {
- ZIs = token_value ;
-	    }
-	    ADVANCE_LEXER;
-	    {
-    set_integer ( (*ZInm), atoi ( (ZIs) ) ) ;
-	    }
-	}
-	break;
-      case 2:
-	{
-	    SID_STRING ZIs;
-	    {
- ZIs = token_value ;
 	    }
 	    ADVANCE_LEXER;
+	    {
-    set_string ( (*ZInm), (ZIs) ) ;
+ (ZIkey) = "10" ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
-    return;
+    goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
+  ZL0:;
+    *ZOkey = ZIkey;
+}
 static void
-ZRif_Hcommand PROTO_N ((ZOc, ZOs))
-  PROTO_T (SID_COMMAND *ZOc X SID_STRING *ZOs)
+ZRif_Hcommand(SID_COMMAND *ZOc, SID_STRING *ZOs)
+{
     SID_COMMAND ZIc;
     SID_STRING ZIs;
     switch (CURRENT_TERMINAL) {
       case 16:
+	{
 	    ADVANCE_LEXER;
 	    ZRconstant_Hvalue (&ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
     (ZIc) = make_object ( (ZIs), OBJ_IF ) ;
     (ZIc)->u.u_num = CMD_IF ;
 	    }
 	}
 	break;
       case 17:
+	{
 	    ADVANCE_LEXER;
 	    ZRifdef_Hmacro_Hname (&ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
-		RESTORE_LEXER;
-		goto ZL1;
-	    }
-	    {
-    (ZIc) = make_object ( (ZIs), OBJ_IF ) ;
-    (ZIc)->u.u_num = CMD_IFDEF ;
-	    }
-	}
-	break;
-      case 18:
-	{
-	    ADVANCE_LEXER;
-	    ZRifdef_Hmacro_Hname (&ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
+	    {
     (ZIc) = make_object ( (ZIs), OBJ_IF ) ;
-    (ZIc)->u.u_num = CMD_IFNDEF ;
+    (ZIc)->u.u_num = CMD_IFDEF ;
+	    }
+	}
 	break;
-      case 74:
+      case 18:
-	return;
-      default:
-	goto ZL1;
-    }
+	{
-    goto ZL0;
-  ZL1:;
-    SAVE_LEXER (74);
+	    ADVANCE_LEXER;
-    return;
-  ZL0:;
-    *ZOc = ZIc;
-    *ZOs = ZIs;
-}
-static void
-ZRbitfield_Hoperator PROTO_N ((ZOt))
+	    ZRifdef_Hmacro_Hname (&ZIs);
-  PROTO_T (SID_TYPE *ZOt)
+	    if ((CURRENT_TERMINAL) == 75) {
-{
-    SID_TYPE ZIt;
+		RESTORE_LEXER;
-    if ((CURRENT_TERMINAL) == 74) {
-	return;
+		goto ZL1;
-    }
+	    }
-    {
+	    {
-	SID_STRING ZIa;
+    (ZIc) = make_object ( (ZIs), OBJ_IF ) ;
+    (ZIc)->u.u_num = CMD_IFNDEF ;
+	    }
+	}
+	break;
+      case 75:
+	return;
+      default:
+	goto ZL1;
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOc = ZIc;
+    *ZOs = ZIs;
+}
+static void
+ZR353(SID_STRING *ZOkey)
+{
+    SID_STRING ZIkey;
+    switch (CURRENT_TERMINAL) {
+      case 67:
+	{
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 57:
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    {
+ (ZIkey) = "01" ;
+	    }
+	}
+	break;
+      case 70:
+	{
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 57:
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    {
+ (ZIkey) = "00" ;
+	    }
+	}
+	break;
+      case 75:
+	return;
+      default:
+	goto ZL1;
+    }
+    goto ZL0;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+  ZL0:;
+    *ZOkey = ZIkey;
+}
+static void
+ZR354(SID_STRING *ZInm)
+{
+    switch (CURRENT_TERMINAL) {
+      case 68:
+	{
+	    SID_STRING ZIs;
+	    ADVANCE_LEXER;
+	    switch (CURRENT_TERMINAL) {
+	      case 1:
+		{
+ ZIs = token_value ;
+		}
+		break;
+	      default:
+		goto ZL1;
+	    }
+	    ADVANCE_LEXER;
+	    {
+    set_integer ( (*ZInm), -atoi ( (ZIs) ) ) ;
+	    }
+	}
+	break;
+      case 1:
+	{
+	    SID_STRING ZIs;
+	    {
+ ZIs = token_value ;
+	    }
+	    ADVANCE_LEXER;
+	    {
+    set_integer ( (*ZInm), atoi ( (ZIs) ) ) ;
+	    }
+	}
+	break;
+      case 2:
+	{
+	    SID_STRING ZIs;
+	    {
+ ZIs = token_value ;
+	    }
+	    ADVANCE_LEXER;
+	    {
+    set_string ( (*ZInm), (ZIs) ) ;
+	    }
+	}
+	break;
+      case 75:
+	return;
+      default:
+	goto ZL1;
+    }
+    return;
+  ZL1:;
+    SAVE_LEXER (75);
+    return;
+}
+static void
+ZRbitfield_Hoperator(SID_TYPE *ZOt)
+{
+    SID_TYPE ZIt;
+    if ((CURRENT_TERMINAL) == 75) {
+	return;
+    }
+    {
+	SID_STRING ZIa;
 	switch (CURRENT_TERMINAL) {
-	  case 60:
+	  case 61:
 	    break;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
 	ZRconstant_Hvalue (&ZIa);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+	{
     (ZIt)->v.str = (ZIa) ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRuse_Hsubset_Hname PROTO_N ((ZOs))
+ZRuse_Hsubset_Hname(SID_STRING *ZOs)
-  PROTO_T (SID_STRING *ZOs)
+{
     SID_STRING ZIs;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_STRING ZIa;
 	SID_STRING ZIb;
-	switch (CURRENT_TERMINAL) {
-	  case 55:
-	    break;
-	  default:
-	    goto ZL1;
-	}
-	ADVANCE_LEXER;
-	switch (CURRENT_TERMINAL) {
-	  case 2:
-	    {
- ZIa = token_value ;
-	    }
-	    break;
-	  default:
-	    goto ZL1;
-	}
-	ADVANCE_LEXER;
 	switch (CURRENT_TERMINAL) {
 	  case 56:
 	    break;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
+	switch (CURRENT_TERMINAL) {
+	  case 2:
+	    {
+ ZIa = token_value ;
+	    }
+	    break;
+	  default:
+	    goto ZL1;
+	}
+	ADVANCE_LEXER;
+	switch (CURRENT_TERMINAL) {
+	  case 57:
+	    break;
+	  default:
+	    goto ZL1;
+	}
+	ADVANCE_LEXER;
 	switch (CURRENT_TERMINAL) {
-	  case 61:
+	  case 62:
 	    break;
 	  default:
 	    goto ZL1;
 	}
 	ADVANCE_LEXER;
 	switch (CURRENT_TERMINAL) {
 	  case 2:
 	    {
  ZIb = token_value ;
 	    }
 	    break;
 	  default:
 	    goto ZL1;
 	}
 	ADVANCE_LEXER;
 	{
     (ZIs) = subset_name ( (ZIa), (ZIb), null_str ) ;
 	}
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOs = ZIs;
+}
 void
-read_spec PROTO_N ((ZOc))
-  PROTO_T (SID_COMMAND *ZOc)
+read_spec(SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	ZRsubset_Hcommand (&ZIc);
 	switch (CURRENT_TERMINAL) {
-	  case 70:
+	  case 71:
 	    break;
-	  case 74:
+	  case 75:
 	    RESTORE_LEXER;
 	    goto ZL1;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
 	switch (CURRENT_TERMINAL) {
-	  case 72:
+	  case 73:
 	    break;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
   ZL1:;
+    {
+	{
     error ( ERR_SERIOUS, "Syntax error" ) ;
 	}
 	{
     (ZIc) = null ;
 	}
     }
   ZL0:;
     *ZOc = ZIc;
 }
 static void
-ZRmacro_Hdeclarator PROTO_N ((ZOid, ZOt))
-  PROTO_T (SID_IDENTIFIER *ZOid X SID_TYPE *ZOt)
+ZRmacro_Hdeclarator(SID_IDENTIFIER *ZOid, SID_TYPE *ZOt)
+{
     SID_IDENTIFIER ZIid;
     SID_TYPE ZIt;
     switch (CURRENT_TERMINAL) {
       case 0:
 	{
 	    ZRidentifier (&ZIid);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
 	    }
 	    {
     (ZIt) = null ;
 	    }
+	}
 	break;
-      case 71:
+      case 72:
+	{
 	    SID_TYPE ZIp;
 	    SID_TYPE ZIs;
 	    ZRptr_Hoperator (&ZIp);
 	    ZRmacro_Hdeclarator (&ZIid, &ZIs);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     (ZIt) = inject_type ( (ZIs), (ZIp) ) ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOid = ZIid;
     *ZOt = ZIt;
+}
 static void
-ZRsubset_Hname PROTO_N ((ZOs))
+ZRsubset_Hname(SID_STRING *ZOs)
-  PROTO_T (SID_STRING *ZOs)
+{
     SID_STRING ZIs;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	SID_STRING ZIa;
 	switch (CURRENT_TERMINAL) {
 	  case 2:
+	    {
  ZIa = token_value ;
 	    }
 	    break;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
-	ZR318 (&ZIa, &ZIs);
+	ZR320 (&ZIa, &ZIs);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOs = ZIs;
+}
 static void
-ZRbuiltin_Htype PROTO_N ((ZOb))
+ZRbuiltin_Htype(unsigned *ZOb)
-  PROTO_T (unsigned *ZOb)
+{
     unsigned ZIb;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	unsigned ZIa;
 	unsigned ZIc;
 	ZRtype_Hkeyword (&ZIa);
+	{
 	    switch (CURRENT_TERMINAL) {
-	      case 31: case 33: case 36: case 37: case 38:
+	      case 32: case 34: case 37: case 38: case 39:
-	      case 41: case 42: case 45: case 46:
+	      case 42: case 43: case 46: case 47:
+		{
 		    unsigned ZId;
 		    ZRbuiltin_Htype (&ZId);
-		    if ((CURRENT_TERMINAL) == 74) {
+		    if ((CURRENT_TERMINAL) == 75) {
 			RESTORE_LEXER;
 			goto ZL1;
+		    }
+		    {
 	    break ;
+	}
+    }
     (ZIc) = ( (ZIa) | (ZId) ) ;
+		    }
 		}
 		break;
 	      default:
+		{
 		    ZIc = ZIa;
+		}
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	}
 	ZIb = ZIc;
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOb = ZIb;
+}
 static void
-ZRobject_Hqualifier PROTO_N ((ZOlv))
+ZRobject_Hqualifier(int *ZOlv)
-  PROTO_T (int *ZOlv)
+{
     int ZIlv;
     switch (CURRENT_TERMINAL) {
-      case 39:
+      case 40:
+	{
 	    ADVANCE_LEXER;
+	    {
  (ZIlv) = TYPE_LVALUE ;
+	    }
+	    {
  (ZIlv) = TYPE_RVALUE ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
+    }
     *ZOlv = ZIlv;
+}
 static void
-ZRfield_Hlist PROTO_N ((ZIm, ZOc))
-  PROTO_T (SID_TYPE ZIm X SID_COMMAND *ZOc)
+ZRfield_Hlist(SID_TYPE ZIm, SID_COMMAND *ZOc)
+{
     SID_COMMAND ZIc;
     switch (CURRENT_TERMINAL) {
       case 16: case 17: case 18:
 		switch (CURRENT_TERMINAL) {
 		  case 10:
+		    {
 			ADVANCE_LEXER;
 			ZRfield_Hlist (ZIm, &ZIb);
-			if ((CURRENT_TERMINAL) == 74) {
+			if ((CURRENT_TERMINAL) == 75) {
 			    RESTORE_LEXER;
 			    goto ZL1;
+			}
+		    }
 		    break;
     (ZIb) = null ;
+			}
+		    }
 		    break;
-		  case 74:
+		  case 75:
 		    RESTORE_LEXER;
 		    goto ZL1;
+		}
+	    }
 	    switch (CURRENT_TERMINAL) {
     q = make_object ( (ZIs), OBJ_IF ) ;
     q->u.u_num = CMD_ENDIF ;
     (ZIc1) = join_object ( p, q ) ;
+	    }
 	    ZRfield_Hlist (ZIm, &ZIc2);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     (ZIc) = join_object ( (ZIc1), (ZIc2) ) ;
+	    }
+	}
 	break;
-      case 0: case 31: case 32: case 33: case 34:
+      case 0: case 32: case 33: case 34: case 35:
-      case 36: case 37: case 38: case 41: case 42:
+      case 37: case 38: case 39: case 42: case 43:
-      case 43: case 44: case 45: case 46: case 47:
+      case 44: case 45: case 46: case 47: case 48:
+	{
 	    SID_TYPE ZIt;
 	    SID_COMMAND ZIa;
 	    SID_COMMAND ZIb;
 	    ZRqualified_Htype (&ZIt);
 	    ZRfield_Hdeclarator_Hlist (ZIm, ZIt, &ZIa);
 	    switch (CURRENT_TERMINAL) {
-	      case 70:
+	      case 71:
 		break;
-	      case 74:
+	      case 75:
 		RESTORE_LEXER;
 		goto ZL1;
 	      default:
 		goto ZL1;
 	    }
 	    ADVANCE_LEXER;
 	    ZRfield_Hlist (ZIm, &ZIb);
-	    if ((CURRENT_TERMINAL) == 74) {
+	    if ((CURRENT_TERMINAL) == 75) {
 		RESTORE_LEXER;
 		goto ZL1;
+	    }
+	    {
     (ZIc) = join_object ( (ZIa), (ZIb) ) ;
 	    }
+	}
 	break;
       default:
+	{
+	    {
     (ZIc) = null ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
     }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOc = ZIc;
 }
 static void
-ZRptr_Hoperator PROTO_N ((ZOt))
+ZRptr_Hoperator(SID_TYPE *ZOt)
-  PROTO_T (SID_TYPE *ZOt)
 {
     SID_TYPE ZIt;
-    if ((CURRENT_TERMINAL) == 74) {
+    if ((CURRENT_TERMINAL) == 75) {
 	return;
+    }
+    {
 	unsigned ZIcv;
 	switch (CURRENT_TERMINAL) {
-	  case 71:
+	  case 72:
 	    break;
 	  default:
 	    goto ZL1;
+	}
 	ADVANCE_LEXER;
 	ZRtype_Hqualifier_Hopt (&ZIcv);
-	if ((CURRENT_TERMINAL) == 74) {
+	if ((CURRENT_TERMINAL) == 75) {
 	    RESTORE_LEXER;
 	    goto ZL1;
+	}
+	{
     (ZIt)->v.str = cv_qualifier [ (ZIcv) ] ;
+	}
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOt = ZIt;
+}
 static void
-ZRtype_Hkeyword PROTO_N ((ZOb))
+ZRtype_Hkeyword(unsigned *ZOb)
-  PROTO_T (unsigned *ZOb)
+{
     unsigned ZIb;
     switch (CURRENT_TERMINAL) {
-      case 31:
+      case 32:
-	{
-	    ADVANCE_LEXER;
-	    {
- (ZIb) = BTYPE_CHAR ;
-	    }
-	}
-	break;
-      case 33:
+	{
 	    ADVANCE_LEXER;
+	    {
- (ZIb) = BTYPE_DOUBLE ;
+ (ZIb) = BTYPE_CHAR ;
+	    }
+	}
 	break;
-      case 36:
+      case 34:
+	{
 	    ADVANCE_LEXER;
+	    {
- (ZIb) = BTYPE_FLOAT ;
+ (ZIb) = BTYPE_DOUBLE ;
+	    }
+	}
 	break;
       case 37:
 	{
 	    ADVANCE_LEXER;
+	    {
- (ZIb) = BTYPE_INT ;
+ (ZIb) = BTYPE_FLOAT ;
+	    }
+	}
 	break;
       case 38:
 	{
 	    ADVANCE_LEXER;
 	    {
- (ZIb) = BTYPE_LONG ;
+ (ZIb) = BTYPE_INT ;
+	    }
+	}
 	break;
-      case 41:
+      case 39:
+	{
 	    ADVANCE_LEXER;
 	    {
- (ZIb) = BTYPE_SHORT ;
+ (ZIb) = BTYPE_LONG ;
+	    }
+	}
 	break;
       case 42:
 	{
+	    ADVANCE_LEXER;
+	    {
+ (ZIb) = BTYPE_SHORT ;
+	    }
+	}
+	break;
+      case 43:
+	{
 	    ADVANCE_LEXER;
+	    {
  (ZIb) = BTYPE_SIGNED ;
+	    }
+	}
 	break;
-      case 45:
+      case 46:
+	{
 	    ADVANCE_LEXER;
+	    {
  (ZIb) = BTYPE_UNSIGNED ;
+	    }
+	}
 	break;
-      case 46:
+      case 47:
+	{
 	    ADVANCE_LEXER;
+	    {
  (ZIb) = BTYPE_VOID ;
+	    }
+	}
 	break;
-      case 74:
+      case 75:
 	return;
       default:
 	goto ZL1;
+    }
     goto ZL0;
   ZL1:;
-    SAVE_LEXER (74);
+    SAVE_LEXER (75);
     return;
   ZL0:;
     *ZOb = ZIb;
+}

Subversion Repositories tendra.SVN

(root)/trunk/src/tools/tspec/syntax.c – Rev 2 → 7