![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to routine.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / mig|
Return to routine.c CVS log | Up to [GnuMach] / Gnu-Mach / mig |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1992,1991,1990 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26:
27: /*
28: * ABSTRACT:
29: * Provides the routine used by parser.c to generate
30: * routine structures for each routine statement.
31: * The parser generates a threaded list of statements
32: * of which the most interesting are the various kinds
33: * routine statments. The routine structure is defined
34: * in routine.h which includes it name, kind of routine
35: * and other information,
36: * a pointer to an argument list which contains the name
37: * and type information for each argument, and a list
38: * of distinguished arguments, eg. Request and Reply
39: * ports, waittime, retcode etc.
40: */
41:
42: #include <stdio.h>
43: #include <stdlib.h>
44:
45: #include "error.h"
46: #include "global.h"
47: #include "routine.h"
48: #include "message.h"
49:
50: u_int rtNumber = 0;
51:
52: routine_t *
53: rtAlloc(void)
54: {
55: register routine_t *new;
56:
57: new = (routine_t *) calloc(1, sizeof *new);
58: if (new == rtNULL)
59: fatal("rtAlloc(): %s", unix_error_string(errno));
60: new->rtNumber = rtNumber++;
61: new->rtName = strNULL;
62: new->rtErrorName = strNULL;
63: new->rtUserName = strNULL;
64: new->rtServerName = strNULL;
65:
66: return new;
67: }
68:
69: void
70: rtSkip(int n)
71: {
72: rtNumber += n;
73: }
74:
75: argument_t *
76: argAlloc(void)
77: {
78: static const argument_t prototype =
79: {
80: strNULL, /* identifier_t argName */
81: argNULL, /* argument_t *argNext */
82: akNone, /* arg_kind_t argKind */
83: itNULL, /* ipc_type_t *argType */
84: strNULL, /* string_t argVarName */
85: strNULL, /* string_t argMsgField */
86: strNULL, /* string_t argTTName */
87: strNULL, /* string_t argPadName */
88: flNone, /* ipc_flags_t argFlags */
89: d_NO, /* dealloc_t argDeallocate */
90: FALSE, /* boolean_t argLongForm */
91: FALSE, /* boolean_t argServerCopy */
92: FALSE, /* boolean_t argCountInOut */
93: rtNULL, /* routine_t *argRoutine */
94: argNULL, /* argument_t *argCount */
95: argNULL, /* argument_t *argCInOut */
96: argNULL, /* argument_t *argPoly */
97: argNULL, /* argument_t *argDealloc */
98: argNULL, /* argument_t *argSCopy */
99: argNULL, /* argument_t *argParent */
100: 1, /* int argMultiplier */
101: 0, /* int argRequestPos */
102: 0, /* int argReplyPos */
103: FALSE, /* boolean_t argByReferenceUser */
104: FALSE /* boolean_t argByReferenceServer */
105: };
106: register argument_t *new;
107:
108: new = malloc(sizeof *new);
109: if (new == argNULL)
110: fatal("argAlloc(): %s", unix_error_string(errno));
111: *new = prototype;
112: return new;
113: }
114:
115: routine_t *
116: rtMakeRoutine(identifier_t name, argument_t *args)
117: {
118: register routine_t *rt = rtAlloc();
119:
120: rt->rtName = name;
121: rt->rtKind = rkRoutine;
122: rt->rtArgs = args;
123:
124: return rt;
125: }
126:
127: routine_t *
128: rtMakeSimpleRoutine(identifier_t name, argument_t *args)
129: {
130: register routine_t *rt = rtAlloc();
131:
132: rt->rtName = name;
133: rt->rtKind = rkSimpleRoutine;
134: rt->rtArgs = args;
135:
136: return rt;
137: }
138:
139: routine_t *
140: rtMakeProcedure(identifier_t name, argument_t *args)
141: {
142: register routine_t *rt = rtAlloc();
143:
144: rt->rtName = name;
145: rt->rtKind = rkProcedure;
146: rt->rtArgs = args;
147:
148: warn("Procedure %s: obsolete routine kind", name);
149:
150: return rt;
151: }
152:
153: routine_t *
154: rtMakeSimpleProcedure(identifier_t name, argument_t *args)
155: {
156: register routine_t *rt = rtAlloc();
157:
158: rt->rtName = name;
159: rt->rtKind = rkSimpleProcedure;
160: rt->rtArgs = args;
161:
162: warn("SimpleProcedure %s: obsolete routine kind", name);
163:
164: return rt;
165: }
166:
167: routine_t *
168: rtMakeFunction(identifier_t name, argument_t *args, ipc_type_t *type)
169: {
170: register routine_t *rt = rtAlloc();
171: register argument_t *ret = argAlloc();
172:
173: ret->argName = name;
174: ret->argKind = akReturn;
175: ret->argType = type;
176: ret->argNext = args;
177:
178: rt->rtName = name;
179: rt->rtKind = rkFunction;
180: rt->rtArgs = ret;
181:
182: warn("Function %s: obsolete routine kind", name);
183:
184: return rt;
185: }
186:
187: const char *
188: rtRoutineKindToStr(routine_kind_t rk)
189: {
190: switch (rk)
191: {
192: case rkRoutine:
193: return "Routine";
194: case rkSimpleRoutine:
195: return "SimpleRoutine";
196: case rkProcedure:
197: return "Procedure";
198: case rkSimpleProcedure:
199: return "SimpleProcedure";
200: case rkFunction:
201: return "Function";
202: default:
203: fatal("rtRoutineKindToStr(%d): not a routine_kind_t", rk);
204: /*NOTREACHED*/
205: }
206: }
207:
208: static void
209: rtPrintArg(register const argument_t *arg)
210: {
211: register const ipc_type_t *it = arg->argType;
212:
213: if (!akCheck(arg->argKind, akbUserArg|akbServerArg) ||
214: (akIdent(arg->argKind) == akeCount) ||
215: (akIdent(arg->argKind) == akePoly))
216: return;
217:
218: printf("\n\t");
219:
220: switch (akIdent(arg->argKind))
221: {
222: case akeRequestPort:
223: printf("RequestPort");
224: break;
225: case akeReplyPort:
226: printf("ReplyPort");
227: break;
228: case akeWaitTime:
229: printf("WaitTime");
230: break;
231: case akeMsgOption:
232: printf("MsgOption");
233: break;
234: case akeMsgSeqno:
235: printf("MsgSeqno\t");
236: break;
237: default:
238: if (akCheck(arg->argKind, akbRequest))
239: if (akCheck(arg->argKind, akbSend))
240: printf("In");
241: else
242: printf("(In)");
243: if (akCheck(arg->argKind, akbReply))
244: if (akCheck(arg->argKind, akbReturn))
245: printf("Out");
246: else
247: printf("(Out)");
248: printf("\t");
249: }
250:
251: printf("\t%s: %s", arg->argName, it->itName);
252:
253: if (arg->argDeallocate != it->itDeallocate)
254: if (arg->argDeallocate == d_YES)
255: printf(", Dealloc");
256: else if (arg->argDeallocate == d_MAYBE)
257: printf(", Dealloc[]");
258: else
259: printf(", NotDealloc");
260:
261: if (arg->argLongForm != it->itLongForm)
262: if (arg->argLongForm)
263: printf(", IsLong");
264: else
265: printf(", IsNotLong");
266:
267: if (arg->argServerCopy)
268: printf(", ServerCopy");
269:
270: if (arg->argCountInOut)
271: printf(", CountInOut");
272: }
273:
274: void
275: rtPrintRoutine(register const routine_t *rt)
276: {
277: register const argument_t *arg;
278:
279: printf("%s (%d) %s(", rtRoutineKindToStr(rt->rtKind),
280: rt->rtNumber, rt->rtName);
281:
282: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
283: rtPrintArg(arg);
284:
285: if (rt->rtKind == rkFunction)
286: printf("): %s\n", rt->rtReturn->argType->itName);
287: else
288: printf(")\n");
289:
290: printf("\n");
291: }
292:
293: /*
294: * Determines appropriate value of msg-simple for the message,
295: * and whether this value can vary at runtime. (If it can vary,
296: * then the simple value is optimistically returned as TRUE.)
297: * Uses itInName values, so useful when sending messages.
298: */
299:
300: static void
301: rtCheckSimpleIn(const argument_t *args, u_int mask, boolean_t *fixed,
302: boolean_t *simple)
303: {
304: register const argument_t *arg;
305: boolean_t MayBeComplex = FALSE;
306: boolean_t MustBeComplex = FALSE;
307:
308: for (arg = args; arg != argNULL; arg = arg->argNext)
309: if (akCheck(arg->argKind, mask))
310: {
311: register const ipc_type_t *it = arg->argType;
312:
313: if (it->itInName == MACH_MSG_TYPE_POLYMORPHIC)
314: MayBeComplex = TRUE;
315:
316: if (it->itIndefinite)
317: MayBeComplex = TRUE;
318:
319: if (MACH_MSG_TYPE_PORT_ANY(it->itInName) ||
320: !it->itInLine)
321: MustBeComplex = TRUE;
322: }
323:
324: *fixed = MustBeComplex || !MayBeComplex;
325: *simple = !MustBeComplex;
326: }
327:
328: /*
329: * Determines appropriate value of msg-simple for the message,
330: * and whether this value can vary at runtime. (If it can vary,
331: * then the simple value is optimistically returned as TRUE.)
332: * Uses itOutName values, so useful when receiving messages
333: * (and sending reply messages in KernelServer interfaces).
334: */
335:
336: static void
337: rtCheckSimpleOut(const argument_t *args, u_int mask, boolean_t *fixed,
338: boolean_t *simple)
339: {
340: register const argument_t *arg;
341: boolean_t MayBeComplex = FALSE;
342: boolean_t MustBeComplex = FALSE;
343:
344: for (arg = args; arg != argNULL; arg = arg->argNext)
345: if (akCheck(arg->argKind, mask))
346: {
347: register const ipc_type_t *it = arg->argType;
348:
349: if (it->itOutName == MACH_MSG_TYPE_POLYMORPHIC)
350: MayBeComplex = TRUE;
351:
352: if (it->itIndefinite)
353: MayBeComplex = TRUE;
354:
355: if (MACH_MSG_TYPE_PORT_ANY(it->itOutName) ||
356: !it->itInLine)
357: MustBeComplex = TRUE;
358: }
359:
360: *fixed = MustBeComplex || !MayBeComplex;
361: *simple = !MustBeComplex;
362: }
363:
364: static u_int
365: rtFindSize(const argument_t *args, u_int mask)
366: {
367: register const argument_t *arg;
368: u_int size = sizeof_mach_msg_header_t;
369:
370: for (arg = args; arg != argNULL; arg = arg->argNext)
371: if (akCheck(arg->argKind, mask))
372: {
373: register ipc_type_t *it = arg->argType;
374:
375: if (arg->argLongForm) {
376: /* might need proper alignment on 64bit archies */
377: size = (size + word_size-1) & ~(word_size-1);
378: size += sizeof_mach_msg_type_long_t;
379: } else {
380: register bs = (it->itSize / 8); /* in bytes */
381: size += (bs > sizeof_mach_msg_type_t) ? bs : sizeof_mach_msg_type_t;
382: }
383:
384: size += it->itMinTypeSize;
385: }
386:
387: return size;
388: }
389:
390: boolean_t
391: rtCheckMask(const argument_t *args, u_int mask)
392: {
393: register const argument_t *arg;
394:
395: for (arg = args; arg != argNULL; arg = arg->argNext)
396: if (akCheckAll(arg->argKind, mask))
397: return TRUE;
398: return FALSE;
399: }
400:
401: boolean_t
402: rtCheckMaskFunction(const argument_t *args, u_int mask,
403: boolean_t (*func)(const argument_t *))
404: {
405: register const argument_t *arg;
406:
407: for (arg = args; arg != argNULL; arg = arg->argNext)
408: if (akCheckAll(arg->argKind, mask))
409: if ((*func)(arg))
410: return TRUE;
411: return FALSE;
412: }
413:
414: /* arg->argType may be NULL in this function */
415:
416: static void
417: rtDefaultArgKind(const routine_t *rt, argument_t *arg)
418: {
419: if ((arg->argKind == akNone) &&
420: (rt->rtRequestPort == argNULL))
421: arg->argKind = akRequestPort;
422:
423: if (arg->argKind == akNone)
424: arg->argKind = akIn;
425: }
426:
427: /*
428: * Initializes arg->argDeallocate, arg->argLongForm,
429: * arg->argServerCopy, arg->argCountInOut from arg->argFlags.
430: */
431:
432: static void
433: rtProcessArgFlags(register argument_t *arg)
434: {
435: register const ipc_type_t *it = arg->argType;
436:
437: arg->argFlags = itCheckFlags(arg->argFlags, arg->argName);
438:
439: if (((IsKernelServer && akCheck(arg->argKind, akbReturn)) ||
440: (IsKernelUser && akCheck(arg->argKind, akbSend))) &&
441: (arg->argFlags & flDealloc) &&
442: (it->itDeallocate == d_NO)) {
443: /*
444: * For a KernelServer interface and an Out argument,
445: * or a KernelUser interface and an In argument,
446: * we avoid a possible spurious warning about the deallocate bit.
447: * For compatibility with Mach 2.5, the deallocate bit
448: * may need to be enabled on some inline arguments.
449: */
450:
451: arg->argDeallocate = d_YES;
452: } else
453: arg->argDeallocate = itCheckDeallocate(it, arg->argFlags,
454: it->itDeallocate, arg->argName);
455:
456: arg->argLongForm = itCheckIsLong(it, arg->argFlags,
457: it->itLongForm, arg->argName);
458:
459: if (arg->argFlags & flServerCopy) {
460: if (it->itIndefinite && akCheck(arg->argKind, akbSend))
461: arg->argServerCopy = TRUE;
462: else
463: warn("%s: ServerCopy on argument is meaningless", arg->argName);
464: }
465:
466: if (arg->argFlags & flCountInOut) {
467: if (it->itVarArray && it->itInLine &&
468: akCheck(arg->argKind, akbReply))
469: arg->argCountInOut = TRUE;
470: else
471: warn("%s: CountInOut on argument is meaningless", arg->argName);
472: }
473: }
474:
475: static void
476: rtAugmentArgKind(argument_t *arg)
477: {
478: register ipc_type_t *it = arg->argType;
479:
480: /* akbVariable means variable-sized inline. */
481:
482: if (it->itVarArray && it->itInLine)
483: {
484: if (akCheckAll(arg->argKind, akbRequest|akbReply))
485: error("%s: Inline variable-sized arguments can't be InOut",
486: arg->argName);
487: arg->argKind = akAddFeature(arg->argKind, akbVariable);
488:
489: /* akbIndefinite means inline or out-of-line */
490:
491: if (it->itIndefinite)
492: arg->argKind = akAddFeature(arg->argKind, akbIndefinite);
493: }
494:
495: /*
496: * Kernel servers can't do quick-checking of request arguments
497: * which are out-of-line or ports, because the deallocate bit isn't
498: * predictable. This is because the deallocate bit is preserved
499: * at message copyin time and normalized during message copyout.
500: * This accomodates old IPC programs which expect the deallocate
501: * bit to be preserved.
502: */
503:
504: if (akCheck(arg->argKind, akbRequest) &&
505: !arg->argLongForm &&
506: (it->itOutName != MACH_MSG_TYPE_POLYMORPHIC) &&
507: !it->itVarArray &&
508: !(IsKernelServer && (!it->itInLine ||
509: MACH_MSG_TYPE_PORT_ANY(it->itOutName))))
510: arg->argKind = akAddFeature(arg->argKind, akbRequestQC);
511:
512: if (akCheck(arg->argKind, akbReply) &&
513: !arg->argLongForm &&
514: (it->itOutName != MACH_MSG_TYPE_POLYMORPHIC) &&
515: !it->itVarArray)
516: arg->argKind = akAddFeature(arg->argKind, akbReplyQC);
517:
518: /*
519: * Need to use a local variable in the following cases:
520: * 1) There is a translate-out function & the argument is being
521: * returned. We need to translate it before it hits the message.
522: * 2) There is a translate-in function & the argument is
523: * sent and returned. We need a local variable for its address.
524: * 3) There is a destructor function, which will be used
525: * (SendRcv and not ReturnSnd), and there is a translate-in
526: * function whose value must be saved for the destructor.
527: * 4) This is a count arg, getting returned. The count can't get
528: * stored directly into the msg-type, because the msg-type won't
529: * get initialized until later, and that would trash the count.
530: * 5) This is a poly arg, getting returned. The name can't get
531: * stored directly into the msg-type, because the msg-type won't
532: * get initialized until later, and that would trash the name.
533: * 6) This is a dealloc arg, being returned. The name can't be
534: * stored directly into the msg_type, because the msg-type
535: * field is a bit-field.
536: */
537:
538: if (((it->itOutTrans != strNULL) &&
539: akCheck(arg->argKind, akbReturnSnd)) ||
540: ((it->itInTrans != strNULL) &&
541: akCheckAll(arg->argKind, akbSendRcv|akbReturnSnd)) ||
542: ((it->itDestructor != strNULL) &&
543: akCheck(arg->argKind, akbSendRcv) &&
544: !akCheck(arg->argKind, akbReturnSnd) &&
545: (it->itInTrans != strNULL)) ||
546: ((akIdent(arg->argKind) == akeCount) &&
547: akCheck(arg->argKind, akbReturnSnd)) ||
548: ((akIdent(arg->argKind) == akePoly) &&
549: akCheck(arg->argKind, akbReturnSnd)) ||
550: ((akIdent(arg->argKind) == akeDealloc) &&
551: akCheck(arg->argKind, akbReturnSnd)))
552: {
553: arg->argKind = akRemFeature(arg->argKind, akbReplyCopy);
554: arg->argKind = akAddFeature(arg->argKind, akbVarNeeded);
555: }
556:
557: /*
558: * If the argument is a variable-length array that can be passed in-line
559: * or out-of-line, and is being returned, the server procedure
560: * is passed a pointer to the buffer, which it can change.
561: */
562: if (it->itIndefinite &&
563: akCheck(arg->argKind, akbReturnSnd))
564: {
565: arg->argKind = akAddFeature(arg->argKind, akbPointer);
566: }
567: }
568:
569: /* arg->argType may be NULL in this function */
570:
571: static void
572: rtCheckRoutineArg(routine_t *rt, argument_t *arg)
573: {
574: switch (akIdent(arg->argKind))
575: {
576: case akeRequestPort:
577: if (rt->rtRequestPort != argNULL)
578: warn("multiple RequestPort args in %s; %s won't be used",
579: rt->rtName, rt->rtRequestPort->argName);
580: rt->rtRequestPort = arg;
581: break;
582:
583: case akeReplyPort:
584: if (akCheck (arg->argKind, akbUserArg))
585: {
586: if (rt->rtUReplyPort != argNULL)
587: warn("multiple UserReplyPort args in %s; %s won't be used",
588: rt->rtName, rt->rtUReplyPort->argName);
589: rt->rtUReplyPort = arg;
590: }
591: if (akCheck (arg->argKind, akbServerArg))
592: {
593: if (rt->rtSReplyPort != argNULL)
594: warn("multiple ServerReplyPort args in %s; %s won't be used",
595: rt->rtName, rt->rtSReplyPort->argName);
596: rt->rtSReplyPort = arg;
597: }
598: break;
599:
600: case akeWaitTime:
601: if (rt->rtWaitTime != argNULL)
602: warn("multiple WaitTime args in %s; %s won't be used",
603: rt->rtName, rt->rtWaitTime->argName);
604: rt->rtWaitTime = arg;
605: break;
606:
607: case akeMsgOption:
608: if (rt->rtMsgOption != argNULL)
609: warn("multiple MsgOption args in %s; %s won't be used",
610: rt->rtName, rt->rtMsgOption->argName);
611: rt->rtMsgOption = arg;
612: break;
613:
614: case akeMsgSeqno:
615: if (rt->rtMsgSeqno != argNULL)
616: warn("multiple MsgSeqno args in %s; %s won't be used",
617: rt->rtName, rt->rtMsgSeqno->argName);
618: rt->rtMsgSeqno = arg;
619: break;
620:
621: case akeReturn:
622: if (rt->rtReturn != argNULL)
623: warn("multiple Return args in %s; %s won't be used",
624: rt->rtName, rt->rtReturn->argName);
625: rt->rtReturn = arg;
626: break;
627:
628: default:
629: break;
630: }
631: }
632:
633: /* arg->argType may be NULL in this function */
634:
635: static void
636: rtSetArgDefaults(routine_t *rt, register argument_t *arg)
637: {
638: arg->argRoutine = rt;
639: if (arg->argVarName == strNULL)
640: arg->argVarName = arg->argName;
641: if (arg->argMsgField == strNULL)
642: switch(akIdent(arg->argKind))
643: {
644: case akeRequestPort:
645: arg->argMsgField = "Head.msgh_request_port";
646: break;
647: case akeReplyPort:
648: arg->argMsgField = "Head.msgh_reply_port";
649: break;
650: case akeMsgSeqno:
651: arg->argMsgField = "Head.msgh_seqno";
652: break;
653: default:
654: arg->argMsgField = arg->argName;
655: break;
656: }
657: if (arg->argTTName == strNULL)
658: arg->argTTName = strconcat(arg->argName, "Type");
659: if (arg->argPadName == strNULL)
660: arg->argPadName = strconcat(arg->argName, "Pad");
661:
662: /*
663: * The poly args for the request and reply ports have special defaults,
664: * because their msg-type-name values aren't stored in normal fields.
665: */
666:
667: if ((rt->rtRequestPort != argNULL) &&
668: (rt->rtRequestPort->argPoly == arg) &&
669: (arg->argType != itNULL)) {
670: arg->argMsgField = "Head.msgh_bits";
671: arg->argType->itInTrans = "MACH_MSGH_BITS_REQUEST";
672: }
673:
674: if ((rt->rtUReplyPort != argNULL) &&
675: (rt->rtUReplyPort->argPoly == arg) &&
676: (arg->argType != itNULL)) {
677: arg->argMsgField = "Head.msgh_bits";
678: arg->argType->itInTrans = "MACH_MSGH_BITS_REPLY";
679: }
680: if ((rt->rtSReplyPort != argNULL) &&
681: (rt->rtSReplyPort->argPoly == arg) &&
682: (arg->argType != itNULL)) {
683: arg->argMsgField = "Head.msgh_bits";
684: arg->argType->itInTrans = "MACH_MSGH_BITS_REPLY";
685: }
686: }
687:
688: static void
689: rtAddCountArg(register argument_t *arg)
690: {
691: register argument_t *count;
692:
693: count = argAlloc();
694: count->argName = strconcat(arg->argName, "Cnt");
695: count->argType = itMakeCountType();
696: count->argParent = arg;
697: count->argMultiplier = arg->argType->itElement->itNumber;
698: count->argNext = arg->argNext;
699: arg->argNext = count;
700: arg->argCount = count;
701:
702: if (arg->argType->itString) {
703: /* C String gets no Count argument on either side.
704: There is no explicit field in the message -
705: the count is passed as part of the descriptor. */
706: count->argKind = akeCount;
707: count->argVarName = (char *)0;
708: } else
709: count->argKind = akAddFeature(akCount,
710: akCheck(arg->argKind, akbSendReturnBits));
711:
712: if (arg->argLongForm)
713: count->argMsgField = strconcat(arg->argTTName,
714: ".msgtl_number");
715: else
716: count->argMsgField = strconcat(arg->argTTName, ".msgt_number");
717: }
718:
719: static void
720: rtAddCountInOutArg(register argument_t *arg)
721: {
722: register argument_t *count;
723:
724: /*
725: * The user sees a single count variable. However, to get the
726: * count passed from user to server for variable-sized inline OUT
727: * arrays, we need two count arguments internally. This is
728: * because the count value lives in different message fields (and
729: * is scaled differently) in the request and reply messages.
730: *
731: * The two variables have the same name to simplify code generation.
732: *
733: * This variable has a null argParent field because it has akbRequest.
734: * For example, see rtCheckVariable.
735: */
736:
737: count = argAlloc();
738: count->argName = strconcat(arg->argName, "Cnt");
739: count->argType = itMakeCountType();
740: count->argParent = argNULL;
741: count->argNext = arg->argNext;
742: arg->argNext = count;
743: (count->argCInOut = arg->argCount)->argCInOut = count;
744: count->argKind = akCountInOut;
745: }
746:
747: static void
748: rtAddPolyArg(register argument_t *arg)
749: {
750: register const ipc_type_t *it = arg->argType;
751: register argument_t *poly;
752: arg_kind_t akbsend, akbreturn;
753:
754: poly = argAlloc();
755: poly->argName = strconcat(arg->argName, "Poly");
756: poly->argType = itMakePolyType();
757: poly->argParent = arg;
758: poly->argNext = arg->argNext;
759: arg->argNext = poly;
760: arg->argPoly = poly;
761:
762: /*
763: * akbsend is bits added if the arg is In;
764: * akbreturn is bits added if the arg is Out.
765: * The mysterious business with KernelServer subsystems:
766: * when packing Out arguments, they use OutNames instead
767: * of InNames, and the OutName determines if they are poly-in
768: * as well as poly-out.
769: */
770:
771: akbsend = akbSend|akbSendBody;
772: akbreturn = akbReturn|akbReturnBody;
773:
774: if (it->itInName == MACH_MSG_TYPE_POLYMORPHIC)
775: {
776: akbsend |= akbUserArg|akbSendSnd;
777: if (!IsKernelServer)
778: akbreturn |= akbServerArg|akbReturnSnd;
779: }
780: if (it->itOutName == MACH_MSG_TYPE_POLYMORPHIC)
781: {
782: akbsend |= akbServerArg|akbSendRcv;
783: akbreturn |= akbUserArg|akbReturnRcv;
784: if (IsKernelServer)
785: akbreturn |= akbServerArg|akbReturnSnd;
786: }
787:
788: poly->argKind = akPoly;
789: if (akCheck(arg->argKind, akbSend))
790: poly->argKind = akAddFeature(poly->argKind,
791: akCheck(arg->argKind, akbsend));
792: if (akCheck(arg->argKind, akbReturn))
793: poly->argKind = akAddFeature(poly->argKind,
794: akCheck(arg->argKind, akbreturn));
795:
796: if (arg->argLongForm)
797: poly->argMsgField = strconcat(arg->argTTName,
798: ".msgtl_name");
799: else
800: poly->argMsgField = strconcat(arg->argTTName, ".msgt_name");
801: }
802:
803: static void
804: rtAddDeallocArg(register argument_t *arg)
805: {
806: register argument_t *dealloc;
807:
808: dealloc = argAlloc();
809: dealloc->argName = strconcat(arg->argName, "Dealloc");
810: dealloc->argType = itMakeDeallocType();
811: dealloc->argParent = arg;
812: dealloc->argNext = arg->argNext;
813: arg->argNext = dealloc;
814: arg->argDealloc = dealloc;
815:
816: /*
817: * For Indefinite types, we leave out akbSendSnd and akbReturnSnd
818: * so that the normal argument-packing is bypassed. The special code
819: * generated for the Indefinite argument handles the deallocate bit.
820: * (It can only be enabled if the data is actually out-of-line.)
821: */
822:
823: dealloc->argKind = akeDealloc;
824: if (akCheck(arg->argKind, akbSend))
825: dealloc->argKind = akAddFeature(dealloc->argKind,
826: akCheck(arg->argKind,
827: akbUserArg|akbSend|akbSendBody|
828: (arg->argType->itIndefinite ? 0 : akbSendSnd)));
829: if (akCheck(arg->argKind, akbReturn)) {
830: dealloc->argKind = akAddFeature(dealloc->argKind,
831: akCheck(arg->argKind,
832: akbServerArg|akbReturn|akbReturnBody|
833: (arg->argType->itIndefinite ? 0 : akbReturnSnd)));
834:
835: /*
836: * Without akbReturnSnd, rtAugmentArgKind will not add
837: * akbVarNeeded and rtAddByReference will not set
838: * argByReferenceServer. So we do it here.
839: */
840:
841: if (arg->argType->itIndefinite) {
842: dealloc->argKind = akAddFeature(dealloc->argKind, akbVarNeeded);
843: dealloc->argByReferenceServer = TRUE;
844: }
845: }
846:
847: if (arg->argLongForm)
848: dealloc->argMsgField = strconcat(arg->argTTName,
849: ".msgtl_header.msgt_deallocate");
850: else
851: dealloc->argMsgField = strconcat(arg->argTTName, ".msgt_deallocate");
852:
853: }
854:
855: static void
856: rtAddSCopyArg(register argument_t *arg)
857: {
858: register argument_t *scopy;
859:
860: scopy = argAlloc();
861: scopy->argName = strconcat(arg->argName, "SCopy");
862: scopy->argType = itMakeDeallocType();
863: scopy->argParent = arg;
864: scopy->argNext = arg->argNext;
865: arg->argNext = scopy;
866: arg->argSCopy = scopy;
867:
868: scopy->argKind = akServerCopy;
869:
870: if (arg->argLongForm)
871: scopy->argMsgField = strconcat(arg->argTTName,
872: ".msgtl_header.msgt_inline");
873: else
874: scopy->argMsgField = strconcat(arg->argTTName, ".msgt_inline");
875: }
876:
877: static void
878: rtCheckRoutineArgs(routine_t *rt)
879: {
880: register argument_t *arg;
881:
882: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
883: {
884: register const ipc_type_t *it = arg->argType;
885:
886: rtDefaultArgKind(rt, arg);
887: rtCheckRoutineArg(rt, arg);
888:
889: /* need to set argTTName before adding implicit args */
890: rtSetArgDefaults(rt, arg);
891:
892: /* the arg may not have a type (if there was some error in parsing it),
893: in which case we don't want to do these steps. */
894:
895: if (it != itNULL)
896: {
897: /* need to set argLongForm before adding implicit args */
898: rtProcessArgFlags(arg);
899: rtAugmentArgKind(arg);
900:
901: /* args added here will get processed in later iterations */
902: /* order of args is 'arg poly countinout count dealloc scopy' */
903:
904: if (arg->argServerCopy)
905: rtAddSCopyArg(arg);
906: if (arg->argDeallocate == d_MAYBE)
907: rtAddDeallocArg(arg);
908: if (it->itVarArray)
909: rtAddCountArg(arg);
910: if (arg->argCountInOut)
911: rtAddCountInOutArg(arg);
912: if ((it->itInName == MACH_MSG_TYPE_POLYMORPHIC) ||
913: (it->itOutName == MACH_MSG_TYPE_POLYMORPHIC))
914: rtAddPolyArg(arg);
915: }
916: }
917: }
918:
919: static void
920: rtCheckArgTypes(routine_t *rt)
921: {
922: if (rt->rtRequestPort == argNULL)
923: error("%s %s doesn't have a server port argument",
924: rtRoutineKindToStr(rt->rtKind), rt->rtName);
925:
926: if ((rt->rtKind == rkFunction) &&
927: (rt->rtReturn == argNULL))
928: error("Function %s doesn't have a return arg", rt->rtName);
929:
930: if ((rt->rtKind != rkFunction) &&
931: (rt->rtReturn != argNULL))
932: error("non-function %s has a return arg", rt->rtName);
933:
934: if ((rt->rtReturn == argNULL) && !rt->rtProcedure)
935: rt->rtReturn = rt->rtRetCode;
936:
937: rt->rtServerReturn = rt->rtReturn;
938:
939: if ((rt->rtReturn != argNULL) &&
940: (rt->rtReturn->argType != itNULL))
941: itCheckReturnType(rt->rtReturn->argName,
942: rt->rtReturn->argType);
943:
944: if ((rt->rtRequestPort != argNULL) &&
945: (rt->rtRequestPort->argType != itNULL))
946: itCheckRequestPortType(rt->rtRequestPort->argName,
947: rt->rtRequestPort->argType);
948:
949: if ((rt->rtUReplyPort != argNULL) &&
950: (rt->rtUReplyPort->argType != itNULL))
951: itCheckReplyPortType(rt->rtUReplyPort->argName,
952: rt->rtUReplyPort->argType);
953: if ((rt->rtSReplyPort != argNULL) &&
954: (rt->rtSReplyPort->argType != itNULL))
955: itCheckReplyPortType(rt->rtSReplyPort->argName,
956: rt->rtSReplyPort->argType);
957:
958: if ((rt->rtWaitTime != argNULL) &&
959: (rt->rtWaitTime->argType != itNULL))
960: itCheckIntType(rt->rtWaitTime->argName,
961: rt->rtWaitTime->argType);
962:
963: if ((rt->rtMsgOption != argNULL) &&
964: (rt->rtMsgOption->argType != itNULL))
965: itCheckIntType(rt->rtMsgOption->argName,
966: rt->rtMsgOption->argType);
967:
968: if ((rt->rtMsgSeqno != argNULL) &&
969: (rt->rtMsgSeqno->argType != itNULL))
970: itCheckNaturalType(rt->rtMsgSeqno->argName,
971: rt->rtMsgSeqno->argType);
972: }
973:
974: /*
975: * Check for arguments which are missing seemingly needed functions.
976: * We make this check here instead of in itCheckDecl, because here
977: * we can take into account what kind of argument the type is
978: * being used with.
979: *
980: * These are warnings, not hard errors, because mig will generate
981: * reasonable code in any case. The generated code will work fine
982: * if the ServerType and TransType are really the same, even though
983: * they have different names.
984: */
985:
986: static void
987: rtCheckArgTrans(const routine_t *rt)
988: {
989: register const argument_t *arg;
990:
991: /* the arg may not have a type (if there was some error in parsing it) */
992:
993: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
994: {
995: register const ipc_type_t *it = arg->argType;
996:
997: if ((it != itNULL) &&
998: !streql(it->itServerType, it->itTransType))
999: {
1000: if (akCheck(arg->argKind, akbSendRcv) &&
1001: (it->itInTrans == strNULL))
1002: warn("%s: argument has no in-translation function",
1003: arg->argName);
1004:
1005: if (akCheck(arg->argKind, akbReturnSnd) &&
1006: (it->itOutTrans == strNULL))
1007: warn("%s: argument has no out-translation function",
1008: arg->argName);
1009: }
1010: }
1011: }
1012:
1013: /*
1014: * Adds an implicit return-code argument. It exists in the reply message,
1015: * where it is the first piece of data. Even if there is no reply
1016: * message (rtOneWay is true), we generate the argument because
1017: * the server-side stub needs a dummy reply msg to return error codes
1018: * back to the server loop.
1019: */
1020:
1021: static void
1022: rtAddRetCode(routine_t *rt)
1023: {
1024: register argument_t *arg = argAlloc();
1025:
1026: arg->argName = "RetCode";
1027: arg->argType = itRetCodeType;
1028: arg->argKind = akRetCode;
1029: rt->rtRetCode = arg;
1030:
1031: /* add at beginning, so return-code is first in the reply message */
1032: arg->argNext = rt->rtArgs;
1033: rt->rtArgs = arg;
1034: }
1035:
1036: /*
1037: * Adds a dummy WaitTime argument to the function.
1038: * This argument doesn't show up in any C argument lists;
1039: * it implements the global WaitTime statement.
1040: */
1041:
1042: static void
1043: rtAddWaitTime(routine_t *rt, identifier_t name)
1044: {
1045: register argument_t *arg = argAlloc();
1046: argument_t **loc;
1047:
1048: arg->argName = "dummy WaitTime arg";
1049: arg->argVarName = name;
1050: arg->argType = itWaitTimeType;
1051: arg->argKind = akeWaitTime;
1052: rt->rtWaitTime = arg;
1053:
1054: /* add wait-time after msg-option, if possible */
1055:
1056: if (rt->rtMsgOption != argNULL)
1057: loc = &rt->rtMsgOption->argNext;
1058: else
1059: loc = &rt->rtArgs;
1060:
1061: arg->argNext = *loc;
1062: *loc = arg;
1063:
1064: rtSetArgDefaults(rt, arg);
1065: }
1066:
1067: /*
1068: * Adds a dummy MsgOption argument to the function.
1069: * This argument doesn't show up in any C argument lists;
1070: * it implements the global MsgOption statement.
1071: */
1072:
1073: static void
1074: rtAddMsgOption(routine_t *rt, identifier_t name)
1075: {
1076: register argument_t *arg = argAlloc();
1077: argument_t **loc;
1078:
1079: arg->argName = "dummy MsgOption arg";
1080: arg->argVarName = name;
1081: arg->argType = itMsgOptionType;
1082: arg->argKind = akeMsgOption;
1083: rt->rtMsgOption = arg;
1084:
1085: /* add msg-option after msg-seqno */
1086:
1087: if (rt->rtMsgSeqno != argNULL)
1088: loc = &rt->rtMsgSeqno->argNext;
1089: else
1090: loc = &rt->rtArgs;
1091:
1092: arg->argNext = *loc;
1093: *loc = arg;
1094:
1095: rtSetArgDefaults(rt, arg);
1096: }
1097:
1098: /*
1099: * Adds a dummy reply port argument to the function. If USER is true, the
1100: * user reply port is set, otherwise the server.
1101: */
1102:
1103: static void
1104: rtAddDummyReplyPort(routine_t *rt, ipc_type_t *type, int user)
1105: {
1106: register argument_t *arg = argAlloc();
1107: argument_t **loc;
1108:
1109: arg->argName = "dummy ReplyPort arg";
1110: arg->argVarName = "dummy ReplyPort arg";
1111: arg->argType = type;
1112: arg->argKind = akeReplyPort;
1113: if (user)
1114: rt->rtUReplyPort = arg;
1115: else
1116: rt->rtSReplyPort = arg;
1117:
1118: /* add the reply port after the request port */
1119:
1120: if (rt->rtRequestPort != argNULL)
1121: loc = &rt->rtRequestPort->argNext;
1122: else
1123: loc = &rt->rtArgs;
1124:
1125: arg->argNext = *loc;
1126: *loc = arg;
1127:
1128: rtSetArgDefaults(rt, arg);
1129: }
1130:
1131: /*
1132: * Initializes argRequestPos, argReplyPos, rtMaxRequestPos, rtMaxReplyPos,
1133: * rtNumRequestVar, rtNumReplyVar, and adds akbVarNeeded to those arguments
1134: * that need it because of variable-sized inline considerations.
1135: *
1136: * argRequestPos and argReplyPos get -1 if the value shouldn't be used.
1137: */
1138: static void
1139: rtCheckVariable(register routine_t *rt)
1140: {
1141: register argument_t *arg;
1142: int NumRequestVar = 0;
1143: int NumReplyVar = 0;
1144: int MaxRequestPos = 0;
1145: int MaxReplyPos = 0;
1146:
1147: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
1148: register argument_t *parent = arg->argParent;
1149:
1150: if (parent == argNULL) {
1151: if (akCheck(arg->argKind, akbRequest|akbSend)) {
1152: arg->argRequestPos = NumRequestVar;
1153: MaxRequestPos = NumRequestVar;
1154: if (akCheck(arg->argKind, akbVariable))
1155: NumRequestVar++;
1156: } else
1157: arg->argRequestPos = -1;
1158:
1159: if (akCheck(arg->argKind, akbReply|akbReturn)) {
1160: arg->argReplyPos = NumReplyVar;
1161: MaxReplyPos = NumReplyVar;
1162: if (akCheck(arg->argKind, akbVariable))
1163: NumReplyVar++;
1164: } else
1165: arg->argReplyPos = -1;
1166: } else {
1167: arg->argRequestPos = parent->argRequestPos;
1168: arg->argReplyPos = parent->argReplyPos;
1169: }
1170:
1171: /* Out variables that follow a variable-sized field
1172: need VarNeeded or ReplyCopy; they can't be stored
1173: directly into the reply message. */
1174:
1175: if (akCheck(arg->argKind, akbReturnSnd) &&
1176: !akCheck(arg->argKind, akbReplyCopy|akbVarNeeded) &&
1177: (arg->argReplyPos > 0))
1178: arg->argKind = akAddFeature(arg->argKind, akbVarNeeded);
1179: }
1180:
1181: rt->rtNumRequestVar = NumRequestVar;
1182: rt->rtNumReplyVar = NumReplyVar;
1183: rt->rtMaxRequestPos = MaxRequestPos;
1184: rt->rtMaxReplyPos = MaxReplyPos;
1185: }
1186:
1187: /*
1188: * Adds akbDestroy where needed.
1189: */
1190:
1191: static void
1192: rtCheckDestroy(register routine_t *rt)
1193: {
1194: register argument_t *arg;
1195:
1196: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
1197: register const ipc_type_t *it = arg->argType;
1198:
1199: if(akCheck(arg->argKind, akbSendRcv) &&
1200: !akCheck(arg->argKind, akbReturnSnd)) {
1201: if ((it->itDestructor != strNULL) ||
1202: (akCheck(arg->argKind, akbIndefinite) && !arg->argServerCopy))
1203: arg->argKind = akAddFeature(arg->argKind, akbDestroy);
1204: }
1205: }
1206: }
1207:
1208: /*
1209: * Sets ByReferenceUser and ByReferenceServer.
1210: */
1211:
1212: static void
1213: rtAddByReference(register routine_t *rt)
1214: {
1215: register argument_t *arg;
1216:
1217: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
1218: register const ipc_type_t *it = arg->argType;
1219:
1220: if (akCheck(arg->argKind, akbReturnRcv) &&
1221: (it->itStruct || it->itIndefinite)) {
1222: arg->argByReferenceUser = TRUE;
1223:
1224: /*
1225: * A CountInOut arg itself is not akbReturnRcv,
1226: * so we need to set argByReferenceUser specially.
1227: */
1228:
1229: if (arg->argCInOut != argNULL)
1230: arg->argCInOut->argByReferenceUser = TRUE;
1231: }
1232:
1233: if (akCheck(arg->argKind, akbReturnSnd) &&
1234: (it->itStruct || it->itIndefinite))
1235: arg->argByReferenceServer = TRUE;
1236: }
1237: }
1238:
1239: void
1240: rtCheckRoutine(register routine_t *rt)
1241: {
1242: /* Initialize random fields. */
1243:
1244: rt->rtErrorName = ErrorProc;
1245: rt->rtOneWay = ((rt->rtKind == rkSimpleProcedure) ||
1246: (rt->rtKind == rkSimpleRoutine));
1247: rt->rtProcedure = ((rt->rtKind == rkProcedure) ||
1248: (rt->rtKind == rkSimpleProcedure));
1249: rt->rtUseError = rt->rtProcedure || (rt->rtKind == rkFunction);
1250: rt->rtServerName = strconcat(ServerPrefix, rt->rtName);
1251: rt->rtServerName = strconcat(RoutinePrefix, rt->rtServerName);
1252: rt->rtUserName = strconcat(UserPrefix, rt->rtName);
1253: rt->rtUserName = strconcat(RoutinePrefix, rt->rtUserName);
1254:
1255: /* Add implicit arguments. */
1256:
1257: rtAddRetCode(rt);
1258:
1259: /* Check out the arguments and their types. Add count, poly
1260: implicit args. Any arguments added after rtCheckRoutineArgs
1261: should have rtSetArgDefaults called on them. */
1262:
1263: rtCheckRoutineArgs(rt);
1264:
1265: /* Add dummy WaitTime and MsgOption arguments, if the routine
1266: doesn't have its own args and the user specified global values. */
1267:
1268: if (rt->rtUReplyPort == argNULL)
1269: if (rt->rtOneWay)
1270: rtAddDummyReplyPort(rt, itZeroReplyPortType, 1);
1271: else
1272: rtAddDummyReplyPort(rt, itRealReplyPortType, 1);
1273: if (rt->rtSReplyPort == argNULL)
1274: if (rt->rtOneWay)
1275: rtAddDummyReplyPort(rt, itZeroReplyPortType, 0);
1276: else
1277: rtAddDummyReplyPort(rt, itRealReplyPortType, 0);
1278:
1279: if (rt->rtMsgOption == argNULL)
1280: if (MsgOption == strNULL)
1281: rtAddMsgOption(rt, "MACH_MSG_OPTION_NONE");
1282: else
1283: rtAddMsgOption(rt, MsgOption);
1284:
1285: if ((rt->rtWaitTime == argNULL) &&
1286: (WaitTime != strNULL))
1287: rtAddWaitTime(rt, WaitTime);
1288:
1289: /* Now that all the arguments are in place, do more checking. */
1290:
1291: rtCheckArgTypes(rt);
1292: rtCheckArgTrans(rt);
1293:
1294: if (rt->rtOneWay && rtCheckMask(rt->rtArgs, akbReturn))
1295: error("%s %s has OUT argument",
1296: rtRoutineKindToStr(rt->rtKind), rt->rtName);
1297:
1298: /* If there were any errors, don't bother calculating more info
1299: that is only used in code generation anyway. Therefore,
1300: the following functions don't have to worry about null types. */
1301:
1302: if (errors > 0)
1303: return;
1304:
1305: rtCheckSimpleIn(rt->rtArgs, akbRequest,
1306: &rt->rtSimpleFixedRequest,
1307: &rt->rtSimpleSendRequest);
1308: rtCheckSimpleOut(rt->rtArgs, akbRequest,
1309: &rt->rtSimpleCheckRequest,
1310: &rt->rtSimpleReceiveRequest);
1311: rt->rtRequestSize = rtFindSize(rt->rtArgs, akbRequest);
1312:
1313: if (IsKernelServer)
1314: rtCheckSimpleOut(rt->rtArgs, akbReply,
1315: &rt->rtSimpleFixedReply,
1316: &rt->rtSimpleSendReply);
1317: else
1318: rtCheckSimpleIn(rt->rtArgs, akbReply,
1319: &rt->rtSimpleFixedReply,
1320: &rt->rtSimpleSendReply);
1321: rtCheckSimpleOut(rt->rtArgs, akbReply,
1322: &rt->rtSimpleCheckReply,
1323: &rt->rtSimpleReceiveReply);
1324: rt->rtReplySize = rtFindSize(rt->rtArgs, akbReply);
1325:
1326: rtCheckVariable(rt);
1327: rtCheckDestroy(rt);
1328: rtAddByReference(rt);
1329:
1330: if (rt->rtKind == rkFunction)
1331: rt->rtNoReplyArgs = FALSE;
1332: else
1333: rt->rtNoReplyArgs = !rtCheckMask(rt->rtArgs, akbReturnSnd);
1334: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.