[_CDCSL_93-16_]<1>Cedar>release>XNSRemoteFile>XNSFilingAttributeImpl.mesa

XNSFilingAttributeImpl.mesa

Bill Jackson (bj), May 25, 1990 6:51 pm PDT

DIRECTORY

Basics USING [LongNumber, ShortNumber],

BasicTime USING [FromNSTime, GMT, nullGMT, OutOfRange, ToNSTime],

CHNameP2V0 USING [],

FilingAttributesP10V5 USING [AccessEntrySequence, AccessList, Attribute, AttributeSequence, AttributeSequenceObject, AttributeValue, AttributeValueObject, FileID, Interpretation, InterpretedAttributeType, nullFileID, Ordering, Position, PositionObject, User],

FilingP10V5 USING [allDescendants, Control, ControlSequence, ControlSequenceObject, Direction, Filter, FilterObject, FilterType, PatternFilter, RelationFilter, Scope, ScopeObject, ScopeSequence, ScopeSequenceObject, ScopeType, unlimitedCount],

RefText USING [InlineAppendChar, ObtainScratch],

Rope USING [FromProc, InlineFetch, Length, ROPE],

XNSFilingAttributes USING [Interpreted, InterpretedRange];

XNSFilingAttributeImpl: CEDAR MONITOR

IMPORTS BasicTime, RefText, Rope

EXPORTS XNSFilingAttributes ~ {

OPEN FilingP10V5, FilingAttributesP10V5, XNSFilingAttributes;

ROPE: TYPE ~ Rope.ROPE;

InfoFromAttributeSequence: PUBLIC PROC [attributes: AttributeSequence]
RETURNS [vers: CARD Ź 0, bytes: INT Ź -1, created: BasicTime.GMT Ź BasicTime.nullGMT, fileType: CARD Ź 0, pathName: REF TEXT Ź NIL, fID: FileID Ź nullFileID, isDir: BOOL Ź FALSE, numKids: CARD Ź 0] ~ {

FOR i: INT IN [0..attributes.length) DO

attribute: Attribute ~ attributes[i];

color: Interpreted;

IF ( attribute.type NOT IN InterpretedRange ) THEN LOOP;

color Ź VAL[attribute.type];

SELECT color FROM

createdOn => {

temp: CARD32 ~ DecapsulateCard32[attribute.value];

created Ź BasicTime.FromNSTime[temp ! BasicTime.OutOfRange => CONTINUE];

};

numberOfChildren => {

numKids Ź 0;

IF ( attribute.value = NIL ) THEN LOOP;

IF ( attribute.value.length = 0 ) THEN LOOP;

numKids Ź DecapsulateCard16[attribute.value];

};

dataSize => { bytes Ź DecapsulateCard32[attribute.value] };

fileID => { fID Ź DecapsulateFileID[attribute.value] };

isDirectory => { isDir Ź DecapsulateBoolean[attribute.value] };

pathname => { pathName Ź DecapsulateRefText[attribute.value] };

type => { fileType Ź DecapsulateCard32[attribute.value] };

version => { vers Ź DecapsulateCard16[attribute.value] };

ENDCASE => NULL;

ENDLOOP;

};

Well-known constants

nullAttributes: PUBLIC AttributeSequence Ź NEW[AttributeSequenceObject[0]];

nullControls: PUBLIC ControlSequence Ź NEW[ControlSequenceObject[0]];

Support things

BuildScope: PUBLIC PROC [filterType: FilterType, rope: ROPE, type: CARD32]
RETURNS [scope: ScopeSequence] = {

value: AttributeValue Ź EncapsulateRope[rope];

filter: Filter;

scope Ź NEW[ScopeSequenceObject[4]];

scope[0] Ź NEW[ScopeObject.count Ź [count[unlimitedCount]]];

scope[1] Ź NEW[ScopeObject.depth Ź [depth[allDescendants]]];

scope[2] Ź NEW[ScopeObject.direction Ź [direction[forward]]];

filter Ź SELECT filterType FROM

matches => NEW [FilterObject.matches Ź
[matches[matches: [attribute: [type: type, value: value]]] ]],

equal => NEW [FilterObject.equal Ź
[equal[equal: [attribute: [type: type, value: value], interpretation: string]] ]],

ENDCASE => NEW [FilterObject.none Ź
[none[none: [null: 0]] ]];

scope[3] Ź NEW [ScopeObject.filter Ź [filter[filter: filter]]];

};

BuildAttribute: PUBLIC PROC [name: ROPE, type: CARD32,
time: BasicTime.GMT Ź BasicTime.nullGMT, timeType: CARD32 Ź 0]
RETURNS [attributes: AttributeSequence] = {

IF time = BasicTime.nullGMT THEN {

attributes Ź NEW [AttributeSequenceObject[1]];

attributes[0] Ź [type: type, value: EncapsulateRope[name]];

RETURN[attributes];

};

attributes Ź NEW [AttributeSequenceObject[2]];

attributes[0] Ź [type: timeType, value: EncapsulateCard32[BasicTime.ToNSTime[time]]];

attributes[1] Ź [type: type, value: EncapsulateRope[name]];

RETURN[attributes];

};

BuildDirectoryAttribute: PUBLIC PROC [nameR: ROPE]
RETURNS [attributes: AttributeSequence] = {

attributes Ź NEW [AttributeSequenceObject[3]];

attributes[0] Ź [type: Interpreted.isDirectory.ORD, value: EncapsulateBoolean[TRUE]];

attributes[1] Ź [type: Interpreted.name.ORD, value: EncapsulateRope[nameR]];

attributes[2] Ź [type: Interpreted.type.ORD, value: EncapsulateCard32[1 -- tDirectory --]];

RETURN[attributes];

};

BuildStoreAttributes: PUBLIC PROC [file: ROPE, vers: CARDINAL, created: BasicTime.GMT]
RETURNS [attributes: AttributeSequence] ~ {

num: CARDINAL Ź IF ( created = BasicTime.nullGMT ) THEN 2 ELSE 3;

attributes Ź NEW [AttributeSequenceObject[num]];

attributes[0] Ź [type: Interpreted.name.ORD, value: EncapsulateRope[file]];

attributes[1] Ź [type: Interpreted.version.ORD, value: EncapsulateCard16[vers]];

IF ( created # BasicTime.nullGMT ) THEN {

time: CARD32 Ź BasicTime.ToNSTime[created];

attributes[2] Ź [type: Interpreted.createdOn.ORD, value: EncapsulateCard32[time]];

};

Attribute Encapsulation

EncapsulateAccessList: PUBLIC PROC [accessList: AccessList]
RETURNS [value: AttributeValue] ~ {

value Ź NIL;

};

DecapsulateAccessList: PUBLIC PROC [value: AttributeValue]
RETURNS [accessList: AccessList] ~ {

GetAccessEntrySequence: PROC [h: CrRPC.Handle, s: CrRPC.STREAM]

RETURNS [res: AccessEntrySequence] ~ {

GetAccess: PROC [h: CrRPC.Handle, s: CrRPC.STREAM]

RETURNS [res: AccessSequence] ~ {

length14: CARDINAL ~ DecapsulateCard16[attribute.value];

interpreted ← NEW[AccessSequenceObject[length14]];

FOR i13: CARDINAL IN [0..length14) DO

res.body[i13] ← VAL[DecapsulateCard16[attribute.value]];

ENDLOOP;

};

length11: CARDINAL ~ DecapsulateCard16[attribute.value];

interpreted ← NEW[AccessEntrySequenceObject[length11]];

FOR i10: CARDINAL IN [0..length11) DO

res.body[i10].key.organization ← DecapsulateRope[attribute.value];

res.body[i10].key.domain ← DecapsulateRope[attribute.value];

res.body[i10].key.object ← DecapsulateRope[attribute.value];

res.body[i10].access ← GetAccess[h, s];

ENDLOOP;

};

accessList.entries ← GetAccessEntrySequence[h, s];

accessList.defaulted ← DecapsulateBoolean[attribute.value];

};

EncapsulateFileID: PUBLIC PROC [fileID: FileID] RETURNS [value: AttributeValue] ~ {

len: CARDINAL ~ 5;

value Ź NEW[AttributeValueObject[len]];

FOR i: CARDINAL IN [0..len) DO

value[i] Ź fileID[i];

ENDLOOP;

};

DecapsulateFileID: PUBLIC PROC [value: AttributeValue] RETURNS [fileID: FileID] ~ {

IF value = NIL THEN ERROR;

IF value.length # 5 THEN ERROR;

FOR i: CARDINAL IN [0..5) DO

fileID[i] Ź value[i];

ENDLOOP;

};

EncapsulateOrdering: PUBLIC PROC [ordering: Ordering]
RETURNS [value: AttributeValue] ~ {

value Ź NIL;

};

DecapsulateOrdering: PUBLIC PROC [value: AttributeValue]
RETURNS [ordering: Ordering] ~ {

temp: Basics.LongNumber;

IF value = NIL THEN ERROR;

IF value.length # 4 THEN ERROR;

temp.hi Ź value[0];

temp.lo Ź value[1];

ordering.key Ź temp.lc;

ordering.ascending Ź IF value[2] = 1 THEN TRUE ELSE FALSE;

ordering.interpretation Ź VAL[value[3]];

};

EncapsulatePosition: PUBLIC PROC [position: Position]
RETURNS [value: AttributeValue] ~ {

value Ź NIL;

};

DecapsulatePosition: PUBLIC PROC [value: AttributeValue]
RETURNS [position: Position] ~ {

length: CARDINAL;

IF value = NIL THEN ERROR;

IF value.length <= 0 THEN ERROR;

length Ź value[0];

position Ź NEW[PositionObject[length]];

FOR i: CARDINAL IN [0..length) DO

position.body[i] Ź value[i+1];

ENDLOOP;

};

EncapsulateUser: PUBLIC PROC [name: ROPE] RETURNS [value: AttributeValue] ~ {

value Ź NIL;

};

DecapsulateUser: PUBLIC PROC [value: AttributeValue] RETURNS [user: User] ~ {

place: NAT Ź 0;

GetRope: PROC [] RETURNS [r: ROPE] = {

temp: Basics.ShortNumber;

len, i: NAT Ź 0;

P: PROC RETURNS[c: CHAR] = {

IF i MOD 2 = 0

THEN {temp.sc Ź value[place]; place Ź place + 1; c Ź VAL[temp.hi]}

ELSE {c Ź VAL[temp.lo]};

i Ź i + 1;

};

len Ź value[place];

place Ź place + 1;

r Ź Rope.FromProc[len: len, p: P];

};

IF value = NIL THEN ERROR;

user.organization Ź GetRope[];

user.domain Ź GetRope[];

user.object Ź GetRope[];

};

Generic (immuatable?)

EncapsulateBoolean: PUBLIC PROC [b: BOOL] RETURNS [value: AttributeValue] ~ {

len: NAT ~ 1; -- wrapped len

value Ź NEW [AttributeValueObject[len]];

value[0] Ź IF b THEN 1 ELSE 0;

};

DecapsulateBoolean: PUBLIC PROC [value: AttributeValue] RETURNS [b: BOOL] ~ {

IF value = NIL THEN ERROR;

IF value.length # 1 THEN ERROR;

b Ź IF value[0] = 1 THEN TRUE ELSE FALSE;

};

EncapsulateCard16: PUBLIC PROC [i: CARD16] RETURNS [value: AttributeValue] ~ {

len: NAT ~ 1; -- wrapped len

value Ź NEW [AttributeValueObject[len]];

value[0] Ź i;

};

DecapsulateCard16: PUBLIC PROC [value: AttributeValue] RETURNS [i: CARD16] ~ {

IF value = NIL THEN ERROR;

IF value.length # 1 THEN ERROR;

i Ź value[0];

};

EncapsulateCard32: PUBLIC PROC [i: CARD32] RETURNS [value: AttributeValue] ~ {

temp: Basics.LongNumber;

len: NAT ~ 2; -- wrapped len

value Ź NEW [AttributeValueObject[len]];

temp.lc Ź i;

value[0] Ź temp.hi;

value[1] Ź temp.lo;

};

DecapsulateCard32: PUBLIC PROC [value: AttributeValue] RETURNS [i: CARD32] ~ {

temp: Basics.LongNumber;

IF value = NIL THEN ERROR;

IF value.length # 2 THEN ERROR;

temp.hi Ź value[0];

temp.lo Ź value[1];

i Ź temp.lc;

};

EncapsulateRope: PUBLIC PROC [name: ROPE] RETURNS [value: AttributeValue] ~ {

len: NAT ~ (name.Length[]+3) / 2; -- wrapped len

value Ź NEW[AttributeValueObject[len]];

TRUSTED { EncapsulateBytes[@(value.body), name] };

};

DecapsulateRope: PUBLIC PROC [value: AttributeValue] RETURNS [rope: ROPE] ~ {

place: NAT Ź 0;

GetRope: PROC [] RETURNS [r: ROPE] = {

temp: Basics.ShortNumber;

len, i: NAT Ź 0;

P: PROC RETURNS[c: CHAR] = {

IF i MOD 2 = 0

THEN {temp.sc Ź value[place]; place Ź place + 1; c Ź VAL[temp.hi]}

ELSE {c Ź VAL[temp.lo]};

i Ź i + 1;

};

len Ź value[place];

place Ź place + 1;

r Ź Rope.FromProc[len: len, p: P];

};

IF value = NIL THEN ERROR;

rope Ź GetRope[];

};

DecapsulateRefText: PUBLIC PROC [value: AttributeValue] RETURNS [rope: REF TEXT] ~ {

place: NAT Ź 0;

GetRope: PROC [] RETURNS [r: REF TEXT] = {

temp: Basics.ShortNumber;

len: NAT Ź 0;

P: PROC [i: NAT] RETURNS[c: CHAR] = {

IF i MOD 2 = 0

THEN {temp.sc Ź value[place]; place Ź place + 1; c Ź VAL[temp.hi]}

ELSE {c Ź VAL[temp.lo]};

};

len Ź value[place];

place Ź place + 1;

r Ź RefText.ObtainScratch[len];

FOR i: NAT IN [0 .. len) DO

c: CHAR ~ P[i];

r Ź RefText.InlineAppendChar[r, c];

ENDLOOP;

};

IF value = NIL THEN ERROR;

rope Ź GetRope[];

};

OpaqueByteObject: TYPE ~ MACHINE DEPENDENT RECORD [

length: CARDINAL,

textLength: CARD16, -- first two bytes of body!

body: PACKED ARRAY [0..1000) OF CHAR

];

EncapsulateBytes: PUBLIC PROC [bytes: LONG POINTER, rope: ROPE] ~ TRUSTED {

len: NAT ~ rope.Length[];

b: LONG POINTER TO OpaqueByteObject ~ bytes;

avo: LONG POINTER TO AttributeValueObject ~ bytes;

b.sequenceLength ← len; -- skip sequence length

avo.body[0] Ź len;

FOR i: NAT IN [0..len) DO

b.body[i+2] Ź rope.InlineFetch[i];

ENDLOOP;

IF ( (len MOD 2) = 1 ) THEN b.body[len+2] Ź 0C;

};

EncapsulateNull: PUBLIC PROC RETURNS [value: AttributeValue] ~ {

len: NAT ~ 0; -- wrapped len

value Ź NEW [AttributeValueObject[len]];

};

AllInterpretedValues: TYPE ~ REF AllInterpretedValuesRep;

AllInterpretedValuesRep: TYPE ~ RECORD [

set: PACKED ARRAY Interpreted OF BOOL,

checksum: CARDINAL

];

GetInterpretation: PUBLIC PROC [attribute: Attribute, old: AllInterpretedValues Ź NIL]
RETURNS [new: AllInterpretedValues] ~ {

IF old # NIL

THEN new Ź old

ELSE { new Ź NEW[AllInterpretedValuesRep]; new.set Ź ALL[FALSE] };

IF ( attribute.type IN InterpretedRange ) THEN {

color: Interpreted ~ VAL[attribute.type];

new.set[color] Ź TRUE;

SELECT color FROM

checksum => { new.checksum Ź
DecapsulateCard16[attribute.value]; };

childrenUniquelyNamed => { new.childrenUniquelyNamed Ź
DecapsulateBoolean[attribute.value] };

createdBy => { new.createdBy Ź
DecapsulateUser[attribute.value] };

createdOn => { new.createdOn Ź
DecapsulateCard32[attribute.value] };

fileID => { new.fileID Ź
DecapsulateFileID[attribute.value] };

isDirectory => { new.isDirectory Ź
DecapsulateBoolean[attribute.value] };

isTemporary => { new.isTemporary Ź
DecapsulateBoolean[attribute.value] };

modifiedBy => { new.modifiedBy Ź
DecapsulateUser[attribute.value] };

modifiedOn => { new.modifiedOn Ź
DecapsulateCard32[attribute.value] };

name => { new.name Ź
DecapsulateRope[attribute.value] };

numberOfChildren => { new.numberOfChildren Ź
DecapsulateCard16[attribute.value] };

ordering => { new.ordering Ź
DecapsulateOrdering[attribute.value] };

parentID => { new.parentID Ź
DecapsulateFileID[attribute.value] };

position => { new.position Ź
DecapsulatePosition[attribute.value] };

readBy => { new.readBy Ź
DecapsulateUser[attribute.value] };

readOn => { new.readOn Ź
DecapsulateCard32[attribute.value] };

dataSize => { new.dataSize Ź
DecapsulateCard32[attribute.value] };

type => { new.type Ź
DecapsulateCard32[attribute.value] };

version => { new.version Ź
DecapsulateCard16[attribute.value] };

accessList => { new.accessList Ź
DecapsulateAccessList[attribute.value] };

defaultAccessList => { new.defaultAccessList Ź
DecapsulateAccessList[attribute.value] };

pathname => { new.pathname Ź
DecapsulateRope[attribute.value] };

storedSize => { new.storedSize Ź
DecapsulateCard32[attribute.value] };

subtreeSize => { new.subtreeSize Ź
DecapsulateCard32[attribute.value] };

subtreeSizeLimit => { new.subtreeSizeLimit Ź
DecapsulateCard32[attribute.value] };

ENDCASE => ERROR;

};