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
