[PATCH] Remove functions, procedures and simple procedures.

[Flavio Cruz]

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.
---
 lexxer.l  |  3 ---
 parser.y  | 19 --------------
 routine.c | 85 +++++----------------------------------------------------------
 routine.h | 22 +++--------------
 user.c    | 32 ++++++------------------
 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);
        }
     }
 
-- 
2.6.4