* mig: Subdirectory removed, now in separate dist.

1 files changed, 0 insertions, 1332 deletions

diff --git a/mig/user.c b/mig/user.c
deleted file mode 100644
index a5ca5fb..0000000
--- a/mig/user.c
+++ /dev/null
@@ -1,1332 +0,0 @@
-/* 
- * Mach Operating System
- * Copyright (c) 1992,1991,1990 Carnegie Mellon University
- * All Rights Reserved.
- * 
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- * 
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS 
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- * 
- * Carnegie Mellon requests users of this software to return to
- * 
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- * 
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#include <assert.h>
-
-#include "write.h"
-#include "error.h"
-#include "utils.h"
-#include "global.h"
-#include "mig_string.h"
-#include "cpu.h"
-
-/*************************************************************
- *	Writes the standard includes. The subsystem specific
- *	includes  are in <SubsystemName>.h and writen by
- *	header:WriteHeader. Called by WriteProlog.
- *************************************************************/
-static void
-WriteIncludes(FILE *file)
-{
-    if (IsKernelServer)
-    {
-	/*
-	 *	We want to get the user-side definitions of types
-	 *	like task_t, ipc_space_t, etc. in mach/mach_types.h.
-	 */
-
-	fprintf(file, "#undef\tKERNEL\n");
-
-	if (InternalHeaderFileName != strNULL)
-	{
-	    register char *cp;
-
-	    /* Strip any leading path from InternalHeaderFileName. */
-	    cp = strrchr(InternalHeaderFileName, '/');
-	    if (cp == 0)
-		cp = InternalHeaderFileName;
-	    else
-		cp++;	/* skip '/' */
-	    fprintf(file, "#include \"%s\"\n", cp);
-	}
-    }
-
-    if (UserHeaderFileName != strNULL)
-    {
-	register char *cp;
-
-	/* Strip any leading path from UserHeaderFileName. */
-	cp = strrchr(UserHeaderFileName, '/');
-	if (cp == 0)
-	    cp = UserHeaderFileName;
-	else
-	    cp++;	/* skip '/' */
-	fprintf(file, "#include \"%s\"\n", cp);
-    }
-
-    fprintf(file, "#define EXPORT_BOOLEAN\n");
-    fprintf(file, "#include <mach/boolean.h>\n");
-    fprintf(file, "#include <mach/kern_return.h>\n");
-    fprintf(file, "#include <mach/message.h>\n");
-    fprintf(file, "#include <mach/notify.h>\n");
-    fprintf(file, "#include <mach/mach_types.h>\n");
-    fprintf(file, "#include <mach/mig_errors.h>\n");
-    fprintf(file, "#include <mach/mig_support.h>\n");
-    fprintf(file, "#include <mach/msg_type.h>\n");
-    fprintf(file, "/* LINTLIBRARY */\n");
-    fprintf(file, "\n");
-}
-
-static void
-WriteGlobalDecls(FILE *file)
-{
-    if (RCSId != strNULL)
-	WriteRCSDecl(file, strconcat(SubsystemName, "_user"), RCSId);
-
-    fprintf(file, "#define msgh_request_port\tmsgh_remote_port\n");
-    fprintf(file, "#define msgh_reply_port\t\tmsgh_local_port\n");
-    fprintf(file, "\n");
-}
-
-/*************************************************************
- *	Writes the standard #includes, #defines, and
- *	RCS declaration. Called by WriteUser.
- *************************************************************/
-static void
-WriteProlog(FILE *file)
-{
-    WriteIncludes(file);
-    WriteBogusDefines(file);
-    WriteGlobalDecls(file);
-}
-
-/*ARGSUSED*/
-static void
-WriteEpilog(FILE *file)
-{
-}
-
-static const_string_t
-WriteHeaderPortType(const argument_t *arg)
-{
-    if (arg->argType->itInName == MACH_MSG_TYPE_POLYMORPHIC)
-	return arg->argPoly->argVarName;
-    else
-	return arg->argType->itInNameStr;
-}
-
-static void
-WriteRequestHead(FILE *file, const routine_t *rt)
-{
-    if (rt->rtMaxRequestPos > 0)
-	fprintf(file, "\tInP = &Mess.In;\n");
-
-    if (rt->rtSimpleFixedRequest) {
-	fprintf(file, "\tInP->Head.msgh_bits =");
-	if (!rt->rtSimpleSendRequest)
-	    fprintf(file, " MACH_MSGH_BITS_COMPLEX|");
-	fprintf(file, "\n");
-	fprintf(file, "\t\tMACH_MSGH_BITS(%s, %s);\n",
-		WriteHeaderPortType(rt->rtRequestPort),
-		WriteHeaderPortType(rt->rtUReplyPort));
-    } else {
-	fprintf(file, "\tInP->Head.msgh_bits = msgh_simple ?\n");
-	fprintf(file, "\t\tMACH_MSGH_BITS(%s, %s) :\n",
-		WriteHeaderPortType(rt->rtRequestPort),
-		WriteHeaderPortType(rt->rtUReplyPort));
-	fprintf(file, "\t\t(MACH_MSGH_BITS_COMPLEX|\n");
-	fprintf(file, "\t\t MACH_MSGH_BITS(%s, %s));\n",
-		WriteHeaderPortType(rt->rtRequestPort),
-		WriteHeaderPortType(rt->rtUReplyPort));
-    }
-
-    fprintf(file, "\t/* msgh_size passed as argument */\n");
-
-    /*
-     *	KernelUser stubs need to cast the request and reply ports
-     *	from ipc_port_t to mach_port_t.
-     */
-
-    if (IsKernelUser)
-	fprintf(file, "\tInP->%s = (mach_port_t) %s;\n",
-		rt->rtRequestPort->argMsgField,
-		rt->rtRequestPort->argVarName);
-    else
-	fprintf(file, "\tInP->%s = %s;\n",
-		rt->rtRequestPort->argMsgField,
-		rt->rtRequestPort->argVarName);
-
-    if (akCheck(rt->rtUReplyPort->argKind, akbUserArg)) {
-	if (IsKernelUser)
-	    fprintf(file, "\tInP->%s = (mach_port_t) %s;\n",
-		    rt->rtUReplyPort->argMsgField,
-		    rt->rtUReplyPort->argVarName);
-	else
-	    fprintf(file, "\tInP->%s = %s;\n",
-		    rt->rtUReplyPort->argMsgField,
-		    rt->rtUReplyPort->argVarName);
-    } else if (rt->rtOneWay || IsKernelUser)
-	fprintf(file, "\tInP->%s = MACH_PORT_NULL;\n",
-		rt->rtUReplyPort->argMsgField);
-    else
-	fprintf(file, "\tInP->%s = %smig_get_reply_port();\n",
-		rt->rtUReplyPort->argMsgField, SubrPrefix);
-
-    fprintf(file, "\tInP->Head.msgh_seqno = 0;\n");
-    fprintf(file, "\tInP->Head.msgh_id = %d;\n", rt->rtNumber + SubsystemBase);
-}
-
-/*************************************************************
- *  Writes declarations for the message types, variables
- *  and return  variable if needed. Called by WriteRoutine.
- *************************************************************/
-static void
-WriteVarDecls(FILE *file, const routine_t *rt)
-{
-    fprintf(file, "\tunion {\n");
-    fprintf(file, "\t\tRequest In;\n");
-    if (!rt->rtOneWay)
-	fprintf(file, "\t\tReply Out;\n");
-    fprintf(file, "\t} Mess;\n");
-    fprintf(file, "\n");
-
-    fprintf(file, "\tregister Request *InP = &Mess.In;\n");
-    if (!rt->rtOneWay)
-	fprintf(file, "\tregister Reply *OutP = &Mess.Out;\n");
-    fprintf(file, "\n");
-
-    if (!rt->rtOneWay || rt->rtProcedure)
-	fprintf(file, "\tmach_msg_return_t msg_result;\n");
-
-    if (!rt->rtSimpleFixedRequest)
-	fprintf(file, "\tboolean_t msgh_simple = %s;\n",
-		strbool(rt->rtSimpleSendRequest));
-    else if (!rt->rtOneWay &&
-	     !(rt->rtSimpleCheckReply && rt->rtSimpleReceiveReply)) {
-	fprintf(file, "#if\tTypeCheck\n");
-	fprintf(file, "\tboolean_t msgh_simple;\n");
-	fprintf(file, "#endif\t/* TypeCheck */\n");
-    }
-
-    if (rt->rtNumRequestVar > 0)
-	fprintf(file, "\tunsigned int msgh_size;\n");
-    else if (!rt->rtOneWay && !rt->rtNoReplyArgs)
-    {
-	fprintf(file, "#if\tTypeCheck\n");
-	fprintf(file, "\tunsigned int msgh_size;\n");
-	fprintf(file, "#endif\t/* TypeCheck */\n");
-    }
-
-    /* if either request or reply is variable, we need msgh_size_delta */
-    if ((rt->rtMaxRequestPos > 0) ||
-	(rt->rtMaxReplyPos > 0))
-	fprintf(file, "\tunsigned int msgh_size_delta;\n");
-
-    fprintf(file, "\n");
-}
-
-/*************************************************************
- *  Writes code to call the user provided error procedure
- *  when a MIG error occurs. Called by WriteMsgSend, 
- *  WriteMsgCheckReceive, WriteMsgSendReceive, WriteCheckIdentity,
- *  WriteRetCodeCheck, WriteTypeCheck, WritePackArgValue.
- *************************************************************/
-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)
-    {
-	fprintf(file, "\t\t{ %s(%s); ", rt->rtErrorName, error_msg);
-	if (rt->rtNumReplyVar > 0)
-	    fprintf(file, "OutP = &Mess.Out; ");
-	fprintf(file, "return OutP->%s; }\n", rt->rtReturn->argMsgField);
-    }
-    else
-	fprintf(file, "\t\treturn %s;\n", error_msg);
-}
-
-/*************************************************************
- *   Writes the send call when there is to be no subsequent
- *   receive. Called by WriteRoutine for SimpleProcedures
- *   or SimpleRoutines
- *************************************************************/
-static void
-WriteMsgSend(FILE *file, const routine_t *rt)
-{
-    const char *MsgResult = (rt->rtProcedure)
-			? "msg_result ="
-			: "return";
-
-    char SendSize[24];
-
-    if (rt->rtNumRequestVar == 0)
-        sprintf(SendSize, "%d", rt->rtRequestSize);
-    else
-	strcpy(SendSize, "msgh_size");
-
-    if (IsKernelUser)
-    {
-	fprintf(file, "\t%s %smach_msg_send_from_kernel(",
-		MsgResult, SubrPrefix);
-	fprintf(file, "&InP->Head, %s);\n", SendSize);
-    }
-    else
-    {
-	fprintf(file, "\t%s %smach_msg(&InP->Head, MACH_SEND_MSG|%s, %s, 0,",
-		MsgResult,
-		SubrPrefix,
-		rt->rtMsgOption->argVarName,
-		SendSize);
-	fprintf(file,
-		" 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");
-    }
-}
-
-/*************************************************************
- *  Writes to code to check for error returns from receive.
- *  Called by WriteMsgSendReceive and WriteMsgRPC
- *************************************************************/
-static void
-WriteMsgCheckReceive(FILE *file, const routine_t *rt, const char *success)
-{
-    fprintf(file, "\tif (msg_result != %s) {\n", success);
-    if (!akCheck(rt->rtUReplyPort->argKind, akbUserArg) && !IsKernelUser)
-    {
-        /* If we aren't using a user-supplied reply port,
-	   then deallocate the reply port on any message transmission
-	   errors. */
-	fprintf(file, "\t\t%smig_dealloc_reply_port(%s);\n",
-		SubrPrefix, "InP->Head.msgh_reply_port");
-    }
-    WriteMsgError(file, rt, "msg_result");
-    fprintf(file, "\t}\n");
-
-    /* 
-     * If not using a user supplied reply port, tell the port
-     * allocator we're done with the port.
-     */
-    if (!akCheck(rt->rtUReplyPort->argKind, akbUserArg) && !IsKernelUser)
-    {
-	fprintf(file, "\t%smig_put_reply_port(InP->Head.msgh_reply_port);\n",
-		SubrPrefix);
-    }
-}
-
-/*************************************************************
- *  Writes the send and receive calls and code to check
- *  for errors. Normally the rpc code is generated instead
- *  although, the subsytem can be compiled with the -R option
- *  which will cause this code to be generated. Called by
- *  WriteRoutine if UseMsgRPC option is false.
- *************************************************************/
-static void
-WriteMsgSendReceive(FILE *file, const routine_t *rt)
-{
-    char SendSize[24];
-
-    if (rt->rtNumRequestVar == 0)
-        sprintf(SendSize, "%d", rt->rtRequestSize);
-    else
-	strcpy(SendSize, "msgh_size");
-
-    fprintf(file, "\tmsg_result = %smach_msg(&InP->Head, MACH_SEND_MSG|%s, %s, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);\n",
-	    SubrPrefix,
-	    rt->rtMsgOption->argVarName,
-	    SendSize);
-
-    fprintf(file, "\tif (msg_result != MACH_MSG_SUCCESS)\n");
-    WriteMsgError(file, rt, "msg_result");
-    fprintf(file, "\n");
-
-    fprintf(file, "\tmsg_result = %smach_msg(&OutP->Head, MACH_RCV_MSG|%s%s, 0, sizeof(Reply), InP->Head.msgh_local_port, %s, MACH_PORT_NULL);\n",
-	    SubrPrefix,
-	    rt->rtMsgOption->argVarName,
-	    rt->rtWaitTime != argNULL ? "|MACH_RCV_TIMEOUT" : "",
-	    rt->rtWaitTime != argNULL ? rt->rtWaitTime->argVarName : "MACH_MSG_TIMEOUT_NONE");
-    WriteMsgCheckReceive(file, rt, "MACH_MSG_SUCCESS");
-    fprintf(file, "\n");
-}
-
-/*************************************************************
- *  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.
- *************************************************************/
-static void
-WriteMsgRPC(FILE *file, const routine_t *rt)
-{
-    char SendSize[24];
-
-    if (rt->rtNumRequestVar == 0)
-        sprintf(SendSize, "%d", rt->rtRequestSize);
-    else
-	strcpy(SendSize, "msgh_size");
-
-    if (IsKernelUser)
-	fprintf(file, "\tmsg_result = %smach_msg_rpc_from_kernel(&InP->Head, %s, sizeof(Reply));\n",
-		SubrPrefix,
-		SendSize);
-    else
-	fprintf(file, "\tmsg_result = %smach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|%s%s, %s, sizeof(Reply), InP->Head.msgh_reply_port, %s, MACH_PORT_NULL);\n",
-	    SubrPrefix,
-	    rt->rtMsgOption->argVarName,
-	    rt->rtWaitTime != argNULL ? "|MACH_RCV_TIMEOUT" : "",
-	    SendSize,
-	    rt->rtWaitTime != argNULL? rt->rtWaitTime->argVarName : "MACH_MSG_TIMEOUT_NONE");
-    WriteMsgCheckReceive(file, rt, "MACH_MSG_SUCCESS");
-    fprintf(file, "\n");
-}
-
-/*************************************************************
- *   Sets the correct value of the dealloc flag and calls
- *   Utils:WritePackMsgType to fill in the ipc msg type word(s)
- *   in the request message. Called by WriteRoutine for each
- *   argument that is to be sent in the request message.
- *************************************************************/
-static void
-WritePackArgType(FILE *file, const argument_t *arg)
-{
-    WritePackMsgType(file, arg->argType,
-		     arg->argType->itIndefinite ? d_NO : arg->argDeallocate,
-		     arg->argLongForm, TRUE,
-		     "InP->%s", "%s", arg->argTTName);
-    fprintf(file, "\n");
-}
-
-/*************************************************************
- *  Writes code to copy an argument into the request message.  
- *  Called by WriteRoutine for each argument that is to placed
- *  in the request message.
- *************************************************************/
-static void
-WritePackArgValue(FILE *file, register const argument_t *arg)
-{
-    register const ipc_type_t *it = arg->argType;
-    register const char *ref = arg->argByReferenceUser ? "*" : "";
-
-    if (it->itInLine && it->itVarArray) {
-
-	if (it->itString) {
-	    /*
-	     *	Copy variable-size C string with mig_strncpy.
-	     *	Save the string length (+ 1 for trailing 0)
-	     *	in the argument`s count field.
-	     */
-	    fprintf(file,
-		"\tInP->%s = %smig_strncpy(InP->%s, %s, %d);\n",
-		arg->argCount->argMsgField,
-		SubrPrefix,
-		arg->argMsgField,
-		arg->argVarName,
-		it->itNumber);
-	}
-	else {
-
-	    /*
-	     *	Copy in variable-size inline array with memcpy,
-	     *	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;
-
-	    /* Note btype->itNumber == count->argMultiplier */
-
-	    fprintf(file, "\tif (%s%s > %d) {\n",
-		countRef, count->argVarName,
-		it->itNumber/btype->itNumber);
-	    if (it->itIndefinite) {
-		fprintf(file, "\t\tInP->%s%s.msgt_inline = FALSE;\n",
-			arg->argTTName,
-			arg->argLongForm ? ".msgtl_header" : "");
-		if (arg->argDeallocate == d_YES)
-		    fprintf(file, "\t\tInP->%s%s.msgt_deallocate = TRUE;\n",
-			    arg->argTTName,
-			    arg->argLongForm ? ".msgtl_header" : "");
-		else if (arg->argDeallocate == d_MAYBE)
-		    fprintf(file, "\t\tInP->%s%s.msgt_deallocate = %s%s;\n",
-			    arg->argTTName,
-			    arg->argLongForm ? ".msgtl_header" : "",
-			    arg->argDealloc->argByReferenceUser ? "*" : "",
-			    arg->argDealloc->argVarName);
-		fprintf(file, "\t\t*((%s **)InP->%s) = %s%s;\n",
-			FetchUserType(btype),
-			arg->argMsgField,
-			ref, arg->argVarName);
-		if (!arg->argRoutine->rtSimpleFixedRequest)
-		    fprintf(file, "\t\tmsgh_simple = FALSE;\n");
-	    }
-	    else
-		WriteMsgError(file, arg->argRoutine, "MIG_ARRAY_TOO_LARGE");
-
-	    fprintf(file, "\t}\n\telse {\n");
-
-	    fprintf(file, "\t\tmemcpy(InP->%s, %s%s, ", arg->argMsgField,
-		ref, arg->argVarName);
-	    if (btype->itTypeSize > 1)
-		fprintf(file, "%d * ", btype->itTypeSize);
-	    fprintf(file, "%s%s);\n",
-		countRef, count->argVarName);
-	    fprintf(file, "\t}\n");
-	}
-    }
-    else if (arg->argMultiplier > 1)
-	WriteCopyType(file, it, "InP->%s", "/* %s */ %d * %s%s",
-		      arg->argMsgField, arg->argMultiplier,
-		      ref, arg->argVarName);
-    else
-	WriteCopyType(file, it, "InP->%s", "/* %s */ %s%s",
-		      arg->argMsgField, ref, arg->argVarName);
-    fprintf(file, "\n");
-}
-
-static void
-WriteAdjustMsgSimple(FILE *file, register const argument_t *arg)
-{
-    if (!arg->argRoutine->rtSimpleFixedRequest)
-    {
-	register const char *ref = arg->argByReferenceUser ? "*" : "";
-
-	fprintf(file, "\tif (MACH_MSG_TYPE_PORT_ANY(%s%s))\n",
-		ref, arg->argVarName);
-	fprintf(file, "\t\tmsgh_simple = FALSE;\n");
-	fprintf(file, "\n");
-    }
-}
-
-/*
- * Calculate the size of a variable-length message field.
- */
-static void
-WriteArgSize(FILE *file, register 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;
-
-    if (ptype->itIndefinite) {
-	/*
-	 *	Check descriptor.  If out-of-line, use standard size.
-	 */
-	fprintf(file, "(InP->%s%s.msgt_inline) ? ",
-		arg->argTTName, arg->argLongForm ? ".msgtl_header" : "");
-    }
-    if (bsize % 4 != 0)
-	fprintf(file, "(");
-
-    if (bsize > 1)
-	fprintf(file, "%d * ", bsize);
-
-    if (ptype->itString)
-	/* get count from descriptor in message */
-	fprintf(file, "InP->%s", count->argMsgField);
-    else
-	/* get count from argument */
-	fprintf(file, "%s%s",
-		count->argByReferenceUser ? "*" : "",
-		count->argVarName);
-
-    /*
-     * If the base type size is not a multiple of sizeof(int) [4],
-     * we have to round up.
-     */
-    if (bsize % 4 != 0)
-	fprintf(file, " + 3) & ~3");
-
-    if (ptype->itIndefinite) {
-	fprintf(file, " : sizeof(%s *)",
-		FetchUserType(ptype->itElement));
-    }
-}
-
-/*
- * Adjust message size and advance request pointer.
- * Called after packing a variable-length argument that
- * has more arguments following.
- */
-static void
-WriteAdjustMsgSize(FILE *file, register const argument_t *arg)
-{
-    register 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
-       in msgh_size_delta. */
-
-    fprintf(file, "\tmsgh_size_delta = ");
-    WriteArgSize(file, arg);
-    fprintf(file, ";\n");
-
-    if (arg->argRequestPos == 0)
-	/* First variable-length argument.  The previous msgh_size value
-	   is the minimum request size. */
-
-	fprintf(file, "\tmsgh_size = %d + msgh_size_delta;\n",
-		arg->argRoutine->rtRequestSize);
-    else
-	fprintf(file, "\tmsgh_size += msgh_size_delta;\n");
-
-    fprintf(file,
-	"\tInP = (Request *) ((char *) InP + msgh_size_delta - %d);\n",
-	ptype->itTypeSize + ptype->itPadSize);
-}
-
-/*
- * Calculate the size of the message.  Called after the
- * last argument has been packed.
- */
-static void
-WriteFinishMsgSize(FILE *file, register const argument_t *arg)
-{
-    /* No more In arguments.  If this is the only variable In
-       argument, the previous msgh_size value is the minimum
-       request size. */
-
-    if (arg->argRequestPos == 0) {
-	fprintf(file, "\tmsgh_size = %d + (",
-			arg->argRoutine->rtRequestSize);
-	WriteArgSize(file, arg);
-	fprintf(file, ");\n");
-    }
-    else {
-        fprintf(file, "\tmsgh_size += ");
-	WriteArgSize(file, arg);
-        fprintf(file, ";\n");
-    }
-}
-
-static void
-WriteInitializeCount(FILE *file, register const argument_t *arg)
-{
-    register const ipc_type_t *ptype = arg->argCInOut->argParent->argType;
-    register const ipc_type_t *btype = ptype->itElement;
-
-    fprintf(file, "\tif (%s%s < %d)\n",
-	    arg->argByReferenceUser ? "*" : "",
-	    arg->argVarName,
-	    ptype->itNumber/btype->itNumber);
-    fprintf(file, "\t\tInP->%s = %s%s;\n",
-	    arg->argMsgField,
-	    arg->argByReferenceUser ? "*" : "",
-	    arg->argVarName);
-    fprintf(file, "\telse\n");
-    fprintf(file, "\t\tInP->%s = %d;\n",
-	    arg->argMsgField, ptype->itNumber/btype->itNumber);
-    fprintf(file, "\n");
-}
-
-/*
- * Called for every argument.  Responsible for packing that
- * argument into the request message.
- */
-static void
-WritePackArg(FILE *file, register const argument_t *arg)
-{
-    if (akCheck(arg->argKind, akbRequest))
-	WritePackArgType(file, arg);
-
-    if ((akIdent(arg->argKind) == akePoly) &&
-	akCheckAll(arg->argKind, akbSendSnd|akbUserArg))
-	WriteAdjustMsgSimple(file, arg);
-
-    if ((akIdent(arg->argKind) == akeCountInOut) &&
-	akCheck(arg->argKind, akbSendSnd))
-	WriteInitializeCount(file, arg);
-    else if (akCheckAll(arg->argKind, akbSendSnd|akbSendBody))
-	WritePackArgValue(file, arg);
-}
-
-/*
- * Generate code to fill in all of the request arguments and their
- * message types.
- */
-static void
-WriteRequestArgs(FILE *file, register const routine_t *rt)
-{
-    register const argument_t *arg;
-    register const argument_t *lastVarArg;
-
-    lastVarArg = argNULL;
-    for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
-    {
-	/*
-	 * Adjust message size and advance message pointer if
-	 * the last request argument was variable-length and the
-	 * request position will change.
-	 */
-	if (lastVarArg != argNULL &&
-	    lastVarArg->argRequestPos < arg->argRequestPos)
-	{
-	    WriteAdjustMsgSize(file, lastVarArg);
-	    lastVarArg = argNULL;
-	}
-
-	/*
-	 * Copy the argument
-	 */
-	WritePackArg(file, arg);
-
-	/*
-	 * Remember whether this was variable-length.
-	 */
-	if (akCheckAll(arg->argKind, akbSendSnd|akbSendBody|akbVariable))
-	    lastVarArg = arg;
-    }
-
-    /*
-     * Finish the message size.
-     */
-    if (lastVarArg != argNULL)
-	WriteFinishMsgSize(file, lastVarArg);
-}
-
-/*************************************************************
- *  Writes code to check that the return msgh_id is correct and that
- *  the size of the return message is correct. Called by
- *  WriteRoutine.
- *************************************************************/
-static void
-WriteCheckIdentity(FILE *file, const routine_t *rt)
-{
-    fprintf(file, "\tif (OutP->Head.msgh_id != %d) {\n",
-	    rt->rtNumber + SubsystemBase + 100);
-    fprintf(file, "\t\tif (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)\n");
-    WriteMsgError(file, rt, "MIG_SERVER_DIED");
-    fprintf(file, "\t\telse {\n");
-    fprintf(file, "\t\t\t%smig_dealloc_reply_port(%s);\n\t",
-          SubrPrefix,"InP->Head.msgh_reply_port");
-    WriteMsgError(file, rt, "MIG_REPLY_MISMATCH");
-    fprintf(file, "\t\t}\n\t}\n");
-    fprintf(file, "\n");
-    fprintf(file, "#if\tTypeCheck\n");
-
-    if (rt->rtSimpleCheckReply && rt->rtSimpleReceiveReply)
-    {
-	/* Expecting a simple message.  We can factor out the check for
-	   a simple message, since the error reply message is also simple.
-	   */
-
-	if (!rt->rtNoReplyArgs)
-	    fprintf(file, "\tmsgh_size = OutP->Head.msgh_size;\n\n");
-
-	fprintf(file,
-	    "\tif ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||\n");
-	if (rt->rtNoReplyArgs)
-	    fprintf(file, "\t    (OutP->Head.msgh_size != %d))\n",
-			rt->rtReplySize);
-	else {
-	    fprintf(file, "\t    ((msgh_size %s %d) &&\n",
-		(rt->rtNumReplyVar > 0) ? "<" : "!=",
-		rt->rtReplySize);
-	    fprintf(file, "\t     ((msgh_size != sizeof(mig_reply_header_t)) ||\n");
-	    fprintf(file, "\t      (OutP->RetCode == KERN_SUCCESS))))\n");
-	}
-    }
-    else {
-	/* Expecting a complex message, or may vary at run time. */
-
-	fprintf(file, "\tmsgh_size = OutP->Head.msgh_size;\n");
-	fprintf(file, "\tmsgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);\n");
-	fprintf(file, "\n");
-
-	fprintf(file, "\tif (((msgh_size %s %d)",
-		(rt->rtNumReplyVar > 0) ? "<" : "!=",
-		rt->rtReplySize);
-
-	if (rt->rtSimpleCheckReply)
-	    /* if rtSimpleReceiveReply was true, then we would have
-	       executed the code above.  So we know that the message
-	       is complex. */
-	    fprintf(file, " || msgh_simple");
-	fprintf(file, ") &&\n");
-
-	fprintf(file, "\t    ((msgh_size != sizeof(mig_reply_header_t)) ||\n");
-	fprintf(file, "\t     !msgh_simple ||\n");
-	fprintf(file, "\t     (OutP->RetCode == KERN_SUCCESS)))\n");
-    }
-    WriteMsgError(file, rt, "MIG_TYPE_ERROR");
-    fprintf(file, "#endif\t/* TypeCheck */\n");
-    fprintf(file, "\n");
-}
-
-/*************************************************************
- *  Write code to generate error handling code if the RetCode
- *  argument of a Routine is not KERN_SUCCESS.
- *************************************************************/
-static void
-WriteRetCodeCheck(FILE *file, const routine_t *rt)
-{
-    fprintf(file, "\tif (OutP->RetCode != KERN_SUCCESS)\n");
-    WriteMsgError(file, rt, "OutP->RetCode");
-    fprintf(file, "\n");
-}
-
-/*************************************************************
- *  Writes code to check that the type of each of the arguments
- *  in the reply message is what is expected. Called by 
- *  WriteRoutine for each argument in the reply message.
- *************************************************************/
-static void
-WriteTypeCheck(FILE *file, register const argument_t *arg)
-{
-    register const ipc_type_t *it = arg->argType;
-    register const routine_t *rt = arg->argRoutine;
-
-    fprintf(file, "#if\tTypeCheck\n");
-    if (akCheck(arg->argKind, akbReplyQC))
-    {
-	fprintf(file, "\tif (* (int *) &OutP->%s != * (int *) &%sCheck)\n",
-		arg->argTTName, arg->argVarName);
-    }
-    else
-    {
-	fprintf(file, "\tif (");
-	if (!it->itIndefinite) {
-	    fprintf(file, "(OutP->%s%s.msgt_inline != %s) ||\n\t    ",
-		arg->argTTName,
-		arg->argLongForm ? ".msgtl_header" : "",
-		strbool(it->itInLine));
-	}
-	fprintf(file, "(OutP->%s%s.msgt_longform != %s) ||\n",
-		arg->argTTName,
-		arg->argLongForm ? ".msgtl_header" : "",
-		strbool(arg->argLongForm));
-	if (it->itOutName == MACH_MSG_TYPE_POLYMORPHIC)
-	{
-	    if (!rt->rtSimpleCheckReply)
-		fprintf(file, "\t    (MACH_MSG_TYPE_PORT_ANY(OutP->%s.msgt%s_name) && msgh_simple) ||\n",
-			arg->argTTName,
-			arg->argLongForm ? "l" : "");
-	}
-	else
-	    fprintf(file, "\t    (OutP->%s.msgt%s_name != %s) ||\n",
-		    arg->argTTName,
-		    arg->argLongForm ? "l" : "",
-		    it->itOutNameStr);
-	if (!it->itVarArray)
-	    fprintf(file, "\t    (OutP->%s.msgt%s_number != %d) ||\n",
-		    arg->argTTName,
-		    arg->argLongForm ? "l" : "",
-		    it->itNumber);
-	fprintf(file, "\t    (OutP->%s.msgt%s_size != %d))\n",
-		arg->argTTName,
-		arg->argLongForm ? "l" : "",
-		it->itSize);
-    }
-    WriteMsgError(file, rt, "MIG_TYPE_ERROR");
-    fprintf(file, "#endif\t/* TypeCheck */\n");
-    fprintf(file, "\n");
-}
-
-static void
-WriteCheckArgSize(FILE *file, register const argument_t *arg)
-{
-    register const ipc_type_t *ptype = arg->argType;
-    register const ipc_type_t *btype = ptype->itElement;
-    const argument_t *count = arg->argCount;
-    int multiplier = btype->itTypeSize / btype->itNumber;
-
-    if (ptype->itIndefinite) {
-	/*
-	 * Check descriptor.  If out-of-line, use standard size.
-	 */
-	fprintf(file, "(OutP->%s%s.msgt_inline) ? ",
-		arg->argTTName, arg->argLongForm ? ".msgtl_header" : "");
-    }
-
-    if (btype->itTypeSize % 4 != 0)
-	fprintf(file, "(");
-
-    if (multiplier > 1)
-	fprintf(file, "%d * ", multiplier);
-
-    fprintf(file, "OutP->%s", count->argMsgField);
-
-    /* If the base type size of the data field isn`t a multiple of 4,
-       we have to round up. */
-    if (btype->itTypeSize % 4 != 0)
-	fprintf(file, " + 3) & ~3");
-
-    if (ptype->itIndefinite)
-	fprintf(file, " : sizeof(%s *)", FetchUserType(btype));
-}
-
-static void
-WriteCheckMsgSize(FILE *file, register const argument_t *arg)
-{
-    register 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
-       the TypeCheck conditional. */
-
-    if (arg->argReplyPos == rt->rtMaxReplyPos)
-    {
-	fprintf(file, "#if\tTypeCheck\n");
-	fprintf(file, "\tif (msgh_size != %d + (",
-		rt->rtReplySize);
-	WriteCheckArgSize(file, arg);
-	fprintf(file, "))\n");
-
-	WriteMsgError(file, rt, "MIG_TYPE_ERROR");
-	fprintf(file, "#endif\t/* TypeCheck */\n");
-    }
-    else
-    {
-	/* If there aren't any more variable-sized arguments after this,
-	   then we must check for exact msg-size and we don't need
-	   to update msgh_size. */
-
-	boolean_t LastVarArg = arg->argReplyPos+1 == rt->rtNumReplyVar;
-
-	/* calculate the actual size in bytes of the data field.  note
-	   that this quantity must be a multiple of four.  hence, if
-	   the base type size isn't a multiple of four, we have to
-	   round up.  note also that btype->itNumber must
-	   divide btype->itTypeSize (see itCalculateSizeInfo). */
-
-	fprintf(file, "\tmsgh_size_delta = ");
-	WriteCheckArgSize(file, arg);
-	fprintf(file, ";\n");
-	fprintf(file, "#if\tTypeCheck\n");
-
-	/* Don't decrement msgh_size until we've checked that
-	   it won't underflow. */
-
-	if (LastVarArg)
-	    fprintf(file, "\tif (msgh_size != %d + msgh_size_delta)\n",
-		rt->rtReplySize);
-	else
-	    fprintf(file, "\tif (msgh_size < %d + msgh_size_delta)\n",
-		rt->rtReplySize);
-	WriteMsgError(file, rt, "MIG_TYPE_ERROR");
-
-	if (!LastVarArg)
-	    fprintf(file, "\tmsgh_size -= msgh_size_delta;\n");
-
-	fprintf(file, "#endif\t/* TypeCheck */\n");
-    }
-    fprintf(file, "\n");
-}
-
-/*************************************************************
- *  Write code to copy an argument from the reply message
- *  to the parameter. Called by WriteRoutine for each argument
- *  in the reply message.
- *************************************************************/
-static void
-WriteExtractArgValue(FILE *file, register const argument_t *arg)
-{
-    register const ipc_type_t	*argType = arg->argType;
-    register const char *ref = arg->argByReferenceUser ? "*" : "";
-
-    if (argType->itInLine && argType->itVarArray) {
-
-	if (argType->itString) {
-	    /*
-	     *	Copy out variable-size C string with mig_strncpy.
-	     */
-	    fprintf(file, "\t(void) %smig_strncpy(%s%s, OutP->%s, %d);\n",
-		SubrPrefix,
-		ref,
-		arg->argVarName,
-		arg->argMsgField,
-		argType->itNumber);
-	}
-	else if (argType->itIndefinite) {
-	    /*
-	     * If data was returned out-of-line,
-	     *    change user`s pointer to point to it.
-	     * If data was returned in-line but doesn`t fit,
-	     *    allocate a new buffer, copy the data to it,
-	     *	  and change user`s pointer to point to it.
-	     * If data was returned in-line and fits,
-	     *    copy to buffer.
-	     */
-	    const argument_t *count = arg->argCount;
-	    const char *countRef = count->argByReferenceUser ? "*" : "";
-	    const ipc_type_t *btype = argType->itElement;
-
-	    fprintf(file, "\tif (!OutP->%s%s.msgt_inline)\n",
-		    arg->argTTName,
-		    arg->argLongForm ? ".msgtl_header" : "");
-	    fprintf(file, "\t    %s%s = *((%s **)OutP->%s);\n",
-		    ref, arg->argVarName,
-		    FetchUserType(btype), arg->argMsgField);
-	    fprintf(file, "\telse if (OutP->%s", count->argMsgField);
-	    if (btype->itNumber > 1)
-		fprintf(file, " / %d", btype->itNumber);
-	    fprintf(file, " > %s%s) {\n", countRef, count->argVarName);
-	    fprintf(file, "\t    %smig_allocate((vm_offset_t *)%s,\n\t\t",
-		    SubrPrefix, arg->argVarName);	/* no ref! */
-	    if (btype->itTypeSize != btype->itNumber)
-		fprintf(file, "%d * ", btype->itTypeSize/btype->itNumber);
-	    fprintf(file, "OutP->%s);\n", count->argMsgField);
-	    fprintf(file, "\t    memcpy(%s%s, OutP->%s, ", ref, arg->argVarName,
-		    arg->argMsgField);
-	    if (btype->itTypeSize != btype->itNumber)
-		fprintf(file, "%d * ", btype->itTypeSize/btype->itNumber);
-	    fprintf(file, "OutP->%s);\n", count->argMsgField);
-	    fprintf(file, "\t}\n");
-	    fprintf(file, "\telse {\n");
-
-	    fprintf(file, "\t    memcpy(%s%s, OutP->%s, ", ref, arg->argVarName,
-		    arg->argMsgField);
-	    if (btype->itTypeSize != btype->itNumber)
-		fprintf(file, "%d * ", btype->itTypeSize/btype->itNumber);
-	    fprintf(file, "OutP->%s);\n", count->argMsgField);
-	    fprintf(file, "\t}\n");
-	}
-	else {
-
-	    /*
-	     *	Copy out variable-size inline array with memcpy,
-	     *	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;
-
-	    /* Note count->argMultiplier == btype->itNumber */
-
-	    fprintf(file, "\tif (OutP->%s", count->argMsgField);
-	    if (btype->itNumber > 1)
-		fprintf(file, " / %d", btype->itNumber);
-	    fprintf(file, " > %s%s) {\n",
-		countRef, count->argVarName);
-
-	    /*
-	     * If number of elements is too many for user receiving area,
-	     * fill user`s area as much as possible.  Return the correct
-	     * number of elements.
-	     */
-	    fprintf(file, "\t\tmemcpy(%s%s, OutP->%s, ", ref, arg->argVarName,
-		    arg->argMsgField);
-	    if (btype->itTypeSize > 1)
-		fprintf(file, "%d * ", btype->itTypeSize);
-	    fprintf(file, "%s%s);\n",
-		countRef, count->argVarName);
-
-	    fprintf(file, "\t\t%s%s = OutP->%s",
-		     countRef, count->argVarName, count->argMsgField);
-	    if (btype->itNumber > 1)
-		fprintf(file, " / %d", btype->itNumber);
-	    fprintf(file, ";\n");
-	    WriteMsgError(file,arg->argRoutine, "MIG_ARRAY_TOO_LARGE");
-
-	    fprintf(file, "\t}\n\telse {\n");
-
-	    fprintf(file, "\t\tmemcpy(%s%s, OutP->%s, ", ref, arg->argVarName,
-		    arg->argMsgField);
-	    if (btype->itTypeSize != btype->itNumber)
-		fprintf(file, "%d * ", btype->itTypeSize/btype->itNumber);
-	    fprintf(file, "OutP->%s);\n", count->argMsgField);
-	    fprintf(file, "\t}\n");
-	}
-    }
-    else if (arg->argMultiplier > 1)
-	WriteCopyType(file, argType,
-		      "%s%s", "/* %s%s */ OutP->%s / %d",
-		      ref, arg->argVarName, arg->argMsgField,
-		      arg->argMultiplier);
-    else
-	WriteCopyType(file, argType,
-		      "%s%s", "/* %s%s */ OutP->%s",
-		      ref, arg->argVarName, arg->argMsgField);
-    fprintf(file, "\n");
-}
-
-static void
-WriteExtractArg(FILE *file, register const argument_t *arg)
-{
-    register const routine_t *rt = arg->argRoutine;
-
-    if (akCheck(arg->argKind, akbReply))
-	WriteTypeCheck(file, arg);
-
-    if (akCheckAll(arg->argKind, akbVariable|akbReply))
-	WriteCheckMsgSize(file, arg);
-
-    /* Now that the RetCode is type-checked, check its value.
-       Must abort immediately if it isn't KERN_SUCCESS, because
-       in that case the reply message is truncated. */
-
-    if (arg == rt->rtRetCode)
-	WriteRetCodeCheck(file, rt);
-
-    if (akCheckAll(arg->argKind, akbReturnRcv))
-	WriteExtractArgValue(file, arg);
-}
-
-static void
-WriteAdjustReplyMsgPtr(FILE *file, register const argument_t *arg)
-{
-    register const ipc_type_t *ptype = arg->argType;
-
-    fprintf(file,
-	"\tOutP = (Reply *) ((char *) OutP + msgh_size_delta - %d);\n\n",
-	ptype->itTypeSize + ptype->itPadSize);
-}
-
-static void
-WriteReplyArgs(FILE *file, register const routine_t *rt)
-{
-    register const argument_t *arg;
-    register const argument_t *lastVarArg;
-
-    lastVarArg = argNULL;
-    for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
-
-	/*
-	 * Advance message pointer if the last reply argument was
-	 * variable-length and the reply position will change.
-	 */
-	if (lastVarArg != argNULL &&
-	    lastVarArg->argReplyPos < arg->argReplyPos)
-	{
-	    WriteAdjustReplyMsgPtr(file, lastVarArg);
-	    lastVarArg = argNULL;
-	}
-
-	/*
-	 * Copy the argument
-	 */
-	WriteExtractArg(file, arg);
-
-	/*
-	 * Remember whether this was variable-length.
-	 */
-	if (akCheckAll(arg->argKind, akbReturnRcv|akbVariable))
-	    lastVarArg = arg;
-    }
-}
-
-/*************************************************************
- *  Writes code to return the return value. Called by WriteRoutine
- *  for routines and functions.
- *************************************************************/
-static void
-WriteReturnValue(FILE *file, const routine_t *rt)
-{
-    if (rt->rtReturn == rt->rtRetCode)
-	/* If returning RetCode, we have already checked that it is
-	   KERN_SUCCESS */
-	fprintf(file, "\treturn KERN_SUCCESS;\n");
-
-    else
-    {
-	if (rt->rtNumReplyVar > 0)
-	    fprintf(file, "\tOutP = &Mess.Out;\n");
-
-	fprintf(file, "\treturn OutP->%s;\n", rt->rtReturn->argMsgField);
-    }
-}
-
-/*************************************************************
- *  Writes the elements of the message type declaration: the
- *  msg_type structure, the argument itself and any padding 
- *  that is required to make the argument a multiple of 4 bytes.
- *  Called by WriteRoutine for all the arguments in the request
- *  message first and then the reply message.
- *************************************************************/
-static void
-WriteFieldDecl(FILE *file, const argument_t *arg)
-{
-    WriteFieldDeclPrim(file, arg, FetchUserType);
-}
-
-static void
-WriteStubDecl(FILE *file, register const routine_t *rt)
-{
-    fprintf(file, "\n");
-    fprintf(file, "/* %s %s */\n", rtRoutineKindToStr(rt->rtKind), rt->rtName);
-    fprintf(file, "mig_external %s %s\n", ReturnTypeStr(rt), rt->rtUserName);
-    fprintf(file, "(\n");
-    WriteList(file, rt->rtArgs, WriteUserVarDecl, akbUserArg, ",\n", "\n");
-    fprintf(file, ")\n");
-    fprintf(file, "{\n");
-}
-
-/*************************************************************
- *  Writes all the code comprising a routine body. Called by
- *  WriteUser for each routine.
- *************************************************************/
-static void
-WriteRoutine(FILE *file, register const routine_t *rt)
-{
-    /* write the stub's declaration */
-
-    WriteStubDecl(file, rt);
-
-    /* typedef of structure for Request and Reply messages */
-
-    WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbRequest, "Request");
-    if (!rt->rtOneWay)
-	WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbReply, "Reply");
-
-    /* declarations for local vars: Union of Request and Reply messages,
-       InP, OutP and return value */
-
-    WriteVarDecls(file, rt);
-
-    /* declarations and initializations of the mach_msg_type_t variables
-       for each argument */
-
-    WriteList(file, rt->rtArgs, WriteTypeDeclIn, akbRequest, "\n", "\n");
-    if (!rt->rtOneWay)
-	WriteList(file, rt->rtArgs, WriteCheckDecl, akbReplyQC, "\n", "\n");
-
-    /* fill in all the request message types and then arguments */
-
-    WriteRequestArgs(file, rt);
-
-    /* fill in request message head */
-
-    WriteRequestHead(file, rt);
-    fprintf(file, "\n");
-
-    /* Write the send/receive or rpc call */
-
-    if (rt->rtOneWay)
-	WriteMsgSend(file, rt);
-    else
-    {
-	if (UseMsgRPC)
-	    WriteMsgRPC(file, rt);
-	else
-	    WriteMsgSendReceive(file, rt);
-
-	/* Check the values that are returned in the reply message */
-
-	WriteCheckIdentity(file, rt);
-
-	/* If the reply message has no Out parameters or return values
-	   other than the return code, we can type-check it and
-	   return it directly. */
-
-	if (rt->rtNoReplyArgs)
-	{
-	    WriteTypeCheck(file, rt->rtRetCode);
-
-	    fprintf(file, "\treturn OutP->RetCode;\n");
-	}
-	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);
-	}
-    }
-
-    fprintf(file, "}\n");
-}
-
-/*************************************************************
- *  Writes out the xxxUser.c file. Called by mig.c
- *************************************************************/
-void
-WriteUser(FILE *file, const statement_t *stats)
-{
-    register const statement_t *stat;
-
-    WriteProlog(file);
-    for (stat = stats; stat != stNULL; stat = stat->stNext)
-	switch (stat->stKind)
-	{
-	  case skRoutine:
-	    WriteRoutine(file, stat->stRoutine);
-	    break;
-	  case skImport:
-	  case skUImport:
-	    WriteImport(file, stat->stFileName);
-	    break;
-	  case skSImport:
-	    break;
-	  default:
-	    fatal("WriteUser(): bad statement_kind_t (%d)",
-		  (int) stat->stKind);
-	}
-    WriteEpilog(file);
-}
-
-/*************************************************************
- *  Writes out individual .c user files for each routine.  Called by mig.c
- *************************************************************/
-void
-WriteUserIndividual(const statement_t *stats)
-{
-    register const statement_t *stat;
-
-    for (stat = stats; stat != stNULL; stat = stat->stNext)
-	switch (stat->stKind)
-	{
-	  case skRoutine:
-	    {
-		FILE *file;
-		register char *filename;
-
-		filename = strconcat(UserFilePrefix,
-				     strconcat(stat->stRoutine->rtName, ".c"));
-		file = fopen(filename, "w");
-		if (file == NULL)
-		    fatal("fopen(%s): %s", filename,
-			  unix_error_string(errno));
-		WriteProlog(file);
-
-		{
-		  /* Write all the imports.  */
-		  const statement_t *s;
-		  for (s = stats; s != stNULL; s = s->stNext)
-		    switch (s->stKind)
-		      {
-		      case skImport:
-		      case skUImport:
-			WriteImport(file, s->stFileName);
-			break;
-		      }
-		}
-
-		WriteRoutine(file, stat->stRoutine);
-		WriteEpilog(file);
-		fclose(file);
-		strfree(filename);
-	    }
-	    break;
-	  case skImport:
-	  case skUImport:
-	    break;
-	  case skSImport:
-	    break;
-	  default:
-	    fatal("WriteUserIndividual(): bad statement_kind_t (%d)",
-		  (int) stat->stKind);
-	}
-}