summaryrefslogtreecommitdiff
path: root/mig/user.c
diff options
context:
space:
mode:
authorRoland McGrath <roland@gnu.org>1998-07-19 06:48:50 +0000
committerRoland McGrath <roland@gnu.org>1998-07-19 06:48:50 +0000
commit3f07f7d0137a757f1908805f809ddcba8ba4c21e (patch)
tree5a99942a2b6bdfb8e81cffff059a7d16f3553e24 /mig/user.c
parent1ffb1ca21b8db814cdbd8638b6c3b1ddece5aec1 (diff)
* mig: Subdirectory removed, now in separate dist.
Diffstat (limited to 'mig/user.c')
-rw-r--r--mig/user.c1332
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);
- }
-}