DataMuseum.dk

top - metrics - download

    Length: 38775 (0x9777)
    Types: TextFile
    Names: »msap.py«

└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
    └─⟦e83f91978⟧ »EurOpenD22/isode/osimis-2.0.tar.Z« 
        └─⟦d846658bd⟧ 
            └─⟦this⟧ »osimis/msap/msap.py« 

TextFile

--
-- Copyright (c) 1988 University College London
-- All rights reserved.
--
-- Redistribution and use in source and binary forms are permitted
-- provided that the above copyright notice and this paragraph are
-- duplicated in all such forms and that any documentation,
-- advertising materials, and other materials related to such
-- distribution and use acknowledge that the software was developed
-- by the Department of Computer Science, University College London.
-- The name of the University may not be used to
-- endorse or promote products derived from this software without
-- specific prior written permission.
-- THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
-- IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-- WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
--

-- msap.py - pepy source for CMIP

-- By George Pavlou, April 1990


CMIP	-- ISO 9596-CMIP
{ joint-iso-ccitt ms(9) cmip(1) version1(1) protocol(3) }
DEFINITIONS ::=

%{
#include <stdio.h>
#include <isode/rosap.h>
#include "msap.h"

#define encode_UNIV_GeneralizedTime	build_UNIV_GeneralizedTime
#define decode_UNIV_GeneralizedTime	parse_UNIV_GeneralizedTime

#define PEPYPARM pepyparm
/* LINTLIBRARY */
%}

PREFIXES encode decode print

BEGIN

-- Directory Service Definitions

IMPORTS DistinguishedName, RDNSequence FROM IF
{ joint-iso-ccitt ds(5) modules(1) informationFramework(1) };


ENCODER build

ObjectClass [[P MID]] ::= CHOICE << parm -> mid_type + 1 >>
	{
	globalForm	[0] IMPLICIT OBJECT IDENTIFIER [[O parm -> mid_global]],
	localForm	[1] IMPLICIT INTEGER [[i parm -> mid_local]]
	}

DECODER parse

ObjectClass [[P MID]] ::= CHOICE
	{
	globalForm	[0] IMPLICIT OBJECT IDENTIFIER [[O parm -> mid_global]]
			%{ parm -> mid_type = MID_GLOBAL; %},
	localForm	[1] IMPLICIT INTEGER [[i parm -> mid_local]]
			%{ parm -> mid_type = MID_LOCAL; %}
	}

ENCODER build

ObjectInstance [[P MN]] ::= CHOICE << parm -> mn_type == MN_DN ? 1 :
				     (parm -> mn_type == MN_LOCALDN ? 3 : 2) >>
	{
	distinguishedName	[2] IMPLICIT DistinguishedName
						[[p parm -> mn_dn]],
	nonSpecificForm		[3] IMPLICIT OCTET STRING
						[[s parm -> mn_nonspec]],
	localDistinguishedName	[4] IMPLICIT RDNSequence
						[[p parm -> mn_dn]]
	}

DECODER parse

ObjectInstance [[P MN]] ::= CHOICE
	{
	distinguishedName	[2] IMPLICIT DistinguishedName
						[[p &parm -> mn_dn]]
				%{ parm -> mn_type = MN_DN; %},
	nonSpecificForm		[3] IMPLICIT OCTET STRING
						[[s parm -> mn_nonspec]]
				%{ parm -> mn_type = MN_NONSPEC; %},
	localDistinguishedName	[4] IMPLICIT RDNSequence
						[[p &parm -> mn_dn]]
				%{ parm -> mn_type = MN_LOCALDN; %}
	}

SECTIONS build parse none

BaseManagedObjectId [[P CMISerrparam *]] ::= SEQUENCE
	{
	baseManagedObjectClass	ObjectClass [[p &parm -> me_class]],
	baseManagedObjectInstance  ObjectInstance [[p &parm -> me_inst]]
	}

ENCODER build

AccessControl [[P External *]] ::= EXTERNAL [[p parm]]

DECODER parse

AccessControl [[P External **]] ::= EXTERNAL [[p parm]]

SECTIONS build parse none

CMISSync [[P int *]] ::= ENUMERATED [[i *parm]]
	{
	bestEffort	(0),
	atomic		(1)
	}

ModifyOperator [[P int *]] ::= ENUMERATED [[i *parm]]
	{
	replace		(0),
	addValues	(1),
	removeValues	(2),
	setToDefault	(3)
	}

ENCODER build

Scope [[P Scope *]] ::= CHOICE
	<< parm -> sc_type == Sc_BaseToNthLevel ? 3 :
	  (parm -> sc_type == Sc_IndividualLevel ? 2 : 1) >>
	{
	INTEGER [[i parm -> sc_type]]
		{ baseObject (0),
	 	  firstLevelOnly (1),
	  	  wholeSubtree (2) },
	individualLevels	[1] IMPLICIT INTEGER [[i parm -> sc_level]],
	baseToNthLevel		[2] IMPLICIT INTEGER [[i parm -> sc_level]]
	}
	
DECODER parse

Scope [[P Scope *]] ::= CHOICE
	{
	INTEGER [[i parm -> sc_type]]
		{ baseObject (0),
	 	  firstLevelOnly (1),
	  	  wholeSubtree (2) },
	individualLevels	[1] IMPLICIT INTEGER [[i parm -> sc_level]]
	%{ parm -> sc_type = Sc_IndividualLevel; %},
	baseToNthLevel		[2] IMPLICIT INTEGER [[i parm -> sc_level]]
	%{ parm -> sc_type = Sc_BaseToNthLevel; %}
	}
	
ENCODER build

CMISFilter [[P CMISfilter *]] %{ CMISfilter * this; %}
	::= CHOICE
	<< parm -> flt_type + 1 >>
	{
	item		[8] FilterItem [[p parm -> flt_item]],
	and		[9] IMPLICIT SET OF
			<< this = parm -> flt_filter; this;
						this = this -> flt_next >>
			CMISFilter [[p this]],
	or		[10] IMPLICIT SET OF
			<< this = parm -> flt_filter; this;
						this = this -> flt_next >>
			CMISFilter [[p this]],
	not		[11] CMISFilter [[p parm -> flt_filter]]
	}

DECODER parse

CMISFilter [[P CMISfilter **]] %{ CMISfilter **this; %}
	::= CHOICE
	%{ if ((*parm = (CMISfilter *) calloc(1, sizeof(CMISfilter))) == NULL)
	   	return NOTOK; %}
	{
	item		[8] FilterItem [[p &(*parm) -> flt_item]]
			%{ (*parm) -> flt_type = Filter_Item; %},
	and		[9] IMPLICIT SET OF
			%{ this = parm; %}
			CMISFilter [[p &(*this) -> flt_filter]]
			%{ (*this) -> flt_type = Filter_And;
			   this = &(*this) -> flt_next; %},
	or		[10] IMPLICIT SET OF
			%{ this = parm; %}
			CMISFilter [[p &(*this) -> flt_filter]]
			%{ (*this) -> flt_type = Filter_Or;
			   this = &(*this) -> flt_next; %},
	not		[11] CMISFilter [[p &(*parm) -> flt_filter]]
			%{ (*parm) -> flt_type = Filter_Not; %}
	}

ENCODER build

FilterItem [[P FilterItem *]] %{ FilterSubstrings *this; PE string; %}
	::= CHOICE
	<< parm -> fi_type + 1 >>
	{
	equality	[0] IMPLICIT Attribute [[p &parm -> fi_attr]],
	substrings	[1] IMPLICIT SEQUENCE OF
			<< this = parm -> fi_substrings; this;
						this = this -> fi_sub_next >>
			CHOICE
			%{ string = oct2prim(this -> fi_sub_string,
					strlen(this -> fi_sub_string)); %}
			<< this -> fi_sub_type + 1 >>
			{
			initialString		[0] IMPLICIT SEQUENCE {
				attributeId	AttributeId
						[[p &this -> fi_sub_attrid]],
				string		ANY DEFINED BY attributeId
						[[a string]] },
			anyString		[1] IMPLICIT SEQUENCE {
				attributeId	AttributeId
						[[p &this -> fi_sub_attrid]],
				string		ANY DEFINED BY attributeId
						[[a string]] },
			finalString		[2] IMPLICIT SEQUENCE {
				attributeId	AttributeId
						[[p &this -> fi_sub_attrid]],
				string		ANY DEFINED BY attributeId
						[[a string]] }
			}
			%{ pe_free(string); %},
	greaterOrEqual  [2] IMPLICIT Attribute [[p &parm -> fi_attr]],
	lessOrEqual	[3] IMPLICIT Attribute [[p &parm -> fi_attr]],
	present		[4] AttributeId [[p &parm -> fi_attr.mp_id]],
	subsetOf	[5] IMPLICIT Attribute [[p &parm -> fi_attr]],
	supersetOf	[6] IMPLICIT Attribute [[p &parm -> fi_attr]],
	nonNullIntersection [7] IMPLICIT Attribute [[p &parm -> fi_attr]]
	}

DECODER parse

FilterItem [[P FilterItem **]]
	%{ FilterSubstrings **this; PE string; int stringlen; %}
	::= CHOICE
	%{ if ((*parm = (FilterItem *) calloc(1, sizeof(FilterItem))) == NULL)
	   	return NOTOK; %}
	{
	equality	[0] IMPLICIT Attribute [[p &(*parm) -> fi_attr]]
			%{ (*parm) -> fi_type = FI_Equality; %},
	substrings	[1] %{ this = &(*parm) -> fi_substrings; %}
			IMPLICIT SEQUENCE OF
			%{ if ((*this = (FilterSubstrings *)
				 calloc(1, sizeof(FilterSubstrings))) == NULL)
			       return NOTOK; %}
			CHOICE
			{
			initialString		[0] IMPLICIT SEQUENCE {
				attributeId	AttributeId
						[[p &(*this) -> fi_sub_attrid]],
				string		ANY DEFINED BY attributeId
						%{ string = pe_cpy($$); %}
				}
			%{ (*this) -> fi_sub_type = FI_Substring_Initial; %},
			anyString		[1] IMPLICIT SEQUENCE {
				attributeId	AttributeId
						[[p &(*this) -> fi_sub_attrid]],
				string		ANY DEFINED BY attributeId
						%{ string = pe_cpy($$); %}
				}
			%{ (*this) -> fi_sub_type = FI_Substring_Any; %},
			finalString		[2] IMPLICIT SEQUENCE {
				attributeId	AttributeId
						[[p &(*this) -> fi_sub_attrid]],
				string		ANY DEFINED BY attributeId
						%{ string = pe_cpy($$); %}
				}
			%{ (*this) -> fi_sub_type = FI_Substring_Final; %}
			}
			%{ (*this) -> fi_sub_string =
					prim2str(string, &stringlen);
			   pe_free(string);
			   this = &(*this) -> fi_sub_next; %},
	greaterOrEqual  [2] IMPLICIT Attribute [[p &(*parm) -> fi_attr]]
			%{ (*parm) -> fi_type = FI_GreaterOrEqual; %},
	lessOrEqual	[3] IMPLICIT Attribute [[p &(*parm) -> fi_attr]]
			%{ (*parm) -> fi_type = FI_LessOrEqual; %},
	present		[4] AttributeId [[p &(*parm) -> fi_attr.mp_id]]
			%{ (*parm) -> fi_type = FI_Present; %},
	subsetOf	[5] IMPLICIT Attribute [[p &(*parm) -> fi_attr]]
			%{ (*parm) -> fi_type = FI_SubsetOf; %},
	supersetOf	[6] IMPLICIT Attribute [[p &(*parm) -> fi_attr]]
			%{ (*parm) -> fi_type = FI_SupersetOf; %},
	nonNullIntersection [7] IMPLICIT Attribute [[p &(*parm) -> fi_attr]]
			%{ (*parm) -> fi_type = FI_NonNullSetIntersect; %}
	}

ENCODER build

AttributeIdList [[P MID]] %{ int nid; %}
	::= SET OF
	<< nid = 0; nid < 1; nid++ >>
	AttributeId [[p parm]]

DECODER parse

AttributeIdList [[P MID]] %{ int nid = 0; MIDent attrid, * this; %}
	::= SET OF
	%{ this = (nid == 0 ? parm : &attrid); %}
	AttributeId [[p this]]
	%{ if (nid && attrid.mid_type == MID_GLOBAL && attrid.mid_global)
	       oid_free(attrid.mid_global);
	   nid++;
	%}

ENCODER build

AttributeId [[P MID]] ::= CHOICE << parm -> mid_type + 1 >>
	{
	globalForm	[0] IMPLICIT OBJECT IDENTIFIER [[O parm -> mid_global]],
	localForm	[1] IMPLICIT INTEGER [[i parm -> mid_local]]
	}

EventTypeId [[P MID]] ::= CHOICE << parm -> mid_type + 1 >>
	{
	globalForm	[6] IMPLICIT OBJECT IDENTIFIER [[O parm -> mid_global]],
	localForm	[7] IMPLICIT INTEGER [[i parm -> mid_local]]
	}

ActionTypeId [[P MID]] ::= CHOICE << parm -> mid_type + 1 >>
	{
	globalForm	[2] IMPLICIT OBJECT IDENTIFIER [[O parm -> mid_global]],
	localForm	[3] IMPLICIT INTEGER [[i parm -> mid_local]]
	}

DECODER parse

AttributeId [[P MID]] ::= CHOICE
	{
	globalForm	[0] IMPLICIT OBJECT IDENTIFIER [[O parm -> mid_global]]
			%{ parm -> mid_type = MID_GLOBAL; %},
	localForm	[1] IMPLICIT INTEGER [[i parm -> mid_local]]
			%{ parm -> mid_type = MID_LOCAL; %}
	}

EventTypeId [[P MID]] ::= CHOICE
	{
	globalForm	[6] IMPLICIT OBJECT IDENTIFIER [[O parm -> mid_global]]
			%{ parm -> mid_type = MID_GLOBAL; %},
	localForm	[7] IMPLICIT INTEGER [[i parm -> mid_local]]
			%{ parm -> mid_type = MID_LOCAL; %}
	}

ActionTypeId [[P MID]] ::= CHOICE
	{
	globalForm	[2] IMPLICIT OBJECT IDENTIFIER [[O parm -> mid_global]]
			%{ parm -> mid_type = MID_GLOBAL; %},
	localForm	[3] IMPLICIT INTEGER [[i parm -> mid_local]]
			%{ parm -> mid_type = MID_LOCAL; %}
	}

ENCODER build

Attribute [[P CMISparam *]] ::= SEQUENCE
	{
	attributeId	AttributeId [[p &parm -> mp_id]],
	attributeValue	ANY DEFINED BY attributeId [[a parm -> mp_val]]
	}

EventReply [[P CMISparam *]] ::= SEQUENCE
	{
	eventType	EventTypeId [[p &parm -> mp_id]],
	eventReplyInfo	[8] ANY DEFINED BY eventType [[a parm -> mp_val]]
			OPTIONAL << parm -> mp_val != NULLPE >>
	}

ActionInfo [[P CMISparam *]] ::= SEQUENCE
	{
	actionType	ActionTypeId [[p &parm -> mp_id]],
	actionInfoArg	[4] ANY DEFINED BY actionType [[a parm -> mp_val]]
			OPTIONAL << parm -> mp_val != NULLPE >>
	}

ActionReply [[P CMISparam *]] ::= SEQUENCE
	{
	actionType	ActionTypeId [[p &parm -> mp_id]],
	actionReplyInfo	[4] ANY DEFINED BY actionType [[a parm -> mp_val]]
	}

DECODER parse

Attribute [[P CMISparam *]] ::= SEQUENCE
	{
	attributeId	AttributeId [[p &parm -> mp_id]],
	attributeValue	ANY DEFINED BY attributeId
			%{ parm -> mp_val = pe_cpy($$); %}
	}

EventReply [[P CMISparam *]] ::= SEQUENCE
	{
	eventType	EventTypeId [[p &parm -> mp_id]],
	eventReplyInfo	[8] ANY DEFINED BY eventType
			%{ parm -> mp_val = pe_cpy($$); %}
			OPTIONAL
	}

ActionInfo [[P CMISparam *]] ::= SEQUENCE
	{
	actionType	ActionTypeId [[p &parm -> mp_id]],
	actionInfoArg	[4] ANY DEFINED BY actionType
			%{ parm -> mp_val = pe_cpy($$); %}
			OPTIONAL
	}

ActionReply [[P CMISparam *]] ::= SEQUENCE
	{
	actionType	ActionTypeId [[p &parm -> mp_id]],
	actionReplyInfo	[4] ANY DEFINED BY actionType
			%{ parm -> mp_val = pe_cpy($$); %}
	}

ENCODER build

AttributeIdError [[P CMISparam *]] ::= SEQUENCE
	{
	errorStatus	ENUMERATED [[i (int) parm -> mp_error - 1]] {
				accessDenied (2),
				noSuchAttribute (5) },
	attributeId	AttributeId [[p &parm -> mp_id]]
	}

DECODER parse

AttributeIdError [[P CMISparam *]] ::= SEQUENCE
	{
	errorStatus	ENUMERATED [[i (int) parm -> mp_error]] {
				accessDenied (2),
				noSuchAttribute (5) }
			%{ ((int) parm -> mp_error)++; %},
	attributeId	AttributeId [[p &parm -> mp_id]]
	}

ENCODER build

AttributeError [[P CMISparam *]] ::= SEQUENCE
	{
	errorStatus	ENUMERATED [[i (int) parm -> mp_error - 1]] {
				accessDenied (2),
				noSuchAttribute (5),
				invalidAttributeValue (6),
				invalidOperation (24),
				invalidOperator (25) },
	attributeId	AttributeId [[p &parm -> mp_id]],
	attributeValue	ANY DEFINED BY attributeId [[a parm -> mp_val]]
	}

DECODER parse

AttributeError [[P CMISparam *]] ::= SEQUENCE
	{
	errorStatus	ENUMERATED [[i (int) parm -> mp_error]] {
				accessDenied (2),
				noSuchAttribute (5),
				invalidAttributeValue (6),
				invalidOperation (24),
				invalidOperator (25) }
			%{ ((int) parm -> mp_error)++; %},
	attributeId	AttributeId [[p &parm -> mp_id]],
	attributeValue	ANY DEFINED BY attributeId
			%{ parm -> mp_val = pe_cpy($$); %}
	}

SECTIONS build parse none

NoSuchAction [[P CMISerrparam *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> me_class]],
	actionType		ActionTypeId [[p &parm -> me_id]]
	}

NoSuchEventType [[P CMISerrparam *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> me_class]],
	eventType		EventTypeId [[p &parm -> me_id]]
	}
  
ENCODER build

NoSuchArgument [[P CMISerrparam *]] ::= CHOICE
	<< parm -> me_operation == M_ACTIONC ? 1 : 2 >>
	{
	actionId	[0] IMPLICIT SEQUENCE
			{
			managedObjectClass ObjectClass [[p &parm -> me_class]]
			OPTIONAL
			<< parm -> me_class.mid_global != NULLOID ||
			   parm -> me_class.mid_type != MID_GLOBAL >>,
			actionType ActionTypeId [[p &parm -> me_id]]
			},
	eventId		[1] IMPLICIT SEQUENCE
			{
			managedObjectClass ObjectClass [[p &parm -> me_class]]
			OPTIONAL
			<< parm -> me_class.mid_global != NULLOID ||
			   parm -> me_class.mid_type != MID_GLOBAL >>,
			eventType EventTypeId [[p &parm -> me_id]]
			}
	}

InvalidArgumentValue [[P CMISerrparam *]] ::= CHOICE
	<< parm -> me_operation == M_ACTIONC ? 1 : 2 >>
	{
	actionValue	[0] IMPLICIT SEQUENCE
			{
			actionType ActionTypeId [[p &parm -> me_id]],
			actionInfoArg [4] ANY DEFINED BY actionType
			[[a parm -> me_val]]
			OPTIONAL << parm -> me_val != NULLPE >>
			},
	eventValue	[1] IMPLICIT SEQUENCE
			{
			eventType EventTypeId [[p &parm -> me_id]],
			eventInfo [8] ANY DEFINED BY eventType
			[[a parm -> me_val]]
			OPTIONAL << parm -> me_val != NULLPE >>
			}
	}

DECODER parse

NoSuchArgument [[P CMISerrparam *]] ::= CHOICE
	{
	actionId	[0] IMPLICIT SEQUENCE
			{
			managedObjectClass ObjectClass [[p &parm -> me_class]]
			OPTIONAL,
			actionType ActionTypeId [[p &parm -> me_id]]
			},
	eventId		[1] IMPLICIT SEQUENCE
			{
			managedObjectClass ObjectClass [[p &parm -> me_class]]
			OPTIONAL,
			eventType EventTypeId [[p &parm -> me_id]]
			}
	}

InvalidArgumentValue [[P CMISerrparam *]] ::= CHOICE
	{
	actionValue	[0] IMPLICIT SEQUENCE
			{
			actionType ActionTypeId [[p &parm -> me_id]],
			actionInfoArg [4] ANY DEFINED BY actionType
			%{ parm -> me_val = pe_cpy($$); %}
			OPTIONAL
			},
	eventValue	[1] IMPLICIT SEQUENCE
			{
			eventType EventTypeId [[p &parm -> me_id]],
			eventInfo [8] ANY DEFINED BY eventType
			%{ parm -> me_val = pe_cpy($$); %}
			OPTIONAL
			}
	}

ENCODER build

ComplexityLimitation [[P CMISerrparam *]] ::= SET
	{
	scope	[0] Scope [[p &parm -> me_scope]]
		OPTIONAL << parm -> me_scope.sc_type != Sc_BaseObject >>,
	filter	[1] CMISFilter [[p parm -> me_filter]]
		OPTIONAL << parm -> me_filter != NULLFILTER >>,
	sync	[2] CMISSync [[p (int *) &parm -> me_sync]]
		OPTIONAL << parm -> me_sync != s_bestEffort >>
	}

ProcessingFailure [[P CMISerrparam *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> me_class]],
	managedObjectInstance	ObjectInstance [[p &parm -> me_inst]] OPTIONAL
				<< parm -> me_inst.mn_dn != NULLDN ||
				   parm -> me_inst.mn_type != MN_DN >>,
	specificErrorInfo	[6] ANY DEFINED BY managedObjectClass
				[[a parm -> me_val]]
	}

DECODER parse

ComplexityLimitation [[P CMISerrparam *]] ::= SET
	{
	scope	[0] Scope [[p &parm -> me_scope]]
		OPTIONAL,
	filter	[1] CMISFilter [[p &parm -> me_filter]]
		OPTIONAL,
	sync	[2] CMISSync [[p (int *) &parm -> me_sync]]
		OPTIONAL
	}

ProcessingFailure [[P CMISerrparam *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> me_class]],
	managedObjectInstance	ObjectInstance [[p &parm -> me_inst]] OPTIONAL,
	specificErrorInfo	[6] ANY DEFINED BY managedObjectClass
				%{ parm -> me_val = pe_cpy($$); %}
	}

ENCODER build

GetInfoStatus [[P CMISparam *]] ::= CHOICE
	<< parm -> mp_error == m_noError ? 2 : 1 >>
	{
	attributeIdError	[0] IMPLICIT AttributeIdError [[p parm]],
	attribute		[1] IMPLICIT Attribute [[p parm]]
	}

SetInfoStatus [[P CMISparam *]] ::= CHOICE
	<< parm -> mp_error == m_noError ? 2 : 1 >>
	{
	attributeError		[0] IMPLICIT AttributeError [[p parm]],
	attribute		[1] IMPLICIT Attribute [[p parm]]
	}

DECODER parse

GetInfoStatus [[P CMISparam *]] ::= CHOICE
	{
	attributeIdError	[0] IMPLICIT AttributeIdError [[p parm]]
				%{ parm -> mp_val = NULLPE; %},
	attribute		[1] IMPLICIT Attribute [[p parm]]
				%{ parm -> mp_error = m_noError; %}
	}

SetInfoStatus [[P CMISparam *]] ::= CHOICE
	{
	attributeError		[0] IMPLICIT AttributeError [[p parm]],
	attribute		[1] IMPLICIT Attribute [[p parm]]
				%{ parm -> mp_error = m_noError; %}
	}

ENCODER build

EventReportArgument [[P struct event_rep_arg *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> ea_class]],
	managedObjectInstance	ObjectInstance [[p &parm -> ea_inst]],
	eventTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> ea_time]]
				OPTIONAL << parm -> ea_time != NULLCP >>,
	eventType		EventTypeId [[p &parm -> ea_type]],
	eventInfo		[8] ANY DEFINED BY eventType
				[[a parm -> ea_info]]
				OPTIONAL << parm -> ea_info != NULLPE >>
	}

DECODER parse

EventReportArgument [[P struct event_rep_arg *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> ea_class]],
	managedObjectInstance	ObjectInstance [[p &parm -> ea_inst]],
	eventTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> ea_time]] OPTIONAL,
	eventType		EventTypeId [[p &parm -> ea_type]],
	eventInfo		[8] ANY DEFINED BY eventType
				%{ parm -> ea_info = pe_cpy($$); %}
				OPTIONAL
	}

SECTIONS build parse none

EventReportResult [[P struct event_rep_res *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> er_class]] OPTIONAL
				<< parm -> er_class.mid_global != NULLOID ||
				   parm -> er_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> er_inst]] OPTIONAL
				<< parm -> er_inst.mn_dn != NULLDN ||
				   parm -> er_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> er_time]]
				OPTIONAL << parm -> er_time != NULLCP >>,
	eventReply		EventReply [[p &parm -> er_reply]] OPTIONAL
				<< parm->er_reply.mp_id.mid_global != NULLOID ||
				  parm->er_reply.mp_id.mid_type != MID_GLOBAL >>
	}

ENCODER build

ActionArgument [[P struct action_arg *]] ::= SEQUENCE
	{
	baseManagedObjectClass	ObjectClass [[p &parm -> aa_class]],
	baseManagedObjectInstance ObjectInstance [[p &parm -> aa_inst]],
	accessControl		[5] AccessControl [[p parm -> aa_access]]
				OPTIONAL << parm -> aa_access >>,
	synchronization		[6] IMPLICIT CMISSync
				[[p (int *) &parm -> aa_sync]]
				DEFAULT bestEffort
				<< parm -> aa_sync != s_bestEffort >>,
	scope			[7] Scope [[p &parm -> aa_scope]]
				DEFAULT baseObject
				<< parm -> aa_scope.sc_type != Sc_BaseObject >>,
	filter			CMISFilter [[p parm -> aa_filter]]
				DEFAULT and {}
				<< parm -> aa_filter != NULLFILTER >>,
	actionInfo		[12] IMPLICIT ActionInfo [[p &parm -> aa_info]]
	}

ActionErrorInfo [[P CMISerrparam *]] ::= SEQUENCE
	{
	errorStatus	ENUMERATED [[i (int) parm -> me_error - 1]] {
				accessDenied	(2),
				noSuchAction	(9),
				noSuchArgument	(14),
				invalidArgumentValue (15) },
	errorInfo	CHOICE << parm -> me_error ==
						m_invalidArgumentValue ? 3 :
				 (parm -> me_error ==
						m_noSuchArgument ? 2 : 1) >>
				{
				actionType	ActionTypeId
						[[p &parm -> me_id]],
				actionArgument	[0] NoSuchArgument
						[[p parm]],
				argumentValue	[1] InvalidArgumentValue
						[[p parm]]
				}
	}

DECODER parse

ActionArgument [[P struct action_arg *]] ::= SEQUENCE
	{
	baseManagedObjectClass	ObjectClass [[p &parm -> aa_class]],
	baseManagedObjectInstance ObjectInstance [[p &parm -> aa_inst]],
	accessControl		[5] AccessControl [[p &parm -> aa_access]]
				OPTIONAL,
	synchronization		[6] IMPLICIT CMISSync
				[[p (int *) &parm -> aa_sync]]
				DEFAULT bestEffort,
	scope			[7] Scope [[p &parm -> aa_scope]]
				DEFAULT baseObject,
	filter			CMISFilter [[p &parm -> aa_filter]]
				DEFAULT and {},
	actionInfo		[12] IMPLICIT ActionInfo [[p &parm -> aa_info]]
	}

ActionErrorInfo [[P CMISerrparam *]] ::= SEQUENCE
	{
	errorStatus	ENUMERATED [[i (int) parm -> me_error]] {
				accessDenied	(2),
				noSuchAction	(9),
				noSuchArgument	(14),
				invalidArgumentValue (15) }
			%{ ((int) parm -> me_error)++; %},
	errorInfo	CHOICE
			{
			actionType	ActionTypeId
					[[p &parm -> me_id]],
			actionArgument	[0] NoSuchArgument
					[[p parm]],
			argumentValue	[1] InvalidArgumentValue
					[[p parm]]
			}
	}

SECTIONS build parse none

ActionResult [[P struct action_res *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> ar_class]] OPTIONAL
				<< parm -> ar_class.mid_global != NULLOID ||
				   parm -> ar_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> ar_inst]] OPTIONAL
				<< parm -> ar_inst.mn_dn != NULLDN ||
				   parm -> ar_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> ar_time]]
				OPTIONAL << parm -> ar_time != NULLCP >>,
	actionReply		[6] IMPLICIT ActionReply
				[[p &parm -> ar_reply]] OPTIONAL
				<< parm->ar_reply.mp_id.mid_global != NULLOID ||
				  parm->ar_reply.mp_id.mid_type != MID_GLOBAL >>
	}

ActionError [[P CMISerrparam *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> me_class]] OPTIONAL
				<< parm -> me_class.mid_global != NULLOID ||
				   parm -> me_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> me_inst]] OPTIONAL
				<< parm -> me_inst.mn_dn != NULLDN ||
				   parm -> me_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> me_time]]
				OPTIONAL << parm -> me_time != NULLCP >>,
	actionErrorInfo		[6] IMPLICIT ActionErrorInfo [[p parm]]
	}

ENCODER build

GetArgument [[P struct get_arg *]] %{ MID mid; int i; %} ::= SEQUENCE
	{
	baseManagedObjectClass	ObjectClass [[p &parm -> ga_class]],
	baseManagedObjectInstance ObjectInstance [[p &parm -> ga_inst]],
	accessControl		[5] AccessControl [[p parm -> ga_access]]
				OPTIONAL << parm -> ga_access >>,
	synchronization		[6] IMPLICIT CMISSync
				[[p (int *) &parm -> ga_sync]]
				DEFAULT bestEffort
				<< parm -> ga_sync != s_bestEffort >>,
	scope			[7] Scope [[p &parm -> ga_scope]]
				DEFAULT baseObject
				<< parm -> ga_scope.sc_type != Sc_BaseObject >>,
	filter			CMISFilter [[p parm -> ga_filter]]
				DEFAULT and {}
				<< parm -> ga_filter != NULLFILTER >>,
	attributeIdList		[12] IMPLICIT SET OF
				<< i = parm->ga_nattrs, mid = parm->ga_attrs;
				   i; mid++, i-- >>
				AttributeId [[p mid]]
				OPTIONAL << parm -> ga_nattrs >>
	}

DECODER parse

GetArgument [[P struct get_arg *]] %{ MID mid = parm -> ga_attrs; %}
	::= SEQUENCE %{ parm -> ga_nattrs = 0; %}
	{
	baseManagedObjectClass	ObjectClass [[p &parm -> ga_class]],
	baseManagedObjectInstance ObjectInstance [[p &parm -> ga_inst]],
	accessControl		[5] AccessControl [[p &parm -> ga_access]]
				OPTIONAL,
	synchronization		[6] IMPLICIT CMISSync
				[[p (int *) &parm -> ga_sync]]
				DEFAULT bestEffort,
	scope			[7] Scope [[p &parm -> ga_scope]]
				DEFAULT baseObject,
	filter			CMISFilter [[p &parm -> ga_filter]]
				DEFAULT and {},
	attributeIdList		[12] IMPLICIT SET OF AttributeId [[p mid++]]
				%{ parm -> ga_nattrs++; %}
				OPTIONAL
	}

ENCODER build

GetResult [[P struct get_res *]] %{ CMISparam * attr; int i; %} ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> gr_class]] OPTIONAL
				<< parm -> gr_class.mid_global != NULLOID ||
				   parm -> gr_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> gr_inst]] OPTIONAL
				<< parm -> gr_inst.mn_dn != NULLDN ||
				   parm -> gr_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> gr_time]]
				OPTIONAL << parm -> gr_time != NULLCP >>,
	attributeList		[6] IMPLICIT SET OF
				<< i = parm->gr_nattrs, attr = parm->gr_attrs;
				   i; attr++, i-- >>
				Attribute [[p attr]]
				OPTIONAL << parm -> gr_nattrs >>
	}

GetListError [[P struct get_res *]] %{ CMISparam * attr; int i; %} ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> gr_class]] OPTIONAL
				<< parm -> gr_class.mid_global != NULLOID ||
				   parm -> gr_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> gr_inst]] OPTIONAL
				<< parm -> gr_inst.mn_dn != NULLDN ||
				   parm -> gr_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> gr_time]]
				OPTIONAL << parm -> gr_time != NULLCP >>,
	getInfoList		[6] IMPLICIT SET OF
				<< i = parm->gr_nattrs, attr = parm->gr_attrs;
				   i; attr++, i-- >>
				GetInfoStatus [[p attr]]
				OPTIONAL << parm -> gr_nattrs >>
	}

DECODER parse

GetResult [[P struct get_res *]] %{ CMISparam * attr = parm -> gr_attrs; %}
	::= SEQUENCE %{ parm -> gr_nattrs = 0; %}
	{
	managedObjectClass	ObjectClass [[p &parm -> gr_class]]
				OPTIONAL,
	managedObjectInstance	ObjectInstance [[p &parm -> gr_inst]]
				OPTIONAL,
	currentTime		[5] IMPLICIT GeneralizedTime [[s parm -> gr_time]]
				OPTIONAL,
	attributeList		[6] IMPLICIT SET OF Attribute [[p attr++]]
				%{ parm -> gr_nattrs++; %}
				OPTIONAL
	}

GetListError [[P struct get_res *]] %{ CMISparam * attr = parm -> gr_attrs; %}
	::= SEQUENCE %{ parm -> gr_nattrs = 0; %}
	{
	managedObjectClass	ObjectClass [[p &parm -> gr_class]]
				OPTIONAL,
	managedObjectInstance	ObjectInstance [[p &parm -> gr_inst]]
				OPTIONAL,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> gr_time]]
				OPTIONAL,
	getInfoList		[6] IMPLICIT SET OF GetInfoStatus [[p attr++]]
				%{ parm -> gr_nattrs++; %}
	}

ENCODER build

SetArgument [[P struct set_arg *]] %{ CMISparam * attr; int i; %}
	::= SEQUENCE
	{
	baseManagedObjectClass	ObjectClass [[p &parm -> sa_class]],
	baseManagedObjectInstance ObjectInstance [[p &parm -> sa_inst]],
	accessControl		[5] AccessControl [[p parm -> sa_access]]
				OPTIONAL << parm -> sa_access >>,
	synchronization		[6] IMPLICIT CMISSync
				[[p (int *) &parm -> sa_sync]]
				DEFAULT bestEffort
				<< parm -> sa_sync != s_bestEffort >>,
	scope			[7] Scope [[p &parm -> sa_scope]]
				DEFAULT baseObject
				<< parm -> sa_scope.sc_type != Sc_BaseObject >>,
	filter			CMISFilter [[p parm -> sa_filter]]
				DEFAULT and {}
				<< parm -> sa_filter != NULLFILTER >>,
	modificationList	[12] IMPLICIT SET OF
				<< i = parm->sa_nattrs, attr = parm->sa_attrs;
				   i; attr++, i-- >>
			SEQUENCE
			{
			attributeId	[0] IMPLICIT AttributeId
					[[p &attr -> mp_id]],
			attributeValue	[1] ANY DEFINED BY attributeId
					[[a attr -> mp_val]] OPTIONAL
					<< attr -> mp_val != NULLPE >>,
			modifyOperator	[2] IMPLICIT ModifyOperator
					[[p (int *) &attr -> mp_modify]]
					DEFAULT replace
					<< attr -> mp_modify != m_replace >>
			}
	}
 
DECODER parse

SetArgument [[P struct set_arg *]] %{ CMISparam * attr = parm -> sa_attrs; %}
	::= SEQUENCE %{ parm -> sa_nattrs = 0; %}
	{
	baseManagedObjectClass	ObjectClass [[p &parm -> sa_class]],
	baseManagedObjectInstance ObjectInstance [[p &parm -> sa_inst]],
	accessControl		[5] AccessControl [[p &parm -> sa_access]]
				OPTIONAL,
	synchronization		[6] IMPLICIT CMISSync
				[[p (int *) &parm -> sa_sync]]
				DEFAULT bestEffort,
	scope			[7] Scope [[p &parm -> sa_scope]]
				DEFAULT baseObject,
	filter			CMISFilter [[p &parm -> sa_filter]]
				DEFAULT and {},
	modificationList	[12] IMPLICIT SET OF
			SEQUENCE
			{
			attributeId	[0] IMPLICIT AttributeId
					[[p &attr -> mp_id]],
			attributeValue	[1] ANY DEFINED BY attributeId
					%{ attr -> mp_val = pe_cpy($$); %}
					OPTIONAL,
			modifyOperator	[2] IMPLICIT ModifyOperator
					[[p (int *) &attr -> mp_modify]]
					DEFAULT replace
			}
				%{ parm -> sa_nattrs++; attr++;%}
	}

ENCODER build

SetResult [[P struct set_res *]] %{ CMISparam * attr; int i; %} ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> sr_class]] OPTIONAL
				<< parm -> sr_class.mid_global != NULLOID ||
				   parm -> sr_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> sr_inst]] OPTIONAL
				<< parm -> sr_inst.mn_dn != NULLDN ||
				   parm -> sr_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> sr_time]]
				OPTIONAL << parm -> sr_time != NULLCP >>,
	attributeList		[6] IMPLICIT SET OF
				<< i = parm->sr_nattrs, attr = parm->sr_attrs;
				   i; attr++, i-- >>
				Attribute [[p attr]]
				OPTIONAL << parm -> sr_nattrs >>
	}

SetListError [[P struct set_res *]] %{ CMISparam * attr; int i; %} ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> sr_class]] OPTIONAL
				<< parm -> sr_class.mid_global != NULLOID ||
				   parm -> sr_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> sr_inst]] OPTIONAL
				<< parm -> sr_inst.mn_dn != NULLDN ||
				   parm -> sr_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> sr_time]]
				OPTIONAL << parm -> sr_time != NULLCP >>,
	setInfoList		[6] IMPLICIT SET OF
				<< i = parm->sr_nattrs, attr = parm->sr_attrs;
				   i; attr++, i-- >>
				SetInfoStatus [[p attr]]
				OPTIONAL << parm -> sr_nattrs >>
	}

DECODER parse

SetResult [[P struct set_res *]] %{ CMISparam * attr = parm -> sr_attrs; %}
	::= SEQUENCE %{ parm -> sr_nattrs = 0; %}
	{
	managedObjectClass	ObjectClass [[p &parm -> sr_class]]
				OPTIONAL,
	managedObjectInstance	ObjectInstance [[p &parm -> sr_inst]]
				OPTIONAL,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> sr_time]] OPTIONAL,
	attributeList		[6] IMPLICIT SET OF Attribute [[p attr++]]
				%{ parm -> sr_nattrs++; %}
				OPTIONAL
	}

SetListError [[P struct set_res *]] %{ CMISparam * attr = parm -> sr_attrs; %}
	::= SEQUENCE %{ parm -> sr_nattrs = 0; %}
	{
	managedObjectClass	ObjectClass [[p &parm -> sr_class]]
				OPTIONAL,
	managedObjectInstance	ObjectInstance [[p &parm -> sr_inst]]
				OPTIONAL,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> sr_time]] OPTIONAL,
	setInfoList		[6] IMPLICIT SET OF SetInfoStatus [[p attr++]]
				%{ parm -> sr_nattrs++; %}
				OPTIONAL
	}

ENCODER build

CreateArgument [[P struct create_arg *]] %{ CMISparam * attr; int i; %}
	::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> ca_class]],
		CHOICE << parm -> ca_instype == CA_OBJECT_INST ? 1 : 2 >>
		{
		managedObjectInstance	ObjectInstance [[p &parm -> ca_inst]],
	 	superiorObjectInstance	[8] ObjectInstance
						[[p &parm -> ca_inst]]
		} OPTIONAL
		<< parm -> ca_inst.mn_dn != NULLDN ||
		   parm -> ca_inst.mn_type != MN_DN >>,
	accessControl		[5] AccessControl [[p parm -> ca_access]]
				OPTIONAL << parm -> ca_access >>,
	referenceObjectInstance [6] ObjectInstance [[p &parm -> ca_refinst]]
				OPTIONAL << parm -> ca_refinst.mn_dn != NULLDN ||
					 parm -> ca_refinst.mn_type != MN_DN >>,
	attributeList		[7] IMPLICIT SET OF
				<< i = parm->ca_nattrs, attr = parm->ca_attrs;
				   i; attr++, i-- >>
				Attribute [[p attr]]
				OPTIONAL << parm -> ca_nattrs >>
	}
	
DECODER parse

CreateArgument [[P struct create_arg *]] %{CMISparam * attr = parm->ca_attrs;%}
	::= SEQUENCE %{ parm -> ca_nattrs = 0; %}
	{
	managedObjectClass	ObjectClass [[p &parm -> ca_class]],
		CHOICE
		{
		managedObjectInstance  ObjectInstance [[p &parm -> ca_inst]]
				%{ parm -> ca_instype = CA_OBJECT_INST; %},
	 	superiorObjectInstance [8] ObjectInstance [[p &parm -> ca_inst]]
				%{ parm -> ca_instype = CA_PARENT_INST; %}
		} OPTIONAL,
	accessControl		[5] AccessControl [[p &parm -> ca_access]]
				OPTIONAL,
	referenceObjectInstance [6] ObjectInstance [[p &parm -> ca_refinst]]
				OPTIONAL,
	attributeList		[7] IMPLICIT SET OF Attribute [[p attr++]]
				%{ parm -> ca_nattrs++; %}
				OPTIONAL
	}
	
ENCODER build

CreateResult [[P struct create_res *]] %{ CMISparam * attr; int i; %}
	::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> cr_class]] OPTIONAL
				<< parm -> cr_class.mid_global != NULLOID ||
				   parm -> cr_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> cr_inst]] OPTIONAL
				<< parm -> cr_inst.mn_dn != NULLDN ||
				   parm -> cr_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> cr_time]]
				OPTIONAL << parm -> cr_time != NULLCP >>,
	attributeList		[6] IMPLICIT SET OF
				<< i = parm->cr_nattrs, attr = parm->cr_attrs;
				   i; attr++, i-- >>
				Attribute [[p attr]]
				OPTIONAL << parm -> cr_nattrs >>
	}

DECODER parse

CreateResult [[P struct create_res *]] %{ CMISparam * attr = parm->cr_attrs; %}
	::= SEQUENCE %{ parm -> cr_nattrs = 0; %}
	{
	managedObjectClass	ObjectClass [[p &parm -> cr_class]]
				OPTIONAL,
	managedObjectInstance	ObjectInstance [[p &parm -> cr_inst]]
				OPTIONAL,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> cr_time]] OPTIONAL,
	attributeList		[6] IMPLICIT SET OF Attribute [[p attr++]]
				%{ parm -> cr_nattrs++; %}
				OPTIONAL
	}

ENCODER build

DeleteArgument [[P struct delete_arg *]] ::= SEQUENCE
	{
	baseManagedObjectClass	ObjectClass [[p &parm -> da_class]],
	baseManagedObjectInstance ObjectInstance [[p &parm -> da_inst]],
	accessControl		[5] AccessControl [[p parm -> da_access]]
				OPTIONAL << parm -> da_access >>,
	synchronization		[6] IMPLICIT CMISSync
				[[p (int *) &parm -> da_sync]]
				DEFAULT bestEffort
				<< parm -> da_sync != s_bestEffort >>,
	scope			[7] Scope [[p &parm -> da_scope]]
				DEFAULT baseObject
				<< parm -> da_scope.sc_type != Sc_BaseObject >>,
	filter			CMISFilter [[p parm -> da_filter]]
				DEFAULT and {}
				<< parm -> da_filter != NULLFILTER >>
	}

DECODER parse

DeleteArgument [[P struct delete_arg *]] ::= SEQUENCE
	{
	baseManagedObjectClass	ObjectClass [[p &parm -> da_class]],
	baseManagedObjectInstance ObjectInstance [[p &parm -> da_inst]],
	accessControl		[5] AccessControl [[p &parm -> da_access]]
				OPTIONAL,
	synchronization		[6] IMPLICIT CMISSync
				[[p (int *) &parm -> da_sync]]
				DEFAULT bestEffort,
	scope			[7] Scope [[p &parm -> da_scope]]
				DEFAULT baseObject,
	filter			CMISFilter [[p &parm -> da_filter]]
				DEFAULT and {}
	}

SECTIONS build parse none

DeleteResult [[P struct delete_res *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> dr_class]] OPTIONAL
				<< parm -> dr_class.mid_global != NULLOID ||
				   parm -> dr_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> dr_inst]] OPTIONAL
				<< parm -> dr_inst.mn_dn != NULLDN ||
				   parm -> dr_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> dr_time]]
				OPTIONAL << parm -> dr_time != NULLCP >>
	}

ENCODER build

DeleteError [[P CMISerrparam *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> me_class]] OPTIONAL
				<< parm -> me_class.mid_global != NULLOID ||
				   parm -> me_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> me_inst]] OPTIONAL
				<< parm -> me_inst.mn_dn != NULLDN ||
				   parm -> me_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> me_time]]
				OPTIONAL << parm -> me_time != NULLCP >>,
	deleteErrorInfo		[6] ENUMERATED [[i (int) parm -> me_error - 1]]
				{ accessDenied (2) }
	}

DECODER parse

DeleteError [[P CMISerrparam *]] ::= SEQUENCE
	{
	managedObjectClass	ObjectClass [[p &parm -> me_class]] OPTIONAL
				<< parm -> me_class.mid_global != NULLOID ||
				   parm -> me_class.mid_type != MID_GLOBAL >>,
	managedObjectInstance	ObjectInstance [[p &parm -> me_inst]] OPTIONAL
				<< parm -> me_inst.mn_dn != NULLDN ||
				   parm -> me_inst.mn_type != MN_DN >>,
	currentTime		[5] IMPLICIT GeneralizedTime
				[[s parm -> me_time]]
				OPTIONAL << parm -> me_time != NULLCP >>,
	deleteErrorInfo		[6] ENUMERATED [[i (int) parm -> me_error]]
				{ accessDenied (2) }
				%{ ((int) parm -> me_error)++; %}
	}

ENCODER build

LinkedReplyArgument [[P struct linked_reply_arg *]] ::= CHOICE
	<< parm -> lr_type >>
	{
	getResult	[0] IMPLICIT GetResult [[p &parm -> lr_getr]],
	getListError	[1] IMPLICIT GetListError [[p &parm -> lr_getr]],
	setResult	[2] IMPLICIT SetResult [[p &parm -> lr_setr]],
	setListError	[3] IMPLICIT SetListError [[p &parm -> lr_setr]],
	actionResult	[4] IMPLICIT ActionResult [[p &parm -> lr_actionr]],
	processingFailure [5] IMPLICIT ProcessingFailure [[p &parm->lr_error]],
	deleteResult	[6] IMPLICIT DeleteResult [[p &parm -> lr_deleter]],
	actionError	[7] IMPLICIT ActionError [[p &parm -> lr_error]],
	deleteError	[8] IMPLICIT DeleteError [[p &parm -> lr_error]]
	}

DECODER parse

LinkedReplyArgument [[P struct linked_reply_arg *]] ::= CHOICE
	{
	getResult	[0] IMPLICIT GetResult [[p &parm -> lr_getr]]
			%{ parm -> lr_type = LR_GET_RES; %},
	getListError	[1] IMPLICIT GetListError [[p &parm -> lr_getr]]
			%{ parm -> lr_type = LR_GET_LISTERR; %},
	setResult	[2] IMPLICIT SetResult [[p &parm -> lr_setr]]
			%{ parm -> lr_type = LR_SET_RES; %},
	setListError	[3] IMPLICIT SetListError [[p &parm -> lr_setr]]
			%{ parm -> lr_type = LR_SET_LISTERR; %},
	actionResult	[4] IMPLICIT ActionResult [[p &parm -> lr_actionr]]
			%{ parm -> lr_type = LR_ACTION_RES; %},
	processingFailure [5] IMPLICIT ProcessingFailure [[p &parm->lr_error]]
			%{ parm -> lr_type = LR_PROC_FAIL; %},
	deleteResult	[6] IMPLICIT DeleteResult [[p &parm -> lr_deleter]]
			%{ parm -> lr_type = LR_DELETE_RES; %},
	actionError	[7] IMPLICIT ActionError [[p &parm -> lr_error]]
			%{ parm -> lr_type = LR_ACTION_ERR; %},
	deleteError	[8] IMPLICIT DeleteError [[p &parm -> lr_error]]
			%{ parm -> lr_type = LR_DELETE_ERR; %}
	}

END

%{

/* VARARGS2 */

static void  advise (what, fmt, a, b, c, d, e, f, g, h, i, j)
char  *what, *fmt, *a, *b, *c, *d, *e, *f, *g, *h, *i, *j;
{
    (void) fflush(stdout);
    (void) fprintf(stderr, "libmsap: ");
    (void) fprintf(stderr, fmt, a, b, c, d, e, f, g, h, i, j);
    if (what)
	(void) fputc(' ', stderr), perror(what);
    else
	(void) fputc('\n', stderr);
    (void) fflush(stderr);
}

%}