![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmip-pepy.py CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / doc / cookbook|
Return to cmip-pepy.py CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / doc / cookbook |
1.1 root 1: -- automatically generated by posy 3.2 #15 (gonzo), do not edit!
2:
3: CMIP DEFINITIONS ::=
4:
5: %{
6: #include <stdio.h>
7: #include "CMIP-types.h"
8: %}
9:
10: PREFIXES encode decode print
11:
12: BEGIN
13:
14: ENCODER encode
15:
16: EventReportArgument
17: %{
18: struct type_CMIP_EventReportArgument *arg =
19: (struct type_CMIP_EventReportArgument *) parm;
20: %}
21: ::=
22: SEQUENCE {
23: managedObjectClass
24: ObjectClass
25: [[p (PEPYPARM) arg -> managedObjectClass]],
26:
27: managedObjectInstance
28: ObjectInstance
29: [[p (PEPYPARM) arg -> managedObjectInstance]],
30:
31: eventType[5]
32: EventTypeID
33: [[p (PEPYPARM) arg -> eventType]],
34:
35: eventTime[6]
36: IMPLICIT GeneralizedTime
37: [[p (PEPYPARM) arg -> eventTime]]
38: OPTIONAL <<arg -> eventTime>>,
39:
40: eventInfo[7]
41: EventInfo
42: [[p (PEPYPARM) arg -> eventInfo]]
43: OPTIONAL <<arg -> eventInfo>>
44: }
45:
46: EventReportResult ::=
47: NULL
48:
49: LinkedReplyArgument
50: %{
51: struct type_CMIP_LinkedReplyArgument *arg =
52: (struct type_CMIP_LinkedReplyArgument *) parm;
53: %}
54: ::=
55: CHOICE <<arg -> offset>> {
56: getResult[0]
57: IMPLICIT GetResult
58: [[p (PEPYPARM) arg -> un.getResult]],
59:
60: getError[1]
61: IMPLICIT GetListError
62: [[p (PEPYPARM) arg -> un.getError]],
63:
64: setResult[2]
65: IMPLICIT SetResult
66: [[p (PEPYPARM) arg -> un.setResult]],
67:
68: setError[3]
69: IMPLICIT SetListError
70: [[p (PEPYPARM) arg -> un.setError]],
71:
72: actionResult[4]
73: IMPLICIT ActionResult
74: [[p (PEPYPARM) arg -> un.actionResult]]
75: }
76:
77: GetArgument
78: %{
79: struct type_CMIP_GetArgument *arg =
80: (struct type_CMIP_GetArgument *) parm;
81: struct element_CMIP_0 *element_CMIP_0;
82: %}
83: ::=
84: SEQUENCE %{ element_CMIP_0 = arg -> element_CMIP_0; %} {
85: managedObjectClass
86: ObjectClass
87: [[p (PEPYPARM) arg -> managedObjectClass]],
88:
89: managedObjectInstance
90: ObjectInstance
91: [[p (PEPYPARM) arg -> managedObjectInstance]],
92:
93: accessControl[5]
94: AccessControl
95: [[p (PEPYPARM) arg -> accessControl]]
96: OPTIONAL <<arg -> accessControl>>,
97:
98: synchronization[6]
99: IMPLICIT CMISSync
100: [[p (PEPYPARM) arg -> synchronization]]
101: DEFAULT bestEffort <<arg -> synchronization>>,
102:
103: filter
104: CMISFilter
105: [[p (PEPYPARM) arg -> filter]]
106: OPTIONAL <<arg -> filter>>,
107:
108: mgmtInfoIdList[11]
109: IMPLICIT SEQUENCE OF
110: <<element_CMIP_0 = arg -> element_CMIP_0;
111: element_CMIP_0;
112: element_CMIP_0 = element_CMIP_0 -> next>>
113: MgmtInfoId
114: [[p (PEPYPARM) element_CMIP_0 -> MgmtInfoId]]
115: }
116:
117: GetResult
118: %{
119: struct type_CMIP_GetResult *arg =
120: (struct type_CMIP_GetResult *) parm;
121: struct element_CMIP_1 *element_CMIP_1;
122: %}
123: ::=
124: SEQUENCE %{ element_CMIP_1 = arg -> element_CMIP_1; %} {
125: managedObjectClass
126: ObjectClass
127: [[p (PEPYPARM) arg -> managedObjectClass]]
128: OPTIONAL <<arg -> managedObjectClass>>,
129:
130: managedObjectInstance
131: ObjectInstance
132: [[p (PEPYPARM) arg -> managedObjectInstance]]
133: OPTIONAL <<arg -> managedObjectInstance>>,
134:
135: currentTime[5]
136: IMPLICIT GeneralizedTime
137: [[p (PEPYPARM) arg -> currentTime]]
138: OPTIONAL <<arg -> currentTime>>,
139:
140: mgmtInfoList[6]
141: IMPLICIT SEQUENCE OF
142: <<element_CMIP_1 = arg -> element_CMIP_1;
143: element_CMIP_1;
144: element_CMIP_1 = element_CMIP_1 -> next>>
145: MgmtInfo
146: [[p (PEPYPARM) element_CMIP_1 -> MgmtInfo]]
147: }
148:
149: SetArgument
150: %{
151: struct type_CMIP_SetArgument *arg =
152: (struct type_CMIP_SetArgument *) parm;
153: struct element_CMIP_2 *element_CMIP_2;
154: %}
155: ::=
156: SEQUENCE %{ element_CMIP_2 = arg -> element_CMIP_2; %} {
157: managedObjectClass
158: ObjectClass
159: [[p (PEPYPARM) arg -> managedObjectClass]],
160:
161: managedObjectInstance
162: ObjectInstance
163: [[p (PEPYPARM) arg -> managedObjectInstance]],
164:
165: accessControl[5]
166: AccessControl
167: [[p (PEPYPARM) arg -> accessControl]]
168: OPTIONAL <<arg -> accessControl>>,
169:
170: synchronization[6]
171: IMPLICIT CMISSync
172: [[p (PEPYPARM) arg -> synchronization]]
173: DEFAULT bestEffort <<arg -> synchronization>>,
174:
175: filter
176: CMISFilter
177: [[p (PEPYPARM) arg -> filter]]
178: OPTIONAL <<arg -> filter>>,
179:
180: mgmtInfoList[11]
181: IMPLICIT SEQUENCE OF
182: <<element_CMIP_2 = arg -> element_CMIP_2;
183: element_CMIP_2;
184: element_CMIP_2 = element_CMIP_2 -> next>>
185: MgmtInfo
186: [[p (PEPYPARM) element_CMIP_2 -> MgmtInfo]]
187: }
188:
189: SetResult
190: %{
191: struct type_CMIP_SetResult *arg =
192: (struct type_CMIP_SetResult *) parm;
193: struct element_CMIP_3 *element_CMIP_3;
194: %}
195: ::=
196: SEQUENCE %{ element_CMIP_3 = arg -> element_CMIP_3; %} {
197: managedObjectClass
198: ObjectClass
199: [[p (PEPYPARM) arg -> managedObjectClass]]
200: OPTIONAL <<arg -> managedObjectClass>>,
201:
202: managedObjectInstance
203: ObjectInstance
204: [[p (PEPYPARM) arg -> managedObjectInstance]]
205: OPTIONAL <<arg -> managedObjectInstance>>,
206:
207: currentTime[5]
208: IMPLICIT GeneralizedTime
209: [[p (PEPYPARM) arg -> currentTime]]
210: OPTIONAL <<arg -> currentTime>>,
211:
212: mgmtInfoList[6]
213: IMPLICIT SEQUENCE OF
214: <<element_CMIP_3 = arg -> element_CMIP_3;
215: element_CMIP_3;
216: element_CMIP_3 = element_CMIP_3 -> next>>
217: MgmtInfo
218: [[p (PEPYPARM) element_CMIP_3 -> MgmtInfo]]
219: }
220:
221: ActionArgument
222: %{
223: struct type_CMIP_ActionArgument *arg =
224: (struct type_CMIP_ActionArgument *) parm;
225: %}
226: ::=
227: SEQUENCE {
228: managedObjectClass
229: ObjectClass
230: [[p (PEPYPARM) arg -> managedObjectClass]],
231:
232: managedObjectInstance
233: ObjectInstance
234: [[p (PEPYPARM) arg -> managedObjectInstance]],
235:
236: accessControl[5]
237: AccessControl
238: [[p (PEPYPARM) arg -> accessControl]]
239: OPTIONAL <<arg -> accessControl>>,
240:
241: filter
242: CMISFilter
243: [[p (PEPYPARM) arg -> filter]]
244: OPTIONAL <<arg -> filter>>,
245:
246: actionType[11]
247: ActionTypeId
248: [[p (PEPYPARM) arg -> actionType]],
249:
250: actionInfo[12]
251: ActionInfo
252: [[p (PEPYPARM) arg -> actionInfo]]
253: OPTIONAL <<arg -> actionInfo>>
254: }
255:
256: ActionResult
257: %{
258: struct type_CMIP_ActionResult *arg =
259: (struct type_CMIP_ActionResult *) parm;
260: %}
261: ::=
262: SEQUENCE {
263: managedObjectClass
264: ObjectClass
265: [[p (PEPYPARM) arg -> managedObjectClass]]
266: OPTIONAL <<arg -> managedObjectClass>>,
267:
268: managedObjectInstance
269: ObjectInstance
270: [[p (PEPYPARM) arg -> managedObjectInstance]]
271: OPTIONAL <<arg -> managedObjectInstance>>,
272:
273: currentTime[5]
274: IMPLICIT GeneralizedTime
275: [[p (PEPYPARM) arg -> currentTime]]
276: OPTIONAL <<arg -> currentTime>>,
277:
278: actionResult[6]
279: IMPLICIT MgmtInfo
280: [[p (PEPYPARM) arg -> actionResult]]
281: }
282:
283: NoSuchObject
284: %{
285: struct type_CMIP_NoSuchObject *arg =
286: (struct type_CMIP_NoSuchObject *) parm;
287: %}
288: ::=
289: OBJECT IDENTIFIER
290: [[O arg]]
291:
292: SyncNotSupported
293: %{
294: struct type_CMIP_SyncNotSupported *arg =
295: (struct type_CMIP_SyncNotSupported *) parm;
296: %}
297: ::=
298: CMISSync
299: [[p (PEPYPARM) arg]]
300:
301: InvalidFilter
302: %{
303: struct type_CMIP_InvalidFilter *arg =
304: (struct type_CMIP_InvalidFilter *) parm;
305: %}
306: ::=
307: CMISFilter
308: [[p (PEPYPARM) arg]]
309:
310: NoSuchMgmtInfoId
311: %{
312: struct type_CMIP_NoSuchMgmtInfoId *arg =
313: (struct type_CMIP_NoSuchMgmtInfoId *) parm;
314: %}
315: ::=
316: MgmtInfoId
317: [[p (PEPYPARM) arg]]
318:
319: InvalidMgmtInfoValue
320: %{
321: struct type_CMIP_InvalidMgmtInfoValue *arg =
322: (struct type_CMIP_InvalidMgmtInfoValue *) parm;
323: %}
324: ::=
325: MgmtInfo
326: [[p (PEPYPARM) arg]]
327:
328: GetListError
329: %{
330: struct type_CMIP_GetListError *arg =
331: (struct type_CMIP_GetListError *) parm;
332: struct element_CMIP_4 *element_CMIP_4;
333: %}
334: ::=
335: SEQUENCE %{ element_CMIP_4 = arg -> element_CMIP_4; %} {
336: managedObjectClass
337: ObjectClass
338: [[p (PEPYPARM) arg -> managedObjectClass]]
339: OPTIONAL <<arg -> managedObjectClass>>,
340:
341: managedObjectInstance
342: ObjectInstance
343: [[p (PEPYPARM) arg -> managedObjectInstance]]
344: OPTIONAL <<arg -> managedObjectInstance>>,
345:
346: currentTime[5]
347: IMPLICIT GeneralizedTime
348: [[p (PEPYPARM) arg -> currentTime]]
349: OPTIONAL <<arg -> currentTime>>,
350:
351: mgmtInfoList[6]
352: IMPLICIT SEQUENCE OF
353: <<element_CMIP_4 = arg -> element_CMIP_4;
354: element_CMIP_4;
355: element_CMIP_4 = element_CMIP_4 -> next>>
356: MISGetInfoStatus
357: [[p (PEPYPARM) element_CMIP_4 -> MISGetInfoStatus]]
358: }
359:
360: MISGetInfoStatus
361: %{
362: struct type_CMIP_MISGetInfoStatus *arg =
363: (struct type_CMIP_MISGetInfoStatus *) parm;
364: %}
365: ::=
366: CHOICE <<arg -> offset>> {
367: mgmtInfoIdError[0]
368: IMPLICIT MgmtInfoIdError
369: [[p (PEPYPARM) arg -> un.mgmtInfoIdError]],
370:
371: mgmtInfo[1]
372: IMPLICIT MgmtInfo
373: [[p (PEPYPARM) arg -> un.mgmtInfo]]
374: }
375:
376: MgmtInfoIdError
377: %{
378: struct type_CMIP_MgmtInfoIdError *arg =
379: (struct type_CMIP_MgmtInfoIdError *) parm;
380: %}
381: ::=
382: SEQUENCE {
383: errorStatus[0]
384: IMPLICIT ErrorStatus
385: [[p (PEPYPARM) arg -> errorStatus]],
386:
387: mgmtInfoId[1]
388: MgmtInfoId
389: [[p (PEPYPARM) arg -> mgmtInfoId]]
390: }
391:
392: SetListError
393: %{
394: struct type_CMIP_SetListError *arg =
395: (struct type_CMIP_SetListError *) parm;
396: struct element_CMIP_5 *element_CMIP_5;
397: %}
398: ::=
399: SEQUENCE %{ element_CMIP_5 = arg -> element_CMIP_5; %} {
400: managedObjectClass
401: ObjectClass
402: [[p (PEPYPARM) arg -> managedObjectClass]]
403: OPTIONAL <<arg -> managedObjectClass>>,
404:
405: managedObjectInstance
406: ObjectInstance
407: [[p (PEPYPARM) arg -> managedObjectInstance]]
408: OPTIONAL <<arg -> managedObjectInstance>>,
409:
410: currentTime[5]
411: IMPLICIT GeneralizedTime
412: [[p (PEPYPARM) arg -> currentTime]]
413: OPTIONAL <<arg -> currentTime>>,
414:
415: mgmtInfoList[6]
416: IMPLICIT SEQUENCE OF
417: <<element_CMIP_5 = arg -> element_CMIP_5;
418: element_CMIP_5;
419: element_CMIP_5 = element_CMIP_5 -> next>>
420: MISSetInfoStatus
421: [[p (PEPYPARM) element_CMIP_5 -> MISSetInfoStatus]]
422: }
423:
424: MISSetInfoStatus
425: %{
426: struct type_CMIP_MISSetInfoStatus *arg =
427: (struct type_CMIP_MISSetInfoStatus *) parm;
428: %}
429: ::=
430: CHOICE <<arg -> offset>> {
431: mgmtInfoError[0]
432: IMPLICIT MgmtInfoError
433: [[p (PEPYPARM) arg -> un.mgmtInfoError]],
434:
435: mgmtInfo[1]
436: IMPLICIT MgmtInfo
437: [[p (PEPYPARM) arg -> un.mgmtInfo]]
438: }
439:
440: MgmtInfoError
441: %{
442: struct type_CMIP_MgmtInfoError *arg =
443: (struct type_CMIP_MgmtInfoError *) parm;
444: %}
445: ::=
446: SEQUENCE {
447: errorStatus[0]
448: IMPLICIT ErrorStatus
449: [[p (PEPYPARM) arg -> errorStatus]],
450:
451: mgmtInfo[1]
452: IMPLICIT MgmtInfo
453: [[p (PEPYPARM) arg -> mgmtInfo]]
454: }
455:
456: ErrorStatus
457: %{
458: struct type_CMIP_ErrorStatus *arg =
459: (struct type_CMIP_ErrorStatus *) parm;
460: %}
461: ::=
462: INTEGER
463: [[i arg -> arg]]
464: {
465: accessDenied(2),
466: noSuchMgmtInfoId(5),
467: invalidMgmtInfoValue(7)
468: }
469:
470: NoSuchAction
471: %{
472: struct type_CMIP_NoSuchAction *arg =
473: (struct type_CMIP_NoSuchAction *) parm;
474: %}
475: ::=
476: ActionTypeId
477: [[p (PEPYPARM) arg]]
478:
479: ProcessingFailure
480: %{
481: struct type_CMIP_ProcessingFailure *arg =
482: (struct type_CMIP_ProcessingFailure *) parm;
483: %}
484: ::=
485: CHOICE <<arg -> offset>> {
486: actual[0]
487: SpecificErrorInfo
488: [[p (PEPYPARM) arg -> un.actual]],
489:
490: none[1]
491: IMPLICIT NULL
492: }
493:
494: NoSuchEventType
495: %{
496: struct type_CMIP_NoSuchEventType *arg =
497: (struct type_CMIP_NoSuchEventType *) parm;
498: %}
499: ::=
500: EventTypeID
501: [[p (PEPYPARM) arg]]
502:
503: ObjectClass
504: %{
505: struct type_CMIP_ObjectClass *arg =
506: (struct type_CMIP_ObjectClass *) parm;
507: %}
508: ::=
509: CHOICE <<arg -> offset>> {
510: globalForm[0]
511: IMPLICIT OBJECT IDENTIFIER
512: [[O arg -> un.globalForm]],
513:
514: nonSpecificForm[1]
515: IMPLICIT OCTET STRING
516: [[o (arg -> un.nonSpecificForm) ? arg -> un.nonSpecificForm -> qb_base : NULLCP
517: $ (arg -> un.nonSpecificForm) ? arg -> un.nonSpecificForm -> qb_len : 0]]
518: }
519:
520: ObjectInstance
521: %{
522: struct type_CMIP_ObjectInstance *arg =
523: (struct type_CMIP_ObjectInstance *) parm;
524: %}
525: ::=
526: CHOICE <<arg -> offset>> {
527: distinguishedName[2]
528: IMPLICIT DistinguishedName
529: [[p (PEPYPARM) arg -> un.distinguishedName]],
530:
531: nonSpecificForm[3]
532: IMPLICIT OCTET STRING
533: [[o (arg -> un.nonSpecificForm) ? arg -> un.nonSpecificForm -> qb_base : NULLCP
534: $ (arg -> un.nonSpecificForm) ? arg -> un.nonSpecificForm -> qb_len : 0]],
535:
536: enumeratedForm[4]
537: IMPLICIT INTEGER
538: [[i arg -> un.enumeratedForm]]
539: }
540:
541: CMISSync
542: %{
543: struct type_CMIP_CMISSync *arg =
544: (struct type_CMIP_CMISSync *) parm;
545: %}
546: ::=
547: INTEGER
548: [[i arg -> arg]]
549: {
550: bestEffort(0),
551: ordered(1),
552: stopOnError(2),
553: atomic(3)
554: }
555:
556: CMISFilter
557: %{
558: struct type_CMIP_CMISFilter *arg =
559: (struct type_CMIP_CMISFilter *) parm;
560: struct member_CMIP_0 *member_CMIP_0;
561: struct member_CMIP_1 *member_CMIP_1;
562: %}
563: ::=
564: CHOICE
565: %{
566: member_CMIP_0 = arg -> un.member_CMIP_0;
567: member_CMIP_1 = arg -> un.member_CMIP_1;
568: %}
569: <<arg -> offset>>
570: {
571: item[7]
572: FilterItem
573: [[p (PEPYPARM) arg -> un.item]],
574:
575: and[8]
576: IMPLICIT SET OF
577: <<member_CMIP_0 = arg -> un.member_CMIP_0;
578: member_CMIP_0;
579: member_CMIP_0 = member_CMIP_0 -> next>>
580: CMISFilter
581: [[p (PEPYPARM) member_CMIP_0 -> CMISFilter]],
582:
583: or[9]
584: IMPLICIT SET OF
585: <<member_CMIP_1 = arg -> un.member_CMIP_1;
586: member_CMIP_1;
587: member_CMIP_1 = member_CMIP_1 -> next>>
588: CMISFilter
589: [[p (PEPYPARM) member_CMIP_1 -> CMISFilter]],
590:
591: not[10]
592: CMISFilter
593: [[p (PEPYPARM) arg -> un.not]]
594: }
595:
596: FilterItem
597: %{
598: struct type_CMIP_FilterItem *arg =
599: (struct type_CMIP_FilterItem *) parm;
600: %}
601: ::=
602: CHOICE <<arg -> offset>> {
603: equality[0]
604: IMPLICIT MgmtInfo
605: [[p (PEPYPARM) arg -> un.equality]],
606:
607: greaterOrEqual[1]
608: IMPLICIT MgmtInfo
609: [[p (PEPYPARM) arg -> un.greaterOrEqual]],
610:
611: lessOrEqual[2]
612: IMPLICIT MgmtInfo
613: [[p (PEPYPARM) arg -> un.lessOrEqual]],
614:
615: present[3]
616: MgmtInfoID
617: [[p (PEPYPARM) arg -> un.present]]
618: }
619:
620: AccessControl
621: %{
622: struct type_CMIP_AccessControl *arg =
623: (struct type_CMIP_AccessControl *) parm;
624: %}
625: ::=
626: ANY
627: [[a arg]]
628:
629: EventTypeId
630: %{
631: struct type_CMIP_EventTypeId *arg =
632: (struct type_CMIP_EventTypeId *) parm;
633: %}
634: ::=
635: ANY
636: [[a arg]]
637:
638: EventInfo
639: %{
640: struct type_CMIP_EventInfo *arg =
641: (struct type_CMIP_EventInfo *) parm;
642: %}
643: ::=
644: ANY
645: [[a arg]]
646:
647: MgmtInfo
648: %{
649: struct type_CMIP_MgmtInfo *arg =
650: (struct type_CMIP_MgmtInfo *) parm;
651: %}
652: ::=
653: SEQUENCE {
654: MgmtInfoId
655: [[p (PEPYPARM) arg -> element_CMIP_6]],
656:
657: MgmtInfoValue
658: [[p (PEPYPARM) arg -> element_CMIP_7]]
659: }
660:
661: MgmtInfoId
662: %{
663: struct type_CMIP_MgmtInfoId *arg =
664: (struct type_CMIP_MgmtInfoId *) parm;
665: %}
666: ::=
667: ANY
668: [[a arg]]
669:
670: MgmtInfoValue
671: %{
672: struct type_CMIP_MgmtInfoValue *arg =
673: (struct type_CMIP_MgmtInfoValue *) parm;
674: %}
675: ::=
676: ANY
677: [[a arg]]
678:
679: ActionTypeId
680: %{
681: struct type_CMIP_ActionTypeId *arg =
682: (struct type_CMIP_ActionTypeId *) parm;
683: %}
684: ::=
685: ANY
686: [[a arg]]
687:
688: ActionInfo
689: %{
690: struct type_CMIP_ActionInfo *arg =
691: (struct type_CMIP_ActionInfo *) parm;
692: %}
693: ::=
694: ANY
695: [[a arg]]
696:
697: SpecificErrorInfo
698: %{
699: struct type_CMIP_SpecificErrorInfo *arg =
700: (struct type_CMIP_SpecificErrorInfo *) parm;
701: %}
702: ::=
703: ANY
704: [[a arg]]
705:
706: DECODER decode
707:
708: EventReportArgument
709: %{
710: struct type_CMIP_EventReportArgument **arg =
711: (struct type_CMIP_EventReportArgument **) parm;
712: %}
713: ::=
714: %{
715: if ((*(arg) = (struct type_CMIP_EventReportArgument *)
716: calloc (1, sizeof **(arg))) == ((struct type_CMIP_EventReportArgument *) 0)) {
717: advise (NULLCP, "out of memory");
718: return NOTOK;
719: }
720: %}
721: SEQUENCE {
722: managedObjectClass
723: ObjectClass
724: [[p (PEPYPARM) &((*arg) -> managedObjectClass)]],
725:
726: managedObjectInstance
727: ObjectInstance
728: [[p (PEPYPARM) &((*arg) -> managedObjectInstance)]],
729:
730: eventType[5]
731: EventTypeID
732: [[p (PEPYPARM) &((*arg) -> eventType)]],
733:
734: eventTime[6]
735: IMPLICIT GeneralizedTime
736: [[p (PEPYPARM) &((*arg) -> eventTime)]]
737: OPTIONAL,
738:
739: eventInfo[7]
740: EventInfo
741: [[p (PEPYPARM) &((*arg) -> eventInfo)]]
742: OPTIONAL
743: }
744:
745: EventReportResult
746: %{
747: struct type_CMIP_EventReportResult **arg =
748: (struct type_CMIP_EventReportResult **) parm;
749: %}
750: ::=
751: %{
752: if ((*(arg) = (struct type_CMIP_EventReportResult *)
753: calloc (1, sizeof **(arg))) == ((struct type_CMIP_EventReportResult *) 0)) {
754: advise (NULLCP, "out of memory");
755: return NOTOK;
756: }
757: %}
758: NULL
759:
760: LinkedReplyArgument
761: %{
762: struct type_CMIP_LinkedReplyArgument **arg =
763: (struct type_CMIP_LinkedReplyArgument **) parm;
764: %}
765: ::=
766: %{
767: if ((*(arg) = (struct type_CMIP_LinkedReplyArgument *)
768: calloc (1, sizeof **(arg))) == ((struct type_CMIP_LinkedReplyArgument *) 0)) {
769: advise (NULLCP, "out of memory");
770: return NOTOK;
771: }
772: %}
773: CHOICE
774: {
775: getResult[0]
776: IMPLICIT GetResult
777: [[p (PEPYPARM) &((*arg) -> un.getResult)]]
778: %{ (*(arg)) -> offset = type_CMIP_LinkedReplyArgument_getResult; %},
779:
780: getError[1]
781: IMPLICIT GetListError
782: [[p (PEPYPARM) &((*arg) -> un.getError)]]
783: %{ (*(arg)) -> offset = type_CMIP_LinkedReplyArgument_getError; %},
784:
785: setResult[2]
786: IMPLICIT SetResult
787: [[p (PEPYPARM) &((*arg) -> un.setResult)]]
788: %{ (*(arg)) -> offset = type_CMIP_LinkedReplyArgument_setResult; %},
789:
790: setError[3]
791: IMPLICIT SetListError
792: [[p (PEPYPARM) &((*arg) -> un.setError)]]
793: %{ (*(arg)) -> offset = type_CMIP_LinkedReplyArgument_setError; %},
794:
795: actionResult[4]
796: IMPLICIT ActionResult
797: [[p (PEPYPARM) &((*arg) -> un.actionResult)]]
798: %{ (*(arg)) -> offset = type_CMIP_LinkedReplyArgument_actionResult; %}
799: }
800:
801: GetArgument
802: %{
803: struct type_CMIP_GetArgument **arg =
804: (struct type_CMIP_GetArgument **) parm;
805: struct element_CMIP_0 **element_CMIP_0;
806: %}
807: ::=
808: %{
809: if ((*(arg) = (struct type_CMIP_GetArgument *)
810: calloc (1, sizeof **(arg))) == ((struct type_CMIP_GetArgument *) 0)) {
811: advise (NULLCP, "out of memory");
812: return NOTOK;
813: }
814: element_CMIP_0 = &((*arg) -> element_CMIP_0);
815: %}
816: SEQUENCE %{ element_CMIP_0 = &((*arg) -> element_CMIP_0); %} {
817: managedObjectClass
818: ObjectClass
819: [[p (PEPYPARM) &((*arg) -> managedObjectClass)]],
820:
821: managedObjectInstance
822: ObjectInstance
823: [[p (PEPYPARM) &((*arg) -> managedObjectInstance)]],
824:
825: accessControl[5]
826: AccessControl
827: [[p (PEPYPARM) &((*arg) -> accessControl)]]
828: OPTIONAL,
829:
830: synchronization[6]
831: IMPLICIT CMISSync
832: [[p (PEPYPARM) &((*arg) -> synchronization)]]
833: DEFAULT bestEffort,
834:
835: filter
836: CMISFilter
837: [[p (PEPYPARM) &((*arg) -> filter)]]
838: OPTIONAL,
839:
840: mgmtInfoIdList[11]
841: IMPLICIT SEQUENCE OF
842: %{
843: if ((*(element_CMIP_0) = (struct element_CMIP_0 *)
844: calloc (1, sizeof **(element_CMIP_0))) == ((struct element_CMIP_0 *) 0)) {
845: advise (NULLCP, "out of memory");
846: return NOTOK;
847: }
848: %}
849: MgmtInfoId
850: [[p (PEPYPARM) &((*element_CMIP_0) -> MgmtInfoId)]]
851: %{ element_CMIP_0 = &((*element_CMIP_0) -> next); %}
852: }
853:
854: GetResult
855: %{
856: struct type_CMIP_GetResult **arg =
857: (struct type_CMIP_GetResult **) parm;
858: struct element_CMIP_1 **element_CMIP_1;
859: %}
860: ::=
861: %{
862: if ((*(arg) = (struct type_CMIP_GetResult *)
863: calloc (1, sizeof **(arg))) == ((struct type_CMIP_GetResult *) 0)) {
864: advise (NULLCP, "out of memory");
865: return NOTOK;
866: }
867: element_CMIP_1 = &((*arg) -> element_CMIP_1);
868: %}
869: SEQUENCE %{ element_CMIP_1 = &((*arg) -> element_CMIP_1); %} {
870: managedObjectClass
871: ObjectClass
872: [[p (PEPYPARM) &((*arg) -> managedObjectClass)]]
873: OPTIONAL,
874:
875: managedObjectInstance
876: ObjectInstance
877: [[p (PEPYPARM) &((*arg) -> managedObjectInstance)]]
878: OPTIONAL,
879:
880: currentTime[5]
881: IMPLICIT GeneralizedTime
882: [[p (PEPYPARM) &((*arg) -> currentTime)]]
883: OPTIONAL,
884:
885: mgmtInfoList[6]
886: IMPLICIT SEQUENCE OF
887: %{
888: if ((*(element_CMIP_1) = (struct element_CMIP_1 *)
889: calloc (1, sizeof **(element_CMIP_1))) == ((struct element_CMIP_1 *) 0)) {
890: advise (NULLCP, "out of memory");
891: return NOTOK;
892: }
893: %}
894: MgmtInfo
895: [[p (PEPYPARM) &((*element_CMIP_1) -> MgmtInfo)]]
896: %{ element_CMIP_1 = &((*element_CMIP_1) -> next); %}
897: }
898:
899: SetArgument
900: %{
901: struct type_CMIP_SetArgument **arg =
902: (struct type_CMIP_SetArgument **) parm;
903: struct element_CMIP_2 **element_CMIP_2;
904: %}
905: ::=
906: %{
907: if ((*(arg) = (struct type_CMIP_SetArgument *)
908: calloc (1, sizeof **(arg))) == ((struct type_CMIP_SetArgument *) 0)) {
909: advise (NULLCP, "out of memory");
910: return NOTOK;
911: }
912: element_CMIP_2 = &((*arg) -> element_CMIP_2);
913: %}
914: SEQUENCE %{ element_CMIP_2 = &((*arg) -> element_CMIP_2); %} {
915: managedObjectClass
916: ObjectClass
917: [[p (PEPYPARM) &((*arg) -> managedObjectClass)]],
918:
919: managedObjectInstance
920: ObjectInstance
921: [[p (PEPYPARM) &((*arg) -> managedObjectInstance)]],
922:
923: accessControl[5]
924: AccessControl
925: [[p (PEPYPARM) &((*arg) -> accessControl)]]
926: OPTIONAL,
927:
928: synchronization[6]
929: IMPLICIT CMISSync
930: [[p (PEPYPARM) &((*arg) -> synchronization)]]
931: DEFAULT bestEffort,
932:
933: filter
934: CMISFilter
935: [[p (PEPYPARM) &((*arg) -> filter)]]
936: OPTIONAL,
937:
938: mgmtInfoList[11]
939: IMPLICIT SEQUENCE OF
940: %{
941: if ((*(element_CMIP_2) = (struct element_CMIP_2 *)
942: calloc (1, sizeof **(element_CMIP_2))) == ((struct element_CMIP_2 *) 0)) {
943: advise (NULLCP, "out of memory");
944: return NOTOK;
945: }
946: %}
947: MgmtInfo
948: [[p (PEPYPARM) &((*element_CMIP_2) -> MgmtInfo)]]
949: %{ element_CMIP_2 = &((*element_CMIP_2) -> next); %}
950: }
951:
952: SetResult
953: %{
954: struct type_CMIP_SetResult **arg =
955: (struct type_CMIP_SetResult **) parm;
956: struct element_CMIP_3 **element_CMIP_3;
957: %}
958: ::=
959: %{
960: if ((*(arg) = (struct type_CMIP_SetResult *)
961: calloc (1, sizeof **(arg))) == ((struct type_CMIP_SetResult *) 0)) {
962: advise (NULLCP, "out of memory");
963: return NOTOK;
964: }
965: element_CMIP_3 = &((*arg) -> element_CMIP_3);
966: %}
967: SEQUENCE %{ element_CMIP_3 = &((*arg) -> element_CMIP_3); %} {
968: managedObjectClass
969: ObjectClass
970: [[p (PEPYPARM) &((*arg) -> managedObjectClass)]]
971: OPTIONAL,
972:
973: managedObjectInstance
974: ObjectInstance
975: [[p (PEPYPARM) &((*arg) -> managedObjectInstance)]]
976: OPTIONAL,
977:
978: currentTime[5]
979: IMPLICIT GeneralizedTime
980: [[p (PEPYPARM) &((*arg) -> currentTime)]]
981: OPTIONAL,
982:
983: mgmtInfoList[6]
984: IMPLICIT SEQUENCE OF
985: %{
986: if ((*(element_CMIP_3) = (struct element_CMIP_3 *)
987: calloc (1, sizeof **(element_CMIP_3))) == ((struct element_CMIP_3 *) 0)) {
988: advise (NULLCP, "out of memory");
989: return NOTOK;
990: }
991: %}
992: MgmtInfo
993: [[p (PEPYPARM) &((*element_CMIP_3) -> MgmtInfo)]]
994: %{ element_CMIP_3 = &((*element_CMIP_3) -> next); %}
995: }
996:
997: ActionArgument
998: %{
999: struct type_CMIP_ActionArgument **arg =
1000: (struct type_CMIP_ActionArgument **) parm;
1001: %}
1002: ::=
1003: %{
1004: if ((*(arg) = (struct type_CMIP_ActionArgument *)
1005: calloc (1, sizeof **(arg))) == ((struct type_CMIP_ActionArgument *) 0)) {
1006: advise (NULLCP, "out of memory");
1007: return NOTOK;
1008: }
1009: %}
1010: SEQUENCE {
1011: managedObjectClass
1012: ObjectClass
1013: [[p (PEPYPARM) &((*arg) -> managedObjectClass)]],
1014:
1015: managedObjectInstance
1016: ObjectInstance
1017: [[p (PEPYPARM) &((*arg) -> managedObjectInstance)]],
1018:
1019: accessControl[5]
1020: AccessControl
1021: [[p (PEPYPARM) &((*arg) -> accessControl)]]
1022: OPTIONAL,
1023:
1024: filter
1025: CMISFilter
1026: [[p (PEPYPARM) &((*arg) -> filter)]]
1027: OPTIONAL,
1028:
1029: actionType[11]
1030: ActionTypeId
1031: [[p (PEPYPARM) &((*arg) -> actionType)]],
1032:
1033: actionInfo[12]
1034: ActionInfo
1035: [[p (PEPYPARM) &((*arg) -> actionInfo)]]
1036: OPTIONAL
1037: }
1038:
1039: ActionResult
1040: %{
1041: struct type_CMIP_ActionResult **arg =
1042: (struct type_CMIP_ActionResult **) parm;
1043: %}
1044: ::=
1045: %{
1046: if ((*(arg) = (struct type_CMIP_ActionResult *)
1047: calloc (1, sizeof **(arg))) == ((struct type_CMIP_ActionResult *) 0)) {
1048: advise (NULLCP, "out of memory");
1049: return NOTOK;
1050: }
1051: %}
1052: SEQUENCE {
1053: managedObjectClass
1054: ObjectClass
1055: [[p (PEPYPARM) &((*arg) -> managedObjectClass)]]
1056: OPTIONAL,
1057:
1058: managedObjectInstance
1059: ObjectInstance
1060: [[p (PEPYPARM) &((*arg) -> managedObjectInstance)]]
1061: OPTIONAL,
1062:
1063: currentTime[5]
1064: IMPLICIT GeneralizedTime
1065: [[p (PEPYPARM) &((*arg) -> currentTime)]]
1066: OPTIONAL,
1067:
1068: actionResult[6]
1069: IMPLICIT MgmtInfo
1070: [[p (PEPYPARM) &((*arg) -> actionResult)]]
1071: }
1072:
1073: NoSuchObject
1074: %{
1075: struct type_CMIP_NoSuchObject **arg =
1076: (struct type_CMIP_NoSuchObject **) parm;
1077: %}
1078: ::=
1079: OBJECT IDENTIFIER
1080: [[O (*arg)]]
1081:
1082: SyncNotSupported
1083: %{
1084: struct type_CMIP_SyncNotSupported **arg =
1085: (struct type_CMIP_SyncNotSupported **) parm;
1086: %}
1087: ::=
1088: CMISSync
1089: [[p (PEPYPARM) &((*arg))]]
1090:
1091: InvalidFilter
1092: %{
1093: struct type_CMIP_InvalidFilter **arg =
1094: (struct type_CMIP_InvalidFilter **) parm;
1095: %}
1096: ::=
1097: CMISFilter
1098: [[p (PEPYPARM) &((*arg))]]
1099:
1100: NoSuchMgmtInfoId
1101: %{
1102: struct type_CMIP_NoSuchMgmtInfoId **arg =
1103: (struct type_CMIP_NoSuchMgmtInfoId **) parm;
1104: %}
1105: ::=
1106: MgmtInfoId
1107: [[p (PEPYPARM) &((*arg))]]
1108:
1109: InvalidMgmtInfoValue
1110: %{
1111: struct type_CMIP_InvalidMgmtInfoValue **arg =
1112: (struct type_CMIP_InvalidMgmtInfoValue **) parm;
1113: %}
1114: ::=
1115: MgmtInfo
1116: [[p (PEPYPARM) &((*arg))]]
1117:
1118: GetListError
1119: %{
1120: struct type_CMIP_GetListError **arg =
1121: (struct type_CMIP_GetListError **) parm;
1122: struct element_CMIP_4 **element_CMIP_4;
1123: %}
1124: ::=
1125: %{
1126: if ((*(arg) = (struct type_CMIP_GetListError *)
1127: calloc (1, sizeof **(arg))) == ((struct type_CMIP_GetListError *) 0)) {
1128: advise (NULLCP, "out of memory");
1129: return NOTOK;
1130: }
1131: element_CMIP_4 = &((*arg) -> element_CMIP_4);
1132: %}
1133: SEQUENCE %{ element_CMIP_4 = &((*arg) -> element_CMIP_4); %} {
1134: managedObjectClass
1135: ObjectClass
1136: [[p (PEPYPARM) &((*arg) -> managedObjectClass)]]
1137: OPTIONAL,
1138:
1139: managedObjectInstance
1140: ObjectInstance
1141: [[p (PEPYPARM) &((*arg) -> managedObjectInstance)]]
1142: OPTIONAL,
1143:
1144: currentTime[5]
1145: IMPLICIT GeneralizedTime
1146: [[p (PEPYPARM) &((*arg) -> currentTime)]]
1147: OPTIONAL,
1148:
1149: mgmtInfoList[6]
1150: IMPLICIT SEQUENCE OF
1151: %{
1152: if ((*(element_CMIP_4) = (struct element_CMIP_4 *)
1153: calloc (1, sizeof **(element_CMIP_4))) == ((struct element_CMIP_4 *) 0)) {
1154: advise (NULLCP, "out of memory");
1155: return NOTOK;
1156: }
1157: %}
1158: MISGetInfoStatus
1159: [[p (PEPYPARM) &((*element_CMIP_4) -> MISGetInfoStatus)]]
1160: %{ element_CMIP_4 = &((*element_CMIP_4) -> next); %}
1161: }
1162:
1163: MISGetInfoStatus
1164: %{
1165: struct type_CMIP_MISGetInfoStatus **arg =
1166: (struct type_CMIP_MISGetInfoStatus **) parm;
1167: %}
1168: ::=
1169: %{
1170: if ((*(arg) = (struct type_CMIP_MISGetInfoStatus *)
1171: calloc (1, sizeof **(arg))) == ((struct type_CMIP_MISGetInfoStatus *) 0)) {
1172: advise (NULLCP, "out of memory");
1173: return NOTOK;
1174: }
1175: %}
1176: CHOICE
1177: {
1178: mgmtInfoIdError[0]
1179: IMPLICIT MgmtInfoIdError
1180: [[p (PEPYPARM) &((*arg) -> un.mgmtInfoIdError)]]
1181: %{ (*(arg)) -> offset = type_CMIP_MISGetInfoStatus_mgmtInfoIdError; %},
1182:
1183: mgmtInfo[1]
1184: IMPLICIT MgmtInfo
1185: [[p (PEPYPARM) &((*arg) -> un.mgmtInfo)]]
1186: %{ (*(arg)) -> offset = type_CMIP_MISGetInfoStatus_mgmtInfo; %}
1187: }
1188:
1189: MgmtInfoIdError
1190: %{
1191: struct type_CMIP_MgmtInfoIdError **arg =
1192: (struct type_CMIP_MgmtInfoIdError **) parm;
1193: %}
1194: ::=
1195: %{
1196: if ((*(arg) = (struct type_CMIP_MgmtInfoIdError *)
1197: calloc (1, sizeof **(arg))) == ((struct type_CMIP_MgmtInfoIdError *) 0)) {
1198: advise (NULLCP, "out of memory");
1199: return NOTOK;
1200: }
1201: %}
1202: SEQUENCE {
1203: errorStatus[0]
1204: IMPLICIT ErrorStatus
1205: [[p (PEPYPARM) &((*arg) -> errorStatus)]],
1206:
1207: mgmtInfoId[1]
1208: MgmtInfoId
1209: [[p (PEPYPARM) &((*arg) -> mgmtInfoId)]]
1210: }
1211:
1212: SetListError
1213: %{
1214: struct type_CMIP_SetListError **arg =
1215: (struct type_CMIP_SetListError **) parm;
1216: struct element_CMIP_5 **element_CMIP_5;
1217: %}
1218: ::=
1219: %{
1220: if ((*(arg) = (struct type_CMIP_SetListError *)
1221: calloc (1, sizeof **(arg))) == ((struct type_CMIP_SetListError *) 0)) {
1222: advise (NULLCP, "out of memory");
1223: return NOTOK;
1224: }
1225: element_CMIP_5 = &((*arg) -> element_CMIP_5);
1226: %}
1227: SEQUENCE %{ element_CMIP_5 = &((*arg) -> element_CMIP_5); %} {
1228: managedObjectClass
1229: ObjectClass
1230: [[p (PEPYPARM) &((*arg) -> managedObjectClass)]]
1231: OPTIONAL,
1232:
1233: managedObjectInstance
1234: ObjectInstance
1235: [[p (PEPYPARM) &((*arg) -> managedObjectInstance)]]
1236: OPTIONAL,
1237:
1238: currentTime[5]
1239: IMPLICIT GeneralizedTime
1240: [[p (PEPYPARM) &((*arg) -> currentTime)]]
1241: OPTIONAL,
1242:
1243: mgmtInfoList[6]
1244: IMPLICIT SEQUENCE OF
1245: %{
1246: if ((*(element_CMIP_5) = (struct element_CMIP_5 *)
1247: calloc (1, sizeof **(element_CMIP_5))) == ((struct element_CMIP_5 *) 0)) {
1248: advise (NULLCP, "out of memory");
1249: return NOTOK;
1250: }
1251: %}
1252: MISSetInfoStatus
1253: [[p (PEPYPARM) &((*element_CMIP_5) -> MISSetInfoStatus)]]
1254: %{ element_CMIP_5 = &((*element_CMIP_5) -> next); %}
1255: }
1256:
1257: MISSetInfoStatus
1258: %{
1259: struct type_CMIP_MISSetInfoStatus **arg =
1260: (struct type_CMIP_MISSetInfoStatus **) parm;
1261: %}
1262: ::=
1263: %{
1264: if ((*(arg) = (struct type_CMIP_MISSetInfoStatus *)
1265: calloc (1, sizeof **(arg))) == ((struct type_CMIP_MISSetInfoStatus *) 0)) {
1266: advise (NULLCP, "out of memory");
1267: return NOTOK;
1268: }
1269: %}
1270: CHOICE
1271: {
1272: mgmtInfoError[0]
1273: IMPLICIT MgmtInfoError
1274: [[p (PEPYPARM) &((*arg) -> un.mgmtInfoError)]]
1275: %{ (*(arg)) -> offset = type_CMIP_MISSetInfoStatus_mgmtInfoError; %},
1276:
1277: mgmtInfo[1]
1278: IMPLICIT MgmtInfo
1279: [[p (PEPYPARM) &((*arg) -> un.mgmtInfo)]]
1280: %{ (*(arg)) -> offset = type_CMIP_MISSetInfoStatus_mgmtInfo; %}
1281: }
1282:
1283: MgmtInfoError
1284: %{
1285: struct type_CMIP_MgmtInfoError **arg =
1286: (struct type_CMIP_MgmtInfoError **) parm;
1287: %}
1288: ::=
1289: %{
1290: if ((*(arg) = (struct type_CMIP_MgmtInfoError *)
1291: calloc (1, sizeof **(arg))) == ((struct type_CMIP_MgmtInfoError *) 0)) {
1292: advise (NULLCP, "out of memory");
1293: return NOTOK;
1294: }
1295: %}
1296: SEQUENCE {
1297: errorStatus[0]
1298: IMPLICIT ErrorStatus
1299: [[p (PEPYPARM) &((*arg) -> errorStatus)]],
1300:
1301: mgmtInfo[1]
1302: IMPLICIT MgmtInfo
1303: [[p (PEPYPARM) &((*arg) -> mgmtInfo)]]
1304: }
1305:
1306: ErrorStatus
1307: %{
1308: struct type_CMIP_ErrorStatus **arg =
1309: (struct type_CMIP_ErrorStatus **) parm;
1310: %}
1311: ::=
1312: %{
1313: if ((*(arg) = (struct type_CMIP_ErrorStatus *)
1314: calloc (1, sizeof **(arg))) == ((struct type_CMIP_ErrorStatus *) 0)) {
1315: advise (NULLCP, "out of memory");
1316: return NOTOK;
1317: }
1318: %}
1319: INTEGER
1320: [[i (*arg) -> arg]]
1321: {
1322: accessDenied(2),
1323: noSuchMgmtInfoId(5),
1324: invalidMgmtInfoValue(7)
1325: }
1326:
1327: NoSuchAction
1328: %{
1329: struct type_CMIP_NoSuchAction **arg =
1330: (struct type_CMIP_NoSuchAction **) parm;
1331: %}
1332: ::=
1333: ActionTypeId
1334: [[p (PEPYPARM) &((*arg))]]
1335:
1336: ProcessingFailure
1337: %{
1338: struct type_CMIP_ProcessingFailure **arg =
1339: (struct type_CMIP_ProcessingFailure **) parm;
1340: %}
1341: ::=
1342: %{
1343: if ((*(arg) = (struct type_CMIP_ProcessingFailure *)
1344: calloc (1, sizeof **(arg))) == ((struct type_CMIP_ProcessingFailure *) 0)) {
1345: advise (NULLCP, "out of memory");
1346: return NOTOK;
1347: }
1348: %}
1349: CHOICE
1350: {
1351: actual[0]
1352: SpecificErrorInfo
1353: [[p (PEPYPARM) &((*arg) -> un.actual)]]
1354: %{ (*(arg)) -> offset = type_CMIP_ProcessingFailure_actual; %},
1355:
1356: none[1]
1357: IMPLICIT NULL
1358: %{ (*(arg)) -> offset = type_CMIP_ProcessingFailure_none; %}
1359: }
1360:
1361: NoSuchEventType
1362: %{
1363: struct type_CMIP_NoSuchEventType **arg =
1364: (struct type_CMIP_NoSuchEventType **) parm;
1365: %}
1366: ::=
1367: EventTypeID
1368: [[p (PEPYPARM) &((*arg))]]
1369:
1370: ObjectClass
1371: %{
1372: struct type_CMIP_ObjectClass **arg =
1373: (struct type_CMIP_ObjectClass **) parm;
1374: %}
1375: ::=
1376: %{
1377: if ((*(arg) = (struct type_CMIP_ObjectClass *)
1378: calloc (1, sizeof **(arg))) == ((struct type_CMIP_ObjectClass *) 0)) {
1379: advise (NULLCP, "out of memory");
1380: return NOTOK;
1381: }
1382: %}
1383: CHOICE
1384: {
1385: globalForm[0]
1386: IMPLICIT OBJECT IDENTIFIER
1387: [[O (*arg) -> un.globalForm]]
1388: %{ (*(arg)) -> offset = type_CMIP_ObjectClass_globalForm; %},
1389:
1390: nonSpecificForm[1]
1391: IMPLICIT OCTET STRING
1392: %{
1393: if (((*arg) -> un.nonSpecificForm = str2qb ($$, $$_len)) == ((struct qbuf *) 0)) {
1394: advise (NULLCP, "out of memory");
1395: return NOTOK;
1396: }
1397:
1398: (*(arg)) -> offset = type_CMIP_ObjectClass_nonSpecificForm;
1399: %}
1400: }
1401:
1402: ObjectInstance
1403: %{
1404: struct type_CMIP_ObjectInstance **arg =
1405: (struct type_CMIP_ObjectInstance **) parm;
1406: %}
1407: ::=
1408: %{
1409: if ((*(arg) = (struct type_CMIP_ObjectInstance *)
1410: calloc (1, sizeof **(arg))) == ((struct type_CMIP_ObjectInstance *) 0)) {
1411: advise (NULLCP, "out of memory");
1412: return NOTOK;
1413: }
1414: %}
1415: CHOICE
1416: {
1417: distinguishedName[2]
1418: IMPLICIT DistinguishedName
1419: [[p (PEPYPARM) &((*arg) -> un.distinguishedName)]]
1420: %{ (*(arg)) -> offset = type_CMIP_ObjectInstance_distinguishedName; %},
1421:
1422: nonSpecificForm[3]
1423: IMPLICIT OCTET STRING
1424: %{
1425: if (((*arg) -> un.nonSpecificForm = str2qb ($$, $$_len)) == ((struct qbuf *) 0)) {
1426: advise (NULLCP, "out of memory");
1427: return NOTOK;
1428: }
1429:
1430: (*(arg)) -> offset = type_CMIP_ObjectInstance_nonSpecificForm;
1431: %},
1432:
1433: enumeratedForm[4]
1434: IMPLICIT INTEGER
1435: [[i (*arg) -> un.enumeratedForm]]
1436: %{ (*(arg)) -> offset = type_CMIP_ObjectInstance_enumeratedForm; %}
1437: }
1438:
1439: CMISSync
1440: %{
1441: struct type_CMIP_CMISSync **arg =
1442: (struct type_CMIP_CMISSync **) parm;
1443: %}
1444: ::=
1445: %{
1446: if ((*(arg) = (struct type_CMIP_CMISSync *)
1447: calloc (1, sizeof **(arg))) == ((struct type_CMIP_CMISSync *) 0)) {
1448: advise (NULLCP, "out of memory");
1449: return NOTOK;
1450: }
1451: %}
1452: INTEGER
1453: [[i (*arg) -> arg]]
1454: {
1455: bestEffort(0),
1456: ordered(1),
1457: stopOnError(2),
1458: atomic(3)
1459: }
1460:
1461: CMISFilter
1462: %{
1463: struct type_CMIP_CMISFilter **arg =
1464: (struct type_CMIP_CMISFilter **) parm;
1465: struct member_CMIP_0 **member_CMIP_0;
1466: struct member_CMIP_1 **member_CMIP_1;
1467: %}
1468: ::=
1469: %{
1470: if ((*(arg) = (struct type_CMIP_CMISFilter *)
1471: calloc (1, sizeof **(arg))) == ((struct type_CMIP_CMISFilter *) 0)) {
1472: advise (NULLCP, "out of memory");
1473: return NOTOK;
1474: }
1475: member_CMIP_0 = &((*arg) -> un.member_CMIP_0);
1476: member_CMIP_1 = &((*arg) -> un.member_CMIP_1);
1477: %}
1478: CHOICE
1479: {
1480: item[7]
1481: FilterItem
1482: [[p (PEPYPARM) &((*arg) -> un.item)]]
1483: %{ (*(arg)) -> offset = type_CMIP_CMISFilter_item; %},
1484:
1485: and[8]
1486: IMPLICIT SET OF
1487: %{
1488: if ((*(member_CMIP_0) = (struct member_CMIP_0 *)
1489: calloc (1, sizeof **(member_CMIP_0))) == ((struct member_CMIP_0 *) 0)) {
1490: advise (NULLCP, "out of memory");
1491: return NOTOK;
1492: }
1493: %}
1494: CMISFilter
1495: [[p (PEPYPARM) &((*member_CMIP_0) -> CMISFilter)]]
1496: %{ member_CMIP_0 = &((*member_CMIP_0) -> next); (*(arg)) -> offset = type_CMIP_CMISFilter_and; %},
1497:
1498: or[9]
1499: IMPLICIT SET OF
1500: %{
1501: if ((*(member_CMIP_1) = (struct member_CMIP_1 *)
1502: calloc (1, sizeof **(member_CMIP_1))) == ((struct member_CMIP_1 *) 0)) {
1503: advise (NULLCP, "out of memory");
1504: return NOTOK;
1505: }
1506: %}
1507: CMISFilter
1508: [[p (PEPYPARM) &((*member_CMIP_1) -> CMISFilter)]]
1509: %{ member_CMIP_1 = &((*member_CMIP_1) -> next); (*(arg)) -> offset = type_CMIP_CMISFilter_or; %},
1510:
1511: not[10]
1512: CMISFilter
1513: [[p (PEPYPARM) &((*arg) -> un.not)]]
1514: %{ (*(arg)) -> offset = type_CMIP_CMISFilter_not; %}
1515: }
1516:
1517: FilterItem
1518: %{
1519: struct type_CMIP_FilterItem **arg =
1520: (struct type_CMIP_FilterItem **) parm;
1521: %}
1522: ::=
1523: %{
1524: if ((*(arg) = (struct type_CMIP_FilterItem *)
1525: calloc (1, sizeof **(arg))) == ((struct type_CMIP_FilterItem *) 0)) {
1526: advise (NULLCP, "out of memory");
1527: return NOTOK;
1528: }
1529: %}
1530: CHOICE
1531: {
1532: equality[0]
1533: IMPLICIT MgmtInfo
1534: [[p (PEPYPARM) &((*arg) -> un.equality)]]
1535: %{ (*(arg)) -> offset = type_CMIP_FilterItem_equality; %},
1536:
1537: greaterOrEqual[1]
1538: IMPLICIT MgmtInfo
1539: [[p (PEPYPARM) &((*arg) -> un.greaterOrEqual)]]
1540: %{ (*(arg)) -> offset = type_CMIP_FilterItem_greaterOrEqual; %},
1541:
1542: lessOrEqual[2]
1543: IMPLICIT MgmtInfo
1544: [[p (PEPYPARM) &((*arg) -> un.lessOrEqual)]]
1545: %{ (*(arg)) -> offset = type_CMIP_FilterItem_lessOrEqual; %},
1546:
1547: present[3]
1548: MgmtInfoID
1549: [[p (PEPYPARM) &((*arg) -> un.present)]]
1550: %{ (*(arg)) -> offset = type_CMIP_FilterItem_present; %}
1551: }
1552:
1553: AccessControl
1554: %{
1555: struct type_CMIP_AccessControl **arg =
1556: (struct type_CMIP_AccessControl **) parm;
1557: %}
1558: ::=
1559: ANY
1560: [[a (*arg)]]
1561:
1562: EventTypeId
1563: %{
1564: struct type_CMIP_EventTypeId **arg =
1565: (struct type_CMIP_EventTypeId **) parm;
1566: %}
1567: ::=
1568: ANY
1569: [[a (*arg)]]
1570:
1571: EventInfo
1572: %{
1573: struct type_CMIP_EventInfo **arg =
1574: (struct type_CMIP_EventInfo **) parm;
1575: %}
1576: ::=
1577: ANY
1578: [[a (*arg)]]
1579:
1580: MgmtInfo
1581: %{
1582: struct type_CMIP_MgmtInfo **arg =
1583: (struct type_CMIP_MgmtInfo **) parm;
1584: %}
1585: ::=
1586: %{
1587: if ((*(arg) = (struct type_CMIP_MgmtInfo *)
1588: calloc (1, sizeof **(arg))) == ((struct type_CMIP_MgmtInfo *) 0)) {
1589: advise (NULLCP, "out of memory");
1590: return NOTOK;
1591: }
1592: %}
1593: SEQUENCE {
1594: MgmtInfoId
1595: [[p (PEPYPARM) &((*arg) -> element_CMIP_6)]],
1596:
1597: MgmtInfoValue
1598: [[p (PEPYPARM) &((*arg) -> element_CMIP_7)]]
1599: }
1600:
1601: MgmtInfoId
1602: %{
1603: struct type_CMIP_MgmtInfoId **arg =
1604: (struct type_CMIP_MgmtInfoId **) parm;
1605: %}
1606: ::=
1607: ANY
1608: [[a (*arg)]]
1609:
1610: MgmtInfoValue
1611: %{
1612: struct type_CMIP_MgmtInfoValue **arg =
1613: (struct type_CMIP_MgmtInfoValue **) parm;
1614: %}
1615: ::=
1616: ANY
1617: [[a (*arg)]]
1618:
1619: ActionTypeId
1620: %{
1621: struct type_CMIP_ActionTypeId **arg =
1622: (struct type_CMIP_ActionTypeId **) parm;
1623: %}
1624: ::=
1625: ANY
1626: [[a (*arg)]]
1627:
1628: ActionInfo
1629: %{
1630: struct type_CMIP_ActionInfo **arg =
1631: (struct type_CMIP_ActionInfo **) parm;
1632: %}
1633: ::=
1634: ANY
1635: [[a (*arg)]]
1636:
1637: SpecificErrorInfo
1638: %{
1639: struct type_CMIP_SpecificErrorInfo **arg =
1640: (struct type_CMIP_SpecificErrorInfo **) parm;
1641: %}
1642: ::=
1643: ANY
1644: [[a (*arg)]]
1645:
1646: END
1647:
1648: %{
1649:
1650: free_CMIP_EventReportArgument (arg)
1651: struct type_CMIP_EventReportArgument *arg;
1652: {
1653: if (arg == NULL)
1654: return;
1655:
1656: if (arg -> managedObjectClass)
1657: free_CMIP_ObjectClass (arg -> managedObjectClass),
1658: arg -> managedObjectClass = NULL;
1659: if (arg -> managedObjectInstance)
1660: free_CMIP_ObjectInstance (arg -> managedObjectInstance),
1661: arg -> managedObjectInstance = NULL;
1662: if (arg -> eventType)
1663: free_CMIP_EventTypeID (arg -> eventType),
1664: arg -> eventType = NULL;
1665: if (arg -> eventTime)
1666: free_UNIV_GeneralizedTime (arg -> eventTime),
1667: arg -> eventTime = NULL;
1668: if (arg -> eventInfo)
1669: free_CMIP_EventInfo (arg -> eventInfo),
1670: arg -> eventInfo = NULL;
1671:
1672: if (arg)
1673: free ((char *) arg);
1674: }
1675:
1676: free_CMIP_EventReportResult (arg)
1677: struct type_CMIP_EventReportResult *arg;
1678: {
1679: if (arg == NULL)
1680: return;
1681:
1682:
1683: if (arg)
1684: free ((char *) arg);
1685: }
1686:
1687: free_CMIP_LinkedReplyArgument (arg)
1688: struct type_CMIP_LinkedReplyArgument *arg;
1689: {
1690: if (arg == NULL)
1691: return;
1692:
1693: switch (arg -> offset) {
1694: case type_CMIP_LinkedReplyArgument_getResult:
1695: if (arg -> un.getResult)
1696: free_CMIP_GetResult (arg -> un.getResult),
1697: arg -> un.getResult = NULL;
1698: break;
1699:
1700: case type_CMIP_LinkedReplyArgument_getError:
1701: if (arg -> un.getError)
1702: free_CMIP_GetListError (arg -> un.getError),
1703: arg -> un.getError = NULL;
1704: break;
1705:
1706: case type_CMIP_LinkedReplyArgument_setResult:
1707: if (arg -> un.setResult)
1708: free_CMIP_SetResult (arg -> un.setResult),
1709: arg -> un.setResult = NULL;
1710: break;
1711:
1712: case type_CMIP_LinkedReplyArgument_setError:
1713: if (arg -> un.setError)
1714: free_CMIP_SetListError (arg -> un.setError),
1715: arg -> un.setError = NULL;
1716: break;
1717:
1718: case type_CMIP_LinkedReplyArgument_actionResult:
1719: if (arg -> un.actionResult)
1720: free_CMIP_ActionResult (arg -> un.actionResult),
1721: arg -> un.actionResult = NULL;
1722: break;
1723: }
1724:
1725: if (arg)
1726: free ((char *) arg);
1727: }
1728:
1729: free_CMIP_GetArgument (arg)
1730: struct type_CMIP_GetArgument *arg;
1731: {
1732: if (arg == NULL)
1733: return;
1734:
1735: if (arg -> managedObjectClass)
1736: free_CMIP_ObjectClass (arg -> managedObjectClass),
1737: arg -> managedObjectClass = NULL;
1738: if (arg -> managedObjectInstance)
1739: free_CMIP_ObjectInstance (arg -> managedObjectInstance),
1740: arg -> managedObjectInstance = NULL;
1741: if (arg -> accessControl)
1742: free_CMIP_AccessControl (arg -> accessControl),
1743: arg -> accessControl = NULL;
1744: if (arg -> synchronization)
1745: free_CMIP_CMISSync (arg -> synchronization),
1746: arg -> synchronization = NULL;
1747: if (arg -> filter)
1748: free_CMIP_CMISFilter (arg -> filter),
1749: arg -> filter = NULL;
1750: {
1751: struct element_CMIP_0 *element_CMIP_0;
1752:
1753: for (element_CMIP_0 = arg -> element_CMIP_0;
1754: element_CMIP_0;
1755: element_CMIP_0 = element_CMIP_0 -> next) {
1756: if (element_CMIP_0 -> MgmtInfoId)
1757: free_CMIP_MgmtInfoId (element_CMIP_0 -> MgmtInfoId),
1758: element_CMIP_0 -> MgmtInfoId = NULL;
1759:
1760: if (element_CMIP_0)
1761: free ((char *) element_CMIP_0);
1762: }
1763:
1764: arg -> element_CMIP_0 = NULL;
1765: }
1766:
1767: if (arg)
1768: free ((char *) arg);
1769: }
1770:
1771: free_CMIP_GetResult (arg)
1772: struct type_CMIP_GetResult *arg;
1773: {
1774: if (arg == NULL)
1775: return;
1776:
1777: if (arg -> managedObjectClass)
1778: free_CMIP_ObjectClass (arg -> managedObjectClass),
1779: arg -> managedObjectClass = NULL;
1780: if (arg -> managedObjectInstance)
1781: free_CMIP_ObjectInstance (arg -> managedObjectInstance),
1782: arg -> managedObjectInstance = NULL;
1783: if (arg -> currentTime)
1784: free_UNIV_GeneralizedTime (arg -> currentTime),
1785: arg -> currentTime = NULL;
1786: {
1787: struct element_CMIP_1 *element_CMIP_1;
1788:
1789: for (element_CMIP_1 = arg -> element_CMIP_1;
1790: element_CMIP_1;
1791: element_CMIP_1 = element_CMIP_1 -> next) {
1792: if (element_CMIP_1 -> MgmtInfo)
1793: free_CMIP_MgmtInfo (element_CMIP_1 -> MgmtInfo),
1794: element_CMIP_1 -> MgmtInfo = NULL;
1795:
1796: if (element_CMIP_1)
1797: free ((char *) element_CMIP_1);
1798: }
1799:
1800: arg -> element_CMIP_1 = NULL;
1801: }
1802:
1803: if (arg)
1804: free ((char *) arg);
1805: }
1806:
1807: free_CMIP_SetArgument (arg)
1808: struct type_CMIP_SetArgument *arg;
1809: {
1810: if (arg == NULL)
1811: return;
1812:
1813: if (arg -> managedObjectClass)
1814: free_CMIP_ObjectClass (arg -> managedObjectClass),
1815: arg -> managedObjectClass = NULL;
1816: if (arg -> managedObjectInstance)
1817: free_CMIP_ObjectInstance (arg -> managedObjectInstance),
1818: arg -> managedObjectInstance = NULL;
1819: if (arg -> accessControl)
1820: free_CMIP_AccessControl (arg -> accessControl),
1821: arg -> accessControl = NULL;
1822: if (arg -> synchronization)
1823: free_CMIP_CMISSync (arg -> synchronization),
1824: arg -> synchronization = NULL;
1825: if (arg -> filter)
1826: free_CMIP_CMISFilter (arg -> filter),
1827: arg -> filter = NULL;
1828: {
1829: struct element_CMIP_2 *element_CMIP_2;
1830:
1831: for (element_CMIP_2 = arg -> element_CMIP_2;
1832: element_CMIP_2;
1833: element_CMIP_2 = element_CMIP_2 -> next) {
1834: if (element_CMIP_2 -> MgmtInfo)
1835: free_CMIP_MgmtInfo (element_CMIP_2 -> MgmtInfo),
1836: element_CMIP_2 -> MgmtInfo = NULL;
1837:
1838: if (element_CMIP_2)
1839: free ((char *) element_CMIP_2);
1840: }
1841:
1842: arg -> element_CMIP_2 = NULL;
1843: }
1844:
1845: if (arg)
1846: free ((char *) arg);
1847: }
1848:
1849: free_CMIP_SetResult (arg)
1850: struct type_CMIP_SetResult *arg;
1851: {
1852: if (arg == NULL)
1853: return;
1854:
1855: if (arg -> managedObjectClass)
1856: free_CMIP_ObjectClass (arg -> managedObjectClass),
1857: arg -> managedObjectClass = NULL;
1858: if (arg -> managedObjectInstance)
1859: free_CMIP_ObjectInstance (arg -> managedObjectInstance),
1860: arg -> managedObjectInstance = NULL;
1861: if (arg -> currentTime)
1862: free_UNIV_GeneralizedTime (arg -> currentTime),
1863: arg -> currentTime = NULL;
1864: {
1865: struct element_CMIP_3 *element_CMIP_3;
1866:
1867: for (element_CMIP_3 = arg -> element_CMIP_3;
1868: element_CMIP_3;
1869: element_CMIP_3 = element_CMIP_3 -> next) {
1870: if (element_CMIP_3 -> MgmtInfo)
1871: free_CMIP_MgmtInfo (element_CMIP_3 -> MgmtInfo),
1872: element_CMIP_3 -> MgmtInfo = NULL;
1873:
1874: if (element_CMIP_3)
1875: free ((char *) element_CMIP_3);
1876: }
1877:
1878: arg -> element_CMIP_3 = NULL;
1879: }
1880:
1881: if (arg)
1882: free ((char *) arg);
1883: }
1884:
1885: free_CMIP_ActionArgument (arg)
1886: struct type_CMIP_ActionArgument *arg;
1887: {
1888: if (arg == NULL)
1889: return;
1890:
1891: if (arg -> managedObjectClass)
1892: free_CMIP_ObjectClass (arg -> managedObjectClass),
1893: arg -> managedObjectClass = NULL;
1894: if (arg -> managedObjectInstance)
1895: free_CMIP_ObjectInstance (arg -> managedObjectInstance),
1896: arg -> managedObjectInstance = NULL;
1897: if (arg -> accessControl)
1898: free_CMIP_AccessControl (arg -> accessControl),
1899: arg -> accessControl = NULL;
1900: if (arg -> filter)
1901: free_CMIP_CMISFilter (arg -> filter),
1902: arg -> filter = NULL;
1903: if (arg -> actionType)
1904: free_CMIP_ActionTypeId (arg -> actionType),
1905: arg -> actionType = NULL;
1906: if (arg -> actionInfo)
1907: free_CMIP_ActionInfo (arg -> actionInfo),
1908: arg -> actionInfo = NULL;
1909:
1910: if (arg)
1911: free ((char *) arg);
1912: }
1913:
1914: free_CMIP_ActionResult (arg)
1915: struct type_CMIP_ActionResult *arg;
1916: {
1917: if (arg == NULL)
1918: return;
1919:
1920: if (arg -> managedObjectClass)
1921: free_CMIP_ObjectClass (arg -> managedObjectClass),
1922: arg -> managedObjectClass = NULL;
1923: if (arg -> managedObjectInstance)
1924: free_CMIP_ObjectInstance (arg -> managedObjectInstance),
1925: arg -> managedObjectInstance = NULL;
1926: if (arg -> currentTime)
1927: free_UNIV_GeneralizedTime (arg -> currentTime),
1928: arg -> currentTime = NULL;
1929: if (arg -> actionResult)
1930: free_CMIP_MgmtInfo (arg -> actionResult),
1931: arg -> actionResult = NULL;
1932:
1933: if (arg)
1934: free ((char *) arg);
1935: }
1936:
1937: free_CMIP_GetListError (arg)
1938: struct type_CMIP_GetListError *arg;
1939: {
1940: if (arg == NULL)
1941: return;
1942:
1943: if (arg -> managedObjectClass)
1944: free_CMIP_ObjectClass (arg -> managedObjectClass),
1945: arg -> managedObjectClass = NULL;
1946: if (arg -> managedObjectInstance)
1947: free_CMIP_ObjectInstance (arg -> managedObjectInstance),
1948: arg -> managedObjectInstance = NULL;
1949: if (arg -> currentTime)
1950: free_UNIV_GeneralizedTime (arg -> currentTime),
1951: arg -> currentTime = NULL;
1952: {
1953: struct element_CMIP_4 *element_CMIP_4;
1954:
1955: for (element_CMIP_4 = arg -> element_CMIP_4;
1956: element_CMIP_4;
1957: element_CMIP_4 = element_CMIP_4 -> next) {
1958: if (element_CMIP_4 -> MISGetInfoStatus)
1959: free_CMIP_MISGetInfoStatus (element_CMIP_4 -> MISGetInfoStatus),
1960: element_CMIP_4 -> MISGetInfoStatus = NULL;
1961:
1962: if (element_CMIP_4)
1963: free ((char *) element_CMIP_4);
1964: }
1965:
1966: arg -> element_CMIP_4 = NULL;
1967: }
1968:
1969: if (arg)
1970: free ((char *) arg);
1971: }
1972:
1973: free_CMIP_MISGetInfoStatus (arg)
1974: struct type_CMIP_MISGetInfoStatus *arg;
1975: {
1976: if (arg == NULL)
1977: return;
1978:
1979: switch (arg -> offset) {
1980: case type_CMIP_MISGetInfoStatus_mgmtInfoIdError:
1981: if (arg -> un.mgmtInfoIdError)
1982: free_CMIP_MgmtInfoIdError (arg -> un.mgmtInfoIdError),
1983: arg -> un.mgmtInfoIdError = NULL;
1984: break;
1985:
1986: case type_CMIP_MISGetInfoStatus_mgmtInfo:
1987: if (arg -> un.mgmtInfo)
1988: free_CMIP_MgmtInfo (arg -> un.mgmtInfo),
1989: arg -> un.mgmtInfo = NULL;
1990: break;
1991: }
1992:
1993: if (arg)
1994: free ((char *) arg);
1995: }
1996:
1997: free_CMIP_MgmtInfoIdError (arg)
1998: struct type_CMIP_MgmtInfoIdError *arg;
1999: {
2000: if (arg == NULL)
2001: return;
2002:
2003: if (arg -> errorStatus)
2004: free_CMIP_ErrorStatus (arg -> errorStatus),
2005: arg -> errorStatus = NULL;
2006: if (arg -> mgmtInfoId)
2007: free_CMIP_MgmtInfoId (arg -> mgmtInfoId),
2008: arg -> mgmtInfoId = NULL;
2009:
2010: if (arg)
2011: free ((char *) arg);
2012: }
2013:
2014: free_CMIP_SetListError (arg)
2015: struct type_CMIP_SetListError *arg;
2016: {
2017: if (arg == NULL)
2018: return;
2019:
2020: if (arg -> managedObjectClass)
2021: free_CMIP_ObjectClass (arg -> managedObjectClass),
2022: arg -> managedObjectClass = NULL;
2023: if (arg -> managedObjectInstance)
2024: free_CMIP_ObjectInstance (arg -> managedObjectInstance),
2025: arg -> managedObjectInstance = NULL;
2026: if (arg -> currentTime)
2027: free_UNIV_GeneralizedTime (arg -> currentTime),
2028: arg -> currentTime = NULL;
2029: {
2030: struct element_CMIP_5 *element_CMIP_5;
2031:
2032: for (element_CMIP_5 = arg -> element_CMIP_5;
2033: element_CMIP_5;
2034: element_CMIP_5 = element_CMIP_5 -> next) {
2035: if (element_CMIP_5 -> MISSetInfoStatus)
2036: free_CMIP_MISSetInfoStatus (element_CMIP_5 -> MISSetInfoStatus),
2037: element_CMIP_5 -> MISSetInfoStatus = NULL;
2038:
2039: if (element_CMIP_5)
2040: free ((char *) element_CMIP_5);
2041: }
2042:
2043: arg -> element_CMIP_5 = NULL;
2044: }
2045:
2046: if (arg)
2047: free ((char *) arg);
2048: }
2049:
2050: free_CMIP_MISSetInfoStatus (arg)
2051: struct type_CMIP_MISSetInfoStatus *arg;
2052: {
2053: if (arg == NULL)
2054: return;
2055:
2056: switch (arg -> offset) {
2057: case type_CMIP_MISSetInfoStatus_mgmtInfoError:
2058: if (arg -> un.mgmtInfoError)
2059: free_CMIP_MgmtInfoError (arg -> un.mgmtInfoError),
2060: arg -> un.mgmtInfoError = NULL;
2061: break;
2062:
2063: case type_CMIP_MISSetInfoStatus_mgmtInfo:
2064: if (arg -> un.mgmtInfo)
2065: free_CMIP_MgmtInfo (arg -> un.mgmtInfo),
2066: arg -> un.mgmtInfo = NULL;
2067: break;
2068: }
2069:
2070: if (arg)
2071: free ((char *) arg);
2072: }
2073:
2074: free_CMIP_MgmtInfoError (arg)
2075: struct type_CMIP_MgmtInfoError *arg;
2076: {
2077: if (arg == NULL)
2078: return;
2079:
2080: if (arg -> errorStatus)
2081: free_CMIP_ErrorStatus (arg -> errorStatus),
2082: arg -> errorStatus = NULL;
2083: if (arg -> mgmtInfo)
2084: free_CMIP_MgmtInfo (arg -> mgmtInfo),
2085: arg -> mgmtInfo = NULL;
2086:
2087: if (arg)
2088: free ((char *) arg);
2089: }
2090:
2091: free_CMIP_ErrorStatus (arg)
2092: struct type_CMIP_ErrorStatus *arg;
2093: {
2094: if (arg == NULL)
2095: return;
2096:
2097:
2098: if (arg)
2099: free ((char *) arg);
2100: }
2101:
2102: free_CMIP_ProcessingFailure (arg)
2103: struct type_CMIP_ProcessingFailure *arg;
2104: {
2105: if (arg == NULL)
2106: return;
2107:
2108: switch (arg -> offset) {
2109: case type_CMIP_ProcessingFailure_actual:
2110: if (arg -> un.actual)
2111: free_CMIP_SpecificErrorInfo (arg -> un.actual),
2112: arg -> un.actual = NULL;
2113: break;
2114:
2115: case type_CMIP_ProcessingFailure_none:
2116: break;
2117: }
2118:
2119: if (arg)
2120: free ((char *) arg);
2121: }
2122:
2123: free_CMIP_ObjectClass (arg)
2124: struct type_CMIP_ObjectClass *arg;
2125: {
2126: if (arg == NULL)
2127: return;
2128:
2129: switch (arg -> offset) {
2130: case type_CMIP_ObjectClass_globalForm:
2131: if (arg -> un.globalForm)
2132: oid_free (arg -> un.globalForm),
2133: arg -> un.globalForm = NULLOID;
2134: break;
2135:
2136: case type_CMIP_ObjectClass_nonSpecificForm:
2137: if (arg -> un.nonSpecificForm)
2138: qb_free (arg -> un.nonSpecificForm),
2139: arg -> un.nonSpecificForm = NULL;
2140: break;
2141: }
2142:
2143: if (arg)
2144: free ((char *) arg);
2145: }
2146:
2147: free_CMIP_ObjectInstance (arg)
2148: struct type_CMIP_ObjectInstance *arg;
2149: {
2150: if (arg == NULL)
2151: return;
2152:
2153: switch (arg -> offset) {
2154: case type_CMIP_ObjectInstance_distinguishedName:
2155: if (arg -> un.distinguishedName)
2156: free_CMIP_DistinguishedName (arg -> un.distinguishedName),
2157: arg -> un.distinguishedName = NULL;
2158: break;
2159:
2160: case type_CMIP_ObjectInstance_nonSpecificForm:
2161: if (arg -> un.nonSpecificForm)
2162: qb_free (arg -> un.nonSpecificForm),
2163: arg -> un.nonSpecificForm = NULL;
2164: break;
2165:
2166: case type_CMIP_ObjectInstance_enumeratedForm:
2167: break;
2168: }
2169:
2170: if (arg)
2171: free ((char *) arg);
2172: }
2173:
2174: free_CMIP_CMISSync (arg)
2175: struct type_CMIP_CMISSync *arg;
2176: {
2177: if (arg == NULL)
2178: return;
2179:
2180:
2181: if (arg)
2182: free ((char *) arg);
2183: }
2184:
2185: free_CMIP_CMISFilter (arg)
2186: struct type_CMIP_CMISFilter *arg;
2187: {
2188: if (arg == NULL)
2189: return;
2190:
2191: switch (arg -> offset) {
2192: case type_CMIP_CMISFilter_item:
2193: if (arg -> un.item)
2194: free_CMIP_FilterItem (arg -> un.item),
2195: arg -> un.item = NULL;
2196: break;
2197:
2198: case type_CMIP_CMISFilter_and:
2199: {
2200: struct member_CMIP_0 *member_CMIP_0;
2201:
2202: for (member_CMIP_0 = arg -> un.member_CMIP_0;
2203: member_CMIP_0;
2204: member_CMIP_0 = member_CMIP_0 -> next) {
2205: if (member_CMIP_0 -> CMISFilter)
2206: free_CMIP_CMISFilter (member_CMIP_0 -> CMISFilter),
2207: member_CMIP_0 -> CMISFilter = NULL;
2208:
2209: if (member_CMIP_0)
2210: free ((char *) member_CMIP_0);
2211: }
2212:
2213: arg -> un.member_CMIP_0 = NULL;
2214: }
2215: break;
2216:
2217: case type_CMIP_CMISFilter_or:
2218: {
2219: struct member_CMIP_1 *member_CMIP_1;
2220:
2221: for (member_CMIP_1 = arg -> un.member_CMIP_1;
2222: member_CMIP_1;
2223: member_CMIP_1 = member_CMIP_1 -> next) {
2224: if (member_CMIP_1 -> CMISFilter)
2225: free_CMIP_CMISFilter (member_CMIP_1 -> CMISFilter),
2226: member_CMIP_1 -> CMISFilter = NULL;
2227:
2228: if (member_CMIP_1)
2229: free ((char *) member_CMIP_1);
2230: }
2231:
2232: arg -> un.member_CMIP_1 = NULL;
2233: }
2234: break;
2235:
2236: case type_CMIP_CMISFilter_not:
2237: if (arg -> un.not)
2238: free_CMIP_CMISFilter (arg -> un.not),
2239: arg -> un.not = NULL;
2240: break;
2241: }
2242:
2243: if (arg)
2244: free ((char *) arg);
2245: }
2246:
2247: free_CMIP_FilterItem (arg)
2248: struct type_CMIP_FilterItem *arg;
2249: {
2250: if (arg == NULL)
2251: return;
2252:
2253: switch (arg -> offset) {
2254: case type_CMIP_FilterItem_equality:
2255: if (arg -> un.equality)
2256: free_CMIP_MgmtInfo (arg -> un.equality),
2257: arg -> un.equality = NULL;
2258: break;
2259:
2260: case type_CMIP_FilterItem_greaterOrEqual:
2261: if (arg -> un.greaterOrEqual)
2262: free_CMIP_MgmtInfo (arg -> un.greaterOrEqual),
2263: arg -> un.greaterOrEqual = NULL;
2264: break;
2265:
2266: case type_CMIP_FilterItem_lessOrEqual:
2267: if (arg -> un.lessOrEqual)
2268: free_CMIP_MgmtInfo (arg -> un.lessOrEqual),
2269: arg -> un.lessOrEqual = NULL;
2270: break;
2271:
2272: case type_CMIP_FilterItem_present:
2273: if (arg -> un.present)
2274: free_CMIP_MgmtInfoID (arg -> un.present),
2275: arg -> un.present = NULL;
2276: break;
2277: }
2278:
2279: if (arg)
2280: free ((char *) arg);
2281: }
2282:
2283: free_CMIP_MgmtInfo (arg)
2284: struct type_CMIP_MgmtInfo *arg;
2285: {
2286: if (arg == NULL)
2287: return;
2288:
2289: if (arg -> element_CMIP_6)
2290: free_CMIP_MgmtInfoId (arg -> element_CMIP_6),
2291: arg -> element_CMIP_6 = NULL;
2292: if (arg -> element_CMIP_7)
2293: free_CMIP_MgmtInfoValue (arg -> element_CMIP_7),
2294: arg -> element_CMIP_7 = NULL;
2295:
2296: if (arg)
2297: free ((char *) arg);
2298: }
2299:
2300: %}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.