
<<AlpineP2202V2ClientBImpl.Mesa>>
<<Copyright (C) 1986 by Xerox Corporation.  All rights reserved.>>
<<Generated by CHauser.pa at November 13, 1987 1:17:35 pm PST>>
<<using Sirocco [2.0] of January 31, 1987 1:52:42 am PST>>
    <<Carl Hauser, November 16, 1987 3:54:23 pm PST>>

DIRECTORY
CrRPC,
CHNameP2V0,
AuthenticationP14V2,
AlpineEnvironmentP2201V1,
BulkDataP0V1,
AlpineP2202V2;

AlpineP2202V2ClientBImpl: CEDAR PROGRAM
IMPORTS CrRPC, AlpineP2202V2
EXPORTS AlpineP2202V2 ~ {
OPEN AlpineP2202V2;

<<Errors>>


StaticallyInvalid: StaticallyInvalidType ~ AlpineP2202V2.StaticallyInvalid;

AccessFailed: AccessFailedType ~ AlpineP2202V2.AccessFailed;

OperationFailed: OperationFailedType ~ AlpineP2202V2.OperationFailed;

Unknown: UnknownType ~ AlpineP2202V2.Unknown;

LockFailed: LockFailedType ~ AlpineP2202V2.LockFailed;

ConnectionError: ConnectionErrorType ~ AlpineP2202V2.ConnectionError;

AuthenticationError: AuthenticationErrorType ~ AlpineP2202V2.AuthenticationError;

PossiblyDamaged: PossiblyDamagedType ~ AlpineP2202V2.PossiblyDamaged;

<<GetErrorProc>>

GetError: CrRPC.GetErrorProc ~ {
SELECT errNum FROM
4  => ERROR StaticallyInvalid[];
0  => {
missingAccess: AlpineEnvironmentP2201V1.NeededAccess;
missingAccess _ VAL[CrRPC.GetCard16[s]];
ERROR AccessFailed[missingAccess]
};
2  => {
why: AlpineEnvironmentP2201V1.OperationFailure;
why _ VAL[CrRPC.GetCard16[s]];
ERROR OperationFailed[why]
};
5  => {
what: AlpineEnvironmentP2201V1.UnknownType;
what _ VAL[CrRPC.GetCard16[s]];
ERROR Unknown[what]
};
1  => {
why: AlpineEnvironmentP2201V1.LockFailure;
why _ VAL[CrRPC.GetCard16[s]];
ERROR LockFailed[why]
};
7  => {
problem: ConnectionProblem;
problem _ VAL[CrRPC.GetCard16[s]];
ERROR ConnectionError[problem]
};
6  => {
problem: AuthenticationP14V2.Problem;
problem _ VAL[CrRPC.GetCard16[s]];
ERROR AuthenticationError[problem]
};
3  => ERROR PossiblyDamaged[];
ENDCASE => {
ERROR CrRPC.Error[h, remoteError, "Unexpected Remote Error"];
};
};

<<Remote Procedures -->>


UnlockFile: PUBLIC UnlockFileType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

SetLockOption: PUBLIC SetLockOptionType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
CrRPC.PutCard16[s, ORD[lock.mode]];
CrRPC.PutCard16[s, ORD[lock.ifConflict]];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

AssertAlpineWheel: PUBLIC AssertAlpineWheelType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
FOR i32: CARDINAL IN [0..9) DO
CrRPC.PutCard16[s, transID[i32]];
ENDLOOP;
CrRPC.PutBool[s, enable];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

CreateTransaction: PUBLIC CreateTransactionType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutBool[s, createLocalWorker];
};
GetResults: CrRPC.GetResultsProc ~ {
FOR i33: CARDINAL IN [0..9) DO
transID[i33] _ CrRPC.GetCard16[s];
ENDLOOP;
replyVerifier _ UProc2[h, s];
};

CrRPC.Call[h~h, remotePgm~2202, remotePgmVersion~2, remoteProc~2 , 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]];
MProc1[h, s, credentials.value];
CrRPC.PutRope[s, gvCredentials.name];
CrRPC.PutRope[s, gvCredentials.pwd];
MProc1[h, s, verifier];
};
GetResults: CrRPC.GetResultsProc ~ {
session.token _ CrRPC.GetCard32[s];
session.verifier _ UProc2[h, s];
replyVerifier _ UProc2[h, s];
};

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

GetNextGroup: PUBLIC GetNextGroupType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
FOR i34: CARDINAL IN [0..9) DO
CrRPC.PutCard16[s, transID[i34]];
ENDLOOP;
FOR i35: CARDINAL IN [0..5) DO
CrRPC.PutCard16[s, previousGroup.vgid[i35]];
ENDLOOP;
CrRPC.PutCard16[s, ORD[lock.mode]];
CrRPC.PutCard16[s, ORD[lock.ifConflict]];
};
GetResults: CrRPC.GetResultsProc ~ {
FOR i36: CARDINAL IN [0..5) DO
volumeGroupID.vgid[i36] _ CrRPC.GetCard16[s];
ENDLOOP;
replyVerifier _ UProc2[h, s];
};

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

Delete: PUBLIC DeleteType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

GetLockOption: PUBLIC GetLockOptionType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
};
GetResults: CrRPC.GetResultsProc ~ {
lock.mode _ VAL[CrRPC.GetCard16[s]];
lock.ifConflict _ VAL[CrRPC.GetCard16[s]];
replyVerifier _ UProc2[h, s];
};

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

UnlockVersion: PUBLIC UnlockVersionType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

CreateWorker: PUBLIC CreateWorkerType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
FOR i37: CARDINAL IN [0..9) DO
CrRPC.PutCard16[s, transID[i37]];
ENDLOOP;
CrRPC.PutRope[s, coordinator];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

UnlockOwnerDB: PUBLIC UnlockOwnerDBType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
FOR i38: CARDINAL IN [0..9) DO
CrRPC.PutCard16[s, transID[i38]];
ENDLOOP;
FOR i39: CARDINAL IN [0..5) DO
CrRPC.PutCard16[s, volumeGroupID.vgid[i39]];
ENDLOOP;
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

LockPages: PUBLIC LockPagesType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
CrRPC.PutInt32[s, pageRun.firstPage];
CrRPC.PutCard16[s, pageRun.count];
CrRPC.PutCard16[s, ORD[lock.mode]];
CrRPC.PutCard16[s, ORD[lock.ifConflict]];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

WriteOwnerProperties: PUBLIC WriteOwnerPropertiesType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
FOR i40: CARDINAL IN [0..9) DO
CrRPC.PutCard16[s, transID[i40]];
ENDLOOP;
FOR i41: CARDINAL IN [0..5) DO
CrRPC.PutCard16[s, volumeGroupID.vgid[i41]];
ENDLOOP;
CrRPC.PutRope[s, owner];
MProc13[h, s, properties];
CrRPC.PutBool[s, enforceTotalQuota];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

Create: PUBLIC CreateType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
FOR i42: CARDINAL IN [0..9) DO
CrRPC.PutCard16[s, transID[i42]];
ENDLOOP;
FOR i43: CARDINAL IN [0..5) DO
CrRPC.PutCard16[s, volumeID[i43]];
ENDLOOP;
CrRPC.PutRope[s, owner];
CrRPC.PutInt32[s, initialSize];
CrRPC.PutCard16[s, ORD[recoveryOption]];
CrRPC.PutCard16[s, ORD[referencePattern]];
};
GetResults: CrRPC.GetResultsProc ~ {
openFileID _ CrRPC.GetCard32[s];
FOR i44: CARDINAL IN [0..5) DO
universalFile.volumeID.vgid[i44] _ CrRPC.GetCard16[s];
ENDLOOP;
FOR i45: CARDINAL IN [0..2) DO
universalFile.fileID.id[i45] _ CrRPC.GetCard16[s];
ENDLOOP;
FOR i46: CARDINAL IN [0..2) DO
universalFile.fileID.da[i46] _ CrRPC.GetCard16[s];
ENDLOOP;
replyVerifier _ UProc2[h, s];
};

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

SetSize: PUBLIC SetSizeType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
CrRPC.PutInt32[s, size];
CrRPC.PutCard16[s, ORD[lock.mode]];
CrRPC.PutCard16[s, ORD[lock.ifConflict]];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

ReadOwnerDBProperties: PUBLIC ReadOwnerDBPropertiesType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
FOR i47: CARDINAL IN [0..9) DO
CrRPC.PutCard16[s, transID[i47]];
ENDLOOP;
FOR i48: CARDINAL IN [0..5) DO
CrRPC.PutCard16[s, volumeGroupID.vgid[i48]];
ENDLOOP;
};
GetResults: CrRPC.GetResultsProc ~ {
nOwners _ CrRPC.GetInt32[s];
nEntriesUsed _ CrRPC.GetInt32[s];
nEntries _ CrRPC.GetInt32[s];
totalQuota _ CrRPC.GetInt32[s];
totalSpaceInUse _ CrRPC.GetInt32[s];
volumeGroupSize _ CrRPC.GetInt32[s];
replyVerifier _ UProc2[h, s];
};

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

Close: PUBLIC CloseType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

Open: PUBLIC OpenType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
FOR i49: CARDINAL IN [0..9) DO
CrRPC.PutCard16[s, transID[i49]];
ENDLOOP;
FOR i50: CARDINAL IN [0..5) DO
CrRPC.PutCard16[s, universalFile.volumeID.vgid[i50]];
ENDLOOP;
FOR i51: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, universalFile.fileID.id[i51]];
ENDLOOP;
FOR i52: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, universalFile.fileID.da[i52]];
ENDLOOP;
CrRPC.PutCard16[s, ORD[access]];
CrRPC.PutCard16[s, ORD[lock.mode]];
CrRPC.PutCard16[s, ORD[lock.ifConflict]];
CrRPC.PutCard16[s, ORD[recoveryOption]];
CrRPC.PutCard16[s, ORD[referencePattern]];
};
GetResults: CrRPC.GetResultsProc ~ {
openFileID _ CrRPC.GetCard32[s];
FOR i53: CARDINAL IN [0..2) DO
fileID.id[i53] _ CrRPC.GetCard16[s];
ENDLOOP;
FOR i54: CARDINAL IN [0..2) DO
fileID.da[i54] _ CrRPC.GetCard16[s];
ENDLOOP;
replyVerifier _ UProc2[h, s];
};

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

IncrementVersion: PUBLIC IncrementVersionType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
CrRPC.PutInt32[s, increment];
};
GetResults: CrRPC.GetResultsProc ~ {
replyVerifier _ UProc2[h, s];
};

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

GetAccessRights: PUBLIC GetAccessRightsType ~ {
PutArgs: CrRPC.PutArgsProc ~ {
CrRPC.PutCard32[s, session.token];
MProc1[h, s, session.verifier];
CrRPC.PutCard32[s, openFileID];
};
GetResults: CrRPC.GetResultsProc ~ {
access _ VAL[CrRPC.GetCard16[s]];
replyVerifier _ UProc2[h, s];
};

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

<<Unmarshal / Marshal Procs -->>


MProc3: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: AlpineEnvironmentP2201V1.Properties] ~ {
CrRPC.PutCard16[s, val.length];
FOR i55: CARDINAL IN [0..val.length) DO
MProc56[h, s, val.body[i55]];
ENDLOOP;
};

UProc24: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: AlpineEnvironmentP2201V1.OwnerProperties] ~ {
{
length58: CARDINAL ~ CrRPC.GetCard16[s];
res _  NEW[AlpineEnvironmentP2201V1.OwnerPropertiesObject[length58]];
FOR i57: CARDINAL IN [0..length58) DO
res.body[i57] _ UProc59[h, s];
ENDLOOP;
};
};

UProc16: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: AlpineEnvironmentP2201V1.VolumeIDs] ~ {
{
length61: CARDINAL ~ CrRPC.GetCard16[s];
res _  NEW[AlpineEnvironmentP2201V1.VolumeIDsObject[length61]];
FOR i60: CARDINAL IN [0..length61) DO
FOR i62: CARDINAL IN [0..5) DO
res.body[i60].vgid[i62] _ CrRPC.GetCard16[s];
ENDLOOP;
ENDLOOP;
};
};

UProc59: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: AlpineEnvironmentP2201V1.OwnerPropertyValuePair] ~ {
{
tag63: AlpineEnvironmentP2201V1.OwnerProperty ~ VAL[CrRPC.GetCard16[s]];
SELECT tag63 FROM
createAccessList => {
temp64: AlpineEnvironmentP2201V1.AccessList;
temp64 _ UProc65[h, s];
res _ NEW[AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.createAccessList _ [createAccessList[temp64]]] };
modifyAccessList => {
temp64: AlpineEnvironmentP2201V1.AccessList;
temp64 _ UProc65[h, s];
res _ NEW[AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.modifyAccessList _ [modifyAccessList[temp64]]] };
quota => {
temp64: INT32;
temp64 _ CrRPC.GetInt32[s];
res _ NEW[AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.quota _ [quota[temp64]]] };
spaceInUse => {
temp64: INT32;
temp64 _ CrRPC.GetInt32[s];
res _ NEW[AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.spaceInUse _ [spaceInUse[temp64]]] };
rootFile => {
temp64: AlpineEnvironmentP2201V1.UniversalFile;
FOR i66: CARDINAL IN [0..5) DO
temp64.volumeID.vgid[i66] _ CrRPC.GetCard16[s];
ENDLOOP;
FOR i67: CARDINAL IN [0..2) DO
temp64.fileID.id[i67] _ CrRPC.GetCard16[s];
ENDLOOP;
FOR i68: CARDINAL IN [0..2) DO
temp64.fileID.da[i68] _ CrRPC.GetCard16[s];
ENDLOOP;
res _ NEW[AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.rootFile _ [rootFile[temp64]]] };
ENDCASE => ERROR;
};
};

UProc5: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: AlpineEnvironmentP2201V1.Properties] ~ {
{
length70: CARDINAL ~ CrRPC.GetCard16[s];
res _  NEW[AlpineEnvironmentP2201V1.PropertiesObject[length70]];
FOR i69: CARDINAL IN [0..length70) DO
res.body[i69] _ UProc71[h, s];
ENDLOOP;
};
};

MProc13: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: AlpineEnvironmentP2201V1.OwnerProperties] ~ {
CrRPC.PutCard16[s, val.length];
FOR i72: CARDINAL IN [0..val.length) DO
MProc73[h, s, val.body[i72]];
ENDLOOP;
};

UProc2: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: AuthenticationP14V2.SeqWords] ~ {
{
length75: CARDINAL ~ CrRPC.GetCard16[s];
res _  NEW[AuthenticationP14V2.SeqWordsObject[length75]];
FOR i74: CARDINAL IN [0..length75) DO
res.body[i74] _ CrRPC.GetCard16[s];
ENDLOOP;
};
};

MProc56: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: AlpineEnvironmentP2201V1.PropertyValuePair] ~ {
CrRPC.PutCard16[s, ORD[val.type]];
WITH val SELECT FROM
it: REF AlpineEnvironmentP2201V1.PropertyValuePairObject.byteLength => {
CrRPC.PutInt32[s, it^.byteLength];
};
it: REF AlpineEnvironmentP2201V1.PropertyValuePairObject.createTime => {
CrRPC.PutCard32[s, it^.createTime];
};
it: REF AlpineEnvironmentP2201V1.PropertyValuePairObject.highWaterMark => {
CrRPC.PutInt32[s, it^.highWaterMark];
};
it: REF AlpineEnvironmentP2201V1.PropertyValuePairObject.modifyAccess => {
MProc77[h, s, it^.modifyAccess];
};
it: REF AlpineEnvironmentP2201V1.PropertyValuePairObject.owner => {
CrRPC.PutRope[s, it^.owner];
};
it: REF AlpineEnvironmentP2201V1.PropertyValuePairObject.readAccess => {
MProc77[h, s, it^.readAccess];
};
it: REF AlpineEnvironmentP2201V1.PropertyValuePairObject.stringName => {
CrRPC.PutRope[s, it^.stringName];
};
it: REF AlpineEnvironmentP2201V1.PropertyValuePairObject.version => {
CrRPC.PutInt32[s, it^.version];
};
ENDCASE;
};

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

UProc65: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: AlpineEnvironmentP2201V1.AccessList] ~ {
{
length80: CARDINAL ~ CrRPC.GetCard16[s];
res _  NEW[AlpineEnvironmentP2201V1.AccessListObject[length80]];
FOR i79: CARDINAL IN [0..length80) DO
res.body[i79] _ CrRPC.GetRope[s];
ENDLOOP;
};
};

MProc73: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: AlpineEnvironmentP2201V1.OwnerPropertyValuePair] ~ {
CrRPC.PutCard16[s, ORD[val.type]];
WITH val SELECT FROM
it: REF AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.createAccessList => {
MProc77[h, s, it^.createAccessList];
};
it: REF AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.modifyAccessList => {
MProc77[h, s, it^.modifyAccessList];
};
it: REF AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.quota => {
CrRPC.PutInt32[s, it^.quota];
};
it: REF AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.spaceInUse => {
CrRPC.PutInt32[s, it^.spaceInUse];
};
it: REF AlpineEnvironmentP2201V1.OwnerPropertyValuePairObject.rootFile => {
FOR i82: CARDINAL IN [0..5) DO
CrRPC.PutCard16[s, it^.rootFile.volumeID.vgid[i82]];
ENDLOOP;
FOR i83: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, it^.rootFile.fileID.id[i83]];
ENDLOOP;
FOR i84: CARDINAL IN [0..2) DO
CrRPC.PutCard16[s, it^.rootFile.fileID.da[i84]];
ENDLOOP;
};
ENDCASE;
};

UProc71: PROC [h: CrRPC.Handle, s: CrRPC.STREAM] RETURNS [res: AlpineEnvironmentP2201V1.PropertyValuePair] ~ {
{
tag85: AlpineEnvironmentP2201V1.Property ~ VAL[CrRPC.GetCard16[s]];
SELECT tag85 FROM
byteLength => {
temp86: INT32;
temp86 _ CrRPC.GetInt32[s];
res _ NEW[AlpineEnvironmentP2201V1.PropertyValuePairObject.byteLength _ [byteLength[temp86]]] };
createTime => {
temp86: CARD32;
temp86 _ CrRPC.GetCard32[s];
res _ NEW[AlpineEnvironmentP2201V1.PropertyValuePairObject.createTime _ [createTime[temp86]]] };
highWaterMark => {
temp86: INT32;
temp86 _ CrRPC.GetInt32[s];
res _ NEW[AlpineEnvironmentP2201V1.PropertyValuePairObject.highWaterMark _ [highWaterMark[temp86]]] };
modifyAccess => {
temp86: AlpineEnvironmentP2201V1.AccessList;
temp86 _ UProc65[h, s];
res _ NEW[AlpineEnvironmentP2201V1.PropertyValuePairObject.modifyAccess _ [modifyAccess[temp86]]] };
owner => {
temp86: ROPE;
temp86 _ CrRPC.GetRope[s];
res _ NEW[AlpineEnvironmentP2201V1.PropertyValuePairObject.owner _ [owner[temp86]]] };
readAccess => {
temp86: AlpineEnvironmentP2201V1.AccessList;
temp86 _ UProc65[h, s];
res _ NEW[AlpineEnvironmentP2201V1.PropertyValuePairObject.readAccess _ [readAccess[temp86]]] };
stringName => {
temp86: ROPE;
temp86 _ CrRPC.GetRope[s];
res _ NEW[AlpineEnvironmentP2201V1.PropertyValuePairObject.stringName _ [stringName[temp86]]] };
version => {
temp86: INT32;
temp86 _ CrRPC.GetInt32[s];
res _ NEW[AlpineEnvironmentP2201V1.PropertyValuePairObject.version _ [version[temp86]]] };
ENDCASE => ERROR;
};
};

MProc77: PROC [h: CrRPC.Handle, s: CrRPC.STREAM, val: AlpineEnvironmentP2201V1.AccessList] ~ {
CrRPC.PutCard16[s, val.length];
FOR i87: CARDINAL IN [0..val.length) DO
CrRPC.PutRope[s, val.body[i87]];
ENDLOOP;
};

}...