Remove functions, procedures and simple procedures.

This has been tested by cross-compiling a base Hurd system to make sure
these kinds of routines are no longer used.

* lexxer.l: Remove tokens.
* parser.y: Remove token types and production rules.
* routine.c: Remove rtMakeProcedure, rtMakeSimpleProcedure,
rtMakeFunction.
* routine.h: Remove enum values rkSimpleProcedure, rkProcedure,
rkFunction. Remove dead fields from struct routine.
* user.c: Simplify and remove dead code.

5 files changed, 18 insertions, 143 deletions

diff --git a/lexxer.l b/lexxer.l
index 06b04e2..bd7a718 100644
--- a/lexxer.l
+++ b/lexxer.l
@@ -108,9 +108,6 @@ static void doSharp(const char *body); /* process body of # directives */
 %%
 
 <Normal>(?i:routine)		RETURN(syRoutine);
-<Normal>(?i:function)		RETURN(syFunction);
-<Normal>(?i:procedure)		RETURN(syProcedure);
-<Normal>(?i:simpleprocedure)	RETURN(sySimpleProcedure);
 <Normal>(?i:simpleroutine)	RETURN(sySimpleRoutine);
 <Normal>(?i:subsystem)		RETURN(sySubsystem);
 <Normal>(?i:msgoption)		RETURN(syMsgOption);
diff --git a/parser.y b/parser.y
index e88fd22..b05bcc9 100644
--- a/parser.y
+++ b/parser.y
@@ -27,9 +27,6 @@
 %token	sySkip
 %token	syRoutine
 %token	sySimpleRoutine
-%token	sySimpleProcedure
-%token	syProcedure
-%token	syFunction
 
 %token	sySubsystem
 %token	syKernelUser
@@ -111,7 +108,6 @@
 %type	<type> BasicTypeSpec PrevTypeSpec ArgumentType
 %type	<symtype> PrimIPCType IPCType
 %type	<routine> RoutineDecl Routine SimpleRoutine
-%type	<routine> Procedure SimpleProcedure Function
 %type	<direction> Direction
 %type	<argument> Argument Arguments ArgumentList
 %type	<flag> IPCFlags
@@ -582,9 +578,6 @@ IntExp			: 	IntExp	syPlus	IntExp
  
 RoutineDecl		:	Routine			{ $$ = $1; }
 			|	SimpleRoutine		{ $$ = $1; }
-			|	Procedure		{ $$ = $1; }
-			|	SimpleProcedure		{ $$ = $1; }
-			|	Function		{ $$ = $1; }
 			;
 
 Routine			:	syRoutine syIdentifier Arguments
@@ -595,18 +588,6 @@ SimpleRoutine		:	sySimpleRoutine syIdentifier Arguments
 				{ $$ = rtMakeSimpleRoutine($2, $3); }
 			;
 
-Procedure		:	syProcedure syIdentifier Arguments
-				{ $$ = rtMakeProcedure($2, $3); }
-			;
-
-SimpleProcedure		:	sySimpleProcedure syIdentifier Arguments
-				{ $$ = rtMakeSimpleProcedure($2, $3); }
-			;
-
-Function		:	syFunction syIdentifier Arguments ArgumentType
-				{ $$ = rtMakeFunction($2, $3, $4); }
-			;
-
 Arguments		:	syLParen syRParen
 				{ $$ = argNULL; }
 			|	syLParen ArgumentList syRParen
diff --git a/routine.c b/routine.c
index ddf5770..d9154ef 100644
--- a/routine.c
+++ b/routine.c
@@ -59,7 +59,6 @@ rtAlloc(void)
 	fatal("rtAlloc(): %s", unix_error_string(errno));
     new->rtNumber = rtNumber++;
     new->rtName = strNULL;
-    new->rtErrorName = strNULL;
     new->rtUserName = strNULL;
     new->rtServerName = strNULL;
 
@@ -136,54 +135,6 @@ rtMakeSimpleRoutine(identifier_t name, argument_t *args)
     return rt;
 }
 
-routine_t *
-rtMakeProcedure(identifier_t name, argument_t *args)
-{
-    routine_t *rt = rtAlloc();
-
-    rt->rtName = name;
-    rt->rtKind = rkProcedure;
-    rt->rtArgs = args;
-
-    warn("Procedure %s: obsolete routine kind", name);
-
-    return rt;
-}
-
-routine_t *
-rtMakeSimpleProcedure(identifier_t name, argument_t *args)
-{
-    routine_t *rt = rtAlloc();
-
-    rt->rtName = name;
-    rt->rtKind = rkSimpleProcedure;
-    rt->rtArgs = args;
-
-    warn("SimpleProcedure %s: obsolete routine kind", name);
-
-    return rt;
-}
-
-routine_t *
-rtMakeFunction(identifier_t name, argument_t *args, ipc_type_t *type)
-{
-    routine_t *rt = rtAlloc();
-    argument_t *ret = argAlloc();
-
-    ret->argName = name;
-    ret->argKind = akReturn;
-    ret->argType = type;
-    ret->argNext = args;
-
-    rt->rtName = name;
-    rt->rtKind = rkFunction;
-    rt->rtArgs = ret;
-
-    warn("Function %s: obsolete routine kind", name);
-
-    return rt;
-}
-
 const char *
 rtRoutineKindToStr(routine_kind_t rk)
 {
@@ -193,12 +144,6 @@ rtRoutineKindToStr(routine_kind_t rk)
 	return "Routine";
       case rkSimpleRoutine:
 	return "SimpleRoutine";
-      case rkProcedure:
-	return "Procedure";
-      case rkSimpleProcedure:
-	return "SimpleProcedure";
-      case rkFunction:
-	return "Function";
       default:
 	fatal("rtRoutineKindToStr(%d): not a routine_kind_t", rk);
 	/*NOTREACHED*/
@@ -290,12 +235,7 @@ rtPrintRoutine(const routine_t *rt)
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
 	rtPrintArg(arg);
 
-    if (rt->rtKind == rkFunction)
-	printf("): %s\n", rt->rtReturn->argType->itName);
-    else
-	printf(")\n");
-
-    printf("\n");
+    printf(")\n");
 }
 
 /*
@@ -932,15 +872,10 @@ rtCheckArgTypes(routine_t *rt)
 	error("%s %s doesn't have a server port argument",
 	      rtRoutineKindToStr(rt->rtKind), rt->rtName);
 
-    if ((rt->rtKind == rkFunction) &&
-	(rt->rtReturn == argNULL))
-	error("Function %s doesn't have a return arg", rt->rtName);
+    if (rt->rtReturn != argNULL)
+	error("routine %s has a return arg", rt->rtName);
 
-    if ((rt->rtKind != rkFunction) &&
-	(rt->rtReturn != argNULL))
-	error("non-function %s has a return arg", rt->rtName);
-
-    if ((rt->rtReturn == argNULL) && !rt->rtProcedure)
+    if (rt->rtReturn == argNULL)
 	rt->rtReturn = rt->rtRetCode;
 
     rt->rtServerReturn = rt->rtReturn;
@@ -1250,12 +1185,7 @@ rtCheckRoutine(routine_t *rt)
 {
     /* Initialize random fields. */
 
-    rt->rtErrorName = ErrorProc;
-    rt->rtOneWay = ((rt->rtKind == rkSimpleProcedure) ||
-		    (rt->rtKind == rkSimpleRoutine));
-    rt->rtProcedure = ((rt->rtKind == rkProcedure) ||
-		       (rt->rtKind == rkSimpleProcedure));
-    rt->rtUseError = rt->rtProcedure || (rt->rtKind == rkFunction);
+    rt->rtOneWay = (rt->rtKind == rkSimpleRoutine);
     rt->rtServerName = strconcat(ServerPrefix, rt->rtName);
     rt->rtServerName = strconcat(RoutinePrefix, rt->rtServerName);
     rt->rtUserName = strconcat(UserPrefix, rt->rtName);
@@ -1342,8 +1272,5 @@ rtCheckRoutine(routine_t *rt)
     rtCheckDestroy(rt);
     rtAddByReference(rt);
 
-    if (rt->rtKind == rkFunction)
-	rt->rtNoReplyArgs = FALSE;
-    else
-	rt->rtNoReplyArgs = !rtCheckMask(rt->rtArgs, akbReturnSnd);
+    rt->rtNoReplyArgs = !rtCheckMask(rt->rtArgs, akbReturnSnd);
 }
diff --git a/routine.h b/routine.h
index f80a174..2b79b27 100644
--- a/routine.h
+++ b/routine.h
@@ -264,7 +264,6 @@ typedef u_int  arg_kind_t;
 
 typedef struct argument
 {
-    /* if argKind == akReturn, then argName is name of the function */
     identifier_t argName;
     struct argument *argNext;
 
@@ -305,18 +304,14 @@ typedef struct argument
 
 /*
  * The various routine kinds' peculiarities are abstracted by rtCheckRoutine
- * into attributes like rtOneWay, rtProcedure, etc.  These are what
- * code generation should use.  It is Bad Form for code generation to
- * test rtKind.
+ * into attributes like rtOneWay, etc.  These are what code generation should
+ * use.  It is bad Form for code generation to test rtKind.
  */
 
 typedef enum
 {
     rkRoutine,
     rkSimpleRoutine,
-    rkSimpleProcedure,
-    rkProcedure,
-    rkFunction,
 } routine_kind_t;
 
 typedef struct routine
@@ -329,12 +324,7 @@ typedef struct routine
     identifier_t rtUserName;	/* user-visible name (UserPrefix + Name) */
     identifier_t rtServerName;	/* server-side name (ServerPrefix + Name) */
 
-    /* rtErrorName is only used for Procs, SimpleProcs, & Functions */
-    identifier_t rtErrorName;	/* error-handler name */
-
-    boolean_t rtOneWay;		/* SimpleProcedure or SimpleRoutine */
-    boolean_t rtProcedure;	/* Procedure or SimpleProcedure */
-    boolean_t rtUseError;	/* Procedure or Function */
+    boolean_t rtOneWay;		/* TRUE for SimpleRoutine */
 
     boolean_t rtSimpleFixedRequest;	/* fixed msg-simple value in request */
     boolean_t rtSimpleSendRequest;	/* in any case, initial value */
@@ -362,7 +352,7 @@ typedef struct routine
     argument_t *rtRequestPort;	/* always non-NULL, defaults to first arg */
     argument_t *rtUReplyPort;	/* always non-NULL, defaults to Mig-supplied */
     argument_t *rtSReplyPort;	/* always non-NULL, defaults to Mig-supplied */
-    argument_t *rtReturn;	/* non-NULL unless rtProcedure */
+    argument_t *rtReturn;	/* non-NULL */
     argument_t *rtServerReturn;	/* NULL or rtReturn  */
     argument_t *rtRetCode;	/* always non-NULL */
     argument_t *rtWaitTime;	/* if non-NULL, will use MACH_RCV_TIMEOUT */
@@ -388,10 +378,6 @@ extern boolean_t rtCheckMaskFunction(const argument_t *args, u_int mask,
 
 extern routine_t *rtMakeRoutine(identifier_t name, argument_t *args);
 extern routine_t *rtMakeSimpleRoutine(identifier_t name, argument_t *args);
-extern routine_t *rtMakeProcedure(identifier_t name, argument_t *args);
-extern routine_t *rtMakeSimpleProcedure(identifier_t name, argument_t *args);
-extern routine_t *rtMakeFunction(identifier_t name, argument_t *args,
-				 ipc_type_t *type);
 
 extern void rtPrintRoutine(const routine_t *rt);
 extern void rtCheckRoutine(routine_t *rt);
diff --git a/user.c b/user.c
index 1f3ba3d..66859f0 100644
--- a/user.c
+++ b/user.c
@@ -213,7 +213,7 @@ WriteVarDecls(FILE *file, const routine_t *rt)
 	fprintf(file, "\tReply *OutP = &Mess.Out;\n");
     fprintf(file, "\n");
 
-    if (!rt->rtOneWay || rt->rtProcedure)
+    if (!rt->rtOneWay)
 	fprintf(file, "\tmach_msg_return_t msg_result;\n");
 
     if (!rt->rtSimpleFixedRequest)
@@ -252,11 +252,9 @@ WriteVarDecls(FILE *file, const routine_t *rt)
 static void
 WriteMsgError(FILE *file, const routine_t *rt, const char *error_msg)
 {
-    if (rt->rtProcedure)
-	fprintf(file, "\t\t{ %s(%s); return; }\n", rt->rtErrorName, error_msg);
-    else if (rt->rtReturn != rt->rtRetCode)
+    if (rt->rtReturn != rt->rtRetCode)
     {
-	fprintf(file, "\t\t{ %s(%s); ", rt->rtErrorName, error_msg);
+	fprintf(file, "\t\t{ (%s); ", error_msg);
 	if (rt->rtNumReplyVar > 0)
 	    fprintf(file, "OutP = &Mess.Out; ");
 	fprintf(file, "return OutP->%s; }\n", rt->rtReturn->argMsgField);
@@ -267,16 +265,12 @@ WriteMsgError(FILE *file, const routine_t *rt, const char *error_msg)
 
 /*************************************************************
  *   Writes the send call when there is to be no subsequent
- *   receive. Called by WriteRoutine for SimpleProcedures
- *   or SimpleRoutines
+ *   receive. Called by WriteRoutine for SimpleRoutines.
  *************************************************************/
 static void
 WriteMsgSend(FILE *file, const routine_t *rt)
 {
-    const char *MsgResult = (rt->rtProcedure)
-			? "msg_result ="
-			: "return";
-
+    const char *MsgResult = "return";
     char SendSize[24];
 
     if (rt->rtNumRequestVar == 0)
@@ -301,12 +295,6 @@ WriteMsgSend(FILE *file, const routine_t *rt)
 		" MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);\n"
 		);
     }
-
-    if (rt->rtProcedure)
-    {
-	fprintf(file, "\tif (msg_result != MACH_MSG_SUCCESS)\n");
-	WriteMsgError(file, rt, "msg_result");
-    }
 }
 
 /*************************************************************
@@ -342,7 +330,7 @@ WriteMsgCheckReceive(FILE *file, const routine_t *rt, const char *success)
 /*************************************************************
  *  Writes the rpc call and the code to check for errors.
  *  This is the default code to be generated. Called by WriteRoutine
- *  for all routine types except SimpleProcedure and SimpleRoutine.
+ *  for all routine types except SimpleRoutine.
  *************************************************************/
 static void
 WriteMsgRPC(FILE *file, const routine_t *rt)
@@ -1213,12 +1201,8 @@ WriteRoutine(FILE *file, const routine_t *rt)
 	else {
 	    WriteReplyArgs(file, rt);
 
-	    /* return the return value, if any */
-
-	    if (rt->rtProcedure)
-		fprintf(file, "\t/* Procedure - no return needed */\n");
-	    else
-		WriteReturnValue(file, rt);
+	    /* return the return value */
+            WriteReturnValue(file, rt);
 	}
     }