DataMuseum.dk

Presents historical artifacts from the history of:

DKUUG/EUUG Conference tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about DKUUG/EUUG Conference tapes

Excavated with: AutoArchaeologist - Free & Open Source Software. 

top - metrics - download
Index: T d

⟦746be7a5e⟧ TextFile

    Length: 22972 (0x59bc)
    Types: TextFile
    Names: »do-enc.py«

Derivation

└─⟦3d0c2be1b⟧ Bits:30001254 ISODE-5.0 Tape
    └─⟦eba4602b1⟧ »./isode-5.0.tar.Z« 
        └─⟦d3ac74d73⟧ 
            └─⟦this⟧ »isode-5.0/dsap/x500as/do-enc.py«

TextFile

-- do-enc.py - manually augmented DistributedOperations module

-- $Header: /f/osi/dsap/x500as/RCS/do-enc.py,v 6.0 89/03/18 23:29:30 mrose Rel $
--
--
-- $Log:	do-enc.py,v $
-- Revision 6.0  89/03/18  23:29:30  mrose
-- Release 5.0
-- 

--
--				  NOTICE
--
--    Acquisition, use, and distribution of this module and related
--    materials are subject to the restrictions of a license agreement.
--    Consult the Preface in the User's Manual for the full terms of
--    this agreement.
--
--


DO
	{
	joint-iso-ccitt
	ds(5)
	modules(1)
	distributedOperations(3)
	}

DEFINITIONS ::=

%{
#include "quipu/util.h"
#include "quipu/entry.h"
#include "quipu/common.h"
#include "quipu/dsargument.h"

extern  LLog    * log_dsap;

#define	encode_DSE_PSAPaddr	build_DSE_PSAPaddr
%}

PREFIXES encode decode print
BEGIN

-- EXPORTS
--	ContinuationReference ,
--	OperationProgress ,
-- 	DSAReferralParm;

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

	AlgorithmIdentifier
		FROM AF
			{
			joint-iso-ccitt
			ds(5)
			modules(1)
			authenticationFramework(7)
			}

	ReadArgument ,
	ReadResult ,
	CompareArgument ,
	CompareResult ,
	AbandonArgument ,
	AbandonResult ,
	ListArgument ,
	ListResult ,
	SearchArgument ,
	SearchResult ,
	AddEntryArgument ,
	AddEntryResult ,
	RemoveEntryArgument ,
	RemoveEntryResult ,
	ModifyEntryArgument ,
	ModifyEntryResult ,
	ModifyRDNArgument ,
	ModifyRDNResult ,
	SecurityParameters
		FROM DAS
			{
			joint-iso-ccitt
			ds(5)
			modules(1)
			directoryAbstractService(2)
			};

ENCODER encode

ChainedReadArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChaineReadArgument"));
        %}
	CHOICE <<1>>
	{
		ChainedReadArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedReadArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChaineReadArgument"));
        %}

ChainedReadArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedReadArgumentData"));
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] ReadArgument [[p &(parm->dca_dsarg.arg_rd)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedReadArgumentData"));
        %}

ChainedReadResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedReadResult"));
        %}
	CHOICE <<1>>
	{
		ChainedReadResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedReadResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedReadResult"));
        %}

ChainedReadResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedReadResultData"));
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] ReadResult [[p &(parm->dcr_dsres.res_rd)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedReadResultData"));
        %}

ChainedCompareArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedCompareArgument"));
        %}
	CHOICE <<1>>
	{
		ChainedCompareArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedCompareArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedCompareArgument"));
        %}

ChainedCompareArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedCompareArgumentData"));
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] CompareArgument [[p &(parm->dca_dsarg.arg_cm)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedCompareArgumentData"));
        %}

ChainedCompareResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedCompareResult"));
        %}
	CHOICE <<1>>
	{
		ChainedCompareResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedCompareResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedCompareResult"));
        %}

ChainedCompareResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedCompareResultData"));
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] CompareResult [[p &(parm->dcr_dsres.res_cm)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedCompareResultData"));
        %}

ChainedAbandonArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedAbandonArgument"));
        %}
	AbandonArgument [[p &(parm->dca_dsarg.arg_ab)]]
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedAbandonArgument"));
        %}

ChainedAbandonResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedAbandonResult"));
        %}
	AbandonResult
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedAbandonResult"));
        %}

ChainedListArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedListArgument"));
        %}
	CHOICE <<1>>
	{
		ChainedListArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedListArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedListArgument"));
        %}

ChainedListArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedListArgumentData"));
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] ListArgument [[p &(parm->dca_dsarg.arg_ls)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedListArgumentData"));
        %}

ChainedListResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedListResult"));
        %}
	CHOICE <<1>>
	{
		ChainedListResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedListResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedListResult"));
        %}

ChainedListResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedListResultData"));
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] ListResult [[p &(parm->dcr_dsres.res_ls)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedListResultData"));
        %}

ChainedSearchArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedSearchArgument"));
        %}
	CHOICE <<1>>
	{
		ChainedSearchArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedSearchArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedSearchArgument"));
        %}

ChainedSearchArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedSearchArgumentData"));
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] SearchArgument [[p &(parm->dca_dsarg.arg_sr)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedSearchArgumentData"));
        %}

ChainedSearchResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedSearchResult"));
        %}
	CHOICE <<1>>
	{
		ChainedSearchResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedSearchResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedSearchResult"));
        %}

ChainedSearchResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedSearchResultData"));
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] SearchResult [[p &(parm->dcr_dsres.res_sr)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedSearchResultData"));
        %}

ChainedAddEntryArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedAddEntryArgument"));
        %}
	CHOICE <<1>>
	{
		ChainedAddEntryArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedAddEntryArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedAddEntryArgument"));
        %}

ChainedAddEntryArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedAddEntrArgumentData"));
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] AddEntryArgument [[p &(parm->dca_dsarg.arg_ad)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedAddEntrArgumentData"));
        %}

ChainedAddEntryResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedAddEntryResult"));
        %}
	CHOICE <<1>>
	{
		ChainedAddEntryResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedAddEntryResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedAddEntryResult"));
        %}

ChainedAddEntryResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedAddEntryResultData"));
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] AddEntryResult
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedAddEntryResultData"));
        %}

ChainedRemoveEntryArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedRemoveEntryArgument"));
        %}
	CHOICE <<1>>
	{
		ChainedRemoveEntryArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedRemoveEntryArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedRemoveEntryArgument"));
        %}

ChainedRemoveEntryArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedRemoveEntryArgumentData"));
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] RemoveEntryArgument [[p &(parm->dca_dsarg.arg_rm)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedRemoveEntryArgumentData"));
        %}

ChainedRemoveEntryResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedRemoveEntryResult"));
        %}
	CHOICE <<1>>
	{
		ChainedRemoveEntryResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedRemoveEntryResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedRemoveEntryResult"));
        %}

ChainedRemoveEntryResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedRemoveEntryResultData"));
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] RemoveEntryResult
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedRemoveEntryResultData"));
        %}

ChainedModifyEntryArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedModifyEntryArgument"));
        %}
	CHOICE <<1>>
	{
		ChainedModifyEntryArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedModifyEntryArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedModifyEntryArgument"));
        %}

ChainedModifyEntryArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedModifyEntryArgumentData"));
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] ModifyEntryArgument [[p &(parm->dca_dsarg.arg_me)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedModifyEntryArgumentData"));
        %}

ChainedModifyEntryResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedModifyEntryResult"));
        %}
	CHOICE <<1>>
	{
		ChainedModifyEntryResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedModifyEntryResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedModifyEntryResult"));
        %}

ChainedModifyEntryResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedModifyEntryResultData"));
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] ModifyEntryResult
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedModifyEntryResultData"));
        %}

ChainedModifyRDNArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedModifyRDNArgument"));
        %}
	CHOICE <<1>>
	{
		ChainedModifyRDNArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedModifyRDNArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedModifyRDNArgument"));
        %}

ChainedModifyRDNArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedModifyRDNArgumentData"));
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] ModifyRDNArgument [[p &(parm->dca_dsarg.arg_mr)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedModifyRDNArgumentData"));
        %}

ChainedModifyRDNResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedModifyRDNResult"));
        %}
	CHOICE <<1>>
	{
		ChainedModifyRDNResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedModifyRDNResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedModifyRDNResult"));
        %}

ChainedModifyRDNResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainedModifyRDNResultData"));
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] ModifyRDNResult
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainedModifyRDNResultData"));
        %}

DSAReferralParm [[P struct DSE_referral *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode DSAReferralParm"));
        %}
	SET
	{
		[0] ContinuationReference [[p parm->DSE_ref_candidates]] ,
	contextPrefix
		[1] DistinguishedName [[p parm->DSE_ref_prefix]]
		    OPTIONAL <<parm->DSE_ref_prefix != NULLDN>>
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode DSAReferralParm"));
        %}

ChainingArgument [[P struct chain_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainingArgument"));
        %}
	SET
	{
	originator
		[0] DistinguishedName [[p parm->cha_originator]]
		    OPTIONAL <<parm->cha_originator != NULLDN>> ,
	targetObject
		[1] DistinguishedName [[p parm->cha_target]]
		    OPTIONAL <<parm->cha_target != NULLDN>> ,
	operationProgress
		[2] OperationProgress [[p &(parm->cha_progress)]]
		    -- DEFAULT {notStarted} ,
		    OPTIONAL <<TRUE>> ,
	traceInformation
		[3] TraceInformation [[p parm->cha_trace]] ,
	aliasDereferenced
		[4] BOOLEAN [[b parm->cha_aliasderef]]
		    -- DEFAULT FALSE ,
		    OPTIONAL <<parm->cha_aliasderef != FALSE>> ,
	aliasedRDNs
		[5] INTEGER [[i parm->cha_aliasedrdns]]
		    OPTIONAL <<parm->cha_aliasderef != FALSE>> ,
	returnCrossRefs
		[6] BOOLEAN [[b parm->cha_returnrefs]]
		    -- DEFAULT FALSE ,
		    OPTIONAL <<parm->cha_returnrefs != FALSE>> ,
	referenceType
		[7] ReferenceType [[p parm->cha_reftype]]
		    -- DEFAULT superior ,
		    OPTIONAL <<parm->cha_reftype != RT_SUPERIOR>> ,
	info
		[8] DomainInfo [[p parm->cha_domaininfo]]
		    OPTIONAL <<FALSE>> ,
	timeLimit
		[9] UTCTime
		    OPTIONAL <<FALSE>> ,
		[10] SecurityParameters
		    -- DEFAULT {}
		    OPTIONAL <<FALSE>>
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainingArgument"));
        %}

ChainingResult [[P struct chain_res *]]
%{
        struct cross_ref	* xrefp;
%}
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ChainingResult"));
        %}
	SET
	{
	info
		[0] DomainInfo [[p parm->chr_domaininfo]]
		    OPTIONAL <<FALSE>> ,
	crossReferences
		[1] SEQUENCE OF
		<<xrefp=parm->chr_crossrefs; xrefp!=NULLXREF; xrefp=xrefp->xref_next>>
			CrossReference [[p xrefp]]
			%{
			%}
		%{
		%}
		    OPTIONAL <<FALSE>> ,
		[2] SecurityParameters
		    -- DEFAULT {}
		    OPTIONAL <<FALSE>>
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ChainingResult"));
        %}

CrossReference [[P struct cross_ref *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode CrossReference"));
        %}
	SET
	{
	contextPrefix
		[0] DistinguishedName [[p parm->xref_dn]] ,
	accessPoint
		[1] AccessPoint [[p parm->xref_ap]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode CrossReference"));
        %}

ReferenceType [[P int]]
%{
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ReferenceType PE"));
        %}
        ENUMERATED [[i parm]]
        {
        superior(1) ,
        subordinate(2) ,
        cross(3) ,
        nonSpecificSubordinate(4)
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ReferenceType PE"));
        %}

TraceInformation [[P struct trace_info *]]
%{
	struct trace_info	* tip;
%}
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode TraceInformation"));
        %}
	SEQUENCE OF
	<<tip=parm; tip!=NULLTRACEINFO; tip=tip->ti_next>>
		TraceItem [[p tip]]
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode TraceInformation"));
        %}

TraceItem [[P struct trace_info *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode TraceItem"));
        %}
	SET
	{
	dsa
		[0] Name [[p parm->ti_dsa]] ,
	targetObject
		[1] Name [[p parm->ti_target]]
		    OPTIONAL <<TRUE>> ,
	operationProgress
		[2] OperationProgress [[p &(parm->ti_progress)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode TraceItem"));
        %}

OperationProgress [[P struct op_progress *]]
%{
        int     phase;
%}
        ::=
        %{
        DLOG(log_dsap, LLOG_TRACE, ("About to encode OperationProgress PE"));
                phase = parm->op_resolution_phase;
                if(phase < 0)
                        phase = 0;
                if(phase > 2)
                        phase = 2;
                phase = phase + 1;
        %}
        SET
        {
        nameResolutionPhase
                [0] ENUMERATED [[i phase]]
                {
                notStarted(1) ,
                proceeding(2) ,
                completed(3)
                }
                %{
                %} ,
        nextRDNToBeResolved
                [1] INTEGER [[i parm->op_nextrdntoberesolved]]
                %{
                %}
		    OPTIONAL <<parm->op_nextrdntoberesolved != 0>>
        }
        %{
        DLOG(log_dsap, LLOG_TRACE, ("Done encode OperationProgress PE"));
        %}

DomainInfo [[P PE]]
%{
	PE	  new_pe = pe_cpy(parm);
%}
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode DomainInfo"));
        %}
	ANY [[a new_pe]]
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode DomainInfo"));
        %}

ContinuationReference [[P ContinuationRef]]
%{
        struct  access_point    *app;
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ContinuationReference PE"));
        %}
        SET
        {
        targetObject
                [0] Name [[p parm->cr_name]]
                %{
                %} ,
        aliasedRDNs
                [1] INTEGER [[i parm->cr_aliasedRDNs]]
                %{
                %}
                    OPTIONAL <<parm->cr_aliasedRDNs != CR_NOALIASEDRDNS>> ,
        operationProgress
                [2] OperationProgress [[p &(parm->cr_progress)]]
                %{
                %} ,
        rdnsResolved
                [3] INTEGER [[i parm->cr_rdn_resolved]]
                %{
                %}
                    OPTIONAL <<parm->cr_rdn_resolved != CR_RDNRESOLVED_NOTDEFINED>> ,
        referenceType
                [4] ReferenceType [[p parm->cr_reftype]]
                %{
                %}
                    OPTIONAL <<parm->cr_reftype != RT_UNDEFINED>> ,
        accessPoints
                [5] SET OF
                %{
                %}
                <<app = &(parm->cr_accesspoints);app != NULLACCESSPOINT;app = app->ap_next>>
                        AccessPoint [[p app]]
                        %{
                        %}
                %{
                %}
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ContinuationReference PE"));
        %}

AccessPoint [[P struct access_point *]]
%{
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode AccessPoint PE"));
        %}
        SET
        {
                [0] Name [[p parm->ap_name]]
                %{
                %} ,
                [1] ISODEPresentationAddress [[p &(parm->ap_address)]]
                %{
                %}
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode AccessPoint PE"));
        %}

ISODEPresentationAddress [[P struct PSAPaddr * ]]
    ::=
        %{
        DLOG(log_dsap, LLOG_TRACE, ("About to encode PresentationAddress PE"));
        %}
	DSE.PSAPaddr [[p parm]]
        %{
        DLOG(log_dsap, LLOG_TRACE, ("Done encode PresentationAddress PE"));
        %}

InvokeID [[P int]]
%{
%}
        ::=
        %{
        DLOG(log_dsap, LLOG_TRACE, ("About to encode InvokeID PE"));
        %}
        INTEGER [[i parm]]
        %{
        DLOG(log_dsap, LLOG_TRACE, ("Done encode InvokeID PE"));
        %}

END