DIRECTORY
CrRPC,
TimeP15V2,
FilingAttributesP10V5,
CHNameP2V0,
AuthenticationP14V2,
BulkDataP0V1,
FilingP10V5,
FilingP10V5ClientHack;

FilingP10V5ClientImpl: CEDAR PROGRAM
IMPORTS CrRPC
EXPORTS FilingP10V5, FilingP10V5ClientHack ~ {
OPEN FilingP10V5;



HandleError: PUBLIC HandleErrorType ~ CODE;

ControlTypeError: PUBLIC ControlTypeErrorType ~ CODE;

TransferError: PUBLIC TransferErrorType ~ CODE;

SpaceError: PUBLIC SpaceErrorType ~ CODE;

ServiceError: PUBLIC ServiceErrorType ~ CODE;

RangeError: PUBLIC RangeErrorType ~ CODE;

SessionError: PUBLIC SessionErrorType ~ CODE;

UndefinedError: PUBLIC UndefinedErrorType ~ CODE;

ConnectionError: PUBLIC ConnectionErrorType ~ CODE;

AuthenticationError: PUBLIC AuthenticationErrorType ~ CODE;

ScopeValueError: PUBLIC ScopeValueErrorType ~ CODE;

AttributeValueError: PUBLIC AttributeValueErrorType ~ CODE;

InsertionError: PUBLIC InsertionErrorType ~ CODE;

ControlValueError: PUBLIC ControlValueErrorType ~ CODE;

AccessError: PUBLIC AccessErrorType ~ CODE;

AttributeTypeError: PUBLIC AttributeTypeErrorType ~ CODE;

ScopeTypeError: PUBLIC ScopeTypeErrorType ~ CODE;


GetError: PUBLIC CrRPC.GetErrorProc ~ {
SELECT errNum FROM
9  => {
problem: HandleProblem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR HandleError[problem]
};
2  => {
problem: ArgumentProblem;
type: ControlType;
problem ¬ VAL[CrRPC.GetCard16[s]];
type ¬ VAL[CrRPC.GetCard16[s]];
ERROR ControlTypeError[problem, type]
};
14  => {
problem: TransferProblem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR TransferError[problem]
};
13  => {
problem: SpaceProblem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR SpaceError[problem]
};
11  => {
problem: ServiceProblem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR ServiceError[problem]
};
16  => {
problem: ArgumentProblem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR RangeError[problem]
};
12  => {
problem: SessionProblem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR SessionError[problem]
};
15  => {
problem: CARD16;
problem ¬ CrRPC.GetCard16[s];
ERROR UndefinedError[problem]
};
8  => {
problem: ConnectionProblem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR ConnectionError[problem]
};
7  => {
problem: AuthenticationP14V2.Problem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR AuthenticationError[problem]
};
5  => {
problem: ArgumentProblem;
type: ScopeType;
problem ¬ VAL[CrRPC.GetCard16[s]];
type ¬ VAL[CrRPC.GetCard16[s]];
ERROR ScopeValueError[problem, type]
};
1  => {
problem: ArgumentProblem;
type: CARD32;
problem ¬ VAL[CrRPC.GetCard16[s]];
type ¬ CrRPC.GetCard32[s];
ERROR AttributeValueError[problem, type]
};
10  => {
problem: InsertionProblem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR InsertionError[problem]
};
3  => {
problem: ArgumentProblem;
type: ControlType;
problem ¬ VAL[CrRPC.GetCard16[s]];
type ¬ VAL[CrRPC.GetCard16[s]];
ERROR ControlValueError[problem, type]
};
6  => {
problem: AccessProblem;
problem ¬ VAL[CrRPC.GetCard16[s]];
ERROR AccessError[problem]
};
0  => {
problem: ArgumentProblem;
type: CARD32;
problem ¬ VAL[CrRPC.GetCard16[s]];
type ¬ CrRPC.GetCard32[s];
ERROR AttributeTypeError[problem, type]
};
4  => {
problem: ArgumentProblem;
type: ScopeType;
problem ¬ VAL[CrRPC.GetCard16[s]];
type ¬ VAL[CrRPC.GetCard16[s]];
ERROR ScopeTypeError[problem, type]
};
ENDCASE => {
ERROR CrRPC.Error[h, remoteError, "Unexpected Remote Error"];
};
};


ReplaceBytes: PUBLIC ReplaceBytesType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i2: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i2]];
ENDLOOP;
CrRPC.PutCard32[s, range.firstByte];
CrRPC.PutCard32[s, range.count];
CrRPC.PutBulkDataSource[h, s, source];
FOR i3: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i3]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~23 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Logoff: PUBLIC LogoffType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i5: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i5]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~1 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

UnifyAccessLists: PUBLIC UnifyAccessListsType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i6: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, directory[i6]];
ENDLOOP;
FOR i7: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i7]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~20 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

ChangeAttributes: PUBLIC ChangeAttributesType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i8: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i8]];
ENDLOOP;
MProc9[h, s, attributes];
FOR i10: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i10]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~9 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Copy: PUBLIC CopyType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i11: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i11]];
ENDLOOP;
FOR i12: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, destinationDirectory[i12]];
ENDLOOP;
MProc9[h, s, attributes];
MProc13[h, s, controls];
FOR i14: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i14]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
FOR i15: CARDINAL IN [0..2) DO
newFile[i15] ¬ CrRPC.GetCard16[s];
ENDLOOP;
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~10 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

ChangeControls: PUBLIC ChangeControlsType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i16: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i16]];
ENDLOOP;
MProc13[h, s, controls];
FOR i17: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i17]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~7 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

GetControls: PUBLIC GetControlsType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i18: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i18]];
ENDLOOP;
MProc19[h, s, types];
FOR i20: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i20]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
controls ¬ UProc21[h, s];
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~6 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Replace: PUBLIC ReplaceType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i22: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i22]];
ENDLOOP;
MProc9[h, s, attributes];
CrRPC.PutBulkDataSource[h, s, content];
FOR i23: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i23]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~14 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Move: PUBLIC MoveType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i24: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i24]];
ENDLOOP;
FOR i25: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, destinationDirectory[i25]];
ENDLOOP;
MProc9[h, s, attributes];
FOR i26: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i26]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~11 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Continue: PUBLIC ContinueType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i27: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i27]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
continuance ¬ CrRPC.GetCard16[s];
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~19 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

GetAttributes: PUBLIC GetAttributesType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i28: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i28]];
ENDLOOP;
MProc29[h, s, types];
FOR i30: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i30]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
attributes ¬ UProc31[h, s];
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~8 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

List: PUBLIC ListType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i32: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, directory[i32]];
ENDLOOP;
MProc29[h, s, types];
MProc33[h, s, scope];
CrRPC.PutBulkDataSink[h, s, listing];
FOR i34: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i34]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~18 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Deserialize: PUBLIC DeserializeType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i35: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, directory[i35]];
ENDLOOP;
MProc9[h, s, attributes];
MProc13[h, s, controls];
CrRPC.PutBulkDataSource[h, s, serializedFile];
FOR i36: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i36]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
FOR i37: CARDINAL IN [0..2) DO
file[i37] ¬ CrRPC.GetCard16[s];
ENDLOOP;
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~16 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Store: PUBLIC StoreType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i38: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, directory[i38]];
ENDLOOP;
MProc9[h, s, attributes];
MProc13[h, s, controls];
CrRPC.PutBulkDataSource[h, s, content];
FOR i39: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i39]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
FOR i40: CARDINAL IN [0..2) DO
file[i40] ¬ CrRPC.GetCard16[s];
ENDLOOP;
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~12 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Retrieve: PUBLIC RetrieveType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i41: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i41]];
ENDLOOP;
CrRPC.PutBulkDataSink[h, s, content];
FOR i42: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i42]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~13 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

RetrieveBytes: PUBLIC RetrieveBytesType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i43: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i43]];
ENDLOOP;
CrRPC.PutCard32[s, range.firstByte];
CrRPC.PutCard32[s, range.count];
CrRPC.PutBulkDataSink[h, s, sink];
FOR i44: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i44]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~22 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Logon: PUBLIC LogonType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutRope[s, service.organization];
CrRPC.PutRope[s, service.domain];
CrRPC.PutRope[s, service.object];
CrRPC.PutCard16[s, ORD[credentials.type]];
MProc4[h, s, credentials.value];
MProc4[h, s, verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
FOR i45: CARDINAL IN [0..2) DO
session.token[i45] ¬ CrRPC.GetCard16[s];
ENDLOOP;
session.verifier ¬ UProc46[h, s];
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~0 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Delete: PUBLIC DeleteType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i47: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i47]];
ENDLOOP;
FOR i48: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i48]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~5 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Serialize: PUBLIC SerializeType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i49: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i49]];
ENDLOOP;
CrRPC.PutBulkDataSink[h, s, serializedFile];
FOR i50: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i50]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~15 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Find: PUBLIC FindType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i51: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, directory[i51]];
ENDLOOP;
MProc33[h, s, scope];
MProc13[h, s, controls];
FOR i52: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i52]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
FOR i53: CARDINAL IN [0..2) DO
file[i53] ¬ CrRPC.GetCard16[s];
ENDLOOP;
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~17 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Create: PUBLIC CreateType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i54: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, directory[i54]];
ENDLOOP;
MProc9[h, s, attributes];
MProc13[h, s, controls];
FOR i55: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i55]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
FOR i56: CARDINAL IN [0..2) DO
file[i56] ¬ CrRPC.GetCard16[s];
ENDLOOP;
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~4 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Close: PUBLIC CloseType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
FOR i57: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, file[i57]];
ENDLOOP;
FOR i58: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i58]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~3 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

Open: PUBLIC OpenType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
MProc9[h, s, attributes];
FOR i59: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, directory[i59]];
ENDLOOP;
MProc13[h, s, controls];
FOR i60: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i60]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
FOR i61: CARDINAL IN [0..2) DO
file[i61] ¬ CrRPC.GetCard16[s];
ENDLOOP;
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~2 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};

SetService: PUBLIC SetServiceType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutRope[s, service.organization];
CrRPC.PutRope[s, service.domain];
CrRPC.PutRope[s, service.object];
FOR i62: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, session.token[i62]];
ENDLOOP;
MProc4[h, s, session.verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
NULL
};

CrRPC.Call[h~h, remotePgm~10, remotePgmVersion~5, remoteProc~21 , putArgs~PutArgs, getResults~GetResults, getError~GetError];
};



UProc21: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: ControlSequence] ~ {
{
length64: CARDINAL ~ CrRPC.GetCard16[s];
res ¬  NEW[ControlSequenceObject[length64]];
FOR i63: CARDINAL IN [0..length64) DO
res.body[i63] ¬ UProc65[h, s];
ENDLOOP;
};
};

MProc19: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: ControlTypeSequence] ~ {
CrRPC.PutCard16[s, val.length];
FOR i66: CARDINAL IN [0..val.length) DO
CrRPC.PutCard16[s, ORD[val.body[i66]]];
ENDLOOP;
};

MProc9: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: FilingAttributesP10V5.AttributeSequence] ~ {
CrRPC.PutCard16[s, val.length];
FOR i67: CARDINAL IN [0..val.length) DO
CrRPC.PutCard32[s, val.body[i67].type];
MProc68[h, s, val.body[i67].value];
ENDLOOP;
};

MProc33: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: ScopeSequence] ~ {
CrRPC.PutCard16[s, val.length];
FOR i69: CARDINAL IN [0..val.length) DO
MProc70[h, s, val.body[i69]];
ENDLOOP;
};

MProc70: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: Scope] ~ {
CrRPC.PutCard16[s, ORD[val.type]];
WITH val SELECT FROM
it: REF ScopeObject.count => {
CrRPC.PutCard16[s, it­.count];
};
it: REF ScopeObject.depth => {
CrRPC.PutCard16[s, it­.depth];
};
it: REF ScopeObject.direction => {
CrRPC.PutCard16[s, ORD[it­.direction]];
};
it: REF ScopeObject.filter => {
MProc72[h, s, it­.filter];
};
ENDCASE;
};

MProc13: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: ControlSequence] ~ {
CrRPC.PutCard16[s, val.length];
FOR i73: CARDINAL IN [0..val.length) DO
MProc74[h, s, val.body[i73]];
ENDLOOP;
};

MProc72: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: Filter] ~ {
CrRPC.PutCard16[s, ORD[val.type]];
WITH val SELECT FROM
it: REF FilterObject.less => {
CrRPC.PutCard32[s, it­.less.attribute.type];
MProc68[h, s, it­.less.attribute.value];
CrRPC.PutCard16[s, ORD[it­.less.interpretation]];
};
it: REF FilterObject.lessOrEqual => {
CrRPC.PutCard32[s, it­.lessOrEqual.attribute.type];
MProc68[h, s, it­.lessOrEqual.attribute.value];
CrRPC.PutCard16[s, ORD[it­.lessOrEqual.interpretation]];
};
it: REF FilterObject.equal => {
CrRPC.PutCard32[s, it­.equal.attribute.type];
MProc68[h, s, it­.equal.attribute.value];
CrRPC.PutCard16[s, ORD[it­.equal.interpretation]];
};
it: REF FilterObject.notEqual => {
CrRPC.PutCard32[s, it­.notEqual.attribute.type];
MProc68[h, s, it­.notEqual.attribute.value];
CrRPC.PutCard16[s, ORD[it­.notEqual.interpretation]];
};
it: REF FilterObject.greaterOrEqual => {
CrRPC.PutCard32[s, it­.greaterOrEqual.attribute.type];
MProc68[h, s, it­.greaterOrEqual.attribute.value];
CrRPC.PutCard16[s, ORD[it­.greaterOrEqual.interpretation]];
};
it: REF FilterObject.greater => {
CrRPC.PutCard32[s, it­.greater.attribute.type];
MProc68[h, s, it­.greater.attribute.value];
CrRPC.PutCard16[s, ORD[it­.greater.interpretation]];
};
it: REF FilterObject.and => {
NULL; -- RECORD [] --
};
it: REF FilterObject.or => {
NULL; -- RECORD [] --
};
it: REF FilterObject.not => {
NULL; -- RECORD [] --
};
it: REF FilterObject.none => {
NULL; -- RECORD [] --
};
it: REF FilterObject.all => {
NULL; -- RECORD [] --
};
it: REF FilterObject.matches => {
CrRPC.PutCard32[s, it­.matches.attribute.type];
MProc68[h, s, it­.matches.attribute.value];
};
ENDCASE;
};

UProc46: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: AuthenticationP14V2.SeqWords] ~ {
{
length77: CARDINAL ~ CrRPC.GetCard16[s];
res ¬  NEW[AuthenticationP14V2.SeqWordsObject[length77]];
FOR i76: CARDINAL IN [0..length77) DO
res.body[i76] ¬ CrRPC.GetCard16[s];
ENDLOOP;
};
};

UProc31: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: FilingAttributesP10V5.AttributeSequence] ~ {
{
length79: CARDINAL ~ CrRPC.GetCard16[s];
res ¬  NEW[FilingAttributesP10V5.AttributeSequenceObject[length79]];
FOR i78: CARDINAL IN [0..length79) DO
res.body[i78].type ¬ CrRPC.GetCard32[s];
res.body[i78].value ¬ UProc80[h, s];
ENDLOOP;
};
};

MProc29: PUBLIC PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: AttributeTypeSequence] ~ {
CrRPC.PutCard16[s, val.length];
FOR i81: CARDINAL IN [0..val.length) DO
CrRPC.PutCard32[s, val.body[i81]];
ENDLOOP;
};

MProc4: PUBLIC PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: AuthenticationP14V2.SeqWords] ~ {
CrRPC.PutCard16[s, val.length];
FOR i82: CARDINAL IN [0..val.length) DO
CrRPC.PutCard16[s, val.body[i82]];
ENDLOOP;
};

MProc74: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: Control] ~ {
CrRPC.PutCard16[s, ORD[val.type]];
WITH val SELECT FROM
it: REF ControlObject.lock => {
CrRPC.PutCard16[s, ORD[it­.lock]];
};
it: REF ControlObject.timeout => {
CrRPC.PutCard16[s, it­.timeout];
};
it: REF ControlObject.access => {
MProc84[h, s, it­.access];
};
ENDCASE;
};

UProc65: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: Control] ~ {
{
tag85: ControlType ~ VAL[CrRPC.GetCard16[s]];
SELECT tag85 FROM
lock => {
temp86: Lock;
temp86 ¬ VAL[CrRPC.GetCard16[s]];
res ¬ NEW[ControlObject.lock ¬ [lock[temp86]]] };
timeout => {
temp86: CARD16;
temp86 ¬ CrRPC.GetCard16[s];
res ¬ NEW[ControlObject.timeout ¬ [timeout[temp86]]] };
access => {
temp86: FilingAttributesP10V5.AccessSequence;
temp86 ¬ UProc87[h, s];
res ¬ NEW[ControlObject.access ¬ [access[temp86]]] };
ENDCASE => ERROR;
};
};

MProc68: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: FilingAttributesP10V5.AttributeValue] ~ {
CrRPC.PutCard16[s, val.length];
FOR i88: CARDINAL IN [0..val.length) DO
CrRPC.PutCard16[s, val.body[i88]];
ENDLOOP;
};

UProc80: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: FilingAttributesP10V5.AttributeValue] ~ {
{
length90: CARDINAL ~ CrRPC.GetCard16[s];
res ¬  NEW[FilingAttributesP10V5.AttributeValueObject[length90]];
FOR i89: CARDINAL IN [0..length90) DO
res.body[i89] ¬ CrRPC.GetCard16[s];
ENDLOOP;
};
};

MProc84: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: FilingAttributesP10V5.AccessSequence] ~ {
CrRPC.PutCard16[s, val.length];
FOR i91: CARDINAL IN [0..val.length) DO
CrRPC.PutCard16[s, ORD[val.body[i91]]];
ENDLOOP;
};

UProc87: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: FilingAttributesP10V5.AccessSequence] ~ {
{
length93: CARDINAL ~ CrRPC.GetCard16[s];
res ¬  NEW[FilingAttributesP10V5.AccessSequenceObject[length93]];
FOR i92: CARDINAL IN [0..length93) DO
res.body[i92] ¬ VAL[CrRPC.GetCard16[s]];
ENDLOOP;
};
};

}...


R
FilingP10V5ClientImpl.Mesa
Copyright Σ 1986, 1990, 1991 by Xerox Corporation.  All rights reserved.
Generated by Diebert.pa at June 6, 1988 7:40:00 am PDT
using Sirocco [2.0] of January 31, 1987 1:52:42 am PST
Bill Jackson (bj) February 12, 1990 8:56:06 pm PST
Errors
GetErrorProc
Remote Procedures --
Unmarshal / Marshal Procs --
ΚZ•NewlineDelimiter

–
(cedarcode) style™š
œ™Jšœ
Οe
œ=™HJš
œ6™6Jš
œ6™6Icode™2K˜—š
Οk	˜	K˜K˜
K˜K˜K˜K˜
K˜Kš
œ˜—K˜šΟnœžœ
ž˜$Kšžœ˜
Kšžœ'˜.Kšžœ
˜—K˜š
œ™K˜K˜KšŸœžœžœ
˜+K˜KšŸœžœžœ
˜5K˜KšŸ
œžœžœ
˜/K˜KšŸ
œžœžœ
˜)K˜KšŸœžœžœ
˜-K˜KšŸ
œžœžœ
˜)K˜KšŸœžœžœ
˜-K˜KšŸœžœžœ
˜1K˜KšŸœžœžœ
˜3K˜KšŸœžœžœ
˜;K˜KšŸœžœžœ
˜3K˜KšŸœžœžœ
˜;K˜KšŸœžœžœ
˜1K˜KšŸœžœžœ
˜7K˜KšŸœžœžœ
˜+K˜KšŸœžœžœ
˜9K˜KšŸœžœžœ
˜1K˜—š
œ™K˜šŸœžœ˜'šžœž˜˜K˜Kšœ
žœ˜"Kšžœ˜K˜—˜K˜K˜Kšœ
žœ˜"Kšœžœ˜Kšžœ ˜%K˜—˜K˜Kšœ
žœ˜"Kšžœ˜K˜—˜K˜Kšœ
žœ˜"Kšžœ˜K˜—˜K˜Kšœ
žœ˜"Kšžœ˜K˜—˜K˜Kšœ
žœ˜"Kšžœ˜K˜—˜K˜Kšœ
žœ˜"Kšžœ˜K˜—˜Kšœ	žœ
˜K˜Kšžœ˜K˜—˜K˜Kšœ
žœ˜"Kšžœ˜K˜—˜K˜%Kšœ
žœ˜"Kšžœ˜"K˜—˜K˜K˜Kšœ
žœ˜"Kšœžœ˜Kšžœ˜$K˜—˜K˜Kšœžœ
˜
Kšœ
žœ˜"K˜Kšžœ#˜(K˜—˜K˜Kšœ
žœ˜"Kšžœ˜K˜—˜K˜K˜Kšœ
žœ˜"Kšœžœ˜Kšžœ!˜&K˜—˜K˜Kšœ
žœ˜"Kšžœ˜K˜—˜K˜Kšœžœ
˜
Kšœ
žœ˜"K˜Kšžœ"˜'K˜—˜K˜K˜Kšœ
žœ˜"Kšœžœ˜Kšžœ˜#K˜—šžœ˜Kšžœ8˜=K˜——K˜—K˜—š
œ™K˜šŸœžœ˜)šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—K˜$K˜ K˜&šžœžœ
žœž˜K˜&Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜}K˜—K˜šŸœžœ˜šŸœ˜šžœžœ
žœž˜K˜&Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜|K˜—K˜šŸœžœ˜1šŸœ˜šžœžœ
žœž˜K˜"Kšžœ
˜—šžœžœ
žœž˜K˜&Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜}K˜—K˜šŸœžœ˜1šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—K˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜|K˜—K˜šŸœžœ
˜šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—šžœžœ
žœž˜K˜.Kšžœ
˜—K˜K˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$šžœžœ
žœž˜K˜"Kšžœ
˜—K˜K˜—K˜}K˜—K˜šŸœžœ˜-šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—K˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜|K˜—K˜šŸœžœ˜'šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—K˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$K˜K˜K˜—K˜|K˜—K˜šŸœžœ˜šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—K˜K˜'šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜}K˜—K˜šŸœžœ
˜šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—šžœžœ
žœž˜K˜.Kšžœ
˜—K˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜}K˜—K˜šŸœžœ˜!šŸœ˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$K˜!K˜K˜—K˜}K˜—K˜šŸ
œžœ˜+šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—K˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$K˜K˜K˜—K˜|K˜—K˜šŸœžœ
˜šŸœ˜šžœžœ
žœž˜K˜#Kšžœ
˜—K˜K˜K˜%šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜}K˜—K˜šŸœžœ˜'šŸœ˜šžœžœ
žœž˜K˜#Kšžœ
˜—K˜K˜K˜.šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$šžœžœ
žœž˜K˜Kšžœ
˜—K˜K˜—K˜}K˜—K˜šŸœžœ˜šŸœ˜šžœžœ
žœž˜K˜#Kšžœ
˜—K˜K˜K˜'šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$šžœžœ
žœž˜K˜Kšžœ
˜—K˜K˜—K˜}K˜—K˜šŸœžœ˜!šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—K˜%šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜}K˜—K˜šŸ
œžœ˜+šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—K˜$K˜ K˜"šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜}K˜—K˜šŸœžœ˜šŸœ˜K˜'K˜!K˜!Kšœžœ˜*K˜ K˜K˜—šŸ
œ˜$šžœžœ
žœž˜K˜(Kšžœ
˜—K˜!K˜K˜—K˜|K˜—K˜šŸœžœ˜šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜|K˜—K˜šŸ	œžœ˜#šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—K˜,šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜}K˜—K˜šŸœžœ
˜šŸœ˜šžœžœ
žœž˜K˜#Kšžœ
˜—K˜K˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$šžœžœ
žœž˜K˜Kšžœ
˜—K˜K˜—K˜}K˜—K˜šŸœžœ˜šŸœ˜šžœžœ
žœž˜K˜#Kšžœ
˜—K˜K˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$šžœžœ
žœž˜K˜Kšžœ
˜—K˜K˜—K˜|K˜—K˜šŸœžœ˜šŸœ˜šžœžœ
žœž˜K˜Kšžœ
˜—šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜|K˜—K˜šŸœžœ
˜šŸœ˜K˜šžœžœ
žœž˜K˜#Kšžœ
˜—K˜šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$šžœžœ
žœž˜K˜Kšžœ
˜—K˜K˜—K˜|K˜—K˜šŸ
œžœ˜%šŸœ˜K˜'K˜!K˜!šžœžœ
žœž˜K˜'Kšžœ
˜—K˜K˜—šŸ
œ˜$Kš
ž˜K˜K˜—K˜}K˜—K˜—š
œ™K˜K˜šŸœžœžœžœ˜S˜
Kšœ
žœ˜(Kšœžœ"˜,šžœžœ
žœž˜%K˜Kšžœ
˜—K˜—K˜—K˜šŸœžœžœ˜NK˜šžœžœ
žœž˜'Kšœžœ˜'Kšžœ
˜—K˜—K˜šŸœžœžœ3˜aK˜šžœžœ
žœž˜'K˜'K˜#Kšžœ
˜—K˜—K˜šŸœžœžœ˜HK˜šžœžœ
žœž˜'K˜Kšžœ
˜—K˜—K˜šŸœžœžœ˜@Kšœžœ˜"šžœžœ
ž˜šœžœ˜K˜K˜—šœžœ˜K˜K˜—šœžœ˜"Kšœžœ˜'K˜—šœžœ˜K˜K˜—Kšžœ
˜—K˜—K˜šŸœžœžœ˜JK˜šžœžœ
žœž˜'K˜Kšžœ
˜—K˜—K˜šŸœžœžœ˜AKšœžœ˜"šžœžœ
ž˜šœžœ˜K˜,K˜(Kšœžœ˜1K˜—šœžœ˜%K˜3K˜/Kšœžœ"˜8K˜—šœžœ˜K˜-K˜)Kšœžœ˜2K˜—šœžœ˜"K˜0K˜,Kšœžœ˜5K˜—šœžœ!˜(K˜6K˜2Kšœžœ%˜;K˜—šœžœ˜!K˜/K˜+Kšœžœ˜4K˜—šœžœ˜KšžœΟc˜K˜—šœžœ˜Kšžœ ˜K˜—šœžœ˜Kšžœ ˜K˜—šœžœ˜Kšžœ ˜K˜—šœžœ˜Kšžœ ˜K˜—šœžœ˜!K˜/K˜+K˜—Kšžœ
˜—K˜—K˜šŸœžœžœžœ(˜`˜
Kšœ
žœ˜(Kšœžœ/˜9šžœžœ
žœž˜%K˜#Kšžœ
˜—K˜—K˜—K˜šŸœžœžœžœ3˜k˜
Kšœ
žœ˜(Kšœžœ:˜Dšžœžœ
žœž˜%K˜(K˜$Kšžœ
˜—K˜—K˜—K˜šŸœžœ
žœžœ!˜WK˜šžœžœ
žœž˜'K˜"Kšžœ
˜—K˜—K˜šŸœžœ
žœžœ(˜]K˜šžœžœ
žœž˜'K˜"Kšžœ
˜—K˜—K˜šŸœžœžœ˜BKšœžœ˜"šžœžœ
ž˜šœžœ˜Kšœžœ˜"K˜—šœžœ˜"K˜ K˜—šœžœ˜!K˜K˜—Kšžœ
˜—K˜—K˜šŸœžœžœžœ˜K˜
Kšœžœ˜-šžœž˜˜	K˜
Kšœ	žœ˜!Kšœžœ(˜1—˜Kšœžœ
˜K˜Kšœžœ.˜7—˜K˜-K˜Kšœžœ,˜5—Kšžœžœ
˜—K˜—K˜—K˜šŸœžœžœ0˜_K˜šžœžœ
žœž˜'K˜"Kšžœ
˜—K˜—K˜šŸœžœžœžœ0˜h˜
Kšœ
žœ˜(Kšœžœ7˜Ašžœžœ
žœž˜%K˜#Kšžœ
˜—K˜—K˜—K˜šŸœžœžœ0˜_K˜šžœžœ
žœž˜'Kšœžœ˜'Kšžœ
˜—K˜—K˜šŸœžœžœžœ0˜h˜
Kšœ
žœ˜(Kšœžœ7˜Ašžœžœ
žœž˜%Kšœžœ˜(Kšžœ
˜—K˜—K˜—K˜—K˜K˜—…—SŠm6