Drop the register keyword

Drop the register keyword both from MIGs code and from the generated
code. The register keyword is only a hint and it is ignored by modern
compilers.

* alloca.c: Drop the register keyword.
* header.c: Likewise.
* lexxer.l: Likewise.
* parser.y: Likewise.
* routine.c: Likewise.
* server.c: Likewise.
* statement.c: Likewise.
* string.c: Likewise.
* type.c: Likewise.
* user.c: Likewise.
* utils.c: Likewise.
* vprint.c: Likewise.

12 files changed, 224 insertions, 224 deletions

diff --git a/alloca.c b/alloca.c
index 8f98b73..ce1d6c5 100644
--- a/alloca.c
+++ b/alloca.c
@@ -172,7 +172,7 @@ alloca (size)
      unsigned size;
 {
   auto char probe;		/* Probes stack depth: */
-  register char *depth = ADDRESS_FUNCTION (probe);
+  char *depth = ADDRESS_FUNCTION (probe);
 
 #if STACK_DIRECTION == 0
   if (STACK_DIR == 0)		/* Unknown growth direction.  */
@@ -183,7 +183,7 @@ alloca (size)
      was allocated from deeper in the stack than currently.  */
 
   {
-    register header *hp;	/* Traverses linked list.  */
+    header *hp;	/* Traverses linked list.  */
 
 #ifdef emacs
     BLOCK_INPUT;
@@ -193,7 +193,7 @@ alloca (size)
       if ((STACK_DIR > 0 && hp->h.deep > depth)
 	  || (STACK_DIR < 0 && hp->h.deep < depth))
 	{
-	  register header *np = hp->h.next;
+	  header *np = hp->h.next;
 
 	  free ((pointer) hp);	/* Collect garbage.  */
 
@@ -215,7 +215,7 @@ alloca (size)
   /* Allocate combined header + user data storage.  */
 
   {
-    register pointer new = malloc (sizeof (header) + size);
+    pointer new = malloc (sizeof (header) + size);
     /* Address of header.  */
 
     if (new == 0)
diff --git a/header.c b/header.c
index e8a56fe..150412a 100644
--- a/header.c
+++ b/header.c
@@ -93,7 +93,7 @@ WriteUserRoutine(FILE *file, const routine_t *rt)
 void
 WriteUserHeader(FILE *file, const statement_t *stats)
 {
-    register const statement_t *stat;
+    const statement_t *stat;
     const char *protect = strconcat(SubsystemName, "_user_");
 
     WriteProlog(file, protect);
@@ -149,7 +149,7 @@ WriteServerRoutine(FILE *file, const routine_t *rt)
 void
 WriteServerHeader(FILE *file, const statement_t *stats)
 {
-    register const statement_t *stat;
+    const statement_t *stat;
     const char *protect = strconcat(SubsystemName, "_server_");
 
     WriteProlog(file, protect);
@@ -173,7 +173,7 @@ WriteServerHeader(FILE *file, const statement_t *stats)
 }
 
 static void
-WriteInternalRedefine(FILE *file, register const routine_t *rt)
+WriteInternalRedefine(FILE *file, const routine_t *rt)
 {
     fprintf(file, "#define %s %s_external\n", rt->rtUserName, rt->rtUserName);
 }
@@ -181,7 +181,7 @@ WriteInternalRedefine(FILE *file, register const routine_t *rt)
 void
 WriteInternalHeader(FILE *file, const statement_t *stats)
 {
-    register const statement_t *stat;
+    const statement_t *stat;
 
     for (stat = stats; stat != stNULL; stat = stat->stNext)
 	switch (stat->stKind)
diff --git a/lexxer.l b/lexxer.l
index 9725d0b..6686b55 100644
--- a/lexxer.l
+++ b/lexxer.l
@@ -262,7 +262,7 @@ LookFileName(void)
 static void
 doSharp(const char *body)
 {
-    register const char *startName;
+    const char *startName;
 
     lineno = atoi(body);
     startName = strchr(body, '"');
diff --git a/parser.y b/parser.y
index ade56be..a916cb3 100644
--- a/parser.y
+++ b/parser.y
@@ -172,7 +172,7 @@ Statement		:	Subsystem sySemi
 			|	TypeDecl sySemi
 			|	RoutineDecl sySemi
 {
-    register statement_t *st = stAlloc();
+    statement_t *st = stAlloc();
 
     st->stKind = skRoutine;
     st->stRoutine = $1;
@@ -305,7 +305,7 @@ ServerDemux		:	syServerDemux syIdentifier
 
 Import			:	LookFileName ImportIndicant syFileName
 {
-    register statement_t *st = stAlloc();
+    statement_t *st = stAlloc();
     st->stKind = $2;
     st->stFileName = $3;
 
@@ -331,7 +331,7 @@ RCSDecl			:	LookQString syRCSId syQString
 
 TypeDecl		:	syType NamedTypeSpec
 {
-    register identifier_t name = $2->itName;
+    identifier_t name = $2->itName;
 
     if (itLookUp(name) != itNULL)
 	warn("overriding previous definition of %s", name);
diff --git a/routine.c b/routine.c
index fcdfaf1..94e2b4c 100644
--- a/routine.c
+++ b/routine.c
@@ -52,7 +52,7 @@ u_int rtNumber = 0;
 routine_t *
 rtAlloc(void)
 {
-    register routine_t *new;
+    routine_t *new;
 
     new = (routine_t *) calloc(1, sizeof *new);
     if (new == rtNULL)
@@ -103,7 +103,7 @@ argAlloc(void)
 	FALSE,			/* boolean_t argByReferenceUser */
 	FALSE			/* boolean_t argByReferenceServer */
     };
-    register argument_t *new;
+    argument_t *new;
 
     new = malloc(sizeof *new);
     if (new == argNULL)
@@ -115,7 +115,7 @@ argAlloc(void)
 routine_t *
 rtMakeRoutine(identifier_t name, argument_t *args)
 {
-    register routine_t *rt = rtAlloc();
+    routine_t *rt = rtAlloc();
 
     rt->rtName = name;
     rt->rtKind = rkRoutine;
@@ -127,7 +127,7 @@ rtMakeRoutine(identifier_t name, argument_t *args)
 routine_t *
 rtMakeSimpleRoutine(identifier_t name, argument_t *args)
 {
-    register routine_t *rt = rtAlloc();
+    routine_t *rt = rtAlloc();
 
     rt->rtName = name;
     rt->rtKind = rkSimpleRoutine;
@@ -139,7 +139,7 @@ rtMakeSimpleRoutine(identifier_t name, argument_t *args)
 routine_t *
 rtMakeProcedure(identifier_t name, argument_t *args)
 {
-    register routine_t *rt = rtAlloc();
+    routine_t *rt = rtAlloc();
 
     rt->rtName = name;
     rt->rtKind = rkProcedure;
@@ -153,7 +153,7 @@ rtMakeProcedure(identifier_t name, argument_t *args)
 routine_t *
 rtMakeSimpleProcedure(identifier_t name, argument_t *args)
 {
-    register routine_t *rt = rtAlloc();
+    routine_t *rt = rtAlloc();
 
     rt->rtName = name;
     rt->rtKind = rkSimpleProcedure;
@@ -167,8 +167,8 @@ rtMakeSimpleProcedure(identifier_t name, argument_t *args)
 routine_t *
 rtMakeFunction(identifier_t name, argument_t *args, ipc_type_t *type)
 {
-    register routine_t *rt = rtAlloc();
-    register argument_t *ret = argAlloc();
+    routine_t *rt = rtAlloc();
+    argument_t *ret = argAlloc();
 
     ret->argName = name;
     ret->argKind = akReturn;
@@ -206,9 +206,9 @@ rtRoutineKindToStr(routine_kind_t rk)
 }
 
 static void
-rtPrintArg(register const argument_t *arg)
+rtPrintArg(const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     if (!akCheck(arg->argKind, akbUserArg|akbServerArg) ||
 	(akIdent(arg->argKind) == akeCount) ||
@@ -280,9 +280,9 @@ rtPrintArg(register const argument_t *arg)
 }
 
 void
-rtPrintRoutine(register const routine_t *rt)
+rtPrintRoutine(const routine_t *rt)
 {
-    register const argument_t *arg;
+    const argument_t *arg;
 
     printf("%s (%d) %s(", rtRoutineKindToStr(rt->rtKind),
 	   rt->rtNumber, rt->rtName);
@@ -309,14 +309,14 @@ static void
 rtCheckSimpleIn(const argument_t *args, u_int mask, boolean_t *fixed,
 		boolean_t *simple)
 {
-    register const argument_t *arg;
+    const argument_t *arg;
     boolean_t MayBeComplex = FALSE;
     boolean_t MustBeComplex = FALSE;
 
     for (arg = args; arg != argNULL; arg = arg->argNext)
 	if (akCheck(arg->argKind, mask))
 	{
-	    register const ipc_type_t *it = arg->argType;
+	    const ipc_type_t *it = arg->argType;
 
 	    if (it->itInName == MACH_MSG_TYPE_POLYMORPHIC)
 		MayBeComplex = TRUE;
@@ -345,14 +345,14 @@ static void
 rtCheckSimpleOut(const argument_t *args, u_int mask, boolean_t *fixed,
 		 boolean_t *simple)
 {
-    register const argument_t *arg;
+    const argument_t *arg;
     boolean_t MayBeComplex = FALSE;
     boolean_t MustBeComplex = FALSE;
 
     for (arg = args; arg != argNULL; arg = arg->argNext)
 	if (akCheck(arg->argKind, mask))
 	{
-	    register const ipc_type_t *it = arg->argType;
+	    const ipc_type_t *it = arg->argType;
 
 	    if (it->itOutName == MACH_MSG_TYPE_POLYMORPHIC)
 		MayBeComplex = TRUE;
@@ -372,13 +372,13 @@ rtCheckSimpleOut(const argument_t *args, u_int mask, boolean_t *fixed,
 static u_int
 rtFindSize(const argument_t *args, u_int mask)
 {
-    register const argument_t *arg;
+    const argument_t *arg;
     u_int size = sizeof_mach_msg_header_t;
 
     for (arg = args; arg != argNULL; arg = arg->argNext)
 	if (akCheck(arg->argKind, mask))
 	{
-	    register ipc_type_t *it = arg->argType;
+	    ipc_type_t *it = arg->argType;
 
 	    if (arg->argLongForm) {
 		/* might need proper alignment on 64bit archies */
@@ -397,7 +397,7 @@ rtFindSize(const argument_t *args, u_int mask)
 boolean_t
 rtCheckMask(const argument_t *args, u_int mask)
 {
-    register const argument_t *arg;
+    const argument_t *arg;
 
     for (arg = args; arg != argNULL; arg = arg->argNext)
 	if (akCheckAll(arg->argKind, mask))
@@ -409,7 +409,7 @@ boolean_t
 rtCheckMaskFunction(const argument_t *args, u_int mask,
 		    boolean_t (*func)(const argument_t *))
 {
-    register const argument_t *arg;
+    const argument_t *arg;
 
     for (arg = args; arg != argNULL; arg = arg->argNext)
 	if (akCheckAll(arg->argKind, mask))
@@ -437,9 +437,9 @@ rtDefaultArgKind(const routine_t *rt, argument_t *arg)
  */
 
 static void
-rtProcessArgFlags(register argument_t *arg)
+rtProcessArgFlags(argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     arg->argFlags = itCheckFlags(arg->argFlags, arg->argName);
 
@@ -482,7 +482,7 @@ rtProcessArgFlags(register argument_t *arg)
 static void
 rtAugmentArgKind(argument_t *arg)
 {
-    register ipc_type_t *it = arg->argType;
+    ipc_type_t *it = arg->argType;
 
     /* akbVariable means variable-sized inline. */
 
@@ -640,7 +640,7 @@ rtCheckRoutineArg(routine_t *rt, argument_t *arg)
 /* arg->argType may be NULL in this function */
 
 static void
-rtSetArgDefaults(routine_t *rt, register argument_t *arg)
+rtSetArgDefaults(routine_t *rt, argument_t *arg)
 {
     arg->argRoutine = rt;
     if (arg->argVarName == strNULL)
@@ -693,9 +693,9 @@ rtSetArgDefaults(routine_t *rt, register argument_t *arg)
 }
 
 static void
-rtAddCountArg(register argument_t *arg)
+rtAddCountArg(argument_t *arg)
 {
-    register argument_t *count;
+    argument_t *count;
 
     count = argAlloc();
     count->argName = strconcat(arg->argName, "Cnt");
@@ -724,9 +724,9 @@ rtAddCountArg(register argument_t *arg)
 }
 
 static void
-rtAddCountInOutArg(register argument_t *arg)
+rtAddCountInOutArg(argument_t *arg)
 {
-    register argument_t *count;
+    argument_t *count;
 
     /*
      *	The user sees a single count variable.  However, to get the
@@ -752,10 +752,10 @@ rtAddCountInOutArg(register argument_t *arg)
 }
 
 static void
-rtAddPolyArg(register argument_t *arg)
+rtAddPolyArg(argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
-    register argument_t *poly;
+    const ipc_type_t *it = arg->argType;
+    argument_t *poly;
     arg_kind_t akbsend, akbreturn;
 
     poly = argAlloc();
@@ -808,9 +808,9 @@ rtAddPolyArg(register argument_t *arg)
 }
 
 static void
-rtAddDeallocArg(register argument_t *arg)
+rtAddDeallocArg(argument_t *arg)
 {
-    register argument_t *dealloc;
+    argument_t *dealloc;
 
     dealloc = argAlloc();
     dealloc->argName = strconcat(arg->argName, "Dealloc");
@@ -860,9 +860,9 @@ rtAddDeallocArg(register argument_t *arg)
 }
 
 static void
-rtAddSCopyArg(register argument_t *arg)
+rtAddSCopyArg(argument_t *arg)
 {
-    register argument_t *scopy;
+    argument_t *scopy;
 
     scopy = argAlloc();
     scopy->argName = strconcat(arg->argName, "SCopy");
@@ -884,11 +884,11 @@ rtAddSCopyArg(register argument_t *arg)
 static void
 rtCheckRoutineArgs(routine_t *rt)
 {
-    register argument_t *arg;
+    argument_t *arg;
 
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
     {
-	register const ipc_type_t *it = arg->argType;
+	const ipc_type_t *it = arg->argType;
 
 	rtDefaultArgKind(rt, arg);
 	rtCheckRoutineArg(rt, arg);
@@ -993,13 +993,13 @@ rtCheckArgTypes(routine_t *rt)
 static void
 rtCheckArgTrans(const routine_t *rt)
 {
-    register const argument_t *arg;
+    const argument_t *arg;
 
     /* the arg may not have a type (if there was some error in parsing it) */
 
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
     {
-	register const ipc_type_t *it = arg->argType;
+	const ipc_type_t *it = arg->argType;
 
 	if ((it != itNULL) &&
 	    !streql(it->itServerType, it->itTransType))
@@ -1028,7 +1028,7 @@ rtCheckArgTrans(const routine_t *rt)
 static void
 rtAddRetCode(routine_t *rt)
 {
-    register argument_t *arg = argAlloc();
+    argument_t *arg = argAlloc();
 
     arg->argName = "RetCode";
     arg->argType = itRetCodeType;
@@ -1049,7 +1049,7 @@ rtAddRetCode(routine_t *rt)
 static void
 rtAddWaitTime(routine_t *rt, identifier_t name)
 {
-    register argument_t *arg = argAlloc();
+    argument_t *arg = argAlloc();
     argument_t **loc;
 
     arg->argName = "dummy WaitTime arg";
@@ -1080,7 +1080,7 @@ rtAddWaitTime(routine_t *rt, identifier_t name)
 static void
 rtAddMsgOption(routine_t *rt, identifier_t name)
 {
-    register argument_t *arg = argAlloc();
+    argument_t *arg = argAlloc();
     argument_t **loc;
 
     arg->argName = "dummy MsgOption arg";
@@ -1110,7 +1110,7 @@ rtAddMsgOption(routine_t *rt, identifier_t name)
 static void
 rtAddDummyReplyPort(routine_t *rt, ipc_type_t *type, int user)
 {
-    register argument_t *arg = argAlloc();
+    argument_t *arg = argAlloc();
     argument_t **loc;
 
     arg->argName = "dummy ReplyPort arg";
@@ -1143,16 +1143,16 @@ rtAddDummyReplyPort(routine_t *rt, ipc_type_t *type, int user)
  * argRequestPos and argReplyPos get -1 if the value shouldn't be used.
  */
 static void
-rtCheckVariable(register routine_t *rt)
+rtCheckVariable(routine_t *rt)
 {
-    register argument_t *arg;
+    argument_t *arg;
     int NumRequestVar = 0;
     int NumReplyVar = 0;
     int MaxRequestPos = 0;
     int MaxReplyPos = 0;
 
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
-	register argument_t *parent = arg->argParent;
+	argument_t *parent = arg->argParent;
 
 	if (parent == argNULL) {
 	    if (akCheck(arg->argKind, akbRequest|akbSend)) {
@@ -1196,12 +1196,12 @@ rtCheckVariable(register routine_t *rt)
  */
 
 static void
-rtCheckDestroy(register routine_t *rt)
+rtCheckDestroy(routine_t *rt)
 {
-    register argument_t *arg;
+    argument_t *arg;
 
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
-	register const ipc_type_t *it = arg->argType;
+	const ipc_type_t *it = arg->argType;
 
 	if(akCheck(arg->argKind, akbSendRcv) &&
 	   !akCheck(arg->argKind, akbReturnSnd)) {
@@ -1217,12 +1217,12 @@ rtCheckDestroy(register routine_t *rt)
  */
 
 static void
-rtAddByReference(register routine_t *rt)
+rtAddByReference(routine_t *rt)
 {
-    register argument_t *arg;
+    argument_t *arg;
 
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
-	register const ipc_type_t *it = arg->argType;
+	const ipc_type_t *it = arg->argType;
 
 	if (akCheck(arg->argKind, akbReturnRcv) &&
 	    (it->itStruct || it->itIndefinite)) {
@@ -1244,7 +1244,7 @@ rtAddByReference(register routine_t *rt)
 }
 
 void
-rtCheckRoutine(register routine_t *rt)
+rtCheckRoutine(routine_t *rt)
 {
     /* Initialize random fields. */
 
diff --git a/server.c b/server.c
index a041e61..8496da7 100644
--- a/server.c
+++ b/server.c
@@ -95,12 +95,12 @@ WriteProlog(FILE *file)
 static void
 WriteSymTabEntries(FILE *file, const statement_t *stats)
 {
-    register const statement_t *stat;
-    register u_int current = 0;
+    const statement_t *stat;
+    u_int current = 0;
 
     for (stat = stats; stat != stNULL; stat = stat->stNext)
 	if (stat->stKind == skRoutine) {
-	    register u_int num = stat->stRoutine->rtNumber;
+	    u_int num = stat->stRoutine->rtNumber;
 	    const char	*name = stat->stRoutine->rtName;
 
 	    while (++current <= num)
@@ -117,13 +117,13 @@ WriteSymTabEntries(FILE *file, const statement_t *stats)
 static void
 WriteArrayEntries(FILE *file, const statement_t *stats)
 {
-    register u_int current = 0;
-    register const statement_t *stat;
+    u_int current = 0;
+    const statement_t *stat;
 
     for (stat = stats; stat != stNULL; stat = stat->stNext)
 	if (stat->stKind == skRoutine)
 	{
-	    register const routine_t *rt = stat->stRoutine;
+	    const routine_t *rt = stat->stRoutine;
 
 	    while (current++ < rt->rtNumber)
 		fprintf(file, "\t\t0,\n");
@@ -155,9 +155,9 @@ WriteEpilog(FILE *file, const statement_t *stats)
     fprintf(file, "\t(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)\n");
 
     fprintf(file, "{\n");
-    fprintf(file, "\tregister mach_msg_header_t *InP =  InHeadP;\n");
+    fprintf(file, "\tmach_msg_header_t *InP =  InHeadP;\n");
 
-    fprintf(file, "\tregister mig_reply_header_t *OutP = (mig_reply_header_t *) OutHeadP;\n");
+    fprintf(file, "\tmig_reply_header_t *OutP = (mig_reply_header_t *) OutHeadP;\n");
 
     fprintf(file, "\n");
 
@@ -166,7 +166,7 @@ WriteEpilog(FILE *file, const statement_t *stats)
 		    !IsKernelServer, "RetCodeType");
     fprintf(file, "\n");
 
-    fprintf(file, "\tregister mig_routine_t routine;\n");
+    fprintf(file, "\tmig_routine_t routine;\n");
     fprintf(file, "\n");
 
     fprintf(file, "\tOutP->Head.msgh_bits = ");
@@ -203,7 +203,7 @@ WriteEpilog(FILE *file, const statement_t *stats)
     fprintf(file, "\t(const mach_msg_header_t *InHeadP)\n");
 
     fprintf(file, "{\n");
-    fprintf(file, "\tregister int msgh_id;\n");
+    fprintf(file, "\tint msgh_id;\n");
     fprintf(file, "\n");
     fprintf(file, "\tmsgh_id = InHeadP->msgh_id - %d;\n", SubsystemBase);
     fprintf(file, "\n");
@@ -240,13 +240,13 @@ ServerSideType(const routine_t *rt)
 }
 
 static void
-WriteLocalVarDecl(FILE *file, register const argument_t *arg)
+WriteLocalVarDecl(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     if (it->itInLine && it->itVarArray)
     {
-	register const ipc_type_t *btype = it->itElement;
+	const ipc_type_t *btype = it->itElement;
 
 	fprintf(file, "\t%s %s[%d]", btype->itTransType,
 		arg->argVarName, it->itNumber/btype->itNumber);
@@ -256,7 +256,7 @@ WriteLocalVarDecl(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteLocalPtrDecl(FILE *file, register const argument_t *arg)
+WriteLocalPtrDecl(FILE *file, const argument_t *arg)
 {
     fprintf(file, "\t%s *%sP",
 		FetchServerType(arg->argType->itElement),
@@ -283,10 +283,10 @@ WriteVarDecls(FILE *file, const routine_t *rt)
     boolean_t NeedMsghSize = FALSE;
     boolean_t NeedMsghSizeDelta = FALSE;
 
-    fprintf(file, "\tregister Request *In0P = (Request *) InHeadP;\n");
+    fprintf(file, "\tRequest *In0P = (Request *) InHeadP;\n");
     for (i = 1; i <= rt->rtMaxRequestPos; i++)
-	fprintf(file, "\tregister Request *In%dP;\n", i);
-    fprintf(file, "\tregister Reply *OutP = (Reply *) OutHeadP;\n");
+	fprintf(file, "\tRequest *In%dP;\n", i);
+    fprintf(file, "\tReply *OutP = (Reply *) OutHeadP;\n");
 
     fprintf(file, "\tmig_external %s %s\n",
 	    ServerSideType(rt), rt->rtServerName);
@@ -411,10 +411,10 @@ WriteCheckHead(FILE *file, const routine_t *rt)
 }
 
 static void
-WriteTypeCheck(FILE *file, register const argument_t *arg)
+WriteTypeCheck(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
-    register const routine_t *rt = arg->argRoutine;
+    const ipc_type_t *it = arg->argType;
+    const routine_t *rt = arg->argRoutine;
 
     fprintf(file, "#if\tTypeCheck\n");
     if (akCheck(arg->argKind, akbRequestQC))
@@ -461,10 +461,10 @@ WriteTypeCheck(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteCheckArgSize(FILE *file, register const argument_t *arg)
+WriteCheckArgSize(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *ptype = arg->argType;
-    register const ipc_type_t *btype = ptype->itElement;
+    const ipc_type_t *ptype = arg->argType;
+    const ipc_type_t *btype = ptype->itElement;
     const argument_t *count = arg->argCount;
     int multiplier = btype->itTypeSize / btype->itNumber;
 
@@ -497,9 +497,9 @@ WriteCheckArgSize(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteCheckMsgSize(FILE *file, register const argument_t *arg)
+WriteCheckMsgSize(FILE *file, const argument_t *arg)
 {
-    register const routine_t *rt = arg->argRoutine;
+    const routine_t *rt = arg->argRoutine;
 
     /* If there aren't any more In args after this, then
        we can use the msgh_size_delta value directly in
@@ -554,7 +554,7 @@ WriteCheckMsgSize(FILE *file, register const argument_t *arg)
 }
 
 static const char *
-InArgMsgField(register const argument_t *arg)
+InArgMsgField(const argument_t *arg)
 {
     static char buffer[100];
 
@@ -577,9 +577,9 @@ InArgMsgField(register const argument_t *arg)
 }
 
 static void
-WriteExtractArgValue(FILE *file, register const argument_t *arg)
+WriteExtractArgValue(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     if (arg->argMultiplier > 1)
 	WriteCopyType(file, it, "%s", "/* %s */ %s / %d",
@@ -594,10 +594,10 @@ WriteExtractArgValue(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteInitializeCount(FILE *file, register const argument_t *arg)
+WriteInitializeCount(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *ptype = arg->argParent->argType;
-    register const ipc_type_t *btype = ptype->itElement;
+    const ipc_type_t *ptype = arg->argParent->argType;
+    const ipc_type_t *btype = ptype->itElement;
 
     /*
      *	Initialize 'count' argument for variable-length inline OUT parameter
@@ -624,7 +624,7 @@ WriteInitializeCount(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteInitializePtr(FILE *file, register const argument_t *arg)
+WriteInitializePtr(FILE *file, const argument_t *arg)
 {
     if (akCheck(arg->argKind, akbVarNeeded))
 	fprintf(file, "\t%sP = %s;\n",
@@ -635,7 +635,7 @@ WriteInitializePtr(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteTypeCheckArg(FILE *file, register const argument_t *arg)
+WriteTypeCheckArg(FILE *file, const argument_t *arg)
 {
     if (akCheck(arg->argKind, akbRequest)) {
 	WriteTypeCheck(file, arg);
@@ -646,9 +646,9 @@ WriteTypeCheckArg(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteAdjustRequestMsgPtr(FILE *file, register const argument_t *arg)
+WriteAdjustRequestMsgPtr(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *ptype = arg->argType;
+    const ipc_type_t *ptype = arg->argType;
 
     fprintf(file,
 	"\tIn%dP = (Request *) ((char *) In%dP + msgh_size_delta - %d);\n\n",
@@ -657,10 +657,10 @@ WriteAdjustRequestMsgPtr(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteTypeCheckRequestArgs(FILE *file, register const routine_t *rt)
+WriteTypeCheckRequestArgs(FILE *file, const routine_t *rt)
 {
-    register const argument_t *arg;
-    register const argument_t *lastVarArg;
+    const argument_t *arg;
+    const argument_t *lastVarArg;
 
     lastVarArg = argNULL;
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
@@ -690,7 +690,7 @@ WriteTypeCheckRequestArgs(FILE *file, register const routine_t *rt)
 }
 
 static void
-WriteExtractArg(FILE *file, register const argument_t *arg)
+WriteExtractArg(FILE *file, const argument_t *arg)
 {
     if (akCheckAll(arg->argKind, akbSendRcv|akbVarNeeded))
 	WriteExtractArgValue(file, arg);
@@ -698,7 +698,7 @@ WriteExtractArg(FILE *file, register const argument_t *arg)
     if ((akIdent(arg->argKind) == akeCount) &&
 	akCheck(arg->argKind, akbReturnSnd))
     {
-	register ipc_type_t *ptype = arg->argParent->argType;
+	ipc_type_t *ptype = arg->argParent->argType;
 
 	if (ptype->itInLine && ptype->itVarArray)
 	    WriteInitializeCount(file, arg);
@@ -709,7 +709,7 @@ WriteExtractArg(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteServerCallArg(FILE *file, register const argument_t *arg)
+WriteServerCallArg(FILE *file, const argument_t *arg)
 {
     const ipc_type_t *it = arg->argType;
     boolean_t NeedClose = FALSE;
@@ -754,9 +754,9 @@ WriteServerCallArg(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteDestroyArg(FILE *file, register const argument_t *arg)
+WriteDestroyArg(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     if (akCheck(arg->argKind, akbIndefinite)) {
 	/*
@@ -790,9 +790,9 @@ WriteDestroyArg(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteDestroyPortArg(FILE *file, register const argument_t *arg)
+WriteDestroyPortArg(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     /*
      *	If a translated port argument occurs in the body of a request
@@ -816,9 +816,9 @@ WriteDestroyPortArg(FILE *file, register const argument_t *arg)
  * Check whether WriteDestroyPortArg would generate any code for arg.
  */
 static boolean_t
-CheckDestroyPortArg(register const argument_t *arg)
+CheckDestroyPortArg(const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     if ((it->itInTrans != strNULL) &&
 	(it->itOutName == MACH_MSG_TYPE_PORT_SEND))
@@ -854,7 +854,7 @@ WriteServerCall(FILE *file, const routine_t *rt)
 }
 
 static void
-WriteGetReturnValue(FILE *file, register const routine_t *rt)
+WriteGetReturnValue(FILE *file, const routine_t *rt)
 {
     if (rt->rtServerReturn != rt->rtRetCode)
 	fprintf(file, "\tOutP->%s = KERN_SUCCESS;\n",
@@ -862,7 +862,7 @@ WriteGetReturnValue(FILE *file, register const routine_t *rt)
 }
 
 static void
-WriteCheckReturnValue(FILE *file, register const routine_t *rt)
+WriteCheckReturnValue(FILE *file, const routine_t *rt)
 {
     if (rt->rtServerReturn == rt->rtRetCode)
     {
@@ -873,7 +873,7 @@ WriteCheckReturnValue(FILE *file, register const routine_t *rt)
 }
 
 static void
-WritePackArgType(FILE *file, register const argument_t *arg)
+WritePackArgType(FILE *file, const argument_t *arg)
 {
     fprintf(file, "\n");
 
@@ -884,9 +884,9 @@ WritePackArgType(FILE *file, register const argument_t *arg)
 }
 
 static void
-WritePackArgValue(FILE *file, register const argument_t *arg)
+WritePackArgValue(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     fprintf(file, "\n");
 
@@ -907,8 +907,8 @@ WritePackArgValue(FILE *file, register const argument_t *arg)
 		it->itNumber);
 	}
 	else {
-	    register argument_t *count = arg->argCount;
-	    register ipc_type_t *btype = it->itElement;
+	    argument_t *count = arg->argCount;
+	    ipc_type_t *btype = it->itElement;
 
 	    /* Note btype->itNumber == count->argMultiplier */
 
@@ -965,7 +965,7 @@ WritePackArgValue(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteCopyArgValue(FILE *file, register const argument_t *arg)
+WriteCopyArgValue(FILE *file, const argument_t *arg)
 {
     fprintf(file, "\n");
     WriteCopyType(file, arg->argType, "/* %d */ OutP->%s", "In%dP->%s",
@@ -973,7 +973,7 @@ WriteCopyArgValue(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteAdjustMsgSimple(FILE *file, register const argument_t *arg)
+WriteAdjustMsgSimple(FILE *file, const argument_t *arg)
 {
     /* akbVarNeeded must be on */
 
@@ -986,7 +986,7 @@ WriteAdjustMsgSimple(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteAdjustMsgCircular(FILE *file, register const argument_t *arg)
+WriteAdjustMsgCircular(FILE *file, const argument_t *arg)
 {
     fprintf(file, "\n");
 
@@ -1016,11 +1016,11 @@ WriteAdjustMsgCircular(FILE *file, register const argument_t *arg)
  * Calculate the size of a variable-length message field.
  */
 static void
-WriteArgSize(FILE *file, register const argument_t *arg)
+WriteArgSize(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *ptype = arg->argType;
-    register int bsize = ptype->itElement->itTypeSize;
-    register const argument_t *count = arg->argCount;
+    const ipc_type_t *ptype = arg->argType;
+    int bsize = ptype->itElement->itTypeSize;
+    const argument_t *count = arg->argCount;
 
     if (ptype->itIndefinite) {
 	/*
@@ -1062,10 +1062,10 @@ WriteArgSize(FILE *file, register const argument_t *arg)
  * has more arguments following.
  */
 static void
-WriteAdjustMsgSize(FILE *file, register const argument_t *arg)
+WriteAdjustMsgSize(FILE *file, const argument_t *arg)
 {
-    register routine_t *rt = arg->argRoutine;
-    register ipc_type_t *ptype = arg->argType;
+    routine_t *rt = arg->argRoutine;
+    ipc_type_t *ptype = arg->argType;
 
     /* There are more Out arguments.  We need to adjust msgh_size
        and advance OutP, so we save the size of the current field
@@ -1101,7 +1101,7 @@ WriteAdjustMsgSize(FILE *file, register const argument_t *arg)
  * last argument has been packed.
  */
 static void
-WriteFinishMsgSize(FILE *file, register const argument_t *arg)
+WriteFinishMsgSize(FILE *file, const argument_t *arg)
 {
     /* No more Out arguments.  If this is the only variable Out
        argument, we can assign to msgh_size directly. */
@@ -1120,7 +1120,7 @@ WriteFinishMsgSize(FILE *file, register const argument_t *arg)
 }
 
 static void
-WritePackArg(FILE *file, register const argument_t *arg)
+WritePackArg(FILE *file, const argument_t *arg)
 {
     if (akCheck(arg->argKind, akbReplyInit))
 	WritePackArgType(file, arg);
@@ -1132,7 +1132,7 @@ WritePackArg(FILE *file, register const argument_t *arg)
     if (akCheckAll(arg->argKind, akbReturnSnd|akbVarNeeded))
 	WritePackArgValue(file, arg);
     else if (akCheckAll(arg->argKind, akbReturnSnd|akbVariable)) {
-	register const ipc_type_t *it = arg->argType;
+	const ipc_type_t *it = arg->argType;
 
 	if (it->itString) {
 	    /* Need to call strlen to calculate the size of the argument. */
@@ -1190,10 +1190,10 @@ WritePackArg(FILE *file, register const argument_t *arg)
  * that need to be copied.
  */
 static void
-WritePackReplyArgs(FILE *file, register const routine_t *rt)
+WritePackReplyArgs(FILE *file, const routine_t *rt)
 {
-    register const argument_t *arg;
-    register const argument_t *lastVarArg;
+    const argument_t *arg;
+    const argument_t *lastVarArg;
 
     lastVarArg = argNULL;
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
@@ -1236,7 +1236,7 @@ WriteFieldDecl(FILE *file, const argument_t *arg)
 }
 
 static void
-WriteRoutine(FILE *file, register const routine_t *rt)
+WriteRoutine(FILE *file, const routine_t *rt)
 {
     fprintf(file, "\n");
 
@@ -1308,7 +1308,7 @@ WriteRoutine(FILE *file, register const routine_t *rt)
 void
 WriteServer(FILE *file, const statement_t *stats)
 {
-    register const statement_t *stat;
+    const statement_t *stat;
 
     WriteProlog(file);
     for (stat = stats; stat != stNULL; stat = stat->stNext)
diff --git a/statement.c b/statement.c
index d26e17c..1110698 100644
--- a/statement.c
+++ b/statement.c
@@ -36,7 +36,7 @@ static statement_t **last = &StatementList;
 statement_t *
 stAlloc(void)
 {
-    register statement_t *new;
+    statement_t *new;
 
     new = malloc(sizeof *new);
     if (new == stNULL)
diff --git a/string.c b/string.c
index 6fe29c2..3f69903 100644
--- a/string.c
+++ b/string.c
@@ -34,7 +34,7 @@
 string_t
 strmake(const char *string)
 {
-    register string_t saved;
+    string_t saved;
 
     saved = malloc(strlen(string) + 1);
     if (saved == strNULL)
@@ -45,7 +45,7 @@ strmake(const char *string)
 string_t
 strconcat(const_string_t left, const_string_t right)
 {
-    register string_t saved;
+    string_t saved;
 
     saved = malloc(strlen(left) + strlen(right) + 1);
     if (saved == strNULL)
diff --git a/type.c b/type.c
index 2442391..3078dab 100644
--- a/type.c
+++ b/type.c
@@ -61,7 +61,7 @@ static ipc_type_t *list = itNULL;
 ipc_type_t *
 itLookUp(identifier_t name)
 {
-    register ipc_type_t *it, **last;
+    ipc_type_t *it, **last;
 
     for (it = *(last = &list); it != itNULL; it = *(last = &it->itNext))
 	if (streql(name, it->itName))
@@ -121,7 +121,7 @@ itAlloc(void)
 	strNULL,		/* identifier_t itOutTrans */
 	strNULL,		/* identifier_t itDestructor */
     };
-    register ipc_type_t *new;
+    ipc_type_t *new;
 
     new = malloc(sizeof *new);
     if (new == itNULL)
@@ -148,7 +148,7 @@ itNameToString(u_int name)
  * when itInLine, itNumber, or itSize changes.
  */
 static void
-itCalculateSizeInfo(register ipc_type_t *it)
+itCalculateSizeInfo(ipc_type_t *it)
 {
     if (it->itInLine)
     {
@@ -188,7 +188,7 @@ itCalculateSizeInfo(register ipc_type_t *it)
  * Every argument's type should have these values filled in.
  */
 static void
-itCalculateNameInfo(register ipc_type_t *it)
+itCalculateNameInfo(ipc_type_t *it)
 {
     if (it->itInNameStr == strNULL)
 	it->itInNameStr = strmake(itNameToString(it->itInName));
@@ -295,7 +295,7 @@ itCheckDeallocate(const ipc_type_t *it, ipc_flags_t flags, dealloc_t dfault,
 }
 
 static enum uselong { NotLong, CanBeLong, ShouldBeLong, MustBeLong, TooLong }
-itUseLong(register const ipc_type_t *it)
+itUseLong(const ipc_type_t *it)
 {
     enum uselong uselong = NotLong;
 
@@ -364,7 +364,7 @@ itCheckIsLong(const ipc_type_t *it, ipc_flags_t flags, boolean_t dfault,
  *  is parsed.
  ******************************************************/
 static void
-itCheckDecl(identifier_t name, register ipc_type_t *it)
+itCheckDecl(identifier_t name, ipc_type_t *it)
 {
     enum uselong uselong;
 
@@ -501,7 +501,7 @@ ipc_type_t *
 itLongDecl(u_int inname, const_string_t instr, u_int outname,
 	   const_string_t outstr, u_int defsize, u_int size, ipc_flags_t flags)
 {
-    register ipc_type_t *it;
+    ipc_type_t *it;
 
     if ((defsize != 0) && (defsize != size))
 	warn("IPC type decl has strange size (%u instead of %u)",
@@ -527,7 +527,7 @@ itLongDecl(u_int inname, const_string_t instr, u_int outname,
 static ipc_type_t *
 itCopyType(const ipc_type_t *old)
 {
-    register ipc_type_t *new = itAlloc();
+    ipc_type_t *new = itAlloc();
 
     *new = *old;
     new->itName = strNULL;
@@ -571,7 +571,7 @@ itResetType(ipc_type_t *old)
 ipc_type_t *
 itPrevDecl(identifier_t name)
 {
-    register ipc_type_t *old;
+    ipc_type_t *old;
 
     old = itLookUp(name);
     if (old == itNULL)
@@ -590,9 +590,9 @@ itPrevDecl(identifier_t name)
  *	type new = array[*:number] of old;
  */
 ipc_type_t *
-itVarArrayDecl(u_int number, register const ipc_type_t *old)
+itVarArrayDecl(u_int number, const ipc_type_t *old)
 {
-    register ipc_type_t *it = itResetType(itCopyType(old));
+    ipc_type_t *it = itResetType(itCopyType(old));
 
     if (!it->itInLine || it->itVarArray)
 	error("IPC type decl is too complicated");
@@ -623,7 +623,7 @@ itVarArrayDecl(u_int number, register const ipc_type_t *old)
 ipc_type_t *
 itArrayDecl(u_int number, const ipc_type_t *old)
 {
-    register ipc_type_t *it = itResetType(itCopyType(old));
+    ipc_type_t *it = itResetType(itCopyType(old));
 
     if (!it->itInLine || it->itVarArray)
 	error("IPC type decl is too complicated");
@@ -662,7 +662,7 @@ itPtrDecl(ipc_type_t *it)
 ipc_type_t *
 itStructDecl(u_int number, const ipc_type_t *old)
 {
-    register ipc_type_t *it = itResetType(itCopyType(old));
+    ipc_type_t *it = itResetType(itCopyType(old));
 
     if (!it->itInLine || it->itVarArray)
 	error("IPC type decl is too complicated");
@@ -681,8 +681,8 @@ itStructDecl(u_int number, const ipc_type_t *old)
 ipc_type_t *
 itCStringDecl(u_int count, boolean_t varying)
 {
-    register ipc_type_t *it;
-    register ipc_type_t *itElement;
+    ipc_type_t *it;
+    ipc_type_t *itElement;
 
     itElement = itShortDecl(MACH_MSG_TYPE_STRING_C,
 			    "MACH_MSG_TYPE_STRING_C",
diff --git a/user.c b/user.c
index 7b714c4..37f53d2 100644
--- a/user.c
+++ b/user.c
@@ -56,7 +56,7 @@ WriteIncludes(FILE *file)
 
 	if (InternalHeaderFileName != strNULL)
 	{
-	    register char *cp;
+	    char *cp;
 
 	    /* Strip any leading path from InternalHeaderFileName. */
 	    cp = strrchr(InternalHeaderFileName, '/');
@@ -70,7 +70,7 @@ WriteIncludes(FILE *file)
 
     if (UserHeaderFileName != strNULL)
     {
-	register char *cp;
+	char *cp;
 
 	/* Strip any leading path from UserHeaderFileName. */
 	cp = strrchr(UserHeaderFileName, '/');
@@ -208,9 +208,9 @@ WriteVarDecls(FILE *file, const routine_t *rt)
     fprintf(file, "\t} Mess;\n");
     fprintf(file, "\n");
 
-    fprintf(file, "\tregister Request *InP = &Mess.In;\n");
+    fprintf(file, "\tRequest *InP = &Mess.In;\n");
     if (!rt->rtOneWay)
-	fprintf(file, "\tregister Reply *OutP = &Mess.Out;\n");
+	fprintf(file, "\tReply *OutP = &Mess.Out;\n");
     fprintf(file, "\n");
 
     if (!rt->rtOneWay || rt->rtProcedure)
@@ -391,10 +391,10 @@ WritePackArgType(FILE *file, const argument_t *arg)
  *  in the request message.
  *************************************************************/
 static void
-WritePackArgValue(FILE *file, register const argument_t *arg)
+WritePackArgValue(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
-    register const char *ref = arg->argByReferenceUser ? "*" : "";
+    const ipc_type_t *it = arg->argType;
+    const char *ref = arg->argByReferenceUser ? "*" : "";
 
     if (it->itInLine && it->itVarArray) {
 
@@ -419,9 +419,9 @@ WritePackArgValue(FILE *file, register const argument_t *arg)
 	     *	after checking that number of elements doesn`t
 	     *	exceed declared maximum.
 	     */
-	    register const argument_t *count = arg->argCount;
-	    register const char *countRef = count->argByReferenceUser ? "*" :"";
-	    register const ipc_type_t *btype = it->itElement;
+	    const argument_t *count = arg->argCount;
+	    const char *countRef = count->argByReferenceUser ? "*" :"";
+	    const ipc_type_t *btype = it->itElement;
 
 	    /* Note btype->itNumber == count->argMultiplier */
 
@@ -474,11 +474,11 @@ WritePackArgValue(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteAdjustMsgSimple(FILE *file, register const argument_t *arg)
+WriteAdjustMsgSimple(FILE *file, const argument_t *arg)
 {
     if (!arg->argRoutine->rtSimpleFixedRequest)
     {
-	register const char *ref = arg->argByReferenceUser ? "*" : "";
+	const char *ref = arg->argByReferenceUser ? "*" : "";
 
 	fprintf(file, "\tif (MACH_MSG_TYPE_PORT_ANY(%s%s))\n",
 		ref, arg->argVarName);
@@ -491,11 +491,11 @@ WriteAdjustMsgSimple(FILE *file, register const argument_t *arg)
  * Calculate the size of a variable-length message field.
  */
 static void
-WriteArgSize(FILE *file, register const argument_t *arg)
+WriteArgSize(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *ptype = arg->argType;
-    register int bsize = ptype->itElement->itTypeSize;
-    register const argument_t *count = arg->argCount;
+    const ipc_type_t *ptype = arg->argType;
+    int bsize = ptype->itElement->itTypeSize;
+    const argument_t *count = arg->argCount;
 
     if (ptype->itIndefinite) {
 	/*
@@ -538,9 +538,9 @@ WriteArgSize(FILE *file, register const argument_t *arg)
  * has more arguments following.
  */
 static void
-WriteAdjustMsgSize(FILE *file, register const argument_t *arg)
+WriteAdjustMsgSize(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *ptype = arg->argType;
+    const ipc_type_t *ptype = arg->argType;
 
     /* There are more In arguments.  We need to adjust msgh_size
        and advance InP, so we save the size of the current field
@@ -569,7 +569,7 @@ WriteAdjustMsgSize(FILE *file, register const argument_t *arg)
  * last argument has been packed.
  */
 static void
-WriteFinishMsgSize(FILE *file, register const argument_t *arg)
+WriteFinishMsgSize(FILE *file, const argument_t *arg)
 {
     /* No more In arguments.  If this is the only variable In
        argument, the previous msgh_size value is the minimum
@@ -589,10 +589,10 @@ WriteFinishMsgSize(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteInitializeCount(FILE *file, register const argument_t *arg)
+WriteInitializeCount(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *ptype = arg->argCInOut->argParent->argType;
-    register const ipc_type_t *btype = ptype->itElement;
+    const ipc_type_t *ptype = arg->argCInOut->argParent->argType;
+    const ipc_type_t *btype = ptype->itElement;
 
     fprintf(file, "\tif (%s%s < %d)\n",
 	    arg->argByReferenceUser ? "*" : "",
@@ -613,7 +613,7 @@ WriteInitializeCount(FILE *file, register const argument_t *arg)
  * argument into the request message.
  */
 static void
-WritePackArg(FILE *file, register const argument_t *arg)
+WritePackArg(FILE *file, const argument_t *arg)
 {
     if (akCheck(arg->argKind, akbRequest))
 	WritePackArgType(file, arg);
@@ -634,10 +634,10 @@ WritePackArg(FILE *file, register const argument_t *arg)
  * message types.
  */
 static void
-WriteRequestArgs(FILE *file, register const routine_t *rt)
+WriteRequestArgs(FILE *file, const routine_t *rt)
 {
-    register const argument_t *arg;
-    register const argument_t *lastVarArg;
+    const argument_t *arg;
+    const argument_t *lastVarArg;
 
     lastVarArg = argNULL;
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
@@ -760,10 +760,10 @@ WriteRetCodeCheck(FILE *file, const routine_t *rt)
  *  WriteRoutine for each argument in the reply message.
  *************************************************************/
 static void
-WriteTypeCheck(FILE *file, register const argument_t *arg)
+WriteTypeCheck(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
-    register const routine_t *rt = arg->argRoutine;
+    const ipc_type_t *it = arg->argType;
+    const routine_t *rt = arg->argRoutine;
 
     fprintf(file, "#if\tTypeCheck\n");
     if (akCheck(arg->argKind, akbReplyQC))
@@ -812,10 +812,10 @@ WriteTypeCheck(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteCheckArgSize(FILE *file, register const argument_t *arg)
+WriteCheckArgSize(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *ptype = arg->argType;
-    register const ipc_type_t *btype = ptype->itElement;
+    const ipc_type_t *ptype = arg->argType;
+    const ipc_type_t *btype = ptype->itElement;
     const argument_t *count = arg->argCount;
     int multiplier = btype->itTypeSize / btype->itNumber;
 
@@ -845,9 +845,9 @@ WriteCheckArgSize(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteCheckMsgSize(FILE *file, register const argument_t *arg)
+WriteCheckMsgSize(FILE *file, const argument_t *arg)
 {
-    register const routine_t *rt = arg->argRoutine;
+    const routine_t *rt = arg->argRoutine;
 
     /* If there aren't any more Out args after this, then
        we can use the msgh_size_delta value directly in
@@ -908,10 +908,10 @@ WriteCheckMsgSize(FILE *file, register const argument_t *arg)
  *  in the reply message.
  *************************************************************/
 static void
-WriteExtractArgValue(FILE *file, register const argument_t *arg)
+WriteExtractArgValue(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t	*argType = arg->argType;
-    register const char *ref = arg->argByReferenceUser ? "*" : "";
+    const ipc_type_t	*argType = arg->argType;
+    const char *ref = arg->argByReferenceUser ? "*" : "";
 
     if (argType->itInLine && argType->itVarArray) {
 
@@ -977,9 +977,9 @@ WriteExtractArgValue(FILE *file, register const argument_t *arg)
 	     *	after checking that number of elements doesn`t
 	     *	exceed user`s maximum.
 	     */
-	    register const argument_t *count = arg->argCount;
-	    register const char *countRef = count->argByReferenceUser ? "*" :"";
-	    register const ipc_type_t *btype = argType->itElement;
+	    const argument_t *count = arg->argCount;
+	    const char *countRef = count->argByReferenceUser ? "*" :"";
+	    const ipc_type_t *btype = argType->itElement;
 
 	    /* Note count->argMultiplier == btype->itNumber */
 
@@ -1031,9 +1031,9 @@ WriteExtractArgValue(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteExtractArg(FILE *file, register const argument_t *arg)
+WriteExtractArg(FILE *file, const argument_t *arg)
 {
-    register const routine_t *rt = arg->argRoutine;
+    const routine_t *rt = arg->argRoutine;
 
     if (akCheck(arg->argKind, akbReply))
 	WriteTypeCheck(file, arg);
@@ -1053,9 +1053,9 @@ WriteExtractArg(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteAdjustReplyMsgPtr(FILE *file, register const argument_t *arg)
+WriteAdjustReplyMsgPtr(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *ptype = arg->argType;
+    const ipc_type_t *ptype = arg->argType;
 
     fprintf(file,
 	"\tOutP = (Reply *) ((char *) OutP + msgh_size_delta - %d);\n\n",
@@ -1063,10 +1063,10 @@ WriteAdjustReplyMsgPtr(FILE *file, register const argument_t *arg)
 }
 
 static void
-WriteReplyArgs(FILE *file, register const routine_t *rt)
+WriteReplyArgs(FILE *file, const routine_t *rt)
 {
-    register const argument_t *arg;
-    register const argument_t *lastVarArg;
+    const argument_t *arg;
+    const argument_t *lastVarArg;
 
     lastVarArg = argNULL;
     for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
@@ -1130,7 +1130,7 @@ WriteFieldDecl(FILE *file, const argument_t *arg)
 }
 
 static void
-WriteStubDecl(FILE *file, register const routine_t *rt)
+WriteStubDecl(FILE *file, const routine_t *rt)
 {
     fprintf(file, "\n");
     fprintf(file, "/* %s %s */\n", rtRoutineKindToStr(rt->rtKind), rt->rtName);
@@ -1146,7 +1146,7 @@ WriteStubDecl(FILE *file, register const routine_t *rt)
  *  WriteUser for each routine.
  *************************************************************/
 static void
-WriteRoutine(FILE *file, register const routine_t *rt)
+WriteRoutine(FILE *file, const routine_t *rt)
 {
     /* write the stub's declaration */
 
@@ -1222,7 +1222,7 @@ WriteRoutine(FILE *file, register const routine_t *rt)
 void
 WriteUser(FILE *file, const statement_t *stats)
 {
-    register const statement_t *stat;
+    const statement_t *stat;
 
     WriteProlog(file);
     for (stat = stats; stat != stNULL; stat = stat->stNext)
@@ -1250,7 +1250,7 @@ WriteUser(FILE *file, const statement_t *stats)
 void
 WriteUserIndividual(const statement_t *stats)
 {
-    register const statement_t *stat;
+    const statement_t *stat;
 
     for (stat = stats; stat != stNULL; stat = stat->stNext)
 	switch (stat->stKind)
@@ -1258,7 +1258,7 @@ WriteUserIndividual(const statement_t *stats)
 	  case skRoutine:
 	    {
 		FILE *file;
-		register char *filename;
+		char *filename;
 
 		filename = strconcat(UserFilePrefix,
 				     strconcat(stat->stRoutine->rtName, ".c"));
diff --git a/utils.c b/utils.c
index cb40d8f..4feb874 100644
--- a/utils.c
+++ b/utils.c
@@ -81,8 +81,8 @@ void
 WriteList(FILE *file, const argument_t *args, write_list_fn_t *func, u_int mask,
 	  const char *between, const char *after)
 {
-    register const argument_t *arg;
-    register boolean_t sawone = FALSE;
+    const argument_t *arg;
+    boolean_t sawone = FALSE;
 
     for (arg = args; arg != argNULL; arg = arg->argNext)
 	if (akCheckAll(arg->argKind, mask))
@@ -99,7 +99,7 @@ WriteList(FILE *file, const argument_t *args, write_list_fn_t *func, u_int mask,
 }
 
 static boolean_t
-WriteReverseListPrim(FILE *file, register const argument_t *arg,
+WriteReverseListPrim(FILE *file, const argument_t *arg,
 		     write_list_fn_t *func, u_int mask, const char *between)
 {
     boolean_t sawone = FALSE;
@@ -157,7 +157,7 @@ WriteServerVarDecl(FILE *file, const argument_t *arg)
 }
 
 void
-WriteTypeDeclIn(FILE *file, register const argument_t *arg)
+WriteTypeDeclIn(FILE *file, const argument_t *arg)
 {
     WriteStaticDecl(file, arg->argType,
 		    arg->argType->itIndefinite ? d_NO : arg->argDeallocate,
@@ -165,7 +165,7 @@ WriteTypeDeclIn(FILE *file, register const argument_t *arg)
 }
 
 void
-WriteTypeDeclOut(FILE *file, register const argument_t *arg)
+WriteTypeDeclOut(FILE *file, const argument_t *arg)
 {
     WriteStaticDecl(file, arg->argType,
 		    arg->argType->itIndefinite ? d_NO : arg->argDeallocate,
@@ -173,9 +173,9 @@ WriteTypeDeclOut(FILE *file, register const argument_t *arg)
 }
 
 void
-WriteCheckDecl(FILE *file, register const argument_t *arg)
+WriteCheckDecl(FILE *file, const argument_t *arg)
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     /* We'll only be called for short-form types.
        Note we use itOutNameStr instead of itInNameStr, because
@@ -220,14 +220,14 @@ void
 WriteFieldDeclPrim(FILE *file, const argument_t *arg,
 		   const char *(*tfunc)(const ipc_type_t *))
 {
-    register const ipc_type_t *it = arg->argType;
+    const ipc_type_t *it = arg->argType;
 
     fprintf(file, "\t\tmach_msg_type_%st %s;\n",
 	    arg->argLongForm ? "long_" : "", arg->argTTName);
 
     if (it->itInLine && it->itVarArray)
     {
-	register ipc_type_t *btype = it->itElement;
+	ipc_type_t *btype = it->itElement;
 
 	/*
 	 *	Build our own declaration for a varying array:
@@ -258,7 +258,7 @@ WriteStructDecl(FILE *file, const argument_t *args, write_list_fn_t *func,
 }
 
 static void
-WriteStaticLongDecl(FILE *file, register const ipc_type_t *it,
+WriteStaticLongDecl(FILE *file, const ipc_type_t *it,
 		    dealloc_t dealloc, boolean_t inname, identifier_t name)
 {
     fprintf(file, "\tauto const mach_msg_type_long_t %s = {\n", name);
@@ -281,7 +281,7 @@ WriteStaticLongDecl(FILE *file, register const ipc_type_t *it,
 }
 
 static void
-WriteStaticShortDecl(FILE *file, register const ipc_type_t *it,
+WriteStaticShortDecl(FILE *file, const ipc_type_t *it,
 		     dealloc_t dealloc, boolean_t inname, identifier_t name)
 {
     fprintf(file, "\tauto const mach_msg_type_t %s = {\n", name);
@@ -314,7 +314,7 @@ WriteStaticDecl(FILE *file, const ipc_type_t *it, dealloc_t dealloc,
  * and %f are recognized.
  */
 static void
-SkipVFPrintf(FILE *file, register const char *fmt, va_list pvar)
+SkipVFPrintf(FILE *file, const char *fmt, va_list pvar)
 {
     if (*fmt == 0)
 	return;	/* degenerate case */
@@ -325,7 +325,7 @@ SkipVFPrintf(FILE *file, register const char *fmt, va_list pvar)
 	   items in pvar that the enclosed format items would
 	   print. */
 
-	register int c;
+	int c;
 
 	fmt += 2;
 	for (;;) {
diff --git a/vprint.c b/vprint.c
index 0dfbdcb..db5d2cb 100644
--- a/vprint.c
+++ b/vprint.c
@@ -168,7 +168,7 @@ typedef	int	boolean_t;
 #define	LONG	sizeof(long)
 
 static void
-_doprnt_ansi(register const char *fmt, va_list args, FILE *stream)
+_doprnt_ansi(const char *fmt, va_list args, FILE *stream)
 {
 	int		length;
 	int		prec;
@@ -263,8 +263,8 @@ _doprnt_ansi(register const char *fmt, va_list args, FILE *stream)
 	    switch(*fmt) {
 		case 'c':
 		{
-		    register const char *p;
-		    register const char *p2;
+		    const char *p;
+		    const char *p2;
 
 		    char_buf[0] = va_arg(args, int);
 		    p = char_buf;
@@ -368,7 +368,7 @@ _doprnt_ansi(register const char *fmt, va_list args, FILE *stream)
 		print_num:
 		{
 		    char	buf[MAXBUF];	/* build number here */
-		    register char *	p = &buf[MAXBUF-1];
+		    char *	p = &buf[MAXBUF-1];
 		    static const char digits[] = "0123456789abcdef";
 		    const char *prefix = 0;